lOMoARcPSD|9721638

KMIT/CSE/II-II/OS-3 P.VAMSHI KRISHNA

UNIT-III
DEADLOCKS
DEADLOCKS
A set of processes is in a Deadlock state when every process in the set is waiting for an event
that can be caused only by another process in the set. The events with which we are mainly
concerned here are resource acquisition and resource release.
SYSTEM MODEL
A system consists of a finite number of resources to be distributed among a number of
competing processes.
Resources are categorized into two types: Physical resources and Logical resources
 Physical resources: Printers, Tape drives, DVD drives, memory space and CPU cycles
 Logical resources: Semaphores, Mutex locks and files.
Each resource type consists of some number of identical instances. (i.e.) If a system has two
CPU’s then the resource type CPU has two instances.
A process may utilize a resource in the following sequence under normal mode of operation:
1. Request: The process requests the resource. If the resource is being used by another
process then the request cannot be granted immediately then the requesting process must
wait until it can acquire the resource.
2. Use: The process can operate on the resource.
Example: If the resource is a printer, the process can print on the printer.
3. Release: The process releases the resource.
System calls for requesting and releasing resources:
 Device System calls: request( ) and release( )
 Semaphore System calls: wait( ), signal( )
 Mutex locks: acquire( ), release( ).
 Memory System Calls: allocate( ) and free( )
 File System calls: open( ), close( ).
A System Table maintains the status of each resource whether the resource is free or
allocated. For each resource that is allocated, the table also records the process to which it is
allocated. If a process requests a resource that is currently allocated to another process, it can
be added to a queue of processes waiting for this resource.
FOUR NECESSARY CONDITIONS OF DEADLOCK
A deadlock situation can arise if the following 4 conditions hold simultaneously in a system:
1. Mutual exclusion. Only one process at a time can use the resource. If other process
requests that resource, the requesting process must be delayed until the resource has been
released.
2. 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.
3. No preemption. If a process holding a resource and the resource cannot be preempted
until the process has completed its task.

90

Downloaded by Kirti Chauhan (kirtic290@gmail.com)

 lOMoARcPSD|9721638

KMIT/CSE/II-II/OS-3 P.VAMSHI KRISHNA

4. 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.
RESOURCE-ALLOCATION GRAPH
The resource allocation graph is used for identification of deadlocks in the system.
A System Resource-Allocation Graph G={V,E} is a directed graph that consists of a set of
vertices V and a set of edges E.
The set of vertices V is partitioned into two types of nodes: Processes and Resources.
1. Process set P= {P1, P2, ..., Pn} consisting of all the active processes in the system.
2. Resource set R= {R1, R2, ..., Rm} consisting of all resource types in the system.
The set of Edges E is divided into types: Request Edge and Assignment Edge.
1. Request Edge (Pi → Rj): It signifies that process Pi has requested an instance of
resource type Rj and Pi is currently waiting for the resource Rj.
2. Assignment edge (Rj → Pi): It signifies that an instance of resource type Rj has been
allocated to process Pi.
Processes can be represented in Circles and Resources can be represented in Rectangles.
Instance of resource can be represented by a Dot.
Note:
1. When process Pi requests an instance of resource type Rj, a request edge is inserted in the
Resource-allocation graph.
2. When this request can be fulfilled, the request edge is transformed to an assignment edge.
3. When the process no longer needs access to the resource, it releases the resource and the
assignment edge is deleted.
Resource allocation graph shows three situations:
1. Graph with No deadlock
2. Graph with a cycle and deadlock
3. Graph with a cycle and no deadlock
Resource Allocation Graph without Deadlock
The below graph consists of three sets: Process P, Resources R and Edges E.

 Process set P= {P1, P2, P3}.

 Resources set R= {R1, R2, R3, R4}.
 Edge set E= E = {P1 → R1, P2 → R3, R1 → P2, R2 → P2, R2 → P1, R3 → P3}.
Resource type R1 and R3 has only one instance and R2 has two instances and R4 has three
instances.

91

Downloaded by Kirti Chauhan (kirtic290@gmail.com)

 lOMoARcPSD|9721638

KMIT/CSE/II-II/OS-3 P.VAMSHI KRISHNA

The Resource Allocation Graph depicts that:

 R2 → P1, P1 → R1: P1 is holding an instance of resource type R2 and is waiting for an
instance of R1.
 R1 → P2, R2 → P2, P2 → R3: Process P2 is holding an instance of R1 and an instance
of R2 and is waiting for an instance of R3.
 R3 → P3: Process P3 is holding an instance of R3.
The above Resource allocation graph does not contain any cycle then there is no process in
the system is deadlocked.
Note:
1. If each resource type has exactly one instance then a cycle implies a deadlock.
2. If each resource type has several instances then a cycle does not necessarily imply that a
deadlock has occurred.
Resource Allocation Graph with a Cycle and Deadlock

Consider the above graph, with processes and Resources and have some edges:
P1 → R1 → P2 → R3 → P3 → R2 → P1
P2 → R3 → P3 → R2 → P2
 Process P2 is waiting for the resource R3, which is held by process P3.
 Process P3 is waiting for either process P1 or process P2 to release resource R2.
 Process P1 is waiting for process P2 to release resource R1.
Hence the Processes P1, P2 and P3 are deadlocked.
Resource Allocation Graph with a Cycle and No Deadlock

The graph has a cycle: P1 → R1 → P3 → R2 → P1.

 This cycle does not lead to deadlock, because the process P4 and P2 is not waiting for any
resource.
 Process P4 may release its instance of resource type R2. That resource can then be
allocated to P3, breaking the cycle.
92

Downloaded by Kirti Chauhan (kirtic290@gmail.com)

 lOMoARcPSD|9721638

KMIT/CSE/II-II/OS-3 P.VAMSHI KRISHNA

METHODS FOR HANDLING DEADLOCKS

The Deadlock can be handled by 3 methods:
1. Deadlock Prevention
2. Deadlock Avoidance
3. Deadlock Detection and Recovery
DEADLOCK PREVENTION
Deadlock prevention provides a set of methods to ensure that at least one of the necessary
conditions cannot hold. (i.e.) Deadlock can be prevented if any of mutual exclusion, Hold and
wait, No preemption and Circular wait condition cannot hold.
Mutual Exclusion
The mutual exclusion condition must hold when at least one resource must be non-sharable.
 We cannot prevent deadlocks by denying the mutual-exclusion condition, because some
resources by default are nonsharable.
Example 1: A mutex lock cannot be simultaneously shared by several processes.
Example 2: Printer is a resource where only one process can use it.
 Sharable resources do not require mutually exclusive access and thus cannot be involved
in a deadlock. Example: Read-only files.
 If several processes attempt to open a read-only file at the same time, they can be granted
simultaneous access to the file. A process never needs to wait for a sharable resource.
Hold and Wait
To ensure that the hold-and-wait condition never occurs in the system, we must guarantee
that, whenever a process requests a resource, it does not hold any other resources.
 Protocol 1: Each process can request the resources and be allocated all its resources
before it begins execution. We can implement this provision by requiring that system
calls requesting resources for a process precede all other system calls.
Example: Consider a process that copies data from a DVD drive to a file on Hard disk,
sorts the file and then prints the results to a Printer.
If all resources must be requested at the beginning of the process, then the process must
initially request the DVD drive, disk file and Printer. It will hold the printer for its entire
execution, even though it needs the printer only at the end.
 Protocol 2: A process can be allowed 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.
Example: Consider a process that copies data from a DVD drive to a file on Hard disk,
sorts the file and then prints the results to a Printer.
The process to request initially only the DVD drive and Hard disk file. It copies from
the DVD drive to the Hard disk and then releases both the DVD drive and the disk file.
The process must then request the Hard disk file and the Printer. After copying the disk
file to the printer, it releases these two resources and terminates.
Problem: Starvation and Low Resource utilization
 Resource utilization is low, since resources may be allocated but unused for a long period.
 A process that needs several resources may have to wait indefinitely leads to starvation.

93

