Suppose we want to synchronize two concurrent processes P and Q using binary semaphores S and T. The code for the processes P and Q is shown below.

Process P:

while(1){
  W:
  Print '0';
  Print '0';
  X:
}

Process Q:

while(1){
  Y:
  Print '1';
  Print '1';
  Z:
}

Synchronization statements can be inserted only at points W, X, Y, and Z.

Which of the following will ensure that the output string never contains a substring of the form 01ⁿ0 or 10ⁿ1 where n is odd?

Consider Peterson’s algorithm for mutual exclusion between two concurrent processes i and j. The program executed by process is shown below.

 Repeat 
     flag[i]=true; 
     turn=j; 
     while (P) do no-op; 
     Enter critical section, perform actions, then 
     exit critical section 
     Flag[i]=false; 
     Perform other non-critical section actions. 
 Until false;

For the program to guarantee mutual exclusion, the predicate P in the while loop should be

Each process P_i,i=1.....9 is coded as follows

  Repeat
  P(mutex){
  critical section
  }
  V(mutex)
  Forever

The code for P₁₀ is identical except that it uses V(mutex) in place of P(mutex). What is the largest number of processes that can be inside the critical section at any moment?

The concurrent programming constructs fork and join are as below: Fork (label) which creates a new process executing from the specified label join (variable) which decrements the specified synchronization variable (by 1) and terminates the process if the new value is not 0. Show the precedence graph for S1, S2, S3, S4 and S5 of the concurrent program below.
N = 2
M = 2
fork L3
fork L4
S1
L1 : join N
S3
L2: join M
S5
L3:S2
goto L1
L4:S4
goto L2
next: