Operating Systems:

Internals and Design Principles, 6/E

William Stallings

Chapter 6
Concurrency: Deadlock and
Click to edit MasterStarvation
subtitle style

7/11/10
 Today's Agenda
- Assignments: Problem Set #3, Prog #2
- Quiz: Deadlocks
- Principles of Deadlock, Chapter #6
 Roadmap
• Principals of Deadlock
– Deadlock prevention
– Deadlock Avoidance
– Deadlock detection
– An Integrated deadlock strategy
• Dining Philosophers Problem
• Concurrency Mechanisms in UNIX, Linux,
Solaris and Windows
 Deadlock
• A set of processes is deadlocked when
each process in the set is blocked awaiting
an event that can only be triggered by
another blocked process in the set
– Typically involves processes competing for
the same set of resources
• No efficient solution
 Potential Deadlock
I need I need
quad C quad B and
and B C

I need
I need quad A and
quad D B
and A
 Actual Deadlock
HALT until HALT until
D is free C is free

HALT until
HALT until B is free
A is free
 Two Processes P and Q
• Lets look at this with
two processes P and Q
• Each needing
exclusive access to a
resource A and B for a
period of time
 Joint Progress
Diagram of Deadlock
 Alternative logic
• Suppose that P does
not need both
resources at the same
time so that the two
processes have this
form
 Diagram of
alternative logic
 Resource Categories
Two general categories of resources:
• Reusable
– can be safely used by only one process at a
time and is not depleted by that use.
• Consumable
– one that can be created (produced) and
destroyed (consumed).
 Reusable Resources
• Such as:
– Processors, I/O channels, main and
secondary memory, devices, and data
structures such as files, databases, and
semaphores
• Deadlock occurs if each process holds
one resource and requests the other
 Example of
Reuse Deadlock
• Consider two processes that compete for
exclusive access to a disk file D and a
tape drive T.
• Deadlock occurs if each process holds
one resource and requests the other.
Reusable Resources
Example
 Example 2:
Memory Request
• Space is available for allocation of
200Kbytes, and the following sequence of
events occur
P1 P2
... ...
Request 80 Kbytes; Request 70 Kbytes;
... ...
Request 60 Kbytes; Request 80 Kbytes;

• Deadlock occurs if both processes

progress to their second request
 Consumable Resources
• Such as Interrupts, signals, messages,
and information in I/O buffers
• Deadlock may occur if a Receive message
is blocking
• May take a rare combination of events to
cause deadlock
 Example of Deadlock
• Consider a pair of processes, in which
each process attempts to receive a
message from the other process and then
send a message to the other process
 Resource Allocation
Graphs
• Directed graph that depicts a state of the
system of resources and processes
Resource Allocation
Graphs of deadlock
 Conditions for
possible Deadlock
• Mutual exclusion
– Only one process may use a resource at a
time
• Hold-and-wait
–
A process may hold allocated resources while
awaiting assignment of others
• No pre-emption
– No resource can be forcibly removed form a
process holding it
 Actual Deadlock
Requires …
All previous 3 conditions plus:
• Circular wait
– A closed chain of processes exists, such that
each process holds at least one resource
needed by the next process in the chain
 Dealing with Deadlock
• Three general approaches exist for
dealing with deadlock.
– Prevent deadlock
– Avoid deadlock
– Detect Deadlock
 Roadmap
• Principals of Deadlock
– Deadlock prevention
– Deadlock Avoidance
– Deadlock detection
– An Integrated deadlock strategy
• Dining Philosophers Problem
• Concurrency Mechanisms in UNIX, Linux,
Solaris and Windows
 Deadlock Prevention
Strategy
• Design a system in such a way that the
possibility of deadlock is excluded.
• Two main methods
–
Indirect – prevent all three of the necessary
conditions occurring at once
– Direct – prevent circular waits
 Deadlock Prevention
Conditions 1 & 2
• Mutual Exclusion
– Must be supported by the OS

• Hold and Wait

– Require a process request all of its required
resources at one time
 Deadlock Prevention
Conditions 3 & 4
• No Preemption
– Process must release resource and request
again
– OS may preempt a process to require it
releases its resources

• Circular Wait
– Define a linear ordering of resource types
 Roadmap
• Principals of Deadlock
– Deadlock prevention
– Deadlock Avoidance
– Deadlock detection
– An Integrated deadlock strategy
• Dining Philosophers Problem
• Concurrency Mechanisms in UNIX, Linux,
Solaris and Windows
 Deadlock Avoidance
• A decision is made dynamically whether
the current resource allocation request
will, if granted, potentially lead to a
deadlock
• Requires knowledge of future process
requests
 Two Approaches to
Deadlock Avoidance
• Process Initiation Denial
– Do not start a process if its demands might
lead to deadlock

