cc: Add invalidation micro benchmark.

cc/debug/invalidation_benchmark.cc

Index: cc/debug/invalidation_benchmark.cc
diff --git a/cc/debug/invalidation_benchmark.cc b/cc/debug/invalidation_benchmark.cc
new file mode 100644
index 0000000000000000000000000000000000000000..e214f7808f997b9a8dae6115ed611553482e76da
--- /dev/null
+++ b/cc/debug/invalidation_benchmark.cc
@@ -0,0 +1,108 @@
+// Copyright 2014 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/debug/invalidation_benchmark.h"
+
+#include <algorithm>
+#include <limits>
+
+#include "base/basictypes.h"
+#include "base/rand_util.h"
+#include "base/values.h"
+#include "cc/layers/layer.h"
+#include "cc/layers/picture_layer.h"
+#include "cc/trees/layer_tree_host.h"
+#include "cc/trees/layer_tree_host_common.h"
+#include "ui/gfx/rect.h"
+
+namespace cc {
+
+namespace {
+
+const char* kDefaultInvalidationMode = "viewport";
+
+}  // namespace
+
+InvalidationBenchmark::InvalidationBenchmark(
+    scoped_ptr<base::Value> value,
+    const MicroBenchmark::DoneCallback& callback)
+    : MicroBenchmark(callback), seed_(0) {
+  base::DictionaryValue* settings = NULL;
+  value->GetAsDictionary(&settings);
+  if (!settings)
+    return;
+
+  std::string mode_string = kDefaultInvalidationMode;
+
+  if (settings->HasKey("mode"))
+    settings->GetString("mode", &mode_string);
+
+  if (mode_string == "layer") {
+    mode_ = LAYER;
+  } else if (mode_string == "viewport") {
+    mode_ = VIEWPORT;
+  } else if (mode_string == "random") {
+    mode_ = RANDOM;
+  } else {
+    LOG(ERROR) << "Invalid mode: " << mode_string

[vmpstr, 2014/05/27 21:24:21]

You can just do CHECK(false) << "blah" (the macro ends up evaluating to a stream
that will be reported along with the stack trace)

[ernstm, 2014/05/27 21:34:46]

Done.

+               << ". One of {layer, viewport, random} expected";
+    CHECK(false);
+  }
+}
+
+InvalidationBenchmark::~InvalidationBenchmark() {
+}
+
+void InvalidationBenchmark::DidUpdateLayers(LayerTreeHost* host) {
+  LayerTreeHostCommon::CallFunctionForSubtree(
+      host->root_layer(),
+      base::Bind(&InvalidationBenchmark::Run, base::Unretained(this)));
+}
+
+void InvalidationBenchmark::Run(Layer* layer) {
+  layer->RunMicroBenchmark(this);
+}
+
+void InvalidationBenchmark::RunOnLayer(PictureLayer* layer) {
+  switch (mode_) {
+    case LAYER:
+      // Invalidate entire layer.
+      layer->SetNeedsDisplay();
+      break;
+    case VIEWPORT:
+      // Invalidate entire viewport.
+      layer->SetNeedsDisplayRect(layer->visible_content_rect());
+      break;
+    case RANDOM: {
+      // Random invalidation inside the viewport.
+      gfx::Rect visible_content_rect = layer->visible_content_rect();
+      int x_min = LCGRandom() * visible_content_rect.width();
+      int x_max = LCGRandom() * visible_content_rect.width();
+      int y_min = LCGRandom() * visible_content_rect.height();
+      int y_max = LCGRandom() * visible_content_rect.height();
+      if (x_min > x_max)
+        std::swap(x_min, x_max);
+      if (y_min > y_max)
+        std::swap(y_min, y_max);
+      gfx::Rect invalidation_rect(x_min, y_min, x_max - x_min, y_max - y_min);
+      layer->SetNeedsDisplayRect(invalidation_rect);
+      break;
+    }
+    default:
+      NOTREACHED();
+      break;
+  }
+}
+
+// A simple linear congruential generator. The random numbers don't need to be
+// high quality, but they need to be identical in each run. Therefore, we use a
+// LCG and keep the state locally in the benchmark.
+float InvalidationBenchmark::LCGRandom() {
+  const uint32 a = 1664525;
+  const uint32 c = 1013904223;
+  seed_ = a * seed_ + c;

[vmpstr, 2014/05/27 21:24:21]

I'm not familiar with rng algorithms, but I assume it's expected that this will
overflow and wrap around?

[ernstm, 2014/05/27 21:34:46]

Yes, this is expected to overflow and wrap around. The algorithm for LCG is
x_(i+1) = ((a * x_i) + c) mod m
where m is the period of the random number generator. For this particular choice
of a and c, m = 2^32, so we can optimize away the mod instruction.

+  return seed_ / std::numeric_limits<uint32>::max();

[vmpstr, 2014/05/27 21:24:21]

Doesn't this just give you 0, because of integer division. You should cast one
of the terms.

[ernstm, 2014/05/27 21:34:46]

Yes, I accidentally removed the cast in #2 and added it back in #3.

+}
+
+}  // namespace cc