Cider Isn't Darwin Emulation, Really
Something went wrong. Try again.
15 kB · 507 lines
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508// -*- C++ -*-//===------------------------ shared_mutex --------------------------------===////// The LLVM Compiler Infrastructure//// This file is dual licensed under the MIT and the University of Illinois Open// Source Licenses. See LICENSE.TXT for details.////===----------------------------------------------------------------------===//#ifndef _LIBCPP_SHARED_MUTEX#define _LIBCPP_SHARED_MUTEX/* shared_mutex synopsis// C++1ynamespace std{class shared_mutex // C++17{public: shared_mutex(); ~shared_mutex(); shared_mutex(const shared_mutex&) = delete; shared_mutex& operator=(const shared_mutex&) = delete; // Exclusive ownership void lock(); // blocking bool try_lock(); void unlock(); // Shared ownership void lock_shared(); // blocking bool try_lock_shared(); void unlock_shared(); typedef implementation-defined native_handle_type; // See 30.2.3 native_handle_type native_handle(); // See 30.2.3};class shared_timed_mutex{public: shared_timed_mutex(); ~shared_timed_mutex(); shared_timed_mutex(const shared_timed_mutex&) = delete; shared_timed_mutex& operator=(const shared_timed_mutex&) = delete; // Exclusive ownership void lock(); // blocking 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(); // Shared ownership void lock_shared(); // blocking bool try_lock_shared(); template <class Rep, class Period> bool try_lock_shared_for(const chrono::duration<Rep, Period>& rel_time); template <class Clock, class Duration> bool try_lock_shared_until(const chrono::time_point<Clock, Duration>& abs_time); void unlock_shared();};template <class Mutex>class shared_lock{public: typedef Mutex mutex_type; // Shared locking shared_lock() noexcept; explicit shared_lock(mutex_type& m); // blocking shared_lock(mutex_type& m, defer_lock_t) noexcept; shared_lock(mutex_type& m, try_to_lock_t); shared_lock(mutex_type& m, adopt_lock_t); template <class Clock, class Duration> shared_lock(mutex_type& m, const chrono::time_point<Clock, Duration>& abs_time); template <class Rep, class Period> shared_lock(mutex_type& m, const chrono::duration<Rep, Period>& rel_time); ~shared_lock(); shared_lock(shared_lock const&) = delete; shared_lock& operator=(shared_lock const&) = delete; shared_lock(shared_lock&& u) noexcept; shared_lock& operator=(shared_lock&& u) noexcept; void lock(); // blocking 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(); // Setters void swap(shared_lock& u) noexcept; mutex_type* release() noexcept; // Getters bool owns_lock() const noexcept; explicit operator bool () const noexcept; mutex_type* mutex() const noexcept;};template <class Mutex> void swap(shared_lock<Mutex>& x, shared_lock<Mutex>& y) noexcept;} // std*/#include <__config>_LIBCPP_PUSH_MACROS#include <__undef_macros>#if _LIBCPP_STD_VER > 11 || defined(_LIBCPP_BUILDING_SHARED_MUTEX)#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 on this single threaded system#else // !_LIBCPP_HAS_NO_THREADS_LIBCPP_BEGIN_NAMESPACE_STDstruct _LIBCPP_TYPE_VIS _LIBCPP_AVAILABILITY_SHARED_MUTEX __shared_mutex_base{ mutex __mut_; condition_variable __gate1_; condition_variable __gate2_; unsigned __state_; static const unsigned __write_entered_ = 1U << (sizeof(unsigned)*__CHAR_BIT__ - 1); static const unsigned __n_readers_ = ~__write_entered_; __shared_mutex_base(); _LIBCPP_INLINE_VISIBILITY ~__shared_mutex_base() = default; __shared_mutex_base(const __shared_mutex_base&) = delete; __shared_mutex_base& operator=(const __shared_mutex_base&) = delete; // Exclusive ownership void lock(); // blocking bool try_lock(); void unlock(); // Shared ownership void lock_shared(); // blocking bool try_lock_shared(); void unlock_shared();// typedef implementation-defined native_handle_type; // See 30.2.3// native_handle_type native_handle(); // See 30.2.3};#if _LIBCPP_STD_VER > 14class _LIBCPP_TYPE_VIS _LIBCPP_AVAILABILITY_SHARED_MUTEX shared_mutex{ __shared_mutex_base __base;public: _LIBCPP_INLINE_VISIBILITY shared_mutex() : __base() {} _LIBCPP_INLINE_VISIBILITY ~shared_mutex() = default; shared_mutex(const shared_mutex&) = delete; shared_mutex& operator=(const shared_mutex&) = delete; // Exclusive ownership _LIBCPP_INLINE_VISIBILITY void lock() { return __base.lock(); } _LIBCPP_INLINE_VISIBILITY bool try_lock() { return __base.try_lock(); } _LIBCPP_INLINE_VISIBILITY void unlock() { return __base.unlock(); } // Shared ownership _LIBCPP_INLINE_VISIBILITY void lock_shared() { return __base.lock_shared(); } _LIBCPP_INLINE_VISIBILITY bool try_lock_shared() { return __base.try_lock_shared(); } _LIBCPP_INLINE_VISIBILITY void unlock_shared() { return __base.unlock_shared(); }// typedef __shared_mutex_base::native_handle_type native_handle_type;// _LIBCPP_INLINE_VISIBILITY native_handle_type native_handle() { return __base::unlock_shared(); }};#endifclass _LIBCPP_TYPE_VIS _LIBCPP_AVAILABILITY_SHARED_MUTEX shared_timed_mutex{ __shared_mutex_base __base;public: shared_timed_mutex(); _LIBCPP_INLINE_VISIBILITY ~shared_timed_mutex() = default; shared_timed_mutex(const shared_timed_mutex&) = delete; shared_timed_mutex& operator=(const shared_timed_mutex&) = delete; // Exclusive ownership void lock(); bool try_lock(); template <class _Rep, class _Period> _LIBCPP_INLINE_VISIBILITY bool try_lock_for(const chrono::duration<_Rep, _Period>& __rel_time) { return try_lock_until(chrono::steady_clock::now() + __rel_time); } template <class _Clock, class _Duration> _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS bool try_lock_until(const chrono::time_point<_Clock, _Duration>& __abs_time); void unlock(); // Shared ownership void lock_shared(); bool try_lock_shared(); template <class _Rep, class _Period> _LIBCPP_INLINE_VISIBILITY bool try_lock_shared_for(const chrono::duration<_Rep, _Period>& __rel_time) { return try_lock_shared_until(chrono::steady_clock::now() + __rel_time); } template <class _Clock, class _Duration> _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS bool try_lock_shared_until(const chrono::time_point<_Clock, _Duration>& __abs_time); void unlock_shared();};template <class _Clock, class _Duration>boolshared_timed_mutex::try_lock_until( const chrono::time_point<_Clock, _Duration>& __abs_time){ unique_lock<mutex> __lk(__base.__mut_); if (__base.__state_ & __base.__write_entered_) { while (true) { cv_status __status = __base.__gate1_.wait_until(__lk, __abs_time); if ((__base.__state_ & __base.__write_entered_) == 0) break; if (__status == cv_status::timeout) return false; } } __base.__state_ |= __base.__write_entered_; if (__base.__state_ & __base.__n_readers_) { while (true) { cv_status __status = __base.__gate2_.wait_until(__lk, __abs_time); if ((__base.__state_ & __base.__n_readers_) == 0) break; if (__status == cv_status::timeout) { __base.__state_ &= ~__base.__write_entered_; __base.__gate1_.notify_all(); return false; } } } return true;}template <class _Clock, class _Duration>boolshared_timed_mutex::try_lock_shared_until( const chrono::time_point<_Clock, _Duration>& __abs_time){ unique_lock<mutex> __lk(__base.__mut_); if ((__base.__state_ & __base.__write_entered_) || (__base.__state_ & __base.__n_readers_) == __base.__n_readers_) { while (true) { cv_status status = __base.__gate1_.wait_until(__lk, __abs_time); if ((__base.__state_ & __base.__write_entered_) == 0 && (__base.__state_ & __base.__n_readers_) < __base.__n_readers_) break; if (status == cv_status::timeout) return false; } } unsigned __num_readers = (__base.__state_ & __base.__n_readers_) + 1; __base.__state_ &= ~__base.__n_readers_; __base.__state_ |= __num_readers; return true;}template <class _Mutex>class shared_lock{public: typedef _Mutex mutex_type;private: mutex_type* __m_; bool __owns_;public: _LIBCPP_INLINE_VISIBILITY shared_lock() _NOEXCEPT : __m_(nullptr), __owns_(false) {} _LIBCPP_INLINE_VISIBILITY explicit shared_lock(mutex_type& __m) : __m_(_VSTD::addressof(__m)), __owns_(true) {__m_->lock_shared();} _LIBCPP_INLINE_VISIBILITY shared_lock(mutex_type& __m, defer_lock_t) _NOEXCEPT : __m_(_VSTD::addressof(__m)), __owns_(false) {} _LIBCPP_INLINE_VISIBILITY shared_lock(mutex_type& __m, try_to_lock_t) : __m_(_VSTD::addressof(__m)), __owns_(__m.try_lock_shared()) {} _LIBCPP_INLINE_VISIBILITY shared_lock(mutex_type& __m, adopt_lock_t) : __m_(_VSTD::addressof(__m)), __owns_(true) {} template <class _Clock, class _Duration> _LIBCPP_INLINE_VISIBILITY shared_lock(mutex_type& __m, const chrono::time_point<_Clock, _Duration>& __abs_time) : __m_(_VSTD::addressof(__m)), __owns_(__m.try_lock_shared_until(__abs_time)) {} template <class _Rep, class _Period> _LIBCPP_INLINE_VISIBILITY shared_lock(mutex_type& __m, const chrono::duration<_Rep, _Period>& __rel_time) : __m_(_VSTD::addressof(__m)), __owns_(__m.try_lock_shared_for(__rel_time)) {} _LIBCPP_INLINE_VISIBILITY ~shared_lock() { if (__owns_) __m_->unlock_shared(); } shared_lock(shared_lock const&) = delete; shared_lock& operator=(shared_lock const&) = delete; _LIBCPP_INLINE_VISIBILITY shared_lock(shared_lock&& __u) _NOEXCEPT : __m_(__u.__m_), __owns_(__u.__owns_) { __u.__m_ = nullptr; __u.__owns_ = false; } _LIBCPP_INLINE_VISIBILITY shared_lock& operator=(shared_lock&& __u) _NOEXCEPT { if (__owns_) __m_->unlock_shared(); __m_ = nullptr; __owns_ = false; __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>& rel_time); template <class Clock, class Duration> bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time); void unlock(); // Setters _LIBCPP_INLINE_VISIBILITY void swap(shared_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; } // Getters _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_;}};template <class _Mutex>voidshared_lock<_Mutex>::lock(){ if (__m_ == nullptr) __throw_system_error(EPERM, "shared_lock::lock: references null mutex"); if (__owns_) __throw_system_error(EDEADLK, "shared_lock::lock: already locked"); __m_->lock_shared(); __owns_ = true;}template <class _Mutex>boolshared_lock<_Mutex>::try_lock(){ if (__m_ == nullptr) __throw_system_error(EPERM, "shared_lock::try_lock: references null mutex"); if (__owns_) __throw_system_error(EDEADLK, "shared_lock::try_lock: already locked"); __owns_ = __m_->try_lock_shared(); return __owns_;}template <class _Mutex>template <class _Rep, class _Period>boolshared_lock<_Mutex>::try_lock_for(const chrono::duration<_Rep, _Period>& __d){ if (__m_ == nullptr) __throw_system_error(EPERM, "shared_lock::try_lock_for: references null mutex"); if (__owns_) __throw_system_error(EDEADLK, "shared_lock::try_lock_for: already locked"); __owns_ = __m_->try_lock_shared_for(__d); return __owns_;}template <class _Mutex>template <class _Clock, class _Duration>boolshared_lock<_Mutex>::try_lock_until(const chrono::time_point<_Clock, _Duration>& __t){ if (__m_ == nullptr) __throw_system_error(EPERM, "shared_lock::try_lock_until: references null mutex"); if (__owns_) __throw_system_error(EDEADLK, "shared_lock::try_lock_until: already locked"); __owns_ = __m_->try_lock_shared_until(__t); return __owns_;}template <class _Mutex>voidshared_lock<_Mutex>::unlock(){ if (!__owns_) __throw_system_error(EPERM, "shared_lock::unlock: not locked"); __m_->unlock_shared(); __owns_ = false;}template <class _Mutex>inline _LIBCPP_INLINE_VISIBILITYvoidswap(shared_lock<_Mutex>& __x, shared_lock<_Mutex>& __y) _NOEXCEPT {__x.swap(__y);}_LIBCPP_END_NAMESPACE_STD#endif // !_LIBCPP_HAS_NO_THREADS#endif // _LIBCPP_STD_VER > 11_LIBCPP_POP_MACROS#endif // _LIBCPP_SHARED_MUTEX