P1135R1: The C++20 Synchronization Library

1. Introduction

This paper is the unification of the wording for a series of related C++20 proposals for introducing new synchronization and thread coordination facilities and enhancing existing ones:

[P0514r4]: Efficient atomic waiting and semaphores.
[P0666r2]: Latches and barriers.
[P0995r1]: atomic_flag::test and lockfree integral types.

1.1. Changelog

Revision 0: Post Rapperswil changes from [P0514r4], [P0666r2], and [P0995r1] based on Rapperswil feedback.

Refactored basic_barrier and barrier into one class with a default template parameter as suggested by LEWG at Rapperswil.
Refactored basic_semaphore and counting_semaphore into one class with a default template parameter as suggested by LEWG at Rapperswil.
Fixed update parameters in semaphore, latch, and barrier member functions to consistently default to 1 to resolve mistakes identified by LEWG at Rapperswil.

Revision 1: Pre San Diego 2018 changes based on Rapperswil feedback and a June discussion on the LEWG and SG1 mailing lists.

Added member function versions of atomic_wait_* and atomic_notify_*, for consistency. Refactored wording to accommodate this.
Renamed the atomic_flag overloads of atomic_wait and atomic_wait_explicit to atomic_flag_wait and atomic_flag_wait_explicit for consistency and to leave the door open for future compatibility with C.
Renamed latch::arrive_and_wait and barrier::arrive_and_wait to latch::sync and barrier::sync, because LEWG at Rapperswil expected these methods to be the common use case and prefers they have a short name.
Renamed latch::arrive to latch::count_down to further separate and distinguish the latch and barrier interfaces.
Removed barrier::try_wait to resolve concerns raised during LEWG discussion at Rapperswil regarding its "maybe consuming" nature.
Required that barrier::arrival_token's move constructor and move assignment operators are noexcept to resolve discussions in LEWG at Rapperswil regarding exceptions being thrown when using the split arrive and wait barrier interface.
Clarified that counting_semaphore::release, latch::count_down, latch::sync, barrier::wait, and barrier::arrive_and_drop throw nothing (but cannot be noexcept, because they have preconditions) to resolve discussions in LEWG at Rapperswil and on the mailing list.
Made counting_semaphore::acquire, counting_semaphore::try_acquire, and latch::wait noexcept, because participants in the mailing list discussion preferred that synchronization operations not throw and that any resource acquisition failures be reported by throwing during construction of synchronization objects.
Made counting_semaphore, latch, and barrier's constructors non constexpr and allowed them to throw system_error if the latch cannot be created, because participants in the mailing list discussion preferred that synchronization operations not throw and that any resource acquisition failures be reported by throwing during construction of synchronization objects.

2. Wording

Note: The following changes are relative to the post-Rapperswil 2018 working draft of ISO/IEC 14882, ([N4762]).

Note: The � character is used to denote a placeholder number which shall be selected by the editor.

Add <semaphore>, <latch>, and <barrier> to Table 18 "C++ library headers" in [headers].

Modify the header synopsis for <atomic> in [atomics.syn] as follows:

29.2 Header <atomic> synopsis [atomics.syn]

namespace std {
  // ...
  
  // 29.8, non-member functions
  // ...

  template<class T>

    void atomic_notify_one(const volatile atomic<T>*);

  template<class T>

    void atomic_notify_one(const atomic<T>*);

  void atomic_notify_one(const volatile atomic_flag*);

  void atomic_notify_one(const atomic_flag*);

  template<class T>

    void atomic_notify_all(const volatile atomic<T>*);

  template<class T>

    void atomic_notify_all(const atomic<T>*);

  void atomic_notify_all(const volatile atomic_flag*);

  void atomic_notify_all(const atomic_flag*);

  template<class T>

    void atomic_wait(const volatile atomic<T>*,

                     typename atomic<T>::value_type);

  template<class T>

    void atomic_wait(const atomic<T>*,

                     typename atomic<T>::value_type);

  template<class T>

    void atomic_wait_explicit(const volatile atomic<T>*,

                              typename atomic<T>::value_type,

                              memory_order);

  template<class T>

