Synchronization: semaphores and some more stuff. Operating Systems, Spring 2018, I. Dinur, D. Hendler and R. Iakobashvili

Transcription

1 Synchronization: semaphores and some more stuff 1

2 What's wrong with busy waiting? The mutual exclusion algorithms we saw used busy-waiting. What s wrong with that? Doesn't make sense for uni-processor o May cause deadlock Wastes CPU time o But may be efficient if waiting-time is short 2

3 What's wrong with busy waiting? Busy waiting may cause 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 Deadlock results 3

4 Outline Semaphores and the producer/consumer problem Counting semaphores from binary semaphores Event counters and message passing synchronization 4

5 Semaphores Two atomic operations are supported by a semaphore 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-- up(s) [the 'v' operation] If there are blocked processes, wake-up one of them Else S++ S is non-negative Supported by Windows, Unix, 5

6 Semaphores: is the following correct? Two atomic operations are supported by a semaphore S: down(s) [the 'p' operation] If S 0 the process is blocked. It will resume execution only after it is woken-up S-- up(s) [the 'v' operation] S++ If there are blocked processes, wake-up one of them 6

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

8 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 Yes Depends 8

9 Semaphore as a General Synchronization Tool Execute B in P j only after A executed in P i Use semaphore flag initialized to 0 Code: 0 time P i A up(flag) P j down(flag) B 9

10 More on synchronization using semaphores Three processes p1; p2; p3 semaphores s1 = 1, s2 = 0; p1 p2 p3 down(s1); down(s2); down(s2); A B C up(s2); up(s2); up(s1); Which execution orders of A, B, C, are possible? (A B* C)* 10

11 No guarantee for correct synchronization (when multiple semaphores/locks are used) P 0 P 1 down(s); down(q); move1 up(s); up(q) down(q); down(s); move2 up(q); up(s); 1 1 Example: move money between two accounts which are protected by semaphores S and Q Does this work? Deadlock! 11

12 Negative-valued semaphores Two atomic operations are supported by a semaphore S: down(s) S-- If S<0 the process is blocked. It will resume execution only when S is non-negative up(s) S++ If there are blocked processes (i.e. S 0), wake-up one of them -3 If S is negative, then there are S blocked processes 12

13 Negative semaphore Implementation type semaphore = record value: integer; end; L: list of process; -3 L 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

14 Implementing a spin-lock with TSL (test-set-lock) mutex_lock: TSL REG, mutex CMP REG, #0 JZE ok CALL thread_yield JMP mutex_lock ok: RET mutex_unlock: MOV mutex, #0 RET 14

15 Implementing a negative semaphore with TSL type semaphore = record value, flag: integer; L: list of process; end; -3 L 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 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 Any problem with this code? In down(), resetting flag and sleeping should be atomic. 15

16 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 first place? Busy-waiting is now guaranteed to be very short 16

17 buffer Producer-Consumer Problem in out 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 17

18 Bounded Buffer 0 buffer item1 item2 2 Out producer 4 item3 consumer 6 In 5 7 item4 18

19 Implementation using semaphores Two processes or more use a shared buffer in memory The buffer has finite size(i.e., it is bounded) The producer writes to the buffer and the consumer reads from it A full buffer stops the producer An empty buffer stops the consumer 19

20 Producer-Consumer implementation with semaphores #define N 100 /* Buffer size */ typedef int semaphore; semaphore mutex = 1; /* access control to critical section */ semaphore empty = N; /* counts empty buffer slots */ semaphore full = 0; /* counts full slots */ void producer(void) { int item; while(true) { produce_item(&item); /* generate something... */ down(&empty); /* decrement count of empty */ down(&mutex); /* enter critical section */ enter_item(item); /* insert into buffer */ up(&mutex); /* leave critical section */ up(&full); /* increment count of full slots */ } } 20

21 Producer-Consumer implementation with semaphores void consumer(void) { int item; } 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

22 Outline Semaphores and the producer/consumer problem Counting semaphores from binary semaphores Event counters and message passing synchronization 22

23 Binary Semaphore 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? 23

24 Implementing a counting semaphore with binary semaphores (user space): take 1 binary-semaphore S1 initially 1, S2 initially 0, S.value initially 1 down(s): down(s1); S.value--; if(s.value < 0){ L1: up(s1); L2: down(s2); } else up(s1); up(s): down(s1); S.value++; if(s.value 0) up(s2); up(s1) This code does not work. Why? 24

25 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 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. 3 down( ) operations should have been permitted, only 1 was 25

