TimeDelta unpackDelta(PackedDateTimeDelta delta) { auto days = int(delta / USECS_PER_DAY); delta %= USECS_PER_DAY; auto seconds = int(delta / USECS_PER_SEC); return TimeDelta(days, seconds, delta % USECS_PER_SEC); }
void MessagePumpLibevent::Run(Delegate* delegate) { //DCHECK(keep_running_) << "Quit must have been called outside of Run!"; assert(keep_running_); // event_base_loopexit() + EVLOOP_ONCE is leaky, see http://crbug.com/25641. // Instead, make our own timer and reuse it on each call to event_base_loop(). std::unique_ptr<event> timer_event(new event); for (;;) { bool did_work = delegate->DoWork(); if (!keep_running_) break; event_base_loop(event_base_, EVLOOP_NONBLOCK); did_work |= processed_io_events_; processed_io_events_ = false; if (!keep_running_) break; did_work |= delegate->DoDelayedWork(&delayed_work_time_); if (!keep_running_) break; if (did_work) continue; did_work = delegate->DoIdleWork(); if (!keep_running_) break; if (did_work) continue; // EVLOOP_ONCE tells libevent to only block once, // but to service all pending events when it wakes up. if (delayed_work_time_.is_null()) { event_base_loop(event_base_, EVLOOP_ONCE); } else { TimeDelta delay = delayed_work_time_ - TimeTicks::Now(); if (delay > TimeDelta()) { struct timeval poll_tv; poll_tv.tv_sec = (long)delay.InSeconds(); poll_tv.tv_usec = delay.InMicroseconds() % Time::kMicrosecondsPerSecond; event_set(timer_event.get(), -1, 0, timer_callback, event_base_); event_base_set(event_base_, timer_event.get()); event_add(timer_event.get(), &poll_tv); event_base_loop(event_base_, EVLOOP_ONCE); event_del(timer_event.get()); } else { delayed_work_time_ = TimeTicks(); } } } keep_running_ = true; }
bool MessageLoopProxy::PostTaskHelper( const StdClosure& task, TimeDelta delay, bool nestable) { NAutoLock lock(&message_loop_lock_); if (target_message_loop_) { if (nestable) { if (delay == TimeDelta()) target_message_loop_->PostTask(task); else target_message_loop_->PostDelayedTask(task, delay); } else { if (delay == TimeDelta()) target_message_loop_->PostNonNestableTask(task); else target_message_loop_->PostNonNestableDelayedTask(task, delay); } return true; } return false; }
TimeDelta getMJD( int ridx ) { GUInt32 mjd[3] ; if ( ridx < 0 ) ridx += nrec ; EnvisatFile_ReadDatasetRecordChunk(&envfile,index,ridx,mjd,0,12) ; #define INT32(x) ((GInt32)CPL_MSBWORD32(x)) return TimeDelta( INT32(mjd[0]), INT32(mjd[1]), INT32(mjd[2]) ) ; #undef INT32 }
void DefaultMessagePump::Run(Delegate* delegate) { // Quit must have been called outside of Run! assert(should_quit_ == false); for (;;) { bool did_work = delegate->DoWork(); if (should_quit_) break; did_work |= delegate->DoDelayedWork(&delayed_work_time_); if (should_quit_) break; if (did_work) continue; did_work = delegate->DoIdleWork(); if (should_quit_) break; if (did_work) continue; if (delayed_work_time_.is_null()) { Wait(); } else { TimeDelta delay = delayed_work_time_ - TimeTicks::Now(); if (delay > TimeDelta()) WaitTimeout(delay); else { // It looks like delayed_work_time_ indicates a time in the past, so we // need to call DoDelayedWork now. delayed_work_time_ = TimeTicks(); } } } should_quit_ = false; }
TimeDelta operator/(const T &n) const { return TimeDelta(delta_ / n); }
TimeDelta operator*(const T &n) const { return TimeDelta(delta_ * n); }
TimeDelta operator-(const TimeDelta &other) const { return TimeDelta(delta_ - other.delta_); }
// static inline TimeDelta TimeDelta::FromMicroseconds(int64_t us) { return TimeDelta(us); }
bool MessageLoopProxy::PostNonNestableTask(const StdClosure &task) { return PostTaskHelper(task, TimeDelta(), false); }
// static inline TimeDelta TimeDelta::FromSeconds(int64_t secs) { return TimeDelta(secs * Time::kMicrosecondsPerSecond); }
// static inline TimeDelta TimeDelta::FromMinutes(int64_t minutes) { return TimeDelta(minutes * Time::kMicrosecondsPerMinute); }
// static inline TimeDelta TimeDelta::FromHours(int64_t hours) { return TimeDelta(hours * Time::kMicrosecondsPerHour); }
// static inline TimeDelta TimeDelta::FromDays(int64_t days) { return TimeDelta(days * Time::kMicrosecondsPerDay); }
TimeDelta Diff(const Time &other) const { return TimeDelta(us_ - other.us_); }
// static inline TimeDelta TimeDelta::FromMilliseconds(int64_t ms) { return TimeDelta(ms * Time::kMicrosecondsPerMillisecond); }
void X11UIEventLoopImpl::waitForWork() { int fd = _engine->_fd; int fdSize = Math::max(fd, _engine->_wakeUpPipe[0]) + 1; fd_set fdSet; struct timeval tval; struct timeval* ptval = NULL; FD_ZERO(&fdSet); FD_SET(fd, &fdSet); FD_SET(_engine->_wakeUpPipe[0], &fdSet); if (_delayedWorkTime.isNull()) { // There are no scheduled tasks, so ptval is NULL and this tells to select() // that it should wait infinite time. } else { TimeDelta delay = _delayedWorkTime - Time::now(); if (delay > TimeDelta()) { // Go to sleep. X11 will wake us to process X events and we also set // interval to wake up to run planned tasks (usually Timers). int64_t udelay = delay.getMicroseconds(); tval.tv_sec = (int)(udelay / 1000000); tval.tv_usec = (int)(udelay % 1000000); if (tval.tv_usec <= 100) tval.tv_usec = 100; ptval = &tval; } else { // It looks like delayedWorkTime indicates a time in the past, so we // need to call doDelayedWork now. _delayedWorkTime = Time(); return; } } int ret = ::select(fdSize, &fdSet, NULL, NULL, ptval); if (ret < 0) { Logger::error("Fog::X11UIEventLoopImpl", "waitForWork", "Failed to call select(), errno=%d.", errno); } if (ret > 0) { if (FD_ISSET(_engine->_wakeUpPipe[0], &fdSet)) { // Dummy c, the actual value is out of our interest. char c; if (::read(_engine->_wakeUpPipe[0], &c, sizeof(char)) != sizeof(char)) { Logger::error("Fog::X11UIEventLoopImpl", "waitForWork()", "Failed to read from wake-up pipe."); } _wakeUpSent.cmpXchg(1, 0); } } }
bool MessageLoopProxy::PostTask(const StdClosure &task) { return PostTaskHelper(task, TimeDelta(), true); }