1. Outline Announcement Deadlock Deadlock definition - review
Conditions for a deadlock to occur - review
Deadlock prevention – review
Deadlock avoidance
Deadlock detection and recovery

2. Announcement Homework #4 Is due on Nov. 13, 2003
Not on Nov. 11, 2003 (given in the handout)
12/2/2018
COP4610

3. 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.
12/2/2018
COP4610

4. Two-process deadlock
12/2/2018
COP4610

5. Deadlock Examples – cont.
12/2/2018
COP4610

6. Deadlock Examples – cont.
12/2/2018
COP4610

7. Deadlock Characterization
Deadlock can arise only if four conditions hold simultaneously
Mutual exclusion
Hold and wait:
No preemption
Circular wait
12/2/2018
COP4610

8. 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.
12/2/2018
COP4610

9. 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.
12/2/2018
COP4610

10. 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
12/2/2018
COP4610

11. 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.
12/2/2018
COP4610

12. Using the Model There is a resource manager, Mgr(Rj) for every Rj
pi can only request ni  cj units of reusable Rj
pi can request unbounded # of units of consumable Rj
Process pi can request units of Rj if it is currently running
request
Mgr(Rj) can allocate units of Rj to pi
allocate
Mgr(Rj)
Process
12/2/2018
COP4610

13. A Generic Resource Manager
Process
Resource Manager
Blocked Processes
Resource Pool
request()
release()
Policy
12/2/2018
COP4610

14. 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
12/2/2018
COP4610

15. 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 xi Sj Sk
12/2/2018
COP4610

16. 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 Sj r3 a1 r1
p2 is blocked in Sj
12/2/2018
COP4610

17. 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
12/2/2018
COP4610

18. State Diagram – cont. State diagram of one process with one resource
of two units
Under the single unit allocation/release assumption
12/2/2018
COP4610

19. State Diagram – cont.
12/2/2018
COP4610

20. 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
12/2/2018
COP4610

21. 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
12/2/2018
COP4610

22. Example of a Resource Allocation Graph
12/2/2018
COP4610

23. Another Example of a Resource Allocation Graph
12/2/2018
COP4610

24. Yet Another Example of Resource Allocation Graph
12/2/2018
COP4610

25. 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.
12/2/2018
COP4610

26. 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
12/2/2018
COP4610

27. 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.
12/2/2018
COP4610

28. Deadlock Prevention – cont.
- Requesting all resources before starting
12/2/2018
COP4610

29. Deadlock Prevention – cont.
- Release of all resources before requesting more
12/2/2018
COP4610

30. 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.
12/2/2018
COP4610

31. 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)
12/2/2018
COP4610

32. Deadlock Prevention - cont.
12/2/2018
COP4610

33. Deadlock Prevention - cont.
12/2/2018
COP4610

34. 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
12/2/2018
COP4610

35. 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.
12/2/2018
COP4610

36. 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.
12/2/2018
COP4610

37. 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
12/2/2018
COP4610

38. Safe State Strategy
12/2/2018
COP4610

39. Safe, unsafe , deadlock state spaces
12/2/2018
COP4610

40. 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.
12/2/2018
COP4610

41. 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]
12/2/2018
COP4610

42. 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.
12/2/2018
COP4610

43. 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
A B C A B C A B C P P P P P
12/2/2018
COP4610

44. Example - cont.
The content of the matrix. Need is defined to be Max – Allocation.
Allocation Need Available Work
A B C A B C A B C A B C P P P P P
The system is in a safe state since the sequence < P1, P3, P4, P2, P0> satisfies safety criteria.
12/2/2018
COP4610

45. 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:
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
12/2/2018
COP4610

46. Example: P1 request (1,0,2)
Check that Request  Available (that is, (1,0,2)  (3,3,2)  true.)
Allocation Need Available
A B C A B C A B C P P P P P
Executing safety algorithm shows that sequence <P1, P3, P4, P0, P2> satisfies safety requirement.
12/2/2018
COP4610

47. Example Continued Allocation Need Available A B C A B C A B C
Can an additional request for (3,3,0) by P4 be granted?
Can an additional request for (0,2,0) by P0 be granted?
12/2/2018
COP4610

48. 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
12/2/2018
COP4610

49. 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
12/2/2018
COP4610

50. Example Maximum Claim C = <8, 5, 9, 7> Compute total allocated
Process R0 R1 R2 R3 p p p p p
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]
Allocated Resources
Process R0 R1 R2 R3 p p p p p
Sum
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
avail[3] = avail[3]+alloc’[2,3] = 2+3 = 5
12/2/2018
COP4610

