cc/debug/rasterize_and_record_benchmark_impl.cc

   1 // Copyright 2013 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/rasterize_and_record_benchmark_impl.h"
   6
   7 #include <algorithm>
   8 #include <limits>
   9
  10 #include "base/basictypes.h"
  11 #include "base/values.h"
  12 #include "cc/debug/lap_timer.h"
  13 #include "cc/layers/layer_impl.h"
  14 #include "cc/layers/picture_layer_impl.h"
  15 #include "cc/resources/raster_worker_pool.h"
  16 #include "cc/trees/layer_tree_host_common.h"
  17 #include "cc/trees/layer_tree_host_impl.h"
  18 #include "ui/gfx/geometry/rect.h"
  19
  20 namespace cc {
  21
  22 namespace {
  23
  24 const int kDefaultRasterizeRepeatCount = 100;
  25
  26 class BenchmarkRasterTask : public Task {
  27  public:
  28   BenchmarkRasterTask(RasterSource* raster_source,
  29                       const gfx::Rect& content_rect,
  30                       float contents_scale,
  31                       size_t repeat_count)
  32       : raster_source_(raster_source),
  33         content_rect_(content_rect),
  34         contents_scale_(contents_scale),
  35         repeat_count_(repeat_count),
  36         is_solid_color_(false),
  37         best_time_(base::TimeDelta::Max()) {}
  38
  39   // Overridden from Task:
  40   void RunOnWorkerThread() override {
  41     // Parameters for LapTimer.
  42     const int kTimeLimitMillis = 1;
  43     const int kWarmupRuns = 0;
  44     const int kTimeCheckInterval = 1;
  45
  46     for (size_t i = 0; i < repeat_count_; ++i) {
  47       // Run for a minimum amount of time to avoid problems with timer
  48       // quantization when the layer is very small.
  49       LapTimer timer(kWarmupRuns,
  50                      base::TimeDelta::FromMilliseconds(kTimeLimitMillis),
  51                      kTimeCheckInterval);
  52       do {
  53         SkBitmap bitmap;
  54         bitmap.allocPixels(SkImageInfo::MakeN32Premul(content_rect_.width(),
  55                                                       content_rect_.height()));
  56         SkCanvas canvas(bitmap);
  57         RasterSource::SolidColorAnalysis analysis;
  58
  59         raster_source_->PerformSolidColorAnalysis(content_rect_,
  60                                                   contents_scale_, &analysis);
  61         raster_source_->PlaybackToCanvas(&canvas, content_rect_,
  62                                          contents_scale_);
  63
  64         is_solid_color_ = analysis.is_solid_color;
  65
  66         timer.NextLap();
  67       } while (!timer.HasTimeLimitExpired());
  68       base::TimeDelta duration =
  69           base::TimeDelta::FromMillisecondsD(timer.MsPerLap());
  70       if (duration < best_time_)
  71         best_time_ = duration;
  72     }
  73   }
  74
  75   bool IsSolidColor() const { return is_solid_color_; }
  76   base::TimeDelta GetBestTime() const { return best_time_; }
  77
  78  private:
  79   ~BenchmarkRasterTask() override {}
  80
  81   RasterSource* raster_source_;
  82   gfx::Rect content_rect_;
  83   float contents_scale_;
  84   size_t repeat_count_;
  85   bool is_solid_color_;
  86   base::TimeDelta best_time_;
  87 };
  88
  89 class FixedInvalidationPictureLayerTilingClient
  90     : public PictureLayerTilingClient {
  91  public:
  92   FixedInvalidationPictureLayerTilingClient(
  93       PictureLayerTilingClient* base_client,
  94       const Region invalidation)
  95       : base_client_(base_client), invalidation_(invalidation) {}
  96
  97   scoped_refptr<Tile> CreateTile(PictureLayerTiling* tiling,
  98                                  const gfx::Rect& content_rect) override {
  99     return base_client_->CreateTile(tiling, content_rect);
 100   }
 101
 102   RasterSource* GetRasterSource() override {
 103     return base_client_->GetRasterSource();
 104   }
 105
 106   gfx::Size CalculateTileSize(const gfx::Size& content_bounds) const override {
 107     return base_client_->CalculateTileSize(content_bounds);
 108   }
 109
 110   // This is the only function that returns something different from the base
 111   // client. Avoids sharing tiles in this area.
 112   const Region* GetPendingInvalidation() override { return &invalidation_; }
 113
 114   const PictureLayerTiling* GetPendingOrActiveTwinTiling(
 115       const PictureLayerTiling* tiling) const override {
 116     return base_client_->GetPendingOrActiveTwinTiling(tiling);
 117   }
 118
 119   PictureLayerTiling* GetRecycledTwinTiling(
 120       const PictureLayerTiling* tiling) override {
 121     return base_client_->GetRecycledTwinTiling(tiling);
 122   }
 123
 124   TilePriority::PriorityBin GetMaxTilePriorityBin() const override {
 125     return base_client_->GetMaxTilePriorityBin();
 126   }
 127
 128   size_t GetMaxTilesForInterestArea() const override {
 129     return base_client_->GetMaxTilesForInterestArea();
 130   }
 131
 132   float GetSkewportTargetTimeInSeconds() const override {
 133     return base_client_->GetSkewportTargetTimeInSeconds();
 134   }
 135
 136   int GetSkewportExtrapolationLimitInContentPixels() const override {
 137     return base_client_->GetSkewportExtrapolationLimitInContentPixels();
 138   }
 139
 140   WhichTree GetTree() const override { return base_client_->GetTree(); }
 141
 142   bool RequiresHighResToDraw() const override {
 143     return base_client_->RequiresHighResToDraw();
 144   }
 145
 146  private:
 147   PictureLayerTilingClient* base_client_;
 148   Region invalidation_;
 149 };
 150
 151 }  // namespace
 152
 153 RasterizeAndRecordBenchmarkImpl::RasterizeAndRecordBenchmarkImpl(
 154     scoped_refptr<base::MessageLoopProxy> origin_loop,
 155     base::Value* value,
 156     const MicroBenchmarkImpl::DoneCallback& callback)
 157     : MicroBenchmarkImpl(callback, origin_loop),
 158       rasterize_repeat_count_(kDefaultRasterizeRepeatCount) {
 159   base::DictionaryValue* settings = nullptr;
 160   value->GetAsDictionary(&settings);
 161   if (!settings)
 162     return;
 163
 164   if (settings->HasKey("rasterize_repeat_count"))
 165     settings->GetInteger("rasterize_repeat_count", &rasterize_repeat_count_);
 166 }
 167
 168 RasterizeAndRecordBenchmarkImpl::~RasterizeAndRecordBenchmarkImpl() {}
 169
 170 void RasterizeAndRecordBenchmarkImpl::DidCompleteCommit(
 171     LayerTreeHostImpl* host) {
 172   LayerTreeHostCommon::CallFunctionForSubtree(
 173       host->RootLayer(),
 174       base::Bind(&RasterizeAndRecordBenchmarkImpl::Run,
 175                  base::Unretained(this)));
 176
 177   scoped_ptr<base::DictionaryValue> result(new base::DictionaryValue());
 178   result->SetDouble("rasterize_time_ms",
 179                     rasterize_results_.total_best_time.InMillisecondsF());
 180   result->SetInteger("pixels_rasterized", rasterize_results_.pixels_rasterized);
 181   result->SetInteger("pixels_rasterized_with_non_solid_color",
 182                      rasterize_results_.pixels_rasterized_with_non_solid_color);
 183   result->SetInteger("pixels_rasterized_as_opaque",
 184                      rasterize_results_.pixels_rasterized_as_opaque);
 185   result->SetInteger("total_layers", rasterize_results_.total_layers);
 186   result->SetInteger("total_picture_layers",
 187                      rasterize_results_.total_picture_layers);
 188   result->SetInteger("total_picture_layers_with_no_content",
 189                      rasterize_results_.total_picture_layers_with_no_content);
 190   result->SetInteger("total_picture_layers_off_screen",
 191                      rasterize_results_.total_picture_layers_off_screen);
 192
 193   NotifyDone(result.Pass());
 194 }
 195
 196 void RasterizeAndRecordBenchmarkImpl::Run(LayerImpl* layer) {
 197   rasterize_results_.total_layers++;
 198   layer->RunMicroBenchmark(this);
 199 }
 200
 201 void RasterizeAndRecordBenchmarkImpl::RunOnLayer(PictureLayerImpl* layer) {
 202   rasterize_results_.total_picture_layers++;
 203   if (!layer->DrawsContent()) {
 204     rasterize_results_.total_picture_layers_with_no_content++;
 205     return;
 206   }
 207   if (layer->visible_content_rect().IsEmpty()) {
 208     rasterize_results_.total_picture_layers_off_screen++;
 209     return;
 210   }
 211
 212   TaskGraphRunner* task_graph_runner = RasterWorkerPool::GetTaskGraphRunner();
 213   DCHECK(task_graph_runner);
 214
 215   if (!task_namespace_.IsValid())
 216     task_namespace_ = task_graph_runner->GetNamespaceToken();
 217
 218   FixedInvalidationPictureLayerTilingClient client(
 219       layer, gfx::Rect(layer->content_bounds()));
 220   PictureLayerTilingSet tiling_set(&client);
 221
 222   PictureLayerTiling* tiling =
 223       tiling_set.AddTiling(layer->contents_scale_x(), layer->bounds());
 224   tiling->CreateAllTilesForTesting();
 225   for (PictureLayerTiling::CoverageIterator it(
 226            tiling, layer->contents_scale_x(), layer->visible_content_rect());
 227        it;
 228        ++it) {
 229     DCHECK(*it);
 230
 231     RasterSource* raster_source = (*it)->raster_source();
 232     gfx::Rect content_rect = (*it)->content_rect();
 233     float contents_scale = (*it)->contents_scale();
 234
 235     scoped_refptr<BenchmarkRasterTask> benchmark_raster_task(
 236         new BenchmarkRasterTask(raster_source,
 237                                 content_rect,
 238                                 contents_scale,
 239                                 rasterize_repeat_count_));
 240
 241     TaskGraph graph;
 242
 243     graph.nodes.push_back(
 244         TaskGraph::Node(benchmark_raster_task.get(),
 245                         RasterWorkerPool::kBenchmarkRasterTaskPriority,
 246                         0u));
 247
 248     task_graph_runner->ScheduleTasks(task_namespace_, &graph);
 249     task_graph_runner->WaitForTasksToFinishRunning(task_namespace_);
 250
 251     Task::Vector completed_tasks;
 252     task_graph_runner->CollectCompletedTasks(task_namespace_, &completed_tasks);
 253     DCHECK_EQ(1u, completed_tasks.size());
 254     DCHECK_EQ(completed_tasks[0], benchmark_raster_task);
 255
 256     int tile_size = content_rect.width() * content_rect.height();
 257     base::TimeDelta min_time = benchmark_raster_task->GetBestTime();
 258     bool is_solid_color = benchmark_raster_task->IsSolidColor();
 259
 260     if (layer->contents_opaque())
 261       rasterize_results_.pixels_rasterized_as_opaque += tile_size;
 262
 263     if (!is_solid_color) {
 264       rasterize_results_.pixels_rasterized_with_non_solid_color += tile_size;
 265     }
 266
 267     rasterize_results_.pixels_rasterized += tile_size;
 268     rasterize_results_.total_best_time += min_time;
 269   }
 270 }
 271
 272 RasterizeAndRecordBenchmarkImpl::RasterizeResults::RasterizeResults()
 273     : pixels_rasterized(0),
 274       pixels_rasterized_with_non_solid_color(0),
 275       pixels_rasterized_as_opaque(0),
 276       total_layers(0),
 277       total_picture_layers(0),
 278       total_picture_layers_with_no_content(0),
 279       total_picture_layers_off_screen(0) {}
 280
 281 RasterizeAndRecordBenchmarkImpl::RasterizeResults::~RasterizeResults() {}
 282
 283 }  // namespace cc