UNIT-4

Part 1 - Deadlocks: Resources, Conditions for resource deadlocks, Ostrich algorithm, Deadlock detection
and recovery, Deadlock avoidance, Deadlock prevention.

Resource:
A resource can be a piece of hardware such as tape drive, disk drive ,printer etc. or a piece of information such as a file ,a
record within a file ,a shared variable ,a critical section etc.
Resources come in two types:
• Preemptable
• Nonpreemptable.
A Preemptable resource is one which can be allocated to a given process for a period of time, then be allocated to another
process and then be reallocated to the first process without any ill effects. Examples of preemptable resources include
memory, buffers, CPU, array processor, etc.
A Nonpreemptable resource cannot be taken from one process and given to another without side effects. One obvious
example is a printer: certainly we would not want to take the printer away from one process and give it to another in the
middle of a print job.
Under the normal mode of operation, a process may utilize a resource in only the following sequence:
• Request. The process requests the resource. If the request cannot be granted immediately (for example, if the
resource is being used by another process), then the requesting process must wait until it can acquire the resource.
• Use. The process can operate on the resource (for example, if the resource is a printer, the process can print on the
printer).
• Release. The process releases the resource.

Deadlock:
• In a multiprogramming environment, several processes
may compete for a finite number of resources.
• A process requests resources; if the resources are not
available at that time, the process enters a waiting state.
Sometimes, a waiting process is never again able to change
state, because the resources it has requested are held by
other waiting processes. This situation is called a deadlock.

Deadlock Characterization:
In a deadlock, processes never finish executing, and system resources are tied up, preventing other jobs from starting.
• Necessary Conditions:
• A deadlock situation can arise if the following four conditions are true
• 1.Mutual Exclusion
• 2. Hold and wait
• 3.No preemption
• 4. Circular wait.
• Mutual exclusion : At least one resource must be held in a non-sharable mode; that is, only one process at a time can use
the resource. If another process requests that resource, the requesting process must be delayed until the resource has
been released.
• No preemption : Resources cannot be preempted; that is, a resource can be released only voluntarily by the process
holding it, after that process has completed its task.
• Hold and wait: A process must be holding at least one resource and waiting to acquire additional resources that are
currently being held by other processes.
• Circular wait: A set {P0, P1, ..., Pn} of waiting processes must exist such that P0 is waiting for a resource held by P1, P1 is
waiting for a resource held by P2, ..., Pn−1 is waiting for a resource held by Pn, and Pn is waiting for a resource held by
P0.

If any condition fails there is no deadlock

UNIT-3 OPERATING SYSTEMS CSE-AIML, ACOE Page 1

Resource-Allocation Graph
Deadlocks can be described in terms of a directed graph called a system resource-allocation graph.
This graph consists of a set of vertices V and a set of edges E.
The set of vertices V is partitioned into two different types of nodes:
P = {P1, P2, ..., Pn}, the set consisting of all the active processes in the system
R = {R1, R2, ..., Rm}, the set consisting of all resource types in the system.
Request Edge
A directed edge from process Pi to resource type Rj is denoted by Pi → Rj ; it signifies that process Pi has requested
an instance of resource type Rj and is currently waiting for that resource.
Assignment Edge:
A directed edge from resource type Rj to process Pi is denoted by Rj → Pi ; it signifies that an instance of resource
type Rj has been allocated to process Pi .

Process are represented using circle

Resources are denoted using rectangle. Since resource type Rj may have more than one instance,
we represent each such instance as a dot within the rectangle.

The sets P, R, and E:

◦ P = {P1, P2, P3}
◦ R = {R1, R2, R3, R4}
◦ E = {P1 → R1, P2 → R3, R1 → P2, R2 → P2, R2 → P1, R3 → P3}
Resource instances:
◦ One instance of resource type R1
◦ Two instances of resource type R2
◦ One instance of resource type R3
◦ Three instances of resource type R4
Process states:
◦ Process P1 is holding an instance of resource type R2 and is waiting for an
instance of resource type R1.
◦ Process P2 is holding an instance of R1 and an instance of R2 and is waiting for
an instance of R3. Resource Allocation Graph
◦ Process P3 is holding an instance of R3.

• If the graph contains no cycles, then no process in the system is deadlocked.

