Classical Resource Sharing

Problems

Producer / Consumer [ Bounded

Buffer Problem ].
Readers Writers Problem.
Message Passing Problem.
Dining Philosophers Problem [ More
relevant for Deadlock Prevention ].
Barber Shop Problem.

06/28/15

PSD

Se

Producer / Consumer
[ Bounded Buffer Problem ]
Basic Features

There exists a Group of Producers [ The Input Processes , Enqueuer etc.] and a
Group of Consumers [ The Data Receptor Processes , Dequeuer etc. ]

There exists a finite sized / bounded buffer ( A Queue of Items

implemented by a Circular Array A[N] where
Next Index Current Index MOD N + 1) , which is being shared among
ALL the producers & as well as ALL the consumers.

Each of the Producers produces items , one at a time, at its own speed.

After producing an item each of the Producers puts that item ( ENQUEUES
an Item ) in the shared finite sized buffer provided there is some
empty space available in the shared finite sized buffer .

Each of the consumer consumes (DEQUEUES an Item) from the Circular

Array of produced items [Element Queue ] , provided there is some
item left in the Queue, one at a time, at its own speed.

06/28/15

PSD

The Actual Scenario

Queue implemented by a Circular Array
Item being
Consumed

INPUT
Index

OUTPUT
Index

Produced
Items

Bounded
(Circular) Buffer

Producers

06/28/15

PSD

Consumers

The Shared Bounded Buffer

1. An array of N items.
2. The following Possible Status
a) Some Empty Space available
A new Item can be put in by a Producer.
b) No Empty Space available ( Full )
No New Item can be put in by any Producer.
c) Empty No Item exists to Consume by any Consumer.
3. Circularity :
Before ENQUEING : In_Ptr In_Ptr MOD N + 1
After DEQUEING : Out_Ptr Out_Ptr MOD N + 1

06/28/15

PSD

Bounded Buffer Access by the

Producers The Access Protocol
1) No new Item can be Inserted in the Shared Bounded Buffer / Queue by any Producer if there
is No Empty Place already created in it by some consumer.
2) Putting an Item in the shared Bounded Buffer / Queue by any Producer should be done via a dedicated
Input Index shared among the Producers only.
3) Exclusive access of the Input Index by any Producer while putting in an item / Enqueuing an Item is
mandatory
4) Before Enqueuing an Item in the Shared Buffer , any Producer MUST
i) WAIT for an Empty Space in the Shared Buffer .
AFTER GETTING an EMPTY Space
1. Lock the INPUT Index (IN ) from ALL other Producers
2. Update the INPUT Index IN IN MOD N + 1
3. BUFFER [IN] Produced Item.
4. Release the Input Index [IN]
5. Signal to the Consumers about the Filled Item.

Bounded Buffer Access by the

Consumers The Access Protocol
1) No Item can be taken from the Shared Buffer by any Consumer unless some Item
had already been Inserted by some producer.
2) Taking out an Item from the shared Bounded Buffer by any Consumer should be done via a
dedicated Output Index shared among the Consumers only.
3) Exclusive access of the Output Index by any Consumer while taking out in an item /
DEqueuing an Item via its Output Index [OUT] is mandatory.
4) Before DEqueuing an Item from the Shared Buffer any Consumer MUST
i) WAIT for an Filled Space in the Shared Buffer .
AFTER GETTING a Space Filled with an Item
1. Lock the Output Index (OUT ) from all other Consumers.
2. Item BUFFER [OUT] .
3. Update OUTPUT Index i.e. OUT OUT MOD N + 1
4. Release the Output Index [OUT] for the other Consumers.
5. Signal to the Producers about the Empty Space created.
.

Fairness Criteria

1) Each of the producers as well as

consumers MUST be allowed to proceed at
their own speed without being dictated by
any Producer / Consumer.
2) No producer and /or Consumer should
be forced to wait unnecessarily .
.

The Producer Process Outline

(Inserting an Item)
Step 1. Produce an Item.
Step 2. If there is No Empty Place in Buffer
THEN Wait (for Empty).
ELSE // There is Some Empty Place in the Buffer Prepare to Insert
If the Input Index ( IN_Ptr ) is already in Use by some other Producer
THEN Wait ( for IN_Ptr)
ELSE // There is Some Empty Place in the Buffer AND the Input Index ( IN_Ptr) is Free.
// Grab the IN_Ptr for Exclusive Usage.
Step 3. // Update IN_Ptr in a Bounded / Circular Buffer.
IN_Ptr IN_Ptr MOD N + 1
Step 4. // Insert the Produced Item.
Buffer [IN_Ptr] Produced Item.
Step 5. Release the IN_Ptr for other Producers.
Step 6. Signal the Presence of an Yet to be consumed Item to the Consumers.

