[thread] - C++20 → C++23

Files changed (1) hide show

tmp/tmptf6wslwa/{from.md → to.md} +3517 -421

tmp/tmptf6wslwa/{from.md → to.md} RENAMED Viewed

@@ -1,21 +1,22 @@
-# Thread support library <a id="thread">[[thread]]</a>
 ## General <a id="thread.general">[[thread.general]]</a>
 The following subclauses describe components to create and manage
 threads [[intro.multithread]], perform mutual exclusion, and communicate
 conditions and values between threads, as summarized in
 [[thread.summary]].
-**Table: Thread support library summary** <a id="thread.summary">[thread.summary]</a>
 | Subclause            |                     | Header                      |
 | -------------------- | ------------------- | --------------------------- |
 | [[thread.req]]       | Requirements        |                             |
 | [[thread.stoptoken]] | Stop tokens         | `<stop_token>`              |
 | [[thread.threads]]   | Threads             | `<thread>`                  |
 | [[thread.mutex]]     | Mutual exclusion    | `<mutex>`, `<shared_mutex>` |
 | [[thread.condition]] | Condition variables | `<condition_variable>`      |
 | [[thread.sema]]      | Semaphores          | `<semaphore>`               |
 | [[thread.coord]]     | Coordination types  | `<latch>` `<barrier>`       |
 | [[futures]]          | Futures             | `<future>`                  |
@@ -24,15 +25,20 @@ conditions and values between threads, as summarized in
 ## Requirements <a id="thread.req">[[thread.req]]</a>
 ### Template parameter names <a id="thread.req.paramname">[[thread.req.paramname]]</a>
 Throughout this Clause, the names of template parameters are used to
-express type requirements. If a template parameter is named `Predicate`,
-`operator()` applied to the template argument shall return a value that
-is convertible to `bool`. If a template parameter is named `Clock`, the
-corresponding template argument shall be a type `C` for which
-`is_clock_v<C>` is `true`; otherwise the program is ill-formed.
 ### Exceptions <a id="thread.req.exception">[[thread.req.exception]]</a>
 Some functions described in this Clause are specified to throw
 exceptions of type `system_error` [[syserr.syserr]]. Such exceptions are
@@ -40,11 +46,11 @@ thrown if any of the function’s error conditions is detected or a call
 to an operating system or other underlying API results in an error that
 prevents the library function from meeting its specifications. Failure
 to allocate storage is reported as described in
 [[res.on.exception.handling]].
