cv_status condition_variable::wait_until(unique_lock<mutex>& lock, const time_point& timeout_time) { xtimer_t timer; // todo: use function to wait for absolute timepoint once available timex_t before; xtimer_now_timex(&before); auto diff = timex_sub(timeout_time.native_handle(), before); xtimer_set_wakeup(&timer, timex_uint64(diff), sched_active_pid); wait(lock); timex_t after; xtimer_now_timex(&after); xtimer_remove(&timer); auto cmp = timex_cmp(after, timeout_time.native_handle()); return cmp < 1 ? cv_status::no_timeout : cv_status::timeout; }
/*! Retroactively revert a previous operation. * \param t The time point to revert. */ void revert(const time_point &t) { if (t.operation() == queue::push) { // This element was never pushed. --size_; // If t occurs before front, then that means we've previously popped an // element that no longer exists, so it should have popped the element // after it. Hence, move the front to its successor. if (t.it->second) { move_front_succ(); } else if (front_ == t.it) { // We're removing the front, so move it right to ensure validity. move_front_succ(); } // Remove the element corresponding to the push. data_.erase(t.it); } else { move_front_pred(); ++size_; // One less pop means the size increases by 1 } }
std::time_t VirtualClock::to_time_t(time_point point) { return static_cast<std::time_t>( std::chrono::duration_cast<std::chrono::seconds>( point.time_since_epoch()).count()); }
static struct timespec to_timespec(const time_point& tp) { using std::chrono::seconds; using std::chrono::nanoseconds; using std::chrono::duration_cast; duration d = tp.time_since_epoch(); seconds sec = duration_cast<seconds> (d); nanoseconds nsec = duration_cast<nanoseconds> (d - sec); struct timespec result = { sec.count(), nsec.count() }; return result; }
void timer::schedule_next_tick ( time_point const& expiration_time ) { // This will cancel any pending task. timer_.expires_at( expiration_time ); LOG_DEBUG( timer, this ) << "schedule callback at " << expiration_time.time_since_epoch().count() << "." << std::endl; auto on_fire = [ this ]( boost::system::error_code const& failure ) { // The current timeout has been canceled // hence stop right there. if ( failure == boost::asio::error::operation_aborted ) return; if ( failure ) throw std::system_error{ make_error_code( TIMER_MALFUNCTION ) }; // The callbacks to execute are the first // n callbacks with the same keys. auto begin = timeouts_.begin(); auto end = timeouts_.upper_bound( begin->first ); // Call the user callbacks. for ( auto i = begin; i != end; ++ i ) i->second(); LOG_DEBUG( timer, this ) << "remove " << std::distance( begin, end ) << " callback(s) scheduled at " << begin->first.time_since_epoch().count() << "." << std::endl; // And remove the timeout. timeouts_.erase( begin, end ); // If there is a remaining timeout, schedule it. if ( ! timeouts_.empty() ) { LOG_DEBUG( timer, this ) << "schedule remaining timers" << std::endl; schedule_next_tick( timeouts_.begin()->first ); } }; timer_.async_wait( on_fire ); }
std::string format(time_point tp, bool date, bool milliseconds) { auto time = clock::to_time_t(tp); tm tm = {}; #ifndef _WIN32 localtime_r(&time, &tm); #else localtime_s(&tm, &time); #endif auto Y = tm.tm_year + 1900; auto M = tm.tm_mon + 1; auto D = tm.tm_mday; auto h = tm.tm_hour; auto m = tm.tm_min; auto s = tm.tm_sec; auto ms = 0; if (milliseconds) { const auto t = tp.time_since_epoch(); const auto s = std::chrono::duration_cast<std::chrono::seconds>(t); const auto m = std::chrono::duration_cast<std::chrono::milliseconds>(t) - s; ms = static_cast<int>(m.count()); } int size = 0; std::string str; if (date && milliseconds) { str.resize(23 + 1); size = std::snprintf(&str[0], str.size(), "%04d-%02d-%02d %02d:%02d:%02d.%03d", Y, M, D, h, m, s, ms); } else if (date && !milliseconds) { str.resize(19 + 1); size = std::snprintf(&str[0], str.size(), "%04d-%02d-%02d %02d:%02d:%02d", Y, M, D, h, m, s); } else if (!date && milliseconds) { str.resize(12 + 1); size = std::snprintf(&str[0], str.size(), "%02d:%02d:%02d.%03d", h, m, s, ms); } else { str.resize(8 + 1); size = std::snprintf(&str[0], str.size(), "%02d:%02d:%02d", h, m, s); } str.resize(size > 0 ? size : 0); return str; }
TouchArray TouchTracker::getTestTouches(time_point<system_clock> now, int maxTouches) { TouchArray t{}; setMaxTouches(maxTouches); system_clock::duration dtn = now.time_since_epoch(); auto m = std::chrono::duration_cast<std::chrono::milliseconds>(dtn).count(); auto c = m%60000; int ic = c; float fc = ic; for(int i=0; i<maxTouches; ++i) { float minusI = 16-i; float rpm = 2.f*(i + 1); float theta = fc*rpm*kTwoPi/60000.f; float rx = 12.f/16.*minusI; float ry = 2.f/16.*minusI; float cx = 15.f; float cy = 2.5f; float x = cosf(theta)*rx + cx; float y = sinf(theta)*ry + cy; float theta2 = theta*8.f; float amp = sinf(theta2)*0.25f; t[i] = Touch{.x = x, .y = y, .z = amp}; } mTouches = t; // asymmetrical z filter from user setting. Ages are created here. mTouches = filterTouchesZ(mTouches, mTouches2, mLopassZ*2.f, mLopassZ*0.25f); mTouches2 = mTouches; mTouches = clampAndScaleTouches(mTouches); clearAndSendNextFrameIfNeeded(); return mTouches; }
iter_type put(time_point_units<CharT> const& units_facet, iter_type s, std::ios_base& ios, char_type fill, time_point<Clock, Duration> const& tp, const CharT* pattern, const CharT* pat_end) const { const std::ctype<char_type>& ct = std::use_facet<std::ctype<char_type> >(ios.getloc()); for (; pattern != pat_end; ++pattern) { if (ct.narrow(*pattern, 0) == '%') { if (++pattern == pat_end) { *s++ = pattern[-1]; break; } char fmt = ct.narrow(*pattern, 0); switch (fmt) { case 'd': { s = put_duration(s, ios, fill, tp.time_since_epoch()); break; } case 'e': { s = put_epoch<Clock> (units_facet, s, ios); break; } default: AUTOBOOST_ASSERT(false && "Boost::Chrono internal error."); break; } } else *s++ = *pattern; } return s; }
time_point_sec( const time_point& t ) :utc_seconds( t.time_since_epoch().count() / 1000000ll ){}
time_t cf_clock::to_time_t(const time_point &__t) noexcept { return time_t(__t.time_since_epoch().count() + kCFAbsoluteTimeIntervalSince1970); }
/* Conversion to system time */ static time_point to_system_time(const time_point& t) { static std::atomic<int64_t> ns_offset(0); static std::atomic<int64_t> offset_timestamp(0); static std::atomic_flag lock = ATOMIC_FLAG_INIT; static const duration OFFSET_TIMEOUT (15 * (int64_t)1E9, time_unit::NSEC); static const duration CLOSE_DISTANCE (15 * (int64_t)1E3, time_unit::NSEC); static const uint64_t MAX_UPDATE_TRIES (100); time_point current_tsc_time = tsc_clock::now(); time_unit tsc_unit = current_tsc_time.time_since_epoch().unit(); int64_t offset_ts = offset_timestamp.load(std::memory_order_acquire); if (offset_ts == 0 || current_tsc_time.time_since_epoch() - duration(offset_ts, tsc_unit) > OFFSET_TIMEOUT ) { if (!lock.test_and_set(std::memory_order_acquire)) { time_point cycles_start, cycles_end; time_point current_system_time; bool close_pair_found = false; for (uint64_t update_try = 0; update_try < MAX_UPDATE_TRIES; ++update_try) { cycles_start = tsc_clock::now(); current_system_time = system_clock::now(); cycles_end = tsc_clock::now(); if (cycles_end - cycles_start < CLOSE_DISTANCE) { close_pair_found = true; break; } } if (close_pair_found) { time_point cycles_middle = cycles_start + (cycles_end - cycles_start) / 2; int64_t new_offset = duration::convert_to( time_unit::NSEC, current_system_time.time_since_epoch() - cycles_middle.time_since_epoch() ) .count(); ns_offset.store(new_offset, std::memory_order_release); offset_timestamp.store(cycles_middle.time_since_epoch().count(), std::memory_order_release); } lock.clear(std::memory_order_release); } } return time_point( duration::convert_to( time_unit::NSEC, t.time_since_epoch() + duration(ns_offset.load(std::memory_order_acquire), time_unit::NSEC) ), clock_type::SYSTEM ); }
time_point(time_point<clock, Duration2> const & other) : duration_(other.time_since_epoch()) {}
static ::timespec to_native(const time_point& tp) { return to_native_duration(tp.time_since_epoch()); }