C++ Barriers(Multithreading) Introduction














































C++ Barriers(Multithreading) Introduction



Introduction

  • As one of the synchronization methods, a barrier tells a group of threads or processes must stop at the barrier and cannot proceed until all other threads/processes reach this barrier.
  • Unlike std::latch, barriers are reusable: once the arriving threads are unblocked from a barrier phase's synchronization point, the same barrier can be reused.

Member functions

 constructor                       constructs a barrier
 destructor                         destroys the barrier
 operator=[deleted]            barrier is not assignable
 arrive                                arrives at barrier and decrements the expected count
 wait                                   blocks at the phase synchronization point until its phase completion step is run
 arrive_and_wait                arrives at barrier and decrements the expected count by one, then blocks until current                                                     phase completes
 arrive_and_drop               decrements both the initial expected count for subsequent phases and the expected count                                               for current phase by one.

Constants

max[static]                          the maximum value of expected count supported by the implementation

We can create a barrier by calling pthread_barrier_init(). It initializes the barrier and it takes three parameters:

  1. A pointer to the barrier to be initialized.
  2. To determine whether the barrier is private or can be shared, it takes an optional attributes structure.
  3. We need feed the number of threads that need to reach the barrier before any threads are released.
Each thread calls pthread_barrier_wait() when it reaches the barrier, and the call will return when the number of threads has reached the barrier.

A Sample Code

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

pthread_barrier_t b;

void print(void* p)
{
    int id = (int)p;
    printf("before  barrier %d\n", id);
    pthread_barrier_wait(&b;);
    printf("after  barrier %d\n", id);
}

int main()
{
    int num_of_Thread = 4;
    int i;
    pthread_t thread[num_of_Thread];
    pthread_barrier_init(&b;, 0, num_of_Thread);

    for(i = 0; i < num_of_Thread; i++)
        pthread_create(&thread;[i], 0, print, (void*)i);

    for(i = 0; i < num_of_Thread; i++)
        pthread_join(thread[i], 0);

    pthread_barrier_destroy(&b;);
    return 0;
}

The code above shows how the before aquiring the lock just check for queue count barrier force the threads to wait until all the threads have been created.

OUTPUT

before  barrier 3
before  barrier 2
before  barrier 1
before  barrier 0
after  barrier 0
after  barrier 3

after  barrier 2
after  barrier 1

If we did not set the barrier, the output would have been::


before  barrier 3
after  barrier 3
before  barrier 2
after  barrier 2
before  barrier 1
after  barrier 1
before  barrier 0
after  barrier 0


More Articles of Harshit Jain:

Name Views Likes
C++ Ranges::all_view, begin, cbegin Introduction 499 1
C++ future library Intorduction 742 1
C++ Ranges :: ViewableRange, ref_view, reverse_view 624 1
Threads Stop_token library C++ 681 1
C++ cfenv(Numerics Library) Introduction 474 1
YAML CPP Introduction 4519 1
Thead Library C++ Introduction 436 1
Introduction to gSOAP library 651 1
C++ ranges::ForwardRange, InputRange, OutputRange Introduction 627 1
Shared Mutex C++ Introduction 2867 1
SEMAPHORE HEADER C++(MULTI_THREADING) Introduction 2653 1
C++ Ranges::dangling, sized_range, disable_sized range Introduction 409 1
C++ Ranges::views::empty, filter, reverse, iota and Ranges::iota_view Introduction 695 1
MyCSS ( a CSS parser ) Introduction 478 1
C++ ranges::view::VIEW, ALL, COUNTED Introductiion 486 1
Mutex Locks C++ Multithreading Introduction 650 1
C++ Ranges:: Range, RandomAccessRange Introduction 403 1
Condition Variable(Multithreading) C++ Introduction 2937 1
Cpp - toml++ introduction 547 1
C++ Ranges::iterator_t, safe_iterator_t, safe_subrange_t Introduction 326 1
C++ Ranges::empty_view , enable_view, filter_view Introduction 549 1
C++ Barriers(Multithreading) Introduction 3085 1
LATCHES C++ Introduction 921 1
C++ Ranges::bidirectional_range, commom_range, contiguous range Introduction 397 1
C++ ZeroMQ - Introduction 2695 1
C++ BIT Library Introduction 431 1

Comments