Barrier (computer science)

Synchronization method in parallel computing

In parallel computing, a barrier is a type of synchronization method.[1] A barrier for a group of threads or processes in the source code means any thread/process must stop at this point and cannot proceed until all other threads/processes reach this barrier.[2]

Many collective routines and directive-based parallel languages impose implicit barriers. For example, a parallel do loop in Fortran with OpenMP will not be allowed to continue on any thread until the last iteration is completed.[citation needed] This is in case the program relies on the result of the loop immediately after its completion. In message passing, any global communication (such as reduction or scatter) may imply a barrier.

In concurrent computing, a barrier may be in a raised or lowered state. The term latch is sometimes used to refer to a barrier that starts in the raised state and cannot be re-raised once it is in the lowered state. The term count-down latch is sometimes used to refer to a latch that is automatically lowered once a predetermined number of threads/processes have arrived.

## Implementation

[edit]

Take an example for thread, known as the thread barrier. The thread barrier needs a variable to keep track of the total number of threads that have entered the barrier.[3] Whenever there are enough threads enter the barrier, it will be lifted. A synchronization primitive like mutex is also needed when implementing the thread barrier.

This thread barrier method is also known as Centralized Barrier as the threads have to wait in front of a "central barrier" until the expected number of threads have reached the barrier before it is lifted.

The following C code, which implemented thread barrier by using POSIX Threads will demonstrate this procedure:[1]

#include <stdio.h>
#include <pthread.h>

#define TOTAL_THREADS           2
#define THREAD_BARRIERS_NUMBER  3
#define PTHREAD_BARRIER_ATTR    NULL // pthread barrier attribute

typedef struct _thread_barrier

int thread_barrier_number;
pthread_mutex_t lock;
int total_thread;
} thread_barrier;

thread_barrier barrier;

