cc/frame_rate_counter.cc

   1 // Copyright 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "cc/frame_rate_counter.h"
   6
   7 #include <cmath>
   8
   9 #include "base/metrics/histogram.h"
  10 #include "cc/proxy.h"
  11
  12 namespace cc {
  13
  14 const double FrameRateCounter::kFrameTooFast = 1.0 / 70.0; // measured in seconds
  15 const double FrameRateCounter::kFrameTooSlow = 1.0 / 4.0;
  16 const double FrameRateCounter::kDroppedFrameTime = 1.0 / 50.0;
  17
  18 // safeMod works on -1, returning m-1 in that case.
  19 static inline int safeMod(int number, int modulus)
  20 {
  21     return (number + modulus) % modulus;
  22 }
  23
  24 // static
  25 scoped_ptr<FrameRateCounter> FrameRateCounter::create(bool hasImplThread) {
  26   return make_scoped_ptr(new FrameRateCounter(hasImplThread));
  27 }
  28
  29 inline base::TimeDelta FrameRateCounter::frameInterval(int frameNumber) const
  30 {
  31     return m_timeStampHistory[frameIndex(frameNumber)] -
  32         m_timeStampHistory[frameIndex(frameNumber - 1)];
  33 }
  34
  35 inline int FrameRateCounter::frameIndex(int frameNumber) const
  36 {
  37     return safeMod(frameNumber, kTimeStampHistorySize);
  38 }
  39
  40 FrameRateCounter::FrameRateCounter(bool hasImplThread)
  41     : m_hasImplThread(hasImplThread)
  42     , m_currentFrameNumber(1)
  43     , m_droppedFrameCount(0)
  44 {
  45     m_timeStampHistory[0] = base::TimeTicks::Now();
  46     m_timeStampHistory[1] = m_timeStampHistory[0];
  47     for (int i = 2; i < kTimeStampHistorySize; i++)
  48         m_timeStampHistory[i] = base::TimeTicks();
  49 }
  50
  51 void FrameRateCounter::markBeginningOfFrame(base::TimeTicks timestamp)
  52 {
  53     m_timeStampHistory[frameIndex(m_currentFrameNumber)] = timestamp;
  54     base::TimeDelta frameIntervalSeconds = frameInterval(m_currentFrameNumber);
  55
  56     if (m_hasImplThread && m_currentFrameNumber > 0) {
  57         HISTOGRAM_CUSTOM_COUNTS("Renderer4.CompositorThreadImplDrawDelay", frameIntervalSeconds.InMilliseconds(), 1, 120, 60);
  58     }
  59
  60     if (!isBadFrameInterval(frameIntervalSeconds) &&
  61         frameIntervalSeconds.InSecondsF() > kDroppedFrameTime)
  62         ++m_droppedFrameCount;
  63 }
  64
  65 void FrameRateCounter::markEndOfFrame()
  66 {
  67     m_currentFrameNumber += 1;
  68 }
  69
  70 bool FrameRateCounter::isBadFrameInterval(base::TimeDelta intervalBetweenConsecutiveFrames) const
  71 {
  72     double delta = intervalBetweenConsecutiveFrames.InSecondsF();
  73     bool schedulerAllowsDoubleFrames = !m_hasImplThread;
  74     bool intervalTooFast = schedulerAllowsDoubleFrames ? delta < kFrameTooFast : delta <= 0.0;
  75     bool intervalTooSlow = delta > kFrameTooSlow;
  76     return intervalTooFast || intervalTooSlow;
  77 }
  78
  79 bool FrameRateCounter::isBadFrame(int frameNumber) const
  80 {
  81     return isBadFrameInterval(frameInterval(frameNumber));
  82 }
  83
  84 double FrameRateCounter::getAverageFPS() const
  85 {
  86     int frameNumber = m_currentFrameNumber - 1;
  87     int frameCount = 0;
  88     double frameTimesTotal = 0;
  89     double averageFPS = 0;
  90
  91     // Walk backwards through the samples looking for a run of good frame
  92     // timings from which to compute the mean.
  93     //
  94     // Slow frames occur just because the user is inactive, and should be
  95     // ignored. Fast frames are ignored if the scheduler is in single-thread
  96     // mode in order to represent the true frame rate in spite of the fact that
  97     // the first few swapbuffers happen instantly which skews the statistics
  98     // too much for short lived animations.
  99     //
 100     // isBadFrameInterval encapsulates the frame too slow/frame too fast logic.
 101
 102     while (frameIndex(frameNumber) != frameIndex(m_currentFrameNumber) && frameNumber >= 0 && frameTimesTotal < 1.0) {
 103         base::TimeDelta delta = frameInterval(frameNumber);
 104
 105         if (!isBadFrameInterval(delta)) {
 106             frameCount++;
 107             frameTimesTotal += delta.InSecondsF();
 108         } else if (frameCount)
 109             break;
 110
 111         frameNumber--;
 112     }
 113
 114     if (frameCount)
 115         averageFPS = frameCount / frameTimesTotal;
 116
 117     return averageFPS;
 118 }
 119
 120 base::TimeTicks FrameRateCounter::timeStampOfRecentFrame(int n) const
 121 {
 122     DCHECK(n >= 0);
 123     DCHECK(n < kTimeStampHistorySize);
 124     int desiredIndex = (frameIndex(m_currentFrameNumber) + n) % kTimeStampHistorySize;
 125     return m_timeStampHistory[desiredIndex];
 126 }
 127
 128 }  // namespace cc