Process Management

• Deadlock
– 7 Cases of Deadlock Process Synchronization
– Conditions for Deadlock
– Modeling Deadlocks
– Strategies for Handling
Deadlocks
– Avoidance
– Detection Deadlock Starvation
– Recovery Management Management
• Starvation

Understanding 2
Operating Systems
 A Lack of Process Synchronization
Causes Deadlock or Starvation
• Deadlock (“deadly embrace”) -- a system-wide tangle of
resource requests that begins when 2+ jobs are put on hold.

– Each job is waiting for a vital resource to become available.

– Needed resources are held by other jobs also waiting to run but
can’t because they’re waiting for other unavailable resources.
– The jobs come to a standstill.
– The deadlock is complete if remainder of system comes to a
standstill as well.

• Resolved via external intervention.

Understanding 3
Operating Systems
 Deadlock

• Deadlock is more serious than

indefinite postponement or
starvation because it affects
more than one job.

• Because resources are being

tied up, the entire system (not
just a few programs) is affected.

• Requires outside intervention

(e.g., operators or users
terminate a job).

Understanding 4
Operating Systems
 Seven Cases of Deadlocks

1. Deadlocks on file requests

2. Deadlocks in databases
3. Deadlocks in dedicated device allocation
4. Deadlocks in multiple device allocation
5. Deadlocks in spooling
6. Deadlocks in disk sharing
7. Deadlocks in a network

Understanding 5
Operating Systems
 Case 1 : Deadlocks on File Requests

• If jobs can request and hold

files for duration of their
execution, deadlock can occur.

• Any other programs that require

F1 or F2 are put on hold as long
as this situation continues.

• Deadlock remains until a

programs is withdrawn or
forcibly removed and its file is
released.

Understanding 6
Operating Systems
 Case 2 : Deadlocks in Databases

1. P1 accesses R1 and locks it. • Deadlock can occur if 2 processes

access & lock records in database.
2. P2 accesses R2 and locks it.
• 3 different levels of locking :
3. P1 requests R2, which is locked – entire database for duration of
request
by P2.
– a subsection of the database
– individual record until process is
4. P2 requests R1, which is locked completed.
by P1.
• If don’t use locks, can lead to a
race condition.

Understanding 7
Operating Systems
 Case 3: Deadlocks in Dedicated
Device Allocation
1. P1 requests tape drive 1 and • Deadlock can occur when
gets it. there is a limited number
of dedicated devices.
2. P2 requests tape drive 2 and
gets it.
• E.g., printers, plotters or
3. P1 requests tape drive 2 but is tape drives.
blocked.

4. P2 requests tape drive 1 but is

blocked.

Understanding 8
Operating Systems
 Case 4 : Deadlocks in Multiple
Device Allocation
• Deadlocks can happen
when several processes
request, and hold on to,
dedicated devices while
other processes act in a
similar manner.

Understanding 9
Operating Systems
 Case 5 : Deadlocks in Spooling

• Most systems have transformed dedicated devices such as

a printer into a sharable device by installing a high-speed
device, a disk, between it and the CPU.
• Disk accepts output from several users and acts as a
temporary storage area for all output until printer is ready
to accept it (spooling).
• If printer needs all of a job's output before it will begin
printing, but spooling system fills available disk space with
only partially completed output, then a deadlock can occur.

Understanding 10
Operating Systems
 Case 6 : Deadlocks in Disk Sharing

P1 Read records at Disk

cylinder 20 I/O
control
Channel
P2 Write to file at unit
cylinder 310

• Disks are designed to be shared, so it’s not uncommon for

2 processes access different areas of same disk.
• Without controls to regulate use of disk drive, competing
processes could send conflicting commands and deadlock
the system.

Understanding 11
Operating Systems
 Case 7: Deadlocks in a Network

• A network that’s
congested (or filled large
% of its I/O buffer space)
can become deadlocked if
it doesn’t have protocols
to control flow of
messages through
network.

Understanding 12
Operating Systems
 Four Conditions for Deadlock

• Deadlock preceded by simultaneous occurrence of four

conditions that operating system could have recognized:

• Mutual exclusion
• Resource holding
• No preemption
• Circular wait

Understanding 13
Operating Systems
• Mutual exclusion -- the act of allowing only one process
to have access to a dedicated resource.

• Resource holding -- the act of holding a resource and not

releasing it; waiting for the other job to retreat.

• No preemption -- the lack of temporary reallocation of

resources; once a job gets a resource it can hold on to it for
as long as it needs.

• Circular wait -- each process involved in impasse is

waiting for another to voluntarily release the resource so
that at least one will be able to continue.

Understanding 14
Operating Systems
 Modeling Deadlocks Using
Directed Graphs (Holt, 1972)
• Processes represented by circles.
• Resources represented by squares.
• Solid line from a resource to a process means that process
is holding that resource.
• Solid line from a process to a resource means that process
is waiting for that resource.
• Direction of arrow indicates flow.