void thread_barrier_init(thread_barrier *barrier, pthread_mutexattr_t *mutex_attr, int thread_barrier_number){
pthread_mutex_init(&(barrier->lock), mutex_attr);
barrier->thread_barrier_number = thread_barrier_number;
barrier->total_thread = 0;// Init total thread to be 0

void thread_barrier_wait(thread_barrier *barrier){
if(!pthread_mutex_lock(&(barrier->lock))){
barrier->total_thread += 1;
pthread_mutex_unlock(&(barrier->lock));

while (barrier->total_thread < barrier->thread_barrier_number);

if(!pthread_mutex_lock(&(barrier->lock))){
barrier->total_thread -= 1; // Decrease one thread as it has passed the thread barrier
pthread_mutex_unlock(&(barrier->lock));

void thread_barrier_destroy(thread_barrier *barrier){
pthread_mutex_destroy(&(barrier->lock));

void *thread_func(void *ptr){
printf("thread id %ld is waiting at the barrier, as not enough %d threads are running ...\n", pthread_self(), THREAD_BARRIERS_NUMBER);
thread_barrier_wait(&barrier);
printf("The barrier is lifted, thread id %ld is running now\n", pthread_self());

int main()

pthread_t thread_id[TOTAL_THREADS];

thread_barrier_init(&barrier, PTHREAD_BARRIER_ATTR, THREAD_BARRIERS_NUMBER);
for (int i = 0; i < TOTAL_THREADS; i++){
pthread_create(&thread_id[i], NULL, thread_func, NULL);

// As pthread_join() will block the process until all the threads it specified are finished,
// and there is not enough thread to wait at the barrier, so this process is blocked
for (int i = 0; i < TOTAL_THREADS; i++){
pthread_join(thread_id[i], NULL);

thread_barrier_destroy(&barrier);
printf("Thread barrier is lifted\n"); // This line won't be called as TOTAL_THREADS < THREAD_BARRIERS_NUMBER

In this program, the thread barrier is defined as a struct, struct _thread_barrier, which include:

* total_thread: Total threads in the process
* thread_barrier_number: Total number of threads expected to enter the thread barrier so that it can be lifted
* lock: A POSIX thread mutex lock

Based on the definition of barrier, we need to implement a function like thread_barrier_wait() in this program which will "monitor" the total number of thread in the program in order to life the barrier.

In this program, every thread calls thread_barrier_wait() will be blocked until THREAD_BARRIERS_NUMBER threads reach the thread barrier.

The result of that program is:

thread id <thread_id, e.g 139997337872128> is waiting at the barrier, as not enough 3 threads are running ...
thread id <thread_id, e.g 139997329479424> is waiting at the barrier, as not enough 3 threads are running ...
// (main process is blocked as not having enough 3 threads)
// Line printf("Thread barrier is lifted\n") won't be reached

As we can see from the program, there are just only 2 threads are created. Those 2 thread both have `thread_func()`, as the thread function handler, which call `thread_barrier_wait(&barrier)`, while thread barrier expected 3 threads to call `thread_barrier_wait` (`THREAD_BARRIERS_NUMBER = 3`) in order to be lifted. Change TOTAL_THREADS to 3 and the thread barrier is lifted:

thread id <thread ID, e.g 140453108946688> is waiting at the barrier, as not enough 3 threads are running ...
thread id <thread ID, e.g 140453117339392> is waiting at the barrier, as not enough 3 threads are running ...
thread id <thread ID, e.g 140453100553984> is waiting at the barrier, as not enough 3 threads are running ...
The barrier is lifted, thread id <thread ID, e.g 140453108946688> is running now
The barrier is lifted, thread id <thread ID, e.g 140453117339392> is running now
The barrier is lifted, thread id <thread ID, e.g 140453100553984> is running now
Thread barrier is lifted

### Sense-Reversal Centralized Barrier

[edit]

Beside decreasing the total thread number by one for every thread successfully passing the thread barrier, thread barrier can use opposite values to mark for every thread state as passing or stopping.[4] For example, thread 1 with state value is 0 means it's stopping at the barrier, thread 2 with state value is 1 means it has passed the barrier, thread 3's state value = 0 means it's stopping at the barrier and so on.[5] This is known as Sense-Reversal.[1]

The following C code demonstrates this:[3][6]

#include <stdio.h>
#include <stdbool.h>
#include <pthread.h>

#define TOTAL_THREADS           2
#define THREAD_BARRIERS_NUMBER  3
#define PTHREAD_BARRIER_ATTR    NULL // pthread barrier attribute

typedef struct _thread_barrier

int thread_barrier_number;
int total_thread;
pthread_mutex_t lock;
bool flag;
} thread_barrier;

thread_barrier barrier;

void thread_barrier_init(thread_barrier *barrier, pthread_mutexattr_t *mutex_attr, int thread_barrier_number){
pthread_mutex_init(&(barrier->lock), mutex_attr);

barrier->total_thread = 0;
barrier->thread_barrier_number = thread_barrier_number;
barrier->flag = false;

void thread_barrier_wait(thread_barrier *barrier){
bool local_sense = barrier->flag;
if(!pthread_mutex_lock(&(barrier->lock))){
barrier->total_thread += 1;
local_sense = !local_sense;

if (barrier->total_thread == barrier->thread_barrier_number){
barrier->total_thread = 0;
barrier->flag = local_sense;
pthread_mutex_unlock(&(barrier->lock));
} else {
pthread_mutex_unlock(&(barrier->lock));
while (barrier->flag != local_sense); // wait for flag

void thread_barrier_destroy(thread_barrier *barrier){
pthread_mutex_destroy(&(barrier->lock));

void *thread_func(void *ptr){
printf("thread id %ld is waiting at the barrier, as not enough %d threads are running ...\n", pthread_self(), THREAD_BARRIERS_NUMBER);
thread_barrier_wait(&barrier);
printf("The barrier is lifted, thread id %ld is running now\n", pthread_self());

int main()

pthread_t thread_id[TOTAL_THREADS];

thread_barrier_init(&barrier, PTHREAD_BARRIER_ATTR, THREAD_BARRIERS_NUMBER);
for (int i = 0; i < TOTAL_THREADS; i++){
pthread_create(&thread_id[i], NULL, thread_func, NULL);

// As pthread_join() will block the process until all the threads it specified are finished,
// and there is not enough thread to wait at the barrier, so this process is blocked
for (int i = 0; i < TOTAL_THREADS; i++){
pthread_join(thread_id[i], NULL);

thread_barrier_destroy(&barrier);
printf("Thread barrier is lifted\n"); // This line won't be called as TOTAL_THREADS < THREAD_BARRIERS_NUMBER

This program has all features similar to the previous Centralized Barrier source code. It just only implements in a different way by using 2 new variables:[1]

* local_sense: A thread local Boolean variable to check whether THREAD_BARRIERS_NUMBER have arrived at the barrier.
* flag: A Boolean member of struct _thread_barrier to indicate whether THREAD_BARRIERS_NUMBER have arrived at the barrier

When a thread stops at the barrier, local_sense's value is toggled.[1] When there are less than THREAD_BARRIERS_NUMBER threads stopping at the thread barrier, those threads will keep waiting with the condition that the flag member of struct _thread_barrier is not equal to the private `local_sense` variable.

When there are exactly THREAD_BARRIERS_NUMBER threads stopping at the thread barrier, the total thread number is reset to 0, and the flag is set to `local_sense`.

### Combining Tree Barrier

[edit]

The potential problem with the Centralized Barrier is that due to all the threads repeatedly accessing the global variable for pass/stop, the communication traffic is rather high, which decreases the scalability.

This problem can be resolved by regrouping the threads and using multi-level barrier, e.g. Combining Tree Barrier. Also hardware implementations may have the advantage of higher scalability.

A Combining Tree Barrier is a hierarchical way of implementing barrier to resolve the scalability by avoiding the case that all threads are spinning at the same location.[4]

In k-Tree Barrier, all threads are equally divided into subgroups of k threads and a first-round synchronizations are done within these subgroups. Once all subgroups have done their synchronizations, the first thread in each subgroup enters the second level for further synchronization. In the second level, like in the first level, the threads form new subgroups of k threads and synchronize within groups, sending out one thread in each subgroup to next level and so on. Eventually, in the final level there is only one subgroup to be synchronized. After the final-level synchronization, the releasing signal is transmitted to upper levels and all threads get past the barrier.[6][7]

### Hardware Barrier Implementation

[edit]

The hardware barrier uses hardware to implement the above basic barrier model.[3]

The simplest hardware implementation uses dedicated wires to transmit signal to implement barrier. This dedicated wire performs OR/AND operation to act as the pass/block flags and thread counter. For small systems, such a model works and communication speed is not a major concern. In large multiprocessor systems this hardware design can make barrier implementation have high latency. The network connection among processors is one implementation to lower the latency, which is analogous to Combining Tree Barrier.[8]

## POSIX Thread barrier functions

[edit]

POSIX Threads standard directly supports thread barrier functions which can be used to block the specified threads or the whole process at the barrier until other threads to reach that barrier.[2] 3 main API supports by POSIX to implement thread barriers are:

`pthread_barrier_init()`
Init the thread barrier with the number of threads needed to wait at the barrier in order to lift it[9]
`pthread_barrier_destroy()`
Destroy the thread barrier to release back the resource[9]
`pthread_barrier_wait()`
Calling this function will block the current thread until the number of threads specified by `pthread_barrier_init()` call `pthread_barrier_wait()` to lift the barrier.[10]

The following example (implemented in C with pthread API) will use thread barrier to block all the threads of the main process and therefore block the whole process:

#include <stdio.h>
#include <pthread.h>

#define TOTAL_THREADS           2
#define THREAD_BARRIERS_NUMBER  3
#define PTHREAD_BARRIER_ATTR    NULL // pthread barrier attribute

pthread_barrier_t barrier;

void *thread_func(void *ptr){
printf("Waiting at the barrier as not enough %d threads are running ...\n", THREAD_BARRIERS_NUMBER);
pthread_barrier_wait(&barrier);
printf("The barrier is lifted, thread id %ld is running now\n", pthread_self());

int main()

pthread_t thread_id[TOTAL_THREADS];

pthread_barrier_init(&barrier, PTHREAD_BARRIER_ATTR, THREAD_BARRIERS_NUMBER);
for (int i = 0; i < TOTAL_THREADS; i++){
pthread_create(&thread_id[i], NULL, thread_func, NULL);

// As pthread_join() will block the process until all the threads it specifies are finished,
// and there is not enough thread to wait at the barrier, so this process is blocked
for (int i = 0; i < TOTAL_THREADS; i++){
pthread_join(thread_id[i], NULL);

pthread_barrier_destroy(&barrier);
printf("Thread barrier is lifted\n"); // This line won't be called as TOTAL_THREADS < THREAD_BARRIERS_NUMBER

The result of that source code is:

Waiting at the barrier as not enough 3 threads are running ...
Waiting at the barrier as not enough 3 threads are running ...
// (main process is blocked as not having enough 3 threads)
// Line printf("Thread barrier is lifted\n") won't be reached

As we can see from the source code, there are just only two threads are created. Those 2 thread both have thread_func(), as the thread function handler, which call `pthread_barrier_wait(&barrier)`, while thread barrier expected 3 threads to call `pthread_barrier_wait` (`THREAD_BARRIERS_NUMBER = 3`) in order to be lifted. Change TOTAL_THREADS to 3 and the thread barrier is lifted:

Waiting at the barrier as not enough 3 threads are running ...
Waiting at the barrier as not enough 3 threads are running ...
Waiting at the barrier as not enough 3 threads are running ...
The barrier is lifted, thread id 140643372406528 is running now
The barrier is lifted, thread id 140643380799232 is running now
The barrier is lifted, thread id 140643389191936 is running now
Thread barrier is lifted

As main() is treated as a thread, i.e the "main" thread of the process,[11] calling `pthread_barrier_wait()` inside `main()` will block the whole process until other threads reach the barrier. The following example will use thread barrier, with `pthread_barrier_wait()` inside `main()`, to block the process/main thread for 5 seconds as waiting the 2 "newly created" thread to reach the thread barrier:

#define TOTAL_THREADS           2
#define THREAD_BARRIERS_NUMBER  3
#define PTHREAD_BARRIER_ATTR    NULL // pthread barrier attribute

pthread_barrier_t barrier;

void *thread_func(void *ptr){
printf("Waiting at the barrier as not enough %d threads are running ...\n", THREAD_BARRIERS_NUMBER);
sleep(5);
pthread_barrier_wait(&barrier);
printf("The barrier is lifted, thread id %ld is running now\n", pthread_self());

int main()

pthread_t thread_id[TOTAL_THREADS];

pthread_barrier_init(&barrier, PTHREAD_BARRIER_ATTR, THREAD_BARRIERS_NUMBER);
for (int i = 0; i < TOTAL_THREADS; i++){
pthread_create(&thread_id[i], NULL, thread_func, NULL);

pthread_barrier_wait(&barrier);

printf("Thread barrier is lifted\n"); // This line won't be called as TOTAL_THREADS < THREAD_BARRIERS_NUMBER
pthread_barrier_destroy(&barrier);

This example doesn't use `pthread_join()` to wait for 2 "newly created" threads to complete. It calls `pthread_barrier_wait()` inside `main()`, in order to block the main thread, so that the process will be blocked until 2 threads finish its operation after 5 seconds wait (line 9 - `sleep(5)`).

## See also

[edit]

* Fork–join model
* Rendezvous (Plan 9)
* Memory barrier

## References

[edit]

1. ^ a b c d e "Implementing Barriers". Carnegie Mellon University. Archived from the original on 2018-01-20. Retrieved 2017-08-02.
2. ^ a b GNU Operating System. "Implementation of pthread_barrier". gnu.org. Retrieved 2024-03-02.
3. ^ a b c Solihin, Yan (2015-01-01). Fundamentals of Parallel Multicore Architecture (1st ed.). Chapman & Hall/CRC. ISBN 978-1482211184.
4. ^ a b Culler, David (1998). Parallel Computer Architecture, A Hardware/Software Approach. Gulf Professional. ISBN 978-1558603431.
5. ^ Culler, David (1998). Parallel Computer Architecture, A Hardware/Software Approach. Gulf Professional. ISBN 978-1558603431.
6. ^ a b Nanjegowda, Ramachandra; Hernandez, Oscar; Chapman, Barbara; Jin, Haoqiang H. (2009-06-03). Müller, Matthias S.; Supinski, Bronis R. de; Chapman, Barbara M. (eds.). Evolving OpenMP in an Age of Extreme Parallelism. Lecture Notes in Computer Science. Springer Berlin Heidelberg. pp. 42–52. doi:10.1007/978-3-642-02303-3_4. ISBN 9783642022845.
7. ^ Nikolopoulos, Dimitrios S.; Papatheodorou, Theodore S. (1999-01-01). "A quantitative architectural evaluation of synchronization algorithms and disciplines on ccNUMA systems". Proceedings of the 13th international conference on Supercomputing. ICS '99. New York, NY, USA: ACM. pp. 319–328\. doi:10.1145/305138.305209. ISBN 978-1581131642. S2CID 6097544. Archived from the original on 2017-07-25. Retrieved 2019-01-18.
8. ^ N.R. Adiga, et al. An Overview of the BlueGene/L Supercomputer. Proceedings of the Conference on High Performance Networking and Computing, 2002.
9. ^ a b "pthread_barrier_init(), pthread_barrier_destroy()". Linux man page. Retrieved 2024-03-16.
10. ^ "pthread_barrier_wait()". Linux man page. Retrieved 2024-03-16.
11. ^ "How to get number of processes and threads in a C program?". stackoverflow. Retrieved 2024-03-16.

## External links

[edit]

"Parallel Programming with Barrier Synchronization". sourceallies.com. March 2012.

* v
* t
* e

Concurrent computing

General|

* Concurrency
* Concurrency control
* Concurrent data structures
* Concurrent hash tables
* Concurrent users
* Indeterminacy
* Linearizability

Process calculi|

* CSP
* CCS
* ACP
* LOTOS
* π-calculus
* Ambient calculus
* API-Calculus
* PEPA
* Join-calculus

Classic problems|

* ABA problem
* Cigarette smokers problem
* Deadlock
* Dining philosophers problem
* Producer–consumer problem
* Race condition
* Readers–writers problem
* Sleeping barber problem

* Category: Concurrent computing

* v
* t
* e

Parallel computing

General|

* Distributed computing
* Parallel computing
* Parallel algorithm
* Massively parallel
* Cloud computing
* High-performance computing
* Multiprocessing
* Manycore processor
* GPGPU software
* Computer network
* Systolic array

Levels|

* Bit
* Instruction
* Thread
* Task
* Data
* Memory
* Loop
* Pipeline

Multithreading|

* Temporal
* Simultaneous (SMT)
* Simultaneous and heterogenous
* Speculative (SpMT)
* Preemptive
* Cooperative
* Clustered multi-thread (CMT)
* Hardware scout

Theory|

* PRAM model
* PEM model
* Analysis of parallel algorithms
* Amdahl's law
* Gustafson's law
* Cost efficiency
* Karp–Flatt metric
* Slowdown
* Speedup

Elements|

* Process
* Thread
* Fiber
* Instruction window
* Array

Coordination|

* Multiprocessing
* Memory coherence
* Cache coherence
* Cache invalidation
* Barrier
* Synchronization
* Application checkpointing

Programming|

* Stream processing
* Dataflow programming
* Models
* Implicit parallelism
* Explicit parallelism
* Concurrency
* Non-blocking algorithm

Hardware|

* Flynn's taxonomy
* SISD
* SIMD
* Array processing (SIMT)
* Pipelined processing
* Associative processing
* MISD
* MIMD
* Dataflow architecture
* GPGPU hardware
* Pipelined processor
* Superscalar processor
* Vector processor
* Multiprocessor
* symmetric
* asymmetric
* Memory
* shared
* distributed
* distributed shared
* UMA
* NUMA
* COMA
* Massively parallel computer
* Computer cluster
* Beowulf cluster
* Grid computer
* Hardware acceleration

APIs|

* Ateji PX
* Boost
* Chapel
* HPX
* Charm++
* Cilk
* Coarray Fortran
* CUDA
* Dryad
* C++ AMP
* Global Arrays
* GPUOpen
* MPI
* OpenMP
* OpenCL
* OpenHMPP
* OpenACC
* Parallel Extensions
* PVM
* pthreads
* RaftLib
* ROCm
* UPC
* TBB
* ZPL

Problems|

* Automatic parallelization
* Deadlock
* Deterministic algorithm
* Embarrassingly parallel
* Parallel slowdown
* Race condition
* Software lockout
* Scalability
* Starvation

* Category: Parallel computing

*[v]: View this template
*[t]: Discuss this template
*[e]: Edit this template