Question

Can someone help create this program for Linux.

Part 3. IPC (InterProcess Communication) Programming In Part 3, you are asked to develop a multithreaded program and a Makefile to automate the compilation on Linux platform. This assignment assists you for better understanding of processes and threads management, multithreaded programming, and enhancing programming skills and experience with programming on a Unix-like environment. You are asked to implement a multithreaded producer-consumer problem with PThreads library in this programming assignment. The producer-consumer is a common problem that requires cooperating processes or threads. In this problem, a producer produces items and put into a shared buffer, then these items are consumed by consumers. Synchronization and mutual exclusion are required to solve the problem correctly as discussed in the lecture and described in the textbook (please see section 2.3 and corresponding lectures). Figure 2-32 in the textbook shows a solution with one producer and one consumer. In this part of assignment, you are asked to implement this problem with support of multiple producers and consumers threads with PThreads library on a Linux platform. Requirements: 1 Ensure appropriate synchronization and mutual exclusion using PThreads mutex locks and conditional variables as discussed in the class and shown in Figure 2-32 2. Support multiple producer threads and multiple consumer threads. The number of producer threads and consumer threads can be either hard coded in the program or provided through command line arguments. 3. Print out the producer/consumer actions, e.g., "producer i produced one item", "consumer j consumed one item", "producer i found the buffer is full and waiting for a consumer to consume", and "consumer j found the buffer is empty and waiting for a producer to produce 4. You can fix the shared buffer with 8 items, and produce 64 items from each producer thread. Test with 1 producer thread and 1 consumer thread, 2 producer threads and 2 consumer threads, and 4 producer and 4 consumer threads. 5. Develop a Makefile, similar to the one we discussed in lecture to automate the compilation process. Hints: Implement a producer routine and a consumer routine, in which, a mutex lock and a conditional variable used to synchronize accessing the shared buffer. Figure 2-32 in the textbook shows a solution with one producer and one consumer .In the main function, create multiple producer and consumer threads separately, and call for producer/consumer routine. Don't forget to join threads and deallocate data structures such as mutex locks and conditional variables created as shown in Figure 2-32.

Answer 1

# include <stdio.h>
# include <pthread.h>
# include <stdlib.h>
# define BufferSize 10 //defining buffer size

void *Producer();
void *Consumer();

int BufferIndex=0;
char *BUFFER;

pthread_cond_t Buffer_Not_Full=PTHREAD_COND_INITIALIZER;
pthread_cond_t Buffer_Not_Empty=PTHREAD_COND_INITIALIZER;
pthread_mutex_t mVar=PTHREAD_MUTEX_INITIALIZER;

int main()
{
pthread_t ptid,ctid;

BUFFER=(char *) malloc(sizeof(char) * BufferSize); //allocating buffer

pthread_create(&ptid,NULL,Producer,NULL);//creating producer thread
pthread_create(&ctid,NULL,Consumer,NULL);//creating consumer thread

pthread_join(ptid,NULL);
pthread_join(ctid,NULL);

return 0;
}

//Producer Code
void *Producer()
{
for(;;)
{
pthread_mutex_lock(&mVar);
if(BufferIndex==BufferSize)
{
printf("Producer found that buffer is full and waiting for the consumer to consume");
pthread_cond_wait(&Buffer_Not_Full,&mVar);//producer thread will wait as buffer is full
}
BUFFER[BufferIndex++]='@';
printf("Producer produced one item : %d \n",BufferIndex);
pthread_mutex_unlock(&mVar);
pthread_cond_signal(&Buffer_Not_Empty);
}

}

//Consumer Code
void *Consumer()
{
for(;;)
{
pthread_mutex_lock(&mVar);
if(BufferIndex==-1)
{
printf("Consumer found that the buffer is empty and waiting for the producer to produce");
pthread_cond_wait(&Buffer_Not_Empty,&mVar);//consumer thread will wait as buffer is empty
}
printf("Consumer consumed one item : %d \n",BufferIndex--);
pthread_mutex_unlock(&mVar);
pthread_cond_signal(&Buffer_Not_Full);
}
}

//output :

roducer produced one item : l Producer produced one item : 2 Producer produced one item 3 Producer produced one item : 4 Producer produced one item 5 Producer produced one item : 6 Producer produced one item 7 Producer produced one item : 8 Producer produced one item : 9 Producer produced one item 10 Producer found that buffer is full and waiting for the consumer to consumeConsumer consumed one item10 Consumer consumed one item 9 Consumer consumed one item 8 Consumer consumed one item 7 Consumer consumed one item:6 Consumer consumed one item 5 Consumer consumed one item4 Consumer consumed one item: 3 Consumer consumed one item 2 Consumer consumed one item 1 Consumer consumed one item 0 Consumer found that the buffer is empty and waiting for the producer to produceProducer produced one item: 0 Producer produced one item : 1 Producer produced one item 2 Producer produced one item : 3

//for makefile you can use :
/*

ProducerConsumerMake : ProducerConsumer.c
gcc -o ProducerConsumerMake ProducerConsumer.c -I

*/