Downloaded by Kirti Chauhan (kirtic290@gmail.com)

 lOMoARcPSD|9721638

KMIT/CSE/II-II/OS-3 P.VAMSHI KRISHNA

No Preemption
To ensure that No preemption 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 (i.e.) resources are implicitly released.
 The preempted resources are added to the list of resources for which the process is
waiting.
 The process will be restarted only when it can regain its old resources as well as the new
resources that it is requesting.
Note: 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 be applied to resources such as
mutex locks and semaphores.
Circular Wait
One way to ensure that circular wait 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.
Consider the set of resource types R={R1, R2, ..., Rm} and N be the set of natural numbers.
we define a one-to-one function F: R → N.
 The function assigns each resource type to a unique integer number, which allows us to
compare two resources and to determine whether one resource precedes another resource
in our ordering.
Example: If the set of resource types R includes tape drives, disk drives and printers, then the
function F: R → N might be defined as follows:
F (Tape drive) = 1 (F: Tape drive → 1)
F (Disk drive) = 5 (F: Disk drive → 1)
F (Printer) = 12 (F: Printer → 1)
We can now consider the following protocol to prevent deadlocks:
 Each process can request resources only in an increasing order of enumeration. That is, a
process can initially request any number of instances of a resource type Ri.
 After that, the process can request instances of resource type Rj iff F(Rj) > F(Ri)
 Example: A process that wants to use the tape drive and printer at the same time must
first request the tape drive and then request the printer.
 Alternatively, we can require that a process requesting an instance of resource type Rj
must have released any resources Ri such that F(Ri) ≥ F(Rj).
Note: If several instances of the same resource type are needed, a single request for all of
them must be issued.
Disadvantage of Deadlock Prevention
Deadlock-prevention algorithms leads to low resource utilization and the system throughput
will be reduced.

94

Downloaded by Kirti Chauhan (kirtic290@gmail.com)

 lOMoARcPSD|9721638

KMIT/CSE/II-II/OS-3 P.VAMSHI KRISHNA

DEADLOCK AVOIDANCE
In Deadlock avoidance the processes first informs the operating system about their maximum
allocation of resources to be requested and used during its life time.
 With this information, the operating system can decide for each request whether the
resource will be granted immediately or the process should wait for resources.
 To take this decision about decision about the resource allocation, the operating system
must consider the resources currently available, the resources currently allocated to each
process and the future requests and releases of each process.
Algorithms for Deadlock Avoidance
A deadlock-avoidance algorithm dynamically examines the Resource-Allocation State to
ensure that a circular-wait condition can never exist.
The Resource Allocation State is defined by the number of available resources and allocated
resources and the maximum demands of the processes.
There are three algorithms are designed for deadlock avoidance:
1. Safe State
2. Resource Allocation Graph Algorithm
3. Bankers Algorithm
Safe State Algorithm
If the system can allocate resources to each process up to its maximum in some order and still
avoid a deadlock then the state is called Safe state.
 A system is in a safe state only if there exists a Safe sequence.
 A sequence of processes <P1, P2, ..., Pn> is a safe sequence for the current allocation
state, if for each process Pi, the resource requests that Pi can still make can be satisfied by
the currently available resources plus the resources held by all Pj, with j < i.
 In this situation, if the resources that Pi needs are not immediately available, then Pi can
wait until all Pj have finished.
 When Pj have finished its task, Pi can obtain all of its needed resources and after
completing its designated task Pi can return its allocated resources and terminate.
 When Pi terminates, Pi+1 can obtain its needed resources and so on.
 If no such sequence exists, then the system state is said to be unsafe.
Note:
1. A safe state is not a deadlocked state and a deadlocked state is an unsafe state.
2. An unsafe state may lead to a deadlock but not all unsafe states are deadlocks.
3. As long as the state is safe, the operating system can avoid unsafe and deadlocked states.
4. In an unsafe state, operating system cannot prevent processes from requesting resources
in such a way that a deadlock occurs. Behavior of the processes controls unsafe states.

95

Downloaded by Kirti Chauhan (kirtic290@gmail.com)

 lOMoARcPSD|9721638

