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

Files changed (1) hide show

tmp/tmpgysjhk9l/{from.md → to.md} +74 -104

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

@@ -18,13 +18,14 @@ three atomic parts:
 1.  the release of the mutex and entry into the waiting state;
 2.  the unblocking of the wait; and
 3.  the reacquisition of the lock.
-The implementation shall behave as if `notify_one`, `notify_all`, and
-each part of the `wait`, `wait_for`, and `wait_until` executions are
-executed in some unspecified total order.
 Condition variable construction and destruction need not be
 synchronized.
 ``` cpp
@@ -58,14 +59,13 @@ as if
 ``` cpp
 lk.unlock();
 cond.notify_all();
 ```
-*Synchronization:* The call to `notify_all_at_thread_exit` and the
-completion of the destructors for all the current thread’s variables of
-thread storage duration synchronize with ([[intro.multithread]]) calls
-to functions waiting on `cond`.
 *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
@@ -171,32 +171,29 @@ 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` or `timed_wait`)
-  threads.
 *Effects:*
 - Atomically calls `lock.unlock()` and blocks on `*this`.
 - 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.
-- If the function exits via an exception, `lock.lock()` shall be called
-  prior to exiting the function scope.
 `lock.owns_lock()` is `true` and `lock.mutex()` is locked by the calling
 thread.
-*Throws:* `system_error` when an exception is
-required ([[thread.req.exception]]).
-*Error conditions:*
-- equivalent error condition from `lock.lock()` or `lock.unlock()`.
 ``` cpp
 template <class Predicate>
   void wait(unique_lock<mutex>& lock, Predicate pred);
 ```
@@ -204,29 +201,29 @@ template <class Predicate>
 *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` or `timed_wait`)
-  threads.
-*Effects:*
 ``` cpp
 while (!pred())
   wait(lock);
 ```
 `lock.owns_lock()` is `true` and `lock.mutex()` is locked by the calling
 thread.
-*Throws:* `std::system_error` when an exception is
-required ([[thread.req.exception]]).
-*Error conditions:*
-- equivalent error condition from `lock.lock()` or `lock.unlock()`.
 ``` cpp
 template <class Clock, class Duration>
   cv_status wait_until(unique_lock<mutex>& lock,
                        const chrono::time_point<Clock, Duration>& abs_time);
@@ -248,25 +245,24 @@ thread, and either
 - The function will unblock when signaled by a call to `notify_one()`, a
   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()` shall be called
-  prior to exiting the function scope.
 `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:* `system_error` when an exception is
-required ([[thread.req.exception]]).
-*Error conditions:*
-- equivalent error condition from `lock.lock()` or `lock.unlock()`.
 ``` cpp
 template <class Rep, class Period>
   cv_status wait_for(unique_lock<mutex>& lock,
                      const chrono::duration<Rep, Period>& rel_time);
@@ -278,29 +274,28 @@ 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.
-*Effects:* as if
 ``` 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`.
 `lock.owns_lock()` is `true` and `lock.mutex()` is locked by the calling
 thread.
-*Throws:* `system_error` when an exception is
-required ([[thread.req.exception]]).
-*Error conditions:*
-- equivalent error condition from `lock.lock()` or `lock.unlock()`.
 ``` cpp
 template <class Clock, class Duration, class Predicate>
   bool wait_until(unique_lock<mutex>& lock,
                   const chrono::time_point<Clock, Duration>& abs_time,
@@ -310,36 +305,34 @@ template <class Clock, class Duration, class Predicate>
 *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` or `timed_wait`)
-  threads.
-*Effects:*
 ``` cpp
 while (!pred())
   if (wait_until(lock, abs_time) == cv_status::timeout)
     return pred();
 return true;
 ```
-*Returns:* `pred()`
 `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:* `std::system_error` when an exception is
-required ([[thread.req.exception]]).
-*Error conditions:*
-- equivalent error condition from `lock.lock()` or `lock.unlock()`.
 ``` cpp
 template <class Rep, class Period, class Predicate>
   bool wait_for(unique_lock<mutex>& lock,
                 const chrono::duration<Rep, Period>& rel_time,
@@ -352,33 +345,31 @@ 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.
-*Effects:* as if
 ``` 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.
 `lock.owns_lock()` is `true` and `lock.mutex()` is locked by the calling
 thread.
-*Returns:* `pred()`
 The returned value indicates whether the predicate evaluates to `true`
 regardless of whether the timeout was triggered.
-*Throws:* `system_error` when an exception is
-required ([[thread.req.exception]]).
-*Error conditions:*
-- equivalent error condition from `lock.lock()` or `lock.unlock()`.
 ### 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
@@ -428,12 +419,12 @@ condition_variable_any();
 *Throws:* `bad_alloc` or `system_error` when an exception is
 required ([[thread.req.exception]]).
 *Error conditions:*
-- `resource_unavailable_try_again` — if any native handle type
- manipulated is not available.
 - `operation_not_permitted` — if the thread does not have the privilege
   to perform the operation.
 ``` cpp
 ~condition_variable_any();
@@ -478,28 +469,25 @@ allows to query that, such as the `unique_lock` wrapper.
 - 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.
-- If the function exits via an exception, `lock.lock()` shall be called
-  prior to exiting the function scope.
 `lock` is locked by the calling thread.
-*Throws:* `system_error` when an exception is
-required ([[thread.req.exception]]).
-*Error conditions:*
-- equivalent error condition from `lock.lock()` or `lock.unlock()`.
 ``` cpp
 template <class Lock, class Predicate>
   void wait(Lock& lock, Predicate pred);
 ```
-*Effects:*
 ``` cpp
 while (!pred())
   wait(lock);
 ```
@@ -517,91 +505,73 @@ template <class Lock, class Clock, class Duration>
 - The function will unblock when signaled by a call to `notify_one()`, a
   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()` shall be called
-  prior to exiting the function scope.
 `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:* `system_error` when an exception is
-required ([[thread.req.exception]]).
-*Error conditions:*
-- equivalent error condition from `lock.lock()` or `lock.unlock()`.
 ``` cpp
 template <class Lock, class Rep, class Period>
   cv_status wait_for(Lock& lock, const chrono::duration<Rep, Period>& rel_time);
 ```
-*Effects:* as if
 ``` 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`.
 `lock` is locked by the calling thread.
-*Throws:* `system_error` when an exception is
-required ([[thread.req.exception]]).
-*Error conditions:*
-- equivalent error condition from `lock.lock()` or `lock.unlock()`.
 ``` 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);
 ```
-*Effects:*
 ``` cpp
 while (!pred())
   if (wait_until(lock, abs_time) == cv_status::timeout)
     return pred();
 return true;
 ```
-*Returns:* `pred()`
 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);
 ```
