Scribd
Upload
310 views

Generalized Producer-Consumer Solution Using Semaphore

The document describes the producer-consumer problem and provides a solution using semaphores to synchronize multiple producers and consumers that share a common buffer. The solution uses three semaphores - one mutex lock to protect the shared buffer and two semaphores to track empty and full buffer slots. The producer thread waits for empty slots, adds items to the buffer, and signals available data. The consumer waits for data and removes items from the buffer, signaling available slots. Pseudocode and C code implementing the solution with threads are provided.

Uploaded by

1989vijay
Copyright
© Attribution Non-Commercial (BY-NC)
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
310 views

Generalized Producer-Consumer Solution Using Semaphore

The document describes the producer-consumer problem and provides a solution using semaphores to synchronize multiple producers and consumers that share a common buffer. The solution uses three semaphores - one mutex lock to protect the shared buffer and two semaphores to track empty and full buffer slots. The producer thread waits for empty slots, adds items to the buffer, and signals available data. The consumer waits for data and removes items from the buffer, signaling available slots. Pseudocode and C code implementing the solution with threads are provided.

Uploaded by

1989vijay
Copyright
© Attribution Non-Commercial (BY-NC)
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
You are on page 1/ 5

Page link: http://bir2su.blogspot.com/2008/12/producer-consumer-problem-is-classical.

html

Generalized Producer-Consumer solution using Semaphore


The producer-consumer problem is a classical example of a multi-process synchronization problem. It illustrates the need for synchronization in systems where many processes share a resource. The problem describes two processes, the producer and the consumer, who share a common, fixed-size buffer. The producer's job is to generate a piece of data, put it into the buffer and start again. At the same time the consumer is consuming the data (i.e. removing it from the buffer) one piece at a time. The problem is to make sure that the producer won't try to add data into the buffer if it's full and that the consumer won't try to remove data from an empty buffer.

Here, the problem is generalized to have multiple producers and consumers. The solution to these type of problem must assure three constraints 1. Mutual exclusion

2. Free from Deadlock 3. Free from Starvation Pseudo-code for the solution to multiple producer- consumer problem is given below. Semaphore fullBuffer = 0; // Initially, no item in buffer Semaphore emptyBuffers = numBuffers; // Initially, num empty buffer Semaphore mutex = 1; Producer(item) { emptyBuffers.P(); // Wait until space mutex.P(); Enqueue(item); mutex.V(); fullBuffers.V(); } Consumer() { fullBuffers.P(); mutex.P(); item = Dequeue(); // Tell consumers there is data in buffer // Wait until buffer free // No thread updating the buffer

mutex.V(); emptyBuffers.V(); return item; } The mutex lock is used to ensure that only one process will be accessing the buffer at a time,this protect the Queue data structure (a shared buffer) from being damaged. If the mutex lock is not used then the concurrent process can manipulate the head and tail pointer associated with the buffer in undesired way. The emptyBuffers and fullBuffer are the semaphore specifying the no of the empty buffers and fullbuffer available respectively.

The code implementing the given pseudo-code is shown below:

/* * main.c * * * * * Created on: Dec 31, 2008 Author: Suvash Sedhain Multiple producer and Multiple consumer solution using Semaphores Note: semaphore.P() is actually sem_wait() and semaphore.V() is

sem_post() * * * * Ref: - Operating System Concepts : Abraham Silberschatz, Peter Baer as defined in semaphore.h

Galvin, Greg Gagne * * - Operating Systems, William Stallings - Professor John D. Kubiatowicz lectures notes, University of

California, Berkeley * * */ website: http://inst.eecs.berkeley.edu/~cs162

#include <stdlib.h> #include <pthread.h> #include <semaphore.h> #include <unistd.h> #include <stdio.h> #define BUFFER_SIZE 5 const int MAX_PRODUCER = 20; const int MAX_CONSUMER = 20;

// information to maintain the circular queue data structure int head = 0; int tail = 0;

//shared buffer int buffer[BUFFER_SIZE]; // mutex lock for buffer pthread_mutex_t mutex; //semaphores for specifying the empty and full sem_t emptyBuffers; sem_t fullBuffer;

//initialze the locks void initialize_locks() { pthread_mutex_init(&mutex,NULL); sem_init(&emptyBuffers,0,5); sem_init(&fullBuffer,0,0); }

// Produce random value to shared buffer void *producer(void *param) { int item;

while(1) { item = rand(); sem_wait(&emptyBuffers); pthread_mutex_lock(&mutex); buffer[tail] = item ; tail = (tail+1) % BUFFER_SIZE; printf ("producer: inserted %d \n", item); fflush (stdout); pthread_mutex_unlock(&mutex); sem_post(&fullBuffer);

} printf ("producer quiting\n"); } fflush (stdout);

//consume values from the shared buffer void *consumer(void *param) { int item; while (1) { sem_wait(&fullBuffer); pthread_mutex_lock(&mutex); item = buffer[head]; head = ( head + 1) % BUFFER_SIZE; printf ("consumer: removed %d \n", item); fflush (stdout); pthread_mutex_unlock(&mutex); sem_post(&emptyBuffers); } }

int main( int argc, char *argv[]) { int i, sleep_time = 100, no_of_consumer_threads = 10, no_of_producer_threads = 2; pthread_t producer_id[MAX_PRODUCER], consumer_id[MAX_CONSUMER]; initialize_locks(); // create producer threads for(i = 0; i < no_of_producer_threads; i++) { if (pthread_create(&producer_id[i],NULL,producer,NULL) != 0) { fprintf (stderr, "Unable to create producer thread\n"); return -1; } } // create consumer threads for(i = 0; i < no_of_consumer_threads; i++) { if (pthread_create(&consumer_id[i],NULL,consumer,NULL) != 0) { fprintf (stderr, "Unable to create consumer thread\n"); } } sleep(sleep_time); return 0; }

You might also like

pFad - Phonifier reborn

Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.

Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.


Alternative Proxies:

Alternative Proxy

pFad Proxy

pFad v3 Proxy

pFad v4 Proxy