Semaphores and Bounded Buffer

Semaphores
Fundamental

Principle:

Two or more processes want to cooperate by means of simple signals

Special

Variable: semaphore s

A special kind of int variable Cant just modify or set or increment or decrement it

Copyright : University of Illinois CS 241 Staff

Semaphores

Semaphore is a type of generalized lock

Defined by Dijkstra in the last 60s Main synchronization primitives used in UNIX Consist of a positive integer value Two operations
P():

an atomic operation that waits for semaphore to become positive, then decrement it by 1 V(): an atomic operation that increments semaphore by 1 and wakes up a waiting thread at P(), if any.

Semaphores vs. Integers

No

negative values Only operations are P() and V()

Cannot read or write semaphore values Except at the initialization times
Operations

are atomic

Two P() calls cannot decrement the value below zero A sleeping thread at P() cannot miss a wakeup from V()

Wait operation
Wait

operation:

Wait(S) { While S<=0; //no-op S--; }

Signal operation:

Signal(): Signal(S) { S++; }

Types of Semaphore
Counting

Semaphore:

The value can range over an unrestricted domain

Binary

Semaphore:

It can range between 0 and 1.

Binary Semaphores
A

1 P() waits until the value is 1

Then set it to 0 V() sets the value to 1

binary semaphore is initialized to

Wakes up a thread waiting at P(), if any

Two Uses of Semaphores

1. Mutual exclusion
Lock was designed to do this
lock->acquire(); // critical section lock->release();

Semaphore
Provides mutual exclusion Semaphore S; // initialized to 1 do {

wait (S); //Critical Section signal (S); //Remainder Section

} while (true)

Two Uses of Semaphores

1.

1. The lock function can be realized with a binary semaphore: semaphore subsumes lock.
Semaphore

Mutual exclusion

has an initial value of 1 P() is called before a critical section V() is called after the critical section

semaphore litter_box = 1; P(litter_box); // critical section V(litter_box);

Two Uses of Semaphores

1. Mutual exclusion
Semaphore has an initial value of 1 P() is called before a critical section V() is called after the critical section
semaphore litter_box = 1; P(litter_box); // critical section V(litter_box);

litter_box = 1

Two Uses of Semaphores

1. Mutual exclusion
Semaphore has an initial value of 1 P() is called before a critical section V() is called after the critical section
semaphore litter_box = 1; P(litter_box); // purrr // critical section V(litter_box);

litter_box = 1 0

Two Uses of Semaphores

1. Mutual exclusion
Semaphore has an initial value of 1 P() is called before a critical section V() is called after the critical section
semaphore litter_box = 1; P(litter_box); // critical section V(litter_box);

litter_box = 0

Two Uses of Semaphores

1. Mutual exclusion
Semaphore has an initial value of 1 P() is called before a critical section V() is called after the critical section
semaphore litter_box = 1; P(litter_box); // meow // critical section V(litter_box);

litter_box = 0

Two Uses of Semaphores

1. Mutual exclusion
Semaphore has an initial value of 1 P() is called before a critical section V() is called after the critical section
semaphore litter_box = 1; P(litter_box); // critical section V(litter_box);

litter_box = 0 1

Two Uses of Semaphores

2. Synchronization: Enforcing some order between threads

T1 do X wait for Y do Z

T2 wait for X do Y

wait for Z

Two Uses of Semaphores

2. Synchronization
Semaphore usually has an initial value of 0
semaphore wait_left = 0; semaphore wait_right = 0; Left_Paw() { slide_left(); V(wait_left); P(wait_right); slide_right(); } Right_Paw() { P(wait_left); slide_left(); slide_right(); V(wait_right); }

Two Uses of Semaphores

2. Scheduling
Semaphore usually has an initial value of 0
semaphore wait_left = 0; semaphore wait_right = 0; Left_Paw() { slide_left(); V(wait_left); P(wait_right); slide_right(); } wait_left = 0 wait_right = 0

Right_Paw() { P(wait_left); slide_left(); slide_right(); V(wait_right); }

Two Uses of Semaphores

2. Scheduling
Semaphore usually has an initial value of 0
semaphore wait_left = 0; semaphore wait_right = 0; Left_Paw() { slide_left(); V(wait_left); P(wait_right); slide_right(); } wait_left = 0 wait_right = 0

