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

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

Two-process deadlock 12/2/2018 COP4610

Deadlock Examples – cont. 12/2/2018 COP4610

Deadlock Examples – cont. 12/2/2018 COP4610

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

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

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

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

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

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

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

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

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

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

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

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

State Diagram – cont. 12/2/2018 COP4610

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

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

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

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

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

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

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

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

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

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

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

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

Deadlock Prevention - cont. 12/2/2018 COP4610

Deadlock Prevention - cont. 12/2/2018 COP4610

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

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

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

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

Safe State Strategy 12/2/2018 COP4610

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

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

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

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

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 P0 0 1 0 7 5 3 3 3 2 P1 2 0 0 3 2 2 P2 3 0 2 9 0 2 P3 2 1 1 2 2 2 P4 0 0 2 4 3 3 12/2/2018 COP4610

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 P0 0 1 0 7 4 3 3 3 2 P1 2 0 0 1 2 2 P2 3 0 2 6 0 0 P3 2 1 1 0 1 1 P4 0 0 2 4 3 1 The system is in a safe state since the sequence < P1, P3, P4, P2, P0> satisfies safety criteria. 12/2/2018 COP4610

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

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 P0 0 1 0 7 4 3 2 3 0 P1 3 0 2 0 2 0 P2 3 0 1 6 0 0 P3 2 1 1 0 1 1 P4 0 0 2 4 3 1 Executing safety algorithm shows that sequence <P1, P3, P4, P0, P2> satisfies safety requirement. 12/2/2018 COP4610

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

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

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

Example Maximum Claim C = <8, 5, 9, 7> Compute total allocated Process R0 R1 R2 R3 p0 3 2 1 4 p1 0 2 5 2 p2 5 1 0 5 p3 1 5 3 0 p4 3 0 3 3 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 p0 2 0 1 1 p1 0 1 2 1 p2 4 0 0 3 p3 0 2 1 0 p4 1 0 3 0 Sum 7 3 7 5 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

Example Maximum Claim C = <8, 5, 9, 7> Compute total allocated Process R0 R1 R2 R3 p0 3 2 1 4 p1 0 2 5 2 p2 5 1 0 5 p3 1 5 3 0 p4 3 0 3 3 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 p0 2 0 1 1 p1 0 1 2 1 p2 0 0 0 0 p3 0 2 1 0 p4 1 0 3 0 Sum 3 3 7 2 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

Example Maximum Claim C = <8, 5, 9, 7> Compute total allocated Process R0 R1 R2 R3 p0 3 2 1 4 p1 0 2 5 2 p2 5 1 0 5 p3 1 5 3 0 p4 3 0 3 3 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 p0 2 0 1 1 p1 0 1 2 1 p2 0 0 0 0 p3 0 2 1 0 p4 0 0 0 0 Sum 2 1 4 2 12/2/2018 COP4610

Example Maximum Claim C = <8, 5, 9, 7> Determine available units Process R0 R1 R2 R3 p0 3 2 1 4 p1 0 2 5 2 p2 5 1 0 5 p3 1 5 3 0 p4 3 0 3 3 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 p0 2 0 1 1 p1 0 1 2 1 p2 4 0 0 3 p3 1 2 1 0 p4 1 0 3 0 Sum 8 3 7 5 12/2/2018 COP4610

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

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

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

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

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

Example - cont. P2 requests an additional instance of type C. Allocation Request Available A B C A B C A B C P0 0 1 0 0 0 0 0 0 0 P1 2 0 0 2 0 2 P2 3 0 3 1 0 0 P3 2 1 1 1 0 0 P4 0 0 2 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. 12/2/2018 COP4610

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

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

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

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

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

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

Example p0 p1 S00 12/2/2018 COP4610

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

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

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

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

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

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

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

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

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

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 P0 1 0 1 1 0 0 1 0 0 P1 0 2 0 2 0 0 P2 0 0 0 0 1 1 12/2/2018 COP4610

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 P0 1 0 1 1 0 0 0 0 0 P1 1 0 0 0 1 0 P2 0 2 0 0 0 1 12/2/2018 COP4610

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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