[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

#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

24

30

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

39–45

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

28

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

66

[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

663

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

36 ↗

(On Diff #556829)

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.

69–71 ↗

(On Diff #556829)

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

63–64

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

23–28 ↗

(On Diff #556829)

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

37 ↗

(On Diff #556829)

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

13 ↗

(On Diff #556829)

This should be a link to the github issue!

36 ↗

(On Diff #556829)

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

2

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/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/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/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 <__threading_support>
 #include <atomic>
-#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(
         __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 <__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
+
+#ifdef _LIBCPP_HAS_NO_THREADS
+#  error "<thread> is not supported since libc++ has been configured without support for threads."
+#endif
+
+#if _LIBCPP_STD_VER >= 20
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+class 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(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&& __other) 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 thread __init_thread(_Fun&& __fun, _Args&&... __args) {
+    if constexpr (is_invocable_v<decay_t<_Fun>, stop_token, decay_t<_Args>...>) {
+      return thread(std::forward<_Fun>(__fun), __stop_source_.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
+
+#endif // _LIBCPP___THREAD_JTHREAD_H

libcxx/include/module.modulemap.in

   }
   module thread {
     @requires_LIBCXX_ENABLE_THREADS@
     header "thread"
     export *
 
     module __thread {
       module formatter            { private header "__thread/formatter.h" }
+      module jthread              { private header "__thread/jthread.h" }
       module poll_with_backoff    { private header "__thread/poll_with_backoff.h" }
       module this_thread          { private header "__thread/this_thread.h" }
       module thread               { private header "__thread/thread.h" }
       module timed_backoff_policy { private header "__thread/timed_backoff_policy.h" }
     }
   }
   module tuple {
     header "tuple"

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/poll_with_backoff.h>
 #include <__thread/this_thread.h>
 #include <__thread/thread.h>
 #include <__thread/timed_backoff_policy.h>
 #include <__threading_support>
 #include <version>
 
 // Some tests rely on these chrono dependencies

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: c++03, c++11, c++14, c++17
+// XFAIL: availability-synchronization_library-missing
+// ADDITIONAL_COMPILE_FLAGS: -Wno-self-move
+
+// jthread& operator=(jthread&&) noexcept;
+
+#include <cassert>
+#include <concepts>
+#include <stop_token>
+#include <thread>
+#include <type_traits>
+#include <utility>
+
+#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
+  {
+    bool called = false;
+    std::jthread j1([&called] {
+      std::this_thread::sleep_for(std::chrono::milliseconds{2});
+      called = true;
+    });
+
+    std::jthread j2;
+    j1 = std::move(j2);
+    assert(called);
+  }
+
+  // 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());
+  }
+
+  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: 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: 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)};
+  }
+
+  // [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());
+    }
+  }
+
+  // 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);
+  }
+
+  // TODO: test the following:
+  //
+  // 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.
+
+  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: 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(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: 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/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: c++03, c++11, c++14, c++17
+// XFAIL: availability-synchronization_library-missing
+
+// ~jthread();
+
+#include <cassert>
+#include <optional>
+#include <stop_token>
+#include <thread>
+#include <type_traits>
+#include "test_macros.h"
+
+int main(int, char**) {
+  // !joinable()
+  { std::jthread jt; }
+
+  // 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
+  {
+    bool called = false;
+    std::optional<std::jthread> jt([&called] {
+      std::this_thread::sleep_for(std::chrono::milliseconds{2});
+      called = true;
+    });
+    jt.reset();
+    assert(called);
+  }
+
+  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: 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 <thread>
+#include <type_traits>
+
+#include "test_macros.h"
+
+int main(int, char**) {
+  // Effects: Blocks until the thread represented by *this has completed.
+  {
+    std::atomic_bool flag = false;
+    std::jthread jt{[&] {
+      std::this_thread::sleep_for(std::chrono::milliseconds(2));
+      flag = true;
+    }};
+    jt.join();
+    assert(flag); // if join did not block, sometimes this could be false
+  }
+
+  // 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);
+    }
+  }
+
+  // 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);
+  }
+#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: c++03, c++11, c++14, c++17
+// XFAIL: availability-synchronization_library-missing
+
+// [[nodiscard]] bool joinable() const noexcept;
+
+#include <cassert>
+#include <concepts>
+#include <thread>
+#include <type_traits>
+
+#include "test_macros.h"
+
+template <class T>
+concept IsJoinableNoexcept = requires(const T& a) {
+  { a.joinable() } noexcept;
+};
+
+static_assert(IsJoinableNoexcept<std::jthread>);
+
+int main(int, char**) {
+
+  // Default constructed
+  {
+    const std::jthread jt;
+    std::same_as<bool> auto result = jt.joinable();
+    assert(!result);
+  }
+
+  // Non-default constructed
+  {
+    const std::jthread jt{[]{}};
+    std::same_as<bool> auto result = jt.joinable();
+    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: 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/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: 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/typedef.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: 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>);