[libc++][NFC] Granularise <thread> header

[huixie90]

Summary

• This was to make implementing jthread easier and requested in https://reviews.llvm.org/D151559

[huixie90]

private headers

[huixie90]

CI

[huixie90]

missing includes

[Mordante]

LGTM after undoing the formatting changes and the CI passes.
Can you make two followup commits

• format all the new files, I don't like to do that is the same commit, that makes tracking changes in git harder
• modernize the code _LIBCPP_INLINE_VISIBILITY -> _LIBCPP_HIDE_FROM_ABI, _VSTD -> std, typedef -> using

libcxx/include/thread

111–115

Please don't mix formatting and splitting in one patch.

[huixie90]

unformatting

[huixie90]

CI

[huixie90]

CI

[huixie90]

try again

[huixie90]

includes

[ldionne]

LGTM w/ a few comments and green CI.

libcxx/include/__thread/formatter.h

31–33

I think I would only keep this error message in the top-level <thread> header. That's just for consistency with e.g. <filesystem>. (here and everywhere else)

libcxx/include/thread

91–92

Let's remove those includes since they don't contribute to the public API of <thread>.

At first we tried to systematically include all headers from <__foo/*.h> inside <foo>, but we noticed it didn't work (I think it was causing circular dependency issues but I think @Mordante might remember more context) so now I guess the only consistent thing we can do is include only the ones that contribute to the public API of <foo>.

98–100

Let's fix those tests instead.

[huixie90]

rebase

[Mordante]

libcxx/include/thread

91–92

I don't exactly recall. I thought still wanted to include all <__foo/*.h>. That might be less important nowadays since most headers use the granularized parts of a header instead of the entire header.

[huixie90]

rebase + trigger CI

[huixie90]

address issues

[huixie90]

CI

[huixie90]

rebase + CI

[philnik]

libcxx/include/thread

111–115

Why are these headers only removed when explicitly setting _LIBCPP_REMOVE_TRANSITIVE_INCLUDES?

libcxx/include/CMakeLists.txt

set(files
   __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/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
   __tuple/sfinae_helpers.h
   __tuple/tuple_element.h
   __tuple/tuple_indices.h

libcxx/include/__stop_token/stop_state.h

 #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 <atomic>
+#include <cstdint>
 #include <thread>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 

libcxx/include/__thread/formatter.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_FORMATTER_H
+#define _LIBCPP___THREAD_FORMATTER_H
+
+#include <__concepts/arithmetic.h>
+#include <__config>
+#include <__format/concepts.h>
+#include <__format/format_parse_context.h>
+#include <__format/formatter.h>
+#include <__format/formatter_integral.h>
+#include <__format/parser_std_format_spec.h>
+#include <__threading_support>
+#include <__type_traits/conditional.h>
+#include <__type_traits/is_pointer.h>
+#include <__type_traits/is_same.h>
+#include <cstdint>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+#if _LIBCPP_STD_VER >= 23
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template <__fmt_char_type _CharT>
+struct _LIBCPP_TEMPLATE_VIS formatter<__thread_id, _CharT> {
+  public:
+    template <class _ParseContext>
+    _LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator parse(_ParseContext& __ctx) {
+        return __parser_.__parse(__ctx, __format_spec::__fields_fill_align_width);
+    }
+
+    template <class _FormatContext>
+    _LIBCPP_HIDE_FROM_ABI typename _FormatContext::iterator format(__thread_id __id, _FormatContext& __ctx) const {
+        // In __threading_support __libcpp_thread_id is either a
+        // unsigned long long or a pthread_t.
+        //
+        // The type of pthread_t is left unspecified in POSIX so it can be any
+        // type. The most logical types are an integral or pointer.
+        // On Linux systems pthread_t is an unsigned long long.
+        // On Apple systems pthread_t is a pointer type.
+        //
+        // Note the output should match what the stream operator does. Since
+        // the ostream operator has been shipped years before this formatter
+        // was added to the Standard, this formatter does what the stream
+        // operator does. This may require platform specific changes.
+
+        using _Tp = decltype(__get_underlying_id(__id));
+        using _Cp = conditional_t<integral<_Tp>, _Tp, conditional_t<is_pointer_v<_Tp>, uintptr_t, void>>;
+        static_assert(!is_same_v<_Cp, void>, "unsupported thread::id type, please file a bug report");
+
+        __format_spec::__parsed_specifications<_CharT> __specs = __parser_.__get_parsed_std_specifications(__ctx);
+        if constexpr (is_pointer_v<_Tp>) {
+          __specs.__std_.__alternate_form_ = true;
+          __specs.__std_.__type_           = __format_spec::__type::__hexadecimal_lower_case;
+        }
+        return __formatter::__format_integer(reinterpret_cast<_Cp>(__get_underlying_id(__id)), __ctx, __specs);
+    }
+
+    __format_spec::__parser<_CharT> __parser_{.__alignment_ = __format_spec::__alignment::__right};
+};
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_STD_VER >= 23
+
+#endif // _LIBCPP___THREAD_FORMATTER_H

libcxx/include/__thread/this_thread.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_THIS_THREAD_H
+#define _LIBCPP___THREAD_THIS_THREAD_H
+
+#include <__chrono/steady_clock.h>
+#include <__chrono/time_point.h>
+#include <__condition_variable/condition_variable.h>
+#include <__config>
+#include <__mutex/mutex.h>
+#include <__mutex/unique_lock.h>
+#include <__threading_support>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace this_thread
+{
+
+_LIBCPP_EXPORTED_FROM_ABI void sleep_for(const chrono::nanoseconds& __ns);
+
+template <class _Rep, class _Period>
+_LIBCPP_HIDE_FROM_ABI void
+sleep_for(const chrono::duration<_Rep, _Period>& __d)
+{
+    if (__d > chrono::duration<_Rep, _Period>::zero())
+    {
+        // The standard guarantees a 64bit signed integer resolution for nanoseconds,
+        // so use INT64_MAX / 1e9 as cut-off point. Use a constant to avoid <climits>
+        // and issues with long double folding on PowerPC with GCC.
+        _LIBCPP_CONSTEXPR chrono::duration<long double> __max =
+            chrono::duration<long double>(9223372036.0L);
+        chrono::nanoseconds __ns;
+        if (__d < __max)
+        {
+            __ns = chrono::duration_cast<chrono::nanoseconds>(__d);
+            if (__ns < __d)
+                ++__ns;
+        }
+        else
+            __ns = chrono::nanoseconds::max();
+        this_thread::sleep_for(__ns);
+    }
+}
+
+template <class _Clock, class _Duration>
+_LIBCPP_HIDE_FROM_ABI void
+sleep_until(const chrono::time_point<_Clock, _Duration>& __t)
+{
+    mutex __mut;
+    condition_variable __cv;
+    unique_lock<mutex> __lk(__mut);
+    while (_Clock::now() < __t)
+        __cv.wait_until(__lk, __t);
+}
+
+template <class _Duration>
+inline _LIBCPP_INLINE_VISIBILITY
+void
+sleep_until(const chrono::time_point<chrono::steady_clock, _Duration>& __t)
+{
+    this_thread::sleep_for(__t - chrono::steady_clock::now());
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+void yield() _NOEXCEPT {__libcpp_thread_yield();}
+
+} // namespace this_thread
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___THREAD_THIS_THREAD_H

libcxx/include/__thread/thread.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
-#define _LIBCPP_THREAD
+#ifndef _LIBCPP___THREAD_THREAD_H
+#define _LIBCPP___THREAD_THREAD_H
 
-/*
-
-    thread synopsis
-
-namespace std
-{
-
-class thread
-{
-public:
-    class id;
-    typedef pthread_t native_handle_type;
-
-    thread() noexcept;
-    template <class F, class ...Args> explicit thread(F&& f, Args&&... args);
-    ~thread();
-
-    thread(const thread&) = delete;
-    thread(thread&& t) noexcept;
-
-    thread& operator=(const thread&) = delete;
-    thread& operator=(thread&& t) noexcept;
-
-    void swap(thread& t) noexcept;
-
-    bool joinable() const noexcept;
-    void join();
-    void detach();
-    id get_id() const noexcept;
-    native_handle_type native_handle();
-
-    static unsigned hardware_concurrency() noexcept;
-};
-
-void swap(thread& x, thread& y) noexcept;
-
-class thread::id
-{
-public:
-    id() noexcept;
-};
-
-bool operator==(thread::id x, thread::id y) noexcept;
-bool operator!=(thread::id x, thread::id y) noexcept;             // removed in C++20
-bool operator< (thread::id x, thread::id y) noexcept;             // removed in C++20
-bool operator<=(thread::id x, thread::id y) noexcept;             // removed in C++20
-bool operator> (thread::id x, thread::id y) noexcept;             // removed in C++20
-bool operator>=(thread::id x, thread::id y) noexcept;             // removed in C++20
-strong_ordering operator<=>(thread::id x, thread::id y) noexcept; // C++20
-
-template<class charT, class traits>
-basic_ostream<charT, traits>&
-operator<<(basic_ostream<charT, traits>& out, thread::id id);
-
-template<class charT>
-struct formatter<thread::id, charT>;
-
-namespace this_thread
-{
-
-thread::id get_id() noexcept;
-
-void yield() noexcept;
-
-template <class Clock, class Duration>
-void sleep_until(const chrono::time_point<Clock, Duration>& abs_time);
-
-template <class Rep, class Period>
-void sleep_for(const chrono::duration<Rep, Period>& rel_time);
-
-}  // this_thread
-
-}  // std
-
-*/
-
-#include <__assert> // all public C++ headers provide the assertion handler
-#include <__availability>
-#include <__chrono/steady_clock.h>
-#include <__chrono/time_point.h>
-#include <__concepts/arithmetic.h>
 #include <__condition_variable/condition_variable.h>
 #include <__config>
 #include <__exception/terminate.h>
