semaphores monitors

7/27/2019 Semaphores Monitors

1/30

1

Semaphores and Monitors

CIS450 Winter 2003

Professor Jinhua Guo


2/30

2

Mutual Exclusion with Swap

Initially, s == false;

entry () {

bool spin = true;

Swap(spin, s);while (spin)

Swap(spin, s);

}

exit() {

s = false;

}


3/30

3

Semaphores (Dijkstra)

Synchronization tool that does not requirebusy waiting.

Semaphore is an object contains a

(private) integer value and 2 operations. P operation, also called Down or Wait

Take a resource

V operation, also called Up or Signal Release a resource

Semaphores are resource counters.


4/30


5/30


6/30

6

Critical Sections with Semaphores

semaphore mutex = 1;

entry()

P(mutex);

exit()

V(mutex);

For mutual exclusion, initializesemaphore to 1.


7/30

7

Semaphore as a General

Synchronization Tool

Execute B in Pj only afterA executed in Pi

Use semaphore flaginitialized to 0

Code:Pi Pj

A P(f lag)V(f lag) B


8/30

8

Bounded Buffer Problem

There is one Buffer object used to pass objects

from producers to consumers. The problem is

to allow concurrent access to the Buffer by

producers and consumers, while ensuring that1. The shared Buffer data structure is not screwed up

by race conditions in accessing it.

2. Consumers don't try to remove objects from Buffer

when it is empty.3. Producers don't try to add objects to the Buffer when

it is full.


9/30

9

Bounded Buffer(1 producer, 1 consumer)

Producer()

while (1) {

produce message m;

P(empty);

buf[rear] = m;

rear = rear +1;

V(full);

}

Consumer ()

while (1) {

P(full);

m = buf[front];

front = front + 1;

V(empty);

consume m;

}

char buf[n], int front = 0, rear = 0;semaphore empty = n, full = 0;


10/30

10

Bounded Buffer(multiple producers and consumers)

Producer()

while (1) {

produce message m;P(empty);

P(mutex);

buf[rear] = m;

rear = rear +1;V(mutex);

V(full)

}

Consumer ()

while (1) {

P(full);P(mutex);

m = buf[front];

front = front + 1;

V(mutex);V(empty);

consume m;

}

char buf[n], int front = 0, rear = 0;

semaphore empty = n, full = 0, mutex = 1;


11/30

11

Deadlock and Starvation

Deadlock two or more processes are waitingindefinitely for an event that can be caused by only oneof the waiting processes.

Let S and Q be two semaphores initialized to 1

P0 P1P(S); P(Q);

P(Q); P(S);

V(S); V(Q);

V(Q); V(S); Starvation indefinite blocking. A process may never

be removed from the semaphore queue in which it issuspended.


12/30

12

Readers-Writers Problem

Given a database

Can have multiple readers at a time

dont ever modify database

Only one writer

will modify database

The problem has many variation


13/30

13

Readers-Writers Problem

Semaphore Solution Shared data

semaphore mutex = 1, wrt = 1;int readcount = 0;

Writer ProcesswriteEnter () {

P(wrt);}

writeExit () {V(wrt);

}


14/30

14

Reader ProcessreadEnter () {

P(mutex);

readcount++;if (readcount == 1)P(wrt);

V(mutex);}

readExit() {P(mutex);readcount--;if (readcount == 0)

V(wrt);

V(mutex);}


15/30

15

Dining-Philosophers Problem

Shared data

semaphore chopstick[5];

Initially all values are 1


16/30

16

Dining-Philosophers Problem

Philosopheri:do {

P(chopstick[i])P(chopstick[(i+1) % 5])

eat

V(chopstick[i]);V(chopstick[(i+1) % 5]);

think} while (1);


17/30

17

Dining-Philosophers Problem(Deadlock Free)

Philosopheri:do {

if (i ! = 0) {P(chopstick[i]); P(chopstick[i+1]);

eat

V(chopstick[i]); V(chopstick[i+1]);} else {

P(chopstick[1]); P(chopstick[0]); eat

V(chopstick[1]); V(chopstick[0]);}

think

} while (1);


18/30

18

Problems with Semaphores

Used for 2 independent purposes

Mutual exclusion

Condition Synchronization

Hard to get right

Small mistake easily leads to deadlock

May want to separate mutual exclusion,

condition synchronization


19/30

19

Monitors (Hoare)

Abstract Data Type

Consists of vars and procedures, like C++ class.

3 key differences from a regular class:

Only one thread in monitor at a time (mutual exclusionis automatic);

Special type of variable allowed, called conditionvariable

3 special ops allowed only on condition variables: wait,signal, broadcast

No public data allowed (must call methods to effectany change)


20/30

20

Monitors

monitormonitor-name

{shared variable declarationsprocedure bodyP1() {

. . .}procedurebodyP2() {

. . .}procedure bodyPn() {

. . .}

{initialization code

}}


21/30


22/30


23/30


24/30

24

Semantics of Signal

Signal and Wait (Hoare)

signaller immediately gives up control

thread that was waiting executes

Signal and Continue (Java, Pthread, Mesa)

signaller continues executing

thread that was waiting put on ready queue

when thread actually gets to run

State may have changed! Use while, not if


25/30

25

Monitor Solution to Critical Section

Just make the critical section a monitor

routine!


26/30

26

Readers/Writers Solution Using

Monitors

Similar idea to semaphore solution

Simpler, because dont worry about mutex

When cant get into database, wait on

appropriate condition variable When done with database, signal others

Note: cant just put code for readingdatabase and code for writing databasein the monitor (couldt have >1 reader)


27/30

27

Difference between Monitors and

Semaphores

Monitors enforce mutual exclusion

P() vs Wait

P blocks if value is 0, Wait always blocks

V() vs Signal

V either wakes up a thread or increments

value

Signal only has effect if a thread waiting

Semaphores have memory


28/30

28

Implementing Monitors using

Semaphores

Shared vars:

semaphore mutex = 1(one per monitor)

semaphore c = 0; (one per condition var)

int nc = 0; (one per condition var)

Monitor entry: P(mutex);

Monitor exit: V(mutex);


29/30

29

cond->Wait(mutex):nc++;

V(mutex);

P(c);P(mutex);

cond->Signal():if (nc > 0) {

nc--;

V(c);

}

Implementing Monitors using

Semaphores


30/30

30

Java-style monitors

Integrated into the class mechanism

Annotation synchronized can be applied to a

member function

This function executes with implicit mutualexclusion

Wait, Signal, and Broadcast are called mon

wait, notify, and notifyAll, respectively

semaphores monitors

Documents