• Resource Allocation Denial

– Do not grant an incremental resource request
to a process if this allocation might lead to
deadlock
 Process
Initiation Denial
• A process is only started if the maximum
claim of all current processes plus those of
the new process can be met.
• Not optimal,
– Assumes the worst: that all processes will
make their maximum claims together.
 Resource
Allocation Denial
• Referred to as the banker’s algorithm
– A strategy of resource allocation denial
• Consider a system with fixed number of
resources
– State of the system is the current allocation of
resources to process
– Safe state is where there is at least one
sequence that does not result in deadlock
– Unsafe state is a state that is not safe
 Determination of
Safe State
• A system consisting of four processes and
three resources.
• Allocations are made to processors
• Is this a safe state?

Resources
Amount of available
Existing after
Resources allocation
 Process i
• Cij - Aij ≤ Vj, for all j
• This is not possible for P1,
– which has only 1 unit of R1 and requires 2
more units of R1, 2 units of R2, and 2 units of
R3.
• If we assign one unit of R3 to process P2,
– Then P2 has its maximum required resources
allocated and can run to completion and
return resources to ‘available’ pool
 After P2
runs to completion
• Can any of the remaining processes can
be completed?

Note P2 is
completed
After P1 completes
 P3 Completes

Thus, the state defined

originally is a safe
state.
Determination of an
Unsafe State
This time
Suppose that
P1 makes the
request for one
additional unit
each of R1 and
R3.
Is this safe?
 Deadlock Avoidance
• When a process makes a request for a set
of resources,
– assume that the request is granted,
– Update the system state accordingly,
• Then determine if the result is a safe state.
–
If so, grant the request and,
– if not, block the process until it is safe to grant
the request.
Deadlock Avoidance
Logic
Deadlock Avoidance
Logic
 Deadlock Avoidance
Advantages
• It is not necessary to preempt and rollback
processes, as in deadlock detection,
• It is less restrictive than deadlock
prevention.
 Deadlock Avoidance
Restrictions
• Maximum resource requirement must be
stated in advance
• Processes under consideration must be
independent and with no synchronization
requirements
• There must be a fixed number of
resources to allocate
• No process may exit while holding
resources
 Roadmap
• Principals of Deadlock
– Deadlock prevention
– Deadlock Avoidance
– Deadlock detection
– An Integrated deadlock strategy
• Dining Philosophers Problem
• Concurrency Mechanisms in UNIX, Linux,
Solaris and Windows
 Deadlock Detection
• Deadlock prevention strategies are very
conservative;
– limit access to resources and impose
restrictions on processes.
• Deadlock detection strategies do the
opposite
– Resource requests are granted whenever
possible.
– Regularly check for deadlock
 A Common
Detection Algorithm
• Use a Allocation matrix and Available
vector as previous
• Also use a request matrix Q
–
Where Qij indicates that an amount of
resource j is requested by process I
• First ‘un-mark’ all processes that are not
deadlocked
– Initially that is all processes
 Detection Algorithm
1. Mark each process that has a row in the
Allocation matrix of all zeros.
2. Initialize a temporary vector W to equal
the Available vector.
3. Find an index i such that process i is
currently unmarked and the ith row of Q is
less than or equal to W.
– i.e. Qik ≤ Wk for 1 ≤ k ≤ m.
– If no such row is found, terminate
 Detection Algorithm cont.
4. If such a row is found,
– mark process i and add the corresponding
row of the allocation matrix to W.
– i.e. set Wk = Wk + Aik, for 1 ≤ k ≤ m
Return to step 3.
• A deadlock exists if and only if there are
unmarked processes at the end
• Each unmarked process is deadlocked.
Deadlock Detection
 Recovery Strategies
Once Deadlock Detected
• Abort all deadlocked processes
• Back up each deadlocked process to
some previously defined checkpoint, and
restart all process
– Risk or deadlock recurring
• Successively abort deadlocked processes
until deadlock no longer exists
• Successively preempt resources until
deadlock no longer exists
 Advantages
and Disadvantages
 Roadmap
• Principals of Deadlock
– Deadlock prevention
– Deadlock Avoidance
– Deadlock detection
– An Integrated deadlock strategy
• Dining Philosophers Problem
• Concurrency Mechanisms in UNIX, Linux,
Solaris and Windows
Dining Philosophers
Problem: Scenario
 The Problem
• Devise a ritual (algorithm) that will allow
the philosophers to eat.
– No two philosophers can use the same fork at
the same time (mutual exclusion)
– No philosopher must starve to death (avoid
deadlock and starvation … literally!)
A first solution using
semaphores
Avoiding deadlock
Solution using Monitors
Monitor solution cont.
 Roadmap
