cc: Improve frame/commit accounting

cc/frame_rate_counter.cc

 // Copyright 2012 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 "config.h"
 
 #include "CCFrameRateCounter.h"
 
 #include <cmath>
 
 #include "CCProxy.h"
 #include <public/Platform.h>
 
 namespace cc {
 
-const double CCFrameRateCounter::kFrameTooFast = 1.0 / 70.0; // measured in seconds
-const double CCFrameRateCounter::kFrameTooSlow = 1.0 / 12.0;
-const double CCFrameRateCounter::kDroppedFrameTime = 1.0 / 50.0;
-
 // safeMod works on -1, returning m-1 in that case.
 static inline int safeMod(int number, int modulus)
 {
     return (number + modulus) % modulus;
 }
 
 // static
 scoped_ptr<CCFrameRateCounter> CCFrameRateCounter::create() {
   return make_scoped_ptr(new CCFrameRateCounter());
 }
 
+void CCFrameRateCounter::setTimebaseAndInterval(base::TimeTicks timebase, base::TimeDelta interval)
+{
+    if (interval != m_interval) {
+        base::TimeTicks now = base::TimeTicks::Now();
+        if (m_interval != base::TimeDelta())
+            m_vsyncCount += (now - m_intervalChangedTime + (m_interval/2)) / m_interval;
+        m_intervalChangedTime = now;
+        m_interval = interval;
+    }
+
+    m_frameTooFastSeconds = 0.8 * interval.InSecondsF();
+    m_frameTooSlowSeconds = 1.0 / 12.0;
+}
+
 inline base::TimeDelta CCFrameRateCounter::frameInterval(int frameNumber) const
 {
     return m_timeStampHistory[frameIndex(frameNumber)] -
         m_timeStampHistory[frameIndex(frameNumber - 1)];
 }
 
 inline int CCFrameRateCounter::frameIndex(int frameNumber) const
 {
     return safeMod(frameNumber, kTimeStampHistorySize);
 }
 
 CCFrameRateCounter::CCFrameRateCounter()
-    : m_currentFrameNumber(1)
-    , m_droppedFrameCount(0)
+    : m_vsyncCount(0)
+    , m_currentFrameNumber(1)
 {
+    setTimebaseAndInterval(
+        base::TimeTicks(), base::TimeDelta::FromMicroseconds(base::Time::kMicrosecondsPerSecond / 60));

[reveman, 2012/10/17 19:32:30]

this assumes that 60FPS is the initial frame rate, right? can you instead pass
timebase and interval to the constructor so we don't have to worry about keeping
this in sync with thread_proxy.cc?

or if you know that setTimebaseAndInterval will always be called before these
values are used you can just initialize them to some unique values and ASSERT if
that condition is not met.

[brianderson, 2012/10/17 22:34:48]

Done.

+
     m_timeStampHistory[0] = base::TimeTicks::Now();
     m_timeStampHistory[1] = m_timeStampHistory[0];
     for (int i = 2; i < kTimeStampHistorySize; i++)
         m_timeStampHistory[i] = base::TimeTicks();
 }
 
 void CCFrameRateCounter::markBeginningOfFrame(base::TimeTicks timestamp)
 {
     m_timeStampHistory[frameIndex(m_currentFrameNumber)] = timestamp;
     base::TimeDelta frameIntervalSeconds = frameInterval(m_currentFrameNumber);
 
     if (CCProxy::hasImplThread() && m_currentFrameNumber > 0) {
         double drawDelayMs = frameIntervalSeconds.InMillisecondsF();
         WebKit::Platform::current()->histogramCustomCounts("Renderer4.CompositorThreadImplDrawDelay", static_cast<int>(drawDelayMs), 1, 120, 60);
     }
 
-    if (!isBadFrameInterval(frameIntervalSeconds) &&
-        frameIntervalSeconds.InSecondsF() > kDroppedFrameTime)
-        ++m_droppedFrameCount;
 }
 
 void CCFrameRateCounter::markEndOfFrame()
 {
     m_currentFrameNumber += 1;
 }
 
 bool CCFrameRateCounter::isBadFrameInterval(base::TimeDelta intervalBetweenConsecutiveFrames) const
 {
     bool schedulerAllowsDoubleFrames = !CCProxy::hasImplThread();
-    bool intervalTooFast = schedulerAllowsDoubleFrames && intervalBetweenConsecutiveFrames.InSecondsF() < kFrameTooFast;
-    bool intervalTooSlow = intervalBetweenConsecutiveFrames.InSecondsF() > kFrameTooSlow;
+    bool intervalTooFast = schedulerAllowsDoubleFrames && intervalBetweenConsecutiveFrames.InSecondsF() < m_frameTooFastSeconds;
+    bool intervalTooSlow = intervalBetweenConsecutiveFrames.InSecondsF() > m_frameTooSlowSeconds;
     return intervalTooFast || intervalTooSlow;
 }
 
 bool CCFrameRateCounter::isBadFrame(int frameNumber) const
 {
     return isBadFrameInterval(frameInterval(frameNumber));
 }
 
 void CCFrameRateCounter::getAverageFPSAndStandardDeviation(double& averageFPS, double& standardDeviation) const
 {
@@ skipping 37 matching lines @@
     standardDeviation = sqrt(fpsVarianceNumerator / averageFPSCount);
 }
 
 base::TimeTicks CCFrameRateCounter::timeStampOfRecentFrame(int n)
 {
     ASSERT(n >= 0 && n < kTimeStampHistorySize);
     int desiredIndex = (frameIndex(m_currentFrameNumber) + n) % kTimeStampHistorySize;
     return m_timeStampHistory[desiredIndex];
 }
 
+void CCFrameRateCounter::renderingStats(CCRenderingStats* stats) const
+{
+    base::TimeTicks now = base::TimeTicks::Now();
+
+    stats->vsyncCount = m_vsyncCount;
+    if (m_interval != base::TimeDelta())
+        stats->vsyncCount += (now - m_intervalChangedTime + (m_interval/2)) / m_interval;

[reveman, 2012/10/17 19:32:30]

this same logic is used in setTimebaseAndInterval. can you move this into
utility function rather than duplicating it.

[brianderson, 2012/10/17 22:34:48]

Done.

+
+    stats->rendererFrameCount = m_currentFrameNumber - 1;
+    stats->droppedFrameCount = stats->vsyncCount - (m_currentFrameNumber - 1);

[reveman, 2012/10/17 19:32:30]

Looks like droppedFrameCount is unnecessary. Should we remove this field and
have our test code compute it instead?

[brianderson, 2012/10/17 22:34:48]

I think it would be nice to keep it as a separate field in case we ever want to
calculate it in a different way.

+}
+
 }  // namespace cc