Deadlock Prevention Methods

Instructor
Mr. S.Christalin Nelson
Deadlocks

System Model (1/5)
• System consists of finite resources
• The resources may
– Physical resources
• Example: printers, tape drives, memory space, CPU cycles
– Logical resources
• Example: semaphores, mutex locks, files
• Resource types/classes & Resource Instances
– Resource classes should be defined appropriately
• Example: CPU cycles, memory space, I/O devices, etc.
– Each resource type Ri has Wi instances
4/8/2022 3 of 52
Instructor: Mr.S.Christalin Nelson

System Model (2/5)
• Example-1
– System has 2 CPUS. i.e. Resource type CPU has 2 instances
– If process requests resource type CPU => any instance of this
type can be allocated
• Example-2
– System with resource type Printer has 2 instances (Basement
& Floor-9)
– If process requests resource type printer => Can any instance
be allocated?
4/8/2022 4 of 52

System Model (3/5)
• Process resource utilization sequence
– (1) Request, (2) Use , (3) Release
– (1) & (3) may be system calls
• Examples:
– request() and release() device
» semaphore: wait(), signal()
» mutex lock: acquire(), release()
– open() and close() file
– allocate() and free() memory
• System Table (OS records free/allocated resources) & Queue
4/8/2022 5 of 52

System Model (4/5)
• Deadlock?
– A set of processes is deadlocked when every process in the set
is waiting for an event (resource acquisition/release) that can
be caused only by another process in the set
• Processes never finish => System resources are tied-up => other
jobs prevented from starting
4/8/2022 6 of 52

System Model (5/5)
• Illustration-1: Deadlock involving same resource type
– A system has 2 CD-RW drives & 2 processes (P1 & P2)
– Each process holds 1 CD-RW drive
– If P1 & P2 requests for one more drive => Deadlock occurs
• Illustration-2: deadlock involving different resource type
– A system has 1 printer, 1 DVD drive & 2 processes (P1 & P2)
– P1 holds DVD drive & Process-2 holds printer
– If P1 requests printer & P2 requests DVD drive => Deadlock
occurs
4/8/2022 7 of 52

Necessary Conditions for Deadlock
• The following conditions are not completely independent
– (1) Mutual exclusion
– (2) Hold and wait
– (3) No preemption
– (4) Circular wait
4/8/2022 9 of 52

Resource allocation graph (1/3)
• Describes Deadlock using Directed Graph
• Graph (G)
– Defined as set (V, E)
– V = {V1, V2, ..., Vn}
– E = {E1, E2, ..., En}
• For a Resource allocation graph (RAG)
– V = {P, R}
• Set of Active Processes, P = {P1, P2, ..., Pn}
• Set of Resources Types, R = {R1, R2, ..., Rn}
– E = Set of Directed edges
• Ei can be Request edge or Assignment edge
– Pi -> Rj (Pi requested for Rj & waits for it)
– Ri -> Pj (Pi’s request accepted & Ri is allocated to Pj)
4/8/2022 10 of 52

• Notation
– Circle (Process), Rectangle (Resource type), Dot in rectangle
(Resource instance)
– Request edge (Pi-> Rj)
• Edge points to a rectangle
– Assignment edge (Ri -> Pj)
• Edge designates one dot in rectangle
4/8/2022
Resource Instances &
Process States?
11 of 52

• RAG can contain a cycle
– If no cycle => No deadlock
– If cycle exists => Deadlock may or may not exist
• If each resource has one instance (Necessary & sufficient
condition) deadlock exists
• If each resource has >1 instance (Necessary & not sufficient
condition) deadlock may exists
• Example
– Two cycles
4/8/2022 12 of 52

