1. Deadlocks Mark Stanovich Operating Systems COP 4610

2. Deadlocks  Resource: Something a thread waits for  Deadlocks: Occur when threads are waiting for resources with circular dependencies Often involve nonpreemptable resources, which cannot be taken away from its current thread without failing the computation (e.g., storage allocated to a file)

3. Deadlocks  Deadlocks that involve preemptable resources (e.g., CPU) can usually be resolved by reallocation of resources  Starvation: a thread waits indefinitely  A deadlock implies starvation

4. An Example of Deadlocks Thread AThread B P(x);P(y); P(y);P(x);  A deadlock won’t always happen with this code, but it might

5. Deadlocks, Deadlocks, Everywhere…  Can happen with any kind of resource Among multiple resources  Cannot be resolved for each resource independently A thread can grab all the memory The other grabs all the disk space Each thread may need to wait for the other to release

6. Deadlocks, Deadlocks, Everywhere…  Round-Robin CPU scheduling cannot prevent deadlocks (or starvation) from happening  Can occur whenever there is waiting…

7. A Classic Example of Deadlocks  Dinning lawyers (philosophers)  Each needs two chopsticks to eat

8. Dining Lawyers  If each first grabs the chopstick on their right before the one on their left, and all grab at the same time, we have a deadlock (Personally, I prefer to starve than share chopsticks…)

