Operating System Deadlock

B.Tech – CS 2nd Year Operating System (KCS- 401) Dr. Pankaj Kumar
Operating System
KCS – 401
Deadlock
Dr. Pankaj Kumar
Associate Professor – CSE
SRMGPC Lucknow

Outline of the Lecture
System Model
Deadlock Characterization
Methods for Handling Deadlocks
Deadlock Prevention
Deadlock Avoidance
Deadlock Detection
Recovery from Deadlock

System Model
System consists of finite no of resources to be distributed among a number of competing process.
Resources are partitioned into several R1, R2, . . ., Rm consisting number of identical instances.
CPU cycles, memory space, I/O devices (such as printers…)
Each resource type Ri has Wi instances.
Each process utilizes a resource as follows:
request
use
release

Basic Concept - Deadlock
Deadlock is a situation where a set of processes are blocked because each process is holding a
resource and waiting for another resource acquired by some other process.
or
A deadlock happens in operating system when two or more processes need some resource to
complete their execution that is held by the other process.

Deadlock Characterisation
Deadlock can arise if four conditions hold simultaneously.
Mutual exclusion: only one process at a time can use a resource. In the diagram below, there is
a single instance of Resource 1 and it is held by Process 1 only.
Hold and wait: a process holding at least one resource is waiting to acquire additional resources
held by other processes. Process 2 holds Resource 2 and Resource 3 and is requesting the
Resource 1 which is held by Process 1.

No preemption: a resource can be released only voluntarily by the process holding it, after that
process has completed its task. In the diagram below, Process 2 cannot preempt Resource 1 from
Process 1. It will only be released when Process 1 relinquishes it voluntarily after its execution is
complete.
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
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

Resource-Allocation Graph with
Deadlock
Resource-Allocation Graph with
no Deadlock
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

Methods for Handling Deadlocks
To ensure that the system will never enter a deadlock state, the system can use:
Deadlock prevention
Deadlock avoidance
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
Deadlock Prevention is s a set of method for ensuring that at least one of the necessary condition
can not hold.
Mutual Exclusion – not required for sharable resources (e.g., read-only files); must hold for non-
sharable resources
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 allocated to it.
Low resource utilization; starvation possible

Deadlock Prevention
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

Deadlock Avoidance
The deadlock Avoidance method is used by the operating system in order to check whether the
system is in a safe state or in an unsafe state and in order to avoid the deadlocks, the process
must need to tell the operating system about the maximum number of resources a process can
request in order to complete its execution.
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

Deadlock Avoidance
Safe State
A state is safe if the system can allocate resources to each process( up to its maximum
requirement) in some order and still avoid a deadlock. Formally, a system is in a safe state only, if
there exists a safe sequence.
System is in safe state if there exists a sequence <P1, P2, …, Pn> of ALL the 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
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

Deadlock Avoidance
In an Unsafe state, the operating system cannot prevent processes from requesting resources in
such a way that any deadlock occurs. It is not necessary that all unsafe states are deadlocks; an
unsafe state may lead to a deadlock.
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
DEADLOCK
UNSAFE
Only with luck will processes
avoid deadlock.
O.S. can avoid
deadlock.

Deadlock Avoidance
Let's assume a very simple model: each process declares its maximum needs. In this case,
algorithms exist that will ensure that no unsafe state is reached.
EXAMPLE:
There exists a total of 12 tape drives. The current state looks like this:
So at time t0, the system is in a safe state. The sequence is
<P2,P1,P3> satisfies the safety condition. Process P2 can
immediately be allocated all its tape drives and then return
them. After the return the system will have 5 available tapes,
then process P1 can get all its tapes and return them ( the
system will then have 10 tapes); finally, process P3 can get all
its tapes and return them (The system will then have 12
available tapes).
Process Max Needs Allocated Current
Needs
P0 10 5 5
P1 4 2 2
P2 9 2 7
Suppose p2 requests and is given one more tape
drive. What happens then???????????

