Slide 10-1 Copyright © 2004 Pearson Education, Inc. Operating Systems: A Modern Perspective,...

Operating Systems: A Modern Perspective, Chapter 10

Slide 10-1

Copyright © 2004 Pearson Education, Inc.


Slide 10-2


10Deadlock


Slide 10-3


Example

Process 1Process 1 Process 2Process 2

Resource 1Resource 1 Resource 2Resource 2

Process holds the resourceProcess requests the resource


Slide 10-4


Three Deadlocked Processes

Process 1Process 1 Process 2Process 2 Process 3Process 3

Resource 1Resource 1 Resource 2Resource 2 Resource 3Resource 3

Process holds the resourceProcess requests the resource


Slide 10-5


A Model

• P = {p1, p2, …, pn} be a set of processes

• R = {R1, R2, …, Rm} be a set of resources

• cj = number of units of Rj in the system

• S = {S0, S1, …} be a set of states representing the assignment of Rj to pi

– State changes when processes take action– This allows us to identify a deadlock situation

in the operating system


Slide 10-6


State Transitions

• The system changes state because of the action of some process, pi

• There are three pertinent actions:– Request (“ri”): request one or more units of a

resource

– Allocation (“ai”): All outstanding requests from a process for a given resource are satisfied

– Deallocation (“di”): The process releases units of a resource

Sj Skxi


Slide 10-7


Properties of States

• Want to define deadlock in terms of patterns of transitions

• Define: pi is blocked in Sj if pi cannot cause a transition out of Sj

Sjr3

a1

r1

p2 is blocked in Sj


Slide 10-8


Properties of States (cont)

• If pi is blocked in Sj, and will also be blocked in every Sk reachable from Sj, then pi is deadlocked

• Sj is called a deadlock state


Slide 10-9


A Simple Process-Resource Model Instance

P1P1 P3

P3P2P2

R1R1 R2

R2 R3R3

Process holds resource

Process requests resource


Slide 10-10


Example

rad

S0 S1 S2 S3 S4r a

d

• One process, two units of one resource

• Can request one unit at a time


Slide 10-11


Extension of Exampler0a0

d0

S00 S10 S20 S30 S40r0 a0

d0

r0a0

d0

S01 S11 S21 S31 S41r0 a0

d0

r0a0

d0

S02 S12 S22 S32r0

r0a0

d0

S03 S13 S23 S33r0

S04 S14r0

r1 r1 r1r1

r1r1r1r1

a1 a1 a1 a1

a1a1

d1 d1

d1d1 d1 d1

r1


Slide 10-12


Figure 10‑10: A Model of a State with a Circular Wait

R P

RP

P holds R

P requests R

Ri

Pi


Slide 10-13


