Synchronization: semaphores and some more stuff 1 Operating Systems, 2014, Meni Adler, Danny Hendler & Amnon Meisels

What's wrong with busy waiting?  Doesn't make sense for uni-processor o May cause priority inversion and deadlock  Wastes CPU time o But is efficient if waiting-time is short The mutual exclusion algorithms we saw used busy-waiting. What’s wrong with that? 2 Operating Systems, 2014, Meni Adler, Danny Hendler & Amnon Meisels

What's wrong with busy waiting? Busy waiting may cause priority-inversion and deadlock  Process A's priority is higher than process B's  Process B enters the CS  Process A needs to enter the CS, busy-waits for B to exit the CS  Process B cannot execute as long as the higher-priority process A is executing/ready Priority inversion and deadlock result 3 Operating Systems, 2014, Meni Adler, Danny Hendler & Amnon Meisels

Outline  Semaphores and the producer/consumer problem  Counting semaphores from binary semaphores  Event counters and message passing synchronization 4 Operating Systems, 2014, Meni Adler, Danny Hendler & Amnon Meisels

Semaphores up(S) [the `v’ operation]  If there are blocked processes, wake-up one of them  Else S++ down(S) [the ‘p’ operation]  If S ≤ 0 the process is blocked. It will resume execution only after it is woken-up  Else S-- Two atomic operations are supported by a semaphore S:  S is non-negative  Supported by Windows, Unix, … 5 Operating Systems, 2014, Meni Adler, Danny Hendler & Amnon Meisels

Semaphores: is the following correct? up(S) [the `v’ operation]  S++  If there are blocked processes, wake-up one of them down(S) [the ‘p’ operation]  If S ≤ 0 the process is blocked. It will resume execution only after it is woken-up  S-- Two atomic operations are supported by a semaphore S: 6 Operating Systems, 2014, Meni Adler, Danny Hendler & Amnon Meisels

7 Consider the following bad scneario: down(S)  S=0 and process A performs down(S) – A is blocked up(S)S=1  Process B performs up(S) – S=1 A is ready down(S) S=0 & C proceeds  Process C performs down(S) – S=0 & C proceeds S=0  Process A gets a time-slice and proceeds – S=0 A single up() freed 2 down()s Operating Systems, 2011, Danny Hendler & Amnon Meisels Pseudo-code in previous slide is wrong

Implementing mutex with semaphores Shared data: semaphore lock; /* initially lock = 1 */ down(lock) Critical section up(lock) Does the algorithm satisfy mutex? Does it satisfy deadlock-freedom? Does it satisfy starvation-freedom? Yes Depends… 8 Operating Systems, 2014, Meni Adler, Danny Hendler & Amnon Meisels

9

More on synchronization using semaphores Three processes p1; p2; p3 semaphoress1 = 1, s2 = 0; p1p2p3 s1s2s2 down(s1);down(s2);down(s2); A B C s2s2s1 up(s2);up(s2);up(s1); Which execution orders of A, B, C, are possible? (A B* C)* 10 Operating Systems, 2014, Meni Adler, Danny Hendler & Amnon Meisels

P 0 P 1 down(S); down(Q); down(Q); down(S); move1 move2 up(S); up(Q); up(Q) up(S); 1 1  Example: move money between two accounts which are protected by semaphores S and Q No guarantee for correct synchronization Does this work? Deadlock! 11 Operating Systems, 2014, Meni Adler, Danny Hendler & Amnon Meisels

Negative-valued semaphores up(S)  S++  If there are blocked processes (i.e. S ≤ 0), wake-up one of them -3 down(S )  S--  If S<0 the process is blocked. It will resume execution only when S is non-negative Two atomic operations are supported by a semaphore S:  If S is negative, then there are –S blocked processes 12 Operating Systems, 2014, Meni Adler, Danny Hendler & Amnon Meisels

type semaphore = record value: integer; L: list of process; end; Negative semaphore Implementation -3 atomic down(S): S.value--; if (S.value < 0) { add this process to S.L; sleep; } atomic up(S): S.value++; if (S.value <= 0) { remove a process P from S.L; wakeup(P); } 13 Operating Systems, 2014, Meni Adler, Danny Hendler & Amnon Meisels L