-#include <__format/concepts.h>
-#include <__format/format_parse_context.h>
-#include <__format/formatter.h>
-#include <__format/formatter_integral.h>
-#include <__format/parser_std_format_spec.h>
 #include <__functional/hash.h>
 #include <__functional/unary_function.h>
-#include <__memory/addressof.h>
 #include <__memory/unique_ptr.h>
 #include <__mutex/mutex.h>
-#include <__mutex/unique_lock.h>
 #include <__system_error/system_error.h>
-#include <__thread/poll_with_backoff.h>
-#include <__thread/timed_backoff_policy.h>
 #include <__threading_support>
 #include <__utility/forward.h>
-#include <cstddef>
-#include <cstdint>
-#include <iosfwd>
 #include <tuple>
-#include <version>
-
-// standard-mandated includes
-
-// [thread.syn]
-#include <compare>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
-_LIBCPP_PUSH_MACROS
-#include <__undef_macros>
-
-#ifdef _LIBCPP_HAS_NO_THREADS
-# error "<thread> is not supported since libc++ has been configured without support for threads."
-#endif
-
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Tp> class __thread_specific_ptr;
 class _LIBCPP_EXPORTED_FROM_ABI __thread_struct;
 class _LIBCPP_HIDDEN __thread_struct_imp;
 class __assoc_sub_state;
 
 _LIBCPP_EXPORTED_FROM_ABI __thread_specific_ptr<__thread_struct>& __thread_local_data();

 };
 
 template<class _CharT, class _Traits>
 _LIBCPP_INLINE_VISIBILITY
 basic_ostream<_CharT, _Traits>&
 operator<<(basic_ostream<_CharT, _Traits>& __os, __thread_id __id)
 {return __os << __id.__id_;}
 
