[libc++] Granularize __mutex_base

[philnik]

Summary

This also updates the moved code to the current style. (i.e. _VSTD -> std, _LIBCPP_INLINE_VISIBILITY -> _LIBCPP_HIDE_FROM_ABI, clang-format).

[philnik]

Format granularized headers

[Mordante]

I really dislike mixing granularizing patches with other changes. For the future please only do one change per patch.
I'm fine with only CI testing the followup changes and self-approving them. I don't feel it's needed to undo the changes for now.

I want to see it again to see the changes to the transitive includes.

libcxx/test/libcxx/transitive_includes/cxx2b.csv

120

Merge conflicts

[philnik]

Try to fix CI

[philnik]

Try to fix CI

[EricWF]

I agree with @Mordante

These sorts of changes really muddy up the history, and are hard to review.

[Mordante]

LGTM!

[miyuki]

Hi. This change causes failures in one of our configurations, compiled with _LIBCPP_HAS_NO_THREADS. Compilation of mutex.cpp fails with the following error:

[2023-03-22T20:37:03.871Z] In file included from /workspace/workspace/armcompiler/next/toolchain/src/llvm-project/libcxx/src/mutex.cpp:11:
[2023-03-22T20:37:03.871Z] In file included from /workspace/workspace/armcompiler/next/toolchain/build/libcxx_libcxxabi_libunwind/armv8.1m.main_hard_nofp_mve_armlibc/src/libcxx_libcxxabi_libunwind_armv8.1m.main_hard_nofp_mve_armlibc-build/include/c++/v1/mutex:192:
[2023-03-22T20:37:03.871Z] /workspace/workspace/armcompiler/next/toolchain/build/libcxx_libcxxabi_libunwind/armv8.1m.main_hard_nofp_mve_armlibc/src/libcxx_libcxxabi_libunwind_armv8.1m.main_hard_nofp_mve_armlibc-build/include/c++/v1/__condition_variable/condition_variable.h:94:44: error: no template named 'is_floating_point'; did you mean 'std::is_floating_point'?
[2023-03-22T20:37:03.871Z] inline _LIBCPP_HIDE_FROM_ABI __enable_if_t<is_floating_point<_Rep>::value, chrono::nanoseconds>
[2023-03-22T20:37:03.871Z]                                            ^~~~~~~~~~~~~~~~~

[2023-03-22T20:37:03.871Z]                                            std::is_floating_point

This happens because in the file __condition_variable/condition_variable.h, the _LIBCPP_BEGIN_NAMESPACE_STD line is guarded with #ifndef _LIBCPP_HAS_NO_THREADS so when the file is used with _LIBCPP_HAS_NO_THREADS the function __safe_nanosecond_cast gets defined in the global namespace (instead of std) from which is_floating_point is not accessible via unqualified lookup.

Could you please fix this issue?

[philnik]

In D146228#4216755, @miyuki wrote:

Hi. This change causes failures in one of our configurations, compiled with _LIBCPP_HAS_NO_THREADS. Compilation of mutex.cpp fails with the following error:

[2023-03-22T20:37:03.871Z] In file included from /workspace/workspace/armcompiler/next/toolchain/src/llvm-project/libcxx/src/mutex.cpp:11:
[2023-03-22T20:37:03.871Z] In file included from /workspace/workspace/armcompiler/next/toolchain/build/libcxx_libcxxabi_libunwind/armv8.1m.main_hard_nofp_mve_armlibc/src/libcxx_libcxxabi_libunwind_armv8.1m.main_hard_nofp_mve_armlibc-build/include/c++/v1/mutex:192:
[2023-03-22T20:37:03.871Z] /workspace/workspace/armcompiler/next/toolchain/build/libcxx_libcxxabi_libunwind/armv8.1m.main_hard_nofp_mve_armlibc/src/libcxx_libcxxabi_libunwind_armv8.1m.main_hard_nofp_mve_armlibc-build/include/c++/v1/__condition_variable/condition_variable.h:94:44: error: no template named 'is_floating_point'; did you mean 'std::is_floating_point'?
[2023-03-22T20:37:03.871Z] inline _LIBCPP_HIDE_FROM_ABI __enable_if_t<is_floating_point<_Rep>::value, chrono::nanoseconds>
[2023-03-22T20:37:03.871Z]                                            ^~~~~~~~~~~~~~~~~

[2023-03-22T20:37:03.871Z]                                            std::is_floating_point

This happens because in the file __condition_variable/condition_variable.h, the _LIBCPP_BEGIN_NAMESPACE_STD line is guarded with #ifndef _LIBCPP_HAS_NO_THREADS so when the file is used with _LIBCPP_HAS_NO_THREADS the function __safe_nanosecond_cast gets defined in the global namespace (instead of std) from which is_floating_point is not accessible via unqualified lookup.

Could you please fix this issue?

This is fixed by D146682. I hope @glandium lands it soon.

libcxx/docs/ReleaseNotes.rst

 - The ``<experimental/coroutine>`` header has been removed in this release. The ``<coroutine>`` header
   has been shipping since LLVM 14, so the Coroutines TS implementation is being removed per our policy
   for removing TSes.
 
 - Several incidental transitive includes have been removed from libc++. Those
   includes are removed based on the language version used. Incidental transitive
   inclusions of the following headers have been removed:
 
-  - C++2b: ``atomic``, ``bit``, ``cstring``, ``type_traits``
+  - C++2b: ``atomic``, ``bit``, ``cstdint``, ``cstdlib``, ``cstring``, ``initializer_list``, ``new``, ``stdexcept``,
+           ``type_traits``, ``typeinfo``
 
 - The headers ``<experimental/algorithm>`` and ``<experimental/functional>`` have been removed, since all the contents
   have been implemented in namespace ``std`` for at least two releases.
 
 - The formatter specialization ``template<size_t N> struct formatter<const charT[N], charT>``
   has been removed. Since libc++'s format library was marked experimental there
   is no backwards compatibility option. This specialization has been removed
   from the Standard since it was never used, the proper specialization to use

libcxx/include/CMakeLists.txt

