| #ifndef BOOST_THREAD_CONDITION_VARIABLE_WIN32_HPP |
| #define BOOST_THREAD_CONDITION_VARIABLE_WIN32_HPP |
| // 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) |
| // (C) Copyright 2007-8 Anthony Williams |
| // (C) Copyright 2011-2012 Vicente J. Botet Escriba |
| |
| #include <boost/thread/win32/thread_primitives.hpp> |
| #include <boost/thread/win32/thread_data.hpp> |
| #include <boost/thread/win32/thread_data.hpp> |
| #include <boost/thread/win32/interlocked_read.hpp> |
| #include <boost/thread/cv_status.hpp> |
| #if defined BOOST_THREAD_USES_DATETIME |
| #include <boost/thread/xtime.hpp> |
| #endif |
| #include <boost/thread/mutex.hpp> |
| #include <boost/thread/thread_time.hpp> |
| #include <boost/thread/lock_guard.hpp> |
| #include <boost/thread/lock_types.hpp> |
| #include <boost/thread/detail/platform_time.hpp> |
| |
| #include <boost/assert.hpp> |
| #include <boost/intrusive_ptr.hpp> |
| |
| #ifdef BOOST_THREAD_USES_CHRONO |
| #include <boost/chrono/system_clocks.hpp> |
| #include <boost/chrono/ceil.hpp> |
| #endif |
| |
| #include <limits.h> |
| #include <algorithm> |
| #include <vector> |
| |
| #include <boost/config/abi_prefix.hpp> |
| |
| namespace boost |
| { |
| namespace detail |
| { |
| class basic_cv_list_entry; |
| void intrusive_ptr_add_ref(basic_cv_list_entry * p); |
| void intrusive_ptr_release(basic_cv_list_entry * p); |
| |
| class basic_cv_list_entry |
| { |
| private: |
| detail::win32::handle_manager semaphore; |
| detail::win32::handle_manager wake_sem; |
| long waiters; |
| bool notified; |
| long references; |
| |
| public: |
| BOOST_THREAD_NO_COPYABLE(basic_cv_list_entry) |
| explicit basic_cv_list_entry(detail::win32::handle_manager const& wake_sem_): |
| semaphore(detail::win32::create_anonymous_semaphore(0,LONG_MAX)), |
| wake_sem(wake_sem_.duplicate()), |
| waiters(1),notified(false),references(0) |
| {} |
| |
| static bool no_waiters(boost::intrusive_ptr<basic_cv_list_entry> const& entry) |
| { |
| return !detail::interlocked_read_acquire(&entry->waiters); |
| } |
| |
| void add_waiter() |
| { |
| BOOST_INTERLOCKED_INCREMENT(&waiters); |
| } |
| |
| void remove_waiter() |
| { |
| BOOST_INTERLOCKED_DECREMENT(&waiters); |
| } |
| |
| void release(unsigned count_to_release) |
| { |
| notified=true; |
| winapi::ReleaseSemaphore(semaphore,count_to_release,0); |
| } |
| |
| void release_waiters() |
| { |
| release(detail::interlocked_read_acquire(&waiters)); |
| } |
| |
| bool is_notified() const |
| { |
| return notified; |
| } |
| |
| bool interruptible_wait(detail::internal_platform_timepoint const &timeout) |
| { |
| return this_thread::interruptible_wait(semaphore, timeout); |
| } |
| |
| bool woken() |
| { |
| unsigned long const woken_result=winapi::WaitForSingleObjectEx(wake_sem,0,0); |
| BOOST_ASSERT((woken_result==detail::win32::timeout) || (woken_result==0)); |
| return woken_result==0; |
| } |
| |
| friend void intrusive_ptr_add_ref(basic_cv_list_entry * p); |
| friend void intrusive_ptr_release(basic_cv_list_entry * p); |
| }; |
| |
| inline void intrusive_ptr_add_ref(basic_cv_list_entry * p) |
| { |
| BOOST_INTERLOCKED_INCREMENT(&p->references); |
| } |
| |
| inline void intrusive_ptr_release(basic_cv_list_entry * p) |
| { |
| if(!BOOST_INTERLOCKED_DECREMENT(&p->references)) |
| { |
| delete p; |
| } |
| } |
| |
| class basic_condition_variable |
| { |
| boost::mutex internal_mutex; |
| long total_count; |
| unsigned active_generation_count; |
| |
| typedef basic_cv_list_entry list_entry; |
| |
| typedef boost::intrusive_ptr<list_entry> entry_ptr; |
| typedef std::vector<entry_ptr> generation_list; |
| |
| generation_list generations; |
| detail::win32::handle_manager wake_sem; |
| |
| void wake_waiters(long count_to_wake) |
| { |
| detail::interlocked_write_release(&total_count,total_count-count_to_wake); |
| winapi::ReleaseSemaphore(wake_sem,count_to_wake,0); |
| } |
| |
| template<typename lock_type> |
| struct relocker |
| { |
| BOOST_THREAD_NO_COPYABLE(relocker) |
| lock_type& _lock; |
| bool _unlocked; |
| |
| relocker(lock_type& lock_): |
| _lock(lock_), _unlocked(false) |
| {} |
| void unlock() |
| { |
| if ( ! _unlocked ) |
| { |
| _lock.unlock(); |
| _unlocked=true; |
| } |
| } |
| void lock() |
| { |
| if ( _unlocked ) |
| { |
| _lock.lock(); |
| _unlocked=false; |
| } |
| } |
| ~relocker() BOOST_NOEXCEPT_IF(false) |
| { |
| lock(); |
| } |
| }; |
| |
| |
| entry_ptr get_wait_entry() |
| { |
| boost::lock_guard<boost::mutex> lk(internal_mutex); |
| if(!wake_sem) |
| { |
| wake_sem=detail::win32::create_anonymous_semaphore(0,LONG_MAX); |
| BOOST_ASSERT(wake_sem); |
| } |
| |
| detail::interlocked_write_release(&total_count,total_count+1); |
| if(generations.empty() || generations.back()->is_notified()) |
| { |
| entry_ptr new_entry(new list_entry(wake_sem)); |
| generations.push_back(new_entry); |
| return new_entry; |
| } |
| else |
| { |
| generations.back()->add_waiter(); |
| return generations.back(); |
| } |
| } |
| |
| struct entry_manager |
| { |
| entry_ptr entry; |
| boost::mutex& internal_mutex; |
| |
| |
| BOOST_THREAD_NO_COPYABLE(entry_manager) |
| #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) |
| entry_manager(entry_ptr&& entry_, boost::mutex& mutex_): |
| entry(static_cast< entry_ptr&& >(entry_)), internal_mutex(mutex_) |
| {} |
| #else |
| entry_manager(entry_ptr const& entry_, boost::mutex& mutex_): |
| entry(entry_), internal_mutex(mutex_) |
| {} |
| #endif |
| |
| void remove_waiter_and_reset() |
| { |
| if (entry) { |
| boost::lock_guard<boost::mutex> internal_lock(internal_mutex); |
| entry->remove_waiter(); |
| entry.reset(); |
| } |
| } |
| ~entry_manager() BOOST_NOEXCEPT_IF(false) |
| { |
| remove_waiter_and_reset(); |
| } |
| |
| list_entry* operator->() |
| { |
| return entry.get(); |
| } |
| }; |
| |
| protected: |
| basic_condition_variable(const basic_condition_variable& other); |
| basic_condition_variable& operator=(const basic_condition_variable& other); |
| |
| public: |
| basic_condition_variable(): |
| total_count(0),active_generation_count(0),wake_sem(0) |
| {} |
| |
| ~basic_condition_variable() |
| {} |
| |
| // When this function returns true: |
| // * A notification (or sometimes a spurious OS signal) has been received |
| // * Do not assume that the timeout has not been reached |
| // * Do not assume that the predicate has been changed |
| // |
| // When this function returns false: |
| // * The timeout has been reached |
| // * Do not assume that a notification has not been received |
| // * Do not assume that the predicate has not been changed |
| template<typename lock_type> |
| bool do_wait_until(lock_type& lock, detail::internal_platform_timepoint const &timeout) |
| { |
| relocker<lock_type> locker(lock); |
| entry_manager entry(get_wait_entry(), internal_mutex); |
| locker.unlock(); |
| |
| bool woken=false; |
| while(!woken) |
| { |
| if(!entry->interruptible_wait(timeout)) |
| { |
| return false; |
| } |
| |
| woken=entry->woken(); |
| } |
| // do it here to avoid throwing on the destructor |
| entry.remove_waiter_and_reset(); |
| locker.lock(); |
| return true; |
| } |
| |
| void notify_one() BOOST_NOEXCEPT |
| { |
| if(detail::interlocked_read_acquire(&total_count)) |
| { |
| boost::lock_guard<boost::mutex> internal_lock(internal_mutex); |
| if(!total_count) |
| { |
| return; |
| } |
| wake_waiters(1); |
| |
| for(generation_list::iterator it=generations.begin(), |
| end=generations.end(); |
| it!=end;++it) |
| { |
| (*it)->release(1); |
| } |
| generations.erase(std::remove_if(generations.begin(),generations.end(),&basic_cv_list_entry::no_waiters),generations.end()); |
| } |
| } |
| |
| void notify_all() BOOST_NOEXCEPT |
| { |
| if(detail::interlocked_read_acquire(&total_count)) |
| { |
| boost::lock_guard<boost::mutex> internal_lock(internal_mutex); |
| if(!total_count) |
| { |
| return; |
| } |
| wake_waiters(total_count); |
| for(generation_list::iterator it=generations.begin(), |
| end=generations.end(); |
| it!=end;++it) |
| { |
| (*it)->release_waiters(); |
| } |
| generations.clear(); |
| wake_sem=detail::win32::handle(0); |
| } |
| } |
| |
| }; |
| } |
| |
| class condition_variable: |
| private detail::basic_condition_variable |
| { |
| public: |
| BOOST_THREAD_NO_COPYABLE(condition_variable) |
| condition_variable() |
| {} |
| |
| using detail::basic_condition_variable::do_wait_until; |
| using detail::basic_condition_variable::notify_one; |
| using detail::basic_condition_variable::notify_all; |
| |
| void wait(unique_lock<mutex>& m) |
| { |
| do_wait_until(m, detail::internal_platform_timepoint::getMax()); |
| } |
| |
| template<typename predicate_type> |
| void wait(unique_lock<mutex>& m,predicate_type pred) |
| { |
| while (!pred()) |
| { |
| wait(m); |
| } |
| } |
| |
| #if defined BOOST_THREAD_USES_DATETIME |
| bool timed_wait(unique_lock<mutex>& m,boost::system_time const& abs_time) |
| { |
| // The system time may jump while this function is waiting. To compensate for this and time |
| // out near the correct time, we could call do_wait_until() in a loop with a short timeout |
| // and recheck the time remaining each time through the loop. However, because we can't |
| // check the predicate each time do_wait_until() completes, this introduces the possibility |
| // of not exiting the function when a notification occurs, since do_wait_until() may report |
| // that it timed out even though a notification was received. The best this function can do |
| // is report correctly whether or not it reached the timeout time. |
| const detail::real_platform_timepoint ts(abs_time); |
| const detail::platform_duration d(ts - detail::real_platform_clock::now()); |
| do_wait_until(m, detail::internal_platform_clock::now() + d); |
| return ts > detail::real_platform_clock::now(); |
| } |
| bool timed_wait(unique_lock<mutex>& m,boost::xtime const& abs_time) |
| { |
| return timed_wait(m, system_time(abs_time)); |
| } |
| template<typename duration_type> |
| bool timed_wait(unique_lock<mutex>& m,duration_type const& wait_duration) |
| { |
| if (wait_duration.is_pos_infinity()) |
| { |
| wait(m); |
| return true; |
| } |
| if (wait_duration.is_special()) |
| { |
| return true; |
| } |
| const detail::platform_duration d(wait_duration); |
| return do_wait_until(m, detail::internal_platform_clock::now() + d); |
| } |
| |
| template<typename predicate_type> |
| bool timed_wait(unique_lock<mutex>& m,boost::system_time const& abs_time,predicate_type pred) |
| { |
| // The system time may jump while this function is waiting. To compensate for this |
| // and time out near the correct time, we call do_wait_until() in a loop with a |
| // short timeout and recheck the time remaining each time through the loop. |
| const detail::real_platform_timepoint ts(abs_time); |
| while (!pred()) |
| { |
| detail::platform_duration d(ts - detail::real_platform_clock::now()); |
| if (d <= detail::platform_duration::zero()) break; // timeout occurred |
| d = (std::min)(d, detail::platform_milliseconds(BOOST_THREAD_POLL_INTERVAL_MILLISECONDS)); |
| do_wait_until(m, detail::internal_platform_clock::now() + d); |
| } |
| return pred(); |
| } |
| template<typename predicate_type> |
| bool timed_wait(unique_lock<mutex>& m,boost::xtime const& abs_time,predicate_type pred) |
| { |
| return timed_wait(m, system_time(abs_time), pred); |
| } |
| template<typename duration_type,typename predicate_type> |
| bool timed_wait(unique_lock<mutex>& m,duration_type const& wait_duration,predicate_type pred) |
| { |
| if (wait_duration.is_pos_infinity()) |
| { |
| while (!pred()) |
| { |
| wait(m); |
| } |
| return true; |
| } |
| if (wait_duration.is_special()) |
| { |
| return pred(); |
| } |
| const detail::platform_duration d(wait_duration); |
| const detail::internal_platform_timepoint ts(detail::internal_platform_clock::now() + d); |
| while (!pred()) |
| { |
| if (!do_wait_until(m, ts)) break; // timeout occurred |
| } |
| return pred(); |
| } |
| #endif |
| #ifdef BOOST_THREAD_USES_CHRONO |
| template <class Duration> |
| cv_status |
| wait_until( |
| unique_lock<mutex>& lock, |
| const chrono::time_point<detail::internal_chrono_clock, Duration>& t) |
| { |
| const detail::internal_platform_timepoint ts(t); |
| if (do_wait_until(lock, ts)) return cv_status::no_timeout; |
| else return cv_status::timeout; |
| } |
| |
| template <class Clock, class Duration> |
| cv_status |
| wait_until( |
| unique_lock<mutex>& lock, |
| const chrono::time_point<Clock, Duration>& t) |
| { |
| // The system time may jump while this function is waiting. To compensate for this and time |
| // out near the correct time, we could call do_wait_until() in a loop with a short timeout |
| // and recheck the time remaining each time through the loop. However, because we can't |
| // check the predicate each time do_wait_until() completes, this introduces the possibility |
| // of not exiting the function when a notification occurs, since do_wait_until() may report |
| // that it timed out even though a notification was received. The best this function can do |
| // is report correctly whether or not it reached the timeout time. |
| typedef typename common_type<Duration, typename Clock::duration>::type common_duration; |
| common_duration d(t - Clock::now()); |
| do_wait_until(lock, detail::internal_chrono_clock::now() + d); |
| if (t > Clock::now()) return cv_status::no_timeout; |
| else return cv_status::timeout; |
| } |
| |
| template <class Rep, class Period> |
| cv_status |
| wait_for( |
| unique_lock<mutex>& lock, |
| const chrono::duration<Rep, Period>& d) |
| { |
| return wait_until(lock, chrono::steady_clock::now() + d); |
| } |
| |
| template <class Duration, class Predicate> |
| bool |
| wait_until( |
| unique_lock<mutex>& lock, |
| const chrono::time_point<detail::internal_chrono_clock, Duration>& t, |
| Predicate pred) |
| { |
| const detail::internal_platform_timepoint ts(t); |
| while (!pred()) |
| { |
| if (!do_wait_until(lock, ts)) break; // timeout occurred |
| } |
| return pred(); |
| } |
| |
| template <class Clock, class Duration, class Predicate> |
| bool |
| wait_until( |
| unique_lock<mutex>& lock, |
| const chrono::time_point<Clock, Duration>& t, |
| Predicate pred) |
| { |
| // The system time may jump while this function is waiting. To compensate for this |
| // and time out near the correct time, we call do_wait_until() in a loop with a |
| // short timeout and recheck the time remaining each time through the loop. |
| typedef typename common_type<Duration, typename Clock::duration>::type common_duration; |
| while (!pred()) |
| { |
| common_duration d(t - Clock::now()); |
| if (d <= common_duration::zero()) break; // timeout occurred |
| d = (std::min)(d, common_duration(chrono::milliseconds(BOOST_THREAD_POLL_INTERVAL_MILLISECONDS))); |
| do_wait_until(lock, detail::internal_platform_clock::now() + detail::platform_duration(d)); |
| } |
| return pred(); |
| } |
| |
| template <class Rep, class Period, class Predicate> |
| bool |
| wait_for( |
| unique_lock<mutex>& lock, |
| const chrono::duration<Rep, Period>& d, |
| Predicate pred) |
| { |
| return wait_until(lock, chrono::steady_clock::now() + d, boost::move(pred)); |
| } |
| #endif |
| }; |
| |
| class condition_variable_any: |
| private detail::basic_condition_variable |
| { |
| public: |
| BOOST_THREAD_NO_COPYABLE(condition_variable_any) |
| condition_variable_any() |
| {} |
| |
| using detail::basic_condition_variable::do_wait_until; |
| using detail::basic_condition_variable::notify_one; |
| using detail::basic_condition_variable::notify_all; |
| |
| template<typename lock_type> |
| void wait(lock_type& m) |
| { |
| do_wait_until(m, detail::internal_platform_timepoint::getMax()); |
| } |
| |
| template<typename lock_type,typename predicate_type> |
| void wait(lock_type& m,predicate_type pred) |
| { |
| while (!pred()) |
| { |
| wait(m); |
| } |
| } |
| |
| #if defined BOOST_THREAD_USES_DATETIME |
| template<typename lock_type> |
| bool timed_wait(lock_type& m,boost::system_time const& abs_time) |
| { |
| // The system time may jump while this function is waiting. To compensate for this and time |
| // out near the correct time, we could call do_wait_until() in a loop with a short timeout |
| // and recheck the time remaining each time through the loop. However, because we can't |
| // check the predicate each time do_wait_until() completes, this introduces the possibility |
| // of not exiting the function when a notification occurs, since do_wait_until() may report |
| // that it timed out even though a notification was received. The best this function can do |
| // is report correctly whether or not it reached the timeout time. |
| const detail::real_platform_timepoint ts(abs_time); |
| const detail::platform_duration d(ts - detail::real_platform_clock::now()); |
| do_wait_until(m, detail::internal_platform_clock::now() + d); |
| return ts > detail::real_platform_clock::now(); |
| } |
| |
| template<typename lock_type> |
| bool timed_wait(lock_type& m,boost::xtime const& abs_time) |
| { |
| return timed_wait(m, system_time(abs_time)); |
| } |
| |
| template<typename lock_type,typename duration_type> |
| bool timed_wait(lock_type& m,duration_type const& wait_duration) |
| { |
| if (wait_duration.is_pos_infinity()) |
| { |
| wait(m); |
| return true; |
| } |
| if (wait_duration.is_special()) |
| { |
| return true; |
| } |
| const detail::platform_duration d(wait_duration); |
| return do_wait_until(m, detail::internal_platform_clock::now() + d); |
| } |
| |
| template<typename lock_type,typename predicate_type> |
| bool timed_wait(lock_type& m,boost::system_time const& abs_time,predicate_type pred) |
| { |
| // The system time may jump while this function is waiting. To compensate for this |
| // and time out near the correct time, we call do_wait_until() in a loop with a |
| // short timeout and recheck the time remaining each time through the loop. |
| const detail::real_platform_timepoint ts(abs_time); |
| while (!pred()) |
| { |
| detail::platform_duration d(ts - detail::real_platform_clock::now()); |
| if (d <= detail::platform_duration::zero()) break; // timeout occurred |
| d = (std::min)(d, detail::platform_milliseconds(BOOST_THREAD_POLL_INTERVAL_MILLISECONDS)); |
| do_wait_until(m, detail::internal_platform_clock::now() + d); |
| } |
| return pred(); |
| } |
| |
| template<typename lock_type,typename predicate_type> |
| bool timed_wait(lock_type& m,boost::xtime const& abs_time,predicate_type pred) |
| { |
| return timed_wait(m, system_time(abs_time), pred); |
| } |
| |
| template<typename lock_type,typename duration_type,typename predicate_type> |
| bool timed_wait(lock_type& m,duration_type const& wait_duration,predicate_type pred) |
| { |
| if (wait_duration.is_pos_infinity()) |
| { |
| while (!pred()) |
| { |
| wait(m); |
| } |
| return true; |
| } |
| if (wait_duration.is_special()) |
| { |
| return pred(); |
| } |
| const detail::platform_duration d(wait_duration); |
| const detail::internal_platform_timepoint ts(detail::internal_platform_clock::now() + d); |
| while (!pred()) |
| { |
| if (!do_wait_until(m, ts)) break; // timeout occurred |
| } |
| return pred(); |
| } |
| #endif |
| #ifdef BOOST_THREAD_USES_CHRONO |
| template <class lock_type,class Duration> |
| cv_status |
| wait_until( |
| lock_type& lock, |
| const chrono::time_point<detail::internal_chrono_clock, Duration>& t) |
| { |
| const detail::internal_platform_timepoint ts(t); |
| if (do_wait_until(lock, ts)) return cv_status::no_timeout; |
| else return cv_status::timeout; |
| } |
| |
| template <class lock_type, class Clock, class Duration> |
| cv_status |
| wait_until( |
| lock_type& lock, |
| const chrono::time_point<Clock, Duration>& t) |
| { |
| // The system time may jump while this function is waiting. To compensate for this and time |
| // out near the correct time, we could call do_wait_until() in a loop with a short timeout |
| // and recheck the time remaining each time through the loop. However, because we can't |
| // check the predicate each time do_wait_until() completes, this introduces the possibility |
| // of not exiting the function when a notification occurs, since do_wait_until() may report |
| // that it timed out even though a notification was received. The best this function can do |
| // is report correctly whether or not it reached the timeout time. |
| typedef typename common_type<Duration, typename Clock::duration>::type common_duration; |
| common_duration d(t - Clock::now()); |
| do_wait_until(lock, detail::internal_chrono_clock::now() + d); |
| if (t > Clock::now()) return cv_status::no_timeout; |
| else return cv_status::timeout; |
| } |
| |
| template <class lock_type, class Rep, class Period> |
| cv_status |
| wait_for( |
| lock_type& lock, |
| const chrono::duration<Rep, Period>& d) |
| { |
| return wait_until(lock, chrono::steady_clock::now() + d); |
| } |
| |
| template <class lock_type, class Clock, class Duration, class Predicate> |
| bool |
| wait_until( |
| lock_type& lock, |
| const chrono::time_point<detail::internal_chrono_clock, Duration>& t, |
| Predicate pred) |
| { |
| const detail::internal_platform_timepoint ts(t); |
| while (!pred()) |
| { |
| if (!do_wait_until(lock, ts)) break; // timeout occurred |
| } |
| return pred(); |
| } |
| |
| template <class lock_type, class Clock, class Duration, class Predicate> |
| bool |
| wait_until( |
| lock_type& lock, |
| const chrono::time_point<Clock, Duration>& t, |
| Predicate pred) |
| { |
| // The system time may jump while this function is waiting. To compensate for this |
| // and time out near the correct time, we call do_wait_until() in a loop with a |
| // short timeout and recheck the time remaining each time through the loop. |
| typedef typename common_type<Duration, typename Clock::duration>::type common_duration; |
| while (!pred()) |
| { |
| common_duration d(t - Clock::now()); |
| if (d <= common_duration::zero()) break; // timeout occurred |
| d = (std::min)(d, common_duration(chrono::milliseconds(BOOST_THREAD_POLL_INTERVAL_MILLISECONDS))); |
| do_wait_until(lock, detail::internal_platform_clock::now() + detail::platform_duration(d)); |
| } |
| return pred(); |
| } |
| |
| template <class lock_type, class Rep, class Period, class Predicate> |
| bool |
| wait_for( |
| lock_type& lock, |
| const chrono::duration<Rep, Period>& d, |
| Predicate pred) |
| { |
| return wait_until(lock, chrono::steady_clock::now() + d, boost::move(pred)); |
| } |
| #endif |
| }; |
| |
| BOOST_THREAD_DECL void notify_all_at_thread_exit(condition_variable& cond, unique_lock<mutex> lk); |
| } |
| |
| #include <boost/config/abi_suffix.hpp> |
| |
| #endif |