    void atomic_wait_explicit(const atomic<T>*,

                              typename atomic<T>::value_type,

                              memory_order);

 
  // 29.3, type aliases
  // ...
   
  using atomic_intptr_t       = atomic<intptr_t>;
  using atomic_uintptr_t      = atomic<uintptr_t>;
  using atomic_size_t         = atomic<size_t>;
  using atomic_ptrdiff_t      = atomic<ptrdiff_t>;
  using atomic_intmax_t       = atomic<intmax_t>;
  using atomic_uintmax_t      = atomic<uintmax_t>;

  using atomic_int_fast_wait_t  = atomic<implementation-defined>;

  using atomic_uint_fast_wait_t = atomic<implementation-defined>;

  using atomic_signed_lock_free   = see below;

  using atomic_unsigned_lock_free = see below;

 
  // ...

  // 29.8, flag type and operations
  struct atomic_flag;

  bool atomic_flag_test(volatile atomic_flag*) noexcept;
  bool atomic_flag_test(atomic_flag*) noexcept;
  bool atomic_flag_test_explicit(volatile atomic_flag*, memory_order) noexcept;
  bool atomic_flag_test_explicit(atomic_flag*, memory_order) noexcept;

  bool atomic_flag_test_and_set(volatile atomic_flag*) noexcept;
  bool atomic_flag_test_and_set(atomic_flag*) noexcept;
  bool atomic_flag_test_and_set_explicit(volatile atomic_flag*, memory_order) noexcept;
  bool atomic_flag_test_and_set_explicit(atomic_flag*, memory_order) noexcept;
  void atomic_flag_clear(volatile atomic_flag*) noexcept;
  void atomic_flag_clear(atomic_flag*) noexcept;
  void atomic_flag_clear_explicit(volatile atomic_flag*, memory_order) noexcept;
  void atomic_flag_clear_explicit(atomic_flag*, memory_order) noexcept;

  void atomic_flag_wait(const volatile atomic_flag*, bool) noexcept;

  void atomic_flag_wait(const atomic_flag*, bool) noexcept;

  void atomic_flag_wait_explicit(const volatile atomic_flag*, bool, memory_order) noexcept;

  void atomic_flag_wait_explicit(const atomic_flag*, bool, memory_order) noexcept;

  void atomic_flag_notify_one(volatile atomic_flag*) noexcept;

  void atomic_flag_notify_one(atomic_flag*) noexcept;

  void atomic_flag_notify_all(volatile atomic_flag*) const noexcept;

  void atomic_flag_notify_all(atomic_flag*) const noexcept;

  #define ATOMIC_FLAG_INIT see below

  // 29.9, fences
  extern "C" void atomic_thread_fence(memory_order) noexcept;
  extern "C" void atomic_signal_fence(memory_order) noexcept;
}

Modify [atomics.alias] as follows:

29.3 Type aliases [atomics.alias]
The type aliases atomic_intN_t, atomic_uintN_t, atomic_intptr_t, and atomic_uintptr_t are defined if and only if intN_t, uintN_t, intptr_t, and uintptr_t are defined, respectively.

The type aliases atomic_signed_lock_free and atomic_unsigned_lock_free are defined to be specializations of atomic whose template arguments are integral types, respectively signed and unsigned, other than bool. is_always_lock_free shall be true for atomic_signed_lock_free and atomic_unsigned_lock_free. An implementation should choose the integral specialization of atomic for which the atomic waiting and notifying operations are most efficient.

The type aliases atomic_int_fast_wait_t and atomic_uint_fast_wait_t are integral atomic types. Implementations should ensure that invocations of atomic waiting and notifying operations (29.�) with these types have the lowest performance overhead among integer types.

Note: The reference to "atomic waiting and notifying operations" in the above change should refer to the new [atomic.wait] subclause.

Add a new subclause after [atomics.lockfree]:

29.� Waiting and notifying [atomics.wait]
Atomic waiting and notifying operations provide a mechanism to wait for the value of an atomic object to change more efficiently than can be achieved with polling.

The following functions are atomic waiting operations:

atomic<T>::wait.

atomic_flag::wait.