26 Implementing a counting semaphore with binary semaphores (user space): take 2 binary-semaphore S1 initially 1, S2 initially 0, S.value initially 1 down(s): down(s1); S.value--; if(s.value < 0){ up(s1); //L1 down(s2); } //L2 up(s1); up(s): down(s1); S.value++; if(s.value 0) up(s2); else up(s1) Does this code work? 26

27 The effect of the changes 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 27

28 Recall the bounded-buffer algorithm #define N 100 typedef int semaphore; semaphore mutex = 1; semaphore empty = N; semaphore full = 0; void producer(void) { int item; while(true) { produce_item(&item); down(&empty); down(&mutex); enter_item(item); up(&mutex); up(&full); } } void consumer(void) { int } item; while(true) { down(&full); down(&mutex); remove_item(&item); up(&mutex); up(&empty); consume_item(item); } 28

29 A Problematic Scheduling Scenario Consider a Bounded buffer of 5 slots. Assume there are 6 processes each filling five slots in turn. 1 2 Empty.Value =

30 A Problematic Scheduling Scenario 1. five slots are filled by the first producer 1 2 Empty.Value =

31 A Problematic Scheduling Scenario 1. The second producer is blocked 1 2 Empty.Value =

32 A Problematic Scheduling Scenario 1. The third producer is blocked 1 2 Empty.Value =

33 A Problematic Scheduling Scenario 1. The fourth producer is blocked 1 2 Empty.Value =

34 A Problematic Scheduling Scenario 1. The fifth producer is blocked 1 2 Empty.Value =

35 A Problematic Scheduling Scenario 2. All blocked producers are waiting on S2 1 2 Empty.Value =

36 A Problematic Scheduling Scenario 3. The consumer consumes an item and is blocked on Empty.S1 until a producer adds an item. 1 2 Empty.Value =

37 A Problematic Scheduling Scenario 3. The consumer consumes an item and is blocked on S1, one producer adds an item. 1 2 Empty.Value =

38 A Problematic Scheduling Scenario 4. Consumer must consume, only then another producer wakes up and produces an item 1 2 Empty.Value =

39 A Problematic Scheduling Scenario 4. Same as in step Empty.Value =

40 A Problematic Scheduling Scenario 5. And again 1 2 Empty.Value =

41 Implementing a counting semaphore with binary semaphores (user space): take 3 (P.A. Kearns, 1988) binary-semaphore S1=1, S2=0, value initially 1, integer wake=0 down(s) down(s1); S.value--; if(s.value < 0){ up(s1); //L1 down(s2); //L2 down(s1); S.wake--; if(s.wake > 0) then up(s2);} //L3 up(s1); up(s): down(s1); S.value++; if(s.value <= 0) { S.wake++; up(s2); } up(s1); Does THIS work? 41

42 Correctness arguments (Kearns) The counter S.wake is used when processes performing down(s) are preempted between lines L1 and L2 In such a case, up(s2) performed by processes during up(s) has no effect However, these processes accumulate their waking signals on the (protected) counter 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

43 Kearns' algorithm is wrong Processes P 0..P 7 perform down(s), P 0 goes through, P 1..P 7 go to sleep after performing line L2 of the operation Processes P 8..P 11 perform up(s) and their up(s2) operations release, say, P 1..P 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 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

44 Implementing a counting semaphore with binary semaphores (user space): take 4 (Hemmendinger, 1989) binary-semaphore S1=1, S2=0, integer wake=0 down(s) down(s1); S.value--; if(s.value < 0){ up(s1); down(s2); down(s1); S.wake--; if(s.wake > 0) then up(s2);} // L3 up(s1); up(s): down(s1); S.value++; if(s.value <= 0) { S.wake++; if (S.wake == 1) up(s2); } up(s1); This works 44

45 Implementing a counting semaphore with binary semaphores (user space): take 5 (Barz, 1983) binary-semaphore S1=1, S2=min(1, init_value), value=init_value 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); This works, is simpler, and was published earlier(!) Can we switch the order of downs in down(s)? 45

46 Correctness arguments 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.value is never negative, because any process performing down(s) is blocked at S2 Signals cannot be 'wasted' 46

47 Fairness of semaphores Order of releasing blocked processes: 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: 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

48 Outline Semaphores and the producer/consumer problem Counting semaphores from binary semaphores Event counters and message passing synchronization 48

49 Event Counters Integer counters with three operations: o Advance(E): increment E by 1, wake up relevant sleepers 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 The Read() operation is not required for the bounded-buffer implementation in the next slide 49

50 producer-consumer with Event Counters (for a single producer and a single consumer) #define N 100 typedef event_counter int in = 0; event_counter; /* 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

51 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

52 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... 52

53 Producer-consumer using message passing 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); } } 53

54 Producer-consumer using message passing (continued) #define N 100 #define MSIZE 4 /* message size */ typedef int message(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 */ } 54

55 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