Transcript Lecture 1: Overview - City University of New York

Chapter 6: Concurrency: Mutual
Exclusion and Synchronization
Operating System
Spring 2007
Chapter 6 of textbook
1
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.
2
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
Terminal
Terminal
Ticket Agent 1 Ticket Agent 2
…
Main memory
Terminal
Ticket Agent n
3
Example for Race condition(cont.)
Ticket Agent 1
Ticket Agent 2
Ticket Agent 3
P1: LOAD #-of-seats
P2: DEC 1
P3: STORE #-of-seats
Q1: LOAD #-of-seats
Q2: DEC 1
Q3: STORE #-of-seats
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.
4
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.
P
P
0
1
Prefix0
Prefix1
CS0
CS1
Suffix0
Suffix1
Pn-1
…
Prefixn-1
CSn-1
Suffixn-1
Goal: To program the processes so that, at any moment of time,
at most one of the processes is in its critical section.
5
Solution to Critical-Section Problem
Any facility to provide support for mutual exclusion should
meet the following requirements:

1.
2.
3.
4.
5.
6.
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.
6
Three Environments
There is no central program to coordinate the
processes. The processes communicate with each
other through global variable.
1.
1.
2.
Solution: Peterson’s algorithm
not covered in this class
Special hardware instructions
2.
1.
2.
TS
Exchange(not covered in this class)
There is a central program to coordinate the
processes.
3.
1.
Semaphore
7
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



8
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
Problem of this program: It is possible that a process may starve
if 2 processes enter the critical section arbitrarily often.
Solution for the starvation won’t be covered in this class.
9
Semaphores
A variable that has an integer value upon which 3
operations are defined.
Three operations:


1.
2.
3.

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.
10
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}
}
11
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
12
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.
13
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
}
14
Two classical examples


Producer and Consumer Problem
Readers/Writers Problem
15
Two classical examples


Producer and Consumer Problem
Readers/Writers Problem
16
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
0
consumer
producer
N buffers
…
N-1
17
Producer and Consumer Problem(cont.)
Global Variable

1.
2.
3.
B[0..N-1] – an array of size N (Buffer)
P – a semaphore, initialized to N
C – a semaphore, initialized to 0
Local Variable

1.
2.
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
W is a local buffer used by the producer
to produce
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 consumer
18
to store the item to be consumed
Two classical examples


Producer and Consumer Problem
Readers/Writers Problem
19
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.
20
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
…
Wait(mutex)
Readcount=readcount-1
If readcount=0 then signal(wrt)
Signal(mutex)
Writer Processes
Wait(wrt)
…
Writing is performed
…
Signal(wrt)
21
End
Thank you!
22