Deadlock.

Deadlock

Process Manager Review
Program Process Abstract Computing Environment Process Description File Manager Process Mgr Protection Deadlock Synchronization Device Manager Memory Manager Resource Manager Scheduler Devices Memory CPU Other H/W

Introduction Let S and Q be two semaphores initialized to 1 P0 P1
P(S); P(Q); P(Q); P(S);   V(S); V(Q); V(Q) V(S); What is the potential problem? How could we overcome this problem if we want to have least constraints on the programmers?

Deadlocks - Introduction
Kansas State legislature “When two trains approach each other at a crossing, both shall come to a full stop and neither shall start up again until the other is gone”

Bridge Crossing Example
Traffic only in one direction. Each section of a bridge can be viewed as a resource. If a deadlock occurs, it can be resolved if one car backs up (preempt resources and rollback). Several cars may have to be backed up if a deadlock occurs. Starvation is possible.

Automobile Gridlocks

The Deadlock Problem A set of blocked processes each holding a resource and waiting to acquire a resource held by another process in the set. Example System has 2 tape drives, one CD-ROM and one DAT drive. P1 and P2 each hold one tape drive and each needs another one.

Two-process deadlock

Deadlock Examples – cont.
Semaphore example semaphores A and B, initialized to 1 P0 P1 P(A); P(B); P(B); P(A); Message deadlock example Process A { receive(B, msg); send(B, msg): } Process B { receive(A, msg); send(A, msg): } Could result from a message being lost

Process 1 Process 2 Resource 1 Resource 2 Process holds resource Process requests resource

Process 1 Process 2 Process 3 Resource 1 Resource 2 Resource 3 Process holds resource Process requests resource

Application Process Resource Manager Process holds resource Process requests resource Memory Resource Disk Block Resource Deadlock can occur even if one of the processes is executing OS code!

Deadlock Characterization
Deadlock can arise if four conditions hold simultaneously Mutual exclusion Hold and wait: No preemption Circular wait

Mutual exclusion only one process 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 {P0, P1, …, Pn} of waiting processes such that P0 is waiting for a resource that is held by P1, P1 is waiting for a resource that is held by P2, …, Pn–1 is waiting for a resource that is held by Pn, and Pn is waiting for a resource that is held by P0.

A Model P = {p1, p2, …, pn} be a set of processes
R = {R1, R2, …, Rm} be a set of resources cj = number of units of Rj in the system S = {S0, S1, …} be a set of states representing the assignment of Rj to pi State changes when processes take action This allows us to identify a deadlock situation in the operating system

Resources Resource: Anything that a process can request, then be blocked because that thing is not available. R = {Rj | 0  j < m} = resource types C = {cj  0 |  RjR (0  j < m)} = units of Rj available Reusable resource: After a unit of the resource has been allocated, it must ultimately be released back to the system. E.g., CPU, primary memory, disk space, … The maximum value for cj is the number of units of that resource Consumable resource: There is no need to release a resource after it has been acquired. E.g., a message, input data, … Notice that cj is unbounded.

Using the Model There is a resource manager, Mgr(Rj) for every Rj
Process pi can request units of Rj if it is currently running pi can only request ni  cj units of reusable Rj pi can request unbounded # of units of consumable Rj Mgr(Rj) can allocate units of Rj to pi request Mgr(Rj) Process allocate

A Generic Resource Manager
Process Resource Manager Blocked Processes Resource Pool request() release() Policy

Using the Model – cont. In most cases, we assume that each process utilizes a resource as follows request If the requested resources are not available, the calling process will be blocked use release Which implies that we are dealing with reusable resources

State Transitions The system changes state because of the action of some process, pi There are three pertinent actions: Request (“ri”): request one or more units of a resource Allocation (“ai”): All outstanding requests from a process for a given resource are satisfied Deallocation (“di”): The process releases units of a resource xi Sj Sk

Properties of States Want to define deadlock in terms of patterns of transitions Define: pi is blocked in Sj if pi cannot cause a transition out of Sj Sj r3 a1 r1 p2 is blocked in Sj

State Diagram If pi is blocked in Sj, and will also be blocked in every Sk reachable from Sj, then pi is deadlocked Sj is called a deadlock state

State Diagram – simple example
State diagram of one process with one resource of two units Can request one unit at a time Progresses from S0 by requesting one unit Progresses from S1 by acquiring the unit From S2 can either relinquish the unit or ask for another unit

State Diagram – example
Extend this to two processes competing for two units of the single resource type Process may request only one unit at a time State diagram in previous slide must be replicated and copies combined to describe all the system states Those states not possible have been removed

