Deadlocks: Part IIDetection and Recovery

2

Dining Philophers Problem

• Five chopsticks/Five philosophers (really cheap restaurant)– Free-for all: Philosopher will grab any one they can– Need two chopsticks to eat

• What if all grab at same time?– Deadlock!

• How to prevent deadlock?– Make one of them give up a chopstick (Hah!)– Eventually everyone will get chance to eat

• How to avoid deadlock?– Never let philosopher take last chopstick if no philosopher has two

chopsticks afterwards

3

Four requirements for Deadlock• Mutual exclusion

– Only one thread at a time can use a resource.

• Hold and wait– Thread holding at least one resource is waiting to acquire

additional resources held by other threads

• No preemption– Resources are released only voluntarily by the thread holding the

resource, after thread is finished with it

• Circular wait– There exists a set {T1, …, Tn} of waiting threads

• T1 is waiting for a resource that is held by T2

• T2 is waiting for a resource that is held by T3

• …

• Tn is waiting for a resource that is held by T1

4

• We saw that you can prevent deadlocks. – By negating one of the four necessary conditions. (which are..?)

• We saw that the OS can schedule processes in a careful way so as to avoid deadlocks.– Using a resource allocation graph.– Banker’s algorithm.– What are the downsides to these?

The story so far..

5

Techniques for Preventing Deadlock• Infinite resources

– Include enough resources so that no one ever runs out of resources. Doesn’t have to be infinite, just large

– Give illusion of infinite resources (e.g. virtual memory)– Examples:

• Brooklyn bridge with 12,000 lanes. Never wait!• Infinite disk space (not realistic yet?)

• No Sharing of resources (totally independent threads)– Not very realistic

• Don’t allow waiting – How the phone company avoids deadlock

• Call to your Mom in Toledo, works its way through the phone lines, but if blocked get busy signal.

– Technique used in Ethernet/some multiprocessor nets• Everyone speaks at once. On collision, back off and retry

– Inefficient, since have to keep retrying• Consider: driving to New York City; when hit traffic jam, suddenly you’re

transported back home and told to retry!

6

Techniques for Preventing Deadlock (con’t)

• Make all threads request everything they’ll need at the beginning.– Problem: Predicting future is hard, tend to over-estimate resources– Example:

• If need 2 chopsticks, request both at same time

• Don’t leave home until we know no one is using any intersection between here and where you want to go; only one car on the Bay Bridge at a time

• Force all threads to request resources in a particular order preventing any cyclic use of resources– Thus, preventing deadlock– Example (x.P, y.P, z.P,…)

• Make tasks request disk, then memory, then…

• Keep from deadlock on freeways around SF by requiring everyone to go clockwise

7

• Toward right idea: – State maximum resource needs in advance– Allow particular thread to proceed if:

