Lec11 semaphores
Upcoming SlideShare
Loading in...5
×
 

Like this? Share it with your network

Share

Lec11 semaphores

on

  • 296 views

 

Statistics

Views

Total Views
296
Views on SlideShare
296
Embed Views
0

Actions

Likes
0
Downloads
29
Comments
0

0 Embeds 0

No embeds

Accessibility

Categories

Upload Details

Uploaded via as Microsoft PowerPoint

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment
  • This solution uses semaphores, showing one instance each of a reader and a writer; the solution does not change for multiple readers and writers. <br /> Once a single reader has begun to access the data area, it is possible for readers to retain control of the data area as long as there is at least one reader in the act of reading. <br /> Therefore, writers are subject to starvation. <br />
  • This solution guarantees that no new readers are allowed access to the data area once at least one writer has declared a desire to write. <br /> Continued on next slide <br />
  • Five philosophers live in a house, where a table is laid for them. <br /> The life of each philosopher consists principally of thinking and eating, and through years of thought, all of the philosophers had agreed that the only food that contributed to their thinking efforts was spaghetti. <br /> Due to a lack of manual skill, each philosopher requires two forks to eat spaghetti. <br /> A philosopher wishing to eat goes to his or her assigned place at the table and, using the two forks on either side of the plate, takes and eats some spaghetti. <br />
  • Each philosopher picks up first the fork on the left and then the fork on the right. <br /> After the philosopher is finished eating, the two forks are replaced on the table. <br /> This solution, alas, leads to deadlock: <br /> If all of the philosophers are hungry at the same time, they all sit down, they all pick up the fork on their left, and they all reach out for the other fork, which is not there. <br /> In this undignified position, all philosophers starve. <br />
  • We could consider adding an attendant who only allows four philosophers at a time into the dining room. <br /> With at most four seated philosophers, at least one philosopher will have access to two forks. <br /> This slide shows such a solution, again using semaphores. This solution is free of deadlock and starvation. <br />

