Barriers

In a sense, a barrier is the logical inverse of a lock. Whereas a lock allows only one thread at a time to proceed (to use a resource), a barrier allows no thread to proceed until an entire group of them are ready to proceed.

• The number of threads expected to gather at a barrier is specified in the barrier structure when it is initialized with barrier_init(S). (See ``Initialization of synchronization mechanisms''.)

• A thread declares its arrival at the barrier with the barrier_wait(S) function.

     int barrier_wait(
     	barrier_t *barrier
     );
  

• The barrier mechanism has no facility to authenticate the threads calling barrier_wait; it simply counts the arriving threads.

• If the number of threads at the barrier is less than the initialized value, the thread calling barrier_wait is suspended.

• If the arriving thread brings the count to the requisite value, all of the waiting threads are made runnable and eventually return from barrier_wait.

• When the threads are released, the count of threads at the barrier is reset to zero. That same barrier can be reused without re-initialization.

• A barrier should not be re-initialized while there are waiting threads.

• There is also a ``spinning'' variant of barriers called _barrier_spin(S). The considerations for usage are similar to those for spin locks given above.