atomic_wait and atomic_wait_explicit.

The following functions are atomic notifying operations:

atomic<T>::notify_one and atomic<T>::notify_all.

atomic_flag::notify_one and atomic_flag::notify_all.

atomic_notify_one and atomic_notify_one_explicit.

atomic_flag_notify_one and atomic_flag_notify_one_explicit.

atomic_notify_all and atomic_notify_all_explicit.

atomic_flag_notify_all and atomic_flag_notify_all_explicit.

Atomic waiting operations in this facility may block until they are unblocked by atomic notifying operations, according to each function’s effects. [ Note: Programs are not guaranteed to observe transient atomic values, an issue known as the A-B-A problem, resulting in continued blocking if a condition is only temporarily met. – End note ]

Modify [atomics.types.generic] as follows:

29.7 Class template atomic [atomics.type.generic]

namespace std {
  template<class T> struct atomic {
    using value_type = T;
    static constexpr bool is_always_lock_free = implementation-defined;
    bool is_lock_free() const volatile noexcept;
    bool is_lock_free() const noexcept;
    void store(T, memory_order = memory_order::seq_cst) volatile noexcept;
    void store(T, memory_order = memory_order::seq_cst) noexcept;
    T load(memory_order = memory_order::seq_cst) const volatile noexcept;
    T load(memory_order = memory_order::seq_cst) const noexcept;
    operator T() const volatile noexcept;
    operator T() const noexcept;
    T exchange(T, memory_order = memory_order::seq_cst) volatile noexcept;
    T exchange(T, memory_order = memory_order::seq_cst) noexcept;
    bool compare_exchange_weak(T&, T, memory_order, memory_order) volatile noexcept;
    bool compare_exchange_weak(T&, T, memory_order, memory_order) noexcept;
    bool compare_exchange_strong(T&, T, memory_order, memory_order) volatile noexcept;
    bool compare_exchange_strong(T&, T, memory_order, memory_order) noexcept;
    bool compare_exchange_weak(T&, T, memory_order = memory_order::seq_cst) volatile noexcept;
    bool compare_exchange_weak(T&, T, memory_order = memory_order::seq_cst) noexcept;
    bool compare_exchange_strong(T&, T, memory_order = memory_order::seq_cst) volatile noexcept;
    bool compare_exchange_strong(T&, T, memory_order = memory_order::seq_cst) noexcept;

    void wait(T old, memory_order = memory_order::seq_cst) const volatile noexcept;

    void wait(T old, memory_order = memory_order::seq_cst) const noexcept;

    void notify_one() const volatile noexcept;

    void notify_one() const noexcept;

    void notify_all() const volatile noexcept;

    void notify_all() const noexcept;

    atomic() noexcept = default;
    constexpr atomic(T) noexcept;
    atomic(const atomic&) = delete;
    atomic& operator=(const atomic&) = delete;
    atomic& operator=(const atomic&) volatile = delete;
    T operator=(T) volatile noexcept;
    T operator=(T) noexcept;
  };
}

Add the following to the end of [atomics.types.operations]:

void wait(T old, memory_order order = memory_order::seq_cst) const volatile noexcept;
void wait(T old, memory_order order = memory_order::seq_cst) const noexcept;
Requires: The order argument shall not be memory_order_release nor memory_order_acq_rel.

Effects: Repeatedly performs the following steps, in order:

Evaluates object->load(order) != old then, if the result is true, returns.

Blocks until an implementation-defined condition has been met. [ Note: Consequently, it may unblock for reasons other than an atomic notifying operation. — end note ]

Remarks: This function is an atomic waiting operation.
void notify_one() const volatile noexcept;
void notify_one() const noexcept;
Effects: Unblocks up to execution of an atomic waiting operation that blocked after observing the result of an atomic operation X, if there exists another atomic operation Y, such that X precedes Y in the modification order of *this, and Y happens before this call.

Remarks: This function is an atomic notifying operation.
void notify_all() const volatile noexcept;
void notify_all() const noexcept;
Effects: Unblocks each execution of an atomic waiting operation that blocked after observing the result of an atomic operation X, if there exists another atomic operation Y, such that X precedes Y in the modification order of *this, and Y happens before this call.