-#if _LIBCPP_STD_VER >= 23
-template <__fmt_char_type _CharT>
-struct _LIBCPP_TEMPLATE_VIS formatter<__thread_id, _CharT> {
-  public:
-    template <class _ParseContext>
-    _LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator parse(_ParseContext& __ctx) {
-        return __parser_.__parse(__ctx, __format_spec::__fields_fill_align_width);
-    }
-
-    template <class _FormatContext>
-    _LIBCPP_HIDE_FROM_ABI typename _FormatContext::iterator format(__thread_id __id, _FormatContext& __ctx) const {
-        // In __threading_support __libcpp_thread_id is either a
-        // unsigned long long or a pthread_t.
-        //
-        // The type of pthread_t is left unspecified in POSIX so it can be any
-        // type. The most logical types are an integral or pointer.
-        // On Linux systems pthread_t is an unsigned long long.
-        // On Apple systems pthread_t is a pointer type.
-        //
-        // Note the output should match what the stream operator does. Since
-        // the ostream operator has been shipped years before this formatter
-        // was added to the Standard, this formatter does what the stream
-        // operator does. This may require platform specific changes.
-
-        using _Tp = decltype(__get_underlying_id(__id));
-        using _Cp = conditional_t<integral<_Tp>, _Tp, conditional_t<is_pointer_v<_Tp>, uintptr_t, void>>;
-        static_assert(!is_same_v<_Cp, void>, "unsupported thread::id type, please file a bug report");
-
-        __format_spec::__parsed_specifications<_CharT> __specs = __parser_.__get_parsed_std_specifications(__ctx);
-        if constexpr (is_pointer_v<_Tp>) {
-          __specs.__std_.__alternate_form_ = true;
-          __specs.__std_.__type_           = __format_spec::__type::__hexadecimal_lower_case;
-        }
-        return __formatter::__format_integer(reinterpret_cast<_Cp>(__get_underlying_id(__id)), __ctx, __specs);
-    }
-
-    __format_spec::__parser<_CharT> __parser_{.__alignment_ = __format_spec::__alignment::__right};
-};
-#endif // _LIBCPP_STD_VER >= 23
-
 class _LIBCPP_EXPORTED_FROM_ABI thread
 {
     __libcpp_thread_t __t_;
 
     thread(const thread&);
     thread& operator=(const thread&);
 public:
     typedef __thread_id id;
else
         __throw_system_error(__ec, "thread constructor failed");
 }
 
 #endif // _LIBCPP_CXX03_LANG
 
 inline _LIBCPP_INLINE_VISIBILITY
 void swap(thread& __x, thread& __y) _NOEXCEPT {__x.swap(__y);}
 
-namespace this_thread
-{
-
-_LIBCPP_EXPORTED_FROM_ABI void sleep_for(const chrono::nanoseconds& __ns);
-
-template <class _Rep, class _Period>
-_LIBCPP_HIDE_FROM_ABI void
-sleep_for(const chrono::duration<_Rep, _Period>& __d)
-{
-    if (__d > chrono::duration<_Rep, _Period>::zero())
-    {
-        // The standard guarantees a 64bit signed integer resolution for nanoseconds,
-        // so use INT64_MAX / 1e9 as cut-off point. Use a constant to avoid <climits>
-        // and issues with long double folding on PowerPC with GCC.
-        _LIBCPP_CONSTEXPR chrono::duration<long double> __max =
-            chrono::duration<long double>(9223372036.0L);
-        chrono::nanoseconds __ns;
-        if (__d < __max)
-        {
-            __ns = chrono::duration_cast<chrono::nanoseconds>(__d);
-            if (__ns < __d)
-                ++__ns;
-        }
-        else
-            __ns = chrono::nanoseconds::max();
-        this_thread::sleep_for(__ns);
-    }
-}
-
-template <class _Clock, class _Duration>
-_LIBCPP_HIDE_FROM_ABI void
-sleep_until(const chrono::time_point<_Clock, _Duration>& __t)
-{
-    mutex __mut;
-    condition_variable __cv;
-    unique_lock<mutex> __lk(__mut);
-    while (_Clock::now() < __t)
-        __cv.wait_until(__lk, __t);
-}
-
-template <class _Duration>
-inline _LIBCPP_INLINE_VISIBILITY
-void
-sleep_until(const chrono::time_point<chrono::steady_clock, _Duration>& __t)
-{
-    this_thread::sleep_for(__t - chrono::steady_clock::now());
-}
-
-inline _LIBCPP_INLINE_VISIBILITY
-void yield() _NOEXCEPT {__libcpp_thread_yield();}
-
-} // namespace this_thread
-
 _LIBCPP_END_NAMESPACE_STD
 
