Commit ec9aebc4 authored by Joseph Noir's avatar Joseph Noir

Add wait until based on new chrono header

parent 9fcdc799
...@@ -24,10 +24,11 @@ ...@@ -24,10 +24,11 @@
#ifdef __RIOTBUILD_FLAG #ifdef __RIOTBUILD_FLAG
#include <chrono>
#include "mutex.hpp" #include "mutex.hpp"
#include "caf/chrono.hpp"
extern "C" { extern "C" {
#include "sched.h" #include "sched.h"
#include "vtimer.h" #include "vtimer.h"
...@@ -53,12 +54,10 @@ class condition_variable { ...@@ -53,12 +54,10 @@ class condition_variable {
void wait(unique_lock<mutex>& lock) noexcept; void wait(unique_lock<mutex>& lock) noexcept;
template <class Predicate> template <class Predicate>
void wait(unique_lock<mutex>& lock, Predicate pred); void wait(unique_lock<mutex>& lock, Predicate pred);
template <class Clock, class Duration>
cv_status wait_until(unique_lock<mutex>& lock, cv_status wait_until(unique_lock<mutex>& lock,
const std::chrono::time_point<Clock, Duration>& timeout_time); const time_point& timeout_time);
template <class Clock, class Duration, class Predicate> template <class Predicate>
bool wait_until(unique_lock<mutex>& lock, bool wait_until(unique_lock<mutex>& lock, const time_point& timeout_time,
const std::chrono::time_point<Clock,Duration>& timeout_time,
Predicate pred); Predicate pred);
template <class Rep, class Period> template <class Rep, class Period>
cv_status wait_for(unique_lock<mutex>& lock, cv_status wait_for(unique_lock<mutex>& lock,
...@@ -94,19 +93,10 @@ void condition_variable::wait(unique_lock<mutex>& lock, Predicate pred) { ...@@ -94,19 +93,10 @@ void condition_variable::wait(unique_lock<mutex>& lock, Predicate pred) {
} }
} }
template <class Clock, class Duration> template <class Predicate>
cv_status condition_variable::wait_until(unique_lock<mutex>& lock,
const std::chrono::time_point<Clock,
Duration>& timeout_time) {
wait_for(lock, timeout_time - Clock::now());
return Clock::now() < timeout_time ?
cv_status::no_timeout : cv_status::timeout;
}
template <class Clock, class Duration, class Predicate>
bool condition_variable::wait_until(unique_lock<mutex>& lock, bool condition_variable::wait_until(unique_lock<mutex>& lock,
const std::chrono::time_point<Clock,Duration>& timeout_time, const time_point& timeout_time,
Predicate pred) { Predicate pred) {
while (!pred()) { while (!pred()) {
if (wait_until(lock, timeout_time) == cv_status::timeout) { if (wait_until(lock, timeout_time) == cv_status::timeout) {
return pred(); return pred();
...@@ -118,27 +108,24 @@ bool condition_variable::wait_until(unique_lock<mutex>& lock, ...@@ -118,27 +108,24 @@ bool condition_variable::wait_until(unique_lock<mutex>& lock,
template <class Rep, class Period> template <class Rep, class Period>
cv_status condition_variable::wait_for(unique_lock<mutex>& lock, cv_status condition_variable::wait_for(unique_lock<mutex>& lock,
const std::chrono::duration<Rep, Period>& timeout_duration) { const std::chrono::duration<Rep, Period>& timeout_duration) {
using namespace std::chrono; using namespace std::chrono;
using std::chrono::duration; using std::chrono::duration;
if (timeout_duration <= timeout_duration.zero()) { if (timeout_duration <= timeout_duration.zero()) {
return cv_status::timeout; return cv_status::timeout;
} }
timex_t timeout, before, after; timex_t timeout, before, after;
auto s = duration_cast<seconds>(timeout_duration); auto s = duration_cast<seconds>(timeout_duration);
timeout.seconds = s.count(); timeout.seconds = s.count();
timeout.microseconds = (duration_cast<microseconds>(timeout_duration) - s).count(); timeout.microseconds = (duration_cast<microseconds>(timeout_duration) - s).count();
vtimer_now(&before); vtimer_now(&before);
vtimer_t timer; vtimer_t timer;
vtimer_set_wakeup(&timer, timeout, sched_active_pid); vtimer_set_wakeup(&timer, timeout, sched_active_pid);
wait(lock); wait(lock);
vtimer_now(&after); vtimer_now(&after);
vtimer_remove(&timer); vtimer_remove(&timer);
auto passed = timex_sub(after,before); auto passed = timex_sub(after,before);
if (passed.seconds >= timeout.seconds && passed.microseconds >= timeout.microseconds) { auto cmp = timex_cmp(passed, timeout);
return cv_status::timeout; return cmp < 1 ? cv_status::no_timeout : cv_status::timeout;
} else {
return cv_status::no_timeout;
}
} }
template <class Rep, class Period, class Predicate> template <class Rep, class Period, class Predicate>
......
...@@ -103,4 +103,17 @@ void condition_variable::wait(unique_lock<mutex>& lock) noexcept { ...@@ -103,4 +103,17 @@ void condition_variable::wait(unique_lock<mutex>& lock) noexcept {
mutex_lock(lock.mutex()->native_handle()); mutex_lock(lock.mutex()->native_handle());
} }
cv_status condition_variable::wait_until(unique_lock<mutex>& lock,
const time_point& timeout_time) {
vtimer_t timer;
vtimer_set_wakeup_timepoint(&timer, timeout_time.native_handle(),
sched_active_pid);
wait(lock);
timex_t after;
vtimer_now(&after);
vtimer_remove(&timer);
auto cmp = timex_cmp(after,timeout_time.native_handle());
return cmp < 1 ? cv_status::no_timeout : cv_status::timeout;
}
} // namespace caf } // namespace caf
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment