diff options
Diffstat (limited to 'cc/scheduler/delay_based_time_source.cc')
| -rw-r--r-- | cc/scheduler/delay_based_time_source.cc | 234 |
1 files changed, 234 insertions, 0 deletions
diff --git a/cc/scheduler/delay_based_time_source.cc b/cc/scheduler/delay_based_time_source.cc new file mode 100644 index 0000000..f7fb1b7 --- /dev/null +++ b/cc/scheduler/delay_based_time_source.cc @@ -0,0 +1,234 @@ +// Copyright 2011 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#include "cc/scheduler/delay_based_time_source.h" + +#include <algorithm> +#include <cmath> + +#include "base/debug/trace_event.h" +#include "base/logging.h" +#include "base/message_loop.h" +#include "cc/base/thread.h" + +namespace cc { + +namespace { + +// doubleTickThreshold prevents ticks from running within the specified fraction of an interval. +// This helps account for jitter in the timebase as well as quick timer reactivation. +const double doubleTickThreshold = 0.25; + +// intervalChangeThreshold is the fraction of the interval that will trigger an immediate interval change. +// phaseChangeThreshold is the fraction of the interval that will trigger an immediate phase change. +// If the changes are within the thresholds, the change will take place on the next tick. +// If either change is outside the thresholds, the next tick will be canceled and reissued immediately. +const double intervalChangeThreshold = 0.25; +const double phaseChangeThreshold = 0.25; + +} // namespace + +scoped_refptr<DelayBasedTimeSource> DelayBasedTimeSource::create(base::TimeDelta interval, Thread* thread) +{ + return make_scoped_refptr(new DelayBasedTimeSource(interval, thread)); +} + +DelayBasedTimeSource::DelayBasedTimeSource(base::TimeDelta interval, Thread* thread) + : m_client(0) + , m_hasTickTarget(false) + , m_currentParameters(interval, base::TimeTicks()) + , m_nextParameters(interval, base::TimeTicks()) + , m_state(STATE_INACTIVE) + , m_thread(thread) + , m_weakFactory(ALLOW_THIS_IN_INITIALIZER_LIST(this)) +{ +} + +DelayBasedTimeSource::~DelayBasedTimeSource() +{ +} + +void DelayBasedTimeSource::setActive(bool active) +{ + TRACE_EVENT1("cc", "DelayBasedTimeSource::setActive", "active", active); + if (!active) { + m_state = STATE_INACTIVE; + m_weakFactory.InvalidateWeakPtrs(); + return; + } + + if (m_state == STATE_STARTING || m_state == STATE_ACTIVE) + return; + + if (!m_hasTickTarget) { + // Becoming active the first time is deferred: we post a 0-delay task. When + // it runs, we use that to establish the timebase, become truly active, and + // fire the first tick. + m_state = STATE_STARTING; + m_thread->PostTask(base::Bind(&DelayBasedTimeSource::onTimerFired, m_weakFactory.GetWeakPtr())); + return; + } + + m_state = STATE_ACTIVE; + + postNextTickTask(now()); +} + +bool DelayBasedTimeSource::active() const +{ + return m_state != STATE_INACTIVE; +} + +base::TimeTicks DelayBasedTimeSource::lastTickTime() +{ + return m_lastTickTime; +} + +base::TimeTicks DelayBasedTimeSource::nextTickTime() +{ + return active() ? m_currentParameters.tickTarget : base::TimeTicks(); +} + +void DelayBasedTimeSource::onTimerFired() +{ + DCHECK(m_state != STATE_INACTIVE); + + base::TimeTicks now = this->now(); + m_lastTickTime = now; + + if (m_state == STATE_STARTING) { + setTimebaseAndInterval(now, m_currentParameters.interval); + m_state = STATE_ACTIVE; + } + + postNextTickTask(now); + + // Fire the tick + if (m_client) + m_client->onTimerTick(); +} + +void DelayBasedTimeSource::setClient(TimeSourceClient* client) +{ + m_client = client; +} + +void DelayBasedTimeSource::setTimebaseAndInterval(base::TimeTicks timebase, base::TimeDelta interval) +{ + m_nextParameters.interval = interval; + m_nextParameters.tickTarget = timebase; + m_hasTickTarget = true; + + if (m_state != STATE_ACTIVE) { + // If we aren't active, there's no need to reset the timer. + return; + } + + // If the change in interval is larger than the change threshold, + // request an immediate reset. + double intervalDelta = std::abs((interval - m_currentParameters.interval).InSecondsF()); + double intervalChange = intervalDelta / interval.InSecondsF(); + if (intervalChange > intervalChangeThreshold) { + setActive(false); + setActive(true); + return; + } + + // If the change in phase is greater than the change threshold in either + // direction, request an immediate reset. This logic might result in a false + // negative if there is a simultaneous small change in the interval and the + // fmod just happens to return something near zero. Assuming the timebase + // is very recent though, which it should be, we'll still be ok because the + // old clock and new clock just happen to line up. + double targetDelta = std::abs((timebase - m_currentParameters.tickTarget).InSecondsF()); + double phaseChange = fmod(targetDelta, interval.InSecondsF()) / interval.InSecondsF(); + if (phaseChange > phaseChangeThreshold && phaseChange < (1.0 - phaseChangeThreshold)) { + setActive(false); + setActive(true); + return; + } +} + +base::TimeTicks DelayBasedTimeSource::now() const +{ + return base::TimeTicks::Now(); +} + +// This code tries to achieve an average tick rate as close to m_interval as possible. +// To do this, it has to deal with a few basic issues: +// 1. postDelayedTask can delay only at a millisecond granularity. So, 16.666 has to +// posted as 16 or 17. +// 2. A delayed task may come back a bit late (a few ms), or really late (frames later) +// +// The basic idea with this scheduler here is to keep track of where we *want* to run in +// m_tickTarget. We update this with the exact interval. +// +// Then, when we post our task, we take the floor of (m_tickTarget and now()). If we +// started at now=0, and 60FPs (all times in milliseconds): +// now=0 target=16.667 postDelayedTask(16) +// +// When our callback runs, we figure out how far off we were from that goal. Because of the flooring +// operation, and assuming our timer runs exactly when it should, this yields: +// now=16 target=16.667 +// +// Since we can't post a 0.667 ms task to get to now=16, we just treat this as a tick. Then, +// we update target to be 33.333. We now post another task based on the difference between our target +// and now: +// now=16 tickTarget=16.667 newTarget=33.333 --> postDelayedTask(floor(33.333 - 16)) --> postDelayedTask(17) +// +// Over time, with no late tasks, this leads to us posting tasks like this: +// now=0 tickTarget=0 newTarget=16.667 --> tick(), postDelayedTask(16) +// now=16 tickTarget=16.667 newTarget=33.333 --> tick(), postDelayedTask(17) +// now=33 tickTarget=33.333 newTarget=50.000 --> tick(), postDelayedTask(17) +// now=50 tickTarget=50.000 newTarget=66.667 --> tick(), postDelayedTask(16) +// +// We treat delays in tasks differently depending on the amount of delay we encounter. Suppose we +// posted a task with a target=16.667: +// Case 1: late but not unrecoverably-so +// now=18 tickTarget=16.667 +// +// Case 2: so late we obviously missed the tick +// now=25.0 tickTarget=16.667 +// +// We treat the first case as a tick anyway, and assume the delay was +// unusual. Thus, we compute the newTarget based on the old timebase: +// now=18 tickTarget=16.667 newTarget=33.333 --> tick(), postDelayedTask(floor(33.333-18)) --> postDelayedTask(15) +// This brings us back to 18+15 = 33, which was where we would have been if the task hadn't been late. +// +// For the really late delay, we we move to the next logical tick. The timebase is not reset. +// now=37 tickTarget=16.667 newTarget=50.000 --> tick(), postDelayedTask(floor(50.000-37)) --> postDelayedTask(13) +base::TimeTicks DelayBasedTimeSource::nextTickTarget(base::TimeTicks now) +{ + base::TimeDelta newInterval = m_nextParameters.interval; + int intervalsElapsed = static_cast<int>(floor((now - m_nextParameters.tickTarget).InSecondsF() / newInterval.InSecondsF())); + base::TimeTicks lastEffectiveTick = m_nextParameters.tickTarget + newInterval * intervalsElapsed; + base::TimeTicks newTickTarget = lastEffectiveTick + newInterval; + DCHECK(newTickTarget > now); + + // Avoid double ticks when: + // 1) Turning off the timer and turning it right back on. + // 2) Jittery data is passed to setTimebaseAndInterval(). + if (newTickTarget - m_lastTickTime <= newInterval / static_cast<int>(1.0 / doubleTickThreshold)) + newTickTarget += newInterval; + + return newTickTarget; +} + +void DelayBasedTimeSource::postNextTickTask(base::TimeTicks now) +{ + base::TimeTicks newTickTarget = nextTickTarget(now); + + // Post another task *before* the tick and update state + base::TimeDelta delay = newTickTarget - now; + DCHECK(delay.InMillisecondsF() <= + m_nextParameters.interval.InMillisecondsF() * (1.0 + doubleTickThreshold)); + m_thread->PostDelayedTask(base::Bind(&DelayBasedTimeSource::onTimerFired, + m_weakFactory.GetWeakPtr()), + delay); + + m_nextParameters.tickTarget = newTickTarget; + m_currentParameters = m_nextParameters; +} + +} // namespace cc |