src/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/resources/resource_provider.h"
   8 #include "cc/resources/scoped_resource.h"
   9 #include "cc/test/fake_output_surface.h"
  10 #include "cc/test/fake_output_surface_client.h"
  11 #include "cc/test/fake_picture_layer_tiling_client.h"
  12 #include "cc/test/test_context_provider.h"
  13 #include "cc/test/test_shared_bitmap_manager.h"
  14
  15 #include "testing/gtest/include/gtest/gtest.h"
  16 #include "testing/perf/perf_test.h"
  17
  18 namespace cc {
  19
  20 namespace {
  21
  22 static const int kTimeLimitMillis = 2000;
  23 static const int kWarmupRuns = 5;
  24 static const int kTimeCheckInterval = 10;
  25
  26 class PictureLayerTilingPerfTest : public testing::Test {
  27  public:
  28   PictureLayerTilingPerfTest()
  29       : timer_(kWarmupRuns,
  30                base::TimeDelta::FromMilliseconds(kTimeLimitMillis),
  31                kTimeCheckInterval),
  32         context_provider_(TestContextProvider::Create()) {
  33     output_surface_ = FakeOutputSurface::Create3d(context_provider_).Pass();
  34     CHECK(output_surface_->BindToClient(&output_surface_client_));
  35
  36     shared_bitmap_manager_.reset(new TestSharedBitmapManager());
  37     resource_provider_ = ResourceProvider::Create(output_surface_.get(),
  38                                                   shared_bitmap_manager_.get(),
  39                                                   NULL,
  40                                                   NULL,
  41                                                   0,
  42                                                   false,
  43                                                   1).Pass();
  44   }
  45
  46   virtual void SetUp() override {
  47     picture_layer_tiling_client_.SetTileSize(gfx::Size(256, 256));
  48     picture_layer_tiling_client_.set_max_tiles_for_interest_area(250);
  49     picture_layer_tiling_client_.set_tree(PENDING_TREE);
  50     picture_layer_tiling_ = PictureLayerTiling::Create(
  51         1, gfx::Size(256 * 50, 256 * 50), &picture_layer_tiling_client_);
  52     picture_layer_tiling_->CreateAllTilesForTesting();
  53   }
  54
  55   virtual void TearDown() override {
  56     picture_layer_tiling_.reset(NULL);
  57   }
  58
  59   void RunInvalidateTest(const std::string& test_name, const Region& region) {
  60     timer_.Reset();
  61     do {
  62       picture_layer_tiling_->UpdateTilesToCurrentPile(
  63           region, picture_layer_tiling_->tiling_size());
  64       timer_.NextLap();
  65     } while (!timer_.HasTimeLimitExpired());
  66
  67     perf_test::PrintResult(
  68         "invalidation", "", test_name, timer_.LapsPerSecond(), "runs/s", true);
  69   }
  70
  71   void RunComputeTilePriorityRectsStationaryTest(
  72       const std::string& test_name,
  73       const gfx::Transform& transform) {
  74     gfx::Rect viewport_rect(0, 0, 1024, 768);
  75
  76     timer_.Reset();
  77     do {
  78       picture_layer_tiling_->ComputeTilePriorityRects(
  79           PENDING_TREE, viewport_rect, 1.f, timer_.NumLaps() + 1, Occlusion());
  80       timer_.NextLap();
  81     } while (!timer_.HasTimeLimitExpired());
  82
  83     perf_test::PrintResult("compute_tile_priority_rects_stationary",
  84                            "",
  85                            test_name,
  86                            timer_.LapsPerSecond(),
  87                            "runs/s",
  88                            true);
  89   }
  90
  91   void RunComputeTilePriorityRectsScrollingTest(
  92       const std::string& test_name,
  93       const gfx::Transform& transform) {
  94     gfx::Size viewport_size(1024, 768);
  95     gfx::Rect viewport_rect(viewport_size);
  96     int xoffsets[] = {10, 0, -10, 0};
  97     int yoffsets[] = {0, 10, 0, -10};
  98     int offsetIndex = 0;
  99     int offsetCount = 0;
 100     const int maxOffsetCount = 1000;
 101
 102     timer_.Reset();
 103     do {
 104       picture_layer_tiling_->ComputeTilePriorityRects(
 105           PENDING_TREE, viewport_rect, 1.f, timer_.NumLaps() + 1, Occlusion());
 106
 107       viewport_rect = gfx::Rect(viewport_rect.x() + xoffsets[offsetIndex],
 108                                 viewport_rect.y() + yoffsets[offsetIndex],
 109                                 viewport_rect.width(),
 110                                 viewport_rect.height());
 111
 112       if (++offsetCount > maxOffsetCount) {
 113         offsetCount = 0;
 114         offsetIndex = (offsetIndex + 1) % 4;
 115       }
 116       timer_.NextLap();
 117     } while (!timer_.HasTimeLimitExpired());
 118
 119     perf_test::PrintResult("compute_tile_priority_rects_scrolling",
 120                            "",
 121                            test_name,
 122                            timer_.LapsPerSecond(),
 123                            "runs/s",
 124                            true);
 125   }
 126
 127   void RunRasterIteratorConstructTest(const std::string& test_name,
 128                                       const gfx::Rect& viewport) {
 129     gfx::Size bounds(viewport.size());
 130     picture_layer_tiling_ =
 131         PictureLayerTiling::Create(1, bounds, &picture_layer_tiling_client_);
 132     picture_layer_tiling_client_.set_tree(ACTIVE_TREE);
 133     picture_layer_tiling_->ComputeTilePriorityRects(
 134         ACTIVE_TREE, viewport, 1.0f, 1.0, Occlusion());
 135
 136     timer_.Reset();
 137     do {
 138       PictureLayerTiling::TilingRasterTileIterator it(
 139           picture_layer_tiling_.get());
 140       timer_.NextLap();
 141     } while (!timer_.HasTimeLimitExpired());
 142
 143     perf_test::PrintResult("tiling_raster_tile_iterator_construct",
 144                            "",
 145                            test_name,
 146                            timer_.LapsPerSecond(),
 147                            "runs/s",
 148                            true);
 149   }
 150
 151   void RunRasterIteratorConstructAndIterateTest(const std::string& test_name,
 152                                                 int num_tiles,
 153                                                 const gfx::Rect& viewport) {
 154     gfx::Size bounds(10000, 10000);
 155     picture_layer_tiling_ =
 156         PictureLayerTiling::Create(1, bounds, &picture_layer_tiling_client_);
 157     picture_layer_tiling_client_.set_tree(ACTIVE_TREE);
 158     picture_layer_tiling_->ComputeTilePriorityRects(
 159         ACTIVE_TREE, viewport, 1.0f, 1.0, Occlusion());
 160
 161     timer_.Reset();
 162     do {
 163       int count = num_tiles;
 164       PictureLayerTiling::TilingRasterTileIterator it(
 165           picture_layer_tiling_.get());
 166       while (count--) {
 167         ASSERT_TRUE(it) << "count: " << count;
 168         ASSERT_TRUE(*it != NULL) << "count: " << count;
 169         ++it;
 170       }
 171       timer_.NextLap();
 172     } while (!timer_.HasTimeLimitExpired());
 173
 174     perf_test::PrintResult("tiling_raster_tile_iterator_construct_and_iterate",
 175                            "",
 176                            test_name,
 177                            timer_.LapsPerSecond(),
 178                            "runs/s",
 179                            true);
 180   }
 181
 182   void RunEvictionIteratorConstructTest(const std::string& test_name,
 183                                         const gfx::Rect& viewport) {
 184     gfx::Size bounds(viewport.size());
 185     picture_layer_tiling_ =
 186         PictureLayerTiling::Create(1, bounds, &picture_layer_tiling_client_);
 187     picture_layer_tiling_client_.set_tree(ACTIVE_TREE);
 188     picture_layer_tiling_->ComputeTilePriorityRects(
 189         ACTIVE_TREE, viewport, 1.0f, 1.0, Occlusion());
 190
 191     timer_.Reset();
 192     TreePriority priorities[] = {SAME_PRIORITY_FOR_BOTH_TREES,
 193                                  SMOOTHNESS_TAKES_PRIORITY,
 194                                  NEW_CONTENT_TAKES_PRIORITY};
 195     int priority_count = 0;
 196     do {
 197       PictureLayerTiling::TilingEvictionTileIterator it(
 198           picture_layer_tiling_.get(),
 199           priorities[priority_count],
 200           PictureLayerTiling::NOW);
 201       priority_count = (priority_count + 1) % arraysize(priorities);
 202       timer_.NextLap();
 203     } while (!timer_.HasTimeLimitExpired());
 204
 205     perf_test::PrintResult("tiling_eviction_tile_iterator_construct",
 206                            "",
 207                            test_name,
 208                            timer_.LapsPerSecond(),
 209                            "runs/s",
 210                            true);
 211   }
 212
 213   void RunEvictionIteratorConstructAndIterateTest(const std::string& test_name,
 214                                                   int num_tiles,
 215                                                   const gfx::Rect& viewport) {
 216     gfx::Size bounds(10000, 10000);
 217     picture_layer_tiling_ =
 218         PictureLayerTiling::Create(1, bounds, &picture_layer_tiling_client_);
 219     picture_layer_tiling_client_.set_tree(ACTIVE_TREE);
 220     picture_layer_tiling_->ComputeTilePriorityRects(
 221         ACTIVE_TREE, viewport, 1.0f, 1.0, Occlusion());
 222
 223     TreePriority priorities[] = {SAME_PRIORITY_FOR_BOTH_TREES,
 224                                  SMOOTHNESS_TAKES_PRIORITY,
 225                                  NEW_CONTENT_TAKES_PRIORITY};
 226
 227     // Ensure all tiles have resources.
 228     std::vector<Tile*> all_tiles = picture_layer_tiling_->AllTilesForTesting();
 229     for (std::vector<Tile*>::iterator tile_it = all_tiles.begin();
 230          tile_it != all_tiles.end();
 231          ++tile_it) {
 232       Tile* tile = *tile_it;
 233       ManagedTileState::DrawInfo& draw_info = tile->draw_info();
 234       draw_info.SetResourceForTesting(
 235           ScopedResource::Create(resource_provider_.get()).Pass());
 236     }
 237
 238     int priority_count = 0;
 239     timer_.Reset();
 240     do {
 241       int count = num_tiles;
 242       PictureLayerTiling::TilingEvictionTileIterator it(
 243           picture_layer_tiling_.get(),
 244           priorities[priority_count],
 245           PictureLayerTiling::EVENTUALLY);
 246       while (count--) {
 247         ASSERT_TRUE(it) << "count: " << count;
 248         ASSERT_TRUE(*it != NULL) << "count: " << count;
 249         ++it;
 250       }
 251       priority_count = (priority_count + 1) % arraysize(priorities);
 252       timer_.NextLap();
 253     } while (!timer_.HasTimeLimitExpired());
 254
 255     // Remove all resources from tiles to make sure the tile version destructor
 256     // doesn't complain.
 257     for (std::vector<Tile*>::iterator tile_it = all_tiles.begin();
 258          tile_it != all_tiles.end();
 259          ++tile_it) {
 260       Tile* tile = *tile_it;
 261       ManagedTileState::DrawInfo& draw_info = tile->draw_info();
 262       draw_info.SetResourceForTesting(nullptr);
 263     }
 264
 265     perf_test::PrintResult(
 266         "tiling_eviction_tile_iterator_construct_and_iterate",
 267         "",
 268         test_name,
 269         timer_.LapsPerSecond(),
 270         "runs/s",
 271         true);
 272   }
 273
 274  private:
 275   FakePictureLayerTilingClient picture_layer_tiling_client_;
 276   scoped_ptr<PictureLayerTiling> picture_layer_tiling_;
 277
 278   LapTimer timer_;
 279
 280   scoped_refptr<ContextProvider> context_provider_;
 281   FakeOutputSurfaceClient output_surface_client_;
 282   scoped_ptr<FakeOutputSurface> output_surface_;
 283   scoped_ptr<SharedBitmapManager> shared_bitmap_manager_;
 284   scoped_ptr<ResourceProvider> resource_provider_;
 285 };
 286
 287 TEST_F(PictureLayerTilingPerfTest, Invalidate) {
 288   Region one_tile(gfx::Rect(256, 256));
 289   RunInvalidateTest("1x1", one_tile);
 290
 291   Region half_region(gfx::Rect(25 * 256, 50 * 256));
 292   RunInvalidateTest("25x50", half_region);
 293
 294   Region full_region(gfx::Rect(50 * 256, 50 * 256));
 295   RunInvalidateTest("50x50", full_region);
 296 }
 297
 298 #if defined(OS_ANDROID)
 299 // TODO(vmpstr): Investigate why this is noisy (crbug.com/310220).
 300 TEST_F(PictureLayerTilingPerfTest, DISABLED_ComputeTilePriorityRects) {
 301 #else
 302 TEST_F(PictureLayerTilingPerfTest, ComputeTilePriorityRects) {
 303 #endif  // defined(OS_ANDROID)
 304   gfx::Transform transform;
 305
 306   RunComputeTilePriorityRectsStationaryTest("no_transform", transform);
 307   RunComputeTilePriorityRectsScrollingTest("no_transform", transform);
 308
 309   transform.Rotate(10);
 310   RunComputeTilePriorityRectsStationaryTest("rotation", transform);
 311   RunComputeTilePriorityRectsScrollingTest("rotation", transform);
 312
 313   transform.ApplyPerspectiveDepth(10);
 314   RunComputeTilePriorityRectsStationaryTest("perspective", transform);
 315   RunComputeTilePriorityRectsScrollingTest("perspective", transform);
 316 }
 317
 318 TEST_F(PictureLayerTilingPerfTest, TilingRasterTileIteratorConstruct) {
 319   RunRasterIteratorConstructTest("0_0_100x100", gfx::Rect(0, 0, 100, 100));
 320   RunRasterIteratorConstructTest("50_0_100x100", gfx::Rect(50, 0, 100, 100));
 321   RunRasterIteratorConstructTest("100_0_100x100", gfx::Rect(100, 0, 100, 100));
 322   RunRasterIteratorConstructTest("150_0_100x100", gfx::Rect(150, 0, 100, 100));
 323 }
 324
 325 TEST_F(PictureLayerTilingPerfTest,
 326        TilingRasterTileIteratorConstructAndIterate) {
 327   RunRasterIteratorConstructAndIterateTest(
 328       "32_100x100", 32, gfx::Rect(0, 0, 100, 100));
 329   RunRasterIteratorConstructAndIterateTest(
 330       "32_500x500", 32, gfx::Rect(0, 0, 500, 500));
 331   RunRasterIteratorConstructAndIterateTest(
 332       "64_100x100", 64, gfx::Rect(0, 0, 100, 100));
 333   RunRasterIteratorConstructAndIterateTest(
 334       "64_500x500", 64, gfx::Rect(0, 0, 500, 500));
 335 }
 336
 337 TEST_F(PictureLayerTilingPerfTest, TilingEvictionTileIteratorConstruct) {
 338   RunEvictionIteratorConstructTest("0_0_100x100", gfx::Rect(0, 0, 100, 100));
 339   RunEvictionIteratorConstructTest("50_0_100x100", gfx::Rect(50, 0, 100, 100));
 340   RunEvictionIteratorConstructTest("100_0_100x100",
 341                                    gfx::Rect(100, 0, 100, 100));
 342   RunEvictionIteratorConstructTest("150_0_100x100",
 343                                    gfx::Rect(150, 0, 100, 100));
 344 }
 345
 346 TEST_F(PictureLayerTilingPerfTest,
 347        TilingEvictionTileIteratorConstructAndIterate) {
 348   RunEvictionIteratorConstructAndIterateTest(
 349       "32_100x100", 32, gfx::Rect(0, 0, 100, 100));
 350   RunEvictionIteratorConstructAndIterateTest(
 351       "32_500x500", 32, gfx::Rect(0, 0, 500, 500));
 352   RunEvictionIteratorConstructAndIterateTest(
 353       "64_100x100", 64, gfx::Rect(0, 0, 100, 100));
 354   RunEvictionIteratorConstructAndIterateTest(
 355       "64_500x500", 64, gfx::Rect(0, 0, 500, 500));
 356 }
 357
 358 }  // namespace
 359
 360 }  // namespace cc