[thread.condition] - C++14 → C++17

Files changed (1) hide show

tmp/tmptklwi16k/{from.md → to.md} +118 -87

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

@@ -26,10 +26,12 @@ executions are executed in a single unspecified total order consistent
 with the "happens before" order.
 Condition variable construction and destruction need not be
 synchronized.
 ``` cpp
 namespace std {
   class condition_variable;
   class condition_variable_any;
@@ -37,10 +39,12 @@ namespace std {
   enum class cv_status { no_timeout, timeout };
 }
 ```
 ``` cpp
 void notify_all_at_thread_exit(condition_variable& cond, unique_lock<mutex> lk);
 ```
 *Requires:* `lk` is locked by the calling thread and either
@@ -48,37 +52,38 @@ void notify_all_at_thread_exit(condition_variable& cond, unique_lock<mutex> lk);
 - no other thread is waiting on `cond`, or
 - `lk.mutex()` returns the same value for each of the lock arguments
   supplied by all concurrently waiting (via `wait`, `wait_for`, or
   `wait_until`) threads.
-*Effects:* transfers ownership of the lock associated with `lk` into
 internal storage and schedules `cond` to be notified when the current
 thread exits, after all objects of thread storage duration associated
 with the current thread have been destroyed. This notification shall be
-as if
 ``` cpp
 lk.unlock();
 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:* The supplied lock will be held until the thread exits, and care
-must 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.
-*Note:* 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
 this lock is not released and reacquired prior to calling
-`notify_all_at_thread_exit`.
 ### Class `condition_variable` <a id="thread.condition.condvar">[[thread.condition.condvar]]</a>
 ``` cpp
 namespace std {
@@ -110,11 +115,11 @@ namespace std {
     template <class Rep, class Period, class Predicate>
       bool wait_for(unique_lock<mutex>& lock,
                     const chrono::duration<Rep, Period>& rel_time,
                     Predicate pred);
- typedef implementation-defined native_handle_type; // See~[thread.req.native]
     native_handle_type native_handle();                // See~[thread.req.native]
   };
 }
 ```
@@ -137,19 +142,21 @@ required ([[thread.req.exception]]).
 ``` cpp
 ~condition_variable();
 ```
-There shall be no thread blocked on `*this`. That is, all threads shall
-have been notified; they may 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 must happen before destruction. The user must 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.
 *Effects:* Destroys the object.
 ``` cpp
 void notify_one() noexcept;
@@ -166,12 +173,12 @@ void notify_all() noexcept;
 ``` cpp
 void wait(unique_lock<mutex>& lock);
 ```
-`lock.owns_lock()` is `true` and `lock.mutex()` is locked by the calling
-thread, and either
 - no other thread is waiting on this `condition_variable` object or
 - `lock.mutex()` returns the same value for each of the `lock` arguments
   supplied by all concurrently waiting (via `wait`, `wait_for`, or
   `wait_until`) threads.
@@ -183,15 +190,17 @@ thread, and either
   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,
-`std::terminate()` shall be called ([[except.terminate]]). This can
-happen if the re-locking of the mutex throws an exception.
-`lock.owns_lock()` is `true` and `lock.mutex()` is locked by the calling
-thread.
 *Throws:* Nothing.
 ``` cpp
 template <class Predicate>
@@ -212,27 +221,28 @@ the calling thread, and either
 while (!pred())
   wait(lock);
 ```
 *Remarks:* If the function fails to meet the postcondition,
-`std::terminate()` shall be called ([[except.terminate]]). This can
-happen if the re-locking of the mutex throws an exception.
-`lock.owns_lock()` is `true` and `lock.mutex()` is locked by the calling
-thread.
-*Throws:* Timeout-related exceptions ([[thread.req.timing]]) or 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);
 ```
-`lock.owns_lock()` is `true` and `lock.mutex()` is locked by the calling
-thread, and either
 - no other thread is waiting on this `condition_variable` object or
 - `lock.mutex()` returns the same value for each of the `lock` arguments
   supplied by all concurrently waiting (via `wait`, `wait_for`, or
   `wait_until`) threads.
@@ -248,15 +258,17 @@ thread, and either
   spuriously.
 - If the function exits via an exception, `lock.lock()` shall be called
   prior to exiting the function.
 *Remarks:* If the function fails to meet the postcondition,
-`std::terminate()` shall be called ([[except.terminate]]). This can
-happen if the re-locking of the mutex throws an exception.
-`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`.
@@ -266,12 +278,12 @@ otherwise `cv_status::no_timeout`.
 template <class Rep, class Period>
   cv_status wait_for(unique_lock<mutex>& lock,
                      const chrono::duration<Rep, Period>& rel_time);
 ```
