The reader/writer problem

Problem description
- There is a shared FIFO buffer of a certain fixed size
- One thread writes into the shared buffer
  The writer thread must block (wait) when the shared buffer is full
- One other thread reads from the shared buffer
  The reader thread must block (wait) when the shared buffer is empty

The read/write buffering scheme

The reader/writer problem uses a circular buffer to store the data items:

nItems = 0 buf: 0 1 2 3 4 ... N-1 +---+---+---+---+---+---+---+---+---+---+---+ | | | | | | | | | | | | +---+---+---+---+---+---+---+---+---+---+---+

Two pointers are used to access the buffer:

A read pointer that points to the next item that is read
A write pointer that points to the next empty slot in the buffer

The pointers are initialized as follows:

nItems = 0 buf: 0 1 2 3 4 ... N-1 +---+---+---+---+---+---+---+---+---+---+---+ | | | | | | | | | | | | +---+---+---+---+---+---+---+---+---+---+---+ ^ | readPtr writePtr

After the writer write an item into the buffer, the writePtr is advanced:

After 3 more writes, the writePtr is then advanced to:

nItems = 4 buf: 0 1 2 3 4 ... N-1 +---+---+---+---+---+---+---+---+---+---+---+ | x | x | x | x | | | | | | | | +---+---+---+---+---+---+---+---+---+---+---+ ^ ^ | | readPtr | | writePtr

(Notice that the writePtr always points to the next empty slot.

The readPtr is on the next available item for reading)

If the reader reads an item from the buffer, the readPtr is advanced:

nItems = 3 buf: 0 1 2 3 4 ... N-1 +---+---+---+---+---+---+---+---+---+---+---+ | | x | x | x | | | | | | | | +---+---+---+---+---+---+---+---+---+---+---+ ^ ^ | | readPtr | | writePtr

Solving the problem with locks

Consider the follwoing solution using mutex locks:

