Fill in the skeleton code that is provided below: Producer/Consumer Problem -Mul
ID: 3826192 • Letter: F
Question
Fill in the skeleton code that is provided below:
Producer/Consumer Problem
-Multiple producers fill data in a buffer
– Multiple consumers remove data from the same buffer
– Producers need to wait if buffer is full
– Consumers need to wait if buffer if empty
– At any time, only one producer or consumer can operate the buffer
Program two solutions to solve the problem
– Use Locks and Condition Variables
– Use Semphores
**********************************************************************************************
sem.c:
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <assert.h>
#include <pthread.h>
#include <semaphore.h>
#include <signal.h>
//At most you can have CMAX threads for producers or consumers
#define CMAX (10)
sem_t empty;
sem_t full;
sem_t mutex;
//Define global variables here
/* ==================================================== */
/* SIGNAL INTERRUPT HANDLER (Catches the SIGINT signal) */
/* ==================================================== */
void handler(int signo)
{
if(signo == SIGINT) {
printf(" Stopping... ");
stopFlag = 1;
}
}
void
Pthread_mutex_lock(pthread_mutex_t *m)
{
int rc = pthread_mutex_lock(m);
assert(rc == 0);
}
void
Pthread_mutex_unlock(pthread_mutex_t *m)
{
int rc = pthread_mutex_unlock(m);
assert(rc == 0);
}
void
Pthread_create(pthread_t *thread, const pthread_attr_t *attr,
void *(*start_routine)(void*), void *arg)
{
int rc = pthread_create(thread, attr, start_routine, arg);
assert(rc == 0);
}
void
Pthread_join(pthread_t thread, void **value_ptr)
{
int rc = pthread_join(thread, value_ptr);
assert(rc == 0);
}
void
Sem_init(sem_t *sem, unsigned int value)
{
int rc = sem_init(sem, 0, value);
assert(rc == 0);
}
void Sem_wait(sem_t *sem)
{
int rc = sem_wait(sem);
assert(rc == 0);
}
void Sem_post(sem_t *sem)
{
int rc = sem_post(sem);
assert(rc == 0);
}
void do_fill(int value)
{
//Implement fill operations here, fill one item per time
}
int do_get()
{
//Implement get operations here, remove one item per time
}
void *
producer(int * arg)
{
int i;
while (!stopFlag) {
//Use semphores to produce an item here
//print a message: producer x fills y
}
// end case
if(stopFlag == 1){
// Gracefully quit the program when CTRL + c
// At this time, only fill -1 to the buffer
//Should print a message: Producer x fills -1
}
return NULL;
}
void *
consumer(int * arg)
{
while (!stopFlag) {
//Use semphores to consume an item here
//print a message: consumer x removes y
}
return NULL;
}
void
main(int argc, char *argv[])
{
if (argc != 4) {
fprintf(stderr, "usage: %s <buffersize> <producers> <consumers> ", argv[0]);
exit(1);
}
//variables initlization here
signal(SIGINT, handler);
//Initializing semphores here
//Start running producer and consumer threads here
//Join producer and consumer thread here
// Destroy semphores here
exit(0);
}
***************************************************
locks and CVs:
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <assert.h>
#include <pthread.h>
#include <semaphore.h>
#include <signal.h>
//At most you can have CMAX threads for producers or consumers
#define CMAX (10)
pthread_cond_t empty = PTHREAD_COND_INITIALIZER;
pthread_cond_t fill = PTHREAD_COND_INITIALIZER;
pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;
// Define global variables here
/* ==================================================== */
/* SIGNAL INTERRUPT HANDLER (Catches the SIGINT signal) */
/* ==================================================== */
int stopFlag = 0; // Flag for signaling other threads to stop running.
void handler(int signo)
{
if(signo == SIGINT) {
printf(" Stopping... ");
stopFlag = 1;
}
}
void
Pthread_mutex_lock(pthread_mutex_t *m)
{
int rc = pthread_mutex_lock(m);
assert(rc == 0);
}
void
Pthread_mutex_unlock(pthread_mutex_t *m)
{
int rc = pthread_mutex_unlock(m);
assert(rc == 0);
}
void
Pthread_create(pthread_t *thread, const pthread_attr_t *attr,
void *(*start_routine)(void*), void *arg)
{
int rc = pthread_create(thread, attr, start_routine, arg);
assert(rc == 0);
}
void
Pthread_join(pthread_t thread, void **value_ptr)
{
int rc = pthread_join(thread, value_ptr);
assert(rc == 0);
}
void do_fill(int value)
{
//Implement fill operations here
//Fill one item each time
}
int do_get()
{
//Implement get item here, remove one item each time
// Return the value consumed by the consumer
}
void *
producer(int *arg)
{
while (!stopFlag) {
//Implement producer mutex and CVs here
//Should print a message: Producer x fills y
}
if(stopFlag == 1){ //end case
// Gracefully quit the program when CTRL + c
// At this time, only fill -1 to the buffer
//Should print a message: Producer x fills -1
}
return NULL;
}
void *
consumer(int *arg)
{
while (!stopFlag) {
//Implement producer mutex and CVs here
//Should print a message: Consumer x removes y
}
return NULL;
}
int
main(int argc, char *argv[])
{
if (argc != 4) {
fprintf(stderr, "usage: %s <buffersize> <producers> <consumers> ", argv[0]);
exit(1);
}
//Implement initilization here
/* ----------------------- */
/* REGISTER SIGNAL HANDLER */
/* ----------------------- */
signal(SIGINT, handler);
//Create producer threads and consumer threads here
//Join producer and consumer threads here
// Destroy the (by now unlocked) mutex lock.
// Destroy CV fill.
// Destroy CV empty.
exit(0);
}
Explanation / Answer
A simple code using thread
Related Questions
drjack9650@gmail.com
Navigate
Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.