How to implement multi-producer multi-consumer single-buffer model? - locking

Question

There is one buffer, multiple producers and multiple consumers. Any producer(only one) can write the buffer when it is empty. Any consumer(only one) can read the buffer when it is full. How to implement such a model?
I tried using pthread_cond_wait and pthread_cond_signal. But I didn't find a solution.

Answer 1

The following multiple producer multiple consumer single buffer implementation is implemented using Ada. The protected object is the buffer. There are two producers and two consumers. The protected object implicitly handles all the locking and condition variables.
The producer task type, consumer task type and protected object are all defined in an Ada package.
The package specification is:
-----------------------------------------------------------------------
-- Producer-consumer with bounded buffer
-----------------------------------------------------------------------
generic
Capacity : Positive;
package Bounded_PC is
task type Producer is
entry set_id(Id : in Positive);
entry Stop;
end Producer;
task type Consumer is
entry set_id(Id : in Positive);
entry Stop;
end Consumer;
end Bounded_PC;
The package body contains the implementation of the task types and the shared buffer.
with Ada.Text_IO; use Ada.Text_IO;
package body Bounded_PC is
subtype Index_T is Positive range 1..Capacity;
type Buf_Array is array (Index_T) of Integer;
------------
-- Buffer --
------------
protected Buffer is
Entry Write(Item : in Integer);
Entry Read(Item : out Integer);
private
Buf : Buf_Array;
Write_Index : Index_T := 1;
Read_Index : Index_T := 1;
Count : Natural := 0;
end Buffer;
protected body Buffer is
entry Write(Item : in Integer) when Count < Capacity is
begin
Buf(Write_Index) := Item;
Write_Index := (Write_Index mod Capacity) + 1;
Count := Count + 1;
end Write;
entry Read(Item : out Integer) when Count > 0 is
begin
Item := Buf(Read_Index);
Read_Index := (Read_Index mod Capacity) + 1;
Count := Count - 1;
end Read;
end Buffer;
--------------
-- Producer --
--------------
task body Producer is
Value : Integer := 0;
Me : Positive;
begin
accept Set_Id(Id : in Positive) do
Me := Id;
end Set_Id;
loop
select
accept Stop;
exit;
else
select
Buffer.Write(Value);
Put_Line("Producer" & Me'Image & " wrote" & Value'Image);
Value := Value + 1;
or
delay 0.001;
end select;
end select;
end loop;
end Producer;
--------------
-- Consumer --
--------------
task body Consumer is
Value : Integer;
Me : Positive;
begin
accept Set_Id(Id : in Positive) do
Me := Id;
end Set_Id;
loop
select
accept Stop;
exit;
else
select
Buffer.Read(Value);
Put_Line("Consumer" & Me'Image & " read" & Value'Image);
or
delay 0.001;
end select;
end select;
end loop;
end Consumer;
end Bounded_PC;
The condition for each entry call is declared in the protected body.
entry Write(Item : in Integer) when Count < Capacity
entry Read(Item : out Integer) when Count > 0
The main procedure for this program is:
with Bounded_PC;
procedure Main is
package Int_Pck is new Bounded_Pc(10);
use Int_Pck;
P1 : Producer;
P2 : Producer;
C1 : Consumer;
C2 : Consumer;
begin
P1.Set_Id(1);
P2.Set_Id(2);
C1.Set_Id(1);
C2.Set_Id(2);
delay 0.01;
P1.Stop;
P2.Stop;
delay 0.01;
C1.Stop;
C2.Stop;
end Main;

Answer 2

I figure out a solution:
bool buffer_empty = true;
// consumer thread:
pthread_mutex_lock(&buffer_lock);
while (buffer_empty) {
pthread_cond_wait(&buffer_full, &buffer_lock);
}
// consume
buffer_empty = true;
pthread_mutex_unlock(&buffer_lock);
// producer thread:
pthread_mutex_lock(&buffer_lock);
while (!buffer_empty) {
pthread_cond_wait(&buffer_full, &buffer_lock);
}
// produce
buffer_empty = false;
pthread_mutex_unlock(&buffer_lock);
pthread_cond_signal(&buffer_full);