Question

9. Here are the codes for producer and consumer problems

Producer:

while (true) {

                /* produce an item in next produced */

                while (counter == BUFFER_SIZE) ;

                                /* do nothing */

                buffer[in] = next_produced;

                in = (in + 1) % BUFFER_SIZE;

                counter++;

}

Consumer:

              while (true) {

                while (counter == 0)

                                ; /* do nothing */

                next_consumed = buffer[out];

                out = (out + 1) % BUFFER_SIZE; counter--;

                /* consume the item in next consumed */

           }

      counter++ could be implemented by Producer as

         register1 = counter

         register1 = register1 + 1

          counter = register1

     counter-- could be implemented by Consumer as

        register2 = counter

        register2 = register2 - 1

        counter = register2

If we set the current value of “counter “ as 4, when Producer and Consumer concurrently execute, what are the possible values of ‘’counter”, please give an example for each value, point out which value is the right one and analysis the reasons for the wrong values.

Answer 1

If there is a switch happens during counter++ or counter--, we will get a wrong value for the counter.

counter++   counter--

         register1 = counter register2 = counter

         register1 = register1 + 1   register2 = register2 - 1

         counter = register1 counter = register2

For example, assume that counter=4,means that there are 4 items which are produced already. Now look at the following steps and value of counter after each step.

1.Producer process is updating counter++(happens at machine level) and during that when it completed register1=counter counter=4

2. Suppose there is a context switch happens to consumer process and it is trying to update counter--(happens at machine level) and during that when it completed register2=counter counter=4

register2=register2-1

counter=register2 counter=3

3. Assume now context switch happened back to producer process and it continues from where it stopped(see step 1)

register1=register1+1

counter=register1 counter=5

See the value of counter variable. It became 5. Consumption of one item is not reflected in the counter variable. To avoid this we need to allow the atomic execution of all these instructions. Means whichever process starts updating the counter,the other one should wait for the completion of it.

4. if producer executes all these machine level instructions at once,then there is no inconsistancy on this.