• If the graph does contain a cycle, then a deadlock may exist.
• At this point, two minimal cycles exist in the system:
• P1 → R1 → P2 → R3 → P3 → R2 → P1
• P2 → R3 → P3 → R2 → P2
• Processes P1, P2, and P3 are deadlocked.
Resource-allocation graph
with a deadlock.
• However, there is no deadlock because that process P4 may release its
instance of resource type R2. That resource can then be allocated to P3,
breaking the cycle.

• If a resource-allocation graph does not have a cycle, then the

system is not in a deadlocked state.
• If there is a cycle, then the system may or may not be in a
deadlocked state.

UNIT-3 OPERATING SYSTEMS CSE-AIML, ACOE Page 2

Methods for Handling Deadlocks
• We can deal with the deadlock problem in one of three ways:
– 1)We can use a protocol to prevent or avoid deadlocks, ensuring that the system will never enter
a deadlocked state.
– 2)We can allow the system to enter a deadlocked state, detect it, and recover.
– 3)We can ignore the problem altogether and pretend that deadlocks never occur in the system.

1) To ensure that deadlocks never occur, the system can use either a deadlock prevention or a deadlock
avoidance scheme.
Deadlock prevention provides a set of methods for ensuring that at least one of the necessary conditions cannot
hold:
1. Mutual Exclusion
2. Hold and wait
3.No preemption
4.Circular wait.
Deadlock avoidance requires that the operating system be given additional information in advance concerning
which resources a process will request and use during its lifetime. With this additional knowledge, the operating
system can decide for each request whether or not the process should wait.

2) If a system does not employ either a deadlock-prevention or a deadlock avoidance algorithm, then a deadlock
situation may arise.
– In this environment, the system can provide an algorithm that examines the state of the system to
determine whether a deadlock has occurred and an algorithm to recover from the deadlock (if a
deadlock has indeed occurred).

3) If a system neither ensures that a deadlock will never occur nor provides a mechanism for deadlock detection
and recovery then, we may arrive at a situation in which the system is in a deadlocked state yet has no way of
recognizing what has happened.

– In this case, the undetected deadlock will cause the system’s performance to deteriorate, because
resources are being held by processes that cannot run and because more and more processes, as
they make requests for resources, will enter a deadlocked state.

Eventually, the system will stop functioning and will need to be restarted manually.

Deadlock Prevention:
For a deadlock to occur, each of the four necessary conditions must hold.
• 1.Mutual Exclusion
• 2. Hold and wait
• 3.No preemption
• 4.Circular wait.
Mutual Exclusion
• The mutual exclusion condition must hold for at least one resource must be non-sharable.
• Example: A printer cannot be simultaneously shared by several process
• Sharable resources, in contrast, do not require mutually exclusive access and thus cannot be involved in a
deadlock.
• Example :Read-only files are a good example of a sharable resource. If several processes
attempt to open a read-only file at the same time, they can be granted simultaneous access
to the file.

UNIT-3 OPERATING SYSTEMS CSE-AIML, ACOE Page 3

Hold and Wait:
• To ensure that the hold-and-wait condition never occurs in the system, whenever a process requests a
resource, it does not hold any other resources.
• One protocol that is each process to request and be allocated all its resources before it begins execution
– An alternative protocol allows a process to request resources only when it has none. A process
may request some resources and use them. Before it can request any additional resources, it must
release all the resources that it is currently allocated.
Both these protocols have two main disadvantage:
1. Resource utilization may be low.
2.Starvation is possible

No Preemption:
To ensure that this condition does not hold, we can use the following protocol.
• If a process is holding some resources and requests another resource that cannot be immediately
allocated to it, then all resources the process is currently holding are preempted.
• Alternatively, if a process requests some resources, we first check whether they are available. If they are,
we allocate them. If they are not, we check whether they are allocated to some other process that is
waiting for additional resources. If so, we preempt the desired resources from the waiting process and
allocate them to the requesting process.
• Example: This protocol is often applied to resources whose state can be easily saved and restored later,
such as CPU registers and memory space. It cannot generally be applied to such resources as printers and
tape drivers

