Operating Systems:

Internals and Design Principles, 6/E

William Stallings

Chapter 5
Concurrency: Mutual
Exclusion and
Synchronization

Dave Bremer
Otago Polytechnic, N.Z.
©2008, Prentice Hall
 Roadmap
• Principals of Concurrency
• Mutual Exclusion: Hardware Support
• Semaphores
• Monitors
• Message Passing
• Readers/Writers Problem
 Multiple Processes
• Central to the design of modern Operating
Systems is managing multiple processes
– Multiprogramming
– Multiprocessing
– Distributed Processing
• Big Issue is Concurrency
– Managing the interaction of all of these
processes
Key Terms
 Difficulties of
Concurrency
• Sharing of global resources
– Writing a shared variable: the order of writes
is important
– Incomplete writes a major problem
• Optimally managing the allocation of
resources
 A Simple Example
void echo()
{
chin = getchar();
chout = chin;
putchar(chout);
}
 A Simple Example:
On a Multiprocessor
Process P1 Process P2
. .
chin = getchar(); .
. chin = getchar();
chout = chin; chout = chin;
putchar(chout); .
. putchar(chout);
. .
 Enforce Single Access
• If we enforce a rule that only one process
may enter the function at a time then:
• P1 & P2 run on separate processors
• P1 enters echo first,
– P2 tries to enter but is blocked – P2 suspends
• P1 completes execution
– P2 resumes and executes echo
 Race Condition
• A race condition occurs when
– Multiple processes or threads read and write
data items
– They do so in a way where the final result
depends on the order of execution of the
processes.
• The output depends on who finishes the
race last.
 Operating System
Concerns
• What design and management issues are
raised by the existence of concurrency?
• The OS must
– Keep track of various processes
– Allocate and de-allocate resources
– Protect the data and resources against
interference by other processes.
– Ensure that the processes and outputs are
independent of the processing speed
Process Interaction
 Competition among
Processes for Resources
Three main control problems:
• Need for Mutual Exclusion
– Critical sections
• Deadlock
• Starvation
 Requirements for
Mutual Exclusion
• Only one process at a time is allowed in
the critical section for a resource
• A process that halts in its noncritical
section must do so without interfering with
other processes
• No deadlock or starvation
 Requirements for
Mutual Exclusion
• A process must not be delayed access to
a critical section when there is no other
process using it
• No assumptions are made about relative
process speeds or number of processes
• A process remains inside its critical section
for a finite time only
 Roadmap
• Principals of Concurrency
• Mutual Exclusion: Hardware Support
• Semaphores
• Monitors
• Message Passing
• Readers/Writers Problem
 Disabling Interrupts
• Uniprocessors only allow interleaving
• Interrupt Disabling
– A process runs until it invokes an operating
system service or until it is interrupted
– Disabling interrupts guarantees mutual
exclusion
– Will not work in multiprocessor architecture
 Pseudo-Code
while (true) {
/* disable interrupts */;
/* critical section */;
/* enable interrupts */;
/* remainder */;
}
 Special Machine
Instructions
• Compare&Swap Instruction
– also called a “compare and exchange
instruction”
• Exchange Instruction
 Compare&Swap
Instruction
int compare_and_swap (int *word,
int testval, int newval)
{
int oldval;
oldval = *word;
if (oldval == testval) *word = newval;
return oldval;
}
Mutual Exclusion (fig 5.2)
 Exchange instruction
void exchange (int register, int
memory)
{
int temp;
temp = memory;
memory = register;
register = temp;
}
Exchange Instruction
(fig 5.2)
 Hardware Mutual
Exclusion: Advantages
• Applicable to any number of processes on
either a single processor or multiple
processors sharing main memory
• It is simple and therefore easy to verify
• It can be used to support multiple critical
sections
 Hardware Mutual
Exclusion: Disadvantages
• Busy-waiting consumes processor time
• Starvation is possible when a process
leaves a critical section and more than one
process is waiting.
– Some process could indefinitely be denied
access.
• Deadlock is possible
 Roadmap
• Principals of Concurrency
• Mutual Exclusion: Hardware Support
• Semaphores
• Monitors
• Message Passing
• Readers/Writers Problem
 Semaphore
• Semaphore:
– An integer value used for signalling among
processes.
• Only three operations may be performed
on a semaphore, all of which are atomic:
– initialize,
– Decrement (semWait)
– increment. (semSignal)
Semaphore Primitives
Binary Semaphore
Primitives
 Strong/Weak
Semaphore
• A queue is used to hold processes waiting
on the semaphore
– In what order are processes removed from
the queue?
• Strong Semaphores use FIFO
• Weak Semaphores don’t specify the
order of removal from the queue
Example of Strong
Semaphore Mechanism
Example of Semaphore
Mechanism
Mutual Exclusion Using
Semaphores
Processes Using
Semaphore
 Producer/Consumer
