Empty element in array-based bounded buffer - c++

Question

I have a classic producer/consumer problem. The code for producer is this:
#define BUFFER_SIZE 10
while (true) {
/* Produce an item */
while (( (in + 1) % BUFFER_SIZE) == out)
; /* do nothing -- no free buffers */
buffer[in] = item;
in = (in + 1) % BUFFER_SIZE;
}
And the consumer is:
while (true) {
while (in == out)
; // do nothing -- nothing to consume
// remove an item from the buffer
item = buffer[out];
out = (out + 1) % BUFFER_SIZE;
return item;
}
This works fine but the problem is that when the first eight elements are filled up and in=9 and out=0, the producer sits there and does not fill the last (ninth) element. This also happens when say, in=4 and out=5. In every case, one element is left empty and the queue appears to be "full" even though one slot is still empty.
I can come up with a few complicated checks but I need to know if there is a clean solution to filling the whole queue. I have tried incrementing in first and then putting the item in but that also runs into similar problems. (Initializing with -1 for both in and out doesn't work either).

Answer 1

See Wikipedia on this very topic. The simplest solutions appear to be either of:
Always keep one slot empty: if in == out then the buffer is empty; if in == out - 1, buffer is full
Replace out with num_unread_items; perform simple maths to retrieve out from num_unread_items and in
... but there are other options related to counting the number of read & write operations (either in separate variables or directly in in and out); or tracking whether the last operation was a read or a write in addition to the current in and out, which allows you to disambiguate the buffer-full/buffer-empty cases.

Answer 2

In an OS development class in college, I had an adjunct teacher that claimed it was impossible to have a software-only solution that could use all N elements in the buffer.
I proved him wrong with something I decided to call the race track solution (inspired by the fact that I like to run track).
On a race track, you are not limited to a 400 meter race; a race can consist of more than one lap. What happens if two runners are neck and neck
in a race? How do you know whether they are tied, or whether one runner has lapped the other? The answer is simple: in a race, we don't monitor a runner's position
on the track; we monitor the distance each runner has traversed. Thus, when two runners are neck and neck, we can disambiguafy between a tie and when one runner has
lapped the other.
So, our algorithm has an N-element array, and manages a 2N race. We don't restart the producer/consumer's counter back to zero until they finish their respective 2N race.
We don't allow the producer to be more than one lap ahead of the consumer, and we don't allow the consumer to be ahead of the producer.
Actually, we only have to monitor the distance between the producer and consumer.
The code is as follows:
Item track[LAP];
int consIdx = 0;
int prodIdx = 0;
void consumer()
{ while(true)
{ int diff = abs(prodIdx - consIdx);
if(0 < diff) //If the consumer isn't tied
{ track[consIdx%LAP] = null;
prodIdx = (prodIdx + 1) % (2*LAP);
}
}
}
void producer()
{ while(true)
{ int diff = (prodIdx - consIdx);
if(diff < LAP) //If prod hasn't lapped cons
{ track[prodIdx%LAP] = Item(); //Advance on the 1-lap track.
prodIdx = (prodIdx + 1) % (2*LAP);//Advance in the 2-lap race.
}
}
}
It's been a while since I originally solved the problem, so this is according to my best recollection. Hopefully I didn't overlook any bugs.
Hope this helps!