A certain computation generates two arrays a and b such that $a[i] = f(i)$ for $0 \le i < n$ and $b[i] = g(a[i])$ for $0 \le i < n$. Suppose this computation is decomposed into two concurrent processes $X$ and $Y$ such that $X$ computes the array a and $Y$ computes the array b. The processes employ two binary semaphores $R$ and $S$, both initialized to zero. The array a is shared by the two processes. The structures of the processes are shown below.Process X: private i; for (i=0; i<n; i++) { a[i] = f(i); ExitX(R, S); }Process Y: private i; for (i=0; i<n; i++) { EntryY(R, S); b[i] = g(a[i]); }Which one of the following represents the CORRECT implementations of ExitX and EntryY?

To correctly compute $b[i] = g(a[i])$ for each index $i$ concurrently:

1. In each iteration $i$, Process $Y$ must wait until Process $X$ finishes computing $a[i]$ before $Y$ reads $a[i]$.

2. Process $X$ should not overwrite $a[i]$ in iteration $i+1$ before Process $Y$ has read $a[i]$ in iteration $i$.

Let both binary semaphores be initialized to 0 ($R = 0, S = 0$).

In Option (C):

• ExitX(R, S): ```cP(S); V(R);```

• EntryY(R, S): ```cV(S); P(R);```

Trace of execution:

• In iteration $i = 0$:

  • Process $X$ computes $a[0]$. Then in ExitX, it performs P(S) and blocks because $S = 0$.

  • Process $Y$ starts EntryY, performs V(S) which signals $S$ (unblocking $X$), and then executes P(R) which blocks since $R = 0$.

  • Unblocked Process $X$ continues and executes V(R), which unblocks Process $Y$.

  • Process $Y$ is now unblocked and computes $b[0] = g(a[0])$.

• For each subsequent iteration $i$, this strict lockstep handshake alternates smoothly and ensures $a[i]$ is produced before being consumed, and $a[i]$ is consumed before $a[i+1]$ is produced.

Thus, (C) is the correct implementation.