Problem
• General Situation:
– One or more producers are generating data and
placing these in a buffer
– A single consumer is taking items out of the buffer
one at time
– Only one producer or consumer may access the
buffer at any one time
• The Problem:
– Ensure that the Producer can’t add data into full buffer
and consumer can’t remove data from empty buffer

Producer/Consumer Animation
Buffer
 Functions
• Assume an infinite buffer b with a linear array of elements
• In: next free slot out: First full position in buffer

Producer Consumer

while (true) { while (true) {

/* produce item v */ while (in <= out)
b[in] = v; /*do nothing */;
in++; w = b[out];
} out++;
/* consume item w */
}
Bounded Buffer
Producer Consumer

while (true) { while (true) {

/* produce item v */ while (in ==
while ((in + 1) % n out)
/* do
== out) /* do nothing */;
nothing */; w = b[out];
b[in] = v; out = (out + 1)
in = (in + 1) % n % n;
} /* consume
item w */
}
 Functions in a
Bounded Buffer
• . Producer Consumer
while (true) { while (true) {
/* produce item v */ while (in == out)
while ((in + 1) % n == out) /* do nothing */;
w = b[out];
/* do nothing */;
out = (out + 1) % n;
b[in] = v; /* consume item w */
in = (in + 1) % n }
}
Semaphores
Semaphores
 Roadmap
• Principals of Concurrency
• Mutual Exclusion: Hardware Support
• Semaphores
• Monitors
• Message Passing
• Readers/Writers Problem
 Monitors
• The monitor is a programming-language
construct that provides equivalent
functionality to that of semaphores and
that is easier to control.
• Implemented in a number of programming
languages, including
– Concurrent Pascal, Pascal-Plus,
– Modula-2, Modula-3, and Java.
 Chief characteristics
• Local data variables are accessible only
by the monitor
• Process enters monitor by invoking one of
its procedures
• Only one process may be executing in the
monitor at a time
 Synchronization
• Synchronisation achieved by condition
variables within a monitor
– only accessible by the monitor.
• Monitor Functions:
–Cwait(c): Suspend execution of the calling
process on condition c
–Csignal(c) Resume execution of some process
blocked after a cwait on the same condition
Structure of a Monitor
Bounded Buffer Solution
Using Monitor
Solution Using Monitor
 Bounded
Buffer Monitor
 Roadmap
• Principals of Concurrency
• Mutual Exclusion: Hardware Support
• Semaphores
• Monitors
• Message Passing
• Readers/Writers Problem
 Process Interaction
• When processes interact with one another,
two fundamental requirements must be
satisfied:
– synchronization and
– communication.
• Message Passing is one solution to the
second requirement
– Added bonus: It works with shared memory
and with distributed systems
 Message Passing
• The actual function of message passing is
normally provided in the form of a pair of
primitives:
• send (destination, message)
• receive (source, message)
 Synchronization
• Communication requires synchronization
– Sender must send before receiver can receive
• What happens to a process after it issues
a send or receive primitive?
– Sender and receiver may or may not be
blocking (waiting for message)
 Blocking send,
Blocking receive
• Both sender and receiver are blocked until
message is delivered
• Known as a rendezvous
• Allows for tight synchronization between
processes.
 Non-blocking Send
• More natural for many concurrent
programming tasks.
• Nonblocking send, blocking receive
– Sender continues on
– Receiver is blocked until the requested
message arrives
• Nonblocking send, nonblocking receive
– Neither party is required to wait
 Addressing
• Sendin process need to be able to specify
which process should receive the
message
– Direct addressing
– Indirect Addressing
 Direct Addressing
• Send primitive includes a specific identifier
of the destination process
• Receive primitive could know ahead of
time which process a message is
expected
• Receive primitive could use source
parameter to return a value when the
receive operation has been performed
 Indirect addressing
• Messages are sent to a shared data
structure consisting of queues
• Queues are called mailboxes
• One process sends a message to the
mailbox and the other process picks up
the message from the mailbox
Indirect Process
Communication
General Message Format
Mutual Exclusion Using
Messages
Producer/Consumer
Messages
 Roadmap
• Principals of Concurrency
• Mutual Exclusion: Hardware Support
• Semaphores
• Monitors
• Message Passing
• Readers/Writers Problem
 Readers/Writers Problem
• A data area is shared among many
processes
– Some processes only read the data area,
some only write to the area
• Conditions to satisfy:
1.Multiple readers may read the file at once.
2.Only one writer at a time may write
3.If a writer is writing to the file, no reader may
read it.
interaction of readers and
writers.
Readers have Priority
Writers have Priority
Writers have Priority
Message Passing
Message Passing