#ifndef BOOST_THREAD_CONDITION_VARIABLE_PTHREAD_HPP #define BOOST_THREAD_CONDITION_VARIABLE_PTHREAD_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-10 Anthony Williams // (C) Copyright 2011-2012 Vicente J. Botet Escriba #include <boost/thread/pthread/timespec.hpp> #include <boost/thread/pthread/pthread_mutex_scoped_lock.hpp> #if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS #include <boost/thread/pthread/thread_data.hpp> #endif #include <boost/thread/pthread/condition_variable_fwd.hpp> #ifdef BOOST_THREAD_USES_CHRONO #include <boost/chrono/system_clocks.hpp> #include <boost/chrono/ceil.hpp> #endif #include <boost/thread/detail/delete.hpp> #include <boost/config/abi_prefix.hpp> namespace boost { #if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS namespace this_thread { void BOOST_THREAD_DECL interruption_point(); } #endif namespace thread_cv_detail { template<typename MutexType> struct lock_on_exit { MutexType* m; lock_on_exit(): m(0) {} void activate(MutexType& m_) { m_.unlock(); m=&m_; } ~lock_on_exit() { if(m) { m->lock(); } } }; } inline void condition_variable::wait(unique_lock<mutex>& m) { #if defined BOOST_THREAD_THROW_IF_PRECONDITION_NOT_SATISFIED if(! m.owns_lock()) { boost::throw_exception(condition_error(-1, "boost::condition_variable::wait() failed precondition mutex not owned")); } #endif int res=0; { #if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS thread_cv_detail::lock_on_exit<unique_lock<mutex> > guard; detail::interruption_checker check_for_interruption(&internal_mutex,&cond); guard.activate(m); do { res = pthread_cond_wait(&cond,&internal_mutex); } while (res == EINTR); #else //boost::pthread::pthread_mutex_scoped_lock check_for_interruption(&internal_mutex); pthread_mutex_t* the_mutex = m.mutex()->native_handle(); do { res = pthread_cond_wait(&cond,the_mutex); } while (res == EINTR); #endif } #if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS this_thread::interruption_point(); #endif if(res) { boost::throw_exception(condition_error(res, "boost::condition_variable::wait failed in pthread_cond_wait")); } } inline bool condition_variable::do_wait_until( unique_lock<mutex>& m, struct timespec const &timeout) { #if defined BOOST_THREAD_THROW_IF_PRECONDITION_NOT_SATISFIED if (!m.owns_lock()) { boost::throw_exception(condition_error(EPERM, "boost::condition_variable::do_wait_until() failed precondition mutex not owned")); } #endif thread_cv_detail::lock_on_exit<unique_lock<mutex> > guard; int cond_res; { #if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS detail::interruption_checker check_for_interruption(&internal_mutex,&cond); guard.activate(m); cond_res=pthread_cond_timedwait(&cond,&internal_mutex,&timeout); #else //boost::pthread::pthread_mutex_scoped_lock check_for_interruption(&internal_mutex); pthread_mutex_t* the_mutex = m.mutex()->native_handle(); cond_res=pthread_cond_timedwait(&cond,the_mutex,&timeout); #endif } #if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS this_thread::interruption_point(); #endif if(cond_res==ETIMEDOUT) { return false; } if(cond_res) { boost::throw_exception(condition_error(cond_res, "boost::condition_variable::do_wait_until failed in pthread_cond_timedwait")); } return true; } inline void condition_variable::notify_one() BOOST_NOEXCEPT { #if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS boost::pthread::pthread_mutex_scoped_lock internal_lock(&internal_mutex); #endif BOOST_VERIFY(!pthread_cond_signal(&cond)); } inline void condition_variable::notify_all() BOOST_NOEXCEPT { #if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS boost::pthread::pthread_mutex_scoped_lock internal_lock(&internal_mutex); #endif BOOST_VERIFY(!pthread_cond_broadcast(&cond)); } class condition_variable_any { pthread_mutex_t internal_mutex; pthread_cond_t cond; public: BOOST_THREAD_NO_COPYABLE(condition_variable_any) condition_variable_any() { int const res=pthread_mutex_init(&internal_mutex,NULL); if(res) { boost::throw_exception(thread_resource_error(res, "boost::condition_variable_any::condition_variable_any() failed in pthread_mutex_init")); } int const res2=pthread_cond_init(&cond,NULL); if(res2) { BOOST_VERIFY(!pthread_mutex_destroy(&internal_mutex)); boost::throw_exception(thread_resource_error(res, "boost::condition_variable_any::condition_variable_any() failed in pthread_cond_init")); } } ~condition_variable_any() { BOOST_VERIFY(!pthread_mutex_destroy(&internal_mutex)); BOOST_VERIFY(!pthread_cond_destroy(&cond)); } template<typename lock_type> void wait(lock_type& m) { int res=0; { thread_cv_detail::lock_on_exit<lock_type> guard; #if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS detail::interruption_checker check_for_interruption(&internal_mutex,&cond); #else boost::pthread::pthread_mutex_scoped_lock check_for_interruption(&internal_mutex); #endif guard.activate(m); res=pthread_cond_wait(&cond,&internal_mutex); } #if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS this_thread::interruption_point(); #endif if(res) { boost::throw_exception(condition_error(res, "boost::condition_variable_any::wait() failed in pthread_cond_wait")); } } 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) { struct timespec const timeout=detail::to_timespec(abs_time); return do_wait_until(m, timeout); } template<typename lock_type> bool timed_wait(lock_type& m,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) { return timed_wait(m,get_system_time()+wait_duration); } template<typename lock_type,typename predicate_type> bool timed_wait(lock_type& m,boost::system_time const& abs_time, predicate_type pred) { while (!pred()) { if(!timed_wait(m, abs_time)) return pred(); } return true; } template<typename lock_type,typename predicate_type> bool timed_wait(lock_type& m,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) { return timed_wait(m,get_system_time()+wait_duration,pred); } #endif #ifdef BOOST_THREAD_USES_CHRONO template <class lock_type,class Duration> cv_status wait_until( lock_type& lock, const chrono::time_point<chrono::system_clock, Duration>& t) { using namespace chrono; typedef time_point<system_clock, nanoseconds> nano_sys_tmpt; wait_until(lock, nano_sys_tmpt(ceil<nanoseconds>(t.time_since_epoch()))); return system_clock::now() < t ? cv_status::no_timeout : 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) { using namespace chrono; system_clock::time_point s_now = system_clock::now(); typename Clock::time_point c_now = Clock::now(); wait_until(lock, s_now + ceil<nanoseconds>(t - c_now)); return Clock::now() < t ? cv_status::no_timeout : cv_status::timeout; } 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) { while (!pred()) { if (wait_until(lock, t) == cv_status::timeout) return pred(); } return true; } template <class lock_type, class Rep, class Period> cv_status wait_for( lock_type& lock, const chrono::duration<Rep, Period>& d) { using namespace chrono; system_clock::time_point s_now = system_clock::now(); steady_clock::time_point c_now = steady_clock::now(); wait_until(lock, s_now + ceil<nanoseconds>(d)); return steady_clock::now() - c_now < d ? cv_status::no_timeout : cv_status::timeout; } 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)); // while (!pred()) // { // if (wait_for(lock, d) == cv_status::timeout) // return pred(); // } // return true; } template <class lock_type> cv_status wait_until( lock_type& lk, chrono::time_point<chrono::system_clock, chrono::nanoseconds> tp) { using namespace chrono; nanoseconds d = tp.time_since_epoch(); timespec ts = boost::detail::to_timespec(d); if (do_wait_until(lk, ts)) return cv_status::no_timeout; else return cv_status::timeout; } #endif void notify_one() BOOST_NOEXCEPT { boost::pthread::pthread_mutex_scoped_lock internal_lock(&internal_mutex); BOOST_VERIFY(!pthread_cond_signal(&cond)); } void notify_all() BOOST_NOEXCEPT { boost::pthread::pthread_mutex_scoped_lock internal_lock(&internal_mutex); BOOST_VERIFY(!pthread_cond_broadcast(&cond)); } private: // used by boost::thread::try_join_until template <class lock_type> inline bool do_wait_until( lock_type& m, struct timespec const &timeout) { int res=0; { thread_cv_detail::lock_on_exit<lock_type> guard; #if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS detail::interruption_checker check_for_interruption(&internal_mutex,&cond); #else boost::pthread::pthread_mutex_scoped_lock check_for_interruption(&internal_mutex); #endif guard.activate(m); res=pthread_cond_timedwait(&cond,&internal_mutex,&timeout); } #if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS this_thread::interruption_point(); #endif if(res==ETIMEDOUT) { return false; } if(res) { boost::throw_exception(condition_error(res, "boost::condition_variable_any::do_wait_until() failed in pthread_cond_timedwait")); } return true; } }; } #include <boost/config/abi_suffix.hpp> #endif