OPERATING SYSTEMS

Unit-3 DEADLOCKS

Dr. B. Rebecca
Department of Computer Science and
Engineering(Data Science)
 Deadlocks
• The Deadlock Problem

• System Model

• Deadlock Characterization

• Methods for Handling Deadlocks

• Deadlock Prevention
• Deadlock Avoidance

• Deadlock Detection
• Recovery from Deadlock
 The Deadlock Problem

• A set of blocked processes each holding a resource and

waiting to acquire a resource held by another process in
the set.
• Example
– System has 2 disk drives.
– P1 and P2 each hold one disk drive and each needs
another one.
• Example
– semaphores A and B, initialized to 1
P0 P1
wait (A); wait(B)
wait (B); wait(A)
 Bridge Crossing Example

• Traffic only in one direction.

• Each section of a bridge can be viewed as a resource.
• If a deadlock occurs, 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.
 System Model

• Resource types R1, R2, . . ., Rm

CPU cycles, memory space, I/O devices
• Each resource type Ri has Wi instances.

• Each process utilizes a resource as follows:

– request
– use
– Release
• Examples:
– Two processes one printer, one DVD drive.
– Two processes and two hard disks
 Deadlock Characterization
eadlock can arise if four conditions hold simultaneously
• Mutual exclusion: only one process at a time can use a
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, …, P0} 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:

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 P1  Rj
• assignment edge – directed edge Rj  Pi
• Process

• Resource Type with 4 instances

• Pi requests instance of Rj

Pi
Rj
• Pi is holding an instance of Rj

Pi
Rj
Example of a Resource Allocation Graph
Resource Allocation Graph With A Deadlock
Graph With A Cycle But No Deadlock
 Methods for Handling Deadlocks

• Use a protocol to avoid deadlock, ensuring that

the system will never enter a deadlock state.

• Allow the system to enter a deadlock state,

detect it, and recover.

• Ignore the problem and pretend that deadlocks

never occur in the system;
– used by most operating systems, including UNIX and
Windows; the application developer to write
programs that handle deadlocks.
 Deadlock Prevention
• We can prevent the occurrence of a deadlock by ensuring that at
least one of four conditions cannot hold.
• Mutual Exclusion
– The mutual-exclusion condition must hold for non-sharable
resources.
– Sharable resources do not require mutual exclusive access and
thus cannot be involved in a deadlock.
• Hold and Wait
– must guarantee that whenever a process requests a resource, it
does not hold any other resources.
– 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.
– Low resource utilization.
– Starvation possible.
• No Preemption

– If a process that is holding some resources, requests another

resource that cannot be immediately allocated to it, then all
resources currently being held are released.

– Preempted resources are added to the list of resources for

which the process is waiting.

– Process will be restarted only when it can regain its old

resources, as well as the new ones that it is requesting.

• Circular Wait

– impose a total ordering of all resource types, and require that

each process requests resources in an increasing order of
enumeration.

– A process can initially request any no. of instances of a resource

Ri ,, after that, it can request a resource Rj if and only if
F(Rj)>F(Ri)
 Deadlock Avoidance
Requires that the system has some additional a priori
information available.

• 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 and allocated resources, and the maximum
demands of the processes.
 Safe State
• When a process requests an available resource, system must
decide if immediate allocation leaves the system in a safe
state.

• A System is in a safe state only if there exists a safe

sequence.
• A sequence of process <P1, P2, …, Pn> is a safe sequence for
the current allocation state if , for each P i, the resource
requests that Pi can still make can be satisfied by currently
available resources + resources held by all the Pj, with j < i.

• 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.
• 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

• Single instance of a resource type. Use a

resource-allocation graph

• Multiple instances of a resource type. Use

the banker’s algorithm
 Resource-Allocation Graph Scheme
• Claim edge Pi  Rj indicated that process Pj may
request resource Rj; at some time in the future,
represented by a dashed line.

• Claim edge converts to request edge when a process

requests a resource.

• Request edge converted to an assignment edge Rj 

Pi 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.

Resource-Allocation Unsafe State In Resource-
Graph Allocation Graph
 Banker’s Algorithm

• Multiple instances.

• Each process must a priori claim maximum use.

• 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.
 1. Data Structures for the Banker’s Algorithm

= number of processes, and m = number of resources ty

• 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].

 2. 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 and i such that both:
(a) Finish [i] = false
(b) 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.
• The content of the matrix Need is defined to be Max –
Allocation.

Need
ABC
P0 743
P1 122
P2 600
P3 011
P4 431

• The system is in a safe state since the sequence < P1,

P3, P4, P2, P0> satisfies safety criteria.
 Example of Banker’s Algorithm

• 5 processes P0 through P4;

3 resource types:
A (10 instances), B (5instances), and C (7
instances).
• Snapshot at time T0:
Allocation Max Available
ABC ABC ABC
P0 010 753 332
P1 200 322
P2 302 902
P3 211 222
P4 002 433
 Example: P1 Request (1,0,2)

• Check that Request  Available (that is, (1,0,2)  (3,3,2)

 true.
Allocation Need Available
ABC ABC ABC
P0 010 743 230
P1 302 020
P2 301 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?
 Deadlock Detection
• Allow system to enter deadlock state

• Detection algorithm

• Recovery scheme
 Single Instance of Each Resource Type

• 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 and Wait-for
Graph

Resource-Allocation Graph
Corresponding wait-for graph
 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:
(a) Work = Available
(b) For i = 1,2, …, n, if Allocationi  0, then
Finish[i] = false;otherwise, Finish[i] = true.
2. Find an index i such that both:
(a) Finish[i] == false
(b) 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. Moreover, if Finish[i] == false, then Pi is deadlocked.
Algorithm requires an order of O(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 (7 instances), B (2 instances), and C (6 instances).
• Snapshot at time T0:
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.
• P2 requests an additional instance of type C.
Request
ABC
P0 000
P1 201
P2 001
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.
 Recovery from Deadlock: 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 from Deadlock: 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.