Embed Size (px)
Citation preview
OS Spring’04
Concurrency
Operating Systems Spring 2004
OS Spring’04
Concurrency pros and cons Concurrency is good for users
One of the reasons for multiprogramming Working on the same problem, simultaneous
execution of programs, background execution
Concurrency is a “pain in the neck” for the system
Access to shared data structuresDeadlock due to resource contention
OS Spring’04
Mutual Exclusion OS is an instance of concurrent
programmingMultiple activities may take place in the same time
Concurrent execution of operations involving multiple steps is problematic
Example: updating linked list Concurrent access to a shared data
structure must be mutually exclusive
OS Spring’04
new->next=current.next
current
new
current
new
current.next=new
insert_after(current,new):
OS Spring’04
tmp=current.next;current.next=current.next.next;free(tmp);
current
current
remove_next(current):
OS Spring’04
current
new
current
new
current
new
OS Spring’04
Atomic operations A generic solution is to ensure
atomic execution of operationsAll the steps are perceived as executed in a single point of time
insert_after(current,new) remove_next(current), or
remove_next(current) insert_after(current,new)
OS Spring’04
The Critical Section Model A code within a
critical section must be executed exclusively by a single process
do {
critical section
remainder section
} while(1)
entry section
exit section
OS Spring’04
Linked list exampledo {
remainder section
} while(1)
entry section
exit section
do {
remainder section
} while(1)
entry section
exit section
new->next=current.next
current.next=new
tmp=current.next;current.next=current.next.next;free(tmp);
OS Spring’04
The Critical Section Problem n processes P0,…,Pn-1
No assumptions on relative process speeds, no synchronized clocks, etc…
Models inherent non-determinism of process scheduling
No assumptions on process activity when executing within
Critical and reminder sections
OS Spring’04
Shared variables Processes are communicating
through shared atomic read/write variables
x is a shared variable, l is a local variableRead: takes the current value:
Write: assigns a provided value:
){...}6(
;
xif
xl
;5x
OS Spring’04
Requirements Mutual Exclusion: If process Pi is
executing its C.S., then no other process is in its C.S.
Progress: If Pi is in its entry section and no process is in C.S., then some process eventually enters C.S.
Fairness: If no process remains in C.S. forever, then each process requesting entry to C.S. will be eventually let into C.S.
OS Spring’04
Solving the CS problem (n=2)
while(1)}
sectionremainder
section critical
);!( while
;
{ do
: Process
nothingdo
iturn
iturn
Pi
;:Shared turn {0,1} enum
OS Spring’04
Solving the CS problem (n=2)
while(1)}
sectionremainder
;1
section critical
);( while
{ do
; Process
iturn
iturn !
Pi
;:Shared turn {0,1} enum
OS Spring’04
Solving the CS problem (n=2)
while(1)}
sectionremainder
;][
section critical
]);1[(
;][
{ do
: Process
falseiflag
iflagwhile
trueiflag
Pi
]2[ :Shared flagboolean
OS Spring’04
Peterson’s algorithm for n=2
while(1)}
sectionremainder
;][
section critical
);1&&]1[(
;1
;][
{ do
: Process
falseiflag
iturniflagwhile
iturn
trueiflag
Pi
; {0,1}];2[ :Shared turn enumflagboolean
OS Spring’04
Bakery algorithm of Lamport Critical section algorithm for any
n>1 Each time a process is requesting an
entry to CS, assign it a ticket which is
Unique and monotonically increasing
Let the process into CS in the order of their numbers
OS Spring’04
Choosing a ticket;[n]boolean];n[ int:Shared choosing number
;1])1[],1[],0[max(][ nnumbernumbernumberinumber
)],[()],[( iinumberjjnumber Does not guarantee uniqueness! Use process Ids:
;][
;1])1[],1[],0[max(][
;][
falseichoosing
nnumbernumbernumberinumber
trueichoosing
Process need to know that somebody perhaps chose a smaller number:
OS Spring’04
Bakery algorithm for n processes
while(1)}sectionremainder ;0][
section critical}
)));],[()],[&((&)0]![((while]);[(while
{ );;0(for;][
;1])1[],1[],0[max(][;][
{ do Process
inumber
iinumberjjnumberjnumberjchoosing
jnjjfalseichoosing
nnumbernumbernumberinumbertrueichoosing
Pi
OS Spring’04
Correctness
)],[()],[(0][
thensection, critical in the is if ,any For
iinumberjjnumberjnumber
Pij j
Lemma:
Mutual exclusion is immediate from this lemma
It is easy to show that Progress and Fairness holdas well (recitation)
OS Spring’04
Hardware primitives Elementary building blocks capable
of performing certain steps atomically
Should be universal to allow for solving versatile synchronization problems
Numerous such primitives were identified:
Test-and-setFetch-and-addCompare-and-swap
OS Spring’04
Test-and-Set (TS)boolean test-and-set(boolean &lock){
temp=lock;lock=TRUE;return temp;
}
reset(boolean &lock){
lock=FALSE;}
OS Spring’04
Critical section using TSShared boolean lock, initially
FALSE
do {while(test-and-set(&lock));
critical section;reset(&lock);
reminder section;} while(1);
Check yourself!•Is mutual exclusion satisfied?•Is progress satisfied?•Is fairness satisfied?
OS Spring’04
Discussion Satisfies Mutual Exclusion and
Progress Does not satisfy Fairness Provides exclusion among
unbounded number of processesProcess IDs and number are unknown
Busy waitingBurning CPU cycles while being blocked
OS Spring’04
Fetch-and-Add (FAA)
s: shared, a: local
int FAA(int &s, int a){
temp=s;s=s+a;return temp;
}FAA can be used as a ticket machine
OS Spring’04
Critical section using FAAShared: int s, turn; Initially: s = 0; turn=0;
Process Pi code:Entry:
me = FAA(s,1);while(turn < me); // busy wait for my turn
Critical sectionExit:
FAA(turn,1);
Check yourself!•Is mutual exclusion satisfied?•Is progress satisfied?•Is fairness satisfied?
OS Spring’04
Discussion Satisfies all three properties Supports unbounded number of
processes Unbounded counter Busy waiting
OS Spring’04
Problems with studied synchronization methods Critical section framework is
inconvenient for programming Performance penalty
Busy waitingToo coarse synchronization
Using hardware primitives directly results in non-portable code
OS Spring’04
Higher Level Abstractions Higher level software abstractions
are represented bySemaphoresMonitors
OS Spring’04
Semaphores Invented by Edsger Dijkstra in 1968 Interface consists of two primitives:
P() and V()
}
;
);0(
{)(
S
Swhile
SP
}
;
{)(
S
SV
OS Spring’04
Notes on the Language Dutch: P: Proberen, V: Verhogen Hebrew: P: חותפ , V: עודו English: P(): wait(), V(): signal()
OS Spring’04
Semaphores: initial value Initial value of a semaphore
indicates how many identical instances of the critical resource exist
A semaphore initialized to 1 is called a mutex (mutual exclusion)
OS Spring’04
Programming with semaphores Semaphores is a powerful
programming abstraction Define a semaphore for each critical
resourceE.g., one for each linked listGranularity?
Concurrent processes access appropriate semaphores when synchronization is needed
OS Spring’04
Some examples…………V(synch);……
…P(synch);……………
OS Spring’04
Some examplesDo {
P(mutex);
critical section
V(mutex);
Remainder section;
While(1);
OS Spring’04
Implementing semaphores Semaphores can be implemented
efficiently by the systemP() is explicitly telling the system: “Hey, I cannot proceed, you can preempt me”V() instructs the system to wake up a waiting process
OS Spring’04
Implementing Semaphores
type semaphore = record count: integer; queue: list of process end;var S: semaphore;
S.count must be initialized to a nonnegative value (depending on application)
OS Spring’04
Implementing Semaphores
P(S): S.count--; if (S.count<0) { add this process to S.queue block this process; }
V(S): S.count++; if (S.count <= 0) { remove a process P from S.queue place this process P on ready queue }
OS Spring’04
We’re still cheating… P() and V() must be executed
atomically In uniprocessor system may disable
interrupts In multi-processor system, use
hardware synchronization primitivesTS, FAA, etc…
Involves a some limited amount of busy waiting
OS Spring’04
Monitorsmonitor monitor-name{
shared variable declarations
procedure P1(…) {…
}…
procedure Pn() {…
}}
Only a single process at a time can be active within the monitor
=> other processes calling Pi() are queued
Conditional variables for finer grain synchronization
x.wait() suspend the execution until another process calls x.signal()