Implementing a spin-lock with TSL  In user space, one can use TSL (test-set-lock)mutex_lock: TSLREG, mutex CMPREG, #0 ok JZEok thread_yield CALLthread_yield JMP mutex_lockok: RETmutex_unlock: MOVmutex, #0 RET 14 Operating Systems, 2014, Meni Adler, Danny Hendler & Amnon Meisels

type semaphore = record value, flag: integer; L: list of process; end; -3 down(S): repeat until test-and-set(S.flag) S.value--; if (S.value < 0) { add this process to S.L; S.flag=0 sleep; } else S.flag=0 Implementing a negative semaphore with TSL up(S): repeat until test-and-set(S.flag) S.value++; if (S.value <= 0) { remove a process P from S.L; wakeup(P); } S.flag=0 15 Operating Systems, 2014, Meni Adler, Danny Hendler & Amnon Meisels L Any problem with this code? In down(), resetting flag and sleeping should be atomic.

More on semaphore implementation  On a uni-processor, disabling interrupts may be used  TSL implementation works for multi-processors  On a multi-processor, we can use spin-lock mutual exclusion to protect semaphore access Why is this better than busy-waiting in the 1 st place? Busy-waiting is now guaranteed to be very short 16 Operating Systems, 2014, Meni Adler, Danny Hendler & Amnon Meisels

Producer-Consumer Problem  Paradigm for cooperating processes, producer process produces information that is consumed by a consumer process  Two versions unbounded-buffer places no practical limit on the size of the buffer bounded-buffer assumes that there is a fixed buffer size buffer in out 17 Operating Systems, 2014, Meni Adler, Danny Hendler & Amnon Meisels

2 6 Out In item1 item4 item3 item2 consumer 0 buffer producer Bounded Buffer Operating Systems, 2014, Meni Adler, Danny Hendler & Amnon Meisels

Implementation using semaphores  Two processes or more use a shared buffer in memory bounded  The buffer has finite size(i.e., it is bounded)  The producer writes to the buffer and the consumer reads from it full buffer  A full buffer stops the producer empty buffer  An empty buffer stops the consumer 19 Operating Systems, 2014, Meni Adler, Danny Hendler & Amnon Meisels

Producer-Consumer Producer-Consumer implementation with semaphores #defineN100/* Buffer size */ semaphore typedefintsemaphore; semaphore semaphoremutex = 1;/* access control to critical section */ semaphore semaphoreempty = N;/* counts empty buffer slots */ semaphore semaphorefull = 0;/* counts full slots */ void producer(void) { intitem; while(TRUE) { produce_item(&item);/* generate something... */ down down(&empty);/* decrement count of empty */ down down(&mutex);/* enter critical section */ enter_item(item);/* insert into buffer */ up up(&mutex);/* leave critical section */ up up(&full);/* increment count of full slots */} 20 Operating Systems, 2014, Meni Adler, Danny Hendler & Amnon Meisels

consumer down down up up void consumer(void) { intitem; while(TRUE){ down(&full);/* decrement count of full */ down(&mutex); /* enter critical section */ remove_item(&item);/* take item from buffer) */ up(&mutex);/* leave critical section */ up(&empty);/* update count of empty */ consume_item(item);/* do something... */ } } 21 Operating Systems, 2014, Meni Adler, Danny Hendler & Amnon Meisels Producer-Consumer Producer-Consumer implementation with semaphores

Outline  Semaphores and the producer/consumer problem  Counting semaphores from binary semaphores  Event counters and message passing synchronization 22 Operating Systems, 2014, Meni Adler, Danny Hendler & Amnon Meisels

23 Operating Systems, 2014, Meni Adler, Danny Hendler & Amnon Meisels  Assumes only values 0 or 1  Wait blocks if semaphore=0  Signal (up operation) either wakes up a waiting process, if there is one, or sets value to 1 (if value is already 1, signal is “wasted”)  How can we implement a counting semaphore by using binary semaphores? Binary Semaphore