set(files
   __concepts/movable.h
   __concepts/predicate.h
   __concepts/regular.h
   __concepts/relation.h
   __concepts/same_as.h
   __concepts/semiregular.h
   __concepts/swappable.h
   __concepts/totally_ordered.h
+  __condition_variable/condition_variable.h
   __config
   __coroutine/coroutine_handle.h
   __coroutine/coroutine_traits.h
   __coroutine/noop_coroutine_handle.h
   __coroutine/trivial_awaitables.h
   __debug
   __debug_utils/randomize_range.h
   __errc
set(files
   __memory/uses_allocator_construction.h
   __memory/voidify.h
   __memory_resource/memory_resource.h
   __memory_resource/monotonic_buffer_resource.h
   __memory_resource/polymorphic_allocator.h
   __memory_resource/pool_options.h
   __memory_resource/synchronized_pool_resource.h
   __memory_resource/unsynchronized_pool_resource.h
-  __mutex_base
+  __mutex/lock_guard.h
+  __mutex/mutex.h
+  __mutex/tag_types.h
+  __mutex/unique_lock.h
   __node_handle
   __numeric/accumulate.h
   __numeric/adjacent_difference.h
   __numeric/exclusive_scan.h
   __numeric/gcd_lcm.h
   __numeric/inclusive_scan.h
   __numeric/inner_product.h
   __numeric/iota.h

libcxx/include/__condition_variable/condition_variable.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___MUTEX_BASE
-#define _LIBCPP___MUTEX_BASE
+#ifndef _LIBCPP___CONDITION_VARIABLE_CONDITION_VARIABLE_H
+#define _LIBCPP___CONDITION_VARIABLE_CONDITION_VARIABLE_H
 
-#include <__chrono/duration.h>
 #include <__chrono/steady_clock.h>
 #include <__chrono/system_clock.h>
 #include <__chrono/time_point.h>
 #include <__config>
+#include <__mutex/mutex.h>
+#include <__mutex/unique_lock.h>
 #include <__threading_support>
+#include <__type_traits/enable_if.h>
 #include <__type_traits/is_floating_point.h>
-#include <__type_traits/is_nothrow_default_constructible.h>
+#include <__utility/move.h>
 #include <ratio>
 #include <system_error>
-#include <time.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
 #ifndef _LIBCPP_HAS_NO_THREADS
 
-class _LIBCPP_TYPE_VIS _LIBCPP_THREAD_SAFETY_ANNOTATION(capability("mutex")) mutex
-{
-    __libcpp_mutex_t __m_ = _LIBCPP_MUTEX_INITIALIZER;
-
-public:
-    _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_CONSTEXPR mutex() = default;
-
-    mutex(const mutex&) = delete;
-    mutex& operator=(const mutex&) = delete;
-
-#if defined(_LIBCPP_HAS_TRIVIAL_MUTEX_DESTRUCTION)
-    ~mutex() = default;
-#else
-    ~mutex() _NOEXCEPT;
-#endif
-
-    void lock() _LIBCPP_THREAD_SAFETY_ANNOTATION(acquire_capability());
-    bool try_lock() _NOEXCEPT _LIBCPP_THREAD_SAFETY_ANNOTATION(try_acquire_capability(true));
-    void unlock() _NOEXCEPT _LIBCPP_THREAD_SAFETY_ANNOTATION(release_capability());
-
-    typedef __libcpp_mutex_t* native_handle_type;
-    _LIBCPP_INLINE_VISIBILITY native_handle_type native_handle() {return &__m_;}
-};
-
-static_assert(is_nothrow_default_constructible<mutex>::value,
-              "the default constructor for std::mutex must be nothrow");
-
-struct _LIBCPP_TYPE_VIS defer_lock_t { explicit defer_lock_t() = default; };
-struct _LIBCPP_TYPE_VIS try_to_lock_t { explicit try_to_lock_t() = default; };
-struct _LIBCPP_TYPE_VIS adopt_lock_t { explicit adopt_lock_t() = default; };
-
-#if defined(_LIBCPP_CXX03_LANG) || defined(_LIBCPP_BUILDING_LIBRARY)
-
-extern _LIBCPP_EXPORTED_FROM_ABI const defer_lock_t  defer_lock;
-extern _LIBCPP_EXPORTED_FROM_ABI const try_to_lock_t try_to_lock;
-extern _LIBCPP_EXPORTED_FROM_ABI const adopt_lock_t  adopt_lock;
-
-#else
-
-/* inline */ constexpr defer_lock_t  defer_lock  = defer_lock_t();
-/* inline */ constexpr try_to_lock_t try_to_lock = try_to_lock_t();
-/* inline */ constexpr adopt_lock_t  adopt_lock  = adopt_lock_t();
-
-#endif
-
-template <class _Mutex>
-class _LIBCPP_TEMPLATE_VIS _LIBCPP_THREAD_SAFETY_ANNOTATION(scoped_lockable)
-lock_guard
-{
-public:
-    typedef _Mutex mutex_type;
-
-private:
-    mutex_type& __m_;
-public:
-
-    _LIBCPP_NODISCARD_EXT _LIBCPP_INLINE_VISIBILITY
-    explicit lock_guard(mutex_type& __m) _LIBCPP_THREAD_SAFETY_ANNOTATION(acquire_capability(__m))
-        : __m_(__m) {__m_.lock();}
-
-    _LIBCPP_NODISCARD_EXT _LIBCPP_INLINE_VISIBILITY
-    lock_guard(mutex_type& __m, adopt_lock_t) _LIBCPP_THREAD_SAFETY_ANNOTATION(requires_capability(__m))
-        : __m_(__m) {}
-    _LIBCPP_INLINE_VISIBILITY
-    ~lock_guard() _LIBCPP_THREAD_SAFETY_ANNOTATION(release_capability()) {__m_.unlock();}
-
-private:
-    lock_guard(lock_guard const&) = delete;
-    lock_guard& operator=(lock_guard const&) = delete;
-};
-_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(lock_guard);
-
-template <class _Mutex>
-class _LIBCPP_TEMPLATE_VIS unique_lock
-{
-public:
-    typedef _Mutex mutex_type;
-
-private:
-    mutex_type* __m_;
-    bool __owns_;
-
-public:
-    _LIBCPP_INLINE_VISIBILITY
-    unique_lock() _NOEXCEPT : __m_(nullptr), __owns_(false) {}
-    _LIBCPP_INLINE_VISIBILITY
-    explicit unique_lock(mutex_type& __m)
-        : __m_(_VSTD::addressof(__m)), __owns_(true) {__m_->lock();}
-    _LIBCPP_INLINE_VISIBILITY
-    unique_lock(mutex_type& __m, defer_lock_t) _NOEXCEPT
-        : __m_(_VSTD::addressof(__m)), __owns_(false) {}
-    _LIBCPP_INLINE_VISIBILITY
-    unique_lock(mutex_type& __m, try_to_lock_t)
-        : __m_(_VSTD::addressof(__m)), __owns_(__m.try_lock()) {}
-    _LIBCPP_INLINE_VISIBILITY
-    unique_lock(mutex_type& __m, adopt_lock_t)
-        : __m_(_VSTD::addressof(__m)), __owns_(true) {}
-    template <class _Clock, class _Duration>
-    _LIBCPP_INLINE_VISIBILITY
-        unique_lock(mutex_type& __m, const chrono::time_point<_Clock, _Duration>& __t)
-            : __m_(_VSTD::addressof(__m)), __owns_(__m.try_lock_until(__t)) {}
-    template <class _Rep, class _Period>
-    _LIBCPP_INLINE_VISIBILITY
-        unique_lock(mutex_type& __m, const chrono::duration<_Rep, _Period>& __d)
-            : __m_(_VSTD::addressof(__m)), __owns_(__m.try_lock_for(__d)) {}
-    _LIBCPP_INLINE_VISIBILITY
-    ~unique_lock()
-    {
-        if (__owns_)
-            __m_->unlock();
-    }
-
-    unique_lock(unique_lock const&) = delete;
-    unique_lock& operator=(unique_lock const&) = delete;
-
-    _LIBCPP_INLINE_VISIBILITY
-    unique_lock(unique_lock&& __u) _NOEXCEPT
-        : __m_(__u.__m_), __owns_(__u.__owns_)
-        {__u.__m_ = nullptr; __u.__owns_ = false;}
-    _LIBCPP_INLINE_VISIBILITY
-    unique_lock& operator=(unique_lock&& __u) _NOEXCEPT
-        {
-            if (__owns_)
-                __m_->unlock();
-            __m_ = __u.__m_;
-            __owns_ = __u.__owns_;
-            __u.__m_ = nullptr;
-            __u.__owns_ = false;
-            return *this;
-        }
-
-    void lock();
-    bool try_lock();
-
-    template <class _Rep, class _Period>
-        bool try_lock_for(const chrono::duration<_Rep, _Period>& __d);
-    template <class _Clock, class _Duration>
-        bool try_lock_until(const chrono::time_point<_Clock, _Duration>& __t);
-
-    void unlock();
-
-    _LIBCPP_INLINE_VISIBILITY
-    void swap(unique_lock& __u) _NOEXCEPT
-    {
-        _VSTD::swap(__m_, __u.__m_);
-        _VSTD::swap(__owns_, __u.__owns_);
-    }
-    _LIBCPP_INLINE_VISIBILITY
-    mutex_type* release() _NOEXCEPT
-    {
-        mutex_type* __m = __m_;
-        __m_ = nullptr;
-        __owns_ = false;
-        return __m;
-    }
-
-    _LIBCPP_INLINE_VISIBILITY
-    bool owns_lock() const _NOEXCEPT {return __owns_;}
-    _LIBCPP_INLINE_VISIBILITY
-    explicit operator bool() const _NOEXCEPT {return __owns_;}
-    _LIBCPP_INLINE_VISIBILITY
-    mutex_type* mutex() const _NOEXCEPT {return __m_;}
-};
-_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(unique_lock);
-
-template <class _Mutex>
-void
-unique_lock<_Mutex>::lock()
-{
-    if (__m_ == nullptr)
-        __throw_system_error(EPERM, "unique_lock::lock: references null mutex");
-    if (__owns_)
-        __throw_system_error(EDEADLK, "unique_lock::lock: already locked");
-    __m_->lock();
-    __owns_ = true;
-}
-
-template <class _Mutex>
-bool
-unique_lock<_Mutex>::try_lock()
-{
-    if (__m_ == nullptr)
-        __throw_system_error(EPERM, "unique_lock::try_lock: references null mutex");
-    if (__owns_)
-        __throw_system_error(EDEADLK, "unique_lock::try_lock: already locked");
-    __owns_ = __m_->try_lock();
-    return __owns_;
-}
-
-template <class _Mutex>
-template <class _Rep, class _Period>
-bool
-unique_lock<_Mutex>::try_lock_for(const chrono::duration<_Rep, _Period>& __d)
-{
-    if (__m_ == nullptr)
-        __throw_system_error(EPERM, "unique_lock::try_lock_for: references null mutex");
-    if (__owns_)
-        __throw_system_error(EDEADLK, "unique_lock::try_lock_for: already locked");
-    __owns_ = __m_->try_lock_for(__d);
-    return __owns_;
-}
-
-template <class _Mutex>
-template <class _Clock, class _Duration>
-bool
-unique_lock<_Mutex>::try_lock_until(const chrono::time_point<_Clock, _Duration>& __t)
-{
-    if (__m_ == nullptr)
-        __throw_system_error(EPERM, "unique_lock::try_lock_until: references null mutex");
-    if (__owns_)
-        __throw_system_error(EDEADLK, "unique_lock::try_lock_until: already locked");
-    __owns_ = __m_->try_lock_until(__t);
-    return __owns_;
-}
-
-template <class _Mutex>
-void
-unique_lock<_Mutex>::unlock()
-{
-    if (!__owns_)
-        __throw_system_error(EPERM, "unique_lock::unlock: not locked");
-    __m_->unlock();
-    __owns_ = false;
-}
-
-template <class _Mutex>
-inline _LIBCPP_INLINE_VISIBILITY
-void
-swap(unique_lock<_Mutex>& __x, unique_lock<_Mutex>& __y) _NOEXCEPT
-    {__x.swap(__y);}
+_LIBCPP_BEGIN_NAMESPACE_STD
 
 //enum class cv_status
 _LIBCPP_DECLARE_STRONG_ENUM(cv_status)
 {
     no_timeout,
     timeout
 };
 _LIBCPP_DECLARE_STRONG_ENUM_EPILOG(cv_status)

 inline
 void
 condition_variable::__do_timed_wait(unique_lock<mutex>& __lk,
      chrono::time_point<_Clock, chrono::nanoseconds> __tp) _NOEXCEPT
 {
     wait_for(__lk, __tp - _Clock::now());
 }
 
-#endif // !_LIBCPP_HAS_NO_THREADS
-
 _LIBCPP_END_NAMESPACE_STD
 
+#endif // _LIBCPP_HAS_NO_THREADS
+
 _LIBCPP_POP_MACROS
 
-#endif // _LIBCPP___MUTEX_BASE
+#endif // _LIBCPP___CONDITION_VARIABLE_CONDITION_VARIABLE_H

libcxx/include/__mutex/lock_guard.h

+//===----------------------------------------------------------------------===//
+//
+// 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___MUTEX_LOCK_GUARD_H
+#define _LIBCPP___MUTEX_LOCK_GUARD_H
+
+#include <__config>
+#include <__mutex/tag_types.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+#ifndef _LIBCPP_HAS_NO_THREADS
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template <class _Mutex>
+class _LIBCPP_TEMPLATE_VIS _LIBCPP_THREAD_SAFETY_ANNOTATION(scoped_lockable)
+lock_guard
+{
+public:
+    typedef _Mutex mutex_type;
+
+private:
+    mutex_type& __m_;
+public:
+
+    _LIBCPP_NODISCARD_EXT _LIBCPP_INLINE_VISIBILITY
+    explicit lock_guard(mutex_type& __m) _LIBCPP_THREAD_SAFETY_ANNOTATION(acquire_capability(__m))
+        : __m_(__m) {__m_.lock();}
+
+    _LIBCPP_NODISCARD_EXT _LIBCPP_INLINE_VISIBILITY
+    lock_guard(mutex_type& __m, adopt_lock_t) _LIBCPP_THREAD_SAFETY_ANNOTATION(requires_capability(__m))
+        : __m_(__m) {}
+    _LIBCPP_INLINE_VISIBILITY
+    ~lock_guard() _LIBCPP_THREAD_SAFETY_ANNOTATION(release_capability()) {__m_.unlock();}
+
+private:
+    lock_guard(lock_guard const&) = delete;
+    lock_guard& operator=(lock_guard const&) = delete;
+};
+_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(lock_guard);
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_HAS_NO_THREADS
+
+#endif // _LIBCPP___MUTEX_LOCK_GUARD_H

libcxx/include/__mutex/mutex.h

+//===----------------------------------------------------------------------===//
+//
+// 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___MUTEX_MUTEX_H
+#define _LIBCPP___MUTEX_MUTEX_H
+
+#include <__config>
+#include <__threading_support>
+#include <__type_traits/is_nothrow_default_constructible.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+#ifndef _LIBCPP_HAS_NO_THREADS
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+class _LIBCPP_TYPE_VIS _LIBCPP_THREAD_SAFETY_ANNOTATION(capability("mutex")) mutex
+{
+    __libcpp_mutex_t __m_ = _LIBCPP_MUTEX_INITIALIZER;
+
+public:
+    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_CONSTEXPR mutex() = default;
+
+    mutex(const mutex&) = delete;
+    mutex& operator=(const mutex&) = delete;
+
+#if defined(_LIBCPP_HAS_TRIVIAL_MUTEX_DESTRUCTION)
+    ~mutex() = default;
+#else
+    ~mutex() _NOEXCEPT;
+#endif
+
+    void lock() _LIBCPP_THREAD_SAFETY_ANNOTATION(acquire_capability());
+    bool try_lock() _NOEXCEPT _LIBCPP_THREAD_SAFETY_ANNOTATION(try_acquire_capability(true));
+    void unlock() _NOEXCEPT _LIBCPP_THREAD_SAFETY_ANNOTATION(release_capability());
+
+    typedef __libcpp_mutex_t* native_handle_type;
+    _LIBCPP_INLINE_VISIBILITY native_handle_type native_handle() {return &__m_;}
+};
+
+static_assert(is_nothrow_default_constructible<mutex>::value,
+              "the default constructor for std::mutex must be nothrow");
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_HAS_NO_THREADS
+
+#endif // _LIBCPP___MUTEX_MUTEX_H

libcxx/include/__mutex/tag_types.h

+//===----------------------------------------------------------------------===//
+//
+// 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___MUTEX_TAG_TYPES_H
+#define _LIBCPP___MUTEX_TAG_TYPES_H
+
+#include <__config>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+#ifndef _LIBCPP_HAS_NO_THREADS
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+struct _LIBCPP_TYPE_VIS defer_lock_t { explicit defer_lock_t() = default; };
+struct _LIBCPP_TYPE_VIS try_to_lock_t { explicit try_to_lock_t() = default; };
+struct _LIBCPP_TYPE_VIS adopt_lock_t { explicit adopt_lock_t() = default; };
+
+#if defined(_LIBCPP_CXX03_LANG) || defined(_LIBCPP_BUILDING_LIBRARY)
+
+extern _LIBCPP_EXPORTED_FROM_ABI const defer_lock_t  defer_lock;
+extern _LIBCPP_EXPORTED_FROM_ABI const try_to_lock_t try_to_lock;
+extern _LIBCPP_EXPORTED_FROM_ABI const adopt_lock_t  adopt_lock;
+
+#else
+
+/* inline */ constexpr defer_lock_t  defer_lock  = defer_lock_t();
+/* inline */ constexpr try_to_lock_t try_to_lock = try_to_lock_t();
+/* inline */ constexpr adopt_lock_t  adopt_lock  = adopt_lock_t();
+
+#endif
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_HAS_NO_THREADS
+
+#endif // _LIBCPP___MUTEX_TAG_TYPES_H

libcxx/include/__mutex/unique_lock.h

+//===----------------------------------------------------------------------===//
+//
+// 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___MUTEX_UNIQUE_LOCK_H
+#define _LIBCPP___MUTEX_UNIQUE_LOCK_H
+
+#include <__chrono/duration.h>
+#include <__chrono/time_point.h>
+#include <__config>
+#include <__memory/addressof.h>
+#include <__mutex/tag_types.h>
+#include <__utility/swap.h>
+#include <system_error>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+#ifndef _LIBCPP_HAS_NO_THREADS
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template <class _Mutex>
+class _LIBCPP_TEMPLATE_VIS unique_lock
+{
+public:
+    typedef _Mutex mutex_type;
+
+private:
+    mutex_type* __m_;
+    bool __owns_;
+
+public:
+    _LIBCPP_INLINE_VISIBILITY
+    unique_lock() _NOEXCEPT : __m_(nullptr), __owns_(false) {}
+    _LIBCPP_INLINE_VISIBILITY
+    explicit unique_lock(mutex_type& __m)
+        : __m_(_VSTD::addressof(__m)), __owns_(true) {__m_->lock();}
+    _LIBCPP_INLINE_VISIBILITY
+    unique_lock(mutex_type& __m, defer_lock_t) _NOEXCEPT
+        : __m_(_VSTD::addressof(__m)), __owns_(false) {}
+    _LIBCPP_INLINE_VISIBILITY
+    unique_lock(mutex_type& __m, try_to_lock_t)
+        : __m_(_VSTD::addressof(__m)), __owns_(__m.try_lock()) {}
+    _LIBCPP_INLINE_VISIBILITY
+    unique_lock(mutex_type& __m, adopt_lock_t)
+        : __m_(_VSTD::addressof(__m)), __owns_(true) {}
+    template <class _Clock, class _Duration>
+    _LIBCPP_INLINE_VISIBILITY
+        unique_lock(mutex_type& __m, const chrono::time_point<_Clock, _Duration>& __t)
+            : __m_(_VSTD::addressof(__m)), __owns_(__m.try_lock_until(__t)) {}
+    template <class _Rep, class _Period>
+    _LIBCPP_INLINE_VISIBILITY
+        unique_lock(mutex_type& __m, const chrono::duration<_Rep, _Period>& __d)
+            : __m_(_VSTD::addressof(__m)), __owns_(__m.try_lock_for(__d)) {}
+    _LIBCPP_INLINE_VISIBILITY
+    ~unique_lock()
+    {
+        if (__owns_)
+            __m_->unlock();
+    }
+
+    unique_lock(unique_lock const&) = delete;
+    unique_lock& operator=(unique_lock const&) = delete;
+
+    _LIBCPP_INLINE_VISIBILITY
+    unique_lock(unique_lock&& __u) _NOEXCEPT
+        : __m_(__u.__m_), __owns_(__u.__owns_)
+        {__u.__m_ = nullptr; __u.__owns_ = false;}
+    _LIBCPP_INLINE_VISIBILITY
+    unique_lock& operator=(unique_lock&& __u) _NOEXCEPT
+        {
+            if (__owns_)
+                __m_->unlock();
+            __m_ = __u.__m_;
+            __owns_ = __u.__owns_;
+            __u.__m_ = nullptr;
+            __u.__owns_ = false;
+            return *this;
+        }
+
+    void lock();
+    bool try_lock();
+
+    template <class _Rep, class _Period>
+        bool try_lock_for(const chrono::duration<_Rep, _Period>& __d);
+    template <class _Clock, class _Duration>
+        bool try_lock_until(const chrono::time_point<_Clock, _Duration>& __t);
+
+    void unlock();
+
+    _LIBCPP_INLINE_VISIBILITY
+    void swap(unique_lock& __u) _NOEXCEPT
+    {
+        _VSTD::swap(__m_, __u.__m_);
+        _VSTD::swap(__owns_, __u.__owns_);
+    }
+    _LIBCPP_INLINE_VISIBILITY
+    mutex_type* release() _NOEXCEPT
+    {
+        mutex_type* __m = __m_;
+        __m_ = nullptr;
+        __owns_ = false;
+        return __m;
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    bool owns_lock() const _NOEXCEPT {return __owns_;}
+    _LIBCPP_INLINE_VISIBILITY
+    explicit operator bool() const _NOEXCEPT {return __owns_;}
+    _LIBCPP_INLINE_VISIBILITY
+    mutex_type* mutex() const _NOEXCEPT {return __m_;}
+};
+_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(unique_lock);
+
+template <class _Mutex>
+void
+unique_lock<_Mutex>::lock()
+{
+    if (__m_ == nullptr)
+        __throw_system_error(EPERM, "unique_lock::lock: references null mutex");
+    if (__owns_)
+        __throw_system_error(EDEADLK, "unique_lock::lock: already locked");
+    __m_->lock();
+    __owns_ = true;
+}
+
+template <class _Mutex>
+bool
+unique_lock<_Mutex>::try_lock()
+{
+    if (__m_ == nullptr)
+        __throw_system_error(EPERM, "unique_lock::try_lock: references null mutex");
+    if (__owns_)
+        __throw_system_error(EDEADLK, "unique_lock::try_lock: already locked");
+    __owns_ = __m_->try_lock();
+    return __owns_;
+}
+
+template <class _Mutex>
+template <class _Rep, class _Period>
+bool
+unique_lock<_Mutex>::try_lock_for(const chrono::duration<_Rep, _Period>& __d)
+{
+    if (__m_ == nullptr)
+        __throw_system_error(EPERM, "unique_lock::try_lock_for: references null mutex");
+    if (__owns_)
+        __throw_system_error(EDEADLK, "unique_lock::try_lock_for: already locked");
+    __owns_ = __m_->try_lock_for(__d);
+    return __owns_;
+}
+
+template <class _Mutex>
+template <class _Clock, class _Duration>
+bool
+unique_lock<_Mutex>::try_lock_until(const chrono::time_point<_Clock, _Duration>& __t)
+{
+    if (__m_ == nullptr)
+        __throw_system_error(EPERM, "unique_lock::try_lock_until: references null mutex");
+    if (__owns_)
+        __throw_system_error(EDEADLK, "unique_lock::try_lock_until: already locked");
+    __owns_ = __m_->try_lock_until(__t);
+    return __owns_;
+}
+
+template <class _Mutex>
+void
+unique_lock<_Mutex>::unlock()
+{
+    if (!__owns_)
+        __throw_system_error(EPERM, "unique_lock::unlock: not locked");
+    __m_->unlock();
+    __owns_ = false;
+}
+
+template <class _Mutex>
+inline _LIBCPP_INLINE_VISIBILITY
+void
+swap(unique_lock<_Mutex>& __x, unique_lock<_Mutex>& __y) _NOEXCEPT
+    {__x.swap(__y);}
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_HAS_NO_THREADS
+
+#endif // _LIBCPP___MUTEX_UNIQUE_LOCK_H

libcxx/include/condition_variable

template <class Lock, class Rep, class Period, class Predicate>
                  Predicate pred);
 };
 
 }  // std
 
 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
