Chapter 7: Deadlocks

 System Model
 Deadlock Characterization
 Methods for Handling Deadlocks
 Deadlock Prevention
Chapter 7: Deadlocks  Deadlock Avoidance
 Deadlock Detection
 Recovery from Deadlock

Operating System Concepts – 9th Edition Silberschatz, Galvin and Gagne ©2013 Operating System Concepts – 9th Edition 7.2 Silberschatz, Galvin and Gagne ©2013

Chapter Objectives System Model

 To develop a description of deadlocks, which prevent  System consists of resources

sets of concurrent processes from completing their  Resource types R1, R2, . . ., Rm
tasks
CPU cycles, memory space, I/O devices
 To present a number of different methods for
 Each resource type Ri has Wi instances.
preventing or avoiding deadlocks in a computer
system  Each process utilizes a resource as follows:
 request
 use
 release

Operating System Concepts – 9th Edition 7.3 Silberschatz, Galvin and Gagne ©2013 Operating System Concepts – 9th Edition 7.4 Silberschatz, Galvin and Gagne ©2013
 Deadlock Characterization Deadlock with Mutex Locks
Deadlock can arise if four conditions hold simultaneously.  Deadlocks can occur via system calls, locking, etc.
 Mutual exclusion: only one process at a time can use a  See example box in text page 318 for mutex deadlock
resource
 Hold and wait: a process holding at least one resource is
waiting to acquire additional resources held by other
processes
 No preemption: a resource can be released only voluntarily
by the process holding it, after that process has completed
its task
 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.

Operating System Concepts – 9th Edition 7.5 Silberschatz, Galvin and Gagne ©2013 Operating System Concepts – 9th Edition 7.6 Silberschatz, Galvin and Gagne ©2013

Resource-Allocation Graph
A set of vertices V and a set of edges E.
 V is partitioned into two types:
 P = {P1, P2, …, Pn}, the set consisting of all the processes
in the system

 R = {R1, R2, …, Rm}, the set consisting of all resource

types in the system

 request edge – directed edge Pi  Rj

 assignment edge – directed edge Rj  Pi

Operating System Concepts – 9th Edition 7.7 Silberschatz, Galvin and Gagne ©2013
 Example of a Resource Allocation Graph Resource Allocation Graph With A Deadlock

Operating System Concepts – 9th Edition 7.9 Silberschatz, Galvin and Gagne ©2013 Operating System Concepts – 9th Edition 7.10 Silberschatz, Galvin and Gagne ©2013

Graph With A Cycle But No Deadlock 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

Operating System Concepts – 9th Edition 7.11 Silberschatz, Galvin and Gagne ©2013 Operating System Concepts – 9th Edition 7.12 Silberschatz, Galvin and Gagne ©2013
 Methods for Handling Deadlocks Deadlock Prevention
 Ensure that the system will never enter a deadlock Restrain the ways request can be made
state:
 Mutual Exclusion –
 Deadlock prevention
– Some resources can be shared easily (like a read-only
 Deadlock avoidence file; many can read it at the same time).
 Allow the system to enter a deadlock state and then – Some resources cannot be shared (like a printer; only
recover one process can use it at a time).
 Ignore the problem and pretend that deadlocks never – For non-sharable resources, we must make sure only
occur in the system; used by most operating systems, one process uses them at a time.
including UNIX
 Hold and Wait –
– Normally, a process can hold one resource and wait for
another, which can cause problems (like deadlock).
– To prevent this, we say:
• A process must request all the resources it needs
before it starts running. OR
• A process can only ask for resources if it has none
already.
Operating System Concepts – 9th Edition 7.13 Silberschatz, Galvin and Gagne ©2013 Operating System Concepts – 9th Edition 7.14 Silberschatz, Galvin and Gagne ©2013

Deadlock Prevention (Cont.) Deadlock Example

 No Preemption – /* thread one runs in this function */
void *do_work_one(void *param)
 If a process that is holding some resources requests {
another resource that cannot be immediately allocated to pthread_mutex_lock(&first_mutex);
it, then all resources currently being held are released pthread_mutex_lock(&second_mutex);
 Preempted resources are added to the list of resources /** * Do some work */
pthread_mutex_unlock(&second_mutex);
for which the process is waiting
pthread_mutex_unlock(&first_mutex);
 Process will be restarted only when it can regain its old pthread_exit(0);
resources, as well as the new ones that it is requesting
}
 Circular Wait – /* thread two runs in this function */
– Deadlocks happen when processes are stuck waiting for void *do_work_two(void *param)
{
each other in a circle.
pthread_mutex_lock(&second_mutex);
– To prevent that, we force an order on all resource types pthread_mutex_lock(&first_mutex);
(like R1, R2, R3... etc.). Then, we say: /** * Do some work */
• Each process must request resources only in the pthread_mutex_unlock(&first_mutex);

order (smallest number first, bigger later). pthread_mutex_unlock(&second_mutex);

pthread_exit(0);
• For example, a process can request R1, then R2, but
}
NOT R2 first and R1 later.
Operating System Concepts – 9th Edition 7.15 Silberschatz, Galvin and Gagne ©2013 Operating System Concepts – 9th Edition 7.16 Silberschatz, Galvin and Gagne ©2013
 Deadlock Example with Lock Ordering Deadlock Avoidance
