cc/debug/rasterize_and_record_benchmark.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.h"
   6
   7 #include <algorithm>
   8 #include <limits>
   9 #include <string>
  10
  11 #include "base/basictypes.h"
  12 #include "base/strings/stringprintf.h"
  13 #include "base/values.h"
  14 #include "cc/debug/lap_timer.h"
  15 #include "cc/debug/rasterize_and_record_benchmark_impl.h"
  16 #include "cc/layers/content_layer_client.h"
  17 #include "cc/layers/layer.h"
  18 #include "cc/layers/picture_layer.h"
  19 #include "cc/resources/display_item_list.h"
  20 #include "cc/resources/picture_pile.h"
  21 #include "cc/trees/layer_tree_host.h"
  22 #include "cc/trees/layer_tree_host_common.h"
  23 #include "third_party/skia/include/utils/SkPictureUtils.h"
  24 #include "ui/gfx/geometry/rect.h"
  25
  26 namespace cc {
  27
  28 namespace {
  29
  30 const int kDefaultRecordRepeatCount = 100;
  31
  32 // Parameters for LapTimer.
  33 const int kTimeLimitMillis = 1;
  34 const int kWarmupRuns = 0;
  35 const int kTimeCheckInterval = 1;
  36
  37 const char* kModeSuffixes[RecordingSource::RECORDING_MODE_COUNT] =
  38     {"", "_sk_null_canvas", "_painting_disabled", "_caching_disabled"};
  39
  40 }  // namespace
  41
  42 RasterizeAndRecordBenchmark::RasterizeAndRecordBenchmark(
  43     scoped_ptr<base::Value> value,
  44     const MicroBenchmark::DoneCallback& callback)
  45     : MicroBenchmark(callback),
  46       record_repeat_count_(kDefaultRecordRepeatCount),
  47       settings_(value.Pass()),
  48       main_thread_benchmark_done_(false),
  49       host_(nullptr),
  50       weak_ptr_factory_(this) {
  51   base::DictionaryValue* settings = nullptr;
  52   settings_->GetAsDictionary(&settings);
  53   if (!settings)
  54     return;
  55
  56   if (settings->HasKey("record_repeat_count"))
  57     settings->GetInteger("record_repeat_count", &record_repeat_count_);
  58 }
  59
  60 RasterizeAndRecordBenchmark::~RasterizeAndRecordBenchmark() {
  61   weak_ptr_factory_.InvalidateWeakPtrs();
  62 }
  63
  64 void RasterizeAndRecordBenchmark::DidUpdateLayers(LayerTreeHost* host) {
  65   host_ = host;
  66   LayerTreeHostCommon::CallFunctionForSubtree(
  67       host->root_layer(),
  68       [this](Layer* layer) { layer->RunMicroBenchmark(this); });
  69
  70   DCHECK(!results_.get());
  71   results_ = make_scoped_ptr(new base::DictionaryValue);
  72   results_->SetInteger("pixels_recorded", record_results_.pixels_recorded);
  73   results_->SetInteger("picture_memory_usage", record_results_.bytes_used);
  74
  75   for (int i = 0; i < RecordingSource::RECORDING_MODE_COUNT; i++) {
  76     std::string name = base::StringPrintf("record_time%s_ms", kModeSuffixes[i]);
  77     results_->SetDouble(name,
  78                         record_results_.total_best_time[i].InMillisecondsF());
  79   }
  80   main_thread_benchmark_done_ = true;
  81 }
  82
  83 void RasterizeAndRecordBenchmark::RecordRasterResults(
  84     scoped_ptr<base::Value> results_value) {
  85   DCHECK(main_thread_benchmark_done_);
  86
  87   base::DictionaryValue* results = nullptr;
  88   results_value->GetAsDictionary(&results);
  89   DCHECK(results);
  90
  91   results_->MergeDictionary(results);
  92
  93   NotifyDone(results_.Pass());
  94 }
  95
  96 scoped_ptr<MicroBenchmarkImpl> RasterizeAndRecordBenchmark::CreateBenchmarkImpl(
  97     scoped_refptr<base::SingleThreadTaskRunner> origin_task_runner) {
  98   return make_scoped_ptr(new RasterizeAndRecordBenchmarkImpl(
  99       origin_task_runner, settings_.get(),
 100       base::Bind(&RasterizeAndRecordBenchmark::RecordRasterResults,
 101                  weak_ptr_factory_.GetWeakPtr())));
 102 }
 103
 104 void RasterizeAndRecordBenchmark::RunOnLayer(PictureLayer* layer) {
 105   DCHECK(host_);
 106
 107   gfx::Rect visible_layer_rect = gfx::ScaleToEnclosingRect(
 108       layer->visible_content_rect(), 1.f / layer->contents_scale_x());
 109   if (visible_layer_rect.IsEmpty())
 110     return;
 111
 112   if (host_->settings().use_display_lists) {
 113     RunOnDisplayListLayer(layer, visible_layer_rect);
 114   } else {
 115     RunOnPictureLayer(layer, visible_layer_rect);
 116   }
 117 }
 118
 119 void RasterizeAndRecordBenchmark::RunOnPictureLayer(
 120     PictureLayer* layer,
 121     const gfx::Rect& visible_layer_rect) {
 122   ContentLayerClient* painter = layer->client();
 123
 124   DCHECK(host_ && !host_->settings().use_display_lists);
 125
 126   gfx::Size tile_grid_size = host_->settings().default_tile_size;
 127
 128   for (int mode_index = 0; mode_index < RecordingSource::RECORDING_MODE_COUNT;
 129        mode_index++) {
 130     RecordingSource::RecordingMode mode =
 131         static_cast<RecordingSource::RecordingMode>(mode_index);
 132     base::TimeDelta min_time = base::TimeDelta::Max();
 133     size_t memory_used = 0;
 134
 135     for (int i = 0; i < record_repeat_count_; ++i) {
 136       // Run for a minimum amount of time to avoid problems with timer
 137       // quantization when the layer is very small.
 138       LapTimer timer(kWarmupRuns,
 139                      base::TimeDelta::FromMilliseconds(kTimeLimitMillis),
 140                      kTimeCheckInterval);
 141       scoped_refptr<Picture> picture;
 142       do {
 143         picture = Picture::Create(visible_layer_rect, painter, tile_grid_size,
 144                                   false, mode);
 145         if (memory_used) {
 146           // Verify we are recording the same thing each time.
 147           DCHECK(memory_used == picture->ApproximateMemoryUsage());
 148         } else {
 149           memory_used = picture->ApproximateMemoryUsage();
 150         }
 151
 152         timer.NextLap();
 153       } while (!timer.HasTimeLimitExpired());
 154       base::TimeDelta duration =
 155           base::TimeDelta::FromMillisecondsD(timer.MsPerLap());
 156       if (duration < min_time)
 157         min_time = duration;
 158     }
 159
 160     if (mode == RecordingSource::RECORD_NORMALLY) {
 161       record_results_.bytes_used += memory_used;
 162       record_results_.pixels_recorded +=
 163           visible_layer_rect.width() * visible_layer_rect.height();
 164     }
 165     record_results_.total_best_time[mode_index] += min_time;
 166   }
 167 }
 168
 169 void RasterizeAndRecordBenchmark::RunOnDisplayListLayer(
 170     PictureLayer* layer,
 171     const gfx::Rect& visible_layer_rect) {
 172   ContentLayerClient* painter = layer->client();
 173
 174   DCHECK(host_ && host_->settings().use_display_lists);
 175
 176   for (int mode_index = 0; mode_index < RecordingSource::RECORDING_MODE_COUNT;
 177        mode_index++) {
 178     ContentLayerClient::PaintingControlSetting painting_control =
 179         ContentLayerClient::PAINTING_BEHAVIOR_NORMAL;
 180     switch (static_cast<RecordingSource::RecordingMode>(mode_index)) {
 181       case RecordingSource::RECORD_NORMALLY:
 182         // Already setup for normal recording.
 183         break;
 184       case RecordingSource::RECORD_WITH_SK_NULL_CANVAS:
 185       // TODO(schenney): Remove this when DisplayList recording is the only
 186       // option. For now, fall through and disable construction.
 187       case RecordingSource::RECORD_WITH_PAINTING_DISABLED:
 188         painting_control =
 189             ContentLayerClient::DISPLAY_LIST_CONSTRUCTION_DISABLED;
 190         break;
 191       case RecordingSource::RECORD_WITH_CACHING_DISABLED:
 192         painting_control = ContentLayerClient::DISPLAY_LIST_CACHING_DISABLED;
 193         break;
 194       default:
 195         NOTREACHED();
 196     }
 197     base::TimeDelta min_time = base::TimeDelta::Max();
 198     size_t memory_used = 0;
 199
 200     scoped_refptr<DisplayItemList> display_list;
 201     for (int i = 0; i < record_repeat_count_; ++i) {
 202       // Run for a minimum amount of time to avoid problems with timer
 203       // quantization when the layer is very small.
 204       LapTimer timer(kWarmupRuns,
 205                      base::TimeDelta::FromMilliseconds(kTimeLimitMillis),
 206                      kTimeCheckInterval);
 207
 208       do {
 209         const bool use_cached_picture = true;
 210         display_list =
 211             DisplayItemList::Create(visible_layer_rect, use_cached_picture);
 212         painter->PaintContentsToDisplayList(
 213             display_list.get(), visible_layer_rect, painting_control);
 214         display_list->CreateAndCacheSkPicture();
 215
 216         if (memory_used) {
 217           // Verify we are recording the same thing each time.
 218           DCHECK(memory_used == display_list->PictureMemoryUsage());
 219         } else {
 220           memory_used = display_list->PictureMemoryUsage();
 221         }
 222
 223         timer.NextLap();
 224       } while (!timer.HasTimeLimitExpired());
 225       base::TimeDelta duration =
 226           base::TimeDelta::FromMillisecondsD(timer.MsPerLap());
 227       if (duration < min_time)
 228         min_time = duration;
 229     }
 230
 231     if (mode_index == RecordingSource::RECORD_NORMALLY) {
 232       record_results_.bytes_used += memory_used;
 233       record_results_.pixels_recorded +=
 234           visible_layer_rect.width() * visible_layer_rect.height();
 235     }
 236     record_results_.total_best_time[mode_index] += min_time;
 237   }
 238 }
 239
 240 RasterizeAndRecordBenchmark::RecordResults::RecordResults()
 241     : pixels_recorded(0), bytes_used(0) {
 242 }
 243
 244 RasterizeAndRecordBenchmark::RecordResults::~RecordResults() {}
 245
 246 }  // namespace cc