Deadlocks. System Model

Transcription

1 Deadlocks System Model Several processes competing for resources. A process may wait for resources. If another waiting process holds resources, possible deadlock. NB: this is a process-coordination problem much like the Critical Section problem, but at a somewhat higher level (e.g. semaphores are already assumed to exist). Finite number of resources distributed among a number of processes. Resources partitioned into types (CPU cycles, memory, files,... ). All resources within a partition are equivalent. A process must request a resource before using it. A process must release a resource when it is done with it. A process may request as many resources as it wants (can t exceed total number of resources). CS Basic OS 1 CS Basic OS 2 Sequence of Resource Usage Example Deadlock 1. Request If the request cannot immediately be granted, process must wait. 2. Use The process can hold the resource for as long as it needs. 3. Release 3 processes, 3 tape drives. Each process has requested and holds a tape drive. Each process requests another tape drive. Request/release are usually system calls. Usually, use of resource is only through system calls too. CS Basic OS 3 CS Basic OS 4

2 The 4 Necessary Conditions For Deadlock Resource Allocation Graphs Mutual Exclusion: At least one resource is non-sharable. i.e., only one process at a time can use it. If another process requests the resource, it must wait. Hold and Wait: There must exist a process that is holding at least one resource and is waiting to acquire additional resources held by other processes. No Preemption: Resources cannot be taken away from processes. the processes must voluntarily relinquish them when done. Circular Wait: There must exist a set of processes {p 0,p 1,..., p n } such that p 0 is waiting for a resource p 1 has, p 1 is waiting for p 2,...,p n is waiting for p 0. All four of these conditions must exist for there to be a deadlock. G =(V, E). V is a set of vertices and E a set of edges. Two types of vertices: 1. process nodes, p P = {p 1,p 2,..., p n }: set of all processes in the system 2. resource nodes, r R = {r 1,r 2,..., r n }: set of all resource types in the system Each edge in E is an ordered pair, either: from a process to a resource node: (p i,r j ): p i has requested and is waiting for a resource of type r j (A request edge) from a resource to a process node: (r j,p i ):a resource of type r j has been allocated to process p i (An assignment edge) Pictorially: represent each process as a circle and each resource type as a box filled with a number of dots corresponding to the number of resources of the type. CS Basic OS 5 CS Basic OS 6 Resource Allocation Graphs Sample Resource Allocation Graph r3 A request edge points to the box, an assignment edge originates from one of the dots in the box. New resource requests add request edges. Granting resources transforms request edges to assignment edges. p1 p2 p3 r4 P = {p 1,p 2,p 3 } R = {r 1,r 2,r 3,r 4 } E = {(p 1,r 1 ), (p 2,r 3 ), (r 1,p 2 ), (r 2,p 2 ), (r 2,p 1 ), (r 3,p 3 )} Process p 1 holds: 1 r 2, wants: 1 r 1. Process p 2 holds: 1 r 1, 1 r 2 ; wants: 1 r 3. Process p 3 holds: 1 r 3. No process holds or wants any r 4. CS Basic OS 7 CS Basic OS 8

3 Resource Allocation Graphs Resource Allocation Graph With a Deadlock If the graph contains no cycles, then no deadlock exists If the graph contains a cycle, a deadlock might exist. (necessary but not sufficient case for deadlock) If each resource type has exactly one instance, then a cycle is both necessary and sufficient for a deadlock r3 p1 p2 p3 r4 Two cycles: p 1 r 1 p 2 r 3 p 3 r 2 p 1. p 2 r 3 p 3 r 2 p 2. CS Basic OS 9 CS Basic OS 10 Graph With Cycle But No Deadlock How to Deal With Deadlocks p1 p2 p3 1. Never allow one to happen (deadlock prevention, deadlock avoidance). 2. Allow deadlocks then recover (deadlock detection, deadlock recovery). p4 Cycle: p 1 r 1 p 3 r 2 p 1 p 4 may release an r 2, thus making it available for p 3, and breaking the cycle. Therefore, no deadlock. CS Basic OS 11 CS Basic OS 12

