1 / 41

Outline

Outline. Objective for today: Formal treatment of deadlock. Dealing with Deadlock. It can be prevented by breaking one of the prerequisite conditions (review): Mutually exclusive use of resources

casper
Download Presentation

Outline

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. Outline Objective for today: Formal treatment of deadlock.

  2. Dealing with Deadlock It can be prevented by breaking one of the prerequisite conditions (review): • Mutually exclusive use of resources • Example: Allowing shared access to read-only files (readers/writers problem from readers point of view) • circular waiting • Example: Define an ordering on resources and acquire them in order (lower numbered fork first) • hold and wait • no pre-emption

  3. Dealing with Deadlock (cont.) Let it happen, then detect it and recover • via externally-imposed preemption of resources Avoid dynamically by monitoring resource requests and denying some. • Banker’s Algorithm ...

  4. The Zax Deadlock Example

  5. Process P0 Request Arc Alloc Arc Resource R0 Resource R1 Process P1 Deadlock Theory State of resource allocation captured in Resource Graph • Bipartite graph model with a set P of vertices representing processes and a set R for resources. • Directed edges • RiPj means Ri alloc to Pj • PjRi means Pj requests Ri • Resource vertices contain units of the resource Reusable Resources

  6. Process P0 Request Arc Alloc Arc Resource R0 Resource R1 Process P1 Deadlock Theory State transitions by operations: • Granting a request • Making a new request if all outstanding requests satisfied Deadlock defined on graph: • Pi is blocked in state S if there is no operation Pi can perform • Pi is deadlocked if it is blocked in all reachable states from S • S is safe if no reachable state is a deadlock state (i.e., having some deadlocked process)

  7. Deadlock Theory P0 Request Arc • Cycle in graph is a necessary condition • no cycle no deadlock. • No deadlock iff graph is completely reducible • Intuition: Analyze graph, asking if deadlock is inevitable from this state by simulating most favorable state transitions. Alloc Arc R0 R1 P1 P3

  8. The Zax Deadlock Example Z0 Z1 B0 B1

  9. Deadlock Detection Algorithm Let U be the set of processes that have yet to be reduced. Initially U = P. Consider only reusable resources. while (there exist unblocked processes in U) { Remove unblocked Pi from U; Cancel Pi’s outstanding requests; Release Pi’s allocated resources; /* possibly unblocking other Pk in U */} if ( U != ) signal deadlock;

  10. P0 Deadlock Detection Example P1 P2 R2 R4 R0 R3 R1 P3 P4

  11. Deadlock Detection Example P1 P2 R2 R4 R0 R3 R1 P0 P3 P4

  12. Deadlock Detection Example P2 R2 R4 R0 R3 R1 P0 P3 P4

  13. Deadlock Detection Example P2 R2 R4 R0 R3 R1 P0 P3 P4

  14. Deadlock Detection Example P2 R2 R4 R0 R3 R1 P0 P4

  15. P0 Deadlock Detection Example P2 R2 R4 R0 R3 R1 P4

  16. P0 Deadlock Detection Example R2 R4 R0 R3 R1 P4

  17. P0 Deadlock Detection Example R2 R4 R0 R3 R1 P4

  18. P0 Deadlock Detection Example R2 R4 R0 R3 R1

  19. Deadlock Detection Example R2 R4 R0 R3 R1 Completely Reducible

  20. Another Example P0 Request Arc Alloc Arc R0 R1 P1 With and without P2 P2

  21. Another Example P0 Request Arc Alloc Arc R0 R1 P1 Is there an unblockedprocess to start with? With and without P2

  22. Another Example P0 Request Arc Alloc Arc R0 R1 P1 With and without P2

  23. Another Example P0 Request Arc Alloc Arc R0 R1 P1 With and without P2

  24. Another Example P0 Request Arc Alloc Arc R0 R1 P1 With and without P2

  25. Another Example P0 Request Arc Alloc Arc R0 R1 Is there an unblockedprocess to start with? P1 With and without P2 P2

  26. R0 Producer Arc P0 P1 Producer Arc P2 R1 Consumable Resources • Not a fixed number of units, operations of producing and consuming (e.g. messages) • Ordering matters on applying reductions • Reducing by producer makes “enough” units, 

  27. Consumable Resources R0 Producer Arc P0 • Not a fixed number of units, operations of producing and consuming (e.g. messages) • Ordering matters on applying reductions • Reducing by producer makes “enough” units,  • Start with P2 P1 Producer Arc P2 R1

  28. Consumable Resources R0 Producer Arc P0 • Not a fixed number of units, operations of producing and consuming (e.g. messages) • Ordering matters on applying reductions • Reducing by producer makes “enough” units,  • Start with P2 P1 Producer Arc P2 R1 Not reducible

  29. R0 Producer Arc P0 P1 Producer Arc P2 R1 Consumable Resources • Not a fixed number of units, operations of producing and consuming (e.g. messages) • Ordering matters on applying reductions • Reducing by producer makes “enough” units,  • Start with P2

  30. Consumable Resources R0 Producer Arc P0 • Not a fixed number of units, operations of producing and consuming (e.g. messages) • Ordering matters on applying reductions • Reducing by producer makes “enough” units,  • Start with P2 • Start with P1 P1 Producer Arc P2 R1

  31. Consumable Resources R0 Producer Arc P0 • Not a fixed number of units, operations of producing and consuming (e.g. messages) • Ordering matters on applying reductions • Reducing by producer makes “enough” units,  • Start with P1  P1 Producer Arc P2 R1

  32. Consumable Resources R0 Producer Arc P0 • Not a fixed number of units, operations of producing and consuming (e.g. messages) • Ordering matters on applying reductions • Reducing by producer makes “enough” units,  • Start with P1  P1 Producer Arc P2  R1

  33. Consumable Resources R0 Producer Arc P0 • Not a fixed number of units, operations of producing and consuming (e.g. messages) • Ordering matters on applying reductions • Reducing by producer makes “enough” units,  • Start with P1 P1 Producer Arc P2 R1 Reducible

  34. Deadlock Detection & Recovery • Continuous monitoring and running this algorithm are expensive. • What to do when a deadlock is detected? • Abort deadlocked processes (will result in restarts). • Preempt resources from selected processes, rolling back the victims to a previous state (undoing effects of work that has been done) • Watch out for starvation.

  35. Avoidance - Banker’s Algorithm • Each process must declare its maximum claim on each of the resources and may never request beyond that level. • When a process places a request, the Banker decides whether to grant that request according to the following criteria: • “If I grant this request, then there is a run on the bank (everyone requests the remainder of their maximum claim), will we have deadlock?”

  36. Representing the State • n processes, m resources • avail[m]- avail[i] is the number of available units of Ri • max[n,m] - max[i,j] is claim of Pi for Rj • alloc[n,m] - alloc[i,j] is current allocation of Rj to Pi • need[n,m] = max[n,m] - alloc[n,m] - the rest that can be requested. 4 7 2 5 2 2

  37. Basic Outline of Algorithm request in ? if (request[i,j] > avail[j]) defer; //Sufficient resources for request //pretend to grant request avail[j] = avail [j] - request [i,j]; alloc[i,j] = alloc[i,j] + request [i,j]; need[i,j] = need[i,j] - request [i,j]; if (safe state) grant; else defer; 4 7-x 2 5 x 2 2 if (x = = 1)? if (x = = 2)?

  38. Basic Outline of Algorithm request in ? if (request[i,j] > avail[j]) defer; //Sufficient resources for request //pretend to grant request avail[j] = avail [j] - request [i,j]; alloc[i,j] = alloc[i,j] + request [i,j]; need[i,j] = need[i,j] - request [i,j]; if (safe state) grant; else defer; 4 6 2 5 1 2 2 if (x = = 1)?

  39. Basic Outline of Algorithm request in ? if (request[i,j] > avail[j]) defer; //Sufficient resources for request //pretend to grant request avail[j] = avail [j] - request [i,j]; alloc[i,j] = alloc[i,j] + request [i,j]; need[i,j] = need[i,j] - request [i,j]; if (safe state) grant; else defer; 4 6 2 5 1

  40. Basic Outline of Algorithm request in ? if (request[i,j] > avail[j]) defer; //Sufficient resources for request //pretend to grant request avail[j] = avail [j] - request [i,j]; alloc[i,j] = alloc[i,j] + request [i,j]; need[i,j] = need[i,j] - request [i,j]; if (safe state) grant; else defer; 6 2 1

  41. Basic Outline of Algorithm request in ? if (request[i,j] > avail[j]) defer; //Sufficient resources for request //pretend to grant request avail[j] = avail [j] - request [i,j]; alloc[i,j] = alloc[i,j] + request [i,j]; need[i,j] = need[i,j] - request [i,j]; if (safe state) grant; else defer; 4 5 2 5 2 2 2 if (x = = 2)?

More Related