GeeksforGeeks App
Open App
Browser
Continue

# GATE | GATE-CS-2006 | Question 79

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?
(A) Lines 6 to 10 are simply replaced by process_arrived–
(B) At the beginning of the barrier the first process to enter the barrier waits
until process_arrived becomes zero before proceeding to execute P(S).
(C) Context switch is disabled at the beginning of the barrier and re-enabled at the end.

Explanation:
Step ‘2’ should not be executed when the process enters the barrier second time till other two processes have not completed their 7th step. This is to prevent variable process_arrived becoming greater than 3.

So, when variable process_arrived becomes zero and variable process_left also becomes zero then the problem of deadlock will be resolved.

Thus, at the beginning of the barrier the first process to enter the barrier waits until process_arrived becomes zero before proceeding to execute P(S).

Thus, option (B) is correct.

Please comment below if you find anything wrong in the above post.

Quiz of this Question

My Personal Notes arrow_drop_up