1. Chapter 7 Deadlocks

2. 7.1 Introduction Deadlock Common approaches to deal with deadlock – Prevention – Avoidance – Detection and recovery

3. 7.2 Basic Principles of Deadlock A state of indefinite waiting of a process May occur when processes are competing for resources or when attempting to interact with one another 3

4. 4 Resource Allocation and Deallocation When a process needs resources, it will normally follow the sequence: 1.Request a number of resource instances. If the resources requested are not available, then process must wait 2.Acquire resource(s), the OS allocates resources 3.Use the resource(s) for a finite interval. 4.Release the resource(s).

5. 5 Synchronizing Allocation of Resources Semaphores can be used to synchronize the allocation and de-allocation of resources.

6. 6 Multiple Resource Allocation Problem Several processes may compete for multiple resources If the allocation of multiple resources to processes is not done with proper synchronization, deadlock might occur This waiting state is much more involved than starvation

7. 7 Deadlock Problem A set of blocked (suspended) processes Each process holding one or more resources Processes waiting to acquire one or more resources held by other processes

8. 8 Example of Deadlock A system has two tape drives, which processes P1 and P2 need Processes P1 and P2 each acquire one tape drive and each wait for the other tape drive Processes P1 and P2 are blocked waiting indefinitely to acquire the other tape unit

9. 9 Deadlock – General Definition A set of processes is in a deadlock state when every processes in the set is waiting for an event that can only be caused by another process in the set. The events of interest are: – allocations of resources – release of resources The resources are: CPU cycles, memory spaces, files, I/O devices in the computer system.

10. 10 Disadvantage Of Deadlock Deadlocked processes can never complete execution because they are waiting indefinitely System resources are tied up because they are held by deadlocked processes. Deadlocks are undesirable because they normally slow down a system

11. 11 Another Example Of Deadlock Consider a system with one printer and one disk unit. Processes P and Q both need the two resources Suppose that process P is holding the printer, and process Q is holding the disk unit. Now P waits for the disk unit and Q waits for the printer. Process P is waiting for process Q to release the disk unit, and process Q is waiting for process P to release the printer.

12. 12 Result Both processes are deadlocked, they cannot proceed.

13. 13 7.2.1 Resource Allocation Graph A resource allocation graph shows the relationships between processes and resources. It consists of the following components: A set of processes P = { P0, P1, …., Pi,…., Pn } A set of resource types, R = { R0, R1, …,Rj,..,Rm } A set of directed edges

14. 14 Directed Edges A request edge (Pi, Rj) from process Pi to resource Rj. Thus, Pi is waiting for an instance of resource type Rj. An assignment edge (Rj, Pi) from resource Rj to process Pi. It indicates that an instance of Rj has been allocated to process Pi.

15. 15 A Resource Allocation Graph

16. 16 7.2.2 Conditions for the Existence of Deadlock A deadlock arises if four conditions hold simultaneously in a system: 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.

17. 17 Conditions for Deadlock (Cont.) No preemption: a resource can be released only voluntarily by the process holding it, after that process has completed its operations. 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, but P1 is waiting for a resource held by P2, …, Pn-1 is waiting for a resource held by Pn, and Pn is waiting for a resource held by P0.

18. 18 About These Conditions These conditions are necessary but not sufficient for deadlock to occur.

19. 19 Resource Allocation Graph with a Cycle

20. 20 Analysis Of This Graph This graph has a cycle Processes p1, p2, and p3 are deadlocked.

21. 21 Another Resource Allocation Graph

22. 22 Analysis Of Resource Allocation Graph If the graph contains no cycles, no deadlock exists. If the graph contain cycles – if each resource type has only 1 instance, then a deadlock exits. – otherwise, a deadlock may exist.

23. 23 Illustrates processes that are competing for exclusive access to more than one resource, such as tape drives or I/O devices. A monastery’s dining table – Circular table – Five plates – Five forks (critical) – Plate of noodles at center of table (endless supply) – Philosophers can only reach forks adjacent to their plate (left and right forks) 7.3 Dining Philosophers