06/28/15

PSD

The Consumer Process Outline

(Consuming an Item)
Step 1. If there is No Item in the Buffer
THEN Wait (for Full).
ELSE // There is Some Item left in the Buffer Prepare to Consume it
If the Output Index ( OUT_Ptr ) is already in Use by some other Consumer
THEN Wait ( for OUT_Ptr)
ELSE // There is Some Item left in the Buffer AND the Output Index ( OUT_Ptr) is Free.
// Grab the OUT_Ptr for Exclusive Usage.
Step 2. // Consume the Left Over Item.
Consumed Item Buffer [OUT_Ptr].
Step 3. // Update OUT_Ptr in a Bounded / Circular Buffer.
OUT_Ptr OUT_Ptr MOD N + 1
Step 4. Release the IN_Ptr for other Producers.
Step 5. Signal the Presence of an Empty Space for Inserting an Item to the Producers.

06/28/15

PSD

Producer Consumer Co- Operation

As soon as any producer puts an item in the shared

bounded buffer it should signal to the group of
consumers about the existence of a new item
( Fullness ) of the shared bounded buffer so that
some consumer can take/consume that item.

As soon as any consumer consumes an item from

the shared bounded buffer it should signal to the
group of producers about an available space
( Emptiness) of the shared bounded buffer so that
some producer can put in an item there.

06/28/15

PSD

10

The Fairness ( Lifeness ) Criteria

1) Each of the producers as well as consumers MUST
be allowed to proceed at their own speed without
being dictated by any Producer / Consumer.
2) No producer and /or consumer should be forced to
wait unnecessarily.

06/28/15

PSD

11

Bounded Buffer
The Required Semaphores

One semaphore Mutex ( Short hand Notation for

Mutual Exclusion ) for enforcing Mutual Exclusion
among the Producers while sharing the IN_Ptr
as well as among the Consumers while sharing
the Out_Ptr.
Two counting Semaphores Empty & Full for
Producer Consumer Co-operation.
Producers wait on Empty while signal Full.
Consumers wait on Full while signal Empty.

06/28/15

PSD

12

The Declaration Section

const N = .; // Buffer Size
typedef Item_type = .;
shared struct Buffer
{ // begin Buffer
Elmnt : Array [0..N-1] of Item_type;
In, Out : 0..N-1; // Buffer Indices
}; // end Buffer
shared B Sem_T Mutex ; // Binary Semaphore
// for Mutual Exclusion among its Indices
shared Sem_T Full, Empty ; // Counting
// Semaphores
06/28/15

PSD

13

The Initialization Section

Empty. Count = n; // Entire n Element Buffer is
empty
Full. Count = 0; // No Elements in the Buffer is
filled
Mutex = 1; // Allow Buffer Index
// Manipulation
Buffer. In = Buffer .Out = 0; // Initialize Buffer
Pointers
06/28/15

PSD

14

The Producer Process

Void Producer ( void )
{ // begin Producer
Item_type Item;
repeat
Produce (Item);
Wait (Empty); // wait till some empty space is available on buffer
Wait (Mutex); // Wait for availability of Buffer Input Index
// capture Buffer
// ENQ ( BUFFER, Item)
Buffer. In = Buffer. In mod N + 1 ; // Update Buffer Input
// Index
Buffer. Elmnt [Buffer. In] = Item; // Put Element in Buffer
Signal (Mutex) ; // Release buffer Input Index
Signal (Full); // To the Consumers

forever
}// end Producer

06/28/15

PSD

15

The Consumer Process

Void Consumer ( void )
{ // begin Consumer
Item_type Item;
repeat
Wait (Full); // Wait for some filled up places in Buffer
Wait (Mutex); // Wait for Buffer Out Index to be Free
// Capture Buffer
// DEQ (Buffer, Item)
Item = Buffer .Elmnt [Buffer. Out]; // Take out the
// Element
Buffer. Out = Buffer. Out mod N + 1; // Update Buffer Out Index
Signal (Mutex) ; // Release Buffer Out Index
Signal (Empty); // To the Producer
forever
} // end Consumer

06/28/15

PSD

16