-`lock.owns_lock()` is `true` and `lock.mutex()` is locked by the calling
-thread, and either
 - no other thread is waiting on this `condition_variable` object or
 - `lock.mutex()` returns the same value for each of the `lock` arguments
   supplied by all concurrently waiting (via `wait`, `wait_for`, or
   `wait_until`) threads.
@@ -285,15 +297,17 @@ 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,
-`std::terminate()` shall be called ([[except.terminate]]). This can
-happen if the re-locking of the mutex throws an exception.
-`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>
@@ -318,18 +332,21 @@ while (!pred())
     return pred();
 return true;
 ```
 *Remarks:* If the function fails to meet the postcondition,
-`std::terminate()` shall be called ([[except.terminate]]). This can
-happen if the re-locking of the mutex throws an exception.
-`lock.owns_lock()` is `true` and `lock.mutex()` is locked by the calling
-thread.
-The returned value indicates whether the predicate evaluated to `true`
-regardless of whether the timeout was triggered.
 *Throws:* Timeout-related exceptions ([[thread.req.timing]]) or any
 exception thrown by `pred`.
 ``` cpp
@@ -337,12 +354,12 @@ template <class Rep, class Period, class Predicate>
   bool wait_for(unique_lock<mutex>& lock,
                 const chrono::duration<Rep, Period>& rel_time,
                 Predicate pred);
 ```
-`lock.owns_lock()` is `true` and `lock.mutex()` is locked by the calling
-thread, and either
 - no other thread is waiting on this `condition_variable` object or
 - `lock.mutex()` returns the same value for each of the `lock` arguments
   supplied by all concurrently waiting (via `wait`, `wait_for`, or
   `wait_until`) threads.
@@ -351,35 +368,40 @@ thread, and either
 ``` cpp
 return wait_until(lock, chrono::steady_clock::now() + rel_time, std::move(pred));
 ```
-There is no blocking if `pred()` is initially `true`, even if the
-timeout has already expired.
 *Remarks:* If the function fails to meet the postcondition,
-`std::terminate()` shall be called ([[except.terminate]]). This can
-happen if the re-locking of the mutex throws an exception.
-`lock.owns_lock()` is `true` and `lock.mutex()` is locked by the calling
-thread.
-The returned value indicates whether the predicate evaluates to `true`
-regardless of whether the timeout was triggered.
 *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 `BasicLockable` requirements (
-[[thread.req.lockable.basic]]). 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 must ensure that any necessary
 synchronization is in place with respect to the predicate associated
-with the `condition_variable_any` instance.
 ``` cpp
 namespace std {
   class condition_variable_any {
   public:
@@ -428,19 +450,21 @@ required ([[thread.req.exception]]).
 ``` cpp
 ~condition_variable_any();
 ```
-There shall be no thread blocked on `*this`. That is, all threads shall
-have been notified; they may 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 must happen before destruction. The user must 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.
 *Effects:* Destroys the object.
 ``` cpp
 void notify_one() noexcept;
@@ -458,27 +482,29 @@ void notify_all() noexcept;
 ``` cpp
 template <class Lock>
   void wait(Lock& lock);
 ```
-*Note:* if any of the `wait` functions exits via an exception, it is
 unspecified whether the `Lock` is held. One can use a `Lock` type that
-allows to query that, such as the `unique_lock` wrapper.
 *Effects:*
 - Atomically calls `lock.unlock()` and blocks on `*this`.
 - 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,
-`std::terminate()` shall be called ([[except.terminate]]). This can
-happen if the re-locking of the mutex throws an exception.
-`lock` is locked by the calling thread.
 *Throws:* Nothing.
 ``` cpp
 template <class Lock, class Predicate>
@@ -508,14 +534,16 @@ template <class Lock, class Clock, class Duration>
   spuriously.
 - If the function exits via an exception, `lock.lock()` shall be called
   prior to exiting the function.
 *Remarks:* If the function fails to meet the postcondition,
-`std::terminate()` shall be called ([[except.terminate]]). This can
-happen if the re-locking of the mutex throws an exception.
-`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`.
@@ -535,14 +563,16 @@ 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,
-`std::terminate()` shall be called ([[except.terminate]]). This can
-happen if the re-locking of the mutex throws an exception.
-`lock` is locked by the calling thread.
 *Throws:* Timeout-related exceptions ([[thread.req.timing]]).
 ``` cpp
 template <class Lock, class Clock, class Duration, class Predicate>
