You are given three $(3)$ processes in one program that work together to solve a producer consumer problem. Two Processes are $$producers$,$ each producing its own type of product in a continuous loop. That is$,$ one product type produced by one producer and a different product type by the other producer.

One Process is a $$consumer$$ of products. The consumer process consists of five $(5)$ threads.

One thread is a $$distributor$$ thread

Two $(2)$ threads consume one type of product. That is$,$ each of these two threads consumes only product type $1.$

Two $(2)$ threads consume a second type of product. That is$,$ each of these two threads consumes only product type $2.$

The consumer process contains two $(2)$ product storage buffers, each comprised of a fixed number of slots. The number of slots in the buffers are to be different $($one has more slots than the other$).$ You choose and specify the number of slots in each buffer as a definition in your program solution

Communication between the producer processes and the consumer process is to be through a single $$pipe$.$ This single, shared pipe is used to communicate between each producer process and the consumer process. Each producer process writes into this pipe the product to be consumed by the consumer process.

Synchronization

This project includes features of the consumer$-$producer problem that we have discussed in class. There are different approaches that one can take to implement the necessary synchronization. But, for this project, you are to use condition variables to achieve synchronization and locks to provide the associated mutual exclusion for all concurrent accesses.

Access to each buffer in the consumer process is to be shared among the associated two product consumer threads and the distributor thread. The access must be done safely with no race conditions.

Program Output

Products that are consumed by the product consumer threads are to be logged to a file. The file is to be your design, but contains data as follows. Each product consumer thread writes to the file: the product type, the consumption thread ID$,$ the production sequence number $($producer $$count$$ value$)$ and the consumption sequence number $($the counter value for consumption of that product item$).$ These values can help you evaluate whether you are losing data and the way that your program is producing and consuming data.

Deliverables:

Week $1$ deliverable includes: the creation of all processes and the pipe communication among processes; the design of the two consumer storage buffers; read and write $($get$/$put$)$ functions for the two buffers,

Week $2$ deliverable includes: the product distributor thread, the product consumer threads; locks for mutual exclusion where needed and condition variable code where needed.

Week $3$ Final program delivery: integration of all of the processes, threads, and storage buffers; output file design, file data record design and write functions; sample data runs with output files; logs showing testing comparisons.

Grading Rubric:

Creation of $3$ processes $1$

implementation of loop delays in the producer processes $0\mathrm{.}5$

Termination send $0\mathrm{.}5$

Creation of the Distribution thread $2$

Pipe communication

send to pipe $0\mathrm{.}5$

receive from pipe $0\mathrm{.}5$

Create circular buffers

get and put functions $1$

Creation of worker threads $1$

Buffer write synchronization using conditional variables $1$

use of lock $0\mathrm{.}5$

Access to consumer product counters

mutual exclution using locks foir read and write $0\mathrm{.}5$

separate locks per counter $0\mathrm{.}5$

File output

creation of the output file $0\mathrm{.}5$

creation of record structure for file writes $0\mathrm{.}5$

write to output file $0\mathrm{.}5$

Proper shutdown mechanism $1$

Do week one in C thank you.