Deadlock

Deadlock and Starvation
Fred Kuhns
(fredk@arl.wustl.edu, http://www.arl.wustl.edu/~fredk)
Department of Computer Science and Engineering

Washington University in St. Louis
Washington
WASHINGTON UNIVERSITY IN ST LOUIS
Introduction to deadlock
• Typical scenario for a process P:
– request exclusive access to some resource R
– process P uses the resource
– P then releases or returns the resource R to the system.
• If two processes request R, one must block to ensure sequential

access to R
• “a set of processes is in a deadlock state when every process in the

set is waiting for an event that can be caused only by another
process in the set”, Silberschatz et. al., “Operating Systems
Concepts”
• There is no efficient solution
Fred Kuhns (01/17/09) CS422 – Operating Systems Concepts 2

Reusable/Consumable Resources
• Reusable resource:
– Description:
• Used by one process at a time and not depleted by that use
• Processes obtain resources that they later release for reuse by other
processes
– Example:
• Processor time, I/O channels, main and secondary memory, files, databases,
and semaphores
• Consumable resources
– Description:
• Created (produced) and destroyed (consumed) by a process
– Examples:
• Interrupts, signals, messages, and information in I/O buffers

Bridge Crossing Example
• Traffic only in one direction.
• Each section of a bridge can be viewed as a resource.
• Deadlock can occur if two cars enter the bridge from opposite sides
– it can be resolved if one car backs up (preempt resources and rollback).
• Several cars may have to be backed up if a deadlock occurs.
• Starvation is possible
– timid driver hesitates to enter bridge

Consumable Resource Example
• Deadlock occurs if receive is blocking
P1 P2
... ...
Receive(P2); Receive(P1);
... ...
Send(P2); Send(P1);

Necessary Conditions for Deadlock
• 1) Mutual exclusion:
– One process holds a resource in a non-sharable mode.
– Other processes requesting resource must wait for resource to be
released.
• 2) Hold-and-wait:
– A process must hold at least one allocated resource while awaiting one or
more resources held by other processes.
• 3) No preemption:
– Resources not forcibly removed from a process holding it, the holding
process must voluntarily released it.
• 4) Circular wait
– a closed chain of processes exists, such that each process holds at least
one resource needed by the next process in the chain.

System Model - Reusable Resources
• Resource types R1, R2, . . ., Rm
CPU cycles, memory space, I/O devices
• Each resource type Ri has Wi instances.
• At any given time the system has N processes,

designated by Pi
• Each process utilizes a resource as follows:

– request – block if resource is not available
– use – process “owns” resource, but may elect to share with other
processes
– release – may result in a blocked processes being woken up

Resource-Allocation Graph
• A set of Vertices V and a set of Edges E
• V is partitioned into:
– P = {P1, P2, …, Pn}, all processes in the system.
– R = {R1, R2, …, Rm}, all resource types in the system.
• Request edge – directed edge Pi → Rj. Indicates Pi is

waiting for an instance of resource type Rj
• Assignment edge – directed edge Rj→ Pi. Indicates that

an instance of resource type Rj has been allocated to Pi.

Resource-Allocation Graph
P
• Process Pi
• Resource Type Rj with 4 instances

Pi
Rj
• Pi requests instance of Rj
Pi
Rj
• Pi is holding an instance of Rj
R1 R2
• Deadlock P1 P2
Example of a Resource Allocation Graph
R1 R2 R1 R2 R1 R2
P1 P2 P3 P1 P2 P3 P1 P2 P3
R3 R4 R3 R4 R3 R4
Initial: P3 requests R3 P2 releases R1,

No Deadlock (Deadlock) P3 requests R3
(No Deadlock:
Why not?)
Basic Facts
• If graph contains no cycles ⇒
– no deadlock.
• If graph contains a cycle ⇒

– if only one instance per resource type, then deadlock.
– if several instances per resource type, possibility of deadlock.

