C++17-compatible barrier implementation. More...

#include <synchronization.h>

Collaboration diagram for kcenon::thread::barrier< CompletionFunction >:

Public Member Functions
	barrier (std::ptrdiff_t count, CompletionFunction completion=[](){})
	Constructs a barrier for the given number of threads.

void	arrive_and_wait ()
	Arrives at the barrier and blocks until all threads arrive.

void	arrive_and_drop ()
	Decrements the counter without blocking.

Private Attributes
std::mutex	mutex_

std::condition_variable	cv_

std::ptrdiff_t	threshold_

std::ptrdiff_t	count_

std::size_t	generation_

CompletionFunction	completion_

Detailed Description

template<typename CompletionFunction = std::function<void()>>
class kcenon::thread::barrier< CompletionFunction >

C++17-compatible barrier implementation.

A reusable thread coordination mechanism that blocks a set of threads until all threads have arrived at the barrier.

Template Parameters

CompletionFunction A callable invoked when all threads arrive

Definition at line 101 of file synchronization.h.

Constructor & Destructor Documentation

◆ barrier()

template<typename CompletionFunction = std::function<void()>>

kcenon::thread::barrier< CompletionFunction >::barrier	(	std::ptrdiff_t	count,
		CompletionFunction	completion = [](){} )

inlineexplicit

Constructs a barrier for the given number of threads.

Parameters

count	The number of threads to synchronize (must be > 0)
completion	Optional function called when all threads arrive

Definition at line 108 of file synchronization.h.

                                                            {})
            : threshold_(count)
            , count_(count)
            , generation_(0)
            , completion_(std::move(completion)) {}

Member Function Documentation

◆ arrive_and_drop()

template<typename CompletionFunction = std::function<void()>>

void kcenon::thread::barrier< CompletionFunction >::arrive_and_drop ( )

inline

Decrements the counter without blocking.

Equivalent to arrive_and_drop() in C++20. This thread will not participate in future barrier phases.

Definition at line 152 of file synchronization.h.

                               {
            std::unique_lock<std::mutex> lock(mutex_);
            --threshold_;
            arrive_and_wait();
        }

References kcenon::thread::barrier< CompletionFunction >::arrive_and_wait(), kcenon::thread::barrier< CompletionFunction >::mutex_, and kcenon::thread::barrier< CompletionFunction >::threshold_.

Here is the call graph for this function:

◆ arrive_and_wait()

template<typename CompletionFunction = std::function<void()>>

void kcenon::thread::barrier< CompletionFunction >::arrive_and_wait ( )

inline

Arrives at the barrier and blocks until all threads arrive.

When the last thread arrives:

The completion function is called
All waiting threads are unblocked
The barrier resets for the next phase

Definition at line 123 of file synchronization.h.

                               {
            std::unique_lock<std::mutex> lock(mutex_);
            auto gen = generation_;
 
            if (--count_ == 0) {
                // Last thread to arrive
                generation_++;
                count_ = threshold_;
 
                // Call completion function (if provided)
                if constexpr (!std::is_same_v<CompletionFunction, std::function<void()>>) {
                    completion_();
                } else if (completion_) {
                    completion_();
                }
 
                cv_.notify_all();
            } else {
                // Wait for all threads to arrive
                cv_.wait(lock, [this, gen] { return gen != generation_; });
            }
        }