Remarks: This function is an atomic notifying operation.

Modify [atomics.flag] as follows:

29.8 Flag type and operations [atomics.flag]

namespace std {
  struct atomic_flag {

    bool test(memory_order = memory_order_seq_cst) volatile noexcept;
    bool test(memory_order = memory_order_seq_cst) noexcept;

    bool test_and_set(memory_order = memory_order_seq_cst) volatile noexcept;
    bool test_and_set(memory_order = memory_order_seq_cst) noexcept;
    void clear(memory_order = memory_order_seq_cst) volatile noexcept;
    void clear(memory_order = memory_order_seq_cst) noexcept;

    void wait(bool, memory_order = memory_order::seq_cst) const volatile noexcept;

    void wait(bool, memory_order = memory_order::seq_cst) const noexcept;

    void notify_one() const volatile noexcept;

    void notify_one() const noexcept;

    void notify_all() const volatile noexcept;

    void notify_all() const noexcept;

 
    atomic_flag() noexcept = default;
    atomic_flag(const atomic_flag&) = delete;
    atomic_flag& operator=(const atomic_flag&) = delete;
    atomic_flag& operator=(const atomic_flag&) volatile = delete;
  };

  bool atomic_flag_test(volatile atomic_flag*) noexcept;
  bool atomic_flag_test(atomic_flag*) noexcept;
  bool atomic_flag_test_explicit(volatile atomic_flag*, memory_order) noexcept;
  bool atomic_flag_test_explicit(atomic_flag*, memory_order) noexcept;

  bool atomic_flag_test_and_set(volatile atomic_flag*) noexcept;
  bool atomic_flag_test_and_set(atomic_flag*) noexcept;
  bool atomic_flag_test_and_set_explicit(volatile atomic_flag*, memory_order) noexcept;
  bool atomic_flag_test_and_set_explicit(atomic_flag*, memory_order) noexcept;
  void atomic_flag_clear(volatile atomic_flag*) noexcept;
  void atomic_flag_clear(atomic_flag*) noexcept;
  void atomic_flag_clear_explicit(volatile atomic_flag*, memory_order) noexcept;
  void atomic_flag_clear_explicit(atomic_flag*, memory_order) noexcept;