• If there’s a cycle in the graph then there’s a deadlock

involving the processes and the resources in the cycle.

Understanding 15
Operating Systems
 Directed Graph Examples

R1 P1 R1

Figure 5.7 (a)

P2 P1

R2
R1 P1

Figure 5.7 (c)

Figure 5.7 (b)

Understanding 16
Operating Systems
Figure 5.8

R1 R1 R2 R2 R3 R3

P1 P1 P2 P2 P3 P3

Figure 5.9

R1 R2 R3 R1 R2 R3

P1 P2 P3 P1 P2 P3

Understanding 17
Operating Systems
 Strategies for Handling Deadlocks

• Prevent one of the four conditions from occurring.

• Avoid the deadlock if it becomes probable.

• Detect the deadlock when it occurs and recover from it

gracefully.

Understanding 20
Operating Systems
 Prevention of Deadlock

• To prevent a deadlock OS must eliminate 1 out of 4

necessary conditions.
– Same condition can’t be eliminated from every resource.

• Mutual exclusion is necessary in any computer system

because some resources (memory, CPU, dedicated devices)
must be exclusively allocated to 1 user at a time.
– Might be able to use spooling for some devices.
– May trade 1 type of deadlock (Case 3) for another (Case 5).

Understanding 21
Operating Systems
 Prevention of Resource Holding
or No Preemption
• Resource holding can be avoided by forcing each job to
request, at creation time, every resource it will need to run
to completion.
– Significantly decreases degree of multiprogramming.
– Peripheral devices would be idle because allocated to a job even
though they wouldn't be used all the time.

• No preemption could be bypassed by allowing OS to

deallocate resources from jobs.
– OK if state of job can be easily saved and restored.
– Bad if preempt dedicated I/O device or files during modification.

Understanding 22
Operating Systems
 Prevention of Circular Wait

• Circular wait can be bypassed if OS prevents formation of

a circle.
• Havender’s solution (1968) is based on a numbering
system for resources such as: printer = 1, disk = 2, tape= 3.
– Forces each job to request its resources in ascending order.
– Any “number one” devices required by job requested first; any
“number two” devices requested next …

• Require that jobs anticipate order in which they will

request resources.
– A best order is difficult to determine.

Understanding 23
Operating Systems
 Avoidance

• Even if OS can’t remove 1 conditions for deadlock, it can

avoid one if system knows ahead of time sequence of
requests associated with each of the active processes.

• Dijkstra’s Bankers Algorithm (1965) used to regulate

resources allocation to avoid deadlock.

• Safe state -- if there exists a safe sequence of all processes

where they can all get the resources needed.
• Unsafe state -- doesn’t necessarily lead to deadlock, but it
does indicate that system is an excellent candidate for one.
Understanding 24
Operating Systems
 Banker’s Algorithm

• Based on a bank with a fixed amount of capital that

operates on the following principles:
− No customer will be granted a loan exceeding bank’s total capital.
− All customers will be given a maximum credit limit when opening
an account.
− No customer will be allowed to borrow over the limit.
− The sum of all loans won’t exceed the bank’s total capital.

• OS (bank) must be sure never to satisfy a request that

moves it from a safe state to an unsafe one.
• Job with smallest number of remaining resources < = number of
available resources
Understanding 25
Operating Systems
 A Bank’s Safe and Unsafe States

Safe
Customer Loan amount Maximum credit Remaining credit
C1 0 4,000 4,000
C2 2,000 5,000 3,000
C3 4,000 8,000 4,000
Total loaned: $6,000
Total capital fund: $10,000

Unsafe
Customer Loan amount Maximum credit Remaining credit
C1 2,000 4,000 2,000
C2 3,000 5,000 2,000
C3 4,000 8,000 4,000
Total loaned: $9,000
Total capital fund: $10,000

Understanding 26
Operating Systems
 Problems with Banker’s Algorithm

1. As they enter system, jobs must state in advance the maximum number
of resources needed.
2. Number of total resources for each class must remain constant.
3. Number of jobs must remain fixed.
4. Overhead cost incurred by running the avoidance algorithm can be
quite high.
5. Resources aren’t well utilized because the algorithm assumes the worst
case.
6. Scheduling suffers as a result of the poor utilization and jobs are kept
waiting for resource allocation.

Understanding 27
Operating Systems
 Detection

• Use directed graphs to show circular wait which indicates

a deadlock.
• Algorithm used to detect circularity can be executed
whenever it is appropriate.

Understanding 28
Operating Systems
 Reducing Directed Resource Graphs

1. Find a process that is currently using a resource and not

waiting for one. Remove this process from graph and
return resource to “available list.”
2. Find a process that’s waiting only for resource classes that
aren’t fully allocated.
– Process isn’t contributing to deadlock since eventually gets
resource it’s waiting for, finish its work, and return resource to
“available list.”
3. Go back to Step 1 and continue the loop until all lines
connecting resources to processes have been removed.