Implementing a counting semaphore with binary semaphores (user space): take 1 down(S): down(S1); S S.value--; S if(S.value < 0){ up(S1); down(S2); } else up(S1); binary-semaphore S1 initially 1, S2 initially 0, S.value initially 1 up(S): down(S1); S S.value++; S if(S.value ≤ 0) up(S2); up(S1) This code does not work. Why? 24 Operating Systems, 2014, Meni Adler, Danny Hendler & Amnon Meisels L1: L2:

Race condition for counting semaphore take 1 1.Processes Q1 – Q4 perform down(S), Q2 – Q4 are preempted between lines L1 and L2: the value of the counting semaphore is now -3 2.Processes Q5-Q7 now perform up(S): the value of the counting semaphore is now 0 3.Now, Q2-Q4 wake-up in turn and perform line L2 (down S2) 4.Q2 runs but Q3-Q4 block. 25 Operating Systems, 2014, Meni Adler, Danny Hendler & Amnon Meisels There is a discrepancy between the value of S and the number of processes waiting on it

Implementing a counting semaphore with binary semaphores (user space): take 2 down(S): down(S1); S S.value--; S if(S.value < 0){ up(S1); //L1 down(S2); } //L2 up(S1);up(S): down(S1); S S.value++; S if(S.value ≤ 0) up(S2); else up(S1) Does this code work? 26 Operating Systems, 2014, Meni Adler, Danny Hendler & Amnon Meisels binary-semaphore S1 initially 1, S2 initially 0, S.value initially 1

only if no process waits on S2  up(S1) is performed by up(S) only if no process waits on S2  Q5 leaves up(S) without releasing S1  Q6 cannot enter the critical section that protects the counter  It can only do so after one of Q2-Q4 releases S1  This generates a “lock-step” situation: an up(), a down(), an up()…  The critical section that protects the counter is entered alternately by a producer or a consumer The effect of the added ‘else’ 27 Operating Systems, 2014, Meni Adler, Danny Hendler & Amnon Meisels

Recall the bounded-buffer algorithm #defineN100 semaphore typedefintsemaphore; semaphore semaphoremutex = 1; semaphore semaphoreempty = N; semaphore semaphorefull = 0; producer void producer(void) { intitem; while(TRUE) { produce_item(&item); down down(&empty); down down(&mutex); enter_item(item); up up(&mutex); up up(&full);} consumer down down up up void consumer(void) { intitem; while(TRUE){ down(&full); down(&mutex); remove_item(&item); up(&mutex); up(&empty); consume_item(item); } } 28 Operating Systems, 2014, Meni Adler, Danny Hendler & Amnon Meisels

A Problematic Scheduling Scenario Consider a Bounded buffer of 5 slots. Assume there are 6 processes each filling five slots in turn. Empty.Value = Operating Systems, 2014, Meni Adler, Danny Hendler & Amnon Meisels

A Problematic Scheduling Scenario five slots are filled by the first producer Empty.Value = Operating Systems, 2014, Meni Adler, Danny Hendler & Amnon Meisels

A Problematic Scheduling Scenario The second producer is blocked Empty.Value = Operating Systems, 2014, Meni Adler, Danny Hendler & Amnon Meisels

A Problematic Scheduling Scenario The third producer is blocked Empty.Value = Operating Systems, 2014, Meni Adler, Danny Hendler & Amnon Meisels

A Problematic Scheduling Scenario 1 1. The fourth producer is blocked Empty.Value = Operating Systems, 2014, Meni Adler, Danny Hendler & Amnon Meisels

A Problematic Scheduling Scenario The fifth producer is blocked Empty.Value = Operating Systems, 2014, Meni Adler, Danny Hendler & Amnon Meisels

A Problematic Scheduling Scenario All blocked producers are waiting on S2 Empty.Value = Operating Systems, 2014, Meni Adler, Danny Hendler & Amnon Meisels

A Problematic Scheduling Scenario The consumer consumes an item and is blocked on Empty.S1 until a producer adds an item. Empty.Value = Operating Systems, 2014, Meni Adler, Danny Hendler & Amnon Meisels

A Problematic Scheduling Scenario The consumer consumes an item and is blocked on S1, one producer adds an item. Empty.Value = Operating Systems, 2014, Meni Adler, Danny Hendler & Amnon Meisels

A Problematic Scheduling Scenario 4 4. Consumer must consume, only then another producer wakes up and produces an item Empty.Value = Operating Systems, 2014, Meni Adler, Danny Hendler & Amnon Meisels

A Problematic Scheduling Scenario Same as in step 3. Empty.Value = Operating Systems, 2014, Meni Adler, Danny Hendler & Amnon Meisels

A Problematic Scheduling Scenario And again… Empty.Value = Operating Systems, 2014, Meni Adler, Danny Hendler & Amnon Meisels

Implementing a counting semaphore with binary semaphores (user space): take 3 (P.A. Kearns, 1988) down(S) down(S1); S S.value--; S if(S.value < 0){ up(S1); //L1 down(S2); //L2 down(S1); S S.wake--; S if(S.wake > 0) then up(S2);} //L3 up(S1); up(S): down(S1); S S.value++; S if(S.value <= 0) { S S.wake++; up(S2); } up(S1); binary-semaphore S1=1, S2=0, value initially 1, integer wake=0 Does THIS work? 41 Operating Systems, 2014, Meni Adler, Danny Hendler & Amnon Meisels

Correctness arguments (Kearns)… S.wakedown(S)  The counter S.wake is used when processes performing down(S) are preempted between lines L1 and L2 up(S)  In such a case, up(S2) performed by processes during up(S) has no effect S.wake  However, these processes accumulate their waking signals on the (protected) counter S.wake S.wake  After preemption is over, any single process that wakes up from its block on down(S2) checks the value of S.wake  The check is again protected  For each count of the wake-up signals, the awakened process performs the up(S2) (in line L3)  Each re-scheduled process wakes up the next one 42 Operating Systems, 2014, Meni Adler, Danny Hendler & Amnon Meisels

Kearns' algorithm is wrong down(S),  Processes P 0..P 7 perform down(S), P 0 goes through, P 1..P 7 are preempted just after line L2 of the operation up(S)  Processes P 8..P 11 perform up(S) and their up(S2) operations release, say, P 1..P 4 S.wake = 4  Processes P 5, P 6, P 7 are still waiting on S2 and S.wake = 4  Processes P 1..P 4 are ready, just before line L3 S.wake  Each of P 1..P 3 will decrement S.wake in its turn, check that it's positive and signal one of P 5..P 7  Four up operations have released 7 down operations 43 Operating Systems, 2014, Meni Adler, Danny Hendler & Amnon Meisels

Implementing a counting semaphore with binary semaphores (user space): take 4 (Hemmendinger, 1989) down(S) down(S1); S S.value--; S if(S.value < 0){ up(S1); down(S2); down(S1); S S.wake--; S if(S.wake > 0) then up(S2);} // L3 up(S1); up(S): down(S1); S S.value++; S if(S.value <= 0) { S S.wake++; if (S.wake == 1) up(S2); } up(S1); binary-semaphore S1=1, S2=0, integer wake=0 This works 44 Operating Systems, 2014, Meni Adler, Danny Hendler & Amnon Meisels

Implementing a counting semaphore with binary semaphores (user space): take 5 (Barz, 1983) down(S) down(S2); down(S1); S.value--; if (S.value>0) then up(S2); up(S1); up(S): down(S1); S.value++; if(S.value == 1) { up(S2); } up(S1); binary-semaphore S1=1, S2=min(1, init_value), value=init_value This works, is simpler, and was published earlier(!)… Can we switch the order of downs in down(S)? 45 Operating Systems, 2014, Meni Adler, Danny Hendler & Amnon Meisels

Correctness arguments… SSS  The critical section is guarded by S1 and each of the operations down(S) and up(S) uses it to correctly update the value of S.value  After updating (and inside the critical section) both operations release the S2 semaphore only if value is positive  S S  S.value is never negative, because any process performing down(S) is blocked at S2  Signals cannot be 'wasted' 46 Operating Systems, 2014, Meni Adler, Danny Hendler & Amnon Meisels

Fairness of semaphores  Order of releasing blocked processes: enters after o Weak – up() performing process enters after (one of the) blocked processes o Strong – An upper bound on the number of entries of process that performed up() if others are waiting Unfair:  Unfair: o No guarantee about the number of times the up() performing process enters before the blocked o Open competition each time the lock is free o Imitating the Java 'wait' 'notify' mechanism o Or the spin-lock of XV6… 47 Operating Systems, 2014, Meni Adler, Danny Hendler & Amnon Meisels

Outline  Semaphores and the producer/consumer problem  Counting semaphores from binary semaphores  Event counters and message passing synchronization 48 Operating Systems, 2014, Meni Adler, Danny Hendler & Amnon Meisels

Event Counters  Integer counters with three operations: o Advance(E): increment E by 1, wake up relevant sleepers Sleep if E < v o Await(E,v): wait until E ≥ v. Sleep if E < v o Read(E): return the current value of E Counter value is ever increasing  Counter value is ever increasing  The Read() operation is not required for the bounded-buffer implementation in the next slide 49 Operating Systems, 2014, Meni Adler, Danny Hendler & Amnon Meisels

producer-consumer with Event Counters (for a single producer and a single consumer) #defineN100 typedefintevent_counter; event_counterin = 0;/* counts inserted items */ event_counter out = 0;/* items removed from buffer */ void producer(void) { int item, sequence = 0; while(TRUE) { produce_item(&item); sequence = sequence + 1; /* counts items produced */ await(out, sequence - N); /* wait for room in buffer */ enter_item(item); /* insert into buffer */ advance(&in); /* inform consumer */ } } 50 Operating Systems, 2014, Meni Adler, Danny Hendler & Amnon Meisels

Event counters Event counters (producer-consumer) void consumer(void) { int item, sequence = 0; while(TRUE) { sequence = sequence + 1; /* count items consumed */ await(in, sequence); /* wait for item */ remove_item(&item); /* take item from buffer */ advance(&out); /* inform producer */ consume_item(item); } } 51 Operating Systems, 2014, Meni Adler, Danny Hendler & Amnon Meisels

Message Passing – no shared memory  In a multi-processor system without shared memory, synchronization can be implemented by message passing  Implementation issues: o Acknowledgements may be required (messages may be lost) o Message sequence numbers required to avoid message duplication o Unique process addresses across CPUs (domains..) o Authentication (validate sender’s identity, a multi-machine environment…)  Two main functions: o send(destination, &message); o receive(source, &message) block while waiting Operating Systems, 2014, Meni Adler, Danny Hendler & Amnon Meisels

Message Passing Producer-consumer with Message Passing #defineN100 #define MSIZE4/* message size */ typedefintmessage(MSIZE); void producer(void) { int item; message m;/* message buffer */ while(TRUE) { produce_item(&item); receive(consumer, &m);/*wait for an empty */ construct_message(&m, item); send(consumer, &m);/* send item */ } 53 Operating Systems, 2014, Meni Adler, Danny Hendler & Amnon Meisels

Message passing (cont.) empties void consumer(void) { int item, i; message m; for(i = 0; i < N; i++) send(producer, &m); /* send N empties */ while(TRUE) { receive(producer, &m);/* get message with item */ extract_item(&m, &item); send(producer, &m);/* send an empty reply */ consume_item(item); } } 54 Operating Systems, 2014, Meni Adler, Danny Hendler & Amnon Meisels

Message passing variations  Messages can be addressed to a process address or to a mailbox o Mailboxes are generated with some capacity. When sending a message to a full mailbox, a process blocks o Buffer management done by mailbox  Unix pipes - a generalization of messages … no fixed size message (blocking receive)  If no buffer is maintained by the system, then send and receive must run in lock-step. Example: Unix rendezvous 55 Operating Systems, 2014, Meni Adler, Danny Hendler & Amnon Meisels