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

I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.

## PowerPoint Slideshow about '6.5 Semaphore' - lyndon

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 - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript

Can only be accessed via two indivisible (atomic) operations

wait (S) {

while S <= 0

; // no-op

S--;

}

signal (S) {

S++;

}

• 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

• 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

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.

• 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

Dining-Philosophers Problem

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)

signal (mutex) //violate mutual exclusive

critical section

wait (mutex)

critical section

wait (mutex)

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

• 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

monitor monitor-name

{

// shared variable declarations

procedure P1 (…) { …. }

procedure Pn(…) {……}

Initialization code ( ….) { …}

}

• 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 monitor-name

{

// shared variable declarations

procedure P1 (…) { …. }

procedure Pn(…) {……}

Initialization code ( ….) { …}

}

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

dp.pickup(i)

EAT

dp.putdown(i)