| #ifndef BOOST_THREAD_V2_SHARED_MUTEX_HPP |
| #define BOOST_THREAD_V2_SHARED_MUTEX_HPP |
| |
| // shared_mutex.hpp |
| // |
| // Copyright Howard Hinnant 2007-2010. |
| // Copyright Vicente J. Botet Escriba 2012. |
| // |
| // Distributed under the Boost Software License, Version 1.0. (See |
| // accompanying file LICENSE_1_0.txt or copy at |
| // http://www.boost.org/LICENSE_1_0.txt) |
| |
| /* |
| <shared_mutex> synopsis |
| |
| namespace boost |
| { |
| namespace thread_v2 |
| { |
| |
| class shared_mutex |
| { |
| public: |
| |
| shared_mutex(); |
| ~shared_mutex(); |
| |
| shared_mutex(const shared_mutex&) = delete; |
| shared_mutex& operator=(const shared_mutex&) = delete; |
| |
| // Exclusive ownership |
| |
| void lock(); |
| bool try_lock(); |
| template <class Rep, class Period> |
| bool try_lock_for(const boost::chrono::duration<Rep, Period>& rel_time); |
| template <class Clock, class Duration> |
| bool |
| try_lock_until( |
| const boost::chrono::time_point<Clock, Duration>& abs_time); |
| void unlock(); |
| |
| // Shared ownership |
| |
| void lock_shared(); |
| bool try_lock_shared(); |
| template <class Rep, class Period> |
| bool |
| try_lock_shared_for(const boost::chrono::duration<Rep, Period>& rel_time); |
| template <class Clock, class Duration> |
| bool |
| try_lock_shared_until( |
| const boost::chrono::time_point<Clock, Duration>& abs_time); |
| void unlock_shared(); |
| }; |
| |
| class upgrade_mutex |
| { |
| public: |
| |
| upgrade_mutex(); |
| ~upgrade_mutex(); |
| |
| upgrade_mutex(const upgrade_mutex&) = delete; |
| upgrade_mutex& operator=(const upgrade_mutex&) = delete; |
| |
| // Exclusive ownership |
| |
| void lock(); |
| bool try_lock(); |
| template <class Rep, class Period> |
| bool try_lock_for(const boost::chrono::duration<Rep, Period>& rel_time); |
| template <class Clock, class Duration> |
| bool |
| try_lock_until( |
| const boost::chrono::time_point<Clock, Duration>& abs_time); |
| void unlock(); |
| |
| // Shared ownership |
| |
| void lock_shared(); |
| bool try_lock_shared(); |
| template <class Rep, class Period> |
| bool |
| try_lock_shared_for(const boost::chrono::duration<Rep, Period>& rel_time); |
| template <class Clock, class Duration> |
| bool |
| try_lock_shared_until( |
| const boost::chrono::time_point<Clock, Duration>& abs_time); |
| void unlock_shared(); |
| |
| // Upgrade ownership |
| |
| void lock_upgrade(); |
| bool try_lock_upgrade(); |
| template <class Rep, class Period> |
| bool |
| try_lock_upgrade_for( |
| const boost::chrono::duration<Rep, Period>& rel_time); |
| template <class Clock, class Duration> |
| bool |
| try_lock_upgrade_until( |
| const boost::chrono::time_point<Clock, Duration>& abs_time); |
| void unlock_upgrade(); |
| |
| // Shared <-> Exclusive |
| |
| bool try_unlock_shared_and_lock(); |
| template <class Rep, class Period> |
| bool |
| try_unlock_shared_and_lock_for( |
| const boost::chrono::duration<Rep, Period>& rel_time); |
| template <class Clock, class Duration> |
| bool |
| try_unlock_shared_and_lock_until( |
| const boost::chrono::time_point<Clock, Duration>& abs_time); |
| void unlock_and_lock_shared(); |
| |
| // Shared <-> Upgrade |
| |
| bool try_unlock_shared_and_lock_upgrade(); |
| template <class Rep, class Period> |
| bool |
| try_unlock_shared_and_lock_upgrade_for( |
| const boost::chrono::duration<Rep, Period>& rel_time); |
| template <class Clock, class Duration> |
| bool |
| try_unlock_shared_and_lock_upgrade_until( |
| const boost::chrono::time_point<Clock, Duration>& abs_time); |
| void unlock_upgrade_and_lock_shared(); |
| |
| // Upgrade <-> Exclusive |
| |
| void unlock_upgrade_and_lock(); |
| bool try_unlock_upgrade_and_lock(); |
| template <class Rep, class Period> |
| bool |
| try_unlock_upgrade_and_lock_for( |
| const boost::chrono::duration<Rep, Period>& rel_time); |
| template <class Clock, class Duration> |
| bool |
| try_unlock_upgrade_and_lock_until( |
| const boost::chrono::time_point<Clock, Duration>& abs_time); |
| void unlock_and_lock_upgrade(); |
| }; |
| |
| } // thread_v2 |
| } // boost |
| |
| */ |
| |
| #include <boost/thread/detail/config.hpp> |
| #include <boost/thread/mutex.hpp> |
| #include <boost/thread/condition_variable.hpp> |
| #include <boost/thread/mutex.hpp> |
| #ifdef BOOST_THREAD_USES_CHRONO |
| #include <boost/chrono.hpp> |
| #endif |
| #include <climits> |
| #include <boost/system/system_error.hpp> |
| #include <boost/bind/bind.hpp> |
| |
| namespace boost { |
| namespace thread_v2 { |
| |
| class shared_mutex |
| { |
| typedef boost::mutex mutex_t; |
| typedef boost::condition_variable cond_t; |
| typedef unsigned count_t; |
| |
| mutex_t mut_; |
| cond_t gate1_; |
| // the gate2_ condition variable is only used by functions that |
| // have taken write_entered_ but are waiting for no_readers() |
| cond_t gate2_; |
| count_t state_; |
| |
| static const count_t write_entered_ = 1U << (sizeof(count_t)*CHAR_BIT - 1); |
| static const count_t n_readers_ = ~write_entered_; |
| |
| bool no_writer() const |
| { |
| return (state_ & write_entered_) == 0; |
| } |
| |
| bool one_writer() const |
| { |
| return (state_ & write_entered_) != 0; |
| } |
| |
| bool no_writer_no_readers() const |
| { |
| //return (state_ & write_entered_) == 0 && |
| // (state_ & n_readers_) == 0; |
| return state_ == 0; |
| } |
| |
| bool no_writer_no_max_readers() const |
| { |
| return (state_ & write_entered_) == 0 && |
| (state_ & n_readers_) != n_readers_; |
| } |
| |
| bool no_readers() const |
| { |
| return (state_ & n_readers_) == 0; |
| } |
| |
| bool one_or_more_readers() const |
| { |
| return (state_ & n_readers_) > 0; |
| } |
| |
| shared_mutex(shared_mutex const&); |
| shared_mutex& operator=(shared_mutex const&); |
| |
| public: |
| shared_mutex(); |
| ~shared_mutex(); |
| |
| // Exclusive ownership |
| |
| void lock(); |
| bool try_lock(); |
| #ifdef BOOST_THREAD_USES_CHRONO |
| template <class Rep, class Period> |
| bool try_lock_for(const boost::chrono::duration<Rep, Period>& rel_time) |
| { |
| return try_lock_until(chrono::steady_clock::now() + rel_time); |
| } |
| template <class Clock, class Duration> |
| bool try_lock_until( |
| const boost::chrono::time_point<Clock, Duration>& abs_time); |
| #endif |
| #if defined BOOST_THREAD_USES_DATETIME |
| template<typename T> |
| bool timed_lock(T const & abs_or_rel_time); |
| #endif |
| void unlock(); |
| |
| // Shared ownership |
| |
| void lock_shared(); |
| bool try_lock_shared(); |
| #ifdef BOOST_THREAD_USES_CHRONO |
| template <class Rep, class Period> |
| bool try_lock_shared_for(const boost::chrono::duration<Rep, Period>& rel_time) |
| { |
| return try_lock_shared_until(chrono::steady_clock::now() + rel_time); |
| } |
| template <class Clock, class Duration> |
| bool try_lock_shared_until( |
| const boost::chrono::time_point<Clock, Duration>& abs_time); |
| #endif |
| #if defined BOOST_THREAD_USES_DATETIME |
| template<typename T> |
| bool timed_lock_shared(T const & abs_or_rel_time); |
| #endif |
| void unlock_shared(); |
| }; |
| |
| inline shared_mutex::shared_mutex() |
| : state_(0) |
| { |
| } |
| |
| inline shared_mutex::~shared_mutex() |
| { |
| boost::lock_guard<mutex_t> _(mut_); |
| } |
| |
| // Exclusive ownership |
| |
| inline void shared_mutex::lock() |
| { |
| boost::unique_lock<mutex_t> lk(mut_); |
| gate1_.wait(lk, boost::bind(&shared_mutex::no_writer, boost::ref(*this))); |
| state_ |= write_entered_; |
| gate2_.wait(lk, boost::bind(&shared_mutex::no_readers, boost::ref(*this))); |
| } |
| |
| inline bool shared_mutex::try_lock() |
| { |
| boost::unique_lock<mutex_t> lk(mut_); |
| if (!no_writer_no_readers()) |
| { |
| return false; |
| } |
| state_ = write_entered_; |
| return true; |
| } |
| |
| #ifdef BOOST_THREAD_USES_CHRONO |
| template <class Clock, class Duration> |
| bool shared_mutex::try_lock_until( |
| const boost::chrono::time_point<Clock, Duration>& abs_time) |
| { |
| boost::unique_lock<mutex_t> lk(mut_); |
| if (!gate1_.wait_until(lk, abs_time, boost::bind( |
| &shared_mutex::no_writer, boost::ref(*this)))) |
| { |
| return false; |
| } |
| state_ |= write_entered_; |
| if (!gate2_.wait_until(lk, abs_time, boost::bind( |
| &shared_mutex::no_readers, boost::ref(*this)))) |
| { |
| state_ &= ~write_entered_; |
| return false; |
| } |
| return true; |
| } |
| #endif |
| |
| #if defined BOOST_THREAD_USES_DATETIME |
| template<typename T> |
| bool shared_mutex::timed_lock(T const & abs_or_rel_time) |
| { |
| boost::unique_lock<mutex_t> lk(mut_); |
| if (!gate1_.timed_wait(lk, abs_or_rel_time, boost::bind( |
| &shared_mutex::no_writer, boost::ref(*this)))) |
| { |
| return false; |
| } |
| state_ |= write_entered_; |
| if (!gate2_.timed_wait(lk, abs_or_rel_time, boost::bind( |
| &shared_mutex::no_readers, boost::ref(*this)))) |
| { |
| state_ &= ~write_entered_; |
| return false; |
| } |
| return true; |
| } |
| #endif |
| |
| inline void shared_mutex::unlock() |
| { |
| boost::lock_guard<mutex_t> _(mut_); |
| BOOST_ASSERT(one_writer()); |
| BOOST_ASSERT(no_readers()); |
| state_ = 0; |
| // notify all since multiple *lock_shared*() calls may be able |
| // to proceed in response to this notification |
| gate1_.notify_all(); |
| } |
| |
| // Shared ownership |
| |
| inline void shared_mutex::lock_shared() |
| { |
| boost::unique_lock<mutex_t> lk(mut_); |
| gate1_.wait(lk, boost::bind(&shared_mutex::no_writer_no_max_readers, boost::ref(*this))); |
| count_t num_readers = (state_ & n_readers_) + 1; |
| state_ &= ~n_readers_; |
| state_ |= num_readers; |
| } |
| |
| inline bool shared_mutex::try_lock_shared() |
| { |
| boost::unique_lock<mutex_t> lk(mut_); |
| if (!no_writer_no_max_readers()) |
| { |
| return false; |
| } |
| count_t num_readers = (state_ & n_readers_) + 1; |
| state_ &= ~n_readers_; |
| state_ |= num_readers; |
| return true; |
| } |
| |
| #ifdef BOOST_THREAD_USES_CHRONO |
| template <class Clock, class Duration> |
| bool shared_mutex::try_lock_shared_until( |
| const boost::chrono::time_point<Clock, Duration>& abs_time) |
| { |
| boost::unique_lock<mutex_t> lk(mut_); |
| if (!gate1_.wait_until(lk, abs_time, boost::bind( |
| &shared_mutex::no_writer_no_max_readers, boost::ref(*this)))) |
| { |
| return false; |
| } |
| count_t num_readers = (state_ & n_readers_) + 1; |
| state_ &= ~n_readers_; |
| state_ |= num_readers; |
| return true; |
| } |
| #endif |
| |
| #if defined BOOST_THREAD_USES_DATETIME |
| template<typename T> |
| bool shared_mutex::timed_lock_shared(T const & abs_or_rel_time) |
| { |
| boost::unique_lock<mutex_t> lk(mut_); |
| if (!gate1_.timed_wait(lk, abs_or_rel_time, boost::bind( |
| &shared_mutex::no_writer_no_max_readers, boost::ref(*this)))) |
| { |
| return false; |
| } |
| count_t num_readers = (state_ & n_readers_) + 1; |
| state_ &= ~n_readers_; |
| state_ |= num_readers; |
| return true; |
| } |
| #endif |
| |
| inline void shared_mutex::unlock_shared() |
| { |
| boost::lock_guard<mutex_t> _(mut_); |
| BOOST_ASSERT(one_or_more_readers()); |
| count_t num_readers = (state_ & n_readers_) - 1; |
| state_ &= ~n_readers_; |
| state_ |= num_readers; |
| if (no_writer()) |
| { |
| if (num_readers == n_readers_ - 1) |
| gate1_.notify_one(); |
| } |
| else |
| { |
| if (num_readers == 0) |
| gate2_.notify_one(); |
| } |
| } |
| |
| } // thread_v2 |
| } // boost |
| |
| namespace boost { |
| namespace thread_v2 { |
| |
| class upgrade_mutex |
| { |
| typedef boost::mutex mutex_t; |
| typedef boost::condition_variable cond_t; |
| typedef unsigned count_t; |
| |
| mutex_t mut_; |
| cond_t gate1_; |
| // the gate2_ condition variable is only used by functions that |
| // have taken write_entered_ but are waiting for no_readers() |
| cond_t gate2_; |
| count_t state_; |
| |
| static const unsigned write_entered_ = 1U << (sizeof(count_t)*CHAR_BIT - 1); |
| static const unsigned upgradable_entered_ = write_entered_ >> 1; |
| static const unsigned n_readers_ = ~(write_entered_ | upgradable_entered_); |
| |
| bool no_writer() const |
| { |
| return (state_ & write_entered_) == 0; |
| } |
| |
| bool one_writer() const |
| { |
| return (state_ & write_entered_) != 0; |
| } |
| |
| bool no_writer_no_max_readers() const |
| { |
| return (state_ & write_entered_) == 0 && |
| (state_ & n_readers_) != n_readers_; |
| } |
| |
| bool no_writer_no_upgrader() const |
| { |
| return (state_ & (write_entered_ | upgradable_entered_)) == 0; |
| } |
| |
| bool no_writer_no_upgrader_no_readers() const |
| { |
| //return (state_ & (write_entered_ | upgradable_entered_)) == 0 && |
| // (state_ & n_readers_) == 0; |
| return state_ == 0; |
| } |
| |
| bool no_writer_no_upgrader_one_reader() const |
| { |
| //return (state_ & (write_entered_ | upgradable_entered_)) == 0 && |
| // (state_ & n_readers_) == 1; |
| return state_ == 1; |
| } |
| |
| bool no_writer_no_upgrader_no_max_readers() const |
| { |
| return (state_ & (write_entered_ | upgradable_entered_)) == 0 && |
| (state_ & n_readers_) != n_readers_; |
| } |
| |
| bool no_upgrader() const |
| { |
| return (state_ & upgradable_entered_) == 0; |
| } |
| |
| bool one_upgrader() const |
| { |
| return (state_ & upgradable_entered_) != 0; |
| } |
| |
| bool no_readers() const |
| { |
| return (state_ & n_readers_) == 0; |
| } |
| |
| bool one_reader() const |
| { |
| return (state_ & n_readers_) == 1; |
| } |
| |
| bool one_or_more_readers() const |
| { |
| return (state_ & n_readers_) > 0; |
| } |
| |
| upgrade_mutex(const upgrade_mutex&); |
| upgrade_mutex& operator=(const upgrade_mutex&); |
| |
| public: |
| upgrade_mutex(); |
| ~upgrade_mutex(); |
| |
| // Exclusive ownership |
| |
| void lock(); |
| bool try_lock(); |
| #ifdef BOOST_THREAD_USES_CHRONO |
| template <class Rep, class Period> |
| bool try_lock_for(const boost::chrono::duration<Rep, Period>& rel_time) |
| { |
| return try_lock_until(chrono::steady_clock::now() + rel_time); |
| } |
| template <class Clock, class Duration> |
| bool try_lock_until( |
| const boost::chrono::time_point<Clock, Duration>& abs_time); |
| #endif |
| #if defined BOOST_THREAD_USES_DATETIME |
| template<typename T> |
| bool timed_lock(T const & abs_or_rel_time); |
| #endif |
| void unlock(); |
| |
| // Shared ownership |
| |
| void lock_shared(); |
| bool try_lock_shared(); |
| #ifdef BOOST_THREAD_USES_CHRONO |
| template <class Rep, class Period> |
| bool try_lock_shared_for(const boost::chrono::duration<Rep, Period>& rel_time) |
| { |
| return try_lock_shared_until(chrono::steady_clock::now() + rel_time); |
| } |
| template <class Clock, class Duration> |
| bool try_lock_shared_until( |
| const boost::chrono::time_point<Clock, Duration>& abs_time); |
| #endif |
| #if defined BOOST_THREAD_USES_DATETIME |
| template<typename T> |
| bool timed_lock_shared(T const & abs_or_rel_time); |
| #endif |
| void unlock_shared(); |
| |
| // Upgrade ownership |
| |
| void lock_upgrade(); |
| bool try_lock_upgrade(); |
| #ifdef BOOST_THREAD_USES_CHRONO |
| template <class Rep, class Period> |
| bool try_lock_upgrade_for( |
| const boost::chrono::duration<Rep, Period>& rel_time) |
| { |
| return try_lock_upgrade_until(chrono::steady_clock::now() + rel_time); |
| } |
| template <class Clock, class Duration> |
| bool try_lock_upgrade_until( |
| const boost::chrono::time_point<Clock, Duration>& abs_time); |
| #endif |
| #if defined BOOST_THREAD_USES_DATETIME |
| template<typename T> |
| bool timed_lock_upgrade(T const & abs_or_rel_time); |
| #endif |
| void unlock_upgrade(); |
| |
| // Shared <-> Exclusive |
| |
| #ifdef BOOST_THREAD_PROVIDES_SHARED_MUTEX_UPWARDS_CONVERSIONS |
| //bool unlock_shared_and_lock(); // can cause a deadlock if used |
| bool try_unlock_shared_and_lock(); |
| #ifdef BOOST_THREAD_USES_CHRONO |
| template <class Rep, class Period> |
| bool try_unlock_shared_and_lock_for( |
| const boost::chrono::duration<Rep, Period>& rel_time) |
| { |
| return try_unlock_shared_and_lock_until(chrono::steady_clock::now() + rel_time); |
| } |
| template <class Clock, class Duration> |
| bool try_unlock_shared_and_lock_until( |
| const boost::chrono::time_point<Clock, Duration>& abs_time); |
| #endif |
| #endif |
| void unlock_and_lock_shared(); |
| |
| // Shared <-> Upgrade |
| |
| #ifdef BOOST_THREAD_PROVIDES_SHARED_MUTEX_UPWARDS_CONVERSIONS |
| //bool unlock_shared_and_lock_upgrade(); // can cause a deadlock if used |
| bool try_unlock_shared_and_lock_upgrade(); |
| #ifdef BOOST_THREAD_USES_CHRONO |
| template <class Rep, class Period> |
| bool try_unlock_shared_and_lock_upgrade_for( |
| const boost::chrono::duration<Rep, Period>& rel_time) |
| { |
| return try_unlock_shared_and_lock_upgrade_until(chrono::steady_clock::now() + rel_time); |
| } |
| template <class Clock, class Duration> |
| bool try_unlock_shared_and_lock_upgrade_until( |
| const boost::chrono::time_point<Clock, Duration>& abs_time); |
| #endif |
| #endif |
| void unlock_upgrade_and_lock_shared(); |
| |
| // Upgrade <-> Exclusive |
| |
| void unlock_upgrade_and_lock(); |
| bool try_unlock_upgrade_and_lock(); |
| #ifdef BOOST_THREAD_USES_CHRONO |
| template <class Rep, class Period> |
| bool try_unlock_upgrade_and_lock_for( |
| const boost::chrono::duration<Rep, Period>& rel_time) |
| { |
| return try_unlock_upgrade_and_lock_until(chrono::steady_clock::now() + rel_time); |
| } |
| template <class Clock, class Duration> |
| bool try_unlock_upgrade_and_lock_until( |
| const boost::chrono::time_point<Clock, Duration>& abs_time); |
| #endif |
| void unlock_and_lock_upgrade(); |
| }; |
| |
| inline upgrade_mutex::upgrade_mutex() |
| : gate1_(), |
| gate2_(), |
| state_(0) |
| { |
| } |
| |
| inline upgrade_mutex::~upgrade_mutex() |
| { |
| boost::lock_guard<mutex_t> _(mut_); |
| } |
| |
| // Exclusive ownership |
| |
| inline void upgrade_mutex::lock() |
| { |
| boost::unique_lock<mutex_t> lk(mut_); |
| gate1_.wait(lk, boost::bind(&upgrade_mutex::no_writer_no_upgrader, boost::ref(*this))); |
| state_ |= write_entered_; |
| gate2_.wait(lk, boost::bind(&upgrade_mutex::no_readers, boost::ref(*this))); |
| } |
| |
| inline bool upgrade_mutex::try_lock() |
| { |
| boost::unique_lock<mutex_t> lk(mut_); |
| if (!no_writer_no_upgrader_no_readers()) |
| { |
| return false; |
| } |
| state_ = write_entered_; |
| return true; |
| } |
| |
| #ifdef BOOST_THREAD_USES_CHRONO |
| template <class Clock, class Duration> |
| bool upgrade_mutex::try_lock_until( |
| const boost::chrono::time_point<Clock, Duration>& abs_time) |
| { |
| boost::unique_lock<mutex_t> lk(mut_); |
| if (!gate1_.wait_until(lk, abs_time, boost::bind( |
| &upgrade_mutex::no_writer_no_upgrader, boost::ref(*this)))) |
| { |
| return false; |
| } |
| state_ |= write_entered_; |
| if (!gate2_.wait_until(lk, abs_time, boost::bind( |
| &upgrade_mutex::no_readers, boost::ref(*this)))) |
| { |
| state_ &= ~write_entered_; |
| return false; |
| } |
| return true; |
| } |
| #endif |
| |
| #if defined BOOST_THREAD_USES_DATETIME |
| template<typename T> |
| bool upgrade_mutex::timed_lock(T const & abs_or_rel_time) |
| { |
| boost::unique_lock<mutex_t> lk(mut_); |
| if (!gate1_.timed_wait(lk, abs_or_rel_time, boost::bind( |
| &upgrade_mutex::no_writer_no_upgrader, boost::ref(*this)))) |
| { |
| return false; |
| } |
| state_ |= write_entered_; |
| if (!gate2_.timed_wait(lk, abs_or_rel_time, boost::bind( |
| &upgrade_mutex::no_readers, boost::ref(*this)))) |
| { |
| state_ &= ~write_entered_; |
| return false; |
| } |
| return true; |
| } |
| #endif |
| |
| inline void upgrade_mutex::unlock() |
| { |
| boost::lock_guard<mutex_t> _(mut_); |
| BOOST_ASSERT(one_writer()); |
| BOOST_ASSERT(no_upgrader()); |
| BOOST_ASSERT(no_readers()); |
| state_ = 0; |
| // notify all since multiple *lock_shared*() calls and a *lock_upgrade*() |
| // call may be able to proceed in response to this notification |
| gate1_.notify_all(); |
| } |
| |
| // Shared ownership |
| |
| inline void upgrade_mutex::lock_shared() |
| { |
| boost::unique_lock<mutex_t> lk(mut_); |
| gate1_.wait(lk, boost::bind(&upgrade_mutex::no_writer_no_max_readers, boost::ref(*this))); |
| count_t num_readers = (state_ & n_readers_) + 1; |
| state_ &= ~n_readers_; |
| state_ |= num_readers; |
| } |
| |
| inline bool upgrade_mutex::try_lock_shared() |
| { |
| boost::unique_lock<mutex_t> lk(mut_); |
| if (!no_writer_no_max_readers()) |
| { |
| return false; |
| } |
| count_t num_readers = (state_ & n_readers_) + 1; |
| state_ &= ~n_readers_; |
| state_ |= num_readers; |
| return true; |
| } |
| |
| #ifdef BOOST_THREAD_USES_CHRONO |
| template <class Clock, class Duration> |
| bool upgrade_mutex::try_lock_shared_until( |
| const boost::chrono::time_point<Clock, Duration>& abs_time) |
| { |
| boost::unique_lock<mutex_t> lk(mut_); |
| if (!gate1_.wait_until(lk, abs_time, boost::bind( |
| &upgrade_mutex::no_writer_no_max_readers, boost::ref(*this)))) |
| { |
| return false; |
| } |
| count_t num_readers = (state_ & n_readers_) + 1; |
| state_ &= ~n_readers_; |
| state_ |= num_readers; |
| return true; |
| } |
| #endif |
| |
| #if defined BOOST_THREAD_USES_DATETIME |
| template<typename T> |
| bool upgrade_mutex::timed_lock_shared(T const & abs_or_rel_time) |
| { |
| boost::unique_lock<mutex_t> lk(mut_); |
| if (!gate1_.timed_wait(lk, abs_or_rel_time, boost::bind( |
| &upgrade_mutex::no_writer_no_max_readers, boost::ref(*this)))) |
| { |
| return false; |
| } |
| count_t num_readers = (state_ & n_readers_) + 1; |
| state_ &= ~n_readers_; |
| state_ |= num_readers; |
| return true; |
| } |
| #endif |
| |
| inline void upgrade_mutex::unlock_shared() |
| { |
| boost::lock_guard<mutex_t> _(mut_); |
| BOOST_ASSERT(one_or_more_readers()); |
| count_t num_readers = (state_ & n_readers_) - 1; |
| state_ &= ~n_readers_; |
| state_ |= num_readers; |
| if (no_writer()) |
| { |
| if (num_readers == n_readers_ - 1) |
| gate1_.notify_one(); |
| } |
| else |
| { |
| if (num_readers == 0) |
| gate2_.notify_one(); |
| } |
| } |
| |
| // Upgrade ownership |
| |
| inline void upgrade_mutex::lock_upgrade() |
| { |
| boost::unique_lock<mutex_t> lk(mut_); |
| gate1_.wait(lk, boost::bind(&upgrade_mutex::no_writer_no_upgrader_no_max_readers, boost::ref(*this))); |
| count_t num_readers = (state_ & n_readers_) + 1; |
| state_ &= ~n_readers_; |
| state_ |= upgradable_entered_ | num_readers; |
| } |
| |
| inline bool upgrade_mutex::try_lock_upgrade() |
| { |
| boost::unique_lock<mutex_t> lk(mut_); |
| if (!no_writer_no_upgrader_no_max_readers()) |
| { |
| return false; |
| } |
| count_t num_readers = (state_ & n_readers_) + 1; |
| state_ &= ~n_readers_; |
| state_ |= upgradable_entered_ | num_readers; |
| return true; |
| } |
| |
| #ifdef BOOST_THREAD_USES_CHRONO |
| template <class Clock, class Duration> |
| bool upgrade_mutex::try_lock_upgrade_until( |
| const boost::chrono::time_point<Clock, Duration>& abs_time) |
| { |
| boost::unique_lock<mutex_t> lk(mut_); |
| if (!gate1_.wait_until(lk, abs_time, boost::bind( |
| &upgrade_mutex::no_writer_no_upgrader_no_max_readers, boost::ref(*this)))) |
| { |
| return false; |
| } |
| count_t num_readers = (state_ & n_readers_) + 1; |
| state_ &= ~n_readers_; |
| state_ |= upgradable_entered_ | num_readers; |
| return true; |
| } |
| #endif |
| |
| #if defined BOOST_THREAD_USES_DATETIME |
| template<typename T> |
| bool upgrade_mutex::timed_lock_upgrade(T const & abs_or_rel_time) |
| { |
| boost::unique_lock<mutex_t> lk(mut_); |
| if (!gate1_.timed_wait(lk, abs_or_rel_time, boost::bind( |
| &upgrade_mutex::no_writer_no_upgrader_no_max_readers, boost::ref(*this)))) |
| { |
| return false; |
| } |
| count_t num_readers = (state_ & n_readers_) + 1; |
| state_ &= ~n_readers_; |
| state_ |= upgradable_entered_ | num_readers; |
| return true; |
| } |
| #endif |
| |
| inline void upgrade_mutex::unlock_upgrade() |
| { |
| boost::lock_guard<mutex_t> _(mut_); |
| BOOST_ASSERT(no_writer()); |
| BOOST_ASSERT(one_upgrader()); |
| BOOST_ASSERT(one_or_more_readers()); |
| count_t num_readers = (state_ & n_readers_) - 1; |
| state_ &= ~(upgradable_entered_ | n_readers_); |
| state_ |= num_readers; |
| // notify all since both a *lock*() and a *lock_shared*() call |
| // may be able to proceed in response to this notification |
| gate1_.notify_all(); |
| } |
| |
| // Shared <-> Exclusive |
| |
| #ifdef BOOST_THREAD_PROVIDES_SHARED_MUTEX_UPWARDS_CONVERSIONS |
| inline bool upgrade_mutex::try_unlock_shared_and_lock() |
| { |
| boost::unique_lock<mutex_t> lk(mut_); |
| BOOST_ASSERT(one_or_more_readers()); |
| if (!no_writer_no_upgrader_one_reader()) |
| { |
| return false; |
| } |
| state_ = write_entered_; |
| return true; |
| } |
| |
| #ifdef BOOST_THREAD_USES_CHRONO |
| template <class Clock, class Duration> |
| bool upgrade_mutex::try_unlock_shared_and_lock_until( |
| const boost::chrono::time_point<Clock, Duration>& abs_time) |
| { |
| boost::unique_lock<mutex_t> lk(mut_); |
| BOOST_ASSERT(one_or_more_readers()); |
| if (!gate1_.wait_until(lk, abs_time, boost::bind( |
| &upgrade_mutex::no_writer_no_upgrader, boost::ref(*this)))) |
| { |
| return false; |
| } |
| count_t num_readers = (state_ & n_readers_) - 1; |
| state_ &= ~n_readers_; |
| state_ |= (write_entered_ | num_readers); |
| if (!gate2_.wait_until(lk, abs_time, boost::bind( |
| &upgrade_mutex::no_readers, boost::ref(*this)))) |
| { |
| ++num_readers; |
| state_ &= ~(write_entered_ | n_readers_); |
| state_ |= num_readers; |
| return false; |
| } |
| return true; |
| } |
| #endif |
| #endif |
| |
| inline void upgrade_mutex::unlock_and_lock_shared() |
| { |
| boost::lock_guard<mutex_t> _(mut_); |
| BOOST_ASSERT(one_writer()); |
| BOOST_ASSERT(no_upgrader()); |
| BOOST_ASSERT(no_readers()); |
| state_ = 1; |
| // notify all since multiple *lock_shared*() calls and a *lock_upgrade*() |
| // call may be able to proceed in response to this notification |
| gate1_.notify_all(); |
| } |
| |
| // Shared <-> Upgrade |
| |
| #ifdef BOOST_THREAD_PROVIDES_SHARED_MUTEX_UPWARDS_CONVERSIONS |
| inline bool upgrade_mutex::try_unlock_shared_and_lock_upgrade() |
| { |
| boost::unique_lock<mutex_t> lk(mut_); |
| BOOST_ASSERT(one_or_more_readers()); |
| if (!no_writer_no_upgrader()) |
| { |
| return false; |
| } |
| state_ |= upgradable_entered_; |
| return true; |
| } |
| |
| #ifdef BOOST_THREAD_USES_CHRONO |
| template <class Clock, class Duration> |
| bool upgrade_mutex::try_unlock_shared_and_lock_upgrade_until( |
| const boost::chrono::time_point<Clock, Duration>& abs_time) |
| { |
| boost::unique_lock<mutex_t> lk(mut_); |
| BOOST_ASSERT(one_or_more_readers()); |
| if (!gate1_.wait_until(lk, abs_time, boost::bind( |
| &upgrade_mutex::no_writer_no_upgrader, boost::ref(*this)))) |
| { |
| return false; |
| } |
| state_ |= upgradable_entered_; |
| return true; |
| } |
| #endif |
| #endif |
| |
| inline void upgrade_mutex::unlock_upgrade_and_lock_shared() |
| { |
| boost::lock_guard<mutex_t> _(mut_); |
| BOOST_ASSERT(no_writer()); |
| BOOST_ASSERT(one_upgrader()); |
| BOOST_ASSERT(one_or_more_readers()); |
| state_ &= ~upgradable_entered_; |
| // notify all since only one *lock*() or *lock_upgrade*() call can win and |
| // proceed in response to this notification, but a *lock_shared*() call may |
| // also be waiting and could steal the notification |
| gate1_.notify_all(); |
| } |
| |
| // Upgrade <-> Exclusive |
| |
| inline void upgrade_mutex::unlock_upgrade_and_lock() |
| { |
| boost::unique_lock<mutex_t> lk(mut_); |
| BOOST_ASSERT(no_writer()); |
| BOOST_ASSERT(one_upgrader()); |
| BOOST_ASSERT(one_or_more_readers()); |
| count_t num_readers = (state_ & n_readers_) - 1; |
| state_ &= ~(upgradable_entered_ | n_readers_); |
| state_ |= write_entered_ | num_readers; |
| gate2_.wait(lk, boost::bind(&upgrade_mutex::no_readers, boost::ref(*this))); |
| } |
| |
| inline bool upgrade_mutex::try_unlock_upgrade_and_lock() |
| { |
| boost::unique_lock<mutex_t> lk(mut_); |
| BOOST_ASSERT(no_writer()); |
| BOOST_ASSERT(one_upgrader()); |
| BOOST_ASSERT(one_or_more_readers()); |
| if (!one_reader()) |
| { |
| return false; |
| } |
| state_ = write_entered_; |
| return true; |
| } |
| |
| #ifdef BOOST_THREAD_USES_CHRONO |
| template <class Clock, class Duration> |
| bool upgrade_mutex::try_unlock_upgrade_and_lock_until( |
| const boost::chrono::time_point<Clock, Duration>& abs_time) |
| { |
| boost::unique_lock<mutex_t> lk(mut_); |
| BOOST_ASSERT(no_writer()); |
| BOOST_ASSERT(one_upgrader()); |
| BOOST_ASSERT(one_or_more_readers()); |
| count_t num_readers = (state_ & n_readers_) - 1; |
| state_ &= ~(upgradable_entered_ | n_readers_); |
| state_ |= (write_entered_ | num_readers); |
| if (!gate2_.wait_until(lk, abs_time, boost::bind( |
| &upgrade_mutex::no_readers, boost::ref(*this)))) |
| { |
| ++num_readers; |
| state_ &= ~(write_entered_ | n_readers_); |
| state_ |= (upgradable_entered_ | num_readers); |
| return false; |
| } |
| return true; |
| } |
| #endif |
| |
| inline void upgrade_mutex::unlock_and_lock_upgrade() |
| { |
| boost::lock_guard<mutex_t> _(mut_); |
| BOOST_ASSERT(one_writer()); |
| BOOST_ASSERT(no_upgrader()); |
| BOOST_ASSERT(no_readers()); |
| state_ = upgradable_entered_ | 1; |
| // notify all since multiple *lock_shared*() calls may be able |
| // to proceed in response to this notification |
| gate1_.notify_all(); |
| } |
| |
| } // thread_v2 |
| } // boost |
| |
| namespace boost { |
| //using thread_v2::shared_mutex; |
| using thread_v2::upgrade_mutex; |
| typedef thread_v2::upgrade_mutex shared_mutex; |
| } |
| |
| #endif |
