Consider a system with N blocks of storage, each of which holds one unit of information (e.g. an integer,

character, or employee record). Initially, these blocks are empty and are linked onto a list called freelist.

Three processes communicate using shared memory in the following manner:

Shared Variables: freelist, list-1, list-2: block (where block is some data type to hold items)

PROCESS #1

var b: pointer to type block;

while (1)

{

b:= unlink(freelist);

produce_information_in_block(b);

link(b, list1);

}

PROCESS #2

var x,y: pointer to type block;

while (1)

{

x:=unlink(list-1);

y:=unlink(freelist);

use_block_x_to_produce info_in_y(x, y);

link(x, freelist);

link(y, list-2);

}

PROCESS #3

var c: pointer to type block;

while(1)

{

c:=unlink(list-2);

consume_information_in_block(c);

link(c, freelist);

}

Using the appropriate libraries, rewrite the pseudo-code as actual Unix/Linux processes, using semaphores to

implement the necessary mutual exclusion and synchronization. The solution must be deadlock-free and

concurrency should not be unnecessarily restricted. Further, you will have to implement a correct representation

of the three lists so that access to them is shared among the processes