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

Files changed (1) hide show

tmp/tmp8g4eg4x4/{from.md → to.md} +98 -94

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

@@ -1,7 +1,9 @@
 ## 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.
@@ -21,22 +23,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 };
 }
 ```
@@ -67,16 +72,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
@@ -140,18 +141,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;
 ```
@@ -183,21 +184,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);
 ```
@@ -214,21 +215,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);
 ```
@@ -250,25 +251,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);
 ```
@@ -285,25 +286,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);
@@ -324,26 +325,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);
@@ -364,37 +365,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:
@@ -454,18 +458,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;
 ```
@@ -492,20 +496,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);
 ```
@@ -530,24 +534,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);
 ```
@@ -555,24 +559,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);
 ```
@@ -630,18 +634,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);
 ```
@@ -652,11 +656,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();
 ```
@@ -668,19 +672,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);
 ```

 ## 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);
 ```

Diff to HTML by rtfpessoa