Operating Systems

Deadlocks
 Topics
• System Model
• Deadlock Characterization
• Methods for Handling Deadlocks
• Deadlock Prevention
• Deadlock Avoidance
• Deadlock Detection
• Recovery from Deadlock
• Combined Approach to Deadlock Handling
 The Deadlock Problem
• A set of blocked processes each holding a resource and waiting to
acquire a resource held by another process in the set.
• Example
– System has 2 tape drives.
– P1 and P2 each hold one tape drive and each needs another one.
• Example
• semaphores A and B , initialized to 1
P0 P1
------ ------
wait(A) wait(B)
wait(B) wait(A)
 Example: bridge crossing

• 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.
 System Model
• Resource types R1 , R2 , ..., Rm-1
• Examples of resource types - CPU cycles, memory
space, I/O devices
• Each resource type Ri has Wi instances.
• e.g. 2 CPUs, 1 Floppy Disk, 2 Hard Disks
• Each process utilizes a resource (using system
calls) as follows:
– request
– use
– release
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 , and Pn is
waiting for a resource that is held by P 0 .
Resource-Allocation Graph – a diagram
showing allocations
• 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 = {R 1 , R 2 , ..., Rm }, the set consisting of all
resource types in the system.
• request edge - directed edge Pi -> Rj
• assignment edge - directed edge Rj -> Pi
• Example
• Process
 Cont’d
• Resource type with 4 instances

• Pi requests instance of R j

• Pi is holding an instance of R j
 Cont’d
• Example of a resource-allocation graph with
no cycles
 Cont’d
• Example of a resource-allocation graph with a
cycle
 Cont’d
• 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.
• e.g. R={1r1,2r2,1r3},E={(p1,r1),(p2,r3),(r1,p2),
(r2,p2),(r2,p1),(r3,p3),(p3,r2)}
• e.g. R={2r1,2r2},E={(p1,r1),(r1,p2),(r1,p3),(r2,p1),
(p3,r2),(r2,p4)}
 Methods for Handling Deadlocks
• Ensure that the system will never enter a
deadlock state. (traffic lights)
• Allow the system to enter a deadlock state
and then recover. (back up cars)
• Ignore the problem and pretend that
deadlocks never occur in the system; used by
most operating systems, including UNIX.
Deadlock Prevention - restrain the ways
resource requests 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 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, and
require that each process requests resources in an increasing order
of enumeration.
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
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 <P1 , P2 , ..., Pn > is safe if for each Pi , the
resources that Pi can still request can be satisfied by the
currently available resources plus the 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.
• 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.
 Cont’d
• e.g. 12 instances of a resource.
Max Needs Current Needs
p0 10 5
P1 4 2
P2 9 2
• systems is safe because <p1, p0, p2> satisfies safety condition. The
following diagram shows how deadlock can occur. At point t, any move
upwards would enter an unsafe state
Resource-Allocation Graph Algorithm
• Claim edge Pi -> Rj indicates 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 a priori in the system.
• Example
• E={(r1,p1)} C={(p1,r2),(p2,r1),(p2,r2)}
• no cycles -> system is safe
• now if p2 requests r2 -> system is unsafe
 Banker's Algorithm (Dijkstra 1965)
• Multiple resource types.
• 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 where n =
number of processes, and m = number of resource 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 R j .
– Allocation: n x m matrix. If Allocation[i,j] = k, then Pi is currently
allocated k instances of R j .
– 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]
 Example: consider the following:
• A banker 10 thousand dollars and four customers Florence, Dougal, Dylan and
Zebedee each customer has a maximum need and and starts owing nothing.
Name Used Max
Florence 0 6
Dougal 0 5
Dylan 0 4
Zebedee 0 7
Available = 10 Safe
Name Used Max
Florence 1 6
Dougal 1 5
Dylan 2 4
Zebedee 4 7
Available = 2 Safe, because any requests for loans, except to Dylan, can wait until
Dylan repays his loan
Name Used Max
Florence 1 6
Dougal 2 5
Dylan 2 4
Zebedee 4 7
Available = 1 Unsafe, since if all customers ask for their maximum, none will get it,
causing deadlock
 Safety Algorithm
1. Let Work and Finish be vectors of length m and n,
respectively.
Initialize:
Work := Available
Finish[i] := false for i = 1, 2, ..., n.
2. Find an i such that both:
Finish[i] = false
Need i <= Work (every element in Needi < every element in
Work)
If no such i exists, go to step 4.
3. Work := Work + Allocation I
Finish[i] := true
go to step 2.
4. If Finish[i] = true for all i, then the system is in a safe state.
• May require an order of m x n 2 operations to decide
whether a state is safe
Resource-Request Algorithm for process Pi
• Request i = request vector for process Pi .
• If Request i [ j ] = k , then process Pi wants k instances of
resource type R j .
1. If Request i <= Need i , go to step 2. Otherwise, raise
error condition, since process has exceeded its maximum
claim.
2. If Request i <= 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 - Request i ;
• Allocation i := Allocation i + Request i ;
• Need i := Need i - Request i ;
– If safe -> the resources are allocated to Pi .
– If unsafe -> Pi must wait, and the old resource-allocation state
is restored
 Example of Banker's algorithm
• 5 processes P 0 through P4 ; 3 resource types A (10
instances), B (5 instances), and C (7 instances).
• Snapshot at time T 0 :
Allocation Max Available Need
---------- --- --------- -----
ABC ABC ABC ABC
P0 0 1 0 753 332 743
P1 2 0 0 322 122
P2 3 0 2 902 600
P3 2 1 1 222 011
P4 0 0 2 433 431
• Sequence <P1, P3, P4, P2, P0> satisfies safety criteria.
• P1 now requests resources
 Cont’d
• Request 1 = (1,0,2).
Check that Request 1 <= Available (that is, (1,0,2) <= (3,3,2)) ->
true.
Allocation Need Available
---------- --- ---------
ABC ABC ABC
P0 010 743 230
P1 302 020
P2 302 600
P3 211 011
P4 002 431
– Executing safety algorithm shows that sequence <P1, P3, P4, P0,
P2>n satisfies safety requirement.
• From this state, can request for (3,3,0) by P4 be granted?
• From this state, can request for (0,2,0) by P0 be granted?
•
Deadlock Detection
Allow system to enter deadlock state
• Detection algorithm
• Recovery scheme
• Single Instance of Each Resource Type
• Maintain 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 n 2
operations, where n is the number of vertices in the graph.
• Several Instances of a Resource Type
• Data structures
– 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
 Detection Algorithm
1. Let Work and Finish be vectors of length m and n, respectively.
Initialize:
Work := Available.
For i = 1, 2, ..., n, if Allocationi <> 0, then Finish[i] := false;
otherwise,
Finish[i] := true.
2. Find an index i such that both:
1. Finish[i] = false.
2. Request i <= Work.
If no such i exists, go to step 4.
3. Work := Work + Allocation i
Finish[i] := true
go to step 2.
4. If Finish[i] = false, for some i, 1 <= i <= n, then the system is in a
deadlock state. Moreover, if Finish[i] = false, then Pi is deadlocked.
• Algorithm requires an order of m x n2 operations to detect whether
the system is in a deadlocked state.
•
Example of Detection algorithm
Five processes P 0 through P4 ; three resource types A (7 instances), B (2 instances), and C (6
instances).
• ·Snapshot at time T 0 :
Allocation Request Available
---------- ------- ---------
ABC ABC ABC
P0 010 000 000
P1 200 202
P2 303 000
P3 211 100
P4 002 002
• Sequence <P0, P2, P3, P1, P4> will result in Finish[i] = true for all i.
• 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
 Detection-Algorithm Usage
• When, and how often, to invoke 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 detection algorithm is invoked arbitrarily, there may be many cycles in the
resource graph and so we would not be able to tell which of the many deadlocked
processes ``caused'' the deadlock.
• 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?
 Cont’d
• 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.
• Combined Approach to Deadlock Handling
• Combine the three basic approaches (prevention, avoidance,
and detection), allowing the use of the optimal approach for
each class of resources in the system.
• Partition resources into hierarchically ordered classes.
• Use most appropriate technique for handling deadlocks
within each class