void transaction(Account from, Account to, double amount)
Requires that the system has some additional a priori information
{ available
mutex lock1, lock2;
lock1 = get_lock(from);
 Simplest and most useful model requires that each process
lock2 = get_lock(to); declare the maximum number of resources of each type
acquire(lock1);
that it may need
acquire(lock2);  The deadlock-avoidance algorithm dynamically examines
withdraw(from, amount); the resource-allocation state to ensure that there can never
deposit(to, amount); be a circular-wait condition
release(lock2);  Resource-allocation state is defined by the number of
release(lock1); available and allocated resources, and the maximum
} demands of the processes
Transactions 1 and 2 execute concurrently. Transaction 1 transfers $25
from account A to account B, and Transaction 2 transfers $50 from account
B to account A

Operating System Concepts – 9th Edition 7.17 Silberschatz, Galvin and Gagne ©2013 Operating System Concepts – 9th Edition 7.18 Silberschatz, Galvin and Gagne ©2013

Safe State Basic Facts

 When a process requests an available resource, system must  If a system is in safe state  no deadlocks
decide if immediate allocation leaves the system in a safe state
 System is in safe state if there exists a sequence <P1, P2, …, Pn>  If a system is in unsafe state  possibility of deadlock
of ALL the processes in the systems such that for each Pi, the
resources that Pi can still request can be satisfied by currently  Avoidance  ensure that a system will never enter an
available resources + resources held by all the Pj, with j < I unsafe state.
 That is:
 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

Operating System Concepts – 9th Edition 7.19 Silberschatz, Galvin and Gagne ©2013 Operating System Concepts – 9th Edition 7.20 Silberschatz, Galvin and Gagne ©2013
 Safe, Unsafe, Deadlock State Avoidance Algorithms
 Single instance of a resource type
 Use a resource-allocation graph

 Multiple instances of a resource type

 Use the banker’s algorithm

Operating System Concepts – 9th Edition 7.21 Silberschatz, Galvin and Gagne ©2013 Operating System Concepts – 9th Edition 7.22 Silberschatz, Galvin and Gagne ©2013

Resource-Allocation Graph Scheme Resource-Allocation Graph

 Claim edge Pi  Rj indicated that process Pj 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
 Resources must be claimed a priori in the system

Operating System Concepts – 9th Edition 7.23 Silberschatz, Galvin and Gagne ©2013 Operating System Concepts – 9th Edition 7.24 Silberschatz, Galvin and Gagne ©2013
 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

Operating System Concepts – 9th Edition 7.25 Silberschatz, Galvin and Gagne ©2013 Operating System Concepts – 9th Edition 7.26 Silberschatz, Galvin and Gagne ©2013

Banker’s Algorithm Data Structures for the Banker’s Algorithm

 Multiple instances Let n = number of processes, and m = number of resources types.

 Each process must a priori claim maximum use

 Available: Vector of length m. If available [j] = k, there are k
instances of resource type Rj available
 When a process requests a resource it may have to wait  Max: n x m matrix. If Max [i,j] = k, then process Pi may request at
most k instances of resource type Rj
 When a process gets all its resources it must return them in a
finite amount of time  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]

Operating System Concepts – 9th Edition 7.27 Silberschatz, Galvin and Gagne ©2013 Operating System Concepts – 9th Edition 7.28 Silberschatz, Galvin and Gagne ©2013
 Safety Algorithm Resource-Request Algorithm for Process Pi

1. Let Work and Finish be vectors of length m and n, respectively. Requesti = request vector for process Pi. If Requesti [j] = k then
Initialize: process Pi wants k instances of resource type Rj
Work = Available 1. If Requesti  Needi go to step 2. Otherwise, raise error condition,
Finish [i] = false for i = 0, 1, …, n- 1 since process has exceeded its maximum claim
2. If Requesti  Available, go to step 3. Otherwise Pi must wait,
2. Find an i such that both: since resources are not available
(a) Finish [i] = false 3. Pretend to allocate requested resources to Pi by modifying the
(b) Needi  Work state as follows:
If no such i exists, go to step 4 Available = Available – Requesti;
Allocationi = Allocationi + Requesti;
3. Work = Work + Allocationi
Finish[i] = true Needi = Needi – Requesti;
go to step 2  If safe  the resources are allocated to Pi
4. If Finish [i] == true for all i, then the system is in a safe state  If unsafe  Pi must wait, and the old resource-allocation state
is restored

Operating System Concepts – 9th Edition 7.29 Silberschatz, Galvin and Gagne ©2013 Operating System Concepts – 9th Edition 7.30 Silberschatz, Galvin and Gagne ©2013

