Computer Science 08/10/2024

Topics
Banker's algorithm

Banker's algorithm is a resource allocation and deadlock avoidance algorithm that ensures a
safe sequence of processes by analyzing resource requests.

Ensures processes do not get stuck waiting for resources

Considers current available resources and future requests
Can prevent deadlock by denying resource request if it may lead to an unsafe state
Uses matrices to represent the current state and analyze safe sequences

Conditions for deadlock

Deadlock occurs when multiple processes are unable to proceed because each is waiting for
another to release a resource.

Resource holding, no preemption: A process holds resources while waiting for more, cannot
be taken back.
Wait for resource: Processes wait indefinitely for resources held by others, further
exacerbating the deadlock.
No preemption: Resources cannot be forcibly removed from a process, leading to potential
resource starvation.
Circular wait: Processes form a circular chain where each process is waiting for a resource
held by the next.

Deadlock

Deadlock occurs when two or more processes are unable to proceed because each is waiting for
a resource held by the other.

Deadlock can lead to system-wide halt and is a common problem in multitasking and
multiprogramming systems.
The four necessary conditions for deadlock are mutual exclusion, hold and wait, no
preemption, and circular wait.
Techniques to prevent deadlock include resource allocation graph, banker's algorithm, and
prevention by denying at least one of the necessary conditions.
Techniques to address deadlock include detection and recovery, wherein processes are
terminated or resources are forcibly taken back.

deadlock avoidance
Deadlock avoidance is a method used to prevent deadlocks in a system by ensuring that the
necessary conditions for deadlock formation are not present.

Resources are allocated before they are needed.

Deadlock avoidance requires the system to have information about the future resource
requests of all processes.
The system uses algorithms to determine the safe sequence for resource allocation.
It is a proactive approach compared to deadlock detection and does not rely on detecting and
recovering from deadlocks.

deadlock detection

Deadlock detection is a technique used to identify and resolve resource allocation conflicts that
can prevent a system from making progress.

Deadlock occurs when a set of processes are waiting for resources held by each other,
resulting in a circular dependency.
Deadlock detection algorithms rely on resource allocation graphs to identify cycles in the
resource allocation hierarchy.
Once a deadlock is detected, it can be resolved through techniques like resource preemption
or process termination.
Deadlock detection is an essential component of operating systems and concurrent
programming to ensure system stability and prevent resource starvation.

Deadlock prevention

Deadlock prevention involves implementing strategies to ensure that resources are allocated in a
way that avoids situations where processes are unable to proceed.

Resource allocation policies can help prevent deadlock by ensuring processes do not hold
resources indefinitely.
Using a hierarchical approach to resource allocation can help avoid circular waits and
potential deadlocks.
Implementing timeouts on resource requests can help preemptively break potential
deadlocks and allow processes to progress.
Detecting and breaking deadlock cycles through periodic checks and recovery mechanisms
helps prevent system halting.

Dining philosopher's problem

The Dining philosopher's problem involves a group of philosophers seated around a dining table
with chopsticks, aiming to avoid deadlock and starvation.

Each philosopher must alternate between thinking and eating, utilizing exclusive access to
 both chopsticks.
If a philosopher cannot acquire both chopsticks, they must release the chopstick and
continue thinking to prevent deadlock.
A solution involves ensuring that each philosopher picks up the right chopstick first or using a
designated controller to allocate chopsticks efficiently.
Approaches like resource hierarchy and limiting the number of philosophers allowed to pick
up chopsticks simultaneously can help in resolving this problem.

Resource allocation graphs

Resource allocation graphs depict which resources are assigned to each process and help
identify potential deadlocks.

Processes are circles, resources are rectangles, and edges show which process is using
which resource.
Potential deadlocks occur when a cycle forms in the resource allocation graph.
Wait-for graph can be derived from a resource allocation graph to provide more detailed
information on potential deadlocks.
Resource allocation graphs are useful for optimizing resource allocation and avoiding
bottlenecks in a system.

Safe State

A safe state is a condition in which a process can proceed without the risk of deadlock or other
critical issues.