Methods to handle Deadlock (1/2)
• Ensure system never enters deadlock state -> Deadlock
prevention/avoidance
– Deadlock prevention
• One necessary condition not satisfied
– Deadlock avoidance
• Prior information on resource which process can request/use in
its lifetime required -> OS decides whether current request is
satisfied/delayed (i.e. Consider available resources, allocated
resources & future requests and releases)
• Allow system to enter deadlock state & recover -> Deadlock
detection & recovery
• Ignore problem & pretend that deadlocks never occur in
system -> handled by application developer (Used by UNIX &
Windows)
4/8/2022 14 of 52

Methods to handle Deadlock (2/2)
• Overhead for Deadlock detection and Recovery
– Run-time costs of maintaining necessary information &
executing detection algorithm
– Potential losses inherent in recovering from a deadlock
4/8/2022 15 of 52

Deadlock Prevention (1/8)
• Mutual exclusion condition
– Should be satisfied (cannot be denied)
– Sharable resources do not require mutually exclusive access &
not involved in a deadlock.
• Example: Read-only files
– Some resources (at least one) are non-sharable
• Example: mutex lock
4/8/2022 17 of 52

• Hold and Wait condition
– To deny, guarantee that when a process requests a resource it
does not hold any other resources
• Solution-1: Process can execute only after its gets all resources
requested. i.e System calls requesting resources for a process
precede all other system calls
• Solution-2: Process can request resources only after releasing all
currently allocated resources
– (Soln. 1 vs. 2) Illustration: P1 copies data from DVD drive to a
file on disk, sorts file, and prints results to a printer
• Solution-1: P1 requests & holds DVD drive, disk file, and printer
for its entire execution. Note: Printer required only at the end
• Solution-2: P1 requests & holds DVD and Disk File to perform
copy => Release both => Requests Disk File & sorts => Requests
Disk File & Printer to print
4/8/2022 18 of 52

• Hold and Wait condition (contd.)
– Disadvantages of both solutions
• (1) Low resource utilization
– Allocated resources are unused for a long period
• (2) Starvation
– At least one resource is always allocated to another process
4/8/2022 19 of 52

• No preemption of already allocated resources
– To deny the condition
• Solution-1: P1 requests for resources -> Some resources are
allocated to P1 & few are held by other processes -> Preempt all
resources from P1 & add to resource waiting list -> P1 restarts
after getting all resources
• Solution-2: P1 requests for resources -> Some resources are
allocated to P1 & few are held by P2 -> Check if P2 is waiting for
new resource -> If yes, preempt desired resources from P2 &
allocate to P1 -> If no, P1 waits -> During wait other acquired
resources may be preempted if requested by other process -> P1
restarts after getting all resources
– Note:
• Cannot be applied to resources (mutex locks, semaphores)
• Applied to resources whose state can be easily saved & restored
later (CPU registers, Memory space).
4/8/2022 20 of 52

• Circular Wait
– To deny this condition
• Total ordering of all resource types & Process should request
resources in an increasing order of enumeration.
– Illustration: Let set of resource types, R = {R1, R2, ..., Rm}
» Assign unique integer no. to each resource type. i.e Define a
one-to-one function F: R→N, where N = set of natural numbers
» Compare two resources & determine whether one precedes
another in ordering.
• Function F is based on normal order of usage of system resources
– Example: If tape drive is usually needed before printer, define
F(tape drive) < F(printer)
4/8/2022 21 of 52

• Circular Wait (contd.)
– Example
• R = {tape drives, disk drives, printers}
• Define F as follows:
– F(tape drive) = 1
– F(disk drive) = 5
– F(printer) = 12
• Solution: If a process wants tape drive & printer at same time
– Using F, it request tape drive & then printer
– Process requesting an instance of Rj must have released any
resources Ri such that F(Ri) ≥ F(Rj)
• Note: A single request is required if several instances of same
resource type are needed
4/8/2022 22 of 52