KMIT/CSE/II-II/OS-3 P.VAMSHI KRISHNA

Example: Consider a system with 12 magnetic tape drives and 3 processes: P0, P1 and P2.
Process Maximum Needs Current Needs
P0 10 5
P1 4 2
P2 9 2
The above table describes as follows:
 Process P0 requires 10 tape drives, P1 needs 4 tape drives and P2 need 9 tape drives.
 At time t0, process P0 is holding 5 tape drives, P1 and P2 is holding 2 tape drives each.
 Now there are 3 free tape drives.
At time t0, the system is in a safe state. <P1, P0, P2> sequence satisfies the safety condition.
 Process P1 can immediately be allocated all its tape drives and then return all 4 resources.
(i.e.) P1 currently holding 2 tape drives and out of 3 free tape drives 2 tape drives will be
given to P1. Now P1 is having all 4 resources. Hence P1 will use all of its resources and
after completing its task P1 releases all 4 resources and then returns to the system. Now
the system is having 5 available tape drives.
 Now process P0 needs 5 tape drives and the system has 5 available tape drives. Hence P0
can get all its tape drives and it reaches its maximum 10 tape drives. After completing its
task P0 returns the resources to the system. Now system has 10 available tape drives.
 Now the process P2 needs 7 additional resources and system have 10 resources available.
Hence process P2 can get all its tape drives and return them. Now the system will have
all 12 tape drives available.
Problem: Low Resource utilization
If a process requests a resource that is currently available, it may still have to wait. Hence
there exist a low resource utilization is possible.
Resource-Allocation-Graph Algorithm
In this algorithm we use three edges: request edge, assignment edge and a claim edge.
 Claim edge Pi → Rj indicates that process Pi may request resource Rj at some time in
the future.
 Claim edge resembles a request edge in direction but is represented by dashed line.
 When process Pi requests resource Rj, the claim edge Pi → Rj is converted to a request
edge.
 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. That is, before process Pi starts
executing, all its claim edges must already appear in the resource-allocation graph.

96

Downloaded by Kirti Chauhan (kirtic290@gmail.com)

 lOMoARcPSD|9721638

KMIT/CSE/II-II/OS-3 P.VAMSHI KRISHNA

Now suppose that process Pi requests resource Rj.

 The request can be granted only if converting the request edge Pi → Rj to an assignment
edge Rj → Pi does not result in the formation of a cycle in the resource-allocation graph.
We check for safety by using a cycle-detection algorithm.
 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. In that case,
process Pi will have to wait for its requests to be satisfied.
Example: consider the above resource-allocation graph. Suppose that P2 requests R2.
 R2 is currently free still we cannot allocate it to P2, since this will create a cycle in graph.
 A cycle indicates that the system is in an unsafe state.
 If P1 requests R2 and P2 requests R1, then a deadlock will occur.
Problem: The resource-allocation-graph algorithm is not applicable to a resource allocation
system with multiple instances of each resource type.
BANKER’s ALGORITHM
Banker’s algorithm is used in a system with multiple instance of each resource type.
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.
Banker’s algorithm uses two algorithms:
1. Safety algorithm
2. Resource-Request algorithm
Process of Banker’s algorithm:
 When a new process enters the system, the process must declare the Maximum number
of instances of each resource type that it may need.
 The Maximum number may not exceed the Total number of resources in the system.
 When a user requests a set of resources, the system must determine whether the allocation
of these resources will leave the system in a safe state.
 If the system is in safe state then the resources are allocated.
 If the system is in unsafe state then the process must wait until some other process
releases enough resources.
Data structures used to implement the Banker’s algorithm
Consider the system with n number of processes and m number of resource types:
 Availablem: A vector of length m indicates the number of available resources of each
type.
 Maxn × m: An n × m matrix defines the maximum demand of each process.
 Allocation n × m: An n × m matrix defines the number of resources of each type currently
allocated to each process.
 Need n × m: An n × m matrix indicates the remaining resource need of each process.
Need[i][j] = Max[i][j]−Allocation[i][j].
 Available[j] = k means then k instances of resource type Rj are available.
 Max[i][j] = k means process Pi may request at most k instances of resource type Rj.

