Commit ec9aebc4 authored by Joseph Noir's avatar Joseph Noir

Add wait until based on new chrono header

parent 9fcdc799
......@@ -24,10 +24,11 @@
#ifdef __RIOTBUILD_FLAG
#include <chrono>
#include "mutex.hpp"
#include "caf/chrono.hpp"
extern "C" {
#include "sched.h"
#include "vtimer.h"
......@@ -53,12 +54,10 @@ class condition_variable {
void wait(unique_lock<mutex>& lock) noexcept;
template <class Predicate>
void wait(unique_lock<mutex>& lock, Predicate pred);
template <class Clock, class Duration>
cv_status wait_until(unique_lock<mutex>& lock,
const std::chrono::time_point<Clock, Duration>& timeout_time);
template <class Clock, class Duration, class Predicate>
bool wait_until(unique_lock<mutex>& lock,
const std::chrono::time_point<Clock,Duration>& timeout_time,
const time_point& timeout_time);
template <class Predicate>
bool wait_until(unique_lock<mutex>& lock, const time_point& timeout_time,
Predicate pred);
template <class Rep, class Period>
cv_status wait_for(unique_lock<mutex>& lock,
......@@ -94,19 +93,10 @@ void condition_variable::wait(unique_lock<mutex>& lock, Predicate pred) {
}
}
template <class Clock, class Duration>
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>
template <class Predicate>
bool condition_variable::wait_until(unique_lock<mutex>& lock,
const std::chrono::time_point<Clock,Duration>& timeout_time,
Predicate pred) {
const time_point& timeout_time,
Predicate pred) {
while (!pred()) {
if (wait_until(lock, timeout_time) == cv_status::timeout) {
return pred();
......@@ -118,27 +108,24 @@ bool condition_variable::wait_until(unique_lock<mutex>& lock,
template <class Rep, class Period>
cv_status condition_variable::wait_for(unique_lock<mutex>& lock,
const std::chrono::duration<Rep, Period>& timeout_duration) {
using namespace std::chrono;
using std::chrono::duration;
if (timeout_duration <= timeout_duration.zero()) {
return cv_status::timeout;
}
timex_t timeout, before, after;
auto s = duration_cast<seconds>(timeout_duration);
timeout.seconds = s.count();
timeout.microseconds = (duration_cast<microseconds>(timeout_duration) - s).count();
vtimer_now(&before);
vtimer_t timer;
vtimer_set_wakeup(&timer, timeout, sched_active_pid);
wait(lock);
vtimer_now(&after);
vtimer_remove(&timer);
auto passed = timex_sub(after,before);
if (passed.seconds >= timeout.seconds && passed.microseconds >= timeout.microseconds) {
return cv_status::timeout;
} else {
return cv_status::no_timeout;
}
using namespace std::chrono;
using std::chrono::duration;
if (timeout_duration <= timeout_duration.zero()) {
return cv_status::timeout;
}
timex_t timeout, before, after;
auto s = duration_cast<seconds>(timeout_duration);
timeout.seconds = s.count();
timeout.microseconds = (duration_cast<microseconds>(timeout_duration) - s).count();
vtimer_now(&before);
vtimer_t timer;
vtimer_set_wakeup(&timer, timeout, sched_active_pid);
wait(lock);
vtimer_now(&after);
vtimer_remove(&timer);
auto passed = timex_sub(after,before);
auto cmp = timex_cmp(passed, timeout);
return cmp < 1 ? cv_status::no_timeout : cv_status::timeout;
}
template <class Rep, class Period, class Predicate>
......
......@@ -103,4 +103,17 @@ void condition_variable::wait(unique_lock<mutex>& lock) noexcept {
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
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