CS 3733 Operating Systems Notes: Semaphore implementation without busy waiting

The idea:

When a process begins waiting, it should be removed from the CPU.
It goes into a special queue of processes waiting for a semaphore
This is like an I/O waiting queue.
The OS will manage this queue (say as a FIFO queue) and remove a process when a signal occurs.
A semaphore will now be a record consisting of an integer (S.value) and a linked list of waiting processes (S.list).
If the integer is 0 or negative, its magnitude is the number of processes waiting for this semaphore.
It is initialized to have 0 value and empty list.

wait(S):

 S.value--;  
 if (S.value < 0) {
     <Add this process to S.list>
     <block>
 }

signal(S):

 S.value++;
 if (S.value <= 0) {
    <move a process from S.list to the ready list>
 }

Standard ways to use a semaphore:
Protect a critical section:
S is initialized to 1:

   wait(S);
     <C.S.>
   signal(S);

Make sure P₁ executes before P₂:
S initialized to 0:
P₁

   <do something>
   signal(S);

P₂

   wait(S);
   <do something>

Note: the type of queue we use will determine the order in which processes which are waiting for a given semaphore get serviced.
A FIFO queue guarantees bounded waiting, but othe queue techniques may produce starvation.

Care must be taken when dealing with semaphores:
Consider two processes P₁ and P₂.
P₁ executes:

       wait(S);
           ...
       signal(Q);

while P₂ executes:

        wait(Q);
           ...
        signal(S);

Each is waiting for the other and if the semaphores are both initialized to 0, a deadlock can occur.

Bounded buffer problem using sempahores
Assume we have n buffers.
Use three semaphores:

mutex initialized to 1 (used for mututal exclusion)
empty initialized to n (keeps track of the number of empty slots)
full initialized to 0 (keeps track of the number of full slots)

Producer Loop

     produce item in nextp
     wait(empty)
     wait(mutex)
        <add nextp to buffer>
     signal(mutex)
     signal(full)

Consumer Loop

     wait(full)
     wait(mutex)
        <remove item from buffer, put in nextp>
     signal(mutex)
     signal(empty)
     consume item in nextp