[libc++] Implement `std::condition_variable_any::wait[_for/until]` overloads that take `stop_token`

[huixie90]

Summary

• This is section 32.6.4 of P0660R10
• https://eel.is/c++draft/thread.condvarany.intwait

[huixie90]

CI

[Mordante]

In general looks good. I have some minor comments. I think it would be good to keep track how often predicates are called and whether that matches the (minimal) expectation. For example when a stop_requested() == true the predicate is called exactly one time.

libcxx/include/condition_variable

106

Can you align the // since C++20 ?

319

328

libcxx/test/std/thread/thread.condition/thread.condition.condvarany/wait_for_token_pred.pass.cpp

96

This is our typical code style.

135

I wonder here and at other places whether 2 ms is long enough.
Are we sure this is changed after the wait_for is really in it's loop? Or can the flag be set before entering the loop.

Would it make sense to validate how often the predicate is executed? When it's less than 2 the loop was executed 0 times.

libcxx/test/std/thread/thread.condition/thread.condition.condvarany/wait_token_pred.pass.cpp

43

Please include <concepts>.

[ldionne]

Commandeering per discussion w/ Hui.

libcxx/include/condition_variable

95

Let's mark this as experimental.

[huixie90]

address feedback rebase

[huixie90]

CI

[huixie90]

libcxx/include/condition_variable

319

this is a member function call . not std::wait_until

328

this is a member function call, not std::wait_until

[huixie90]

rebase

[huixie90]

FTM

[huixie90]

CI

[huixie90]

CI

[huixie90]

CI

[huixie90]

CI

[huixie90]

guard stop_token headers with no thread macro

[huixie90]

ci

[ldionne]

libcxx/test/std/thread/thread.condition/thread.condition.condvarany/wait_for_token_pred.pass.cpp

135

If the thread creation is really slow, this test could be vacuous (it would test the same as the test that does request_stop() before we wait_for). Would it make sense to instead do something like:

auto thread = support::make_test_thread([&]() {
    // wait until we're ready
    some_atomic.wait(...);
    ss.request_stop();

    while (!done) {
        cv.notify_all();
        std::this_thread::sleep_for(2ms);
      }
});

std::same_as<bool> auto r = cv.wait_for(lock, ss.get_token(), 1h, [&]() {
  some_atomic.notify_all(); // here signal that we're ready for the other thread to request a stop
  return false;
});
assert(!r);
done = true;
thread.join();

Does this make sense at all? That way the pred will be the one to trigger the fact that we request_stop() on the other thread. Would that be more robust?

libcxx/test/std/thread/thread.condition/thread.condition.condvarany/wait_token_pred.pass.cpp

80

Whatever we do for the other test we should do here too.

libcxx/test/std/thread/thread.condition/thread.condition.condvarany/wait_until_token_pred.pass.cpp

130

And here.

[huixie90]

address feedback

[ldionne]

LGTM with minor nitpick. You can ignore the CI failures since they are unrelated and have been fixed since then. Thanks!

libcxx/docs/Status/Cxx20.rst

51

libcxx/docs/FeatureTestMacroTable.rst

.. table:: Current Status
     ``__cpp_lib_is_constant_evaluated``                 ``201811L``
     --------------------------------------------------- -----------------
     ``__cpp_lib_is_layout_compatible``                  *unimplemented*
     --------------------------------------------------- -----------------
     ``__cpp_lib_is_nothrow_convertible``                ``201806L``
     --------------------------------------------------- -----------------
     ``__cpp_lib_is_pointer_interconvertible``           *unimplemented*
     --------------------------------------------------- -----------------
-    ``__cpp_lib_jthread``                               *unimplemented*
+    ``__cpp_lib_jthread``                               ``201911L``
     --------------------------------------------------- -----------------
     ``__cpp_lib_latch``                                 ``201907L``
     --------------------------------------------------- -----------------
     ``__cpp_lib_list_remove_return_type``               ``201806L``
     --------------------------------------------------- -----------------
     ``__cpp_lib_math_constants``                        ``201907L``
     --------------------------------------------------- -----------------
     ``__cpp_lib_move_iterator_concept``                 ``202207L``

libcxx/docs/Status/Cxx20.rst