@@ -556,15 +586,16 @@ while (!pred())
   if (wait_until(lock, abs_time) == cv_status::timeout)
     return pred();
 return true;
 ```
-There is no blocking if `pred()` is initially `true`, or if the timeout
-has already expired.
-The returned value indicates whether the predicate evaluates to `true`
-regardless of whether the timeout was triggered.
 ``` cpp
 template <class Lock, class Rep, class Period, class Predicate>
   bool wait_for(Lock& lock, const chrono::duration<Rep, Period>& rel_time, Predicate pred);
 ```

 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;
   enum class cv_status { no_timeout, timeout };
 }
 ```
+### Non-member functions <a id="thread.condition.nonmember">[[thread.condition.nonmember]]</a>
 ``` cpp
 void notify_all_at_thread_exit(condition_variable& cond, unique_lock<mutex> lk);
 ```
 *Requires:* `lk` is locked by the calling thread and either
 - no other thread is waiting on `cond`, or
 - `lk.mutex()` returns the same value for each of the lock arguments
   supplied by all concurrently waiting (via `wait`, `wait_for`, or
   `wait_until`) threads.
+*Effects:* Transfers ownership of the lock associated with `lk` into
 internal storage and schedules `cond` to be notified when the current
 thread exits, after all objects of thread storage duration associated
 with the current thread have been destroyed. This notification shall be
+as if:
 ``` cpp
 lk.unlock();
 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 must 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
 this lock is not released and reacquired prior to calling
+`notify_all_at_thread_exit`. — *end note*]
 ### Class `condition_variable` <a id="thread.condition.condvar">[[thread.condition.condvar]]</a>
 ``` cpp
 namespace std {
     template <class Rep, class Period, class Predicate>
       bool wait_for(unique_lock<mutex>& lock,
                     const chrono::duration<Rep, Period>& rel_time,
                     Predicate pred);
+ using native_handle_type = implementation-defined; // See~[thread.req.native]
     native_handle_type native_handle();                // See~[thread.req.native]
   };
 }
 ```
 ``` cpp
 ~condition_variable();
 ```
+*Requires:* There shall be no thread blocked on `*this`.
+[*Note 1*: That is, all threads shall have been notified; they may
+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 must happen
+before destruction. The user must 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*]
 *Effects:* Destroys the object.
 ``` cpp
 void notify_one() noexcept;
 ``` cpp
 void wait(unique_lock<mutex>& lock);
 ```
+*Requires:* `lock.owns_lock()` is `true` and `lock.mutex()` is locked by
+the calling thread, and either
 - no other thread is waiting on this `condition_variable` object or
 - `lock.mutex()` returns the same value for each of the `lock` arguments
   supplied by all concurrently waiting (via `wait`, `wait_for`, or
   `wait_until`) threads.
   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()` shall be called ([[except.terminate]]).
+[*Note 2*: This can happen if the re-locking of the mutex throws an
+exception. — *end note*]
+*Postconditions:* `lock.owns_lock()` is `true` and `lock.mutex()` is
+locked by the calling thread.
 *Throws:* Nothing.
 ``` cpp
 template <class Predicate>
 while (!pred())
   wait(lock);
 ```
 *Remarks:* If the function fails to meet the postcondition,
+`terminate()` shall be called ([[except.terminate]]).
+[*Note 3*: This can happen if the re-locking of the mutex throws an
+exception. — *end note*]
+*Postconditions:* `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);
 ```
+*Requires:* `lock.owns_lock()` is `true` and `lock.mutex()` is locked by
+the calling thread, and either
 - no other thread is waiting on this `condition_variable` object or
 - `lock.mutex()` returns the same value for each of the `lock` arguments
   supplied by all concurrently waiting (via `wait`, `wait_for`, or
   `wait_until`) threads.
   spuriously.
 - If the function exits via an exception, `lock.lock()` shall be called
   prior to exiting the function.
 *Remarks:* If the function fails to meet the postcondition,
+`terminate()` shall be called ([[except.terminate]]).
+[*Note 4*: This can happen if the re-locking of the mutex throws an
+exception. — *end note*]
+*Postconditions:* `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`.
 template <class Rep, class Period>
   cv_status wait_for(unique_lock<mutex>& lock,
                      const chrono::duration<Rep, Period>& rel_time);
 ```
