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/geometry/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
= nullptr;
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 [this](Layer
* layer
) { layer
->RunMicroBenchmark(this); });
70 void InvalidationBenchmark::RunOnLayer(PictureLayer
* layer
) {
73 // Invalidation with a random position and fixed size.
74 gfx::Rect visible_layer_rect
= layer
->visible_layer_rect();
75 int x
= LCGRandom() * (visible_layer_rect
.width() - width_
);
76 int y
= LCGRandom() * (visible_layer_rect
.height() - height_
);
77 gfx::Rect
invalidation_rect(x
, y
, width_
, height_
);
78 layer
->SetNeedsDisplayRect(invalidation_rect
);
82 // Invalidate entire layer.
83 layer
->SetNeedsDisplay();
87 // Random invalidation inside the viewport.
88 gfx::Rect visible_layer_rect
= layer
->visible_layer_rect();
89 int x_min
= LCGRandom() * visible_layer_rect
.width();
90 int x_max
= LCGRandom() * visible_layer_rect
.width();
91 int y_min
= LCGRandom() * visible_layer_rect
.height();
92 int y_max
= LCGRandom() * visible_layer_rect
.height();
94 std::swap(x_min
, x_max
);
96 std::swap(y_min
, y_max
);
97 gfx::Rect
invalidation_rect(x_min
, y_min
, x_max
- x_min
, y_max
- y_min
);
98 layer
->SetNeedsDisplayRect(invalidation_rect
);
102 // Invalidate entire viewport.
103 layer
->SetNeedsDisplayRect(layer
->visible_layer_rect());
109 bool InvalidationBenchmark::ProcessMessage(scoped_ptr
<base::Value
> value
) {
110 base::DictionaryValue
* message
= nullptr;
111 value
->GetAsDictionary(&message
);
116 if (message
->HasKey("notify_done")) {
117 message
->GetBoolean("notify_done", ¬ify_done
);
119 NotifyDone(base::Value::CreateNullValue());
125 // A simple linear congruential generator. The random numbers don't need to be
126 // high quality, but they need to be identical in each run. Therefore, we use a
127 // LCG and keep the state locally in the benchmark.
128 float InvalidationBenchmark::LCGRandom() {
129 const uint32 a
= 1664525;
130 const uint32 c
= 1013904223;
131 seed_
= a
* seed_
+ c
;
132 return static_cast<float>(seed_
) / std::numeric_limits
<uint32
>::max();