24. 24 Life of a Philosopher 1.Spends some time thinking 2.Gets hungry 3.Sits at the table 4.Attempts to get the left fork 5.Attempts to get the right fork 6.Starts eating, this activity takes a finite time 7.Releases the left and right forks 8.Returns to the initial state (thinking)

25. 25 Dining Table

26. 26 When a philosopher is hungry – obtains 2 forks (1 at a time) – Proceeds to eat When a philosopher has satisfied hunger returns both forks and goes back to think Problem: There are 5 competing philosopher processes Using semaphores as before, is not sufficient for solving the problem Why Synchronize?

27. 27 Suppose all philosophers want to eat at the same time Each one will pick up the left fork first then block trying to pickup the right fork All processes will now block indefinitely - deadlock Dining Philosophers 1st Attempt

28. 28 Dining Philosophers 2nd Attempt After taking the left fork, if the right fork is not available, philosopher puts back the left fork and waits for a while. Problem: Suppose all philosophers want to eat at the same time: – Each will pick up the left fork first and then try to pick up the right fork. – The right fork is not available, so all philosophers put back left forks and wait. – After some time, philosophers pick up the left fork and try again - the cycle repeats.

29. 29 Use a mutex semaphore to make eating mutually exclusive. A philosopher is guaranteed to get both forks in this case. Problem: Only one philosopher can be eating at any given time. Dining Philosophers 3rd Attempt

30. 30 4th Attempt to a Solution A philosopher’s neighbors are defined by macros LEFT & RIGHT. A philosopher may move only into eating state if neither neighbor is eating. Use an array, state, to keep track of whether a philosopher is eating, thinking or hungry (trying to acquire forks). Use an array of semaphores, one per philosopher, so hungry philosophers can block if the needed forks are busy.

31. 31 7.4 Method for Handling Deadlocks General approaches Ensure that the system will never enter a deadlock state. Allow the system to enter a deadlock state and then recover. Ignore the problem and pretend that deadlocks never occur in the system.

32. 32 Methods For Dealing With Deadlocks Deadlock prevention: disallow the existence of one of the four necessary conditions for deadlocks to occur. Deadlock avoidance: for each resources request which can be satisfied, determine whether the request should be delayed in order to avoid a possible deadlock in the future. Deadlock detection and recovery: detect the existence of deadlock; if it has occurred, take actions to remove it.

33. 33 7.5 Deadlock Prevention Non-existence of the hold and wait condition – break condition 2 Non-existence of the circular wait condition – break condition 4

34. 34 7.5.1 Disallowing Hold and Wait Non-existence of hold and wait. Two methods: A process must require all resources it need before starting to use the resources A process must release all resources it has acquired before requesting any new resources. In both methods: – Low resource utilization (system throughput, resource utilization, average wait time are affected) – Starvation possible (a low priority process may wait forever)

35. 35 7.5.2 Disallowing Circular Wait Non-existence of circular wait. Impose a linear ordering of resource types. Processes must request resources in an increasing order of enumeration.

36. 36 Disallow Circular Wait Impose a total ordering of all resource types, R = {R1, R2, …, Rm}. Define a one to one function, F: R  N Require that each process requests resources in an increasing order of enumeration. Process P can request resources of type Ri, then resources of type Rj, only if: F( Rj) > F( Ri)

37. General Cycle 37

38. 38 Example of Linear Ordering A system has the following resources types: R = {Disk, Tape, Printer} The following ordering is defined for the resources with function F: F(Disk) = 1; F(Tape) = 3; F(Printer) = 7 A process, P, has to request first an instance of Disk, then an instance of Tape, then an instance of Printer. If a process holds Tape drive and ask for Disk, can this process acquire it? No. why? – it must release Tape, then acquire Disk, and then acquire Tape

39. 39 Deadlock Prevention (3) Non-existence of mutual exclusion; make each resource shareable (impossible for printers). – break condition 1 Existence of preemption: – break condition 3 – Process must release resources held when no further resource allocations are possible. – Preempt the desired resources from a waiting process which hold the resource. – A Process will be restarted only when it can regain its old resources, and acquire the new resources requested.

