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::HighResNow();
  47 }
  48
  49 void ProxyTimingHistory::DidCommit() {
  50   commit_complete_time_ = base::TimeTicks::HighResNow();
  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::HighResNow() - 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::HighResNow();
  81 }
  82
  83 void ProxyTimingHistory::DidFinishDrawing() {
  84   base::TimeDelta draw_duration =
  85       base::TimeTicks::HighResNow() - start_draw_time_;
  86
  87   // Before adding the new data point to the timing history, see what we would
  88   // have predicted for this frame. This allows us to keep track of the accuracy
  89   // of our predictions.
  90   base::TimeDelta draw_duration_estimate = DrawDurationEstimate();
  91   rendering_stats_instrumentation_->AddDrawDuration(draw_duration,
  92                                                     draw_duration_estimate);
  93
  94   AddDrawDurationUMA(draw_duration, draw_duration_estimate);
  95
  96   draw_duration_history_.InsertSample(draw_duration);
  97 }
  98
  99 void ProxyTimingHistory::AddDrawDurationUMA(
 100     base::TimeDelta draw_duration,
 101     base::TimeDelta draw_duration_estimate) {
 102   base::TimeDelta draw_duration_overestimate;
 103   base::TimeDelta draw_duration_underestimate;
 104   if (draw_duration > draw_duration_estimate)
 105     draw_duration_underestimate = draw_duration - draw_duration_estimate;
 106   else
 107     draw_duration_overestimate = draw_duration_estimate - draw_duration;
 108   UMA_HISTOGRAM_CUSTOM_TIMES("Renderer.DrawDuration",
 109                              draw_duration,
 110                              base::TimeDelta::FromMilliseconds(1),
 111                              base::TimeDelta::FromMilliseconds(100),
 112                              50);
 113   UMA_HISTOGRAM_CUSTOM_TIMES("Renderer.DrawDurationUnderestimate",
 114                              draw_duration_underestimate,
 115                              base::TimeDelta::FromMilliseconds(1),
 116                              base::TimeDelta::FromMilliseconds(100),
 117                              50);
 118   UMA_HISTOGRAM_CUSTOM_TIMES("Renderer.DrawDurationOverestimate",
 119                              draw_duration_overestimate,
 120                              base::TimeDelta::FromMilliseconds(1),
 121                              base::TimeDelta::FromMilliseconds(100),
 122                              50);
 123 }
 124
 125 }  // namespace cc