• Principals of Deadlock
– Deadlock prevention
– Deadlock Avoidance
– Deadlock detection
– An Integrated deadlock strategy
• Dining Philosophers Problem
• Concurrency Mechanisms in UNIX, Linux,
Solaris and Windows
 UNIX Concurrency
Mechanisms
• UNIX provides a variety of mechanisms for
interprocessor communication and
synchronization including:
– Pipes
–
Messages
– Shared memory
–
Semaphores
– Signals
 Pipes
• A circular buffer allowing two processes to
communicate on the producer-consumer
model
– first-in-first-out queue, written by one process
and read by another.
• Two types:
– Named:
– Unnamed
 Messages
• A block of bytes with an accompanying
type.
• UNIX provides msgsnd and msgrcv
system calls for processes to engage in
message passing.
• Associated with each process is a
message queue, which functions like a
mailbox.
 Shared Memory
• A common block of virtual memory shared
by multiple processes.
• Permission is read-only or read-write for a
process,
– determined on a per-process basis.
• Mutual exclusion constraints are not part
of the shared-memory facility but must be
provided by the processes using the
shared memory.
 Semaphores
• SVR4 uses a generalization of the
semWait and semSignal primitives
defined in Chapter 5;
• Associated with the semaphore are
queues of processes blocked on that
semaphore.
 Signals
• A software mechanism that informs a
process of the occurrence of
asynchronous events.
– Similar to a hardware interrupt, without
priorities
• A signal is delivered by updating a field in
the process table for the process to which
the signal is being sent.
Signals defined for
UNIX SVR4.
 Linux Kernel
Concurrency Mechanism
• Includes all the mechanisms found in
UNIX plus
– Atomic operations
– Spinlocks
– Semaphores (slightly different to SVR4)
– Barriers
 Atomic Operations
• Atomic operations execute without
interruption and without interference
• Two types:
–
Integer operations – operating on an integer
variable
– Bitmap operations – operating on one bit in a
bitmap
Linux Atomic Operations
Linux Atomic Operations
 Spinlock
• Only one thread at a time can acquire a
spinlock.
– Any other thread will keep trying (spinning)
until it can acquire the lock.
• A spinlock is an integer
– If 0, the thread sets the value to 1 and enters
its critical section.
– If the value is nonzero, the thread continually
checks the value until it is zero.
Linux Spinlocks
 Semaphores
• Similar to UNIX SVR4 but also provides an
implementation of semaphores for its own
use.
• Three types of kernel semaphores:
– Binary semaphores
– counting semaphores,
– reader-writer semaphores.
Linux Semaphores
 Barriers
• To enforce the order in which instructions
are executed, Linux provides the memory
barrier facility.
 Solaris Thread
Synchronization Primitives
• In addition to the concurrency
mechanisms of UNIX SVR4
– Mutual exclusion (mutex) locks
– Semaphores
– Multiple readers, single writer (readers/writer)
locks
– Condition variables
Solaris Synchronization
Data Structures
 MUTEX Lock
• A mutex is used to ensure only one thread
at a time can access the resource
protected by the mutex.
• The thread that locks the mutex must be
the one that unlocks it.
 Semaphores and
Read/Write locks
• Solaris provides classic counting
semaphores.
• The readers/writer lock allows multiple
threads to have simultaneous read-only
access to an object protected by the lock.
– It also allows a single thread to access the
object for writing at one time, while excluding
all readers.
 Condition Variables
• A condition variable is used to wait until a
particular condition is true.
• Condition variables must be used in
conjunction with a mutex lock.
 Windows concurrency
mechanisms
• Windows provides synchronization among
threads as part of the object architecture.
• Important methods of synchronization are
–
Executive dispatcher objects (using Wait
functions),
– user mode critical sections,
– slim reader-writer locks, and
– condition variables.
 Wait Functions
• The wait functions allow a thread to block
its own execution.
– The wait functions do not return until the
specified criteria have been met.
– The type of wait function determines the set of
criteria used.
Dispatcher Objects
 Critical Sections
• Similar mechanism to mutex
– except that critical sections can be used only
by the threads of a single process.
• If the system is a multiprocessor, the code
will attempt to acquire a spin-lock.
– As a last resort, if the spinlock cannot be
acquired, a dispatcher object is used to block
the thread so that the Kernel can dispatch
another thread onto the processor.
 Slim Read-Writer Locks
• Windows Vista added a user mode reader-
writer.
• The readerwriter lock enters the kernel to
block only after attempting to use a spin-
lock.
• ‘Slim’ as it normally only requires
allocation of a single pointer-sized piece of
memory.
 Condition Variables
• Windows Vista also added condition
variables.
• The process must declare and initialise a
CONDITION_VARIABLE
• Used with either critical sections or SRW
locks
Windows/Linux
Comparison
 Windows/Linux
Comparison cont.