Dining Philosophers Revisited philosopher(int i){ while (TRUE) { // Think // Eat P(fork[i]); /* Pick up left fork */ P(fork[(i+1) mod 5]); /* Pick up right fork */ eat(); V(fork[(i+1) mod 5]); V(fork[i]); }}philosopher4(){ while (TRUE) { // Think // Eat P(fork[0]); /* Pick up right fork */ P(fork[4]); /* Pick up left fork */ eat(); V(fork[4]); V(fork[0]); }}

semaphore fork[5];fork[0] = fork[1] = fork[2] = fork[3] = fork[4] = 1;fork(philosopher, 1, 0);fork(philosopher, 1, 1);fork(philosopher, 1, 2);fork(philosopher, 1, 3);fork(philosopher4, 0);


Slide 10-14


Addressing Deadlock

• Prevention: Design the system so that deadlock is impossible

• Avoidance: Construct a model of system states, then choose a strategy that will not allow the system to go to a deadlock state

• Detection & Recovery: Check for deadlock (periodically or sporadically), then recover

• Manual intervention: Have the operator reboot the machine if it seems too slow


Slide 10-15


Prevention

• Necessary conditions for deadlock– Mutual exclusion– Hold and wait– Circular waiting– No preemption

• Ensure that at least one of the necessary conditions is false at all times– Mutual exclusion must hold at all times


Slide 10-16


Hold and Wait

• Need to be sure a process does not hold one resource while requesting another

• Approach 1: Force a process to request all resources it needs at one time

• Approach 2: If a process needs to acquire a new resource, it must first release all resources it holds, then reacquire all it needs

• What does this say about state transition diagrams?


Slide 10-17


Circular Wait

• Have a situation in which there are K processes holding units of K resources

R P

RP

P holds R

P requests R

Ri

Pi


Slide 10-18


Circular Wait (cont)• There is a cycle in the graph of processes

and resources

• Choose a resource request strategy by which no cycle will be introduced

• Total order on all resources, then can only ask for Rj if Ri < Rj for all Ri the process is currently holding


Slide 10-19


Circular Wait (cont)

• There is a cycle in the graph of processes and resources

• Choose a resource request strategy by which no cycle will be introduced

• Total order on all resources, then can only ask for Rj if Ri < Rj for all Ri the process is currently holding

• This is how we noticed the easy solution for the dining philosophers


Slide 10-20


Allowing Preemption

• Allow a process to time-out on a blocked request -- withdrawing the request if it fails

Si

ru

dv ru

Sj

Sk

wu


Slide 10-21


Avoidance

• Define a model of system states, then choose a strategy that will guarantee that the system will not go to a deadlock state

• Requires extra information, e.g., the maximum claim for each process

• Allows resource manager to see the worst case that could happen, then to allow transitions based on that knowledge


Slide 10-22


Safe vs Unsafe States• Safe state: one in which the system can assure

that any sequence of subsequent transitions leads back to the initial state– Even if all exercise their maximum claim, there is an

allocation strategy by which all claims can be met

• Unsafe state: one in which the system cannot guarantee that the system will transition back to the initial state– Unsafe state can lead to a deadlock state if too many

processes exercise their maximum claim at once


Slide 10-23


More on Safe & Unsafe States

NormalExecution

RequestMax Claim

Execute, thenrelease

No

Yes

Likely to be in a safe state

Probability of being in unsafe state increases


Slide 10-24


More on Safe & Unsafe States

I

Safe States

Unsafe States

Deadlock States

Disallow


Slide 10-25


Banker’s Algorithm

• Let maxc[i, j] be the maximum claim for Rj by pi

• Let alloc[i, j] be the number of units of Rj held by pi

• Can always compute– avail[j] = cj - 0i nalloc[i,j]

– Then number of available units of Rj

• Should be able to determine if the state is safe or not using this info


Slide 10-26


Banker’s Algorithm

• Copy the alloc[i,j] table to alloc’[i,j]• Given C, maxc and alloc’, compute avail

vector• Find pi: maxc[i,j] - alloc’[i,j] avail[j]

for 0 j < m and 0 i < n.– If no such pi exists, the state is unsafe– If alloc’[i,j] is 0 for all i and j, the state is safe

• Set alloc’[i,j] to 0; deallocate all resources held by pi; go to Step 2


Slide 10-27


ExampleProcess R0 R1 R2 R3

p0 3 2 1 4p1 0 2 5 2p2 5 1 0 5p3 1 5 3 0p4 3 0 3 3

Maximum Claim

Process R0 R1 R2 R3

p0 2 0 1 1p1 0 1 2 1p2 4 0 0 3p3 0 2 1 0p4 1 0 3 0Sum 7 3 7 5

Allocated Resources

C = <8, 5, 9, 7>

•Compute total allocated•Determine available units

avail = <8-7, 5-3, 9-7, 7-5> = <1, 2, 2, 2>

•Can anyone’s maxc be met?maxc[2,0]-alloc’[2,0] = 5-4 = 11 = avail[0]maxc[2,1]-alloc’[2,1] = 1-0 = 12 = avail[1]maxc[2,2]-alloc’[2,2] = 0-0 = 02 = avail[2]maxc[2,3]-alloc’[2,3] = 5-3 = 22 = avail[3]

•P2 can exercise max claimavail[0] = avail[0]+alloc’[2,0] = 1+4 = 5avail[1] = avail[1]+alloc’[2,1] = 2+0 = 2avail[2] = avail[2]+alloc’[2,2] = 2+0 = 2avail[3] = avail[3]+alloc’[2,3] = 2+3 = 5


Slide 10-28



p0 3 2 1 4p1 0 2 5 2p2 5 1 0 5p3 1 5 3 0p4 3 0 3 3

Maximum Claim

Process R0 R1 R2 R3

p0 2 0 1 1p1 0 1 2 1p2 0 0 0 0p3 0 2 1 0p4 1 0 3 0Sum 3 3 7 2

Allocated Resources

C = <8, 5, 9, 7>


avail = <8-7, 5-3, 9-7, 7-5> = <5, 2, 2, 5>

•Can anyone’s maxc be met?maxc[4,0]-alloc’[4,0] = 5-1 = 45 = avail[0]maxc[4,1]-alloc’[4,1] = 0-0 = 02 = avail[1]maxc[4,2]-alloc’[4,2] = 3-3 = 02 = avail[2]maxc[4,3]-alloc’[4,3] = 3-0 = 35 = avail[3]

•P4 can exercise max claimavail[0] = avail[0]+alloc’[4,0] = 5+1 = 6avail[1] = avail[1]+alloc’[4,1] = 2+0 = 2avail[2] = avail[2]+alloc’[4,2] = 2+3 = 5avail[3] = avail[3]+alloc’[4,3] = 5+0 = 5


Slide 10-29



p0 3 2 1 4p1 0 2 5 2p2 5 1 0 5p3 1 5 3 0p4 3 0 3 3

Maximum Claim

Process R0 R1 R2 R3

p0 2 0 1 1p1 0 1 2 1p2 0 0 0 0p3 0 2 1 0p4 0 0 0 0Sum 2 1 4 2

Allocated Resources

C = <8, 5, 9, 7>


avail = <8-7, 5-3, 9-7, 7-5> = <6, 2, 5, 5>

•Can anyone’s maxc be met? (Yes, any of them can)


Slide 10-30


Detection & Recovery

• Check for deadlock (periodically or sporadically), then recover

• Can be far more aggressive with allocation• No maximum claim, no safe/unsafe states• Differentiate between

– Serially reusable resources: A unit must be allocated before being released

– Consumable resources: Never release acquired resources; resource count is number currently available


Slide 10-31


Reusable Resource Graphs (RRGs)

• Micro model to describe a single state

• Nodes = {p0, p1, …, pn} {R1, R2, …, Rm}

• Edges connect pi to Rj, or Rj to pi

– (pi, Rj) is a request edge for one unit of Rj

– (Rj, pi) is an assignment edge of one unit of Rj

• For each Rj there is a count, cj of units Rj

• Number of units of Rj allocated to pi plus the number requested by pi cannot exceed cj


Slide 10-32


State Transitions due to Request

• In Sj, pi is allowed to request qch units of Rh, provided pi has no outstanding requests.

• Sj Sk, where the RRG for Sk is derived from Sj by adding q request edges from pi to Rh

Rhpi Rhpi

State SjState Sk

pi request q unitsof Rh

q edges


Slide 10-33


State Transition for Acquire

• In Sj, pi is allowed to acquire units of Rh, iff there is (pi, Rh) in the graph, and all can be satisfied.

• Sj Sk, where the RRG for Sk is derived from Sj by changing each request edge to an assignment edge.

Rhpi Rhpi

State SjState Sk

pi acquires unitsof Rh


Slide 10-34


State Transition for Release

• In Sj, pi is allowed to release units of Rh, iff there is (Rh, pi) in the graph, and there is no request edge from pi.

• Sj Sk, where the RRG for Sk is derived from Sj by deleting all assignment edges.

Rhpi Rhpi

State SjState Sk

pi releases unitsof Rh


Slide 10-35


Example

P holds one unit of R

A Deadlock State

P requests one unit of RR

R

p

p


Slide 10-36


Example

Not a Deadlock State No Cycle in the Graph


Slide 10-37


Example

p0

p1

S00


Slide 10-38


Example

p0

p1

p0

p1

S00 S01


Slide 10-39


Example

p0

p1

p0 p0

p1 p1

S00 S01 S11


Slide 10-40


Example

p0

p1

p0 p0 p0

p1 p1 p1

S00 S01 S11 S21


Slide 10-41


Example

p0

p1

p0 p0 p0 p0

p1 p1 p1 p1

S00 S01 S11 S21 S22


Slide 10-42


Example

p0

p1

p0 p0 p0 p0 p0

p1 p1 p1 p1 p1

S00 S01 S11 S21 S22 S33

. . .


Slide 10-43


Graph Reduction• Deadlock state if there is no sequence of

transitions unblocking every process

• A RRG represents a state; can analyze the RRG to determine if there is a sequence

• A graph reduction represents the (optimal) action of an unblocked process. Can reduce by pi if

– pi is not blocked

– pi has no request edges, and there are (Rj, pi) in the RRG


Slide 10-44


Graph Reduction (cont)

• Transforms RRG to another RRG with all assignment edges into pi removed

• Represents pi releasing the resources it holds

pi

pi

Reducing by pi


Slide 10-45


Graph Reduction (cont)

• A RRG is completely reducible if there a sequence of reductions that leads to a RRG with no edges

• A state is a deadlock state if and only if the RRG is not completely reducible.


Slide 10-46


Example RRGp0

p1 p2

p0

p1 p2

p0

p1 p2

p0

p1 p2


Slide 10-47


Example RRGp0

p1 p2


Slide 10-48


Consumable Resource Graphs (CRGs)

• Number of units varies, have producers/consumers

• Nodes = {p0, p1, …, pn} {R1, R2, …, Rm}

• Edges connect pi to Rj, or Rj to pi

– (pi, Rj) is a request edge for one unit of Rj

– (Rj, pi) is an producer edge (must have at least one producer for each Rj)

• For each Rj there is a count, wj of units Rj


Slide 10-49


State Transitions due to Request• In Sj, pi is allowed to request any number of

units of Rh, provided pi has no outstanding requests.

• Sj Sk, where the RRG for Sk is derived from Sj by adding q request edges from pi to Rh

Rhpi Rhpi

State SjState Sk

pi request q unitsof Rh

q edges


Slide 10-50


State Transition for Acquire• In Sj, pi is allowed to acquire units of Rh, iff

there is (pi, Rh) in the graph, and all can be satisfied.

• Sj Sk, where the RRG for Sk is derived from Sj by deleting each request edge and decrementing wh.

Rhpi Rhpi

State SjState Sk

pi acquires unitsof Rh


Slide 10-51


State Transition for Release• In Sj, pi is allowed to release units of Rh, iff

there is (Rh, pi) in the graph, and there is no request edge from pi.

• Sj Sk, where the RRG for Sk is derived from Sj by incrementing wh.

Rhpi Rhpi

State SjState Sk

pi releases 2 unitsof Rh


Slide 10-52


Example

p0

p1

p0

p1

p0

p1

p0

p1

p0

p1


Slide 10-53


Deadlock Detection

• May have a CRG that is not completely reducible, but it is not a deadlock state

• For each process:– Find at least one sequence which leaves each

process unblocked.

• There may be different sequences for different processes -- not necessarily an efficient approach


Slide 10-54


Deadlock Detection• May have a CRG that is not completely

reducible, but it is not a deadlock state

• Only need to find sequences, which leave each process unblocked.

p0

p1


Slide 10-55


Deadlock Detection• May have a CRG that is not completely

reducible, but it is not a deadlock state

• Only need to find a set of sequences, which leaves each process unblocked.


Slide 10-56


General Resource Graphs

• Have consumable and reusable resources

• Apply consumable reductions to consumables, and reusable reductions to reusables

• See Figure 10.29


Slide 10-57


GRG Example (Fig 10.29)

Reusable

Consumable

p0

R2

R1

R0

p3 p2

p1

Not in Fig 10.29


Slide 10-58



Reusable

Consumable

p0

R2

R1

R0

p3 p2

p1

Reduce by p3


Slide 10-59



Reusable

Consumable

p0

R2

R1

R0

p3 p2

p1

Reduce by p0


Slide 10-60


Recovery

• No magic here– Choose a blocked resource– Preempt it (releasing its resources)– Run the detection algorithm– Iterate if until the state is not a deadlock state

Slide 10-1 Copyright © 2004 Pearson Education, Inc. Operating Systems: A Modern Perspective,...

Documents

Transcript of Slide 10-1 Copyright © 2004 Pearson Education, Inc. Operating Systems: A Modern Perspective,...