Deadlock Characterization

1
Deadlock Characterization

• Deadlock can arise if four conditions hold
  simultaneously
• Mutual Exclusion
• Hold and Wait
• No Preemption
• Circular Wait

2
Mutual Exclusion

• only one process at a time can use a resource.
• If another process requests that resource, the
  requesting process must be delayed until the
  resource has been released

3
Hold and Wait

• a process that holding at least one resource is
  waiting to acquire additional resources held by
  other processes.

4
No preemption

• a resource can be released only voluntarily by
  the process holding it, after that process has
  completed its task.

5
Circular Wait

• there exists a set P0, P1, , P0 of waiting
  processes such that
• P0 is waiting for a resource that is held by P1,
• P1is waiting for a resource that is held by P2,
  , Pn1is waiting for a resource that is held by
  Pn, and P0is waiting for a resource that is held
  by P0.

6
Resource-Allocation Graph

• A set of vertices V and a set of edges E.
• 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.
• E is also partitioned into two types
• request edge directed edge P1 ?Rj
• assignment edge directed edge Rj?Pi

7
7.4 Deadlock Prevention

• We try to ensure that one of the four necessary
  conditions cannot hold, then we can prevent it
• Mutual Exclusion
• If it is shareable resource, then we can break
  the mutual exclusion (such as Read-only file)
• If it is not a shareable resource, then mutual
  exclusion must hold (such as Printer)

8
7.4 Deadlock Prevention

• Hold and wait two methods
• 1. Require process to request and be allocated
  all its resources before it begins execution.
• 2. allow process to request resources only when
  the process has none.

9
Hold and Wait method example

• We consider a process that copies data from DVD
  drive to a picture file on disk and then prints
  the picture to a printer
• Method1 request DVD drive, Disk, and Printer
  before it execute. It will hold the Printer for
  entire execution, even though it needs the
  printer only at the end
• Method2 request only for DVD drive and Disk
  initially. It finishes the copy step and release
  both resource. The process must then again ask
  for disk and printer to finish the job

10
Hold and Wait method example

• Low resource utilization
• starvation possible, (if a process needs several
  popular resources)

11
7.4 Deadlock Prevention

• NO preemption
• If a process that is holding some resources
  requests
• another resource that cannot be immediately to
  
• allocated 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.

12
7.4 Deadlock Prevention

• Circular wait
• impose a total ordering of all resource
• types, and require that each process
• requests resources in an increasing order
• of enumeration.

13
Circular wait

• First of all we create a map function that maps
  each resource, for example
• F(tape drive) 1,
• F(disk drive) 5,
• F(Printer) 12
• Then we have two rules for Processes to request
  Resources
• Each process can request resources only in an
  increasing order
• Whenever a process requests an instance of
  resource Rj, it has released any resources Ri
  such that F(Ri) gt F(Rj)

14
Circular wait

• Let the set of processes involved in the circular
  wait condition be P0,P1,..,Pn, where Pi is
  waiting for a resource Ri, which is held by Pi1
  (Pn is waiting for Rn which held by P0)
• Since Pi1 is holding Ri while requesting
  resource Ri1, we must have F(Ri) lt F(Ri1) for
  all I
• But this condition means that
• F(R0)ltF(R1)ltltF(Rn)ltF(R0)
• By transitivity F(R0) lt F(R0) which is impossible

15
7.5 Deadlock Avoidance

• Possible side effects of preventing deadlock are
  low device utilization and reduce system
  throughput
• An alternative method for avoiding deadlocks is
  to require additional information about how
  resources are to be required.

16
7.5 Deadlock Avoidance

• 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 possible
  future deadlock
• A deadlock avoidance algorithm dynamically
  examines the resource-allocation state to ensure
  that a circular wait condition can never happen

17
Safe State

• A state is safe if the system can allocate
  resources to each processes in some order (safe
  sequence) and still avoid a deadlock
• If no such sequence exists, then the system state
  is said to be unsafe

18
Safe State

• To illustrate, we consider a system has 12
  magnetic tape drives and 3 processes. P0 needs 10
  tapes, P1 needs 4 and P2 needs 9.
• Currently, P0 has 5, P1 has 2 and P2 has 2
• Max needs Current needs
• P0 10 5
• P1 4 2
• P2 9 2
• At T0, the system is in safe state, since
  ltP1,P0,P2gt satisfied safe state condition
• What if P2 currently ask for one more tape and
  has that one?

19
Safe, Unsafe, Deadlock
20
7.5 Deadlock Avoidance

• The algorithm is simply to ensure that the system
  will always remain in safe state.
• Therefore, if a process requests a resource that
  is currently available, it may still have to
  wait.
• Thus, resource utilization may be lower

21
Avoidance algorithms

• Single instance of a resource type. Use a
  resource allocation graph
• Multiple instances of a resource type. Use the
  bankers algorithm

22
Resource-Allocation Graph Scheme

• Claim edge Pi ? Rj indicated that process Pj may
  request resource Rj in the future represented by
  a dashed line.
• Claim edge converts to request edge when a
  process requests a resource.
• Request edge converted to an assignment edge when
  the resource is allocated to the process.
• When a resource is released by a process,
  assignment edge reconverts to a claim edge.

23
Resource-Allocation Graph
24
Unsafe State In Resource-Allocation Graph
25
Resource-Allocation Graph Algorithm

• Suppose that process Pi requests a resource Rj
• The request can be granted only if converting the
  request edge to an assignment edge does not
  result in the formation of a cycle in the
  resource allocation graph

26
Bankers Algorithm

• Multiple instances.
• Each process must a claim maximum use in advance.
• 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.

27
Bankers Algorithm

• Two algorithms need to be discussed
• 1. Safety state check algorithm
• 2. Resource request algorithm

28
Data Structures for the Bankers Algorithm
29
Safety Algorithm
30
Resource-Request Algorithm for Process Pi
31
Example of Bankers Algorithm
32
Example of Bankers Algorithm
33
Example of Bankers Algorithm