Note: The following (with modifications) is adapted from Silberschatz (our course textbook), Project: Producer-Consumer Problem.

Transcription

1 CSCI-375 Operating Systems Lab #5 Semaphores, Producer/Consumer Problem October 19, 2016 Note: The following (with modifications) is adapted from Silberschatz (our course textbook), Project: Producer-Consumer Problem. The code below illustrates how a semaphore is created: sem_t sem; // Create the semaphore and initialize it to 5 sem_init(&sem, 0, 5); The sem_init() creates and initializes a semaphore. This function is passed three parameters: 1. A pointer to the semaphore 2. A flag indicating the level of sharing 3. The semaphore s initial value In this example, by passing the flag 0, we are indicating that this semaphore can only be shared by threads belonging to the same process that created the semaphore. A nonzero value would allow other processes to access the semaphore as well. Pthreads names the P() and V() operations that we discussed in class sem_wait() and sem_post(), respectively. The code example below creates a binary semaphore mutex with an initial value of 1 and illustrates its use in protecting a critical section: sem_t mutex; // Create the semaphore and initialize it to 1 sem_init(&mutex, 0, 1); sem_wait(&mutex); // *** critical section *** sem_post(&mutex); Your task is to carefully read, understand, complete, and run the code below, which implements a semaphore-based solution to the bounded buffer producer/consumer problem that we discussed in class. The parts of the program that you need to complete are written in boldface.

2 The buffer is manipulated with two functions, insert_item() and remove_item(), which are called by the producer and consumer threads, respectively. After you complete (by using semaphores) the insert_item() and remove_item()functions, these functions will synchronize the producer and consumer threads. You must use three semaphores: empty and full, which count the number of empty and full slots in the buffer, and mutex, which is a binary (or mutual exclusion) semaphore that protects the actual insertion or removal of items in the buffer (i.e., the critical section). The main() function initializes the buffer and creates separate producer and consumer threads. Once it has created the producer and consumer threads, the main() function will sleep for a period of time and, upon awakening, will terminate the application. The main() function is passed three parameters on the command line: 1. How long to sleep before terminating 2. The number of producer threads 3. The number of consumer threads The producer thread alternates between sleeping for a random period of time and inserting a random integer into the buffer. The consumer thread sleeps for a random period of time and, upon awakening, attempts to remove an item from the buffer. After you complete the code, compile it: gcc buffer.c lpthread or gcc buffer.c lpthread lposix After successful compilation, run the program and test it. Submit a printout of the completed program. // buffer.c // Bounded-buffer Producer/Consumer problem with semaphores #include <stdio.h> #include <stdlib.h> #include <pthread.h> #define TRUE 1 #define BUFFER_SIZE 5 typedef int buffer_item; buffer_item buffer[buffer_size]; // DECLARE THE 3 SEMAPHORES empty, full, AND mutex int insertpointer = 0, removepointer = 0; void *producer(void *param); void *consumer(void *param); int insert_item(buffer_item item);

3 int remove_item(buffer_item *item); int insert_item(buffer_item item) // EXECUTE OPERATION ON empty SEMAPHORE TO WAIT FOR EMPTY SPACE IN BUFFER // EXECUTE OPERATION ON mutex SEMAPHORE TO WAIT FOR ACCESS TO CRITICAL // SECTION (I.E., BUFFER) TO INSERT ITEM buffer[insertpointer++] = item; insertpointer = insertpointer % 5; // EXECUTE OPERATION ON mutex SEMAPHORE TO RELEASE ACCESS TO CRITICAL SECTION (I.E., BUFFER) // EXECUTE OPERATION ON full SEMAPHORE TO SIGNAL AVAILABILITY OF ONE MORE ITEM IN BUFFER int remove_item(buffer_item *item) // EXECUTE OPERATION ON full SEMAPHORE TO WAIT FOR ITEM IN BUFFER // EXECUTE OPERATION ON mutex SEMAPHORE TO WAIT FOR ACCESS TO CRITICAL // SECTION (I.E., BUFFER) TO REMOVE ITEM *item = buffer[removepointer]; buffer[removepointer++] = -1; removepointer = removepointer % 5; // EXECUTE OPERATION ON mutex SEMAPHORE TO RELEASE ACCESS TO CRITICAL SECTION (I.E., BUFFER) // EXECUTE OPERATION ON empty SEMAPHORE TO SIGNAL AVAILABILITY OF ONE MORE FREE SPACE IN BUFFER int main(int argc, char *argv[])

4 int sleeptime, producerthreads, consumerthreads; int i, j; if(argc!= 4) fprintf(stderr, "Useage: <sleep time> <producer threads> <consumer threads>\n"); return -1; sleeptime = atoi(argv[1]); producerthreads = atoi(argv[2]); consumerthreads = atoi(argv[3]); // INITIALIZE THE THREE SEMAPHORES srand(time(0)); //Create the producer and consumer threads for(i = 0; i < producerthreads; i++) pthread_t tid; pthread_attr_t attr; pthread_attr_init(&attr); pthread_create(&tid, &attr, producer, NULL); for(j = 0; j < consumerthreads; j++) pthread_t tid; pthread_attr_t attr; pthread_attr_init(&attr); pthread_create(&tid, &attr, consumer, NULL); //Sleep for user specified time sleep(sleeptime); void *producer(void *param) buffer_item random; int r;

5 while(true) r = rand() % 5; sleep(r); random = rand(); if(insert_item(random)) fprintf(stderr, "Error"); printf("producer produced %d \n", random); void *consumer(void *param) buffer_item random; int r; while(true) r = rand() % 5; sleep(r); if(remove_item(&random)) fprintf(stderr, "Error Consuming"); else printf("consumer consumed %d \n", random);