Deadlock Avoidance
Banker’s Algorithm
Banker's algorithm is a deadlock avoidance algorithm. It is named so because this algorithm is
used in banking systems to determine whether a loan can be granted or not.
The bank would never allocate its money in such a way that it can no longer satisfy the needs of
all its customers. The bank would try to be in safe state always.
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

Data Structure for Banker’s Algorithm
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]
Let n = number of processes, and m = number of resources types.

Safety Algorithm
1) Let Work and Finish be vectors of length ‘m’ and ‘n’ respectively.
Initialize: Work = Available
Finish[i] = false; for i=1, 2, 3, 4….n
2) Find an i such that both
a) Finish[i] = false
b) Needi <= Work
if no such i exists goto step (4)
3) Work = Work + Allocation[i]
Finish[i] = true
goto step (2)
4) if Finish [i] = true for all i then the system is in a safe state

Resource Request Algorithm
Requesti = request vector for process Pi. If Requesti [j] = k then process Pi wants k instances of
resource type Rj
1. If Requesti  Needi go to step 2. Otherwise, raise error condition, since process has exceeded
its maximum claim
2. If Requesti  Available, go to step 3. Otherwise Pi must wait, since resources are not available
3. Pretend to allocate requested resources to Pi by modifying the state as follows:
Available = Available – Requesti;
Allocationi = Allocationi + Requesti;
Needi = Needi – Requesti;
• If safe  the resources are allocated to Pi
• If unsafe  Pi must wait, and the old resource-allocation state is restored

Example
Considering a system with five processes P0 through P4 and three resources of type A, B, C.
Resource type A has 10 instances, B has 5 instances and type C has 7 instances. Suppose at time
t0 following snapshot of the system has been taken:
1.What is the reference of the need matrix?
2.Determine if the system is safe or not.
3.What will happen if the resource request (1, 0, 0) for process P1 can the system accept this
request immediately?

Resource A B C
Instance 10 5 7
Total Allocation 7 2 5
Available 3 3 2
Snapshot at time T0:
Need [i] = Max [i] - Allocation [i]
Need for P0: (7, 5, 3) - (0, 1, 0) = 7, 4, 3
Need for P1: (3, 2, 2) - (2, 0, 0) = 1, 2, 2
Need for P2: (9, 0, 2) - (3, 0, 2) = 6, 0, 0
Need for P3: (2, 2, 2) - (2, 1, 1) = 0, 1, 1
Need for P4: (4, 3, 3) - (0, 0, 2) = 4, 3, 1
For Process P1:
Need <= work
1, 2, 2 <= 3, 3, 2 condition true
New work = work + Allocation
(3, 3, 2) + (2, 0, 0) => 5, 3, 2
Finish(1) = true
Work = available = 3 3 2
Finish(i) = false for i=0,1,2,3,4
For Process P3:
Need <= work
0, 1, 1 <= 5, 3, 2 condition true
(5, 3, 2) + (2, 1, 1) => 7, 4, 3
Finish(3) = true
For Process P4:
Need <= work
4, 3, 1 <= 7, 4, 3 condition true
(7, 4, 3) + (0, 0, 2) => 7, 4, 5
Finish(4) = true
For Process P0:
Need <= work
7, 4, 3 <= 7, 4, 5 condition true
(7, 4, 5) + (0, 1, 0) => 7, 5, 5
Finish(0) = true
For Process P2:
Need <= work
6, 0, 0 <= 7, 5, 5 condition true
(7, 5, 5) + (3, 0, 2) => 10, 5, 7
Finish(2) = true
safe state and the safe sequence is P1 P3 P4 P0 P2

What will happen if the resource request (1, 0, 0) for process P1
can the system accept this request immediately?
For granting the Request (1, 0, 0),
first we have to check that Request <= Available, that is (1, 0, 0) <= (3, 3, 2), since the
condition is true. So the process P1 gets the request immediately.
Resource A B C
Instance 10 5 7
Total Allocation 7 2 5
Available 3 3 2

Operating System Deadlock

More Related Content

Similar to Operating System Deadlock (20)

More from Shri Ram Swaroop Memorial College of Engineering & Management (18)

Recently uploaded (20)

Operating System Deadlock