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
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
This solution uses semaphores, showing one instance each of a reader and a writer; the solution does not change for multiple readers and writers.
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.
Therefore, writers are subject to starvation.
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.
Continued on next slide
Five philosophers live in a house, where a table is laid for them.
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.
Due to a lack of manual skill, each philosopher requires two forks to eat spaghetti.
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.
Each philosopher picks up first the fork on the left and then the fork on the right.
After the philosopher is finished eating, the two forks are replaced on the table.
This solution, alas, leads to deadlock:
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.
In this undignified position, all philosophers starve.
We could consider adding an attendant who only allows four philosophers at a time into the dining room.
With at most four seated philosophers, at least one philosopher will have access to two forks.
This slide shows such a solution, again using semaphores. This solution is free of deadlock and starvation.
