Deadlock

The deadlock problem

If two or more processes are waiting
on happening an event which never
happen ie called Deadlock.
The deadlock problem
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 same track and there is
only one track, none of the trains can move once
they are in front of each other.
Similar situation occurs in operating systems
when there are two or more processes hold some
resources and wait for resources held by other.
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.
Deadlock characterization
Deadlock can arise if following four
conditions hold simultaneously
Mutual Exclusion: One or more than one
resource are non-sharable (Only one process
can use at a time)
Hold and Wait: A process is holding at least
one resource and waiting for resources.
No Preemption: A resource cannot be taken
from a process unless the process releases the
resource.
Circular Wait: A set of processes are waiting
for each other in circular form.
Methods for handling deadlocks
 Prevention
 Ensure that the system will never enter a
deadlock state
 Avoidance
 Ensure that the system will never enter an
unsafe state
 Detection
 Allow the system to enter a deadlock state and
then recover
 Do Nothing
 Ignore the problem and let the user or system
administrator respond to the problem; used by
Deadlock Prevention
If we can be able to violate one of the four
necessary conditions and don't let them occur
together then we can prevent the deadlock.
Let's see how we can prevent each of the
conditions:
 Mutual Exclusion
All the resources are shareable ie multiple processes
can share the resources.
 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.
Hold and wait
we must guarantee that whenever a
process requests a resource, it does not
hold any other resources
Require a process to request and be
allocated all its resources before it
begins execution, or allow a process to
request resources only when the process
has none
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
 A process will be restarted only when it can
regain its old resources, as well as the new
ones that it is requesting
Circular Wait
 To violate circular wait, we can assign a priority number to
each of the resource. A process can't request for a lesser
priority resource. This ensures that not a single process can
request a resource which is being utilized by some other
process and no cycle will be formed.
 Each resource will be assigned with a numerical number. A
process can request for the resources only in increasing
order of numbering.
For Example, if P1 process is allocated R5 resources, now
next time if P1 ask for R4, R3 lesser than R5 such request
will not be granted, only request for resources more than
R5 will be granted.
Deadlock Avoidance
 In deadlock avoidance, the request for any resource will be
granted if the resulting state of the system doesn't cause
deadlock in the system.
 The state of the system will continuously be checked for safe
and unsafe states.
 In order to avoid deadlocks, the process must tell OS, the
maximum number of resources a process can request to
complete its execution.
 The simplest and most useful approach states that the
process should declare the maximum number of resources of
each type it may ever need.
 The Deadlock avoidance algorithm examines the resource
allocations so that there can never be a circular wait
condition.
Banker’s Algorithm
The banker’s algorithm is a resource allocation
and deadlock avoidance algorithm.
We can also detect the deadlock by using the
same algo.
Let ‘n’ be the number of processes in the system
and ‘m’ be the number of resources types.
Allocationi specifies the resources currently
allocated to process Pi and Needi specifies the
additional resources that process Pi may still
request to complete its task.
Banker’s algorithm consist of Safety algorithm
and Resource request algorithm
Example: Considering a system with five processes
P0 through P4 and three resources types A, B, C.
Resource type A has 10 instances, B has 5 instances
and type C has 7 instances. Suppose at time
t0 following snapshot of the system has been taken:
Question1. What will be the content of
the Need matrix?
Remaining Need [i, j] = Max [i, j] – Allocation
[i, j]
So, the content of Need Matrix is:
Question2. Is the system in safe state? If
Yes, then what is the safe sequence?
Question3. What will happen if
process P1 requests one additional instance of
resource type A and two instances of resource
type C?
Safe state
 When a process requests an available resource, the system must
decide if immediate allocation leaves the system in a safe state
 A system is in a safe state only if there exists a safe sequence
 A sequence of processes <P1, P2, …, Pn> is a safe sequence for the
current allocation state if, for each Pi, the resource requests that Pi
can still make, can be satisfied by currently available resources
plus resources held by all Pj, with j < i.
 That is:
 If the 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
 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 state
Avoidance algorithms
Resource allocation graph
Banker’s algorithm
Resource allocation graph
As its name suggests, the resource allocation
graph is the complete information about all
the processes which are holding some
resources or waiting for some resources.
It also contains the information about all the
instances of all the resources whether they
are available or being used by the processes.
In Resource allocation graph, the process is
represented by a Circle while the Resource is
represented by a rectangle.
Vertices are mainly of two types, Resource
and process. Each of them will be represented
by a different shape. Circle represents process
while rectangle represents resource.
A resource can have more than one instance.
Each instance will be represented by a dot
inside the rectangle.
Edges in RAG are also of two types, one
represents assignment and other represents
the wait of a process for a resource.
Example
 Let's consider 3 processes P1, P2 and P3, and two
types of resources R1 and R2. The resources are
having 1 instance each.
 According to the graph, R1 is being used by P1, P2 is
holding R2 and waiting for R1, P3 is waiting for R1 as
well as R2.
 The graph is deadlock free since no cycle is being
