l13 06 producer consumer

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.

PSD Semaphore_Application

Producer / Consumer [ Bounded Buffer Problem ]Basic FeaturesThere 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.

PSD Producer_Consumer

The Actual Scenario Queue implemented by a Circular ArrayProducersConsumersBounded (Circular) BufferProduced ItemsItem being ConsumedINPUT IndexOUTPUT Index


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


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.


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.


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.


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.


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.


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 Buffershared B Sem_T Mutex ; // Binary Semaphore // for Mutual Exclusion among its Indicesshared Sem_T Full, Empty ; // Counting // Semaphores


The Initialization SectionEmpty. 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


The Producer Process Void Producer ( void ) { // begin Producer Item_type Item; repeatProduce (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


The Consumer ProcessVoid 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


Resource Sharing ProblemsP.S.Dey

l13 06 producer consumer

Documents