1. Lecture 6: Concurrency: Mutual Exclusion and Synchronization
Operating System
Fall 2006

2. Concurrency
An OS has many concurrent processes that run in parallel but share common access
Race Condition: A situation where several processes access and manipulate the same data concurrently and the outcome of the execution depends on the particular order in which the access takes place.

3. Example for Race condition
Suppose a customer wants to book a seat on UAL 56. Ticket agent will check the #-of-seats. If it is greater than 0, he will grab a seat and decrement #-of-seats by 1.
UAL 56: #-of-seats=12
Main memory
Terminal …
Ticket Agent 1
Ticket Agent 2
Ticket Agent n

4. Example for Race condition(cont.)
Ticket Agent 1
P1: LOAD #-of-seats
P2: DEC 1
P3: STORE #-of-seats
Ticket Agent 2
Q1: LOAD #-of-seats
Q2: DEC 1
Q3: STORE #-of-seats
Ticket Agent 3
R1: LOAD #-of-seats
R2: DEC 1
R3: STORE #-of-seats
Suppose, initially, #-of-seats=12
Suppose instructions are interleaved as P1,Q1,R1,P2,Q2,R2,P3,Q3,R3
The result would be #-of-seats=11, instead of 9
To solve the above problem, we must make sure that:
P1,P2,P3 must be completely executed before we execute Q1 or R1, or
Q1,Q2,Q3 must be completely executed before we execute P1 or R1, or
R1,R2,R3 must be completely executed before we execute P1 or Q1.

5. Critical Section Problem
Critical section: a segment of code in which the process may be
changing common variables, updating a table, writing a file, and so on.
Prefix0
CS0
Suffix0 P0
Prefix1
CS1
Suffix1 P1
Prefixn-1
CSn-1
Suffixn-1
Pn-1 …
Goal: To program the processes so that, at any moment of time,
at most one of the processes is in its critical section.

6. Solution to Critical-Section Problem
Any facility to provide support for mutual exclusion should meet the following requirements:
Mutual exclusion must be enforced: Only one process at a time is allowed into its critical section
A process that halts in its noncritical section must do so without interfering with other processes.
A process waiting to enter its critical section cannot be delayed indefinitely
When no process is in a critical section, any process that requests entry to its critical section must be permitted to enter without delay.
No assumption are made about the relative process speeds or the number of processors.
A process remains inside its critical section for a finite time only.

7. Three Environments
There is no central program to coordinate the processes. The processes communicate with each other through global variable.
Special hardware instructions
There is a central program to coordinate the processes.

8. Three Environments
There is no central program to coordinate the processes. The processes communicate with each other through global variable.
Special hardware instructions
There is a central program to coordinate the processes.

9. 1st Attempt Start with just 2 processes, P0 and p1
Global variable turn, initially turn=0
Prefix0
While (turn0) do {}
CS0
turn=1
suffix0
Prefix1
While (turn1) do {}
CS1
turn=0
suffix1
The processes take turn to enter its critical section
If turn=0, P0 enters
If turn=1, P1 enters
This solution guarantees mutual exclusion.
But the drawback is that if one process leaves the system or fails,
the other will be blocked permanently.

10. 2st Attempt
Global variable flag[0] and flag[1], initially flag[0] and flag[1] are both false
Prefix0
While (flag[1]) do {}
flag[0]=true
CS0
flag[0]=false
suffix0
Prefix1
While (flag[0]) do {}
flag[1]=true
CS1
flag[1]= false
suffix1
If P0 is in critical section, flag[0] is true;
If P1 is in critical section, flag[1] is true
If one process leaves the system, it will not block the other process.
However, mutual exclusion is not guaranteed.
P0 executes the while statement and finds that flag[1] is false;
P1 executes the while statement and finds that flag[0] is false.
P0 sets flag[0] to true and enters its critical section;
P1 sets flag[1] to true and enters its critical section.

11. 3st Attempt
Global variable flag[0] and flag[1], initially flag[0] and flag[1] are both false
Prefix0
flag[0]=true
While (flag[1]) do {}
CS0
flag[0]=false
suffix0
Prefix1
flag[1]=true
While (flag[0]) do {}
CS1
flag[1]= false
suffix1
If P0 is in critical section, flag[0] is true;
If P1 is in critical section, flag[1] is true
Guarantees mutual exclusion.
But mutual blocking can occur.
P0 sets flag[0] to be true;
P1 sets flag[1] to be true;
Both will be hung in the while loop.