4 Deadlock Prevention: Deny One of the Necessary Conditions Deadlock Avoidance Mutual Exclusion: Sharable resources do not require mutual exclusion. For example, read-only files. Some resources, however, are intrinsically non-sharable. Hold and Wait: Don t allow resources to be held when new resources are requested. Request all resources when execution begins. Request some resources and use them, but release them before asking for others. Both lead to low resource utilization and possible starvation. No Preemption: Allow preemption. Good for resources whose state can be saved and restored later, like the processor or memory. Circular Wait: Impose a total ordering on all resources. must acquire resources in increasing order. Attempt to address low resource utilization of deadlock prevention. Requires additional information about how resources are to be requested. Not all requests have to wait, but some do. Therefore, resource utilization may still be low. CS Basic OS 13 CS Basic OS 14 Simplest Avoidance Model Safe and Unsafe States (Formally) Each process must declare the maximum number of each type of resource it wants. Given this, you can construct an algorithm that guarantees a deadlock will never occur. Deadlock avoidance algorithms dynamically examine resource allocation state to ensure that there can never be a circular wait condition. A resource allocation state is defined by number of available and allocated resources and the maximum demands of the processes. A particular state is safe is the system can allocate resources to each process in some order and still avoid a deadlock. A system is in a safe state only if there exists a safe sequence. A sequence of processes <p 1,p 2,..., p n > is a safe sequence for the current allocation state if for each p i, the resources that p i can still request can be satisfied by the currently available resources plus the resources held by all the p j where j < i. E.g., if not all the resources p i needs are available, then p i could: 1. wait until all p j have finished, 2. obtain its needed resources, 3. complete its designated task, 4. return its allocated resources, and 5. terminate. When p i finishes, p i+1 can obtain its needed resources, etc. If no safe sequence exists, the system is in an unsafe state. CS Basic OS 15 CS Basic OS 16

5 Safe and Unsafe States An Example A safe state is not a deadlocked state. A deadlocked state is not a safe state. Not all unsafe states are deadlock states. However, an unsafe state may lead to a deadlock. As long as the state is safe, the os can avoid unsafe states and deadlocks. 12 resources (tape drives) in system. Maximum Needs Current (time = T 0 ) p p p Therefore, 3 free tape drives. deadlock unsafe <p 1,p 0,p 2 > is a safe sequence. If p 2 is allocated another, the system is no longer in a safe state. Why not? safe CS Basic OS 17 CS Basic OS 18 Banker s Algorithm for Deadlock Avoidance Banker s Algorithm Assume n processes and m resource types Available: array of length m = number of available resources of each type. Max: n m array = maximum demand of each process. Allocation: n m array = Current Resource Allocation. Need: n m array = remaining resource need of each process. Note that Need[i, j] =Max[i, j] Allocation[i, j] Other notation: If X and Y are vectors of length n, x<yif for each i, x[i] <y[i]. Each row of Allocation and Need is a vector. Allocation i denotes resources currenly allocated to process p i. Need i denotes resources needed by process p i. Let Request i be the request vector for process p i. If Request i [j] =k, then process p i wants k instances of resource type r j. When a request for resources is made by process p i, the following actions are taken: 1. If Request i Need i proceed to step 2. Otherwise raise an error, because a process has exceeded its maximum claim. 2. If Request i Available proceed to step 3. Otherwise p i must wait. 3. Pretend to allocate the requested resources to process p i by pretending to modify the state as follows: Available = Available Request i Allocation i = Allocation i + Request i Need i = Need i Request i If the resulting allocation is safe, let it happen for real. If it is unsafe, p i must wait. CS Basic OS 19 CS Basic OS 20

6 How To Tell a Safe State An Example 1. Let W ork and F inish be vectors of length m and n respectively. Initialize W ork = Available and F inish[i] =false. 2. Find an i Such That: (a) F inish[i] =f alse (b) Need j W ork If none exists, go to step 4 3. Simulate the finish of the process from step 2: (a) W ork = W ork + Allocation i (b) F inish[i] =true (c) goto Step 2 4. If F inish[i] =true for all i, the the system is in a safe state. If not, this is an unsafe state. Note: This is an O(mn 2 ) algorithm. Five processes {p 0,p 1,p 2,p 3,p 4 } Three resource types {A, B, C} 10 A s, 5 B s, and 7 C s Time T 0 : Allocation Max Available A B C A B C A B C p p p p p Need = Max Allocation: Need ABC p p p p p CS Basic OS 21 CS Basic OS 22 Banker s Alg. Example (cont.) Banker s Alg. Example (III) This system is in a safe state. <p 1,p 3,p 4,p 2,p 0 > is a safe sequence. Now assume p 1 requests an additional A and two more C s, i.e., Request i = (1, 0, 2). 1. First check that Request i Available i 2. (1, 0, 2) (3, 3, 2)... YES 3. Pretend: Allocation Need Available A B C A B C A B C p p p p p Apply safety algorithm. 5. Find that <p 1,p 3,p 4,p 0,p 2 > is safe 6. Therefore, grant request. An unsafe request would be Request 0 = (0, 2, 0) 1. First check that Request i Available i 2. (0, 2, 0) (3, 3, 2)... YES 3. Pretend: Allocation Need Available A B C A B C A B C p p p p p Apply safety algorithm. 5. What is the result? CS Basic OS 23 CS Basic OS 24

