11 Chapter 3: Deadlocks Instructor: Hengming Zou, Ph.D. In Pursuit of Absolute Simplicity

11

Chapter 3: DeadlocksInstructor: Hengming Zou, Ph.D.

In Pursuit of Absolute Simplicity 求于至简，归于永恒

22

Content

Resource Deadlocks Deadlock modeling Deadlock detection and recovery Deadlock avoidance and prevention

33

Resources

Something needed by a thread A thread waits for resources Examples of computer resources

– Printers, tape drives, tables,

– locks, disk space, memory, CPU

44

Resources

Processes need access to resources– in reasonable order

Preemptable resources– can be taken away from a process with no ill effects

Nonpreemptable resources– will cause the process to fail if taken away

55

Resources

Suppose a process holds resource A – and requests resource B

At same time another process holds B – and requests A

both are blocked and remain so– Deadlock!

66

Resources

Sequence of events required to use a resource

1. request the resource

2. use the resource

3. release the resource

77

Resources

Must wait if request is denied– requesting process may be blocked

– may fail with error code

88

Deadlocks

A circular waiting for resources– leading to threads involved not being able to make progress

Deadlocks occur when …

– processes are granted exclusive access to resources

99

Deadlocks

Formal definition: A set of processes is deadlocked if:

– each process in the set is waiting for an event that only another process in the set can cause

Usually the event is release of a held resource

1010

Deadlocks

In a deadlock, none of the processes can …– run

– release resources

– be awakened

1111

Deadlocks

General structure of thread code– phase 1. while (not done) {

– acquire some resources

– work

– }

– phase 2. release all resources

Assume phase 1 has finite amount of work

1212

Deadlocks

Example

thread A thread B

lock(x) lock(y)

lock(y) lock(x)

... ...

unlock(y) unlock(x)

unlock(x) unlock(y)

1313

Deadlocks

Can deadlock occur with code? Will deadlock always occur with this code?

1414

Dining Philosophers Problem

1515

Dining Philosophers

5 philosophers sitting around a round table 1 chopstick in between each pair of philosophers

– 5 chopsticks total

Each philosopher needs two chopsticks to eat How to prevent deadlock

1616

Dining Philosophers

Algorithm for each philosopher– wait for chopstick on right to be free, then pick it up

– wait for chopstick on left to be free, then pick it up

– eat

– put both chopsticks down

Can this deadlock?

1717

Conditions for Deadlock

4 conditions must all be true for deadlock to occur Limited resource:

– not enough resources to serve all threads simultaneously

Hold and wait: – threads hold resources while waiting to acquire others

1818

Conditions for Deadlock

No preemption– can’t force thread to give up resource

Circular chain of requests

Resource BResource A

Thread A

Thread B

1919

Four Conditions for Deadlock

The first condition is sometimes called Mutual exclusion condition

– each resource assigned to 1 process or is available

Tanebaum, etc.

2020

Deadlock Modeling

Modeled with directed graphs

2121

Deadlock Modeling

Resource R assigned to process A Process B is requesting/waiting for resource S Process C and D are in deadlock

– over resources T and U

2222

Deadlock Modeling

2323

(o) (p) (q)

How deadlock can be avoided

2424

Strategies for dealing with Deadlocks

Ignore: just ignore the problem altogether Detection and recovery Dynamic avoidance: careful resource allocation Prevention:

– negating one of the four necessary conditions

2525

Ignore Strategy

Pretend there is no problem Reasonable if

– deadlocks occur very rarely

– cost of prevention is high

UNIX and Windows takes this approach a trade off between convenience & correctness

2626

Detect and Fix

Note the resource ownership and requests Detect by looking for cycles in the wait-for graph How to fix once detected?

2727

Detection with Wait-for Graph

2828


2929

An example for the deadlock detection algorithm


3030

Recovery from Deadlock

Recovery through preemption– take a resource from some other process

– depends on nature of the resource

Recovery through rollback– checkpoint a process periodically

– use this saved state

– restart the process if it is found deadlocked

3131

Recovery from Deadlock

Recovery through killing processes– crudest but simplest way to break a deadlock

– kill one of the processes in the deadlock cycle

– the other processes get its resources

– choose process that can be rerun from the beginning

3232

Deadlock Avoidance