Approaches to Deadlock Handling
• Ensure system never enters a deadlocked state: Use protocol to
prevent or avoid deadlock:
– deadlock prevention scheme - ensure that at least one of the necessary
conditions cannot hold.
– deadlock avoidance scheme - requires the OS know in advance the
resource usage requirements of all processes. Then for each request the
OS decides if it could lead to a deadlock before granting.
• Allow the system to enter a deadlock state and then recover
(detection and recovery).
– system implements an algorithm for deadlock detection, if so then
recover
• Assume deadlocks never occur in the system
– used by most operating systems, including UNIX.

Deadlock Prevention
• At least 1 necessary condition does not hold
– Mutual Exclusion: not required for sharable resources; must hold for non-
sharable resources.
– Hold-and-Wait: can not request new when holding resources.

• Protocol 1: request all resources before it begins execution
• Protocol 2: request resources only when the process has none.
• Low resource utilization; starvation possible.
– No Preemption: preempt resources from processes

• Protocol 1: If a request can not be satisfied then preempt all resources held and
block
• Protocol 2: Preempt only if resources are needed by another running process
• Requires resource state to be easily restored
– Circular Wait: Block any request that results in a cycle.

• Impose a total ordering of all resource types, and require that each process requests
resources in an increasing order

More on Preventing Circular Wait
• Define F such that F: R -> N (i.e. each resource type is
assigned a unique integer.
• Assume process holds resource Ri
• Protocol 1: Request resource Rj iff F(Rj) > R(Ri).

– Must request multiple instances of same type at same time
• Protocol 2: Request resource Rj iff it has released all Ri

such that F(Ri) ≥ R(Rj).
• Prove that there can not be a circular wait.

Deadlock Avoidance
• Requires that system have a priori information
• Simplest and most useful model requires that each process

declare the maximum number of resources of each type that it
may need.
• The deadlock-avoidance algorithm dynamically examines the

resource-allocation state to ensure that there can never be a
circular-wait condition.
• Resource-allocation state is defined by the

– number of available resources
– number of allocated resources,
– maximum demands of the processes.

Safe State
• Safe State: System can allocate resources to existing
processes in some order that prevents deadlock. i.e.
there is a safe sequence of all processes whose
allocation requests can be satisfied.
• Sequence <P1, P2, …, Pn> is safe if for each Pi, the

resources that Pi can still request can be satisfied by
currently available resources + resources held by all
the Pj, with j < i.
– If Pi resource needs are not immediately available, then Pi can
wait until all Pj have finished.
– When Pj is finished, Pi can obtain needed resources, execute,
return allocated resources, and terminate.
– When Pi terminates, Pi+1 can obtain its needed resources, and
so on.
Basic Facts
• If a system is in safe state ⇒
– no deadlocks.
• If a system is in unsafe state ⇒

– possibility of deadlock.
• Avoidance ⇒
– ensure that a system will never enter an unsafe state.

Resource-Allocation Graph Algorithm
• Must have no more than one instance of each resource
type.
• Claim edge Pi → Rj indicates process Pj may request

resource Rj; represented by a dashed line.
• Claim edge converts to request edge when a process

requests a resource.
• When a resource is released by a process, assignment

edge reconverts to a claim edge.
• Resources must be claimed a priori in the system.

Resource-Allocation Graph:Deadlock Avoidance
Resource Allocation graph P2 requests R2,

Unsafe state (cycle)
Some Definitions
Definitions
Resource = R = (R1, R2, ..., Rm) Available = V = (V1, V2, ..., Vm)
Relationships
M11 M12 ... M1m A11 A12 ... A1m n
M21 M22 ... M2m A21 A22 ... A2m 1) Ri = Vi + Σ Aki, for all i
Max = M = Allocation = A =
... ... k=1
Mn1 Mn2 ... Mnm An1 An2 ... Anm 2) Mki ≤ Ri, for all k, i
3) Aki ≤ Mki, for all k, i
N11 N12 ... N1m
N21 N22 ... N2m
Need = N = Max - Allocation =
...
Nn1 Nn2 ... Nnm
• If X and Y are vectors then X < Y iff X[i] < Y[i] for all i
• Row i of a matrix corresponds to process Pi. So Mi is the set of
maximum allocations for process i.
Deadlock Avoidance Policies
• Deadlock Avoidance Policy – Process Initiation Denial
– Start if the max claim of all process can be met (including new
process)
– Start a new process Pn+1 only if the below inequality holds
n
Ri ≥ M(n+1)i + Σ Mki for all i
k=1
• Resource Allocation Denial: Banker’s Algorithm