• Circular Wait (contd.)
– “Circular wait is eliminated” - Proof by contradiction
• Assume circular wait exists
• Processes {P0, P1, ..., Pn} are involved in circular wait such that
– Pi is waiting for Ri, which is held by process Pi+1
– Pn is waiting for a resource Rn held by P0
– Pi+1 is holding resource Ri while requesting resource Ri+1
• Hence, F(Ri+1) > F(Ri) for all i
– Which means F(R0) < F(R1) < ... < F(Rn) < F(R0)
– By transitivity, F(R0) < F(R0) is impossible
• Therefore, there can be no circular wait
4/8/2022 23 of 52

• Using with application program
– Develop an ordering of all synchronization objects in system
– Application developers write programs to ensure that
resources are acquired in proper order
– Requests for synchronization objects made in increasing order
• Verification & Warning software
– Used to check ordering & when locks are acquired out of order
and deadlock is possible
– Example: Witness
• Lock-order verifier for BSD versions of UNIX such as FreeBSD
• Uses mutual-exclusion locks to protect critical sections
• Note: Imposing lock ordering does not guarantee deadlock
prevention if locks can be acquired dynamically
4/8/2022 24 of 52

Deadlock Avoidance Vs. Prevention
• Deadlock prevention works by limiting how requests can be
made.
– i.e Ensure at least one of necessary conditions for deadlock
cannot occur.
• Side effects of Deadlock Prevention
– Low device utilization
– Reduced system throughput
• Deadlock avoidance
– System has knowledge (additional information) of complete
sequence of requests & releases for each process & can decide
• Example: A system has one tape drive & one printer. System
knows P will request tape drive first & then printer, before
releasing both. Q will request printer first & then the tape drive
4/8/2022 26 of 52

Algorithms
• Approaches can differ in amount & type of information
required
• Simplest & most useful model
– Process declares required max. no. of resources of each type
• Should be <= max. resources in system
• Given this a priori information, algorithm can ensure that system
will never enter deadlocked state
• Ensure circular-wait condition does not exist by dynamic
examination of resource-allocation state
– Resource allocation state: No. of available & allocated
resources, max. demands of processes
4/8/2022 27 of 52

Safe & Unsafe State (1/2)
• Safe State
– System can allocate resources to each process (up to max.) in
some order & still avoid a deadlock
– Safe sequence of processes <P1, P2, ..., Pn> for current
allocation state exists
• Resource requests of Pi is satisfied by currently available
resources + resources held by all Pj and j<i
– If resources are not immediately available -> Pi waits until all Pj have
finished -> When finished, Pi obtains all its needed resources,
complete task, return allocated resources, and terminate -> When Pi
terminates, Pi+1 obtains its needed resources -> ….
4/8/2022 28 of 52

Safe & Unsafe State (2/2)
• Unsafe state
– Behavior of processes controls unsafe states
– OS cannot prevent processes from requesting resources in
such a way that a deadlock occurs
– May lead to a deadlocked state
• Note: Not all unsafe states are deadlocks
– Depicted as a Cycle in RAG
4/8/2022 29 of 52

Avoidance Algorithms
• Single instance of a resource type
– Resource-allocation graph (RAG)
• Multiple instances of a resource type
– Banker’s algorithm
• Less efficient than RAG scheme
4/8/2022 30 of 52

RAG Algorithm (1/2)
• Include Claim edge Pi → Rj (Notation: dashed line)
– Pi may request Rj in future
• All claim edges should be known a priori (before execution)
– Variant: Known a priori if all edges of Pi are claim edges
4/8/2022 31 of 52

RAG Algorithm (2/2)
• On request: Claim edge is converted to Request edge
• On allocation: Request edge is converted to Assignment
edge
– Cycle is not formed in RAG to ensure safe state
– Cycle Detection algorithm requires n2 operation for ‘n’
processes
– On release: Assignment edge is converted to Claim edge
4/8/2022
cycle
32 of 52

Banker’s Algorithm (1/7)
• New process entering system should declare max. no. of
instances of each resource type required
• Resource allocations occur only if safe state exists
– Else, process waits required resources are released
• Data Structures
– Encode resource-allocation state
– For 'n' processes & 'm' resources types
• Available[m] – Vector mentioning the availability of resources
• Max[n][m] – Matrix mentioning the demands of processes
• Allocation[n][m] – Matrix mentioning the allocation to processes
• Need[n][m] – Matrix mentioning the additional requirement of
processes
4/8/2022 33 of 52

