UNIT – 2

Deadlocks

❖ Deadlocks
● System Model
● Deadlock Characterization
● Methods for Handling Deadlocks
● Deadlock Prevention
● Deadlock Detection, and Avoidance
● Recovery from Deadlock

Deadlock:
A deadlock is a situation where a set of processes are blocked because each process is holding a
resource and waiting for another resource acquired by some other process.
Consider an example when two trains are coming toward each other on the same track and there is
only one track, none of the trains can move once they are in front of each other. A similar situation
occurs in operating systems when there are two or more processes that hold some resources and
wait for resources held by other(s). For example, in the below diagram, Process 1 is holding Resource
1 and waiting for resource 2 which is acquired by process 2, and process 2 is waiting for resource 1.

System Model
● System consists of resources
● Resource types R1, R2, . . ., Rm
They are CPU cycles, memory space, I/O Devices
● Each resource type Ri has Wi instances For i = 1, 2,
…, n
● Each process utilizes a resource as follows:
1. Requests a resource
2. Use the resource
3. Releases the resource

❖ Deadlock Characterization
 Deadlock can arise if four conditions hold simultaneously.

-> Mutual exclusion:

Only one process at a time can use a resource

-> Hold and wait:

A process holding at least one resource is waiting to acquire additional
resources held by other processes
-> No preemption:
A resource can be released only voluntarily by the process holding it, after
that process has completed its task
-> Circular wait:
There exists a set {P0, P1, …, Pn} of waiting processes such that
● P0 is waiting for a resource that is held by P1
● P1 is waiting for a resource that is held by P2
● Pn–1 is waiting for a resource that is held by Pn
● Pn is waiting for a resource that is held by P0

Resource-Allocation Graph ( RAG )

A set of vertices V and a set of edges E.

V is partitioned into two types:
P = {P1, P2, …, Pn}, the set consisting of all the processes in
the system

R = {R1, R2, …, Rm}, the set consisting of all resource types

in the system

Request Edge – Directed edge Pi -> Rj Assignment Edge –

Directed edge Pi <- Rj.
The Resource Allocation Graph, also known as RAG is a graphical representation of the state of a
system. It has all the information about the resource allocation to each process and the request of each
process.
The resource can be of two types:
Single Instance - It contains the single instance of the resource, and is represented by a single dot inside
the rectangle which is the resource vertex.
Multiple Instance - It contains the multiple instances of the resource, and is represented by multiple
(more than one) dots inside the rectangle.

Example of Single Instances RAG

In the above single instances RAG example, it can be seen that P2 is holding the R1 and waiting for R3.
P1 is waiting for R1 and holding R2 and, P3 is holding the R3 and waiting for R2. So, it can be concluded
that none of the processes will get executed.

Example of Multiple Instances RAG

In the case of Multiple Instances RAG, it becomes difficult to analyze from the RAG that the system is in
a safe state or not.

Basic Facts

● If graph contains no cycles => no deadlock

● If graph contains a cycle
● if only one instance per resource type, then deadlock
● if several instances per resource type, possibility
of deadlock

Methods for Handling Deadlocks

1) Ensure that the system will never enter a deadlock

state:
● Deadlock Prevention
● Deadlock Avoidance
2) Allow the system to enter a deadlock state and then Recover
3) We can ignore the problem altogether and pretend that deadlock never
occurred in the system.
Deadlock Prevention Method
 Mutual Exclusion

Mutual section from the resource point of view is the fact that a resource can never be used by more
than one process simultaneously which is fair enough but that is the main reason behind the deadlock.
If a resource could have been used by more than one process at the same time then the process would
have never been waiting for any resource.

However, if we can be able to violate resources behaving in the mutually exclusive manner then the
deadlock can be prevented.

Spooling

For a device like printer, spooling can work. There is a memory associated with the printer which stores
jobs from each of the process into it. Later, Printer collects all the jobs and print each one of them
according to FCFS. By using this mechanism, the process doesn't have to wait for the printer and it can
continue whatever it was doing. Later, it collects the output when it is produced.

Although, Spooling can be an effective approach to violate mutual exclusion but it suffers from two
kinds of problems.

1. This cannot be applied to every resource.

2. After some point of time, there may arise a race condition between the processes to get space
in that spool.

We cannot force a resource to be used by more than one process at the same time since it will not be
fair enough and some serious problems may arise in the performance. Therefore, we cannot violate
mutual exclusion for a process practically.

Hold and Wait

Must guarantee that whenever a process requests a resource,
it does not hold any other Resources

Process to request and be allocated all its resources

before it begins execution
 Allow process to request resources only when the process has none
allocated to it

Low resource utilization; starvation possible

