Race Condition

• A potential problem; the order of instructions of cooperating processes (see Table 1).
  

  Table 1: Race Condition

  Process A	Process B	concurrent access
  X = 1;	Y = 2;	does not matter
  X = Y + 1;	Y = Y * 2;	important!

  
  
• Producer-consumer problem. It is described that how a bounded buffer could be used to enable processes to share memory
  • Bounded buffer problem. The solution allows at most
    $BUFFER\_SIZE - 1$ items in the buffer at the same time.
  • An integer variable counter, initialized to 0. counter is incremented every time we add a new item to the buffer and is decremented every time we remove one item from the buffer.
• The code for the producer process:

   while (true)
    {
      /* produce an item in next Produced */
      while (counter == BUFFER_SIZE)
        ; /* do nothing */
      buffer [in] = nextProduced;
      in = (in + 1) % BUFFER_SIZE;
      counter++;
    }
  

• The code for the consumer process:

   while (true)
    {
      while (counter == 0)
        ; /* do nothing */
      nextConsumed = buffer [out] ;
      out = (out + 1) % BUFFER_SIZE;
      counter--j;
      /* consume the item in nextConsumed */
    }
  

• Although both the producer and consumer routines are correct separately, they may not function correctly when executed concurrently.
• We would arrive at incorrect state because we allowed both processes to manipulate the variable counter concurrently.
• A race condition is a situation where two or more processes access shared data concurrently and final value of shared data depends on timing (race to access and modify data)
• To guard against the race condition above, we need to ensure that only one process at a time can be manipulating the variable counter (process synchronization).