– Each process must a priori claim maximum use (claims) which may not
exceed the total number of resources
– When a process requests a resource it may have to wait.
– When a process gets all its resources it must return them in a finite
amount of time.

Safety Algorithm
• Let Work and Finish be vectors of length m and n, respectively.
Initialize:
Work = Available
Finish [i] = false for i - 1,3, …, n.
• Find an i (that is, a Pi) such that both:

Finish [i] == false // Pi has not completed
Needi ≤ Work // Pi can allocate remaining Resources
If no such i exists, go to step 4.
• Set Work = Work + Allocationi // assume Pi returns resources

Set Finish[i] = True // Pi completes
go to step 2.
• If Finish [i] == True for all i, then the system is in a safe state.
Otherwise it is unsafe.
Resource-Request Algorithm for Pi
If Requesti [j] = k,then process Pi wants k instances of

resource type Rj.
– If Requesti ≤ Needi,, then go to step 2.
Otherwise, raise error condition, (exceeded claim).
– If Requesti ≤ Available, then go to step 3.

Otherwise Pi must wait, resources not available.
– Pretend to allocate requested resources to Pi:

Available = Available - Requesti;
Allocationi = Allocationi + Requesti;
Needi = Needi – Requesti;
• safe ⇒ the resources are allocated to Pi.
• unsafe ⇒ Pi must wait, and the old resource-allocation state is
restored
Example of Banker’s Algorithm
• 5 processes P0 through P4;
3 resource types A (10), B (5), and C (7).
• Snapshot at time T0:
Alloc Max Avail Need
ABC ABC ABC ABC
P0 010 753 332 743
P1 200 322 122
P2 302 902 600
P3 211 222 011
P4 002 433 431
• Is the system in a safe state?

Checking for Safe State
• 5 processes P0 through P4;
3 resource types A (10), B (5), and C (7).
Alloc Max Avail Need
ABC ABC ABC ABC
P0 010 753 332 743
P1 200 322 122
P2 302 902 600
P3 211 222 011
P4 002 433 431
• Work = (3 3 2)
• Allocate P1, Need1 (1 2 2) <= Work (3 3 2); Work = Work + (2 0 0) = (5 3 2)
All Fred
finished so Safe.
Kuhns (01/17/09) CS422 – Operating Systems Concepts 25
Example P1 Request (1,0,2)
• Check that Request ≤ Available
– (that is, (1,0,2) ≤ (3,3,2) ⇒ true: Request[i] ≤ Avail[i])
Request1 Alloc Max Avail Need
(1,0,2) A B C ABC ABC ABC
PAlloc
0 010 753 332 743
1 Need1
P(3,0,2)
1 200 322 Avail 1 2 2 (0,2,0)
(2,3,0)
P2 302 902 600
P3 211 222 011
P4 002 433 431
• Executing safety algorithm shows that sequence <P1, P3,
P4, P0, P2> satisfies safety requirement.
• Can request for (3,3,0) by P4 be granted?
• Can request for (0,2,0) by P0 be granted?

Deadlock Detection
• Allow system to enter deadlock state
• Detection algorithm
• Recovery scheme

Single Instance each Resource Type: Wait-for graph
P0
P0
R1 R2
P1 P2 P3
P1 P2 P3
R3 R4 P4
P4
Wait-For
Resource Allocation Graph
Graph
• Maintain wait-for graph
– Nodes are processes.
– Pi → Pj if Pi is waiting for Pj.
• Periodically invoke an algorithm that searches for a cycle in the
graph.
Several Instances ea Resource Type
• Available: A vector of length m indicates the number of available
resources of each type.
• Allocation: An n x m matrix defines the number of resources of each