+#include <__chrono/duration.h>
+#include <__chrono/steady_clock.h>
+#include <__chrono/time_point.h>
+#include <__condition_variable/condition_variable.h>
 #include <__config>
 #include <__memory/shared_ptr.h>
 #include <__memory/unique_ptr.h>
-#include <__mutex_base>
+#include <__mutex/lock_guard.h>
+#include <__mutex/mutex.h>
+#include <__mutex/tag_types.h>
+#include <__mutex/unique_lock.h>
+#include <__utility/move.h>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #ifndef _LIBCPP_HAS_NO_THREADS
 

 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // !_LIBCPP_HAS_NO_THREADS
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <atomic>
 #  include <concepts>
+#  include <cstdint>
+#  include <cstdlib>
+#  include <cstring>
+#  include <initializer_list>
+#  include <new>
+#  include <stdexcept>
 #  include <type_traits>
+#  include <typeinfo>
 #endif
 
 #endif // _LIBCPP_CONDITION_VARIABLE

libcxx/include/libcxx.imp

[
   { include: [ "<__tree>", "private", "<set>", "public" ] },
   { include: [ "@<__algorithm/.*>", "private", "<algorithm>", "public" ] },
   { include: [ "@<__atomic/.*>", "private", "<atomic>", "public" ] },
   { include: [ "@<__bit/.*>", "private", "<bit>", "public" ] },
   { include: [ "@<__charconv/.*>", "private", "<charconv>", "public" ] },
   { include: [ "@<__chrono/.*>", "private", "<chrono>", "public" ] },
   { include: [ "@<__compare/.*>", "private", "<compare>", "public" ] },
   { include: [ "@<__concepts/.*>", "private", "<concepts>", "public" ] },
+  { include: [ "@<__condition_variable/.*>", "private", "<condition_variable>", "public" ] },
   { include: [ "@<__coroutine/.*>", "private", "<coroutine>", "public" ] },
   { include: [ "@<__debug_utils/.*>", "private", "<debug_utils>", "public" ] },
   { include: [ "@<__exception/.*>", "private", "<exception>", "public" ] },
   { include: [ "@<__expected/.*>", "private", "<expected>", "public" ] },
   { include: [ "@<__filesystem/.*>", "private", "<filesystem>", "public" ] },
   { include: [ "@<__format/.*>", "private", "<format>", "public" ] },
   { include: [ "@<__functional/.*>", "private", "<functional>", "public" ] },
   { include: [ "@<__fwd/.*>", "private", "<fwd>", "public" ] },
   { include: [ "@<__ios/.*>", "private", "<ios>", "public" ] },
   { include: [ "@<__iterator/.*>", "private", "<iterator>", "public" ] },
   { include: [ "@<__memory/.*>", "private", "<memory>", "public" ] },
   { include: [ "@<__memory_resource/.*>", "private", "<memory_resource>", "public" ] },
+  { include: [ "@<__mutex/.*>", "private", "<mutex>", "public" ] },
   { include: [ "@<__numeric/.*>", "private", "<numeric>", "public" ] },
   { include: [ "@<__random/.*>", "private", "<random>", "public" ] },
   { include: [ "@<__ranges/.*>", "private", "<ranges>", "public" ] },
   { include: [ "@<__string/.*>", "private", "<string>", "public" ] },
   { include: [ "@<__support/.*>", "private", "<support>", "public" ] },
   { include: [ "@<__thread/.*>", "private", "<thread>", "public" ] },
   { include: [ "@<__tuple_dir/.*>", "private", "<tuple>", "public" ] },
   { include: [ "@<__type_traits/.*>", "private", "<type_traits>", "public" ] },
   { include: [ "@<__utility/.*>", "private", "<utility>", "public" ] },
   { include: [ "@<__variant/.*>", "private", "<variant>", "public" ] },
 ]

