| //===------------------------- 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 "mutex" |
| #include "limits" |
| #include "system_error" |
| #include "include/atomic_support.h" |
| #include "__undef_macros" |
| |
| #ifndef _LIBCPP_HAS_NO_THREADS |
| #if defined(__ELF__) && defined(_LIBCPP_LINK_PTHREAD_LIB) |
| #pragma comment(lib, "pthread") |
| #endif |
| #endif |
| |
| _LIBCPP_BEGIN_NAMESPACE_STD |
| #ifndef _LIBCPP_HAS_NO_THREADS |
| |
| const defer_lock_t defer_lock{}; |
| const try_to_lock_t try_to_lock{}; |
| const adopt_lock_t adopt_lock{}; |
| |
| // ~mutex is defined elsewhere |
| |
| void |
| mutex::lock() |
| { |
| int ec = __libcpp_mutex_lock(&__m_); |
| if (ec) |
| __throw_system_error(ec, "mutex lock failed"); |
| } |
| |
| bool |
| mutex::try_lock() noexcept |
| { |
| return __libcpp_mutex_trylock(&__m_); |
| } |
| |
| void |
| mutex::unlock() noexcept |
| { |
| int ec = __libcpp_mutex_unlock(&__m_); |
| (void)ec; |
| _LIBCPP_ASSERT(ec == 0, "call to mutex::unlock failed"); |
| } |
| |
| // recursive_mutex |
| |
| recursive_mutex::recursive_mutex() |
| { |
| int ec = __libcpp_recursive_mutex_init(&__m_); |
| if (ec) |
| __throw_system_error(ec, "recursive_mutex constructor failed"); |
| } |
| |
| recursive_mutex::~recursive_mutex() |
| { |
| int e = __libcpp_recursive_mutex_destroy(&__m_); |
| (void)e; |
| _LIBCPP_ASSERT(e == 0, "call to ~recursive_mutex() failed"); |
| } |
| |
| void |
| recursive_mutex::lock() |
| { |
| int ec = __libcpp_recursive_mutex_lock(&__m_); |
| if (ec) |
| __throw_system_error(ec, "recursive_mutex lock failed"); |
| } |
| |
| void |
| recursive_mutex::unlock() noexcept |
| { |
| int e = __libcpp_recursive_mutex_unlock(&__m_); |
| (void)e; |
| _LIBCPP_ASSERT(e == 0, "call to recursive_mutex::unlock() failed"); |
| } |
| |
| bool |
| recursive_mutex::try_lock() noexcept |
| { |
| return __libcpp_recursive_mutex_trylock(&__m_); |
| } |
| |
| // timed_mutex |
| |
| timed_mutex::timed_mutex() |
| : __locked_(false) |
| { |
| } |
| |
| timed_mutex::~timed_mutex() |
| { |
| lock_guard<mutex> _(__m_); |
| } |
| |
| void |
| timed_mutex::lock() |
| { |
| unique_lock<mutex> lk(__m_); |
| while (__locked_) |
| __cv_.wait(lk); |
| __locked_ = true; |
| } |
| |
| bool |
| timed_mutex::try_lock() noexcept |
| { |
| unique_lock<mutex> lk(__m_, try_to_lock); |
| if (lk.owns_lock() && !__locked_) |
| { |
| __locked_ = true; |
| return true; |
| } |
| return false; |
| } |
| |
| void |
| timed_mutex::unlock() noexcept |
| { |
| lock_guard<mutex> _(__m_); |
| __locked_ = false; |
| __cv_.notify_one(); |
| } |
| |
| // recursive_timed_mutex |
| |
| recursive_timed_mutex::recursive_timed_mutex() |
| : __count_(0), |
| __id_{} |
| { |
| } |
| |
| recursive_timed_mutex::~recursive_timed_mutex() |
| { |
| lock_guard<mutex> _(__m_); |
| } |
| |
| void |
| recursive_timed_mutex::lock() |
| { |
| __thread_id id = this_thread::get_id(); |
| unique_lock<mutex> lk(__m_); |
| if (id ==__id_) |
| { |
| if (__count_ == numeric_limits<size_t>::max()) |
| __throw_system_error(EAGAIN, "recursive_timed_mutex lock limit reached"); |
| ++__count_; |
| return; |
| } |
| while (__count_ != 0) |
| __cv_.wait(lk); |
| __count_ = 1; |
| __id_ = id; |
| } |
| |
| bool |
| recursive_timed_mutex::try_lock() noexcept |
| { |
| __thread_id id = this_thread::get_id(); |
| unique_lock<mutex> lk(__m_, try_to_lock); |
| if (lk.owns_lock() && (__count_ == 0 || id == __id_)) |
| { |
| if (__count_ == numeric_limits<size_t>::max()) |
| return false; |
| ++__count_; |
| __id_ = id; |
| return true; |
| } |
| return false; |
| } |
| |
| void |
| recursive_timed_mutex::unlock() noexcept |
| { |
| unique_lock<mutex> lk(__m_); |
| if (--__count_ == 0) |
| { |
| __id_.__reset(); |
| lk.unlock(); |
| __cv_.notify_one(); |
| } |
| } |
| |
| #endif // !_LIBCPP_HAS_NO_THREADS |
| |
| // If dispatch_once_f ever handles C++ exceptions, and if one can get to it |
| // without illegal macros (unexpected macros not beginning with _UpperCase or |
| // __lowercase), and if it stops spinning waiting threads, then call_once should |
| // call into dispatch_once_f instead of here. Relevant radar this code needs to |
| // keep in sync with: 7741191. |
| |
| #ifndef _LIBCPP_HAS_NO_THREADS |
| _LIBCPP_SAFE_STATIC static __libcpp_mutex_t mut = _LIBCPP_MUTEX_INITIALIZER; |
| _LIBCPP_SAFE_STATIC static __libcpp_condvar_t cv = _LIBCPP_CONDVAR_INITIALIZER; |
| #endif |
| |
| void __call_once(volatile once_flag::_State_type& flag, void* arg, |
| void (*func)(void*)) |
| { |
| #if defined(_LIBCPP_HAS_NO_THREADS) |
| if (flag == 0) |
| { |
| #ifndef _LIBCPP_NO_EXCEPTIONS |
| try |
| { |
| #endif // _LIBCPP_NO_EXCEPTIONS |
| flag = 1; |
| func(arg); |
| flag = ~once_flag::_State_type(0); |
| #ifndef _LIBCPP_NO_EXCEPTIONS |
| } |
| catch (...) |
| { |
| flag = 0; |
| throw; |
| } |
| #endif // _LIBCPP_NO_EXCEPTIONS |
| } |
| #else // !_LIBCPP_HAS_NO_THREADS |
| __libcpp_mutex_lock(&mut); |
| while (flag == 1) |
| __libcpp_condvar_wait(&cv, &mut); |
| if (flag == 0) |
| { |
| #ifndef _LIBCPP_NO_EXCEPTIONS |
| try |
| { |
| #endif // _LIBCPP_NO_EXCEPTIONS |
| __libcpp_relaxed_store(&flag, once_flag::_State_type(1)); |
| __libcpp_mutex_unlock(&mut); |
| func(arg); |
| __libcpp_mutex_lock(&mut); |
| __libcpp_atomic_store(&flag, ~once_flag::_State_type(0), |
| _AO_Release); |
| __libcpp_mutex_unlock(&mut); |
| __libcpp_condvar_broadcast(&cv); |
| #ifndef _LIBCPP_NO_EXCEPTIONS |
| } |
| catch (...) |
| { |
| __libcpp_mutex_lock(&mut); |
| __libcpp_relaxed_store(&flag, once_flag::_State_type(0)); |
| __libcpp_mutex_unlock(&mut); |
| __libcpp_condvar_broadcast(&cv); |
| throw; |
| } |
| #endif // _LIBCPP_NO_EXCEPTIONS |
| } |
| else |
| __libcpp_mutex_unlock(&mut); |
| #endif // !_LIBCPP_HAS_NO_THREADS |
| } |
| |
| _LIBCPP_END_NAMESPACE_STD |