12. 4st Attempt
Global variable flag[0] and flag[1], initially flag[0] and flag[1] are both false
Prefix0
L0: flag[0]=true
If (flag[1]) then {
flag[0]=false;
goto L0}
CS0
flag[0]=false
suffix0
Prefix1
L1: flag[1]=true
If (flag[0]) then {
flag[1]=false;
goto L1}}
CS1
flag[1]= false
suffix1
Guarantees mutual exclusion.
mutual blocking can occur if they execute at the same speed.

13. Correct Solution Initially, flag[0]=flag[1]=false; turn=0 Prefix0
flag[0]=true
while (flag[1]) do
{ if (turn=1){
flag[0]=false;
while(turn=1) do{}
flag[0]=true; }
CS0
turn=1
flag[0]=false
suffix0
Prefix1
flag[1]=true
while (flag[0]) do
{ if (turn=0){
flag[1]=false;
while(turn=0) do{}
flag[1]=true; }
CS1
turn=0
flag[1]=false
suffix1

14. Peterson’s Algorithm for 2 processes
Initially, flag[0]=flag[1]=false
Prefix0
flag[0]=true
turn=1
while (flag[1] and turn=1) do{}
CS0
flag[0]=false
suffix0
Prefix1
flag[1]=true
turn=0
while (flag[0] and turn=0) do{}
CS1
flag[1]=false
suffix1

15. Solution for n processes
Global Variable
Flag[0..n-1] – array of size n.
Turn. Initially, Turn=some no. between 0 and n-1
Idle if Pi is outside Csi
Flag[i]=
Want-in if Pi wants to be in CSi
in-CS if Pi is in CSi

16. Solutions for n processesPi
Prefixi
Repeat
Flag[i]=want-in;
j=Turn;
while ji do {if Flag[j]idle then j=Turn else j=(j+1) mod n}
Flag[i]=in-CS
j=0
while (j<n) and (j=i or Flag[j]in-CS) do {j=j+1}
Until (jn) and (Turn=i or Flag[Turn]=idle)
Turn=i;
CSi
j=(Turn+1)mod n
While (jTurn) and (Flag[j]=idle) do{j=(i+1) mod n}
Turn=j
Flag[i]=idle

17. Three Environments
There is no central program to coordinate the processes. The processes communicate with each other through global variable.
Special hardware instructions
There is a central program to coordinate the processes.

18. Hardware Support Disable interrupt CS Enable interrupt
Won’t work if we have multiprocessors

19. Special Machine Instructions
Modern machines provide special atomic hardware instructions
Atomic = non-interruptable
Either test memory word and set value
Or swap contents of two memory words

20. TS – Test and Set Boolean TS(i)= true if i=0; it will also set i to 1
false if i=1
Initially, lock=0 Pi
Prefixi
While(¬ TS(lock)) do {}
CSi
Lock=0
suffixi
It is possible that a process may starve if 2 processes enter the
critical section arbitrarily often.
OS Fall 2005

21. TS – Test and Set (cont.)
To avoid the starvation problem, we can do the following:
Global variables: waiting[0..n-1] (boolean)
lock (integer)
Local variable: Keyi (boolean)
Initially, lock=0 and waiting[i]=false for all 0in-1 Pi
Waiting[i]=true;
Keyi=true;
While(waiting[i] and Keyi) do {Keyi=¬ TS(lock)}
Waiting[i]=false;
CSi
j=(i+1) mod n
While(ji and ¬ waiting[j]) do {j=(j+1) mod n}
if (j=i) then lock=0 else Waiting[j]=false

22. Exchange(int register, int memory)
Exchange the contents of a register with that of memory.
Shared Variable: lock, initially 0
local variable: key
Process Pi
… Prefixi
Keyi=1
While(Keyi0) do {exchange(Keyi,lock)}
CSi
Lock=0;
… suffixi
OS Fall 2005

23. Three Environments
There is no central program to coordinate the processes. The processes communicate with each other through global variable.
Special hardware instructions
There is a central program to coordinate the processes.

24. Semaphores
A variable that has an integer value upon which 3 operations are defined.
Three operations:
A semaphore may be initialized to a nonnegative value
The wait operation decrements the semaphore value. If the value becomes negative, then the process executing the wait is blocked
The signal operation increments the semaphore value. If the value is not positive, then a process blocked by a wait operation is unblocked.
Other than these 3 operations, there is no way to inspect or manipulate semaphores.

25. Wait(s) and Signal(s) Wait(s) – is also called P(s) { s=s-1;
if (s<0) {place this process in a waiting queue} }
Signal(s) – is also called V(s)
s=s+1;
if(s0) {remove a process from the waiting queue}

26. Semaphore as General Synchronization Tool
Counting semaphore – integer value can range over an unrestricted domain
Binary semaphore – integer value can range only between 0 and 1; can be simpler to implement
Also known as mutex locks
Wait B(s) s is a binary semaphore {
if s=1 then s=0 else block this process }
Signal B(s)
if there is a blocked process then unblock a process else s=1
Can implement a counting semaphore S as a binary semaphore

27. Note
The wait and signal primitives are assumed to be atomic; they cannot be interrupted and each routine can be treated as an indivisible step.

28. Mutual Exclusion provided by Semaphores
Semaphore S; // initialized to 1 Pi
prefixi
wait (S);
CSi
signal (S);
suffixi
Wait B(s) s is a binary semaphore {
if s=1
then s=0
else block this process }
Signal B(s) {
if there is a blocked process
then unblock a process
else s=1 }

29. Message Passing Direct Addressing …
Specific identifier of source and destination processes
Send(destination, message)
Receive(source, message)
Indirect Addressing
Messages are not sent directly from sender to receiver but rather are sent to a shared data structure consisting of queues that can temporarily hold messages.
Such queues are generally referred to as mailboxes.
Thus, for 2 processes to communicate, one process sends a message to the appropriate mailbox and the other process picks up the message from the mailbox.
Mailbox P1 Pn … Q1 Qn
Sending processes
Receiving processes

30. Message Passing (cont.)
When a send primitive is executed in a process, there are 2 possibilities:
Either the sending process is blocked until the message is received
Or it is not
When a receive primitive is executed in a process, there are 2 possibilities:
If a message has previously been sent, the message is received and execution continues
If there is no waiting message, then either
The process is blocked until a message arrives, or
The process continues to execute, abandoning the attempt to receive.
Blocking send, blocking receive
Nonblocking send, blocking receive
Nonblocking send , nonblocking receive

31. Mutual Exclusion Create_mailbox(mutex) Send(mutex, null) Pi Prefixi
Receive(mutex,msg);
CSi
Send(mutex,msg);
Suffixi
Main process
Mailbox name is mutex

32. Two classical examples
Producer and Consumer Problem
Readers/Writers Problem

33. Two classical examples
Producer and Consumer Problem
Readers/Writers Problem

34. Producer and Consumer Problem
Producer can only put something in when there is an empty buffer
Consumer can only take something out when there is a full buffer
Producer and consumer are concurrent processes …
consumer
producer
N buffers
N-1

35. Producer and Consumer Problem(cont.)
Global Variable
B[0..N-1] – an array of size N (Buffer)
P – a semaphore, initialized to N
C – a semaphore, initialized to 0
Local Variable
In – a ptr(integer) used by the producer, in=0 initially
Out – a ptr(integer) used by the consumer, out=0 initially
Producer Process
producer: produce(w)
wait(p)
B[in]=w
in=(in+1)mod N
signal(c)
goto producer
Consumer Process
consumer: wait(c)
w=B[out]
out=(out+1)mod N
signal(p)
consume(w)
goto consumer
W is a local buffer used by the producer
to produce
W is a local buffer used by the consumer
to store the item to be consumed

36. Two classical examples
Producer and Consumer Problem
Readers/Writers Problem

37. Readers/Writers Problem
Suppose a data object is to be shared among several concurrent processes. Some of these processes want only to read the data object, while others want to update (both read and write)
Readers – Processes that read only
Writers – processes that read and write
If a reader process is using the data object, then other reader processes are allowed to use it at the same time.
If a writer process is using the data object, then no other process (reader or writer) is allowed to use it simultaneously.

38. Solve Readers/Writers Problem using wait and signal primitives(cont.)
Global Variable:
Wrt is a binary semaphore, initialized to 1; Wrt is used by both readers and writers
For Reader Processes:
Mutex is a binary semaphore, initialized to 1;Readcount is an integer variable, initialized to 0
Mutex and readcount used by readers only
Reader Processes
Wait(mutex)
Readcount=readcount+1
If readcount=1 then wait(wrt)
Signal(mutex); …
Reading is performed
Readcount=readcount-1
If readcount=0 then signal(wrt)
Signal(mutex)
Writer Processes
Wait(wrt)
Writing is performed
Signal(wrt)

39. End of lecture 6
Thank you!