Don’t get in a position where– Deadlock becomes possible

Use:– Resource Trajectories

3333

Safe and Unsafe States

Demonstration that the state in (a) is safe

A 3 9

B 2 4

C 2 7

Has Max

(a) Free: 3

A 3 9

B 4 4

C 2 7

Has Max

(b) Free: 1

A 3 9

B 0 －C 2 7

Has Max

(c) Free: 5

A 3 9

B 0 －C 7 7

Has Max

(d) Free: 0

3434

Safe and Unsafe States

Demonstration that the state in b is not safe

A 3 9

B 2 4

C 2 7

Has Max

(a) Free: 3

A 4 9

B 2 4

C 2 7

Has Max

(b) Free: 2

A 4 9

B 4 4

C 2 7

Has Max

(c) Free: 0

A 4 9

B －－C 2 7

Has Max

(d) Free: 4

3535

Deadlock Prevention

Idea is to eliminate one of the four necessary conditions Increase resources to decrease waiting

– this minimizes chance of deadlock

3636

Deadlock Prevention

Attacking the Mutual Exclusion Condition Attacking the Hold and Wait Condition Attacking the No Preemption Condition Attacking the Circular Wait Condition

3737

Attacking Mutual Exclusion

Some devices (such as printer) can be spooled– only the printer daemon uses printer resource

– thus deadlock for printer eliminated

Not all devices can be spooled

3838

Attacking Mutual Exclusion

Principle: Avoid assigning resource when not absolutely necessary As few processes as possible actually claim the resource

3939

Attacking Hold & Wait Condition

Processes to request resources before starting– a process never has to wait for what it needs

Eliminate hold and wait

4040


phase 1a. acquire all resources phase 1b. while (not done) { acquire some resource work } phase 2. release all resources

4141


A. wait until all resources you’ll need are free, then grab them all at once

(or) B. if you find resource busy, release all acquired resources and go back to beginning

4242


Problems? May not know required resources at start of run Ties up resources others could be using

4343


Variation: Process must give up all resources Then request all immediately needed

4444

Attacking No Preemption Condition

Allow Preemption! Can preempt CPU by saving its state to thread control block

and resuming later Can preempt memory by swapping memory out to disk and

loading it back later Can we preempt the holding of a lock?

4545

Attacking No Preemption Condition

Some resource cannot be preempted Consider a process given the printer

– halfway through its job

– now forcibly take away printer

– !!??

4646

Attacking Circular Wait Condition

Normally ordered resources– Imagesetter scanner plotter printer

A resource graph

4747

Banker’s Algorithm

Derive from methods by bankers to grant loans Similar to reserving all resources at beginning

– but more efficient

4848


State maximum resource needs in advance– but don’t actually acquire the resources

When thread later tries to acquire a resource, Banker’s algorithm determines:

– when it’s safe to satisfy the request

– and blocks the thread when it’s not safe

4949


General structure of thread code– phase 1a. state maximum resource needed

– phase 1b. while (not done) {

– acquire some resources

– work

– }

– phase 2. release all resources

5050


Preventing deadlock by requesting all resources at beginning would block thread in phase 1a above

– but phase 1b can proceed without waiting

5151


Phase 1a provides information needed to determine – when it’s safe to satisfy each resource request in phase 1b

“Safe” means guaranteeing the ability for all threads to finish – no possibility of deadlock

5252


Example: use banker’s algorithm to model a bank loaning money to its customers

5353


Bank has $6000 Customers sign up with bank and establish a credit limit

(maximum resource needed) They borrow money in stages (up to credit limit) When they’re done, they return all the money

5454

Solution #1

Bank gives money when requested– as long as the money is available

– Bank must reserve all resources when customer starts

Ann asks for credit limit of $2000 Bob asks for credit limit of $4000 Charlie asks for credit limit of $6000

5555


Can bank approve all these credit lines– if it promises to give money upon request if available?

5656

Solution #2: Banker’s Algorithm

bank approves all credit limits but customer may have to wait

– when actually asking for the money

5757


Ann asks for credit limit of $2000 (bank oks) Bob asks for credit limit of $4000 (bank oks) Charlie asks for credit limit of $6000 (bank oks) Ann takes out $1000 (bank has $5000 left) Bob takes out $2000 (bank has $3000 left) Charlie wants to take out $2000. Is this allowed?

