summaryrefslogtreecommitdiff
path: root/third_party/libcxx/include/c++/v1/mutex
diff options
context:
space:
mode:
Diffstat (limited to 'third_party/libcxx/include/c++/v1/mutex')
-rw-r--r--third_party/libcxx/include/c++/v1/mutex524
1 files changed, 0 insertions, 524 deletions
diff --git a/third_party/libcxx/include/c++/v1/mutex b/third_party/libcxx/include/c++/v1/mutex
deleted file mode 100644
index bec0185..0000000
--- a/third_party/libcxx/include/c++/v1/mutex
+++ /dev/null
@@ -1,524 +0,0 @@
-// -*- 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
-#define _LIBCPP_MUTEX
-
-/*
- mutex synopsis
-
-namespace std
-{
-
-class mutex
-{
-public:
- constexpr mutex() noexcept;
- ~mutex();
-
- mutex(const mutex&) = delete;
- mutex& operator=(const mutex&) = delete;
-
- void lock();
- bool try_lock();
- void unlock();
-
- typedef pthread_mutex_t* native_handle_type;
- native_handle_type native_handle();
-};
-
-class recursive_mutex
-{
-public:
- recursive_mutex();
- ~recursive_mutex();
-
- recursive_mutex(const recursive_mutex&) = delete;
- recursive_mutex& operator=(const recursive_mutex&) = delete;
-
- void lock();
- bool try_lock() noexcept;
- void unlock();
-
- typedef pthread_mutex_t* native_handle_type;
- native_handle_type native_handle();
-};
-
-class timed_mutex
-{
-public:
- timed_mutex();
- ~timed_mutex();
-
- timed_mutex(const timed_mutex&) = delete;
- timed_mutex& operator=(const timed_mutex&) = delete;
-
- void lock();
- bool try_lock();
- template <class Rep, class Period>
- bool try_lock_for(const chrono::duration<Rep, Period>& rel_time);
- template <class Clock, class Duration>
- bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time);
- void unlock();
-};
-
-class recursive_timed_mutex
-{
-public:
- recursive_timed_mutex();
- ~recursive_timed_mutex();
-
- recursive_timed_mutex(const recursive_timed_mutex&) = delete;
- recursive_timed_mutex& operator=(const recursive_timed_mutex&) = delete;
-
- void lock();
- bool try_lock() noexcept;
- template <class Rep, class Period>
- bool try_lock_for(const chrono::duration<Rep, Period>& rel_time);
- template <class Clock, class Duration>
- bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time);
- void unlock();
-};
-
-struct defer_lock_t { explicit defer_lock_t() = default; };
-struct try_to_lock_t { explicit try_to_lock_t() = default; };
-struct adopt_lock_t { explicit adopt_lock_t() = default; };
-
-inline constexpr defer_lock_t defer_lock{};
-inline constexpr try_to_lock_t try_to_lock{};
-inline constexpr adopt_lock_t adopt_lock{};
-
-template <class Mutex>
-class lock_guard
-{
-public:
- typedef Mutex mutex_type;
-
- explicit lock_guard(mutex_type& m);
- lock_guard(mutex_type& m, adopt_lock_t);
- ~lock_guard();
-
- lock_guard(lock_guard const&) = delete;
- lock_guard& operator=(lock_guard const&) = delete;
-};
-
-template <class... MutexTypes>
-class scoped_lock // C++17
-{
-public:
- using mutex_type = Mutex; // Only if sizeof...(MutexTypes) == 1
-
- explicit scoped_lock(MutexTypes&... m);
- scoped_lock(adopt_lock_t, MutexTypes&... m);
- ~scoped_lock();
- scoped_lock(scoped_lock const&) = delete;
- scoped_lock& operator=(scoped_lock const&) = delete;
-private:
- tuple<MutexTypes&...> pm; // exposition only
-};
-
-template <class Mutex>
-class unique_lock
-{
-public:
- typedef Mutex mutex_type;
- unique_lock() noexcept;
- explicit unique_lock(mutex_type& m);
- unique_lock(mutex_type& m, defer_lock_t) noexcept;
- unique_lock(mutex_type& m, try_to_lock_t);
- unique_lock(mutex_type& m, adopt_lock_t);
- template <class Clock, class Duration>
- unique_lock(mutex_type& m, const chrono::time_point<Clock, Duration>& abs_time);
- template <class Rep, class Period>
- unique_lock(mutex_type& m, const chrono::duration<Rep, Period>& rel_time);
- ~unique_lock();
-
- unique_lock(unique_lock const&) = delete;
- unique_lock& operator=(unique_lock const&) = delete;
-
- unique_lock(unique_lock&& u) noexcept;
- unique_lock& operator=(unique_lock&& u) noexcept;
-
- void lock();
- bool try_lock();
-
- template <class Rep, class Period>
- bool try_lock_for(const chrono::duration<Rep, Period>& rel_time);
- template <class Clock, class Duration>
- bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time);
-
- void unlock();
-
- void swap(unique_lock& u) noexcept;
- mutex_type* release() noexcept;
-
- bool owns_lock() const noexcept;
- explicit operator bool () const noexcept;
- mutex_type* mutex() const noexcept;
-};
-
-template <class Mutex>
- void swap(unique_lock<Mutex>& x, unique_lock<Mutex>& y) noexcept;
-
-template <class L1, class L2, class... L3>
- int try_lock(L1&, L2&, L3&...);
-template <class L1, class L2, class... L3>
- void lock(L1&, L2&, L3&...);
-
-struct once_flag
-{
- constexpr once_flag() noexcept;
-
- once_flag(const once_flag&) = delete;
- once_flag& operator=(const once_flag&) = delete;
-};
-
-template<class Callable, class ...Args>
- void call_once(once_flag& flag, Callable&& func, Args&&... args);
-
-} // std
-
-*/
-
-#if __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)
-# include <__cxx03/mutex>
-#else
-# include <__chrono/steady_clock.h>
-# include <__chrono/time_point.h>
-# include <__condition_variable/condition_variable.h>
-# include <__config>
-# include <__mutex/lock_guard.h>
-# include <__mutex/mutex.h>
-# include <__mutex/once_flag.h>
-# include <__mutex/tag_types.h>
-# include <__mutex/unique_lock.h>
-# include <__thread/id.h>
-# include <__thread/support.h>
-# include <__utility/forward.h>
-# include <limits>
-# ifndef _LIBCPP_CXX03_LANG
-# include <tuple>
-# endif
-# include <version>
-
-# if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-# pragma GCC system_header
-# endif
-
-_LIBCPP_PUSH_MACROS
-# include <__undef_macros>
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-# if _LIBCPP_HAS_THREADS
-
-class _LIBCPP_EXPORTED_FROM_ABI recursive_mutex {
- __libcpp_recursive_mutex_t __m_;
-
-public:
- recursive_mutex();
- ~recursive_mutex();
-
- recursive_mutex(const recursive_mutex&) = delete;
- recursive_mutex& operator=(const recursive_mutex&) = delete;
-
- void lock();
- [[__nodiscard__]] bool try_lock() _NOEXCEPT;
- void unlock() _NOEXCEPT;
-
- typedef __libcpp_recursive_mutex_t* native_handle_type;
-
- [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI native_handle_type native_handle() { return &__m_; }
-};
-
-class _LIBCPP_EXPORTED_FROM_ABI timed_mutex {
- mutex __m_;
- condition_variable __cv_;
- bool __locked_;
-
-public:
- timed_mutex();
- ~timed_mutex();
-
- timed_mutex(const timed_mutex&) = delete;
- timed_mutex& operator=(const timed_mutex&) = delete;
-
-public:
- void lock();
- [[__nodiscard__]] bool try_lock() _NOEXCEPT;
- template <class _Rep, class _Period>
- [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI bool try_lock_for(const chrono::duration<_Rep, _Period>& __d) {
- return try_lock_until(chrono::steady_clock::now() + __d);
- }
-
- template <class _Clock, class _Duration>
- [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI bool try_lock_until(const chrono::time_point<_Clock, _Duration>& __t) {
- using namespace chrono;
- unique_lock<mutex> __lk(__m_);
- bool __no_timeout = _Clock::now() < __t;
- while (__no_timeout && __locked_)
- __no_timeout = __cv_.wait_until(__lk, __t) == cv_status::no_timeout;
- if (!__locked_) {
- __locked_ = true;
- return true;
- }
- return false;
- }
-
- void unlock() _NOEXCEPT;
-};
-
-class _LIBCPP_EXPORTED_FROM_ABI recursive_timed_mutex {
- mutex __m_;
- condition_variable __cv_;
- size_t __count_;
- __thread_id __id_;
-
-public:
- recursive_timed_mutex();
- ~recursive_timed_mutex();
-
- recursive_timed_mutex(const recursive_timed_mutex&) = delete;
- recursive_timed_mutex& operator=(const recursive_timed_mutex&) = delete;
-
- void lock();
- [[__nodiscard__]] bool try_lock() _NOEXCEPT;
- template <class _Rep, class _Period>
- [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI bool try_lock_for(const chrono::duration<_Rep, _Period>& __d) {
- return try_lock_until(chrono::steady_clock::now() + __d);
- }
-
- template <class _Clock, class _Duration>
- [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI bool try_lock_until(const chrono::time_point<_Clock, _Duration>& __t) {
- using namespace chrono;
- __thread_id __id = this_thread::get_id();
- unique_lock<mutex> __lk(__m_);
- if (__id == __id_) {
- if (__count_ == numeric_limits<size_t>::max())
- return false;
- ++__count_;
- return true;
- }
- bool __no_timeout = _Clock::now() < __t;
- while (__no_timeout && __count_ != 0)
- __no_timeout = __cv_.wait_until(__lk, __t) == cv_status::no_timeout;
- if (__count_ == 0) {
- __count_ = 1;
- __id_ = __id;
- return true;
- }
- return false;
- }
-
- void unlock() _NOEXCEPT;
-};
-
-template <class _L0, class _L1>
-[[__nodiscard__]] _LIBCPP_NO_THREAD_SAFETY_ANALYSIS _LIBCPP_HIDE_FROM_ABI int try_lock(_L0& __l0, _L1& __l1) {
- unique_lock<_L0> __u0(__l0, try_to_lock_t());
- if (__u0.owns_lock()) {
- if (__l1.try_lock()) {
- __u0.release();
- return -1;
- } else
- return 1;
- }
- return 0;
-}
-
-# ifndef _LIBCPP_CXX03_LANG
-
-template <class _L0, class _L1, class _L2, class... _L3>
-[[__nodiscard__]] _LIBCPP_NO_THREAD_SAFETY_ANALYSIS
- _LIBCPP_HIDE_FROM_ABI int try_lock(_L0& __l0, _L1& __l1, _L2& __l2, _L3&... __l3) {
- int __r = 0;
- unique_lock<_L0> __u0(__l0, try_to_lock);
- if (__u0.owns_lock()) {
- __r = std::try_lock(__l1, __l2, __l3...);
- if (__r == -1)
- __u0.release();
- else
- ++__r;
- }
- return __r;
-}
-
-# endif // _LIBCPP_CXX03_LANG
-
-// We're using unique_lock to implement the functions, which thread annotations don't support. So we have to disable
-// the analysis inside the function.
-template <class _L0, class _L1>
-_LIBCPP_NO_THREAD_SAFETY_ANALYSIS _LIBCPP_HIDE_FROM_ABI void lock(_L0& __l0, _L1& __l1)
- _LIBCPP_ACQUIRE_CAPABILITY(__l0, __l1) {
- while (true) {
- {
- unique_lock<_L0> __u0(__l0);
- if (__l1.try_lock()) {
- __u0.release();
- break;
- }
- }
- __libcpp_thread_yield();
- {
- unique_lock<_L1> __u1(__l1);
- if (__l0.try_lock()) {
- __u1.release();
- break;
- }
- }
- __libcpp_thread_yield();
- }
-}
-
-# ifndef _LIBCPP_CXX03_LANG
-
-template <class _L0, class _L1, class _L2, class... _L3>
-_LIBCPP_NO_THREAD_SAFETY_ANALYSIS void __lock_first(int __i, _L0& __l0, _L1& __l1, _L2& __l2, _L3&... __l3) {
- while (true) {
- switch (__i) {
- case 0: {
- unique_lock<_L0> __u0(__l0);
- __i = std::try_lock(__l1, __l2, __l3...);
- if (__i == -1) {
- __u0.release();
- return;
- }
- }
- ++__i;
- __libcpp_thread_yield();
- break;
- case 1: {
- unique_lock<_L1> __u1(__l1);
- __i = std::try_lock(__l2, __l3..., __l0);
- if (__i == -1) {
- __u1.release();
- return;
- }
- }
- if (__i == sizeof...(_L3) + 1)
- __i = 0;
- else
- __i += 2;
- __libcpp_thread_yield();
- break;
- default:
- std::__lock_first(__i - 2, __l2, __l3..., __l0, __l1);
- return;
- }
- }
-}
-
-// We're using unique_lock to implement the functions, which thread annotations don't support. So we have to disable
-// the analysis inside the function.
-template <class _L0, class _L1, class _L2, class... _L3>
-_LIBCPP_NO_THREAD_SAFETY_ANALYSIS inline _LIBCPP_HIDE_FROM_ABI void lock(_L0& __l0, _L1& __l1, _L2& __l2, _L3&... __l3)
-# if defined(_LIBCPP_CLANG_VER) && _LIBCPP_CLANG_VER >= 2101
- _LIBCPP_ACQUIRE_CAPABILITY(__l0, __l1, __l2, __l3...)
-# endif
-{
- std::__lock_first(0, __l0, __l1, __l2, __l3...);
-}
-
-# endif // _LIBCPP_CXX03_LANG
-
-# if _LIBCPP_STD_VER >= 17
-template <class... _Mutexes>
-class scoped_lock;
-
-template <>
-class scoped_lock<> {
-public:
- [[nodiscard]] _LIBCPP_HIDE_FROM_ABI explicit scoped_lock() {}
- ~scoped_lock() = default;
-
- [[nodiscard]] _LIBCPP_HIDE_FROM_ABI explicit scoped_lock(adopt_lock_t) {}
-
- scoped_lock(scoped_lock const&) = delete;
- scoped_lock& operator=(scoped_lock const&) = delete;
-};
-
-template <class _Mutex>
-class _LIBCPP_SCOPED_LOCKABLE scoped_lock<_Mutex> {
-public:
- typedef _Mutex mutex_type;
-
-private:
- mutex_type& __m_;
-
-public:
- [[nodiscard]] _LIBCPP_HIDE_FROM_ABI explicit scoped_lock(mutex_type& __m) _LIBCPP_ACQUIRE_CAPABILITY(__m)
- : __m_(__m) {
- __m_.lock();
- }
-
- _LIBCPP_RELEASE_CAPABILITY _LIBCPP_HIDE_FROM_ABI ~scoped_lock() { __m_.unlock(); }
-
- [[nodiscard]]
- _LIBCPP_HIDE_FROM_ABI explicit scoped_lock(adopt_lock_t, mutex_type& __m) _LIBCPP_REQUIRES_CAPABILITY(__m)
- : __m_(__m) {}
-
- scoped_lock(scoped_lock const&) = delete;
- scoped_lock& operator=(scoped_lock const&) = delete;
-};
-
-template <class... _MArgs>
-class scoped_lock {
- static_assert(sizeof...(_MArgs) > 1, "At least 2 lock types required");
- typedef tuple<_MArgs&...> _MutexTuple;
-
-public:
- [[nodiscard]] _LIBCPP_HIDE_FROM_ABI explicit scoped_lock(_MArgs&... __margs) : __t_(__margs...) {
- std::lock(__margs...);
- }
-
- [[nodiscard]] _LIBCPP_HIDE_FROM_ABI scoped_lock(adopt_lock_t, _MArgs&... __margs) : __t_(__margs...) {}
-
- _LIBCPP_HIDE_FROM_ABI ~scoped_lock() { __unlock_unpack(make_index_sequence<sizeof...(_MArgs)>(), __t_); }
-
- scoped_lock(scoped_lock const&) = delete;
- scoped_lock& operator=(scoped_lock const&) = delete;
-
-private:
- template <size_t... _Indx>
- _LIBCPP_HIDE_FROM_ABI static void __unlock_unpack(index_sequence<_Indx...>, _MutexTuple& __mt) {
- (std::get<_Indx>(__mt).unlock(), ...);
- }
-
- _MutexTuple __t_;
-};
-_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(scoped_lock);
-
-# endif // _LIBCPP_STD_VER >= 17
-# endif // _LIBCPP_HAS_THREADS
-
-_LIBCPP_END_NAMESPACE_STD
-
-_LIBCPP_POP_MACROS
-
-# if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 23
-# include <typeinfo>
-# endif
-
-# if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
-# include <atomic>
-# include <concepts>
-# include <cstdlib>
-# include <cstring>
-# include <ctime>
-# include <initializer_list>
-# include <iosfwd>
-# include <new>
-# include <optional>
-# include <stdexcept>
-# include <system_error>
-# include <type_traits>
-# endif
-#endif // __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)
-
-#endif // _LIBCPP_MUTEX
generated by cgit v1.2.3 (git 2.46.0) at 2026-10-29 13:30:43 +0000