51. Example Maximum Claim C = <8, 5, 9, 7> Compute total allocated
Process R0 R1 R2 R3 p p p p p
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]
Allocated Resources
Process R0 R1 R2 R3 p p p p p
Sum
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
avail[3] = avail[3]+alloc’[4,3] = 5+0 = 5
12/2/2018
COP4610

52. Example Maximum Claim C = <8, 5, 9, 7> Compute total allocated
Process R0 R1 R2 R3 p p p p p
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)
Allocated Resources
Process R0 R1 R2 R3 p p p p p
Sum
12/2/2018
COP4610

53. Example Maximum Claim C = <8, 5, 9, 7> Determine available units
Process R0 R1 R2 R3 p p p p p
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 R0 R1 R2 R3 p p p p p
Sum
12/2/2018
COP4610

54. Deadlock Detection and Recovery
Allow system to enter deadlock state
Detection algorithm
Recovery scheme
12/2/2018
COP4610

55. 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
12/2/2018
COP4610

56. 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.
12/2/2018
COP4610

57. 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.
12/2/2018
COP4610

58. 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
A B C A B C A B C P P P P P
Sequence <P0, P2, P3, P1, P4> will result in Finish[i] = true for all i.
12/2/2018
COP4610

59. Example - cont. P2 requests an additional instance of type C.
Allocation Request Available
A B C A B C A B C P P P P P
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.
12/2/2018
COP4610

60. 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
12/2/2018
COP4610

61. 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 pi Rh
pi request q units
State Sj
State Sk
of Rh
12/2/2018
COP4610

62. 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 pi Rh
pi acquires units
State Sj
State Sk
of Rh
12/2/2018
COP4610

63. 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 pi Rh
pi releases units
State Sj
State Sk
of Rh
12/2/2018
COP4610

64. Example R p P holds one unit of R P requests one unit of R p R
A Deadlock State
12/2/2018
COP4610

65. Example
Not a Deadlock State
No Cycle in the Graph
12/2/2018
COP4610

66. Example p0 p1
S00
12/2/2018
COP4610

67. Example p0 p0 p1 p1
S00
S01
12/2/2018
COP4610

68. Example p0 p0 p0 p1 p1 p1
S00
S01
S11
12/2/2018
COP4610

69. Example p0 p0 p0 p0 p1 p1 p1 p1
S00
S01
S11
S21
12/2/2018
COP4610

70. Example S00 S01 S11 S21 S22 p0 p0 p0 p0 p0 p1 p1 p1 p1 p1 12/2/2018
COP4610

71. Example . . . S00 S01 S11 S21 S22 S33 p0 p0 p0 p0 p0 p0 p1 p1 p1 p1 p1
12/2/2018
COP4610

72. 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
12/2/2018
COP4610

73. 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
12/2/2018
COP4610

74. 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.
12/2/2018
COP4610

75. Example RRG A C B p0 p0 p1 p2 p1 p2 p0 p1 p2 p0 p1 p2 12/2/2018
COP4610

76. 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
A B C A B C A B C P P P
12/2/2018
COP4610

77. Example RRG A B C A B C A B C A B C P0 1 0 1 1 0 0 0 0 0
Allocation Request Available
A B C A B C A B C P P P
12/2/2018
COP4610

78. 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
12/2/2018
COP4610

79. 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 pi Rh
pi request q units
State Sj
State Sk
of Rh
12/2/2018
COP4610

80. 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 pi Rh
pi acquires units
State Sj
State Sk
of Rh
12/2/2018
COP4610

81. 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 pi Rh
pi releases 2 units
State Sj
State Sk
of Rh
12/2/2018
COP4610

82. Example p0 p0 p1 p0 p1 p0 p1 p0 p1 p1
12/2/2018
COP4610

83. 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
12/2/2018
COP4610

84. 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 p1
12/2/2018
COP4610

85. 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.
12/2/2018
COP4610

86. General Resource Graphs
Have consumable and reusable resources
Apply consumable reductions to consumables, and reusable reductions to reusables
See Figure 10.29
12/2/2018
COP4610

87. GRG Example (Fig 10.29) Reusable Consumable p0 R2 R1 R0 p3 p2 p1
Not in Fig 10.29
12/2/2018
COP4610

88. GRG Example (Fig 10.29) Reduce by p3 p3 p2 R0 R2 R1 p0 p1 Reusable
Consumable
12/2/2018
COP4610

89. GRG Example (Fig 10.29) Reduce by p0 p3 p2 R0  R2 R1 p0 p1 Reusable
Consumable
12/2/2018
COP4610

90. 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.
12/2/2018
COP4610

91. 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?
12/2/2018
COP4610

92. 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.
12/2/2018
COP4610

93. 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.
12/2/2018
COP4610

94. 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
12/2/2018
COP4610