+*Requires:* `lock.owns_lock()` is `true` and `lock.mutex()` is locked by
+the calling thread, and either
 - no other thread is waiting on this `condition_variable` object or
 - `lock.mutex()` returns the same value for each of the `lock` arguments
   supplied by all concurrently waiting (via `wait`, `wait_for`, or
   `wait_until`) threads.
 *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()` shall be called ([[except.terminate]]).
+[*Note 5*: This can happen if the re-locking of the mutex throws an
+exception. — *end note*]
+*Postconditions:* `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>
     return pred();
 return true;
 ```
 *Remarks:* If the function fails to meet the postcondition,
+`terminate()` shall be called ([[except.terminate]]).
+[*Note 6*: This can happen if the re-locking of the mutex throws an
+exception. — *end note*]
+*Postconditions:* `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
   bool wait_for(unique_lock<mutex>& lock,
                 const chrono::duration<Rep, Period>& rel_time,
                 Predicate pred);
 ```
+*Requires:* `lock.owns_lock()` is `true` and `lock.mutex()` is locked by
+the calling thread, and either
 - no other thread is waiting on this `condition_variable` object or
 - `lock.mutex()` returns the same value for each of the `lock` arguments
   supplied by all concurrently waiting (via `wait`, `wait_for`, or
   `wait_until`) threads.
 ``` cpp
 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()` shall be called ([[except.terminate]]).
+[*Note 9*: This can happen if the re-locking of the mutex throws an
+exception. — *end note*]
+*Postconditions:* `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 `BasicLockable` 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 must 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:
 ``` cpp
 ~condition_variable_any();
 ```
+*Requires:* There shall be no thread blocked on `*this`.
+[*Note 1*: That is, all threads shall have been notified; they may
+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 must happen
+before destruction. The user must 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*]
 *Effects:* Destroys the object.
 ``` cpp
 void notify_one() noexcept;
 ``` cpp
 template <class Lock>
   void wait(Lock& lock);
 ```
+[*Note 2*: If any of the `wait` functions exits via an exception, it is
 unspecified whether the `Lock` is held. One can use a `Lock` type that
+allows to query that, such as the `unique_lock` wrapper. — *end note*]
 *Effects:*
 - Atomically calls `lock.unlock()` and blocks on `*this`.
 - 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()` shall be called ([[except.terminate]]).
+[*Note 3*: This can happen if the re-locking of the mutex throws an
+exception. — *end note*]
+*Postconditions:* `lock` is locked by the calling thread.
 *Throws:* Nothing.
 ``` cpp
 template <class Lock, class Predicate>
   spuriously.
 - If the function exits via an exception, `lock.lock()` shall be called
   prior to exiting the function.
 *Remarks:* If the function fails to meet the postcondition,
+`terminate()` shall be called ([[except.terminate]]).
+[*Note 4*: This can happen if the re-locking of the mutex throws an
+exception. — *end note*]
+*Postconditions:* `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`.
 *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()` shall be called ([[except.terminate]]).
+[*Note 5*: This can happen if the re-locking of the mutex throws an
+exception. — *end note*]
+*Postconditions:* `lock` is locked by the calling thread.
 *Throws:* Timeout-related exceptions ([[thread.req.timing]]).
 ``` cpp
 template <class Lock, class Clock, class Duration, class Predicate>
   if (wait_until(lock, abs_time) == cv_status::timeout)
     return pred();
 return true;
 ```
+[*Note 6*: There is no blocking if `pred()` is initially `true`, or if
+the timeout has already expired. — *end note*]
+[*Note 7*: The returned value indicates whether the predicate evaluates
+to `true` regardless of whether the timeout was
+triggered. — *end note*]
 ``` cpp
 template <class Lock, class Rep, class Period, class Predicate>
   bool wait_for(Lock& lock, const chrono::duration<Rep, Period>& rel_time, Predicate pred);
 ```

Diff to HTML by rtfpessoa