6.5 Semaphore

Can only be accessed via two indivisible (atomic) operations

wait (S) { while S <= 0 ; // no-op S--;}

signal (S) { S++;}

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

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

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.

6.6 Classical Problems of Synchronization

Bounded-Buffer Problem Readers and Writers Problem Dining-Philosophers Problem

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.

Bounded Buffer Problem

Bounded Buffer Problem

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

Readers-Writers Problem

Shared Data Data set Semaphore mutex initialized to 1. Semaphore wrt initialized to 1. Integer read count initialized to 0.

Readers Readers-Writers Problem

Readers Readers-Writers Problem

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

Dining-Philosophers Problem

Dining-Philosophers Problem

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)

Problems with Semaphores

signal (mutex) //violate mutual exclusive critical sectionwait (mutex)

wait (mutex) //deadlock occurs critical sectionwait (mutex)

Omitting of wait (mutex) or signal (mutex) (or both)

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

Syntax of Monitor

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

Monitor

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()

Monitor with Condition Variables

Syntax of Monitor

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

Solution to Dining Philosophers

Solution to Dining Philosophers

Solution to Dining Philosophers

Each philosopher I invokes the operations pickup() and putdown() in the following sequence:

dp.pickup(i) EATdp.putdown(i)

Monitor Implementation Using Semaphores

Monitor Implementation Using Semaphores

Monitor Implementation Using Semaphores