-*Effects:* as if
 ``` 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.
-`lock` is locked by the calling thread.
-*Returns:* `pred()`
-The returned value indicates whether the predicate evaluates to `true`
-regardless of whether the timeout was triggered.
-*Throws:* `system_error` when an exception is
-required ([[thread.req.exception]]).
-*Error conditions:*
-- equivalent error condition from `lock.lock()` or `lock.unlock()`.

 1.  the release of the mutex and entry into the waiting state;
 2.  the unblocking of the wait; and
 3.  the reacquisition of the lock.
+The implementation shall behave 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.
 ``` cpp
 ``` 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
 `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.
 *Effects:*
 - Atomically calls `lock.unlock()` and blocks on `*this`.
 - 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,
+`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>
   void wait(unique_lock<mutex>& lock, 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.
+*Effects:* Equivalent to:
 ``` cpp
 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);
 - The function will unblock when signaled by a call to `notify_one()`, a
   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()` 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`.
+*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);
 - 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.
+*Effects:* Equivalent to:
 ``` 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,
+`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>
   bool 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.
+*Effects:* Equivalent to:
 ``` cpp
 while (!pred())
   if (wait_until(lock, abs_time) == cv_status::timeout)
     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
 template <class Rep, class Period, class Predicate>
   bool wait_for(unique_lock<mutex>& lock,
                 const chrono::duration<Rep, Period>& rel_time,
 - 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.
+*Effects:* Equivalent to:
 ``` 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
 *Throws:* `bad_alloc` or `system_error` when an exception is
 required ([[thread.req.exception]]).
 *Error conditions:*
+- `resource_unavailable_try_again` — if some non-memory resource
+ limitation prevents initialization.
 - `operation_not_permitted` — if the thread does not have the privilege
   to perform the operation.
 ``` cpp
 ~condition_variable_any();
 - 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>
   void wait(Lock& lock, Predicate pred);
 ```
+*Effects:* Equivalent to:
 ``` cpp
 while (!pred())
   wait(lock);
 ```
 - The function will unblock when signaled by a call to `notify_one()`, a
   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()` 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`.
+*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);
 ```
+*Effects:* Equivalent to:
 ``` 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,
+`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>
   bool wait_until(Lock& lock, const chrono::time_point<Clock, Duration>& abs_time, Predicate pred);
 ```
+*Effects:* Equivalent to:
 ``` cpp
 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);
 ```
+*Effects:* Equivalent to:
 ``` cpp
 return wait_until(lock, chrono::steady_clock::now() + rel_time, std::move(pred));
 ```

Diff to HTML by rtfpessoa