  void atomic_flag_wait(const volatile atomic_flag*, bool) noexcept;
  void atomic_flag_wait(const atomic_flag*, bool) noexcept;
  void atomic_flag_wait_explicit(const volatile atomic_flag*, bool, memory_order) noexcept;
  void atomic_flag_wait_explicit(const atomic_flag*, bool, memory_order) noexcept;
  void atomic_flag_notify_one(volatile atomic_flag*) noexcept;
  void atomic_flag_notify_one(atomic_flag*) noexcept;
  void atomic_flag_notify_all(volatile atomic_flag*) const noexcept;
  void atomic_flag_notify_all(atomic_flag*) const noexcept;

 
  #define ATOMIC_FLAG_INIT see below

The atomic_flag type provides the classic test-and-set functionality. It has two states, set and clear.

Operations on an object of type atomic_flag shall be lock-free. [ Note: Hence the operations should also be address-free. — end note ]

The atomic_flag type is a standard-layout struct. It has a trivial default constructor and a trivial destructor.

The macro ATOMIC_FLAG_INIT shall be defined in such a way that it can be used to initialize an object of type atomic_flag to the clear state. The macro can be used in the form:

atomic_flag guard = ATOMIC_FLAG_INIT;

It is unspecified whether the macro can be used in other initialization contexts. For a complete static-duration object, that initialization shall be static. Unless initialized with ATOMIC_FLAG_INIT, it is unspecified whether an atomic_flag object has an initial state of set or clear.

bool atomic_flag_test(volatile atomic_flag* object) noexcept;
bool atomic_flag_test(atomic_flag* object) noexcept;
bool atomic_flag_test_explicit(volatile atomic_flag* object, memory_order order) noexcept;
bool atomic_flag_test_explicit(atomic_flag* object, memory_order order) noexcept;
bool atomic_flag::test(memory_order order = memory_order_seq_cst) volatile noexcept;
bool atomic_flag::test(memory_order order = memory_order_seq_cst) noexcept;

Requires: The order argument shall not be memory_order_release nor memory_order_acq_rel.

Effects: Memory is affected according to the value of order.

Returns: Atomically returns the value pointed to by object or this.

bool atomic_flag_test_and_set(volatile atomic_flag* object) noexcept;
bool atomic_flag_test_and_set(atomic_flag* object) noexcept;
bool atomic_flag_test_and_set_explicit(volatile atomic_flag* object,
                                       memory_order order) noexcept;
bool atomic_flag_test_and_set_explicit(atomic_flag* object, memory_order order) noexcept;
bool atomic_flag::test_and_set(memory_order order = memory_order_seq_cst) volatile noexcept;
bool atomic_flag::test_and_set(memory_order order = memory_order_seq_cst) noexcept;

Effects: Atomically sets the value pointed to by object or by this to true. Memory is affected according to the value of order. These operations are atomic read-modify-write operations (4.7).

Returns: Atomically, the value of the object immediately before the effects.

void atomic_flag_clear(volatile atomic_flag* object) noexcept;
void atomic_flag_clear(atomic_flag* object) noexcept;
void atomic_flag_clear_explicit(volatile atomic_flag* object,
                                memory_order order) noexcept;
void atomic_flag_clear_explicit(atomic_flag* object, memory_order order) noexcept;
void atomic_flag::clear(memory_order order = memory_order_seq_cst) volatile noexcept;
void atomic_flag::clear(memory_order order = memory_order_seq_cst) noexcept;

Requires: The order argument shall not be memory_order_consume, memory_order_acquire, nor memory_order_acq_rel.

Effects: Atomically sets the value pointed to by object or by this to false. Memory is affected according to the value of order.

void atomic_flag_wait(const volatile atomic_flag* object, bool old) noexcept;
void atomic_flag_wait(const atomic_flag* object, bool old) noexcept;
void atomic_flag_wait_explicit(const volatile atomic_flag* object,
                               bool old, memory_order order) noexcept;
void atomic_flag_wait_explicit(const atomic_flag* object,
                               bool old, memory_order order) noexcept;
void atomic_flag::wait(bool old,
                       memory_order order = memory_order::seq_cst) const volatile noexcept;
void atomic_flag::wait(bool old,
                       memory_order order = memory_order::seq_cst) const noexcept;

Requires: The order argument shall not be memory_order_release nor memory_order_acq_rel.

Effects: Repeatedly performs the following steps, in order:

Evaluates object->load(order) != old then, if the result is true, returns.
Blocks until an implementation-defined condition has been met. [ Note: Consequently, it may unblock for reasons other than an atomic notifying operation. — end note ]

Remarks: This function is an atomic waiting operation.

void atomic_flag_notify_one(volatile atomic_flag* object) noexcept;
void atomic_flag_notify_one(atomic_flag* object) noexcept;
void atomic_flag::notify_one() const volatile noexcept;
void atomic_flag::notify_one() const noexcept;

Effects: Unblocks up to one execution of a atomic waiting operation that blocked after observing the result of an atomic operation X, if there exists another atomic operation Y, such that X precedes Y in the modification order of *object or *this, and Y happens before this call.

Remarks: This function is an atomic notifying operation.

void atomic_flag_notify_all(volatile atomic_flag* object) const noexcept;
void atomic_flag_notify_all(atomic_flag* object) const noexcept;
void atomic_flag::notify_all() const volatile noexcept;
void atomic_flag::notify_all() const noexcept;

Effects: Unblocks each execution of a atomic waiting operation that blocked after observing the result of an atomic operation X, if there exists another atomic operation Y, such that X precedes Y in the modification order of *object or *this, and Y happens before this call.

Remarks: This function is an atomic notifying operation.

Modify Table 135 "Thread support library summary" in [thread.general] as follows:

Table 135 — Thread support library summary

Subclause Header(s)
30.2 Requirements
30.3 Threads <thread>
30.4 Mutual exclusion <mutex> <shared_mutex>
30.5 Condition variables <condition_variable>
30.� Semaphores <semaphore>
30.� Latches and barriers <latch> <barrier>
30.6 Futures <future>