-_LIBCPP_POP_MACROS
-
-#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 17
-#  include <chrono>
-#endif
-
-#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
-#  include <cstring>
-#  include <functional>
-#  include <new>
-#  include <system_error>
-#endif
-
-#endif // _LIBCPP_THREAD
+#endif // _LIBCPP___THREAD_THREAD_H

libcxx/include/future

 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__availability>
 #include <__chrono/duration.h>
 #include <__chrono/time_point.h>
 #include <__config>
 #include <__exception/exception_ptr.h>
+#include <__memory/addressof.h>
 #include <__memory/allocator.h>
 #include <__memory/allocator_arg_t.h>
 #include <__memory/allocator_destructor.h>
 #include <__memory/allocator_traits.h>
 #include <__memory/compressed_pair.h>
 #include <__memory/pointer_traits.h>
 #include <__memory/shared_ptr.h>
 #include <__memory/unique_ptr.h>

libcxx/include/module.modulemap.in

module system_error {
     }
   }
   module thread {
     @requires_LIBCXX_ENABLE_THREADS@
     header "thread"
     export *
 
     module __thread {
+      module formatter            { private header "__thread/formatter.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"
     export *
 
     module get_fwd          { private header "__fwd/get.h" }

libcxx/include/thread

 }  // this_thread
 
 }  // std
 
 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__availability>
-#include <__chrono/steady_clock.h>
-#include <__chrono/time_point.h>
-#include <__concepts/arithmetic.h>
-#include <__condition_variable/condition_variable.h>
 #include <__config>
-#include <__exception/terminate.h>
-#include <__format/concepts.h>
-#include <__format/format_parse_context.h>
-#include <__format/formatter.h>
-#include <__format/formatter_integral.h>
-#include <__format/parser_std_format_spec.h>
-#include <__functional/hash.h>
-#include <__functional/unary_function.h>
-#include <__memory/addressof.h>
-#include <__memory/unique_ptr.h>
-#include <__mutex/mutex.h>
-#include <__mutex/unique_lock.h>
-#include <__system_error/system_error.h>
-#include <__thread/poll_with_backoff.h>
-#include <__thread/timed_backoff_policy.h>
+#include <__thread/formatter.h>
+#include <__thread/this_thread.h>
+#include <__thread/thread.h>
 #include <__threading_support>
-#include <__utility/forward.h>
-#include <cstddef>
-#include <cstdint>
-#include <iosfwd>
-#include <tuple>
 #include <version>
 
 // standard-mandated includes
 
 // [thread.syn]
 #include <compare>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
-_LIBCPP_PUSH_MACROS
-#include <__undef_macros>
-
 #ifdef _LIBCPP_HAS_NO_THREADS
 # error "<thread> is not supported since libc++ has been configured without support for threads."
 #endif
 
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-template <class _Tp> class __thread_specific_ptr;
-class _LIBCPP_EXPORTED_FROM_ABI __thread_struct;
-class _LIBCPP_HIDDEN __thread_struct_imp;
-class __assoc_sub_state;
-
-_LIBCPP_EXPORTED_FROM_ABI __thread_specific_ptr<__thread_struct>& __thread_local_data();
-
-class _LIBCPP_EXPORTED_FROM_ABI __thread_struct
-{
-    __thread_struct_imp* __p_;
-
-    __thread_struct(const __thread_struct&);
-    __thread_struct& operator=(const __thread_struct&);
-public:
-    __thread_struct();
-    ~__thread_struct();
-
-    void notify_all_at_thread_exit(condition_variable*, mutex*);
-    void __make_ready_at_thread_exit(__assoc_sub_state*);
-};
-
-template <class _Tp>
-class __thread_specific_ptr
-{
-    __libcpp_tls_key __key_;
-
-     // Only __thread_local_data() may construct a __thread_specific_ptr
-     // and only with _Tp == __thread_struct.
-    static_assert((is_same<_Tp, __thread_struct>::value), "");
-    __thread_specific_ptr();
-    friend _LIBCPP_EXPORTED_FROM_ABI __thread_specific_ptr<__thread_struct>& __thread_local_data();
-
-    __thread_specific_ptr(const __thread_specific_ptr&);
-    __thread_specific_ptr& operator=(const __thread_specific_ptr&);
-
-    _LIBCPP_HIDDEN static void _LIBCPP_TLS_DESTRUCTOR_CC __at_thread_exit(void*);
-
-public:
-    typedef _Tp* pointer;
-
-    ~__thread_specific_ptr();
-
-    _LIBCPP_INLINE_VISIBILITY
-    pointer get() const {return static_cast<_Tp*>(__libcpp_tls_get(__key_));}
-    _LIBCPP_INLINE_VISIBILITY
-    pointer operator*() const {return *get();}
-    _LIBCPP_INLINE_VISIBILITY
-    pointer operator->() const {return get();}
-    void set_pointer(pointer __p);
-};
-
-template <class _Tp>
-void _LIBCPP_TLS_DESTRUCTOR_CC
-__thread_specific_ptr<_Tp>::__at_thread_exit(void* __p)
-{
-    delete static_cast<pointer>(__p);
-}
-
-template <class _Tp>
-__thread_specific_ptr<_Tp>::__thread_specific_ptr()
-{
-  int __ec =
-      __libcpp_tls_create(&__key_, &__thread_specific_ptr::__at_thread_exit);
-  if (__ec)
-    __throw_system_error(__ec, "__thread_specific_ptr construction failed");
-}
-
-template <class _Tp>
-__thread_specific_ptr<_Tp>::~__thread_specific_ptr()
-{
-    // __thread_specific_ptr is only created with a static storage duration
-    // so this destructor is only invoked during program termination. Invoking
-    // pthread_key_delete(__key_) may prevent other threads from deleting their
-    // thread local data. For this reason we leak the key.
-}
-
-template <class _Tp>
-void
-__thread_specific_ptr<_Tp>::set_pointer(pointer __p)
-{
-    _LIBCPP_ASSERT(get() == nullptr,
-                   "Attempting to overwrite thread local data");
-    std::__libcpp_tls_set(__key_, __p);
-}
-
-template<>
-struct _LIBCPP_TEMPLATE_VIS hash<__thread_id>
-    : public __unary_function<__thread_id, size_t>
-{
-    _LIBCPP_INLINE_VISIBILITY
-    size_t operator()(__thread_id __v) const _NOEXCEPT
-    {
-        return hash<__libcpp_thread_id>()(__v.__id_);
-    }
-};
-
-template<class _CharT, class _Traits>
-_LIBCPP_INLINE_VISIBILITY
-basic_ostream<_CharT, _Traits>&
-operator<<(basic_ostream<_CharT, _Traits>& __os, __thread_id __id)
-{return __os << __id.__id_;}
-
-#if _LIBCPP_STD_VER >= 23
-template <__fmt_char_type _CharT>
-struct _LIBCPP_TEMPLATE_VIS formatter<__thread_id, _CharT> {
-  public:
-    template <class _ParseContext>
-    _LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator parse(_ParseContext& __ctx) {
-        return __parser_.__parse(__ctx, __format_spec::__fields_fill_align_width);
-    }
-
-    template <class _FormatContext>
-    _LIBCPP_HIDE_FROM_ABI typename _FormatContext::iterator format(__thread_id __id, _FormatContext& __ctx) const {
-        // In __threading_support __libcpp_thread_id is either a
-        // unsigned long long or a pthread_t.
-        //
-        // The type of pthread_t is left unspecified in POSIX so it can be any
-        // type. The most logical types are an integral or pointer.
-        // On Linux systems pthread_t is an unsigned long long.
-        // On Apple systems pthread_t is a pointer type.
-        //
-        // Note the output should match what the stream operator does. Since
-        // the ostream operator has been shipped years before this formatter
-        // was added to the Standard, this formatter does what the stream
-        // operator does. This may require platform specific changes.
-
-        using _Tp = decltype(__get_underlying_id(__id));
-        using _Cp = conditional_t<integral<_Tp>, _Tp, conditional_t<is_pointer_v<_Tp>, uintptr_t, void>>;
-        static_assert(!is_same_v<_Cp, void>, "unsupported thread::id type, please file a bug report");
-
-        __format_spec::__parsed_specifications<_CharT> __specs = __parser_.__get_parsed_std_specifications(__ctx);
-        if constexpr (is_pointer_v<_Tp>) {
-          __specs.__std_.__alternate_form_ = true;
-          __specs.__std_.__type_           = __format_spec::__type::__hexadecimal_lower_case;
-        }
-        return __formatter::__format_integer(reinterpret_cast<_Cp>(__get_underlying_id(__id)), __ctx, __specs);
-    }
-
-    __format_spec::__parser<_CharT> __parser_{.__alignment_ = __format_spec::__alignment::__right};
-};
-#endif // _LIBCPP_STD_VER >= 23
-
-class _LIBCPP_EXPORTED_FROM_ABI thread
-{
-    __libcpp_thread_t __t_;
-
-    thread(const thread&);
-    thread& operator=(const thread&);
-public:
-    typedef __thread_id id;
-    typedef __libcpp_thread_t native_handle_type;
-
-    _LIBCPP_INLINE_VISIBILITY
-    thread() _NOEXCEPT : __t_(_LIBCPP_NULL_THREAD) {}
-#ifndef _LIBCPP_CXX03_LANG
-    template <class _Fp, class ..._Args,
-              class = __enable_if_t<!is_same<__remove_cvref_t<_Fp>, thread>::value> >
-        _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
-        explicit thread(_Fp&& __f, _Args&&... __args);
-#else  // _LIBCPP_CXX03_LANG
-    template <class _Fp>
-    _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
-    explicit thread(_Fp __f);
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES)
+#  include <cstddef>
+#  include <ctime>
+#  include <iosfwd>
+#  include <ratio>
 #endif
-    ~thread();
-
-    _LIBCPP_INLINE_VISIBILITY
-    thread(thread&& __t) _NOEXCEPT : __t_(__t.__t_) {
-        __t.__t_ = _LIBCPP_NULL_THREAD;
-    }
-
-    _LIBCPP_INLINE_VISIBILITY
-    thread& operator=(thread&& __t) _NOEXCEPT {
-        if (!__libcpp_thread_isnull(&__t_))
-            terminate();
-        __t_ = __t.__t_;
-        __t.__t_ = _LIBCPP_NULL_THREAD;
-        return *this;
-    }
-
-    _LIBCPP_INLINE_VISIBILITY
-    void swap(thread& __t) _NOEXCEPT {_VSTD::swap(__t_, __t.__t_);}
-
-    _LIBCPP_INLINE_VISIBILITY
-    bool joinable() const _NOEXCEPT {return !__libcpp_thread_isnull(&__t_);}
-    void join();
-    void detach();
-    _LIBCPP_INLINE_VISIBILITY
-    id get_id() const _NOEXCEPT {return __libcpp_thread_get_id(&__t_);}
-    _LIBCPP_INLINE_VISIBILITY
-    native_handle_type native_handle() _NOEXCEPT {return __t_;}
-
-    static unsigned hardware_concurrency() _NOEXCEPT;
-};
-
-#ifndef _LIBCPP_CXX03_LANG
-
-template <class _TSp, class _Fp, class ..._Args, size_t ..._Indices>
-inline _LIBCPP_INLINE_VISIBILITY
-void
-__thread_execute(tuple<_TSp, _Fp, _Args...>& __t, __tuple_indices<_Indices...>)
-{
-    _VSTD::__invoke(_VSTD::move(_VSTD::get<1>(__t)), _VSTD::move(_VSTD::get<_Indices>(__t))...);
-}
-
-template <class _Fp>
-_LIBCPP_INLINE_VISIBILITY
-void* __thread_proxy(void* __vp)
-{
-    // _Fp = tuple< unique_ptr<__thread_struct>, Functor, Args...>
-    unique_ptr<_Fp> __p(static_cast<_Fp*>(__vp));
-    __thread_local_data().set_pointer(_VSTD::get<0>(*__p.get()).release());
-    typedef typename __make_tuple_indices<tuple_size<_Fp>::value, 2>::type _Index;
-    _VSTD::__thread_execute(*__p.get(), _Index());
-    return nullptr;
-}
-
-template <class _Fp, class ..._Args,
-          class
-         >
-thread::thread(_Fp&& __f, _Args&&... __args)
-{
-    typedef unique_ptr<__thread_struct> _TSPtr;
-    _TSPtr __tsp(new __thread_struct);
-    typedef tuple<_TSPtr, __decay_t<_Fp>, __decay_t<_Args>...> _Gp;
-    unique_ptr<_Gp> __p(
-            new _Gp(_VSTD::move(__tsp),
-                    _VSTD::forward<_Fp>(__f),
-                    _VSTD::forward<_Args>(__args)...));
-    int __ec = _VSTD::__libcpp_thread_create(&__t_, &__thread_proxy<_Gp>, __p.get());
-    if (__ec == 0)
-        __p.release();
-    else
-        __throw_system_error(__ec, "thread constructor failed");
-}
-
-#else  // _LIBCPP_CXX03_LANG
-
-template <class _Fp>
-struct __thread_invoke_pair {
-    // This type is used to pass memory for thread local storage and a functor
-    // to a newly created thread because std::pair doesn't work with
-    // std::unique_ptr in C++03.
-    _LIBCPP_HIDE_FROM_ABI __thread_invoke_pair(_Fp& __f) : __tsp_(new __thread_struct), __fn_(__f) {}
-    unique_ptr<__thread_struct> __tsp_;
-    _Fp __fn_;
-};
-
-template <class _Fp>
-_LIBCPP_HIDE_FROM_ABI void* __thread_proxy_cxx03(void* __vp)
-{
-    unique_ptr<_Fp> __p(static_cast<_Fp*>(__vp));
-    __thread_local_data().set_pointer(__p->__tsp_.release());
-    (__p->__fn_)();
-    return nullptr;
-}
-
-template <class _Fp>
-thread::thread(_Fp __f)
-{
-
-    typedef __thread_invoke_pair<_Fp> _InvokePair;
-    typedef unique_ptr<_InvokePair> _PairPtr;
-    _PairPtr __pp(new _InvokePair(__f));
-    int __ec = _VSTD::__libcpp_thread_create(&__t_, &__thread_proxy_cxx03<_InvokePair>, __pp.get());
-    if (__ec == 0)
-        __pp.release();
-    else
-        __throw_system_error(__ec, "thread constructor failed");
-}
-
-#endif // _LIBCPP_CXX03_LANG
-
-inline _LIBCPP_INLINE_VISIBILITY
-void swap(thread& __x, thread& __y) _NOEXCEPT {__x.swap(__y);}
-
-namespace this_thread
-{
-
-_LIBCPP_EXPORTED_FROM_ABI void sleep_for(const chrono::nanoseconds& __ns);
-
-template <class _Rep, class _Period>
-_LIBCPP_HIDE_FROM_ABI void
-sleep_for(const chrono::duration<_Rep, _Period>& __d)
-{
-    if (__d > chrono::duration<_Rep, _Period>::zero())
-    {
-        // The standard guarantees a 64bit signed integer resolution for nanoseconds,
-        // so use INT64_MAX / 1e9 as cut-off point. Use a constant to avoid <climits>
-        // and issues with long double folding on PowerPC with GCC.
-        _LIBCPP_CONSTEXPR chrono::duration<long double> __max =
-            chrono::duration<long double>(9223372036.0L);
-        chrono::nanoseconds __ns;
-        if (__d < __max)
-        {
-            __ns = chrono::duration_cast<chrono::nanoseconds>(__d);
-            if (__ns < __d)
-                ++__ns;
-        }
-        else
-            __ns = chrono::nanoseconds::max();
-        this_thread::sleep_for(__ns);
-    }
-}
-
-template <class _Clock, class _Duration>
-_LIBCPP_HIDE_FROM_ABI void
-sleep_until(const chrono::time_point<_Clock, _Duration>& __t)
-{
-    mutex __mut;
-    condition_variable __cv;
-    unique_lock<mutex> __lk(__mut);
-    while (_Clock::now() < __t)
-        __cv.wait_until(__lk, __t);
-}
-
-template <class _Duration>
-inline _LIBCPP_INLINE_VISIBILITY
-void
-sleep_until(const chrono::time_point<chrono::steady_clock, _Duration>& __t)
-{
-    this_thread::sleep_for(__t - chrono::steady_clock::now());
-}
-
-inline _LIBCPP_INLINE_VISIBILITY
-void yield() _NOEXCEPT {__libcpp_thread_yield();}
-
-} // namespace this_thread
-
-_LIBCPP_END_NAMESPACE_STD
-
-_LIBCPP_POP_MACROS
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 17
 #  include <chrono>
 #endif
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <cstring>
 #  include <functional>
 #  include <new>
 #  include <system_error>