97

Downloaded by Kirti Chauhan (kirtic290@gmail.com)

 lOMoARcPSD|9721638

KMIT/CSE/II-II/OS-3 P.VAMSHI KRISHNA

 Allocation[i][j]=k means process Pi is currently allocated k instances of resource type Rj.

 Need[i][j]=k means process Pi may need k more instances of resource type Rj to
complete its task.
Each row in the matrices Allocation n × m and Need n × m are considered as vectors and refer to
them as Allocationi and Needi.
 The vector Allocationi specifies the resources currently allocated to process Pi.
 The vector Needi specifies the additional resources that process Pi may still request to
complete its task.
Safety algorithm
Safety algorithm finds out whether the system is in safe state or not. The algorithm can be
described as follows:
1. Let Work and Finish be vectors of length m and n, respectively. We initialize
Work = Available
Finish[i] = false for i = 0, 1, ..., n − 1.
2. Find an index i such that both
Finish[i] == false
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.
Note: To determine a safe state, this algorithm requires an order of m×n2 operations.
Resource-Request Algorithm
This algorithm determines whether requests can be safely granted.
Let Requesti be the request vector for process Pi. If Requesti [ j] == k, then process Pi wants
k instances of resource type Rj.
When a request for resources is made by process Pi, the following actions are taken:
1. If Requesti ≤ Needi, go to step 2.
Otherwise, raise an error condition, since the process has exceeded its maximum claim.
2. If Requesti ≤ 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– Requesti ;
Allocationi = Allocationi + Requesti;
Needi = Needi – Requesti ;
4. If the resulting resource-allocation state is safe, the transaction is completed and process
Pi is allocated its resources.
If the new state is unsafe, then Pi must wait for Requesti and the old resource-allocation
state is restored.

98

Downloaded by Kirti Chauhan (kirtic290@gmail.com)

 lOMoARcPSD|9721638

KMIT/CSE/II-II/OS-3 P.VAMSHI KRISHNA

Example for Banker’s Algorithm

Consider a system with 5 processes: P0, P1, P2, P3, P4 and 3 resource types A, B and C with
10, 5, 7 instances respectively. (i.e.) . Resource type A=10, B= 5 and C=7 instances.
Suppose that, at time T0, the following snapshot of the system has been taken:
Allocation Max Available
Process A B C A B C A B C
P0 0 1 0 7 5 3 3 3 2
P1 2 0 0 3 2 2
P2 3 0 2 9 0 2
P3 2 1 1 2 2 2
P4 0 0 2 4 3 3

The Available vector can be calculated by subtractring total no of resources from the sum of
resources allocated to each process.
Available resources of A= Total resources of A – Sum of resources allocated to Process P1 to P4

The Need matrix can be obtained by using Need[i][j] = Max[i][j]−Allocation[i][j]

Max Allocation Need
A B C A B C A B C
P0 7 5 3 0 1 0 7 4 3
P1 3 2 2 2 0 0 1 2 2
P2 9 0 2 3 0 2 6 0 0
P3 2 2 2 2 1 1 0 1 1
P4 4 3 3 0 0 2 4 3 1

By using the banker’s algorithm we can decide whether the state is safe or not.
After solving the above problem by using bankers algorithm we will get to a safe state with
safe sequence <P1,P3,P4,P0,P2>.
Now we get a safe state, the resources will be granted immediately for requested process P1.
DEADLOCK DETECTION ALGORITHM
If a system does not employ either a Deadlock-Prevention or a Deadlock-Avoidance
algorithm then a deadlock situation may occur. In this environment, the system may provide:
 An algorithm that examines the state of the system to determine whether a deadlock has
occurred
 An algorithm to recover from the deadlock.
Deadlock Detection in 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 wait-for graph from the resource-allocation graph by removing the resource nodes
and collapsing the appropriate edges.
 An edge from Pi to Pj in a wait-for graph implies that process Pi is waiting for process Pj
to release a resource that Pi needs.
 An edge Pi → Pj exists in a wait-for graph if and only if the corresponding resource