Shared variables: int MAX; int nItems = 0; // Number of items in buffer int buf[MAX];
Writer: while ( true ) { int x; x = produce_next_value(); lock(mutex); if ( nItems == N ) WAIT (BLOCK); buf[writePtr] = x; // Put x in buffer writePtr = (writePtr+1) % N; nItems++; if ( reader is BLOCKED ) UNBLOCK reader; unlock(mutex); }
Reader: while ( true ) { int x; lock(mutex); if ( nItems == 0 ) WAIT (BLOCK); x = buf[readPtr++]; // Get x from buffer readPtr = (readPtr+1) % N; nItems--; if ( writer is BLOCKED ) UNBLOCK writer; unlock(mutex); consume_value(x); }

This solution will end in deadlock

Here is a sequence of steps that will leads to deadlock:

1. Reader starts first 2. Reader locks the mutex 3. Reader finds buffer empty 4. Reader blocks 5. Writer starts 6. Writer tries to lock the mutex 7. Write blocks too

The system is now dead locked because the writer cannot put an item in the buffer to release the reader

A solution without locks

We can avoid using locks by noting that:

The buffer is empty when readPtr == writePtr:

nItems = 0 buf: 0 1 2 3 4 ... N-1 +---+---+---+---+---+---+---+---+---+---+---+ | | | | | | | | | | | | +---+---+---+---+---+---+---+---+---+---+---+ ^ | readPtr writePtr

The buffer is about to fill up when (writePtr+1)%N == readPtr:

nItems = N-1 buf: 0 1 2 3 4 ... N-1 +---+---+---+---+---+---+---+---+---+---+---+ | x | x | x | x | | x | x | x | x | x | x | +---+---+---+---+---+---+---+---+---+---+---+ ^ ^ | | | readPtr writePtr writePtr has wrapped around and points to the last empty slow

We will not use the last empty slot
(Because if we fill the last empty slot, we will no be able to distinguish the filled state from the empty state)

So we will detect the full buffer state using:

(writePtr+1)%N == readPtr

Consider the following solution witout using mutex locks:

Shared variables: int MAX; int nItems = 0; // Number of items in buffer int buf[MAX];
Writer: while ( true ) { int x; x = produce_next_value(); if ( (writePtr+1)%N == readPtr ) { // Buffer is full WAIT (BLOCK); } buf[writePtr] = x; // Put x in buffer writePtr = (writePtr+1) % N; if ( reader is BLOCKED ) UNBLOCK reader; }
Reader: while ( true ) { int x; if ( readPtr == writePtr ) { // Buffer is empty WAIT (BLOCK); } x = buf[readPtr]; // Get x from buffer readPtr = (readPtr+1) % N; if ( writer is BLOCKED ) UNBLOCK writer; consume_value(x); }

This solution can avoid the deadlock situation described above:


   1. Reader starts first
   2. Reader finds buffer empty (readPtr == writePtr)      
   3. Reader blocks

   4. Writer starts
   5. Writer write an item to buffer
   6. Writer detects a BLOCKED reader and            
      UNBLOCKS the reader...

Problem solved... or so it seems :-)

This solution will also end in deadlock
But creating a situation is more subtle.

Here is a sequence of steps that will leads to deadlock:

1. Reader starts first 2. Reader finds buffer empty (readPtr == writePtr) 3. Writer starts !!! 4. Writer detects buffer not filled 5. Writer writes an item 4. Writer again detects buffer not filled 5. Writer again writes an item .... and so on until buffer is filled completely (All the while, the reader did not progress, so reader is NOT BLOCKED) k. Writer Blocks k+1. Reader finally progresses and BLOCKS

The system is now dead locked

NOTE:

Lesson from the reader/writer problem
- There are different kinds of synchronization problems
- Different kinds of synchronization problems will require different kinds of synchronization primitives to resolve the sharing problem
Semaphore synchronization primitive
- A semaphore is a shared memory synchronization method that is more general than locks
- A semaphore does not have ownership requirements
  Any thread can perform operations on a semaphore
- The semaphore concept (invented by Dijkstra) was inspired by the train system
  Here is a picture of a "real life" semaphore:
- A semaphore is used on a stretch of rail where that is only one set of tracks.
  A semaphore is places at the entrance of stretch of single-tracked rail:
- When a train passes a semaphore, it disables the power of train on the other end
  So there can only be one train traveling on the stretch of rail !!!
  (Older semaphores will only cause the signal at the other end to set to the danger state and the conductor must manually stop the train....)

Definition of a (counting) semaphore

Conceptually a (counting) semaphore consists of:
When the semaphore is defined, the count variable is set to a given value and the queue is empty
Example:

There are 2 operations defined on a semaphore s:

P(s): (pass - Dutch: passeer)

The operation is trying to pass the semaphore (check point)
If the semaphore's value is greater than zero, then:
1. P(s) is successful (i.e., the thread continues execution)
2. The semaphore's value is decremented by one
If the semaphore's value is ZERO, then:
1. P(s) is unsuccesfull (i.e., the thread will BLOCK - put in the semaphore queue)
2. (The semaphore's value remains ZERO)

V(s): (leave - Dutch: verlaten)

This operation is make the train leave the guarded section
This operation will always be successful
Effect:
1. If the semaphore's value is greater than zero, then: increment count by one
2. If the semaphore's value is ZERO, and no thread is BLOCKED in the queue, then: set semaphore value to ONE
3. If the semaphore's value is ZERO, and some thread(s) is BLOCKED in the queue, then: UNBLOCK one of the threads

Furthermore: the P(s) and V(s) operations are atomic

That means all the effects of each operations are completed without any interruption (no intervening action of any kind).

Semaphores used to solve access to shared variables
- Similar to locks, a semaphore can be used to access shared variables
  Example code used to access a shared variable:
  Because the semaphore is initialed to one, the number of times that P(s) will succeed is one time only.
  Therefore, only one thread can pass P(s) at any time...
  Mutual exclusion is ensured !

Semaphores used to solve the reader/writer problem

Example

Shared variables: int MAX; int nItems = 0; // Number of items in buffer int buf[MAX]; semaphore sender(MAX); // Initially, let sender in MAX times semaphore receiver(0); // Inirially, block receiver's entry
Writer: while ( true ) { int x; x = produce_next_value(); P(sender); buf[writePtr] = x; // Put x in buffer writePtr = (writePtr+1) % N; V(receiver); }
Reader: while ( true ) { int x; P(receiver); x = buf[readPtr]; // Get x from buffer readPtr = (readPtr+1) % N; V(sender); consume_value(x); }

It's tricky:

The sender can succeed at most MAX times; then it will block
So if P(sender) succeeds, the sender can surely find an empty slot to write into
The receiver can only succeed if the sender lets it succeed
The sender "gives" credits to the receiver by using: V(receiver)
In turn, the receiver - after taking an item from the buffer - "gives" credits to the sender by using: V(sender)