-[*Example 1*: Consider a function in this clause that is specified to
 throw exceptions of type `system_error` and specifies error conditions
 that include `operation_not_permitted` for a thread that does not have
 the privilege to perform the operation. Assume that, during the
 execution of this function, an `errno` of `EPERM` is reported by a POSIX
 API call used by the implementation. Since POSIX specifies an `errno` of
@@ -82,12 +88,13 @@ and memory resources induces a “quality of management” delay, expressed
 as duration Dₘ. The delay durations may vary from timeout to timeout,
 but in all cases shorter is better.
 The functions whose names end in `_for` take an argument that specifies
 a duration. These functions produce relative timeouts. Implementations
-should use a steady clock to measure time for these functions.[^1] Given
-a duration argument Dₜ, the real-time duration of the timeout is
 Dₜ + Dᵢ + Dₘ.
 The functions whose names end in `_until` take an argument that
 specifies a time point. These functions produce absolute timeouts.
 Implementations should use the clock specified in the time point to
@@ -95,15 +102,15 @@ measure time for these functions. Given a clock time point argument Cₜ,
 the clock time point of the return from timeout should be Cₜ + Dᵢ + Dₘ
 when the clock is not adjusted during the timeout. If the clock is
 adjusted to the time Cₐ during the timeout, the behavior should be as
 follows:
-- if Cₐ > Cₜ, the waiting function should wake as soon as possible,
   i.e., Cₐ + Dᵢ + Dₘ, since the timeout is already satisfied. This
   specification may result in the total duration of the wait decreasing
   when measured against a steady clock.
-- if Cₐ ≤ Cₜ, the waiting function should not time out until
   `Clock::now()` returns a time Cₙ ≥ Cₜ, i.e., waking at Cₜ + Dᵢ + Dₘ.
   \[*Note 1*: When the clock is adjusted backwards, this specification
   can result in the total duration of the wait increasing when measured
   against a steady clock. When the clock is adjusted forwards, this
   specification can result in the total duration of the wait decreasing
@@ -112,15 +119,15 @@ follows:
 An implementation returns from such a timeout at any point from the time
 specified above to the time it would return from a steady-clock relative
 timeout on the difference between Cₜ and the time point of the call to
 the `_until` function.
-[*Note 2*: Implementations should decrease the duration of the wait
-when the clock is adjusted forwards. — *end note*]
-[*Note 3*: If the clock is not synchronized with a steady clock, e.g.,
-a CPU time clock, these timeouts might not provide useful
 functionality. — *end note*]
 The resolution of timing provided by an implementation depends on both
 operating system and hardware. The finest resolution provided by an
 implementation is called the *native resolution*.
@@ -131,11 +138,11 @@ the *Cpp17TrivialClock* requirements [[time.clock.req]].
 A function that takes an argument which specifies a timeout will throw
 if, during its execution, a clock, time point, or time duration throws
 an exception. Such exceptions are referred to as *timeout-related
 exceptions*.
-[*Note 4*: Instantiations of clock, time point and duration types
 supplied by the implementation as specified in  [[time.clock]] do not
 throw exceptions. — *end note*]
 ### Requirements for *Cpp17Lockable* types <a id="thread.req.lockable">[[thread.req.lockable]]</a>
@@ -158,17 +165,31 @@ The standard library templates `unique_lock` [[thread.lock.unique]],
 `shared_lock` [[thread.lock.shared]], `scoped_lock`
 [[thread.lock.scoped]], `lock_guard` [[thread.lock.guard]], `lock`,
 `try_lock` [[thread.lock.algorithm]], and `condition_variable_any`
 [[thread.condition.condvarany]] all operate on user-supplied lockable
 objects. The *Cpp17BasicLockable* requirements, the *Cpp17Lockable*
-requirements, and the *Cpp17TimedLockable* requirements list the
-requirements imposed by these library types in order to acquire or
-release ownership of a `lock` by a given execution agent.
 [*Note 3*: The nature of any lock ownership and any synchronization it
 entails are not part of these requirements. — *end note*]
 #### *Cpp17BasicLockable* requirements <a id="thread.req.lockable.basic">[[thread.req.lockable.basic]]</a>
 A type `L` meets the *Cpp17BasicLockable* requirements if the following
 expressions are well-formed and have the specified semantics (`m`
 denotes a value of type `L`).
@@ -183,13 +204,15 @@ acquired for the current execution agent.
 ``` cpp
 m.unlock()
 ```
-*Preconditions:* The current execution agent holds a lock on `m`.
-*Effects:* Releases a lock on `m` held by the current execution agent.
 *Throws:* Nothing.
 #### *Cpp17Lockable* requirements <a id="thread.req.lockable.req">[[thread.req.lockable.req]]</a>
@@ -206,11 +229,11 @@ m.try_lock()
 without blocking. If an exception is thrown then a lock shall not have
 been acquired for the current execution agent.
 *Return type:* `bool`.
-*Returns:* `true` if the lock was acquired, `false` otherwise.
 #### *Cpp17TimedLockable* requirements <a id="thread.req.lockable.timed">[[thread.req.lockable.timed]]</a>
 A type `L` meets the *Cpp17TimedLockable* requirements if it meets the
 *Cpp17Lockable* requirements and the following expressions are
@@ -230,11 +253,11 @@ within the relative timeout [[thread.req.timing]] specified by
 execution agent. If an exception is thrown then a lock has not been
 acquired for the current execution agent.
 *Return type:* `bool`.
-*Returns:* `true` if the lock was acquired, `false` otherwise.
 ``` cpp
 m.try_lock_until(abs_time)
 ```
@@ -245,20 +268,91 @@ before the absolute timeout [[thread.req.timing]] specified by
 execution agent. If an exception is thrown then a lock has not been
 acquired for the current execution agent.
 *Return type:* `bool`.
 *Returns:* `true` if the lock was acquired, `false` otherwise.
 ## Stop tokens <a id="thread.stoptoken">[[thread.stoptoken]]</a>
 ### Introduction <a id="thread.stoptoken.intro">[[thread.stoptoken.intro]]</a>
-This clause describes components that can be used to asynchonously
-request that an operation stops execution in a timely manner, typically
-because the result is no longer required. Such a request is called a
-*stop request*.
 `stop_source`, `stop_token`, and `stop_callback` implement semantics of
 shared ownership of a *stop state*. Any `stop_source`, `stop_token`, or
 `stop_callback` that shares ownership of the same stop state is an
 *associated* `stop_source`, `stop_token`, or `stop_callback`,
@@ -300,22 +394,24 @@ namespace std {
   struct nostopstate_t {
     explicit nostopstate_t() = default;
   };
   inline constexpr nostopstate_t nostopstate{};
-  // [stopcallback], class stop_callback
   template<class Callback>
     class stop_callback;
 }
 ```
 ### Class `stop_token` <a id="stoptoken">[[stoptoken]]</a>
 The class `stop_token` provides an interface for querying whether a stop
 request has been made (`stop_requested`) or can ever be made
-(`stop_possible`) using an associated `stop_source` object (
-[[stopsource]]). A `stop_token` can also be passed to a `stop_callback`
 [[stopcallback]] constructor to register a callback to be called when a
 stop request has been made from an associated `stop_source`.
 ``` cpp
 namespace std {
@@ -435,14 +531,16 @@ friend void swap(stop_token& x, stop_token& y) noexcept;
 *Effects:* Equivalent to: `x.swap(y)`.
 ### Class `stop_source` <a id="stopsource">[[stopsource]]</a>
 The class `stop_source` implements the semantics of making a stop
 request. A stop request made on a `stop_source` object is visible to all
-associated `stop_source` and `stop_token` ([[stoptoken]]) objects. Once
-a stop request has been made it cannot be withdrawn (a subsequent stop
 request has no effect).
 ``` cpp
 namespace std {
   // no-shared-stop-state indicator
@@ -486,12 +584,11 @@ stop_source();
 *Effects:* Initialises `*this` to have ownership of a new stop state.
 *Ensures:* `stop_possible()` is `true` and `stop_requested()` is
 `false`.
-*Throws:* `bad_alloc` if memory could not be allocated for the stop
-state.
 ``` cpp
 explicit stop_source(nostopstate_t) noexcept;
 ```
@@ -576,11 +673,11 @@ bool request_stop() noexcept;
 has received a stop request, and if not, makes a stop request. The
 determination and making of the stop request are an atomic
 read-modify-write operation [[intro.races]]. If the request was made,
 the callbacks registered by associated `stop_callback` objects are
 synchronously called. If an invocation of a callback exits via an
-exception then `terminate` is called [[except.terminate]].
 [*Note 1*: A stop request includes notifying all condition variables of
 type `condition_variable_any` temporarily registered during an
 interruptible wait [[thread.condvarany.intwait]]. — *end note*]
@@ -605,10 +702,12 @@ friend void swap(stop_source& x, stop_source& y) noexcept;
 *Effects:* Equivalent to: `x.swap(y)`.
 ### Class template `stop_callback` <a id="stopcallback">[[stopcallback]]</a>
 ``` cpp
 namespace std {
   template<class Callback>
   class stop_callback {
   public:
@@ -669,15 +768,15 @@ before the constructor returns. Otherwise, if `st` has ownership of a
 stop state, acquires shared ownership of that stop state and registers
 the callback with that stop state such that
 `std::forward<Callback>(callback)()` is evaluated by the first call to
 `request_stop()` on an associated `stop_source`.
-*Remarks:* If evaluating `std::forward<Callback>(callback)()` exits via
-an exception, then `terminate` is called [[except.terminate]].
 *Throws:* Any exception thrown by the initialization of `callback`.
 ``` cpp
 ~stop_callback();
 ```
 *Effects:* Unregisters the callback from the owned stop state, if any.
@@ -690,30 +789,33 @@ thread, then the destructor does not block [[defns.block]] waiting for
 the return from the invocation of `callback`. Releases ownership of the
 stop state, if any.
 ## Threads <a id="thread.threads">[[thread.threads]]</a>
 [[thread.threads]] describes components that can be used to create and
 manage threads.
 [*Note 1*: These threads are intended to map one-to-one with operating
 system threads. — *end note*]
 ### Header `<thread>` synopsis <a id="thread.syn">[[thread.syn]]</a>
 ``` cpp
 #include <compare>              // see [compare.syn]
-#include <initializer_list>     // see [initializer.list.syn]
 namespace std {
   class thread;
   void swap(thread& x, thread& y) noexcept;
-  // [thread.jthread.class] class jthread
   class jthread;
   namespace this_thread {
     thread::id get_id() noexcept;
     void yield() noexcept;
     template<class Clock, class Duration>
@@ -724,10 +826,12 @@ namespace std {
 }
 ```
 ### Class `thread` <a id="thread.thread.class">[[thread.thread.class]]</a>
 The class `thread` provides a mechanism to create a new thread of
 execution, to join with a thread (i.e., wait for a thread to complete),
 and to perform other operations that manage and query the state of a
 thread. A `thread` object uniquely represents a particular thread of
 execution. That representation may be transferred to other `thread`
@@ -743,11 +847,11 @@ successful call to `detach` or `join`. — *end note*]
 ``` cpp
 namespace std {
   class thread {
   public:
-    // types
     class id;
     using native_handle_type = implementation-defined;         // see~[thread.req.native]
     // construct/copy/destroy
     thread() noexcept;
@@ -756,11 +860,11 @@ namespace std {
     thread(const thread&) = delete;
     thread(thread&&) noexcept;
     thread& operator=(const thread&) = delete;
     thread& operator=(thread&&) noexcept;
-    // members
     void swap(thread&) noexcept;
     bool joinable() const noexcept;
     void join();
     void detach();
     id get_id() const noexcept;
@@ -786,10 +890,12 @@ namespace std {
   template<class charT, class traits>
     basic_ostream<charT, traits>&
       operator<<(basic_ostream<charT, traits>& out, thread::id id);
   // hash support
   template<class T> struct hash;
   template<> struct hash<thread::id>;
 }
 ```
@@ -800,10 +906,16 @@ that do not represent a thread of execution [[thread.thread.class]].
 Each thread of execution has an associated `thread::id` object that is
 not equal to the `thread::id` object of any other thread of execution
 and that is not equal to the `thread::id` object of any `thread` object
 that does not represent threads of execution.
 `thread::id` is a trivially copyable class [[class.prop]]. The library
 may reuse the value of a `thread::id` of a terminated thread that can no
 longer be joined.
 [*Note 1*: Relational operators allow `thread::id` objects to be used
@@ -838,17 +950,37 @@ described in [[alg.sorting]].
 template<class charT, class traits>
   basic_ostream<charT, traits>&
     operator<< (basic_ostream<charT, traits>& out, thread::id id);
 ```
-*Effects:* Inserts an unspecified text representation of `id` into
-`out`. For two objects of type `thread::id` `x` and `y`, if `x == y` the
-`thread::id` objects have the same text representation and if `x != y`
-the `thread::id` objects have distinct text representations.
 *Returns:* `out`.
 ``` cpp
 template<> struct hash<thread::id>;
 ```
 The specialization is enabled [[unord.hash]].
@@ -870,33 +1002,30 @@ template<class F, class... Args> explicit thread(F&& f, Args&&... args);
 *Constraints:* `remove_cvref_t<F>` is not the same type as `thread`.
 *Mandates:* The following are all `true`:
 - `is_constructible_v<decay_t<F>, F>`,
-- `(is_constructible_v<decay_t<Args>, Args> && ...)`,
-- `is_move_constructible_v<decay_t<F>>`,
-- `(is_move_constructible_v<decay_t<Args>> && ...)`, and
 - `is_invocable_v<decay_t<F>, decay_t<Args>...>`.
-*Preconditions:* `decay_t<F>` and each type in `decay_t<Args>` meet the
-*Cpp17MoveConstructible* requirements.
 *Effects:* The new thread of execution executes
 ``` cpp
-invoke(decay-copy(std::forward<F>(f)), decay-copy(std::forward<Args>(args))...)
 ```
-with the calls to *`decay-copy`* being evaluated in the constructing
-thread. Any return value from this invocation is ignored.
 [*Note 1*: This implies that any exceptions not thrown from the
 invocation of the copy of `f` will be thrown in the constructing thread,
 not the new thread. — *end note*]
 If the invocation of `invoke` terminates with an uncaught exception,
-`terminate` is called.
 *Synchronization:* The completion of the invocation of the constructor
 synchronizes with the beginning of the invocation of the copy of `f`.
 *Ensures:* `get_id() != id()`. `*this` represents the newly started
@@ -921,27 +1050,29 @@ thread(thread&& x) noexcept;
 ``` cpp
 ~thread();
 ```
-*Effects:* If `joinable()`, calls `terminate()`. Otherwise, has no
-effects.
 [*Note 1*: Either implicitly detaching or joining a `joinable()` thread
-in its destructor could result in difficult to debug correctness (for
 detach) or performance (for join) bugs encountered only when an
-exception is thrown. Thus the programmer must ensure that the destructor
-is never executed while the thread is still joinable. — *end note*]
 #### Assignment <a id="thread.thread.assign">[[thread.thread.assign]]</a>
 ``` cpp
 thread& operator=(thread&& x) noexcept;
 ```
-*Effects:* If `joinable()`, calls `terminate()`. Otherwise, assigns the
-state of `x` to `*this` and sets `x` to a default constructed state.
 *Ensures:* `x.get_id() == id()` and `get_id()` returns the value of
 `x.get_id()` prior to the assignment.
 *Returns:* `*this`.
@@ -1035,10 +1166,12 @@ void swap(thread& x, thread& y) noexcept;
 *Effects:* As if by `x.swap(y)`.
 ### Class `jthread` <a id="thread.jthread.class">[[thread.jthread.class]]</a>
 The class `jthread` provides a mechanism to create a new thread of
 execution. The functionality is the same as for class `thread`
 [[thread.thread.class]] with the additional abilities to provide a
 `stop_token` [[thread.stoptoken]] to the new thread of execution, make
 stop requests, and automatically join.
@@ -1104,34 +1237,30 @@ template<class F, class... Args> explicit jthread(F&& f, Args&&... args);
 *Constraints:* `remove_cvref_t<F>` is not the same type as `jthread`.
 *Mandates:* The following are all `true`:
 - `is_constructible_v<decay_t<F>, F>`,
-- `(is_constructible_v<decay_t<Args>, Args> && ...)`,
-- `is_move_constructible_v<decay_t<F>>`,
-- `(is_move_constructible_v<decay_t<Args>> && ...)`, and
 - `is_invocable_v<decay_t<F>, decay_t<Args>...> ||`
   `is_invocable_v<decay_t<F>, stop_token, decay_t<Args>...>`.
-*Preconditions:* `decay_t<F>` and each type in `decay_t<Args>` meet the
-*Cpp17MoveConstructible* requirements.
 *Effects:* Initializes `ssource`. The new thread of execution executes
 ``` cpp
-invoke(decay-copy(std::forward<F>(f)), get_stop_token(),
- decay-copy(std::forward<Args>(args))...)
 ```
 if that expression is well-formed, otherwise
 ``` cpp
-invoke(decay-copy(std::forward<F>(f)), decay-copy(std::forward<Args>(args))...)
 ```
-with the calls to *`decay-copy`* being evaluated in the constructing
-thread. Any return value from this invocation is ignored.
 [*Note 1*: This implies that any exceptions not thrown from the
 invocation of the copy of `f` will be thrown in the constructing thread,
 not the new thread. — *end note*]
@@ -1175,18 +1304,18 @@ of `x.ssource` prior to the start of construction and
 ``` cpp
 jthread& operator=(jthread&& x) noexcept;
 ```
-*Effects:* If `joinable()` is `true`, calls `request_stop()` and then
-`join()`. Assigns the state of `x` to `*this` and sets `x` to a default
 constructed state.
-*Ensures:* `x.get_id() == id()` and `get_id()` returns the value of
-`x.get_id()` prior to the assignment. `ssource` has the value of
-`x.ssource` prior to the assignment and `x.ssource.stop_possible()` is
-`false`.
 *Returns:* `*this`.
 #### Members <a id="thread.jthread.mem">[[thread.jthread.mem]]</a>
@@ -1308,13 +1437,13 @@ namespace std::this_thread {
 ``` cpp
 thread::id this_thread::get_id() noexcept;
 ```
 *Returns:* An object of type `thread::id` that uniquely identifies the
-current thread of execution. No other thread of execution has this id
-and this thread of execution always has this id. The object returned
-does not compare equal to a default constructed `thread::id`.
 ``` cpp
 void this_thread::yield() noexcept;
 ```
@@ -1344,40 +1473,2886 @@ timeout [[thread.req.timing]] specified by `rel_time`.
 *Synchronization:* None.
 *Throws:* Timeout-related exceptions [[thread.req.timing]].
 ## Mutual exclusion <a id="thread.mutex">[[thread.mutex]]</a>
-This subclause provides mechanisms for mutual exclusion: mutexes, locks,
-and call once. These mechanisms ease the production of race-free
-programs [[intro.multithread]].
 ### Header `<mutex>` synopsis <a id="mutex.syn">[[mutex.syn]]</a>
 ``` cpp
 namespace std {
   class mutex;
   class recursive_mutex;
   class timed_mutex;
   class recursive_timed_mutex;
   struct defer_lock_t { explicit defer_lock_t() = default; };
   struct try_to_lock_t { explicit try_to_lock_t() = default; };
   struct adopt_lock_t { explicit adopt_lock_t() = default; };
   inline constexpr defer_lock_t  defer_lock { };
   inline constexpr try_to_lock_t try_to_lock { };
   inline constexpr adopt_lock_t  adopt_lock { };
   template<class Mutex> class lock_guard;
   template<class... MutexTypes> class scoped_lock;
   template<class Mutex> class unique_lock;
   template<class Mutex>
     void swap(unique_lock<Mutex>& x, unique_lock<Mutex>& y) noexcept;
   template<class L1, class L2, class... L3> int try_lock(L1&, L2&, L3&...);
   template<class L1, class L2, class... L3> void lock(L1&, L2&, L3&...);
   struct once_flag;
@@ -1388,12 +4363,15 @@ namespace std {
 ### Header `<shared_mutex>` synopsis <a id="shared.mutex.syn">[[shared.mutex.syn]]</a>
 ``` cpp
 namespace std {
   class shared_mutex;
   class shared_timed_mutex;
   template<class Mutex> class shared_lock;
   template<class Mutex>
     void swap(shared_lock<Mutex>& x, shared_lock<Mutex>& y) noexcept;
 }
 ```
@@ -1410,18 +4388,20 @@ Mutexes can be either recursive or non-recursive, and can grant
 simultaneous ownership to one or many execution agents. Both recursive
 and non-recursive mutexes are supplied.
 #### Mutex types <a id="thread.mutex.requirements.mutex">[[thread.mutex.requirements.mutex]]</a>
 The *mutex types* are the standard library types `mutex`,
 `recursive_mutex`, `timed_mutex`, `recursive_timed_mutex`,
 `shared_mutex`, and `shared_timed_mutex`. They meet the requirements set
-out in this subclause. In this description, `m` denotes an object of a
-mutex type.
-The mutex types meet the *Cpp17Lockable* requirements
-[[thread.req.lockable.req]].
 The mutex types meet *Cpp17DefaultConstructible* and
 *Cpp17Destructible*. If initialization of an object of a mutex type
 fails, an exception of type `system_error` is thrown. The mutex types
 are neither copyable nor movable.
@@ -1439,15 +4419,15 @@ functions of the mutex types are as follows:
 The implementation provides lock and unlock operations, as described
 below. For purposes of determining the existence of a data race, these
 behave as atomic operations [[intro.multithread]]. The lock and unlock
 operations on a single mutex appears to occur in a single total order.
-[*Note 1*: This can be viewed as the modification order
 [[intro.multithread]] of the mutex. — *end note*]
-[*Note 2*: Construction and destruction of an object of a mutex type
-need not be thread-safe; other synchronization should be used to ensure
 that mutex objects are initialized and visible to other
 threads. — *end note*]
 The expression `m.lock()` is well-formed and has the following
 semantics:
@@ -1457,17 +4437,17 @@ semantics:
 the mutex.
 *Effects:* Blocks the calling thread until ownership of the mutex can be
 obtained for the calling thread.
-*Ensures:* The calling thread owns the mutex.
-*Return type:* `void`.
 *Synchronization:* Prior `unlock()` operations on the same object
 *synchronize with*[[intro.multithread]] this operation.
 *Throws:* `system_error` when an exception is
 required [[thread.req.exception]].
 *Error conditions:*
@@ -1493,24 +4473,23 @@ interesting implementations based on a simple compare and
 exchange [[atomics]]. — *end note*]
 An implementation should ensure that `try_lock()` does not consistently
 return `false` in the absence of contending mutex acquisitions.
-*Return type:* `bool`.
-*Returns:* `true` if ownership of the mutex was obtained for the calling
-thread, otherwise `false`.
 *Synchronization:* If `try_lock()` returns `true`, prior `unlock()`
 operations on the same object *synchronize with*[[intro.multithread]]
 this operation.
 [*Note 2*: Since `lock()` does not synchronize with a failed subsequent
 `try_lock()`, the visibility rules are weak enough that little would be
 known about the state after a failure, even in the absence of spurious
 failures. — *end note*]
 *Throws:* Nothing.
 The expression `m.unlock()` is well-formed and has the following
 semantics:
@@ -1552,11 +4531,11 @@ The class `mutex` provides a non-recursive mutex with exclusive
 ownership semantics. If one thread owns a mutex object, attempts by
 another thread to acquire ownership of that object will fail (for
 `try_lock()`) or block (for `lock()`) until the owning thread has
 released ownership with a call to `unlock()`.
-[*Note 3*: After a thread `A` has called `unlock()`, releasing a mutex,
 it is possible for another thread `B` to lock the same mutex, observe
 that it is no longer in use, unlock it, and destroy it, before thread
 `A` appears to have returned from its unlock call. Implementations are
 required to handle such scenarios correctly, as long as thread `A`
 doesn’t access the mutex after the unlock call returns. These cases
@@ -1565,11 +4544,11 @@ used to protect the reference count. — *end note*]
 The class `mutex` meets all of the mutex requirements
 [[thread.mutex.requirements]]. It is a standard-layout class
 [[class.prop]].
-[*Note 4*: A program can deadlock if the thread that owns a `mutex`
 object calls `lock()` on that object. If the implementation can detect
 the deadlock, a `resource_deadlock_would_occur` error condition might be
 observed. — *end note*]
 The behavior of a program is undefined if it destroys a `mutex` object
@@ -1624,19 +4603,21 @@ The behavior of a program is undefined if:
 - it destroys a `recursive_mutex` object owned by any thread or
 - a thread terminates while owning a `recursive_mutex` object.
 #### Timed mutex types <a id="thread.timedmutex.requirements">[[thread.timedmutex.requirements]]</a>
 The *timed mutex types* are the standard library types `timed_mutex`,
 `recursive_timed_mutex`, and `shared_timed_mutex`. They meet the
 requirements set out below. In this description, `m` denotes an object
 of a mutex type, `rel_time` denotes an object of an instantiation of
 `duration` [[time.duration]], and `abs_time` denotes an object of an
 instantiation of `time_point` [[time.point]].
-The timed mutex types meet the *Cpp17TimedLockable* requirements
-[[thread.req.lockable.timed]].
 The expression `m.try_lock_for(rel_time)` is well-formed and has the
 following semantics:
 *Preconditions:* If `m` is of type `timed_mutex` or
@@ -1652,18 +4633,18 @@ the mutex object.
 [*Note 1*: As with `try_lock()`, there is no guarantee that ownership
 will be obtained if the lock is available, but implementations are
 expected to make a strong effort to do so. — *end note*]
-*Return type:* `bool`.
-*Returns:* `true` if ownership was obtained, otherwise `false`.
 *Synchronization:* If `try_lock_for()` returns `true`, prior `unlock()`
 operations on the same object *synchronize with*[[intro.multithread]]
 this operation.
 *Throws:* Timeout-related exceptions [[thread.req.timing]].
 The expression `m.try_lock_until(abs_time)` is well-formed and has the
 following semantics:
@@ -1678,18 +4659,18 @@ before the absolute timeout [[thread.req.timing]] specified by
 [*Note 2*: As with `try_lock()`, there is no guarantee that ownership
 will be obtained if the lock is available, but implementations are
 expected to make a strong effort to do so. — *end note*]
-*Return type:* `bool`.
-*Returns:* `true` if ownership was obtained, otherwise `false`.
 *Synchronization:* If `try_lock_until()` returns `true`, prior
 `unlock()` operations on the same object *synchronize
 with*[[intro.multithread]] this operation.
 *Throws:* Timeout-related exceptions [[thread.req.timing]].
 ##### Class `timed_mutex` <a id="thread.timedmutex.class">[[thread.timedmutex.class]]</a>
 ``` cpp
@@ -1792,16 +4773,21 @@ The behavior of a program is undefined if:
 - it destroys a `recursive_timed_mutex` object owned by any thread, or
 - a thread terminates while owning a `recursive_timed_mutex` object.
 #### Shared mutex types <a id="thread.sharedmutex.requirements">[[thread.sharedmutex.requirements]]</a>
 The standard library types `shared_mutex` and `shared_timed_mutex` are
 *shared mutex types*. Shared mutex types meet the requirements of mutex
 types [[thread.mutex.requirements.mutex]] and additionally meet the
 requirements set out below. In this description, `m` denotes an object
 of a shared mutex type.
 In addition to the exclusive lock ownership mode specified in
 [[thread.mutex.requirements.mutex]], shared mutex types provide a
 *shared lock* ownership mode. Multiple execution agents can
 simultaneously hold a shared lock ownership of a shared mutex type. But
 no execution agent holds a shared lock while another execution agent
@@ -1820,17 +4806,17 @@ semantics:
 *Effects:* Blocks the calling thread until shared ownership of the mutex
 can be obtained for the calling thread. If an exception is thrown then a
 shared lock has not been acquired for the current thread.
-*Ensures:* The calling thread has a shared lock on the mutex.
-*Return type:* `void`.
 *Synchronization:* Prior `unlock()` operations on the same object
 synchronize with [[intro.multithread]] this operation.
 *Throws:* `system_error` when an exception is
 required [[thread.req.exception]].
 *Error conditions:*
@@ -1864,19 +4850,18 @@ following semantics:
 calling thread without blocking. If shared ownership is not obtained,
 there is no effect and `try_lock_shared()` immediately returns. An
 implementation may fail to obtain the lock even if it is not held by any
 other thread.
-*Return type:* `bool`.
-*Returns:* `true` if the shared ownership lock was acquired, `false`
-otherwise.
 *Synchronization:* If `try_lock_shared()` returns `true`, prior
 `unlock()` operations on the same object synchronize
 with [[intro.multithread]] this operation.
 *Throws:* Nothing.
 ##### Class `shared_mutex` <a id="thread.sharedmutex.class">[[thread.sharedmutex.class]]</a>
 ``` cpp
@@ -1922,19 +4907,25 @@ The behavior of a program is undefined if:
 `shared_mutex` may be a synonym for `shared_timed_mutex`.
 #### Shared timed mutex types <a id="thread.sharedtimedmutex.requirements">[[thread.sharedtimedmutex.requirements]]</a>
 The standard library type `shared_timed_mutex` is a *shared timed mutex
 type*. Shared timed mutex types meet the requirements of timed mutex
 types [[thread.timedmutex.requirements]], shared mutex types
 [[thread.sharedmutex.requirements]], and additionally meet the
 requirements set out below. In this description, `m` denotes an object
-of a shared timed mutex type, `rel_type` denotes an object of an
 instantiation of `duration` [[time.duration]], and `abs_time` denotes an
 object of an instantiation of `time_point` [[time.point]].
 The expression `m.try_lock_shared_for(rel_time)` is well-formed and has
 the following semantics:
 *Preconditions:* The calling thread has no ownership of the mutex.
@@ -1951,18 +4942,18 @@ will be obtained if the lock is available, but implementations are
 expected to make a strong effort to do so. — *end note*]
 If an exception is thrown then a shared lock has not been acquired for
 the current thread.
-*Return type:* `bool`.
-*Returns:* `true` if the shared lock was acquired, `false` otherwise.
 *Synchronization:* If `try_lock_shared_for()` returns `true`, prior
 `unlock()` operations on the same object synchronize
 with [[intro.multithread]] this operation.
 *Throws:* Timeout-related exceptions [[thread.req.timing]].
 The expression `m.try_lock_shared_until(abs_time)` is well-formed and
 has the following semantics:
@@ -1980,18 +4971,18 @@ will be obtained if the lock is available, but implementations are
 expected to make a strong effort to do so. — *end note*]
 If an exception is thrown then a shared lock has not been acquired for
 the current thread.
-*Return type:* `bool`.
-*Returns:* `true` if the shared lock was acquired, `false` otherwise.
 *Synchronization:* If `try_lock_shared_until()` returns `true`, prior
 `unlock()` operations on the same object synchronize
 with [[intro.multithread]] this operation.
 *Throws:* Timeout-related exceptions [[thread.req.timing]].
 ##### Class `shared_timed_mutex` <a id="thread.sharedtimedmutex.class">[[thread.sharedtimedmutex.class]]</a>
 ``` cpp
@@ -2040,10 +5031,12 @@ The behavior of a program is undefined if:
 - a thread terminates while possessing any ownership of a
   `shared_timed_mutex`.
 ### Locks <a id="thread.lock">[[thread.lock]]</a>
 A *lock* is an object that holds a reference to a lockable object and
 may unlock the lockable object during the lock’s destruction (such as
 when leaving block scope). An execution agent may use a lock to aid in
 managing ownership of a lockable object in an exception safe manner. A
 lock is said to *own* a lockable object if it is currently managing the
@@ -2103,39 +5096,36 @@ object referenced by `pm` does not exist for the entire lifetime of the
 ``` cpp
 explicit lock_guard(mutex_type& m);
 ```
-*Preconditions:* If `mutex_type` is not a recursive mutex, the calling
-thread does not own the mutex `m`.
 *Effects:* Initializes `pm` with `m`. Calls `m.lock()`.
 ``` cpp
 lock_guard(mutex_type& m, adopt_lock_t);
 ```
-*Preconditions:* The calling thread owns the mutex `m`.
 *Effects:* Initializes `pm` with `m`.
 *Throws:* Nothing.
 ``` cpp
 ~lock_guard();
 ```
-*Effects:* As if by `pm.unlock()`.
 #### Class template `scoped_lock` <a id="thread.lock.scoped">[[thread.lock.scoped]]</a>
 ``` cpp
 namespace std {
   template<class... MutexTypes>
   class scoped_lock {
   public:
-    using mutex_type = Mutex; // If MutexTypes... consists of the single type Mutex
     explicit scoped_lock(MutexTypes&... m);
     explicit scoped_lock(adopt_lock_t, MutexTypes&... m);
     ~scoped_lock();
@@ -2151,32 +5141,35 @@ namespace std {
 An object of type `scoped_lock` controls the ownership of lockable
 objects within a scope. A `scoped_lock` object maintains ownership of
 lockable objects throughout the `scoped_lock` object’s lifetime
 [[basic.life]]. The behavior of a program is undefined if the lockable
 objects referenced by `pm` do not exist for the entire lifetime of the
-`scoped_lock` object. When `sizeof...(MutexTypes)` is `1`, the supplied
-`Mutex` type shall meet the *Cpp17BasicLockable* requirements
-[[thread.req.lockable.basic]]. Otherwise, each of the mutex types shall
-meet the *Cpp17Lockable* requirements [[thread.req.lockable.req]].
 ``` cpp
 explicit scoped_lock(MutexTypes&... m);
 ```
-*Preconditions:* If a `MutexTypes` type is not a recursive mutex, the
-calling thread does not own the corresponding mutex element of `m`.
 *Effects:* Initializes `pm` with `tie(m...)`. Then if
 `sizeof...(MutexTypes)` is `0`, no effects. Otherwise if
 `sizeof...(MutexTypes)` is `1`, then `m.lock()`. Otherwise,
 `lock(m...)`.
 ``` cpp
 explicit scoped_lock(adopt_lock_t, MutexTypes&... m);
 ```
-*Preconditions:* The calling thread owns all the mutexes in `m`.
 *Effects:* Initializes `pm` with `tie(m...)`.
 *Throws:* Nothing.
@@ -2187,10 +5180,12 @@ explicit scoped_lock(adopt_lock_t, MutexTypes&... m);
 *Effects:* For all `i` in \[`0`, `sizeof...(MutexTypes)`),
 `get<i>(pm).unlock()`.
 #### Class template `unique_lock` <a id="thread.lock.unique">[[thread.lock.unique]]</a>
 ``` cpp
 namespace std {
   template<class Mutex>
   class unique_lock {
   public:
@@ -2236,13 +5231,10 @@ namespace std {
   private:
     mutex_type* pm;             // exposition only
     bool owns;                  // exposition only
   };
-  template<class Mutex>
-    void swap(unique_lock<Mutex>& x, unique_lock<Mutex>& y) noexcept;
 }
 ```
 An object of type `unique_lock` controls the ownership of a lockable
 object within a scope. Ownership of the lockable object may be acquired
@@ -2266,19 +5258,16 @@ meets the *Cpp17TimedLockable* requirements. — *end note*]
 ``` cpp
 unique_lock() noexcept;
 ```
-*Ensures:* `pm == 0` and `owns == false`.
 ``` cpp
 explicit unique_lock(mutex_type& m);
 ```
-*Preconditions:* If `mutex_type` is not a recursive mutex the calling
-thread does not own the mutex.
 *Effects:* Calls `m.lock()`.
 *Ensures:* `pm == addressof(m)` and `owns == true`.
 ``` cpp
@@ -2290,35 +5279,33 @@ unique_lock(mutex_type& m, defer_lock_t) noexcept;
 ``` cpp
 unique_lock(mutex_type& m, try_to_lock_t);
 ```
 *Preconditions:* The supplied `Mutex` type meets the *Cpp17Lockable*
-requirements [[thread.req.lockable.req]]. If `mutex_type` is not a
-recursive mutex the calling thread does not own the mutex.
 *Effects:* Calls `m.try_lock()`.
 *Ensures:* `pm == addressof(m)` and `owns == res`, where `res` is the
 value returned by the call to `m.try_lock()`.
 ``` cpp
 unique_lock(mutex_type& m, adopt_lock_t);
 ```
-*Preconditions:* The calling thread owns the mutex.
 *Ensures:* `pm == addressof(m)` and `owns == true`.
 *Throws:* Nothing.
 ``` cpp
 template<class Clock, class Duration>
   unique_lock(mutex_type& m, const chrono::time_point<Clock, Duration>& abs_time);
 ```
-*Preconditions:* If `mutex_type` is not a recursive mutex the calling
-thread does not own the mutex. The supplied `Mutex` type meets the
 *Cpp17TimedLockable* requirements [[thread.req.lockable.timed]].
 *Effects:* Calls `m.try_lock_until(abs_time)`.
 *Ensures:* `pm == addressof(m)` and `owns == res`, where `res` is the
@@ -2327,12 +5314,11 @@ value returned by the call to `m.try_lock_until(abs_time)`.
 ``` cpp
 template<class Rep, class Period>
   unique_lock(mutex_type& m, const chrono::duration<Rep, Period>& rel_time);
 ```
-*Preconditions:* If `mutex_type` is not a recursive mutex the calling
-thread does not own the mutex. The supplied `Mutex` type meets the
 *Cpp17TimedLockable* requirements [[thread.req.lockable.timed]].
 *Effects:* Calls `m.try_lock_for(rel_time)`.
 *Ensures:* `pm == addressof(m)` and `owns == res`, where `res` is the
@@ -2393,14 +5379,14 @@ bool try_lock();
 *Preconditions:* The supplied `Mutex` meets the *Cpp17Lockable*
 requirements [[thread.req.lockable.req]].
 *Effects:* As if by `pm->try_lock()`.
-*Returns:* The value returned by the call to `try_lock()`.
-*Ensures:* `owns == res`, where `res` is the value returned by the call
-to `try_lock()`.
 *Throws:* Any exception thrown by `pm->try_lock()`. `system_error` when
 an exception is required [[thread.req.exception]].
 *Error conditions:*
@@ -2416,17 +5402,17 @@ template<class Clock, class Duration>
 *Preconditions:* The supplied `Mutex` type meets the
 *Cpp17TimedLockable* requirements [[thread.req.lockable.timed]].
 *Effects:* As if by `pm->try_lock_until(abs_time)`.
-*Returns:* The value returned by the call to `try_lock_until(abs_time)`.
-*Ensures:* `owns == res`, where `res` is the value returned by the call
-to `try_lock_until(abs_time)`.
-*Throws:* Any exception thrown by `pm->try_lock_until()`. `system_error`
-when an exception is required [[thread.req.exception]].
 *Error conditions:*
 - `operation_not_permitted` — if `pm` is `nullptr`.
 - `resource_deadlock_would_occur` — if on entry `owns` is `true`.
@@ -2439,17 +5425,17 @@ template<class Rep, class Period>
 *Preconditions:* The supplied `Mutex` type meets the
 *Cpp17TimedLockable* requirements [[thread.req.lockable.timed]].
 *Effects:* As if by `pm->try_lock_for(rel_time)`.
-*Returns:* The value returned by the call to `try_lock_for(rel_time)`.
-*Ensures:* `owns == res`, where `res` is the value returned by the call
-to `try_lock_for(rel_time)`.
-*Throws:* Any exception thrown by `pm->try_lock_for()`. `system_error`
-when an exception is required [[thread.req.exception]].
 *Error conditions:*
 - `operation_not_permitted` — if `pm` is `nullptr`.
 - `resource_deadlock_would_occur` — if on entry `owns` is `true`.
@@ -2479,14 +5465,14 @@ void swap(unique_lock& u) noexcept;
 ``` cpp
 mutex_type* release() noexcept;
 ```
-*Returns:* The previous value of `pm`.
 *Ensures:* `pm == 0` and `owns == false`.
 ``` cpp
 template<class Mutex>
   void swap(unique_lock<Mutex>& x, unique_lock<Mutex>& y) noexcept;
 ```
@@ -2512,10 +5498,12 @@ mutex_type *mutex() const noexcept;
 *Returns:* `pm`.
 #### Class template `shared_lock` <a id="thread.lock.shared">[[thread.lock.shared]]</a>
 ``` cpp
 namespace std {
   template<class Mutex>
   class shared_lock {
   public:
@@ -2559,13 +5547,10 @@ namespace std {
   private:
     mutex_type* pm;                             // exposition only
     bool owns;                                  // exposition only
   };
-  template<class Mutex>
-    void swap(shared_lock<Mutex>& x, shared_lock<Mutex>& y) noexcept;
 }
 ```
 An object of type `shared_lock` controls the shared ownership of a
 lockable object within a scope. Shared ownership of the lockable object
@@ -2573,15 +5558,19 @@ may be acquired at construction or after construction, and may be
 transferred, after acquisition, to another `shared_lock` object. Objects
 of type `shared_lock` are not copyable but are movable. The behavior of
 a program is undefined if the contained pointer `pm` is not null and the
 lockable object pointed to by `pm` does not exist for the entire
 remaining lifetime [[basic.life]] of the `shared_lock` object. The
-supplied `Mutex` type shall meet the shared mutex requirements
-[[thread.sharedtimedmutex.requirements]].
-[*Note 1*: `shared_lock<Mutex>` meets the *Cpp17TimedLockable*
-requirements [[thread.req.lockable.timed]]. — *end note*]
 ##### Constructors, destructor, and assignment <a id="thread.lock.shared.cons">[[thread.lock.shared.cons]]</a>
 ``` cpp
 shared_lock() noexcept;
@@ -2591,13 +5580,10 @@ shared_lock() noexcept;
 ``` cpp
 explicit shared_lock(mutex_type& m);
 ```
-*Preconditions:* The calling thread does not own the mutex for any
-ownership mode.
 *Effects:* Calls `m.lock_shared()`.
 *Ensures:* `pm == addressof(m)` and `owns == true`.
 ``` cpp
@@ -2608,34 +5594,31 @@ shared_lock(mutex_type& m, defer_lock_t) noexcept;
 ``` cpp
 shared_lock(mutex_type& m, try_to_lock_t);
 ```
-*Preconditions:* The calling thread does not own the mutex for any
-ownership mode.
 *Effects:* Calls `m.try_lock_shared()`.
 *Ensures:* `pm == addressof(m)` and `owns == res` where `res` is the
 value returned by the call to `m.try_lock_shared()`.
 ``` cpp
 shared_lock(mutex_type& m, adopt_lock_t);
 ```
-*Preconditions:* The calling thread has shared ownership of the mutex.
 *Ensures:* `pm == addressof(m)` and `owns == true`.
 ``` cpp
 template<class Clock, class Duration>
   shared_lock(mutex_type& m,
               const chrono::time_point<Clock, Duration>& abs_time);
 ```
-*Preconditions:* The calling thread does not own the mutex for any
-ownership mode.
 *Effects:* Calls `m.try_lock_shared_until(abs_time)`.
 *Ensures:* `pm == addressof(m)` and `owns == res` where `res` is the
 value returned by the call to `m.try_lock_shared_until(abs_time)`.
@@ -2644,12 +5627,12 @@ value returned by the call to `m.try_lock_shared_until(abs_time)`.
 template<class Rep, class Period>
   shared_lock(mutex_type& m,
               const chrono::duration<Rep, Period>& rel_time);
 ```
-*Preconditions:* The calling thread does not own the mutex for any
-ownership mode.
 *Effects:* Calls `m.try_lock_shared_for(rel_time)`.
 *Ensures:* `pm == addressof(m)` and `owns == res` where `res` is the
 value returned by the call to `m.try_lock_shared_for(rel_time)`.
@@ -2700,15 +5683,15 @@ when an exception is required [[thread.req.exception]].
 bool try_lock();
 ```
 *Effects:* As if by `pm->try_lock_shared()`.
-*Returns:* The value returned by the call to `pm->try_lock_shared()`.
 *Ensures:* `owns == res`, where `res` is the value returned by the call
 to `pm->try_lock_shared()`.
 *Throws:* Any exception thrown by `pm->try_lock_shared()`.
 `system_error` when an exception is required [[thread.req.exception]].
 *Error conditions:*
@@ -2718,18 +5701,21 @@ to `pm->try_lock_shared()`.
 ``` cpp
 template<class Clock, class Duration>
   bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time);
 ```
 *Effects:* As if by `pm->try_lock_shared_until(abs_time)`.
-*Returns:* The value returned by the call to
-`pm->try_lock_shared_until(abs_time)`.
 *Ensures:* `owns == res`, where `res` is the value returned by the call
 to `pm->try_lock_shared_until(abs_time)`.
 *Throws:* Any exception thrown by `pm->try_lock_shared_until(abs_time)`.
 `system_error` when an exception is required [[thread.req.exception]].
 *Error conditions:*
@@ -2739,18 +5725,21 @@ to `pm->try_lock_shared_until(abs_time)`.
 ``` cpp
 template<class Rep, class Period>
   bool try_lock_for(const chrono::duration<Rep, Period>& rel_time);
 ```
 *Effects:* As if by `pm->try_lock_shared_for(rel_time)`.
-*Returns:* The value returned by the call to
-`pm->try_lock_shared_for(rel_time)`.
 *Ensures:* `owns == res`, where `res` is the value returned by the call
 to `pm->try_lock_shared_for(rel_time)`.
 *Throws:* Any exception thrown by `pm->try_lock_shared_for(rel_time)`.
 `system_error` when an exception is required [[thread.req.exception]].
 *Error conditions:*
@@ -2782,14 +5771,14 @@ void swap(shared_lock& sl) noexcept;
 ``` cpp
 mutex_type* release() noexcept;
 ```
-*Returns:* The previous value of `pm`.
 *Ensures:* `pm == nullptr` and `owns == false`.
 ``` cpp
 template<class Mutex>
   void swap(shared_lock<Mutex>& x, shared_lock<Mutex>& y) noexcept;
 ```
@@ -2849,11 +5838,11 @@ when suitably instantiated. — *end note*]
 *Effects:* All arguments are locked via a sequence of calls to `lock()`,
 `try_lock()`, or `unlock()` on each argument. The sequence of calls does
 not result in deadlock, but is otherwise unspecified.
-[*Note 3*: A deadlock avoidance algorithm such as try-and-back-off must
 be used, but the specific algorithm is not specified to avoid
 over-constraining implementations. — *end note*]
 If a call to `lock()` or `try_lock()` throws an exception, `unlock()` is
 called for any argument that had been locked by a call to `lock()` or
@@ -2898,18 +5887,18 @@ template<class Callable, class... Args>
 *Mandates:* `is_invocable_v<Callable, Args...>` is `true`.
 *Effects:* An execution of `call_once` that does not call its `func` is
 a *passive* execution. An execution of `call_once` that calls its `func`
 is an *active* execution. An active execution calls *INVOKE*(
-std::forward\<Callable\>(func), std::forward\<Args\>(args)...). If such
-a call to `func` throws an exception the execution is *exceptional*,
-otherwise it is *returning*. An exceptional execution propagates the
-exception to the caller of `call_once`. Among all executions of
-`call_once` for any given `once_flag`: at most one is a returning
-execution; if there is a returning execution, it is the last active
-execution; and there are passive executions only if there is a returning
-execution.
 [*Note 1*: Passive executions allow other threads to reliably observe
 the results produced by the earlier returning execution. — *end note*]
 *Synchronization:* For any given `once_flag`: all active executions
@@ -2953,10 +5942,12 @@ public:
 — *end example*]
 ## Condition variables <a id="thread.condition">[[thread.condition]]</a>
 Condition variables provide synchronization primitives used to block a
 thread until notified by some other thread that some condition is met or
 until a system time is reached. Class `condition_variable` provides a
 condition variable that can only wait on an object of type
 `unique_lock<mutex>`, allowing the implementation to be more efficient.
@@ -2976,22 +5967,25 @@ three atomic parts:
 3.  the reacquisition of the lock.
 The implementation behaves as if all executions of `notify_one`,
 `notify_all`, and each part of the `wait`, `wait_for`, and `wait_until`
 executions are executed in a single unspecified total order consistent
-with the "happens before" order.
 Condition variable construction and destruction need not be
 synchronized.
 ### Header `<condition_variable>` synopsis <a id="condition.variable.syn">[[condition.variable.syn]]</a>
 ``` cpp
 namespace std {
   class condition_variable;
   class condition_variable_any;
   void notify_all_at_thread_exit(condition_variable& cond, unique_lock<mutex> lk);
   enum class cv_status { no_timeout, timeout };
 }
 ```
@@ -3022,16 +6016,12 @@ cond.notify_all();
 *Synchronization:* The implied `lk.unlock()` call is sequenced after the
 destruction of all objects with thread storage duration associated with
 the current thread.
-[*Note 1*: The supplied lock will be held until the thread exits, and
-care should be taken to ensure that this does not cause deadlock due to
-lock ordering issues. After calling `notify_all_at_thread_exit` it is
-recommended that the thread should be exited as soon as possible, and
-that no blocking or time-consuming tasks are run on that
-thread. — *end note*]
 [*Note 2*: It is the user’s responsibility to ensure that waiting
 threads do not erroneously assume that the thread has finished if they
 experience spurious wakeups. This typically requires that the condition
 being waited for is satisfied while holding the lock on `lk`, and that
@@ -3095,18 +6085,18 @@ required [[thread.req.exception]].
 ~condition_variable();
 ```
 *Preconditions:* There is no thread blocked on `*this`.
-[*Note 1*: That is, all threads have been notified; they could
 subsequently block on the lock specified in the wait. This relaxes the
 usual rules, which would have required all wait calls to happen before
 destruction. Only the notification to unblock the wait needs to happen
-before destruction. The user should take care to ensure that no threads
-wait on `*this` once the destructor has been started, especially when
-the waiting threads are calling the wait functions in a loop or using
-the overloads of `wait`, `wait_for`, or `wait_until` that take a
 predicate. — *end note*]
 ``` cpp
 void notify_one() noexcept;
 ```
@@ -3138,21 +6128,21 @@ locked by the calling thread, and either
 - When unblocked, calls `lock.lock()` (possibly blocking on the lock),
   then returns.
 - The function will unblock when signaled by a call to `notify_one()` or
   a call to `notify_all()`, or spuriously.
-*Remarks:* If the function fails to meet the postcondition,
-`terminate()` is called [[except.terminate]].
-[*Note 2*: This can happen if the re-locking of the mutex throws an
-exception. — *end note*]
 *Ensures:* `lock.owns_lock()` is `true` and `lock.mutex()` is locked by
 the calling thread.
 *Throws:* Nothing.
 ``` cpp
 template<class Predicate>
   void wait(unique_lock<mutex>& lock, Predicate pred);
 ```
@@ -3169,21 +6159,21 @@ locked by the calling thread, and either
 ``` cpp
 while (!pred())
   wait(lock);
 ```
-*Remarks:* If the function fails to meet the postcondition,
-`terminate()` is called [[except.terminate]].
-[*Note 3*: This can happen if the re-locking of the mutex throws an
-exception. — *end note*]
 *Ensures:* `lock.owns_lock()` is `true` and `lock.mutex()` is locked by
 the calling thread.
 *Throws:* Any exception thrown by `pred`.
 ``` cpp
 template<class Clock, class Duration>
   cv_status wait_until(unique_lock<mutex>& lock,
                        const chrono::time_point<Clock, Duration>& abs_time);
 ```
@@ -3205,25 +6195,25 @@ locked by the calling thread, and either
   call to `notify_all()`, expiration of the absolute
   timeout [[thread.req.timing]] specified by `abs_time`, or spuriously.
 - If the function exits via an exception, `lock.lock()` is called prior
   to exiting the function.
 *Remarks:* If the function fails to meet the postcondition,
-`terminate()` is called [[except.terminate]].
 [*Note 4*: This can happen if the re-locking of the mutex throws an
 exception. — *end note*]
-*Ensures:* `lock.owns_lock()` is `true` and `lock.mutex()` is locked by
-the calling thread.
-*Returns:* `cv_status::timeout` if the absolute
-timeout [[thread.req.timing]] specified by `abs_time` expired, otherwise
-`cv_status::no_timeout`.
-*Throws:* Timeout-related exceptions [[thread.req.timing]].
 ``` cpp
 template<class Rep, class Period>
   cv_status wait_for(unique_lock<mutex>& lock,
                      const chrono::duration<Rep, Period>& rel_time);
 ```
@@ -3240,25 +6230,25 @@ locked by the calling thread, and either
 ``` cpp
 return wait_until(lock, chrono::steady_clock::now() + rel_time);
 ```
 *Returns:* `cv_status::timeout` if the relative
 timeout [[thread.req.timing]] specified by `rel_time` expired, otherwise
 `cv_status::no_timeout`.
-*Remarks:* If the function fails to meet the postcondition,
-`terminate()` is called [[except.terminate]].
 [*Note 5*: This can happen if the re-locking of the mutex throws an
 exception. — *end note*]
-*Ensures:* `lock.owns_lock()` is `true` and `lock.mutex()` is locked by
-the calling thread.
-*Throws:* Timeout-related exceptions [[thread.req.timing]].
 ``` cpp
 template<class Clock, class Duration, class Predicate>
   bool wait_until(unique_lock<mutex>& lock,
                   const chrono::time_point<Clock, Duration>& abs_time,
                   Predicate pred);
@@ -3279,26 +6269,26 @@ while (!pred())
   if (wait_until(lock, abs_time) == cv_status::timeout)
     return pred();
 return true;
 ```
-*Remarks:* If the function fails to meet the postcondition,
-`terminate()` is called [[except.terminate]].
-[*Note 6*: This can happen if the re-locking of the mutex throws an
-exception. — *end note*]
 *Ensures:* `lock.owns_lock()` is `true` and `lock.mutex()` is locked by
 the calling thread.
-[*Note 7*: The returned value indicates whether the predicate evaluated
 to `true` regardless of whether the timeout was
 triggered. — *end note*]
 *Throws:* Timeout-related exceptions [[thread.req.timing]] or any
 exception thrown by `pred`.
 ``` cpp
 template<class Rep, class Period, class Predicate>
   bool wait_for(unique_lock<mutex>& lock,
                 const chrono::duration<Rep, Period>& rel_time,
                 Predicate pred);
@@ -3319,37 +6309,40 @@ return wait_until(lock, chrono::steady_clock::now() + rel_time, std::move(pred))
 ```
 [*Note 8*: There is no blocking if `pred()` is initially `true`, even
 if the timeout has already expired. — *end note*]
-*Remarks:* If the function fails to meet the postcondition,
-`terminate()` is called [[except.terminate]].
-[*Note 9*: This can happen if the re-locking of the mutex throws an
-exception. — *end note*]
 *Ensures:* `lock.owns_lock()` is `true` and `lock.mutex()` is locked by
 the calling thread.
-[*Note 10*: The returned value indicates whether the predicate
-evaluates to `true` regardless of whether the timeout was
 triggered. — *end note*]
 *Throws:* Timeout-related exceptions [[thread.req.timing]] or any
 exception thrown by `pred`.
 ### Class `condition_variable_any` <a id="thread.condition.condvarany">[[thread.condition.condvarany]]</a>
-A `Lock` type shall meet the *Cpp17BasicLockable* requirements
-[[thread.req.lockable.basic]].
 [*Note 1*: All of the standard mutex types meet this requirement. If a
-`Lock` type other than one of the standard mutex types or a
-`unique_lock` wrapper for a standard mutex type is used with
-`condition_variable_any`, the user should ensure that any necessary
-synchronization is in place with respect to the predicate associated
-with the `condition_variable_any` instance. — *end note*]
 ``` cpp
 namespace std {
   class condition_variable_any {
   public:
@@ -3409,18 +6402,18 @@ required [[thread.req.exception]].
 ~condition_variable_any();
 ```
 *Preconditions:* There is no thread blocked on `*this`.
-[*Note 1*: That is, all threads have been notified; they could
 subsequently block on the lock specified in the wait. This relaxes the
 usual rules, which would have required all wait calls to happen before
 destruction. Only the notification to unblock the wait needs to happen
-before destruction. The user should take care to ensure that no threads
-wait on `*this` once the destructor has been started, especially when
-the waiting threads are calling the wait functions in a loop or using
-the overloads of `wait`, `wait_for`, or `wait_until` that take a
 predicate. — *end note*]
 ``` cpp
 void notify_one() noexcept;
 ```
@@ -3447,20 +6440,20 @@ template<class Lock>
 - When unblocked, calls `lock.lock()` (possibly blocking on the lock)
   and returns.
 - The function will unblock when signaled by a call to `notify_one()`, a
   call to `notify_all()`, or spuriously.
 *Remarks:* If the function fails to meet the postcondition,
-`terminate()` is called [[except.terminate]].
 [*Note 1*: This can happen if the re-locking of the mutex throws an
 exception. — *end note*]
-*Ensures:* `lock` is locked by the calling thread.
-*Throws:* Nothing.
 ``` cpp
 template<class Lock, class Predicate>
   void wait(Lock& lock, Predicate pred);
 ```
@@ -3485,24 +6478,24 @@ template<class Lock, class Clock, class Duration>
   call to `notify_all()`, expiration of the absolute
   timeout [[thread.req.timing]] specified by `abs_time`, or spuriously.
 - If the function exits via an exception, `lock.lock()` is called prior
   to exiting the function.
-*Remarks:* If the function fails to meet the postcondition,
-`terminate()` is called [[except.terminate]].
-[*Note 2*: This can happen if the re-locking of the mutex throws an
-exception. — *end note*]
 *Ensures:* `lock` is locked by the calling thread.
 *Returns:* `cv_status::timeout` if the absolute
 timeout [[thread.req.timing]] specified by `abs_time` expired, otherwise
 `cv_status::no_timeout`.
 *Throws:* Timeout-related exceptions [[thread.req.timing]].
 ``` cpp
 template<class Lock, class Rep, class Period>
   cv_status wait_for(Lock& lock, const chrono::duration<Rep, Period>& rel_time);
 ```
@@ -3510,24 +6503,24 @@ template<class Lock, class Rep, class Period>
 ``` cpp
 return wait_until(lock, chrono::steady_clock::now() + rel_time);
 ```
 *Returns:* `cv_status::timeout` if the relative
 timeout [[thread.req.timing]] specified by `rel_time` expired, otherwise
 `cv_status::no_timeout`.
-*Remarks:* If the function fails to meet the postcondition,
-`terminate()` is called [[except.terminate]].
 [*Note 3*: This can happen if the re-locking of the mutex throws an
 exception. — *end note*]
-*Ensures:* `lock` is locked by the calling thread.
-*Throws:* Timeout-related exceptions [[thread.req.timing]].
 ``` cpp
 template<class Lock, class Clock, class Duration, class Predicate>
   bool wait_until(Lock& lock, const chrono::time_point<Clock, Duration>& abs_time, Predicate pred);
 ```
@@ -3585,18 +6578,18 @@ return pred();
 [*Note 1*: The returned value indicates whether the predicate evaluated
 to `true` regardless of whether there was a stop request. — *end note*]
 *Ensures:* `lock` is locked by the calling thread.
 *Remarks:* If the function fails to meet the postcondition, `terminate`
 is called [[except.terminate]].
 [*Note 2*: This can happen if the re-locking of the mutex throws an
 exception. — *end note*]
-*Throws:* Any exception thrown by `pred`.
 ``` cpp
 template<class Lock, class Clock, class Duration, class Predicate>
   bool wait_until(Lock& lock, stop_token stoken,
                   const chrono::time_point<Clock, Duration>& abs_time, Predicate pred);
 ```
@@ -3607,11 +6600,11 @@ equivalent to:
 ``` cpp
 while (!stoken.stop_requested()) {
   if (pred())
     return true;
-  if (cv.wait_until(lock, abs_time) == cv_status::timeout)
     return pred();
 }
 return pred();
 ```
@@ -3623,19 +6616,19 @@ expired. — *end note*]
 to `true` regardless of whether the timeout was triggered or a stop
 request was made. — *end note*]
 *Ensures:* `lock` is locked by the calling thread.
-*Remarks:* If the function fails to meet the postcondition, `terminate`
-is called [[except.terminate]].
-[*Note 5*: This can happen if the re-locking of the mutex throws an
-exception. — *end note*]
 *Throws:* Timeout-related exceptions [[thread.req.timing]], or any
 exception thrown by `pred`.
 ``` cpp
 template<class Lock, class Rep, class Period, class Predicate>
   bool wait_for(Lock& lock, stop_token stoken,
                 const chrono::duration<Rep, Period>& rel_time, Predicate pred);
 ```
@@ -3647,10 +6640,12 @@ return wait_until(lock, std::move(stoken), chrono::steady_clock::now() + rel_tim
                   std::move(pred));
 ```
 ## Semaphore <a id="thread.sema">[[thread.sema]]</a>
 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.
@@ -3661,10 +6656,11 @@ implementation of a counting semaphore with a unit resource count.
 ### Header `<semaphore>` synopsis <a id="semaphore.syn">[[semaphore.syn]]</a>
 ``` cpp
 namespace std {
   template<ptrdiff_t least_max_value = implementation-defined>
     class counting_semaphore;
   using binary_semaphore = counting_semaphore<1>;
 }
@@ -3672,11 +6668,11 @@ namespace std {
 ### Class template `counting_semaphore` <a id="thread.sema.cnt">[[thread.sema.cnt]]</a>
 ``` cpp
 namespace std {
-  template<ptrdiff_t least_max_value = implementation-defined>
   class counting_semaphore {
   public:
     static constexpr ptrdiff_t max() noexcept;
     constexpr explicit counting_semaphore(ptrdiff_t desired);
@@ -3771,11 +6767,11 @@ return `false` in the absence of contending semaphore operations.
 void acquire();
 ```
 *Effects:* Repeatedly performs the following steps, in order:
-- Evaluates `try_acquire`. If the result is `true`, returns.
 - Blocks on `*this` until `counter` is greater than zero.
 *Throws:* `system_error` when an exception is
 required [[thread.req.exception]].
@@ -3807,17 +6803,21 @@ required [[thread.req.exception]].
 *Error conditions:* Any of the error conditions allowed for mutex
 types [[thread.mutex.requirements.mutex]].
 ## Coordination types <a id="thread.coord">[[thread.coord]]</a>
-This subclause 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.
 ### Latches <a id="thread.latch">[[thread.latch]]</a>
 A latch is a thread coordination mechanism that allows any number of
 threads to block until an expected number of threads arrive at the latch
 (via the `count_down` function). The expected count is set when the
 latch is created. An individual latch is a single-use object; once the
 expected count has been reached, the latch cannot be reused.
@@ -3930,10 +6930,12 @@ count_down(update);
 wait();
 ```
 ### Barriers <a id="thread.barrier">[[thread.barrier]]</a>
 A barrier is a thread coordination mechanism whose lifetime consists of
 a sequence of barrier phases, where each phase allows at most an
 expected number of threads to block until the expected number of threads
 arrive at the barrier.
@@ -3981,17 +6983,14 @@ namespace std {
 Each *barrier phase* consists of the following steps:
 - The expected count is decremented by each call to `arrive` or
   `arrive_and_drop`.
-- When the expected count reaches zero, the phase completion step is
- run. For the specialization with the default value of the
-  `CompletionFunction` template parameter, the completion step is run as
- part of the call to `arrive` or `arrive_and_drop` that caused the
-  expected count to reach zero. For other specializations, the
-  completion step is run on one of the threads that arrived at the
-  barrier during the phase.
 - When the completion step finishes, the expected count is reset to what
   was specified by the `expected` argument to the constructor, possibly
   adjusted by calls to `arrive_and_drop`, and the next phase starts.
 Each phase defines a *phase synchronization point*. Threads that arrive
@@ -4147,61 +7146,68 @@ well. — *end note*]
 ### Header `<future>` synopsis <a id="future.syn">[[future.syn]]</a>
 ``` cpp
 namespace std {
   enum class future_errc {
-    broken_promise = implementation-defined,
-    future_already_retrieved = implementation-defined,
-    promise_already_satisfied = implementation-defined,
-    no_state = implementation-defined
   };
   enum class launch : unspecified{} {
     async = unspecified{},
     deferred = unspecified{},
-    implementation-defined
   };
   enum class future_status {
     ready,
     timeout,
     deferred
   };
   template<> struct is_error_code_enum<future_errc> : public true_type { };
   error_code make_error_code(future_errc e) noexcept;
   error_condition make_error_condition(future_errc e) noexcept;
   const error_category& future_category() noexcept;
   class future_error;
   template<class R> class promise;
   template<class R> class promise<R&>;
   template<> class promise<void>;
   template<class R>
     void swap(promise<R>& x, promise<R>& y) noexcept;
   template<class R, class Alloc>
     struct uses_allocator<promise<R>, Alloc>;
   template<class R> class future;
   template<class R> class future<R&>;
   template<> class future<void>;
   template<class R> class shared_future;
   template<class R> class shared_future<R&>;
   template<> class shared_future<void>;
   template<class> class packaged_task;  // not defined
   template<class R, class... ArgTypes>
     class packaged_task<R(ArgTypes...)>;
   template<class R, class... ArgTypes>
     void swap(packaged_task<R(ArgTypes...)>&, packaged_task<R(ArgTypes...)>&) noexcept;
   template<class F, class... Args>
     [[nodiscard]] future<invoke_result_t<decay_t<F>, decay_t<Args>...>>
       async(F&& f, Args&&... args);
   template<class F, class... Args>
     [[nodiscard]] future<invoke_result_t<decay_t<F>, decay_t<Args>...>>
@@ -4227,13 +7233,14 @@ const error_category& future_category() noexcept;
 ```
 *Returns:* A reference to an object of a type derived from class
 `error_category`.
-The object’s `default_error_condition` and equivalent virtual functions
-shall behave as specified for the class `error_category`. The object’s
-`name` virtual function returns a pointer to the string `"future"`.
 ``` cpp
 error_code make_error_code(future_errc e) noexcept;
 ```
@@ -4285,11 +7292,11 @@ const char* what() const noexcept;
 Many of the classes introduced in subclause  [[futures]] use some state
 to communicate results. This *shared state* consists of some state
 information and some (possibly not yet evaluated) *result*, which can be
 a (possibly void) value or an exception.
-[*Note 1*: Futures, promises, and tasks defined in this clause
 reference such shared state. — *end note*]
 [*Note 2*: The result can be any kind of object including a function to
 compute that result, as used by `async` when `policy` is
 `launch::deferred`. — *end note*]
@@ -4395,18 +7402,18 @@ namespace std {
     // setting the result with deferred notification
     void set_value_at_thread_exit(see below);
     void set_exception_at_thread_exit(exception_ptr p);
   };
-  template<class R>
-    void swap(promise<R>& x, promise<R>& y) noexcept;
   template<class R, class Alloc>
     struct uses_allocator<promise<R>, Alloc>;
 }
 ```
 The implementation provides the template `promise` and two
 specializations, `promise<R&>` and `promise<{}void>`. These differ only
 in the argument type of the member functions `set_value` and
 `set_value_at_thread_exit`, as set out in their descriptions, below.
@@ -4419,12 +7426,12 @@ the promise object.
 template<class R, class Alloc>
   struct uses_allocator<promise<R>, Alloc>
     : true_type { };
 ```
-*Preconditions:* `Alloc` meets the *Cpp17Allocator* requirements
-([[cpp17.allocator]]).
 ``` cpp
 promise();
 template<class Allocator>
   promise(allocator_arg_t, const Allocator& a);
@@ -4469,19 +7476,19 @@ to the call to `swap`. `other` has the shared state (if any) that
 ``` cpp
 future<R> get_future();
 ```
-*Returns:* A `future<R>` object with the same shared state as `*this`.
 *Synchronization:* Calls to this function do not introduce data
 races  [[intro.multithread]] with calls to `set_value`, `set_exception`,
 `set_value_at_thread_exit`, or `set_exception_at_thread_exit`.
 [*Note 1*: Such calls need not synchronize with each
 other. — *end note*]
 *Throws:* `future_error` if `*this` has no shared state or if
 `get_future` has already been called on a `promise` with the same shared
 state as `*this`.
 *Error conditions:*
@@ -4605,13 +7612,13 @@ move-assignment operator, `share`, or `valid` on a `future` object for
 which `valid() == false` is undefined.
 [*Note 2*: It is valid to move from a future object for which
 `valid() == false`. — *end note*]
-[*Note 3*: Implementations should detect this case and throw an object
-of type `future_error` with an error condition of
-`future_errc::no_state`. — *end note*]
 ``` cpp
 namespace std {
   template<class R>
   class future {
@@ -4637,10 +7644,13 @@ namespace std {
       future_status wait_until(const chrono::time_point<Clock, Duration>& abs_time) const;
   };
 }
 ```
 The implementation provides the template `future` and two
 specializations, `future<R&>` and `future<{}void>`. These differ only in
 the return type and return value of the member function `get`, as set
 out in its description, below.
@@ -4676,29 +7686,30 @@ state that was originally referred to by `rhs` (if any).
 ``` cpp
 future& operator=(future&& rhs) noexcept;
 ```
-*Effects:*
 - Releases any shared state [[futures.state]].
 - move assigns the contents of `rhs` to `*this`.
 *Ensures:*
 - `valid()` returns the same value as `rhs.valid()` prior to the
   assignment.
-- `rhs.valid() == false`.
 ``` cpp
 shared_future<R> share() noexcept;
 ```
 *Returns:* `shared_future<R>(std::move(*this))`.
-*Ensures:* `valid() == false`.
 ``` cpp
 R future::get();
 R& future<R&>::get();
 void future<void>::get();
 ```
@@ -4711,10 +7722,12 @@ member function `get`. — *end note*]
 - `wait()`s until the shared state is ready, then retrieves the value
   stored in the shared state;
 - releases any shared state [[futures.state]].
 *Returns:*
 - `future::get()` returns the value `v` stored in the object’s shared
   state as `std::move(v)`.
 - `future<R&>::get()` returns the reference stored as value in the
@@ -4722,12 +7735,10 @@ member function `get`. — *end note*]
 - `future<void>::get()` returns nothing.
 *Throws:* The stored exception, if an exception was stored in the shared
 state.
-*Ensures:* `valid() == false`.
 ``` cpp
 bool valid() const noexcept;
 ```
 *Returns:* `true` only if `*this` refers to a shared state.
@@ -4800,13 +7811,13 @@ move-assignment operator, the copy-assignment operator, or `valid()` on
 a `shared_future` object for which `valid() == false` is undefined.
 [*Note 2*: It is valid to copy or move from a `shared_future` object
 for which `valid()` is `false`. — *end note*]
-[*Note 3*: Implementations should detect this case and throw an object
-of type `future_error` with an error condition of
-`future_errc::no_state`. — *end note*]
 ``` cpp
 namespace std {
   template<class R>
   class shared_future {
@@ -4832,10 +7843,13 @@ namespace std {
       future_status wait_until(const chrono::time_point<Clock, Duration>& abs_time) const;
   };
 }
 ```
 The implementation provides the template `shared_future` and two
 specializations, `shared_future<R&>` and `shared_future<void>`. These
 differ only in the return type and return value of the member function
 `get`, as set out in its description, below.
@@ -4880,29 +7894,31 @@ shared state that was originally referred to by `rhs` (if any).
 ``` cpp
 shared_future& operator=(shared_future&& rhs) noexcept;
 ```
-*Effects:*
 - Releases any shared state [[futures.state]];
 - move assigns the contents of `rhs` to `*this`.
 *Ensures:*
 - `valid()` returns the same value as `rhs.valid()` returned prior to
   the assignment.
-- `rhs.valid() == false`.
 ``` cpp
 shared_future& operator=(const shared_future& rhs) noexcept;
 ```
-*Effects:*
 - Releases any shared state [[futures.state]];
-- assigns the contents of `rhs` to `*this`. \[*Note 4*: As a result,
   `*this` refers to the same shared state as `rhs` (if
   any). — *end note*]
 *Ensures:* `valid() == rhs.valid()`.
@@ -4915,20 +7931,20 @@ void shared_future<void>::get() const;
 [*Note 1*: As described above, the template and its two required
 specializations differ only in the return type and return value of the
 member function `get`. — *end note*]
 [*Note 2*: Access to a value object stored in the shared state is
-unsynchronized, so programmers should apply only those operations on `R`
-that do not introduce a data race [[intro.multithread]]. — *end note*]
 *Effects:* `wait()`s until the shared state is ready, then retrieves the
 value stored in the shared state.
 *Returns:*
 - `shared_future::get()` returns a const reference to the value stored
-  in the object’s shared state. \[*Note 5*: Access through that
   reference after the shared state has been destroyed produces undefined
   behavior; this can be avoided by not storing the reference in any
   storage with a greater lifetime than the `shared_future` object that
   returned the reference. — *end note*]
 - `shared_future<R&>::get()` returns the reference stored as value in
@@ -5008,82 +8024,64 @@ template<class F, class... Args>
 ```
 *Mandates:* The following are all `true`:
 - `is_constructible_v<decay_t<F>, F>`,
-- `(is_constructible_v<decay_t<Args>, Args> &&...)`,
-- `is_move_constructible_v<decay_t<F>>`,
-- `(is_move_constructible_v<decay_t<Args>> &&...)`, and
 - `is_invocable_v<decay_t<F>, decay_t<Args>...>`.
-*Preconditions:* `decay_t<F>` and each type in `decay_t<Args>` meet the
-*Cpp17MoveConstructible* requirements.
 *Effects:* The first function behaves the same as a call to the second
 function with a `policy` argument of `launch::async | launch::deferred`
 and the same arguments for `F` and `Args`. The second function creates a
 shared state that is associated with the returned `future` object. The
 further behavior of the second function depends on the `policy` argument
 as follows (if more than one of these conditions applies, the
 implementation may choose any of the corresponding policies):
 - If `launch::async` is set in `policy`, calls
-  `invoke(`*`decay-copy`*`(std::forward<F>(f)),`
- *decay-copy*(std::forward\<Args\>(args))...) ([[func.require]],
- [[thread.thread.constr]]) as if in a new thread of execution
- represented by a `thread` object with the calls to *`decay-copy`*
- being evaluated in the thread that called `async`. Any return value is
- stored as the result in the shared state. Any exception propagated
- from the execution of
-  `invoke(`*`decay-copy`*`(std::forward<F>(f)), `*`decay-copy`*`(std::forward<Args>(args))...)`
   is stored as the exceptional result in the shared state. The `thread`
   object is stored in the shared state and affects the behavior of any
   asynchronous return objects that reference that state.
 - If `launch::deferred` is set in `policy`, stores
- *decay-copy*(std::forward\<F\>(f)) and
- *decay-copy*(std::forward\<Args\>(args))... in the shared state. These
- copies of `f` and `args` constitute a *deferred function*. Invocation
-  of the deferred function evaluates
   `invoke(std::move(g), std::move(xyz))` where `g` is the stored value
-  of *decay-copy*(std::forward\<F\>(f)) and `xyz` is the stored copy of
- *decay-copy*(std::forward\<Args\>(args)).... Any return value is
- stored as the result in the shared state. Any exception propagated
- from the execution of the deferred function is stored as the
- exceptional result in the shared state. The shared state is not made
- ready until the function has completed. The first call to a non-timed
- waiting function [[futures.state]] on an asynchronous return object
- referring to this shared state invokes the deferred function in the
- thread that called the waiting function. Once evaluation of
   `invoke(std::move(g), std::move(xyz))` begins, the function is no
-  longer considered deferred. \[*Note 1*: If this policy is specified
-  together with other policies, such as when using a `policy` value of
-  `launch::async | launch::deferred`, implementations should defer
-  invocation or the selection of the policy when no more concurrency can
-  be effectively exploited. — *end note*]
 - If no value is set in the launch policy, or a value is set that is
   neither specified in this document nor by the implementation, the
   behavior is undefined.
-*Returns:* An object of type
-`future<invoke_result_t<decay_t<F>, decay_t<Args>...>``>` that refers to
-the shared state created by this call to `async`.
-[*Note 1*: If a future obtained from `async` is moved outside the local
-scope, other code that uses the future should be aware that the future’s
-destructor can block for the shared state to become
-ready. — *end note*]
-*Synchronization:* Regardless of the provided `policy` argument,
-- the invocation of `async` synchronizes with [[intro.multithread]] the
-  invocation of `f`. \[*Note 2*: This statement applies even when the
-  corresponding `future` object is moved to another
-  thread. — *end note*] ; and
-- the completion of the function `f` is sequenced
-  before [[intro.multithread]] the shared state is made ready.
-  \[*Note 3*: `f` might not be called at all, so its completion might
-  never happen. — *end note*]
 If the implementation chooses the `launch::async` policy,
 - a call to a waiting function on an asynchronous return object that
   shares the shared state created by this `async` call shall block until
@@ -5093,27 +8091,37 @@ If the implementation chooses the `launch::async` policy,
   with [[intro.multithread]] the return from the first function that
   successfully detects the ready status of the shared state or with the
   return from the last function that releases the shared state,
   whichever happens first.
 *Throws:* `system_error` if `policy == launch::async` and the
 implementation is unable to start a new thread, or `std::bad_alloc` if
-memory for the internal data structures could not be allocated.
 *Error conditions:*
 - `resource_unavailable_try_again` — if `policy == launch::async` and
   the system is unable to start a new thread.
-[*Note 4*: Line \#1 might not result in concurrency because the `async`
-call uses the default policy, which may use `launch::deferred`, in which
-case the lambda might not be invoked until the `get()` call; in that
-case, `work1` and `work2` are called on the same thread and there is no
-concurrency. — *end note*]
 ### Class template `packaged_task` <a id="futures.task">[[futures.task]]</a>
 The class template `packaged_task` defines a type for wrapping a
 function or callable object so that the return value of the function or
 callable object is stored in a future when it is invoked.
 When the `packaged_task` object is invoked, its stored task is invoked
@@ -5154,11 +8162,13 @@ namespace std {
     void reset();
   };
   template<class R, class... ArgTypes>
- void swap(packaged_task<R(ArgTypes...)>& x, packaged_task<R(ArgTypes...)>& y) noexcept;
 }
 ```
 #### Member functions <a id="futures.task.members">[[futures.task.members]]</a>
@@ -5168,11 +8178,11 @@ packaged_task() noexcept;
 *Effects:* The object has no shared state and no stored task.
 ``` cpp
 template<class F>
-  packaged_task(F&& f);
 ```
 *Constraints:* `remove_cvref_t<F>` is not the same type as
 `packaged_task<R(ArgTypes...)>`.
@@ -5183,13 +8193,29 @@ template<class F>
 *Effects:* Constructs a new `packaged_task` object with a shared state
 and initializes the object’s stored task with `std::forward<F>(f)`.
 *Throws:* Any exceptions thrown by the copy or move constructor of `f`,
-or `bad_alloc` if memory for the internal data structures could not be
 allocated.
 ``` cpp
 packaged_task(packaged_task&& rhs) noexcept;
 ```
 *Effects:* Transfers ownership of `rhs`’s shared state to `*this`,
@@ -5232,20 +8258,20 @@ bool valid() const noexcept;
 ``` cpp
 future<R> get_future();
 ```
-*Returns:* A `future` object that shares the same shared state as
-`*this`.
 *Synchronization:* Calls to this function do not introduce data
 races  [[intro.multithread]] with calls to `operator()` or
 `make_ready_at_thread_exit`.
 [*Note 1*: Such calls need not synchronize with each
 other. — *end note*]
 *Throws:* A `future_error` object if an error occurs.
 *Error conditions:*
 - `future_already_retrieved` if `get_future` has already been called on
@@ -5305,12 +8331,12 @@ task stored in `*this`.
 [*Note 2*: This constructs a new shared state for `*this`. The old
 state is abandoned [[futures.state]]. — *end note*]
 *Throws:*
-- `bad_alloc` if memory for the new shared state could not be allocated.
-- any exception thrown by the move constructor of the task stored in the
   shared state.
 - `future_error` with an error condition of `no_state` if `*this` has no
   shared state.
 #### Globals <a id="futures.task.nonmembers">[[futures.task.nonmembers]]</a>
@@ -5322,139 +8348,209 @@ template<class R, class... ArgTypes>
 *Effects:* As if by `x.swap(y)`.
 <!-- Link reference definitions -->
 [alg.sorting]: algorithms.md#alg.sorting
-[atomics]: atomics.md#atomics
 [barrier.syn]: #barrier.syn
 [basic.life]: basic.md#basic.life
 [basic.stc.thread]: basic.md#basic.stc.thread
 [bitmask.types]: library.md#bitmask.types
 [class.prop]: class.md#class.prop
 [condition.variable.syn]: #condition.variable.syn
-[cpp17.allocator]: #cpp17.allocator
 [cpp17.defaultconstructible]: #cpp17.defaultconstructible
 [cpp17.destructible]: #cpp17.destructible
 [cpp17.moveassignable]: #cpp17.moveassignable
 [cpp17.moveconstructible]: #cpp17.moveconstructible
 [defns.block]: intro.md#defns.block
 [except.terminate]: except.md#except.terminate
 [func.require]: utilities.md#func.require
 [future.syn]: #future.syn
 [futures]: #futures
 [futures.async]: #futures.async
 [futures.errors]: #futures.errors
 [futures.future.error]: #futures.future.error
 [futures.overview]: #futures.overview
 [futures.promise]: #futures.promise
 [futures.shared.future]: #futures.shared.future
 [futures.state]: #futures.state
 [futures.task]: #futures.task
 [futures.task.members]: #futures.task.members
 [futures.task.nonmembers]: #futures.task.nonmembers
 [futures.unique.future]: #futures.unique.future
 [intro.multithread]: basic.md#intro.multithread
 [intro.races]: basic.md#intro.races
 [latch.syn]: #latch.syn
 [mutex.syn]: #mutex.syn
 [res.on.data.races]: library.md#res.on.data.races
 [res.on.exception.handling]: library.md#res.on.exception.handling
 [semaphore.syn]: #semaphore.syn
 [shared.mutex.syn]: #shared.mutex.syn
 [stopcallback]: #stopcallback
 [stopcallback.cons]: #stopcallback.cons
 [stopsource]: #stopsource
 [stopsource.cons]: #stopsource.cons
 [stopsource.mem]: #stopsource.mem
 [stopsource.nonmembers]: #stopsource.nonmembers
 [stoptoken]: #stoptoken
 [stoptoken.cons]: #stoptoken.cons
 [stoptoken.mem]: #stoptoken.mem
 [stoptoken.nonmembers]: #stoptoken.nonmembers
 [syserr]: diagnostics.md#syserr
 [syserr.syserr]: diagnostics.md#syserr.syserr
 [thread]: #thread
 [thread.barrier]: #thread.barrier
 [thread.barrier.class]: #thread.barrier.class
 [thread.condition]: #thread.condition
 [thread.condition.condvar]: #thread.condition.condvar
 [thread.condition.condvarany]: #thread.condition.condvarany
 [thread.condition.nonmember]: #thread.condition.nonmember
 [thread.condvarany.intwait]: #thread.condvarany.intwait
 [thread.condvarany.wait]: #thread.condvarany.wait
 [thread.coord]: #thread.coord
 [thread.general]: #thread.general
 [thread.jthread.class]: #thread.jthread.class
 [thread.jthread.cons]: #thread.jthread.cons
 [thread.jthread.mem]: #thread.jthread.mem
 [thread.jthread.special]: #thread.jthread.special
 [thread.jthread.static]: #thread.jthread.static
 [thread.jthread.stop]: #thread.jthread.stop
 [thread.latch]: #thread.latch
 [thread.latch.class]: #thread.latch.class
 [thread.lock]: #thread.lock
 [thread.lock.algorithm]: #thread.lock.algorithm
 [thread.lock.guard]: #thread.lock.guard
 [thread.lock.scoped]: #thread.lock.scoped
 [thread.lock.shared]: #thread.lock.shared
 [thread.lock.shared.cons]: #thread.lock.shared.cons
 [thread.lock.shared.locking]: #thread.lock.shared.locking
 [thread.lock.shared.mod]: #thread.lock.shared.mod
 [thread.lock.shared.obs]: #thread.lock.shared.obs
 [thread.lock.unique]: #thread.lock.unique
 [thread.lock.unique.cons]: #thread.lock.unique.cons
 [thread.lock.unique.locking]: #thread.lock.unique.locking
 [thread.lock.unique.mod]: #thread.lock.unique.mod
 [thread.lock.unique.obs]: #thread.lock.unique.obs
 [thread.mutex]: #thread.mutex
 [thread.mutex.class]: #thread.mutex.class
 [thread.mutex.recursive]: #thread.mutex.recursive
 [thread.mutex.requirements]: #thread.mutex.requirements
 [thread.mutex.requirements.general]: #thread.mutex.requirements.general
 [thread.mutex.requirements.mutex]: #thread.mutex.requirements.mutex
 [thread.once]: #thread.once
 [thread.once.callonce]: #thread.once.callonce
 [thread.once.onceflag]: #thread.once.onceflag
 [thread.req]: #thread.req
 [thread.req.exception]: #thread.req.exception
 [thread.req.lockable]: #thread.req.lockable
 [thread.req.lockable.basic]: #thread.req.lockable.basic
 [thread.req.lockable.general]: #thread.req.lockable.general
 [thread.req.lockable.req]: #thread.req.lockable.req
 [thread.req.lockable.timed]: #thread.req.lockable.timed
 [thread.req.native]: #thread.req.native
 [thread.req.paramname]: #thread.req.paramname
 [thread.req.timing]: #thread.req.timing
 [thread.sema]: #thread.sema
 [thread.sema.cnt]: #thread.sema.cnt
 [thread.sharedmutex.class]: #thread.sharedmutex.class
 [thread.sharedmutex.requirements]: #thread.sharedmutex.requirements
 [thread.sharedtimedmutex.class]: #thread.sharedtimedmutex.class
 [thread.sharedtimedmutex.requirements]: #thread.sharedtimedmutex.requirements
 [thread.stoptoken]: #thread.stoptoken
 [thread.stoptoken.intro]: #thread.stoptoken.intro
 [thread.stoptoken.syn]: #thread.stoptoken.syn
 [thread.summary]: #thread.summary
 [thread.syn]: #thread.syn
 [thread.thread.algorithm]: #thread.thread.algorithm
 [thread.thread.assign]: #thread.thread.assign
 [thread.thread.class]: #thread.thread.class
 [thread.thread.constr]: #thread.thread.constr
 [thread.thread.destr]: #thread.thread.destr
 [thread.thread.id]: #thread.thread.id
 [thread.thread.member]: #thread.thread.member
 [thread.thread.static]: #thread.thread.static
 [thread.thread.this]: #thread.thread.this
 [thread.threads]: #thread.threads
 [thread.timedmutex.class]: #thread.timedmutex.class
 [thread.timedmutex.recursive]: #thread.timedmutex.recursive
 [thread.timedmutex.requirements]: #thread.timedmutex.requirements
 [time]: time.md#time
 [time.clock]: time.md#time.clock
 [time.clock.req]: time.md#time.clock.req
 [time.duration]: time.md#time.duration
 [time.point]: time.md#time.point
 [unord.hash]: utilities.md#unord.hash
-[^1]: All implementations for which standard time units are meaningful
- must necessarily have a steady clock within their hardware
-    implementation.

+# Concurrency support library <a id="thread">[[thread]]</a>
 ## General <a id="thread.general">[[thread.general]]</a>
 The following subclauses describe components to create and manage
 threads [[intro.multithread]], perform mutual exclusion, and communicate
 conditions and values between threads, as summarized in
 [[thread.summary]].
+**Table: Concurrency support library summary** <a id="thread.summary">[thread.summary]</a>
 | Subclause            |                     | Header                      |
 | -------------------- | ------------------- | --------------------------- |
 | [[thread.req]]       | Requirements        |                             |
 | [[thread.stoptoken]] | Stop tokens         | `<stop_token>`              |
 | [[thread.threads]]   | Threads             | `<thread>`                  |
+| [[atomics]]          | Atomic operations   | `<atomic>`, `<stdatomic.h>` |
 | [[thread.mutex]]     | Mutual exclusion    | `<mutex>`, `<shared_mutex>` |
 | [[thread.condition]] | Condition variables | `<condition_variable>`      |
 | [[thread.sema]]      | Semaphores          | `<semaphore>`               |
 | [[thread.coord]]     | Coordination types  | `<latch>` `<barrier>`       |
 | [[futures]]          | Futures             | `<future>`                  |
 ## Requirements <a id="thread.req">[[thread.req]]</a>
 ### Template parameter names <a id="thread.req.paramname">[[thread.req.paramname]]</a>
 Throughout this Clause, the names of template parameters are used to
+express type requirements. `Predicate` is a function object type
+[[function.objects]]. Let `pred` denote an lvalue of type `Predicate`.
+Then the expression `pred()` shall be well-formed and the type
+`decltype(pred())` shall model `boolean-testable`
+[[concept.booleantestable]]. The return value of `pred()`, converted to
+`bool`, yields `true` if the corresponding test condition is satisfied,
+and `false` otherwise. If a template parameter is named `Clock`, the
+corresponding template argument shall be a type `C` that meets the
+*Cpp17Clock* requirements [[time.clock.req]]; the program is ill-formed
+if `is_clock_v<C>` is `false`.
 ### Exceptions <a id="thread.req.exception">[[thread.req.exception]]</a>
 Some functions described in this Clause are specified to throw
 exceptions of type `system_error` [[syserr.syserr]]. Such exceptions are
 to an operating system or other underlying API results in an error that
 prevents the library function from meeting its specifications. Failure
 to allocate storage is reported as described in
 [[res.on.exception.handling]].
+[*Example 1*: Consider a function in this Clause that is specified to
 throw exceptions of type `system_error` and specifies error conditions
 that include `operation_not_permitted` for a thread that does not have
 the privilege to perform the operation. Assume that, during the
 execution of this function, an `errno` of `EPERM` is reported by a POSIX
 API call used by the implementation. Since POSIX specifies an `errno` of
 as duration Dₘ. The delay durations may vary from timeout to timeout,
 but in all cases shorter is better.
 The functions whose names end in `_for` take an argument that specifies
 a duration. These functions produce relative timeouts. Implementations
+should use a steady clock to measure time for these functions.[^1]
+Given a duration argument Dₜ, the real-time duration of the timeout is
 Dₜ + Dᵢ + Dₘ.
 The functions whose names end in `_until` take an argument that
 specifies a time point. These functions produce absolute timeouts.
 Implementations should use the clock specified in the time point to
 the clock time point of the return from timeout should be Cₜ + Dᵢ + Dₘ
 when the clock is not adjusted during the timeout. If the clock is
 adjusted to the time Cₐ during the timeout, the behavior should be as
 follows:
+- If Cₐ > Cₜ, the waiting function should wake as soon as possible,
   i.e., Cₐ + Dᵢ + Dₘ, since the timeout is already satisfied. This
   specification may result in the total duration of the wait decreasing
   when measured against a steady clock.
+- If Cₐ ≤ Cₜ, the waiting function should not time out until
   `Clock::now()` returns a time Cₙ ≥ Cₜ, i.e., waking at Cₜ + Dᵢ + Dₘ.
   \[*Note 1*: When the clock is adjusted backwards, this specification
   can result in the total duration of the wait increasing when measured
   against a steady clock. When the clock is adjusted forwards, this
   specification can result in the total duration of the wait decreasing
 An implementation returns from such a timeout at any point from the time
 specified above to the time it would return from a steady-clock relative
 timeout on the difference between Cₜ and the time point of the call to
 the `_until` function.
+*Recommended practice:* Implementations should decrease the duration of
+the wait when the clock is adjusted forwards.
+[*Note 2*: If the clock is not synchronized with a steady clock, e.g.,
+a CPU time clock, these timeouts can fail to provide useful
 functionality. — *end note*]
 The resolution of timing provided by an implementation depends on both
 operating system and hardware. The finest resolution provided by an
 implementation is called the *native resolution*.
 A function that takes an argument which specifies a timeout will throw
 if, during its execution, a clock, time point, or time duration throws
 an exception. Such exceptions are referred to as *timeout-related
 exceptions*.
+[*Note 3*: Instantiations of clock, time point and duration types
 supplied by the implementation as specified in  [[time.clock]] do not
 throw exceptions. — *end note*]
 ### Requirements for *Cpp17Lockable* types <a id="thread.req.lockable">[[thread.req.lockable]]</a>
 `shared_lock` [[thread.lock.shared]], `scoped_lock`
 [[thread.lock.scoped]], `lock_guard` [[thread.lock.guard]], `lock`,
 `try_lock` [[thread.lock.algorithm]], and `condition_variable_any`
 [[thread.condition.condvarany]] all operate on user-supplied lockable
 objects. The *Cpp17BasicLockable* requirements, the *Cpp17Lockable*
+requirements, the *Cpp17TimedLockable* requirements, the
+*Cpp17SharedLockable* requirements, and the *Cpp17SharedTimedLockable*
+requirements list the requirements imposed by these library types in
+order to acquire or release ownership of a `lock` by a given execution
+agent.
 [*Note 3*: The nature of any lock ownership and any synchronization it
 entails are not part of these requirements. — *end note*]
+A lock on an object `m` is said to be
+- a *non-shared lock* if it is acquired by a call to `lock`, `try_lock`,
+  `try_lock_for`, or `try_lock_until` on `m`, or
+- a *shared lock* if it is acquired by a call to `lock_shared`,
+  `try_lock_shared`, `try_lock_shared_for`, or `try_lock_shared_until`
+  on `m`.
+[*Note 4*: Only the method of lock acquisition is considered; the
+nature of any lock ownership is not part of these
+definitions. — *end note*]
 #### *Cpp17BasicLockable* requirements <a id="thread.req.lockable.basic">[[thread.req.lockable.basic]]</a>
 A type `L` meets the *Cpp17BasicLockable* requirements if the following
 expressions are well-formed and have the specified semantics (`m`
 denotes a value of type `L`).
 ``` cpp
 m.unlock()
 ```
+*Preconditions:* The current execution agent holds a non-shared lock on
+`m`.
+*Effects:* Releases a non-shared lock on `m` held by the current
+execution agent.
 *Throws:* Nothing.
 #### *Cpp17Lockable* requirements <a id="thread.req.lockable.req">[[thread.req.lockable.req]]</a>
 without blocking. If an exception is thrown then a lock shall not have
 been acquired for the current execution agent.
 *Return type:* `bool`.
+*Returns:* `true` if the lock was acquired, otherwise `false`.
 #### *Cpp17TimedLockable* requirements <a id="thread.req.lockable.timed">[[thread.req.lockable.timed]]</a>
 A type `L` meets the *Cpp17TimedLockable* requirements if it meets the
 *Cpp17Lockable* requirements and the following expressions are
 execution agent. If an exception is thrown then a lock has not been
 acquired for the current execution agent.
 *Return type:* `bool`.
+*Returns:* `true` if the lock was acquired, otherwise `false`.
 ``` cpp
 m.try_lock_until(abs_time)
 ```
 execution agent. If an exception is thrown then a lock has not been
 acquired for the current execution agent.
 *Return type:* `bool`.
+*Returns:* `true` if the lock was acquired, otherwise `false`.
+#### *Cpp17SharedLockable* requirements <a id="thread.req.lockable.shared">[[thread.req.lockable.shared]]</a>
+A type `L` meets the *Cpp17SharedLockable* requirements if the following
+expressions are well-formed, have the specified semantics, and the
+expression `m.try_lock_shared()` has type `bool` (`m` denotes a value of
+type `L`):
+``` cpp
+m.lock_shared()
+```
+*Effects:* Blocks until a lock can be acquired for the current execution
+agent. If an exception is thrown then a lock shall not have been
+acquired for the current execution agent.
+``` cpp
+m.try_lock_shared()
+```
+*Effects:* Attempts to acquire a lock for the current execution agent
+without blocking. If an exception is thrown then a lock shall not have
+been acquired for the current execution agent.
+*Returns:* `true` if the lock was acquired, `false` otherwise.
+``` cpp
+m.unlock_shared()
+```
+*Preconditions:* The current execution agent holds a shared lock on `m`.
+*Effects:* Releases a shared lock on `m` held by the current execution
+agent.
+*Throws:* Nothing.
+#### *Cpp17SharedTimedLockable* requirements <a id="thread.req.lockable.shared.timed">[[thread.req.lockable.shared.timed]]</a>
+A type `L` meets the *Cpp17SharedTimedLockable* requirements if it meets
+the *Cpp17SharedLockable* requirements, and the following expressions
+are well-formed, have type `bool`, and have the specified semantics (`m`
+denotes a value of type `L`, `rel_time` denotes a value of a
+specialization of `chrono::duration`, and `abs_time` denotes a value of
+a specialization of `chrono::time_point`).
+``` cpp
+m.try_lock_shared_for(rel_time)
+```
+*Effects:* Attempts to acquire a lock for the current execution agent
+within the relative timeout [[thread.req.timing]] specified by
+`rel_time`. The function will not return within the timeout specified by
+`rel_time` unless it has obtained a lock on `m` for the current
+execution agent. If an exception is thrown then a lock has not been
+acquired for the current execution agent.
+*Returns:* `true` if the lock was acquired, `false` otherwise.
+``` cpp
+m.try_lock_shared_until(abs_time)
+```
+*Effects:* Attempts to acquire a lock for the current execution agent
+before the absolute timeout [[thread.req.timing]] specified by
+`abs_time`. The function will not return before the timeout specified by
+`abs_time` unless it has obtained a lock on `m` for the current
+execution agent. If an exception is thrown then a lock has not been
+acquired for the current execution agent.
 *Returns:* `true` if the lock was acquired, `false` otherwise.
 ## Stop tokens <a id="thread.stoptoken">[[thread.stoptoken]]</a>
 ### Introduction <a id="thread.stoptoken.intro">[[thread.stoptoken.intro]]</a>
+Subclause [[thread.stoptoken]] describes components that can be used to
+asynchronously request that an operation stops execution in a timely
+manner, typically because the result is no longer required. Such a
+request is called a *stop request*.
 `stop_source`, `stop_token`, and `stop_callback` implement semantics of
 shared ownership of a *stop state*. Any `stop_source`, `stop_token`, or
 `stop_callback` that shares ownership of the same stop state is an
 *associated* `stop_source`, `stop_token`, or `stop_callback`,
   struct nostopstate_t {
     explicit nostopstate_t() = default;
   };
   inline constexpr nostopstate_t nostopstate{};
+  // [stopcallback], class template stop_callback
   template<class Callback>
     class stop_callback;
 }
 ```
 ### Class `stop_token` <a id="stoptoken">[[stoptoken]]</a>
+#### General <a id="stoptoken.general">[[stoptoken.general]]</a>
 The class `stop_token` provides an interface for querying whether a stop
 request has been made (`stop_requested`) or can ever be made
+(`stop_possible`) using an associated `stop_source` object
+[[stopsource]]. A `stop_token` can also be passed to a `stop_callback`
 [[stopcallback]] constructor to register a callback to be called when a
 stop request has been made from an associated `stop_source`.
 ``` cpp
 namespace std {
 *Effects:* Equivalent to: `x.swap(y)`.
 ### Class `stop_source` <a id="stopsource">[[stopsource]]</a>
+#### General <a id="stopsource.general">[[stopsource.general]]</a>
 The class `stop_source` implements the semantics of making a stop
 request. A stop request made on a `stop_source` object is visible to all
+associated `stop_source` and `stop_token` [[stoptoken]] objects. Once a
+stop request has been made it cannot be withdrawn (a subsequent stop
 request has no effect).
 ``` cpp
 namespace std {
   // no-shared-stop-state indicator
 *Effects:* Initialises `*this` to have ownership of a new stop state.
 *Ensures:* `stop_possible()` is `true` and `stop_requested()` is
 `false`.
+*Throws:* `bad_alloc` if memory cannot be allocated for the stop state.
 ``` cpp
 explicit stop_source(nostopstate_t) noexcept;
 ```
 has received a stop request, and if not, makes a stop request. The
 determination and making of the stop request are an atomic
 read-modify-write operation [[intro.races]]. If the request was made,
 the callbacks registered by associated `stop_callback` objects are
 synchronously called. If an invocation of a callback exits via an
+exception then `terminate` is invoked [[except.terminate]].
 [*Note 1*: A stop request includes notifying all condition variables of
 type `condition_variable_any` temporarily registered during an
 interruptible wait [[thread.condvarany.intwait]]. — *end note*]
 *Effects:* Equivalent to: `x.swap(y)`.
 ### Class template `stop_callback` <a id="stopcallback">[[stopcallback]]</a>
+#### General <a id="stopcallback.general">[[stopcallback.general]]</a>
 ``` cpp
 namespace std {
   template<class Callback>
   class stop_callback {
   public:
 stop state, acquires shared ownership of that stop state and registers
 the callback with that stop state such that
 `std::forward<Callback>(callback)()` is evaluated by the first call to
 `request_stop()` on an associated `stop_source`.
 *Throws:* Any exception thrown by the initialization of `callback`.
+*Remarks:* If evaluating `std::forward<Callback>(callback)()` exits via
+an exception, then `terminate` is invoked [[except.terminate]].
 ``` cpp
 ~stop_callback();
 ```
 *Effects:* Unregisters the callback from the owned stop state, if any.
 the return from the invocation of `callback`. Releases ownership of the
 stop state, if any.
 ## Threads <a id="thread.threads">[[thread.threads]]</a>
+### General <a id="thread.threads.general">[[thread.threads.general]]</a>
 [[thread.threads]] describes components that can be used to create and
 manage threads.
 [*Note 1*: These threads are intended to map one-to-one with operating
 system threads. — *end note*]
 ### Header `<thread>` synopsis <a id="thread.syn">[[thread.syn]]</a>
 ``` cpp
 #include <compare>              // see [compare.syn]
 namespace std {
+  // [thread.thread.class], class thread
   class thread;
   void swap(thread& x, thread& y) noexcept;
+  // [thread.jthread.class], class jthread
   class jthread;
+  // [thread.thread.this], namespace this_thread
   namespace this_thread {
     thread::id get_id() noexcept;
     void yield() noexcept;
     template<class Clock, class Duration>
 }
 ```
 ### Class `thread` <a id="thread.thread.class">[[thread.thread.class]]</a>
+#### General <a id="thread.thread.class.general">[[thread.thread.class.general]]</a>
 The class `thread` provides a mechanism to create a new thread of
 execution, to join with a thread (i.e., wait for a thread to complete),
 and to perform other operations that manage and query the state of a
 thread. A `thread` object uniquely represents a particular thread of
 execution. That representation may be transferred to other `thread`
 ``` cpp
 namespace std {
   class thread {
   public:
+    // [thread.thread.id], class thread::id
     class id;
     using native_handle_type = implementation-defined;         // see~[thread.req.native]
     // construct/copy/destroy
     thread() noexcept;
     thread(const thread&) = delete;
     thread(thread&&) noexcept;
     thread& operator=(const thread&) = delete;
     thread& operator=(thread&&) noexcept;
+    // [thread.thread.member], members
     void swap(thread&) noexcept;
     bool joinable() const noexcept;
     void join();
     void detach();
     id get_id() const noexcept;
   template<class charT, class traits>
     basic_ostream<charT, traits>&
       operator<<(basic_ostream<charT, traits>& out, thread::id id);
+  template<class charT> struct formatter<thread::id, charT>;
   // hash support
   template<class T> struct hash;
   template<> struct hash<thread::id>;
 }
 ```
 Each thread of execution has an associated `thread::id` object that is
 not equal to the `thread::id` object of any other thread of execution
 and that is not equal to the `thread::id` object of any `thread` object
 that does not represent threads of execution.
+The *text representation* for the character type `charT` of an object of
+type `thread::id` is an unspecified sequence of `charT` such that, for
+two objects of type `thread::id` `x` and `y`, if `x == y` is `true`, the
+`thread::id` objects have the same text representation, and if `x != y`
+is `true`, the `thread::id` objects have distinct text representations.
 `thread::id` is a trivially copyable class [[class.prop]]. The library
 may reuse the value of a `thread::id` of a terminated thread that can no
 longer be joined.
 [*Note 1*: Relational operators allow `thread::id` objects to be used
 template<class charT, class traits>
   basic_ostream<charT, traits>&
     operator<< (basic_ostream<charT, traits>& out, thread::id id);
 ```
+*Effects:* Inserts the text representation for `charT` of `id` into
+`out`.
 *Returns:* `out`.
+``` cpp
+template<class charT> struct formatter<thread::id, charT>;
+```
+`formatter<thread::id, charT>` interprets *format-spec* as a
+*thread-id-format-spec*. The syntax of format specifications is as
+follows:
+``` bnf
+thread-id-format-spec
+    fill-and-alignₒₚₜ widthₒₚₜ
+```
+[*Note 1*: The productions *fill-and-align* and *width* are described
+in [[format.string.std]]. — *end note*]
+If the *align* option is omitted it defaults to `>`.
+A `thread::id` object is formatted by writing its text representation
+for `charT` to the output with additional padding and adjustments as
+specified by the format specifiers.
 ``` cpp
 template<> struct hash<thread::id>;
 ```
 The specialization is enabled [[unord.hash]].
 *Constraints:* `remove_cvref_t<F>` is not the same type as `thread`.
 *Mandates:* The following are all `true`:
 - `is_constructible_v<decay_t<F>, F>`,
+- `(is_constructible_v<decay_t<Args>, Args> && ...)`, and
 - `is_invocable_v<decay_t<F>, decay_t<Args>...>`.
 *Effects:* The new thread of execution executes
 ``` cpp
+invoke(auto(std::forward<F>(f)),                // for invoke, see [func.invoke]
+       auto(std::forward<Args>(args))...)
 ```
+with the values produced by `auto` being materialized [[conv.rval]] in
+the constructing thread. Any return value from this invocation is
+ignored.
 [*Note 1*: This implies that any exceptions not thrown from the
 invocation of the copy of `f` will be thrown in the constructing thread,
 not the new thread. — *end note*]
 If the invocation of `invoke` terminates with an uncaught exception,
+`terminate` is invoked [[except.terminate]].
 *Synchronization:* The completion of the invocation of the constructor
 synchronizes with the beginning of the invocation of the copy of `f`.
 *Ensures:* `get_id() != id()`. `*this` represents the newly started
 ``` cpp
 ~thread();
 ```
+*Effects:* If `joinable()`, invokes `terminate` [[except.terminate]].
+Otherwise, has no effects.
 [*Note 1*: Either implicitly detaching or joining a `joinable()` thread
+in its destructor can result in difficult to debug correctness (for
 detach) or performance (for join) bugs encountered only when an
+exception is thrown. These bugs can be avoided by ensuring that the
+destructor is never executed while the thread is still
+joinable. — *end note*]
 #### Assignment <a id="thread.thread.assign">[[thread.thread.assign]]</a>
 ``` cpp
 thread& operator=(thread&& x) noexcept;
 ```
+*Effects:* If `joinable()`, invokes `terminate` [[except.terminate]].
+Otherwise, assigns the state of `x` to `*this` and sets `x` to a default
+constructed state.
 *Ensures:* `x.get_id() == id()` and `get_id()` returns the value of
 `x.get_id()` prior to the assignment.
 *Returns:* `*this`.
 *Effects:* As if by `x.swap(y)`.
 ### Class `jthread` <a id="thread.jthread.class">[[thread.jthread.class]]</a>
+#### General <a id="thread.jthread.class.general">[[thread.jthread.class.general]]</a>
 The class `jthread` provides a mechanism to create a new thread of
 execution. The functionality is the same as for class `thread`
 [[thread.thread.class]] with the additional abilities to provide a
 `stop_token` [[thread.stoptoken]] to the new thread of execution, make
 stop requests, and automatically join.
 *Constraints:* `remove_cvref_t<F>` is not the same type as `jthread`.
 *Mandates:* The following are all `true`:
 - `is_constructible_v<decay_t<F>, F>`,
+- `(is_constructible_v<decay_t<Args>, Args> && ...)`, and
 - `is_invocable_v<decay_t<F>, decay_t<Args>...> ||`
   `is_invocable_v<decay_t<F>, stop_token, decay_t<Args>...>`.
 *Effects:* Initializes `ssource`. The new thread of execution executes
 ``` cpp
+invoke(auto(std::forward<F>(f)), get_stop_token(),  // for invoke, see [func.invoke]
+ auto(std::forward<Args>(args))...)
 ```
 if that expression is well-formed, otherwise
 ``` cpp
+invoke(auto(std::forward<F>(f)), auto(std::forward<Args>(args))...)
 ```
+with the values produced by `auto` being materialized [[conv.rval]] in
+the constructing thread. Any return value from this invocation is
+ignored.
 [*Note 1*: This implies that any exceptions not thrown from the
 invocation of the copy of `f` will be thrown in the constructing thread,
 not the new thread. — *end note*]
 ``` cpp
 jthread& operator=(jthread&& x) noexcept;
 ```
+*Effects:* If `&x == this` is `true`, there are no effects. Otherwise,
+if `joinable()` is `true`, calls `request_stop()` and then `join()`,
+then assigns the state of `x` to `*this` and sets `x` to a default
 constructed state.
+*Ensures:* `get_id()` returns the value of `x.get_id()` prior to the
+assignment. `ssource` has the value of `x.ssource` prior to the
+assignment.
 *Returns:* `*this`.
 #### Members <a id="thread.jthread.mem">[[thread.jthread.mem]]</a>
 ``` cpp
 thread::id this_thread::get_id() noexcept;
 ```
 *Returns:* An object of type `thread::id` that uniquely identifies the
+current thread of execution. Every invocation from this thread of
+execution returns the same value. The object returned does not compare
+equal to a default-constructed `thread::id`.
 ``` cpp
 void this_thread::yield() noexcept;
 ```
 *Synchronization:* None.
 *Throws:* Timeout-related exceptions [[thread.req.timing]].
+## Atomic operations <a id="atomics">[[atomics]]</a>
+### General <a id="atomics.general">[[atomics.general]]</a>
+Subclause [[atomics]] describes components for fine-grained atomic
+access. This access is provided via operations on atomic objects.
+### Header `<atomic>` synopsis <a id="atomics.syn">[[atomics.syn]]</a>
+``` cpp
+namespace std {
+  // [atomics.order], order and consistency
+  enum class memory_order : unspecified;                                            // freestanding
+  inline constexpr memory_order memory_order_relaxed = memory_order::relaxed;       // freestanding
+  inline constexpr memory_order memory_order_consume = memory_order::consume;       // freestanding
+  inline constexpr memory_order memory_order_acquire = memory_order::acquire;       // freestanding
+  inline constexpr memory_order memory_order_release = memory_order::release;       // freestanding
+  inline constexpr memory_order memory_order_acq_rel = memory_order::acq_rel;       // freestanding
+  inline constexpr memory_order memory_order_seq_cst = memory_order::seq_cst;       // freestanding
+  template<class T>
+    T kill_dependency(T y) noexcept;                                                // freestanding
+}
+// [atomics.lockfree], lock-free property
+#define ATOMIC_BOOL_LOCK_FREE unspecified                                           // freestanding
+#define ATOMIC_CHAR_LOCK_FREE unspecified                                           // freestanding
+#define ATOMIC_CHAR8_T_LOCK_FREE unspecified                                        // freestanding
+#define ATOMIC_CHAR16_T_LOCK_FREE unspecified                                       // freestanding
+#define ATOMIC_CHAR32_T_LOCK_FREE unspecified                                       // freestanding
+#define ATOMIC_WCHAR_T_LOCK_FREE unspecified                                        // freestanding
+#define ATOMIC_SHORT_LOCK_FREE unspecified                                          // freestanding
+#define ATOMIC_INT_LOCK_FREE unspecified                                            // freestanding
+#define ATOMIC_LONG_LOCK_FREE unspecified                                           // freestanding
+#define ATOMIC_LLONG_LOCK_FREE unspecified                                          // freestanding
+#define ATOMIC_POINTER_LOCK_FREE unspecified                                        // freestanding
+namespace std {
+  // [atomics.ref.generic], class template atomic_ref
+  template<class T> struct atomic_ref;                                              // freestanding
+  // [atomics.ref.pointer], partial specialization for pointers
+  template<class T> struct atomic_ref<T*>;                                          // freestanding
+  // [atomics.types.generic], class template atomic
+  template<class T> struct atomic;                                                  // freestanding
+  // [atomics.types.pointer], partial specialization for pointers
+  template<class T> struct atomic<T*>;                                              // freestanding
+  // [atomics.nonmembers], non-member functions
+  template<class T>
+    bool atomic_is_lock_free(const volatile atomic<T>*) noexcept;                   // freestanding
+  template<class T>
+    bool atomic_is_lock_free(const atomic<T>*) noexcept;                            // freestanding
+  template<class T>
+    void atomic_store(volatile atomic<T>*,                                          // freestanding
+                      typename atomic<T>::value_type) noexcept;
+  template<class T>
+    void atomic_store(atomic<T>*, typename atomic<T>::value_type) noexcept;         // freestanding
+  template<class T>
+    void atomic_store_explicit(volatile atomic<T>*,                                 // freestanding
+                               typename atomic<T>::value_type,
+                               memory_order) noexcept;
+  template<class T>
+    void atomic_store_explicit(atomic<T>*, typename atomic<T>::value_type,          // freestanding
+                               memory_order) noexcept;
+  template<class T>
+    T atomic_load(const volatile atomic<T>*) noexcept;                              // freestanding
+  template<class T>
+    T atomic_load(const atomic<T>*) noexcept;                                       // freestanding
+  template<class T>
+    T atomic_load_explicit(const volatile atomic<T>*, memory_order) noexcept;       // freestanding
+  template<class T>
+    T atomic_load_explicit(const atomic<T>*, memory_order) noexcept;                // freestanding
+  template<class T>
+    T atomic_exchange(volatile atomic<T>*,                                          // freestanding
+                      typename atomic<T>::value_type) noexcept;
+  template<class T>
+    T atomic_exchange(atomic<T>*, typename atomic<T>::value_type) noexcept;         // freestanding
+  template<class T>
+    T atomic_exchange_explicit(volatile atomic<T>*,                                 // freestanding
+                               typename atomic<T>::value_type,
+                               memory_order) noexcept;
+  template<class T>
+    T atomic_exchange_explicit(atomic<T>*, typename atomic<T>::value_type,          // freestanding
+                               memory_order) noexcept;
+  template<class T>
+    bool atomic_compare_exchange_weak(volatile atomic<T>*,                          // freestanding
+                                      typename atomic<T>::value_type*,
+                                      typename atomic<T>::value_type) noexcept;
+  template<class T>
+    bool atomic_compare_exchange_weak(atomic<T>*,                                   // freestanding
+                                      typename atomic<T>::value_type*,
+                                      typename atomic<T>::value_type) noexcept;
+  template<class T>
+    bool atomic_compare_exchange_strong(volatile atomic<T>*,                        // freestanding
+                                        typename atomic<T>::value_type*,
+                                        typename atomic<T>::value_type) noexcept;
+  template<class T>
+    bool atomic_compare_exchange_strong(atomic<T>*,                                 // freestanding
+                                        typename atomic<T>::value_type*,
+                                        typename atomic<T>::value_type) noexcept;
+  template<class T>
+    bool atomic_compare_exchange_weak_explicit(volatile atomic<T>*,                 // freestanding
+                                               typename atomic<T>::value_type*,
+                                               typename atomic<T>::value_type,
+                                               memory_order, memory_order) noexcept;
+  template<class T>
+    bool atomic_compare_exchange_weak_explicit(atomic<T>*,                          // freestanding
+                                               typename atomic<T>::value_type*,
+                                               typename atomic<T>::value_type,
+                                               memory_order, memory_order) noexcept;
+  template<class T>
+    bool atomic_compare_exchange_strong_explicit(volatile atomic<T>*,               // freestanding
+                                                 typename atomic<T>::value_type*,
+                                                 typename atomic<T>::value_type,
+                                                 memory_order, memory_order) noexcept;
+  template<class T>
+    bool atomic_compare_exchange_strong_explicit(atomic<T>*,                        // freestanding
+                                                 typename atomic<T>::value_type*,
+                                                 typename atomic<T>::value_type,
+                                                 memory_order, memory_order) noexcept;
+  template<class T>
+    T atomic_fetch_add(volatile atomic<T>*,                                         // freestanding
+                       typename atomic<T>::difference_type) noexcept;
+  template<class T>
+    T atomic_fetch_add(atomic<T>*, typename atomic<T>::difference_type) noexcept;   // freestanding
+  template<class T>
+    T atomic_fetch_add_explicit(volatile atomic<T>*,                                // freestanding
+                                typename atomic<T>::difference_type,
+                                memory_order) noexcept;
+  template<class T>
+    T atomic_fetch_add_explicit(atomic<T>*, typename atomic<T>::difference_type,    // freestanding
+                                memory_order) noexcept;
+  template<class T>
+    T atomic_fetch_sub(volatile atomic<T>*,                                         // freestanding
+                       typename atomic<T>::difference_type) noexcept;
+  template<class T>
+    T atomic_fetch_sub(atomic<T>*, typename atomic<T>::difference_type) noexcept;   // freestanding
+  template<class T>
+    T atomic_fetch_sub_explicit(volatile atomic<T>*,                                // freestanding
+                                typename atomic<T>::difference_type,
+                                memory_order) noexcept;
+  template<class T>
+    T atomic_fetch_sub_explicit(atomic<T>*, typename atomic<T>::difference_type,    // freestanding
+                                memory_order) noexcept;
+  template<class T>
+    T atomic_fetch_and(volatile atomic<T>*,                                         // freestanding
+                       typename atomic<T>::value_type) noexcept;
+  template<class T>
+    T atomic_fetch_and(atomic<T>*, typename atomic<T>::value_type) noexcept;        // freestanding
+  template<class T>
+    T atomic_fetch_and_explicit(volatile atomic<T>*,                                // freestanding
+                                typename atomic<T>::value_type,
+                                memory_order) noexcept;
+  template<class T>
+    T atomic_fetch_and_explicit(atomic<T>*, typename atomic<T>::value_type,         // freestanding
+                                memory_order) noexcept;
+  template<class T>
+    T atomic_fetch_or(volatile atomic<T>*,                                          // freestanding
+                      typename atomic<T>::value_type) noexcept;
+  template<class T>
+    T atomic_fetch_or(atomic<T>*, typename atomic<T>::value_type) noexcept;         // freestanding
+  template<class T>
+    T atomic_fetch_or_explicit(volatile atomic<T>*,                                 // freestanding
+                               typename atomic<T>::value_type,
+                               memory_order) noexcept;
+  template<class T>
+    T atomic_fetch_or_explicit(atomic<T>*, typename atomic<T>::value_type,          // freestanding
+                               memory_order) noexcept;
+  template<class T>
+    T atomic_fetch_xor(volatile atomic<T>*,                                         // freestanding
+                       typename atomic<T>::value_type) noexcept;
+  template<class T>
+    T atomic_fetch_xor(atomic<T>*, typename atomic<T>::value_type) noexcept;        // freestanding
+  template<class T>
+    T atomic_fetch_xor_explicit(volatile atomic<T>*,                                // freestanding
+                                typename atomic<T>::value_type,
+                                memory_order) noexcept;
+  template<class T>
+    T atomic_fetch_xor_explicit(atomic<T>*, typename atomic<T>::value_type,         // freestanding
+                                memory_order) noexcept;
+  template<class T>
+    void atomic_wait(const volatile atomic<T>*,                                     // freestanding
+                 typename atomic<T>::value_type) noexcept;
+  template<class T>
+    void atomic_wait(const atomic<T>*, typename atomic<T>::value_type) noexcept;    // freestanding
+  template<class T>
+    void atomic_wait_explicit(const volatile atomic<T>*,                            // freestanding
+                              typename atomic<T>::value_type,
+                              memory_order) noexcept;
+  template<class T>
+    void atomic_wait_explicit(const atomic<T>*, typename atomic<T>::value_type,     // freestanding
+                              memory_order) noexcept;
+  template<class T>
+    void atomic_notify_one(volatile atomic<T>*) noexcept;                           // freestanding
+  template<class T>
+    void atomic_notify_one(atomic<T>*) noexcept;                                    // freestanding
+  template<class T>
+    void atomic_notify_all(volatile atomic<T>*) noexcept;                           // freestanding
+  template<class T>
+    void atomic_notify_all(atomic<T>*) noexcept;                                    // freestanding
+  // [atomics.alias], type aliases
+  using atomic_bool           = atomic<bool>;                                       // freestanding
+  using atomic_char           = atomic<char>;                                       // freestanding
+  using atomic_schar          = atomic<signed char>;                                // freestanding
+  using atomic_uchar          = atomic<unsigned char>;                              // freestanding
+  using atomic_short          = atomic<short>;                                      // freestanding
+  using atomic_ushort         = atomic<unsigned short>;                             // freestanding
+  using atomic_int            = atomic<int>;                                        // freestanding
+  using atomic_uint           = atomic<unsigned int>;                               // freestanding
+  using atomic_long           = atomic<long>;                                       // freestanding
+  using atomic_ulong          = atomic<unsigned long>;                              // freestanding
+  using atomic_llong          = atomic<long long>;                                  // freestanding
+  using atomic_ullong         = atomic<unsigned long long>;                         // freestanding
+  using atomic_char8_t        = atomic<char8_t>;                                    // freestanding
+  using atomic_char16_t       = atomic<char16_t>;                                   // freestanding
+  using atomic_char32_t       = atomic<char32_t>;                                   // freestanding
+  using atomic_wchar_t        = atomic<wchar_t>;                                    // freestanding
+  using atomic_int8_t         = atomic<int8_t>;                                     // freestanding
+  using atomic_uint8_t        = atomic<uint8_t>;                                    // freestanding
+  using atomic_int16_t        = atomic<int16_t>;                                    // freestanding
+  using atomic_uint16_t       = atomic<uint16_t>;                                   // freestanding
+  using atomic_int32_t        = atomic<int32_t>;                                    // freestanding
+  using atomic_uint32_t       = atomic<uint32_t>;                                   // freestanding
+  using atomic_int64_t        = atomic<int64_t>;                                    // freestanding
+  using atomic_uint64_t       = atomic<uint64_t>;                                   // freestanding
+  using atomic_int_least8_t   = atomic<int_least8_t>;                               // freestanding
+  using atomic_uint_least8_t  = atomic<uint_least8_t>;                              // freestanding
+  using atomic_int_least16_t  = atomic<int_least16_t>;                              // freestanding
+  using atomic_uint_least16_t = atomic<uint_least16_t>;                             // freestanding
+  using atomic_int_least32_t  = atomic<int_least32_t>;                              // freestanding
+  using atomic_uint_least32_t = atomic<uint_least32_t>;                             // freestanding
+  using atomic_int_least64_t  = atomic<int_least64_t>;                              // freestanding
+  using atomic_uint_least64_t = atomic<uint_least64_t>;                             // freestanding
+  using atomic_int_fast8_t    = atomic<int_fast8_t>;                                // freestanding
+  using atomic_uint_fast8_t   = atomic<uint_fast8_t>;                               // freestanding
+  using atomic_int_fast16_t   = atomic<int_fast16_t>;                               // freestanding
+  using atomic_uint_fast16_t  = atomic<uint_fast16_t>;                              // freestanding
+  using atomic_int_fast32_t   = atomic<int_fast32_t>;                               // freestanding
+  using atomic_uint_fast32_t  = atomic<uint_fast32_t>;                              // freestanding
+  using atomic_int_fast64_t   = atomic<int_fast64_t>;                               // freestanding
+  using atomic_uint_fast64_t  = atomic<uint_fast64_t>;                              // freestanding
+  using atomic_intptr_t       = atomic<intptr_t>;                                   // freestanding
+  using atomic_uintptr_t      = atomic<uintptr_t>;                                  // freestanding
+  using atomic_size_t         = atomic<size_t>;                                     // freestanding
+  using atomic_ptrdiff_t      = atomic<ptrdiff_t>;                                  // freestanding
+  using atomic_intmax_t       = atomic<intmax_t>;                                   // freestanding
+  using atomic_uintmax_t      = atomic<uintmax_t>;                                  // freestanding
+  using atomic_signed_lock_free   = see below;
+  using atomic_unsigned_lock_free = see below;
+  // [atomics.flag], flag type and operations
+  struct atomic_flag;                                                               // freestanding
+  bool atomic_flag_test(const volatile atomic_flag*) noexcept;                      // freestanding
+  bool atomic_flag_test(const atomic_flag*) noexcept;                               // freestanding
+  bool atomic_flag_test_explicit(const volatile atomic_flag*,                       // freestanding
+                                 memory_order) noexcept;
+  bool atomic_flag_test_explicit(const atomic_flag*, memory_order) noexcept;        // freestanding
+  bool atomic_flag_test_and_set(volatile atomic_flag*) noexcept;                    // freestanding
+  bool atomic_flag_test_and_set(atomic_flag*) noexcept;                             // freestanding
+  bool atomic_flag_test_and_set_explicit(volatile atomic_flag*,                     // freestanding
+                                         memory_order) noexcept;
+  bool atomic_flag_test_and_set_explicit(atomic_flag*, memory_order) noexcept;      // freestanding
+  void atomic_flag_clear(volatile atomic_flag*) noexcept;                           // freestanding
+  void atomic_flag_clear(atomic_flag*) noexcept;                                    // freestanding
+  void atomic_flag_clear_explicit(volatile atomic_flag*, memory_order) noexcept;    // freestanding
+  void atomic_flag_clear_explicit(atomic_flag*, memory_order) noexcept;             // freestanding
+  void atomic_flag_wait(const volatile atomic_flag*, bool) noexcept;                // freestanding
+  void atomic_flag_wait(const atomic_flag*, bool) noexcept;                         // freestanding
+  void atomic_flag_wait_explicit(const volatile atomic_flag*,                       // freestanding
+                                 bool, memory_order) noexcept;
+  void atomic_flag_wait_explicit(const atomic_flag*,                                // freestanding
+                                 bool, memory_order) noexcept;
+  void atomic_flag_notify_one(volatile atomic_flag*) noexcept;                      // freestanding
+  void atomic_flag_notify_one(atomic_flag*) noexcept;                               // freestanding
+  void atomic_flag_notify_all(volatile atomic_flag*) noexcept;                      // freestanding
+  void atomic_flag_notify_all(atomic_flag*) noexcept;                               // freestanding
+  #define ATOMIC_FLAG_INIT see belownc                                                // freestanding
+  // [atomics.fences], fences
+  extern "C" void atomic_thread_fence(memory_order) noexcept;                       // freestanding
+  extern "C" void atomic_signal_fence(memory_order) noexcept;                       // freestanding
+}
+```
+### Type aliases <a id="atomics.alias">[[atomics.alias]]</a>
+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` name specializations of `atomic` whose
+template arguments are integral types, respectively signed and unsigned,
+and whose `is_always_lock_free` property is `true`.
+[*Note 1*:  These aliases are optional in freestanding implementations
+[[compliance]]. — *end note*]
+Implementations should choose for these aliases the integral
+specializations of `atomic` for which the atomic waiting and notifying
+operations [[atomics.wait]] are most efficient.
+### Order and consistency <a id="atomics.order">[[atomics.order]]</a>
+``` cpp
+namespace std {
+  enum class memory_order : unspecified {
+    relaxed, consume, acquire, release, acq_rel, seq_cst
+  };
+}
+```
+The enumeration `memory_order` specifies the detailed regular
+(non-atomic) memory synchronization order as defined in
+[[intro.multithread]] and may provide for operation ordering. Its
+enumerated values and their meanings are as follows:
+- `memory_order::relaxed`: no operation orders memory.
+- `memory_order::release`, `memory_order::acq_rel`, and
+  `memory_order::seq_cst`: a store operation performs a release
+  operation on the affected memory location.
+- `memory_order::consume`: a load operation performs a consume operation
+  on the affected memory location. \[*Note 1*: Prefer
+  `memory_order::acquire`, which provides stronger guarantees than
+  `memory_order::consume`. Implementations have found it infeasible to
+  provide performance better than that of `memory_order::acquire`.
+  Specification revisions are under consideration. — *end note*]
+- `memory_order::acquire`, `memory_order::acq_rel`, and
+  `memory_order::seq_cst`: a load operation performs an acquire
+  operation on the affected memory location.
+[*Note 2*: Atomic operations specifying `memory_order::relaxed` are
+relaxed with respect to memory ordering. Implementations must still
+guarantee that any given atomic access to a particular atomic object be
+indivisible with respect to all other atomic accesses to that
+object. — *end note*]
+An atomic operation A that performs a release operation on an atomic
+object M synchronizes with an atomic operation B that performs an
+acquire operation on M and takes its value from any side effect in the
+release sequence headed by A.
+An atomic operation A on some atomic object M is *coherence-ordered
+before* another atomic operation B on M if
+- A is a modification, and B reads the value stored by A, or
+- A precedes B in the modification order of M, or
+- A and B are not the same atomic read-modify-write operation, and there
+  exists an atomic modification X of M such that A reads the value
+  stored by X and X precedes B in the modification order of M, or
+- there exists an atomic modification X of M such that A is
+  coherence-ordered before X and X is coherence-ordered before B.
+There is a single total order S on all `memory_order::seq_cst`
+operations, including fences, that satisfies the following constraints.
+First, if A and B are `memory_order::seq_cst` operations and A strongly
+happens before B, then A precedes B in S. Second, for every pair of
+atomic operations A and B on an object M, where A is coherence-ordered
+before B, the following four conditions are required to be satisfied by
+S:
+- if A and B are both `memory_order::seq_cst` operations, then A
+  precedes B in S; and
+- if A is a `memory_order::seq_cst` operation and B happens before a
+  `memory_order::seq_cst` fence Y, then A precedes Y in S; and
+- if a `memory_order::seq_cst` fence X happens before A and B is a
+  `memory_order::seq_cst` operation, then X precedes B in S; and
+- if a `memory_order::seq_cst` fence X happens before A and B happens
+  before a `memory_order::seq_cst` fence Y, then X precedes Y in S.
+[*Note 3*: This definition ensures that S is consistent with the
+modification order of any atomic object M. It also ensures that a
+`memory_order::seq_cst` load A of M gets its value either from the last
+modification of M that precedes A in S or from some
+non-`memory_order::seq_cst` modification of M that does not happen
+before any modification of M that precedes A in S. — *end note*]
+[*Note 4*: We do not require that S be consistent with “happens before”
+[[intro.races]]. This allows more efficient implementation of
+`memory_order::acquire` and `memory_order::release` on some machine
+architectures. It can produce surprising results when these are mixed
+with `memory_order::seq_cst` accesses. — *end note*]
+[*Note 5*: `memory_order::seq_cst` ensures sequential consistency only
+for a program that is free of data races and uses exclusively
+`memory_order::seq_cst` atomic operations. Any use of weaker ordering
+will invalidate this guarantee unless extreme care is used. In many
+cases, `memory_order::seq_cst` atomic operations are reorderable with
+respect to other atomic operations performed by the same
+thread. — *end note*]
+Implementations should ensure that no “out-of-thin-air” values are
+computed that circularly depend on their own computation.
+[*Note 6*:
+For example, with `x` and `y` initially zero,
+``` cpp
+// Thread 1:
+r1 = y.load(memory_order::relaxed);
+x.store(r1, memory_order::relaxed);
+```
+``` cpp
+// Thread 2:
+r2 = x.load(memory_order::relaxed);
+y.store(r2, memory_order::relaxed);
+```
+this recommendation discourages producing `r1 == r2 == 42`, since the
+store of 42 to `y` is only possible if the store to `x` stores `42`,
+which circularly depends on the store to `y` storing `42`. Note that
+without this restriction, such an execution is possible.
+— *end note*]
+[*Note 7*:
+The recommendation similarly disallows `r1 == r2 == 42` in the following
+example, with `x` and `y` again initially zero:
+``` cpp
+// Thread 1:
+r1 = x.load(memory_order::relaxed);
+if (r1 == 42) y.store(42, memory_order::relaxed);
+```
+``` cpp
+// Thread 2:
+r2 = y.load(memory_order::relaxed);
+if (r2 == 42) x.store(42, memory_order::relaxed);
+```
+— *end note*]
+Atomic read-modify-write operations shall always read the last value (in
+the modification order) written before the write associated with the
+read-modify-write operation.
+Implementations should make atomic stores visible to atomic loads within
+a reasonable amount of time.
+``` cpp
+template<class T>
+  T kill_dependency(T y) noexcept;
+```
+*Effects:* The argument does not carry a dependency to the return
+value [[intro.multithread]].
+*Returns:* `y`.
+### Lock-free property <a id="atomics.lockfree">[[atomics.lockfree]]</a>
+``` cpp
+#define ATOMIC_BOOL_LOCK_FREE unspecified
+#define ATOMIC_CHAR_LOCK_FREE unspecified
+#define ATOMIC_CHAR8_T_LOCK_FREE unspecified
+#define ATOMIC_CHAR16_T_LOCK_FREE unspecified
+#define ATOMIC_CHAR32_T_LOCK_FREE unspecified
+#define ATOMIC_WCHAR_T_LOCK_FREE unspecified
+#define ATOMIC_SHORT_LOCK_FREE unspecified
+#define ATOMIC_INT_LOCK_FREE unspecified
+#define ATOMIC_LONG_LOCK_FREE unspecified
+#define ATOMIC_LLONG_LOCK_FREE unspecified
+#define ATOMIC_POINTER_LOCK_FREE unspecified
+```
+The `ATOMIC_..._LOCK_FREE` macros indicate the lock-free property of the
+corresponding atomic types, with the signed and unsigned variants
+grouped together. The properties also apply to the corresponding
+(partial) specializations of the `atomic` template. A value of 0
+indicates that the types are never lock-free. A value of 1 indicates
+that the types are sometimes lock-free. A value of 2 indicates that the
+types are always lock-free.
+On a hosted implementation [[compliance]], at least one signed integral
+specialization of the `atomic` template, along with the specialization
+for the corresponding unsigned type [[basic.fundamental]], is always
+lock-free.
+The functions `atomic<T>::is_lock_free` and `atomic_is_lock_free`
+[[atomics.types.operations]] indicate whether the object is lock-free.
+In any given program execution, the result of the lock-free query is the
+same for all atomic objects of the same type.
+Atomic operations that are not lock-free are considered to potentially
+block [[intro.progress]].
+*Recommended practice:* Operations that are lock-free should also be
+address-free.[^2]
+The implementation of these operations should not depend on any
+per-process state.
+[*Note 1*: This restriction enables communication by memory that is
+mapped into a process more than once and by memory that is shared
+between two processes. — *end note*]
+### Waiting and notifying <a id="atomics.wait">[[atomics.wait]]</a>
+*Atomic waiting operations* and *atomic notifying operations* provide a
+mechanism to wait for the value of an atomic object to change more
+efficiently than can be achieved with polling. An atomic waiting
+operation may block until it is unblocked by an atomic notifying
+operation, according to each function’s effects.
+[*Note 1*: 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*]
+[*Note 2*:
+The following functions are atomic waiting operations:
+- `atomic<T>::wait`,
+- `atomic_flag::wait`,
+- `atomic_wait` and `atomic_wait_explicit`,
+- `atomic_flag_wait` and `atomic_flag_wait_explicit`, and
+- `atomic_ref<T>::wait`.
+— *end note*]
+[*Note 3*:
+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_all`,
+- `atomic_flag_notify_one` and `atomic_flag_notify_all`, and
+- `atomic_ref<T>::notify_one` and `atomic_ref<T>::notify_all`.
+— *end note*]
+A call to an atomic waiting operation on an atomic object `M` is
+*eligible to be unblocked* by a call to an atomic notifying operation on
+`M` if there exist side effects `X` and `Y` on `M` such that:
+- the atomic waiting operation has blocked after observing the result of
+  `X`,
+- `X` precedes `Y` in the modification order of `M`, and
+- `Y` happens before the call to the atomic notifying operation.
+### Class template `atomic_ref` <a id="atomics.ref.generic">[[atomics.ref.generic]]</a>
+#### General <a id="atomics.ref.generic.general">[[atomics.ref.generic.general]]</a>
+``` cpp
+namespace std {
+  template<class T> struct atomic_ref {
+  private:
+    T* ptr;             // exposition only
+  public:
+    using value_type = T;
+    static constexpr size_t required_alignment = implementation-defined  // required alignment for atomic_ref type's operations;
+    static constexpr bool is_always_lock_free = implementation-defined  // whether a given atomic_ref type's operations are always lock free;
+    bool is_lock_free() const noexcept;
+    explicit atomic_ref(T&);
+    atomic_ref(const atomic_ref&) noexcept;
+    atomic_ref& operator=(const atomic_ref&) = delete;
+    void store(T, memory_order = memory_order::seq_cst) const noexcept;
+    T operator=(T) const noexcept;
+    T load(memory_order = memory_order::seq_cst) const noexcept;
+    operator T() const noexcept;
+    T exchange(T, memory_order = memory_order::seq_cst) const noexcept;
+    bool compare_exchange_weak(T&, T,
+                               memory_order, memory_order) const noexcept;
+    bool compare_exchange_strong(T&, T,
+                                 memory_order, memory_order) const noexcept;
+    bool compare_exchange_weak(T&, T,
+                               memory_order = memory_order::seq_cst) const noexcept;
+    bool compare_exchange_strong(T&, T,
+                                 memory_order = memory_order::seq_cst) const noexcept;
+    void wait(T, memory_order = memory_order::seq_cst) const noexcept;
+    void notify_one() const noexcept;
+    void notify_all() const noexcept;
+  };
+}
+```
+An `atomic_ref` object applies atomic operations [[atomics.general]] to
+the object referenced by `*ptr` such that, for the lifetime
+[[basic.life]] of the `atomic_ref` object, the object referenced by
+`*ptr` is an atomic object [[intro.races]].
+The program is ill-formed if `is_trivially_copyable_v<T>` is `false`.
+The lifetime [[basic.life]] of an object referenced by `*ptr` shall
+exceed the lifetime of all `atomic_ref`s that reference the object.
+While any `atomic_ref` instances exist that reference the `*ptr` object,
+all accesses to that object shall exclusively occur through those
+`atomic_ref` instances. No subobject of the object referenced by
+`atomic_ref` shall be concurrently referenced by any other `atomic_ref`
+object.
+Atomic operations applied to an object through a referencing
+`atomic_ref` are atomic with respect to atomic operations applied
+through any other `atomic_ref` referencing the same object.
+[*Note 1*: Atomic operations or the `atomic_ref` constructor can
+acquire a shared resource, such as a lock associated with the referenced
+object, to enable atomic operations to be applied to the referenced
+object. — *end note*]
+#### Operations <a id="atomics.ref.ops">[[atomics.ref.ops]]</a>
+``` cpp
+static constexpr size_t required_alignment;
+```
+The alignment required for an object to be referenced by an atomic
+reference, which is at least `alignof(T)`.
+[*Note 1*: Hardware could require an object referenced by an
+`atomic_ref` to have stricter alignment [[basic.align]] than other
+objects of type `T`. Further, whether operations on an `atomic_ref` are
+lock-free could depend on the alignment of the referenced object. For
+example, lock-free operations on `std::complex<double>` could be
+supported only if aligned to `2*alignof(double)`. — *end note*]
+``` cpp
+static constexpr bool is_always_lock_free;
+```
+The static data member `is_always_lock_free` is `true` if the
+`atomic_ref` type’s operations are always lock-free, and `false`
+otherwise.
+``` cpp
+bool is_lock_free() const noexcept;
+```
+*Returns:* `true` if operations on all objects of the type
+`atomic_ref<T>` are lock-free, `false` otherwise.
+``` cpp
+atomic_ref(T& obj);
+```
+*Preconditions:* The referenced object is aligned to
+`required_alignment`.
+*Ensures:* `*this` references `obj`.
+*Throws:* Nothing.
+``` cpp
+atomic_ref(const atomic_ref& ref) noexcept;
+```
+*Ensures:* `*this` references the object referenced by `ref`.
+``` cpp
+void store(T desired, memory_order order = memory_order::seq_cst) const noexcept;
+```
+*Preconditions:* The `order` argument is neither
+`memory_order::consume`, `memory_order::acquire`, nor
+`memory_order::acq_rel`.
+*Effects:* Atomically replaces the value referenced by `*ptr` with the
+value of `desired`. Memory is affected according to the value of
+`order`.
+``` cpp
+T operator=(T desired) const noexcept;
+```
+*Effects:* Equivalent to:
+``` cpp
+store(desired);
+return desired;
+```
+``` cpp
+T load(memory_order order = memory_order::seq_cst) const noexcept;
+```
+*Preconditions:* The `order` argument is neither `memory_order::release`
+nor `memory_order::acq_rel`.
+*Effects:* Memory is affected according to the value of `order`.
+*Returns:* Atomically returns the value referenced by `*ptr`.
+``` cpp
+operator T() const noexcept;
+```
+*Effects:* Equivalent to: `return load();`
+``` cpp
+T exchange(T desired, memory_order order = memory_order::seq_cst) const noexcept;
+```
+*Effects:* Atomically replaces the value referenced by `*ptr` with
+`desired`. Memory is affected according to the value of `order`. This
+operation is an atomic read-modify-write
+operation [[intro.multithread]].
+*Returns:* Atomically returns the value referenced by `*ptr` immediately
+before the effects.
+``` cpp
+bool compare_exchange_weak(T& expected, T desired,
+                           memory_order success, memory_order failure) const noexcept;
+bool compare_exchange_strong(T& expected, T desired,
+                             memory_order success, memory_order failure) const noexcept;
+bool compare_exchange_weak(T& expected, T desired,
+                           memory_order order = memory_order::seq_cst) const noexcept;
+bool compare_exchange_strong(T& expected, T desired,
+                             memory_order order = memory_order::seq_cst) const noexcept;
+```
+*Preconditions:* The `failure` argument is neither
+`memory_order::release` nor `memory_order::acq_rel`.
+*Effects:* Retrieves the value in `expected`. It then atomically
+compares the value representation of the value referenced by `*ptr` for
+equality with that previously retrieved from `expected`, and if `true`,
+replaces the value referenced by `*ptr` with that in `desired`. If and
+only if the comparison is `true`, memory is affected according to the
+value of `success`, and if the comparison is `false`, memory is affected
+according to the value of `failure`. When only one `memory_order`
+argument is supplied, the value of `success` is `order`, and the value
+of `failure` is `order` except that a value of `memory_order::acq_rel`
+shall be replaced by the value `memory_order::acquire` and a value of
+`memory_order::release` shall be replaced by the value
+`memory_order::relaxed`. If and only if the comparison is `false` then,
+after the atomic operation, the value in `expected` is replaced by the
+value read from the value referenced by `*ptr` during the atomic
+comparison. If the operation returns `true`, these operations are atomic
+read-modify-write operations [[intro.races]] on the value referenced by
+`*ptr`. Otherwise, these operations are atomic load operations on that
+memory.
+*Returns:* The result of the comparison.
+*Remarks:* A weak compare-and-exchange operation may fail spuriously.
+That is, even when the contents of memory referred to by `expected` and
+`ptr` are equal, it may return `false` and store back to `expected` the
+same memory contents that were originally there.
+[*Note 2*: This spurious failure enables implementation of
+compare-and-exchange on a broader class of machines, e.g., load-locked
+store-conditional machines. A consequence of spurious failure is that
+nearly all uses of weak compare-and-exchange will be in a loop. When a
+compare-and-exchange is in a loop, the weak version will yield better
+performance on some platforms. When a weak compare-and-exchange would
+require a loop and a strong one would not, the strong one is
+preferable. — *end note*]
+``` cpp
+void wait(T old, memory_order order = memory_order::seq_cst) const noexcept;
+```
+*Preconditions:* `order` is neither `memory_order::release` nor
+`memory_order::acq_rel`.
+*Effects:* Repeatedly performs the following steps, in order:
+- Evaluates `load(order)` and compares its value representation for
+  equality against that of `old`.
+- If they compare unequal, returns.
+- Blocks until it is unblocked by an atomic notifying operation or is
+  unblocked spuriously.
+*Remarks:* This function is an atomic waiting operation [[atomics.wait]]
+on atomic object `*ptr`.
+``` cpp
+void notify_one() const noexcept;
+```
+*Effects:* Unblocks the execution of at least one atomic waiting
+operation on `*ptr` that is eligible to be unblocked [[atomics.wait]] by
+this call, if any such atomic waiting operations exist.
+*Remarks:* This function is an atomic notifying
+operation [[atomics.wait]] on atomic object `*ptr`.
+``` cpp
+void notify_all() const noexcept;
+```
+*Effects:* Unblocks the execution of all atomic waiting operations on
+`*ptr` that are eligible to be unblocked [[atomics.wait]] by this call.
+*Remarks:* This function is an atomic notifying
+operation [[atomics.wait]] on atomic object `*ptr`.
+#### Specializations for integral types <a id="atomics.ref.int">[[atomics.ref.int]]</a>
+There are specializations of the `atomic_ref` class template for the
+integral types `char`, `signed char`, `unsigned char`, `short`,
+`unsigned short`, `int`, `unsigned int`, `long`, `unsigned long`,
+`long long`, `unsigned long long`, `char8_t`, `char16_t`, `char32_t`,
+`wchar_t`, and any other types needed by the typedefs in the header
+`<cstdint>`. For each such type `integral-type`, the specialization
+`atomic_ref<integral-type>` provides additional atomic operations
+appropriate to integral types.
+[*Note 1*: The specialization `atomic_ref<bool>` uses the primary
+template [[atomics.ref.generic]]. — *end note*]
+``` cpp
+namespace std {
+  template<> struct atomic_ref<integral-type> {
+  private:
+    integral-type* ptr;         // exposition only
+  public:
+    using value_type = integral-type;
+    using difference_type = value_type;
+    static constexpr size_t required_alignment = implementation-defined  // required alignment for atomic_ref type's operations;
+    static constexpr bool is_always_lock_free = implementation-defined  // whether a given atomic_ref type's operations are always lock free;
+    bool is_lock_free() const noexcept;
+    explicit atomic_ref(integral-type&);
+    atomic_ref(const atomic_ref&) noexcept;
+    atomic_ref& operator=(const atomic_ref&) = delete;
+    void store(integral-type, memory_order = memory_order::seq_cst) const noexcept;
+    integral-type operator=(integral-type) const noexcept;
+    integral-type load(memory_order = memory_order::seq_cst) const noexcept;
+    operator integral-type() const noexcept;
+    integral-type exchange(integral-type,
+                           memory_order = memory_order::seq_cst) const noexcept;
+    bool compare_exchange_weak(integral-type&, integral-type,
+                               memory_order, memory_order) const noexcept;
+    bool compare_exchange_strong(integral-type&, integral-type,
+                                 memory_order, memory_order) const noexcept;
+    bool compare_exchange_weak(integral-type&, integral-type,
+                               memory_order = memory_order::seq_cst) const noexcept;
+    bool compare_exchange_strong(integral-type&, integral-type,
+                                 memory_order = memory_order::seq_cst) const noexcept;
+    integral-type fetch_add(integral-type,
+                            memory_order = memory_order::seq_cst) const noexcept;
+    integral-type fetch_sub(integral-type,
+                            memory_order = memory_order::seq_cst) const noexcept;
+    integral-type fetch_and(integral-type,
+                            memory_order = memory_order::seq_cst) const noexcept;
+    integral-type fetch_or(integral-type,
+                            memory_order = memory_order::seq_cst) const noexcept;
+    integral-type fetch_xor(integral-type,
+                            memory_order = memory_order::seq_cst) const noexcept;
+    integral-type operator++(int) const noexcept;
+    integral-type operator--(int) const noexcept;
+    integral-type operator++() const noexcept;
+    integral-type operator--() const noexcept;
+    integral-type operator+=(integral-type) const noexcept;
+    integral-type operator-=(integral-type) const noexcept;
+    integral-type operator&=(integral-type) const noexcept;
+    integral-type operator|=(integral-type) const noexcept;
+    integral-type operator^=(integral-type) const noexcept;
+    void wait(integral-type, memory_order = memory_order::seq_cst) const noexcept;
+    void notify_one() const noexcept;
+    void notify_all() const noexcept;
+  };
+}
+```
+Descriptions are provided below only for members that differ from the
+primary template.
+The following operations perform arithmetic computations. The
+correspondence among key, operator, and computation is specified in
+[[atomic.types.int.comp]].
+``` cpp
+integral-type fetch_key(integral-type operand,
+  memory_order order = memory_order::seq_cst) const noexcept;
+```
+*Effects:* Atomically replaces the value referenced by `*ptr` with the
+result of the computation applied to the value referenced by `*ptr` and
+the given operand. Memory is affected according to the value of `order`.
+These operations are atomic read-modify-write
+operations [[intro.races]].
+*Returns:* Atomically, the value referenced by `*ptr` immediately before
+the effects.
+*Remarks:* For signed integer types, the result is as if the object
+value and parameters were converted to their corresponding unsigned
+types, the computation performed on those types, and the result
+converted back to the signed type.
+[*Note 1*: There are no undefined results arising from the
+computation. — *end note*]
+``` cpp
+integral-type operator op=(integral-type operand) const noexcept;
+```
+*Effects:* Equivalent to:
+`return fetch_`*`key`*`(operand) `*`op`*` operand;`
+#### Specializations for floating-point types <a id="atomics.ref.float">[[atomics.ref.float]]</a>
+There are specializations of the `atomic_ref` class template for all
+cv-unqualified floating-point types. For each such type
+`floating-point-type`, the specialization `atomic_ref<floating-point>`
+provides additional atomic operations appropriate to floating-point
+types.
+``` cpp
+namespace std {
+  template<> struct atomic_ref<floating-point-type> {
+  private:
+    floating-point-type* ptr;   // exposition only
+  public:
+    using value_type = floating-point-type;
+    using difference_type = value_type;
+    static constexpr size_t required_alignment = implementation-defined  // required alignment for atomic_ref type's operations;
+    static constexpr bool is_always_lock_free = implementation-defined  // whether a given atomic_ref type's operations are always lock free;
+    bool is_lock_free() const noexcept;
+    explicit atomic_ref(floating-point-type&);
+    atomic_ref(const atomic_ref&) noexcept;
+    atomic_ref& operator=(const atomic_ref&) = delete;
+    void store(floating-point-type, memory_order = memory_order::seq_cst) const noexcept;
+    floating-point-type operator=(floating-point-type) const noexcept;
+    floating-point-type load(memory_order = memory_order::seq_cst) const noexcept;
+    operator floating-point-type() const noexcept;
+    floating-point-type exchange(floating-point-type,
+                                 memory_order = memory_order::seq_cst) const noexcept;
+    bool compare_exchange_weak(floating-point-type&, floating-point-type,
+                               memory_order, memory_order) const noexcept;
+    bool compare_exchange_strong(floating-point-type&, floating-point-type,
+                                 memory_order, memory_order) const noexcept;
+    bool compare_exchange_weak(floating-point-type&, floating-point-type,
+                               memory_order = memory_order::seq_cst) const noexcept;
+    bool compare_exchange_strong(floating-point-type&, floating-point-type,
+                                 memory_order = memory_order::seq_cst) const noexcept;
+    floating-point-type fetch_add(floating-point-type,
+                                  memory_order = memory_order::seq_cst) const noexcept;
+    floating-point-type fetch_sub(floating-point-type,
+                                  memory_order = memory_order::seq_cst) const noexcept;
+    floating-point-type operator+=(floating-point-type) const noexcept;
+    floating-point-type operator-=(floating-point-type) const noexcept;
+    void wait(floating-point-type, memory_order = memory_order::seq_cst) const noexcept;
+    void notify_one() const noexcept;
+    void notify_all() const noexcept;
+  };
+}
+```
+Descriptions are provided below only for members that differ from the
+primary template.
+The following operations perform arithmetic computations. The
+correspondence among key, operator, and computation is specified in
+[[atomic.types.int.comp]].
+``` cpp
+floating-point-type fetch_key(floating-point-type operand,
+                          memory_order order = memory_order::seq_cst) const noexcept;
+```
+*Effects:* Atomically replaces the value referenced by `*ptr` with the
+result of the computation applied to the value referenced by `*ptr` and
+the given operand. Memory is affected according to the value of `order`.
+These operations are atomic read-modify-write
+operations [[intro.races]].
+*Returns:* Atomically, the value referenced by `*ptr` immediately before
+the effects.
+*Remarks:* If the result is not a representable value for its
+type [[expr.pre]], the result is unspecified, but the operations
+otherwise have no undefined behavior. Atomic arithmetic operations on
+*`floating-point-type`* should conform to the
+`std::numeric_limits<`*`floating-point-type`*`>` traits associated with
+the floating-point type [[limits.syn]]. The floating-point
+environment [[cfenv]] for atomic arithmetic operations on
+*`floating-point-type`* may be different than the calling thread’s
+floating-point environment.
+``` cpp
+floating-point-type operator op=(floating-point-type operand) const noexcept;
+```
+*Effects:* Equivalent to:
+`return fetch_`*`key`*`(operand) `*`op`*` operand;`
+#### Partial specialization for pointers <a id="atomics.ref.pointer">[[atomics.ref.pointer]]</a>
+``` cpp
+namespace std {
+  template<class T> struct atomic_ref<T*> {
+  private:
+    T** ptr;        // exposition only
+  public:
+    using value_type = T*;
+    using difference_type = ptrdiff_t;
+    static constexpr size_t required_alignment = implementation-defined  // required alignment for atomic_ref type's operations;
+    static constexpr bool is_always_lock_free = implementation-defined  // whether a given atomic_ref type's operations are always lock free;
+    bool is_lock_free() const noexcept;
+    explicit atomic_ref(T*&);
+    atomic_ref(const atomic_ref&) noexcept;
+    atomic_ref& operator=(const atomic_ref&) = delete;
+    void store(T*, memory_order = memory_order::seq_cst) const noexcept;
+    T* operator=(T*) const noexcept;
+    T* load(memory_order = memory_order::seq_cst) const noexcept;
+    operator T*() const noexcept;
+    T* exchange(T*, memory_order = memory_order::seq_cst) const noexcept;
+    bool compare_exchange_weak(T*&, T*,
+                               memory_order, memory_order) const noexcept;
+    bool compare_exchange_strong(T*&, T*,
+                                 memory_order, memory_order) const noexcept;
+    bool compare_exchange_weak(T*&, T*,
+                               memory_order = memory_order::seq_cst) const noexcept;
+    bool compare_exchange_strong(T*&, T*,
+                                 memory_order = memory_order::seq_cst) const noexcept;
+    T* fetch_add(difference_type, memory_order = memory_order::seq_cst) const noexcept;
+    T* fetch_sub(difference_type, memory_order = memory_order::seq_cst) const noexcept;
+    T* operator++(int) const noexcept;
+    T* operator--(int) const noexcept;
+    T* operator++() const noexcept;
+    T* operator--() const noexcept;
+    T* operator+=(difference_type) const noexcept;
+    T* operator-=(difference_type) const noexcept;
+    void wait(T*, memory_order = memory_order::seq_cst) const noexcept;
+    void notify_one() const noexcept;
+    void notify_all() const noexcept;
+  };
+}
+```
+Descriptions are provided below only for members that differ from the
+primary template.
+The following operations perform arithmetic computations. The
+correspondence among key, operator, and computation is specified in
+[[atomic.types.pointer.comp]].
+``` cpp
+T* fetch_key(difference_type operand, memory_order order = memory_order::seq_cst) const noexcept;
+```
+*Mandates:* `T` is a complete object type.
+*Effects:* Atomically replaces the value referenced by `*ptr` with the
+result of the computation applied to the value referenced by `*ptr` and
+the given operand. Memory is affected according to the value of `order`.
+These operations are atomic read-modify-write
+operations [[intro.races]].
+*Returns:* Atomically, the value referenced by `*ptr` immediately before
+the effects.
+*Remarks:* The result may be an undefined address, but the operations
+otherwise have no undefined behavior.
+``` cpp
+T* operator op=(difference_type operand) const noexcept;
+```
+*Effects:* Equivalent to:
+`return fetch_`*`key`*`(operand) `*`op`*` operand;`
+#### Member operators common to integers and pointers to objects <a id="atomics.ref.memop">[[atomics.ref.memop]]</a>
+``` cpp
+value_type operator++(int) const noexcept;
+```
+*Effects:* Equivalent to: `return fetch_add(1);`
+``` cpp
+value_type operator--(int) const noexcept;
+```
+*Effects:* Equivalent to: `return fetch_sub(1);`
+``` cpp
+value_type operator++() const noexcept;
+```
+*Effects:* Equivalent to: `return fetch_add(1) + 1;`
+``` cpp
+value_type operator--() const noexcept;
+```
+*Effects:* Equivalent to: `return fetch_sub(1) - 1;`
+### Class template `atomic` <a id="atomics.types.generic">[[atomics.types.generic]]</a>
+#### General <a id="atomics.types.generic.general">[[atomics.types.generic.general]]</a>
+``` cpp
+namespace std {
+  template<class T> struct atomic {
+    using value_type = T;
+    static constexpr bool is_always_lock_free = implementation-defined  // whether a given atomic type's operations are always lock free;
+    bool is_lock_free() const volatile noexcept;
+    bool is_lock_free() const noexcept;
+    // [atomics.types.operations], operations on atomic types
+    constexpr atomic() noexcept(is_nothrow_default_constructible_v<T>);
+    constexpr atomic(T) noexcept;
+    atomic(const atomic&) = delete;
+    atomic& operator=(const atomic&) = delete;
+    atomic& operator=(const atomic&) volatile = delete;
+    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;
+    void store(T, memory_order = memory_order::seq_cst) volatile noexcept;
+    void store(T, memory_order = memory_order::seq_cst) noexcept;
+    T operator=(T) volatile noexcept;
+    T operator=(T) 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, memory_order = memory_order::seq_cst) const volatile noexcept;
+    void wait(T, memory_order = memory_order::seq_cst) const noexcept;
+    void notify_one() volatile noexcept;
+    void notify_one() noexcept;
+    void notify_all() volatile noexcept;
+    void notify_all() noexcept;
+  };
+}
+```
+The template argument for `T` shall meet the *Cpp17CopyConstructible*
+and *Cpp17CopyAssignable* requirements. The program is ill-formed if any
+of
+- `is_trivially_copyable_v<T>`,
+- `is_copy_constructible_v<T>`,
+- `is_move_constructible_v<T>`,
+- `is_copy_assignable_v<T>`, or
+- `is_move_assignable_v<T>`
+is `false`.
+[*Note 1*: Type arguments that are not also statically initializable
+can be difficult to use. — *end note*]
+The specialization `atomic<bool>` is a standard-layout struct.
+[*Note 2*: The representation of an atomic specialization need not have
+the same size and alignment requirement as its corresponding argument
+type. — *end note*]
+#### Operations on atomic types <a id="atomics.types.operations">[[atomics.types.operations]]</a>
+``` cpp
+constexpr atomic() noexcept(is_nothrow_default_constructible_v<T>);
+```
+*Mandates:* `is_default_constructible_v<T>` is `true`.
+*Effects:* Initializes the atomic object with the value of `T()`.
+Initialization is not an atomic operation [[intro.multithread]].
+``` cpp
+constexpr atomic(T desired) noexcept;
+```
+*Effects:* Initializes the object with the value `desired`.
+Initialization is not an atomic operation [[intro.multithread]].
+[*Note 1*: It is possible to have an access to an atomic object `A`
+race with its construction, for example by communicating the address of
+the just-constructed object `A` to another thread via
+`memory_order::relaxed` operations on a suitable atomic pointer
+variable, and then immediately accessing `A` in the receiving thread.
+This results in undefined behavior. — *end note*]
+``` cpp
+static constexpr bool is_always_lock_free = implementation-defined  // whether a given atomic type's operations are always lock free;
+```
+The `static` data member `is_always_lock_free` is `true` if the atomic
+type’s operations are always lock-free, and `false` otherwise.
+[*Note 2*: The value of `is_always_lock_free` is consistent with the
+value of the corresponding `ATOMIC_..._LOCK_FREE` macro, if
+defined. — *end note*]
+``` cpp
+bool is_lock_free() const volatile noexcept;
+bool is_lock_free() const noexcept;
+```
+*Returns:* `true` if the object’s operations are lock-free, `false`
+otherwise.
+[*Note 3*: The return value of the `is_lock_free` member function is
+consistent with the value of `is_always_lock_free` for the same
+type. — *end note*]
+``` cpp
+void store(T desired, memory_order order = memory_order::seq_cst) volatile noexcept;
+void store(T desired, memory_order order = memory_order::seq_cst) noexcept;
+```
+*Constraints:* For the `volatile` overload of this function,
+`is_always_lock_free` is `true`.
+*Preconditions:* The `order` argument is neither
+`memory_order::consume`, `memory_order::acquire`, nor
+`memory_order::acq_rel`.
+*Effects:* Atomically replaces the value pointed to by `this` with the
+value of `desired`. Memory is affected according to the value of
+`order`.
+``` cpp
+T operator=(T desired) volatile noexcept;
+T operator=(T desired) noexcept;
+```
+*Constraints:* For the `volatile` overload of this function,
+`is_always_lock_free` is `true`.
+*Effects:* Equivalent to `store(desired)`.
+*Returns:* `desired`.
+``` cpp
+T load(memory_order order = memory_order::seq_cst) const volatile noexcept;
+T load(memory_order order = memory_order::seq_cst) const noexcept;
+```
+*Constraints:* For the `volatile` overload of this function,
+`is_always_lock_free` is `true`.
+*Preconditions:* The `order` argument is neither `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 `this`.
+``` cpp
+operator T() const volatile noexcept;
+operator T() const noexcept;
+```
+*Constraints:* For the `volatile` overload of this function,
+`is_always_lock_free` is `true`.
+*Effects:* Equivalent to: `return load();`
+``` cpp
+T exchange(T desired, memory_order order = memory_order::seq_cst) volatile noexcept;
+T exchange(T desired, memory_order order = memory_order::seq_cst) noexcept;
+```
+*Constraints:* For the `volatile` overload of this function,
+`is_always_lock_free` is `true`.
+*Effects:* Atomically replaces the value pointed to by `this` with
+`desired`. Memory is affected according to the value of `order`. These
+operations are atomic read-modify-write
+operations [[intro.multithread]].
+*Returns:* Atomically returns the value pointed to by `this` immediately
+before the effects.
+``` cpp
+bool compare_exchange_weak(T& expected, T desired,
+                           memory_order success, memory_order failure) volatile noexcept;
+bool compare_exchange_weak(T& expected, T desired,
+                           memory_order success, memory_order failure) noexcept;
+bool compare_exchange_strong(T& expected, T desired,
+                             memory_order success, memory_order failure) volatile noexcept;
+bool compare_exchange_strong(T& expected, T desired,
+                             memory_order success, memory_order failure) noexcept;
+bool compare_exchange_weak(T& expected, T desired,
+                           memory_order order = memory_order::seq_cst) volatile noexcept;
+bool compare_exchange_weak(T& expected, T desired,
+                           memory_order order = memory_order::seq_cst) noexcept;
+bool compare_exchange_strong(T& expected, T desired,
+                             memory_order order = memory_order::seq_cst) volatile noexcept;
+bool compare_exchange_strong(T& expected, T desired,
+                             memory_order order = memory_order::seq_cst) noexcept;
+```
+*Constraints:* For the `volatile` overload of this function,
+`is_always_lock_free` is `true`.
+*Preconditions:* The `failure` argument is neither
+`memory_order::release` nor `memory_order::acq_rel`.
+*Effects:* Retrieves the value in `expected`. It then atomically
+compares the value representation of the value pointed to by `this` for
+equality with that previously retrieved from `expected`, and if true,
+replaces the value pointed to by `this` with that in `desired`. If and
+only if the comparison is `true`, memory is affected according to the
+value of `success`, and if the comparison is false, memory is affected
+according to the value of `failure`. When only one `memory_order`
+argument is supplied, the value of `success` is `order`, and the value
+of `failure` is `order` except that a value of `memory_order::acq_rel`
+shall be replaced by the value `memory_order::acquire` and a value of
+`memory_order::release` shall be replaced by the value
+`memory_order::relaxed`. If and only if the comparison is false then,
+after the atomic operation, the value in `expected` is replaced by the
+value pointed to by `this` during the atomic comparison. If the
+operation returns `true`, these operations are atomic read-modify-write
+operations [[intro.multithread]] on the memory pointed to by `this`.
+Otherwise, these operations are atomic load operations on that memory.
+*Returns:* The result of the comparison.
+[*Note 4*:
+For example, the effect of `compare_exchange_strong` on objects without
+padding bits [[term.padding.bits]] is
+``` cpp
+if (memcmp(this, &expected, sizeof(*this)) == 0)
+  memcpy(this, &desired, sizeof(*this));
+else
+  memcpy(&expected, this, sizeof(*this));
+```
+— *end note*]
+[*Example 1*:
+The expected use of the compare-and-exchange operations is as follows.
+The compare-and-exchange operations will update `expected` when another
+iteration of the loop is needed.
+``` cpp
+expected = current.load();
+do {
+  desired = function(expected);
+} while (!current.compare_exchange_weak(expected, desired));
+```
+— *end example*]
+[*Example 2*:
+Because the expected value is updated only on failure, code releasing
+the memory containing the `expected` value on success will work. For
+example, list head insertion will act atomically and would not introduce
+a data race in the following code:
+``` cpp
+do {
+  p->next = head;                                   // make new list node point to the current head
+} while (!head.compare_exchange_weak(p->next, p));  // try to insert
+```
+— *end example*]
+Implementations should ensure that weak compare-and-exchange operations
+do not consistently return `false` unless either the atomic object has
+value different from `expected` or there are concurrent modifications to
+the atomic object.
+*Remarks:* A weak compare-and-exchange operation may fail spuriously.
+That is, even when the contents of memory referred to by `expected` and
+`this` are equal, it may return `false` and store back to `expected` the
+same memory contents that were originally there.
+[*Note 5*: This spurious failure enables implementation of
+compare-and-exchange on a broader class of machines, e.g., load-locked
+store-conditional machines. A consequence of spurious failure is that
+nearly all uses of weak compare-and-exchange will be in a loop. When a
+compare-and-exchange is in a loop, the weak version will yield better
+performance on some platforms. When a weak compare-and-exchange would
+require a loop and a strong one would not, the strong one is
+preferable. — *end note*]
+[*Note 6*: Under cases where the `memcpy` and `memcmp` semantics of the
+compare-and-exchange operations apply, the comparisons can fail for
+values that compare equal with `operator==` if the value representation
+has trap bits or alternate representations of the same value. Notably,
+on implementations conforming to ISO/IEC/IEEE 60559, floating-point
+`-0.0` and `+0.0` will not compare equal with `memcmp` but will compare
+equal with `operator==`, and NaNs with the same payload will compare
+equal with `memcmp` but will not compare equal with
+`operator==`. — *end note*]
+[*Note 7*:
+Because compare-and-exchange acts on an object’s value representation,
+padding bits that never participate in the object’s value representation
+are ignored. As a consequence, the following code is guaranteed to avoid
+spurious failure:
+``` cpp
+struct padded {
+  char clank = 0x42;
+  // Padding here.
+  unsigned biff = 0xC0DEFEFE;
+};
+atomic<padded> pad = {};
+bool zap() {
+  padded expected, desired{0, 0};
+  return pad.compare_exchange_strong(expected, desired);
+}
+```
+— *end note*]
+[*Note 8*:
+For a union with bits that participate in the value representation of
+some members but not others, compare-and-exchange might always fail.
+This is because such padding bits have an indeterminate value when they
+do not participate in the value representation of the active member. As
+a consequence, the following code is not guaranteed to ever succeed:
+``` cpp
+union pony {
+  double celestia = 0.;
+  short luna;       // padded
+};
+atomic<pony> princesses = {};
+bool party(pony desired) {
+  pony expected;
+  return princesses.compare_exchange_strong(expected, desired);
+}
+```
+— *end note*]
+``` cpp
+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;
+```
+*Preconditions:* `order` is neither `memory_order::release` nor
+`memory_order::acq_rel`.
+*Effects:* Repeatedly performs the following steps, in order:
+- Evaluates `load(order)` and compares its value representation for
+  equality against that of `old`.
+- If they compare unequal, returns.
+- Blocks until it is unblocked by an atomic notifying operation or is
+  unblocked spuriously.
+*Remarks:* This function is an atomic waiting
+operation [[atomics.wait]].
+``` cpp
+void notify_one() volatile noexcept;
+void notify_one() noexcept;
+```
+*Effects:* Unblocks the execution of at least one atomic waiting
+operation that is eligible to be unblocked [[atomics.wait]] by this
+call, if any such atomic waiting operations exist.
+*Remarks:* This function is an atomic notifying
+operation [[atomics.wait]].
+``` cpp
+void notify_all() volatile noexcept;
+void notify_all() noexcept;
+```
+*Effects:* Unblocks the execution of all atomic waiting operations that
+are eligible to be unblocked [[atomics.wait]] by this call.
+*Remarks:* This function is an atomic notifying
+operation [[atomics.wait]].
+#### Specializations for integers <a id="atomics.types.int">[[atomics.types.int]]</a>
+There are specializations of the `atomic` class template for the
+integral types `char`, `signed char`, `unsigned char`, `short`,
+`unsigned short`, `int`, `unsigned int`, `long`, `unsigned long`,
+`long long`, `unsigned long long`, `char8_t`, `char16_t`, `char32_t`,
+`wchar_t`, and any other types needed by the typedefs in the header
+`<cstdint>`. For each such type `integral-type`, the specialization
+`atomic<integral-type>` provides additional atomic operations
+appropriate to integral types.
+[*Note 1*: The specialization `atomic<bool>` uses the primary template
+[[atomics.types.generic]]. — *end note*]
+``` cpp
+namespace std {
+  template<> struct atomic<integral-type> {
+    using value_type = integral-type;
+    using difference_type = value_type;
+    static constexpr bool is_always_lock_free = implementation-defined  // whether a given atomic type's operations are always lock free;
+    bool is_lock_free() const volatile noexcept;
+    bool is_lock_free() const noexcept;
+    constexpr atomic() noexcept;
+    constexpr atomic(integral-type) noexcept;
+    atomic(const atomic&) = delete;
+    atomic& operator=(const atomic&) = delete;
+    atomic& operator=(const atomic&) volatile = delete;
+    void store(integral-type, memory_order = memory_order::seq_cst) volatile noexcept;
+    void store(integral-type, memory_order = memory_order::seq_cst) noexcept;
+    integral-type operator=(integral-type) volatile noexcept;
+    integral-type operator=(integral-type) noexcept;
+    integral-type load(memory_order = memory_order::seq_cst) const volatile noexcept;
+    integral-type load(memory_order = memory_order::seq_cst) const noexcept;
+    operator integral-type() const volatile noexcept;
+    operator integral-type() const noexcept;
+    integral-type exchange(integral-type,
+                           memory_order = memory_order::seq_cst) volatile noexcept;
+    integral-type exchange(integral-type,
+                           memory_order = memory_order::seq_cst) noexcept;
+    bool compare_exchange_weak(integral-type&, integral-type,
+                               memory_order, memory_order) volatile noexcept;
+    bool compare_exchange_weak(integral-type&, integral-type,
+                               memory_order, memory_order) noexcept;
+    bool compare_exchange_strong(integral-type&, integral-type,
+                                 memory_order, memory_order) volatile noexcept;
+    bool compare_exchange_strong(integral-type&, integral-type,
+                                 memory_order, memory_order) noexcept;
+    bool compare_exchange_weak(integral-type&, integral-type,
+                               memory_order = memory_order::seq_cst) volatile noexcept;
+    bool compare_exchange_weak(integral-type&, integral-type,
+                               memory_order = memory_order::seq_cst) noexcept;
+    bool compare_exchange_strong(integral-type&, integral-type,
+                                 memory_order = memory_order::seq_cst) volatile noexcept;
+    bool compare_exchange_strong(integral-type&, integral-type,
+                                 memory_order = memory_order::seq_cst) noexcept;
+    integral-type fetch_add(integral-type,
+                            memory_order = memory_order::seq_cst) volatile noexcept;
+    integral-type fetch_add(integral-type,
+                            memory_order = memory_order::seq_cst) noexcept;
+    integral-type fetch_sub(integral-type,
+                            memory_order = memory_order::seq_cst) volatile noexcept;
+    integral-type fetch_sub(integral-type,
+                            memory_order = memory_order::seq_cst) noexcept;
+    integral-type fetch_and(integral-type,
+                            memory_order = memory_order::seq_cst) volatile noexcept;
+    integral-type fetch_and(integral-type,
+                            memory_order = memory_order::seq_cst) noexcept;
+    integral-type fetch_or(integral-type,
+                            memory_order = memory_order::seq_cst) volatile noexcept;
+    integral-type fetch_or(integral-type,
+                            memory_order = memory_order::seq_cst) noexcept;
+    integral-type fetch_xor(integral-type,
+                            memory_order = memory_order::seq_cst) volatile noexcept;
+    integral-type fetch_xor(integral-type,
+                            memory_order = memory_order::seq_cst) noexcept;
+    integral-type operator++(int) volatile noexcept;
+    integral-type operator++(int) noexcept;
+    integral-type operator--(int) volatile noexcept;
+    integral-type operator--(int) noexcept;
+    integral-type operator++() volatile noexcept;
+    integral-type operator++() noexcept;
+    integral-type operator--() volatile noexcept;
+    integral-type operator--() noexcept;
+    integral-type operator+=(integral-type) volatile noexcept;
+    integral-type operator+=(integral-type) noexcept;
+    integral-type operator-=(integral-type) volatile noexcept;
+    integral-type operator-=(integral-type) noexcept;
+    integral-type operator&=(integral-type) volatile noexcept;
+    integral-type operator&=(integral-type) noexcept;
+    integral-type operator|=(integral-type) volatile noexcept;
+    integral-type operator|=(integral-type) noexcept;
+    integral-type operator^=(integral-type) volatile noexcept;
+    integral-type operator^=(integral-type) noexcept;
+    void wait(integral-type, memory_order = memory_order::seq_cst) const volatile noexcept;
+    void wait(integral-type, memory_order = memory_order::seq_cst) const noexcept;
+    void notify_one() volatile noexcept;
+    void notify_one() noexcept;
+    void notify_all() volatile noexcept;
+    void notify_all() noexcept;
+  };
+}
+```
+The atomic integral specializations are standard-layout structs. They
+each have a trivial destructor.
+Descriptions are provided below only for members that differ from the
+primary template.
+The following operations perform arithmetic computations. The
+correspondence among key, operator, and computation is specified in
+[[atomic.types.int.comp]].
+**Table: Atomic arithmetic computations** <a id="atomic.types.int.comp">[atomic.types.int.comp]</a>
+|       |     |                      |       |     |                      |
+| ----- | --- | -------------------- | ----- | --- | -------------------- |
+| `add` | `+` | addition             | `sub` | `-` | subtraction          |
+| `or`  | `|` | bitwise inclusive or | `xor` | `^` | bitwise exclusive or |
+| `and` | `&` | bitwise and          |       |     |                      |
+``` cpp
+T fetch_key(T operand, memory_order order = memory_order::seq_cst) volatile noexcept;
+T fetch_key(T operand, memory_order order = memory_order::seq_cst) noexcept;
+```
+*Constraints:* For the `volatile` overload of this function,
+`is_always_lock_free` is `true`.
+*Effects:* Atomically replaces the value pointed to by `this` with the
+result of the computation applied to the value pointed to by `this` and
+the given `operand`. Memory is affected according to the value of
+`order`. These operations are atomic read-modify-write
+operations [[intro.multithread]].
+*Returns:* Atomically, the value pointed to by `this` immediately before
+the effects.
+*Remarks:* For signed integer types, the result is as if the object
+value and parameters were converted to their corresponding unsigned
+types, the computation performed on those types, and the result
+converted back to the signed type.
+[*Note 1*: There are no undefined results arising from the
+computation. — *end note*]
+``` cpp
+T operator op=(T operand) volatile noexcept;
+T operator op=(T operand) noexcept;
+```
+*Constraints:* For the `volatile` overload of this function,
+`is_always_lock_free` is `true`.
+*Effects:* Equivalent to:
+`return fetch_`*`key`*`(operand) `*`op`*` operand;`
+#### Specializations for floating-point types <a id="atomics.types.float">[[atomics.types.float]]</a>
+There are specializations of the `atomic` class template for all
+cv-unqualified floating-point types. For each such type
+`floating-point-type`, the specialization `atomic<floating-point-type>`
+provides additional atomic operations appropriate to floating-point
+types.
+``` cpp
+namespace std {
+  template<> struct atomic<floating-point-type> {
+    using value_type = floating-point-type;
+    using difference_type = value_type;
+    static constexpr bool is_always_lock_free = implementation-defined  // whether a given atomic type's operations are always lock free;
+    bool is_lock_free() const volatile noexcept;
+    bool is_lock_free() const noexcept;
+    constexpr atomic() noexcept;
+    constexpr atomic(floating-point-type) noexcept;
+    atomic(const atomic&) = delete;
+    atomic& operator=(const atomic&) = delete;
+    atomic& operator=(const atomic&) volatile = delete;
+    void store(floating-point-type, memory_order = memory_order::seq_cst) volatile noexcept;
+    void store(floating-point-type, memory_order = memory_order::seq_cst) noexcept;
+    floating-point-type operator=(floating-point-type) volatile noexcept;
+    floating-point-type operator=(floating-point-type) noexcept;
+    floating-point-type load(memory_order = memory_order::seq_cst) volatile noexcept;
+    floating-point-type load(memory_order = memory_order::seq_cst) noexcept;
+    operator floating-point-type() volatile noexcept;
+    operator floating-point-type() noexcept;
+    floating-point-type exchange(floating-point-type,
+                                 memory_order = memory_order::seq_cst) volatile noexcept;
+    floating-point-type exchange(floating-point-type,
+                                 memory_order = memory_order::seq_cst) noexcept;
+    bool compare_exchange_weak(floating-point-type&, floating-point-type,
+                               memory_order, memory_order) volatile noexcept;
+    bool compare_exchange_weak(floating-point-type&, floating-point-type,
+                               memory_order, memory_order) noexcept;
+    bool compare_exchange_strong(floating-point-type&, floating-point-type,
+                                 memory_order, memory_order) volatile noexcept;
+    bool compare_exchange_strong(floating-point-type&, floating-point-type,
+                                 memory_order, memory_order) noexcept;
+    bool compare_exchange_weak(floating-point-type&, floating-point-type,
+                               memory_order = memory_order::seq_cst) volatile noexcept;
+    bool compare_exchange_weak(floating-point-type&, floating-point-type,
+                               memory_order = memory_order::seq_cst) noexcept;
+    bool compare_exchange_strong(floating-point-type&, floating-point-type,
+                                 memory_order = memory_order::seq_cst) volatile noexcept;
+    bool compare_exchange_strong(floating-point-type&, floating-point-type,
+                                 memory_order = memory_order::seq_cst) noexcept;
+    floating-point-type fetch_add(floating-point-type,
+                                  memory_order = memory_order::seq_cst) volatile noexcept;
+    floating-point-type fetch_add(floating-point-type,
+                                  memory_order = memory_order::seq_cst) noexcept;
+    floating-point-type fetch_sub(floating-point-type,
+                                  memory_order = memory_order::seq_cst) volatile noexcept;
+    floating-point-type fetch_sub(floating-point-type,
+                                  memory_order = memory_order::seq_cst) noexcept;
+    floating-point-type operator+=(floating-point-type) volatile noexcept;
+    floating-point-type operator+=(floating-point-type) noexcept;
+    floating-point-type operator-=(floating-point-type) volatile noexcept;
+    floating-point-type operator-=(floating-point-type) noexcept;
+    void wait(floating-point-type, memory_order = memory_order::seq_cst) const volatile noexcept;
+    void wait(floating-point-type, memory_order = memory_order::seq_cst) const noexcept;
+    void notify_one() volatile noexcept;
+    void notify_one() noexcept;
+    void notify_all() volatile noexcept;
+    void notify_all() noexcept;
+  };
+}
+```
+The atomic floating-point specializations are standard-layout structs.
+They each have a trivial destructor.
+Descriptions are provided below only for members that differ from the
+primary template.
+The following operations perform arithmetic addition and subtraction
+computations. The correspondence among key, operator, and computation is
+specified in [[atomic.types.int.comp]].
+``` cpp
+T fetch_key(T operand, memory_order order = memory_order::seq_cst) volatile noexcept;
+T fetch_key(T operand, memory_order order = memory_order::seq_cst) noexcept;
+```
+*Constraints:* For the `volatile` overload of this function,
+`is_always_lock_free` is `true`.
+*Effects:* Atomically replaces the value pointed to by `this` with the
+result of the computation applied to the value pointed to by `this` and
+the given `operand`. Memory is affected according to the value of
+`order`. These operations are atomic read-modify-write
+operations [[intro.multithread]].
+*Returns:* Atomically, the value pointed to by `this` immediately before
+the effects.
+*Remarks:* If the result is not a representable value for its
+type [[expr.pre]] the result is unspecified, but the operations
+otherwise have no undefined behavior. Atomic arithmetic operations on
+*`floating-point-type`* should conform to the
+`std::numeric_limits<`*`floating-point-type`*`>` traits associated with
+the floating-point type [[limits.syn]]. The floating-point
+environment [[cfenv]] for atomic arithmetic operations on
+*`floating-point-type`* may be different than the calling thread’s
+floating-point environment.
+``` cpp
+T operator op=(T operand) volatile noexcept;
+T operator op=(T operand) noexcept;
+```
+*Constraints:* For the `volatile` overload of this function,
+`is_always_lock_free` is `true`.
+*Effects:* Equivalent to:
+`return fetch_`*`key`*`(operand) `*`op`*` operand;`
+*Remarks:* If the result is not a representable value for its
+type [[expr.pre]] the result is unspecified, but the operations
+otherwise have no undefined behavior. Atomic arithmetic operations on
+*`floating-point-type`* should conform to the
+`std::numeric_limits<`*`floating-point-type`*`>` traits associated with
+the floating-point type [[limits.syn]]. The floating-point
+environment [[cfenv]] for atomic arithmetic operations on
+*`floating-point-type`* may be different than the calling thread’s
+floating-point environment.
+#### Partial specialization for pointers <a id="atomics.types.pointer">[[atomics.types.pointer]]</a>
+``` cpp
+namespace std {
+  template<class T> struct atomic<T*> {
+    using value_type = T*;
+    using difference_type = ptrdiff_t;
+    static constexpr bool is_always_lock_free = implementation-defined  // whether a given atomic type's operations are always lock free;
+    bool is_lock_free() const volatile noexcept;
+    bool is_lock_free() const noexcept;
+    constexpr atomic() noexcept;
+    constexpr atomic(T*) noexcept;
+    atomic(const atomic&) = delete;
+    atomic& operator=(const atomic&) = delete;
+    atomic& operator=(const atomic&) volatile = delete;
+    void store(T*, memory_order = memory_order::seq_cst) volatile noexcept;
+    void store(T*, memory_order = memory_order::seq_cst) noexcept;
+    T* operator=(T*) volatile noexcept;
+    T* operator=(T*) 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;
+    T* fetch_add(ptrdiff_t, memory_order = memory_order::seq_cst) volatile noexcept;
+    T* fetch_add(ptrdiff_t, memory_order = memory_order::seq_cst) noexcept;
+    T* fetch_sub(ptrdiff_t, memory_order = memory_order::seq_cst) volatile noexcept;
+    T* fetch_sub(ptrdiff_t, memory_order = memory_order::seq_cst) noexcept;
+    T* operator++(int) volatile noexcept;
+    T* operator++(int) noexcept;
+    T* operator--(int) volatile noexcept;
+    T* operator--(int) noexcept;
+    T* operator++() volatile noexcept;
+    T* operator++() noexcept;
+    T* operator--() volatile noexcept;
+    T* operator--() noexcept;
+    T* operator+=(ptrdiff_t) volatile noexcept;
+    T* operator+=(ptrdiff_t) noexcept;
+    T* operator-=(ptrdiff_t) volatile noexcept;
+    T* operator-=(ptrdiff_t) noexcept;
+    void wait(T*, memory_order = memory_order::seq_cst) const volatile noexcept;
+    void wait(T*, memory_order = memory_order::seq_cst) const noexcept;
+    void notify_one() volatile noexcept;
+    void notify_one() noexcept;
+    void notify_all() volatile noexcept;
+    void notify_all() noexcept;
+  };
+}
+```
+There is a partial specialization of the `atomic` class template for
+pointers. Specializations of this partial specialization are
+standard-layout structs. They each have a trivial destructor.
+Descriptions are provided below only for members that differ from the
+primary template.
+The following operations perform pointer arithmetic. The correspondence
+among key, operator, and computation is specified in
+[[atomic.types.pointer.comp]].
+**Table: Atomic pointer computations** <a id="atomic.types.pointer.comp">[atomic.types.pointer.comp]</a>
+|       |     |          |       |     |             |
+| ----- | --- | -------- | ----- | --- | ----------- |
+| `add` | `+` | addition | `sub` | `-` | subtraction |
+``` cpp
+T* fetch_key(ptrdiff_t operand, memory_order order = memory_order::seq_cst) volatile noexcept;
+T* fetch_key(ptrdiff_t operand, memory_order order = memory_order::seq_cst) noexcept;
+```
+*Constraints:* For the `volatile` overload of this function,
+`is_always_lock_free` is `true`.
+*Mandates:* `T` is a complete object type.
+[*Note 1*: Pointer arithmetic on `void*` or function pointers is
+ill-formed. — *end note*]
+*Effects:* Atomically replaces the value pointed to by `this` with the
+result of the computation applied to the value pointed to by `this` and
+the given `operand`. Memory is affected according to the value of
+`order`. These operations are atomic read-modify-write
+operations [[intro.multithread]].
+*Returns:* Atomically, the value pointed to by `this` immediately before
+the effects.
+*Remarks:* The result may be an undefined address, but the operations
+otherwise have no undefined behavior.
+``` cpp
+T* operator op=(ptrdiff_t operand) volatile noexcept;
+T* operator op=(ptrdiff_t operand) noexcept;
+```
+*Constraints:* For the `volatile` overload of this function,
+`is_always_lock_free` is `true`.
+*Effects:* Equivalent to:
+`return fetch_`*`key`*`(operand) `*`op`*` operand;`
+#### Member operators common to integers and pointers to objects <a id="atomics.types.memop">[[atomics.types.memop]]</a>
+``` cpp
+value_type operator++(int) volatile noexcept;
+value_type operator++(int) noexcept;
+```
+*Constraints:* For the `volatile` overload of this function,
+`is_always_lock_free` is `true`.
+*Effects:* Equivalent to: `return fetch_add(1);`
+``` cpp
+value_type operator--(int) volatile noexcept;
+value_type operator--(int) noexcept;
+```
+*Constraints:* For the `volatile` overload of this function,
+`is_always_lock_free` is `true`.
+*Effects:* Equivalent to: `return fetch_sub(1);`
+``` cpp
+value_type operator++() volatile noexcept;
+value_type operator++() noexcept;
+```
+*Constraints:* For the `volatile` overload of this function,
+`is_always_lock_free` is `true`.
+*Effects:* Equivalent to: `return fetch_add(1) + 1;`
+``` cpp
+value_type operator--() volatile noexcept;
+value_type operator--() noexcept;
+```
+*Constraints:* For the `volatile` overload of this function,
+`is_always_lock_free` is `true`.
+*Effects:* Equivalent to: `return fetch_sub(1) - 1;`
+#### Partial specializations for smart pointers <a id="util.smartptr.atomic">[[util.smartptr.atomic]]</a>
+##### General <a id="util.smartptr.atomic.general">[[util.smartptr.atomic.general]]</a>
+The library provides partial specializations of the `atomic` template
+for shared-ownership smart pointers [[util.sharedptr]].
+[*Note 1*: The partial specializations are declared in header
+`<memory>`. — *end note*]
+The behavior of all operations is as specified in
+[[atomics.types.generic]], unless specified otherwise. The template
+parameter `T` of these partial specializations may be an incomplete
+type.
+All changes to an atomic smart pointer in [[util.smartptr.atomic]], and
+all associated `use_count` increments, are guaranteed to be performed
+atomically. Associated `use_count` decrements are sequenced after the
+atomic operation, but are not required to be part of it. Any associated
+deletion and deallocation are sequenced after the atomic update step and
+are not part of the atomic operation.
+[*Note 2*: If the atomic operation uses locks, locks acquired by the
+implementation will be held when any `use_count` adjustments are
+performed, and will not be held when any destruction or deallocation
+resulting from this is performed. — *end note*]
+[*Example 1*:
+``` cpp
+template<typename T> class atomic_list {
+  struct node {
+    T t;
+    shared_ptr<node> next;
+  };
+  atomic<shared_ptr<node>> head;
+public:
+  shared_ptr<node> find(T t) const {
+    auto p = head.load();
+    while (p && p->t != t)
+      p = p->next;
+    return p;
+  }
+  void push_front(T t) {
+    auto p = make_shared<node>();
+    p->t = t;
+    p->next = head;
+    while (!head.compare_exchange_weak(p->next, p)) {}
+  }
+};
+```
+— *end example*]
+##### Partial specialization for `shared_ptr` <a id="util.smartptr.atomic.shared">[[util.smartptr.atomic.shared]]</a>
+``` cpp
+namespace std {
+  template<class T> struct atomic<shared_ptr<T>> {
+    using value_type = shared_ptr<T>;
+    static constexpr bool is_always_lock_free = implementation-defined  // whether a given atomic type's operations are always lock free;
+    bool is_lock_free() const noexcept;
+    constexpr atomic() noexcept;
+    constexpr atomic(nullptr_t) noexcept : atomic() { }
+    atomic(shared_ptr<T> desired) noexcept;
+    atomic(const atomic&) = delete;
+    void operator=(const atomic&) = delete;
+    shared_ptr<T> load(memory_order order = memory_order::seq_cst) const noexcept;
+    operator shared_ptr<T>() const noexcept;
+    void store(shared_ptr<T> desired, memory_order order = memory_order::seq_cst) noexcept;
+    void operator=(shared_ptr<T> desired) noexcept;
+    shared_ptr<T> exchange(shared_ptr<T> desired,
+                           memory_order order = memory_order::seq_cst) noexcept;
+    bool compare_exchange_weak(shared_ptr<T>& expected, shared_ptr<T> desired,
+                               memory_order success, memory_order failure) noexcept;
+    bool compare_exchange_strong(shared_ptr<T>& expected, shared_ptr<T> desired,
+                                 memory_order success, memory_order failure) noexcept;
+    bool compare_exchange_weak(shared_ptr<T>& expected, shared_ptr<T> desired,
+                               memory_order order = memory_order::seq_cst) noexcept;
+    bool compare_exchange_strong(shared_ptr<T>& expected, shared_ptr<T> desired,
+                                 memory_order order = memory_order::seq_cst) noexcept;
+    void wait(shared_ptr<T> old, memory_order order = memory_order::seq_cst) const noexcept;
+    void notify_one() noexcept;
+    void notify_all() noexcept;
+  private:
+    shared_ptr<T> p;            // exposition only
+  };
+}
+```
+``` cpp
+constexpr atomic() noexcept;
+```
+*Effects:* Initializes `p{}`.
+``` cpp
+atomic(shared_ptr<T> desired) noexcept;
+```
+*Effects:* Initializes the object with the value `desired`.
+Initialization is not an atomic operation [[intro.multithread]].
+[*Note 1*: It is possible to have an access to an atomic object `A`
+race with its construction, for example, by communicating the address of
+the just-constructed object `A` to another thread via
+`memory_order::relaxed` operations on a suitable atomic pointer
+variable, and then immediately accessing `A` in the receiving thread.
+This results in undefined behavior. — *end note*]
+``` cpp
+void store(shared_ptr<T> desired, memory_order order = memory_order::seq_cst) noexcept;
+```
+*Preconditions:* `order` is neither `memory_order::consume`,
+`memory_order::acquire`, nor `memory_order::acq_rel`.
+*Effects:* Atomically replaces the value pointed to by `this` with the
+value of `desired` as if by `p.swap(desired)`. Memory is affected
+according to the value of `order`.
+``` cpp
+void operator=(shared_ptr<T> desired) noexcept;
+```
+*Effects:* Equivalent to `store(desired)`.
+``` cpp
+shared_ptr<T> load(memory_order order = memory_order::seq_cst) const noexcept;
+```
+*Preconditions:* `order` is neither `memory_order::release` nor
+`memory_order::acq_rel`.
+*Effects:* Memory is affected according to the value of `order`.
+*Returns:* Atomically returns `p`.
+``` cpp
+operator shared_ptr<T>() const noexcept;
+```
+*Effects:* Equivalent to: `return load();`
+``` cpp
+shared_ptr<T> exchange(shared_ptr<T> desired, memory_order order = memory_order::seq_cst) noexcept;
+```
+*Effects:* Atomically replaces `p` with `desired` as if by
+`p.swap(desired)`. Memory is affected according to the value of `order`.
+This is an atomic read-modify-write operation [[intro.races]].
+*Returns:* Atomically returns the value of `p` immediately before the
+effects.
+``` cpp
+bool compare_exchange_weak(shared_ptr<T>& expected, shared_ptr<T> desired,
+                           memory_order success, memory_order failure) noexcept;
+bool compare_exchange_strong(shared_ptr<T>& expected, shared_ptr<T> desired,
+                             memory_order success, memory_order failure) noexcept;
+```
+*Preconditions:* `failure` is neither `memory_order::release` nor
+`memory_order::acq_rel`.
+*Effects:* If `p` is equivalent to `expected`, assigns `desired` to `p`
+and has synchronization semantics corresponding to the value of
+`success`, otherwise assigns `p` to `expected` and has synchronization
+semantics corresponding to the value of `failure`.
+*Returns:* `true` if `p` was equivalent to `expected`, `false`
+otherwise.
+*Remarks:* Two `shared_ptr` objects are equivalent if they store the
+same pointer value and either share ownership or are both empty. The
+weak form may fail spuriously. See [[atomics.types.operations]].
+If the operation returns `true`, `expected` is not accessed after the
+atomic update and the operation is an atomic read-modify-write
+operation [[intro.multithread]] on the memory pointed to by `this`.
+Otherwise, the operation is an atomic load operation on that memory, and
+`expected` is updated with the existing value read from the atomic
+object in the attempted atomic update. The `use_count` update
+corresponding to the write to `expected` is part of the atomic
+operation. The write to `expected` itself is not required to be part of
+the atomic operation.
+``` cpp
+bool compare_exchange_weak(shared_ptr<T>& expected, shared_ptr<T> desired,
+                           memory_order order = memory_order::seq_cst) noexcept;
+```
+*Effects:* Equivalent to:
+``` cpp
+return compare_exchange_weak(expected, desired, order, fail_order);
+```
+where `fail_order` is the same as `order` except that a value of
+`memory_order::acq_rel` shall be replaced by the value
+`memory_order::acquire` and a value of `memory_order::release` shall be
+replaced by the value `memory_order::relaxed`.
+``` cpp
+bool compare_exchange_strong(shared_ptr<T>& expected, shared_ptr<T> desired,
+                             memory_order order = memory_order::seq_cst) noexcept;
+```
+*Effects:* Equivalent to:
+``` cpp
+return compare_exchange_strong(expected, desired, order, fail_order);
+```
+where `fail_order` is the same as `order` except that a value of
+`memory_order::acq_rel` shall be replaced by the value
+`memory_order::acquire` and a value of `memory_order::release` shall be
+replaced by the value `memory_order::relaxed`.
+``` cpp
+void wait(shared_ptr<T> old, memory_order order = memory_order::seq_cst) const noexcept;
+```
+*Preconditions:* `order` is neither `memory_order::release` nor
+`memory_order::acq_rel`.
+*Effects:* Repeatedly performs the following steps, in order:
+- Evaluates `load(order)` and compares it to `old`.
+- If the two are not equivalent, returns.
+- Blocks until it is unblocked by an atomic notifying operation or is
+  unblocked spuriously.
+*Remarks:* Two `shared_ptr` objects are equivalent if they store the
+same pointer and either share ownership or are both empty. This function
+is an atomic waiting operation [[atomics.wait]].
+``` cpp
+void notify_one() noexcept;
+```
+*Effects:* Unblocks the execution of at least one atomic waiting
+operation that is eligible to be unblocked [[atomics.wait]] by this
+call, if any such atomic waiting operations exist.
+*Remarks:* This function is an atomic notifying
+operation [[atomics.wait]].
+``` cpp
+void notify_all() noexcept;
+```
+*Effects:* Unblocks the execution of all atomic waiting operations that
+are eligible to be unblocked [[atomics.wait]] by this call.
+*Remarks:* This function is an atomic notifying
+operation [[atomics.wait]].
+##### Partial specialization for `weak_ptr` <a id="util.smartptr.atomic.weak">[[util.smartptr.atomic.weak]]</a>
+``` cpp
+namespace std {
+  template<class T> struct atomic<weak_ptr<T>> {
+    using value_type = weak_ptr<T>;
+    static constexpr bool is_always_lock_free = implementation-defined  // whether a given atomic type's operations are always lock free;
+    bool is_lock_free() const noexcept;
+    constexpr atomic() noexcept;
+    atomic(weak_ptr<T> desired) noexcept;
+    atomic(const atomic&) = delete;
+    void operator=(const atomic&) = delete;
+    weak_ptr<T> load(memory_order order = memory_order::seq_cst) const noexcept;
+    operator weak_ptr<T>() const noexcept;
+    void store(weak_ptr<T> desired, memory_order order = memory_order::seq_cst) noexcept;
+    void operator=(weak_ptr<T> desired) noexcept;
+    weak_ptr<T> exchange(weak_ptr<T> desired,
+                         memory_order order = memory_order::seq_cst) noexcept;
+    bool compare_exchange_weak(weak_ptr<T>& expected, weak_ptr<T> desired,
+                               memory_order success, memory_order failure) noexcept;
+    bool compare_exchange_strong(weak_ptr<T>& expected, weak_ptr<T> desired,
+                                 memory_order success, memory_order failure) noexcept;
+    bool compare_exchange_weak(weak_ptr<T>& expected, weak_ptr<T> desired,
+                               memory_order order = memory_order::seq_cst) noexcept;
+    bool compare_exchange_strong(weak_ptr<T>& expected, weak_ptr<T> desired,
+                                 memory_order order = memory_order::seq_cst) noexcept;
+    void wait(weak_ptr<T> old, memory_order order = memory_order::seq_cst) const noexcept;
+    void notify_one() noexcept;
+    void notify_all() noexcept;
+  private:
+    weak_ptr<T> p;              // exposition only
+  };
+}
+```
+``` cpp
+constexpr atomic() noexcept;
+```
+*Effects:* Initializes `p{}`.
+``` cpp
+atomic(weak_ptr<T> desired) noexcept;
+```
+*Effects:* Initializes the object with the value `desired`.
+Initialization is not an atomic operation [[intro.multithread]].
+[*Note 2*: It is possible to have an access to an atomic object `A`
+race with its construction, for example, by communicating the address of
+the just-constructed object `A` to another thread via
+`memory_order::relaxed` operations on a suitable atomic pointer
+variable, and then immediately accessing `A` in the receiving thread.
+This results in undefined behavior. — *end note*]
+``` cpp
+void store(weak_ptr<T> desired, memory_order order = memory_order::seq_cst) noexcept;
+```
+*Preconditions:* `order` is neither `memory_order::consume`,
+`memory_order::acquire`, nor `memory_order::acq_rel`.
+*Effects:* Atomically replaces the value pointed to by `this` with the
+value of `desired` as if by `p.swap(desired)`. Memory is affected
+according to the value of `order`.
+``` cpp
+void operator=(weak_ptr<T> desired) noexcept;
+```
+*Effects:* Equivalent to `store(desired)`.
+``` cpp
+weak_ptr<T> load(memory_order order = memory_order::seq_cst) const noexcept;
+```
+*Preconditions:* `order` is neither `memory_order::release` nor
+`memory_order::acq_rel`.
+*Effects:* Memory is affected according to the value of `order`.
+*Returns:* Atomically returns `p`.
+``` cpp
+operator weak_ptr<T>() const noexcept;
+```
+*Effects:* Equivalent to: `return load();`
+``` cpp
+weak_ptr<T> exchange(weak_ptr<T> desired, memory_order order = memory_order::seq_cst) noexcept;
+```
+*Effects:* Atomically replaces `p` with `desired` as if by
+`p.swap(desired)`. Memory is affected according to the value of `order`.
+This is an atomic read-modify-write operation [[intro.races]].
+*Returns:* Atomically returns the value of `p` immediately before the
+effects.
+``` cpp
+bool compare_exchange_weak(weak_ptr<T>& expected, weak_ptr<T> desired,
+                           memory_order success, memory_order failure) noexcept;
+bool compare_exchange_strong(weak_ptr<T>& expected, weak_ptr<T> desired,
+                             memory_order success, memory_order failure) noexcept;
+```
+*Preconditions:* `failure` is neither `memory_order::release` nor
+`memory_order::acq_rel`.
+*Effects:* If `p` is equivalent to `expected`, assigns `desired` to `p`
+and has synchronization semantics corresponding to the value of
+`success`, otherwise assigns `p` to `expected` and has synchronization
+semantics corresponding to the value of `failure`.
+*Returns:* `true` if `p` was equivalent to `expected`, `false`
+otherwise.
+*Remarks:* Two `weak_ptr` objects are equivalent if they store the same
+pointer value and either share ownership or are both empty. The weak
+form may fail spuriously. See [[atomics.types.operations]].
+If the operation returns `true`, `expected` is not accessed after the
+atomic update and the operation is an atomic read-modify-write
+operation [[intro.multithread]] on the memory pointed to by `this`.
+Otherwise, the operation is an atomic load operation on that memory, and
+`expected` is updated with the existing value read from the atomic
+object in the attempted atomic update. The `use_count` update
+corresponding to the write to `expected` is part of the atomic
+operation. The write to `expected` itself is not required to be part of
+the atomic operation.
+``` cpp
+bool compare_exchange_weak(weak_ptr<T>& expected, weak_ptr<T> desired,
+                           memory_order order = memory_order::seq_cst) noexcept;
+```
+*Effects:* Equivalent to:
+``` cpp
+return compare_exchange_weak(expected, desired, order, fail_order);
+```
+where `fail_order` is the same as `order` except that a value of
+`memory_order::acq_rel` shall be replaced by the value
+`memory_order::acquire` and a value of `memory_order::release` shall be
+replaced by the value `memory_order::relaxed`.
+``` cpp
+bool compare_exchange_strong(weak_ptr<T>& expected, weak_ptr<T> desired,
+                             memory_order order = memory_order::seq_cst) noexcept;
+```
+*Effects:* Equivalent to:
+``` cpp
+return compare_exchange_strong(expected, desired, order, fail_order);
+```
+where `fail_order` is the same as `order` except that a value of
+`memory_order::acq_rel` shall be replaced by the value
+`memory_order::acquire` and a value of `memory_order::release` shall be
+replaced by the value `memory_order::relaxed`.
+``` cpp
+void wait(weak_ptr<T> old, memory_order order = memory_order::seq_cst) const noexcept;
+```
+*Preconditions:* `order` is neither `memory_order::release` nor
+`memory_order::acq_rel`.
+*Effects:* Repeatedly performs the following steps, in order:
+- Evaluates `load(order)` and compares it to `old`.
+- If the two are not equivalent, returns.
+- Blocks until it is unblocked by an atomic notifying operation or is
+  unblocked spuriously.
+*Remarks:* Two `weak_ptr` objects are equivalent if they store the same
+pointer and either share ownership or are both empty. This function is
+an atomic waiting operation [[atomics.wait]].
+``` cpp
+void notify_one() noexcept;
+```
+*Effects:* Unblocks the execution of at least one atomic waiting
+operation that is eligible to be unblocked [[atomics.wait]] by this
+call, if any such atomic waiting operations exist.
+*Remarks:* This function is an atomic notifying
+operation [[atomics.wait]].
+``` cpp
+void notify_all() noexcept;
+```
+*Effects:* Unblocks the execution of all atomic waiting operations that
+are eligible to be unblocked [[atomics.wait]] by this call.
+*Remarks:* This function is an atomic notifying
+operation [[atomics.wait]].
+### Non-member functions <a id="atomics.nonmembers">[[atomics.nonmembers]]</a>
+A non-member function template whose name matches the pattern `atomic_f`
+or the pattern `atomic_f_explicit` invokes the member function `f`, with
+the value of the first parameter as the object expression and the values
+of the remaining parameters (if any) as the arguments of the member
+function call, in order. An argument for a parameter of type
+`atomic<T>::value_type*` is dereferenced when passed to the member
+function call. If no such member function exists, the program is
+ill-formed.
+[*Note 1*: The non-member functions enable programmers to write code
+that can be compiled as either C or C++, for example in a shared header
+file. — *end note*]
+### Flag type and operations <a id="atomics.flag">[[atomics.flag]]</a>
+``` cpp
+namespace std {
+  struct atomic_flag {
+    constexpr atomic_flag() noexcept;
+    atomic_flag(const atomic_flag&) = delete;
+    atomic_flag& operator=(const atomic_flag&) = delete;
+    atomic_flag& operator=(const atomic_flag&) volatile = delete;
+    bool test(memory_order = memory_order::seq_cst) const volatile noexcept;
+    bool test(memory_order = memory_order::seq_cst) const 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() volatile noexcept;
+    void notify_one() noexcept;
+    void notify_all() volatile noexcept;
+    void notify_all() noexcept;
+  };
+}
+```
+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. The
+operations should also be address-free.
+The `atomic_flag` type is a standard-layout struct. It has a trivial
+destructor.
+``` cpp
+constexpr atomic_flag::atomic_flag() noexcept;
+```
+*Effects:* Initializes `*this` to the clear state.
+``` cpp
+bool atomic_flag_test(const volatile atomic_flag* object) noexcept;
+bool atomic_flag_test(const atomic_flag* object) noexcept;
+bool atomic_flag_test_explicit(const volatile atomic_flag* object,
+                               memory_order order) noexcept;
+bool atomic_flag_test_explicit(const atomic_flag* object,
+                               memory_order order) noexcept;
+bool atomic_flag::test(memory_order order = memory_order::seq_cst) const volatile noexcept;
+bool atomic_flag::test(memory_order order = memory_order::seq_cst) const noexcept;
+```
+For `atomic_flag_test`, let `order` be `memory_order::seq_cst`.
+*Preconditions:* `order` is neither `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`.
+``` cpp
+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 [[intro.multithread]].
+*Returns:* Atomically, the value of the object immediately before the
+effects.
+``` cpp
+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;
+```
+*Preconditions:* The `order` argument is neither
+`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`.
+``` cpp
+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;
+```
+For `atomic_flag_wait`, let `order` be `memory_order::seq_cst`. Let
+`flag` be `object` for the non-member functions and `this` for the
+member functions.
+*Preconditions:* `order` is neither `memory_order::release` nor
+`memory_order::acq_rel`.
+*Effects:* Repeatedly performs the following steps, in order:
+- Evaluates `flag->test(order) != old`.
+- If the result of that evaluation is `true`, returns.
+- Blocks until it is unblocked by an atomic notifying operation or is
+  unblocked spuriously.
+*Remarks:* This function is an atomic waiting
+operation [[atomics.wait]].
+``` cpp
+void atomic_flag_notify_one(volatile atomic_flag* object) noexcept;
+void atomic_flag_notify_one(atomic_flag* object) noexcept;
+void atomic_flag::notify_one() volatile noexcept;
+void atomic_flag::notify_one() noexcept;
+```
+*Effects:* Unblocks the execution of at least one atomic waiting
+operation that is eligible to be unblocked [[atomics.wait]] by this
+call, if any such atomic waiting operations exist.
+*Remarks:* This function is an atomic notifying
+operation [[atomics.wait]].
+``` cpp
+void atomic_flag_notify_all(volatile atomic_flag* object) noexcept;
+void atomic_flag_notify_all(atomic_flag* object) noexcept;
+void atomic_flag::notify_all() volatile noexcept;
+void atomic_flag::notify_all() noexcept;
+```
+*Effects:* Unblocks the execution of all atomic waiting operations that
+are eligible to be unblocked [[atomics.wait]] by this call.
+*Remarks:* This function is an atomic notifying
+operation [[atomics.wait]].
+``` cpp
+#define ATOMIC_FLAG_INIT see below
+```
+*Remarks:* The macro `ATOMIC_FLAG_INIT` is 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:
+``` cpp
+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.
+### Fences <a id="atomics.fences">[[atomics.fences]]</a>
+This subclause introduces synchronization primitives called *fences*.
+Fences can have acquire semantics, release semantics, or both. A fence
+with acquire semantics is called an *acquire fence*. A fence with
+release semantics is called a *release fence*.
+A release fence A synchronizes with an acquire fence B if there exist
+atomic operations X and Y, both operating on some atomic object M, such
+that A is sequenced before X, X modifies M, Y is sequenced before B, and
+Y reads the value written by X or a value written by any side effect in
+the hypothetical release sequence X would head if it were a release
+operation.
+A release fence A synchronizes with an atomic operation B that performs
+an acquire operation on an atomic object M if there exists an atomic
+operation X such that A is sequenced before X, X modifies M, and B reads
+the value written by X or a value written by any side effect in the
+hypothetical release sequence X would head if it were a release
+operation.
+An atomic operation A that is a release operation on an atomic object M
+synchronizes with an acquire fence B if there exists some atomic
+operation X on M such that X is sequenced before B and reads the value
+written by A or a value written by any side effect in the release
+sequence headed by A.
+``` cpp
+extern "C" void atomic_thread_fence(memory_order order) noexcept;
+```
+*Effects:* Depending on the value of `order`, this operation:
+- has no effects, if `order == memory_order::relaxed`;
+- is an acquire fence, if `order == memory_order::acquire` or
+  `order == memory_order::consume`;
+- is a release fence, if `order == memory_order::release`;
+- is both an acquire fence and a release fence, if
+  `order == memory_order::acq_rel`;
+- is a sequentially consistent acquire and release fence, if
+  `order == memory_order::seq_cst`.
+``` cpp
+extern "C" void atomic_signal_fence(memory_order order) noexcept;
+```
+*Effects:* Equivalent to `atomic_thread_fence(order)`, except that the
+resulting ordering constraints are established only between a thread and
+a signal handler executed in the same thread.
+[*Note 1*: `atomic_signal_fence` can be used to specify the order in
+which actions performed by the thread become visible to the signal
+handler. Compiler optimizations and reorderings of loads and stores are
+inhibited in the same way as with `atomic_thread_fence`, but the
+hardware fence instructions that `atomic_thread_fence` would have
+inserted are not emitted. — *end note*]
+### C compatibility <a id="stdatomic.h.syn">[[stdatomic.h.syn]]</a>
+The header `<stdatomic.h>` provides the following definitions:
+``` cpp
+template<class T>
+  using std-atomic = std::atomic<T>;        // exposition only
+#define _Atomic(T) std-atomic<T>
+#define ATOMIC_BOOL_LOCK_FREE see below
+#define ATOMIC_CHAR_LOCK_FREE see below
+#define ATOMIC_CHAR16_T_LOCK_FREE see below
+#define ATOMIC_CHAR32_T_LOCK_FREE see below
+#define ATOMIC_WCHAR_T_LOCK_FREE see below
+#define ATOMIC_SHORT_LOCK_FREE see below
+#define ATOMIC_INT_LOCK_FREE see below
+#define ATOMIC_LONG_LOCK_FREE see below
+#define ATOMIC_LLONG_LOCK_FREE see below
+#define ATOMIC_POINTER_LOCK_FREE see below
+using std::memory_order;             // see below
+using std::memory_order_relaxed;     // see below
+using std::memory_order_consume;     // see below
+using std::memory_order_acquire;     // see below
+using std::memory_order_release;     // see below
+using std::memory_order_acq_rel;     // see below
+using std::memory_order_seq_cst;     // see below
+using std::atomic_flag;              // see below
+using std::atomic_bool;              // see below
+using std::atomic_char;              // see below
+using std::atomic_schar;             // see below
+using std::atomic_uchar;             // see below
+using std::atomic_short;             // see below
+using std::atomic_ushort;            // see below
+using std::atomic_int;               // see below
+using std::atomic_uint;              // see below
+using std::atomic_long;              // see below
+using std::atomic_ulong;             // see below
+using std::atomic_llong;             // see below
+using std::atomic_ullong;            // see below
+using std::atomic_char8_t;           // see below
+using std::atomic_char16_t;          // see below
+using std::atomic_char32_t;          // see below
+using std::atomic_wchar_t;           // see below
+using std::atomic_int8_t;            // see below
+using std::atomic_uint8_t;           // see below
+using std::atomic_int16_t;           // see below
+using std::atomic_uint16_t;          // see below
+using std::atomic_int32_t;           // see below
+using std::atomic_uint32_t;          // see below
+using std::atomic_int64_t;           // see below
+using std::atomic_uint64_t;          // see below
+using std::atomic_int_least8_t;      // see below
+using std::atomic_uint_least8_t;     // see below
+using std::atomic_int_least16_t;     // see below
+using std::atomic_uint_least16_t;    // see below
+using std::atomic_int_least32_t;     // see below
+using std::atomic_uint_least32_t;    // see below
+using std::atomic_int_least64_t;     // see below
+using std::atomic_uint_least64_t;    // see below
+using std::atomic_int_fast8_t;       // see below
+using std::atomic_uint_fast8_t;      // see below
+using std::atomic_int_fast16_t;      // see below
+using std::atomic_uint_fast16_t;     // see below
+using std::atomic_int_fast32_t;      // see below
+using std::atomic_uint_fast32_t;     // see below
+using std::atomic_int_fast64_t;      // see below
+using std::atomic_uint_fast64_t;     // see below
+using std::atomic_intptr_t;          // see below
+using std::atomic_uintptr_t;         // see below
+using std::atomic_size_t;            // see below
+using std::atomic_ptrdiff_t;         // see below
+using std::atomic_intmax_t;          // see below
+using std::atomic_uintmax_t;         // see below
+using std::atomic_is_lock_free;                          // see below
+using std::atomic_load;                                  // see below
+using std::atomic_load_explicit;                         // see below
+using std::atomic_store;                                 // see below
+using std::atomic_store_explicit;                        // see below
+using std::atomic_exchange;                              // see below
+using std::atomic_exchange_explicit;                     // see below
+using std::atomic_compare_exchange_strong;               // see below
+using std::atomic_compare_exchange_strong_explicit;      // see below
+using std::atomic_compare_exchange_weak;                 // see below
+using std::atomic_compare_exchange_weak_explicit;        // see below
+using std::atomic_fetch_add;                             // see below
+using std::atomic_fetch_add_explicit;                    // see below
+using std::atomic_fetch_sub;                             // see below
+using std::atomic_fetch_sub_explicit;                    // see below
+using std::atomic_fetch_and;                             // see below
+using std::atomic_fetch_and_explicit;                    // see below
+using std::atomic_fetch_or;                              // see below
+using std::atomic_fetch_or_explicit;                     // see below
+using std::atomic_fetch_xor;                             // see below
+using std::atomic_fetch_xor_explicit;                    // see below
+using std::atomic_flag_test_and_set;                     // see below
+using std::atomic_flag_test_and_set_explicit;            // see below
+using std::atomic_flag_clear;                            // see below
+using std::atomic_flag_clear_explicit;                   // see below
+#define ATOMIC_FLAG_INIT see below
+using std::atomic_thread_fence;                          // see below
+using std::atomic_signal_fence;                          // see below
+```
+Each *using-declaration* for some name A in the synopsis above makes
+available the same entity as `std::A` declared in `<atomic>`. Each macro
+listed above other than `_Atomic(T)` is defined as in `<atomic>`. It is
+unspecified whether `<stdatomic.h>` makes available any declarations in
+namespace `std`.
+Each of the *using-declaration*s for `intN_t`, `uintN_t`, `intptr_t`,
+and `uintptr_t` listed above is defined if and only if the
+implementation defines the corresponding *typedef-name* in
+[[atomics.syn]].
+Neither the `_Atomic` macro, nor any of the non-macro global namespace
+declarations, are provided by any C++ standard library header other than
+`<stdatomic.h>`.
+*Recommended practice:* Implementations should ensure that C and C++
+representations of atomic objects are compatible, so that the same
+object can be accessed as both an `_Atomic(T)` from C code and an
+`atomic<T>` from C++ code. The representations should be the same, and
+the mechanisms used to ensure atomicity and memory ordering should be
+compatible.
 ## Mutual exclusion <a id="thread.mutex">[[thread.mutex]]</a>
+### General <a id="thread.mutex.general">[[thread.mutex.general]]</a>
+Subclause [[thread.mutex]] provides mechanisms for mutual exclusion:
+mutexes, locks, and call once. These mechanisms ease the production of
+race-free programs [[intro.multithread]].
 ### Header `<mutex>` synopsis <a id="mutex.syn">[[mutex.syn]]</a>
 ``` cpp
 namespace std {
+  // [thread.mutex.class], class mutex
   class mutex;
+  // [thread.mutex.recursive], class recursive_mutex
   class recursive_mutex;
+  // [thread.timedmutex.class] class timed_mutex
   class timed_mutex;
+  // [thread.timedmutex.recursive], class recursive_timed_mutex
   class recursive_timed_mutex;
   struct defer_lock_t { explicit defer_lock_t() = default; };
   struct try_to_lock_t { explicit try_to_lock_t() = default; };
   struct adopt_lock_t { explicit adopt_lock_t() = default; };
   inline constexpr defer_lock_t  defer_lock { };
   inline constexpr try_to_lock_t try_to_lock { };
   inline constexpr adopt_lock_t  adopt_lock { };
+  // [thread.lock], locks
   template<class Mutex> class lock_guard;
   template<class... MutexTypes> class scoped_lock;
   template<class Mutex> class unique_lock;
   template<class Mutex>
     void swap(unique_lock<Mutex>& x, unique_lock<Mutex>& y) noexcept;
+  // [thread.lock.algorithm], generic locking algorithms
   template<class L1, class L2, class... L3> int try_lock(L1&, L2&, L3&...);
   template<class L1, class L2, class... L3> void lock(L1&, L2&, L3&...);
   struct once_flag;
 ### Header `<shared_mutex>` synopsis <a id="shared.mutex.syn">[[shared.mutex.syn]]</a>
 ``` cpp
 namespace std {
+  // [thread.sharedmutex.class], class shared_mutex
   class shared_mutex;
+  // [thread.sharedtimedmutex.class], class shared_timed_mutex
   class shared_timed_mutex;
+  // [thread.lock.shared], class template shared_lock
   template<class Mutex> class shared_lock;
   template<class Mutex>
     void swap(shared_lock<Mutex>& x, shared_lock<Mutex>& y) noexcept;
 }
 ```
 simultaneous ownership to one or many execution agents. Both recursive
 and non-recursive mutexes are supplied.
 #### Mutex types <a id="thread.mutex.requirements.mutex">[[thread.mutex.requirements.mutex]]</a>
+##### General <a id="thread.mutex.requirements.mutex.general">[[thread.mutex.requirements.mutex.general]]</a>
 The *mutex types* are the standard library types `mutex`,
 `recursive_mutex`, `timed_mutex`, `recursive_timed_mutex`,
 `shared_mutex`, and `shared_timed_mutex`. They meet the requirements set
+out in [[thread.mutex.requirements.mutex]]. In this description, `m`
+denotes an object of a mutex type.
+[*Note 1*: The mutex types meet the *Cpp17Lockable* requirements
+[[thread.req.lockable.req]]. — *end note*]
 The mutex types meet *Cpp17DefaultConstructible* and
 *Cpp17Destructible*. If initialization of an object of a mutex type
 fails, an exception of type `system_error` is thrown. The mutex types
 are neither copyable nor movable.
 The implementation provides lock and unlock operations, as described
 below. For purposes of determining the existence of a data race, these
 behave as atomic operations [[intro.multithread]]. The lock and unlock
 operations on a single mutex appears to occur in a single total order.
+[*Note 2*: This can be viewed as the modification order
 [[intro.multithread]] of the mutex. — *end note*]
+[*Note 3*: Construction and destruction of an object of a mutex type
+need not be thread-safe; other synchronization can be used to ensure
 that mutex objects are initialized and visible to other
 threads. — *end note*]
 The expression `m.lock()` is well-formed and has the following
 semantics:
 the mutex.
 *Effects:* Blocks the calling thread until ownership of the mutex can be
 obtained for the calling thread.
 *Synchronization:* Prior `unlock()` operations on the same object
 *synchronize with*[[intro.multithread]] this operation.
+*Ensures:* The calling thread owns the mutex.
+*Return type:* `void`.
 *Throws:* `system_error` when an exception is
 required [[thread.req.exception]].
 *Error conditions:*
 exchange [[atomics]]. — *end note*]
 An implementation should ensure that `try_lock()` does not consistently
 return `false` in the absence of contending mutex acquisitions.
 *Synchronization:* If `try_lock()` returns `true`, prior `unlock()`
 operations on the same object *synchronize with*[[intro.multithread]]
 this operation.
 [*Note 2*: Since `lock()` does not synchronize with a failed subsequent
 `try_lock()`, the visibility rules are weak enough that little would be
 known about the state after a failure, even in the absence of spurious
 failures. — *end note*]
+*Return type:* `bool`.
+*Returns:* `true` if ownership was obtained, otherwise `false`.
 *Throws:* Nothing.
 The expression `m.unlock()` is well-formed and has the following
 semantics:
 ownership semantics. If one thread owns a mutex object, attempts by
 another thread to acquire ownership of that object will fail (for
 `try_lock()`) or block (for `lock()`) until the owning thread has
 released ownership with a call to `unlock()`.
+[*Note 4*: After a thread `A` has called `unlock()`, releasing a mutex,
 it is possible for another thread `B` to lock the same mutex, observe
 that it is no longer in use, unlock it, and destroy it, before thread
 `A` appears to have returned from its unlock call. Implementations are
 required to handle such scenarios correctly, as long as thread `A`
 doesn’t access the mutex after the unlock call returns. These cases
 The class `mutex` meets all of the mutex requirements
 [[thread.mutex.requirements]]. It is a standard-layout class
 [[class.prop]].
+[*Note 5*: A program can deadlock if the thread that owns a `mutex`
 object calls `lock()` on that object. If the implementation can detect
 the deadlock, a `resource_deadlock_would_occur` error condition might be
 observed. — *end note*]
 The behavior of a program is undefined if it destroys a `mutex` object
 - it destroys a `recursive_mutex` object owned by any thread or
 - a thread terminates while owning a `recursive_mutex` object.
 #### Timed mutex types <a id="thread.timedmutex.requirements">[[thread.timedmutex.requirements]]</a>
+##### General <a id="thread.timedmutex.requirements.general">[[thread.timedmutex.requirements.general]]</a>
 The *timed mutex types* are the standard library types `timed_mutex`,
 `recursive_timed_mutex`, and `shared_timed_mutex`. They meet the
 requirements set out below. In this description, `m` denotes an object
 of a mutex type, `rel_time` denotes an object of an instantiation of
 `duration` [[time.duration]], and `abs_time` denotes an object of an
 instantiation of `time_point` [[time.point]].
+[*Note 1*: The timed mutex types meet the *Cpp17TimedLockable*
+requirements [[thread.req.lockable.timed]]. — *end note*]
 The expression `m.try_lock_for(rel_time)` is well-formed and has the
 following semantics:
 *Preconditions:* If `m` is of type `timed_mutex` or
 [*Note 1*: As with `try_lock()`, there is no guarantee that ownership
 will be obtained if the lock is available, but implementations are
 expected to make a strong effort to do so. — *end note*]
 *Synchronization:* If `try_lock_for()` returns `true`, prior `unlock()`
 operations on the same object *synchronize with*[[intro.multithread]]
 this operation.
+*Return type:* `bool`.
+*Returns:* `true` if ownership was obtained, otherwise `false`.
 *Throws:* Timeout-related exceptions [[thread.req.timing]].
 The expression `m.try_lock_until(abs_time)` is well-formed and has the
 following semantics:
 [*Note 2*: As with `try_lock()`, there is no guarantee that ownership
 will be obtained if the lock is available, but implementations are
 expected to make a strong effort to do so. — *end note*]
 *Synchronization:* If `try_lock_until()` returns `true`, prior
 `unlock()` operations on the same object *synchronize
 with*[[intro.multithread]] this operation.
+*Return type:* `bool`.
+*Returns:* `true` if ownership was obtained, otherwise `false`.
 *Throws:* Timeout-related exceptions [[thread.req.timing]].
 ##### Class `timed_mutex` <a id="thread.timedmutex.class">[[thread.timedmutex.class]]</a>
 ``` cpp
 - it destroys a `recursive_timed_mutex` object owned by any thread, or
 - a thread terminates while owning a `recursive_timed_mutex` object.
 #### Shared mutex types <a id="thread.sharedmutex.requirements">[[thread.sharedmutex.requirements]]</a>
+##### General <a id="thread.sharedmutex.requirements.general">[[thread.sharedmutex.requirements.general]]</a>
 The standard library types `shared_mutex` and `shared_timed_mutex` are
 *shared mutex types*. Shared mutex types meet the requirements of mutex
 types [[thread.mutex.requirements.mutex]] and additionally meet the
 requirements set out below. In this description, `m` denotes an object
 of a shared mutex type.
+[*Note 1*: The shared mutex types meet the *Cpp17SharedLockable*
+requirements [[thread.req.lockable.shared]]. — *end note*]
 In addition to the exclusive lock ownership mode specified in
 [[thread.mutex.requirements.mutex]], shared mutex types provide a
 *shared lock* ownership mode. Multiple execution agents can
 simultaneously hold a shared lock ownership of a shared mutex type. But
 no execution agent holds a shared lock while another execution agent
 *Effects:* Blocks the calling thread until shared ownership of the mutex
 can be obtained for the calling thread. If an exception is thrown then a
 shared lock has not been acquired for the current thread.
 *Synchronization:* Prior `unlock()` operations on the same object
 synchronize with [[intro.multithread]] this operation.
+*Ensures:* The calling thread has a shared lock on the mutex.
+*Return type:* `void`.
 *Throws:* `system_error` when an exception is
 required [[thread.req.exception]].
 *Error conditions:*
 calling thread without blocking. If shared ownership is not obtained,
 there is no effect and `try_lock_shared()` immediately returns. An
 implementation may fail to obtain the lock even if it is not held by any
 other thread.
 *Synchronization:* If `try_lock_shared()` returns `true`, prior
 `unlock()` operations on the same object synchronize
 with [[intro.multithread]] this operation.
+*Return type:* `bool`.
+*Returns:* `true` if the shared lock was acquired, otherwise `false`.
 *Throws:* Nothing.
 ##### Class `shared_mutex` <a id="thread.sharedmutex.class">[[thread.sharedmutex.class]]</a>
 ``` cpp
 `shared_mutex` may be a synonym for `shared_timed_mutex`.
 #### Shared timed mutex types <a id="thread.sharedtimedmutex.requirements">[[thread.sharedtimedmutex.requirements]]</a>
+##### General <a id="thread.sharedtimedmutex.requirements.general">[[thread.sharedtimedmutex.requirements.general]]</a>
 The standard library type `shared_timed_mutex` is a *shared timed mutex
 type*. Shared timed mutex types meet the requirements of timed mutex
 types [[thread.timedmutex.requirements]], shared mutex types
 [[thread.sharedmutex.requirements]], and additionally meet the
 requirements set out below. In this description, `m` denotes an object
+of a shared timed mutex type, `rel_time` denotes an object of an
 instantiation of `duration` [[time.duration]], and `abs_time` denotes an
 object of an instantiation of `time_point` [[time.point]].
+[*Note 1*: The shared timed mutex types meet the
+*Cpp17SharedTimedLockable* requirements
+[[thread.req.lockable.shared.timed]]. — *end note*]
 The expression `m.try_lock_shared_for(rel_time)` is well-formed and has
 the following semantics:
 *Preconditions:* The calling thread has no ownership of the mutex.
 expected to make a strong effort to do so. — *end note*]
 If an exception is thrown then a shared lock has not been acquired for
 the current thread.
 *Synchronization:* If `try_lock_shared_for()` returns `true`, prior
 `unlock()` operations on the same object synchronize
 with [[intro.multithread]] this operation.
+*Return type:* `bool`.
+*Returns:* `true` if the shared lock was acquired, otherwise `false`.
 *Throws:* Timeout-related exceptions [[thread.req.timing]].
 The expression `m.try_lock_shared_until(abs_time)` is well-formed and
 has the following semantics:
 expected to make a strong effort to do so. — *end note*]
 If an exception is thrown then a shared lock has not been acquired for
 the current thread.
 *Synchronization:* If `try_lock_shared_until()` returns `true`, prior
 `unlock()` operations on the same object synchronize
 with [[intro.multithread]] this operation.
+*Return type:* `bool`.
+*Returns:* `true` if the shared lock was acquired, otherwise `false`.
 *Throws:* Timeout-related exceptions [[thread.req.timing]].
 ##### Class `shared_timed_mutex` <a id="thread.sharedtimedmutex.class">[[thread.sharedtimedmutex.class]]</a>
 ``` cpp
 - a thread terminates while possessing any ownership of a
   `shared_timed_mutex`.
 ### Locks <a id="thread.lock">[[thread.lock]]</a>
+#### General <a id="thread.lock.general">[[thread.lock.general]]</a>
 A *lock* is an object that holds a reference to a lockable object and
 may unlock the lockable object during the lock’s destruction (such as
 when leaving block scope). An execution agent may use a lock to aid in
 managing ownership of a lockable object in an exception safe manner. A
 lock is said to *own* a lockable object if it is currently managing the
 ``` cpp
 explicit lock_guard(mutex_type& m);
 ```
 *Effects:* Initializes `pm` with `m`. Calls `m.lock()`.
 ``` cpp
 lock_guard(mutex_type& m, adopt_lock_t);
 ```
+*Preconditions:* The calling thread holds a non-shared lock on `m`.
 *Effects:* Initializes `pm` with `m`.
 *Throws:* Nothing.
 ``` cpp
 ~lock_guard();
 ```
+*Effects:* Equivalent to: `pm.unlock()`
 #### Class template `scoped_lock` <a id="thread.lock.scoped">[[thread.lock.scoped]]</a>
 ``` cpp
 namespace std {
   template<class... MutexTypes>
   class scoped_lock {
   public:
+    using mutex_type = see below; // Only if sizeof...(MutexTypes) == 1 is true
     explicit scoped_lock(MutexTypes&... m);
     explicit scoped_lock(adopt_lock_t, MutexTypes&... m);
     ~scoped_lock();
 An object of type `scoped_lock` controls the ownership of lockable
 objects within a scope. A `scoped_lock` object maintains ownership of
 lockable objects throughout the `scoped_lock` object’s lifetime
 [[basic.life]]. The behavior of a program is undefined if the lockable
 objects referenced by `pm` do not exist for the entire lifetime of the
+`scoped_lock` object.
+- If `sizeof...(MutexTypes)` is one, let `Mutex` denote the sole type
+  constituting the pack `MutexTypes`. `Mutex` shall meet the
+  *Cpp17BasicLockable* requirements [[thread.req.lockable.basic]]. The
+  member *typedef-name* `mutex_type` denotes the same type as `Mutex`.
+- Otherwise, all types in the template parameter pack `MutexTypes` shall
+  meet the *Cpp17Lockable* requirements [[thread.req.lockable.req]] and
+  there is no member `mutex_type`.
 ``` cpp
 explicit scoped_lock(MutexTypes&... m);
 ```
 *Effects:* Initializes `pm` with `tie(m...)`. Then if
 `sizeof...(MutexTypes)` is `0`, no effects. Otherwise if
 `sizeof...(MutexTypes)` is `1`, then `m.lock()`. Otherwise,
 `lock(m...)`.
 ``` cpp
 explicit scoped_lock(adopt_lock_t, MutexTypes&... m);
 ```
+*Preconditions:* The calling thread holds a non-shared lock on each
+element of `m`.
 *Effects:* Initializes `pm` with `tie(m...)`.
 *Throws:* Nothing.
 *Effects:* For all `i` in \[`0`, `sizeof...(MutexTypes)`),
 `get<i>(pm).unlock()`.
 #### Class template `unique_lock` <a id="thread.lock.unique">[[thread.lock.unique]]</a>
+##### General <a id="thread.lock.unique.general">[[thread.lock.unique.general]]</a>
 ``` cpp
 namespace std {
   template<class Mutex>
   class unique_lock {
   public:
   private:
     mutex_type* pm;             // exposition only
     bool owns;                  // exposition only
   };
 }
 ```
 An object of type `unique_lock` controls the ownership of a lockable
 object within a scope. Ownership of the lockable object may be acquired
 ``` cpp
 unique_lock() noexcept;
 ```
+*Ensures:* `pm == nullptr` and `owns == false`.
 ``` cpp
 explicit unique_lock(mutex_type& m);
 ```
 *Effects:* Calls `m.lock()`.
 *Ensures:* `pm == addressof(m)` and `owns == true`.
 ``` cpp
 ``` cpp
 unique_lock(mutex_type& m, try_to_lock_t);
 ```
 *Preconditions:* The supplied `Mutex` type meets the *Cpp17Lockable*
+requirements [[thread.req.lockable.req]].
 *Effects:* Calls `m.try_lock()`.
 *Ensures:* `pm == addressof(m)` and `owns == res`, where `res` is the
 value returned by the call to `m.try_lock()`.
 ``` cpp
 unique_lock(mutex_type& m, adopt_lock_t);
 ```
+*Preconditions:* The calling thread holds a non-shared lock on `m`.
 *Ensures:* `pm == addressof(m)` and `owns == true`.
 *Throws:* Nothing.
 ``` cpp
 template<class Clock, class Duration>
   unique_lock(mutex_type& m, const chrono::time_point<Clock, Duration>& abs_time);
 ```
+*Preconditions:* The supplied `Mutex` type meets the
 *Cpp17TimedLockable* requirements [[thread.req.lockable.timed]].
 *Effects:* Calls `m.try_lock_until(abs_time)`.
 *Ensures:* `pm == addressof(m)` and `owns == res`, where `res` is the
 ``` cpp
 template<class Rep, class Period>
   unique_lock(mutex_type& m, const chrono::duration<Rep, Period>& rel_time);
 ```
+*Preconditions:* The supplied `Mutex` type meets the
 *Cpp17TimedLockable* requirements [[thread.req.lockable.timed]].
 *Effects:* Calls `m.try_lock_for(rel_time)`.
 *Ensures:* `pm == addressof(m)` and `owns == res`, where `res` is the
 *Preconditions:* The supplied `Mutex` meets the *Cpp17Lockable*
 requirements [[thread.req.lockable.req]].
 *Effects:* As if by `pm->try_lock()`.
+*Ensures:* `owns == res`, where `res` is the value returned by
+`pm->try_lock()`.
+*Returns:* The value returned by `pm->try_lock()`.
 *Throws:* Any exception thrown by `pm->try_lock()`. `system_error` when
 an exception is required [[thread.req.exception]].
 *Error conditions:*
 *Preconditions:* The supplied `Mutex` type meets the
 *Cpp17TimedLockable* requirements [[thread.req.lockable.timed]].
 *Effects:* As if by `pm->try_lock_until(abs_time)`.
+*Ensures:* `owns == res`, where `res` is the value returned by
+`pm->try_lock_until(abs_time)`.
+*Returns:* The value returned by `pm->try_lock_until(abs_time)`.
+*Throws:* Any exception thrown by `pm->try_lock_until(abstime)`.
+`system_error` when an exception is required [[thread.req.exception]].
 *Error conditions:*
 - `operation_not_permitted` — if `pm` is `nullptr`.
 - `resource_deadlock_would_occur` — if on entry `owns` is `true`.
 *Preconditions:* The supplied `Mutex` type meets the
 *Cpp17TimedLockable* requirements [[thread.req.lockable.timed]].
 *Effects:* As if by `pm->try_lock_for(rel_time)`.
+*Ensures:* `owns == res`, where `res` is the value returned by
+`pm->try_lock_for(rel_time)`.
+*Returns:* The value returned by `pm->try_lock_for(rel_time)`.
+*Throws:* Any exception thrown by `pm->try_lock_for(rel_time)`.
+`system_error` when an exception is required [[thread.req.exception]].
 *Error conditions:*
 - `operation_not_permitted` — if `pm` is `nullptr`.
 - `resource_deadlock_would_occur` — if on entry `owns` is `true`.
 ``` cpp
 mutex_type* release() noexcept;
 ```
 *Ensures:* `pm == 0` and `owns == false`.
+*Returns:* The previous value of `pm`.
 ``` cpp
 template<class Mutex>
   void swap(unique_lock<Mutex>& x, unique_lock<Mutex>& y) noexcept;
 ```
 *Returns:* `pm`.
 #### Class template `shared_lock` <a id="thread.lock.shared">[[thread.lock.shared]]</a>
+##### General <a id="thread.lock.shared.general">[[thread.lock.shared.general]]</a>
 ``` cpp
 namespace std {
   template<class Mutex>
   class shared_lock {
   public:
   private:
     mutex_type* pm;                             // exposition only
     bool owns;                                  // exposition only
   };
 }
 ```
 An object of type `shared_lock` controls the shared ownership of a
 lockable object within a scope. Shared ownership of the lockable object
 transferred, after acquisition, to another `shared_lock` object. Objects
 of type `shared_lock` are not copyable but are movable. The behavior of
 a program is undefined if the contained pointer `pm` is not null and the
 lockable object pointed to by `pm` does not exist for the entire
 remaining lifetime [[basic.life]] of the `shared_lock` object. The
+supplied `Mutex` type shall meet the *Cpp17SharedLockable* requirements
+[[thread.req.lockable.shared]].
+[*Note 1*: `shared_lock<Mutex>` meets the *Cpp17Lockable* requirements
+[[thread.req.lockable.req]]. If `Mutex` meets the
+*Cpp17SharedTimedLockable* requirements
+[[thread.req.lockable.shared.timed]], `shared_lock<Mutex>` also meets
+the *Cpp17TimedLockable* requirements
+[[thread.req.lockable.timed]]. — *end note*]
 ##### Constructors, destructor, and assignment <a id="thread.lock.shared.cons">[[thread.lock.shared.cons]]</a>
 ``` cpp
 shared_lock() noexcept;
 ``` cpp
 explicit shared_lock(mutex_type& m);
 ```
 *Effects:* Calls `m.lock_shared()`.
 *Ensures:* `pm == addressof(m)` and `owns == true`.
 ``` cpp
 ``` cpp
 shared_lock(mutex_type& m, try_to_lock_t);
 ```
 *Effects:* Calls `m.try_lock_shared()`.
 *Ensures:* `pm == addressof(m)` and `owns == res` where `res` is the
 value returned by the call to `m.try_lock_shared()`.
 ``` cpp
 shared_lock(mutex_type& m, adopt_lock_t);
 ```
+*Preconditions:* The calling thread holds a shared lock on `m`.
 *Ensures:* `pm == addressof(m)` and `owns == true`.
 ``` cpp
 template<class Clock, class Duration>
   shared_lock(mutex_type& m,
               const chrono::time_point<Clock, Duration>& abs_time);
 ```
+*Preconditions:* `Mutex` meets the *Cpp17SharedTimedLockable*
+requirements [[thread.req.lockable.shared.timed]].
 *Effects:* Calls `m.try_lock_shared_until(abs_time)`.
 *Ensures:* `pm == addressof(m)` and `owns == res` where `res` is the
 value returned by the call to `m.try_lock_shared_until(abs_time)`.
 template<class Rep, class Period>
   shared_lock(mutex_type& m,
               const chrono::duration<Rep, Period>& rel_time);
 ```
+*Preconditions:* `Mutex` meets the *Cpp17SharedTimedLockable*
+requirements [[thread.req.lockable.shared.timed]].
 *Effects:* Calls `m.try_lock_shared_for(rel_time)`.
 *Ensures:* `pm == addressof(m)` and `owns == res` where `res` is the
 value returned by the call to `m.try_lock_shared_for(rel_time)`.
 bool try_lock();
 ```
 *Effects:* As if by `pm->try_lock_shared()`.
 *Ensures:* `owns == res`, where `res` is the value returned by the call
 to `pm->try_lock_shared()`.
+*Returns:* The value returned by the call to `pm->try_lock_shared()`.
 *Throws:* Any exception thrown by `pm->try_lock_shared()`.
 `system_error` when an exception is required [[thread.req.exception]].
 *Error conditions:*
 ``` cpp
 template<class Clock, class Duration>
   bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time);
 ```
+*Preconditions:* `Mutex` meets the *Cpp17SharedTimedLockable*
+requirements [[thread.req.lockable.shared.timed]].
 *Effects:* As if by `pm->try_lock_shared_until(abs_time)`.
 *Ensures:* `owns == res`, where `res` is the value returned by the call
 to `pm->try_lock_shared_until(abs_time)`.
+*Returns:* The value returned by the call to
+`pm->try_lock_shared_until(abs_time)`.
 *Throws:* Any exception thrown by `pm->try_lock_shared_until(abs_time)`.
 `system_error` when an exception is required [[thread.req.exception]].
 *Error conditions:*
 ``` cpp
 template<class Rep, class Period>
   bool try_lock_for(const chrono::duration<Rep, Period>& rel_time);
 ```
+*Preconditions:* `Mutex` meets the *Cpp17SharedTimedLockable*
+requirements [[thread.req.lockable.shared.timed]].
 *Effects:* As if by `pm->try_lock_shared_for(rel_time)`.
 *Ensures:* `owns == res`, where `res` is the value returned by the call
 to `pm->try_lock_shared_for(rel_time)`.
+*Returns:* The value returned by the call to
+`pm->try_lock_shared_for(rel_time)`.
 *Throws:* Any exception thrown by `pm->try_lock_shared_for(rel_time)`.
 `system_error` when an exception is required [[thread.req.exception]].
 *Error conditions:*
 ``` cpp
 mutex_type* release() noexcept;
 ```
 *Ensures:* `pm == nullptr` and `owns == false`.
+*Returns:* The previous value of `pm`.
 ``` cpp
 template<class Mutex>
   void swap(shared_lock<Mutex>& x, shared_lock<Mutex>& y) noexcept;
 ```
 *Effects:* All arguments are locked via a sequence of calls to `lock()`,
 `try_lock()`, or `unlock()` on each argument. The sequence of calls does
 not result in deadlock, but is otherwise unspecified.
+[*Note 3*: A deadlock avoidance algorithm such as try-and-back-off can
 be used, but the specific algorithm is not specified to avoid
 over-constraining implementations. — *end note*]
 If a call to `lock()` or `try_lock()` throws an exception, `unlock()` is
 called for any argument that had been locked by a call to `lock()` or
 *Mandates:* `is_invocable_v<Callable, Args...>` is `true`.
 *Effects:* An execution of `call_once` that does not call its `func` is
 a *passive* execution. An execution of `call_once` that calls its `func`
 is an *active* execution. An active execution calls *INVOKE*(
+std::forward\<Callable\>(func),
+std::forward\<Args\>(args)...) [[func.require]]. If such a call to
+`func` throws an exception the execution is *exceptional*, otherwise it
+is *returning*. An exceptional execution propagates the exception to the
+caller of `call_once`. Among all executions of `call_once` for any given
+`once_flag`: at most one is a returning execution; if there is a
+returning execution, it is the last active execution; and there are
+passive executions only if there is a returning execution.
 [*Note 1*: Passive executions allow other threads to reliably observe
 the results produced by the earlier returning execution. — *end note*]
 *Synchronization:* For any given `once_flag`: all active executions
 — *end example*]
 ## Condition variables <a id="thread.condition">[[thread.condition]]</a>
+### General <a id="thread.condition.general">[[thread.condition.general]]</a>
 Condition variables provide synchronization primitives used to block a
 thread until notified by some other thread that some condition is met or
 until a system time is reached. Class `condition_variable` provides a
 condition variable that can only wait on an object of type
 `unique_lock<mutex>`, allowing the implementation to be more efficient.
 3.  the reacquisition of the lock.
 The implementation behaves as if all executions of `notify_one`,
 `notify_all`, and each part of the `wait`, `wait_for`, and `wait_until`
 executions are executed in a single unspecified total order consistent
+with the “happens before” order.
 Condition variable construction and destruction need not be
 synchronized.
 ### Header `<condition_variable>` synopsis <a id="condition.variable.syn">[[condition.variable.syn]]</a>
 ``` cpp
 namespace std {
+  // [thread.condition.condvar], class condition_variable
   class condition_variable;
+  // [thread.condition.condvarany], class condition_variable_any
   class condition_variable_any;
+  // [thread.condition.nonmember], non-member functions
   void notify_all_at_thread_exit(condition_variable& cond, unique_lock<mutex> lk);
   enum class cv_status { no_timeout, timeout };
 }
 ```
 *Synchronization:* The implied `lk.unlock()` call is sequenced after the
 destruction of all objects with thread storage duration associated with
 the current thread.
+[*Note 1*: The supplied lock is held until the thread exits, which
+might cause deadlock due to lock ordering issues. — *end note*]
 [*Note 2*: It is the user’s responsibility to ensure that waiting
 threads do not erroneously assume that the thread has finished if they
 experience spurious wakeups. This typically requires that the condition
 being waited for is satisfied while holding the lock on `lk`, and that
 ~condition_variable();
 ```
 *Preconditions:* There is no thread blocked on `*this`.
+[*Note 1*: That is, all threads have been notified; they can
 subsequently block on the lock specified in the wait. This relaxes the
 usual rules, which would have required all wait calls to happen before
 destruction. Only the notification to unblock the wait needs to happen
+before destruction. Undefined behavior ensues if a thread waits on
+`*this` once the destructor has been started, especially when the
+waiting threads are calling the wait functions in a loop or using the
+overloads of `wait`, `wait_for`, or `wait_until` that take a
 predicate. — *end note*]
 ``` cpp
 void notify_one() noexcept;
 ```
 - When unblocked, calls `lock.lock()` (possibly blocking on the lock),
   then returns.
 - The function will unblock when signaled by a call to `notify_one()` or
   a call to `notify_all()`, or spuriously.
 *Ensures:* `lock.owns_lock()` is `true` and `lock.mutex()` is locked by
 the calling thread.
 *Throws:* Nothing.
+*Remarks:* If the function fails to meet the postcondition,
+`terminate()` is invoked [[except.terminate]].
+[*Note 2*: This can happen if the re-locking of the mutex throws an
+exception. — *end note*]
 ``` cpp
 template<class Predicate>
   void wait(unique_lock<mutex>& lock, Predicate pred);
 ```
 ``` cpp
 while (!pred())
   wait(lock);
 ```
 *Ensures:* `lock.owns_lock()` is `true` and `lock.mutex()` is locked by
 the calling thread.
 *Throws:* Any exception thrown by `pred`.
+*Remarks:* If the function fails to meet the postcondition,
+`terminate()` is invoked [[except.terminate]].
+[*Note 3*: This can happen if the re-locking of the mutex throws an
+exception. — *end note*]
 ``` cpp
 template<class Clock, class Duration>
   cv_status wait_until(unique_lock<mutex>& lock,
                        const chrono::time_point<Clock, Duration>& abs_time);
 ```
   call to `notify_all()`, expiration of the absolute
   timeout [[thread.req.timing]] specified by `abs_time`, or spuriously.
 - If the function exits via an exception, `lock.lock()` is called prior
   to exiting the function.
+*Ensures:* `lock.owns_lock()` is `true` and `lock.mutex()` is locked by
+the calling thread.
+*Returns:* `cv_status::timeout` if the absolute
+timeout [[thread.req.timing]] specified by `abs_time` expired, otherwise
+`cv_status::no_timeout`.
+*Throws:* Timeout-related exceptions [[thread.req.timing]].
 *Remarks:* If the function fails to meet the postcondition,
+`terminate()` is invoked [[except.terminate]].
 [*Note 4*: This can happen if the re-locking of the mutex throws an
 exception. — *end note*]
 ``` cpp
 template<class Rep, class Period>
   cv_status wait_for(unique_lock<mutex>& lock,
                      const chrono::duration<Rep, Period>& rel_time);
 ```
 ``` cpp
 return wait_until(lock, chrono::steady_clock::now() + rel_time);
 ```
+*Ensures:* `lock.owns_lock()` is `true` and `lock.mutex()` is locked by
+the calling thread.
 *Returns:* `cv_status::timeout` if the relative
 timeout [[thread.req.timing]] specified by `rel_time` expired, otherwise
 `cv_status::no_timeout`.
+*Throws:* Timeout-related exceptions [[thread.req.timing]].
+*Remarks:* If the function fails to meet the postcondition, `terminate`
+is invoked [[except.terminate]].
 [*Note 5*: This can happen if the re-locking of the mutex throws an
 exception. — *end note*]
 ``` cpp
 template<class Clock, class Duration, class Predicate>
   bool wait_until(unique_lock<mutex>& lock,
                   const chrono::time_point<Clock, Duration>& abs_time,
                   Predicate pred);
   if (wait_until(lock, abs_time) == cv_status::timeout)
     return pred();
 return true;
 ```
 *Ensures:* `lock.owns_lock()` is `true` and `lock.mutex()` is locked by
 the calling thread.
+[*Note 6*: The returned value indicates whether the predicate evaluated
 to `true` regardless of whether the timeout was
 triggered. — *end note*]
 *Throws:* Timeout-related exceptions [[thread.req.timing]] or any
 exception thrown by `pred`.
+*Remarks:* If the function fails to meet the postcondition,
+`terminate()` is invoked [[except.terminate]].
+[*Note 7*: This can happen if the re-locking of the mutex throws an
+exception. — *end note*]
 ``` cpp
 template<class Rep, class Period, class Predicate>
   bool wait_for(unique_lock<mutex>& lock,
                 const chrono::duration<Rep, Period>& rel_time,
                 Predicate pred);
 ```
 [*Note 8*: There is no blocking if `pred()` is initially `true`, even
 if the timeout has already expired. — *end note*]
 *Ensures:* `lock.owns_lock()` is `true` and `lock.mutex()` is locked by
 the calling thread.
+[*Note 9*: The returned value indicates whether the predicate evaluates
+to `true` regardless of whether the timeout was
 triggered. — *end note*]
 *Throws:* Timeout-related exceptions [[thread.req.timing]] or any
 exception thrown by `pred`.
+*Remarks:* If the function fails to meet the postcondition,
+`terminate()` is invoked [[except.terminate]].
+[*Note 10*: This can happen if the re-locking of the mutex throws an
+exception. — *end note*]
 ### Class `condition_variable_any` <a id="thread.condition.condvarany">[[thread.condition.condvarany]]</a>
+#### General <a id="thread.condition.condvarany.general">[[thread.condition.condvarany.general]]</a>
+In this subclause [[thread.condition.condvarany]], template arguments
+for template parameters named `Lock` shall meet the *Cpp17BasicLockable*
+requirements [[thread.req.lockable.basic]].
 [*Note 1*: All of the standard mutex types meet this requirement. If a
+type other than one of the standard mutex types or a `unique_lock`
+wrapper for a standard mutex type is used with `condition_variable_any`,
+any necessary synchronization is assumed to be in place with respect to
+the predicate associated with the `condition_variable_any`
+instance. — *end note*]
 ``` cpp
 namespace std {
   class condition_variable_any {
   public:
 ~condition_variable_any();
 ```
 *Preconditions:* There is no thread blocked on `*this`.
+[*Note 1*: That is, all threads have been notified; they can
 subsequently block on the lock specified in the wait. This relaxes the
 usual rules, which would have required all wait calls to happen before
 destruction. Only the notification to unblock the wait needs to happen
+before destruction. Undefined behavior ensues if a thread waits on
+`*this` once the destructor has been started, especially when the
+waiting threads are calling the wait functions in a loop or using the
+overloads of `wait`, `wait_for`, or `wait_until` that take a
 predicate. — *end note*]
 ``` cpp
 void notify_one() noexcept;
 ```
 - When unblocked, calls `lock.lock()` (possibly blocking on the lock)
   and returns.
 - The function will unblock when signaled by a call to `notify_one()`, a
   call to `notify_all()`, or spuriously.
+*Ensures:* `lock` is locked by the calling thread.
+*Throws:* Nothing.
 *Remarks:* If the function fails to meet the postcondition,
+`terminate()` is invoked [[except.terminate]].
 [*Note 1*: This can happen if the re-locking of the mutex throws an
 exception. — *end note*]
 ``` cpp
 template<class Lock, class Predicate>
   void wait(Lock& lock, Predicate pred);
 ```
   call to `notify_all()`, expiration of the absolute
   timeout [[thread.req.timing]] specified by `abs_time`, or spuriously.
 - If the function exits via an exception, `lock.lock()` is called prior
   to exiting the function.
 *Ensures:* `lock` is locked by the calling thread.
 *Returns:* `cv_status::timeout` if the absolute
 timeout [[thread.req.timing]] specified by `abs_time` expired, otherwise
 `cv_status::no_timeout`.
 *Throws:* Timeout-related exceptions [[thread.req.timing]].
+*Remarks:* If the function fails to meet the postcondition,
+`terminate()` is invoked [[except.terminate]].
+[*Note 2*: This can happen if the re-locking of the mutex throws an
+exception. — *end note*]
 ``` cpp
 template<class Lock, class Rep, class Period>
   cv_status wait_for(Lock& lock, const chrono::duration<Rep, Period>& rel_time);
 ```
 ``` cpp
 return wait_until(lock, chrono::steady_clock::now() + rel_time);
 ```
+*Ensures:* `lock` is locked by the calling thread.
 *Returns:* `cv_status::timeout` if the relative
 timeout [[thread.req.timing]] specified by `rel_time` expired, otherwise
 `cv_status::no_timeout`.
+*Throws:* Timeout-related exceptions [[thread.req.timing]].
+*Remarks:* If the function fails to meet the postcondition, `terminate`
+is invoked [[except.terminate]].
 [*Note 3*: This can happen if the re-locking of the mutex throws an
 exception. — *end note*]
 ``` cpp
 template<class Lock, class Clock, class Duration, class Predicate>
   bool wait_until(Lock& lock, const chrono::time_point<Clock, Duration>& abs_time, Predicate pred);
 ```
 [*Note 1*: The returned value indicates whether the predicate evaluated
 to `true` regardless of whether there was a stop request. — *end note*]
 *Ensures:* `lock` is locked by the calling thread.
+*Throws:* Any exception thrown by `pred`.
 *Remarks:* If the function fails to meet the postcondition, `terminate`
 is called [[except.terminate]].
 [*Note 2*: This can happen if the re-locking of the mutex throws an
 exception. — *end note*]
 ``` cpp
 template<class Lock, class Clock, class Duration, class Predicate>
   bool wait_until(Lock& lock, stop_token stoken,
                   const chrono::time_point<Clock, Duration>& abs_time, Predicate pred);
 ```
 ``` cpp
 while (!stoken.stop_requested()) {
   if (pred())
     return true;
+  if (wait_until(lock, abs_time) == cv_status::timeout)
     return pred();
 }
 return pred();
 ```
 to `true` regardless of whether the timeout was triggered or a stop
 request was made. — *end note*]
 *Ensures:* `lock` is locked by the calling thread.
 *Throws:* Timeout-related exceptions [[thread.req.timing]], or any
 exception thrown by `pred`.
+*Remarks:* If the function fails to meet the postcondition, `terminate`
+is called [[except.terminate]].
+[*Note 5*: This can happen if the re-locking of the mutex throws an
+exception. — *end note*]
 ``` cpp
 template<class Lock, class Rep, class Period, class Predicate>
   bool wait_for(Lock& lock, stop_token stoken,
                 const chrono::duration<Rep, Period>& rel_time, Predicate pred);
 ```
                   std::move(pred));
 ```
 ## Semaphore <a id="thread.sema">[[thread.sema]]</a>
+### General <a id="thread.sema.general">[[thread.sema.general]]</a>
 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.
 ### Header `<semaphore>` synopsis <a id="semaphore.syn">[[semaphore.syn]]</a>
 ``` cpp
 namespace std {
+  // [thread.sema.cnt], class template counting_semaphore
   template<ptrdiff_t least_max_value = implementation-defined>
     class counting_semaphore;
   using binary_semaphore = counting_semaphore<1>;
 }
 ### Class template `counting_semaphore` <a id="thread.sema.cnt">[[thread.sema.cnt]]</a>
 ``` cpp
 namespace std {
+  template<ptrdiff_t least_max_value = implementation-defined  // default value for least_max_value template parameter of counting_semaphore>
   class counting_semaphore {
   public:
     static constexpr ptrdiff_t max() noexcept;
     constexpr explicit counting_semaphore(ptrdiff_t desired);
 void acquire();
 ```
 *Effects:* Repeatedly performs the following steps, in order:
+- Evaluates `try_acquire()`. If the result is `true`, returns.
 - Blocks on `*this` until `counter` is greater than zero.
 *Throws:* `system_error` when an exception is
 required [[thread.req.exception]].
 *Error conditions:* Any of the error conditions allowed for mutex
 types [[thread.mutex.requirements.mutex]].
 ## Coordination types <a id="thread.coord">[[thread.coord]]</a>
+### General <a id="thread.coord.general">[[thread.coord.general]]</a>
+Subclause [[thread.coord]] 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.
 ### Latches <a id="thread.latch">[[thread.latch]]</a>
+#### General <a id="thread.latch.general">[[thread.latch.general]]</a>
 A latch is a thread coordination mechanism that allows any number of
 threads to block until an expected number of threads arrive at the latch
 (via the `count_down` function). The expected count is set when the
 latch is created. An individual latch is a single-use object; once the
 expected count has been reached, the latch cannot be reused.
 wait();
 ```
 ### Barriers <a id="thread.barrier">[[thread.barrier]]</a>
+#### General <a id="thread.barrier.general">[[thread.barrier.general]]</a>
 A barrier is a thread coordination mechanism whose lifetime consists of
 a sequence of barrier phases, where each phase allows at most an
 expected number of threads to block until the expected number of threads
 arrive at the barrier.
 Each *barrier phase* consists of the following steps:
 - The expected count is decremented by each call to `arrive` or
   `arrive_and_drop`.
+- Exactly once after the expected count reaches zero, a thread executes
+ the completion step during its call to `arrive`, `arrive_and_drop`, or
+  `wait`, except that it is *implementation-defined* whether the step
+ executes if no thread calls `wait`.
 - When the completion step finishes, the expected count is reset to what
   was specified by the `expected` argument to the constructor, possibly
   adjusted by calls to `arrive_and_drop`, and the next phase starts.
 Each phase defines a *phase synchronization point*. Threads that arrive
 ### Header `<future>` synopsis <a id="future.syn">[[future.syn]]</a>
 ``` cpp
 namespace std {
   enum class future_errc {
+    broken_promise = implementation-defined  // value of future_errc::broken_promise,
+    future_already_retrieved = implementation-defined  // value of future_errc::future_already_retrieved,
+    promise_already_satisfied = implementation-defined  // value of future_errc::promise_already_satisfied,
+    no_state = implementation-defined  // value of future_errc::no_state
   };
   enum class launch : unspecified{} {
     async = unspecified{},
     deferred = unspecified{},
+    implementation-defined  // last enumerator of launch
   };
   enum class future_status {
     ready,
     timeout,
     deferred
   };
+  // [futures.errors], error handling
   template<> struct is_error_code_enum<future_errc> : public true_type { };
   error_code make_error_code(future_errc e) noexcept;
   error_condition make_error_condition(future_errc e) noexcept;
   const error_category& future_category() noexcept;
+  // [futures.future.error], class future_error
   class future_error;
+  // [futures.promise], class template promise
   template<class R> class promise;
   template<class R> class promise<R&>;
   template<> class promise<void>;
   template<class R>
     void swap(promise<R>& x, promise<R>& y) noexcept;
   template<class R, class Alloc>
     struct uses_allocator<promise<R>, Alloc>;
+  // [futures.unique.future], class template future
   template<class R> class future;
   template<class R> class future<R&>;
   template<> class future<void>;
+  // [futures.shared.future], class template shared_future
   template<class R> class shared_future;
   template<class R> class shared_future<R&>;
   template<> class shared_future<void>;
+  // [futures.task], class template packaged_task
   template<class> class packaged_task;  // not defined
   template<class R, class... ArgTypes>
     class packaged_task<R(ArgTypes...)>;
   template<class R, class... ArgTypes>
     void swap(packaged_task<R(ArgTypes...)>&, packaged_task<R(ArgTypes...)>&) noexcept;
+  // [futures.async], function template async
   template<class F, class... Args>
     [[nodiscard]] future<invoke_result_t<decay_t<F>, decay_t<Args>...>>
       async(F&& f, Args&&... args);
   template<class F, class... Args>
     [[nodiscard]] future<invoke_result_t<decay_t<F>, decay_t<Args>...>>
 ```
 *Returns:* A reference to an object of a type derived from class
 `error_category`.
+The object’s `default_error_condition` and `equivalent` virtual
+functions shall behave as specified for the class `error_category`. The
+object’s `name` virtual function returns a pointer to the string
+`"future"`.
 ``` cpp
 error_code make_error_code(future_errc e) noexcept;
 ```
 Many of the classes introduced in subclause  [[futures]] use some state
 to communicate results. This *shared state* consists of some state
 information and some (possibly not yet evaluated) *result*, which can be
 a (possibly void) value or an exception.
+[*Note 1*: Futures, promises, and tasks defined in this Clause
 reference such shared state. — *end note*]
 [*Note 2*: The result can be any kind of object including a function to
 compute that result, as used by `async` when `policy` is
 `launch::deferred`. — *end note*]
     // setting the result with deferred notification
     void set_value_at_thread_exit(see below);
     void set_exception_at_thread_exit(exception_ptr p);
   };
   template<class R, class Alloc>
     struct uses_allocator<promise<R>, Alloc>;
 }
 ```
+For the primary template, `R` shall be an object type that meets the
+*Cpp17Destructible* requirements.
 The implementation provides the template `promise` and two
 specializations, `promise<R&>` and `promise<{}void>`. These differ only
 in the argument type of the member functions `set_value` and
 `set_value_at_thread_exit`, as set out in their descriptions, below.
 template<class R, class Alloc>
   struct uses_allocator<promise<R>, Alloc>
     : true_type { };
 ```
+*Preconditions:* `Alloc` meets the *Cpp17Allocator*
+requirements [[allocator.requirements.general]].
 ``` cpp
 promise();
 template<class Allocator>
   promise(allocator_arg_t, const Allocator& a);
 ``` cpp
 future<R> get_future();
 ```
 *Synchronization:* Calls to this function do not introduce data
 races  [[intro.multithread]] with calls to `set_value`, `set_exception`,
 `set_value_at_thread_exit`, or `set_exception_at_thread_exit`.
 [*Note 1*: Such calls need not synchronize with each
 other. — *end note*]
+*Returns:* A `future<R>` object with the same shared state as `*this`.
 *Throws:* `future_error` if `*this` has no shared state or if
 `get_future` has already been called on a `promise` with the same shared
 state as `*this`.
 *Error conditions:*
 which `valid() == false` is undefined.
 [*Note 2*: It is valid to move from a future object for which
 `valid() == false`. — *end note*]
+*Recommended practice:* Implementations should detect this case and
+throw an object of type `future_error` with an error condition of
+`future_errc::no_state`.
 ``` cpp
 namespace std {
   template<class R>
   class future {
       future_status wait_until(const chrono::time_point<Clock, Duration>& abs_time) const;
   };
 }
 ```
+For the primary template, `R` shall be an object type that meets the
+*Cpp17Destructible* requirements.
 The implementation provides the template `future` and two
 specializations, `future<R&>` and `future<{}void>`. These differ only in
 the return type and return value of the member function `get`, as set
 out in its description, below.
 ``` cpp
 future& operator=(future&& rhs) noexcept;
 ```
+*Effects:* If `addressof(rhs) == this` is `true`, there are no effects.
+Otherwise:
 - Releases any shared state [[futures.state]].
 - move assigns the contents of `rhs` to `*this`.
 *Ensures:*
 - `valid()` returns the same value as `rhs.valid()` prior to the
   assignment.
+- If `addressof(rhs) == this` is `false`, `rhs.valid() == false`.
 ``` cpp
 shared_future<R> share() noexcept;
 ```
+*Ensures:* `valid() == false`.
 *Returns:* `shared_future<R>(std::move(*this))`.
 ``` cpp
 R future::get();
 R& future<R&>::get();
 void future<void>::get();
 ```
 - `wait()`s until the shared state is ready, then retrieves the value
   stored in the shared state;
 - releases any shared state [[futures.state]].
+*Ensures:* `valid() == false`.
 *Returns:*
 - `future::get()` returns the value `v` stored in the object’s shared
   state as `std::move(v)`.
 - `future<R&>::get()` returns the reference stored as value in the
 - `future<void>::get()` returns nothing.
 *Throws:* The stored exception, if an exception was stored in the shared
 state.
 ``` cpp
 bool valid() const noexcept;
 ```
 *Returns:* `true` only if `*this` refers to a shared state.
 a `shared_future` object for which `valid() == false` is undefined.
 [*Note 2*: It is valid to copy or move from a `shared_future` object
 for which `valid()` is `false`. — *end note*]
+*Recommended practice:* Implementations should detect this case and
+throw an object of type `future_error` with an error condition of
+`future_errc::no_state`.
 ``` cpp
 namespace std {
   template<class R>
   class shared_future {
       future_status wait_until(const chrono::time_point<Clock, Duration>& abs_time) const;
   };
 }
 ```
+For the primary template, `R` shall be an object type that meets the
+*Cpp17Destructible* requirements.
 The implementation provides the template `shared_future` and two
 specializations, `shared_future<R&>` and `shared_future<void>`. These
 differ only in the return type and return value of the member function
 `get`, as set out in its description, below.
 ``` cpp
 shared_future& operator=(shared_future&& rhs) noexcept;
 ```
+*Effects:* If `addressof(rhs) == this` is `true`, there are no effects.
+Otherwise:
 - Releases any shared state [[futures.state]];
 - move assigns the contents of `rhs` to `*this`.
 *Ensures:*
 - `valid()` returns the same value as `rhs.valid()` returned prior to
   the assignment.
+- If `addressof(rhs) == this` is `false`, `rhs.valid() == false`.
 ``` cpp
 shared_future& operator=(const shared_future& rhs) noexcept;
 ```
+*Effects:* If `addressof(rhs) == this` is `true`, there are no effects.
+Otherwise:
 - Releases any shared state [[futures.state]];
+- assigns the contents of `rhs` to `*this`. \[*Note 3*: As a result,
   `*this` refers to the same shared state as `rhs` (if
   any). — *end note*]
 *Ensures:* `valid() == rhs.valid()`.
 [*Note 1*: As described above, the template and its two required
 specializations differ only in the return type and return value of the
 member function `get`. — *end note*]
 [*Note 2*: Access to a value object stored in the shared state is
+unsynchronized, so operations on `R` might introduce a data
+race [[intro.multithread]]. — *end note*]
 *Effects:* `wait()`s until the shared state is ready, then retrieves the
 value stored in the shared state.
 *Returns:*
 - `shared_future::get()` returns a const reference to the value stored
+  in the object’s shared state. \[*Note 4*: Access through that
   reference after the shared state has been destroyed produces undefined
   behavior; this can be avoided by not storing the reference in any
   storage with a greater lifetime than the `shared_future` object that
   returned the reference. — *end note*]
 - `shared_future<R&>::get()` returns the reference stored as value in
 ```
 *Mandates:* The following are all `true`:
 - `is_constructible_v<decay_t<F>, F>`,
+- `(is_constructible_v<decay_t<Args>, Args> && ...)`, and
 - `is_invocable_v<decay_t<F>, decay_t<Args>...>`.
 *Effects:* The first function behaves the same as a call to the second
 function with a `policy` argument of `launch::async | launch::deferred`
 and the same arguments for `F` and `Args`. The second function creates a
 shared state that is associated with the returned `future` object. The
 further behavior of the second function depends on the `policy` argument
 as follows (if more than one of these conditions applies, the
 implementation may choose any of the corresponding policies):
 - If `launch::async` is set in `policy`, calls
+  `invoke(auto(std::forward<F>(f)), auto(std::forward<Args>(args))...)`
+  [[func.invoke]], [[thread.thread.constr]] as if in a new thread of
+ execution represented by a `thread` object with the values produced by
+  `auto` being materialized [[conv.rval]] in the thread that called
+  `async`. Any return value is stored as the result in the shared state.
+ Any exception propagated from the execution of
+ `invoke(auto(std::forward<F>(f)), auto(std::forward<Args>(args))...)`
   is stored as the exceptional result in the shared state. The `thread`
   object is stored in the shared state and affects the behavior of any
   asynchronous return objects that reference that state.
 - If `launch::deferred` is set in `policy`, stores
+ `auto(std::forward<F>(f))` and `auto(std::forward<Args>(args))...` in
+  the shared state. These copies of `f` and `args` constitute a
+ *deferred function*. Invocation of the deferred function evaluates
   `invoke(std::move(g), std::move(xyz))` where `g` is the stored value
+  of `auto(std::forward<F>(f))` and `xyz` is the stored copy of
+ `auto(std::forward<Args>(args))...`. Any return value is stored as the
+  result in the shared state. Any exception propagated from the
+  execution of the deferred function is stored as the exceptional result
+  in the shared state. The shared state is not made ready until the
+  function has completed. The first call to a non-timed waiting
+  function [[futures.state]] on an asynchronous return object referring
+  to this shared state invokes the deferred function in the thread that
+  called the waiting function. Once evaluation of
   `invoke(std::move(g), std::move(xyz))` begins, the function is no
+  longer considered deferred. *Recommended practice:* If this policy is
+ specified together with other policies, such as when using a `policy`
+ value of `launch::async | launch::deferred`, implementations should
+ defer invocation or the selection of the policy when no more
+ concurrency can be effectively exploited.
 - If no value is set in the launch policy, or a value is set that is
   neither specified in this document nor by the implementation, the
   behavior is undefined.
+*Synchronization:* The invocation of `async` synchronizes with the
+invocation of `f`. The completion of the function `f` is sequenced
+before the shared state is made ready.
+[*Note 1*: These apply regardless of the provided `policy` argument,
+and even if the corresponding `future` object is moved to another
+thread. However, it is possible for `f` not to be called at all, in
+which case its completion never happens. — *end note*]
 If the implementation chooses the `launch::async` policy,
 - a call to a waiting function on an asynchronous return object that
   shares the shared state created by this `async` call shall block until
   with [[intro.multithread]] the return from the first function that
   successfully detects the ready status of the shared state or with the
   return from the last function that releases the shared state,
   whichever happens first.
+*Returns:* An object of type
+`future<invoke_result_t<decay_t<F>, decay_t<Args>...>>` that refers to
+the shared state created by this call to `async`.
+[*Note 2*: If a future obtained from `async` is moved outside the local
+scope, the future’s destructor can block for the shared state to become
+ready. — *end note*]
 *Throws:* `system_error` if `policy == launch::async` and the
 implementation is unable to start a new thread, or `std::bad_alloc` if
+memory for the internal data structures cannot be allocated.
 *Error conditions:*
 - `resource_unavailable_try_again` — if `policy == launch::async` and
   the system is unable to start a new thread.
+[*Note 1*: Line \#1 might not result in concurrency because the `async`
+call uses the default policy, which might use `launch::deferred`, in
+which case the lambda might not be invoked until the `get()` call; in
+that case, `work1` and `work2` are called on the same thread and there
+is no concurrency. — *end note*]
 ### Class template `packaged_task` <a id="futures.task">[[futures.task]]</a>
+#### General <a id="futures.task.general">[[futures.task.general]]</a>
 The class template `packaged_task` defines a type for wrapping a
 function or callable object so that the return value of the function or
 callable object is stored in a future when it is invoked.
 When the `packaged_task` object is invoked, its stored task is invoked
     void reset();
   };
   template<class R, class... ArgTypes>
+    packaged_task(R (*)(ArgTypes...)) -> packaged_task<R(ArgTypes...)>;
+  template<class F> packaged_task(F) -> packaged_task<see below>;
 }
 ```
 #### Member functions <a id="futures.task.members">[[futures.task.members]]</a>
 *Effects:* The object has no shared state and no stored task.
 ``` cpp
 template<class F>
+ explicit packaged_task(F&& f);
 ```
 *Constraints:* `remove_cvref_t<F>` is not the same type as
 `packaged_task<R(ArgTypes...)>`.
 *Effects:* Constructs a new `packaged_task` object with a shared state
 and initializes the object’s stored task with `std::forward<F>(f)`.
 *Throws:* Any exceptions thrown by the copy or move constructor of `f`,
+or `bad_alloc` if memory for the internal data structures cannot be
 allocated.
+``` cpp
+template<class F> packaged_task(F) -> packaged_task<see below>;
+```
+*Constraints:* `&F::operator()` is well-formed when treated as an
+unevaluated operand [[term.unevaluated.operand]] and either
+- `F::operator()` is a non-static member function and
+  `decltype(&F::operator())` is either of the form
+  `R(G::*)(A...)` cv \\ₒₚₜ ` `noexceptₒₚₜ  or of the form
+  `R(*)(G, A...) `noexceptₒₚₜ  for a type `G`, or
+- `F::operator()` is a static member function and
+  `decltype(&F::operator())` is of the form `R(*)(A...) `noexceptₒₚₜ .
+*Remarks:* The deduced type is `packaged_task<R(A...)>`.
 ``` cpp
 packaged_task(packaged_task&& rhs) noexcept;
 ```
 *Effects:* Transfers ownership of `rhs`’s shared state to `*this`,
 ``` cpp
 future<R> get_future();
 ```
 *Synchronization:* Calls to this function do not introduce data
 races  [[intro.multithread]] with calls to `operator()` or
 `make_ready_at_thread_exit`.
 [*Note 1*: Such calls need not synchronize with each
 other. — *end note*]
+*Returns:* A `future` object that shares the same shared state as
+`*this`.
 *Throws:* A `future_error` object if an error occurs.
 *Error conditions:*
 - `future_already_retrieved` if `get_future` has already been called on
 [*Note 2*: This constructs a new shared state for `*this`. The old
 state is abandoned [[futures.state]]. — *end note*]
 *Throws:*
+- `bad_alloc` if memory for the new shared state cannot be allocated.
+- Any exception thrown by the move constructor of the task stored in the
   shared state.
 - `future_error` with an error condition of `no_state` if `*this` has no
   shared state.
 #### Globals <a id="futures.task.nonmembers">[[futures.task.nonmembers]]</a>
 *Effects:* As if by `x.swap(y)`.
 <!-- Link reference definitions -->
 [alg.sorting]: algorithms.md#alg.sorting
+[allocator.requirements.general]: library.md#allocator.requirements.general
+[atomic.types.int.comp]: #atomic.types.int.comp
+[atomic.types.pointer.comp]: #atomic.types.pointer.comp
+[atomics]: #atomics
+[atomics.alias]: #atomics.alias
+[atomics.fences]: #atomics.fences
+[atomics.flag]: #atomics.flag
+[atomics.general]: #atomics.general
+[atomics.lockfree]: #atomics.lockfree
+[atomics.nonmembers]: #atomics.nonmembers
+[atomics.order]: #atomics.order
+[atomics.ref.float]: #atomics.ref.float
+[atomics.ref.generic]: #atomics.ref.generic
+[atomics.ref.generic.general]: #atomics.ref.generic.general
+[atomics.ref.int]: #atomics.ref.int
+[atomics.ref.memop]: #atomics.ref.memop
+[atomics.ref.ops]: #atomics.ref.ops
+[atomics.ref.pointer]: #atomics.ref.pointer
+[atomics.syn]: #atomics.syn
+[atomics.types.float]: #atomics.types.float
+[atomics.types.generic]: #atomics.types.generic
+[atomics.types.generic.general]: #atomics.types.generic.general
+[atomics.types.int]: #atomics.types.int
+[atomics.types.memop]: #atomics.types.memop
+[atomics.types.operations]: #atomics.types.operations
+[atomics.types.pointer]: #atomics.types.pointer
+[atomics.wait]: #atomics.wait
 [barrier.syn]: #barrier.syn
+[basic.align]: basic.md#basic.align
+[basic.fundamental]: basic.md#basic.fundamental
 [basic.life]: basic.md#basic.life
 [basic.stc.thread]: basic.md#basic.stc.thread
 [bitmask.types]: library.md#bitmask.types
+[cfenv]: numerics.md#cfenv
 [class.prop]: class.md#class.prop
+[compliance]: library.md#compliance
+[concept.booleantestable]: concepts.md#concept.booleantestable
 [condition.variable.syn]: #condition.variable.syn
+[conv.rval]: expr.md#conv.rval
 [cpp17.defaultconstructible]: #cpp17.defaultconstructible
 [cpp17.destructible]: #cpp17.destructible
 [cpp17.moveassignable]: #cpp17.moveassignable
 [cpp17.moveconstructible]: #cpp17.moveconstructible
 [defns.block]: intro.md#defns.block
 [except.terminate]: except.md#except.terminate
+[expr.pre]: expr.md#expr.pre
+[format.string.std]: utilities.md#format.string.std
+[func.invoke]: utilities.md#func.invoke
 [func.require]: utilities.md#func.require
+[function.objects]: utilities.md#function.objects
 [future.syn]: #future.syn
 [futures]: #futures
 [futures.async]: #futures.async
 [futures.errors]: #futures.errors
 [futures.future.error]: #futures.future.error
 [futures.overview]: #futures.overview
 [futures.promise]: #futures.promise
 [futures.shared.future]: #futures.shared.future
 [futures.state]: #futures.state
 [futures.task]: #futures.task
+[futures.task.general]: #futures.task.general
 [futures.task.members]: #futures.task.members
 [futures.task.nonmembers]: #futures.task.nonmembers
 [futures.unique.future]: #futures.unique.future
 [intro.multithread]: basic.md#intro.multithread
+[intro.progress]: basic.md#intro.progress
 [intro.races]: basic.md#intro.races
 [latch.syn]: #latch.syn
+[limits.syn]: support.md#limits.syn
 [mutex.syn]: #mutex.syn
 [res.on.data.races]: library.md#res.on.data.races
 [res.on.exception.handling]: library.md#res.on.exception.handling
 [semaphore.syn]: #semaphore.syn
 [shared.mutex.syn]: #shared.mutex.syn
+[stdatomic.h.syn]: #stdatomic.h.syn
 [stopcallback]: #stopcallback
 [stopcallback.cons]: #stopcallback.cons
+[stopcallback.general]: #stopcallback.general
 [stopsource]: #stopsource
 [stopsource.cons]: #stopsource.cons
+[stopsource.general]: #stopsource.general
 [stopsource.mem]: #stopsource.mem
 [stopsource.nonmembers]: #stopsource.nonmembers
 [stoptoken]: #stoptoken
 [stoptoken.cons]: #stoptoken.cons
+[stoptoken.general]: #stoptoken.general
 [stoptoken.mem]: #stoptoken.mem
 [stoptoken.nonmembers]: #stoptoken.nonmembers
 [syserr]: diagnostics.md#syserr
 [syserr.syserr]: diagnostics.md#syserr.syserr
+[term.padding.bits]: basic.md#term.padding.bits
+[term.unevaluated.operand]: expr.md#term.unevaluated.operand
 [thread]: #thread
 [thread.barrier]: #thread.barrier
 [thread.barrier.class]: #thread.barrier.class
+[thread.barrier.general]: #thread.barrier.general
 [thread.condition]: #thread.condition
 [thread.condition.condvar]: #thread.condition.condvar
 [thread.condition.condvarany]: #thread.condition.condvarany
+[thread.condition.condvarany.general]: #thread.condition.condvarany.general
+[thread.condition.general]: #thread.condition.general
 [thread.condition.nonmember]: #thread.condition.nonmember
 [thread.condvarany.intwait]: #thread.condvarany.intwait
 [thread.condvarany.wait]: #thread.condvarany.wait
 [thread.coord]: #thread.coord
+[thread.coord.general]: #thread.coord.general
 [thread.general]: #thread.general
 [thread.jthread.class]: #thread.jthread.class
+[thread.jthread.class.general]: #thread.jthread.class.general
 [thread.jthread.cons]: #thread.jthread.cons
 [thread.jthread.mem]: #thread.jthread.mem
 [thread.jthread.special]: #thread.jthread.special
 [thread.jthread.static]: #thread.jthread.static
 [thread.jthread.stop]: #thread.jthread.stop
 [thread.latch]: #thread.latch
 [thread.latch.class]: #thread.latch.class
+[thread.latch.general]: #thread.latch.general
 [thread.lock]: #thread.lock
 [thread.lock.algorithm]: #thread.lock.algorithm
+[thread.lock.general]: #thread.lock.general
 [thread.lock.guard]: #thread.lock.guard
 [thread.lock.scoped]: #thread.lock.scoped
 [thread.lock.shared]: #thread.lock.shared
 [thread.lock.shared.cons]: #thread.lock.shared.cons
+[thread.lock.shared.general]: #thread.lock.shared.general
 [thread.lock.shared.locking]: #thread.lock.shared.locking
 [thread.lock.shared.mod]: #thread.lock.shared.mod
 [thread.lock.shared.obs]: #thread.lock.shared.obs
 [thread.lock.unique]: #thread.lock.unique
 [thread.lock.unique.cons]: #thread.lock.unique.cons
+[thread.lock.unique.general]: #thread.lock.unique.general
 [thread.lock.unique.locking]: #thread.lock.unique.locking
 [thread.lock.unique.mod]: #thread.lock.unique.mod
 [thread.lock.unique.obs]: #thread.lock.unique.obs
 [thread.mutex]: #thread.mutex
 [thread.mutex.class]: #thread.mutex.class
+[thread.mutex.general]: #thread.mutex.general
 [thread.mutex.recursive]: #thread.mutex.recursive
 [thread.mutex.requirements]: #thread.mutex.requirements
 [thread.mutex.requirements.general]: #thread.mutex.requirements.general
 [thread.mutex.requirements.mutex]: #thread.mutex.requirements.mutex
+[thread.mutex.requirements.mutex.general]: #thread.mutex.requirements.mutex.general
 [thread.once]: #thread.once
 [thread.once.callonce]: #thread.once.callonce
 [thread.once.onceflag]: #thread.once.onceflag
 [thread.req]: #thread.req
 [thread.req.exception]: #thread.req.exception
 [thread.req.lockable]: #thread.req.lockable
 [thread.req.lockable.basic]: #thread.req.lockable.basic
 [thread.req.lockable.general]: #thread.req.lockable.general
 [thread.req.lockable.req]: #thread.req.lockable.req
+[thread.req.lockable.shared]: #thread.req.lockable.shared
+[thread.req.lockable.shared.timed]: #thread.req.lockable.shared.timed
 [thread.req.lockable.timed]: #thread.req.lockable.timed
 [thread.req.native]: #thread.req.native
 [thread.req.paramname]: #thread.req.paramname
 [thread.req.timing]: #thread.req.timing
 [thread.sema]: #thread.sema
 [thread.sema.cnt]: #thread.sema.cnt
+[thread.sema.general]: #thread.sema.general
 [thread.sharedmutex.class]: #thread.sharedmutex.class
 [thread.sharedmutex.requirements]: #thread.sharedmutex.requirements
+[thread.sharedmutex.requirements.general]: #thread.sharedmutex.requirements.general
 [thread.sharedtimedmutex.class]: #thread.sharedtimedmutex.class
 [thread.sharedtimedmutex.requirements]: #thread.sharedtimedmutex.requirements
+[thread.sharedtimedmutex.requirements.general]: #thread.sharedtimedmutex.requirements.general
 [thread.stoptoken]: #thread.stoptoken
 [thread.stoptoken.intro]: #thread.stoptoken.intro
 [thread.stoptoken.syn]: #thread.stoptoken.syn
 [thread.summary]: #thread.summary
 [thread.syn]: #thread.syn
 [thread.thread.algorithm]: #thread.thread.algorithm
 [thread.thread.assign]: #thread.thread.assign
 [thread.thread.class]: #thread.thread.class
+[thread.thread.class.general]: #thread.thread.class.general
 [thread.thread.constr]: #thread.thread.constr
 [thread.thread.destr]: #thread.thread.destr
 [thread.thread.id]: #thread.thread.id
 [thread.thread.member]: #thread.thread.member
 [thread.thread.static]: #thread.thread.static
 [thread.thread.this]: #thread.thread.this
 [thread.threads]: #thread.threads
+[thread.threads.general]: #thread.threads.general
 [thread.timedmutex.class]: #thread.timedmutex.class
 [thread.timedmutex.recursive]: #thread.timedmutex.recursive
 [thread.timedmutex.requirements]: #thread.timedmutex.requirements
+[thread.timedmutex.requirements.general]: #thread.timedmutex.requirements.general
 [time]: time.md#time
 [time.clock]: time.md#time.clock
 [time.clock.req]: time.md#time.clock.req
 [time.duration]: time.md#time.duration
 [time.point]: time.md#time.point
 [unord.hash]: utilities.md#unord.hash
+[util.sharedptr]: mem.md#util.sharedptr
+[util.smartptr.atomic]: #util.smartptr.atomic
+[util.smartptr.atomic.general]: #util.smartptr.atomic.general
+[util.smartptr.atomic.shared]: #util.smartptr.atomic.shared
+[util.smartptr.atomic.weak]: #util.smartptr.atomic.weak
+[^1]: Implementations for which standard time units are meaningful will
+ typically have a steady clock within their hardware implementation.
+[^2]: That is, atomic operations on the same memory location via two
+    different addresses will communicate atomically.

Diff to HTML by rtfpessoa