cc/resources/picture_layer_tiling_perftest.cc

   1 // Copyright 2013 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/lap_timer.h"
   6 #include "cc/resources/picture_layer_tiling.h"
   7 #include "cc/test/fake_picture_layer_tiling_client.h"
   8
   9 #include "testing/gtest/include/gtest/gtest.h"
  10 #include "testing/perf/perf_test.h"
  11
  12 namespace cc {
  13
  14 namespace {
  15
  16 static const int kTimeLimitMillis = 2000;
  17 static const int kWarmupRuns = 5;
  18 static const int kTimeCheckInterval = 10;
  19
  20 class PictureLayerTilingPerfTest : public testing::Test {
  21  public:
  22   PictureLayerTilingPerfTest()
  23       : timer_(kWarmupRuns,
  24                base::TimeDelta::FromMilliseconds(kTimeLimitMillis),
  25                kTimeCheckInterval) {}
  26
  27   virtual void SetUp() OVERRIDE {
  28     picture_layer_tiling_client_.SetTileSize(gfx::Size(256, 256));
  29     picture_layer_tiling_client_.set_max_tiles_for_interest_area(250);
  30     picture_layer_tiling_ = PictureLayerTiling::Create(
  31         1, gfx::Size(256 * 50, 256 * 50), &picture_layer_tiling_client_);
  32     picture_layer_tiling_->CreateAllTilesForTesting();
  33   }
  34
  35   virtual void TearDown() OVERRIDE {
  36     picture_layer_tiling_.reset(NULL);
  37   }
  38
  39   void RunInvalidateTest(const std::string& test_name, const Region& region) {
  40     timer_.Reset();
  41     do {
  42       picture_layer_tiling_->Invalidate(region);
  43       timer_.NextLap();
  44     } while (!timer_.HasTimeLimitExpired());
  45
  46     perf_test::PrintResult(
  47         "invalidation", "", test_name, timer_.LapsPerSecond(), "runs/s", true);
  48   }
  49
  50   void RunUpdateTilePrioritiesStationaryTest(const std::string& test_name,
  51                                              const gfx::Transform& transform) {
  52     gfx::Rect viewport_rect(0, 0, 1024, 768);
  53
  54     timer_.Reset();
  55     do {
  56       picture_layer_tiling_->UpdateTilePriorities(
  57           ACTIVE_TREE, viewport_rect, 1.f, timer_.NumLaps() + 1);
  58       timer_.NextLap();
  59     } while (!timer_.HasTimeLimitExpired());
  60
  61     perf_test::PrintResult("update_tile_priorities_stationary",
  62                            "",
  63                            test_name,
  64                            timer_.LapsPerSecond(),
  65                            "runs/s",
  66                            true);
  67   }
  68
  69   void RunUpdateTilePrioritiesScrollingTest(const std::string& test_name,
  70                                             const gfx::Transform& transform) {
  71     gfx::Size viewport_size(1024, 768);
  72     gfx::Rect viewport_rect(viewport_size);
  73     int xoffsets[] = {10, 0, -10, 0};
  74     int yoffsets[] = {0, 10, 0, -10};
  75     int offsetIndex = 0;
  76     int offsetCount = 0;
  77     const int maxOffsetCount = 1000;
  78
  79     timer_.Reset();
  80     do {
  81       picture_layer_tiling_->UpdateTilePriorities(
  82           ACTIVE_TREE, viewport_rect, 1.f, timer_.NumLaps() + 1);
  83
  84       viewport_rect = gfx::Rect(viewport_rect.x() + xoffsets[offsetIndex],
  85                                 viewport_rect.y() + yoffsets[offsetIndex],
  86                                 viewport_rect.width(),
  87                                 viewport_rect.height());
  88
  89       if (++offsetCount > maxOffsetCount) {
  90         offsetCount = 0;
  91         offsetIndex = (offsetIndex + 1) % 4;
  92       }
  93       timer_.NextLap();
  94     } while (!timer_.HasTimeLimitExpired());
  95
  96     perf_test::PrintResult("update_tile_priorities_scrolling",
  97                            "",
  98                            test_name,
  99                            timer_.LapsPerSecond(),
 100                            "runs/s",
 101                            true);
 102   }
 103
 104   void RunTilingRasterTileIteratorTest(const std::string& test_name,
 105                                        int num_tiles,
 106                                        const gfx::Rect& viewport) {
 107     gfx::Size bounds(10000, 10000);
 108     picture_layer_tiling_ =
 109         PictureLayerTiling::Create(1, bounds, &picture_layer_tiling_client_);
 110     picture_layer_tiling_->UpdateTilePriorities(
 111         ACTIVE_TREE, viewport, 1.0f, 1.0);
 112
 113     timer_.Reset();
 114     do {
 115       int count = num_tiles;
 116       for (PictureLayerTiling::TilingRasterTileIterator it(
 117                picture_layer_tiling_.get(), ACTIVE_TREE);
 118            it && count;
 119            ++it) {
 120         --count;
 121       }
 122       timer_.NextLap();
 123     } while (!timer_.HasTimeLimitExpired());
 124
 125     perf_test::PrintResult("tiling_raster_tile_iterator",
 126                            "",
 127                            test_name,
 128                            timer_.LapsPerSecond(),
 129                            "runs/s",
 130                            true);
 131   }
 132
 133  private:
 134   FakePictureLayerTilingClient picture_layer_tiling_client_;
 135   scoped_ptr<PictureLayerTiling> picture_layer_tiling_;
 136
 137   LapTimer timer_;
 138 };
 139
 140 TEST_F(PictureLayerTilingPerfTest, Invalidate) {
 141   Region one_tile(gfx::Rect(256, 256));
 142   RunInvalidateTest("1x1", one_tile);
 143
 144   Region half_region(gfx::Rect(25 * 256, 50 * 256));
 145   RunInvalidateTest("25x50", half_region);
 146
 147   Region full_region(gfx::Rect(50 * 256, 50 * 256));
 148   RunInvalidateTest("50x50", full_region);
 149 }
 150
 151 #if defined(OS_ANDROID)
 152 // TODO(vmpstr): Investigate why this is noisy (crbug.com/310220).
 153 TEST_F(PictureLayerTilingPerfTest, DISABLED_UpdateTilePriorities) {
 154 #else
 155 TEST_F(PictureLayerTilingPerfTest, UpdateTilePriorities) {
 156 #endif  // defined(OS_ANDROID)
 157   gfx::Transform transform;
 158
 159   RunUpdateTilePrioritiesStationaryTest("no_transform", transform);
 160   RunUpdateTilePrioritiesScrollingTest("no_transform", transform);
 161
 162   transform.Rotate(10);
 163   RunUpdateTilePrioritiesStationaryTest("rotation", transform);
 164   RunUpdateTilePrioritiesScrollingTest("rotation", transform);
 165
 166   transform.ApplyPerspectiveDepth(10);
 167   RunUpdateTilePrioritiesStationaryTest("perspective", transform);
 168   RunUpdateTilePrioritiesScrollingTest("perspective", transform);
 169 }
 170
 171 TEST_F(PictureLayerTilingPerfTest, TilingRasterTileIterator) {
 172   RunTilingRasterTileIteratorTest("32_100x100", 32, gfx::Rect(0, 0, 100, 100));
 173   RunTilingRasterTileIteratorTest("32_500x500", 32, gfx::Rect(0, 0, 500, 500));
 174   RunTilingRasterTileIteratorTest("64_100x100", 64, gfx::Rect(0, 0, 100, 100));
 175   RunTilingRasterTileIteratorTest("64_500x500", 64, gfx::Rect(0, 0, 500, 500));
 176 }
 177
 178 }  // namespace
 179
 180 }  // namespace cc