Right_Paw() { P(wait_left); slide_left(); slide_right(); V(wait_right); }

Two Uses of Semaphores

2. Scheduling
Semaphore usually has an initial value of 0
semaphore wait_left = 0; semaphore wait_right = 0; Left_Paw() { slide_left(); V(wait_left); P(wait_right); slide_right(); } wait_left = 0 wait_right = 0

Right_Paw() { P(wait_left); slide_left(); slide_right(); V(wait_right); } wait

Two Uses of Semaphores

2. Scheduling
Semaphore usually has an initial value of 0
semaphore wait_left = 0; semaphore wait_right = 0; Left_Paw() { slide_left(); V(wait_left); P(wait_right); slide_right(); } wait_left = 0 wait_right = 0

Right_Paw() { P(wait_left); slide_left(); slide_right(); V(wait_right); }

Two Uses of Semaphores

2. Scheduling
Semaphore usually has an initial value of 0
semaphore wait_left = 0; semaphore wait_right = 0; Left_Paw() { slide_left(); V(wait_left); P(wait_right); slide_right(); } wait_left = 0 1 wait_right = 0

Right_Paw() { P(wait_left); slide_left(); slide_right(); V(wait_right); }

Two Uses of Semaphores

2. Scheduling
Semaphore usually has an initial value of 0
semaphore wait_left = 0; semaphore wait_right = 0; Left_Paw() { slide_left(); V(wait_left); P(wait_right); slide_right(); } wait_left = 1 0 wait_right = 0

Right_Paw() { P(wait_left); slide_left(); slide_right(); V(wait_right); }

Two Uses of Semaphores

2. Scheduling
Semaphore usually has an initial value of 0
semaphore wait_left = 0; semaphore wait_right = 0; Left_Paw() { slide_left(); V(wait_left); P(wait_right); slide_right(); } wait_left = 0 wait_right = 0

Right_Paw() { P(wait_left); slide_left(); slide_right(); V(wait_right); }

Two Uses of Semaphores

2. Scheduling
Semaphore usually has an initial value of 0
semaphore wait_left = 0; semaphore wait_right = 0; Left_Paw() { slide_left(); V(wait_left); P(wait_right); slide_right(); } wait wait_left = 0 wait_right = 0

Right_Paw() { P(wait_left); slide_left(); slide_right(); V(wait_right); }

Two Uses of Semaphores

2. Scheduling
Semaphore usually has an initial value of 0
semaphore wait_left = 0; semaphore wait_right = 0; Left_Paw() { slide_left(); V(wait_left); P(wait_right); slide_right(); } wait_left = 0 wait_right = 0

Right_Paw() { P(wait_left); slide_left(); slide_right(); V(wait_right); }

Two Uses of Semaphores

2. Scheduling
Semaphore usually has an initial value of 0
semaphore wait_left = 0; semaphore wait_right = 0; Left_Paw() { slide_left(); V(wait_left); P(wait_right); slide_right(); } wait_left = 0 wait_right = 0 1

Right_Paw() { P(wait_left); slide_left(); slide_right(); V(wait_right); }

Two Uses of Semaphores

2. Scheduling
Semaphore usually has an initial value of 0
semaphore wait_left = 0; semaphore wait_right = 0; Left_Paw() { slide_left(); V(wait_left); P(wait_right); slide_right(); } wait_left = 0 wait_right = 1 0

Right_Paw() { P(wait_left); slide_left(); slide_right(); V(wait_right); }

Two Uses of Semaphores

2. Scheduling
Semaphore usually has an initial value of 0
semaphore wait_left = 0; semaphore wait_right = 0; Left_Paw() { slide_left(); V(wait_left); P(wait_right); slide_right(); } wait_left = 0 wait_right = 0

Right_Paw() { P(wait_left); slide_left(); slide_right(); V(wait_right); }

Two Uses of Semaphores

2. Synchronization
Semaphore usually has an initial value of 0
semaphore s1 = 0; semaphore s2 = 0; A() { write(x); V(s1); P(s2); read(y); } B() { P(s1); read(x); write(y); V(s2); }

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

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

Producer-Consumer with a Bounded Buffer

A

classic problem A producer put things into a shared buffer A consumer takes them out

Problem Constraints
The

solution involves both synchronization and mutual exclusion Constraints

