summaryrefslogtreecommitdiff
path: root/boost/thread/pthread/condition_variable.hpp
diff options
context:
space:
mode:
Diffstat (limited to 'boost/thread/pthread/condition_variable.hpp')
-rw-r--r--boost/thread/pthread/condition_variable.hpp277
1 files changed, 167 insertions, 110 deletions
diff --git a/boost/thread/pthread/condition_variable.hpp b/boost/thread/pthread/condition_variable.hpp
index b66b710a24..285785ff59 100644
--- a/boost/thread/pthread/condition_variable.hpp
+++ b/boost/thread/pthread/condition_variable.hpp
@@ -6,8 +6,10 @@
// (C) Copyright 2007-10 Anthony Williams
// (C) Copyright 2011-2012 Vicente J. Botet Escriba
-#include <boost/thread/pthread/timespec.hpp>
+#include <boost/thread/detail/platform_time.hpp>
#include <boost/thread/pthread/pthread_mutex_scoped_lock.hpp>
+#include <boost/thread/pthread/pthread_helpers.hpp>
+
#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
#include <boost/thread/pthread/thread_data.hpp>
#endif
@@ -18,6 +20,8 @@
#endif
#include <boost/thread/detail/delete.hpp>
+#include <algorithm>
+
#include <boost/config/abi_prefix.hpp>
namespace boost
@@ -95,9 +99,18 @@ namespace boost
}
}
+ // 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
inline bool condition_variable::do_wait_until(
unique_lock<mutex>& m,
- struct timespec const &timeout)
+ detail::internal_platform_timepoint const &timeout)
{
#if defined BOOST_THREAD_THROW_IF_PRECONDITION_NOT_SATISFIED
if (!m.owns_lock())
@@ -112,12 +125,12 @@ namespace boost
detail::interruption_checker check_for_interruption(&internal_mutex,&cond);
pthread_mutex_t* the_mutex = &internal_mutex;
guard.activate(m);
- cond_res=pthread_cond_timedwait(&cond,the_mutex,&timeout);
+ cond_res=pthread_cond_timedwait(&cond,the_mutex,&timeout.getTs());
check_for_interruption.unlock_if_locked();
guard.deactivate();
#else
pthread_mutex_t* the_mutex = m.mutex()->native_handle();
- cond_res=pthread_cond_timedwait(&cond,the_mutex,&timeout);
+ cond_res=pthread_cond_timedwait(&cond,the_mutex,&timeout.getTs());
#endif
}
#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
@@ -164,11 +177,11 @@ namespace boost
{
boost::throw_exception(thread_resource_error(res, "boost::condition_variable_any::condition_variable_any() failed in pthread_mutex_init"));
}
- int const res2 = detail::monotonic_pthread_cond_init(cond);
+ int const res2 = pthread::cond_init(cond);
if(res2)
{
BOOST_VERIFY(!pthread_mutex_destroy(&internal_mutex));
- boost::throw_exception(thread_resource_error(res2, "boost::condition_variable_any::condition_variable_any() failed in detail::monotonic_pthread_cond_init"));
+ boost::throw_exception(thread_resource_error(res2, "boost::condition_variable_any::condition_variable_any() failed in pthread::cond_init"));
}
}
~condition_variable_any()
@@ -205,15 +218,35 @@ namespace boost
template<typename lock_type,typename predicate_type>
void wait(lock_type& m,predicate_type pred)
{
- while(!pred()) wait(m);
+ 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);
+#if defined BOOST_THREAD_WAIT_BUG
+ const detail::real_platform_timepoint ts(abs_time + BOOST_THREAD_WAIT_BUG);
+#else
+ const detail::real_platform_timepoint ts(abs_time);
+#endif
+#if defined BOOST_THREAD_INTERNAL_CLOCK_IS_MONO
+ // 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::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();
+#else
+ return do_wait_until(m, ts);
+#endif
}
template<typename lock_type>
bool timed_wait(lock_type& m,xtime const& abs_time)
@@ -224,18 +257,55 @@ namespace boost
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);
+ if (wait_duration.is_pos_infinity())
+ {
+ wait(m);
+ return true;
+ }
+ if (wait_duration.is_special())
+ {
+ return true;
+ }
+ detail::platform_duration d(wait_duration);
+#if defined(BOOST_THREAD_HAS_MONO_CLOCK) && !defined(BOOST_THREAD_INTERNAL_CLOCK_IS_MONO)
+ // 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::mono_platform_timepoint ts(detail::mono_platform_clock::now() + d);
+ do_wait_until(m, detail::internal_platform_clock::now() + d);
+ return ts > detail::mono_platform_clock::now();
+#else
+ return do_wait_until(m, detail::internal_platform_clock::now() + d);
+#endif
}
template<typename lock_type,typename predicate_type>
bool timed_wait(lock_type& m,boost::system_time const& abs_time, predicate_type pred)
{
+#if defined BOOST_THREAD_WAIT_BUG
+ const detail::real_platform_timepoint ts(abs_time + BOOST_THREAD_WAIT_BUG);
+#else
+ const detail::real_platform_timepoint ts(abs_time);
+#endif
while (!pred())
{
- if(!timed_wait(m, abs_time))
- return pred();
+#if defined BOOST_THREAD_INTERNAL_CLOCK_IS_MONO
+ // 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.
+ 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);
+#else
+ if (!do_wait_until(m, ts)) break; // timeout occurred
+#endif
}
- return true;
+ return pred();
}
template<typename lock_type,typename predicate_type>
@@ -247,24 +317,52 @@ namespace boost
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);
+ if (wait_duration.is_pos_infinity())
+ {
+ while (!pred())
+ {
+ wait(m);
+ }
+ return true;
+ }
+ if (wait_duration.is_special())
+ {
+ return pred();
+ }
+ detail::platform_duration d(wait_duration);
+#if defined(BOOST_THREAD_HAS_MONO_CLOCK) && !defined(BOOST_THREAD_INTERNAL_CLOCK_IS_MONO)
+ // 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::mono_platform_timepoint ts(detail::mono_platform_clock::now() + d);
+ while (!pred())
+ {
+ 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);
+ d = ts - detail::mono_platform_clock::now();
+ }
+#else
+ const detail::internal_platform_timepoint ts(detail::internal_platform_clock::now() + d);
+ while (!pred())
+ {
+ if (!do_wait_until(m, ts)) break; // timeout occurred
+ }
+#endif
+ return pred();
}
#endif
-#ifndef BOOST_THREAD_HAS_CONDATTR_SET_CLOCK_MONOTONIC
#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)
+ const chrono::time_point<detail::internal_chrono_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;
+ const boost::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>
@@ -273,11 +371,18 @@ namespace boost
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;
+ // 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>
@@ -286,86 +391,24 @@ namespace boost
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>
- 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;
+ return wait_until(lock, chrono::steady_clock::now() + d);
}
-#endif
-#else // defined BOOST_THREAD_HAS_CONDATTR_SET_CLOCK_MONOTONIC
-#ifdef BOOST_THREAD_USES_CHRONO
- template <class lock_type, class Duration>
- cv_status
- wait_until(
- lock_type& lock,
- const chrono::time_point<chrono::steady_clock, Duration>& t)
- {
- using namespace chrono;
- typedef time_point<steady_clock, nanoseconds> nano_sys_tmpt;
- wait_until(lock,
- nano_sys_tmpt(ceil<nanoseconds>(t.time_since_epoch())));
- return steady_clock::now() < t ? cv_status::no_timeout :
- cv_status::timeout;
- }
-
- template <class lock_type, class Clock, class Duration>
- cv_status
+ template <class lock_type, class Duration, class Predicate>
+ bool
wait_until(
- lock_type& lock,
- const chrono::time_point<Clock, Duration>& t)
- {
- using namespace chrono;
- steady_clock::time_point s_now = steady_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 Rep, class Period>
- cv_status
- wait_for(
- lock_type& lock,
- const chrono::duration<Rep, Period>& d)
- {
- using namespace chrono;
- steady_clock::time_point c_now = steady_clock::now();
- wait_until(lock, c_now + ceil<nanoseconds>(d));
- return steady_clock::now() - c_now < d ? cv_status::no_timeout :
- cv_status::timeout;
- }
-
- template <class lock_type>
- inline cv_status wait_until(
- lock_type& lock,
- chrono::time_point<chrono::steady_clock, chrono::nanoseconds> tp)
+ lock_type& lock,
+ const chrono::time_point<detail::internal_chrono_clock, Duration>& t,
+ Predicate pred)
{
- using namespace chrono;
- nanoseconds d = tp.time_since_epoch();
- timespec ts = boost::detail::to_timespec(d);
- if (do_wait_until(lock, ts)) return cv_status::no_timeout;
- else return cv_status::timeout;
+ const detail::internal_platform_timepoint ts(t);
+ while (!pred())
+ {
+ if (!do_wait_until(lock, ts)) break; // timeout occurred
+ }
+ return pred();
}
-#endif
-#endif // defined BOOST_THREAD_HAS_CONDATTR_SET_CLOCK_MONOTONIC
-
-#ifdef BOOST_THREAD_USES_CHRONO
template <class lock_type, class Clock, class Duration, class Predicate>
bool
wait_until(
@@ -373,12 +416,18 @@ namespace boost
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())
{
- if (wait_until(lock, t) == cv_status::timeout)
- return 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 true;
+ return pred();
}
template <class lock_type, class Rep, class Period, class Predicate>
@@ -388,7 +437,7 @@ namespace boost
const chrono::duration<Rep, Period>& d,
Predicate pred)
{
- return wait_until(lock, chrono::steady_clock::now() + d, boost::move(pred));
+ return wait_until(lock, chrono::steady_clock::now() + d, boost::move(pred));
}
#endif
@@ -403,12 +452,21 @@ namespace boost
boost::pthread::pthread_mutex_scoped_lock internal_lock(&internal_mutex);
BOOST_VERIFY(!pthread_cond_broadcast(&cond));
}
- private: // used by boost::thread::try_join_until
-
+ private:
+
+ // 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 <class lock_type>
bool do_wait_until(
lock_type& m,
- struct timespec const &timeout)
+ detail::internal_platform_timepoint const &timeout)
{
int res=0;
{
@@ -419,7 +477,7 @@ namespace boost
boost::pthread::pthread_mutex_scoped_lock check_for_interruption(&internal_mutex);
#endif
guard.activate(m);
- res=pthread_cond_timedwait(&cond,&internal_mutex,&timeout);
+ res=pthread_cond_timedwait(&cond,&internal_mutex,&timeout.getTs());
check_for_interruption.unlock_if_locked();
guard.deactivate();
}
@@ -437,7 +495,6 @@ namespace boost
return true;
}
};
-
}
#include <boost/config/abi_suffix.hpp>