Deadlock

• A process in operating systems uses different

resources and uses resources in following way.
1) Requests a resource
2) Use the resource
2) Releases the resource

1
• 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(s).

2
• For example, 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.

3
 Bridge Crossing Example

• Traffic only in one direction.

• Each section of a bridge can be viewed as a resource.
• If a deadlock occurs, it can be resolved if one car backs
up (preempt resources and rollback).
• Several cars may have to be backed up if a deadlock
occurs.
• Starvation is possible.

4
• Deadlock can arise if following four conditions
hold simultaneously (Necessary Conditions)
1. Mutual Exclusion: One or more than one resource are
non-sharable (Only one process can use at a time)
2. Hold and Wait: A process is holding at least one resource
and waiting for resources.
3. No Preemption: A resource cannot be taken from a
process unless the process releases the resource.
4. Circular Wait: A set of processes are waiting for each
other in circular form.

5
 Deadlock Prevention
Constrain the ways request can be made.
• Mutual Exclusion – not required for sharable
resources; must hold for nonsharable resources.

• Hold and Wait – must guarantee that, whenever a

process requests a resource, it does not hold any
other resources.
– Require process to request and be allocated all its
resources before it begins execution, or allow process
to request resources only when the process has none.
– Low resource utilization; starvation is possible.

6
 Deadlock Prevention (Cont.)
• No Preemption –
– If a process that is holding some resources and 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 – To ensure that this condition never holds is

to impose a total ordering of all resource types, and require
that each process requests resources in an increasing order of
enumeration.
7
• Methods for handling deadlock
There are three ways to handle deadlock
1) Deadlock prevention or avoidance:
– The idea is to not let the system into deadlock state.
– One can zoom into each category individually, Prevention is done by
negating one of above mentioned necessary conditions for deadlock.
– Avoidance is kind of futuristic in nature.
– By using strategy of “Avoidance”, we have to make an assumption.
– We need to ensure that all information about resources which
process WILL need are known to us prior to execution of the process.
– Use Banker’s algorithm (Which is in-turn a gift from Dijkstra) in order
to avoid deadlock.

8
2) Deadlock detection and recovery:
• Let deadlock occur, then do preemption to
handle it once occurred.
3) Ignore the problem all together:
• If deadlock is very rare, then let it happen and
reboot the system. This is the approach that
both Windows and UNIX take.

9
10
 System Model
• Resource types R1, R2, . . ., Rm
CPU cycles, memory space, I/O devices, files
• Each resource type Ri has Wi instances.
• Each process utilizes a resource as follows:
– request
– use
– release

11
 Deadlock Characterization
Deadlock can arise if four conditions hold simultaneously.
• Mutual exclusion: only one process can use a resource at a time.

• Hold and wait: a process must be holding at least one resource

and 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 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, and Pn is waiting for a resource that is held by P0.

12
 Resource-Allocation Graph
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 Rj  Pi

13
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

14
Example of a Resource Allocation Graph

15
• If graph contains no cycles, then no process in the
system is deadlocked.
• If the graph does contain a cycle , then deadlock may
exist.
• If each resource type has exactly one instance, then
cycle implies that deadlock has occurred. In this case,
cycle in the graph is both necessary and a sufficient
condition for the existence of deadlock
• If each resource type has several instances, then cycle
does not necessarily imply that deadlock has occurred.
In this case, cycle in the graph is a necessary but not a
sufficient condition for the existence of deadlock

16
Resource Allocation Graph With A Deadlock

17
Resource Allocation Graph With A Cycle But No Deadlock

18
 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.

19
 Methods for Handling Deadlocks
• Ensure that the system will never enter a
deadlock state.

• Allow the system to enter a deadlock state,

detect it and then recover.

• Ignore the problem and pretend that deadlocks

never occur in the system; used by most
operating systems, including UNIX and Windows.
20
• Unit-III(Concurrency Control)
• Lecture 07
• Deadlock Avoidance

21
 Deadlock Avoidance
Requires that the system has some additional a priori information
available.
• Simplest and most useful model 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.
22
 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 safe sequence of all

processes.

• Sequence of processes <P1, P2, …, Pn> is safe if 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.

23
 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.

24
Safe, Unsafe , Deadlock State

25
 Resource-Allocation Graph Algorithm
• 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 requests a resource.

• When a resource is released by a process,

assignment edge reconverts to a claim edge.

• Resources must be claimed priori in the system.

26
 Resource-Allocation Graph Algorithm
• Safety of a system is checked by using a cycle
detection algorithm.

• An algorithm for detecting cycle in this graph

requires an order of n2 operations where n is
the number of processes in the system.

• RAG algorithm is not applicable to a resource

allocation system with multiple instances of
each resource type. 27
Resource-Allocation Graph For Deadlock Avoidance

28
Unsafe State In Resource-Allocation Graph

29
 Banker’s Algorithm
• It is the best known of the avoidance strategies.

• It is modelled after the leading policies employed

in banking system

• It is suitable to a resource allocation system with

multiple instances of each resource type.

30
 Contd…
• Multiple instances.

• 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.
31
 Data Structures for the Banker’s Algorithm

Let n = number of processes, and m = number of resources types.

• 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].
32
 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 both:
