cc/debug/lap_timer.cc

   1 // Copyright 2014 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/debug/lap_timer.h"
   6
   7 #include "base/logging.h"
   8
   9 namespace cc {
  10
  11 namespace {
  12
  13 // Returns the offset from the origin from the ThreadTicks time source.
  14 // TimeTicks is used as a fallback if ThreadTicks is not available on the
  15 // current platform.
  16 base::TimeDelta Now() {
  17   return base::ThreadTicks::IsSupported()
  18              ? base::ThreadTicks::Now() - base::ThreadTicks()
  19              : base::TimeTicks::Now() - base::TimeTicks();
  20 }
  21
  22 // Default values.
  23 static const int kTimeLimitMillis = 3000;
  24 static const int kWarmupRuns = 5;
  25 static const int kTimeCheckInterval = 10;
  26
  27 }  // namespace
  28
  29 LapTimer::LapTimer(int warmup_laps,
  30                    base::TimeDelta time_limit,
  31                    int check_interval)
  32     : warmup_laps_(warmup_laps),
  33       remaining_warmups_(0),
  34       remaining_no_check_laps_(0),
  35       time_limit_(time_limit),
  36       check_interval_(check_interval) {
  37   DCHECK_GT(check_interval, 0);
  38   Reset();
  39 }
  40
  41 LapTimer::LapTimer()
  42     : LapTimer(kWarmupRuns,
  43                base::TimeDelta::FromMilliseconds(kTimeLimitMillis),
  44                kTimeCheckInterval) {
  45 }
  46
  47 void LapTimer::Reset() {
  48   accumulator_ = base::TimeDelta();
  49   num_laps_ = 0;
  50   remaining_warmups_ = warmup_laps_;
  51   remaining_no_check_laps_ = check_interval_;
  52   Start();
  53 }
  54
  55 void LapTimer::Start() {
  56   start_time_ = Now();
  57 }
  58
  59 bool LapTimer::IsWarmedUp() { return remaining_warmups_ <= 0; }
  60
  61 void LapTimer::NextLap() {
  62   if (!IsWarmedUp()) {
  63     --remaining_warmups_;
  64     if (IsWarmedUp()) {
  65       Start();
  66     }
  67     return;
  68   }
  69   ++num_laps_;
  70   --remaining_no_check_laps_;
  71   if (!remaining_no_check_laps_) {
  72     base::TimeDelta now = Now();
  73     accumulator_ += now - start_time_;
  74     start_time_ = now;
  75     remaining_no_check_laps_ = check_interval_;
  76   }
  77 }
  78
  79 bool LapTimer::HasTimeLimitExpired() { return accumulator_ >= time_limit_; }
  80
  81 bool LapTimer::HasTimedAllLaps() { return !(num_laps_ % check_interval_); }
  82
  83 float LapTimer::MsPerLap() {
  84   DCHECK(HasTimedAllLaps());
  85   return accumulator_.InMillisecondsF() / num_laps_;
  86 }
  87
  88 float LapTimer::LapsPerSecond() {
  89   DCHECK(HasTimedAllLaps());
  90   return num_laps_ / accumulator_.InSecondsF();
  91 }
  92
  93 int LapTimer::NumLaps() { return num_laps_; }
  94
  95 }  // namespace cc