State Diagram – example
State S33 is a deadlock state – WHY? r0 a0 r0 S03 S13 S23 S33 d1 d1 a1 a1 r0 S04 S14

Dealing with Deadlocks
Three ways Prevention place restrictions on resource requests to make deadlock impossible Avoidance plan ahead to avoid deadlock. Recovery Check for deadlock (periodically or sporadically) and recover from it Manual intervention (the ad hoc approach) Reboot the machine if it seems too slow

Deadlock Prevention Necessary conditions for deadlock
Mutual exclusion Hold and wait Circular waiting No preemption Ensure that at least one of the necessary conditions is false at all times

Mutual Exclusion Not required for sharable resources
MUST hold for nonsharable resources

Hold and Wait Need to be sure a process does not hold one resource while requesting another Approach 1: Force a process to request all resources it needs at one time Approach 2: If a process needs to acquire a new resource, it must first release all resources it holds, then reacquire all it needs What does this say about state transition diagrams?

Hold and Wait – cont. - Requesting all resources before starting

Hold and Wait – cont. - Release of all resources before requesting more

Hold and Wait – 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.

Hold and Wait – cont. Results in poor utilization of resources
Can lead to starvation due to resource unavailability

Circular Wait Occurs when a set of n processes that hold units of a set of n different resources Impose a total ordering of all resource types, and require that each process requests resources in an increasing order of enumeration Semaphore example semaphores A and B, initialized to 1 P0 P1 wait (A); wait(A) wait (B); wait(B)

Circular Wait Have a situation in which there are K processes holding units of K resources R P Ri P holds R Pi P R P requests R

Circular Wait – cont. There is a cycle in the graph of processes and resources Choose a resource request strategy by which no cycle will be introduced Total order on all resources, then can only ask for Rj if Ri < Rj for all Ri the process is currently holding

Circular Wait – cont. Implementing this strategy
Require that each process requests resources in an increasing order of the associated numbers A process can request instances of type Ri initially After that, the process can only request instances of resource type Rj if F(Rj) > F(Ri), where F(Ri) and F(Rj) are the associated integer number It several instances of the same resource type are needed, all of them must be requested in a single request

Circular Wait – cont. Implementation – continued
Whenever a process requests an instance of resource type Rj, it must first release all the resources Ri, such that F(Ri)  F(Rj) Circular wait cannot hold if a total ordering is imposed Can be shown by contradiction

Circular Wait – cont. This is how we noticed an easy solution for the dining philosophers problem Put a total order on all forks Require that philosopher 4 become a “left-handed” philosopher (pick up the forks in a different order than the rest)