Lec11 semaphores Presentation Transcript

  • 1. Lecture 11: Synchronization (Chapter 6, cont) Operating System Concepts – 8 th Edition, Silberschatz, Galvin and Gagne
  • 2. Semaphores (by Dijkstra 1930 – 2002) Born in Rotterdam, The Netherlands 1972 recipient of the ACM Turing Award Responsible for The idea of building operating systems as explicitly synchronized sequential processes The formal development of computer programs Best known for His efficient shortest path algorithm Having designed and coded the first Algol 60 compiler. Famous campaign for the abolition of the GOTO statement Also known for his hand-written communications with friends and colleagues. For example: http://www.cs.utexas.edu/users/EWD/ewd12xx/EWD1205.PDF Operating System Concepts – 8 th Edition 6.2 Silberschatz, Galvin and Gagne
  • 3. Semaphores Synchronization tool that does not require busy waiting Semaphore S – integer variable Two standard operations modify S: wait() and signal() Originally called P() and V() Also called down() and up() The value of S can only be accessed through wait() and signal() wait (S) { signal (S) { while S <= 0 S++; ; // no-op } S--; } Operating System Concepts – 8 th Edition 6.3 Silberschatz, Galvin and Gagne
  • 4. Semaphore Implementation with no Busy waiting With each semaphore there is an associated waiting queue. typedef struct{ tnt value; struct process *list; } semaphore; Two operations on processes: block – place the process invoking the operation on the appropriate waiting queue. wakeup – remove one of processes in the waiting queue and place it in the ready queue. Operating System Concepts – 8 th Edition 6.4 Silberschatz, Galvin and Gagne
  • 5. Semaphore Implementation with no Busy waiting (Cont.) Implementation of wait: wait(semaphore *S) { S->value--; if (S->value < 0) { add this process to S->list; block(); } } Implementation of signal: signal(semaphore *S) { S->value++; if (S->value <= 0) { remove a process P from S->list; wakeup(P); } Silberschatz, Galvin and Gagne 6.5 Operating System Concepts – 8 Edition } th
  • 6. Semaphore as General Synchronization Tool Counting semaphore – integer value can range over an unrestricted domain Binary semaphore – integer value can range only between 0 and 1; can be simpler to implement Also known as mutex locks Can implement a counting semaphore S as a binary semaphore Provides mutual exclusion Semaphore mutex; // initialized to 1 do { wait (mutex); // Critical Section signal (mutex); // remainder section } while (TRUE); Operating System Concepts – 8 th Edition 6.6 Silberschatz, Galvin and Gagne
  • 7. Group Work (1): Signaling One thread sends a signal to another thread to indicate that something has happened Operating System Concepts – 8 th Edition 6.7 Silberschatz, Galvin and Gagne
  • 8. Group Work (2): rendezvous Generalize the signal pattern so that it works both ways: Thread A has to wait for Thread B and vice versa. Thread A a1 a2 Thread B b1 b2 we want to guarantee that a1 happens before b2 and b1 happens before a2 Operating System Concepts – 8 th Edition 6.8 Silberschatz, Galvin and Gagne
  • 9. Deadlock and Starvation Deadlock – two or more processes are waiting indefinitely for an event that can be caused by only one of the waiting processes Let S and Q be two semaphores initialized to 1 P0 P1 wait (S); wait (Q); wait (Q); wait (S); . . . . . . signal (S); signal (Q); signal (Q); signal (S); Starvation – indefinite blocking. A process may never be removed from the semaphore queue in which it is suspended Priority Inversion - Scheduling problem when lower-priority process holds a lock needed by higher-priority process Operating System Concepts – 8 th Edition 6.9 Silberschatz, Galvin and Gagne
  • 10. Classical Problems of Synchronization Bounded-Buffer Problem Readers and Writers Problem Dining-Philosophers Problem Operating System Concepts – 8 th Edition 6.10 Silberschatz, Galvin and Gagne
  • 11. Bounded-Buffer Problem N buffers, each can hold one item Semaphore mutex initialized to 1 Semaphore full initialized to 0 Semaphore empty initialized to N. Operating System Concepts – 8 th Edition 6.11 Silberschatz, Galvin and Gagne
  • 12. Bounded Buffer Solution Producer: Consumer: do { do { // produce an item in nextp wait (full); wait (mutex); wait (empty); wait (mutex); // remove an item from buffer to nextc // add the item to the buffer signal (mutex); signal (empty); signal (mutex); signal (full); // consume the item in nextc } while (TRUE); } while (TRUE); Operating System Concepts – 8 th Edition 6.12 Silberschatz, Galvin and Gagne
  • 13. Readers-Writers Problem A data set is shared among a number of concurrent processes Readers – only read; 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 can access the shared data at the same time Shared Data Data set Semaphore mutex initialized to 1 Semaphore wrt initialized to 1 Integer readcount initialized to 0 Operating System Concepts – 8 th Edition 6.13 Silberschatz, Galvin and Gagne
  • 14. Readers-Writers Solution Reader: Writer: do { do { wait (mutex) ; readcount ++ ; if (readcount == 1) wait (wrt) ; signal (mutex) wait (wrt) ; // writing is performed signal (wrt) ; // reading is performed } while (TRUE); wait (mutex) ; readcount - - ; if (readcount == 0) signal (wrt) ; signal (mutex) ; } while (TRUE); Operating System Concepts – 8 th Edition 6.14 Silberschatz, Galvin and Gagne
  • 15. Same Solution in Different Format Operating System Concepts – 8 th Edition 6.15 Silberschatz, Galvin and Gagne
  • 16. Version 2 (part 1) Operating System Concepts – 8 th Edition 6.16 Silberschatz, Galvin and Gagne
  • 17. Version 2 (part 2) Operating System Concepts – 8 th Edition 6.17 Silberschatz, Galvin and Gagne
  • 18. Dining Philosophers Problem Operating System Concepts – 8 th Edition 6.18 Silberschatz, Galvin and Gagne
  • 19. The Problem Devise a ritual (algorithm) that will allow the philosophers to eat. No two philosophers can use the same fork at the same time (mutual exclusion) No philosopher must starve to death (avoid deadlock and starvation … literally!) Operating System Concepts – 8 th Edition 6.19 Silberschatz, Galvin and Gagne
  • 20. What's Wrong? Operating System Concepts – 8 th Edition 6.20 Silberschatz, Galvin and Gagne
  • 21. Avoiding deadlock (only 4 philosophers) Operating System Concepts – 8 th Edition 6.21 Silberschatz, Galvin and Gagne
  • 22. Dining Philosophers: Solution Operating System Concepts – 8 th Edition 6.22 Silberschatz, Galvin and Gagne
  • 23. Operating System Concepts – 8 th Edition 6.23 Silberschatz, Galvin and Gagne