libcxx/include/module.modulemap.in

module __concepts {
       module semiregular                { private header "__concepts/semiregular.h" }
       module swappable                  { private header "__concepts/swappable.h" }
       module totally_ordered            { private header "__concepts/totally_ordered.h" }
     }
   }
   module condition_variable {
     header "condition_variable"
     export *
+
+    module __condition_variable {
+      module condition_variable { private header "__condition_variable/condition_variable.h" }
+    }
   }
   module coroutine {
     header "coroutine"
     export compare
     export *
 
     module __coroutine {
       module coroutine_handle           { private header "__coroutine/coroutine_handle.h" }
module __memory_resource {
       module synchronized_pool_resource   { private header "__memory_resource/synchronized_pool_resource.h" }
       module unsynchronized_pool_resource { private header "__memory_resource/unsynchronized_pool_resource.h" }
     }
   }
   module mutex {
     @requires_LIBCXX_ENABLE_THREADS@
     header "mutex"
     export *
+
+    module __mutex {
+      module lock_guard  { private header "__mutex/lock_guard.h" }
+      module mutex       { private header "__mutex/mutex.h" }
+      module tag_types   { private header "__mutex/tag_types.h" }
+      module unique_lock { private header "__mutex/unique_lock.h" }
+    }
   }
   module new {
     header "new"
     export *
   }
   module numbers {
     header "numbers"
     export *

   module __debug             {         header "__debug"             export * }
   module __errc              { private header "__errc"              export * }
   module __hash_table        {         header "__hash_table"        export * }
   module __locale            {
     @requires_LIBCXX_ENABLE_LOCALIZATION@
     private header "__locale" export *
   }
   module __mbstate_t         { private header "__mbstate_t.h"       export * }
-  module __mutex_base        { private header "__mutex_base"        export * }
   module __node_handle       { private header "__node_handle"       export * }
   module __split_buffer      { private header "__split_buffer"      export * }
   module __std_stream        {
     @requires_LIBCXX_ENABLE_LOCALIZATION@
     private header "__std_stream" export *
   }
   module __threading_support {         header "__threading_support" export * }
   module __tree              {         header "__tree"              export * }

libcxx/include/mutex

 template<class Callable, class ...Args>
   void call_once(once_flag& flag, Callable&& func, Args&&... args);
 
 }  // std
 
 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
+#include <__chrono/time_point.h>
+#include <__chrono/steady_clock.h>
+#include <__condition_variable/condition_variable.h>
 #include <__config>
 #include <__memory/shared_ptr.h>
-#include <__mutex_base>
+#include <__mutex/lock_guard.h>
+#include <__mutex/mutex.h>
+#include <__mutex/tag_types.h>
+#include <__mutex/unique_lock.h>
 #include <__threading_support>
 #include <__utility/forward.h>
 #include <cstdint>
 #ifndef _LIBCPP_CXX03_LANG
 # include <tuple>
 #endif
 #include <version>
 

 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <atomic>
 #  include <concepts>
+#  include <cstdlib>
+#  include <cstring>
 #  include <ctime>
 #  include <functional>
+#  include <initializer_list>
+#  include <new>
+#  include <stdexcept>
 #  include <type_traits>
+#  include <typeinfo>
 #endif
 
 #endif // _LIBCPP_MUTEX

libcxx/include/shared_mutex

template <class Mutex>
     void swap(shared_lock<Mutex>& x, shared_lock<Mutex>& y) noexcept;
 
 }  // std
 
 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__availability>
