Consider the following snapshot of a system running n processes. Process i is holding x_i instances of a resource R, for $$1 \le i \le n$$. Currently, all instances of R are occupied. Further, for all i, process i has placed a request for an additional y_i instances while holding the x_i instances it already has. There are exactly two processes p and q such that y_p = y_q = 0. Which one of the following can serve as a necessary condition to guarantee that the system is not approaching a deadlock?

Barrier is a synchronization construct where a set of processes synchronizes globally i.e. each process in the set arrives at the barrier and waits for all others to arrive and then all processes leave the barrier. Let the number of processes in the set be three and S be a binary semaphore with the usual P and V functions. Consider the following C implementation of a barrier with line numbers shown on left.

void barrier (void) { 
1: P(S); 
2: process_arrived++; 
3: V(S); 
4: while (process_arrived !=3); 
5: P(S); 
6: process_left++; 
7: if (process_left==3) { 
8: process_arrived = 0; 
9: process_left = 0; 
10: } 
11: V(S); 
} 

The variables process_arrived and process_left are shared among all processes and are initialized to zero. In a concurrent program all the three processes call the barrier function when they need to synchronize globally.
Which one of the following rectifies the problem in the implementation?

The atomic fetch-and-set x, y instruction unconditionally sets the memory location x to 1 and fetches the old value of x n y without allowing any intervening access to the memory location x. consider the following implementation of P and V functions on a binary semaphore S.

void P (binary_semaphore *s) { 

   unsigned y; 
   unsigned *x = &(s->value); 
   
   do { 

     fetch-and-set x, y; 

   } while (y); 
} 

void V (binary_semaphore *s) { 

   S->value = 0; 

} 

Which one of the following is true?

Barrier is a synchronization construct where a set of processes synchronizes globally i.e. each process in the set arrives at the barrier and waits for all others to arrive and then all processes leave the barrier. Let the number of processes in the set be three and S be a binary semaphore with the usual P and V functions. Consider the following C implementation of a barrier with line numbers shown on left.

void barrier (void) { 
1: P(S); 
2: process_arrived++; 
3: V(S); 
4: while (process_arrived !=3); 
5: P(S); 
6: process_left++; 
7: if (process_left==3) { 
8: process_arrived = 0; 
9: process_left = 0; 
10: } 
11: V(S); 
} 

The variables process_arrived and process_left are shared among all processes and are initialized to zero. In a concurrent program all the three processes call the barrier function when they need to synchronize globally.
The above implementation of barrier is incorrect. Which one of the following is true?