+#  include <type_traits>
 #endif
 
 #endif // _LIBCPP_THREAD

libcxx/src/atomic.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
 //
 //===----------------------------------------------------------------------===//
 
 #include <__config>
 #ifndef _LIBCPP_HAS_NO_THREADS
 
+#include <__thread/timed_backoff_policy.h>
 #include <atomic>
 #include <climits>
 #include <functional>
 #include <thread>
 
 #ifdef __linux__
 
 #include <unistd.h>

libcxx/src/thread.cpp

 //===------------------------- thread.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
 //
 //===----------------------------------------------------------------------===//
 
 #include <__config>
 
 #ifndef _LIBCPP_HAS_NO_THREADS
 
+#include <__thread/poll_with_backoff.h>
+#include <__thread/timed_backoff_policy.h>
 #include <exception>
 #include <future>
 #include <limits>
 #include <thread>
 #include <vector>
 
 #if __has_include(<unistd.h>)
 # include <unistd.h> // for sysconf

libcxx/test/libcxx/transitive_includes/cxx03.csv

 stack limits
 stack type_traits
 stack version
 stdexcept cstdlib
 stdexcept exception
 stdexcept iosfwd
 stop_token atomic
 stop_token cstddef
+stop_token cstdint
 stop_token limits
 stop_token thread
 stop_token version
 streambuf cstdint
 streambuf ios
 streambuf iosfwd
 streambuf version
 string algorithm

