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/geometry/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 = nullptr;
  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       [this](Layer* layer) { layer->RunMicroBenchmark(this); });
  68 }
  69
  70 void InvalidationBenchmark::RunOnLayer(PictureLayer* layer) {
  71   switch (mode_) {
  72     case FIXED_SIZE: {
  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);
  79       break;
  80     }
  81     case LAYER: {
  82       // Invalidate entire layer.
  83       layer->SetNeedsDisplay();
  84       break;
  85     }
  86     case RANDOM: {
  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();
  93       if (x_min > x_max)
  94         std::swap(x_min, x_max);
  95       if (y_min > y_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);
  99       break;
 100     }
 101     case VIEWPORT: {
 102       // Invalidate entire viewport.
 103       layer->SetNeedsDisplayRect(layer->visible_layer_rect());
 104       break;
 105     }
 106   }
 107 }
 108
 109 bool InvalidationBenchmark::ProcessMessage(scoped_ptr<base::Value> value) {
 110   base::DictionaryValue* message = nullptr;
 111   value->GetAsDictionary(&message);
 112   if (!message)
 113     return false;
 114
 115   bool notify_done;
 116   if (message->HasKey("notify_done")) {
 117     message->GetBoolean("notify_done", &notify_done);
 118     if (notify_done)
 119       NotifyDone(base::Value::CreateNullValue());
 120     return true;
 121   }
 122   return false;
 123 }
 124
 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();
 133 }
 134
 135 }  // namespace cc