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.
5 #include "cc/debug/invalidation_benchmark.h"
10 #include "base/basictypes.h"
11 #include "base/rand_util.h"
12 #include "base/values.h"
13 #include "cc/layers/layer.h"
14 #include "cc/layers/picture_layer.h"
15 #include "cc/trees/layer_tree_host.h"
16 #include "cc/trees/layer_tree_host_common.h"
17 #include "ui/gfx/rect.h"
23 const char* kDefaultInvalidationMode = "viewport";
27 InvalidationBenchmark::InvalidationBenchmark(
28 scoped_ptr<base::Value> value,
29 const MicroBenchmark::DoneCallback& callback)
30 : MicroBenchmark(callback), seed_(0) {
31 base::DictionaryValue* settings = NULL;
32 value->GetAsDictionary(&settings);
36 std::string mode_string = kDefaultInvalidationMode;
38 if (settings->HasKey("mode"))
39 settings->GetString("mode", &mode_string);
41 if (mode_string == "fixed_size") {
43 CHECK(settings->HasKey("width"))
44 << "Must provide a width for fixed_size mode.";
45 CHECK(settings->HasKey("height"))
46 << "Must provide a height for fixed_size mode.";
47 settings->GetInteger("width", &width_);
48 settings->GetInteger("height", &height_);
49 } else if (mode_string == "layer") {
51 } else if (mode_string == "random") {
53 } else if (mode_string == "viewport") {
56 CHECK(false) << "Invalid mode: " << mode_string
57 << ". One of {fixed_size, layer, viewport, random} expected.";
61 InvalidationBenchmark::~InvalidationBenchmark() {
64 void InvalidationBenchmark::DidUpdateLayers(LayerTreeHost* host) {
65 LayerTreeHostCommon::CallFunctionForSubtree(
67 base::Bind(&InvalidationBenchmark::Run, base::Unretained(this)));
70 void InvalidationBenchmark::Run(Layer* layer) {
71 layer->RunMicroBenchmark(this);
74 void InvalidationBenchmark::RunOnLayer(PictureLayer* layer) {
77 // Invalidation with a random position and fixed size.
78 gfx::Rect visible_content_rect = layer->visible_content_rect();
79 int x = LCGRandom() * (visible_content_rect.width() - width_);
80 int y = LCGRandom() * (visible_content_rect.height() - height_);
81 gfx::Rect invalidation_rect(x, y, width_, height_);
82 layer->SetNeedsDisplayRect(invalidation_rect);
86 // Invalidate entire layer.
87 layer->SetNeedsDisplay();
91 // Random invalidation inside the viewport.
92 gfx::Rect visible_content_rect = layer->visible_content_rect();
93 int x_min = LCGRandom() * visible_content_rect.width();
94 int x_max = LCGRandom() * visible_content_rect.width();
95 int y_min = LCGRandom() * visible_content_rect.height();
96 int y_max = LCGRandom() * visible_content_rect.height();
98 std::swap(x_min, x_max);
100 std::swap(y_min, y_max);
101 gfx::Rect invalidation_rect(x_min, y_min, x_max - x_min, y_max - y_min);
102 layer->SetNeedsDisplayRect(invalidation_rect);
106 // Invalidate entire viewport.
107 layer->SetNeedsDisplayRect(layer->visible_content_rect());
113 bool InvalidationBenchmark::ProcessMessage(scoped_ptr<base::Value> value) {
114 base::DictionaryValue* message = NULL;
115 value->GetAsDictionary(&message);
120 if (message->HasKey("notify_done")) {
121 message->GetBoolean("notify_done", ¬ify_done);
123 NotifyDone(scoped_ptr<base::Value>(base::Value::CreateNullValue()));
129 // A simple linear congruential generator. The random numbers don't need to be
130 // high quality, but they need to be identical in each run. Therefore, we use a
131 // LCG and keep the state locally in the benchmark.
132 float InvalidationBenchmark::LCGRandom() {
133 const uint32 a = 1664525;
134 const uint32 c = 1013904223;
135 seed_ = a * seed_ + c;
136 return static_cast<float>(seed_) / std::numeric_limits<uint32>::max();