libcxx/test/libcxx/transitive_includes/cxx11.csv

 stack limits
 stack type_traits
 stack version
 stdexcept cstdlib
 stdexcept exception
 stdexcept iosfwd
 stop_token atomic
 stop_token cstddef
+stop_token cstdint
 stop_token limits
 stop_token thread
 stop_token version
 streambuf cstdint
 streambuf ios
 streambuf iosfwd
 streambuf version
 string algorithm

libcxx/test/libcxx/transitive_includes/cxx14.csv

 stack limits
 stack type_traits
 stack version
 stdexcept cstdlib
 stdexcept exception
 stdexcept iosfwd
 stop_token atomic
 stop_token cstddef
+stop_token cstdint
 stop_token limits
 stop_token thread
 stop_token version
 streambuf cstdint
 streambuf ios
 streambuf iosfwd
 streambuf version
 string algorithm

libcxx/test/libcxx/transitive_includes/cxx17.csv

 stack limits
 stack type_traits
 stack version
 stdexcept cstdlib
 stdexcept exception
 stdexcept iosfwd
 stop_token atomic
 stop_token cstddef
+stop_token cstdint
 stop_token limits
 stop_token thread
 stop_token version
 streambuf cstdint
 streambuf ios
 streambuf iosfwd
 streambuf version
 string algorithm