40. 40 7.6 Deadlock Avoidance Requires that the system have additional a priori information available Each process declares the maximum need of resources. The algorithm dynamically examines the resource-allocation state to ensure non- existence of circular-wait The system is kept in a safe state

41. 41 Banker’s algorithm To check current resource-allocation state is safe state. P1, P2, …, Pn: processes C, a vector with the total number of instances of every resource type – called existing resource vector. Ci is number of resource class i ( 1 ≤ i ≤ m) R, a available resource vector, with Ri giving the number of instances that are currently available (remaining resource). A, a matrix with the number of resource instances of every resource type in system - called current allocation matrix. Aij is the number of instance of resource j that Pi currently holds. M, a matrix with the maximum claim of every resource type declared by every process called request matrix. Mij is the number of instance of resource j that Pi wants.

42. 42 Banker’s algorithm – learn details via example Example on page 202: A system has 5 processes: P1, …, P5. There are 4 resource types: R1, …, R4. The total numbers of resource units for R1, …, R4 is 5, 6, 8, 4, respectively. P1’s request for R1, …, R4, is 3, 2, 2, 2 P2’s request for R1, …, R4, is 2, 1, 1, 2 P3’s request for R1, …, R4, is 1, 1, 3, 1 P4’s request for R1, …, R4, is 3, 4, 2, 2 P5’s request for R1, …, R4, is 2, 4, 1, 4 current allocation matrix at time t is: What is the safe sequence to continue to run these 5 process? (Or: Is the system deadlocked? If yes, which processes are involved?)

43. 43 Example solution Existing resource vector, Request matrix, Current allocation matrix Available resource vector,

44. 44 Example solution – cont’d Available resource vector, Need matrix, (1)Compare row vector of N with R, to determine which process can run. P3 can run, R = R – row vector 3 of N = (0 0 2 2) – (0 0 2 1) = (0 0 0 1). (2)After a finite time, P3 finishes and releases its resources. R = R + row vector 3 of M = (0 0 0 1) + (1 1 3 1) = (1 1 3 2)

45. 45 Example solution – cont’d (3) Compare row vector of N with R, to determine which process can run next. P1 can run, R = R – row vector 1 of N = (1 1 3 2) – (1 1 1 2) = (0 0 2 0). (4) After a finite time, P1 finishes and releases its resources. R = R + row vector 1 of M = (0 0 2 0) + (3 2 2 2) = (3 2 4 2) (5) Compare row vector of N with R, to determine which process can run third. P2 can run, R = R – row vector 2 of N = (3 2 4 2) – (2 0 0 2) = (1 2 4 0). (6) After a finite time, P2 finishes and releases its resources. R = R + row vector 2 of M = (1 2 4 0) + (2 1 1 2) = (3 3 5 2)

46. 46 Example solution – cont’d (5) Compare row vector of N with R, to determine which process can run fourth. P4 can run, R = R – row vector 4 of N = (3 3 5 2) – (2 3 0 1) = (1 0 5 1). (6) After a finite time, P4 finishes and releases its resources. R = R + row vector 4 of M = (1 0 5 1) + (3 4 2 2) = (4 4 7 3) (7) P5 acquires (1 2 0 3) resources and runs to completion. Conclusion: No deadlock. The safe sequence of resource allocation is: P3, P1, P2, P4, P5.

47. 47 Safe Sequence of Resource Allocation A system is in a safe state if a safe allocation sequence of processes exists for the current resource allocation state A sequence of processes is a safe sequence for a given resource allocation state if for each process i, its maximum resource request can be satisfied by the current resources plus the total resources held by each P j with 0 < j < i

48. 48 Unsafe State If a system is in an unsafe state, then some sequence of requests may lead “unavoidably” to a deadlock (i.e., the deadlock cannot be avoided by delaying the requests from the processes). An unsafe state is not necessarily a deadlock state and does not necessarily lead to deadlock state.

