1. 1 Synchronization 2: semaphores and more… 1 Operating Systems, 2011, Danny Hendler & Amnon Meisels

2. 2 What’s wrong with busy waiting?  Doesn‘t make sense for Uni-processor  Wastes CPU time  May cause priority inversion and deadlock The mutual exclusion algorithms we saw used busy-waiting. What’s wrong with that? Operating Systems, 2011, Danny Hendler & Amnon Meisels

3. 3 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 Operating Systems, 2011, Danny Hendler & Amnon Meisels

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

5. 5 Synchronization Constructs – Semaphores (Dijkstra ‘68) S Two operations define a semaphore S : DOWN(S)p(s) while(s <= 0); s = s - 1; UP(S)v(s) s = s + 1; indivisibly  Operations on the counter are performed indivisibly S S is non-negative  but this description busy-waits… Operating Systems, 2011, Danny Hendler & Amnon Meisels

6. 6 Semaphores (Dijkstra ‘68) 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 when awakened by an up(S) operation  S-- Two atomic operations are supported by a semaphore S:  S is non-negative  What exactly does “atomic” mean ?? Operating Systems, 2011, Danny Hendler & Amnon Meisels

7. 7 Wrong non negative Semaphore Lines of code are executed asynchronously 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() operation for 2 down()s Operating Systems, 2011, Danny Hendler & Amnon Meisels

8. 8 Semaphores (Dijkstra ‘68) 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 when awakened by an up(S) operation  else S-- Two atomic operations are supported by a semaphore S:  S is non-negative  Supported by Windows, Unix, … Operating Systems, 2011, Danny Hendler & Amnon Meisels

9. 9 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… Operating Systems, 2011, Danny Hendler & Amnon Meisels

10. 10 Operating Systems, 2011, Danny Hendler & Amnon Meisels

11. 11 Synchronization with 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 orderings of A, B, C, are possible? (A B* C)* Operating Systems, 2011, Danny Hendler & Amnon Meisels

12. 12 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! Operating Systems, 2011, Danny Hendler & Amnon Meisels

13. 13 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 Operating Systems, 2011, Danny Hendler & Amnon Meisels

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

15. 15 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 Operating Systems, 2011, Danny Hendler & Amnon Meisels

16. 16 2 6 Out In item1 item4 item3 item2 consumer 0 buffer producer Bounded Buffer 1 2 3 4 5 7 Operating Systems, 2011, Danny Hendler & Amnon Meisels

17. 17 Implementation using semaphores  Two processes or more use a shared buffer in memory bounded  The buffer is finite (e.g., 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 Operating Systems, 2011, Danny Hendler & Amnon Meisels

18. 18 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 */} Operating Systems, 2011, Danny Hendler & Amnon Meisels

19. 19 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... */ } } Comment: up() and down() are atomic operations Operating Systems, 2011, Danny Hendler & Amnon Meisels Producer-Consumer implementation with semaphores

20. 20 Implementing a binary semaphore with TSL  In user space, one can use TSL (test-set-lock)mutex_lock: TSLREG, mutex CMPREG, #0 ok enter_region JZEok| the equivalent of enter_region thread_yield CALLthread_yield JMP mutex_lockok: RETmutex_unlock: MOVmutex, #0 RET also called a Spin-lock Operating Systems, 2011, Danny Hendler & Amnon Meisels

21. 21 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 Operating Systems, 2011, Danny Hendler & Amnon Meisels

22. 22 More on semaphore implementation  TSL implementation can work for multi-processors  On a uni-processor, may be implemented by disabling interrupts  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 Operating Systems, 2011, Danny Hendler & Amnon Meisels

23. 23 Outline  Semaphores and the producer/consumer problem  Counting semaphores from binary semaphores  Event counters and message passing synchronization Operating Systems, 2011, Danny Hendler & Amnon Meisels

24. 24 Operating Systems, 2011, Danny Hendler & Amnon Meisels  Assumes only values 0 or 1  Wait blocks if semaphore=0  Signal either wakes up a waiting thread, if there is one, or sets value to 1  How can wakeup signals be accumulated (for the bounded buffer, for example) Binary Semaphore

25. 25 Implementing a counting semaphore with binary semaphores : take 1 down(S): down(S1); S S.value--; S if(S.value < 0){ up(S1); // L1 down(S2); } //L2 else up(S1); binary-semaphore S1, S2 initially 1; 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 25 Operating Systems, 2011, Danny Hendler & Amnon Meisels

26. 26 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. There is a discrepancy between the value of S and the number of processes waiting on it 26 Operating Systems, 2011, Danny Hendler & Amnon Meisels

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

28. 28 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  The critical section that protects the counter is entered alternately by a producer or a consumer The effect of the added ‘else’ 28 Operating Systems, 2011, Danny Hendler & Amnon Meisels

29. 29 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); } } 29 Operating Systems, 2011, Danny Hendler & Amnon Meisels

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

31. 31 A Problematic Scheduling Scenario 1. 1. five slots are filled by the first producer Empty.Value = 0 21 34 56 31 Operating Systems, 2011, Danny Hendler & Amnon Meisels