+#include <__chrono/duration.h>
+#include <__chrono/ostream.h>
+#include <__chrono/steady_clock.h>
+#include <__chrono/time_point.h>
+#include <__condition_variable/condition_variable.h>
 #include <__config>
+#include <__memory/addressof.h>
+#include <__mutex/mutex.h>
+#include <__mutex/tag_types.h>
+#include <__mutex/unique_lock.h>
+#include <__utility/swap.h>
+#include <cerrno>
+#include <system_error>
 #include <version>
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 
 #if _LIBCPP_STD_VER >= 14 || defined(_LIBCPP_BUILDING_LIBRARY)
 
-#include <__mutex_base>
-
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #ifdef _LIBCPP_HAS_NO_THREADS
 # error "<shared_mutex> is not supported since libc++ has been configured without support for threads."
 #endif
 

libcxx/include/thread

 
 }  // this_thread
 
 }  // std
 
 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
+#include <__chrono/steady_clock.h>
+#include <__chrono/time_point.h>
+#include <__condition_variable/condition_variable.h>
 #include <__config>
 #include <__functional/hash.h>
 #include <__memory/unique_ptr.h>
-#include <__mutex_base>
+#include <__mutex/mutex.h>
+#include <__mutex/unique_lock.h>
 #include <__thread/poll_with_backoff.h>
 #include <__thread/timed_backoff_policy.h>
 #include <__threading_support>
 #include <__utility/forward.h>
 #include <cstddef>
 #include <iosfwd>
 #include <system_error>
 #include <tuple>

 
 _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 <cstdint>
+#  include <cstring>
 #  include <functional>
+#  include <new>
 #endif
 
 #endif // _LIBCPP_THREAD

libcxx/src/shared_mutex.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 <mutex>
 #include <shared_mutex>
 #if defined(__ELF__) && defined(_LIBCPP_LINK_PTHREAD_LIB)
 #  pragma comment(lib, "pthread")
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 // Shared Mutex Base