7 Things are Simpler With One Instance of Each Resource Claim Edge Example Add claim edges to resource allocation graphs. Claim edge (p i,r j ) indicates p i may request r j sometime in the future (use a dashed line arrow). When the request is actually made, the claim edge is converted to a request edge. When the resource is released, the assignment edge is converted back to a claim edge. Like Banker s Alg. all resources must be claimed a priori. A resource request can be granted if converting the request edge to an assignment edge does not form a cycle. Cycle detection is O(n 2 ). Banker s Alg. was O(mn 2 ). No cycle = safe state, cycle = unsafe state. p1 p 1 holds r 1. p 2 has requested r 1. Both processes have claims on r 2. Suppose p 2 requests r 2. Although r 2 is free, granting it would create a cycle which leaves the system in an unsafe state. p2 CS Basic OS 25 CS Basic OS 26 Claim Edge Example (cont.) Deadlock Detection/Recovery p1 p2 If p 1 requests r 2 a deadlock will occur. If you do not use either deadlock prevention or deadlock avoidance then deadlocks may occur. You then need algorithms to: determine when a deadlock has occurred, and recover from a deadlock. Note that the expense of deadlock detection/recovery techniques not only include the costs of maintaining the necessary information, but also the potential losses from recovery. CS Basic OS 27 CS Basic OS 28

8 Deadlock Detection (Several Instances of a Resource Type) Shoshani and Coffman Algorithm Keep the following data structures (similar to Banker s Algorithm): Available: A vector of length m indicating the number of available resources of each type. Allocation: An n m matrix defining the number of resources of each type held by each process. Request: An n m matrix indicating the current request of each process. If Request[i, j] =k, the process p i is requesting k more instances of resource type r j. Simply investigate every possible allocation sequence for the processes that remain to be completed: 1. Let W ork and F inish be vectors of length m and n, respectively. Initialize W ork = Available. For i =1, 2,..., n, if Allocation i 0then F inish[i] =f alse; else, F inish[i] =true. 2. Find an index i Such That: (a) F inish[i] =false, and (b) Request i W ork If none exists goto Step 4 3. Simulate process finish: W ork = W ork + Allocation i F inish[i] =true goto step 2 4. If F inish[i] =false for any i, the system is in a deadlocked state. Process p i is one of the deadlocked processes. CS Basic OS 29 CS Basic OS 30 An Example Allocation Request Available A B C A B C A B C p p p p p This is not deadlocked. <p 0,p 2,p 3,p 1,p 4 > results in F inish[i] = true for all i Single Instance of Each Resource is Simpler Like Banker s Alg. deadlock detection alg. is O(mn 2 ) For single instance case, we construct another kind of graph and run a cycle detection algorithm (O(n 2 )) If p 2 requests an additional C, modify request matrix to: Request ABC p p p p p Now, we are deadlocked. although we can reclaim resources from p 0, it won t leave enough for everybody else. Thus, p 1, p 2, p 3 and p 4 are deadlocked. CS Basic OS 31 CS Basic OS 32

9 Wait-For Graphs Wait-For graphs p5 Constructed by removing resource nodes from Resource Allocation Graphs and collapsing appropriate edges. An edge (p i,p j ) in a Wait-For Graph means p i is waiting for p j to release a resource. An edge exists only if (p i,r q ) and (r q,p j ) existed in the original resource allocation graph for some resource q. If the Wait-For Graph contains a cycle, there is a deadlock. If system maintains a Wait-For Graph, it can periodically check for cycles. r3 p1 p2 p3 p4 r5 p5 p1 p2 p3 r4 p4 CS Basic OS 33 CS Basic OS 34 Deadlock Algorithm Usage Recovery From Deadlock How often should the deadlock detection algorithm be run? Depends on: How often do we believe a deadlock occurs? How many processes will be affected by a deadlock when it happens? Remember, resources allocated to deadlocked processes sit idle. If you invoked it every request, then you can determine which process caused a deadlock. This is expensive. Usually only run it at long intervals, or when CPU utilization is low. Tell the operator and let him or her deal with it. Let the system recover automatically. Kill some processes involved in a circular wait. Preempt some resources. CS Basic OS 35 CS Basic OS 36

10 Process Termination Resource Preemption Kill all deadlocked processes. Expensive. Overkill (if you ll pardon the pun) Kill one process at a time until the deadlock is eliminated. Still expensive. Have to run detection alg. after every kill. Hard to make good choice of victim process. Low priority. How long it has been working already. How many resources it s holding. etc. You must reset the state of any resources in use when you kill a process. Select a victim: similar to previous. Rollback: if you preempt a resource, what do you do with the process? Roll it back to a safe state. Need to keep checkpoints or roll back to the beginning. Starvation: if you keep preempting from the same process, starvation may occur. CS Basic OS 37 CS Basic OS 38 Combined Approach to Deadlock Handling This page intentionally left blank. Usually, prevention, avoidance or detection each work better for some classes of resources than for others. Break resources into classes and use a different technique on each class. CS Basic OS 39 CS Basic OS 40

11 This page intentionally left blank. This page intentionally left blank. CS Basic OS 41 CS Basic OS 42