1 / 57

Synchronization 2: semaphores and more…

This overview discusses the drawbacks of busy waiting in operating systems, particularly in relation to synchronization and mutual exclusion. It explains how busy waiting can lead to priority inversion and deadlock situations by illustrating a scenario where a high-priority process is thrwarted by a lower-priority one. The document also covers semaphore operations, their atomicity, the implementation of mutexes with semaphores, and the classic producer-consumer problem. Key concepts include the definitions and operations on semaphores, as well as the implications of using negative-valued semaphores.

reuel
Download Presentation

Synchronization 2: semaphores and more…

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

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

  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. Priority inversion and deadlock result 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 Operating Systems, 2011, Danny Hendler & Amnon Meisels

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

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

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

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

  9. Implementing mutex with semaphores Shared data: semaphorelock; /* initially lock = 1 down(lock) Critical section up(lock) Yes 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. Operating Systems, 2011, Danny Hendler & Amnon Meisels

  11. Synchronization with semaphores Three processes p1; p2; p3 semaphores s1 = 1, s2 = 0; p1p2p3 down(s1); down(s2); down(s2); A B C 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. No guarantee for correct synchronization P0P1 down(S); down(Q); down(Q); down(S); move1move2 up(S); up(Q); up(Q) up(S); 1 1 • Example: move money between two accounts which are protected by semaphores S and Q Does this work? Deadlock! Operating Systems, 2011, Danny Hendler & Amnon Meisels

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

  14. Negative semaphore Implementation type semaphore = record value: integer; L: list of process; end; -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. out in Producer-Consumer Problem • Paradigm for cooperating processes, • producer process produces information that is consumed by a consumer process • Two versions • unbounded-bufferplaces no practical limit on the size of the buffer • bounded-bufferassumes that there is a fixed buffer size buffer Operating Systems, 2011, Danny Hendler & Amnon Meisels

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

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

  18. Producer-Consumer implementation with semaphores #define N 100 /* Buffer size */ typedefintsemaphore; semaphoremutex = 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 */ } } Operating Systems, 2011, Danny Hendler & Amnon Meisels

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

  20. Implementing a binary semaphore with TSL • In user space, one can use TSL (test-set-lock) mutex_lock: TSL REG, mutex CMP REG, #0 JZE ok | the equivalent ofenter_region CALL thread_yield JMP mutex_lock ok: RET mutex_unlock: MOV mutex, #0 RET also called a Spin-lock Operating Systems, 2011, Danny Hendler & Amnon Meisels

  21. Implementing a negative semaphore with TSL 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=0sleep; }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 Operating Systems, 2011, Danny Hendler & Amnon Meisels

  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 1st place? Busy-waiting is now guaranteed to be very short Operating Systems, 2011, Danny Hendler & Amnon Meisels

  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. Binary Semaphore • 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) Operating Systems, 2011, Danny Hendler & Amnon Meisels

  25. Implementing a counting semaphore with binary semaphores: take 1 down(S): down(S1); S.value--; 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.value++; if(S.value≤ 0) up(S2); up(S1) This code does not work Operating Systems, 2011, Danny Hendler & Amnon Meisels

  26. Race condition for counting semaphore take 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 • Processes Q5-Q7 now perform up(S): the value of the counting semaphore is now 0 • Now, Q2-Q4 wake-up in turn and perform line L2 (down S2) • Q2 runs but Q3-Q4 block. There is a discrepancy between the value of S and the number of processes waiting on it Operating Systems, 2011, Danny Hendler & Amnon Meisels

  27. Implementing a counting semaphore with binary semaphores: take 2 down(S): down(S1); S.value--; 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.value++; if(S.value ≤ 0) up(S2); else up(S1) Does this code work? Operating Systems, 2011, Danny Hendler & Amnon Meisels

  28. The effect of the added ‘else’ • 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 Operating Systems, 2011, Danny Hendler & Amnon Meisels

  29. Recall the bounded-buffer algorithm void consumer(void){int item; while(TRUE) {down(&full); down(&mutex); remove_item(&item);up(&mutex); up(&empty); consume_item(item); }} #define N 100 typedefintsemaphore; semaphoremutex = 1; semaphoreempty = 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); } } Operating Systems, 2011, Danny Hendler & Amnon Meisels

  30. 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 = 5 3 4 5 6 Operating Systems, 2011, Danny Hendler & Amnon Meisels

  31. A Problematic Scheduling Scenario 1. five slots are filled by the first producer 1 2 Empty.Value = 0 3 4 5 6 Operating Systems, 2011, Danny Hendler & Amnon Meisels

  32. A Problematic Scheduling Scenario 1. The second producer is blocked 1 2 Empty.Value = -1 3 4 5 6 Operating Systems, 2011, Danny Hendler & Amnon Meisels

  33. A Problematic Scheduling Scenario 1. The third producer is blocked 1 2 Empty.Value = -2 3 4 5 6 Operating Systems, 2011, Danny Hendler & Amnon Meisels

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

  35. A Problematic Scheduling Scenario 1. The fifth producer is blocked 1 2 Empty.Value = -4 3 4 5 6 Operating Systems, 2011, Danny Hendler & Amnon Meisels

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

  37. 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 = -5 3 4 5 6 Operating Systems, 2011, Danny Hendler & Amnon Meisels

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

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

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

  41. A Problematic Scheduling Scenario 5. And again… 1 2 Empty.Value = -1 3 4 5 6 Operating Systems, 2011, Danny Hendler & Amnon Meisels

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

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

  44. Kearns' algorithm is wrong • Processes P0..P8 perform down(S), P1..P8 are preempted just before line L2 of the operation • Processes P9..P12 perform up(S) and their up(S2) lines release, say, P1..P4 • 4 processes are waiting on S2 and S.wake = 4 • Processes P1..P4 are ready, just before lines L3 • 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) Operating Systems, 2011, Danny Hendler & Amnon Meisels

  45. Implementing a counting semaphore with binary semaphores: take 4 (Hemmendinger, 1989) 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); binary-semaphore S1=1, S2=0, integer value =1, integer wake=0 up(S): down(S1); S.value++; if(S.value <= 0) { S.wake++; if (S.wake == 1) up(S2); } up(S1); This works Operating Systems, 2011, Danny Hendler & Amnon Meisels

  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); binary-semaphore S1=1, S2=min(1, init_value), value=init_value 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)? Operating Systems, 2011, Danny Hendler & Amnon Meisels

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

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

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

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

More Related