Circular Wait – cont. philosopher(int i) { while (TRUE) { ... /* Thinking */ P(fork[i]); /* Pick up left fork */ P(fork[(i+1) mod 5]; /* Pick up right fork */ eat(); V(fork[(i+1) mod 5]; V(fork[i]); } philosopher4() { P(fork[0]); /* Pick up right fork */ P(fork[4]; /* Pick up left fork */ V(fork[4]; V(fork[0]);

Allowing Preemption Allow a process to time-out on a blocked request -- withdrawing the request if it fails r = request resource w = withdraw request d = release or deallocate resource ru Si Sj wu dv ru Sk

Allowing Preemption – cont.
No guarantee that this technique will be effective System may come to set of states where a set of processes is polling for resources held by other processes in the set Livelock, since there are transitions in the state diagram (so no deadlock), but none of these transitions are effective in the long run

Avoidance Define a model of system states, then choose a strategy that will guarantee that the system will not go to a deadlock state Requires extra information, e.g., the maximum claim for each process Allows resource manager to see the worst case that could happen, then to allow transitions based on that knowledge

Deadlock Avoidance Requires that the system has some additional a priori information available Simplest and most useful model requires that each process declare 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 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 safe sequence of all processes. Sequence <P1, P2, …, Pn> is safe if for each Pi, the resources that Pi can still request can be satisfied by currently available resources + resources held by all the Pj, with j < i. 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.

Comments on Safe State It is a worst case analysis
If every process were to request its maximum claim, there would be a sequence of allocations and deallocations that could enable the system to satisfy every process’s request in some order It does not mean that the system must have enough resources to simultaneously meet all the maximum claims

More on Safe & Unsafe States
Likely to be in a safe state Probability of being in unsafe state increases Normal Execution No Request Max Claim Yes Execute, then release

Normal Execution No Request Max Claim Yes Execute, then release Suppose all processes take “yes” branch Avoidance strategy is to allow this to happen, yet still be safe

I Disallow Safe States Unsafe States Deadlock States

Note that a system could run in an unsafe state yet not enter a deadlock state The system may not be able to guarantee that every process could execute its maximum claim, but some processes may not ask for their maximum until the system returns to a safe state, hence avoiding a deadlock An unsafe state does not mean the system is in deadlock or even close – it merely means the resource manager cannot guarantee anything, and the resulting states will be determined only by the actions of the processes

Banker’s Algorithm Best known of avoidance strategies
Modeled after lending policies used by banks Each new process entering system declares the maximum use of resources it may need. When a process requests a resource it may have to wait (until system in a safe state). 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, 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. Need [i,j] = Max[i,j] – Allocation [i,j]

Safety Algorithm 1. Let Work and Finish be vectors of length m and n, respectively. Initialize: Work := Available Finish [i] = false for i - 1, 2, 3, …, n. 2. Find an i such that both: (a) Finish [i] = false (b) 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.

Example of Banker’s Algorithm
5 processes P0 through P4; 3 resource types A (10 instances), B (5 instances), and C (7 instances). Snapshot at time T0: Allocation Max Available A B C A B C A B C P P P P P

Example - cont. The content of the matrix. Need is defined to be Max – Allocation. Allocation Need Available Work A B C A B C A B C A B C P P P P P The system is in a safe state since the sequence < P1, P3, P4, P2, P0> satisfies safety criteria.

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: P1 request (1,0,2) Check that Request  Available (that is, (1,0,2)  (3,3,2)  true.) Allocation Need Available A B C A B C A B C P P P P P Executing safety algorithm shows that sequence <P1, P3, P4, P0, P2> satisfies safety requirement.

Example Continued Allocation Need Available A B C A B C A B C
Can an additional request for (3,3,0) by P4 be granted? Can an additional request for (0,2,0) by P0 be granted?

Banker’s Algorithm Assume n processes and m resources:
Let maxc[i, j] be the maximum claim for Rj by pi Let alloc[i, j] be the number of units of Rj held by pi Let ci be the number of units of each resource Ri Can always compute avail[j] = cj - S0i< nalloc[i,j] The number of available units of Rj Should be able to determine if the state is safe or not using this info

Banker’s Algorithm – cont.
Copy the alloc[i,j] table to alloc’[i,j] Given C, maxc and alloc’, compute avail vector Find pi such that maxc[i,j] - alloc’[i,j]  avail[j] for 0  j < m and 0  i < n. If no such pi exists, the state is unsafe If alloc’[i,j] is 0 for all i and j, the state is safe Set alloc’[i,j] to 0; deallocate all resources held by pi; go to Step 2

Example Maximum Claim C = <8, 5, 9, 7> Compute total allocated
Process R0 R1 R2 R3 p p p p p Compute total allocated Determine available units avail = <8-7, 5-3, 9-7, 7-5> = <1, 2, 2, 2> Can anyone’s maxc be met? maxc[2,0]-alloc’[2,0] = 5-4 = 11 = avail[0] maxc[2,1]-alloc’[2,1] = 1-0 = 12 = avail[1] maxc[2,2]-alloc’[2,2] = 0-0 = 02 = avail[2] maxc[2,3]-alloc’[2,3] = 5-3 = 22 = avail[3] Allocated Resources Process R0 R1 R2 R3 p p p p p Sum P2 can exercise max claim avail[0] = avail[0]+alloc’[2,0] = 1+4 = 5 avail[1] = avail[1]+alloc’[2,1] = 2+0 = 2 avail[2] = avail[2]+alloc’[2,2] = 2+0 = 2 avail[3] = avail[3]+alloc’[2,3] = 2+3 = 5

Process R0 R1 R2 R3 p p p p p Compute total allocated Determine available units avail = <8-7, 5-3, 9-7, 7-5> = <5, 2, 2, 5> Can anyone’s maxc be met? maxc[4,0]-alloc’[4,0] = 5-1 = 45 = avail[0] maxc[4,1]-alloc’[4,1] = 0-0 = 02 = avail[1] maxc[4,2]-alloc’[4,2] = 3-3 = 02 = avail[2] maxc[4,3]-alloc’[4,3] = 3-0 = 35 = avail[3] Allocated Resources Process R0 R1 R2 R3 p p p p p Sum P4 can exercise max claim avail[0] = avail[0]+alloc’[4,0] = 5+1 = 6 avail[1] = avail[1]+alloc’[4,1] = 2+0 = 2 avail[2] = avail[2]+alloc’[4,2] = 2+3 = 5 avail[3] = avail[3]+alloc’[4,3] = 5+0 = 5

Process R0 R1 R2 R3 p p p p p Compute total allocated Determine available units avail = <8-7, 5-3, 9-7, 7-5> = <6, 2, 5, 5> Can anyone’s maxc be met? (Yes, any of them can) Allocated Resources Process R0 R1 R2 R3 p p p p p Sum

Deadlock Detection and Recovery
Allow system to enter deadlock state Detection algorithm Recovery scheme

Detection & Recovery Check for deadlock (periodically or sporadically), then recover Can be far more aggressive with allocation No maximum claim, no safe/unsafe states Differentiate between Serially reusable resources: A unit must be allocated before being released Consumable resources: Never release acquired resources; resource count is number currently available

Deadlock Detection Algorithm
Available: A vector of length m indicates the number of available resources of each type. Allocation: An n x m matrix defines the number of resources of each type currently allocated to each process. Request: An n x m matrix indicates the current request of each process. If Request [ij] = k, then process Pi is requesting k more instances of resource type. Rj.

Detection Algorithm 1. Let Work and Finish be vectors of length m and n, respectively Initialize: (a) Work := Available (b) For i = 1,2, …, n, 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. (a) Work := Work + Allocationi; (b) Finish[i] := true; go to step 2. 4. If Finish[i] = false, for some i, 1  i  n, then the system is in deadlock state. Moreover, if Finish[i] = false, then Pi is deadlocked. Algorithm requires an order of m x n2 operations to detect whether the system is in deadlocked state.

Example of Detection Algorithm
Five processes P0 through P4; three resource types A (7 instances), B (2 instances), and C (6 instances). Snapshot at time T0: Allocation Request Available A B C A B C A B C P P P P P Sequence <P0, P2, P3, P1, P4> will result in Finish[i] = true for all i.

Example - cont. P2 requests an additional instance of type C.
Allocation Request Available A B C A B C A B C P P P P P State of system? Can reclaim resources held by process P0, but insufficient resources to fulfill other processes; requests. Deadlock exists, consisting of processes P1, P2, P3, and P4.

Reusable Resource Graphs (RRGs)
Micro model to describe a single state A directed graph such that n+m nodes represent n processes and m resources Nodes = {p0, p1, …, pn}  {R1, R2, …, Rm} Edges connect pi to Rj, or Rj to pi (pi, Rj) is a request edge for one unit of Rj (Rj, pi) is an assignment edge of one unit of Rj For each Rj there is a count, cj of units Rj Graphically represented by tokens inside Rj Number of units of Rj allocated to pi plus the number requested by pi cannot exceed cj

Example R p P holds one unit of R P requests one unit of R p R
A Deadlock State

Example Not a Deadlock State No Cycle in the Graph

State Transitions due to Request
In Sj, pi is allowed to request qch units of Rh, provided pi has no outstanding requests. Sj  Sk, where the RRG for Sk is derived from Sj by adding q request edges from pi to Rh q edges pi Rh pi Rh pi request q units State Sj State Sk of Rh

State Transition for Acquire
In Sj, pi is allowed to acquire units of Rh, iff there is (pi, Rh) in the graph, and all can be satisfied. Sj  Sk, where the RRG for Sk is derived from Sj by changing each request edge to an assignment edge. pi Rh pi Rh pi acquires units State Sj State Sk of Rh

State Transition for Release
In Sj, pi is allowed to release units of Rh, iff there is (Rh, pi) in the graph, and there is no request edge from pi. Sj  Sk, where the RRG for Sk is derived from Sj by deleting all assignment edges. pi Rh pi Rh pi releases units State Sj State Sk of Rh

Example p0 p1 S00

Example p0 p0 p1 p1 S00 S01

Example p0 p0 p0 p1 p1 p1 S00 S01 S11

Example p0 p0 p0 p0 p1 p1 p1 p1 S00 S01 S11 S21

Example p0 p0 p0 p0 p0 p1 p1 p1 p1 p1 S00 S01 S11 S21 S22

Example . . . S00 S01 S11 S21 S22 S33 p0 p0 p0 p0 p0 p0 p1 p1 p1 p1 p1

Graph Reduction Deadlock state if there is no sequence of transitions unblocking every process A RRG represents a state; can analyze the RRG to determine if there is a sequence A graph reduction represents the (optimal) action of an unblocked process. Can reduce by pi if pi is not blocked pi has no request edges, and there are (Rj, pi) in the RRG

Graph Reduction (cont)
Transforms RRG to another RRG with all assignment edges into pi removed Represents pi releasing the resources it holds pi Reducing by pi pi

Graph Reduction (cont)
A RRG is completely reducible if there a sequence of reductions that leads to a RRG with no edges A state is a deadlock state if and only if the RRG is not completely reducible.

Example RRG p0 p0 p1 p2 A C p1 p2 B p0 p1 p2 p0 p1 p2

Corresponding Detection Algorithm
Three processes P0 through P2; three resource types A (2 instances), B (2 instances), and C (1 instance). Snapshot at time T0: Allocation Request Available A B C A B C A B C P P P

Example RRG A B C A B C A B C A B C P0 1 0 1 1 0 0 0 0 0
Allocation Request Available A B C A B C A B C P P P

Consumable Resource Graphs (CRGs)
Number of units varies, have producers/consumers Nodes = {p0, p1, …, pn}  {R1, R2, …, Rm} Edges connect pi to Rj, or Rj to pi (pi, Rj) is a request edge for one unit of Rj (Rj, pi) is an producer edge (must have at least one producer for each Rj) For each Rj there is a count, wj of units Rj

State Transitions due to Request
In Sj, pi is allowed to request any number of units of Rh, provided pi has no outstanding requests. Sj  Sk, where the RRG for Sk is derived from Sj by adding q request edges from pi to Rh q edges pi Rh pi Rh pi request q units State Sj State Sk of Rh

State Transition for Acquire
In Sj, pi is allowed to acquire units of Rh, iff there is (pi, Rh) in the graph, and all can be satisfied. Sj  Sk, where the RRG for Sk is derived from Sj by deleting each request edge and decrementing wh. pi Rh pi Rh pi acquires units State Sj State Sk of Rh

State Transition for Release
In Sj, pi is allowed to release units of Rh, iff there is (Rh, pi) in the graph, and there is no request edge from pi. Sj  Sk, where the RRG for Sk is derived from Sj by incrementing wh. pi Rh pi Rh pi releases 2 units State Sj State Sk of Rh

Example p0 p0 p1 p0 p1 p0 p1 p0 p1 p1

Deadlock Detection May have a CRG that is not completely reducible, but it is not a deadlock state For each process: Find at least one sequence which leaves each process unblocked. There may be different sequences for different processes -- not necessarily an efficient approach

Deadlock Detection May have a CRG that is not completely reducible, but it is not a deadlock state Only need to find sequences, which leave each process unblocked. p0 p1

Deadlock Detection May have a CRG that is not completely reducible, but it is not a deadlock state Only need to find a set of sequences, which leaves each process unblocked.

General Resource Graphs
Have consumable and reusable resources Apply consumable reductions to consumables, and reusable reductions to reusables See Figure 10.30

GRG Example (Fig 10.30) p3 p2 R0 R2 R1 p0 p1 Reusable Not in Fig 10.30
Consumable

GRG Example (Fig 10.30) Reduce by p3 p3 p2 R0 R2 R1 p0 p1 Reusable
Consumable

GRG Example (Fig 10.30) Reduce by p0 p3 p2 R0  R2 R1 p0 p1 Reusable
Consumable

Detection-Algorithm Usage
When, and how often, to invoke depends on: How often a deadlock is likely to occur? How many processes will need to be rolled back? one for each disjoint cycle If detection algorithm is invoked arbitrarily, there may be many cycles in the resource graph and so we would not be able to tell which of the many deadlocked processes “caused” the deadlock.

Recovery No magic here Choose a blocked process
Preempt it (releasing its resources) Run the detection algorithm Iterate if until the state is not a deadlock state

Recovery from Deadlock: 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? Priority of the process. How long process has computed, and how much longer to completion. Resources the process has used. Resources process needs to complete. How many processes will need to be terminated. Is process interactive or batch?

Recovery from Deadlock: Resource Preemption
Selecting a victim – minimize cost. Rollback – return to some safe state, restart process from that state. Starvation – same process may always be picked as victim, include number of rollback in cost factor.

Combined Approach to Deadlock Handling
Combine the three basic approaches prevention avoidance detection Allowing the use of the optimal approach for each of resources in the system. Partition resources into hierarchically ordered classes. Use most appropriate technique for handling deadlocks within each class.

Deadlock.

Similar presentations

Presentation on theme: "Deadlock."— Presentation transcript:

Similar presentations

About project

Feedback

Log in

Auth with social network:

Deadlock.

Similar presentations

Presentation on theme: "Deadlock."— Presentation transcript:

Similar presentations

About project

Feedback