cc/debug/invalidation_benchmark.cc

   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.
   4
   5 #include "cc/debug/invalidation_benchmark.h"
   6
   7 #include <algorithm>
   8 #include <limits>
   9
  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"
  18
  19 namespace cc {
  20
  21 namespace {
  22
  23 const char* kDefaultInvalidationMode = "viewport";
  24
  25 }  // namespace
  26
  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);
  33   if (!settings)
  34     return;
  35
  36   std::string mode_string = kDefaultInvalidationMode;
  37
  38   if (settings->HasKey("mode"))
  39     settings->GetString("mode", &mode_string);
  40
  41   if (mode_string == "fixed_size") {
  42     mode_ = 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") {
  50     mode_ = LAYER;
  51   } else if (mode_string == "random") {
  52     mode_ = RANDOM;
  53   } else if (mode_string == "viewport") {
  54     mode_ = VIEWPORT;
  55   } else {
  56     CHECK(false) << "Invalid mode: " << mode_string
  57                  << ". One of {fixed_size, layer, viewport, random} expected.";
  58   }
  59 }
  60
  61 InvalidationBenchmark::~InvalidationBenchmark() {
  62 }
  63
  64 void InvalidationBenchmark::DidUpdateLayers(LayerTreeHost* host) {
  65   LayerTreeHostCommon::CallFunctionForSubtree(
  66       host->root_layer(),
  67       base::Bind(&InvalidationBenchmark::Run, base::Unretained(this)));
  68 }
  69
  70 void InvalidationBenchmark::Run(Layer* layer) {
  71   layer->RunMicroBenchmark(this);
  72 }
  73
  74 void InvalidationBenchmark::RunOnLayer(PictureLayer* layer) {
  75   switch (mode_) {
  76     case FIXED_SIZE: {
  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);
  83       break;
  84     }
  85     case LAYER: {
  86       // Invalidate entire layer.
  87       layer->SetNeedsDisplay();
  88       break;
  89     }
  90     case RANDOM: {
  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();
  97       if (x_min > x_max)
  98         std::swap(x_min, x_max);
  99       if (y_min > y_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);
 103       break;
 104     }
 105     case VIEWPORT: {
 106       // Invalidate entire viewport.
 107       layer->SetNeedsDisplayRect(layer->visible_content_rect());
 108       break;
 109     }
 110   }
 111 }
 112
 113 bool InvalidationBenchmark::ProcessMessage(scoped_ptr<base::Value> value) {
 114   base::DictionaryValue* message = NULL;
 115   value->GetAsDictionary(&message);
 116   if (!message)
 117     return false;
 118
 119   bool notify_done;
 120   if (message->HasKey("notify_done")) {
 121     message->GetBoolean("notify_done", &notify_done);
 122     if (notify_done)
 123       NotifyDone(scoped_ptr<base::Value>(base::Value::CreateNullValue()));
 124     return true;
 125   }
 126   return false;
 127 }
 128
 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();
 137 }
 138
 139 }  // namespace cc