Circular Wait:
Way to ensure that this condition never holds is to impose a total ordering of all resource types and to require
that each process requests resources in an increasing order of enumeration.
• Example: Suppose Process P1 is allocated Resources R5.Now if P1 requests for Resources R4 and
R3(which are lesser than R5) such requests will not be granted. Only request for resource greater than R5
will be granted
Developing an ordering, or hierarchy, in itself does not prevent deadlock. It is up to application developers to
write programs that follow the ordering

Deadlock Avoidance
• An alternative method for avoiding deadlocks is to require additional information about how resources
are to be requested.
• With this knowledge of the complete sequence of requests and releases for each process, the system can
decide for each request whether or not the process should wait in order to avoid a possible future
deadlock.
Safe State:
• A state is safe if the system can allocate resources to each process (up to its
maximum) in some order and still avoid a deadlock.
• A system is in a safe state only if there exists a safe sequence.
• A safe state is not a deadlocked state. Conversely, a deadlocked state is an
unsafe state. Not all unsafe states are deadlocks.
• An unsafe state may lead to a deadlock. As long as the state is safe, the
operating system can avoid unsafe (and deadlocked) states.
• Example:
Safe, unsafe, and
• We consider a system with twelve magnetic tape drives and three deadlocked state spaces.
processes: P0, P1, and P2.

UNIT-3 OPERATING SYSTEMS CSE-AIML, ACOE Page 4

Scenario 1:
• At time t0, the system is in a safe state. The sequence <P1, P0, P2> satisfies the safety condition.
• Total tape drives are free:12-9=3
• Now we allocate the 2 tape drives to P1 so it can complete executes. After completion of P1. P0 need 5
tape drives…so we allocate. So it can complete it executes. After 10 tape drives are free so 7 can be
allocate to P2 .
Scenario 2:
• A system can go from a safe state to an unsafe state. Suppose that at time t1 process P2 requests and is
allocated one more tape drive.
• The system is no longer in safe state

Resource-Allocation-Graph Algorithm :

Claim Edge:
• A claim edge Pi → Rj indicates that process Pi may request resource Rj at some time
in the future.
• It resembles a request edge in direction but is represented in the graph by a
dashed line
• When process Pi requests resource Rj , the claim edge Pi → Rj is converted to Resource-allocation graph
a request edge. for deadlock avoidance.
• Similarly, when a resource Rj is released by Pi , the assignment edge Rj → Pi
is reconverted to a claim edge Pi → Rj .
The resources must be claimed a priori in the system.
• If no cycle exists, then the allocation of the resource will leave the system in a
safe state.
• If a cycle is found, then the allocation will put the system in an unsafe state.

Unsafe state.
Banker’s Algorithm:
• An algorithm that can be used for Deadlock Avoidance in resource allocation Systems with multiple
instances of each resources type.
• It is given the name Banker’s algorithm because the name was chosen because the algorithm could be
used in a banking system to ensure that the bank never allocated its available cash in such a way that it
could no longer satisfy the needs of all its customers
Data structures must be maintained to implement the banker’s algorithm.
Let , n is the number of processes in the system and m is the number of resource types:
• Available: A 1-D array of size ‘m’ indicates the number of available resources of each type.
• If Available[j] = k, then k instances of resource type Rj are available.
• Max: An n × m matrix defines the maximum demand of each process.
• If Max[i][j] = k, then process Pi may request at most k instances of resource type Rj .
• Allocation: An n × m matrix defines the number of resources of each type currently allocated to each
process.
• If Allocation[i][j] = k, then process Pi is currently allocated k instances of resource type Rj .
• Need. An n × m matrix indicates the remaining resource need of each process.
• If Need[i][j] = k, then process Pi may need k more instances of resource type Rj to complete its task.
Note that Need[i][j] equalsMax[i][j] − Allocation[i][j].

UNIT-3 OPERATING SYSTEMS CSE-AIML, ACOE Page 5

Safety Algorithm
Let Work and Finish be vectors of length m and n, respectively. Initialize
1. Work = Available
Finish[i] = false for i = 0, 1, ..., n − 1.
2. Find an index i such that both
a. Finish[i] == false
b. Need i ≤Work
If no such i exists, go to step 4.
3. Work =Work + Allocation i
Finish[i] = true
Go to step 2.
4. If Finish[i] == true for all i, then the system is in a safe state.
• The vector Allocation i specifies the resources currently allocated to process Pi ;
• the vector Need i specifies the additional resources that process Pi may still request to complete its task.

