Question

Is This Correct?

Instructions Programming Assignment Four In computing, the producer-consumer problem (also known as the bounded-buffer problem) is a classic example of a multi-process synchronization problem. The problem describes two processes, the producer and the consumer, who share a common, fixed-size buffer used as a queue. The producer's job is to generate data, put it into the buffer, and start again. At the same time, the consumer is consuming the data (i.e., removing it from the buffer), one piece at a time. The problem is to make sure that the producer won't try to add data into the buffer if it's full and that the consumer won't try to remove data from an empty buffer. The solution for the producer is to either go to sleep or discard data if the buffer is full. The next time the consumer removes an item from the buffer, it notifies the producer, who starts to fill the buffer again. In the same way, the consumer can go to sleep if it finds the buffer empty. The next time the producer puts data into the buffer, it wakes up the sleeping consumer. The solution can be reached by means of inter-process communication, typically using semaphores. An inadequate solution could result in a deadlock where both processes are waiting to be awakened. The problem can also be generalized to have multiple producers and consumers. Using semaphores Semaphores solve the problem of lost wakeup calls. In the solution below we use two semaphores, fillCount and empty Count, to solve the problem. fill Count is the number of items already in the buffer and available to be read, while empty Count is the number of available spaces in the buffer where items could be written. fillCount is incremented and emptyCount decremented when a new item is put into the buffer. If the producer tries to decrement empty Count when its value is zero, the producer is put to sleep. The next time an item is consumed, emptyCount is incremented and the producer wakes up. The consumer works analogously. Assignment: Using the programming environment of your choice, write and execute a computer program that performs the producer – consumer function, assuming only one producer and one consumer, using semaphores. Submit your work through the assignment folder provided.

semaphore fillCount = 0;
// Items produced semahore emptyCount = BUFFER_SIZE;
// remaining space procedure producer()
{   
While (true)
{   
item = produceItem();
down(emptyCount);
// emptyCount is decremented
putItemIntoBuffer(item);
up(fillCount);
// fillcount is incremented
}

}
procedure consumer()
{
While (true)
{   
down(fillCount);
item = removeItem();
up(emptyCount);
// emptyCount is incremented
consumeItem(item);

}

}

Answer 1

There is just one mistake in your code. You should use one binary semaphore lock whose initial value is 0, so that any process before changing the value of fillCount and emptyCount, he should acquire the lock and then release lock at the end.

The problem here in your code is that , there is possibility that producer process can just down the emptyCount and they consumer process is swapped into and he get wrong value of emptyCount.

So in order to handle this critical section problem add a binary semaphore lock so your final code will be

binary semaphore lock = 0

semaphore fillCount = 0;
// Items produced semahore emptyCount = BUFFER_SIZE;
// remaining space procedure producer()
{

While (True) /
{   

While(Test_And_Set(lock)); //loop till lock is not 0
item = produceItem();
down(emptyCount);
// emptyCount is decremented
putItemIntoBuffer(item);
up(fillCount);
// fillcount is incremented

lock = 0; //release the lock
}
}

procedure consumer()
{
While (true)
{   

While (Test_And_Set(lock)); //loop till lock is not 0
down(fillCount);
item = removeItem();
up(emptyCount);
// emptyCount is incremented
consumeItem(item);
lock =0; //release the lock
}
}

Now the code is correct