[thread.condition.condvarany]

Files changed (1) hide show

tmp/tmp96dbl619/{from.md → to.md} +46 -43

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

@@ -1,16 +1,19 @@
 ### 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:
@@ -70,18 +73,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;
 ```
@@ -108,20 +111,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);
 ```
@@ -146,24 +149,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);
 ```
@@ -171,24 +174,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);
 ```
@@ -246,18 +249,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);
 ```
@@ -268,11 +271,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();
 ```
@@ -284,19 +287,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);
 ```

 ### 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