Deadlock

These topics are from Chapters 3 (Deadlock) in Advanced Concepts in OS.

Types of Resources

• reusable
  • fixed number of units
  • neither created nor destroyed
  • request --> use --> release --> repeat
• consumable
  • produced by a producer process
  • request, produce/acquire (implies consume)

What are examples of each type of resource?

When is a set of processes deadlocked?

• resource deadlock: each process requests resources held by another process in the the set and it must receive all the requested resources before it can become unblocked
• communication deadlock: each process is waiting for communication from another process, and will not communicate until it receives the communication for which it is waiting

What are the fundamental causes of deadlock?

How can we deal with deadlock?

Fundamental Causes of Deadlock

• exclusive access
• wait while holding
• no preemption
• circular wait

Deadlock Handling Strategies

• prevention
• avoidance
• detection

What is the difference between prevention and avoidance?

What are examples of deadlock prevention?

Deadlock Avoidance

Process P1:
request(R1); ... request(R2); ... release(R2); release(R1);

Process P2:
request(R2); ... request(R1); ... release(R1); release(R2);

The Banker's Algorithm is an example of a well known deadlock avoidance algorithm

Deadlock Prevention

• Ordered allocation

  Process P1:
  request(R1); ... request(R2); ... release(R2); ... release(R1);

  Process P2:
  request(R1); ... request(R2); ... release(R2); ... release(R1);

• Release before request

  Process P1:
  request(R1); ... release (R1); request(R2); ... release(R2);

  Process P2:
  request(R2); ... release (R2); request(R1); ... release(R1);

• Request all at once

  Process P1:
  request(R1, R2); ... release(R1, R2);

  Process P2:
  request(R1, R2); ... release(R1, R2);

Wait-For Graphs (WFG)

Nodes correspond to processes (only).

There is an edge from process P₁ to process P₂ iff P₁ is blocked waiting for P₂ to release some resource.

Single-Unit Resource Allocation Graphs

Nodes correspond to processes and resources.

There is a request edge from process P to resource R iff P is blocked waiting for an allocation of R.

There is an assignment edge from resource R to process P iff P is holding an allocation of R.

How do we model multi-unit resources?

Multiunit Resource Allocation Graphs

General Resource System

A system state consists of:

• set of processes P = {P₁, P₂, ¼P_n}
• set of resources G = {R₁, R₂, ¼R_m}
• for every reusable resource R_i, a nonegative integer t_i,
  the total number of units present in the system
• for every consumable resource R_i,
  a nonempty set of producers of R_i

General Resource Graph

Bipartite directed graph

• nodes are P and G
• (r₁, r₂, ¼r_m) = available units vector
• (P,R) is a request edge
• (R,P) is an assignment edge if R is reusable
• (R,P) is a producer edge if R is consumable

What is a bipartite graph?

Give examples of graphs, operations on graphs, deadlock, and safe/unsafe states.

Request Models

• single-unit
• AND request model
• OR request model
• AND-OR request model
• P-out-of-Q request model

What is a sufficient condition for deadlock in each of these models?

Deadlock Conditions in WFG

Cycle is always a necessary condition for deadlock

• single-unit -- cycle is sufficient
• AND request model -- cycle is sufficient
• OR request model -- knot is sufficient
• AND-OR request model -- knot is sufficient
• P-out-of-Q request model -- knot is sufficient

A cycle is not a sufficient condition for deadlock in multiunit models.

What is a Knot?

A strongly connected subgraph of a directed graph, such that starting from any node in the subset it is impossible to leave the knot by following the edges of the graph.

A cycle with no deadlock, and no knot.

A knot is a sufficient condition for deadlock

A knot is not a necessary condition for deadlock

Conditions on General Resource Graph

• for every reusable resource R_i
  • #(R_i,*) £ t_i
  • r_i = t_i - #(R_i,*)
  • "P_j   :  P_j Î P  ::  #(R_i,P_j) + #(P_j,R_i) £ t_i
• for every consumable resource R_i
  • r_i ³ 0
  • $  edge  (R_i, P_j) Û P_j   is a producer of  R_i

What is the relationship between a system state and a GRG?

Can you describe an algorithm for detecting a deadlock?

Operations on General Resource Graph

• request: add request edges (requires P was not blocked)
• grant: replace reusable request edges by assignment edges, and decrement r_i (requires the resource was available)
• produce: delete consumable request edges (requires the producer was not blocked)
• release: delete assignment edges, and increment r_i (requires P was not blocked)

Graph Reduction

Models a most favorable possible (optimistic) continuation of execution from the current system state.

while there is an unblocked process P_i:

1. For each request edge (P_i, R_j), remove the request edge and decrement the corresponding count r_j. This corresponds to satisfying the request.
2. For each allocation edge (R_j, P_i), remove the allocation edge and increment the corresponding count r_j. This corresponds to releasing the allocation.
3. For each consumable resource production edge (P_i, R_j), remove the producer edge from the graph, and set r_j to infinity. This corresponds to assuming P_i produces as many units of R_j as may be required by other processes.

There is deadlock iff the remaining graph is non-null

Practicality of GRG Reduction

• Useful for characterizing properties of deadlock systems
• Not practical for implementation
• Reducibility is dependent on the order of the reductions
• Worst time complexity is O(mn) where m is number of resources
and $n$ is number of processes

Expedient States

A state is expedient iff all processes having outstanding requests are blocked, i.e. all grantable requests have been granted.

Note: A system must eventually get to one of these states if it is deadlocked.

Theorem In a GRG,

• A cycle is a necessary condition for deadlock
• If the graph is expedient, then a knot is a sufficient condition for deadlock

This still leaves a gap. That is, the existence of a cycle is necessary but not sufficient, and the existence of a knot is sufficient but not necessary.