UMA metric for LayerUpdateTimes

cc/trees/layer_tree_host_in_process.cc

 // Copyright 2011 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 "cc/trees/layer_tree_host_in_process.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
 #include <memory>
 #include <stack>
 #include <string>
 #include <unordered_map>
 
 #include "base/atomic_sequence_num.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/location.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/numerics/safe_math.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/threading/thread_task_runner_handle.h"
+#include "base/timer/elapsed_timer.h"
 #include "base/trace_event/trace_event.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "cc/animation/animation_events.h"
 #include "cc/animation/animation_host.h"
 #include "cc/base/math_util.h"
 #include "cc/blimp/client_picture_cache.h"
 #include "cc/blimp/engine_picture_cache.h"
 #include "cc/blimp/image_serialization_processor.h"
 #include "cc/blimp/picture_data.h"
 #include "cc/blimp/picture_data_conversions.h"
@@ skipping 675 matching lines @@
   DCHECK(!settings_.single_thread_proxy_scheduler);
   SingleThreadProxy* proxy = static_cast<SingleThreadProxy*>(proxy_.get());
 
   proxy->CompositeImmediately(frame_begin_time);
 }
 
 bool LayerTreeHostInProcess::UpdateLayers() {
   if (!layer_tree_->root_layer())
     return false;
   DCHECK(!layer_tree_->root_layer()->parent());
+  base::ElapsedTimer timer;
+
   bool result = DoUpdateLayers(layer_tree_->root_layer());
   micro_benchmark_controller_.DidUpdateLayers();
+
+  std::string histogram_name = base::StringPrintf(
+      "Compositing.Renderer.LayersUpdateTime.%" PRIuS,
+      std::min(static_cast<size_t>(400), layer_tree_->NumLayers()) / 50);

[majidvp, 2016/11/15 13:10:55]

In the current patch I have a simple equal buckets of 80 wide. Number of active
layers is being collected in |Compositing.Browser.NumActiveLayers| histogram and
looking at that buckets of size 80 are probably too coarse. Perhaps we should
switch this to follow bucketization pattern of other histograms.

[flackr, 2016/11/16 16:56:50]

You mean 50 wide?
I'm not sure, I would like to know the difference between < 10 layers (which
seems to be a large number of frames), and 50, but beyond that I think targeting
some of the long tail, even though less common, makes sense since that's
representative of many of the bad cases we look at. Maybe we should just create
a special bucket for < 10 layers for a sort of baseline on ideal layer update
costs?

[majidvp, 2016/12/02 20:03:31]

Fair enough, I changed my bucketization to an expontial scheme
with a total of 5 buckets. Looking at the out UMA metrics for
number of layers I think that covers the most interesting cases.

+  base::Histogram::FactoryTimeGet(
+      histogram_name, base::TimeDelta::FromMilliseconds(1),
+      base::TimeDelta::FromSeconds(10), 50,
+      base::HistogramBase::kUmaTargetedHistogramFlag)
+      ->AddTime(timer.Elapsed());
+
   return result || next_commit_forces_redraw_;
 }
 
 void LayerTreeHostInProcess::DidCompletePageScaleAnimation() {
   did_complete_scale_animation_ = true;
 }
 
 void LayerTreeHostInProcess::RecordGpuRasterizationHistogram() {
   // Gpu rasterization is only supported for Renderer compositors.
   // Checking for IsSingleThreaded() to exclude Browser compositors.
@@ skipping 304 matching lines @@
 
   debug_state_.FromProtobuf(proto.debug_state());
   has_gpu_rasterization_trigger_ = proto.has_gpu_rasterization_trigger();
   content_is_suitable_for_gpu_rasterization_ =
       proto.content_is_suitable_for_gpu_rasterization();
   id_ = proto.id();
   next_commit_forces_redraw_ = proto.next_commit_forces_redraw();
 }
 
 }  // namespace cc