49. 49 Example 2 A system exhibits the following state: there are three processes P0, P1, P2; total system resources: 12 units of magnetic tape. ProcessMax_need Allocation P0 10 5 P1 4 2 P2 9 2 Find out whether the system is in a safe state.

50. 50 Solution Procedure 1.Compute the resources currently available, which is (12 – 9) = 3 2.Build the Need column with the numbers of resources that processes currently need to reach the maximum claim. These are 5, 2, and 7 (for P1, P2, and P3 respectively) 3.Select a process that can proceed to acquire its current need of resources 4.When the process releases the resources, compute the total number of available resources 5.Repeat from step 3

51. 51 Final Solution Safe sequence of allocations found: Therefore, the given state is a safe state

52. 52 Example 2 Assume that when in state 1, the OS allocates 1 more unit of tape. The new state is: Process Max_need AllocationsNeed P0 10 5 5 P1 4 2 2 P2 9 3 6 Resources currently available: 2

53. 53 Safe State? After process P1 completes and releases all the resources it held, the total resources available is 4, which is not sufficient to satisfy the needs of P0 or P2. Therefore, the state given is unsafe, no safe sequence of allocations is possible.

54. 54 Example 3 A system has five processes {PO, P1, … P4} and three resource types {A, B, C}, with 10, 5, and 7 instances respectively. PROCESSALLOCATIONMAXNEED A B CA B C A B C P00 1 07 5 3 7 4 3 P1 2 0 03 2 2 1 2 2 P2 3 0 29 0 2 6 0 0 P3 2 1 1 2 2 2 0 1 1 P4 0 0 2 4 3 3 4 3 1

55. 55 Solution The system is currently in a safe state. The sequence: satisfies the safety criteria.

56. 56 7.7 Deadlock Detection and Recovery Allow system to enter deadlock state Run detection algorithm Recovery Scheme

57. 57 Detection and Recovery A detection and recovery scheme requires overhead that includes: Maintaining information and running the detection algorithm The potential losses inherent in recovering from deadlock

58. 58 Deadlock Detection A detection algorithm is invoked periodically to determine whether a deadlock has occurred. A system has a deadlock if and only if it is impossible to satisfy the resource requests of some processes Formally, a system is in a deadlock-free state if there exists a deadlock-free sequence for the current resource allocation state.

59. 59 Detection Approach The operating system can check for deadlock every time a resource is allocated; this is early detection. Other algorithms are used to detect cycles in the resource allocation graph. The techniques are based on incremental changes to the system state. The algorithms attempt to find a process with its resource requests that can be allocated with the currently available resources, the resources are allocated to the process, the resources are used by the process, and then the resources are released. This is repeated with the other processes. The processes that are in deadlock are identified and a procedure is initiated to stop deadlock.

60. 60 Frequency of Running Deadlock Detection The deadlock detection algorithm can be invoked every time a process requests a resource that cannot be immediately granted (allocated). In this case, the operating system can directly identify the specific process that caused deadlock, in addition to the set of processes that are in deadlock. The detection algorithm is invoked periodically using a period not too long or not too short. Since deadlock reduces the CPU utilization and the system throughput, detection algorithm may be invoked when the CPU utilization drops below 40%.

61. 61 7.7.2 System Recovery Abort all deadlocked processes Abort processes one at a time Preempt resources one at a time Rollback

62. 62 Recovery: Process Termination Abort all deadlocked processes. Abort one process at a time until the deadlock cycle is eliminated. In which order should processes be aborted? – 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?

63. 63 Recovery (2) Selection of resources for preemption and processes to abort. - successively preempt some resources from processes and allocate theses resources to other process until the deadlock cycle is broken. Rollback: the system saves snapshots of a process’ state at periodic intervals. To break a deadlock, the system aborts a process and later resume it at the most recent checkpoint; (technique also useful in system crashes).

64. 64 Deadlock Recovery (3) Process termination - abort (terminate) one or more processes to break the circular-wait condition. Starvation is possible, the same process is selected from which to preempt resources, and it never completes.

65. 7.8 Summary Deadlock Directed graph Deadlock prevention Deadlock avoidance Deadlock detection and recovery