1 / 76

Deadlocks

Deadlocks. Deadlocks. Deadlocks : Occurs 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). Deadlocks.

irina
Download Presentation

Deadlocks

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  1. Deadlocks

  2. Deadlocks • Deadlocks: Occurs 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 • Starvation can also caused by livelocks.

  4. An Example of Deadlocks Thread A Thread 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. Dinning 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 Dinning 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 Dinning 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 Dinning 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. Necessary Conditions for 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. Dealing with deadlock • Deadlock prevention • Make sure that at least one of the conditions for deadlock does not hold. • Prevent deadlock from happening • Deadlock avoidance • Make sure the system is always in a safe state. • Deadlock detection and recovery • Let it be. • Deal with it only when bad things (deadlock) happens. • The chance for deadlock to happen is not big.

  14. Deadlock Prevention Techniques • Involves removing one of the four conditions

  15. Deadlock Prevention Techniques • Limited resource • Virtualize the physical limited resource to make infinite instances • Example: printer pool

  16. Deadlock Prevention Techniques • No preemption • Make the source preempt-able • CPU sharing, copy memory to disk • Not always possible for all resources

  17. Deadlock Prevention Techniques • Wait while holding • 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 • 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) // 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); } }

  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, 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

  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, 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); } } 1 3

  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, 0, 0, 0, 0}, s = 1  0; 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); } } 2 1 3

  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, 0, 0}, s = 0; 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); } } 2 1 3

  24. 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); } }

  25. 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 (1, 2)

  26. 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 (1, 2) 2 ()

  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, 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 3 (1, 2) (3, 4)

  28. Deadlock Prevention Techniques • Circular chain of requests • 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)]); } }

  29. 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

  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] = {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

  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] = {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 1 2

  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, 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 1 2 3

  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, 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 1 2 3 4

  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, 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)]); } } 1 2 3 4 0

  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)]); } } 2 3 4 0 1

  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)]); } } 3 4 0 1 2

  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 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)]); } } 4 0 1 2 3

  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, 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)]); } } 4 0 1 2 3

  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, 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)]); } } 4 0 1 2 3

  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 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)]); } } 4 0 1 2 3

  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, 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)]); } } 4 0 1 2 3

  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}; 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)]); } } 4 0 1 2 3

  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, 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)]); } } 4 0 1 2 3

  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  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)]); } } 4 0 1 2 3

  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, 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)]); } } 4 0 1 2 3

  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}; 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)]); } } 4 0 1 2 3

  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, 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)]); } } 4 0 1 2 3

  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  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)]); } } 4 0 1 2 3

  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, 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)]); } } 4 0 1 2 3

  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}; 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)]); } } 4 0 1 2 3

More Related