• Data structures (contd.)
– Size & value of Data structures can vary over time
– Note:
• Consider each row of matrix as vector denoted as Allocationi &
Needi
4/8/2022
S.No. Example Remarks
1 Available[j] = k ‘k’ instances of resource type ‘Rj’ is available
2 Max[i][j] = k ‘k’ instances of resource type ‘Rj’ is required by process Pi
3 Allocation[i][j] = k ‘k’ instances of resource type ‘Rj’ is allocated to process Pi
4 Need[i][j] = k
‘k’ instances of resource type ‘Rj’ is needed by process Pi
Need[i][j] = Max[i][j] - Allocation[i][j]
34 of 52

• Safety algorithm
– To find if System is in Safe state
• (1) Let Work & Finish be vectors of length m & n, respectively.
Initialize Work = Available, Finish[i] = false for i = 0, 1, ..., n-1
• (2) Find an index i such that Finish[i] == false & Needi ≤ Work
– (2a) If i exists
» Work = Work + Allocationi
» Finish[i] = true, Go to next i
– (2b) Else if no such i exists
» If Finish[i] == true for all i, then system is in a safe state
– Note:
• Requires order of m x n2 operations
4/8/2022 35 of 52

• Resource Request algorithm
– Grant requests safely
• (1) Requesti is request vector for Pi
– Pi wants k instances of Rj if Requesti[ j] == k
• (2) Actions taken when Pi requests for resource
– (a) If Requesti ≤ Needi go to step (2a)
Else, raise error condition (Process has exceeded its max. claim)
– (b) If Requesti ≤ Available go to step (2c)
Else, Pi must wait as resources are unavailable
– (c) System pretends to allocate resources to Pi by modifying state
» Available =Available - Requesti and Needi = Needi - Requesti
» Allocationi = Allocationi + Requesti
• If resource-allocation state is safe, Pi is allocated its resources &
Transaction completed. Else Pi waits for Requesti & old resource-
allocation state restored
4/8/2022 36 of 52

• Example
– A system has 5 processes (P0, P1, P2, P3 & P4), and 3 resource
types (A, B, C). A has 10 instances, B has 5 instances, and C has
7 instances
– At time T0, consider system snapshot is
4/8/2022
Need?
37 of 52

• Example (contd.)
– Consider system is in safe state with safe sequence <P1, P3, P4,
P2, P0>
– If P1 requests 1 instance of A & 2 instances of C
• i.e. Request1 = (1,0,2). Can request be immediately granted?
– Check Request1 ≤ Available i.e. (1,0,2) ≤ (3,3,2) => true
– Pretend that this request has been fulfilled & resulting state is:
4/8/2022
Request1 = (1,0,2)
38 of 52

– Check if above new system state is safe using safety algorithm
• Find safe sequence. We get <P1, P3, P4, P0, P2>. Hence,
immediately grant request of P1
– Further
• Request for (3,3,0) by P4 cannot be granted, since resources are
unavailable
• Request for (0,2,0) by P0 cannot be granted, though resources are
available but resulting state is unsafe
4/8/2022
How?
39 of 52

All resources have single Instance (1/2)
• Convert RAG to WFG
– Remove resource nodes & collapse appropriate edges
• i.e. An edge from Pi -> Pj in WFG => Pi is waiting for process Pj to
release a resource that Pi needs
• An edge Pi → Pj exists in WFG iff corresponding RAG has 2 edges
Pi → Rq & Rq → Pj for Rq
4/8/2022 41 of 52

All resources have single Instance (2/2)
• Deadlock exists iff WFG contains a cycle
– System maintains WFG & periodically invoke an Cycle
detection algorithm (requires an order of n2 operations for 'n'
vertices in graph)
• Not applicable when multiple instances of each resource
type exist
4/8/2022 42 of 52