(available resources - #requested) max remaining that might be needed by any thread

• Banker’s algorithm (less conservative):– Allocate resources dynamically

• Evaluate each request and grant if some ordering of threads is still deadlock free afterward

• Technique: pretend each request is granted, then run safety algorithm, - Check for ([Maxnode]-[Allocnode] ≤ [Avail])- Grant request if result is deadlock free (conservative!)

• Keeps system in a “SAFE” state, i.e. there exists a sequence {P1, P2, … Pn} with P1 requesting all remaining resources, finishing, then T2 requesting all remaining resources, etc..

– Algorithm allows the sum of maximum resource needs of all current threads to be greater than total resources

Banker’s Algorithm for Avoiding Deadlock

8

Banker’s Algorithm

• Decides whether to grant a resource request. • Data structures:

n: integer # of processesm: integer # of resourcesavailable[1..m] available[i] is # of avail resources of type imax[1..n,1..m] max demand of each Pi for each Riallocation[1..n,1..m] current allocation of resource Rj to Pineed[1..n,1..m] max # resource Rj that Pi may still request

needi = maxi - allocationi

let request[i] be vector of # of resource Rj Process Pi wants

9

Basic Algorithm

1. If request[i] > need[i] then error (asked for too much)

2. If request[i] > available[i] then wait (can’t supply it now)

3. Resources are available to satisfy the requestLet’s assume that we satisfy the request. Then we would have:

available = available - request[i]allocation[i] = allocation [i] + request[i]need[i] = need [i] - request [i]

Now, check if this would leave us in a safe state:if yes, grant the request, if no, then leave the state as is and cause process to

wait.

10

Safety Check

free[1..m] = available /* how many resources are available */finish[1..n] = false (for all i) /* none finished yet */

Step 1: Find an i such that finish[i]=false and need[i] <= work /* find a proc that can complete its request now */ if no such i exists, go to step 3 /* we’re done */

Step 2: Found an i:finish [i] = true /* done with this process */

free = free + allocation [i] /* assume this process were to finish, and its allocation back to the available list */

go to step 1

Step 3: If finish[i] = true for all i, the system is safe. Else Not

11

Banker’s Algorithm: Example Allocation Max Available

A B C A B C A B CP0 0 1 0 7 5 3 3 3 2P1 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

this is a safe state: safe sequence <P1, P3, P4, P2, P0>

Suppose that P1 requests (1,0,2)

- add it to P1’s allocation and subtract it from Available

12

Banker’s Algorithm: Example Allocation Max Available

A B C A B C A B CP0 0 1 0 7 5 3 2 3 0P1 3 0 2 3 2 2 P2 3 0 2 9 0 2 P3 2 1 1 2 2 2 P4 0 0 2 4 3 3

This is still safe: safe seq <P1, P3, P4, P0, P2>

In this new state,P4 requests (3,3,0)

not enough available resources

P0 requests (0,2,0)

let’s check resulting state

13

Banker’s Algorithm: Example Allocation Max Available

A B C A B C A B CP0 0 3 0 7 5 3 2 1 0P1 3 0 2 3 2 2 P2 3 0 2 9 0 2 P3 2 1 1 2 2 2 P4 0 0 2 4 3 3

This is unsafe state (why?)

So P0’s request will be denied

Problems with Banker’s Algorithm?

14

Banker’s Algorithm Example

• Banker’s algorithm with dining philosophers– “Safe” (won’t cause deadlock) if when try to grab chopstick either:

• Not last chopstick• Is last chopstick but someone will have

two afterwards– What if k-handed lawyers? Don’t allow if:

• It’s the last one, no one would have k• It’s 2nd to last, and no one would have k-1• It’s 3rd to last, and no one would have k-2• …

15

Remaining deadlock discussion

• Solutions for deadlock detection and recovery

16

Deadlock Detection & Recovery

• If neither avoidance or prevention is implemented, deadlocks can (and will) occur.

• Coping with this requires:– Detection: finding out if deadlock has occurred

• Keep track of resource allocation (who has what)

• Keep track of pending requests (who is waiting for what)

– Recovery: untangle the mess.

• Expensive to detect, as well as recover

17

Using the RAG Algorithm to detect deadlocks

• Suppose there is only one instance of each resource• Example 1: Is this a deadlock?

– P1 has R2 and R3, and is requesting R1– P2 has R4 and is requesting R3– P3 has R1 and is requesting R4

• Example 2: Is this a deadlock?– P1 has R2, and is requesting R1 and R3– P2 has R4 and is requesting R3– P3 has R1 and is requesting R4

• Use a wait-for graph:– Collapse resources– An edge PiPk exists only if RAG has PiRj & Rj Pk – Cycle in wait-for graph deadlock!

18

Resource-Allocation Graph and Wait-for Graph

Resource-Allocation Graph Corresponding wait-for graph

19

2nd Detection Algorithm

• What if there are multiple resource instances?

• Data structures:

n: integer # of processesm: integer # of resourcesavailable[1..m] available[i] is # of avail resources of type irequest[1..n,1..m] max demand of each Pi for each Riallocation[1..n,1..m] current allocation of resource Rj to Pifinish[1..n] true if Pi’s request can be satisfied

let request[i] be vector of # instances of each resource Pi wants

20

2nd Detection Algorithm

1. work[]=available[]

for all i < n, if allocation[i] 0

then finish[i]=false else finish[i]=true

2. find an index i such that:

finish[i]=false;

request[i]<=work

if no such i exists, go to 4.

3. work=work+allocation[i]

finish[i] = true, go to 2

4. if finish[i] = false for some i,

then system is deadlocked with Pi in deadlock

21

Example

Finished = {F, F, F, F}; Work = Available = (0, 0, 1);

R1 R2 R3

P1 1 1 1

P2 2 1 2

P3 1 1 0

P4 1 1 1

R1 R2 R3

P1 3 2 1

P2 2 2 1

P3 0 0 1

P4 1 1 1

Allocation Request

22

Example

Finished = {F, F, T, F}; Work = (1, 1, 1);

R1 R2 R3

P1 1 1 1

P2 2 1 2

P3 1 1 0

P4 1 1 1

R1 R2 R3

P1 3 2 1

P2 2 2 1

P3

P4 1 1 1

Allocation Request

23

Example

Finished = {F, F, T, T}; Work = (2, 2, 2);

R1 R2 R3

P1 1 1 1

P2 2 1 2

P3 1 1 0

P4 1 1 1

R1 R2 R3

P1 3 2 1

P2 2 2 1

P3

P4

Allocation Request

24

Example

Finished = {F, T, T, T}; Work = (4, 3, 4);

R1 R2 R3

P1 1 1 1

P2 2 1 2

P3 1 1 0

P4 1 1 1

R1 R2 R3

P1 3 2 1

P2

P3

P4

Allocation Request

25

Example

Finished = {T, T, T, T}; Work = (4, 3, 4);

R1 R2 R3

P1

P2

P3

P4

R1 R2 R3

P1

P2

P3

P4

Allocation Request

26

When to run Detection Algorithm?

• For every resource request?• For every request that cannot be immediately satisfied?• Once every hour?• When CPU utilization drops below 40%?

27

Deadlock Recovery

• Killing one/all deadlocked processes– Crude, but effective– Keep killing processes, until deadlock broken– Repeat the entire computation

• Preempt resource/processes until deadlock broken– Selecting a victim (# resources held, how long executed)– Rollback (partial or total)– Starvation (prevent a process from being executed)

28

FYI: Java 1.5 Concurrency Tools

• java.lang.management.ThreadMXBean.findDeadlockedThreads()– Part of the JVM management API– Can be used to detect deadlocks: returns you the threadIDs of threads currently

blocking waiting to enter an object (and “ownable synchronizers”)– “It might be an expensive operation” - so when would you run it?

• java.util.concurrent.Semaphore (and thus mutex)

.CountDownLatch & .CountDownLatch.Exchanger (Nice - similar in flavor to co-routines from e.g. Scheme/Lisp)

• java.util.concurrent.atomic– A toolkit of classes that support lock-free programming (given H/W support):

AtomicInteger aint = new AtomicInteger(42);aint.compareAndSet(whatIThinkItIs, whatIWantItToBe); //No lock needed..

• ..and more. Check out the following if interested:– http://java.sun.com/j2se/1.5.0/docs/guide/concurrency/overview.html– http://www-128.ibm.com/developerworks/java/library/j-jtp10264/…but of course, you can’t use this in 414.. :o)

29

Summary• Dining Philosophers Problem

– Highlights need to multiplex resources– Context to discuss starvation, deadlock, livelock

• Four conditions for deadlocks– Mutual exclusion

• Only one thread at a time can use a resource– Hold and wait

• Thread holding at least one resource is waiting to acquire additional resources held by other threads

– No preemption• Resources are released only voluntarily by the threads

– Circular wait set {T1, …, Tn} of threads with a cyclic waiting pattern

30

Summary (2) • Techniques for addressing Deadlock

– Allow system to enter deadlock and then recover– Ensure that system will never enter a deadlock– Ignore the problem and pretend that deadlocks never occur in the

system

• Deadlock prevention– Prevent one of four necessary conditions for deadlock

• Deadlock avoidance– Assesses, for each allocation, whether it has the potential to lead

to deadlock– Banker’s algorithm gives one way to assess this

• Deadlock detection and recover – Attempts to assess whether waiting graph can ever make progress– Recover it not