allocation graph contains two edges Pi → Rq and Rq → Pj for some resource Rq .
99

Downloaded by Kirti Chauhan (kirtic290@gmail.com)

 lOMoARcPSD|9721638

KMIT/CSE/II-II/OS-3 P.VAMSHI KRISHNA

 In above figure we present a resource-allocation graph and the corresponding wait-for

graph. A deadlock exists in the system if and only if the wait-for graph contains a cycle.
 To detect deadlocks, the system needs to maintain the wait-for graph and periodically
invoke an algorithm that searches for a cycle in the graph.
 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.
Several 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 will implement a Deadlock Detection algorithm that is similar to the Banker’s algorithm.
The data structures used in Deadlock Detection algorithm is:
 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]==k, then process Pi is requesting k more instances of resource type Rj.
The detection algorithm described here simply investigates every possible allocation
sequence for the processes that remain to be completed.
1. Let Work and Finish be vectors of length m and n, respectively. We Initialize
Work = Available. For i = 0, 1, ..., n–1.
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, 0 ≤ i < n, then the system is in a deadlocked state.
Moreover, if Finish[i] == false, then process Pi is deadlocked.

100

Downloaded by Kirti Chauhan (kirtic290@gmail.com)

 lOMoARcPSD|9721638

KMIT/CSE/II-II/OS-3 P.VAMSHI KRISHNA

This algorithm requires an order of m × n2 operations to detect whether the system is in a

deadlocked state.
Example:
Consider a system with 5 processes: P0, P1, P2, P3, P4 and 3 resource types A, B and C with
10, 5, 7 instances respectively. (i.e.) . Resource type A=7, B= 2 and C=6 instances.
Suppose that, at time T0, we have the following resource-allocation state:
Allocation Request Available
A B C A B C A B C
P0 0 1 0 0 0 0 0 0 0
P1 2 0 0 2 0 2
P2 3 0 3 0 0 0
P3 2 1 1 1 0 0
P4 0 0 2 0 0 2

Initially the system is not in Deadlock State. If we apply the Deadlock Detection algorithm
we will find the sequence < P0, P2, P3, P1, P4 > results in Finish[i] == true for all i.
The system is in safe state hence there is no deadlock.
RECOVERY FROM DEADLOCK
There are two options for breaking a deadlock.
1. Process termination
2. Resource Preemption
Process Termination
To eliminate deadlocks by aborting a process, we use one of two methods. In both methods,
the system reclaims all resources allocated to the terminated processes.
 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 and probably will have to be
recomputed later.
 Abort one process at a time until the Deadlock cycle is eliminated: This method incurs
considerable overhead, since after each process is aborted, a deadlock-detection algorithm
must be invoked to determine whether any processes are still deadlocked.
Many factors may affect which process is chosen for preempting includes:
1. Priority of the process.
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.
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
To eliminate deadlocks using resource preemption, we successively preempt some resources
from processes and give these resources to other processes until the deadlock cycle is broken.
There are 3 issues related to Resource Preemption:

101

Downloaded by Kirti Chauhan (kirtic290@gmail.com)

 lOMoARcPSD|9721638

KMIT/CSE/II-II/OS-3 P.VAMSHI KRISHNA

1. Selecting a victim. As in process termination, we must determine the order of preemption

to minimize cost. Cost factors may include the number of resources a deadlocked process
is holding and the amount of time the process has thus far consumed.
2. Rollback. If we preempt a resource from a process then the process cannot continue with
its normal execution. It is missing some needed resource. We must do total roll back of
the process and restart it from that state: abort the process and then restart it.
3. Starvation. How do we ensure that starvation will not occur? That is, how can we
guarantee that resources will not always be preempted from the same process?
In a system where victim selection is based on cost factors, it may happen that the same
process is always picked as a victim. As a result, this process never completes its task
which leads to starvation. Hence we must ensure that a process can be picked as a victim
only a finite number of times. The solution is to include the number of rollbacks in the
cost factor.

102

Downloaded by Kirti Chauhan (kirtic290@gmail.com)