	Subclause	Header(s)
30.2	Requirements
30.3	Threads	`<thread>`
30.4	Mutual exclusion	`<mutex>` `<shared_mutex>`
30.5	Condition variables	`<condition_variable>`
30.�	Semaphores	`<semaphore>`
30.�	Latches and barriers	`<latch>` `<barrier>`
30.6	Futures	`<future>`

Add two new subclauses after [thread.condition]:

30.� Semaphores [thread.semaphore]
Semaphores are lightweight synchronization primitives used to constrain concurrent access to a shared resource. They are widely used to implement other synchronization primitives and, whenever both are applicable, can be more efficient than condition variables.

A counting semaphore is a semaphore object that models a non-negative resource count. A binary semaphore is a semaphore object that has only two states, also known as available and unavailable. [ Note: A binary semaphore should be more efficient than a counting semaphore with a unit magnitude count. – end note ]

30.�.1 Header <semaphore> synopsis [thread.semaphore.syn]

namespace std {  
  template<ptrdiff_t least_max_value = implementation-defined>
    class counting_semaphore;

  using binary_semaphore = counting_semaphore<1>;
}

30.�.2 Class template counting_semaphore [thread.semaphore.counting.class]
namespace std {
  template<ptrdiff_t least_max_value>
  class counting_semaphore {
  public:
    static constexpr ptrdiff_t max() noexcept;

    explicit counting_semaphore(ptrdiff_t);
    ~counting_semaphore();

    counting_semaphore(const basic_semaphore&) = delete;
    counting_semaphore(basic_semaphore&&) = delete;
    counting_semaphore& operator=(const basic_semaphore&) = delete;
    counting_semaphore& operator=(basic_semaphore&&) = delete;

    void release(ptrdiff_t update = 1);
    void acquire() noexcept;
    bool try_acquire() noexcept;
    template<class Clock, class Duration>
      bool try_acquire_until(const chrono::time_point<Clock, Duration>&);
    template<class Rep, class Period>
      bool try_acquire_for(const chrono::duration<Rep, Period>&);

  private:
    ptrdiff_t counter; // exposition only
  };
}
Class counting_semaphore maintains an internal counter that is initialized when the semaphore is created. Threads may block waiting until counter >= 1.

Semaphores permit concurrent invocation of the release, acquire, try_acquire, try_acquire_for, and try_acquire_until member functions.
static constexpr ptrdiff_t max() noexcept;
Returns: The maximum value of counter. This value shall not be less than that of the template argument least_max_value. [ Note: The value may exceed least_max_value. – end note ]
explicit counting_semaphore(ptrdiff_t desired);
Requires: desired >= 0 and desired <= max().

Effects: counter = desired.

Throws: system_error if unable to create the semaphore.
~counting_semaphore();
Requires: For every function call that blocks on counter, a function call that will cause it to unblock and return shall happen before this call. [ Note: This relaxes the usual rules, which would have required all wait calls to happen before destruction. — end note ]

Effects: Destroys the object.

Throws: Nothing.
void release(ptrdiff_t update = 1);
Requires: update >= 0, and counter + update <= max().

Effects: counter += update, executed atomically. If any threads are blocked on counter, unblocks them.

Throws: Nothing.

Synchronization: Strongly happens before invocations of try_acquire that observe the result of the effects.
bool try_acquire() noexcept;
Effects:

With low probability, returns immediately. [ Note: An implementation should ensure that try_acquire does not consistently return false in the absence of contending acquisitions. — end note ]

Otherwise, if counter >= 1, then counter -= 1 is executed atomically.

Returns: true if counter was decremented, otherwise false.
void acquire() noexcept;
Effects: Repeatedly performs the following steps, in order:

Evaluates try_acquire, then, if the result is true, returns.

Blocks until counter >= 1.
template<class Clock, class Duration>
  bool try_acquire_until(const chrono::time_point<Clock, Duration>& abs_time);
template<class Rep, class Period>
  bool try_acquire_for(const chrono::duration<Rep, Period>& rel_time);
Effects: Repeatedly performs the following steps, in order:

Evaluates try_acquire. If the result is true, returns true.

Blocks until the timeout expires or counter >= 1. If the timeout expired, returns false.

Throws: Timeout-related exceptions (30.2.4).

30.� Coordination Types [thread.coord]
This section describes various concepts related to thread coordination, and defines the coordination types latch and barrier. These types facilitate concurrent computation performed by a number of threads, in one or more phases.

In this subclause, a synchronization point represents a condition that a thread may contribute to or wait for, potentially blocking until it is satisfied. A thread arrives at the synchronization point when it has an effect on the state of the condition, even if it does not cause it to become satisfied.

Concurrent invocations of the member functions of coordination types, other than their destructors, do not introduce data races.

30.�.1 Latches [thread.coord.latch]
A latch is a thread coordination mechanism that allows any number of threads to block until an expected count is summed (exactly) by threads that arrived at the latch. The expected count is set when the latch is constructed. An individual latch is a single-use object; once the count has been reached, the latch cannot be reused.

30.�.1.1 Header <latch> synopsis [thread.coord.latch.syn]
namespace std {
  class latch;
}

30.�.1.2 Class latch [thread.coord.latch.class]
namespace std {
  class latch {
  public:
    explicit latch(ptrdiff_t expected);
    ~latch();