Example of Banker’s Algorithm Example (Cont.)

 The content of the matrix Need is defined to be Max – Allocation
 5 processes P0 through P4;

3 resource types: Need

A (10 instances), B (5instances), and C (7 instances) ABC
 Snapshot at time T0:
P0 743
Allocation Max Available P1 122
ABC ABC ABC
P2 600
P0 010 753 332
P3 011
P1 200 322
P4 431
P2 302 902
P3 211 222  The system is in a safe state since the sequence < P1, P3, P4, P2, P0>
P4 002 433 satisfies safety criteria

Operating System Concepts – 9th Edition 7.31 Silberschatz, Galvin and Gagne ©2013 Operating System Concepts – 9th Edition 7.32 Silberschatz, Galvin and Gagne ©2013
 Example: P1 Request (1,0,2) Deadlock Detection
 Check that Request  Available (that is, (1,0,2)  (3,3,2)  true  Allow system to enter deadlock state
Allocation Need Available
ABC ABC ABC  Detection algorithm
P0 010 743 230
 Recovery scheme
P1 302 020
P2 302 600
P3 211 011
P4 002 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?

Operating System Concepts – 9th Edition 7.33 Silberschatz, Galvin and Gagne ©2013 Operating System Concepts – 9th Edition 7.34 Silberschatz, Galvin and Gagne ©2013

Single Instance of Each Resource Type Resource-Allocation Graph and Wait-for 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. 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 Corresponding wait-for graph

Operating System Concepts – 9th Edition 7.35 Silberschatz, Galvin and Gagne ©2013 Operating System Concepts – 9th Edition 7.36 Silberschatz, Galvin and Gagne ©2013
 Several Instances of a Resource Type Detection Algorithm

 Available: A vector of length m indicates the number of 1. Let Work and Finish be vectors of length m and n, respectively
available resources of each type Initialize:
 Allocation: An n x m matrix defines the number of resources (a) Work = Available
of each type currently allocated to each process
(b) For i = 1,2, …, n, if Allocationi  0, then
 Request: An n x m matrix indicates the current request of
Finish[i] = false; otherwise, Finish[i] = true
each process. If Request [i][j] = k, then process Pi is
requesting k more instances of resource type Rj.
2. Find an index i such that both:
(a) Finish[i] == false
(b) Requesti  Work

If no such i exists, go to step 4

Operating System Concepts – 9th Edition 7.37 Silberschatz, Galvin and Gagne ©2013 Operating System Concepts – 9th Edition 7.38 Silberschatz, Galvin and Gagne ©2013

Detection Algorithm (Cont.) Example of Detection Algorithm

3. Work = Work + Allocationi  Five processes P0 through P4; three resource types
Finish[i] = true A (7 instances), B (2 instances), and C (6 instances)
go to step 2

 Snapshot at time T0:

4. 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 Allocation Request Available
deadlocked
ABC ABC ABC
P0 010 000 000

Algorithm requires an order of O(m x n2) operations to detect P1 200 202

whether the system is in deadlocked state P2 303 000
P3 211 100
P4 002 002

 Sequence <P0, P2, P3, P1, P4> will result in Finish[i] = true for all i

Operating System Concepts – 9th Edition 7.39 Silberschatz, Galvin and Gagne ©2013 Operating System Concepts – 9th Edition 7.40 Silberschatz, Galvin and Gagne ©2013
 Example (Cont.) Detection-Algorithm Usage
 When, and how often, to invoke depends on:
 P2 requests an additional instance of type C
 How often a deadlock is likely to occur?
Request
 How many processes will need to be rolled back?
ABC
 one for each disjoint cycle
P0 000
P1 202  If detection algorithm is invoked arbitrarily, there may be many
P2 001 cycles in the resource graph and so we would not be able to tell
which of the many deadlocked processes “caused” the deadlock.
P3 100
P4 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

Operating System Concepts – 9th Edition 7.41 Silberschatz, Galvin and Gagne ©2013 Operating System Concepts – 9th Edition 7.42 Silberschatz, Galvin and Gagne ©2013

Recovery from Deadlock: Process Termination Recovery from Deadlock: Resource Preemption

 Abort all deadlocked processes  Selecting a victim – minimize cost

 Abort one process at a time until the deadlock cycle is eliminated  Rollback – return to some safe state, restart process for that
state
 In which order should we choose to abort?
1. Priority of the process  Starvation – same process may always be picked as victim,
include number of rollback in cost factor
2. How long process has computed, and how much longer to
completion
3. Resources the process has used
4. Resources process needs to complete
5. How many processes will need to be terminated
6. Is process interactive or batch?

Operating System Concepts – 9th Edition 7.43 Silberschatz, Galvin and Gagne ©2013 Operating System Concepts – 9th Edition 7.44 Silberschatz, Galvin and Gagne ©2013
 End of Chapter 7

Operating System Concepts – 9th Edition Silberschatz, Galvin and Gagne ©2013