Concurrency: Mutual

Exclusion and
Synchronization
Chapter 5

1
 Concurrency
• Multiple applications
• Structured applications
• Operating system structure

2
Concurrency

3
 Difficulties of Concurrency
• Sharing of global resources
• Operating system managing the
allocation of resources optimally
• Difficult to locate programming errors

4
 Currency
• Communication among processes
• Sharing resources
• Synchronization of multiple processes
• Allocation of processor time

5
 Concurrency
• Multiple applications
– Multiprogramming
• Structured application
– Application can be a set of concurrent
processes
• Operating-system structure
– Operating system is a set of processes or
threads

6
 A Simple Example
void echo()
{
chin = getchar();
chout = chin;
putchar(chout);
}

7
 A Simple Example
Process P1 Process P2
. .
chin = getchar(); .
. chin = getchar();
chout = chin; chout = chin;
putchar(chout); .
. putchar(chout);
. .

8
 Operating System Concerns
• Keep track of various processes
• Allocate and deallocate resources
– Processor time
– Memory
– Files
– I/O devices
• Protect data and resources
• Output of process must be independent of
the speed of execution of other concurrent
processes
9
 Process Interaction
• Processes unaware of each other
• Processes indirectly aware of each
other
• Process directly aware of each other

10
11
 Competition Among
Processes for Resources
• Mutual Exclusion
– Critical sections
• Only one program at a time is allowed in its
critical section
• Example only one process at a time is allowed
to send command to the printer
• Deadlock
• Starvation

12
 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

13
 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
14
 Mutual Exclusion:
Hardware Support
• Interrupt Disabling
– A process runs until it invokes an operating
system service or until it is interrupted
– Disabling interrupts guarantees mutual
exclusion
– Processor is limited in its ability to interleave
programs
– Multiprocessing
• disabling interrupts on one processor will not
guarantee mutual exclusion

15
 Mutual Exclusion:
Hardware Support
• Special Machine Instructions
– Performed in a single instruction cycle
– Access to the memory location is blocked
for any other instructions

16
 Mutual Exclusion:
Hardware Support
• Test and Set Instruction
boolean testset (int i) {
if (i == 0) {
i = 1;
return true;
}
else {
return false;
}
}

17
 Mutual Exclusion:
Hardware Support
• Exchange Instruction
void exchange(int register, int memory)
{
int temp;
temp = memory;
memory = register;
register = temp;
}

18
Mutual Exclusion

19
 Mutual Exclusion Machine
Instructions
• 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

20
 Mutual Exclusion Machine
Instructions
• Disadvantages
– Busy-waiting consumes processor time
– Starvation is possible when a process leaves a
critical section and more than one process is
waiting.
– Deadlock
• If a low priority process has the critical region and a
higher priority process needs, the higher priority
process will obtain the processor to wait for the critical
region

21
 Semaphores
• Special variable called a semaphore is
used for signaling
• If a process is waiting for a signal, it is
suspended until that signal is sent

22
 Semaphores
• Semaphore is a variable that has an
integer value
– May be initialized to a nonnegative
number
– Wait operation decrements the
semaphore value
– Signal operation increments semaphore
value

23
Semaphore Primitives

24
Binary Semaphore Primitives

25
Mutual Exclusion Using
Semaphores

26
27
28
Producer/Consumer Problem
• 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

29
 Producer
producer:
while (true) {
/* produce item v */
b[in] = v;
in++;
}

30
 Consumer
consumer:
while (true) {
while (in <= out)
/*do nothing */;
w = b[out];
out++;
/* consume item w */
}
31
Producer/Consumer Problem

32
Producer with Circular Buffer
producer:
while (true) {
/* produce item v */
while ((in + 1) % n == out)
/* do nothing */;
b[in] = v;
in = (in + 1) % n
}
33
 Consumer with Circular
Buffer
consumer:
while (true) {
while (in == out)
/* do nothing */;
w = b[out];
out = (out + 1) % n;
/* consume item w */
}
34
35
36
37
38
39
 Monitors
• Monitor is a software module
• 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

40
41
42
43
44
 Message Passing
• Enforce mutual exclusion
• Exchange information

send (destination, message)

45
 Synchronization
• 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
– Called a rendezvous

46
 Synchronization
• 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

47
 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

48
 Addressing
• 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

49
50
Message Format

51
52
53
 Readers/Writers Problem
• Any number of readers may
simultaneously read the file
• Only one writer at a time may write to
the file
• If a writer is writing to the file, no
reader may read it

54
55
56