Question

I’m writing a program that simply demonstrates writing and reading from a bounded buffer as it outputs what value it expected and what value actually was read. When I define N as a low value, the program executes as expected. However, when I increase the value, I start to see unexpected results. From what I understand, I am creating data races by using two threads.

By looking at the output, I think I’ve narrowed it down to about three examples of data races as follows:

1. One thread writes to the buffer while another thread reads.
2. Two threads simultaneously write to the buffer.
3. Two threads simultaneously read from the buffer.

Below is my code. The formatting is really strange for the #include statements, so I left them out.

#define BUFFSIZE 10000
#define N   10000

int Buffer[BUFFSIZE];

int numOccupied = 0;    //# items currently in the buffer
int firstOccupied = 0;  //where first/next value or item is to be found or placed

//Adds a given value to the next position in the buffer
void buffadd(int value)
{

Buffer[firstOccupied + numOccupied++] = value;
}


 int buffrem()
{

numOccupied--;
return(Buffer[firstOccupied++]);

}

void *tcode1(void *empty)
{
int i;

//write N values into the buffer

for(i=0; i<N; i++)
    buffadd(i);
}

void *tcode2(void *empty)
{
int i, val;

//Read N values from the buffer, checking the value read with what is expected for testing

for(i=0; i<N; i++)
{
    val = buffrem();
    if(val != i)
        printf("tcode2: removed %d, expected %d\n", val, i);

}
}


main()
{
pthread_t tcb1, tcb2;

pthread_create(&tcb1, NULL, tcode1, NULL);
pthread_create(&tcb2, NULL, tcode2, NULL);

pthread_join(tcb1, NULL);
pthread_join(tcb2, NULL);
}

So here are my questions.

1. Where (in my code) do these data races occur?
2. How do I fix them?

Answer 1

Use a mutex to synchronize access to your shared data structure. You will need the following:

pthread_mutex_t mutex;
pthread_mutex_init(&mutex, NULL);
pthread_mutex_lock(&mutex);
pthread_mutex_unlock(&mutex);
pthread_mutex_destroy(&mutex);

As a basic principle, you lock the mutex before reading/writing to the data structure shared between threads, and unlock it afterwards. In this case, the Buffer plus metadata numOccupied and firstOccupied are your shared data structure you need to protect. So in buffadd() and buffrem(), lock the mutex at the beginning, unlock it at the end. And in main(), initialize the mutex before starting the threads, and destroy it after joining.