Several Instances of a Resource Type (1/4)
• Data structures used (Similar to Banker's algorithm Slide#33)
– For 'n' processes & 'm' resources types
• Available[m] – Vector mentioning availability of resources
• Allocation[n][m] – Matrix mentioning allocation to processes
• Request[n][m] – Matrix mentioning requests of processes
– Size & value of Data structures can vary over time
– Note:
• Consider each row of matrix as vector denoted as Allocationi &
Requesti
4/8/2022 43 of 52

• Algorithm
– (1) Let Work & Finish be vectors of length m & n, respectively
• Initialize:
– Work = Available
– For i = 0, 1, ..., n–1
» If Allocationi != 0, Finish[i] = false. Else, Finish[i] = true
– (2) Find index i such that Finish[i] == false & Requesti ≤ Work
• (2a) If i exists
– Work = Work + Allocationi
– Finish[i] = true, Go to next i
• (2b) Else if no such i exists
– If Finish[i] == false for some i, 0≤i<n, then Pi is deadlocked (System is
in deadlocked state)
– Note: Requires order of m x n2 operations
4/8/2022 44 of 52

• Example
– A system has 5 processes (P0, P1, P2, P3 & P4), and 3 resource
types (A, B, C). A has 7 instances, B has 2 instances, and C has 6
instances
– At time T0, consider resource allocation state (RAS)
• System is not in deadlocked state as Safe sequence <P0, P2, P3,
P1, P4> results in Finish[i] == true for all i
4/8/2022 45 of 52

– P2 makes additional request for 1 instance of C. The modified
Request matrix is
• System is deadlocked (consists processes P1, P2, P3, and P4)
– Though resources held by P0 can be reclaimed, no. of available
resources is insufficient to fulfill requests of other processes
4/8/2022 46 of 52

Usage (1/2)
• Factors to decide invocation of deadlock detection
– (1) How frequent is a deadlock likely to occur?
• If frequent -> Invoke detection algorithm frequently
– (2) How many processes will be affected by deadlock when it
happens?
• Resources allocated to deadlocked processes will be idle until
deadlock can be broken
• No. of processes involved in deadlock cycle may grow
• Deadlocks occur when a process makes a request (final
request makes a cycle) that cannot be granted immediately
– Deadlocked processes is a link in the cycle
– If there are many different resource types, one request may
create many cycles in the resource graph
4/8/2022 47 of 52

Usage (2/2)
• (Extreme) Invoke deadlock detection every time a request
for allocation cannot be granted immediately
– Deadlocked set of processes & specific process that “caused”
deadlock can be identified
• Invoke deadlock-detection for every resource request
– Considerable overhead in computation time
• Invoke deadlock-detection at defined intervals at arbitrary
points in time (once per hr. or whenever CPU utilization
drops below 40%)
– Resource graph may contain many cycles
– The deadlocked processes which “caused” deadlock cannot be
identified
4/8/2022 48 of 52

Process Termination
• Abort all deadlocked processes
• Abort one process at a time until the deadlock cycle is
eliminated
• In which order should we choose to abort?
– 1. Priority of the process
– 2. How long process has computed, and how much longer to
completion
– 3. Resources the process has used
– 4. Resources process needs to complete
– 5. How many processes will need to be terminated
– 6. Is process interactive or batch?
4/8/2022 50 of 52

Resource Preemption
• Selecting a victim – minimize cost
• Rollback – return to some safe state, restart process for that
state
• Starvation – same process may always be picked as victim,
include number of rollback in cost factor
4/8/2022 51 of 52

Deadlock Prevention Methods

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Similar to Deadlock Prevention Methods

Similar to Deadlock Prevention Methods (20)

More from Christalin Nelson

More from Christalin Nelson (20)

Recently uploaded

Recently uploaded (20)

Deadlock Prevention Methods