1 / 17

Operating Systems CMPSC 473

Operating Systems CMPSC 473. Mutual Exclusion Lecture 14: October 14, 2010 Instructor: Bhuvan Urgaonkar. Mid-semester feedback. On Angel, format similar to SRTEs Please submit by end of the week Based on feedback so far: will do a revision of mutual exclusion related topics. Agenda.

Download Presentation

Operating Systems CMPSC 473

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. Operating SystemsCMPSC 473 Mutual Exclusion Lecture 14: October 14, 2010 Instructor: Bhuvan Urgaonkar

  2. Mid-semester feedback • On Angel, format similar to SRTEs • Please submit by end of the week • Based on feedback so far: will do a revision of mutual exclusion related topics

  3. Agenda • Some classic synchronization problems using semaphores • Last class • Producer/Consumer problem • Readers/Writers problem • Solution was free of deadlocks • Starvation problem • Today • Readers/Writers problem • Consider more carefully the definition of starvation • Dining Philosophers problem

  4. Readers-Writers Problem A data set shared among a number of concurrent processes Readers – only read the data set; they do not perform any updates Writers – can both read and write Problem – allow multiple readers to read at the same time. Only one writer may access the shared data at a given time Shared Data Data set Semaphore mutex initialized to 1 Semaphore wrt initialized to 1 Integer readcount initialized to 0

  5. Readers-Writers Problem (Cont.) The structure of a writer process do { wait (wrt) ; // writing is performed signal (wrt) ; } while (TRUE); • mutex = 1 • wrt = 1 • readcount = 0 Allow only one writer at a time to write

  6. Readers-Writers Problem (Cont.) The structure of a reader process do { wait (mutex) ; readcount ++ ; if (readcount == 1) wait (wrt) ; signal (mutex) ; // reading wait (mutex) ; readcount - - ; if (readcount == 0) signal (wrt) ; signal (mutex) ; } while (TRUE); • mutex = 1 • wrt = 1 • readcount = 0 Proceed only if no writer is writing; disallow writers once we proceed Signal a writer only when there are no more active readers

  7. Readers/Writers • Note that starvation is said to occur only when a process, despite getting CPU, does not get to make use of it • Only writers are starved, not readers • Can we eliminate starvation for writers?

  8. Dining-Philosophers Problem Shared data Bowl of rice (data set) Semaphore chopstick [5] initialized to 1

  9. Dining-Philosophers Problem (Cont.) The structure of Philosopher i: do { wait ( chopstick[i] ); wait ( chopStick[ (i + 1) % 5] ); // eat signal ( chopstick[i] ); signal (chopstick[ (i + 1) % 5] ); // think } while (TRUE); • Deadlock? Starvation? • What happens if all pick their left chopsticks?

  10. Dining-Philosophers Problem (Cont.) • Idea #1: Make the two wait operations occur together as an atomic unit (and the two signal operations) • Use another binary semaphore for this • Any problems with this?

  11. Dining-Philosophers Problem (Cont.) • Idea #2: Does it help if one of the neighbors picks their left chopstick first and the other picks their right chopstick first? • What is the most # phils. that can eat simultaneously?

  12. Bounded Buffer/Producer Consumer • Buffer has max capacity N • Producer can only add if buffer has room (i.e., count < N) • Consumer can only remove if buffer has item (i.e., count > 0) N = 4 Producer Consumer 2 empty slots 2 occupied slots

  13. Producer Consumer: Mutex Locks mutex_lock m; int count = 0; Produce() { while (count == N); mutex_lock (m); … ADD TO BUFFER, count++ … mutex_unlock (m); } Consume() { while (count ==0); mutex_lock (m); … REMOVE FROM BUFFER, count-- … mutex_unlock (m); } • Downside: Busy waiting • Liveness guarantee depends on how lock is implemented • E.g., • Peterson’s => Mutex and bounded wait • Test&set => Only mutex

  14. Binary Semaphores == Mutex Locks semaphore m = 1; int count = 0; Produce() { while (count == N); wait (m); … ADD TO BUFFER, count++ … signal (m); } Consume() { while (count ==0); wait (m); … REMOVE FROM BUFFER, count-- … signal (m); }

  15. Producer Consumer: Semaphores semaphore sem = 1; semaphore full = 0; semaphore empty = N; Produce() { wait (empty); wait (sem); … ADD TO BUFFER, count++ … signal (sem); signal (full); } Consume() { wait (full); wait (sem); … REMOVE FROM BUFFER, count-- … signal (sem); signal (empty); } • Use three semaphores • Note important difference from condition variables • Signals are not lost • sem protects critical sections • full forces a consumer to wait till there is at least one item in buffer • empty ensures at most N items are produced between empty buffer and execution of a consumer

  16. Producer Consumer: Semaphores semaphore sem = 1; int count = 0; Produce() { if (count == N) wait (sem); … ADD TO BUFFER, count++ … signal (sem); } Consume() { if (count == 0) wait (sem); … REMOVE FROM BUFFER, count-- … signal (sem); } • A non-working example • Identify the race condition here • That is, can a producer and consumer be in their critical sections simultaneously?

  17. Producer Consumer: Semaphores semaphore sem = 1; int count = 0; mutex_lock m; Produce() { mutex_lock (m); if (count == N) wait (sem); … ADD TO BUFFER, count++ … signal (sem); mutex_unlock (m); } Consume() { mutex_lock (m); if (count == 0) wait (sem); … REMOVE FROM BUFFER, count-- … signal (sem); mutex_unlock (m); } • A non-working example • What happens if a consumer acquires the lock before an item is added to the buffer? • Deadlock!

More Related