5858


Allow iff, after giving the money, there exists some sequential order of fulfilling all maximum resources

– worst-case analysis

5959


If give $2000 to Charlie, bank will have $1000 left Ann can finish even if she takes out her max

– i.e. another $1000

When Ann finishes, she returns her money– bank will have $2000

6060


After Ann finishes, Bob can take out his max – another $2000, then finish

Then Charlie can finish– even if he takes out his max (another $4000)

6161


What about this scenario?– Ann asks for credit limit of $2000 (bank oks)

– Bob asks for credit limit of $4000 (bank oks)

– Charlie asks for credit limit of $6000 (bank oks)

– Ann takes out $1000 (bank has $5000 left)

– Bob takes out $2000 (bank has $3000 left)

– Charlie wants to take out $2500. Is this allowed?

6262


Banker allows system to over commit resources without introducing the possibility of deadlock

Sum of max resource needs of all current threads can be greater than total resources

as long as there’s some way for the all the threads to finish without getting into deadlock.

6363


How to apply banker’s algorithm to dining philosophers? Unfortunately, it’s difficult to anticipate maximum resources

needed

6464

Three resource allocation states

A 0 6

B 0 5

C 0 4

D 0 7

Has Max

(a) Free: 10

A 1 6

B 1 5

C 2 4

D 4 7

Has Max

(b) Free: 2

A 1 6

B 2 5

C 2 4

D 4 7

Has Max

(c) Free: 1

Banker's Algorithm for a Single Resource

6565

Banker's Algorithm for Multiple Resources

6666

Summary of Deadlock Prevention

Mutual Exclusion: spool everything Hold and wait: request all resources initially No preemption: takes resource away Circular wait: order resource numerically

6767

Other Issues

Two-Phase Locking Nonresource Deadlocks Starvation

6868

Two-Phase Locking

Phase One– process tries to lock all records it needs, one at a time

– if needed record found locked, start over

– (no real work done in phase one)

6969

Two-Phase Locking

If phase one succeeds, it starts second phase, – performing updates

– releasing locks

7070

Two-Phase Locking

Note similarity to requesting all resources at once Algorithm works where programmer can arrange

– program can be stopped, restarted

7171

Nonresource Deadlocks

Possible for two processes to deadlock– each is waiting for the other to do some task

Can happen with semaphores– each process required to do a down() on two semaphores

(mutex and another)

– if done in wrong order, deadlock results

7272

Starvation

Algorithm to allocate a resource – may be to give to shortest job first

Works great for multiple short jobs in a system May cause long job to be postponed indefinitely

– even though not blocked

Solution:– First-come, first-serve policy

7373

Let’s return to dining philosophers problem Approach:

– Attacking the Hold and Wait Condition

– Attacking the Circular Wait Condition

Solution to Dinning Philosopher Problem

7474

A Solution with Semaphore

#define N 5 /*# of philosophers*/

#define LEFT (i+N-1)%N /*# of I’s left neighbor*/

#define RIGHT (i+1)%N /*# of I’s right neighbor*/

#define THINKING 0

#define HUNGRY 1

#define EATING 2

typedef int semaphore;

int state[N]; /*array to keep track of everyone’s state*/

semaphore mutex=1;

semaphore s[N]; /*one semaphore per philosopher*/

7575


void philosopher(int i)

{

while(TRUE) {

think();

take_forks(i); /*acquire two forks or block*/

eat();

put_forks(i); /*put both forks on the table*/

}

}

7676


void take_forks(int i)

{

down(&mutex);

state[i]=HUNGRY;

test(i); /*try to acquire 2 forks*/

up(&mutex);

down(&s[i]); /*block if forks were not acquired*/

}

7777


void put_forks(i)

{

down(&mutex);

state[i]=THINKING;

test(LEFT); /*see if left neighbor can eat*/

test(RIGHT); /*see if right neighbor can eat*/

up(&mutex);

}

7878


void test(i)

{

if(state[i]==HUNGRY && state[LEFT]!=EATING && state[RIGHT]!=EATING) {

state[i]=EATING;

up(&s[i]);

}

}

Computer Changes Life

Documents

11 Chapter 3: Deadlocks Instructor: Hengming Zou, Ph.D. In Pursuit of Absolute Simplicity