Deadlocks
êDefinition & Basics:
Deadlock:
A set of blocked processes each holding
a resource & waiting
to acquire a resource held by another process
in the set.
Ex1
System has 2 disk drives
Processes P1 and P2 each hold
one disk drive and each needs another one
Ex2
Semaphores A and B, initialized to
1
P0 P1
wait (A); wait(B)
wait (B); wait(A)
Deadlock
can arise if 4 conditions hold
simultaneously:
1.
Mutual exclusion: only one process at a time can use a resource
2.
Hold and Wait: holding at least one resource and is waiting to acquire additional resources
held by others
3.
No preemption: a resource can be released only voluntarily
by the process holding it.
4.
Circular wait: there exists a set {P0, P1,
…, Pn
} of waiting
processes such that:
P0 is waiting for a
resource that is held by P1,
P1 is waiting for
a resource that is held by P2, …,
Pn–1 is waiting for
a resource that is held by Pn, and
Pn is waiting for a
resource that is held by P0.
êResource-Allocation Graph
A set of vertices V
and a set of edges
E:
·
V is partitioned
into two types:
o
P = {P1,
P2, …, Pn}, the
set consisting of all the Processes
in the system
o
R = {R1, R2,
…, Rm}, the set consisting of all Resource
types in the system
·
E is partitioned into two types:
o
request edge – directed
edge Pi ® Rj
o
assignment edge – directed
edge Rj ® Pi
Resource Allocation Graph with No Deadlock (no cycle)
Resource Allocation Graph with Deadlock (cycle)
Resource Allocation Graph with No Deadlock (cycle)
Basic Facts
·
If
graph contains no cycles Þ no deadlock
·
If
graph contains a cycle Þ
o
if
only one instance per resource type, then deadlock
o
if
several instances per resource type, possibility of deadlock
êDeadlock Prevention
Restrain the
ways request can be made.
Any of the
following polices will prevent deadlock:
1.
Hold and Wait –Require process to request and be
allocated all its resources before it begins execution,
OR allow process
to request resources only when the process has none.
2.
No Preemption – If a process holding some resources
and requests another resource that cannot be immediately allocated to it:
ALL resources
currently being held are released.
Process will be restarted only when it can regain its
old resources, as well as the new ones that it is requesting.
3.
Circular Wait – impose a total ordering of all resource
types, and require process requests resources in an increasing order of enumeration.
êDeadlock Avoidance
Requires that
the system has a
priori information available.
·
Simplest
model requires that each process declare the maximum number of
resources of
each type that it may need.
·
The
deadlock-avoidance algorithm dynamically examines resource-allocation
state
to
ensure there is
no circular-wait.
Safe State
·
When
a process requests an available resource, system must decide if immediate
allocation leaves the system in a safe
state.
·
System
is in safe state if there exists a sequence <P1, P2, …, Pn> of ALL processes
in the systems
such that:
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 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.
Safe, Unsafe & Deadlock State
êAvoidance algorithms
v
Resource-Allocation
Graph Scheme:
(Used for Single instance of resource types)
Resources must be claimed a priori
in the system.
·
Claim edge
Pi ® Rj indicated that process Pi may request resource Rj;
represented by a dashed line
·
Claim edge converts to Request
edge when a process requests a resource
·
Request edge converted to an Assignment
edge when the
resource is allocated to the process
·
When a resource is released by a process,
assignment edge reconverts to a Claim edge
Resource-Allocation Graph
Unsafe State In
Resource-Allocation Graph
Resource-Allocation Graph Algorithm
Suppose that process Pi requests a
resource Rj
The request can be granted
only
if :
converting
the request edge to an assignment edge
does not
result in the formation of a cycle in the resource allocation graph
v
Banker’s
Algorithm ( by Dijkstra)
(Used for Multiple instances of a
resource type)
Each process must a priori
claim maximum
use.
o Data Structures
Let n = number of processes, and
m =
number of resources types
ü Available: vector of length m.
If Available [j] = k, there are
k instances of resource type
Rj available
ü Max: n x m matrix.
If Max [i,j]
= k, then process Pi may request at most k instances of resource type Rj
ü Allocation: n x m matrix.
If Allocation [i,j]
= k then Pi
is currently allocated k
instances of Rj
ü Need: n x m matrix.
If Need [i,j]
= k, then Pi may need k more instances of Rj to complete its task
Need [i,j] = Max [i,j] – Allocation
[i,j]
o Safety Algorithm
1. Let Work and Finish be vectors of
length m and n, respectively.
Initialize:
Work = Available
Finish [i] = false for i = 0, 1, …, n- 1
2. Find an index i
such that:
Finish [i] = false AND Needi
£ Work
If no such i exists, go to step 4
3. Work = Work + Allocationi
Finish[i]
= true
go to step 2
4. If Finish [i] == true for all i, then the
system is in a safe state,
otherwise it is unsafe
The
Algorithm requires m x n2 operations to detect whether the system is in
deadlocked state
o Resource-Request for a Process
Request =
request vector for process Pi
If Requesti [j] = k
then process Pi wants k
instances of resource type Rj
· If Requesti > Needi
Raise error condition, since process has
exceeded its maximum claim.
· If Requesti > Available
Pi must wait, since resources are not
available
· If Requesti <= Available
Pretend to
allocate requested resources to Pi by modifying
the state as follows:
Available = Available
– Requesti
Allocationi = Allocationi + Requesti
Needi = Needi – Requesti
·
If state is safe
Þ
the resources are allocated to Pi
·
If state is unsafe Þ Pi must wait, and the old
resource-allocation state is restored
o Example of Banker’s Algorithm
·
5 processes P0 through P4;
·
3 resource types:
A B C
10 5 7
Snapshot at time T0:
Allocation Max Available
A B C A B C A B C
P0 0
1 0 7 5 3 3 3 2
P1 2 0 0 3
2 2
P2 3 0 2 9 0 2
P3 2 1 1 2 2 2
P4 0 0 2 4 3 3
·
The content of the matrix Need is
defined to be Max – Allocation
Need
A B C
P0 7
4 3
P1 1
2 2
P2 6 0 0
P3 0 1 1
P4 4 3 1
·
The system is in a safe state since the
sequence < P1, P3, P4,
P2, P0> satisfies safety criteria
Example:
P1 Request (1,0,2)
·
Check that Request £ Available that is, (1,0,2) £
(3,3,2) Þ true
Allocation
Need Available
A B C A B C A B C
P0 0 1 0 7 4 3 2 3 0
P1 3
0 2 0 2 0
P2 3 0 1 6 0 0
P3 2 1 1 0 1 1
P4 0 0 2 4 3 1
·
Executing safety algorithm shows that sequence < P1,
P3, P4, P0, P2> satisfies safety requirement
êDeadlock
Detection
Allow system to enter
deadlock state then: Detect
& Recover.
o Single Instance of Each Resource Type
· Maintain wait-for graph
o
Nodes are processes
o
Pi ® Pj if Pi is waiting for Pj
· Periodically invoke an
algorithm that searches for a cycle in the graph.
· If there is a cycle, there exists a deadlock
· An algorithm to detect a cycle in a graph requires an order of n2 operations,
where n is the number of vertices in the graph
Resource-Allocation Graph & Wait-for Graph
Resource-Allocation Graph Corresponding wait-for graph
o Several Instances of a 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
1. Let Work and Finish be vectors of length m and n, respectively
Initialize:
Work = Available
For i =
1,2, …, n: if Allocationi ¹ 0, then Finish[i] = false; else Finish[i] = true
2. Find an index i such that both:
Finish[i] == false AND Requesti
£ Work
If no such i exists, go to step 4
3. Work = Work +
Allocationi
Finish[i] = true
go to step 2
4. If Finish[i] == false, for some i, 1 £ i
£ n, then the system is in deadlock
state.
and Pi is deadlocked
The
Algorithm requires m x n2 operations to detect whether the system is in
deadlocked state
Example of Detection Algorithm
·
Five processes P0 through P4;
·
Three resource types
A B
C
7
2 6
Snapshot
at time T0:
Allocation Request Available
A B C A B C A B C
P0 0 1 0 0
0 0 0 0 0
P1 2 0 0 2
0 2
P2 3
0 3 0 0 0
P3 2 1 1 1
0 0
P4 0 0 2 0
0 2
System is not deadlocked, sequence <P0, P2,
P3, P1, P4> will
result in Finish[i] = true for all i
P2 requests an additional 1
instance of type C
Request
A
B C
P0 0 0 0
P1 2 0 2
P2 0
0 1
P3 1 0 0
P4 0 0 2
·
State of system?
o
Can reclaim resources held by process P0,
but insufficient resources to fulfill other processes requests
o
Deadlock exists,
consisting of processes P1, P2, P3,
and P4
êRecovery from Deadlock:
Options:
·
Abort all deadlocked
processes
·
Abort one process at a
time until the deadlock cycle is eliminated
·
In which order should we choose to abort?
o
Priority of the
process
o
How long process has
computed, and how much longer to completion
o
Resources the process
has used
o
Resources process needs to complete
o
How many processes will
need to be terminated
o
Is process interactive or batch?
·
Selecting a victim to minimize cost
·
Rollback – return to
some safe state, restart process from
that state
· Starvation – same process may always be
picked as victim, include number of rollback in cost factor