[libc++] implement std::`jthread`

[ldionne]

libcxx/include/__thread/formatter.h

1 ↗

(On Diff #526039)

Would it be possible to granularize these headers in a separate patch? That should be a quick NFC to review.

libcxx/include/__thread/jthread.h

11–12

42–43

Note to self: this is tested.

49

Let's make sure we have a test for this note:

[Note 1: This implies that any exceptions not thrown from the invocation of the copy of f will be thrown in the constructing thread, not the new thread. — end note]

(near https://eel.is/c++draft/thread.jthread.class#thread.jthread.cons-5)

Edit: We do already have a test!

72

Do you have a test for self-assignment?

Edit: Of course, you do.

133

libcxx/include/__thread/this_thread.h

10 ↗

(On Diff #526039)

Same here and elsewhere when you do it in another patch.

libcxx/test/std/thread/thread.jthread/assign.move.pass.cpp

38

I think we don't have a test for the case where the source thread isn't joinable.

libcxx/test/std/thread/thread.jthread/cons.func.token.pass.cpp

112

TEST_HAS_NO_EXCEPTIONS

148

Per your suggestion, we might be able to test https://eel.is/c++draft/thread.jthread.class#thread.jthread.cons-8 by setting multiple threads' affinity to the same core. It might not be possible to test this in a robust way, and I think it would be reasonable not to.

[huixie90]

rebase on splitting <thread>

[huixie90]

more tests

[huixie90]

more tests

[ldionne]

libcxx/include/__stop_token/stop_state.h

18–20

#include <__thread/thread.h>? I think this might require exporting * or std.__threading_support.__thread_id from the modulemap.

libcxx/test/std/thread/thread.jthread/dtor.pass.cpp

25

31

assert(jt.joinable()); // test the test

Those are just suggestions, I'm actually not sure how much I like this.

[ldionne]

libcxx/test/std/thread/thread.jthread/dtor.pass.cpp

40–46

To increase the confidence in this test, we could instead spawn more threads and do the same check. That should get the probability that join() isn't called but the test still passes down.

Also, I'd leave a short comment behind explaining this particularity of the test (i.e. it's not going to catch issues 100%).

libcxx/test/std/thread/thread.jthread/join.pass.cpp

29

Same comment here about non-determinism.

[Mordante]

I didn't do an in depth review, I mainly looked at the code out of curiosity.

libcxx/include/__thread/jthread.h

67

[huixie90]

add tests

[huixie90]

update <thread>

[huixie90]

ci

[huixie90]

CI

[huixie90]

CI

[huixie90]

CI

[huixie90]

export jthread

[ldionne]

libcxx/test/std/thread/thread.jthread/join.pass.cpp

85

This test is failing with:

ThreadSanitizer: CHECK failed: sanitizer_thread_registry.cpp:348 "((t)) != (0)" (0x0, 0x0) (tid=3411214)
    #0 __tsan::CheckUnwind() <null> (t.tmp.exe+0xcbd1b) (BuildId: d7fd9285e8961410872ba6334aecc0115d0ff192)
    #1 __sanitizer::CheckFailed(char const*, int, char const*, unsigned long long, unsigned long long) <null> (t.tmp.exe+0x45042) (BuildId: d7fd9285e8961410872ba6334aecc0115d0ff192)
    #2 __sanitizer::ThreadRegistry::ConsumeThreadUserId(unsigned long) <null> (t.tmp.exe+0x43e94) (BuildId: d7fd9285e8961410872ba6334aecc0115d0ff192)
    #3 pthread_join <null> (t.tmp.exe+0x604bb) (BuildId: d7fd9285e8961410872ba6334aecc0115d0ff192)
    #4 std::__1::__libcpp_thread_join[abi:v170000](unsigned long*) /home/libcxx-builder/.buildkite-agent/builds/google-libcxx-builder-69f521df8409-1/llvm-project/libcxx-ci/build/generic-tsan/include/c++/v1/__threading_support:398:10 (libc++.so.1+0x73358) (BuildId: 71b8f06279b5e8117756a82c1e642e312c2a0e30)
    #5 std::__1::thread::join() /home/libcxx-builder/.buildkite-agent/builds/google-libcxx-builder-69f521df8409-1/llvm-project/libcxx-ci/libcxx/src/thread.cpp:51:14 (libc++.so.1+0x73358)
    #6 std::__1::jthread::join[abi:v170000]() /home/libcxx-builder/.buildkite-agent/builds/google-libcxx-builder-69f521df8409-1/llvm-project/libcxx-ci/build/generic-tsan/include/c++/v1/__thread/jthread.h:91:49 (t.tmp.exe+0xed5f9) (BuildId: d7fd9285e8961410872ba6334aecc0115d0ff192)
    #7 std::__1::jthread::~jthread[abi:v170000]() /home/libcxx-builder/.buildkite-agent/builds/google-libcxx-builder-69f521df8409-1/llvm-project/libcxx-ci/build/generic-tsan/include/c++/v1/__thread/jthread.h:60:7 (t.tmp.exe+0xed708) (BuildId: d7fd9285e8961410872ba6334aecc0115d0ff192)
    #8 main /home/libcxx-builder/.buildkite-agent/builds/google-libcxx-builder-69f521df8409-1/llvm-project/libcxx-ci/libcxx/test/std/thread/thread.jthread/join.pass.cpp:108:3 (t.tmp.exe+0xe836d) (BuildId: d7fd9285e8961410872ba6334aecc0115d0ff192)
    #9 __libc_start_call_main csu/../sysdeps/nptl/libc_start_call_main.h:58:16 (libc.so.6+0x29d8f) (BuildId: 69389d485a9793dbe873f0ea2c93e02efaa9aa3d)
    #10 __libc_start_main csu/../csu/libc-start.c:392:3 (libc.so.6+0x29e3f) (BuildId: 69389d485a9793dbe873f0ea2c93e02efaa9aa3d)
    #11 _start <null> (t.tmp.exe+0x30484) (BuildId: d7fd9285e8961410872ba6334aecc0115d0ff192)

What might be happening is that TSAN instruments pthread_join and it thinks that the thread has already been joined when you call it the second time in the destructor. But in reality, the thread wasn't joined the first time around because of the system error. You might be able to figure out what's going on by looking at how these functions are interposed, I think it's in compiler-rt. @vitalybuka Might be able to provide more information as well.

If that's the case, then the issue would be that TSAN's internal state is inconsistent with reality and the fix would be in TSAN. I'm not sure, I'm just guessing.

[huixie90]

libcxx/test/std/thread/thread.jthread/join.pass.cpp

85

had a looked at TSAN's code

TSAN_INTERCEPTOR(int, pthread_join, void *th, void **ret) {
  SCOPED_INTERCEPTOR_RAW(pthread_join, th, ret);
  Tid tid = ThreadConsumeTid(thr, pc, (uptr)th);
  ThreadIgnoreBegin(thr, pc);
  int res = BLOCK_REAL(pthread_join)(th, ret);
  ThreadIgnoreEnd(thr);
  if (res == 0) {
    ThreadJoin(thr, pc, tid);
  }
  return res;
}

ThreadConsumeTid calls ConsumeThreadUserId, which

1. try to find by id, assert id is found
2. remove what is found

From what I can see, the first time join is called, the user id is removed. then join throws.
The second time join is called, the user id is no longer there and assertion failure.

so I guess this is a TSAN problem?

[huixie90]

rebase

[ldionne]

I'll pick up that patch as well per discussion with Hui.

libcxx/include/__thread/jthread.h

2

Let's mark this as experimental.

libcxx/test/std/thread/thread.jthread/join.pass.cpp

85

This seems like we should file a bug report against ASAN for this one.

103

Let's move this to a different test like join.deadlock.pass.cpp and mark it as UNSUPPORTED on Windows with a comment. We can also mark it as UNSUPPORTED on ASAN with a link to the bug report.

[huixie90]

rebase

[huixie90]

put jthread in experimental

[huixie90]

formatting

[huixie90]

transitive includes

[huixie90]

transitive includes

[huixie90]

update module map and all tests guard against experimental stop_token macro

[huixie90]

formatting

[huixie90]

filter platforms

[ldionne]

I don't think any of my comments really require me to take another look. This is really good, thank you!

libcxx/include/CMakeLists.txt

672

Not attached: let's mention this in UsingLibcxx.rst where we have a list of experimental features.

libcxx/include/__stop_token/stop_state.h

18

I think you can simply replace this by __thread/id.h now that it has been split out of __thread/thread.h. This might reduce dependencies a bit.

libcxx/include/__thread/jthread.h

32–34

I would remove this since there's already one in <thread>. We want to revisit how we're handling missing capabilities like this (in some cases we just omit the contents of headers, in other cases like _LIBCPP_HAS_NO_THREADS we have a hard error). Removing this doesn't change anything but it avoids giving the impression that this is the definite way we want to handle those.

52

I might suggest making __init_thread a static member function and passing __stop_source_ to it explicitly. Otherwise we're calling a member function at a point where the object isn't fully initialized yet, which seems questionable. I don't think there's any real issue here, it's more a matter of style / clarity.

libcxx/test/std/thread/thread.jthread/cons.func.token.pass.cpp

151

Let's add a link to https://eel.is/c++draft/thread.jthread.class#thread.jthread.cons-8 in this comment.

Also, if you don't have a concrete idea of how this might be done (portably etc..), let's not make this a TODO. If we don't realistically plan on fixing it, it shouldn't be a TODO.

We can say instead:

// Per https://eel.is/c++draft/thread.jthread.class#thread.jthread.cons-8:
// 
// Throws: system_error if unable to start the new thread.
// Error conditions:
// resource_unavailable_try_again - the system lacked the necessary resources to create another thread,
// or the system-imposed limit on the number of threads in a process would be exceeded.
//
// Unfortunately, this is extremely hard to test portably so we don't have a test for this error condition right now.

libcxx/test/std/thread/thread.jthread/cons.move.pass.cpp

35

https://eel.is/c++draft/thread.jthread.class#thread.jthread.cons-10 says that j1.get_id() should be id(), so we might as well assert that.

libcxx/test/std/thread/thread.jthread/detach.pass.cpp

37

To troubleshoot whether the CI issue is that this curly brace is taking forever to complete and then the main thread finishes before the detached thread is done, you could insert a sleep at the end of the test. If that is indeed the issue, I can't think of another way to solve this problem since you don't have any handle to the thread once you've detached it. It's kind of lame but it might be acceptable to insert a short sleep with a comment at the end if it reliably solves this issue.

70–72

libcxx/test/std/thread/thread.jthread/dtor.pass.cpp

63–64

libcxx/test/std/thread/thread.jthread/get_id.pass.cpp

24–29

Suggestion:

static_assert(noexcept(std::declval<std::jthread>().get_id()));

This seems a bit simpler. This applies in a few other tests as well.

libcxx/test/std/thread/thread.jthread/get_stop_token.pass.cpp

38

That way if we returned a reference, the test would fail. You probably want to do this in the other tests too.

libcxx/test/std/thread/thread.jthread/join.deadlock.pass.cpp

14

This should be a link to the github issue!

37

We could do UNSUPPORTED: no-exceptions instead.

libcxx/test/std/thread/thread.jthread/joinable.pass.cpp

40–45

I think we should check two cases here:

1. The thread of execution has finished running before we call jt.joinable(), and
2. the thread of execution has not finished running yet before we call jt.joinable().

You can use an atomic variable to signal that.

libcxx/test/std/thread/thread.jthread/typedef.compile.pass.cpp

1 ↗

(On Diff #556829)

I would suggest renaming this to types.compile.pass.cpp, I think it is a bit more consistent with the rest of the test suite.

[huixie90]

addressed feedback

[vitalybuka]

libcxx/test/std/thread/thread.jthread/join.pass.cpp

85

This seems like we should file a bug report against ASAN for this one.

TSAN

Asan for similar case make sure result is success

INTERCEPTOR(int, pthread_join, void *thread, void **retval) {
  int result;
  asanThreadArgRetval().Join((uptr)thread, [&]() {
    result = REAL(pthread_join)(thread, retval);
    return !result;
  });
  return result;
}

[huixie90]

CI

[huixie90]

https://github.com/llvm/llvm-project/commit/695138ca8405779c2b7756cc31d887aa54f56bb8

libcxx/docs/UsingLibcxx.rst

 are disabled by default because they are neither API nor ABI stable. However, the
 ``-fexperimental-library`` compiler flag can be defined to turn those features on.
 
 The following features are currently considered experimental and are only provided
 when ``-fexperimental-library`` is passed:
 
 * The parallel algorithms library (``<execution>`` and the associated algorithms)
 * ``std::stop_token``, ``std::stop_source`` and ``std::stop_callback``
+* ``std::jthread``
 * ``std::chrono::tzdb`` and related time zone functionality
 * ``std::ranges::join_view``
 
 .. warning::
   Experimental libraries are experimental.
     * The contents of the ``<experimental/...>`` headers and the associated static
       library will not remain compatible between versions.
     * No guarantees of API or ABI stability are provided.

libcxx/include/CMakeLists.txt

set(files
   __support/ibm/nanosleep.h
   __support/ibm/xlocale.h
   __support/musl/xlocale.h
   __support/newlib/xlocale.h
   __support/openbsd/xlocale.h
   __support/win32/locale_win32.h
   __support/xlocale/__nop_locale_mgmt.h
   __support/xlocale/__posix_l_fallback.h
   __support/xlocale/__strtonum_fallback.h
   __system_error/errc.h
   __system_error/error_category.h
   __system_error/error_code.h
   __system_error/error_condition.h
   __system_error/system_error.h
   __thread/formatter.h
   __thread/id.h
+  __thread/jthread.h
   __thread/poll_with_backoff.h
   __thread/this_thread.h
   __thread/thread.h
   __thread/timed_backoff_policy.h
   __threading_support
   __tree
   __tuple/make_tuple_types.h
   __tuple/pair_like.h

libcxx/include/__stop_token/atomic_unique_lock.h

 #if _LIBCPP_STD_VER >= 20
 
 // This class implements an RAII unique_lock without a mutex.
 // It uses std::atomic<State>,
 // where State contains a lock bit and might contain other data,
 // and LockedBit is the value of State when the lock bit is set, e.g  1 << 2
 template <class _State, _State _LockedBit>
 class _LIBCPP_AVAILABILITY_SYNC __atomic_unique_lock {
-  static_assert(std::popcount(_LockedBit) == 1, "LockedBit must be an integer where only one bit is set");
+  static_assert(std::__libcpp_popcount(static_cast<unsigned long long>(_LockedBit)) == 1,
+                "LockedBit must be an integer where only one bit is set");
 
   std::atomic<_State>& __state_;
   bool __is_locked_;
 
 public:
   _LIBCPP_HIDE_FROM_ABI explicit __atomic_unique_lock(std::atomic<_State>& __state) noexcept
       : __state_(__state), __is_locked_(true) {
     __lock();

libcxx/include/__stop_token/stop_callback.h

 #include <__type_traits/is_nothrow_constructible.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  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)
 
 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 "

 
 template <class _Callback>
 _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)

libcxx/include/__stop_token/stop_state.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___STOP_TOKEN_STOP_STATE_H
 #define _LIBCPP___STOP_TOKEN_STOP_STATE_H
 
 #include <__availability>
 #include <__config>
 #include <__stop_token/atomic_unique_lock.h>
 #include <__stop_token/intrusive_list_view.h>
+#include <__thread/id.h>
 #include <atomic>
 #include <cstdint>
-#include <thread>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 20
 
class __stop_state {
   // It is used by __intrusive_shared_ptr, but it is stored here for better layout
   atomic<uint32_t> __ref_count_ = 0;
 
   using __state_t            = uint32_t;
   using __callback_list_lock = __atomic_unique_lock<__state_t, __callback_list_locked_bit>;
   using __callback_list      = __intrusive_list_view<__stop_callback_base>;
 
   __callback_list __callback_list_;
-  thread::id __requesting_thread_;
+  __thread_id __requesting_thread_;
 
 public:
   _LIBCPP_HIDE_FROM_ABI __stop_state() noexcept = default;
 
   _LIBCPP_HIDE_FROM_ABI void __increment_stop_source_counter() noexcept {
     _LIBCPP_ASSERT_UNCATEGORIZED(
         __state_.load(std::memory_order_relaxed) <= static_cast<__state_t>(~(1 << __stop_source_counter_shift)),
         "stop_source's counter reaches the maximum. Incrementing the counter will overflow");

libcxx/include/__thread/jthread.h

+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___THREAD_JTHREAD_H
+#define _LIBCPP___THREAD_JTHREAD_H
+
+#include <__availability>
+#include <__config>
+#include <__functional/invoke.h>
+#include <__stop_token/stop_source.h>
+#include <__stop_token/stop_token.h>
+#include <__thread/thread.h>
+#include <__threading_support>
+#include <__type_traits/decay.h>
+#include <__type_traits/is_constructible.h>
+#include <__type_traits/is_same.h>
+#include <__type_traits/remove_cvref.h>
+#include <__utility/forward.h>
+#include <__utility/move.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+#if _LIBCPP_STD_VER >= 20 && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_STOP_TOKEN)
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+class _LIBCPP_AVAILABILITY_SYNC jthread {
+public:
+  // types
+  using id                 = thread::id;
+  using native_handle_type = thread::native_handle_type;
+
+  // [thread.jthread.cons], constructors, move, and assignment
+  _LIBCPP_HIDE_FROM_ABI jthread() noexcept : __stop_source_(std::nostopstate) {}
+
+  template <class _Fun, class... _Args>
+  _LIBCPP_HIDE_FROM_ABI explicit jthread(_Fun&& __fun, _Args&&... __args)
+    requires(!std::is_same_v<remove_cvref_t<_Fun>, jthread>)
+      : __stop_source_(),
+        __thread_(__init_thread(__stop_source_, std::forward<_Fun>(__fun), std::forward<_Args>(__args)...)) {
+    static_assert(is_constructible_v<decay_t<_Fun>, _Fun>);
+    static_assert((is_constructible_v<decay_t<_Args>, _Args> && ...));
+    static_assert(is_invocable_v<decay_t<_Fun>, decay_t<_Args>...> ||
+                  is_invocable_v<decay_t<_Fun>, stop_token, decay_t<_Args>...>);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI ~jthread() {
+    if (joinable()) {
+      request_stop();
+      join();
+    }
+  }
+
+  jthread(const jthread&) = delete;
+
+  _LIBCPP_HIDE_FROM_ABI jthread(jthread&&) noexcept = default;
+
+  jthread& operator=(const jthread&) = delete;
+
+  _LIBCPP_HIDE_FROM_ABI jthread& operator=(jthread&& __other) noexcept {
+    if (this != &__other) {
+      if (joinable()) {
+        request_stop();
+        join();
+      }
+      __stop_source_ = std::move(__other.__stop_source_);
+      __thread_      = std::move(__other.__thread_);
+    }
+
+    return *this;
+  }
+
+  // [thread.jthread.mem], members
+  _LIBCPP_HIDE_FROM_ABI void swap(jthread& __other) noexcept {
+    std::swap(__stop_source_, __other.__stop_source_);
+    std::swap(__thread_, __other.__thread_);
+  }
+
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool joinable() const noexcept { return get_id() != id(); }
+
+  _LIBCPP_HIDE_FROM_ABI void join() { __thread_.join(); }
+
+  _LIBCPP_HIDE_FROM_ABI void detach() { __thread_.detach(); }
+
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI id get_id() const noexcept { return __thread_.get_id(); }
+
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI native_handle_type native_handle() { return __thread_.native_handle(); }
+
+  // [thread.jthread.stop], stop token handling
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI stop_source get_stop_source() noexcept { return __stop_source_; }
+
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI stop_token get_stop_token() const noexcept { return __stop_source_.get_token(); }
+
+  _LIBCPP_HIDE_FROM_ABI bool request_stop() noexcept { return __stop_source_.request_stop(); }
+
+  // [thread.jthread.special], specialized algorithms
+  _LIBCPP_HIDE_FROM_ABI friend void swap(jthread& __lhs, jthread& __rhs) noexcept { __lhs.swap(__rhs); }
+
+  // [thread.jthread.static], static members
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI static unsigned int hardware_concurrency() noexcept {
+    return thread::hardware_concurrency();
+  }
+
+private:
+  template <class _Fun, class... _Args>
+  _LIBCPP_HIDE_FROM_ABI static thread __init_thread(const stop_source& __ss, _Fun&& __fun, _Args&&... __args) {
+    if constexpr (is_invocable_v<decay_t<_Fun>, stop_token, decay_t<_Args>...>) {
+      return thread(std::forward<_Fun>(__fun), __ss.get_token(), std::forward<_Args>(__args)...);
+    } else {
+      return thread(std::forward<_Fun>(__fun), std::forward<_Args>(__args)...);
+    }
+  }
+
+  stop_source __stop_source_;
+  thread __thread_;
+};
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_STD_VER >= 20 && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_STOP_TOKEN)
+
+#endif // _LIBCPP___THREAD_JTHREAD_H

libcxx/include/module.modulemap.in

module std_private_system_error_error_condition [system] {
   header "__system_error/error_condition.h"
   export std_private_functional_hash
   export std_private_functional_unary_function
 }
 module std_private_system_error_system_error    [system] { header "__system_error/system_error.h" }
 
 module std_private_thread_formatter            [system] { header "__thread/formatter.h" }
 module std_private_thread_id                   [system] { header "__thread/id.h" }
+module std_private_thread_jthread              [system] {
+  header "__thread/jthread.h"
+  export *
+}
 module std_private_thread_poll_with_backoff    [system] { header "__thread/poll_with_backoff.h" }
 module std_private_thread_this_thread          [system] { header "__thread/this_thread.h" }
 module std_private_thread_thread               [system] {
   header "__thread/thread.h"
   export *
 }
 module std_private_thread_timed_backoff_policy [system] { header "__thread/timed_backoff_policy.h" }
 

libcxx/include/thread

 }  // std
 
 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__availability>
 #include <__config>
 #include <__thread/formatter.h>
+#include <__thread/jthread.h>
 #include <__thread/this_thread.h>
 #include <__thread/thread.h>
 #include <__threading_support>
 #include <version>
 
 // standard-mandated includes
 
 // [thread.syn]

libcxx/modules/std/thread.inc

 export namespace std {
 #ifndef _LIBCPP_HAS_NO_THREADS
   // [thread.thread.class], class thread
   using std::thread;
 
   using std::swap;
 
   // [thread.jthread.class], class jthread
-  // using std::jthread;
+#  if !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_STOP_TOKEN)
+  using std::jthread;
+#  endif
 
   // [thread.thread.this], namespace this_thread
   namespace this_thread {
     using std::this_thread::get_id;
 
     using std::this_thread::sleep_for;
     using std::this_thread::sleep_until;
     using std::this_thread::yield;

libcxx/test/libcxx/transitive_includes/cxx03.csv

 stdexcept cstdlib
 stdexcept exception
 stdexcept iosfwd
 stop_token atomic
 stop_token cstddef
 stop_token cstdint
 stop_token cstring
 stop_token ctime
+stop_token iosfwd
 stop_token limits
 stop_token ratio
-stop_token thread
 stop_token type_traits
 stop_token version
 streambuf cstdint
 streambuf ios
 streambuf iosfwd
 streambuf version
 string algorithm
 string climits

 system_error cstdint
 system_error cstring
 system_error limits
 system_error stdexcept
 system_error string
 system_error type_traits
 system_error version
 thread array
+thread atomic
 thread cerrno
 thread chrono
 thread compare
 thread cstddef
 thread cstdint
 thread cstring
 thread ctime
 thread functional

libcxx/test/libcxx/transitive_includes/cxx11.csv

 stdexcept cstdlib
 stdexcept exception
 stdexcept iosfwd
 stop_token atomic
 stop_token cstddef
 stop_token cstdint
 stop_token cstring
 stop_token ctime
+stop_token iosfwd
 stop_token limits
 stop_token ratio
-stop_token thread
 stop_token type_traits
 stop_token version
 streambuf cstdint
 streambuf ios
 streambuf iosfwd
 streambuf version
 string algorithm
 string climits

 system_error cstdint
 system_error cstring
 system_error limits
 system_error stdexcept
 system_error string
 system_error type_traits
 system_error version
 thread array
+thread atomic
 thread cerrno
 thread chrono
 thread compare
 thread cstddef
 thread cstdint
 thread cstring
 thread ctime
 thread functional

libcxx/test/libcxx/transitive_includes/cxx14.csv

 stdexcept cstdlib
 stdexcept exception
 stdexcept iosfwd
 stop_token atomic
 stop_token cstddef
 stop_token cstdint
 stop_token cstring
 stop_token ctime
+stop_token iosfwd
 stop_token limits
 stop_token ratio
-stop_token thread
 stop_token type_traits
 stop_token version
 streambuf cstdint
 streambuf ios
 streambuf iosfwd
 streambuf version
 string algorithm
 string climits

 system_error cstdint
 system_error cstring
 system_error limits
 system_error stdexcept
 system_error string
 system_error type_traits
 system_error version
 thread array
+thread atomic
 thread cerrno
 thread chrono
 thread compare
 thread cstddef
 thread cstdint
 thread cstring
 thread ctime
 thread functional

libcxx/test/libcxx/transitive_includes/cxx17.csv

 stdexcept cstdlib
 stdexcept exception
 stdexcept iosfwd
 stop_token atomic
 stop_token cstddef
 stop_token cstdint
 stop_token cstring
 stop_token ctime
+stop_token iosfwd
 stop_token limits
 stop_token ratio
-stop_token thread
 stop_token type_traits
 stop_token version
 streambuf cstdint
 streambuf ios
 streambuf iosfwd
 streambuf version
 string algorithm
 string climits

 system_error cstdint
 system_error cstring
 system_error limits
 system_error stdexcept
 system_error string
 system_error type_traits
 system_error version
 thread array
+thread atomic
 thread cerrno
 thread chrono
 thread compare
 thread cstddef
 thread cstdint
 thread cstring
 thread ctime
 thread functional

libcxx/test/libcxx/transitive_includes/cxx20.csv

 stdexcept cstdlib
 stdexcept exception
 stdexcept iosfwd
 stop_token atomic
 stop_token cstddef
 stop_token cstdint
 stop_token cstring
 stop_token ctime
+stop_token iosfwd
 stop_token limits
 stop_token ratio
-stop_token thread
 stop_token type_traits
 stop_token version
 streambuf cstdint
 streambuf ios
 streambuf iosfwd
 streambuf version
 string algorithm
 string climits

 system_error cstdint
 system_error cstring
 system_error limits
 system_error stdexcept
 system_error string
 system_error type_traits
 system_error version
 thread array
+thread atomic
 thread cerrno
 thread compare
 thread cstddef
 thread cstdint
 thread cstring
 thread ctime
 thread functional
 thread iosfwd

libcxx/test/libcxx/transitive_includes/cxx23.csv

 stack new
 stack version
 stdexcept iosfwd
 stop_token atomic
 stop_token cstddef
 stop_token cstdint
 stop_token cstring
 stop_token ctime
+stop_token iosfwd
 stop_token limits
 stop_token ratio
-stop_token thread
 stop_token version
 streambuf cstdint
 streambuf ios
 streambuf iosfwd
 streambuf version
 string climits
 string compare
 string cstddef

 strstream version
 system_error cerrno
 system_error compare
 system_error cstddef
 system_error stdexcept
 system_error string
 system_error version
 thread array
+thread atomic
 thread cerrno
 thread compare
 thread cstddef
 thread cstdint
 thread ctime
 thread initializer_list
 thread iosfwd
 thread limits

libcxx/test/libcxx/transitive_includes/cxx26.csv

 stack new
 stack version
 stdexcept iosfwd
 stop_token atomic
 stop_token cstddef
 stop_token cstdint
 stop_token cstring
 stop_token ctime
+stop_token iosfwd
 stop_token limits
 stop_token ratio
-stop_token thread
 stop_token version
 streambuf cstdint
 streambuf ios
 streambuf iosfwd
 streambuf version
 string climits
 string compare
 string cstddef

 strstream version
 system_error cerrno
 system_error compare
 system_error cstddef
 system_error stdexcept
 system_error string
 system_error version
 thread array
+thread atomic
 thread cerrno
 thread compare
 thread cstddef
 thread cstdint
 thread ctime
 thread initializer_list
 thread iosfwd
 thread limits

libcxx/test/std/thread/thread.jthread/assign.move.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: libcpp-has-no-experimental-stop_token
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// XFAIL: availability-synchronization_library-missing
+// ADDITIONAL_COMPILE_FLAGS: -Wno-self-move
+
+// jthread& operator=(jthread&&) noexcept;
+
+#include <atomic>
+#include <cassert>
+#include <concepts>
+#include <stop_token>
+#include <thread>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#include "test_macros.h"
+
+static_assert(std::is_nothrow_move_assignable_v<std::jthread>);
+
+int main(int, char**) {
+  // If &x == this is true, there are no effects.
+  {
+    std::jthread j([] {});
+    auto id      = j.get_id();
+    auto ssource = j.get_stop_source();
+    j            = std::move(j);
+    assert(j.get_id() == id);
+    assert(j.get_stop_source() == ssource);
+  }
+
+  // if joinable() is true, calls request_stop() and then join()
+  // request_stop is called
+  {
+    std::jthread j1([] {});
+    bool called = false;
+    std::stop_callback cb(j1.get_stop_token(), [&called] { called = true; });
+
+    std::jthread j2([] {});
+    j1 = std::move(j2);
+    assert(called);
+  }
+
+  // if joinable() is true, calls request_stop() and then join()
+  // join is called
+  {
+    std::atomic_int calledTimes = 0;
+    std::vector<std::jthread> jts;
+    constexpr auto numberOfThreads = 10u;
+    jts.reserve(numberOfThreads);
+    for (auto i = 0u; i < numberOfThreads; ++i) {
+      jts.emplace_back([&] {
+        std::this_thread::sleep_for(std::chrono::milliseconds(2));
+        calledTimes.fetch_add(1, std::memory_order_relaxed);
+      });
+    }
+
+    for (auto i = 0u; i < numberOfThreads; ++i) {
+      jts[i] = std::jthread{};
+    }
+
+    // If join was called as expected, calledTimes must equal to numberOfThreads
+    // If join was not called, there is a chance that the check below happened
+    // before test threads incrementing the counter, thus calledTimed would
+    // be less than numberOfThreads.
+    // This is not going to catch issues 100%. Creating more threads to increase
+    // the probability of catching the issue
+    assert(calledTimes.load(std::memory_order_relaxed) == numberOfThreads);
+  }
+
+  // then assigns the state of x to *this
+  {
+    std::jthread j1([] {});
+    std::jthread j2([] {});
+    auto id2      = j2.get_id();
+    auto ssource2 = j2.get_stop_source();
+
+    j1 = std::move(j2);
+
+    assert(j1.get_id() == id2);
+    assert(j1.get_stop_source() == ssource2);
+  }
+
+  // sets x to a default constructed state
+  {
+    std::jthread j1([] {});
+    std::jthread j2([] {});
+    j1 = std::move(j2);
+
+    assert(j2.get_id() == std::jthread::id());
+    assert(!j2.get_stop_source().stop_possible());
+  }
+
+  // joinable is false
+  {
+    std::jthread j1;
+    std::jthread j2([] {});
+
+    auto j2Id = j2.get_id();
+
+    j1 = std::move(j2);
+
+    assert(j1.get_id() == j2Id);
+  }
+
+  return 0;
+}

libcxx/test/std/thread/thread.jthread/cons.default.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: libcpp-has-no-experimental-stop_token
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// XFAIL: availability-synchronization_library-missing
+
+// jthread() noexcept;
+
+#include <cassert>
+#include <stop_token>
+#include <thread>
+#include <type_traits>
+
+#include "test_macros.h"
+
+static_assert(std::is_nothrow_default_constructible_v<std::jthread>);
+
+int main(int, char**) {
+  {
+    std::jthread jt = {}; // implicit
+    assert(!jt.get_stop_source().stop_possible());
+    assert(jt.get_id() == std::jthread::id());
+  }
+
+  return 0;
+}

libcxx/test/std/thread/thread.jthread/cons.func.token.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: libcpp-has-no-experimental-stop_token
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// XFAIL: availability-synchronization_library-missing
+
+// template<class F, class... Args>
+// explicit jthread(F&& f, Args&&... args);
+
+#include <cassert>
+#include <stop_token>
+#include <thread>
+#include <type_traits>
+
+#include "test_macros.h"
+
+template <class... Args>
+struct Func {
+  void operator()(Args...) const;
+};
+
+// Constraints: remove_cvref_t<F> is not the same type as jthread.
+static_assert(std::is_constructible_v<std::jthread, Func<>>);
+static_assert(std::is_constructible_v<std::jthread, Func<int>, int>);
+static_assert(!std::is_constructible_v<std::jthread, std::jthread const&>);
+
+// explicit
+template <class T>
+void conversion_test(T);
+
+template <class T, class... Args>
+concept ImplicitlyConstructible = requires(Args&&... args) { conversion_test<T>({std::forward<Args>(args)...}); };
+
+static_assert(!ImplicitlyConstructible<std::jthread, Func<>>);
+static_assert(!ImplicitlyConstructible<std::jthread, Func<int>, int>);
+
+int main(int, char**) {
+  // Effects: Initializes ssource
+  // Postconditions: get_id() != id() is true and ssource.stop_possible() is true
+  // and *this represents the newly started thread.
+  {
+    std::jthread jt{[] {}};
+    assert(jt.get_stop_source().stop_possible());
+    assert(jt.get_id() != std::jthread::id());
+  }
+
+  // The new thread of execution executes
+  // invoke(auto(std::forward<F>(f)), get_stop_token(), auto(std::forward<Args>(args))...)
+  // if that expression is well-formed,
+  {
+    int result = 0;
+    std::jthread jt{[&result](std::stop_token st, int i) {
+                      assert(st.stop_possible());
+                      assert(!st.stop_requested());
+                      result += i;
+                    },
+                    5};
+    jt.join();
+    assert(result == 5);
+  }
+
+  // otherwise
+  // invoke(auto(std::forward<F>(f)), auto(std::forward<Args>(args))...)
+  {
+    int result = 0;
+    std::jthread jt{[&result](int i) { result += i; }, 5};
+    jt.join();
+    assert(result == 5);
+  }
+
+  // with the values produced by auto being materialized ([conv.rval]) in the constructing thread.
+  {
+    struct TrackThread {
+      std::jthread::id threadId;
+      bool copyConstructed = false;
+      bool moveConstructed = false;
+
+      TrackThread() : threadId(std::this_thread::get_id()) {}
+      TrackThread(const TrackThread&) : threadId(std::this_thread::get_id()), copyConstructed(true) {}
+      TrackThread(TrackThread&&) : threadId(std::this_thread::get_id()), moveConstructed(true) {}
+    };
+
+    auto mainThread = std::this_thread::get_id();
+
+    TrackThread arg1;
+    std::jthread jt1{[mainThread](const TrackThread& arg) {
+                       assert(arg.threadId == mainThread);
+                       assert(arg.threadId != std::this_thread::get_id());
+                       assert(arg.copyConstructed);
+                     },
+                     arg1};
+
+    TrackThread arg2;
+    std::jthread jt2{[mainThread](const TrackThread& arg) {
+                       assert(arg.threadId == mainThread);
+                       assert(arg.threadId != std::this_thread::get_id());
+                       assert(arg.moveConstructed);
+                     },
+                     std::move(arg2)};
+  }
+
+#if !defined(TEST_HAS_NO_EXCEPTIONS)
+  // [Note 1: This implies that any exceptions not thrown from the invocation of the copy
+  // of f will be thrown in the constructing thread, not the new thread. - end note]
+  {
+    struct Exception {
+      std::jthread::id threadId;
+    };
+    struct ThrowOnCopyFunc {
+      ThrowOnCopyFunc() = default;
+      ThrowOnCopyFunc(const ThrowOnCopyFunc&) { throw Exception{std::this_thread::get_id()}; }
+      void operator()() const {}
+    };
+    ThrowOnCopyFunc f1;
+    try {
+      std::jthread jt{f1};
+      assert(false);
+    } catch (const Exception& e) {
+      assert(e.threadId == std::this_thread::get_id());
+    }
+  }
+#endif // !defined(TEST_HAS_NO_EXCEPTIONS)
+
+  // Synchronization: The completion of the invocation of the constructor
+  // synchronizes with the beginning of the invocation of the copy of f.
+  {
+    int flag = 0;
+    struct Arg {
+      int& flag_;
+      Arg(int& f) : flag_(f) {}
+
+      Arg(const Arg& other) : flag_(other.flag_) { flag_ = 5; }
+    };
+
+    Arg arg(flag);
+    std::jthread jt(
+        [&flag](const auto&) {
+          assert(flag == 5); // happens-after the copy-construction of arg
+        },
+        arg);
+  }
+
+  // Per https://eel.is/c++draft/thread.jthread.class#thread.jthread.cons-8:
+  //
+  // Throws: system_error if unable to start the new thread.
+  // Error conditions:
+  // resource_unavailable_try_again - the system lacked the necessary resources to create another thread,
+  // or the system-imposed limit on the number of threads in a process would be exceeded.
+  //
+  // Unfortunately, this is extremely hard to test portably so we don't have a test for this error condition right now.
+
+  return 0;
+}

libcxx/test/std/thread/thread.jthread/cons.move.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: libcpp-has-no-experimental-stop_token
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// XFAIL: availability-synchronization_library-missing
+
+// jthread(jthread&& x) noexcept;
+
+#include <cassert>
+#include <stop_token>
+#include <thread>
+#include <type_traits>
+#include <utility>
+
+#include "test_macros.h"
+
+static_assert(std::is_nothrow_move_constructible_v<std::jthread>);
+
+int main(int, char**) {
+  {
+    // x.get_id() == id() and get_id() returns the value of x.get_id() prior
+    // to the start of construction.
+    std::jthread j1{[] {}};
+    auto id1 = j1.get_id();
+
+    std::jthread j2(std::move(j1));
+    assert(j1.get_id() == std::jthread::id());
+    assert(j2.get_id() == id1);
+  }
+
+  {
+    // ssource has the value of x.ssource prior to the start of construction
+    // and x.ssource.stop_possible() is false.
+    std::jthread j1{[] {}};
+    auto ss1 = j1.get_stop_source();
+
+    std::jthread j2(std::move(j1));
+    assert(ss1 == j2.get_stop_source());
+    assert(!j1.get_stop_source().stop_possible());
+    assert(j2.get_stop_source().stop_possible());
+  }
+
+  return 0;
+}

libcxx/test/std/thread/thread.jthread/copy.delete.compile.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: libcpp-has-no-experimental-stop_token
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// XFAIL: availability-synchronization_library-missing
+
+// jthread(const jthread&) = delete;
+// jthread& operator=(const jthread&) = delete;
+
+#include <thread>
+#include <type_traits>
+
+static_assert(!std::is_copy_constructible_v<std::jthread>);
+static_assert(!std::is_copy_assignable_v<std::jthread>);

libcxx/test/std/thread/thread.jthread/detach.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: libcpp-has-no-experimental-stop_token
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// XFAIL: availability-synchronization_library-missing
+
+// void detach();
+
+#include <atomic>
+#include <cassert>
+#include <chrono>
+#include <concepts>
+#include <functional>
+#include <optional>
+#include <system_error>
+#include <thread>
+#include <type_traits>
+
+#include "test_macros.h"
+
+int main(int, char**) {
+  // Effects: The thread represented by *this continues execution without the calling thread blocking.
+  {
+    std::atomic_bool start{false};
+    std::atomic_bool done{false};
+    std::optional<std::jthread> jt{[&start, &done] {
+      start.wait(false);
+      done = true;
+    }};
+
+    // If it blocks, it will deadlock here
+    jt->detach();
+
+    jt.reset();
+
+    // The other thread continues execution
+    start = true;
+    start.notify_all();
+    while (!done) {
+    }
+  }
+
+  // Postconditions: get_id() == id().
+  {
+    std::jthread jt{[] {}};
+    assert(jt.get_id() != std::jthread::id());
+    jt.detach();
+    assert(jt.get_id() == std::jthread::id());
+  }
+
+#if !defined(TEST_HAS_NO_EXCEPTIONS)
+  // Throws: system_error when an exception is required ([thread.req.exception]).
+  // invalid_argument - if the thread is not joinable.
+  {
+    std::jthread jt;
+    try {
+      jt.detach();
+      assert(false);
+    } catch (const std::system_error& err) {
+      assert(err.code() == std::errc::invalid_argument);
+    }
+  }
+#endif
+
+  std::this_thread::sleep_for(std::chrono::milliseconds{2});
+  return 0;
+}

libcxx/test/std/thread/thread.jthread/dtor.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: libcpp-has-no-experimental-stop_token
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// XFAIL: availability-synchronization_library-missing
+
+// ~jthread();
+
+#include <atomic>
+#include <cassert>
+#include <optional>
+#include <stop_token>
+#include <thread>
+#include <type_traits>
+#include <vector>
+#include "test_macros.h"
+
+int main(int, char**) {
+  // !joinable()
+  {
+    std::jthread jt;
+    assert(!jt.joinable());
+  }
+
+  // If joinable() is true, calls request_stop() and then join().
+  // request_stop is called
+  {
+    std::optional<std::jthread> jt([] {});
+    bool called = false;
+    std::stop_callback cb(jt->get_stop_token(), [&called] { called = true; });
+    jt.reset();
+    assert(called);
+  }
+
+  // If joinable() is true, calls request_stop() and then join().
+  // join is called
+  {
+    std::atomic_int calledTimes = 0;
+    std::vector<std::jthread> jts;
+
+    constexpr auto numberOfThreads = 10u;
+    jts.reserve(numberOfThreads);
+    for (auto i = 0u; i < numberOfThreads; ++i) {
+      jts.emplace_back([&calledTimes] {
+        std::this_thread::sleep_for(std::chrono::milliseconds{2});
+        calledTimes.fetch_add(1, std::memory_order_relaxed);
+      });
+    }
+    jts.clear();
+
+    // If join was called as expected, calledTimes must equal to numberOfThreads
+    // If join was not called, there is a chance that the check below happened
+    // before test threads incrementing the counter, thus calledTimed would
+    // be less than numberOfThreads.
+    // This is not going to catch issues 100%. Creating more threads would increase
+    // the probability of catching the issue
+    assert(calledTimes.load(std::memory_order_relaxed) == numberOfThreads);
+  }
+
+  return 0;
+}

libcxx/test/std/thread/thread.jthread/get_id.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: libcpp-has-no-experimental-stop_token
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// XFAIL: availability-synchronization_library-missing
+
+// [[nodiscard]] id get_id() const noexcept;
+
+#include <cassert>
+#include <concepts>
+#include <thread>
+#include <type_traits>
+
+#include "test_macros.h"
+
+static_assert(noexcept(std::declval<const std::jthread&>().get_id()));
+
+int main(int, char**) {
+  // Does not represent a thread
+  {
+    const std::jthread jt;
+    std::same_as<std::jthread::id> decltype(auto) result = jt.get_id();
+    assert(result == std::jthread::id());
+  }
+
+  // Represents a thread
+  {
+    const std::jthread jt{[] {}};
+    std::same_as<std::jthread::id> decltype(auto) result = jt.get_id();
+    assert(result != std::jthread::id());
+  }
+
+  return 0;
+}

libcxx/test/std/thread/thread.jthread/get_stop_source.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: libcpp-has-no-experimental-stop_token
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// XFAIL: availability-synchronization_library-missing
+
+// [[nodiscard]] stop_source get_stop_source() noexcept;
+
+#include <cassert>
+#include <concepts>
+#include <stop_token>
+#include <thread>
+#include <type_traits>
+
+#include "test_macros.h"
+
+static_assert(noexcept(std::declval<std::jthread&>().get_stop_source()));
+
+int main(int, char**) {
+  // Represents a thread
+  {
+    std::jthread jt{[] {}};
+    std::same_as<std::stop_source> decltype(auto) result = jt.get_stop_source();
+    assert(result.stop_possible());
+  }
+
+  // Does not represents a thread
+  {
+    std::jthread jt{};
+    std::same_as<std::stop_source> decltype(auto) result = jt.get_stop_source();
+    assert(!result.stop_possible());
+  }
+
+  return 0;
+}

libcxx/test/std/thread/thread.jthread/get_stop_token.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: libcpp-has-no-experimental-stop_token
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// XFAIL: availability-synchronization_library-missing
+
+// [[nodiscard]] stop_token get_stop_token() const noexcept;
+
+#include <cassert>
+#include <concepts>
+#include <stop_token>
+#include <thread>
+#include <type_traits>
+#include <utility>
+
+#include "test_macros.h"
+
+static_assert(noexcept(std::declval<const std::jthread&>().get_stop_token()));
+
+int main(int, char**) {
+  // Represents a thread
+  {
+    std::jthread jt{[] {}};
+    auto ss                                         = jt.get_stop_source();
+    std::same_as<std::stop_token> decltype(auto) st = std::as_const(jt).get_stop_token();
+
+    assert(st.stop_possible());
+    assert(!st.stop_requested());
+    ss.request_stop();
+    assert(st.stop_requested());
+  }
+
+  // Does not represent a thread
+  {
+    const std::jthread jt{};
+    std::same_as<std::stop_token> decltype(auto) st = jt.get_stop_token();
+
+    assert(!st.stop_possible());
+  }
+
+  return 0;
+}

libcxx/test/std/thread/thread.jthread/hardware_concurrency.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: libcpp-has-no-experimental-stop_token
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// XFAIL: availability-synchronization_library-missing
+
+// [[nodiscard]] static unsigned int hardware_concurrency() noexcept;
+
+#include <cassert>
+#include <concepts>
+#include <thread>
+#include <type_traits>
+
+#include "test_macros.h"
+
+static_assert(noexcept(std::jthread::hardware_concurrency()));
+
+int main(int, char**) {
+  std::same_as<unsigned int> decltype(auto) result = std::jthread::hardware_concurrency();
+  assert(result == std::thread::hardware_concurrency());
+
+  return 0;
+}

libcxx/test/std/thread/thread.jthread/join.deadlock.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
+//
+//===----------------------------------------------------------------------===//
+//
+// Windows cannot detect the deadlock. Instead of throwing system_error,
+// it would dead lock the test
+// UNSUPPORTED: windows
+
+// TSAN bug: https://github.com/llvm/llvm-project/issues/66537
+// UNSUPPORTED: tsan
+
+// UNSUPPORTED: no-threads
+// UNSUPPORTED: no-exceptions
+// UNSUPPORTED: libcpp-has-no-experimental-stop_token
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// XFAIL: availability-synchronization_library-missing
+
+// void join();
+
+#include <atomic>
+#include <cassert>
+#include <chrono>
+#include <concepts>
+#include <functional>
+#include <system_error>
+#include <thread>
+#include <type_traits>
+#include <vector>
+
+#include "test_macros.h"
+
+int main(int, char**) {
+  // resource_deadlock_would_occur - if deadlock is detected or get_id() == this_thread::get_id().
+  {
+    std::function<void()> f;
+    std::atomic_bool start = false;
+    std::atomic_bool done  = false;
+
+    std::jthread jt{[&] {
+      start.wait(false);
+      f();
+      done = true;
+      done.notify_all();
+    }};
+
+    f = [&] {
+      try {
+        jt.join();
+        assert(false);
+      } catch (const std::system_error& err) {
+        assert(err.code() == std::errc::resource_deadlock_would_occur);
+      }
+    };
+    start = true;
+    start.notify_all();
+    done.wait(false);
+  }
+
+  return 0;
+}

libcxx/test/std/thread/thread.jthread/join.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: libcpp-has-no-experimental-stop_token
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// XFAIL: availability-synchronization_library-missing
+
+// void join();
+
+#include <atomic>
+#include <cassert>
+#include <chrono>
+#include <concepts>
+#include <functional>
+#include <system_error>
+#include <thread>
+#include <type_traits>
+#include <vector>
+
+#include "test_macros.h"
+
+int main(int, char**) {
+  // Effects: Blocks until the thread represented by *this has completed.
+  {
+    std::atomic_int calledTimes = 0;
+    std::vector<std::jthread> jts;
+    constexpr auto numberOfThreads = 10u;
+    jts.reserve(numberOfThreads);
+    for (auto i = 0u; i < numberOfThreads; ++i) {
+      jts.emplace_back([&] {
+        std::this_thread::sleep_for(std::chrono::milliseconds(2));
+        calledTimes.fetch_add(1, std::memory_order_relaxed);
+      });
+    }
+
+    for (auto i = 0u; i < numberOfThreads; ++i) {
+      jts[i].join();
+    }
+
+    // If join did block, calledTimes must equal to numberOfThreads
+    // If join did not block, there is a chance that the check below happened
+    // before test threads incrementing the counter, thus calledTimed would
+    // be less than numberOfThreads.
+    // This is not going to catch issues 100%. Creating more threads to increase
+    // the probability of catching the issue
+    assert(calledTimes.load(std::memory_order_relaxed) == numberOfThreads);
+  }
+
+  // Synchronization: The completion of the thread represented by *this synchronizes with
+  // ([intro.multithread]) the corresponding successful join() return.
+  {
+    bool flag = false;
+    std::jthread jt{[&] { flag = true; }};
+    jt.join();
+    assert(flag); // non atomic write is visible to the current thread
+  }
+
+  // Postconditions: The thread represented by *this has completed. get_id() == id().
+  {
+    std::jthread jt{[] {}};
+    assert(jt.get_id() != std::jthread::id());
+    jt.join();
+    assert(jt.get_id() == std::jthread::id());
+  }
+
+#if !defined(TEST_HAS_NO_EXCEPTIONS)
+  // Throws: system_error when an exception is required ([thread.req.exception]).
+  // invalid_argument - if the thread is not joinable.
+  {
+    std::jthread jt;
+    try {
+      jt.join();
+      assert(false);
+    } catch (const std::system_error& err) {
+      assert(err.code() == std::errc::invalid_argument);
+    }
+  }
+
+#endif
+
+  return 0;
+}

libcxx/test/std/thread/thread.jthread/joinable.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: libcpp-has-no-experimental-stop_token
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// XFAIL: availability-synchronization_library-missing
+
+// [[nodiscard]] bool joinable() const noexcept;
+
+#include <atomic>
+#include <cassert>
+#include <concepts>
+#include <thread>
+#include <type_traits>
+
+#include "test_macros.h"
+
+static_assert(noexcept(std::declval<const std::jthread&>().joinable()));
+
+int main(int, char**) {
+  // Default constructed
+  {
+    const std::jthread jt;
+    std::same_as<bool> decltype(auto) result = jt.joinable();
+    assert(!result);
+  }
+
+  // Non-default constructed
+  {
+    const std::jthread jt{[] {}};
+    std::same_as<bool> decltype(auto) result = jt.joinable();
+    assert(result);
+  }
+
+  // Non-default constructed
+  // the thread of execution has not finished
+  {
+    std::atomic_bool done = false;
+    const std::jthread jt{[&done] { done.wait(false); }};
+    std::same_as<bool> decltype(auto) result = jt.joinable();
+    done                                     = true;
+    assert(result);
+  }
+
+  return 0;
+}

libcxx/test/std/thread/thread.jthread/nodiscard.verify.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: libcpp-has-no-experimental-stop_token
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// XFAIL: availability-synchronization_library-missing
+
+// [[nodiscard]] bool joinable() const noexcept;
+// [[nodiscard]] id get_id() const noexcept;
+// [[nodiscard]] native_handle_type native_handle();
+// [[nodiscard]] stop_source get_stop_source() noexcept;
+// [[nodiscard]] stop_token get_stop_token() const noexcept;
+// [[nodiscard]] static unsigned int hardware_concurrency() noexcept;
+
+#include <thread>
+
+void test() {
+  std::jthread jt;
+  jt.joinable();             // expected-warning {{ignoring return value of function}}
+  jt.get_id();               // expected-warning {{ignoring return value of function}}
+  jt.native_handle();        // expected-warning {{ignoring return value of function}}
+  jt.get_stop_source();      // expected-warning {{ignoring return value of function}}
+  jt.get_stop_token();       // expected-warning {{ignoring return value of function}}
+  jt.hardware_concurrency(); // expected-warning {{ignoring return value of function}}
+}

libcxx/test/std/thread/thread.jthread/request_stop.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: libcpp-has-no-experimental-stop_token
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// XFAIL: availability-synchronization_library-missing
+
+// [[nodiscard]] bool request_stop() noexcept;
+
+#include <cassert>
+#include <concepts>
+#include <stop_token>
+#include <thread>
+#include <type_traits>
+
+#include "test_macros.h"
+
+static_assert(noexcept(std::declval<std::jthread&>().request_stop()));
+
+int main(int, char**) {
+  // Represents a thread
+  {
+    std::jthread jt{[] {}};
+    auto st = jt.get_stop_token();
+    assert(!st.stop_requested());
+    std::same_as<bool> decltype(auto) result = jt.request_stop();
+    assert(result);
+    assert(st.stop_requested());
+  }
+
+  // Does not represent a thread
+  {
+    std::jthread jt{};
+    std::same_as<bool> decltype(auto) result = jt.request_stop();
+    assert(!result);
+  }
+
+  return 0;
+}

libcxx/test/std/thread/thread.jthread/swap.free.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: libcpp-has-no-experimental-stop_token
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// XFAIL: availability-synchronization_library-missing
+
+// friend void swap(jthread& x, jthread& y) noexcept;
+
+#include <cassert>
+#include <thread>
+#include <type_traits>
+
+#include "test_macros.h"
+
+template <class T>
+concept IsFreeSwapNoexcept = requires(T& a, T& b) {
+  { swap(a, b) } noexcept;
+};
+
+static_assert(IsFreeSwapNoexcept<std::jthread>);
+
+int main(int, char**) {
+  // x is default constructed
+  {
+    std::jthread t1;
+    std::jthread t2{[] {}};
+    const auto originalId2 = t2.get_id();
+    swap(t1, t2);
+
+    assert(t1.get_id() == originalId2);
+    assert(t2.get_id() == std::jthread::id());
+  }
+
+  // y is default constructed
+  {
+    std::jthread t1([] {});
+    std::jthread t2{};
+    const auto originalId1 = t1.get_id();
+    swap(t1, t2);
+
+    assert(t1.get_id() == std::jthread::id());
+    assert(t2.get_id() == originalId1);
+  }
+
+  // both not default constructed
+  {
+    std::jthread t1([] {});
+    std::jthread t2{[] {}};
+    const auto originalId1 = t1.get_id();
+    const auto originalId2 = t2.get_id();
+    swap(t1, t2);
+
+    assert(t1.get_id() == originalId2);
+    assert(t2.get_id() == originalId1);
+  }
+
+  // both default constructed
+  {
+    std::jthread t1;
+    std::jthread t2;
+    swap(t1, t2);
+
+    assert(t1.get_id() == std::jthread::id());
+    assert(t2.get_id() == std::jthread::id());
+  }
+
+  return 0;
+}

libcxx/test/std/thread/thread.jthread/swap.member.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: libcpp-has-no-experimental-stop_token
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// XFAIL: availability-synchronization_library-missing
+
+// void swap(jthread& x) noexcept;
+
+#include <cassert>
+#include <thread>
+#include <type_traits>
+
+#include "test_macros.h"
+
+template <class T>
+concept IsMemberSwapNoexcept = requires(T& a, T& b) {
+  { a.swap(b) } noexcept;
+};
+
+static_assert(IsMemberSwapNoexcept<std::jthread>);
+
+int main(int, char**) {
+  // this is default constructed
+  {
+    std::jthread t1;
+    std::jthread t2{[] {}};
+    const auto originalId2 = t2.get_id();
+    t1.swap(t2);
+
+    assert(t1.get_id() == originalId2);
+    assert(t2.get_id() == std::jthread::id());
+  }
+
+  // that is default constructed
+  {
+    std::jthread t1([] {});
+    std::jthread t2{};
+    const auto originalId1 = t1.get_id();
+    t1.swap(t2);
+
+    assert(t1.get_id() == std::jthread::id());
+    assert(t2.get_id() == originalId1);
+  }
+
+  // both not default constructed
+  {
+    std::jthread t1([] {});
+    std::jthread t2{[] {}};
+    const auto originalId1 = t1.get_id();
+    const auto originalId2 = t2.get_id();
+    t1.swap(t2);
+
+    assert(t1.get_id() == originalId2);
+    assert(t2.get_id() == originalId1);
+  }
+
+  // both default constructed
+  {
+    std::jthread t1;
+    std::jthread t2;
+    t1.swap(t2);
+
+    assert(t1.get_id() == std::jthread::id());
+    assert(t2.get_id() == std::jthread::id());
+  }
+
+  return 0;
+}

libcxx/test/std/thread/thread.jthread/type.compile.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: libcpp-has-no-experimental-stop_token
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// XFAIL: availability-synchronization_library-missing
+
+//  using id = thread::id;
+//  using native_handle_type = thread::native_handle_type;
+
+#include <thread>
+#include <type_traits>
+
+static_assert(std::is_same_v<std::jthread::id, std::thread::id>);
+static_assert(std::is_same_v<std::jthread::native_handle_type, std::thread::native_handle_type>);