formed in the graph.
Deadlock Detection using RAG
If a cycle is being formed in a Resource allocation graph
where all the resources have the single instance then
the system is deadlocked.
The following example contains three processes P1, P2,
P3 and three resources R1, R2, R3. All the resources are
having single instances each.
If we analyze the graph then we can find out that there
is a cycle formed in the graph since the system is
satisfying all the four conditions of deadlock.
Allocation Matrix
Allocation matrix can be formed by using the
Resource allocation graph of a system. In
Allocation matrix, an entry will be made for
each of the resource assigned.
Request Matrix
In request matrix, an entry will be made for
each of the resource requested.

Avial = (0,0,0)
Neither we are having any resource available in the system
nor a process going to release. Each of the process needs at
least single resource to complete therefore they will
continuously be holding each one of them.
We cannot fulfill the demand of at least one process using the
available resources therefore the system is deadlocked as
 Resource-Allocation Graph (Cont.)
 Process

 Resource Type with 4 instances

 Pi requests instance of Rj

Pi
Rj
 Pi is holding an instance of Rj

Pi
Rj
Resource Allocation Graph With A Deadlock
Before P3 requested an After P3 requested an
instance of R2 instance of R2
 Graph With A Cycle But No Deadlock

Process P4 may release its instance of resource type R2. That

resource can then be allocated to P3, thereby breaking the cycle.
Relationship of cycles to deadlocks
 If a resource allocation graph contains no cycles
 no deadlock

 If a resource allocation graph contains a cycle

and if only one instance exists per resource type 
deadlock

 If a resource allocation graph contains a cycle

and if several instances exists per resource type 
possibility of deadlock
 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 can rollback 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.
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.
 Safety Algorithm
 The algorithm for finding out whether or not a system is in a
safe state can be described as follows:
 1) Let Work and Finish be vectors of length ‘m’ and ‘n’ respectively.
Initialize: Work = Available
Finish[i] = false; for i=1, 2, 3, 4….n
 2) Find an i such that both
a) Finish[i] = false
b) Needi <= Work
if no such i exists goto step (4)
 3) Work = Work + Allocation[i]
Finish[i] = true
goto step (2)
 4) if Finish [i] = true for all i
then the system is in a safe state
 Resource-Request Algorithm
 Let Requesti be the request array for process P i. Requesti [j] = k means
process Pi wants k instances of resource type Rj. When a request for
resources is made by process Pi, the following actions are taken:
 1) If Requesti <= Needi
Goto step (2) ; otherwise, raise an error condition, since the process has
exceeded its maximum claim.
 2) If Requesti <= Available
Goto step (3); otherwise, Pi must wait, since the resources are not
available.
 3) Have the system pretend to have allocated the requested resources to
process Pi by modifying the state as
follows:
Available = Available – Requesti
Allocationi = Allocationi + Requesti
Needi = Needi– Requesti
What if P4 requests (3,3,0)?
P0 requests (0,2,0)?
Deadlock Detection
Allow system to enter deadlock state
Detection algorithm
Recovery scheme
Resource-Allocation Graph And Wait-for Graph

Resource-Allocation Graph Corresponding wait-for graph

Operating System Concepts

Detection Algorithm
1. Let Work and Finish be vectors of length m and n,
respectively Initialize:
(a) Work :- Available
(b) For i = 1,2, …, n, if Allocationi  0, then
Finish[i] := false;otherwise, Finish[i] := true.
2. Find an index i such that both:
(a) Finish[i] = false
(b) Requesti  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] = false, for some i, 1  i  n, then the system is
in deadlock state. Moreover, if Finish[i] = false, then Pi is
deadlocked.
Operating System Concepts
Example of Detection Algorithm
Five processes P0 through P4; three resource types
A (7 instances), B (2 instances), and C (6 instances).
Snapshot at time T0:
Allocation Request Available
ABC ABC ABC
P0 010 000 000
P1 200 202
P2 3 0 30 0 0
P3 211 100
P4 002 002
Sequence <P0, P2, P3, P4, P1> will result in Finish[i] = true
for all i.
Operating System Concepts
Example (Cont.)
P2 requests an additional instance of type C.
Request
ABC
P0 000
P1 202
P2 001
P3 100
P4 002
State of system?
 Can reclaim resources held by process P0, but insufficient
resources to fulfill other processes; requests.
 Deadlock exists, consisting of processes P1, P2, P3, and P4.

Operating System Concepts

Recovery from Deadlock: Process Termination

Abort all deadlocked processes.

Abort one process at a time until the deadlock
cycle is eliminated.
In which order should we choose to abort?
 Priority of the process.
 How long process has computed, and how much
longer to completion.
 Resources the process has used.
 Resources process needs to complete.
 How many processes will need to be terminated.
 Is process interactive or batch?

Operating System Concepts

Recovery from Deadlock: Resource Preemption

Selecting a victim – minimize cost.

Rollback – return to some safe state, restart
process fro that state.
Starvation – same process may always be
picked as victim, include number of rollback
in cost factor.

Operating System Concepts