The consumer must wait if buffers are empty (synchronization constraint) The producer must wait if buffers are full (synchronization constraint) Only one thread can manipulate the buffer at a time (mutual exclusion)

Developing the Solution

Each constraint needs a semaphore

semaphore mutex = 1; semaphore nFreeBuffers = N; semaphore nLoadedBuffers = 0;

Developing the Solution

Each constraint needs a semaphore

Consumer() {

semaphore mutex = 1; semaphore nFreeBuffers = N; semaphore nLoadedBuffers = 0; Producer() { P(mutex); // put 1 item in the buffer V(mutex); }

P(mutex); // take 1 item from the // buffer V(mutex);

}

Developing the Solution

Each constraint needs a semaphore

semaphore mutex = 1; semaphore nFreeBuffers = N; semaphore nLoadedBuffers = 0; Producer() { P(nFreeBuffers); P(mutex); // put 1 item in the buffer V(mutex); }

Consumer() { P(nLoadedBuffers); P(mutex); // take 1 item from the // buffer V(mutex); }

Developing the Solution

Each constraint needs a semaphore

semaphore mutex = 1; semaphore nFreeBuffers = N; semaphore nLoadedBuffers = 0; Producer() { P(nFreeBuffers); P(mutex); // put 1 item in the buffer V(mutex); V(nLoadedBuffers); }

Consumer() { P(nLoadedBuffers); P(mutex); // take 1 item from the // buffer V(mutex); V(nFreeBuffers); }

Developing the Solution

Each constraint needs a semaphore

semaphore mutex = 1; semaphore nFreeBuffers = 2; semaphore nLoadedBuffers = 0; Producer() { P(nFreeBuffers); P(mutex); // put 1 item in the buffer V(mutex); V(nLoadedBuffers); }

Consumer() { P(nLoadedBuffers); P(mutex); // take 1 item from the // buffer V(mutex); V(nFreeBuffers); }

mutex = 1 nFreeBuffers = 2 nLoadedBuffers = 0

Developing the Solution

Each constraint needs a semaphore

semaphore mutex = 1; semaphore nFreeBuffers = 2; semaphore nLoadedBuffers = 0; Producer() { P(nFreeBuffers); P(mutex); // put 1 item in the buffer V(mutex); V(nLoadedBuffers); }

Consumer() { P(nLoadedBuffers); P(mutex); // take 1 item from the // buffer V(mutex); V(nFreeBuffers); }

mutex = 1 nFreeBuffers = 2 nLoadedBuffers = 0

Developing the Solution

Each constraint needs a semaphore

semaphore mutex = 1; semaphore nFreeBuffers = 2; semaphore nLoadedBuffers = 0; Producer() { P(nFreeBuffers); P(mutex); // put 1 item in the buffer V(mutex); V(nLoadedBuffers); }

Consumer() { P(nLoadedBuffers); P(mutex); // take 1 item from the // buffer V(mutex); V(nFreeBuffers); }

mutex = 1 nFreeBuffers = 2 nLoadedBuffers = 0

Developing the Solution

Each constraint needs a semaphore

semaphore mutex = 1; semaphore nFreeBuffers = 2; semaphore nLoadedBuffers = 0; Producer() { P(nFreeBuffers); P(mutex); // put 1 item in the buffer V(mutex); V(nLoadedBuffers); }

Consumer() { P(nLoadedBuffers); P(mutex); // take 1 item from the // buffer V(mutex); V(nFreeBuffers); }

mutex = 1 nFreeBuffers = 2 1 nLoadedBuffers = 0

Developing the Solution

Each constraint needs a semaphore

semaphore mutex = 1; semaphore nFreeBuffers = 2; semaphore nLoadedBuffers = 0; Producer() { P(nFreeBuffers); P(mutex); // put 1 item in the buffer V(mutex); V(nLoadedBuffers); }

Consumer() { P(nLoadedBuffers); P(mutex); // take 1 item from the // buffer V(mutex); V(nFreeBuffers); }

mutex = 1 0 nFreeBuffers = 1 nLoadedBuffers = 0

Developing the Solution

Each constraint needs a semaphore

semaphore mutex = 1; semaphore nFreeBuffers = 2; semaphore nLoadedBuffers = 0; Producer() { P(nFreeBuffers); P(mutex); // put 1 item in the buffer V(mutex); V(nLoadedBuffers); }

Consumer() { P(nLoadedBuffers); P(mutex); // take 1 item from the // buffer V(mutex); V(nFreeBuffers); }

mutex = 0 nFreeBuffers = 1 nLoadedBuffers = 0

Developing the Solution

Each constraint needs a semaphore

semaphore mutex = 1; semaphore nFreeBuffers = 2; semaphore nLoadedBuffers = 0; Producer() { P(nFreeBuffers); P(mutex); // put 1 item in the buffer V(mutex); V(nLoadedBuffers); }

Consumer() { P(nLoadedBuffers); P(mutex); // take 1 item from the // buffer V(mutex); V(nFreeBuffers); }

mutex = 0 nFreeBuffers = 1 nLoadedBuffers = 0

Developing the Solution

Each constraint needs a semaphore

semaphore mutex = 1; semaphore nFreeBuffers = 2; semaphore nLoadedBuffers = 0; Producer() { P(nFreeBuffers); P(mutex); // put 1 item in the buffer V(mutex); V(nLoadedBuffers); }

Consumer() { P(nLoadedBuffers); P(mutex); // take 1 item from the // buffer V(mutex); V(nFreeBuffers); }

mutex = 0 nFreeBuffers = 1 0 nLoadedBuffers = 0

Developing the Solution

Each constraint needs a semaphore

semaphore mutex = 1; semaphore nFreeBuffers = 2; semaphore nLoadedBuffers = 0; Producer() { P(nFreeBuffers); P(mutex); // put 1 item in the buffer V(mutex); V(nLoadedBuffers); }

Consumer() { P(nLoadedBuffers); P(mutex); // take 1 item from the // buffer V(mutex); V(nFreeBuffers); }

mutex = 0 nFreeBuffers = 0 nLoadedBuffers = 0

Developing the Solution

Each constraint needs a semaphore

semaphore mutex = 1; semaphore nFreeBuffers = 2; semaphore nLoadedBuffers = 0; Producer() { P(nFreeBuffers); P(mutex); // put 1 item in the buffer V(mutex); V(nLoadedBuffers); }

Consumer() { P(nLoadedBuffers); P(mutex); // take 1 item from the // buffer V(mutex); V(nFreeBuffers); }

mutex = 0 1 nFreeBuffers = 0 nLoadedBuffers = 0

Developing the Solution

Each constraint needs a semaphore

semaphore mutex = 1; semaphore nFreeBuffers = 2; semaphore nLoadedBuffers = 0; Producer() { P(nFreeBuffers); P(mutex); // put 1 item in the buffer V(mutex); V(nLoadedBuffers); }

Consumer() { P(nLoadedBuffers); P(mutex); // take 1 item from the // buffer V(mutex); V(nFreeBuffers); }

mutex = 1 0 nFreeBuffers = 0 nLoadedBuffers = 0

Developing the Solution

Each constraint needs a semaphore

semaphore mutex = 1; semaphore nFreeBuffers = 2; semaphore nLoadedBuffers = 0; Producer() { P(nFreeBuffers); P(mutex); // put 1 item in the buffer V(mutex); V(nLoadedBuffers); }

Consumer() { P(nLoadedBuffers); P(mutex); // take 1 item from the // buffer V(mutex); V(nFreeBuffers); }

mutex = 0 nFreeBuffers = 0 nLoadedBuffers = 0

Developing the Solution

Each constraint needs a semaphore

semaphore mutex = 1; semaphore nFreeBuffers = 2; semaphore nLoadedBuffers = 0; Producer() { P(nFreeBuffers); P(mutex); // put 1 item in the buffer V(mutex); V(nLoadedBuffers); }

Consumer() { P(nLoadedBuffers); P(mutex); // take 1 item from the // buffer V(mutex); V(nFreeBuffers); }

mutex = 0 nFreeBuffers = 0 nLoadedBuffers = 0 1

Developing the Solution

Each constraint needs a semaphore

semaphore mutex = 1; semaphore nFreeBuffers = 2; semaphore nLoadedBuffers = 0; Producer() { P(nFreeBuffers); P(mutex); // put 1 item in the buffer V(mutex); V(nLoadedBuffers); }

Consumer() { P(nLoadedBuffers); P(mutex); // take 1 item from the // buffer V(mutex); V(nFreeBuffers); }

mutex = 0 nFreeBuffers = 0 nLoadedBuffers = 1 0

Developing the Solution

Each constraint needs a semaphore

semaphore mutex = 1; semaphore nFreeBuffers = 2; semaphore nLoadedBuffers = 0; Producer() { P(nFreeBuffers); P(mutex); // put 1 item in the buffer V(mutex); V(nLoadedBuffers); }

Consumer() { P(nLoadedBuffers); P(mutex); // take 1 item from the // buffer V(mutex); V(nFreeBuffers); }

mutex = 0 nFreeBuffers = 0 nLoadedBuffers = 0

Developing the Solution

Each constraint needs a semaphore

semaphore mutex = 1; semaphore nFreeBuffers = 2; semaphore nLoadedBuffers = 0; Producer() { P(nFreeBuffers); P(mutex); // put 1 item in the buffer V(mutex); V(nLoadedBuffers); }

Consumer() { P(nLoadedBuffers); P(mutex); // take 1 item from the // buffer V(mutex); V(nFreeBuffers); }

mutex = 0 1 nFreeBuffers = 0 nLoadedBuffers = 0

Developing the Solution

Each constraint needs a semaphore

semaphore mutex = 1; semaphore nFreeBuffers = 2; semaphore nLoadedBuffers = 0; Producer() { P(nFreeBuffers); P(mutex); // put 1 item in the buffer V(mutex); V(nLoadedBuffers); }

Consumer() { P(nLoadedBuffers); P(mutex); // take 1 item from the // buffer V(mutex); V(nFreeBuffers); }

mutex = 1 0 nFreeBuffers = 0 nLoadedBuffers = 0

Developing the Solution

Each constraint needs a semaphore

semaphore mutex = 1; semaphore nFreeBuffers = 2; semaphore nLoadedBuffers = 0; Producer() { P(nFreeBuffers); P(mutex); // put 1 item in the buffer V(mutex); V(nLoadedBuffers); }

Consumer() { P(nLoadedBuffers); P(mutex); // take 1 item from the // buffer V(mutex); V(nFreeBuffers); }

mutex = 0 nFreeBuffers = 0 nLoadedBuffers = 0

Developing the Solution

Each constraint needs a semaphore

semaphore mutex = 1; semaphore nFreeBuffers = 2; semaphore nLoadedBuffers = 0; Producer() { P(nFreeBuffers); P(mutex); // put 1 item in the buffer V(mutex); V(nLoadedBuffers); }

Consumer() { P(nLoadedBuffers); P(mutex); // take 1 item from the // buffer V(mutex); V(nFreeBuffers); }

mutex = 0 nFreeBuffers = 0 nLoadedBuffers = 0

Developing the Solution

Each constraint needs a semaphore

semaphore mutex = 1; semaphore nFreeBuffers = 2; semaphore nLoadedBuffers = 0; Producer() { P(nFreeBuffers); P(mutex); // put 1 item in the buffer V(mutex); V(nLoadedBuffers); }

Consumer() { P(nLoadedBuffers); P(mutex); // take 1 item from the // buffer V(mutex); V(nFreeBuffers); }

mutex = 0 nFreeBuffers = 0 nLoadedBuffers = 0

Developing the Solution

Each constraint needs a semaphore

semaphore mutex = 1; semaphore nFreeBuffers = 2; semaphore nLoadedBuffers = 0; Producer() { P(nFreeBuffers); P(mutex); // put 1 item in the buffer V(mutex); V(nLoadedBuffers); }

Consumer() { P(nLoadedBuffers); P(mutex); // take 1 item from the // buffer V(mutex); V(nFreeBuffers); }

mutex = 0 1 nFreeBuffers = 0 nLoadedBuffers = 0

Developing the Solution

Each constraint needs a semaphore

semaphore mutex = 1; semaphore nFreeBuffers = 2; semaphore nLoadedBuffers = 0; Producer() { P(nFreeBuffers); P(mutex); // put 1 item in the buffer V(mutex); V(nLoadedBuffers); }

Consumer() { P(nLoadedBuffers); P(mutex); // take 1 item from the // buffer V(mutex); V(nFreeBuffers); }

mutex = 1 nFreeBuffers = 0 nLoadedBuffers = 0

Developing the Solution

Each constraint needs a semaphore

semaphore mutex = 1; semaphore nFreeBuffers = 2; semaphore nLoadedBuffers = 0; Producer() { P(nFreeBuffers); P(mutex); // put 1 item in the buffer V(mutex); V(nLoadedBuffers); }

Consumer() { P(nLoadedBuffers); P(mutex); // take 1 item from the // buffer V(mutex); V(nFreeBuffers); }

mutex = 1 nFreeBuffers = 0 nLoadedBuffers = 0

Developing the Solution

Each constraint needs a semaphore

semaphore mutex = 1; semaphore nFreeBuffers = 2; semaphore nLoadedBuffers = 0; Producer() { P(nFreeBuffers); P(mutex); // put 1 item in the buffer V(mutex); V(nLoadedBuffers); }

Consumer() { P(nLoadedBuffers); P(mutex); // take 1 item from the // buffer V(mutex); V(nFreeBuffers); }

mutex = 1 nFreeBuffers = 0 1 nLoadedBuffers = 0

Developing the Solution

Each constraint needs a semaphore

semaphore mutex = 1; semaphore nFreeBuffers = 2; semaphore nLoadedBuffers = 0; Producer() { P(nFreeBuffers); P(mutex); // put 1 item in the buffer V(mutex); V(nLoadedBuffers); }

Consumer() { P(nLoadedBuffers); P(mutex); // take 1 item from the // buffer V(mutex); V(nFreeBuffers); }

mutex = 1 nFreeBuffers = 1 0 nLoadedBuffers = 0

Developing the Solution

Each constraint needs a semaphore

semaphore mutex = 1; semaphore nFreeBuffers = 2; semaphore nLoadedBuffers = 0; Producer() { P(nFreeBuffers); P(mutex); // put 1 item in the buffer V(mutex); V(nLoadedBuffers); }

Consumer() { P(nLoadedBuffers); P(mutex); // take 1 item from the // buffer V(mutex); V(nFreeBuffers); }

mutex = 1 0 nFreeBuffers = 0 nLoadedBuffers = 0

Developing the Solution

Each constraint needs a semaphore

semaphore mutex = 1; semaphore nFreeBuffers = 2; semaphore nLoadedBuffers = 0; Producer() { P(nFreeBuffers); P(mutex); // put 1 item in the buffer V(mutex); V(nLoadedBuffers); }

Consumer() { P(nLoadedBuffers); P(mutex); // take 1 item from the // buffer V(mutex); V(nFreeBuffers); }

mutex = 0 nFreeBuffers = 0 nLoadedBuffers = 0

Developing the Solution

Each constraint needs a semaphore

semaphore mutex = 1; semaphore nFreeBuffers = 2; semaphore nLoadedBuffers = 0; Producer() { P(nFreeBuffers); P(mutex); // put 1 item in the buffer V(mutex); V(nLoadedBuffers); }

Consumer() { P(nLoadedBuffers); P(mutex); // take 1 item from the // buffer V(mutex); V(nFreeBuffers); }

mutex = 0 nFreeBuffers = 0 nLoadedBuffers = 0

Implementing Semaphore
How

to implement semaphore?

Almost exactly like lock. Using spinlock or queue

What

hardware support is needed?

Interrupt disable Test-and-set

Implementing Semaphore
class semaphore { int value; } semaphore::semaphore(int i) { value = i; } semaphore::p() { // disable interrupts while (value == 0) { // enable interrupts // disable interrupts } value --; // enable interrupts } semaphore::v() { // disable interrupts value ++; // enable interrupts }

Implementing Semaphore with test and set

class semaphore { int value; } semaphore::semaphore(int i) { value = i; } semaphore::p() { while (test_and_set(guard)); while (value == 0) { // queue the thread // guard = 0 and sleep } value --; guard = 0; } semaphore::v() { while (test_and_set(guard)); if (anyone waiting) { // wake up one thread // put in on ready queue } else { value ++; } guard = 0; }

Semaphore in UNIX
Managing concurrent access to shared memory.

Semaphore system calls

Creation: semget( ) Incr/Decr/set : semop() Deletion: semctl(semid, 0, IPC_RMID, 0);

See examples: seminit.c, sema.c semb.c