No Preemption
If a process that is holding some resources requests another
resource that cannot be immediately allocated to it, then all
resources currently being held are released

Preempted resources are added to the list of resources for which

the process is waiting

Process will be restarted only when it can regain its old

resources, as well as the new ones that it is requesting

Circular Wait

Impose a total ordering of all resource types

Require that each process requests resources in an increasing

order of enumeration

Deadlock Avoidance Methods

➔ Requires that the system has some additional priori information

● Requires that each process declare the maximum number of resources of

each type that it may need
● The deadlock-avoidance algorithm dynamically examines the resource-
allocation state to ensure that there can never be a circular-wait condition
● Resource-allocation state is defined by the number of available
and allocated resources, and the maximum demands of the
processes

Safe State

● When a process requests an available resource, system must

decide if immediate allocation leaves the system in a safe state

● System is in safe state if there exists a sequence

<P1, P2, …, Pn> of ALL the processes in the systems.

● For each Pi, the resources that Pi can still request can be satisfied by currently
available resources + resources held by all the Pj, with j < i
● If Pi resource needs are not immediately available, then Pi can wait until all Pj have
finished
 ● When Pj is finished, Pi can obtain needed resources, execute, return allocated
resources, and terminate

● When Pi terminates, Pi + 1 can obtain its needed resources, and so on

Basic Facts
● If a system is in safe state no deadlocks

● If a system is in unsafe state possibility of deadlock

➔ Avoidance => ensure that a system will never enter an unsafe state.

Safe, Unsafe, and Deadlock States

Deadlock Avoidance Algorithms

● Single instance of a resource type
➔ Use a Resource-Allocation Graph

● Multiple instances of a resource type

➔ Use the Banker’s Algorithm

Resource-Allocation Graph (Arrorw marks )

● Claim edge Pi Rj indicated that process Pi may request resource Rj; represented by a
dashed line
● Claim edge converts to request edge when a process confirm to requests a resource
● Request edge converted to an assignment edge when the resource is allocated to the
process
● When a resource is released by a process, assignment edge reconverts to a claim edge
● Resources must be claimed a priori in the system
Resource-Allocation Graph
Unsafe State In Resource-Allocation Graph

Resource-Allocation Graph Algorithm

Suppose that process Pi requests a resource Rj

The request can be granted only if converting the request edge

to an assignment edge does not result in the formation of a
cycle in the resource allocation graph

Banker’s Algorithm

● Multiple instances of Resource

● Each process must a priori claim maximum use

● When a process requests a resource it may have to wait

When a process gets all its resources; it must return them in a finite amount of time
Data Structures for the Banker’s Algorithm
Let n = number of processes m =
number of resources types For i,j =
1,2,...,n
Available: Vector of length m. If Available[j] = k, there are k instances of resource
type Rj available

Max: n x m matrix. If Max[i, j] = k, then process Pi may request at most k

instances of resource type Rj

Allocation: n x m matrix. If Allocation[i, j] = k then Pi is currently allocated k

instances of Rj

Need: n x m matrix. If Need[i, j] = k, then Pi may need k more instances

of Rj to complete its task
Need[i, j] = Max[i, j] – Allocation[i, j]
Safety Algorithm
1. Let Work and Finish be vectors of length m and n, respectively.
Initialize:
Work = Available
Finish [i] = false for i = 0, 1, …, n - 1

2. Find an i such that

(a) Finish [i] == false && Needi<= Work If no such
i exists, go to step 4

3. Work = Work + Allocationi

Finish[i] = true
go to step 2

4. If Finish [i] == true for all i, then the system is in a safe state Resource-Request Algorithm for
Process Pi

Requesti = request vector for process Pi

.
If Requesti [j] = k then process Pi wants k instances of resource type Rj

1. If Requesti <= Needi go to step 2. Otherwise, raise error condition, since

process has exceeded its maximum claim

2. If Requesti <= Available, go to step 3. Otherwise Pi must wait, since

resources are not available

3. Allocate requested resources to Pi by modifying the state as follows:

Available = Available – Requesti; Allocationi = Allocationi + Requesti; Needi =

Needi – Requesti;
If safe the resources are allocated to Pi

If unsafe P must wait, and the old resource-allocation state is restored

Example of Banker’s Algorithm

5 processes P1 – P5;

3 resource types: A (10 instances),

B (5 instances), and C (7 instances) Snapshot at
time T0
:
Allocation Max Available
ABC ABC ABC
P1 0 1 0 753 332
 P2 2 0 0 322
P3 3 0 2 902
P4 2 1 1 222
P5 0 0 2 433
Determine the System is Safe State or NOT.

Context of the Need Matrix

Step 0: Determine the matrix Need Need =

