Transcript Lec10

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
wait (A);
wait (B);
Signal(B);
Signal(A);
P1
wait(B);
wait(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.

For example:

Each waits for the other to release.

Deadlock can occur whenever there is waiting.

Example: dining philosophers
– Means you can’t decompose the problem
– can’t solve deadlock for each resource independently.
1. One thread grabs the memory it needs
2. Another grabs disk space
3. Another grabs the tape drive
– 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
Rj

Pi is holding an instance of Rj
Pi
Rj
Resource Allocation Graph Examples
Simple Resource
Allocation 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.
2.

State the maximum number of resources of each
type required in advance.
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 Needs
P0
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 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.

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
Available
ABC
ABC
ABC
P0
010
753
332
P1
200
322
P2
302
902
P3
211
222
P4
002
433

Example (Cont.)


The content of the matrix. Need = Max – Allocation.
Need
Available
ABC
ABC
P0
743
332
P1
122
P2
600
P3
011
P4
431
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
Available
ABC
ABC
ABC
P0
010
743
230
P1
302
020
P2
301
600
P3
211
011
P4
002
431
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 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. Work := Work + Allocationi
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
ABC
ABC
ABC
P0
010
000
000
P1
200
202
P2
303
000
P3
211
100
P4
002
002
 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.
Request
ABC
P0
000
P1
202
P2
001
P3
100
P4
002
 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.