    latch(const latch&) = delete;
    latch(latch&&) = delete;
    latch& operator=(const latch&) = delete;
    latch& operator=(latch&&) = delete;
    
    void count_down(ptrdiff_t update = 1);
    bool try_wait() const noexcept;
    void wait() const noexcept;
    void sync(ptrdiff_t update = 1);

  private:
    ptrdiff_t counter; // exposition only
  };
} 
A latch maintains an internal counter that is initialized when the latch is created. Threads may block at the latch’s synchronization point, waiting for counter to be decremented to 0.
explicit latch(ptrdiff_t expected);
Requires: expected >= 0.

Effects: counter = expected.

Throws: system_error if unable to create the latch.
~latch();
Requires: No threads are blocked at the synchronization point.

Effects: Destroys the latch.

Throws: Nothing.

Remarks: May be called even if some threads have not yet returned from functions that block at the synchronization point, provided that they are unblocked. [ Note: The destructor may block until all threads have exited invocations of wait on this object. — end note ]
void count_down(ptrdiff_t update = 1);
Requires: counter >= update and update >= 0.

Effects: Atomically decrements counter by update.

Throws: Nothing.

Synchronization: Synchronizes with the returns from all calls unblocked by the effects.

Remarks: Arrives at the synchronization point with update count.
bool try_wait() const noexcept;
Returns: counter == 0.
void wait() const noexcept;
Effects: If counter == 0, returns immediately. Otherwise, blocks the calling thread at the synchronization point until counter == 0.
void sync(ptrdiff_t update = 1);
Effects: Equivalent to count_down(update); wait();.

Throws: Nothing.

30.�.2 Barriers [thread.coord.barrier]
A barrier is a thread coordination mechanism that allows at most an expected count of threads to block until that count is summed (exactly) by threads that arrived at the barrier in each of its successive phases. Once threads are released from blocking at the synchronization point for a phase, they can reuse the same barrier immediately in its next phase. [ Note: It is thus useful for managing repeated tasks, or phases of a larger task, that are handled by multiple threads. — end note ]

A barrier has a completion step that is a (possibly empty) set of effects associated with a phase of the barrier. When the member functions defined in this subclause arrive at the barrier, they have the following effects:

When the expected number of threads for this phase have arrived at the barrier, one of those threads executes the barrier type’s completion step.

When the completion step is completed, all threads blocked at the synchronization point for this phase are unblocked and the barrier enters its next phase. The end of the completion step strongly happens before the returns from all calls unblocked by its completion.

30.�.2.1 Header <barrier> synopsis [thread.coord.barrier.syn]
namespace std {
  template<class CompletionFunction = implementation-defined>
    class barrier;
}

30.�.2.2 Class template barrier [thread.coord.barrier.class]
namespace std {
  template<class CompletionFunction>
  class barrier {
  public:
    using arrival_token = implementation-defined;

