Operating Systems: A Modern Perspective, Chapter 10
Download
1 / 60

Deadlock - PowerPoint PPT Presentation


  • 112 Views
  • Uploaded on

Deadlock. 10. Example. Process 1. Process 2. Resource 1. Resource 2. Process holds the resource. Process requests the resource. Three Deadlocked Processes. Process 1. Process 2. Process 3. Resource 1. Resource 2. Resource 3. Process holds the resource.

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about 'Deadlock' - alissa


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.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript

Deadlock

Deadlock

10

Operating Systems: A Modern Perspective, Chapter 10


Example

Process 1

Process 2

Resource 1

Resource 2

Process holds the resource

Process requests the resource

Operating Systems: A Modern Perspective, Chapter 10


Three deadlocked processes
Three Deadlocked Processes

Process 1

Process 2

Process 3

Resource 1

Resource 2

Resource 3

Process holds the resource

Process requests the resource

Operating Systems: A Modern Perspective, Chapter 10


A model
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

Operating Systems: A Modern Perspective, Chapter 10


State transitions
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

xi

Sj

Sk

Operating Systems: A Modern Perspective, Chapter 10


Properties of states

a1

r3

Sj

r1

p2 is blocked in Sj

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

Operating Systems: A Modern Perspective, Chapter 10


Properties of states cont
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

Operating Systems: A Modern Perspective, Chapter 10


A simple process resource model instance
A Simple Process-Resource Model Instance

P1

P2

P3

R1

R2

R3

Process holds resource

Process requests resource

Operating Systems: A Modern Perspective, Chapter 10


Example
Example

  • One process, two units of one resource

  • Can request one unit at a time

d

d

r

a

r

a

S0

S1

S2

S3

S4

Operating Systems: A Modern Perspective, Chapter 10


Extension of example
Extension of Example

d0

d0

r0

a0

r0

a0

S00

S10

S20

S30

S40

r1

r1

r1

r1

r1

d0

d0

r0

a0

r0

a0

S01

S11

S21

S31

S41

d1

d1

d1

d1

a1

a1

a1

a1

d0

r0

a0

r0

S02

S12

S22

S32

r1

r1

d0

r1

r1

r0

a0

r0

S03

S13

S23

S33

d1

d1

a1

a1

r0

S04

S14

Operating Systems: A Modern Perspective, Chapter 10


Figure 10 10 a model of a state with a circular wait
Figure 10‑10: A Model of a State with a Circular Wait

R

P

Ri

P holds R

Pi

P

R

P requests R

Operating Systems: A Modern Perspective, Chapter 10


Dining philosophers revisited
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);

Operating Systems: A Modern Perspective, Chapter 10


Addressing deadlock
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

Operating Systems: A Modern Perspective, Chapter 10


Prevention
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

Operating Systems: A Modern Perspective, Chapter 10


Hold and wait
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?

Operating Systems: A Modern Perspective, Chapter 10


Circular wait
Circular Wait

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

R

P

Ri

P holds R

Pi

P

R

P requests R

Operating Systems: A Modern Perspective, Chapter 10


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

Operating Systems: A Modern Perspective, Chapter 10


Circular wait cont
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

Operating Systems: A Modern Perspective, Chapter 10


Allowing preemption
Allowing Preemption

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

ru

Si

Sj

wu

dv

ru

Sk

Operating Systems: A Modern Perspective, Chapter 10


Avoidance
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

Operating Systems: A Modern Perspective, Chapter 10


Safe vs unsafe states
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

Operating Systems: A Modern Perspective, Chapter 10


More on safe unsafe states

Likely to be in a safe state

Probability of being in unsafe state increases

More on Safe & Unsafe States

Normal

Execution

No

Request

Max Claim

Yes

Execute, then

release

Operating Systems: A Modern Perspective, Chapter 10


More on safe unsafe states1
More on Safe & Unsafe States

I

Disallow

Safe States

Unsafe States

Deadlock States

Operating Systems: A Modern Perspective, Chapter 10


Banker s algorithm
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 - S0i< 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

Operating Systems: A Modern Perspective, Chapter 10


Banker s algorithm1
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

Operating Systems: A Modern Perspective, Chapter 10


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 = 11 = avail[0]

maxc[2,1]-alloc’[2,1] = 1-0 = 12 = avail[1]

maxc[2,2]-alloc’[2,2] = 0-0 = 02 = avail[2]

maxc[2,3]-alloc’[2,3] = 5-3 = 22 = avail[3]

  • P2 can exercise max claim

avail[0] = avail[0]+alloc’[2,0] = 1+4 = 5

avail[1] = avail[1]+alloc’[2,1] = 2+0 = 2

avail[2] = avail[2]+alloc’[2,2] = 2+0 = 2

avail[3] = avail[3]+alloc’[2,3] = 2+3 = 5

Example

Maximum Claim

C = <8, 5, 9, 7>

Process R0 R1 R2 R3

p0 3 2 1 4

p1 0 2 5 2

p2 5 1 0 5

p3 1 5 3 0

p4 3 0 3 3

Allocated Resources

Process R0 R1 R2 R3

p0 2 0 1 1

p1 0 1 2 1

p2 4 0 0 3

p3 0 2 1 0

p4 1 0 3 0

Sum 7 3 7 5

Operating Systems: A Modern Perspective, Chapter 10


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 = 45 = avail[0]

maxc[4,1]-alloc’[4,1] = 0-0 = 02 = avail[1]

maxc[4,2]-alloc’[4,2] = 3-3 = 02 = avail[2]

maxc[4,3]-alloc’[4,3] = 3-0 = 35 = avail[3]

  • P4 can exercise max claim

avail[0] = avail[0]+alloc’[4,0] = 5+1 = 6