Understanding 29
Operating Systems
R1 P2 P3 R1 P2 P3

P1 R2 R3 P1 R2 R3
Figure 5.12 (a)
Figure 5.12 (b)

R1 P2 P3 R1 P2 P3

P1 R2 R3 P1 R2 R3
Figure 5.12 (c)
Figure 5.12 (d)
Understanding 30
Operating Systems
 Recovery

• Once a deadlock has been detected it must be untangled

and system returned to normal as quickly as possible.

• There are several recovery algorithms, all requiring at least

one victim, an expendable job, which, when removed from
deadlock, frees system.

1. Terminate every job that’s active in system and restart

them from beginning.
2. Terminate only the jobs involved in deadlock and ask their
users to resubmit them.
Understanding 31
Operating Systems
 Recovery Algorithms - 2
3. Terminate jobs involved in deadlock one at a time,
checking to see if deadlock is eliminated after each
removal, until it has been resolved.
4. Have job keep record (snapshot) of its progress so it can be
interrupted and then continued without starting again from
the beginning of its execution.
5. Select a non-deadlocked job, preempt resources it’s
holding, and allocate them to a deadlocked process so it
can resume execution, thus breaking the deadlock
6. Stop new jobs from entering system, which allows non-
deadlocked jobs to run to completion so they’ll release
their resources (no victim).
32
Select Victim with Least-Negative Effect

• Priority of job under consideration—high-priority jobs are

usually untouched.
• CPU time used by job—jobs close to completion are
usually left alone.
• Number of other jobs that would be affected if this job
were selected as the victim.
• Programs working with databases deserve special
treatment.

Understanding 33
Operating Systems
 Starvation

• Starvation -- result of conservative allocation of

resources where a single job is prevented from execution
because it’s kept waiting for resources that never become
available.

• “The dining philosophers” Dijkstra (1968).

• Avoid starvation via algorithm designed to detect starving

jobs which tracks how long each job has been waiting for
resources (aging).

Understanding 34
Operating Systems
 Ex

Understanding 35
Operating Systems
 Terminology

• avoidance • prevention
• circular wait • process synchronization
• deadlock • race
• deadly embrace • resource holding
• detection • safe state
• directed graphs • spooling
• locking • starvation
• mutual exclusion • unsafe state
• no preemption • victim

Understanding 36
Operating Systems
 CMP 303 Test 2

Q1. (a) Is it possible to have a deadlock with 1 process only?

(b) What is the minimum number of processes that can have a deadlock amongst
themselves?

Q2. Consider the following snapshot of a system:

Allocation Max Available

A B C D A B C D A B C D
T0 0 0 1 2 0 0 1 2 1 5 2 0
T1 1 0 0 0 1 7 5 0
T2 1 3 5 4 2 3 5 6
T3 0 6 3 2 0 6 5 2
T4 0 0 1 4 0 6 5 6

Answer the following questions using the banker’s algorithm:

(a) What is the content of the matrix Need?

(b) Is the system in a safe state?

(c) If a request from thread T1 arrives for (0,4,2,0), can the request be granted immediately?

Q3.

Job No. Devices Allocated Maximum Required Remaining Needs

1 5 8
2 4 6
3 1 4
Total number of devices in the system: 12
For the System shown above, given that all of the devices are of the same type, answer these
questions:
a. How many devices are available after the initial allocations in the system?
b. Determine the “remaining needs” for each job in the system.
c. Determine whether the system is safe or unsafe.
d. If the system is in a safe state, list the sequence of requests and releases that will make it
possible for all processes to run to completion. 37
e. If the system is in an unsafe state, show how it’s possible for deadlock to occur.
 CMP 303 Test 2 (MARKING SCHEME)

Q1. (a) Is it possible to have a deadlock with 1 process only?

(b) What is the minimum number of processes that can have a deadlock
amongst themselves?

(a) No, it is not possible. With a single process, it is impossible to have

“hold and wait” condition. Now, for a deadlock, all the 4 conditions
should be TRUE simultaneously but Hold and Wait failed here. Hence,
no deadlock could be found with one process.
(b) Hence, minimum number of processes required to have a possibility
of deadlock = 2.

Understanding 38
Operating Systems
 CMP 303 Test 2 (MARKING SCHEME)…
Answer:
a. The values of Need for processes P0 through P4 , respectively, are (0, 0,
0, 0), (0, 7, 5, 0), (1, 0, 0, 2), (0, 0, 2, 0), and (0, 6, 4, 2).

b. The system is in a safe state. With Available equal to (1, 5, 2, 0), either
process P0 or P3 could run. Once process P3 runs, it releases its
resources, which allows all other existing processes to run.

c. The request can be granted immediately. The value of Available is

then (1, 1, 0, 0). One ordering of processes that can finish is P0, P2, P3,
P1, and P4.

Understanding 39
Operating Systems