Post on 19-Jan-2016
This lecture… Definition of deadlock Conditions for its occurrence Solutions for breaking and avoiding deadlock Solutions pose a dilemma:
– Simple solutions – inefficient– Complex solutions – inefficient and unpleasant
Cautionary Tale: OS/2 Every major OS since 1985 provides threads
– Makes it easier to write concurrent programs Microsoft OS/2 (circa 1988): initially, a failure IBM re-wrote it using threads for everything
– Window systems, Inter-Process Communication, …– OS/2 let you print while you worked!– Could have 100 threads, but most not on run queue
(waiting for something) Each thread needs its own stack, say 9 KB Result: System needs an extra 1MB of memory
– $200 in 1988 Moral: Threads are cheap, but they’re not free
– <$0.10 today, but context switching is expensive…
Definitions Threads – active Resources – passive, things needed by thread
to do its job – CPU, disk space, memory
Two kinds of resources:– Preemptable – can take it away
» CPU, Embedded security chip
– Non-preemptable – must leave with thread » disk space, plotter, chunk of virtual address space» Mutual exclusion – the right to enter a critical section is a
kind of resource
Resources Resources may require exclusive access or may
be sharable– Read-only files are typically sharable– Printers are not sharable during time of printing
One of the major tasks of an operating system is to manage resources
Starvation vs Deadlock Starvation – thread waits indefinitely
– Example, low-priority thread waiting for resources constantly in use by high-priority threads
Deadlock – circular waiting for resources– Example:
» I have resource A and need resource B to get my job done.» You have resource B and need resource A to get your job
done.
Deadlock implies starvation, but not vice versa– Starvation can end (but doesn’t have to)– Deadlock can’t end without external intervention.
Conditions for deadlock - Motivation Deadlock need not be deterministic:
– semaphores A and B, initialized to 1
P0 P1
wait (A); wait(B);wait (B); wait(A);Signal(B); signal(A);Signal(A); Signal(B);
– Deadlock won’t always happen with this code, but it might.» Have to have exactly the right timing (“wrong”
timing?)» So you release a piece of software, and you tested it,
and there it is, controlling a nuclear power plant
Conditions for deadlock - Motivation Deadlocks can occur with multiple resources.
– Means you can’t decompose the problem – can’t solve deadlock for each resource independently.
For example:1. One thread grabs the memory it needs2. Another grabs disk space3. Another grabs the tape drive
Each waits for the other to release.
Deadlock can occur whenever there is waiting.
Example: dining philosophers– Each philosopher needs two chopsticks to eat. Each grabs
chopstick on the right first.– What if all grab at the same time? Deadlock.
Conditions for deadlock - Need all four Mutual exclusion: only one process at a time
can use a resource. Hold and wait: wait for additional resource
while holding at least one resource. No preemption: if someone has resource, can’t
take it away. Circular wait: Circular chain of requests
Resource-Allocation Graph
A set of vertices 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.
request edge – directed edge P1 Rj
assignment edge – directed edge Rj Pi
Resource-Allocation Graph (Cont.) Process
Resource Type with 4 instances
Pi requests instance of Rj
Pi is holding an instance of Rj
Pi
PiRj
Rj
Resource Allocation Graph Examples
Simple ResourceAllocation Graph
Allocation Graph
With Deadlock
Allocation Graph With Cycle, but No Deadlock
Solutions to Deadlock Three methods for dealing with deadlock problem:
– Ensure deadlock never happens – prevention and avoidance
– Detect deadlock and fix– Ignore the problem and pretend that deadlocks never
occur; used by most operating systems - UNIX, JVM.
Deadlock prevention - eliminate one of the necessary conditions
Deadlock avoidance – list resources required by a process in advance
Deadlock Prevention Mutual Exclusion: Buy more resources, split into pieces,
or virtualize to make “infinite” copies Hold and Wait
– Make all threads request everything they’ll need at beginning.– allow process to request resources only when the process has
none. No preemption: make copies and preempt
– Can preempt main memory by copying to disk– If holding some resources and requesting other not available,
then release all Circular wait: impose a total ordering of all resource
types, and require that each process requests resources in an increasing order of enumeration
Deadlock Avoidance
1. State the maximum number of resources of each type required in advance.
2. Examine the resource-allocation state dynamically to ensure circular-wait condition does not exist.
Resource-allocation state: number of available and allocated resources, and the maximum demands of the processes.
Deadlock Avoidance Safe state: if the system can allocate resources
to each process (up to its maximum) in some order and still avoid a deadlock.– System is in safe state if there exists a safe sequence
of all processes.
Safe sequence: If for each process the resources that it can still request can be satisfied by currently available resources + resources held by all the processes preceding in the sequence.
Deadlock Avoidance If a system is in safe state no deadlocks. If a system is in unsafe state possibility of
deadlock. Example
– available - 12 magnetic tape drives, 3 processes: P0, P1, P2. At time t0
Maximum Needs Current NeedsP0 10 5
P1 4 2
P2 9 2
– At time t0, the system is in a safe state.
– The sequence <P1,P0,P2> is safe.
Deadlock Avoidance It is possible to go from a safe state to an unsafe
state. Suppose at time t1, process P2 requests and is
allocated 1 more tape drive. The system is no longer in a safe state. Avoidance ensure that a system will never
enter an unsafe state. Wait if allocation will lead to unsafe state.
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 Algorithm1. Let Work and Finish be vectors of length m and n,
respectively. Initialize:Work := AvailableFinish [i] = false for i = 1,2,3, …, n.
2. Find an i such that both: (a) Finish [i] = false(b) Needi WorkIf no such i exists, go to step 4.
3. Work := Work + Allocationi
Finish[i] := truego to step 2.
4. If Finish [i] = true for all i, then the system is in a safe state.
This algorithm may require an order of m x n2 operations to decide whether a state is safe.
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 (5 instances), and C (7 instances). Snapshot at time T0:
Allocation Max AvailableA B C A B C A B C
P0 0 1 0 7 5 3 3 3 2
P1 2 0 0 3 2 2
P2 3 0 2 9 0 2
P3 2 1 1 2 2 2
P4 0 0 2 4 3 3
Example (Cont.) The content of the matrix. Need = Max – Allocation.
Need AvailableA B C A B C
P0 7 4 3 3 3 2
P1 1 2 2
P2 6 0 0
P3 0 1 1
P4 4 3 1
The system is in a safe state since the sequence <P1, P3, P4, P2, P0> satisfies safety criteria.
Example (Cont.): P1 request (1,0,2) Check that Request Available, that is, (1,0,2) (3,3,2)
true.Allocation Need AvailableA B C A B C A B C
P0 0 1 0 7 4 3 2 3 0
P1 3 0 2 0 2 0
P2 3 0 1 6 0 0
P3 2 1 1 0 1 1
P4 0 0 2 4 3 1
Executing safety algorithm shows that sequence <P1, P3, P4, P0, P2> satisfies safety requirement.
Can request for (3,3,0) by P4 be granted? No!
Can request for (0,2,0) by P0 be granted? No!
Deadlock Detection Detection and recovery scheme requires
overhead that includes – run-time costs of maintaining the necessary information
and executing the detection algorithm, – the potential losses inherent in recovering from a
deadlock. A deadlock exists in the system if and only if the
wait-for graph contains a cycle. An algorithm to detect a cycle in a graph requires
an order of n2 operations, where n is the number of vertices in the graph.
Deadlock Detection Several Instances of a Resource Type
– 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 [i,j] = k, then process Pi is requesting k more instances of resource type Rj.
The detection algorithm investigates every possible allocation sequence for the processes that remain to be completed.
Detection Algorithm1. 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 WorkIf no such i exists, go to step 4.
3. Work := Work + AllocationiFinish[i] := truego 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 AvailableA B C A B C A B C
P0 0 1 0 0 0 0 0 0 0
P1 2 0 0 2 0 2
P2 3 0 3 0 0 0
P3 2 1 1 1 0 0
P4 0 0 2 0 0 2 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.
RequestA B C
P0 0 0 0
P1 2 0 2
P2 0 0 1
P3 1 0 0
P4 0 0 2 State of system? Deadlocked!
– 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.
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
Frequent deadlocks invoke detection algorithm frequently.
Extreme case: invoke detection algorithm every time a request for allocation cannot be granted immediately.
A less expensive alternative: invoke the algorithm at less frequent intervals – e.g. once per hour, or whenever CPU utilization drops below 40%.
Recovery from Deadlock: Process Termination Abort all deadlocked processes
– Expensive (partial results may have to be recomputed) Abort one process at a time until the deadlock cycle
is eliminated– considerable overhead (rerun deadlock-detection algorithm)
In which order should we choose the processes to abort?– Priority of the process.– How long process has computed, and how much longer to
completion.– Resources the process has used.– Resources the process needs to complete.– How many processes will need to be terminated. – Is the process interactive or batch?
Recovery from Deadlock: Resource Preemption
Selecting a victim – Which resources and which processes are to be preempted? – minimize cost.– Cost factors include the following parameters:
» number of resources held by a deadlocked process» amount of time consumed so far by the deadlocked process
Rollback – return to some safe state, restart process from that state.– Simpler to rollback completely: abort and restart– partial rollback requires more information to be recorded for all
running processes. Starvation – same process may always be picked as a victim,
– pick up a process as a victim only (small) finite number of times.– include number of rollbacks in the cost factor.
Combined Approach to Deadlock Handling Combine the three basic approaches,
– prevention– avoidance– detection
allowing the use of the optimal approach for each class of resources in the system.
Partition resources into hierarchically ordered classes.
Use most appropriate technique for handling deadlocks within each class.