    explicit barrier(ptrdiff_t expected,
                     CompletionFunction f = CompletionFunction());
    ~barrier();

    barrier(const barrier&) = delete;
    barrier(barrier&&) = delete;
    barrier& operator=(const barrier&) = delete;
    barrier& operator=(barrier&&) = delete;

    [[nodiscard]] arrival_token arrive(ptrdiff_t update = 1);
    void wait(arrival_token arrival) const;

    void sync();
    void arrive_and_drop();

  private:
    CompletionFunction completion; // exposition only
  };
}
A barrier is a barrier type with a completion step controlled by a function object. The completion step calls completion. Threads may block at the barrier’s synchronization point for a phase, waiting for the expected sum contributions by threads that arrive in that phase.

CompletionFunction shall be CopyConstructible, is_invocable_r_v<void, CompletionFunction> shall be true, and noexcept(declval<CompletionFunction>()()) shall be true.

barrier::arrival_token is an implementation-defined type. is_nothrow_move_constructible_v<barrier::arrival_token> shall be true and is_nothrow_move_assignable_v<barrier::arrival_token> shall be true.
explicit barrier(ptrdiff_t expected, CompletionFunction f);
Requires: expected >= 0, and noexcept(f()) shall be true.

Effects: Initializes the barrier for expected number of threads in the first phase, and initializes completion with move(f). [ Note: If expected is 0 this object may only be destroyed. — end note ]

Throws: system_error if unable to create the barrier.
~barrier();
Requires: No threads are blocked at a synchronization point for any phase.

Effects: Destroys the barrier.

Throws: Nothing.

Remarks: May be called even if some threads have not yet returned from functions that block at a synchronization point, provided that they have unblocked. [ Note: The destructor may block until all threads have exited invocations of wait() on this object. — end note ]
[[nodiscard]] arrival_token arrive(ptrdiff_t update = 1);
Requires: The expected count is not less than update.

Effects: Constructs an object of type arrival_token that is associated with the barrier's synchronization point for the current phase, then arrives update times at the synchronization point for the current phase.

Synchronization: The call to arrive strongly happens before the start of the completion step for the current phase.

Returns: The constructed object.

Remarks: This may cause the completion step to start.
void wait(arrival_token arrival) const;
Requires: arrival is associated with a synchronization point for the current or the immediately preceding phases of the barrier.

Effects: Blocks at the synchronization point associated with arrival until the condition is satisfied.

Throws: Nothing.
void sync();
Effects: Equivalent to wait(arrive()).

Throws: Nothing.
void arrive_and_drop();
Requires: The expected number of threads for the current phase is not 0.

Effects: Decrements the expected number of threads for subsequent phases by 1, then arrives at the synchronization point for the current phase.

Throws: Nothing.

Synchronization: The call to arrive_and_drop strongly happens before the start of the completion step for the current phase.

Remarks: This may cause the completion step to start.

Create the following feature test macros:

__cpp_lib_atomic_lock_free_type_aliases, which implies that atomic_signed_lock_free and atomic_unsigned_lock_free types are available.
__cpp_lib_atomic_flag_test, which implies the test methods and free functions for atomic_flag are available.
__cpp_lib_atomic_wait, which implies the notify_* and wait methods and free functions for atomic and atomic_flag and the atomic_int_fast_wait_t and atomic_uint_fast_wait_t types are available.
__cpp_lib_semaphore, which implies that counting_semaphore and binary_semaphore are available.
__cpp_lib_latch, which implies that latch is available.
__cpp_lib_barrier, which implies that barrier is available.

P1135R1
The C++20 Synchronization Library

Published Proposal, 2018-10-08

1. Introduction

1.1. Changelog

2. Wording

Index

Terms defined by this specification

References

Informative References

P1135R1The C++20 Synchronization Library

Published Proposal, 2018-10-08

1. Introduction

1.1. Changelog

2. Wording

Index

Terms defined by this specification

References

Informative References

P1135R1
The C++20 Synchronization Library