Fetch_And_Add(X, i) is an atomic Read-Modify-Write instruction that reads the value of memory location X, increments it by the value i, and returns the old value of X. It is used in the pseudocode shown below to implement a busy-wait lock. L is an unsigned integer shared variable initialized to 0. The value of 0 corresponds to lock being available, while any non-zero value corresponds to the lock being not available.AcquireLock(L){ while (Fetch_And_Add(L,1)) L = 1; } ReleaseLock(L){ L = 0; }This implementation

Consider two processes, $P_1$ and $P_2$, attempting synchronization:

1. Initially, $L = 0$.

2. $P_1$ executes AcquireLock(L): Fetch_And_Add(L, 1) reads $0$ and sets $L = 1$. Since the return value is $0$, $P_1$ exits the while loop and enters the critical section.

3. While $P_1$ is inside the critical section, $P_2$ calls AcquireLock(L): Fetch_And_Add(L, 1) reads $1$ and sets $L = 2$. Since the return value is non-zero, $P_2$ enters the body of the while loop, preparing to execute L = 1;.

4. Now, $P_1$ finishes the critical section and executes ReleaseLock(L), setting $L = 0$ (the lock is now actually available).

5. Immediately after, $P_2$ executes the statement inside its while loop: L = 1;. This overwrites $L$ to $1$ even though no process is holding the lock.

6. On the next iteration of the while loop, $P_2$ calls Fetch_And_Add(L, 1), reads $1$, and remains trapped in the loop. Consequently, no process can acquire the lock even though it was released.

Hence, the implementation fails because $L$ can take on a non-zero value when the lock is actually available (Option B).