Outline
• Announcement
• Deadlock
–
–
–
–
–
Deadlock definition - review
Conditions for a deadlock to occur - review
Deadlock prevention – review
Deadlock avoidance
Deadlock detection and recovery
Announcement
• Homework #4
– Is due on Nov. 13, 2003
– Not on Nov. 11, 2003 (given in the handout)
5/29/2016
COP4610
2
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, one CD-ROM and one
DAT drive.
– P1 and P2 each hold one tape drive and each
needs another one.
5/29/2016
COP4610
3
Two-process deadlock
5/29/2016
COP4610
4
Deadlock Examples – cont.
5/29/2016
COP4610
5
Deadlock Examples – cont.
5/29/2016
COP4610
6
Deadlock Characterization
• Deadlock can arise only if four conditions
hold simultaneously
–
–
–
–
Mutual exclusion
Hold and wait:
No preemption
Circular wait
5/29/2016
COP4610
7
Deadlock Characterization
• 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.
5/29/2016
COP4610
8
Deadlock Characterization
• 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, …, P0} 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 P0 is
waiting for a resource that is held by P0.
5/29/2016
COP4610
9
A Model
•
•
•
•
P = {p1, p2, …, pn} be a set of processes
R = {R1, R2, …, Rm} be a set of resources
cj = number of units of Rj in the system
S = {S0, S1, …} be a set of states
representing the assignment of Rj to pi
– State changes when processes take action
– This allows us to identify a deadlock situation in
the operating system
5/29/2016
COP4610
10
Resources
Resource: Anything that a process can request, then be
blocked because that thing is not available.
R = {Rj | 0  j < m} = resource types
C = {cj  0 |  RjR (0  j < m)} = units of Rj available
Reusable resource: After a unit of the resource has been
allocated, it must ultimately be released back to the
system. E.g., CPU, primary memory, disk space, … The
maximum value for cj is the number of units of that
resource
Consumable resource: There is no need to release a
resource after it has been acquired. E.g., a message,
input data, … Notice that cj is unbounded.
5/29/2016
COP4610
11
Using the Model
• There is a resource manager, Mgr(Rj) for every Rj
• Process pi can request units of Rj if it is currently running
pi can only request ni  cj units of reusable Rj
pi can request unbounded # of units of consumable Rj
•Mgr(Rj) can allocate units of Rj to pi
request
Mgr(Rj)
Process
allocate
5/29/2016
COP4610
12
A Generic Resource Manager
Resource Manager
Blocked Processes
Policy
Process Process
Process
request()
Process
release()
Resource Pool
5/29/2016
COP4610
13
Using the Model – cont.
• In most cases, we assume that each process
utilizes a resource as follows
– request
• If the requested resources are not available, the calling
process will be blocked
– use
– release
– Which implies that we are dealing with reusable
resources
5/29/2016
COP4610
14
State Transitions
• The system changes state because of the
action of some process, pi
• There are three pertinent actions:
– Request (“ri”): request one or more units of a
resource
– Allocation (“ai”): All outstanding requests from
a process for a given resource are satisfied
– Deallocation (“di”): The process releases units
of a resource
Sj
5/29/2016
xi
Sk
COP4610
15
Properties of States
• Want to define deadlock in terms of patterns
of transitions
• Define: pi is blocked in Sj if pi cannot cause
a transition out of Sj
a1
r3
Sj
r1
5/29/2016
COP4610
p2 is blocked in Sj
16
Properties of States - cont.
• If pi is blocked in Sj, and will also be blocked
in every Sk reachable from Sj, then pi is
deadlocked
• Sj is called a deadlock state
5/29/2016
COP4610
17
State Diagram – cont.
- State diagram of one process with one resource
of two units
Under the single unit allocation/release assumption
5/29/2016
COP4610
18
State Diagram – cont.
5/29/2016
COP4610
19
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 P1  Rj
– assignment edge – directed edge Rj  Pi
5/29/2016
COP4610
20
Resource-Allocation Graph - cont.
• Process
• Resource Type with 4 instances
• Pi requests instance of Rj
• Pi is holding an instance of Rj
Pi
Rj
Pi
Rj
5/29/2016
COP4610
21
Example of a Resource Allocation Graph
5/29/2016
COP4610
22
Another Example of a Resource Allocation Graph
5/29/2016
COP4610
23
Yet Another Example of Resource Allocation Graph
5/29/2016
COP4610
24
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.
5/29/2016
COP4610
25
Dealing with Deadlocks
• Three ways
– Prevention
• place restrictions on resource requests to make
deadlock impossible
– Avoidance
• plan ahead to avoid deadlock.
– Recovery
• detect when deadlock occurs and recover from it
5/29/2016
COP4610
26
Deadlock Prevention
• Restrain the ways that 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 possible.
5/29/2016
COP4610
27
Deadlock Prevention – cont.
- Requesting all resources before starting
5/29/2016
COP4610
28
Deadlock Prevention – cont.
- Release of all resources before requesting more
5/29/2016
COP4610
29
Deadlock Prevention - cont.
• 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.
5/29/2016
COP4610
30
Deadlock Prevention - cont.
• Circular Wait
– Impose a total ordering of all resource types, and require
that each process requests resources in an increasing order
of enumeration
• In other words, assuming Ri < Rj if i < j, we only a process to
acquire a resource Rj if it has acquired all other resources Ri, for i
<j
– Here we assume F(Ri)=i
– Semaphore example
• semaphores A and B, initialized to 1
P0
P1
wait (A); wait(A)
wait (B);
wait(B)
5/29/2016
COP4610
31
Deadlock Prevention - cont.
5/29/2016
COP4610
32
Deadlock Prevention - cont.
5/29/2016
COP4610
33
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
5/29/2016
COP4610
34
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
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.
5/29/2016
COP4610
35
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.
5/29/2016
COP4610
36
Comments on Safe State
• It is a worst case analysis
– If every process were to request its maximum
claim, there would be a sequence of allocations
and deallocations that could enable the system to
satisfy every process’s request in some order
• It does not mean that the system must have
enough resources to simultaneously meet all
the maximum claims
5/29/2016
COP4610
37
Safe State Strategy
5/29/2016
COP4610
38
Safe, unsafe , deadlock state spaces
5/29/2016
COP4610
39
Banker’s Algorithm
• 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.
5/29/2016
COP4610
40
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]
5/29/2016
COP4610
41
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, 3, …, n.
2. Find and 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.
5/29/2016
COP4610
42
Example of Banker’s Algorithm
• 5 processes P0 through P4; 3 resource types A (10 instances),
B (5instances, 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
5/29/2016
COP4610
43
Example - cont.
• The content of the matrix. Need is defined to be Max – Allocation.
Allocation
Need Available Work
ABC
ABC ABC
ABC
P0 0 1 0
743 332
P1 2 0 0
122
P2 3 0 2
600
P3 2 1 1
011
P4 0 0 2
431
• The system is in a safe state since the sequence < P1, P3, P4, P2,
P0> satisfies safety criteria.
5/29/2016
COP4610
44
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. Pretend to allocate requested resources to Pi by modifying the state
as follows:
•
•
5/29/2016
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
COP4610
45
Example: P1 request (1,0,2)
• 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.
5/29/2016
COP4610
46
Example Continued
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
• Can an additional request for (3,3,0) by P4 be granted?
• Can an additional request for (0,2,0) by P0 be granted?
5/29/2016
COP4610
47
Banker’s Algorithm
• Let maxc[i, j] be the maximum claim for Rj
by pi
• Let alloc[i, j] be the number of units of Rj
held by pi
• Can always compute
– avail[j] = cj - S0i< nalloc[i,j]
– Then number of available units of Rj
• Should be able to determine if the state is
safe or not using this info
5/29/2016
COP4610
48
Banker’s Algorithm
• Copy the alloc[i,j] table to alloc’[i,j]
• Given C, maxc and alloc’, compute avail
vector
• Find pi: maxc[i,j] - alloc’[i,j]  avail[j]
for 0  j < m and 0  i < n.
– If no such pi exists, the state is unsafe
– If alloc’[i,j] is 0 for all i and j, the state is safe
• Set alloc’[i,j] to 0; deallocate all resources
held by pi; go to Step 2
5/29/2016
COP4610
49
Example
Maximum Claim
Process
p0
p1
p2
p3
p4
R0
3
0
5
1
3
R1
2
2
1
5
0
C = <8, 5, 9, 7>
R2
1
5
0
3
3
R3
4
2
5
0
3
Allocated Resources
Process
p0
p1
p2
p3
p4
Sum
R0
2
0
4
0
1
7
5/29/2016
R1
0
1
0
2
0
3
R2
1
2
0
1
3
7
R3
1
1
3
0
0
5
•Compute total allocated
•Determine available units
avail = <8-7, 5-3, 9-7, 7-5>
= <1, 2, 2, 2>
•Can anyone’s maxc be met?
maxc[2,0]-alloc’[2,0] = 5-4 = 11 = avail[0]
maxc[2,1]-alloc’[2,1] = 1-0 = 12 = avail[1]
maxc[2,2]-alloc’[2,2] = 0-0 = 02 = avail[2]
maxc[2,3]-alloc’[2,3] = 5-3 = 22 = avail[3]
•P2 can exercise max claim
avail[0] = avail[0]+alloc’[2,0] = 1+4 = 5
avail[1] = avail[1]+alloc’[2,1] = 2+0 = 2
avail[2] = avail[2]+alloc’[2,2] = 2+0 = 2
COP4610 avail[3] = avail[3]+alloc’[2,3] = 2+3
50 = 5
Example
Maximum Claim
Process
p0
p1
p2
p3
p4
R0
3
0
5
1
3
R1
2
2
1
5
0
C = <8, 5, 9, 7>
R2
1
5
0
3
3
R3
4
2
5
0
3
Allocated Resources
Process
p0
p1
p2
p3
p4
Sum
R0
2
0
0
0
1
3
5/29/2016
R1
0
1
0
2
0
3
R2
1
2
0
1
3
7
R3
1
1
0
0
0
2
•Compute total allocated
•Determine available units
avail = <8-7, 5-3, 9-7, 7-5>
= <5, 2, 2, 5>
•Can anyone’s maxc be met?
maxc[4,0]-alloc’[4,0] = 5-1 = 45 = avail[0]
maxc[4,1]-alloc’[4,1] = 0-0 = 02 = avail[1]
maxc[4,2]-alloc’[4,2] = 3-3 = 02 = avail[2]
maxc[4,3]-alloc’[4,3] = 3-0 = 35 = avail[3]
•P4 can exercise max claim
avail[0] = avail[0]+alloc’[4,0] = 5+1 = 6
avail[1] = avail[1]+alloc’[4,1] = 2+0 = 2
avail[2] = avail[2]+alloc’[4,2] = 2+3 = 5
COP4610 avail[3] = avail[3]+alloc’[4,3] = 5+0
51 = 5
Example
Maximum Claim
Process
p0
p1
p2
p3
p4
R0
3
0
5
1
3
R1
2
2
1
5
0
C = <8, 5, 9, 7>
R2
1
5
0
3
3
R3
4
2
5
0
3
R2
1
2
0
1
0
4
R3
1
1
0
0
0
2
Allocated Resources
Process
p0
p1
p2
p3
p4
Sum
R0
2
0
0
0
0
2
5/29/2016
R1
0
1
0
2
0
1
COP4610
•Compute total allocated
•Determine available units
avail = <8-7, 5-3, 9-7, 7-5>
= <6, 2, 5, 5>
•Can anyone’s maxc be met?
(Yes, any of them can)
52
Example
Maximum Claim
Process
p0
p1
p2
p3
p4
R0
3
0
5
1
3
R1
2
2
1
5
0
R2
1
5
0
3
3
R3
4
2
5
0
3
R2
1
2
0
1
3
7
R3
1
1
3
0
0
5
C = <8, 5, 9, 7>
Determine available units
avail = <8-8, 5-3, 9-7, 7-5>
= <0, 2, 2, 2>
•Can anyone’s maxc be met?
Allocated Resources
Process
p0
p1
p2
p3
p4
Sum
R0
2
0
4
1
1
8
5/29/2016
R1
0
1
0
2
0
3
COP4610
53
Deadlock Detection and Recovery
• Allow system to enter deadlock state
• Detection algorithm
• Recovery scheme
5/29/2016
COP4610
54
Deadlock Detection and Recovery – cont.
• Check for deadlock (periodically or
sporadically), then recover
• Can be far more aggressive with allocation
• No maximum claim, no safe/unsafe states
• Differentiate between
– Serially reusable resources: A unit must be
allocated before being released
– Consumable resources: Never release acquired
resources; resource count is number currently
available
5/29/2016
COP4610
55
Deadlock Detection Algorithm
• 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 [ij] = k, then
process Pi is requesting k more instances of resource
type. Rj.
5/29/2016
COP4610
56
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. (a) Work := Work + Allocationi; (b) 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 m x n2 operations to detect whether
the system is in deadlocked state.
5/29/2016
COP4610
57
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.
5/29/2016
COP4610
58
Example - cont.
• P2 requests an additional instance of type C.
Allocation Request Available
P0
P1
P2
P3
P4
ABC
010
200
303
211
002
ABC ABC
000 000
202
100
100
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.
5/29/2016
COP4610
59
Reusable Resource Graphs
• Micro model to describe a single state
• Nodes = {p0, p1, …, pn}  {R1, R2, …, Rm}
• Edges connect pi to Rj, or Rj to pi
– (pi, Rj) is a request edge for one unit of Rj
– (Rj, pi) is an assignment edge of one unit of Rj
• For each Rj there is a count, cj of units Rj
• Number of units of Rj allocated to pi plus
the number requested by pi cannot exceed cj
5/29/2016
COP4610
60
State Transitions due to Request
• In Sj, pi is allowed to request qch units of
Rh, provided pi has no outstanding requests.
• Sj  Sk, where the RRG for Sk is derived
from Sj by adding q request edges from pi to
Rh
q edges
pi
Rh
State Sj
5/29/2016
pi request q units
of Rh
COP4610
pi
Rh
State Sk
61
State Transition for Acquire
• In Sj, pi is allowed to acquire units of Rh, iff
there is (pi, Rh) in the graph, and all can be
satisfied.
• Sj  Sk, where the RRG for Sk is derived
from Sj by changing each request edge to an
assignment edge.
pi
Rh
State Sj
5/29/2016
pi acquires units
of Rh
COP4610
pi
Rh
State Sk
62
State Transition for Release
• In Sj, pi is allowed to release units of Rh, iff
there is (Rh, pi) in the graph, and there is no
request edge from pi.
• Sj  Sk, where the RRG for Sk is derived
from Sj by deleting all assignment edges.
pi
Rh
State Sj
5/29/2016
pi releases units
of Rh
COP4610
pi
Rh
State Sk
63
Example
R
p
P holds one unit of R
P requests one unit of R
p
R
A Deadlock State
5/29/2016
COP4610
64
Example
Not a Deadlock State
5/29/2016
No Cycle in the Graph
COP4610
65
Example
p0
p1
S00
5/29/2016
COP4610
66
Example
5/29/2016
p0
p0
p1
p1
S00
S01
COP4610
67
Example
5/29/2016
p0
p0
p0
p1
p1
p1
S00
S01
S11
COP4610
68
Example
5/29/2016
p0
p0
p0
p0
p1
p1
p1
p1
S00
S01
S11
S21
COP4610
69
Example
5/29/2016
p0
p0
p0
p0
p0
p1
p1
p1
p1
p1
S00
S01
S11
S21
S22
COP4610
70
Example
p0
p0
p0
p0
p0
p0
...
5/29/2016
p1
p1
p1
p1
p1
p1
S00
S01
S11
S21
S22
S33
COP4610
71
Graph Reduction
• Deadlock state if there is no sequence of
transitions unblocking every process
• A RRG represents a state; can analyze the
RRG to determine if there is a sequence
• A graph reduction represents the (optimal)
action of an unblocked process. Can reduce
by pi if
– pi is not blocked
– pi has no request edges, and there are (Rj, pi) in
the RRG
5/29/2016
COP4610
72
Graph Reduction (cont)
• Transforms RRG to another RRG with all
assignment edges into pi removed
• Represents pi releasing the resources it
holds
pi
Reducing by pi
pi
5/29/2016
COP4610
73
Graph Reduction (cont)
• A RRG is completely reducible if there a
sequence of reductions that leads to a RRG
with no edges
• A state is a deadlock state if and only if the
RRG is not completely reducible.
5/29/2016
COP4610
74
Example RRG
p0
p0
A
C
p1
p1
p2
p2
B
p0
p1
5/29/2016
p0
p1
p2
COP4610
p2
75
Corresponding Detection Algorithm
• Three processes P0 through P2; three resource types
A (2 instances), B (2 instances), and C (1 instance).
• Snapshot at time T0:
Allocation Request Available
ABC
P0 1 0 1
P1 0 2 0
P2 0 0 0
5/29/2016
ABC
100
200
011
COP4610
ABC
100
76
Example RRG
p0
A
Allocation Request Available
C
ABC ABC ABC
p1
p2
B
5/29/2016
P0
101
P1
100 010
P2
020
COP4610
100
000
001
77
Consumable Resource Graphs (CRGs)
• Number of units varies, have
producers/consumers
• Nodes = {p0, p1, …, pn}  {R1, R2, …, Rm}
• Edges connect pi to Rj, or Rj to pi
– (pi, Rj) is a request edge for one unit of Rj
– (Rj, pi) is an producer edge (must have at least
one producer for each Rj)
• For each Rj there is a count, wj of units Rj
5/29/2016
COP4610
78
State Transitions due to Request
• In Sj, pi is allowed to request any number of
units of Rh, provided pi has no outstanding
requests.
• Sj  Sk, where the RRG for Sk is derived
from Sj by adding q request edges from pi to
Rh
q edges
pi
Rh
State Sj
5/29/2016
pi request q units
of Rh
COP4610
pi
Rh
State Sk
79
State Transition for Acquire
• In Sj, pi is allowed to acquire units of Rh, iff
there is (pi, Rh) in the graph, and all can be
satisfied.
• Sj  Sk, where the RRG for Sk is derived
from Sj by deleting each request edge and
decrementing wh.
pi
Rh
State Sj
5/29/2016
pi acquires units
of Rh
COP4610
pi
Rh
State Sk
80
State Transition for Release
• In Sj, pi is allowed to release units of Rh, iff
there is (Rh, pi) in the graph, and there is no
request edge from pi.
• Sj  Sk, where the RRG for Sk is derived
from Sj by incrementing wh.
pi
Rh
State Sj
5/29/2016
pi releases 2 units
of Rh
COP4610
pi
Rh
State Sk
81
Example
5/29/2016
p0
p0
p0
p0
p0
p1
p1
p1
p1
p1
COP4610
82
Deadlock Detection
• May have a CRG that is not completely
reducible, but it is not a deadlock state
• For each process:
– Find at least one sequence which leaves each
process unblocked.
• There may be different sequences for
different processes -- not necessarily an
efficient approach
5/29/2016
COP4610
83
Deadlock Detection
• May have a CRG that is not completely
reducible, but it is not a deadlock state
• Only need to find sequences, which leave
each process unblocked.
p0
5/29/2016
p1
COP4610
84
Deadlock Detection
• May have a CRG that is not completely
reducible, but it is not a deadlock state
• Only need to find a set of sequences, which
leaves each process unblocked.
5/29/2016
COP4610
85
General Resource Graphs
• Have consumable and reusable resources
• Apply consumable reductions to
consumables, and reusable reductions to
reusables
• See Figure 10.29
5/29/2016
COP4610
86
GRG Example (Fig 10.29)
p3
p2
R0
R2
R1
p0
p1
Reusable
Consumable
Not in Fig 10.29
5/29/2016
COP4610
87
GRG Example (Fig 10.29)
p3
p2
Reduce by p3
R0
R2
R1
p0
p1
Reusable
Consumable
5/29/2016
COP4610
88
GRG Example (Fig 10.29)
p3
p2

R1
R0
p0
R2
p1
Reduce by p0
Reusable
Consumable
5/29/2016
COP4610
89
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.
5/29/2016
COP4610
90
Recovery from Deadlock: Process Termination
• Abort all deadlocked processes.
– Roll back to a previous checkpoint
• 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?
5/29/2016
COP4610
91
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.
5/29/2016
COP4610
92
Combined Approach to Deadlock Handling
• Combine the three basic approaches
– prevention
– avoidance
– detection
• Allowing the use of the optimal approach for
each of resources in the system.
• Partition resources into hierarchically ordered
classes.
• Use most appropriate technique for handling
deadlocks within each class.
5/29/2016
COP4610
93
Summary
• Deadlock is a situation where a set of
blocked processes are waiting for each other
• Three ways to deal with deadlocks
– Deadlock prevention
– Deadlock avoidance
– Deadlock recovery
5/29/2016
COP4610
94