1. 6.5 Semaphore
Can only be accessed via two indivisible (atomic) operations
wait (S) {
while S <= 0
; // no-op
S--; }
signal (S) {
S++;

2. 6.5 Semaphore
Binary semaphore –integer value can range only between 0 and 1; can be simpler to implement
Counting semaphore –integer value can range over an unrestricted domain

3. 6.5 Semaphore
The main disadvantage of the semaphore is that it requires busy waiting, which wastes CPU cycle that some other process might be able to use productively
This type of semaphore is also called a spinlock because the process “spins” while waiting for the lock

4. 6.5 Semaphore
To overcome the busy waiting problem, we create two more operations:
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.

5. 6.6 Classical Problems of Synchronization
Bounded-Buffer Problem
Readers and Writers Problem
Dining-Philosophers Problem

6. 6.6 Classical Problems of Synchronization
N buffers, each can hold one item
Semaphore mutex initialized to the value 1
Semaphore full initialized to the value 0
Semaphore empty initialized to the value N.

7. Bounded Buffer Problem

8. Bounded Buffer Problem

9. Readers-Writers Problem
A data set is 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.
First readers-writers problem: requires that no reader will be kept waiting unless a writer has already obtained permission to use the shared object

10. Readers-Writers Problem
Shared Data
Data set
Semaphore mutex initialized to 1.
Semaphore wrt initialized to 1.
Integer read count initialized to 0.

11. Readers Readers-Writers Problem

12. Readers Readers-Writers Problem

13. Dining- Philosophers Problem
The philosophers share a circular table surrounded by five chairs, each belonging to one philosopher
In the center of table is a bowl of rice, and the table is laid with 5 single chopsticks
From time to time, a philosopher gets hungry and tries to pick up the two chopsticks that are closest to her
When a hungry philosopher has both her chopsticks at the same time, she eats without releasing her chopsticks
When she is finished eating, she puts down both her chopsticks and starts thinking

14. Dining- Philosophers Problem

15. Dining- Philosophers Problem

16. Dining- Philosophers Problem
Methods to avoid deadlock:
Allow at most four philosophers to be sitting simultaneously
Allow a philosopher to pick up her chopsticks only if both chopsticks are available (pick them up is a critical section)

17. Problems with Semaphores
signal (mutex) //violate mutual exclusive
critical section
wait (mutex)
wait (mutex) //deadlock occurs
Omitting of wait (mutex) or signal (mutex) (or both)

18. Monitors
A high-level abstraction that provides a convenient and effective mechanism for process synchronization
Only one process may be active within the monitor at a time

19. Syntax of Monitor monitor monitor-name {
// shared variable declarations
procedure P1 (…) { …. } …
procedure Pn(…) {……}
Initialization code ( ….) { …} }

20. Monitor

21. Condition Variables
However, the monitor construct, as defined so far, is not powerful enough
We need to define one or more variables of type condition: condition x, y;
Two operations on a condition variable:
x.wait() –a process that invokes the operation is suspended.
x.signal() –resumes one of processes (if any) that invoked x.wait()

22. Monitor with Condition Variables

23. Syntax of Monitor monitor monitor-name {
// shared variable declarations
procedure P1 (…) { …. } …
procedure Pn(…) {……}
Initialization code ( ….) { …} }

24. Solution to Dining Philosophers

25. Solution to Dining Philosophers

26. Solution to Dining Philosophers
Each philosopher I invokes the operations pickup() and putdown() in the following sequence:
dp.pickup(i)
EAT
dp.putdown(i)

27. Monitor Implementation Using Semaphores

28. Monitor Implementation Using Semaphores

29. Monitor Implementation Using Semaphores