An Illustrative Example-banker’s algorithm

Consider a system with five processes P0 through P4 and three resource types A, B, and C. Resource type A has 10
instances, resource type B has 5 instances, and resource type C has 7 instances.

Resource-Request Algorithm
Algorithm for determining whether requests can be safely granted or not .It is the extension safety Algorithm
1. If Request i ≤Need i , go to step 2.
Otherwise, raise an error condition, since the process has exceeded it maximum claim.
2. If Request i ≤ Available, go to step 3.
Otherwise, Pi must wait, since the resources are not available.
3. Have the system pretend to have allocated the requested resources to process Pi by modifying the state as
follows:
Available = Available–Request i ;
Allocation i = Allocation i + Request i ;
Need i = Need i –Request i ;

UNIT-3 OPERATING SYSTEMS CSE-AIML, ACOE Page 6

Example for Resource Request Algorithm
• Suppose now that process P1 requests one additional instance of resource type A and two instances of
resource type C, so Request1 = (1,0,2). What will happen if process P 1 requests one additional instance of
resource type A and two instances of resource type C?

• We must determine whether this new system state is safe. To do so, we again execute Safety algorithm on the
above data structures.

Deadlock Detection:
For Single Instance of Each Resource Type:
• Single Instance of Each Resource Type.
• If all resources have only a single instance, then we can define a deadlock detection algorithm that uses a
variant of the resource-allocation graph, called a wait-for graph.
• We obtain this graph from the resource-allocation graph by removing the resource nodes and collapsing
the appropriate edges.
• In a wait for Graph:
– An edge from Pi to Pj indicates that Pi is waiting for Pj to release a resource that is needed by Pi
– In a Resource-Allocation graph,the same would be denoted as PiRk, and RkPi

UNIT-3 OPERATING SYSTEMS CSE-AIML, ACOE Page 7

 Deadlock exists in the
system if and only if
the wait-for graph
contains a cycle

(a) Resource-allocation graph. (b) Corresponding wait-for graph.

Multiple Instances of a Resource Type

• The wait-for graph scheme is not applicable to a resource-allocation system with multiple instances of
each resource type.
• We turn now to a deadlock detection algorithm that is applicable to such a system. The algorithm
employs several time-varying data structures that are similar to those used in the banker’s algorithm
• Available: A vector of length m indicates the number of available resources of each type.
• Allocation: An n × m matrix defines the number of resources of each type currently allocated to each
process.
• Request: An n × m matrix indicates the current request of each process.
• If Request[i][j] equals k, then process Pi is requesting k more instances of resource type Rj .

Algorithm- for Multiple Instances of a Resource Type

1. LetWork and Finish be vectors of length m and n, respectively. Initialize
Work = Available.
Finish[i] = false if Allocation i != 0, then
Finish[i] = true if Allocation i = 0, then
2. Find an index i such that both
a. Finish[i] == false
b. Request i ≤Work
If no such i exists, go to step 4.
3. Work =Work + Allocation i
Finish[i] = true
Go to step 2.
4. If Finish[i] ==false for some i, 0≤i<n, then the system is in a deadlocked state.
Moreover, if Finish[i] == false, then process Pi is deadlocked.
Example:
• Consider a system with five processes P0 through P4 and three resource types A, B, and C. Resource type A
has seven instances, resource type B has two instances, and resource type C has six instances. Suppose that,
at time T0, we have the following resource-allocation state:

Safe sequence <P0, P2, P3, P1, P4>

results in Finish[i] == true for all i.

Solution:
• In this, Work = [0, 0, 0] &
Finish = [false, false, false, false, false]

• i=0 is selected as both Finish[0] = false and [0, 0, 0]<=[0, 0, 0].

Work =[0, 0, 0]+[0, 1, 0] =>[0, 1, 0] &
Finish = [true, false, false, false, false].

UNIT-3 OPERATING SYSTEMS CSE-AIML, ACOE Page 8

 • i=2 is selected as both Finish[2] = false and [0, 0, 0]<=[0, 1, 0].