type currently allocated to each process.
• Request: An n x m matrix indicates the current request of each

process. If Request [ij] = k, then process Pi is requesting k more
instances of resource type. Rj.

Detection Algorithm
• Work and Finish are vectors of length m and n, respectively.
Initialize:
– Work = Available
– if Allocationi ≠ 0, then Finish[i] = false else Finish[i] = true.
• Find an index i such that both:

– Finish[i] == false // has allocated resources
– Requesti ≤ Work // request can be filled
– If no such i exists, go to step 3
5. Find P that can finish
– Work = Work + Allocationi;
– Finish[i] = true;
– go to step 2
• If Finish[i] == false, for some i, 1 ≤ i ≤ n, then the system is in
deadlock state. Moreover, if Finish[i] == false, then Pi is deadlocked.

Example of Detection Algorithm
• Five processes P0 through P4
• three resource types A (7), B (2), and C (6).
Allocation Request Available
ABC ABC ABC
P0 010 000 000
P1 200 202
P2 303 000
P3 211 100
P4 002 002
• Sequence <P0, P2, P3, P1, P4> will result in Finish[i] = true for all i.

Step 0
Total Resource {A = 7, B = 2, C = 6}
ABC ABC ABC
P0 0 1 0 000 000
P1 2 0 0 202
P2 3 0 3 000
P3 2 1 1 100
P4 0 0 2 002
Step 0:
Work = Available = {0, 0, 0}
Finish = {false, false, false, false, false}

Steps 1, 2 and 3
Allocation Request Steps 1 & 2:
ABC ABC • Request0 < work // {0 0 0}
Work = {0 1 0}
P0 010 000 Finish = {true, false, false, false, false}
P1 200 202 • Request2 < work // {0 1 0}
P2 303 000 Work = {3 1 3}
Finish = {true, false, true, false, false}
P3 211 100 • Request1 < work // {3 1 3}
P4 002 002 Work = {5 1 3}
Finish = {true, true, true, false, false}
• Request3 < work // {5 1 3}
Work = {7 2 4}
Step 3: Finish = {true, true, true, true, false}
• No deadlock since all elements of • Request4 < work // {7 2 4}
Finish = true Work = {7 2 6}
Finish = {true, true, true, true, true}

New Request from P2
• P2 requests an additional instance of type C
ABC ABC ABC
P0 010 000 000
P1 200 202
P2 303 001
P3 211 100
P4 002 002
• State of system?
– Can reclaim resources held by process P0, but insufficient resources
to fulfill other processes; requests.
– Deadlock exists, consisting of processes P1, P2, P3, and P4.

Steps 1, 2 and 3 with new P2 request
Allocation Request Steps 1 & 2:
ABC ABC • Request0 < work // {0 0 0}
P0 010 000 Work = {0 1 0}
Finish = {true, false, false, false, false}
P1 200 202
• No other Processes with Request < work.
P2 303 000
P3 211 100
P4 002 002

Detection-Algorithm Usage
• When, and how often, to invoke depends on:
– How often a deadlock is likely to occur?
– How many processes will need to be rolled back?
• one for each disjoint cycle
• If detection algorithm is invoked arbitrarily, there

may be many cycles in the resource graph and so we
would not be able to tell which of the many deadlocked
processes “caused” the deadlock.

Recovery: Process Termination
• Abort all deadlocked processes.
• Abort one process at a time until the deadlock cycle is
eliminated.
• In which order should we choose to abort?
– Priority of the process.
– How long process has computed, and how much longer to
completion.
– Resources the process has used.
– Resources process needs to complete.
– How many processes will need to be terminated.
– Is process interactive or batch?

Recovery: Resource Preemption
• Selecting a victim – minimize cost.
• Rollback – return to some safe state, restart process

for that state.
• Starvation – same process may always be picked as

victim, include number of rollback in cost factor.