9. A Dining Lawyer Implementation semaphore chopstick[5] = {1, 1, 1, 1, 1}; lawyer(int j) { while (TRUE) { P(chopstick[j]); P(chopstick[(j + 1) % 5]; // eat V(chopstick[(j + 1) % 5]; V(chopstick[j]); }

10. A Dining Lawyer Implementation // chopstick[5] = {0, 0, 0, 0, 0}; lawyer(int j) { while (TRUE) { P(chopstick[j]); P(chopstick[(j + 1) % 5]; // eat V(chopstick[(j + 1) % 5]; V(chopstick[j]); }

11. A Dining Lawyer Implementation // chopstick[5] = {0, 0, 0, 0, 0}; lawyer(int j) { while (TRUE) { P(chopstick[j]); P(chopstick[(j + 1) % 5]; // eat V(chopstick[(j + 1) % 5]; V(chopstick[j]); }

12. What Causes a Deadlock?  Four necessary (but not sufficient) conditions Limited access (lock-protected resources) No preemption (if someone has the resource, it cannot be taken away) Wait while holding (holding a resource while requesting and waiting for the next resource) Circular chain of requests

13. How to deal with deadlocks?  Prevention  Ensure it cannot occur  Avoidance  Dynamically steer clear of it  Detection  Recover if one occurs

14. Deadlock Prevention Techniques  When encountering a deadlock All four conditions must be true  To prevent deadlocks Remove one of the four conditions

15. Deadlock Prevention Techniques 1. Infinite resources (buy a very large disk)

16. Deadlock Prevention Techniques 2.No sharing (independent threads)

17. Deadlock Prevention Techniques 3.Allocate all resources at the beginning (if you need 2 chopsticks, grab both at the same time) easier said than done…

18. Deadlock Prevention Techniques 3.Allocate all resources at the beginning (if you need 2 chopsticks, grab both at the same time) semaphore chopstick[5] = {1, 1, 1, 1, 1}, s = 1; lawyer(int j) { while (TRUE) { P(s); P(chopstick[j]); P(chopstick[(j + 1) % 5]; // eat V(chopstick[(j + 1) % 5]; V(chopstick[j]); V(s); }

19. Deadlock Prevention Techniques 3.Allocate all resources at the beginning (if you need 2 chopsticks, grab both at the same time) semaphore chopstick[5] = {1, 1  0, 1  0, 1, 1}, s = 1  0; lawyer(int j) { while (TRUE) { P(s); P(chopstick[j]); P(chopstick[(j + 1) % 5]; // eat V(chopstick[(j + 1) % 5]; V(chopstick[j]); V(s); } 1

20. Deadlock Prevention Techniques 3.Allocate all resources at the beginning (if you need 2 chopsticks, grab both at the same time) // chopstick[5] = {1, 0, 0, 1, 1}, s = 0; lawyer(int j) { while (TRUE) { P(s); P(chopstick[j]); P(chopstick[(j + 1) % 5]; // eat V(chopstick[(j + 1) % 5]; V(chopstick[j]); V(s); } 1 3

21. Deadlock Prevention Techniques 3.Allocate all resources at the beginning (if you need 2 chopsticks, grab both at the same time) // chopstick[5] = {1, 1, 1, 1, 1}, s = 1; lawyer(int j) { while (TRUE) { P(s); P(chopstick[j]); P(chopstick[(j + 1) % 5]; V(s); // eat P(s); V(chopstick[(j + 1) % 5]; V(chopstick[j]); V(s); }

22. Deadlock Prevention Techniques 3.Allocate all resources at the beginning (if you need 2 chopsticks, grab both at the same time) // chopstick[5] = {1, 1  0, 1  0, 1, 1}, s = 1  0  1; lawyer(int j) { while (TRUE) { P(s); P(chopstick[j]); P(chopstick[(j + 1) % 5]; V(s); // eat P(s); V(chopstick[(j + 1) % 5]; V(chopstick[j]); V(s); } 1

23. Deadlock Prevention Techniques 3.Allocate all resources at the beginning (if you need 2 chopsticks, grab both at the same time) // chopstick[5] = {1, 0, 0, 1  0, 1  0}, s = 1  0  1; lawyer(int j) { while (TRUE) { P(s); P(chopstick[j]); P(chopstick[(j + 1) % 5]; V(s); // eat P(s); V(chopstick[(j + 1) % 5]; V(chopstick[j]); V(s); } 13

24. Deadlock Prevention Techniques 3.Allocate all resources at the beginning (if you need 2 chopsticks, grab both at the same time) // chopstick[5] = {1, 0, 0, 0, 0}, s = 1  0; lawyer(int j) { while (TRUE) { P(s); P(chopstick[j]); // deadlock P(chopstick[(j + 1) % 5]; V(s); // eat P(s); V(chopstick[(j + 1) % 5]; V(chopstick[j]); V(s); } 13 2

25. Deadlock Prevention Techniques 3.Allocate all resources at the beginning (if you need 2 chopsticks, grab both at the same time) // chopstick[5] = {1, 0, 0, 0, 0}, s = 0; lawyer(int j) { while (TRUE) { P(s); P(chopstick[j]); P(chopstick[(j + 1) % 5]; V(s); // eat P(s); // deadlock V(chopstick[(j + 1) % 5]; V(chopstick[j]); V(s); } 13 2

26. Deadlock Prevention Techniques 3.Allocate all resources at the beginning (if you need 2 chopsticks, grab both at the same time) int counter[5] = {1, 1, 1, 1, 1}; semaphore chopstick[5] = {1, 1, 1, 1, 1}, s = 1; lawyer(int j) { while (TRUE) { P(s); // if both counters j and (j + 1) % 5 > 0, decrement counters // and grab chopstick[j] and chopstick[(j + 1) % 5] V(s); // if holding both chopsticks, eat P(s); // release chopsticks and increment counters as needed V(s); }

27. Deadlock Prevention Techniques 3.Allocate all resources at the beginning (if you need 2 chopsticks, grab both at the same time) // counter[5] = {1, 0, 0, 1, 1}; chopstick[5] = {1, 0, 0, 1, 1}, s = 1; lawyer(int j) { while (TRUE) { P(s); // if both counters j and (j + 1) % 5 > 0, decrement counters // and grab chopstick[j] and chopstick[(j + 1) % 5] V(s); // if holding both chopsticks, eat P(s); // release chopsticks and increment counters as needed V(s); } (1, 2) 1

28. Deadlock Prevention Techniques 3.Allocate all resources at the beginning (if you need 2 chopsticks, grab both at the same time) // counter[5] = {1, 0, 0, 1, 1}; chopstick[5] = {1, 0, 0, 1, 1}, s = 1; lawyer(int j) { while (TRUE) { P(s); // if both counters j and (j + 1) % 5 > 0, decrement counters // and grab chopstick[j] and chopstick[(j + 1) % 5] V(s); // if holding both chopsticks, eat P(s); // release chopsticks and increment counters as needed V(s); } (1, 2) 1 () 2

29. Deadlock Prevention Techniques 3.Allocate all resources at the beginning (if you need 2 chopsticks, grab both at the same time) // counter[5] = {1, 0, 0, 0, 0}; chopstick[5] = {1, 0, 0, 0, 0}, s = 1; lawyer(int j) { while (TRUE) { P(s); // if both counters j and (j + 1) % 5 > 0, decrement counters // and grab chopstick[j] and chopstick[(j + 1) % 5] V(s); // if holding both chopsticks, eat P(s); // release chopsticks and increment counters as needed V(s); } (1, 2) 1 (3, 4) 3

30. Deadlock Prevention Techniques 4.Make everyone use the same ordering in accessing resource (All threads must call P(x) before P(y) // chopstick[5] = {1, 1, 1, 1, 1}; lawyer(int j) { while (TRUE) { P(chopstick[min(j, (j + 1) % 5)]); P(chopstick[max(j, (j + 1) % 5)]); // eat V(chopstick[max(j, (j + 1) % 5)]); V(chopstick[min(j, (j + 1) % 5)]); }

31. Deadlock Prevention Techniques 4.Make everyone use the same ordering in accessing resource (All threads must call P(x) before P(y) // chopstick[5] = {1  0, 1, 1, 1, 1}; lawyer(int j) { while (TRUE) { P(chopstick[min(j, (j + 1) % 5)]); P(chopstick[max(j, (j + 1) % 5)]); // eat V(chopstick[max(j, (j + 1) % 5)]); V(chopstick[min(j, (j + 1) % 5)]); } 0

32. Deadlock Prevention Techniques 4.Make everyone use the same ordering in accessing resource (All threads must call P(x) before P(y) // chopstick[5] = {0, 1  0, 1, 1, 1}; lawyer(int j) { while (TRUE) { P(chopstick[min(j, (j + 1) % 5)]); P(chopstick[max(j, (j + 1) % 5)]); // eat V(chopstick[max(j, (j + 1) % 5)]); V(chopstick[min(j, (j + 1) % 5)]); } 0 1

33. Deadlock Prevention Techniques 4.Make everyone use the same ordering in accessing resource (All threads must call P(x) before P(y) // chopstick[5] = {0, 0, 1  0, 1, 1}; lawyer(int j) { while (TRUE) { P(chopstick[min(j, (j + 1) % 5)]); P(chopstick[max(j, (j + 1) % 5)]); // eat V(chopstick[max(j, (j + 1) % 5)]); V(chopstick[min(j, (j + 1) % 5)]); } 0 12

34. Deadlock Prevention Techniques 4.Make everyone use the same ordering in accessing resource (All threads must call P(x) before P(y) // chopstick[5] = {0, 0, 0, 1  0, 1}; lawyer(int j) { while (TRUE) { P(chopstick[min(j, (j + 1) % 5)]); P(chopstick[max(j, (j + 1) % 5)]); // eat V(chopstick[max(j, (j + 1) % 5)]); V(chopstick[min(j, (j + 1) % 5)]); } 0 123

35. Deadlock Prevention Techniques 4.Make everyone use the same ordering in accessing resource (All threads must call P(x) before P(y) // chopstick[5] = {0, 0, 0, 0, 1}; lawyer(int j) { while (TRUE) { P(chopstick[min(j, (j + 1) % 5)]); P(chopstick[max(j, (j + 1) % 5)]); // eat V(chopstick[max(j, (j + 1) % 5)]); V(chopstick[min(j, (j + 1) % 5)]); } 0 1234

36. Deadlock Prevention Techniques 4.Make everyone use the same ordering in accessing resource (All threads must call P(x) before P(y) // chopstick[5] = {0, 0, 0, 0, 1}; lawyer(int j) { while (TRUE) { P(chopstick[min(j, (j + 1) % 5)]); P(chopstick[max(j, (j + 1) % 5)]); // eat V(chopstick[max(j, (j + 1) % 5)]); V(chopstick[min(j, (j + 1) % 5)]); } 0 1234

37. Deadlock Prevention Techniques 4.Make everyone use the same ordering in accessing resource (All threads must call P(x) before P(y) // chopstick[5] = {0, 0, 0, 0, 1}; lawyer(int j) { while (TRUE) { P(chopstick[min(j, (j + 1) % 5)]); P(chopstick[max(j, (j + 1) % 5)]); // eat V(chopstick[max(j, (j + 1) % 5)]); V(chopstick[min(j, (j + 1) % 5)]); } 01 234

38. Deadlock Prevention Techniques 4.Make everyone use the same ordering in accessing resource (All threads must call P(x) before P(y) // chopstick[5] = {0, 0, 0, 0, 1}; lawyer(int j) { while (TRUE) { P(chopstick[min(j, (j + 1) % 5)]); P(chopstick[max(j, (j + 1) % 5)]); // eat V(chopstick[max(j, (j + 1) % 5)]); V(chopstick[min(j, (j + 1) % 5)]); } 012 34

39. Deadlock Prevention Techniques 4.Make everyone use the same ordering in accessing resource (All threads must call P(x) before P(y) // chopstick[5] = {0, 0, 0, 0, 1  0}; lawyer(int j) { while (TRUE) { P(chopstick[min(j, (j + 1) % 5)]); P(chopstick[max(j, (j + 1) % 5)]); // eat V(chopstick[max(j, (j + 1) % 5)]); V(chopstick[min(j, (j + 1) % 5)]); } 0123 4

40. Deadlock Prevention Techniques 4.Make everyone use the same ordering in accessing resource (All threads must call P(x) before P(y) // chopstick[5] = {0, 0, 0, 0, 0}; lawyer(int j) { while (TRUE) { P(chopstick[min(j, (j + 1) % 5)]); P(chopstick[max(j, (j + 1) % 5)]); // eat V(chopstick[max(j, (j + 1) % 5)]); V(chopstick[min(j, (j + 1) % 5)]); } 012 3 4

41. Deadlock Prevention Techniques 4.Make everyone use the same ordering in accessing resource (All threads must call P(x) before P(y) // chopstick[5] = {0, 0, 0, 0, 0  1}; lawyer(int j) { while (TRUE) { P(chopstick[min(j, (j + 1) % 5)]); P(chopstick[max(j, (j + 1) % 5)]); // eat V(chopstick[max(j, (j + 1) % 5)]); V(chopstick[min(j, (j + 1) % 5)]); } 012 3 4

42. Deadlock Prevention Techniques 4.Make everyone use the same ordering in accessing resource (All threads must call P(x) before P(y) // chopstick[5] = {0, 0, 0, 0  1, 1}; lawyer(int j) { while (TRUE) { P(chopstick[min(j, (j + 1) % 5)]); P(chopstick[max(j, (j + 1) % 5)]); // eat V(chopstick[max(j, (j + 1) % 5)]); V(chopstick[min(j, (j + 1) % 5)]); } 012 3 4

43. Deadlock Prevention Techniques 4.Make everyone use the same ordering in accessing resource (All threads must call P(x) before P(y) // chopstick[5] = {0, 0, 0, 1  0, 1}; lawyer(int j) { while (TRUE) { P(chopstick[min(j, (j + 1) % 5)]); P(chopstick[max(j, (j + 1) % 5)]); // eat V(chopstick[max(j, (j + 1) % 5)]); V(chopstick[min(j, (j + 1) % 5)]); } 012 3 4

44. Deadlock Prevention Techniques 4.Make everyone use the same ordering in accessing resource (All threads must call P(x) before P(y) // chopstick[5] = {0, 0, 0, 0, 1}; lawyer(int j) { while (TRUE) { P(chopstick[min(j, (j + 1) % 5)]); P(chopstick[max(j, (j + 1) % 5)]); // eat V(chopstick[max(j, (j + 1) % 5)]); V(chopstick[min(j, (j + 1) % 5)]); } 01 2 3 4

45. Deadlock Prevention Techniques 4.Make everyone use the same ordering in accessing resource (All threads must call P(x) before P(y) // chopstick[5] = {0, 0, 0, 0  1, 1}; lawyer(int j) { while (TRUE) { P(chopstick[min(j, (j + 1) % 5)]); P(chopstick[max(j, (j + 1) % 5)]); // eat V(chopstick[max(j, (j + 1) % 5)]); V(chopstick[min(j, (j + 1) % 5)]); } 01 2 3 4

46. Deadlock Prevention Techniques 4.Make everyone use the same ordering in accessing resource (All threads must call P(x) before P(y) // chopstick[5] = {0, 0, 0  1, 1, 1}; lawyer(int j) { while (TRUE) { P(chopstick[min(j, (j + 1) % 5)]); P(chopstick[max(j, (j + 1) % 5)]); // eat V(chopstick[max(j, (j + 1) % 5)]); V(chopstick[min(j, (j + 1) % 5)]); } 01 23 4

47. Deadlock Prevention Techniques 4.Make everyone use the same ordering in accessing resource (All threads must call P(x) before P(y) // chopstick[5] = {0, 0, 1  0, 1, 1}; lawyer(int j) { while (TRUE) { P(chopstick[min(j, (j + 1) % 5)]); P(chopstick[max(j, (j + 1) % 5)]); // eat V(chopstick[max(j, (j + 1) % 5)]); V(chopstick[min(j, (j + 1) % 5)]); } 01 23 4

48. Deadlock Prevention Techniques 4.Make everyone use the same ordering in accessing resource (All threads must call P(x) before P(y) // chopstick[5] = {0, 0, 0, 1, 1}; lawyer(int j) { while (TRUE) { P(chopstick[min(j, (j + 1) % 5)]); P(chopstick[max(j, (j + 1) % 5)]); // eat V(chopstick[max(j, (j + 1) % 5)]); V(chopstick[min(j, (j + 1) % 5)]); } 0 1 23 4

49. Deadlock Prevention Techniques 4.Make everyone use the same ordering in accessing resource (All threads must call P(x) before P(y) // chopstick[5] = {0, 0, 0  1, 1, 1}; lawyer(int j) { while (TRUE) { P(chopstick[min(j, (j + 1) % 5)]); P(chopstick[max(j, (j + 1) % 5)]); // eat V(chopstick[max(j, (j + 1) % 5)]); V(chopstick[min(j, (j + 1) % 5)]); } 0 1 23 4

50. Deadlock Prevention Techniques 4.Make everyone use the same ordering in accessing resource (All threads must call P(x) before P(y) // chopstick[5] = {0, 0  1, 1, 1, 1}; lawyer(int j) { while (TRUE) { P(chopstick[min(j, (j + 1) % 5)]); P(chopstick[max(j, (j + 1) % 5)]); // eat V(chopstick[max(j, (j + 1) % 5)]); V(chopstick[min(j, (j + 1) % 5)]); } 0 123 4

51. Deadlock Prevention Techniques 4.Make everyone use the same ordering in accessing resource (All threads must call P(x) before P(y) // chopstick[5] = {0, 1  0, 1, 1, 1}; lawyer(int j) { while (TRUE) { P(chopstick[min(j, (j + 1) % 5)]); P(chopstick[max(j, (j + 1) % 5)]); // eat V(chopstick[max(j, (j + 1) % 5)]); V(chopstick[min(j, (j + 1) % 5)]); } 0 123 4

52. Deadlock Prevention Techniques 4.Make everyone use the same ordering in accessing resource (All threads must call P(x) before P(y) // chopstick[5] = {0, 0, 1, 1, 1}; lawyer(int j) { while (TRUE) { P(chopstick[min(j, (j + 1) % 5)]); P(chopstick[max(j, (j + 1) % 5)]); // eat V(chopstick[max(j, (j + 1) % 5)]); V(chopstick[min(j, (j + 1) % 5)]); } 0 123 4

53. Deadlock Prevention Techniques 4.Make everyone use the same ordering in accessing resource (All threads must call P(x) before P(y) // chopstick[5] = {0, 0  1, 1, 1, 1}; lawyer(int j) { while (TRUE) { P(chopstick[min(j, (j + 1) % 5)]); P(chopstick[max(j, (j + 1) % 5)]); // eat V(chopstick[max(j, (j + 1) % 5)]); V(chopstick[min(j, (j + 1) % 5)]); } 0 123 4

54. Deadlock Prevention Techniques 4.Make everyone use the same ordering in accessing resource (All threads must call P(x) before P(y) // chopstick[5] = {0  1, 1, 1, 1, 1}; lawyer(int j) { while (TRUE) { P(chopstick[min(j, (j + 1) % 5)]); P(chopstick[max(j, (j + 1) % 5)]); // eat V(chopstick[max(j, (j + 1) % 5)]); V(chopstick[min(j, (j + 1) % 5)]); } 0123 4

55. Deadlock Prevention Techniques 4.Make everyone use the same ordering in accessing resource (All threads must call P(x) before P(y) // chopstick[5] = {1  0, 1, 1, 1, 1}; lawyer(int j) { while (TRUE) { P(chopstick[min(j, (j + 1) % 5)]); P(chopstick[max(j, (j + 1) % 5)]); // eat V(chopstick[max(j, (j + 1) % 5)]); V(chopstick[min(j, (j + 1) % 5)]); } 0123 4

56. Deadlock Prevention Techniques 4.Make everyone use the same ordering in accessing resource (All threads must call P(x) before P(y) // chopstick[5] = {0, 1, 1, 1, 1  0}; lawyer(int j) { while (TRUE) { P(chopstick[min(j, (j + 1) % 5)]); P(chopstick[max(j, (j + 1) % 5)]); // eat V(chopstick[max(j, (j + 1) % 5)]); V(chopstick[min(j, (j + 1) % 5)]); } 0123 4

57. More Deadlock Prevention Methods 5.No waiting (phone company) 6.Preempt resources (copying memory content to disk) 7.Banker’s algorithm 8.A combination of techniques

58. Banker’s Algorithm  The idea of Banker’s algorithm: Allows the sum of requested resources > total resources As long as, there is some way for all threads to finish without getting into any deadlocks

59. Banker’s Algorithm  Banker’s algorithm: A thread states its maximum resource needs in advance The OS allocates resource dynamically as needed. A thread waits if granting its request could lead to a deadlock A request can be granted if some sequential ordering of threads is deadlock free

60. Example 1  Total RAM 256 MB AllocatedStill needed P1P1 80 MB30 MB P2P2 10 MB P3P3 120 MB80 MB time free RAM (MB) 46

61. Example 1  Total RAM 256 MB AllocatedStill needed P1P1 80 MB30 MB P2P2 20 MB0 MB P3P3 120 MB80 MB time free RAM (MB) 46 P2P2 36

62. Example 1  Total RAM 256 MB AllocatedStill needed P1P1 80 MB30 MB P2P2 0 MB P3P3 120 MB80 MB time free RAM (MB) 46 P2P2 36 56

63. Example 1  Total RAM 256 MB AllocatedStill needed P1P1 110 MB0 MB P2P2 P3P3 120 MB80 MB time free RAM (MB) 46 P2P2 36 56 P1P1 26

64. Example 1  Total RAM 256 MB AllocatedStill needed P1P1 0 MB P2P2 P3P3 120 MB80 MB time free RAM (MB) 46 P2P2 36 56 P1P1 26 136

65. Example 1  Total RAM 256 MB AllocatedStill needed P1P1 0 MB P2P2 P3P3 200 MB0 MB time free RAM (MB) 46 P2P2 36 56 P1P1 26 136 P3P3 56

66. Example 1  Total RAM 256 MB AllocatedStill needed P1P1 0 MB P2P2 P3P3 time free RAM (MB) 46 P2P2 36 56 P1P1 26 136 P3P3 56 256

67. Example 1  Total RAM 256 MB AllocatedStill needed P1P1 80 MB30 MB P2P2 10 MB P3P3 120 MB80 MB time free RAM (MB) 46 P2P2 36 56 P1P1 26 136 P3P3 56 256 The system is initially in a safe state, since we can run P 2, P 1, and then P 3

68. Example 2 AllocatedStill needed P1P1 50 MB90 MB P2P2 10 MB P3P3 120 MB80 MB time free RAM (MB) 76  Total RAM 256 MB (P 1 requests 30 MB)

69. Example 2  Total RAM 256 MB AllocatedStill needed P1P1 80 MB60 MB P2P2 10 MB P3P3 120 MB80 MB time free RAM (MB) 46

70. Example 2  Total RAM 256 MB AllocatedStill needed P1P1 80 MB60 MB P2P2 20 MB0 MB P3P3 120 MB80 MB time free RAM (MB) 46 P2P2 36

71. Example 2  Total RAM 256 MB AllocatedStill needed P1P1 80 MB60 MB P2P2 0 MB P3P3 120 MB80 MB time free RAM (MB) 46 P2P2 36 56

72. Example 2  Total RAM 256 MB AllocatedStill needed P1P1 80 MB60 MB P2P2 0 MB P3P3 120 MB80 MB time free RAM (MB) 46 P2P2 36 56

73. Example 2  Total RAM 256 MB AllocatedStill needed P1P1 80 MB60 MB P2P2 10 MB P3P3 120 MB80 MB time free RAM (MB) 46 P2P2 36 56 The system is initially in an unsafe state, since we cannot find an execution sequence for P 1, P 2, and P 3

74. Deadlock Detection and Recovery  Scan the resource allocation graph  Detect circular chains of requests  Recover from the deadlock

75. Resource Allocation Graph T1 T2 R1 R2 R1 is held by R2 is held by is waiting for R1 is waiting for R2

76. Once A Cycle is Detected…  Some possible actions Kill a thread and force it to give up resources  Remaining system may be in an inconsistent state Rollback actions of a deadlocked thread  Not always possible (a file maybe half- way through modifications)  Need checkpointing, or taking snapshots of system states from time to time