Submitted By: Submitted to:-

Narender Kumar Mr. Saoud Sarwar

(MTC/10/16) (HOD,CSE)
MTech(CSE-2sem)
Deadlock Definition

A set of processes is deadlocked if each process in the set is waiting for an event
that only another process in the set can cause (including itself).

Waiting for an event could be:

• waiting for access to a critical section

• waiting for a resource Note that it is usually a non-preemptable (resource).
pre-emptable resources can be yanked away and given to another.

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
o System has 2 disk drives.
o P1 and P2 each hold one disk drive and each needs another one.
• Example
o 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:
o request
o use
o release

Conditions for Deadlock

• Mutual exclusion: resources cannot be shared.

• Hold and wait: processes request resources incrementally, and hold on
to what they've got.
• No preemption: resources cannot be forcibly taken from processes.
• Circular wait: circular chain of waiting, in which each process is waiting
for a resource held by the next process in the chain.

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.
• request edge – directed edge P1 → Rj
 • assignment edge – directed edge Rj → Pi

Resource-Allocation Graph (Cont.)

• Process

• Resource Type with 4 instances

....

• Pi requests instance of Rj

....

• Pi is holding an instance of Rj

....
Example of a Resource Allocation Graph
Resource Allocation Graph With A Deadlock
Graph With A Cycle But No Deadlock

• 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.
 Methods for Handling Deadlocks

• Ensure that the system will never enter a deadlock state.

• Allow the system to enter a deadlock state and then recover.
• Ignore the problem and pretend that deadlocks never occur in the
system; used by most operating systems, including UNIX.

Deadlock Prevention

Difference from avoidance is that here, the system itself is build in such a way
that there are no deadlocks.

Make sure atleast one of the 4 deadlock conditions is never satisfied.

This may however be even more conservative than deadlock avoidance strategy.

• Attacking Mutex condition

o never grant exclusive access. but this may not be possible for
several resources.
• Attacking preemption
o not something you want to do.
• Attacking hold and wait condition
o make a process hold at the most 1 resource at a time.
o make all the requests at the beginning. All or nothing policy. If you
feel, retry. eg. 2-phase locking
• Attacking circular wait
o Order all the resources.
o Make sure that the requests are issued in the correct order so that
there are no cycles present in the resource graph.

Resources numbered 1 ... n. Resources can be requested only in

increasing order. ie. you cannot request a resource whose no is
less than any you may be holding.
Deadlock Avoidance

Avoid actions that may lead to a deadlock.

Think of it as a state machine moving from 1 state to another as each

instruction is executed.

Safe State

Safe state is one where

o It is not a deadlocked state

o There is some sequence by which all requests can be satisfied.

To avoid deadlocks, we try to make only those transitions that will take
you from one safe state to another. We avoid transitions to unsafe state (a
state that is not deadlocked, and is not safe)

eg.
Total # of instances of resource = 12
(Max, Allocated, Still Needs)
P0 (10, 5, 5) P1 (4, 2, 2) P2 (9, 2, 7) Free = 3
- Safe
The sequence is a reducible sequence
the first state is safe.

What if P2 requests 1 more and is allocated 1 more

instance?
- results in Unsafe state

So do not allow P2's request to be satisfied.

Banker's Algorithm for Deadlock Avoidance

When a request is made, check to see if after the request is satisfied,

there is a (atleast one!) sequence of moves that can satisfy all the
requests. ie. the new state is safe. If so, satisfy the request, else make the
request wait.

How do you find if a state is safe

n process and m resources

Max[n * m]
Allocated[n * m]
Still_Needs[n * m]
Available[m]
Temp[m]
Done[n]

while ()
{
Temp[j]=Available[j] for all j
Find an i such that
a) Done[i] = False
b) Still_Needs[i,j] <= Temp[j]
if so {
Temp[j] += Allocated[i,j] for all j
Done[i] = TRUE}
}

else if Done[i] = TRUE for all i then state is safe

else state is unsafe

}
Detection and Recovery

Is there a deadlock currently?

One resource of each type (1 printer, 1 plotter, 1 terminal etc.)

o check if there is a cycle in the resource graph. for each node N in

the graph do DFS (depth first search) of the graph with N as the
root In the DFS if you come back to a node already traversed, then
there is a cycle. }

Multiple resources of each type

o m resources, n processes
o Max resources in existence = [E1, E2, E3, .... Em]
o Current Allocation = C1-n,1-m
o Resources currently Available = [A1, A2, ... Am]
o Request matrix = R1-n,1-m
o Invariant = Sum(Cij) + Aj = Ej
o Define A <= B for 2 vectors, A and B, if Ai <= Bi for all i
o Overview of deadlock detection algorithm,

Check R matrix, and find a row i such at Ri < A.

If such a process is found, add Ci to A and remove process i from
the system.
Keep doing this till either you have removed all processes, or you
cannot remove any other process.
Whatever is remaining is deadlocked.

Basic idea, is that there is atleast 1 execution which will undeadlock

the system

Recovery

o through preemption
o rollback
 keep checkpointing periodically
 when a deadlock is detected, see which resource is needed.
 Take away the resource from the process currently having it.
 Later on, you can restart this process from a check pointed
state where it may need to reacquire the resource.
o killing processes
 where possible, kill a process that can be rerun from the
beginning without illeffects