mirror of
https://github.com/capstone-engine/llvm-capstone.git
synced 2025-01-01 05:11:15 +00:00
2eadbc8614
Currently, vendor-specific availability markup is enabled by default. This means that even when building against trunk libc++, the headers will by default prevent you from using some features that were not released in the dylib on your target platform. This is a source of frustration since people building libc++ from sources are usually not trying to use some vendor's released dylib. For that reason, I've been thinking for a long time that availability annotations should be off by default, which is the primary change that this commit enables. In addition, it reworks the implementation to make it easier for new vendors to add availability annotations for their platform, and it refreshes the documentation to reflect the current state of the codebase. Finally, a CMake configuration option is added to control whether availability annotations should be turned on for the flavor of libc++ being created. The intent is for vendors like Apple to turn it on, and for the upstream libc++ to leave it off (the default). Differential Revision: https://reviews.llvm.org/D90843
510 lines
15 KiB
C++
510 lines
15 KiB
C++
// -*- C++ -*-
|
|
//===------------------------ shared_mutex --------------------------------===//
|
|
//
|
|
// 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_SHARED_MUTEX
|
|
#define _LIBCPP_SHARED_MUTEX
|
|
|
|
/*
|
|
shared_mutex synopsis
|
|
|
|
// C++1y
|
|
|
|
namespace 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>
|
|
#include <__availability>
|
|
#include <version>
|
|
|
|
_LIBCPP_PUSH_MACROS
|
|
#include <__undef_macros>
|
|
|
|
|
|
#if _LIBCPP_STD_VER > 11 || 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 on this single threaded system
|
|
#else // !_LIBCPP_HAS_NO_THREADS
|
|
|
|
_LIBCPP_BEGIN_NAMESPACE_STD
|
|
|
|
struct _LIBCPP_TYPE_VIS _LIBCPP_AVAILABILITY_SHARED_MUTEX _LIBCPP_THREAD_SAFETY_ANNOTATION(capability("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() _LIBCPP_THREAD_SAFETY_ANNOTATION(acquire_capability()); // blocking
|
|
bool try_lock() _LIBCPP_THREAD_SAFETY_ANNOTATION(try_acquire_capability(true));
|
|
void unlock() _LIBCPP_THREAD_SAFETY_ANNOTATION(release_capability());
|
|
|
|
// Shared ownership
|
|
void lock_shared() _LIBCPP_THREAD_SAFETY_ANNOTATION(acquire_shared_capability()); // blocking
|
|
bool try_lock_shared() _LIBCPP_THREAD_SAFETY_ANNOTATION(try_acquire_shared_capability(true));
|
|
void unlock_shared() _LIBCPP_THREAD_SAFETY_ANNOTATION(release_shared_capability());
|
|
|
|
// typedef implementation-defined native_handle_type; // See 30.2.3
|
|
// native_handle_type native_handle(); // See 30.2.3
|
|
};
|
|
|
|
|
|
#if _LIBCPP_STD_VER > 14
|
|
class _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(); }
|
|
};
|
|
#endif
|
|
|
|
|
|
class _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>
|
|
bool
|
|
shared_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>
|
|
bool
|
|
shared_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>
|
|
void
|
|
shared_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>
|
|
bool
|
|
shared_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>
|
|
bool
|
|
shared_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>
|
|
bool
|
|
shared_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>
|
|
void
|
|
shared_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_VISIBILITY
|
|
void
|
|
swap(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
|