Safe state implies that each process in the system can continue to completion without being
affected by other processes.
Processes in a safe state can grant resource requests, avoiding deadlock.
Resource allocation graph is used to determine if a system is in a safe state.
Ensuring a safe state is crucial for maintaining system stability and efficient resource
utilization.

Key Terms
circular wait

Circular wait refers to a deadlock situation where a set of processes are waiting for each other's
resources, creating a circular dependency.

Circular wait can lead to a system deadlock, where no process can proceed.
Prevention strategies for circular wait include using a resource allocation graph.
Deadlock detection and recovery mechanisms can be used to handle circular wait situations.
Implementing a priority-based resource allocation algorithm can help prevent circular wait
scenarios.
Consumable resources

Consumable resources are elements that are used up in a process and must be carefully
managed to ensure there is enough for future use.

These resources include physical items like paper and ink cartridges.
They are also common in manufacturing processes where raw materials are transformed into
finished products.
Effective tracking and monitoring are essential to prevent shortages and plan for
replenishment.
Optimizing the use of consumable resources can lead to cost savings and environmental
benefits.

Hold-and-wait

In 'Hold-and-wait', a process holds a resource while waiting for additional resources, potentially
leading to resource wastage and deadlock.

A process may hold onto one resource while waiting for another, causing inefficiency.
Deadlock may occur if multiple processes are waiting for resources that are held by each
other.
Implementing timeouts on resource allocation can help prevent indefinite waiting periods.
Strategies like resource pre-allocation can reduce the risk of 'Hold-and-wait' situations.

mutual exclusion

Mutual exclusion is a concept that ensures only one process or thread can access a shared
resource at a time.

Mutex is a common mechanism used for implementing mutual exclusion.

Mutual exclusion prevents race conditions and data inconsistencies.
It is essential for managing shared resources in concurrent systems.
Semaphores can be used to provide mutual exclusion by allowing only a limited number of
threads to access a resource.

no preemption

In the context of task scheduling, 'no preemption' means that once a task starts executing, it
cannot be interrupted until it completes.

The 'no preemption' policy ensures that a task is given uninterrupted access to the resources
it needs to complete.
This policy simplifies scheduling algorithms, as it eliminates the need for context switching.
 No preemption can lead to longer response times for higher-priority tasks if a lower-priority
task is executing.
Non-preemptive scheduling is commonly used in real-time systems where predictability and
determinism are crucial.

resource allocation graph

A resource allocation graph is a visual representation that shows the allocation of resources to
processes in a system.

Nodes represent processes and resources, while directed edges represent requests and
allocations.
A cycle in the graph indicates a deadlock situation where no process can proceed.
The graph helps analyze resource dependency and identify potential deadlocks in a system.
Detection and resolution of deadlocks can be done using algorithms like the Banker's
algorithm or cycle detection algorithms.

Reusable resources

Reusable resources are tools or materials that can be used multiple times, reducing waste and
saving time and effort.

They help optimize efficiency and productivity in various projects and tasks.
Examples include templates, libraries, and modules.
Proper documentation is essential for the effective utilization of reusable resources.
Adopting best practices when creating reusable resources can lead to long-term benefits.

Semaphore

In Computer Science, a semaphore is a synchronization construct that can be used to control

access to a shared resource.

A semaphore can have an initial value indicating the number of permits available for
concurrent access.
Semaphores can be used to solve the critical section problem in concurrent programming.
A binary semaphore is a special type of semaphore that can only take the values 0 and 1.
A counting semaphore is a semaphore that can take any non-negative integer value.

Unsafe State

Unsafe State occurs when a system's resources are manipulated in a way that could lead to
incorrect results or unpredictable behavior.

It can result from concurrent access to shared resources.

 Can lead to data corruption or race conditions.
Preventing it requires proper synchronization techniques.
Can cause security vulnerabilities.

wait-for graph

A wait-for graph visually represents the relationships between processes in terms of their
resource dependencies.

Nodes represent processes, edges show which process is waiting for a resource held by
another.
Frequently used in deadlock detection and prevention strategies.
Can assist in identifying potential circular wait conditions within a system.
Helps analyze and resolve resource allocation issues.