libcxx/test/libcxx/transitive_includes/cxx20.csv

 stack limits
 stack type_traits
 stack version
 stdexcept cstdlib
 stdexcept exception
 stdexcept iosfwd
 stop_token atomic
 stop_token cstddef
+stop_token cstdint
 stop_token limits
 stop_token thread
 stop_token version
 streambuf cstdint
 streambuf ios
 streambuf iosfwd
 streambuf version
 string algorithm

libcxx/test/libcxx/transitive_includes/cxx23.csv

 stack cstdint
 stack deque
 stack initializer_list
 stack limits
 stack version
 stdexcept iosfwd
 stop_token atomic
 stop_token cstddef
+stop_token cstdint
 stop_token limits
 stop_token thread
 stop_token version
 streambuf cstdint
 streambuf ios
 streambuf iosfwd
 streambuf version
 string climits

 system_error version
 thread array
 thread cerrno
 thread compare
 thread cstddef
 thread cstdint
 thread cstdlib
 thread ctime
+thread initializer_list
 thread iosfwd
 thread limits
 thread locale
 thread new
 thread ratio
 thread stdexcept
 thread string
 thread string_view

libcxx/test/libcxx/transitive_includes/cxx26.csv

 stack cstdint
 stack deque
 stack initializer_list
 stack limits
 stack version
 stdexcept iosfwd
 stop_token atomic
 stop_token cstddef
