Outline for today

Outline for today • Objective: Formal treatment of deadlock. • Administrative:

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

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

The Zax Deadlock Example

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

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)

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

The Zax Deadlock Example Z0 Z1 B0 B1

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;

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

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

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

Deadlock Detection Example P2 R2 R4 R0 R3 R1 P0 P4

P0 Deadlock Detection Example P2 R2 R4 R0 R3 R1 P4

P0 Deadlock Detection Example R2 R4 R0 R3 R1 P4

P0 Deadlock Detection Example R2 R4 R0 R3 R1

Deadlock Detection Example R2 R4 R0 R3 R1 Completely Reducible

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

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

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

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

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

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

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

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

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

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

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

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

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.

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?”

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

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)?

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)?

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

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

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)?

Outline for today