summaryrefslogtreecommitdiff
path: root/boost/thread/concurrent_queues/sync_timed_queue.hpp
diff options
context:
space:
mode:
authorDongHun Kwak <dh0128.kwak@samsung.com>2019-12-05 15:11:01 +0900
committerDongHun Kwak <dh0128.kwak@samsung.com>2019-12-05 15:11:01 +0900
commit3fdc3e5ee96dca5b11d1694975a65200787eab86 (patch)
tree5c1733853892b8397d67706fa453a9bd978d2102 /boost/thread/concurrent_queues/sync_timed_queue.hpp
parent88e602c57797660ebe0f9e15dbd64c1ff16dead3 (diff)
downloadboost-3fdc3e5ee96dca5b11d1694975a65200787eab86.tar.gz
boost-3fdc3e5ee96dca5b11d1694975a65200787eab86.tar.bz2
boost-3fdc3e5ee96dca5b11d1694975a65200787eab86.zip
Imported Upstream version 1.66.0upstream/1.66.0
Diffstat (limited to 'boost/thread/concurrent_queues/sync_timed_queue.hpp')
-rw-r--r--boost/thread/concurrent_queues/sync_timed_queue.hpp155
1 files changed, 78 insertions, 77 deletions
diff --git a/boost/thread/concurrent_queues/sync_timed_queue.hpp b/boost/thread/concurrent_queues/sync_timed_queue.hpp
index e6a360f2b1..596a625ef5 100644
--- a/boost/thread/concurrent_queues/sync_timed_queue.hpp
+++ b/boost/thread/concurrent_queues/sync_timed_queue.hpp
@@ -1,5 +1,5 @@
// Copyright (C) 2014 Ian Forbed
-// Copyright (C) 2014 Vicente J. Botet Escriba
+// Copyright (C) 2014-2017 Vicente J. Botet Escriba
//
// 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)
@@ -24,12 +24,13 @@ namespace concurrent
{
namespace detail
{
- template <class T, class Clock = chrono::steady_clock>
+ // fixme: shouldn't the timepoint be configurable
+ template <class T, class Clock = chrono::steady_clock, class TimePoint=typename Clock::time_point>
struct scheduled_type
{
typedef T value_type;
typedef Clock clock;
- typedef typename clock::time_point time_point;
+ typedef TimePoint time_point;
T data;
time_point time;
@@ -57,7 +58,7 @@ namespace detail
return time > clock::now();
}
- bool operator <(const scheduled_type<T> other) const
+ bool operator <(const scheduled_type & other) const
{
return this->time > other.time;
}
@@ -65,11 +66,11 @@ namespace detail
} //end detail namespace
- template <class T, class Clock = chrono::steady_clock>
+ template <class T, class Clock = chrono::steady_clock, class TimePoint=typename Clock::time_point>
class sync_timed_queue
- : private sync_priority_queue<detail::scheduled_type<T, Clock> >
+ : private sync_priority_queue<detail::scheduled_type<T, Clock, TimePoint> >
{
- typedef detail::scheduled_type<T, Clock> stype;
+ typedef detail::scheduled_type<T, Clock, TimePoint> stype;
typedef sync_priority_queue<stype> super;
public:
typedef T value_type;
@@ -92,8 +93,8 @@ namespace detail
T pull();
void pull(T& elem);
- template <class Duration>
- queue_op_status pull_until(chrono::time_point<clock,Duration> const& tp, T& elem);
+ template <class WClock, class Duration>
+ queue_op_status pull_until(chrono::time_point<WClock,Duration> const& tp, T& elem);
template <class Rep, class Period>
queue_op_status pull_for(chrono::duration<Rep,Period> const& dura, T& elem);
@@ -135,8 +136,8 @@ namespace detail
bool wait_until_not_empty_time_reached_or_closed(unique_lock<mutex>&);
T pull_when_time_reached(unique_lock<mutex>&);
- template <class Duration>
- queue_op_status pull_when_time_reached_until(unique_lock<mutex>&, chrono::time_point<clock,Duration> const& tp, T& elem);
+ template <class WClock, class Duration>
+ queue_op_status pull_when_time_reached_until(unique_lock<mutex>&, chrono::time_point<WClock,Duration> const& tp, T& elem);
bool time_not_reached(unique_lock<mutex>&);
bool time_not_reached(lock_guard<mutex>&);
bool empty_or_time_not_reached(unique_lock<mutex>&);
@@ -149,80 +150,80 @@ namespace detail
}; //end class
- template <class T, class Clock>
+ template <class T, class Clock, class TimePoint>
template <class Duration>
- void sync_timed_queue<T, Clock>::push(const T& elem, chrono::time_point<clock,Duration> const& tp)
+ void sync_timed_queue<T, Clock, TimePoint>::push(const T& elem, chrono::time_point<clock,Duration> const& tp)
{
super::push(stype(elem,tp));
}
- template <class T, class Clock>
+ template <class T, class Clock, class TimePoint>
template <class Rep, class Period>
- void sync_timed_queue<T, Clock>::push(const T& elem, chrono::duration<Rep,Period> const& dura)
+ void sync_timed_queue<T, Clock, TimePoint>::push(const T& elem, chrono::duration<Rep,Period> const& dura)
{
push(elem, clock::now() + dura);
}
- template <class T, class Clock>
+ template <class T, class Clock, class TimePoint>
template <class Duration>
- void sync_timed_queue<T, Clock>::push(BOOST_THREAD_RV_REF(T) elem, chrono::time_point<clock,Duration> const& tp)
+ void sync_timed_queue<T, Clock, TimePoint>::push(BOOST_THREAD_RV_REF(T) elem, chrono::time_point<clock,Duration> const& tp)
{
super::push(stype(boost::move(elem),tp));
}
- template <class T, class Clock>
+ template <class T, class Clock, class TimePoint>
template <class Rep, class Period>
- void sync_timed_queue<T, Clock>::push(BOOST_THREAD_RV_REF(T) elem, chrono::duration<Rep,Period> const& dura)
+ void sync_timed_queue<T, Clock, TimePoint>::push(BOOST_THREAD_RV_REF(T) elem, chrono::duration<Rep,Period> const& dura)
{
push(boost::move(elem), clock::now() + dura);
}
- template <class T, class Clock>
+ template <class T, class Clock, class TimePoint>
template <class Duration>
- queue_op_status sync_timed_queue<T, Clock>::try_push(const T& elem, chrono::time_point<clock,Duration> const& tp)
+ queue_op_status sync_timed_queue<T, Clock, TimePoint>::try_push(const T& elem, chrono::time_point<clock,Duration> const& tp)
{
return super::try_push(stype(elem,tp));
}
- template <class T, class Clock>
+ template <class T, class Clock, class TimePoint>
template <class Rep, class Period>
- queue_op_status sync_timed_queue<T, Clock>::try_push(const T& elem, chrono::duration<Rep,Period> const& dura)
+ queue_op_status sync_timed_queue<T, Clock, TimePoint>::try_push(const T& elem, chrono::duration<Rep,Period> const& dura)
{
return try_push(elem,clock::now() + dura);
}
- template <class T, class Clock>
+ template <class T, class Clock, class TimePoint>
template <class Duration>
- queue_op_status sync_timed_queue<T, Clock>::try_push(BOOST_THREAD_RV_REF(T) elem, chrono::time_point<clock,Duration> const& tp)
+ queue_op_status sync_timed_queue<T, Clock, TimePoint>::try_push(BOOST_THREAD_RV_REF(T) elem, chrono::time_point<clock,Duration> const& tp)
{
return super::try_push(stype(boost::move(elem), tp));
}
- template <class T, class Clock>
+ template <class T, class Clock, class TimePoint>
template <class Rep, class Period>
- queue_op_status sync_timed_queue<T, Clock>::try_push(BOOST_THREAD_RV_REF(T) elem, chrono::duration<Rep,Period> const& dura)
+ queue_op_status sync_timed_queue<T, Clock, TimePoint>::try_push(BOOST_THREAD_RV_REF(T) elem, chrono::duration<Rep,Period> const& dura)
{
return try_push(boost::move(elem), clock::now() + dura);
}
///////////////////////////
- template <class T, class Clock>
- bool sync_timed_queue<T, Clock>::time_not_reached(unique_lock<mutex>&)
+ template <class T, class Clock, class TimePoint>
+ bool sync_timed_queue<T, Clock, TimePoint>::time_not_reached(unique_lock<mutex>&)
{
return super::data_.top().time_not_reached();
}
- template <class T, class Clock>
- bool sync_timed_queue<T, Clock>::time_not_reached(lock_guard<mutex>&)
+ template <class T, class Clock, class TimePoint>
+ bool sync_timed_queue<T, Clock, TimePoint>::time_not_reached(lock_guard<mutex>&)
{
return super::data_.top().time_not_reached();
}
///////////////////////////
- template <class T, class Clock>
- bool sync_timed_queue<T, Clock>::wait_until_not_empty_time_reached_or_closed(unique_lock<mutex>& lk)
+ template <class T, class Clock, class TimePoint>
+ bool sync_timed_queue<T, Clock, TimePoint>::wait_until_not_empty_time_reached_or_closed(unique_lock<mutex>& lk)
{
for (;;)
{
@@ -240,8 +241,8 @@ namespace detail
}
///////////////////////////
- template <class T, class Clock>
- T sync_timed_queue<T, Clock>::pull_when_time_reached(unique_lock<mutex>& lk)
+ template <class T, class Clock, class TimePoint>
+ T sync_timed_queue<T, Clock, TimePoint>::pull_when_time_reached(unique_lock<mutex>& lk)
{
while (time_not_reached(lk))
{
@@ -253,12 +254,12 @@ namespace detail
return pull(lk);
}
- template <class T, class Clock>
- template <class Duration>
+ template <class T, class Clock, class TimePoint>
+ template <class WClock, class Duration>
queue_op_status
- sync_timed_queue<T, Clock>::pull_when_time_reached_until(unique_lock<mutex>& lk, chrono::time_point<clock,Duration> const& tp, T& elem)
+ sync_timed_queue<T, Clock, TimePoint>::pull_when_time_reached_until(unique_lock<mutex>& lk, chrono::time_point<WClock, Duration> const& tp, T& elem)
{
- chrono::time_point<clock,Duration> tpmin = (tp < super::data_.top().time) ? tp : super::data_.top().time;
+ chrono::time_point<WClock, Duration> tpmin = (tp < super::data_.top().time) ? tp : super::data_.top().time;
while (time_not_reached(lk))
{
super::throw_if_closed(lk);
@@ -272,15 +273,15 @@ namespace detail
}
///////////////////////////
- template <class T, class Clock>
- bool sync_timed_queue<T, Clock>::empty_or_time_not_reached(unique_lock<mutex>& lk)
+ template <class T, class Clock, class TimePoint>
+ bool sync_timed_queue<T, Clock, TimePoint>::empty_or_time_not_reached(unique_lock<mutex>& lk)
{
if ( super::empty(lk) ) return true;
if ( time_not_reached(lk) ) return true;
return false;
}
- template <class T, class Clock>
- bool sync_timed_queue<T, Clock>::empty_or_time_not_reached(lock_guard<mutex>& lk)
+ template <class T, class Clock, class TimePoint>
+ bool sync_timed_queue<T, Clock, TimePoint>::empty_or_time_not_reached(lock_guard<mutex>& lk)
{
if ( super::empty(lk) ) return true;
if ( time_not_reached(lk) ) return true;
@@ -288,8 +289,8 @@ namespace detail
}
///////////////////////////
- template <class T, class Clock>
- T sync_timed_queue<T, Clock>::pull(unique_lock<mutex>&)
+ template <class T, class Clock, class TimePoint>
+ T sync_timed_queue<T, Clock, TimePoint>::pull(unique_lock<mutex>&)
{
#if ! defined BOOST_NO_CXX11_RVALUE_REFERENCES
return boost::move(super::data_.pull().data);
@@ -298,8 +299,8 @@ namespace detail
#endif
}
- template <class T, class Clock>
- T sync_timed_queue<T, Clock>::pull(lock_guard<mutex>&)
+ template <class T, class Clock, class TimePoint>
+ T sync_timed_queue<T, Clock, TimePoint>::pull(lock_guard<mutex>&)
{
#if ! defined BOOST_NO_CXX11_RVALUE_REFERENCES
return boost::move(super::data_.pull().data);
@@ -307,8 +308,8 @@ namespace detail
return super::data_.pull().data;
#endif
}
- template <class T, class Clock>
- T sync_timed_queue<T, Clock>::pull()
+ template <class T, class Clock, class TimePoint>
+ T sync_timed_queue<T, Clock, TimePoint>::pull()
{
unique_lock<mutex> lk(super::mtx_);
super::wait_until_not_empty(lk);
@@ -316,8 +317,8 @@ namespace detail
}
///////////////////////////
- template <class T, class Clock>
- void sync_timed_queue<T, Clock>::pull(unique_lock<mutex>&, T& elem)
+ template <class T, class Clock, class TimePoint>
+ void sync_timed_queue<T, Clock, TimePoint>::pull(unique_lock<mutex>&, T& elem)
{
#if ! defined BOOST_NO_CXX11_RVALUE_REFERENCES
elem = boost::move(super::data_.pull().data);
@@ -326,8 +327,8 @@ namespace detail
#endif
}
- template <class T, class Clock>
- void sync_timed_queue<T, Clock>::pull(lock_guard<mutex>&, T& elem)
+ template <class T, class Clock, class TimePoint>
+ void sync_timed_queue<T, Clock, TimePoint>::pull(lock_guard<mutex>&, T& elem)
{
#if ! defined BOOST_NO_CXX11_RVALUE_REFERENCES
elem = boost::move(super::data_.pull().data);
@@ -336,8 +337,8 @@ namespace detail
#endif
}
- template <class T, class Clock>
- void sync_timed_queue<T, Clock>::pull(T& elem)
+ template <class T, class Clock, class TimePoint>
+ void sync_timed_queue<T, Clock, TimePoint>::pull(T& elem)
{
unique_lock<mutex> lk(super::mtx_);
super::wait_until_not_empty(lk);
@@ -345,10 +346,10 @@ namespace detail
}
//////////////////////
- template <class T, class Clock>
- template <class Duration>
+ template <class T, class Clock, class TimePoint>
+ template <class WClock, class Duration>
queue_op_status
- sync_timed_queue<T, Clock>::pull_until(chrono::time_point<clock,Duration> const& tp, T& elem)
+ sync_timed_queue<T, Clock, TimePoint>::pull_until(chrono::time_point<WClock, Duration> const& tp, T& elem)
{
unique_lock<mutex> lk(super::mtx_);
@@ -358,17 +359,17 @@ namespace detail
}
//////////////////////
- template <class T, class Clock>
+ template <class T, class Clock, class TimePoint>
template <class Rep, class Period>
queue_op_status
- sync_timed_queue<T, Clock>::pull_for(chrono::duration<Rep,Period> const& dura, T& elem)
+ sync_timed_queue<T, Clock, TimePoint>::pull_for(chrono::duration<Rep,Period> const& dura, T& elem)
{
- return pull_until(clock::now() + dura, elem);
+ return pull_until(chrono::steady_clock::now() + dura, elem);
}
///////////////////////////
- template <class T, class Clock>
- queue_op_status sync_timed_queue<T, Clock>::try_pull(unique_lock<mutex>& lk, T& elem)
+ template <class T, class Clock, class TimePoint>
+ queue_op_status sync_timed_queue<T, Clock, TimePoint>::try_pull(unique_lock<mutex>& lk, T& elem)
{
if ( super::empty(lk) )
{
@@ -384,8 +385,8 @@ namespace detail
pull(lk, elem);
return queue_op_status::success;
}
- template <class T, class Clock>
- queue_op_status sync_timed_queue<T, Clock>::try_pull(lock_guard<mutex>& lk, T& elem)
+ template <class T, class Clock, class TimePoint>
+ queue_op_status sync_timed_queue<T, Clock, TimePoint>::try_pull(lock_guard<mutex>& lk, T& elem)
{
if ( super::empty(lk) )
{
@@ -401,16 +402,16 @@ namespace detail
return queue_op_status::success;
}
- template <class T, class Clock>
- queue_op_status sync_timed_queue<T, Clock>::try_pull(T& elem)
+ template <class T, class Clock, class TimePoint>
+ queue_op_status sync_timed_queue<T, Clock, TimePoint>::try_pull(T& elem)
{
lock_guard<mutex> lk(super::mtx_);
return try_pull(lk, elem);
}
///////////////////////////
- template <class T, class Clock>
- queue_op_status sync_timed_queue<T, Clock>::wait_pull(unique_lock<mutex>& lk, T& elem)
+ template <class T, class Clock, class TimePoint>
+ queue_op_status sync_timed_queue<T, Clock, TimePoint>::wait_pull(unique_lock<mutex>& lk, T& elem)
{
if (super::empty(lk))
{
@@ -422,16 +423,16 @@ namespace detail
return queue_op_status::success;
}
- template <class T, class Clock>
- queue_op_status sync_timed_queue<T, Clock>::wait_pull(T& elem)
+ template <class T, class Clock, class TimePoint>
+ queue_op_status sync_timed_queue<T, Clock, TimePoint>::wait_pull(T& elem)
{
unique_lock<mutex> lk(super::mtx_);
return wait_pull(lk, elem);
}
// ///////////////////////////
-// template <class T, class Clock>
-// queue_op_status sync_timed_queue<T, Clock>::wait_pull(unique_lock<mutex> &lk, T& elem)
+// template <class T, class Clock, class TimePoint>
+// queue_op_status sync_timed_queue<T, Clock, TimePoint>::wait_pull(unique_lock<mutex> &lk, T& elem)
// {
// if (super::empty(lk))
// {
@@ -442,16 +443,16 @@ namespace detail
// pull(lk, elem);
// return queue_op_status::success;
// }
-// template <class T>
-// queue_op_status sync_timed_queue<T, Clock>::wait_pull(T& elem)
+// template <class T, class Clock, class TimePoint>
+// queue_op_status sync_timed_queue<T, Clock, TimePoint>::wait_pull(T& elem)
// {
// unique_lock<mutex> lk(super::mtx_);
// return wait_pull(lk, elem);
// }
///////////////////////////
- template <class T, class Clock>
- queue_op_status sync_timed_queue<T, Clock>::nonblocking_pull(T& elem)
+ template <class T, class Clock, class TimePoint>
+ queue_op_status sync_timed_queue<T, Clock, TimePoint>::nonblocking_pull(T& elem)
{
unique_lock<mutex> lk(super::mtx_, try_to_lock);
if (! lk.owns_lock()) return queue_op_status::busy;