Split up software and gpu raster time UMA stats

cc/tiles/tile_manager.cc

 // Copyright 2012 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/tiles/tile_manager.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
 #include <limits>
 #include <string>
 
 #include "base/bind.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram.h"
 #include "base/numerics/safe_conversions.h"
+#include "base/optional.h"
 #include "base/threading/thread_checker.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "cc/base/histograms.h"
 #include "cc/debug/devtools_instrumentation.h"
 #include "cc/debug/frame_viewer_instrumentation.h"
 #include "cc/debug/traced_value.h"
 #include "cc/layers/picture_layer_impl.h"
 #include "cc/raster/raster_buffer.h"
 #include "cc/raster/task_category.h"
 #include "cc/tiles/tile.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 
 namespace cc {
 namespace {
 
 // Flag to indicate whether we should try and detect that
 // a tile is of solid color.
 const bool kUseColorEstimator = true;
 
+// TODO(enne): remove this histogram and its monitoring once there is enough new
+// data from the other two raster task timers.

[Ilya Sherman, 2016/10/03 20:59:11]

nit: Mebbe provide a rough milestone target?

 DEFINE_SCOPED_UMA_HISTOGRAM_AREA_TIMER(
-    ScopedRasterTaskTimer,
+    ScopedGeneralRasterTaskTimer,
     "Compositing.%s.RasterTask.RasterUs",
     "Compositing.%s.RasterTask.RasterPixelsPerMs");
 
+DEFINE_SCOPED_UMA_HISTOGRAM_AREA_TIMER(
+    ScopedSoftwareRasterTaskTimer,
+    "Compositing.%s.RasterTask.SoftwareRasterUs",
+    "Compositing.%s.RasterTask.SoftwareRasterPixelsPerMs");

[Ilya Sherman, 2016/10/03 20:59:11]

Optional nit: You might want to name these as "RasterUs.Software", etc., so that
"RasterUs.Software" and "RasterUs.Gpu" end up sorted next to each other.  Also,
if you don't like this suggestion, you might still want to separate "Software"
and "RasterUs" with a dot.

+
+DEFINE_SCOPED_UMA_HISTOGRAM_AREA_TIMER(
+    ScopedGpuRasterTaskTimer,
+    "Compositing.%s.RasterTask.GpuRasterUs",
+    "Compositing.%s.RasterTask.GpuRasterPixelsPerMs");
+
+class ScopedRasterTaskTimer {
+ public:
+  explicit ScopedRasterTaskTimer(bool use_gpu_rasterization) {
+    if (use_gpu_rasterization)
+      gpu_timer_.emplace();
+    else
+      software_timer_.emplace();
+  }
+
+  void SetArea(int area) {
+    general_timer_.SetArea(area);
+    if (software_timer_)
+      software_timer_->SetArea(area);
+    if (gpu_timer_)
+      gpu_timer_->SetArea(area);
+  }
+
+ private:
+  ScopedGeneralRasterTaskTimer general_timer_;
+  base::Optional<ScopedSoftwareRasterTaskTimer> software_timer_;
+  base::Optional<ScopedGpuRasterTaskTimer> gpu_timer_;
+};
+
 class RasterTaskImpl : public TileTask {
  public:
   RasterTaskImpl(TileManager* tile_manager,
                  Tile* tile,
                  Resource* resource,
                  scoped_refptr<RasterSource> raster_source,
                  const RasterSource::PlaybackSettings& playback_settings,
                  TileResolution tile_resolution,
                  gfx::Rect invalidated_rect,
                  uint64_t source_prepare_tiles_id,
                  std::unique_ptr<RasterBuffer> raster_buffer,
                  TileTask::Vector* dependencies,
-                 bool supports_concurrent_execution)
-      : TileTask(supports_concurrent_execution, dependencies),
+                 bool is_gpu_rasterization)
+      : TileTask(!is_gpu_rasterization, dependencies),
         tile_manager_(tile_manager),
         tile_(tile),
         resource_(resource),
         raster_source_(std::move(raster_source)),
         content_rect_(tile->content_rect()),
         invalid_content_rect_(invalidated_rect),
         contents_scale_(tile->contents_scale()),
         playback_settings_(playback_settings),
         tile_resolution_(tile_resolution),
         layer_id_(tile->layer_id()),
         source_prepare_tiles_id_(source_prepare_tiles_id),
         tile_tracing_id_(static_cast<void*>(tile)),
         new_content_id_(tile->id()),
         source_frame_number_(tile->source_frame_number()),
+        is_gpu_rasterization_(is_gpu_rasterization),
         raster_buffer_(std::move(raster_buffer)) {
     DCHECK(origin_thread_checker_.CalledOnValidThread());
   }
 
   // Overridden from Task:
   void RunOnWorkerThread() override {
     TRACE_EVENT1("cc", "RasterizerTaskImpl::RunOnWorkerThread",
                  "source_prepare_tiles_id", source_prepare_tiles_id_);
 
     DCHECK(raster_source_.get());
     DCHECK(raster_buffer_);
 
     frame_viewer_instrumentation::ScopedRasterTask raster_task(
         tile_tracing_id_, tile_resolution_, source_frame_number_, layer_id_);
-    ScopedRasterTaskTimer timer;
+    ScopedRasterTaskTimer timer(is_gpu_rasterization_);
     timer.SetArea(content_rect_.size().GetArea());
 
     DCHECK(raster_source_);
 
     raster_buffer_->Playback(raster_source_.get(), content_rect_,
                              invalid_content_rect_, new_content_id_,
                              contents_scale_, playback_settings_);
   }
 
   // Overridden from TileTask:
@@ skipping 28 matching lines @@
   gfx::Rect content_rect_;
   gfx::Rect invalid_content_rect_;
   float contents_scale_;
   RasterSource::PlaybackSettings playback_settings_;
   TileResolution tile_resolution_;
   int layer_id_;
   uint64_t source_prepare_tiles_id_;
   void* tile_tracing_id_;
   uint64_t new_content_id_;
   int source_frame_number_;
+  bool is_gpu_rasterization_;
   std::unique_ptr<RasterBuffer> raster_buffer_;
 
   DISALLOW_COPY_AND_ASSIGN(RasterTaskImpl);
 };
 
 TaskCategory TaskCategoryForTileTask(TileTask* task,
                                      bool use_foreground_category) {
   if (!task->supports_concurrent_execution())
     return TASK_CATEGORY_NONCONCURRENT_FOREGROUND;
 
@@ skipping 820 matching lines @@
   }
 
   // We can skip the image hijack canvas if we have no images.
   playback_settings.use_image_hijack_canvas = !images.empty();
 
   // Get the tasks for the required images.
   ImageDecodeController::TracingInfo tracing_info(
       prepare_tiles_count_, prioritized_tile.priority().priority_bin);
   image_manager_.GetTasksForImagesAndRef(&images, &decode_tasks, tracing_info);
 
-  bool supports_concurrent_execution = !use_gpu_rasterization_;
   std::unique_ptr<RasterBuffer> raster_buffer =
       raster_buffer_provider_->AcquireBufferForRaster(
           resource, resource_content_id, tile->invalidated_id());
   return make_scoped_refptr(new RasterTaskImpl(
       this, tile, resource, prioritized_tile.raster_source(), playback_settings,
       prioritized_tile.priority().resolution, invalidated_rect,
       prepare_tiles_count_, std::move(raster_buffer), &decode_tasks,
-      supports_concurrent_execution));
+      use_gpu_rasterization_));
 }
 
 void TileManager::OnRasterTaskCompleted(
     std::unique_ptr<RasterBuffer> raster_buffer,
     Tile* tile,
     Resource* resource,
     bool was_canceled) {
   DCHECK(tile);
   DCHECK(tiles_.find(tile->id()) != tiles_.end());
   raster_buffer_provider_->ReleaseBufferForRaster(std::move(raster_buffer));
@@ skipping 334 matching lines @@
   all_tile_tasks_completed = false;
   did_notify_all_tile_tasks_completed = false;
 }
 
 TileManager::PrioritizedWorkToSchedule::PrioritizedWorkToSchedule() = default;
 TileManager::PrioritizedWorkToSchedule::PrioritizedWorkToSchedule(
     PrioritizedWorkToSchedule&& other) = default;
 TileManager::PrioritizedWorkToSchedule::~PrioritizedWorkToSchedule() = default;
 
 }  // namespace cc