CS-303 Operating Systems

Dr. Samia Ijaz

Fall - 2024

Department of Computer
Science
HITEC University Taxila
Chapter 8: Deadlocks

Week-09
 Chapter 8: Deadlocks

● System Model
● Deadlock Characterization
● Methods for Handling Deadlocks
● Deadlock Prevention
● Deadlock Avoidance
● Deadlock Detection
● Recovery from Deadlock
 System Model

● System consists of resources

● 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
 Deadlock Characterization
Deadlock can arise if four conditions hold
simultaneously.
● Mutual exclusion: only one process/thread 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 {T0, T1, …,
Tn} of waiting threads such that T0 is waiting for
a resource that is held by T1, T1 is waiting for a
resource that is held by T2, …, Tn–1 is waiting for
a resource that is held by Tn, and Tn is waiting
for a resource that is held by T0.
 Resource-Allocation Graph
A set of vertices V and a set of
edges E.
● V is partitioned into two types:
● T = {T1, T2, …, Tn}, the set consisting of all
the processes/threads in the system

● R = {R1, R2, …, Rm}, the set consisting of all

resource types in the system

● request edge – directed edge Ti → Rj

● assignment edge – directed edge Rj → Ti

 Resource-Allocation Graph (Cont.)
● Process (P) /Thread (T)

Resource Type with a single instance

● Resource Type with 4 instances

● Ti requests an instance of Rj
T
i
Rj
● Ti is holding an instance of Rj

T
i
Rj
Example of a Resource Allocation Graph
 Basic Facts

● 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
Resource Allocation Graph With A Deadlock
Resource Allocation Graph With A Cycle but No
Deadlock
Example of Resource Allocation graph

● Let’s consider 3 processes P1, P2 and P3, and

two types of resources R1 and R2. The
resources are having 1 instance each.

● R1 is being used by P1, P2 is holding R2 and

waiting for R1, P3 is waiting for R1 as well as
R2.

● Determine the system state, if there exist

deadlock or not?
Solution
 Methods for Handling Deadlocks

● Ensure that the system will never enter a deadlock

state:
● Deadlock prevention
● Deadlock avoidance
● Deadlock detection and recovery
● Allow the system to enter a deadlock state and
then recover
● Deadlock Ignorance
● Ignore the problem and pretend that deadlocks
never occur in the system; used by most
operating systems, including UNIX
● Deadlocks are rare in most general-purpose
systems, so the cost of detection or prevention
may outweigh the benefits.
 Deadlock Prevention
Restrain the ways request can be
made
● 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 (Cont.)
● 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 a particular
increasing order
 Deadlock Avoidance
Requires that the system has some additional a
priori information available
● Simplest and most useful model requires
that each process declares 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
● Safe State: A system is in a safe state if there exists a
sequence of processes such that all processes can
complete successfully without entering a deadlock state.

● Unsafe State: A system is in an unsafe state if there is a

possibility of deadlock, even if the system hasn’t reached
a deadlock yet.
 Safe State
● When a process requests an available resource, system
must decide if immediate allocation leaves the system in
a safe state
● 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,
● 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
 Basic Facts

● 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.
 Avoidance Algorithms

● Single instance of a resource type

● Resource-allocation graph algorithm

● Multiple instances of a resource type

● Banker’s algorithm
 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
 Data Structures for the Banker’s Algorithm
Let n = number of processes /threads,
and
m = number of resources types.
● 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
 Resource-Request Algorithm for Process Pi

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 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 (Cont.)
● The content of the matrix Need is defined to be
Max – Allocation

Need Available
ABC ABC
P0 743 3 3 2
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: 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 302 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?

● Can request for (0,2,0) by P0 be granted?

 Class Activity

1. Calculate the content of need matrix?

2. Is the system in a safe state?
3. Determine the total number of resources of each type?
 End of Chapter 8

Operating System Concepts – 9th Silberschatz, Galvin and Gagne