+stop_token cstdint
 stop_token limits
 stop_token thread
 stop_token version
 streambuf cstdint
 streambuf ios
 streambuf iosfwd
 streambuf version
 string climits

 system_error version
 thread array
 thread cerrno
 thread compare
 thread cstddef
 thread cstdint
 thread cstdlib
 thread ctime
+thread initializer_list
 thread iosfwd
 thread limits
 thread locale
 thread new
 thread ratio
 thread stdexcept
 thread string
 thread string_view

libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_duration.pass.cpp

 
 // template <class Rep, class Period>
 //   shared_lock(mutex_type& m, const chrono::duration<Rep, Period>& rel_time);
 
 #include <thread>
 
 #include <atomic>
 #include <cassert>
+#include <chrono>
 #include <cstdlib>
 #include <shared_mutex>
 #include <vector>
 
 #include "make_test_thread.h"
 #include "test_macros.h"
 
 std::shared_timed_mutex m;

libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_time_point.pass.cpp

 // class shared_timed_mutex;
 
 // template <class Clock, class Duration>
 //   shared_lock(mutex_type& m, const chrono::time_point<Clock, Duration>& abs_time);
 
 #include <thread>
 
 #include <atomic>
+#include <chrono>
 #include <cassert>
 #include <cstdlib>
 #include <shared_mutex>
 #include <vector>
 
 #include "make_test_thread.h"
 #include "test_macros.h"
 

libcxx/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_for.pass.cpp

 
 // template <class Rep, class Period>
 //     bool try_lock_for(const chrono::duration<Rep, Period>& rel_time);
 
 #include <shared_mutex>
 #include <thread>
 #include <cstdlib>
 #include <cassert>
+#include <chrono>
 
 #include "make_test_thread.h"
 #include "test_macros.h"
 
 std::shared_timed_mutex m;
 
 typedef std::chrono::steady_clock Clock;
 typedef Clock::time_point time_point;

libcxx/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_shared_for.pass.cpp

 // template <class Rep, class Period>
 //     bool try_lock_shared_for(const chrono::duration<Rep, Period>& rel_time);
 
 #include <shared_mutex>
 #include <thread>
 #include <vector>
 #include <cstdlib>
 #include <cassert>
+#include <chrono>
 
 #include "make_test_thread.h"
 #include "test_macros.h"
 
 std::shared_timed_mutex m;
 
 typedef std::chrono::steady_clock Clock;
 typedef Clock::time_point time_point;

libcxx/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_shared_until.pass.cpp

 
 // template <class Clock, class Duration>
 //     bool try_lock_shared_until(const chrono::time_point<Clock, Duration>& abs_time);
 
 #include <thread>
 
 #include <atomic>
 #include <cassert>
+#include <chrono>
 #include <cstdlib>
 #include <shared_mutex>
 #include <vector>
 
 #include "make_test_thread.h"
 #include "test_macros.h"
 
 std::shared_timed_mutex m;

libcxx/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_until.pass.cpp

 
 // template <class Clock, class Duration>
 //     bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time);
 
 #include <shared_mutex>
 #include <thread>
 #include <cstdlib>
 #include <cassert>
+#include <chrono>
 
 #include "make_test_thread.h"
 #include "test_macros.h"
 
 std::shared_timed_mutex m;
 
 typedef std::chrono::steady_clock Clock;
 typedef Clock::time_point time_point;

libcxx/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/enabled_hashes.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
 
 // <thread>
 
 // Test that <thread> provides all of the arithmetic, enum, and pointer
 // hash specializations.
 
+#include <functional>
 #include <thread>
 
 #include "poisoned_hash_helper.h"
 
 #include "test_macros.h"
 
 int main(int, char**) {
   test_library_hash_specializations_available();
   {
     test_hash_enabled_for_type<std::thread::id>();
   }
 
   return 0;
 }

libcxx/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/types.compile.pass.cpp

 // TODO FMT Evaluate what to do with [format.formatter.spec]/2
 // [format.formatter.spec]/2
 //   Each header that declares the template formatter provides the following
 //   enabled specializations:
 // Then there is a list of formatters, but is that really useful?
 // Note this should be discussed in LEWG.
 
 #include <concepts>
+#include <format>
 #include <thread>
 
 #include "test_macros.h"
 
 static_assert(std::semiregular<std::formatter<std::thread::id, char>>);
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
 static_assert(std::semiregular<std::formatter<std::thread::id, wchar_t>>);
 #endif

libcxx/utils/data/ignore_format.txt

 libcxx/include/__support/ibm/locale_mgmt_zos.h
 libcxx/include/__support/ibm/nanosleep.h
 libcxx/include/__support/ibm/xlocale.h
 libcxx/include/__support/newlib/xlocale.h
 libcxx/include/__support/win32/locale_win32.h
 libcxx/include/__support/xlocale/__nop_locale_mgmt.h
 libcxx/include/__system_error/errc.h
 libcxx/include/thread
+libcxx/include/__thread/formatter.h
 libcxx/include/__threading_support
 libcxx/include/__thread/poll_with_backoff.h
+libcxx/include/__thread/this_thread.h
+libcxx/include/__thread/thread.h
 libcxx/include/__thread/timed_backoff_policy.h
 libcxx/include/__tree
 libcxx/include/tuple
 libcxx/include/__tuple/make_tuple_types.h
 libcxx/include/__tuple/sfinae_helpers.h
 libcxx/include/__tuple/tuple_element.h
 libcxx/include/__tuple/tuple_indices.h
 libcxx/include/__tuple/tuple_like_ext.h