.. note::
    .. [#note-P0591] P0591: The changes in [mem.poly.allocator.mem] are missing.
    .. [#note-P0645] P0645: The paper is implemented but still marked as an incomplete feature
       (the feature-test macro is not set).
    .. [#note-P0966] P0966: It was previously erroneously marked as complete in version 8.0. See `bug 45368 <https://llvm.org/PR45368>`__.
    .. [#note-P0619] P0619: Only sections D.8, D.9, D.10 and D.13 are implemented. Sections D.4, D.7, D.11, D.12, and D.14 remain undone.
    .. [#note-P0883.1] P0883: shared_ptr and floating-point changes weren't applied as they themselves aren't implemented yet.
    .. [#note-P0883.2] P0883: ``ATOMIC_FLAG_INIT`` was marked deprecated in version 14.0, but was undeprecated with the implementation of LWG3659 in version 15.0.
    .. [#note-P2231] P2231: Optional is complete. The changes to variant haven't been implemented yet.
-   .. [#note-P0660] P0660: Section 32.3 Stop Tokens is complete. ``jthread`` hasn't been implemented yet.
+   .. [#note-P0660] P0660: The paper is implemented but the features are experimental and can be enabled via ``-fexperimental-library``.
    .. [#note-P0355] P0355: The implementation status is:
 
       * ``Calendars`` mostly done in Clang 7
       * ``Input parsers`` not done
       * ``Stream output`` Obsolete due to `P1361R2 <https://wg21.link/P1361R2>`_ "Integration of chrono with text formatting"
       * ``Time zone and leap seconds`` In Progress
       * ``TAI clock`` not done
       * ``GPS clock`` not done

libcxx/docs/Status/Cxx20Papers.csv

 "`P1464R1 <https://wg21.link/P1464R1>`__","LWG","Mandating the Standard Library: Clause 22 - Iterators library","Kona","|Complete|","9.0"
 "","","","","","",""
 "`P0325R4 <https://wg21.link/P0325R4>`__","LWG","to_array from LFTS with updates","Cologne","|Complete|","10.0"
 "`P0408R7 <https://wg21.link/P0408R7>`__","LWG","Efficient Access to basic_stringbuf's Buffer","Cologne","|Complete|","17.0"
 "`P0466R5 <https://wg21.link/P0466R5>`__","LWG","Layout-compatibility and Pointer-interconvertibility Traits","Cologne","",""
 "`P0553R4 <https://wg21.link/P0553R4>`__","LWG","Bit operations","Cologne","|Complete|","9.0"
 "`P0631R8 <https://wg21.link/P0631R8>`__","LWG","Math Constants","Cologne","|Complete|","11.0"
 "`P0645R10 <https://wg21.link/P0645R10>`__","LWG","Text Formatting","Cologne","|Complete| [#note-P0645]_","14.0"
-"`P0660R10 <https://wg21.link/P0660R10>`__","LWG","Stop Token and Joining Thread, Rev 10.","Cologne","|In Progress| [#note-P0660]_",""
+"`P0660R10 <https://wg21.link/P0660R10>`__","LWG","Stop Token and Joining Thread, Rev 10.","Cologne","|Complete| [#note-P0660]_","18.0.0"
 "`P0784R7 <https://wg21.link/P0784R7>`__","CWG","More constexpr containers","Cologne","|Complete|","12.0"
 "`P0980R1 <https://wg21.link/P0980R1>`__","LWG","Making std::string constexpr","Cologne","|Complete|","15.0"
 "`P1004R2 <https://wg21.link/P1004R2>`__","LWG","Making std::vector constexpr","Cologne","|Complete|","15.0"
 "`P1035R7 <https://wg21.link/P1035R7>`__","LWG","Input Range Adaptors","Cologne","|Complete|","16.0","|ranges|"
 "`P1065R2 <https://wg21.link/P1065R2>`__","LWG","Constexpr INVOKE","Cologne","|Complete|","12.0"
 "`P1135R6 <https://wg21.link/P1135R6>`__","LWG","The C++20 Synchronization Library","Cologne","|Complete|","11.0"
 "`P1207R4 <https://wg21.link/P1207R4>`__","LWG","Movability of Single-pass Iterators","Cologne","|Complete|","15.0","|ranges|"
 "`P1208R6 <https://wg21.link/P1208R6>`__","LWG","Adopt source_location for C++20","Cologne","|Complete|","16.0"

libcxx/include/__stop_token/stop_callback.h

 #  pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-#if _LIBCPP_STD_VER >= 20 && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_STOP_TOKEN)
+#if _LIBCPP_STD_VER >= 20 && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_STOP_TOKEN) && !defined(_LIBCPP_HAS_NO_THREADS)
 
 template <class _Callback>
 class _LIBCPP_AVAILABILITY_SYNC stop_callback : private __stop_callback_base {
   static_assert(invocable<_Callback>,
                 "Mandates: stop_callback is instantiated with an argument for the template parameter Callback that "
                 "satisfies invocable.");
   static_assert(destructible<_Callback>,
                 "Mandates: stop_callback is instantiated with an argument for the template parameter Callback that "

 _LIBCPP_AVAILABILITY_SYNC stop_callback(stop_token, _Callback) -> stop_callback<_Callback>;
 
 #endif // _LIBCPP_STD_VER >= 20
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
-#endif // _LIBCPP_STD_VER >= 20 && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_STOP_TOKEN)
+#endif // _LIBCPP_STD_VER >= 20 && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_STOP_TOKEN) && !defined(_LIBCPP_HAS_NO_THREADS)

libcxx/include/__stop_token/stop_source.h

 #include <__utility/move.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-#if _LIBCPP_STD_VER >= 20 && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_STOP_TOKEN)
+#if _LIBCPP_STD_VER >= 20 && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_STOP_TOKEN) && !defined(_LIBCPP_HAS_NO_THREADS)
 
 struct nostopstate_t {
   explicit nostopstate_t() = default;
 };
 
 inline constexpr nostopstate_t nostopstate{};
 
 class _LIBCPP_AVAILABILITY_SYNC stop_source {

 private:
   __intrusive_shared_ptr<__stop_state> __state_;
 };
 
 #endif // _LIBCPP_STD_VER >= 20
 
 _LIBCPP_END_NAMESPACE_STD
 
-#endif // _LIBCPP_STD_VER >= 20 && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_STOP_TOKEN)
+#endif // _LIBCPP_STD_VER >= 20 && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_STOP_TOKEN) && !defined(_LIBCPP_HAS_NO_THREADS)

libcxx/include/__stop_token/stop_state.h

 #include <cstdint>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-#if _LIBCPP_STD_VER >= 20
+#if _LIBCPP_STD_VER >= 20 && !defined(_LIBCPP_HAS_NO_THREADS)
 
 struct __stop_callback_base : __intrusive_node_base<__stop_callback_base> {
   using __callback_fn_t = void(__stop_callback_base*) noexcept;
   _LIBCPP_HIDE_FROM_ABI explicit __stop_callback_base(__callback_fn_t* __callback_fn) : __callback_fn_(__callback_fn) {}
 
   _LIBCPP_HIDE_FROM_ABI void __invoke() noexcept { __callback_fn_(this); }
 
   __callback_fn_t* __callback_fn_;

 
 template <>
 struct __intrusive_shared_ptr_traits<__stop_state> {
   _LIBCPP_HIDE_FROM_ABI static atomic<uint32_t>& __get_atomic_ref_count(__stop_state& __state) {
     return __state.__ref_count_;
   }
 };
 
-#endif // _LIBCPP_STD_VER >= 20
+#endif // _LIBCPP_STD_VER >= 20 && !defined(_LIBCPP_HAS_NO_THREADS)
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___STOP_TOKEN_STOP_STATE_H

libcxx/include/__stop_token/stop_token.h

 #include <__stop_token/stop_state.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-#if _LIBCPP_STD_VER >= 20 && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_STOP_TOKEN)
+#if _LIBCPP_STD_VER >= 20 && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_STOP_TOKEN) && !defined(_LIBCPP_HAS_NO_THREADS)
 
 class _LIBCPP_AVAILABILITY_SYNC stop_token {
 public:
   _LIBCPP_HIDE_FROM_ABI stop_token() noexcept = default;
 
   _LIBCPP_HIDE_FROM_ABI stop_token(const stop_token&) noexcept            = default;
   _LIBCPP_HIDE_FROM_ABI stop_token(stop_token&&) noexcept                 = default;
   _LIBCPP_HIDE_FROM_ABI stop_token& operator=(const stop_token&) noexcept = default;
private:
 
   friend class stop_source;
   template <class _Tp>
   friend class stop_callback;
 
   _LIBCPP_HIDE_FROM_ABI explicit stop_token(const __intrusive_shared_ptr<__stop_state>& __state) : __state_(__state) {}
 };
 
-#endif // _LIBCPP_STD_VER >= 20 && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_STOP_TOKEN)
+#endif // _LIBCPP_STD_VER >= 20 && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_STOP_TOKEN) && !defined(_LIBCPP_HAS_NO_THREADS)
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___STOP_TOKEN_STOP_TOKEN_H

libcxx/include/condition_variable

public:
     template <class Lock, class Clock, class Duration, class Predicate>
         bool
         wait_until(Lock& lock,
                    const chrono::time_point<Clock, Duration>& abs_time,
                    Predicate pred);
 
     template <class Lock, class Rep, class Period>
         cv_status
         wait_for(Lock& lock,
                  const chrono::duration<Rep, Period>& rel_time);
 
     template <class Lock, class Rep, class Period, class Predicate>
         bool
         wait_for(Lock& lock,
                  const chrono::duration<Rep, Period>& rel_time,
                  Predicate pred);
+
+    // [thread.condvarany.intwait], interruptible waits
+    template <class Lock, class Predicate>
+      bool wait(Lock& lock, stop_token stoken, Predicate pred);                               // since C++20
+
+    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);   // since C++20
+
+    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);           // since C++20
 };
 
 }  // std
 
 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
+#include <__availability>
 #include <__chrono/duration.h>
 #include <__chrono/steady_clock.h>
 #include <__chrono/time_point.h>
 #include <__condition_variable/condition_variable.h>
 #include <__config>
 #include <__memory/shared_ptr.h>
 #include <__memory/unique_ptr.h>
 #include <__mutex/lock_guard.h>
 #include <__mutex/mutex.h>
 #include <__mutex/tag_types.h>
 #include <__mutex/unique_lock.h>
+#include <__stop_token/stop_token.h>
 #include <__utility/move.h>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #ifndef _LIBCPP_HAS_NO_THREADS
template <class _Lock, class _Rep, class _Period>
                  const chrono::duration<_Rep, _Period>& __d);
 
     template <class _Lock, class _Rep, class _Period, class _Predicate>
         bool
         _LIBCPP_INLINE_VISIBILITY
         wait_for(_Lock& __lock,
                  const chrono::duration<_Rep, _Period>& __d,
                  _Predicate __pred);
+
+#if _LIBCPP_STD_VER >= 20 && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_STOP_TOKEN)
+
+    template <class _Lock, class _Predicate>
+    _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI bool wait(_Lock& __lock, stop_token __stoken, _Predicate __pred);
+
+    template <class _Lock, class _Clock, class _Duration, class _Predicate>
+    _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI bool wait_until(_Lock& __lock, stop_token __stoken,
+                const chrono::time_point<_Clock, _Duration>& __abs_time, _Predicate __pred);
+
+    template <class _Lock, class _Rep, class _Period, class _Predicate>
+    _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI bool wait_for(_Lock& __lock, stop_token __stoken,
+                const chrono::duration<_Rep, _Period>& __rel_time, _Predicate __pred);
+
+#endif // _LIBCPP_STD_VER >= 20 && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_STOP_TOKEN)
 };
 
 inline
 condition_variable_any::condition_variable_any()
     : __mut_(make_shared<mutex>()) {}
 
 inline
 void

 condition_variable_any::wait_for(_Lock& __lock,
                                  const chrono::duration<_Rep, _Period>& __d,
                                  _Predicate __pred)
 {
     return wait_until(__lock, chrono::steady_clock::now() + __d,
                       _VSTD::move(__pred));
 }
 
+#if _LIBCPP_STD_VER >= 20 && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_STOP_TOKEN)
+
+template <class _Lock, class _Predicate>
+bool condition_variable_any::wait(_Lock& __lock, stop_token __stoken, _Predicate __pred) {
+    while (!__stoken.stop_requested()) {
+        if (__pred())
+            return true;
+        wait(__lock);
+    }
+    return __pred();
+}
+
+template <class _Lock, class _Clock, class _Duration, class _Predicate>
+bool condition_variable_any::wait_until(
+    _Lock& __lock, stop_token __stoken, const chrono::time_point<_Clock, _Duration>& __abs_time, _Predicate __pred) {
+    while (!__stoken.stop_requested()) {
+        if (__pred())
+            return true;
+        if (wait_until(__lock, __abs_time) == cv_status::timeout)
+            return __pred();
+    }
+    return __pred();
+}
+
+template <class _Lock, class _Rep, class _Period, class _Predicate>
+bool condition_variable_any::wait_for(
+    _Lock& __lock, stop_token __stoken, const chrono::duration<_Rep, _Period>& __rel_time, _Predicate __pred) {
+    return wait_until(__lock, std::move(__stoken), chrono::steady_clock::now() + __rel_time, std::move(__pred));
+}
+
+#endif // _LIBCPP_STD_VER >= 20 && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_STOP_TOKEN)
+
 _LIBCPP_EXPORTED_FROM_ABI void notify_all_at_thread_exit(condition_variable&, unique_lock<mutex>);
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // !_LIBCPP_HAS_NO_THREADS
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <atomic>

libcxx/include/version

 # define __cpp_lib_generic_unordered_lookup             201811L
 # define __cpp_lib_int_pow2                             202002L
 # define __cpp_lib_integer_comparison_functions         202002L
 # define __cpp_lib_interpolate                          201902L
 # define __cpp_lib_is_constant_evaluated                201811L
 // # define __cpp_lib_is_layout_compatible                 201907L
 # define __cpp_lib_is_nothrow_convertible               201806L
 // # define __cpp_lib_is_pointer_interconvertible          201907L
-# if !defined(_LIBCPP_HAS_NO_THREADS)
-// #   define __cpp_lib_jthread                            201911L
+# if !defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_STOP_TOKEN) && !defined(_LIBCPP_AVAILABILITY_HAS_NO_SYNC)
+#   define __cpp_lib_jthread                            201911L
 # endif
 # if !defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_HAS_NO_SYNC)
 #   define __cpp_lib_latch                              201907L
 # endif
 # define __cpp_lib_list_remove_return_type              201806L
 # define __cpp_lib_math_constants                       201907L
 # define __cpp_lib_move_iterator_concept                202207L
 # if !defined(_LIBCPP_AVAILABILITY_HAS_NO_PMR)

libcxx/test/libcxx/transitive_includes/cxx03.csv

 condition_variable cerrno
 condition_variable concepts
 condition_variable cstddef
 condition_variable cstdint
 condition_variable cstdlib
 condition_variable cstring
 condition_variable ctime
 condition_variable initializer_list
+condition_variable iosfwd
 condition_variable limits
 condition_variable new
 condition_variable ratio
 condition_variable stdexcept
 condition_variable string
 condition_variable system_error
 condition_variable type_traits
 condition_variable typeinfo

libcxx/test/libcxx/transitive_includes/cxx11.csv

 condition_variable cerrno
 condition_variable concepts
 condition_variable cstddef
 condition_variable cstdint
 condition_variable cstdlib
 condition_variable cstring
 condition_variable ctime
 condition_variable initializer_list
+condition_variable iosfwd
 condition_variable limits
 condition_variable new
 condition_variable ratio
 condition_variable stdexcept
 condition_variable string
 condition_variable system_error
 condition_variable type_traits
 condition_variable typeinfo

libcxx/test/libcxx/transitive_includes/cxx14.csv

 condition_variable cerrno
 condition_variable concepts
 condition_variable cstddef
 condition_variable cstdint
 condition_variable cstdlib
 condition_variable cstring
 condition_variable ctime
 condition_variable initializer_list
+condition_variable iosfwd
 condition_variable limits
 condition_variable new
 condition_variable ratio
 condition_variable stdexcept
 condition_variable string
 condition_variable system_error
 condition_variable type_traits
 condition_variable typeinfo

libcxx/test/libcxx/transitive_includes/cxx17.csv

 condition_variable cerrno
 condition_variable concepts
 condition_variable cstddef
 condition_variable cstdint
 condition_variable cstdlib
 condition_variable cstring
 condition_variable ctime
 condition_variable initializer_list
+condition_variable iosfwd
 condition_variable limits
 condition_variable new
 condition_variable ratio
 condition_variable stdexcept
 condition_variable string
 condition_variable system_error
 condition_variable type_traits
 condition_variable typeinfo

libcxx/test/libcxx/transitive_includes/cxx20.csv

 condition_variable cerrno
 condition_variable concepts
 condition_variable cstddef
 condition_variable cstdint
 condition_variable cstdlib
 condition_variable cstring
 condition_variable ctime
 condition_variable initializer_list
+condition_variable iosfwd
 condition_variable limits
 condition_variable new
 condition_variable ratio
 condition_variable stdexcept
 condition_variable string
 condition_variable system_error
 condition_variable type_traits
 condition_variable typeinfo

libcxx/test/libcxx/transitive_includes/cxx23.csv

 compare version
 complex cmath
 complex iosfwd
 complex sstream
 complex stdexcept
 complex version
 concepts cstddef
 concepts version
+condition_variable atomic
 condition_variable cerrno
 condition_variable cstddef
+condition_variable cstdint
+condition_variable cstring
 condition_variable ctime
 condition_variable iosfwd
 condition_variable limits
 condition_variable new
 condition_variable ratio
 condition_variable stdexcept
 condition_variable string
 condition_variable typeinfo

libcxx/test/libcxx/transitive_includes/cxx26.csv

 compare version
 complex cmath
 complex iosfwd
 complex sstream
 complex stdexcept
 complex version
 concepts cstddef
 concepts version
+condition_variable atomic
 condition_variable cerrno
 condition_variable cstddef
+condition_variable cstdint
+condition_variable cstring
 condition_variable ctime
 condition_variable iosfwd
 condition_variable limits
 condition_variable new
 condition_variable ratio
 condition_variable stdexcept
 condition_variable string
 condition_variable typeinfo

libcxx/test/std/language.support/support.limits/support.limits.general/stop_token.version.compile.pass.cpp

 #elif TEST_STD_VER == 17
 
 # ifdef __cpp_lib_jthread
 #   error "__cpp_lib_jthread should not be defined before c++20"
 # endif
 
 #elif TEST_STD_VER == 20
 
-# if !defined(_LIBCPP_VERSION)
+# if !defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_STOP_TOKEN) && !defined(_LIBCPP_AVAILABILITY_HAS_NO_SYNC)
 #   ifndef __cpp_lib_jthread
 #     error "__cpp_lib_jthread should be defined in c++20"
 #   endif
 #   if __cpp_lib_jthread != 201911L
 #     error "__cpp_lib_jthread should have the value 201911L in c++20"
 #   endif
-# else // _LIBCPP_VERSION
+# else
 #   ifdef __cpp_lib_jthread
-#     error "__cpp_lib_jthread should not be defined because it is unimplemented in libc++!"
+#     error "__cpp_lib_jthread should not be defined when the requirement '!defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_STOP_TOKEN) && !defined(_LIBCPP_AVAILABILITY_HAS_NO_SYNC)' is not met!"
 #   endif
 # endif
 
 #elif TEST_STD_VER == 23
 
-# if !defined(_LIBCPP_VERSION)
+# if !defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_STOP_TOKEN) && !defined(_LIBCPP_AVAILABILITY_HAS_NO_SYNC)
 #   ifndef __cpp_lib_jthread
 #     error "__cpp_lib_jthread should be defined in c++23"
 #   endif
 #   if __cpp_lib_jthread != 201911L
 #     error "__cpp_lib_jthread should have the value 201911L in c++23"
 #   endif
-# else // _LIBCPP_VERSION
+# else
 #   ifdef __cpp_lib_jthread
-#     error "__cpp_lib_jthread should not be defined because it is unimplemented in libc++!"
+#     error "__cpp_lib_jthread should not be defined when the requirement '!defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_STOP_TOKEN) && !defined(_LIBCPP_AVAILABILITY_HAS_NO_SYNC)' is not met!"
 #   endif
 # endif
 
 #elif TEST_STD_VER > 23
 
-# if !defined(_LIBCPP_VERSION)
+# if !defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_STOP_TOKEN) && !defined(_LIBCPP_AVAILABILITY_HAS_NO_SYNC)
 #   ifndef __cpp_lib_jthread
 #     error "__cpp_lib_jthread should be defined in c++26"
 #   endif
 #   if __cpp_lib_jthread != 201911L
 #     error "__cpp_lib_jthread should have the value 201911L in c++26"
 #   endif
-# else // _LIBCPP_VERSION
+# else
 #   ifdef __cpp_lib_jthread
-#     error "__cpp_lib_jthread should not be defined because it is unimplemented in libc++!"
+#     error "__cpp_lib_jthread should not be defined when the requirement '!defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_STOP_TOKEN) && !defined(_LIBCPP_AVAILABILITY_HAS_NO_SYNC)' is not met!"
 #   endif
 # endif
 
 #endif // TEST_STD_VER > 23
 

libcxx/test/std/language.support/support.limits/support.limits.general/thread.version.compile.pass.cpp

 # endif
 
 #elif TEST_STD_VER == 20
 
 # ifdef __cpp_lib_formatters
 #   error "__cpp_lib_formatters should not be defined before c++23"
 # endif
 
-# if !defined(_LIBCPP_VERSION)
+# if !defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_STOP_TOKEN) && !defined(_LIBCPP_AVAILABILITY_HAS_NO_SYNC)
 #   ifndef __cpp_lib_jthread
 #     error "__cpp_lib_jthread should be defined in c++20"
 #   endif
 #   if __cpp_lib_jthread != 201911L
 #     error "__cpp_lib_jthread should have the value 201911L in c++20"
 #   endif
-# else // _LIBCPP_VERSION
+# else
 #   ifdef __cpp_lib_jthread
-#     error "__cpp_lib_jthread should not be defined because it is unimplemented in libc++!"
+#     error "__cpp_lib_jthread should not be defined when the requirement '!defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_STOP_TOKEN) && !defined(_LIBCPP_AVAILABILITY_HAS_NO_SYNC)' is not met!"
 #   endif
 # endif
 
 #elif TEST_STD_VER == 23
 
 # if !defined(_LIBCPP_VERSION)
 #   ifndef __cpp_lib_formatters
 #     error "__cpp_lib_formatters should be defined in c++23"
 #   endif
 #   if __cpp_lib_formatters != 202302L
 #     error "__cpp_lib_formatters should have the value 202302L in c++23"
 #   endif
 # else // _LIBCPP_VERSION
 #   ifdef __cpp_lib_formatters
 #     error "__cpp_lib_formatters should not be defined because it is unimplemented in libc++!"
 #   endif
 # endif
 
-# if !defined(_LIBCPP_VERSION)
+# if !defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_STOP_TOKEN) && !defined(_LIBCPP_AVAILABILITY_HAS_NO_SYNC)
 #   ifndef __cpp_lib_jthread
 #     error "__cpp_lib_jthread should be defined in c++23"
 #   endif
 #   if __cpp_lib_jthread != 201911L
 #     error "__cpp_lib_jthread should have the value 201911L in c++23"
 #   endif
-# else // _LIBCPP_VERSION
+# else
 #   ifdef __cpp_lib_jthread
-#     error "__cpp_lib_jthread should not be defined because it is unimplemented in libc++!"
+#     error "__cpp_lib_jthread should not be defined when the requirement '!defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_STOP_TOKEN) && !defined(_LIBCPP_AVAILABILITY_HAS_NO_SYNC)' is not met!"
 #   endif
 # endif
 
 #elif TEST_STD_VER > 23
 
 # if !defined(_LIBCPP_VERSION)
 #   ifndef __cpp_lib_formatters
 #     error "__cpp_lib_formatters should be defined in c++26"
 #   endif
 #   if __cpp_lib_formatters != 202302L
 #     error "__cpp_lib_formatters should have the value 202302L in c++26"
 #   endif
 # else // _LIBCPP_VERSION
 #   ifdef __cpp_lib_formatters
 #     error "__cpp_lib_formatters should not be defined because it is unimplemented in libc++!"
 #   endif
 # endif
 
-# if !defined(_LIBCPP_VERSION)
+# if !defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_STOP_TOKEN) && !defined(_LIBCPP_AVAILABILITY_HAS_NO_SYNC)
 #   ifndef __cpp_lib_jthread
 #     error "__cpp_lib_jthread should be defined in c++26"
 #   endif
 #   if __cpp_lib_jthread != 201911L
 #     error "__cpp_lib_jthread should have the value 201911L in c++26"
 #   endif
-# else // _LIBCPP_VERSION
+# else
 #   ifdef __cpp_lib_jthread
-#     error "__cpp_lib_jthread should not be defined because it is unimplemented in libc++!"
+#     error "__cpp_lib_jthread should not be defined when the requirement '!defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_STOP_TOKEN) && !defined(_LIBCPP_AVAILABILITY_HAS_NO_SYNC)' is not met!"
 #   endif
 # endif
 
 #endif // TEST_STD_VER > 23
 

libcxx/test/std/language.support/support.limits/support.limits.general/version.version.compile.pass.cpp

 
 # ifndef __cpp_lib_is_swappable
 #   error "__cpp_lib_is_swappable should be defined in c++20"
 # endif
 # if __cpp_lib_is_swappable != 201603L
 #   error "__cpp_lib_is_swappable should have the value 201603L in c++20"
 # endif
 
-# if !defined(_LIBCPP_VERSION)
+# if !defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_STOP_TOKEN) && !defined(_LIBCPP_AVAILABILITY_HAS_NO_SYNC)
 #   ifndef __cpp_lib_jthread
 #     error "__cpp_lib_jthread should be defined in c++20"
 #   endif
 #   if __cpp_lib_jthread != 201911L
 #     error "__cpp_lib_jthread should have the value 201911L in c++20"
 #   endif
-# else // _LIBCPP_VERSION
+# else
 #   ifdef __cpp_lib_jthread
-#     error "__cpp_lib_jthread should not be defined because it is unimplemented in libc++!"
+#     error "__cpp_lib_jthread should not be defined when the requirement '!defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_STOP_TOKEN) && !defined(_LIBCPP_AVAILABILITY_HAS_NO_SYNC)' is not met!"
 #   endif
 # endif
 
 # if !defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_HAS_NO_SYNC)
 #   ifndef __cpp_lib_latch
 #     error "__cpp_lib_latch should be defined in c++20"
 #   endif
 #   if __cpp_lib_latch != 201907L

 
 # ifndef __cpp_lib_is_swappable
 #   error "__cpp_lib_is_swappable should be defined in c++23"
 # endif
 # if __cpp_lib_is_swappable != 201603L
 #   error "__cpp_lib_is_swappable should have the value 201603L in c++23"
 # endif
 
-# if !defined(_LIBCPP_VERSION)
+# if !defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_STOP_TOKEN) && !defined(_LIBCPP_AVAILABILITY_HAS_NO_SYNC)
 #   ifndef __cpp_lib_jthread
 #     error "__cpp_lib_jthread should be defined in c++23"
 #   endif
 #   if __cpp_lib_jthread != 201911L
 #     error "__cpp_lib_jthread should have the value 201911L in c++23"
 #   endif
-# else // _LIBCPP_VERSION
+# else
 #   ifdef __cpp_lib_jthread
-#     error "__cpp_lib_jthread should not be defined because it is unimplemented in libc++!"
+#     error "__cpp_lib_jthread should not be defined when the requirement '!defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_STOP_TOKEN) && !defined(_LIBCPP_AVAILABILITY_HAS_NO_SYNC)' is not met!"
 #   endif
 # endif
 
 # if !defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_HAS_NO_SYNC)
 #   ifndef __cpp_lib_latch
 #     error "__cpp_lib_latch should be defined in c++23"
 #   endif
 #   if __cpp_lib_latch != 201907L

 
 # ifndef __cpp_lib_is_swappable
 #   error "__cpp_lib_is_swappable should be defined in c++26"
 # endif
 # if __cpp_lib_is_swappable != 201603L
 #   error "__cpp_lib_is_swappable should have the value 201603L in c++26"
 # endif
 
-# if !defined(_LIBCPP_VERSION)
+# if !defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_STOP_TOKEN) && !defined(_LIBCPP_AVAILABILITY_HAS_NO_SYNC)
 #   ifndef __cpp_lib_jthread
 #     error "__cpp_lib_jthread should be defined in c++26"
 #   endif
 #   if __cpp_lib_jthread != 201911L
 #     error "__cpp_lib_jthread should have the value 201911L in c++26"
 #   endif
-# else // _LIBCPP_VERSION
+# else
 #   ifdef __cpp_lib_jthread
-#     error "__cpp_lib_jthread should not be defined because it is unimplemented in libc++!"
+#     error "__cpp_lib_jthread should not be defined when the requirement '!defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_STOP_TOKEN) && !defined(_LIBCPP_AVAILABILITY_HAS_NO_SYNC)' is not met!"
 #   endif
 # endif
 
 # if !defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_HAS_NO_SYNC)
 #   ifndef __cpp_lib_latch
 #     error "__cpp_lib_latch should be defined in c++26"
 #   endif
 #   if __cpp_lib_latch != 201907L

libcxx/test/std/thread/thread.condition/thread.condition.condvarany/wait_for_token_pred.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// UNSUPPORTED: no-threads
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-has-no-experimental-stop_token
+// XFAIL: availability-synchronization_library-missing
+
+// <condition_variable>
+
+// class condition_variable_any;
+
+// 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);
+
+#include <cassert>
+#include <chrono>
+#include <concepts>
+#include <condition_variable>
+#include <functional>
+#include <mutex>
+#include <shared_mutex>
+#include <stop_token>
+#include <thread>
+
+#include "make_test_thread.h"
+#include "test_macros.h"
+
+template <class Mutex, class Lock>
+void test() {
+  using namespace std::chrono_literals;
+
+  // stop_requested before hand
+  {
+    std::stop_source ss;
+    std::condition_variable_any cv;
+    Mutex mutex;
+    Lock lock{mutex};
+    ss.request_stop();
+
+    // [Note 4: The returned value indicates whether the predicate evaluated to true
+    // regardless of whether the timeout was triggered or a stop request was made.]
+    std::same_as<bool> auto r1 = cv.wait_for(lock, ss.get_token(), -1h, []() { return false; });
+    assert(!r1);
+
+    std::same_as<bool> auto r2 = cv.wait_for(lock, ss.get_token(), 1h, []() { return false; });
+    assert(!r2);
+
+    std::same_as<bool> auto r3 = cv.wait_for(lock, ss.get_token(), -1h, []() { return true; });
+    assert(r3);
+
+    std::same_as<bool> auto r4 = cv.wait_for(lock, ss.get_token(), 1h, []() { return true; });
+    assert(r4);
+
+    // Postconditions: lock is locked by the calling thread.
+    assert(lock.owns_lock());
+  }
+
+  // no stop request, pred was true
+  {
+    std::stop_source ss;
+    std::condition_variable_any cv;
+    Mutex mutex;
+    Lock lock{mutex};
+
+    std::same_as<bool> auto r1 = cv.wait_for(lock, ss.get_token(), -1h, []() { return true; });
+    assert(r1);
+
+    std::same_as<bool> auto r2 = cv.wait_for(lock, ss.get_token(), 1h, []() { return true; });
+    assert(r2);
+  }
+
+  // no stop request, pred was false, abs_time was in the past
+  {
+    std::stop_source ss;
+    std::condition_variable_any cv;
+    Mutex mutex;
+    Lock lock{mutex};
+
+    std::same_as<bool> auto r1 = cv.wait_for(lock, ss.get_token(), -1h, []() { return false; });
+    assert(!r1);
+  }
+
+  // no stop request, pred was false until timeout
+  {
+    std::stop_source ss;
+    std::condition_variable_any cv;
+    Mutex mutex;
+    Lock lock{mutex};
+
+    auto old_time = std::chrono::steady_clock::now();
+
+    std::same_as<bool> auto r1 = cv.wait_for(lock, ss.get_token(), 2ms, [&]() { return false; });
+
+    assert((std::chrono::steady_clock::now() - old_time) >= 2ms);
+    assert(!r1);
+  }
+
+  // no stop request, pred was false, changed to true before timeout
+  {
+    std::stop_source ss;
+    std::condition_variable_any cv;
+    Mutex mutex;
+    Lock lock{mutex};
+
+    bool flag   = false;
+    auto thread = support::make_test_thread([&]() {
+      std::this_thread::sleep_for(2ms);
+      Lock lock2{mutex};
+      flag = true;
+      cv.notify_all();
+    });
+
+    std::same_as<bool> auto r1 = cv.wait_for(lock, ss.get_token(), 1h, [&]() { return flag; });
+    assert(flag);
+    assert(r1);
+
+    thread.join();
+  }
+
+  // stop request comes while waiting
+  {
+    std::stop_source ss;
+    std::condition_variable_any cv;
+    Mutex mutex;
+    Lock lock{mutex};
+
+    std::atomic_bool start = false;
+    std::atomic_bool done  = false;
+    auto thread            = support::make_test_thread([&]() {
+      start.wait(false);
+      ss.request_stop();
+
+      while (!done) {
+        cv.notify_all();
+        std::this_thread::sleep_for(2ms);
+      }
+    });
+
+    std::same_as<bool> auto r = cv.wait_for(lock, ss.get_token(), 1h, [&]() {
+      start.store(true);
+      start.notify_all();
+      return false;
+    });
+    assert(!r);
+    done = true;
+    thread.join();
+
+    assert(lock.owns_lock());
+  }
+
+#if !defined(TEST_HAS_NO_EXCEPTIONS)
+  // Throws: Any exception thrown by pred.
+  {
+    std::stop_source ss;
+    std::condition_variable_any cv;
+    Mutex mutex;
+    Lock lock{mutex};
+
+    try {
+      cv.wait_for(lock, ss.get_token(), 1h, []() -> bool { throw 5; });
+      assert(false);
+    } catch (int i) {
+      assert(i == 5);
+    }
+  }
+#endif //!defined(TEST_HAS_NO_EXCEPTIONS)
+}
+
+int main(int, char**) {
+  test<std::mutex, std::unique_lock<std::mutex>>();
+  test<std::shared_mutex, std::shared_lock<std::shared_mutex>>();
+
+  return 0;
+}

libcxx/test/std/thread/thread.condition/thread.condition.condvarany/wait_terminates.sh.cpp

 
 // RUN: %{build}
 // RUN: %{run} 1
 // RUN: %{run} 2
 // RUN: %{run} 3
 // RUN: %{run} 4
 // RUN: %{run} 5
 // RUN: %{run} 6
+// RUN: %{run} 7
+// RUN: %{run} 8
+// RUN: %{run} 9
 
 // -----------------------------------------------------------------------------
 // Overview
 //   Check that std::terminate is called if wait(...) fails to meet its post
 //   conditions. This can happen when reacquiring the mutex throws
 //   an exception.
 //
 //  The following methods are tested within this file
 //   1.  void wait(Lock& lock);
 //   2.  void wait(Lock& lock, Pred);
 //   3.  void wait_for(Lock& lock, Duration);
 //   4.  void wait_for(Lock& lock, Duration, Pred);
 //   5.  void wait_until(Lock& lock, TimePoint);
 //   6.  void wait_until(Lock& lock, TimePoint, Pred);
+//   7.  bool wait(Lock& lock, stop_token stoken, Predicate pred);
+//   8.  bool wait_for(Lock& lock, stop_token stoken, Duration, Predicate pred);
+//   9.  bool wait_until(Lock& lock, stop_token stoken, TimePoint, Predicate pred);
 //
 // Plan
 //   1 Create a mutex type, 'ThrowingMutex', that throws when the lock is acquired
 //     for the *second* time.
 //
 //   2 Replace the terminate handler with one that exits with a '0' exit code.
 //
 //   3 Create a 'condition_variable_any' object 'cv' and a 'ThrowingMutex'

 
 #include <atomic>
 #include <cassert>
 #include <chrono>
 #include <condition_variable>
 #include <cstdlib>
 #include <exception>
 #include <string>
+#include <stop_token>
 #include <thread>
 
 #include "make_test_thread.h"
+#include "test_macros.h"
 
 void my_terminate() {
   std::_Exit(0); // Use _Exit to prevent cleanup from taking place.
 }
 
 // The predicate used in the cv.wait calls.
 bool pred = false;
 bool pred_function() {

 }
 
 typedef std::chrono::system_clock Clock;
 typedef std::chrono::milliseconds MS;
 
 int main(int argc, char **argv) {
   assert(argc == 2);
   int id = std::stoi(argv[1]);
-  assert(id >= 1 && id <= 6);
+  assert(id >= 1 && id <= 9);
   std::set_terminate(my_terminate); // set terminate after std::stoi because it can throw.
   MS wait(250);
   try {
     mut.lock();
     assert(pred == false);
     support::make_test_thread(signal_me).detach();
     switch (id) {
       case 1: cv.wait(mut); break;
       case 2: cv.wait(mut, pred_function); break;
       case 3: cv.wait_for(mut, wait); break;
       case 4: cv.wait_for(mut, wait, pred_function); break;
       case 5: cv.wait_until(mut, Clock::now() + wait); break;
       case 6: cv.wait_until(mut, Clock::now() + wait, pred_function); break;
+#if TEST_STD_VER >=20 && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_STOP_TOKEN) && !defined(_LIBCPP_AVAILABILITY_HAS_NO_SYNC)
+      case 7: cv.wait(mut, std::stop_source{}.get_token(), pred_function); break;
+      case 8: cv.wait_for(mut, std::stop_source{}.get_token(), wait, pred_function); break;
+      case 9: cv.wait_until(mut, std::stop_source{}.get_token(), Clock::now() + wait, pred_function); break;
+#else
+      case 7:
+      case 8:
+      case 9:
+        return 0;
+#endif //TEST_STD_VER >=20 && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_STOP_TOKEN)
       default: assert(false);
     }
   } catch (...) {}
   assert(false);
 
   return 0;
 }

libcxx/test/std/thread/thread.condition/thread.condition.condvarany/wait_token_pred.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// UNSUPPORTED: no-threads
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-has-no-experimental-stop_token
+// XFAIL: availability-synchronization_library-missing
+
+// <condition_variable>
+
+// class condition_variable_any;
+
+// template<class Lock, class Predicate>
+//   bool wait(Lock& lock, stop_token stoken, Predicate pred);
+
+#include <cassert>
+#include <concepts>
+#include <condition_variable>
+#include <functional>
+#include <mutex>
+#include <shared_mutex>
+#include <stop_token>
+#include <thread>
+
+#include "make_test_thread.h"
+#include "test_macros.h"
+
+template <class Mutex, class Lock>
+void test() {
+  // stop_requested before hand
+  {
+    std::stop_source ss;
+    std::condition_variable_any cv;
+    Mutex mutex;
+    Lock lock{mutex};
+    ss.request_stop();
+
+    // [Note 1: The returned value indicates whether the predicate evaluated to true regardless of whether there was a stop request.]
+    std::same_as<bool> auto r1 = cv.wait(lock, ss.get_token(), []() { return false; });
+    assert(!r1);
+
+    std::same_as<bool> auto r2 = cv.wait(lock, ss.get_token(), []() { return true; });
+    assert(r2);
+
+    // Postconditions: lock is locked by the calling thread.
+    assert(lock.owns_lock());
+  }
+
+  // no stop request
+  {
+    std::stop_source ss;
+    std::condition_variable_any cv;
+    Mutex mutex;
+    Lock lock{mutex};
+    std::same_as<bool> auto r1 = cv.wait(lock, ss.get_token(), []() { return true; });
+    assert(r1);
+
+    bool flag   = false;
+    auto thread = support::make_test_thread([&]() {
+      std::this_thread::sleep_for(std::chrono::milliseconds(2));
+      Lock lock2{mutex};
+      flag = true;
+      cv.notify_all();
+    });
+
+    std::same_as<bool> auto r2 = cv.wait(lock, ss.get_token(), [&]() { return flag; });
+    assert(flag);
+    assert(r2);
+    thread.join();
+
+    assert(lock.owns_lock());
+  }
+
+  // stop request comes while waiting
+  {
+    std::stop_source ss;
+    std::condition_variable_any cv;
+    Mutex mutex;
+    Lock lock{mutex};
+
+    std::atomic_bool start = false;
+    std::atomic_bool done  = false;
+    auto thread            = support::make_test_thread([&]() {
+      start.wait(false);
+      ss.request_stop();
+
+      while (!done) {
+        cv.notify_all();
+        std::this_thread::sleep_for(std::chrono::milliseconds(2));
+      }
+    });
+
+    std::same_as<bool> auto r = cv.wait(lock, ss.get_token(), [&]() {
+      start.store(true);
+      start.notify_all();
+      return false;
+    });
+    assert(!r);
+    done = true;
+    thread.join();
+
+    assert(lock.owns_lock());
+  }
+
+#if !defined(TEST_HAS_NO_EXCEPTIONS)
+  // Throws: Any exception thrown by pred.
+  {
+    std::stop_source ss;
+    std::condition_variable_any cv;
+    Mutex mutex;
+    Lock lock{mutex};
+
+    try {
+      cv.wait(lock, ss.get_token(), []() -> bool { throw 5; });
+      assert(false);
+    } catch (int i) {
+      assert(i == 5);
+    }
+  }
+#endif //!defined(TEST_HAS_NO_EXCEPTIONS)
+}
+
+int main(int, char**) {
+  test<std::mutex, std::unique_lock<std::mutex>>();
+  test<std::shared_mutex, std::shared_lock<std::shared_mutex>>();
+
+  return 0;
+}

libcxx/test/std/thread/thread.condition/thread.condition.condvarany/wait_until_token_pred.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// UNSUPPORTED: no-threads
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-has-no-experimental-stop_token
+// XFAIL: availability-synchronization_library-missing
+
+// <condition_variable>
+
+// class condition_variable_any;
+
+// 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);
+
+#include <cassert>
+#include <chrono>
+#include <concepts>
+#include <condition_variable>
+#include <functional>
+#include <mutex>
+#include <shared_mutex>
+#include <stop_token>
+#include <thread>
+
+#include "make_test_thread.h"
+#include "test_macros.h"
+
+template <class Mutex, class Lock>
+void test() {
+  const auto past   = std::chrono::steady_clock::now() - std::chrono::hours(1);
+  const auto future = std::chrono::steady_clock::now() + std::chrono::hours(1);
+
+  // stop_requested before hand
+  {
+    std::stop_source ss;
+    std::condition_variable_any cv;
+    Mutex mutex;
+    Lock lock{mutex};
+    ss.request_stop();
+
+    // [Note 4: The returned value indicates whether the predicate evaluated to true
+    // regardless of whether the timeout was triggered or a stop request was made.]
+    std::same_as<bool> auto r1 = cv.wait_until(lock, ss.get_token(), past, []() { return false; });
+    assert(!r1);
+
+    std::same_as<bool> auto r2 = cv.wait_until(lock, ss.get_token(), future, []() { return false; });
+    assert(!r2);
+
+    std::same_as<bool> auto r3 = cv.wait_until(lock, ss.get_token(), past, []() { return true; });
+    assert(r3);
+
+    std::same_as<bool> auto r4 = cv.wait_until(lock, ss.get_token(), future, []() { return true; });
+    assert(r4);
+
+    // Postconditions: lock is locked by the calling thread.
+    assert(lock.owns_lock());
+  }
+
+  // no stop request, pred was true
+  {
+    std::stop_source ss;
+    std::condition_variable_any cv;
+    Mutex mutex;
+    Lock lock{mutex};
+
+    std::same_as<bool> auto r1 = cv.wait_until(lock, ss.get_token(), past, []() { return true; });
+    assert(r1);
+
+    std::same_as<bool> auto r2 = cv.wait_until(lock, ss.get_token(), future, []() { return true; });
+    assert(r2);
+  }
+
+  // no stop request, pred was false, abs_time was in the past
+  {
+    std::stop_source ss;
+    std::condition_variable_any cv;
+    Mutex mutex;
+    Lock lock{mutex};
+
+    std::same_as<bool> auto r1 = cv.wait_until(lock, ss.get_token(), past, []() { return false; });
+    assert(!r1);
+  }
+
+  // no stop request, pred was false until timeout
+  {
+    std::stop_source ss;
+    std::condition_variable_any cv;
+    Mutex mutex;
+    Lock lock{mutex};
+
+    auto oldTime = std::chrono::steady_clock::now();
+
+    std::same_as<bool> auto r1 =
+        cv.wait_until(lock, ss.get_token(), oldTime + std::chrono::milliseconds(2), [&]() { return false; });
+
+    assert((std::chrono::steady_clock::now() - oldTime) >= std::chrono::milliseconds(2));
+    assert(!r1);
+  }
+
+  // no stop request, pred was false, changed to true before timeout
+  {
+    std::stop_source ss;
+    std::condition_variable_any cv;
+    Mutex mutex;
+    Lock lock{mutex};
+
+    bool flag   = false;
+    auto thread = support::make_test_thread([&]() {
+      std::this_thread::sleep_for(std::chrono::milliseconds(2));
+      Lock lock2{mutex};
+      flag = true;
+      cv.notify_all();
+    });
+
+    std::same_as<bool> auto r1 = cv.wait_until(lock, ss.get_token(), future, [&]() { return flag; });
+    assert(flag);
+    assert(r1);
+
+    thread.join();
+  }
+
+  // stop request comes while waiting
+  {
+    std::stop_source ss;
+    std::condition_variable_any cv;
+    Mutex mutex;
+    Lock lock{mutex};
+
+    std::atomic_bool start = false;
+    std::atomic_bool done  = false;
+    auto thread            = support::make_test_thread([&]() {
+      start.wait(false);
+      ss.request_stop();
+
+      while (!done) {
+        cv.notify_all();
+        std::this_thread::sleep_for(std::chrono::milliseconds(2));
+      }
+    });
+
+    std::same_as<bool> auto r = cv.wait_until(lock, ss.get_token(), future, [&]() {
+      start.store(true);
+      start.notify_all();
+      return false;
+    });
+    assert(!r);
+    done = true;
+    thread.join();
+
+    assert(lock.owns_lock());
+  }
+
+#if !defined(TEST_HAS_NO_EXCEPTIONS)
+  // Throws: Any exception thrown by pred.
+  {
+    std::stop_source ss;
+    std::condition_variable_any cv;
+    Mutex mutex;
+    Lock lock{mutex};
+
+    try {
+      cv.wait_until(lock, ss.get_token(), future, []() -> bool { throw 5; });
+      assert(false);
+    } catch (int i) {
+      assert(i == 5);
+    }
+  }
+#endif //!defined(TEST_HAS_NO_EXCEPTIONS)
+}
+
+int main(int, char**) {
+  test<std::mutex, std::unique_lock<std::mutex>>();
+  test<std::shared_mutex, std::shared_lock<std::shared_mutex>>();
+
+  return 0;
+}

libcxx/utils/generate_feature_test_macro_components.py

for x in [
             "name": "__cpp_lib_is_swappable",
             "values": {"c++17": 201603},
             "headers": ["type_traits"],
         },
         {
             "name": "__cpp_lib_jthread",
             "values": {"c++20": 201911},
             "headers": ["stop_token", "thread"],
-            "test_suite_guard": "!defined(_LIBCPP_HAS_NO_THREADS)",
-            "libcxx_guard": "!defined(_LIBCPP_HAS_NO_THREADS)",
-            "unimplemented": True,
+            "test_suite_guard": "!defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_STOP_TOKEN) && !defined(_LIBCPP_AVAILABILITY_HAS_NO_SYNC)",
+            "libcxx_guard": "!defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_STOP_TOKEN) && !defined(_LIBCPP_AVAILABILITY_HAS_NO_SYNC)",
         },
         {
             "name": "__cpp_lib_latch",
             "values": {"c++20": 201907},
             "headers": ["latch"],
             "test_suite_guard": "!defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_HAS_NO_SYNC)",
             "libcxx_guard": "!defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_HAS_NO_SYNC)",
         },