avail[1] = avail[1]+alloc’[4,1] = 2+0 = 2

avail[2] = avail[2]+alloc’[4,2] = 2+3 = 5

avail[3] = avail[3]+alloc’[4,3] = 5+0 = 5

Example

Maximum Claim

C = <8, 5, 9, 7>

Process R0 R1 R2 R3

p0 3 2 1 4

p1 0 2 5 2

p2 5 1 0 5

p3 1 5 3 0

p4 3 0 3 3

Allocated Resources

Process R0 R1 R2 R3

p0 2 0 1 1

p1 0 1 2 1

p2 0 0 0 0

p3 0 2 1 0

p4 1 0 3 0

Sum 3 3 7 2

Operating Systems: A Modern Perspective, Chapter 10


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

= <6, 2, 5, 5>

Example

Maximum Claim

C = <8, 5, 9, 7>

Process R0 R1 R2 R3

p0 3 2 1 4

p1 0 2 5 2

p2 5 1 0 5

p3 1 5 3 0

p4 3 0 3 3

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

Allocated Resources

Process R0 R1 R2 R3

p0 2 0 1 1

p1 0 1 2 1

p2 0 0 0 0

p3 0 2 1 0

p4 0 0 0 0

Sum 2 1 4 2

Operating Systems: A Modern Perspective, Chapter 10


Detection recovery
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

Operating Systems: A Modern Perspective, Chapter 10


Reusable resource graphs rrgs
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

Operating Systems: A Modern Perspective, Chapter 10


State transitions due to request
State Transitions due to Request

  • In Sj, pi is allowed to request qch 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

q edges

pi

Rh

pi

Rh

pi request q units

State Sk

State Sj

of Rh

Operating Systems: A Modern Perspective, Chapter 10


State transition for acquire
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.

pi

Rh

pi

Rh

pi acquires units

State Sk

State Sj

of Rh

Operating Systems: A Modern Perspective, Chapter 10


State transition for release
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.

pi

Rh

pi

Rh

pi releases units

State Sk

State Sj

of Rh

Operating Systems: A Modern Perspective, Chapter 10


Example1
Example

R

p

P holds one unit of R

P requests one unit of R

p

R

A Deadlock State

Operating Systems: A Modern Perspective, Chapter 10


Example

Not a Deadlock State

No Cycle in the Graph

Operating Systems: A Modern Perspective, Chapter 10


Example2
Example

p0

p1

S00

Operating Systems: A Modern Perspective, Chapter 10


Example

p0

p0

p1

p1

S00

S01

Operating Systems: A Modern Perspective, Chapter 10


Example

p0

p0

p0

p1

p1

p1

S00

S01

S11

Operating Systems: A Modern Perspective, Chapter 10


Example

p0

p0

p0

p0

p1

p1

p1

p1

S00

S01

S11

S21

Operating Systems: A Modern Perspective, Chapter 10


Example

p0

p0

p0

p0

p0

p1

p1

p1

p1

p1

S00

S01

S11

S21

S22

Operating Systems: A Modern Perspective, Chapter 10


Example

p0

p0

p0

p0

p0

p0

. . .

p1

p1

p1

p1

p1

p1

S00

S01

S11

S21

S22

S33

Operating Systems: A Modern Perspective, Chapter 10


Graph reduction
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

Operating Systems: A Modern Perspective, Chapter 10


Graph reduction cont
Graph Reduction (cont)

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

  • Represents pi releasing the resources it holds

pi

Reducing by pi

pi

Operating Systems: A Modern Perspective, Chapter 10


Graph reduction cont1
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.

Operating Systems: A Modern Perspective, Chapter 10


Example rrg

p0

p1

p2

p0

p0

p1

p1

p2

p2

Example RRG

p0

p1

p2

Operating Systems: A Modern Perspective, Chapter 10


Example RRG

p0

p1

p2

Operating Systems: A Modern Perspective, Chapter 10


Consumable resource graphs crgs
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

Operating Systems: A Modern Perspective, Chapter 10


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

q edges

pi

Rh

pi

Rh

pi request q units

State Sk

State Sj

of Rh

Operating Systems: A Modern Perspective, Chapter 10


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.

pi

Rh

pi

Rh

pi acquires units

State Sk

State Sj

of Rh

Operating Systems: A Modern Perspective, Chapter 10


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.

pi

Rh

pi

Rh

pi releases 2 units

State Sk

State Sj

of Rh

Operating Systems: A Modern Perspective, Chapter 10


p0

p0

p0

p0

p1

p1

p1

p1

Example

p0

p1

Operating Systems: A Modern Perspective, Chapter 10


Deadlock detection
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

Operating Systems: A Modern Perspective, Chapter 10


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

Operating Systems: A Modern Perspective, Chapter 10


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.

Operating Systems: A Modern Perspective, Chapter 10


General resource graphs
General Resource Graphs

  • Have consumable and reusable resources

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

  • See Figure 10.29

Operating Systems: A Modern Perspective, Chapter 10


Grg example fig 10 29
GRG Example (Fig 10.29)

p3

p2

R0

R2

R1

p0

p1

Reusable

Consumable

Not in Fig 10.29

Operating Systems: A Modern Perspective, Chapter 10


GRG Example (Fig 10.29)

p3

p2

Reduce by p3

R0

R2

R1

p0

p1

Reusable

Consumable

Operating Systems: A Modern Perspective, Chapter 10


GRG Example (Fig 10.29)

p3

p2

R0

R2

R1

p0

p1

Reduce by p0

Reusable

Consumable

Operating Systems: A Modern Perspective, Chapter 10


Recovery
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

Operating Systems: A Modern Perspective, Chapter 10


ad