32. 32 A Problematic Scheduling Scenario 1. 1. The second producer is blocked Empty.Value = -1 21 34 56 32 Operating Systems, 2011, Danny Hendler & Amnon Meisels

33. 33 A Problematic Scheduling Scenario 1. 1. The third producer is blocked Empty.Value = -2 21 34 56 33 Operating Systems, 2011, Danny Hendler & Amnon Meisels

34. 34 A Problematic Scheduling Scenario 1 1. The fourth producer is blocked Empty.Value = -3 21 34 56 34 Operating Systems, 2011, Danny Hendler & Amnon Meisels

35. 35 A Problematic Scheduling Scenario 1. 1. The fifth producer is blocked Empty.Value = -4 21 34 56 35 Operating Systems, 2011, Danny Hendler & Amnon Meisels

36. 36 A Problematic Scheduling Scenario 2. 2. All blocked producers are waiting on S2 Empty.Value = -5 21 34 56 36 Operating Systems, 2011, Danny Hendler & Amnon Meisels

37. 37 A Problematic Scheduling Scenario 3. 3. The consumer consumes an item and is blocked on Empty.S1 until a producer adds an item. Empty.Value = -5 21 34 56 37 Operating Systems, 2011, Danny Hendler & Amnon Meisels

38. 38 A Problematic Scheduling Scenario 3. 3. The consumer consumes an item and is blocked on S1, one producer adds an item. Empty.Value = -4 21 34 56 38 Operating Systems, 2011, Danny Hendler & Amnon Meisels

39. 39 A Problematic Scheduling Scenario 4 4. Consumer must consume, only then another producer wakes up and produces an item Empty.Value = -3 21 34 56 39 Operating Systems, 2011, Danny Hendler & Amnon Meisels

40. 40 A Problematic Scheduling Scenario 4. 4. Same as in step 3. Empty.Value = -2 21 34 56 40 Operating Systems, 2011, Danny Hendler & Amnon Meisels

41. 41 A Problematic Scheduling Scenario 5. 5. And again… Empty.Value = -1 21 34 56 41 Operating Systems, 2011, Danny Hendler & Amnon Meisels

42. 42 Implementing a counting semaphore with binary semaphores: 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--; //L3 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? 42 Operating Systems, 2011, Danny Hendler & Amnon Meisels

43. 43 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) have 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 43 Operating Systems, 2011, Danny Hendler & Amnon Meisels

44. 44 Kearns' algorithm is wrong down(S),  Processes P0..P8 perform down(S), P1..P8 are preempted just before line L2 of the operation up(S)release  Processes P9..P12 perform up(S) and their up(S2) lines release, say, P1..P4 S.wake = 4  4 processes are waiting on S2 and S.wake = 4  Processes P1..P4 are ready, just before lines L3 S.wake  Each of P1..P4 will decrement S.wake in its turn, check that it's positive and signal one of P5..P8  Four up(S) have released 8 down(S) 44 Operating Systems, 2011, Danny Hendler & Amnon Meisels

45. 45 Implementing a counting semaphore with binary semaphores: 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 value =1, integer wake=0 This works 45 Operating Systems, 2011, Danny Hendler & Amnon Meisels

46. 46 Implementing a counting semaphore with binary semaphores: 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)? 46 Operating Systems, 2011, Danny Hendler & Amnon Meisels

47. 47 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' 47 Operating Systems, 2011, Danny Hendler & Amnon Meisels

48. 48 Fairness of semaphores  Order of releasing blocked processes: o Fair o Processes are not allowed multiple entries if others are waiting  Another option: o Open competition each time the lock is free o Imitating the Java ‘wait’ ‘notify’ mechanism o Starvation is possible 48 Operating Systems, 2011, Danny Hendler & Amnon Meisels

49. 49 Counting and Binary semaphores (open contest) down(S): down(S1); S while(S.value == 0){ S S.wait++; up(S1); down(S2); down(S1); S S.wait--; S S.wake--; } S if(S.wake > 0) then up(S2); S S.value--; up(S1); S SS binary-semaphore S1 =1, S2=0; int S.value=k, S.wait=0, S.wake=0 up(S): down(S1); if (S.wait > 0 && S.wake < S.wait) { S.wake++; if (S.wake==1) up(S2); } S.value++ up(S1) 49 Operating Systems, 2011, Danny Hendler & Amnon Meisels

50. 50 Outline  Semaphores and the producer/consumer problem  Counting semaphores from binary semaphores  Event counters and message passing synchronization 50 Operating Systems, 2011, Danny Hendler & Amnon Meisels

51. 51 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 51 Operating Systems, 2011, Danny Hendler & Amnon Meisels

52. 52 producer-consumer with Event Counters #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 */ } } 52 Operating Systems, 2011, Danny Hendler & Amnon Meisels

53. 53 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); } } 53 Operating Systems, 2011, Danny Hendler & Amnon Meisels

54. 54 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... 54 Operating Systems, 2011, Danny Hendler & Amnon Meisels

55. 55 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 */ } 55 Operating Systems, 2011, Danny Hendler & Amnon Meisels

56. 56 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); } } 56 Operating Systems, 2011, Danny Hendler & Amnon Meisels

57. 57 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 57 Operating Systems, 2011, Danny Hendler & Amnon Meisels