(a) Finish [i] == false
(b) 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. (m*n2 operations)
33
 Resource-Request Algorithm
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. Pretend to 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  Pi must wait, and the old resource-
allocation state is restored

34
 Example of Banker’s Algorithm
• 5 processes P0 through P4; 3 resource types A
(10 instances), B (5 instances), and C (7 instances).
• Snapshot at time T0:
Allocation Max Available
ABC ABC ABC
P0 0 1 0 753 332
P1 2 0 0 322
P2 3 0 2 902
P3 2 1 1 222
P4 0 0 2 433
35
 Example (Cont.)
• The content of the matrix. Need is defined to be
Max – Allocation.
Need
ABC
P0 7 4 3
P1 1 2 2
P2 6 0 0
P3 0 1 1
P4 4 3 1
• The system is in a safe state since the sequence
< P1, P3, P4, P0, P2> satisfies safety criteria.

36
Example P1 Request (1,0,2) (Cont.)
• Check that Request  Available (that is, (1,0,2)  (3,3,2)  true.
Allocation Need Available
ABC ABC ABC
P0 0 1 0 743 230
P1 3 0 2 020
P2 3 0 1 600
P3 2 1 1 011
P4 0 0 2 431
• Executing safety algorithm shows that sequence <P1, P3, P4, P0,
P2> satisfies safety requirement.
• Can request for (3,3,0) by P4 be granted?
• Can request for (0,2,0) by P0 be granted?

37
• Unit-III(Concurrency Control)
• Lecture 08
• Deadlock Detection
• The Ostrich algorithm

38
 Deadlock Detection
• If system does not employ either a deadlock
prevention or a deadlock avoidance algo, then a
deadlock situation may occur.

• Allow system to enter deadlock state

• Detection algorithm

• Recovery scheme
39
 Single Instance of Each Resource Type

• Deadlock detection algo uses a variant of the RAG

called wait-for graph
– Nodes are processes.
– Pi  Pj if Pi is waiting for Pj.

• Periodically invoke an algorithm that searches for

a cycle in the graph.

• An algorithm to detect a cycle in a graph requires

an order of n2 operations, where n is the number
of vertices in the graph.

40
Resource-Allocation Graph and Wait-for Graph

Resource-Allocation Graph Corresponding wait-for graph

41
 Several Instances of a Resource Type
• The wait for graph scheme is not applicable to a
resource allocation system with multiple instances

• The deadlock detection algorithm which employs

several time-varying data structures that are
similar to those used in the banker’s algo

42
 Several Instances of a Resource Type
• Available: A vector of length m indicates the number of
available resources of each type.

• Allocation: An n x m matrix defines the number of

resources of each type currently allocated to each
process.

• Request: An n x m matrix indicates the current request

of each process. If Request [i][j] = k, then process Pi is
requesting k more instances of resource type Rj.

43
 Detection Algorithm
1. Let Work and Finish be vectors of length m and n,
respectively. Initialize:
(a) Work = Available
(b)For i = 0,1, …, n-1, 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.

44
 Detection Algorithm (Cont.)
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.
Algorithm requires an order of O(m x n2) operations to detect
whether the system is in deadlocked state.

45
 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 0 1 0 000 000
P1 2 0 0 202
P2 3 0 3 000
P3 2 1 1 100
P4 0 0 2 002
• Sequence <P0, P2, P3, P1, P4> will result in Finish[i] = true for
all i.

46
 Example (Cont.)
• P2 requests an additional instance of type C.
Request
ABC
P0 0 0 0
P1 2 0 2
P2 0 0 1
P3 1 0 0
P4 0 0 2
• 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.

47
 Detection-Algorithm Usage
• When, and how often, to invoke the detection
algo. depends on:
– How often a deadlock is likely to occur?
– How many processes will need to be rolled back?
• one for each disjoint cycle

• If deadlock occur frequently, then the detection

algo. should be invoked frequently. Resources
allocated to deadlocked processes will be idle
until the deadlock can be broken.
48
 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.
– How many resources the process has used.
– How many resources process needs in order to complete.
– How many processes will need to be terminated.
– Whether the process is interactive or batch?

49
 Recovery from Deadlock: Resource
Preemption
• Selecting a victim – minimize cost.

• Rollback – return to some safe state, restart

process from that state.

• Starvation – same process may always be

picked as victim, include number of rollback in
cost factor.

50
 Comparison
Parameters Avoidance Detection Prevention
Resource Midway Very liberal Conservative,
allocation policy between that of under commit
detection and resources
prevention
Different Manipulate to Invoke periodically Preemption,
schemes find at least one to test for resource
safe path deadlock ordering,
requesting all
resources at once
Advantages No preemption Never delays No preemption
necessary process initiation necessary
Disadvantages Process can be Inherent Delays process
blocked for long preemption losses initiation
period 51
Strategies for dealing with Deadlocks

1. just ignore the problem altogether

2. detection and recovery
3. dynamic avoidance
• careful resource allocation
4. prevention
• negating one of the four necessary
conditions

52
 The Ostrich Algorithm
• Pretend there is no problem
• Reasonable if
– deadlocks occur very rarely
– cost of prevention is high
Example of “cost”, only one process runs at a time
• UNIX and Windows takes this approach for
some of the more complex resource relationships to
manage
• It’s a trade off between
– Convenience (engineering approach)
– Correctness (mathematical approach
53