Combined Approach
• Combine the three basic approaches
– prevention
– avoidance
– detection
allowing the use of the optimal approach for each of resources in
the system.
• Partition resources into hierarchically ordered classes.
• Use most appropriate technique for handling deadlocks within

each class.

Deadlock

Încărcat de

Informații document

Descriere originală:

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Deadlock

Încărcat de

Drepturi de autor:

Formate disponibile

Deadlock and Starvation

Department of Computer Science and Engineering

• If two processes request R, one must block to ensure sequential

• “a set of processes is in a deadlock state when every process in the

• There is no efficient solution

Fred Kuhns (01/17/09) CS422 – Operating Systems Concepts 2

Fred Kuhns (01/17/09) CS422 – Operating Systems Concepts 3

• Traffic only in one direction.

• Each section of a bridge can be viewed as a resource.

• Several cars may have to be backed up if a deadlock occurs.

Fred Kuhns (01/17/09) CS422 – Operating Systems Concepts 4

Fred Kuhns (01/17/09) CS422 – Operating Systems Concepts 5

Fred Kuhns (01/17/09) CS422 – Operating Systems Concepts 6

• Each resource type Ri has Wi instances.

• At any given time the system has N processes,

• Each process utilizes a resource as follows:

Fred Kuhns (01/17/09) CS422 – Operating Systems Concepts 7

• Request edge – directed edge Pi → Rj. Indicates Pi is

• Assignment edge – directed edge Rj→ Pi. Indicates that

Fred Kuhns (01/17/09) CS422 – Operating Systems Concepts 8

• Resource Type Rj with 4 instances

Initial: P3 requests R3 P2 releases R1,

• If graph contains a cycle ⇒

Fred Kuhns (01/17/09) CS422 – Operating Systems Concepts 11

Fred Kuhns (01/17/09) CS422 – Operating Systems Concepts 12

– Hold-and-Wait: can not request new when holding resources.

– No Preemption: preempt resources from processes

– Circular Wait: Block any request that results in a cycle.

Fred Kuhns (01/17/09) CS422 – Operating Systems Concepts 13

• Assume process holds resource Ri

• Protocol 1: Request resource Rj iff F(Rj) > R(Ri).

• Protocol 2: Request resource Rj iff it has released all Ri

• Prove that there can not be a circular wait.

• Simplest and most useful model requires that each process

• The deadlock-avoidance algorithm dynamically examines the

• Resource-allocation state is defined by the

Fred Kuhns (01/17/09) CS422 – Operating Systems Concepts 15

• Sequence <P1, P2, …, Pn> is safe if for each Pi, the

• If a system is in unsafe state ⇒

Fred Kuhns (01/17/09) CS422 – Operating Systems Concepts 17

• Claim edge Pi → Rj indicates process Pj may request

• Claim edge converts to request edge when a process

• When a resource is released by a process, assignment

• Resources must be claimed a priori in the system.

Fred Kuhns (01/17/09) CS422 – Operating Systems Concepts 18

Resource Allocation graph P2 requests R2,

• Resource Allocation Denial: Banker’s Algorithm

Fred Kuhns (01/17/09) CS422 – Operating Systems Concepts 21

• Find an i (that is, a Pi) such that both:

• Set Work = Work + Allocationi // assume Pi returns resources

If Requesti [j] = k,then process Pi wants k instances of

– If Requesti ≤ Available, then go to step 3.

– Pretend to allocate requested resources to Pi:

• Is the system in a safe state?

Fred Kuhns (01/17/09) CS422 – Operating Systems Concepts 24

Fred Kuhns (01/17/09) CS422 – Operating Systems Concepts 26

Fred Kuhns (01/17/09) CS422 – Operating Systems Concepts 27

• Allocation: An n x m matrix defines the number of resources of each

• Request: An n x m matrix indicates the current request of each

Fred Kuhns (01/17/09) CS422 – Operating Systems Concepts 29

• Find an index i such that both:

Fred Kuhns (01/17/09) CS422 – Operating Systems Concepts 30

Fred Kuhns (01/17/09) CS422 – Operating Systems Concepts 31