libcxx/test/libcxx/private_headers.verify.cpp

 #include <__concepts/movable.h> // expected-error@*:* {{use of private header from outside its module: '__concepts/movable.h'}}
 #include <__concepts/predicate.h> // expected-error@*:* {{use of private header from outside its module: '__concepts/predicate.h'}}
 #include <__concepts/regular.h> // expected-error@*:* {{use of private header from outside its module: '__concepts/regular.h'}}
 #include <__concepts/relation.h> // expected-error@*:* {{use of private header from outside its module: '__concepts/relation.h'}}
 #include <__concepts/same_as.h> // expected-error@*:* {{use of private header from outside its module: '__concepts/same_as.h'}}
 #include <__concepts/semiregular.h> // expected-error@*:* {{use of private header from outside its module: '__concepts/semiregular.h'}}
 #include <__concepts/swappable.h> // expected-error@*:* {{use of private header from outside its module: '__concepts/swappable.h'}}
 #include <__concepts/totally_ordered.h> // expected-error@*:* {{use of private header from outside its module: '__concepts/totally_ordered.h'}}
+#include <__condition_variable/condition_variable.h> // expected-error@*:* {{use of private header from outside its module: '__condition_variable/condition_variable.h'}}
 #include <__coroutine/coroutine_handle.h> // expected-error@*:* {{use of private header from outside its module: '__coroutine/coroutine_handle.h'}}
 #include <__coroutine/coroutine_traits.h> // expected-error@*:* {{use of private header from outside its module: '__coroutine/coroutine_traits.h'}}
 #include <__coroutine/noop_coroutine_handle.h> // expected-error@*:* {{use of private header from outside its module: '__coroutine/noop_coroutine_handle.h'}}
 #include <__coroutine/trivial_awaitables.h> // expected-error@*:* {{use of private header from outside its module: '__coroutine/trivial_awaitables.h'}}
 #include <__debug_utils/randomize_range.h> // expected-error@*:* {{use of private header from outside its module: '__debug_utils/randomize_range.h'}}
 #include <__errc> // expected-error@*:* {{use of private header from outside its module: '__errc'}}
 #include <__exception/exception.h> // expected-error@*:* {{use of private header from outside its module: '__exception/exception.h'}}
 #include <__exception/exception_ptr.h> // expected-error@*:* {{use of private header from outside its module: '__exception/exception_ptr.h'}}

 #include <__memory/uses_allocator_construction.h> // expected-error@*:* {{use of private header from outside its module: '__memory/uses_allocator_construction.h'}}
 #include <__memory/voidify.h> // expected-error@*:* {{use of private header from outside its module: '__memory/voidify.h'}}
 #include <__memory_resource/memory_resource.h> // expected-error@*:* {{use of private header from outside its module: '__memory_resource/memory_resource.h'}}
 #include <__memory_resource/monotonic_buffer_resource.h> // expected-error@*:* {{use of private header from outside its module: '__memory_resource/monotonic_buffer_resource.h'}}
 #include <__memory_resource/polymorphic_allocator.h> // expected-error@*:* {{use of private header from outside its module: '__memory_resource/polymorphic_allocator.h'}}
 #include <__memory_resource/pool_options.h> // expected-error@*:* {{use of private header from outside its module: '__memory_resource/pool_options.h'}}
 #include <__memory_resource/synchronized_pool_resource.h> // expected-error@*:* {{use of private header from outside its module: '__memory_resource/synchronized_pool_resource.h'}}
 #include <__memory_resource/unsynchronized_pool_resource.h> // expected-error@*:* {{use of private header from outside its module: '__memory_resource/unsynchronized_pool_resource.h'}}
-#include <__mutex_base> // expected-error@*:* {{use of private header from outside its module: '__mutex_base'}}
+#include <__mutex/lock_guard.h> // expected-error@*:* {{use of private header from outside its module: '__mutex/lock_guard.h'}}
+#include <__mutex/mutex.h> // expected-error@*:* {{use of private header from outside its module: '__mutex/mutex.h'}}
+#include <__mutex/tag_types.h> // expected-error@*:* {{use of private header from outside its module: '__mutex/tag_types.h'}}
+#include <__mutex/unique_lock.h> // expected-error@*:* {{use of private header from outside its module: '__mutex/unique_lock.h'}}
 #include <__node_handle> // expected-error@*:* {{use of private header from outside its module: '__node_handle'}}
 #include <__numeric/accumulate.h> // expected-error@*:* {{use of private header from outside its module: '__numeric/accumulate.h'}}
 #include <__numeric/adjacent_difference.h> // expected-error@*:* {{use of private header from outside its module: '__numeric/adjacent_difference.h'}}
 #include <__numeric/exclusive_scan.h> // expected-error@*:* {{use of private header from outside its module: '__numeric/exclusive_scan.h'}}
 #include <__numeric/gcd_lcm.h> // expected-error@*:* {{use of private header from outside its module: '__numeric/gcd_lcm.h'}}
 #include <__numeric/inclusive_scan.h> // expected-error@*:* {{use of private header from outside its module: '__numeric/inclusive_scan.h'}}
 #include <__numeric/inner_product.h> // expected-error@*:* {{use of private header from outside its module: '__numeric/inner_product.h'}}
 #include <__numeric/iota.h> // expected-error@*:* {{use of private header from outside its module: '__numeric/iota.h'}}

libcxx/test/libcxx/thread/thread.condition/thread.condition.condvar/native_handle.pass.cpp

 
 // <condition_variable>
 
 // class condition_variable;
 
 // typedef pthread_cond_t* native_handle_type;
 // native_handle_type native_handle();
 
-#include <condition_variable>
 #include <cassert>
+#include <condition_variable>
+#include <pthread.h>
+#include <type_traits>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     static_assert((std::is_same<std::condition_variable::native_handle_type,
                                 pthread_cond_t*>::value), "");
     std::condition_variable cv;
     std::condition_variable::native_handle_type h = cv.native_handle();
     assert(h != nullptr);
 
   return 0;
 }

libcxx/test/libcxx/transitive_includes/cxx2b.csv

 complex cmath
 complex iosfwd
 complex sstream
 complex stdexcept
 complex version
 concepts cstddef
 concepts version
 condition_variable cstddef
-condition_variable cstdint
 condition_variable cstdlib
+<<<<<<< HEAD
 condition_variable cstring
 condition_variable ctime
 condition_variable initializer_list
+=======
+condition_variable ctime
+>>>>>>> f626323c3b1a ([libc++] Granularize __mutex_base)
 condition_variable iosfwd
 condition_variable limits
 condition_variable new
 condition_variable ratio
 condition_variable stdexcept
 condition_variable system_error
 condition_variable typeinfo
 condition_variable version

 memory_resource mutex
 memory_resource new
 memory_resource stdexcept
 memory_resource tuple
 memory_resource version
 mutex cstddef
 mutex cstdint
 mutex cstdlib
+<<<<<<< HEAD
 mutex cstring
 mutex ctime
 mutex initializer_list
+=======
+mutex ctime
+>>>>>>> f626323c3b1a ([libc++] Granularize __mutex_base)
 mutex iosfwd
 mutex limits
 mutex new
 mutex ratio
 mutex stdexcept
 mutex system_error
 mutex tuple
 mutex typeinfo

 system_error cstdint
 system_error cstring
 system_error limits
 system_error stdexcept
 system_error string
 system_error version
 thread compare
 thread cstddef
-thread cstdint
-thread cstring
 thread ctime
 thread iosfwd
 thread limits
-thread new
 thread ratio
 thread system_error
 thread tuple
 thread version
 tuple compare
 tuple cstddef
 tuple version
 type_traits cstddef

libcxx/test/std/thread/futures/futures.shared_future/wait.pass.cpp

 
 // class shared_future<R>
 
 // void wait() const;
 
 #include <cassert>
 #include <chrono>
 #include <future>
