This presentation is the property of its rightful owner.
1 / 29

# 6.5 Semaphore PowerPoint PPT Presentation

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

6.5 Semaphore

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

### 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.6Classical Problems of Synchronization

• Bounded-Buffer Problem

• Dining-Philosophers Problem

### 6.6Classical 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

• A data set is shared among a number of concurrent processes

• 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

Shared Data

• Data set

• Semaphore mutex initialized to 1.

• Semaphore wrt initialized to 1.

• Integer read count initialized to 0.

### 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

• 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 section

wait (mutex)

critical section

wait (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 ( ….) { …}

}

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

### Syntax of Monitor

monitor monitor-name

{

// shared variable declarations

procedure P1 (…) { …. }

procedure Pn(…) {……}

Initialization code ( ….) { …}

}

### Solution to Dining Philosophers

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

dp.pickup(i)

EAT

dp.putdown(i)