Question

You are given a sample code that when edited/ improved/completed -will work as a producer consumer synchronized solution.
In addition to the counter, you will implement a circular linked list as a buffer of size 200 that stores data items 0 or 1. The producer and consumer take *random* turns to produce and consume- *random* numbers of elements ( turning 1 to a 0 and visa-versa-each time, as discussed in class). After each turn of the producer and/or consumer, your code will printout
the contents of the linked list ( sequence of 0s and 1s)
the number of elements produced/ or consumed
the total of numbers of elements in the buffer

#include <iostream>
#include <thread>
#include <mutex>
#include <chrono>

using namespace std;
mutex g_lock;
mutex g_lock1;
int counter = 0;
void func()
{
   g_lock1.lock();
   for (int i = 1; i < 5; i++)// make this a random number instead of 5
   {
  
   cout << "entered procucer " << std::this_thread::get_id() << endl;
   this_thread::sleep_for(std::chrono::seconds(rand() % 10));
   counter++;
   cout << " counter in process " << this_thread::get_id() << " producer; counter = : " << counter << endl;
   }
   //cout << " counter in process " << this_thread::get_id() << " :" << counter << endl;
   cout << "***********" << endl;
   cout << "leaving thread " << std::this_thread::get_id() << std::endl;
   g_lock1.unlock();

}
void func1()
{
   g_lock.lock();

   cout << "consumer active " << std::this_thread::get_id() << endl;
   for (int i = 1; i < 5; i++)
   {
       this_thread::sleep_for(std::chrono::seconds(rand() % 10));
       counter--;
       cout << " counter in process " << this_thread::get_id() << " :" << counter << endl;
   }
   cout << " counter in process " << this_thread::get_id() << " consumer; counter = :" << counter << endl;
   cout << "***********" << endl;
   cout << "leaving thread " << std::this_thread::get_id() << std::endl;
   g_lock.unlock();

}

int main()
{
   srand((unsigned int)time(0));

   thread t1(func);
   thread t2(func1);

   t1.join();
   t2.join();

   return 0;
}

Answer 1

if you take n instead of 5 in the for loop then the producer program will run for n times. As before entering into the the critical section producer locked the resource which means turned the value of lock1 from 0 to 1. This process have to done first as counter is 0 so no process in critical section. It will print 1.

now if preemption happens then consumer will also turn lock 0 to 1. After entering it will print 0 as counter value now changed by consumer to 0.

In this way both of them will run for n times and each time they will print value(we assumed that preemption happens right after change of values of counter.)

(assume lock=0, lock1=0 initially)

So total n+n= 2n elements will be printed.

There is no t clearly stated what values will be stored in the buffer. But we assume general case where each change of values will be stored. Now the sequence of values can be anything which mainly depends on the preemption sequence. We assume that preemption happens only after the change of values of counter then first value will be stored as 1. Because counter initial value was 0 and only producer can change the value to 1(binary semaphore/mutex can only have 0 or 1 ). If consumer would have changed then value would have been -1. So first value stored is 1 now consumer turns value to 0 and this 0 will be stored. Again producer will change.

In this way values will be laternatively changed to 0 to 1 then 1 to 0.

So the elements will be 101010101010101010....total 200 1's and 0's(100 1's and 100 0's). Because buffer size is 200.