+#include <ratio>
 
 #include "make_test_thread.h"
 #include "test_macros.h"
 
 void func1(std::promise<int> p)
 {
     std::this_thread::sleep_for(std::chrono::milliseconds(500));
     p.set_value(3);

libcxx/test/std/thread/futures/futures.unique_future/wait.pass.cpp

 
 // class future<R>
 
 // void wait() const;
 
 #include <cassert>
 #include <chrono>
 #include <future>
+#include <ratio>
 
 #include "make_test_thread.h"
 #include "test_macros.h"
 
 void func1(std::promise<int> p)
 {
     std::this_thread::sleep_for(std::chrono::milliseconds(500));
     p.set_value(3);

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

 
 // template <class Mutex> class shared_lock;
 
 // explicit shared_lock(mutex_type& m);
 
 // template<class _Mutex> shared_lock(shared_lock<_Mutex>)
 //     -> shared_lock<_Mutex>;  // C++17
 
+#include <cassert>
+#include <chrono>
+#include <cstdlib>
 #include <shared_mutex>
 #include <thread>
 #include <vector>
-#include <cstdlib>
-#include <cassert>
 
 #include "make_test_thread.h"
 #include "test_macros.h"
 
 typedef std::chrono::system_clock Clock;
 typedef Clock::time_point time_point;
 typedef Clock::duration duration;
 typedef std::chrono::milliseconds ms;

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

 // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11}}
 
 // <shared_mutex>
 
 // template <class Mutex> class shared_lock;
 
 // shared_lock(mutex_type& m, try_to_lock_t);
 
+#include <cassert>
+#include <chrono>
+#include <cstdlib>
+#include <mutex>
 #include <shared_mutex>
 #include <thread>
 #include <vector>
-#include <cstdlib>
-#include <cassert>
 
 #include "make_test_thread.h"
 #include "test_macros.h"
 
 std::shared_timed_mutex m;
 
 typedef std::chrono::system_clock Clock;
 typedef Clock::time_point time_point;

libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/lock.pass.cpp

 // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11}}
 
 // <shared_mutex>
 
 // template <class Mutex> class shared_lock;
 
 // void lock();
 
+#include <cassert>
+#include <chrono>
+#include <cstdlib>
+#include <mutex>
 #include <shared_mutex>
 #include <thread>
 #include <vector>
-#include <cstdlib>
-#include <cassert>
 
 #include "make_test_thread.h"
 #include "test_macros.h"
 
 std::shared_timed_mutex m;
 
 typedef std::chrono::system_clock Clock;
 typedef Clock::time_point time_point;

libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/try_lock.pass.cpp

 // ALLOW_RETRIES: 2
 
 // <shared_mutex>
 
 // template <class Mutex> class shared_lock;
 
 // bool try_lock();
 
-#include <shared_mutex>
 #include <cassert>
 #include <mutex>
+#include <shared_mutex>
+#include <system_error>
 
 #include "test_macros.h"
 
 bool try_lock_called = false;
 
 struct mutex
 {
     bool try_lock_shared()

libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/try_lock_for.pass.cpp

 
 // <shared_mutex>
 
 // template <class Mutex> class shared_lock;
 
 // template <class Rep, class Period>
 //   bool try_lock_for(const chrono::duration<Rep, Period>& rel_time);
 
-#include <shared_mutex>
 #include <cassert>
 #include <chrono>
 #include <mutex>
+#include <shared_mutex>
+#include <system_error>
 
 #include "test_macros.h"
 
 bool try_lock_for_called = false;
 
 typedef std::chrono::milliseconds ms;
 
 struct mutex

libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/try_lock_until.pass.cpp

 
 // <shared_mutex>
 
 // template <class Mutex> class shared_lock;
 
 // template <class Clock, class Duration>
 //   bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time);
 
-#include <shared_mutex>
 #include <cassert>
 #include <chrono>
 #include <mutex>
+#include <shared_mutex>
+#include <system_error>
 
 #include "test_macros.h"
 
 bool try_lock_until_called = false;
 
 struct mutex
 {
     template <class Clock, class Duration>

libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex.pass.cpp

 
 // template <class Mutex> class unique_lock;
 
 // explicit unique_lock(mutex_type& m);
 
 // template<class _Mutex> unique_lock(unique_lock<_Mutex>)
 //     -> unique_lock<_Mutex>;  // C++17
 
+#include <cassert>
+#include <chrono>
+#include <cstdlib>
 #include <mutex>
 #include <thread>
-#include <cstdlib>
-#include <cassert>
 
 #include "make_test_thread.h"
 #include "test_macros.h"
 
 std::mutex m;
 
 typedef std::chrono::system_clock Clock;
 typedef Clock::time_point time_point;

libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex_try_to_lock.pass.cpp

 // ALLOW_RETRIES: 2
 
 // <mutex>
 
 // template <class Mutex> class unique_lock;
 
 // unique_lock(mutex_type& m, try_to_lock_t);
 
+#include <cassert>
+#include <chrono>
+#include <cstdlib>
 #include <mutex>
 #include <thread>
-#include <cstdlib>
-#include <cassert>
 
 #include "make_test_thread.h"
 #include "test_macros.h"
 
 std::mutex m;
 
 typedef std::chrono::system_clock Clock;
 typedef Clock::time_point time_point;

libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/lock.pass.cpp

 // ALLOW_RETRIES: 2
 
 // <mutex>
 
 // template <class Mutex> class unique_lock;
 
 // void lock();
 
+#include <cassert>
+#include <chrono>
+#include <cstdlib>
 #include <mutex>
 #include <thread>
-#include <cstdlib>
-#include <cassert>
 
 #include "make_test_thread.h"
 #include "test_macros.h"
 
 std::mutex m;
 
 typedef std::chrono::system_clock Clock;
 typedef Clock::time_point time_point;

libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/try_lock.pass.cpp

 // ALLOW_RETRIES: 2
 
 // <mutex>
 
 // template <class Mutex> class unique_lock;
 
 // bool try_lock();
 
-#include <mutex>
 #include <cassert>
+#include <mutex>
+#include <system_error>
 
 #include "test_macros.h"
 
 bool try_lock_called = false;
 
 struct mutex
 {
     bool try_lock()

libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/try_lock_for.pass.cpp

 
 // <mutex>
 
 // template <class Mutex> class unique_lock;
 
 // template <class Rep, class Period>
 //   bool try_lock_for(const chrono::duration<Rep, Period>& rel_time);
 
-#include <mutex>
 #include <cassert>
+#include <mutex>
+#include <system_error>
 
 #include "test_macros.h"
 
 bool try_lock_for_called = false;
 
 typedef std::chrono::milliseconds ms;
 
 struct mutex

libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/try_lock_until.pass.cpp

 
 // <mutex>
 
 // template <class Mutex> class unique_lock;
 
 // template <class Clock, class Duration>
 //   bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time);
 
-#include <mutex>
 #include <cassert>
+#include <mutex>
+#include <system_error>
 
 #include "test_macros.h"
 
 bool try_lock_until_called = false;
 
 struct mutex
 {
     template <class Clock, class Duration>

libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/unlock.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
 
 // <mutex>
 
 // template <class Mutex> class unique_lock;
 
 // void unlock();
 
-#include <mutex>
 #include <cassert>
+#include <mutex>
+#include <system_error>
 
 #include "test_macros.h"
 
 bool unlock_called = false;
 
 struct mutex
 {
     void lock() {}

libcxx/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.class/lock.pass.cpp

 // ALLOW_RETRIES: 2
 
 // <mutex>
 
 // class mutex;
 
 // void lock();
 
+#include <cassert>
+#include <chrono>
+#include <cstdlib>
 #include <mutex>
 #include <thread>
-#include <cstdlib>
-#include <cassert>
 
 #include "make_test_thread.h"
 #include "test_macros.h"
 
 std::mutex m;
 
 typedef std::chrono::system_clock Clock;
 typedef Clock::time_point time_point;

libcxx/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.class/try_lock.pass.cpp

 // ALLOW_RETRIES: 2
 
 // <mutex>
 
 // class mutex;
 
 // bool try_lock();
 
+#include <cassert>
+#include <chrono>
+#include <cstdlib>
 #include <mutex>
 #include <thread>
-#include <cstdlib>
-#include <cassert>
 
 #include "make_test_thread.h"
 #include "test_macros.h"
 
 std::mutex m;
 
 typedef std::chrono::system_clock Clock;
 typedef Clock::time_point time_point;

libcxx/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.recursive/lock.pass.cpp

 // ALLOW_RETRIES: 2
 
 // <mutex>
 
 // class recursive_mutex;
 
 // void lock();
 
+#include <cassert>
+#include <chrono>
+#include <cstdlib>
 #include <mutex>
 #include <thread>
-#include <cstdlib>
-#include <cassert>
 
 #include "make_test_thread.h"
 #include "test_macros.h"
 
 std::recursive_mutex m;
 
 typedef std::chrono::system_clock Clock;
 typedef Clock::time_point time_point;

libcxx/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.recursive/try_lock.pass.cpp

 // ALLOW_RETRIES: 2
 
 // <mutex>
 
 // class recursive_mutex;
 
 // bool try_lock();
 
+#include <cassert>
+#include <chrono>
+#include <cstdlib>
 #include <mutex>
 #include <thread>
-#include <cstdlib>
-#include <cassert>
 
 #include "make_test_thread.h"
 #include "test_macros.h"
 
 std::recursive_mutex m;
 
 typedef std::chrono::system_clock Clock;
 typedef Clock::time_point time_point;

libcxx/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/lock.pass.cpp

 // UNSUPPORTED: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11}}
 
 // <shared_mutex>
 
 // class shared_mutex;
 
 // void lock();
 
+#include <cassert>
+#include <chrono>
+#include <cstdlib>
 #include <shared_mutex>
 #include <thread>
-#include <cstdlib>
-#include <cassert>
 
 #include "make_test_thread.h"
 #include "test_macros.h"
 
 std::shared_mutex m;
 
 typedef std::chrono::system_clock Clock;
 typedef Clock::time_point time_point;

libcxx/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/lock_shared.pass.cpp

 // UNSUPPORTED: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11}}
 
 // <shared_mutex>
 
 // class shared_mutex;
 
 // void lock_shared();
 
+#include <cassert>
+#include <chrono>
+#include <cstdlib>
 #include <shared_mutex>
 #include <thread>
 #include <vector>
-#include <cstdlib>
-#include <cassert>
 
 #include "make_test_thread.h"
 #include "test_macros.h"
 
 std::shared_mutex m;
 
 typedef std::chrono::system_clock Clock;
 typedef Clock::time_point time_point;

libcxx/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/try_lock.pass.cpp

 // UNSUPPORTED: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11}}
 
 // <shared_mutex>
 
 // class shared_mutex;
 
 // bool try_lock();
 
+#include <cassert>
+#include <chrono>
+#include <cstdlib>
 #include <shared_mutex>
 #include <thread>
-#include <cstdlib>
-#include <cassert>
 
 #include "make_test_thread.h"
 #include "test_macros.h"
 
 std::shared_mutex m;
 
 typedef std::chrono::system_clock Clock;
 typedef Clock::time_point time_point;

libcxx/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/try_lock_shared.pass.cpp

 // UNSUPPORTED: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11}}
 
 // <shared_mutex>
 
 // class shared_mutex;
 
 // bool try_lock_shared();
 
+#include <cassert>
+#include <chrono>
+#include <cstdlib>
 #include <shared_mutex>
 #include <thread>
 #include <vector>
-#include <cstdlib>
-#include <cassert>
 
 #include "make_test_thread.h"
 #include "test_macros.h"
 
 std::shared_mutex m;
 
 typedef std::chrono::system_clock Clock;
 typedef Clock::time_point time_point;

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

 // ALLOW_RETRIES: 3
 
 // <shared_mutex>
 
 // class shared_timed_mutex;
 
 // void lock();
 
-#include <thread>
-
 #include <atomic>
-#include <cstdlib>
 #include <cassert>
+#include <chrono>
+#include <cstdlib>
 #include <shared_mutex>
+#include <thread>
 
 #include "make_test_thread.h"
 #include "test_macros.h"
 
 std::shared_timed_mutex m;
 
 typedef std::chrono::system_clock Clock;
 typedef Clock::time_point time_point;

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

 // ALLOW_RETRIES: 3
 
 // <shared_mutex>
 
 // class shared_timed_mutex;
 
 // void lock_shared();
 
-#include <thread>
 
 #include <atomic>
 #include <cassert>
+#include <chrono>
 #include <cstdlib>
 #include <shared_mutex>
+#include <thread>
 #include <vector>
 
 #include "make_test_thread.h"
 #include "test_macros.h"
 
 std::shared_timed_mutex m;
 
 typedef std::chrono::system_clock Clock;

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

 // UNSUPPORTED: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11}}
 
 // <shared_mutex>
 
 // class shared_timed_mutex;
 
 // bool try_lock();
 
+#include <cassert>
+#include <chrono>
+#include <cstdlib>
 #include <shared_mutex>
 #include <thread>
-#include <cstdlib>
-#include <cassert>
 
 #include "make_test_thread.h"
 #include "test_macros.h"
 
 std::shared_timed_mutex m;
 
 typedef std::chrono::system_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.pass.cpp

 // UNSUPPORTED: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11}}
 
 // <shared_mutex>
 
 // class shared_timed_mutex;
 
 // bool try_lock_shared();
 
+#include <cassert>
+#include <chrono>
+#include <cstdlib>
 #include <shared_mutex>
 #include <thread>
 #include <vector>
-#include <cstdlib>
-#include <cassert>
 
 #include "make_test_thread.h"
 #include "test_macros.h"
 
 std::shared_timed_mutex m;
 
 typedef std::chrono::system_clock Clock;
 typedef Clock::time_point time_point;

libcxx/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.class/lock.pass.cpp

 // ALLOW_RETRIES: 2
 
 // <mutex>
 
 // class timed_mutex;
 
 // void lock();
 
+#include <cassert>
+#include <chrono>
+#include <cstdlib>
 #include <mutex>
 #include <thread>
-#include <cstdlib>
-#include <cassert>
 
 #include "make_test_thread.h"
 #include "test_macros.h"
 
 std::timed_mutex m;
 
 typedef std::chrono::system_clock Clock;
 typedef Clock::time_point time_point;

libcxx/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.class/try_lock.pass.cpp

 // ALLOW_RETRIES: 2
 
 // <mutex>
 
 // class timed_mutex;
 
 // bool try_lock();
 
+#include <cassert>
+#include <chrono>
+#include <cstdlib>
 #include <mutex>
 #include <thread>
-#include <cstdlib>
-#include <cassert>
 
 #include "make_test_thread.h"
 #include "test_macros.h"
 
 std::timed_mutex m;
 
 typedef std::chrono::system_clock Clock;
 typedef Clock::time_point time_point;

libcxx/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.recursive/lock.pass.cpp

 // ALLOW_RETRIES: 2
 
 // <mutex>
 
 // class recursive_timed_mutex;
 
 // void lock();
 
+#include <cassert>
+#include <chrono>
+#include <cstdlib>
 #include <mutex>
 #include <thread>
-#include <cstdlib>
-#include <cassert>
 
 #include "make_test_thread.h"
 #include "test_macros.h"
 
 std::recursive_timed_mutex m;
 
 typedef std::chrono::system_clock Clock;
 typedef Clock::time_point time_point;

libcxx/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.recursive/try_lock.pass.cpp

 // ALLOW_RETRIES: 2
 
 // <mutex>
 
 // class recursive_timed_mutex;
 
 // bool try_lock();
 
+#include <cassert>
+#include <chrono>
+#include <cstdlib>
 #include <mutex>
 #include <thread>
-#include <cstdlib>
-#include <cassert>
 
 #include "make_test_thread.h"
 #include "test_macros.h"
 
 std::recursive_timed_mutex m;
 
 typedef std::chrono::system_clock Clock;
 typedef Clock::time_point time_point;

libcxx/test/std/thread/thread.threads/thread.thread.this/sleep_until.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
 
 // <thread>
 
 // template <class Clock, class Duration>
 //   void sleep_until(const chrono::time_point<Clock, Duration>& abs_time);
 
-#include <thread>
-#include <cstdlib>
 #include <cassert>
+#include <chrono>
+#include <cstdlib>
+#include <thread>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
   typedef std::chrono::system_clock Clock;
   typedef Clock::time_point time_point;
   std::chrono::milliseconds ms(500);