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.