• Work =[0, 1, 0]+[3, 0, 3] =>[3, 1, 3] &
Finish = [true, false, true, false, false].
• i=1 is selected as both Finish[1] = false and [2, 0, 2]<=[3, 1, 3].
• Work =[3, 1, 3]+[2, 0, 0] =>[5, 1, 3] &
Finish = [true, true, true, false, false].
• i=3 is selected as both Finish[3] = false and [1, 0, 0]<=[5, 1, 3].
• Work =[5, 1, 3]+[2, 1, 1] =>[7, 2, 4] &
Finish = [true, true, true, true, false].
• i=4 is selected as both Finish[4] = false and [0, 0, 2]<=[7, 2, 4].
• Work =[7, 2, 4]+[0, 0, 2] =>[7, 2, 6] &
Finish = [true, true, true, true, true].
• Since Finish is a vector of all true it means there is no deadlock in this example

Recovery from Deadlock

What to do when a deadlock detection algorithm determines that a deadlock exists?
– 1. One possibility is to inform the operator that a deadlock has occurred and to let the operator
deal with the deadlock manually.
– 2. Second possibility let the system recover from the deadlock automatically.
There are two options for breaking a deadlock.
– One is simply to abort one or more processes to break the circular wait.
– The other is to preempt some resources from one or more of the deadlocked processes.
Process Termination:
To eliminate deadlocks by aborting a process, we use one of two methods.
• Abort all deadlocked processes.
– This method clearly will break the deadlock cycle, but at great expense. The deadlocked processes
may have computed for a long time, and the results of these partial computations must be
discarded.
• Abort one process at a time until the deadlock cycle is eliminated.
– A deadlock-detection algorithm must be invoked to determine whether any processes are still
deadlocked.
– Aborting a process may not be easy. If the process was in the midst of updating a file,
terminating it will leave that file in an incorrect state.f the process was in the midst of printing
data on a printer, the system must reset the printer to a correct state before printing the next job.
we should abort those processes whose termination will incur the minimum cost
Many factors may affect which process is chosen, including:
1. What the priority of the process is
2. How long the process has computed and how much longer the process will compute before completing its
designated task
3. How many and what types of resources the process has used (for example, whether the resources are
simple to preempt)
4. How many more resources the process needs in order to complete
5. How many processes will need to be terminated?
6. Whether the process is interactive or batch
Resource Preemption
• we successively preempt some resources from processes and give these resources to other processes
until the deadlock cycle is broken.
• If preemption is required to deal with deadlocks, then three issues need to be addressed:
– Selecting a victim.
– Rollback.
– Starvation.

UNIT-3 OPERATING SYSTEMS CSE-AIML, ACOE Page 9

 • Selecting a victim - Deciding which resources to preempt from which processes involves many of the
same decision criteria outlined above.
• Rollback - Ideally one would like to roll back a preempted process to a safe state prior to the point at
which that resource was originally allocated to the process. Unfortunately it can be difficult or impossible
to determine what such a safe state is, and so the only safe rollback is to roll back all the way back to the
beginning. ( I.e. abort the process and make it start over. )
• Starvation - How do you guarantee that a process won't starve because its resources are constantly
being preempted? One option would be to use a priority system, and increase the priority of a process
every time its resources get preempted. Eventually it should get a high enough priority that it won't get
preempted any more.

Ostrich Algorithm
• Deadlock Ignorance is also called as Ostrich Algorithm
• This algorithm is a well-used method to ignore problems. It gets its name
from The Ostrich and the way it sticks its head in the sand and ignores
everything that’s happening around just as the picture below shows
• Scientists all over the world believe that the most efficient method to
deal with deadlock is deadlock prevention.
• But the Engineers that deal with the system believe that deadlock
prevention should be paid less attention as there are very less chances for deadlock occurrence.
• System failure, compiler error, programming bugs, hardware crashes that occur once a week should be
paid more attention rather than deadlock problem that occur once in years.
• Therefore most of the engineers don’t pay much amount in eliminating the deadlock.
Pros of ignorance in deadlocks?
• No manpower is required to do any extra work. When the system crashes, just restart it. This is viable
only when a deadlock occurs rarely. If a computer is having deadlock once per 10 years then rebooting
the system is more preferred than pre
Cons of ignorance in deadlocks?
• If it happens quite often, then this is not an optimal solution. You’ll have to invest some time in properly
dealing with deadlocks, that’s any of the next three methods mentioned above in prevention of deadlock.

UNIT-3 OPERATING SYSTEMS CSE-AIML, ACOE Page 10