cc/trees/proxy_timing_history.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/trees/proxy_timing_history.h"
   6
   7 #include "base/metrics/histogram.h"
   8
   9 const size_t kDurationHistorySize = 60;
  10 const double kCommitAndActivationDurationEstimationPercentile = 50.0;
  11 const double kDrawDurationEstimationPercentile = 100.0;
  12 const int kDrawDurationEstimatePaddingInMicroseconds = 0;
  13
  14 namespace cc {
  15
  16 ProxyTimingHistory::ProxyTimingHistory(
  17     RenderingStatsInstrumentation* rendering_stats_instrumentation)
  18     : draw_duration_history_(kDurationHistorySize),
  19       begin_main_frame_to_commit_duration_history_(kDurationHistorySize),
  20       commit_to_activate_duration_history_(kDurationHistorySize),
  21       rendering_stats_instrumentation_(rendering_stats_instrumentation) {
  22 }
  23
  24 ProxyTimingHistory::~ProxyTimingHistory() {}
  25
  26 base::TimeDelta ProxyTimingHistory::DrawDurationEstimate() const {
  27   base::TimeDelta historical_estimate =
  28       draw_duration_history_.Percentile(kDrawDurationEstimationPercentile);
  29   base::TimeDelta padding = base::TimeDelta::FromMicroseconds(
  30       kDrawDurationEstimatePaddingInMicroseconds);
  31   return historical_estimate + padding;
  32 }
  33
  34 base::TimeDelta ProxyTimingHistory::BeginMainFrameToCommitDurationEstimate()
  35     const {
  36   return begin_main_frame_to_commit_duration_history_.Percentile(
  37       kCommitAndActivationDurationEstimationPercentile);
  38 }
  39
  40 base::TimeDelta ProxyTimingHistory::CommitToActivateDurationEstimate() const {
  41   return commit_to_activate_duration_history_.Percentile(
  42       kCommitAndActivationDurationEstimationPercentile);
  43 }
  44
  45 void ProxyTimingHistory::DidBeginMainFrame() {
  46   begin_main_frame_sent_time_ = base::TimeTicks::Now();
  47 }
  48
  49 void ProxyTimingHistory::DidCommit() {
  50   commit_complete_time_ = base::TimeTicks::Now();
  51   base::TimeDelta begin_main_frame_to_commit_duration =
  52       commit_complete_time_ - begin_main_frame_sent_time_;
  53
  54   // Before adding the new data point to the timing history, see what we would
  55   // have predicted for this frame. This allows us to keep track of the accuracy
  56   // of our predictions.
  57   rendering_stats_instrumentation_->AddBeginMainFrameToCommitDuration(
  58       begin_main_frame_to_commit_duration,
  59       BeginMainFrameToCommitDurationEstimate());
  60
  61   begin_main_frame_to_commit_duration_history_.InsertSample(
  62       begin_main_frame_to_commit_duration);
  63 }
  64
  65 void ProxyTimingHistory::DidActivateSyncTree() {
  66   base::TimeDelta commit_to_activate_duration =
  67       base::TimeTicks::Now() - commit_complete_time_;
  68
  69   // Before adding the new data point to the timing history, see what we would
  70   // have predicted for this frame. This allows us to keep track of the accuracy
  71   // of our predictions.
  72   rendering_stats_instrumentation_->AddCommitToActivateDuration(
  73       commit_to_activate_duration, CommitToActivateDurationEstimate());
  74
  75   commit_to_activate_duration_history_.InsertSample(
  76       commit_to_activate_duration);
  77 }
  78
  79 void ProxyTimingHistory::DidStartDrawing() {
  80   start_draw_time_ = base::TimeTicks::Now();
  81 }
  82
  83 void ProxyTimingHistory::DidFinishDrawing() {
  84   base::TimeDelta draw_duration = base::TimeTicks::Now() - start_draw_time_;
  85
  86   // Before adding the new data point to the timing history, see what we would
  87   // have predicted for this frame. This allows us to keep track of the accuracy
  88   // of our predictions.
  89   base::TimeDelta draw_duration_estimate = DrawDurationEstimate();
  90   rendering_stats_instrumentation_->AddDrawDuration(draw_duration,
  91                                                     draw_duration_estimate);
  92
  93   AddDrawDurationUMA(draw_duration, draw_duration_estimate);
  94
  95   draw_duration_history_.InsertSample(draw_duration);
  96 }
  97
  98 void ProxyTimingHistory::AddDrawDurationUMA(
  99     base::TimeDelta draw_duration,
 100     base::TimeDelta draw_duration_estimate) {
 101   base::TimeDelta draw_duration_overestimate;
 102   base::TimeDelta draw_duration_underestimate;
 103   if (draw_duration > draw_duration_estimate)
 104     draw_duration_underestimate = draw_duration - draw_duration_estimate;
 105   else
 106     draw_duration_overestimate = draw_duration_estimate - draw_duration;
 107   UMA_HISTOGRAM_CUSTOM_TIMES("Renderer.DrawDuration",
 108                              draw_duration,
 109                              base::TimeDelta::FromMilliseconds(1),
 110                              base::TimeDelta::FromMilliseconds(100),
 111                              50);
 112   UMA_HISTOGRAM_CUSTOM_TIMES("Renderer.DrawDurationUnderestimate",
 113                              draw_duration_underestimate,
 114                              base::TimeDelta::FromMilliseconds(1),
 115                              base::TimeDelta::FromMilliseconds(100),
 116                              50);
 117   UMA_HISTOGRAM_CUSTOM_TIMES("Renderer.DrawDurationOverestimate",
 118                              draw_duration_overestimate,
 119                              base::TimeDelta::FromMilliseconds(1),
 120                              base::TimeDelta::FromMilliseconds(100),
 121                              50);
 122 }
 123
 124 }  // namespace cc