Max – Allocation
Need A B
C P1 7 4 3
P2 1 2 2
P3 6 0 0
P4 0 1 1
P5 4 3 1
Banker’s Algorithm
Available Resources of A, B and C are 3, 3, and 2.
Check if each type of resource request is available for each process.

Step 1: For Process P1: Need <=

Available
7, 4, 3 <= 3, 3, 2 condition is false. Examine
another process, P2.

Step 2: For Process P2: Need <=

Available
1, 2, 2 <= 3, 3, 2 condition true
P2 Works now completed, it released all Resources Available =
Available + Allocation
(3, 3, 2) + (2, 0, 0) => 5, 3, 2 ( cur. Avail + cur. Alloc ) Examine
another process P3.

Step 3: For Process P3: Need <=

Available
6, 0, 0 < = 5, 3, 2 condition is false. Examine
another process, P4.

Step 4: For Process P4: Need <=

Available
0, 1, 1 <= 5, 3, 2 condition is true
P4 Works now completed, it released all Resources Available =
Available + Allocation
5, 3, 2 + 2, 1, 1 => 7, 4, 3 ( cur. Avail + cur. Alloc ) Similarly, we
examine another process P5.

Step 5: For Process P5: Need <=

Available
4, 3, 1 <= 7, 4, 3 condition is true
 P5 Works now completed, it released all Resources Available =
Available + Allocation
7, 4, 3 + 0, 0, 2 => 7, 4, 5 ( cur. Avail + cur. Alloc )
Examine resource request for processes P1 and P3.

Step 6: For Process P1: Need <=

Available
7, 4, 3 <= 7, 4, 5 condition is true
P1 Works now completed, it released all Resources Available =
Available + Allocation
7, 4, 5 + 0, 1, 0 => 7, 5, 5 ( cur. Avail + cur. Alloc ) Examine another
process P3

Step 7: For Process P3: Need <=

Available
6, 0, 0 <= 7, 5, 5 condition is true
P3 Works now completed, it released all Resources Available =
Available + Allocation
7, 5, 5 + 3, 0, 2 => 10, 5, 7 ( cur. Avail + cur. Alloc )

The system is in a safe state since the sequence

< P2, P4, P5, P1, P3> satisfies safety criteria

What will happen if the resource request (1, 0, 0) for process P1 can the system
accept this request immediately?

For granting the Request (1, 0, 2), Check that

Request <= Available,
(1, 0, 2) <= (3, 3, 2), condition is true

So the process P1 gets the request immediately.

Deadlock Detection and Recovery

In this approach, The OS doesn't apply any mechanism to avoid or prevent the deadlocks. Therefore the
system considers that the deadlock will definitely occur. In order to get rid of deadlocks, The OS
periodically checks the system for any deadlock. In case, it finds any of the deadlock then the OS will
recover the system using some recovery techniques.

The main task of the OS is detecting the deadlocks. The OS can detect the deadlocks with the help of
Resource allocation graph.
In single instanced resource types, if a cycle is being formed in the system then there will definitely be a
deadlock. On the other hand, in multiple instanced resource type graph, detecting a cycle is not just
enough. We have to apply the safety algorithm on the system by converting the resource allocation
graph into the allocation matrix and request matrix.

In order to recover the system from deadlocks, either OS considers resources or processes.

For Resource

Preempt the resource

We can snatch one of the resources from the owner of the resource (process) and give it to the other
process with the expectation that it will complete the execution and will release this resource sooner.
Well, choosing a resource which will be snatched is going to be a bit difficult.

Rollback to a safe state

System passes through various states to get into the deadlock state. The operating system canrollback
the system to the previous safe state. For this purpose, OS needs to implement check pointing at every
state.

The moment, we get into deadlock, we will rollback all the allocations to get into the previous safe
state.

Starvation: Avoid with starvation, I.e., don’t preemptive the process with same resource.

For Process

Kill a process

Killing a process can solve our problem but the bigger concern is to decide which process to kill.
Generally, Operating system kills a process which has done least amount of work until now.

Kill all process

This is not a suggestible approach but can be implemented if the problem becomes very serious. Killing
all process will lead to inefficiency in the system because all the processes will execute again from
starting.

Advantages of Deadlock Detection and Recovery in OS

Here are some advantages of deadlock detention and recovery in OS.

System Stability: Deadlock detection and recovery techniques help to keep operating systems stable by
finding and resolving deadlocks as soon as possible.

Resource Optimisation: By detecting and resolving deadlocks, system resources can be used more
efficiently, reducing wastage.

Process Continuity: Deadlock detection guarantees that processes do not become stuck indefinitely,
allowing them to continue execution and finish their job.

Improved System Performance: By identifying and recovering from deadlocks, overall system
performance is improved because processes can continue uninterrupted