cc: Add eviction tile queue construct (and iterate) perftests.

This patch adds construct as well as construct and iterate perftests
for the eviction tile priority queue.

Initial runs (from my macbook):
[ RUN      ] TileManagerPerfTest.EvictionTileQueueConstruct
*RESULT tile_manager_eviction_tile_queue_construct: 2= 412610.25 runs/s
*RESULT tile_manager_eviction_tile_queue_construct: 10= 48552.328125 runs/s
*RESULT tile_manager_eviction_tile_queue_construct: 100= 1245.8426513671875 runs/s
[       OK ] TileManagerPerfTest.EvictionTileQueueConstruct (6185 ms)
[ RUN      ] TileManagerPerfTest.EvictionTileQueueConstructAndIterate
*RESULT tile_manager_eviction_tile_queue_construct_and_iterate: 2_16= 3109.413818359375 runs/s
*RESULT tile_manager_eviction_tile_queue_construct_and_iterate: 2_32= 2810.639404296875 runs/s
*RESULT tile_manager_eviction_tile_queue_construct_and_iterate: 2_64= 2365.239990234375 runs/s
*RESULT tile_manager_eviction_tile_queue_construct_and_iterate: 2_128= 1793.8878173828125 runs/s
[       OK ] TileManagerPerfTest.EvictionTileQueueConstructAndIterate (8358 ms)

R=reveman

Review URL: https://codereview.chromium.org/410523002

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@285645 0039d316-1c4b-4281-b951-d872f2087c98

cc/resources/tile_manager_perftest.cc

@@ -225,6 +225,56 @@ class TileManagerPerfTest : public testing::Test {
         true);
   }
 
+  void RunEvictionQueueConstructTest(const std::string& test_name) {
+    TreePriority priorities[] = {SAME_PRIORITY_FOR_BOTH_TREES,
+                                 SMOOTHNESS_TAKES_PRIORITY,
+                                 NEW_CONTENT_TAKES_PRIORITY};
+    int priority_count = 0;
+    timer_.Reset();
+    do {
+      EvictionTilePriorityQueue queue;
+      host_impl_.BuildEvictionQueue(&queue, priorities[priority_count]);
+      priority_count = (priority_count + 1) % arraysize(priorities);
+      timer_.NextLap();
+    } while (!timer_.HasTimeLimitExpired());
+
+    perf_test::PrintResult("tile_manager_eviction_tile_queue_construct",
+                           "",
+                           test_name,
+                           timer_.LapsPerSecond(),
+                           "runs/s",
+                           true);
+  }
+
+  void RunEvictionQueueConstructAndIterateTest(const std::string& test_name,
+                                               unsigned tile_count) {
+    TreePriority priorities[] = {SAME_PRIORITY_FOR_BOTH_TREES,
+                                 SMOOTHNESS_TAKES_PRIORITY,
+                                 NEW_CONTENT_TAKES_PRIORITY};
+    int priority_count = 0;
+    timer_.Reset();
+    do {
+      int count = tile_count;
+      EvictionTilePriorityQueue queue;
+      host_impl_.BuildEvictionQueue(&queue, priorities[priority_count]);
+      while (count--) {
+        ASSERT_FALSE(queue.IsEmpty());
+        ASSERT_TRUE(queue.Top() != NULL);
+        queue.Pop();
+      }
+      priority_count = (priority_count + 1) % arraysize(priorities);
+      timer_.NextLap();
+    } while (!timer_.HasTimeLimitExpired());
+
+    perf_test::PrintResult(
+        "tile_manager_eviction_tile_queue_construct_and_iterate",
+        "",
+        test_name,
+        timer_.LapsPerSecond(),
+        "runs/s",
+        true);
+  }
+
   std::vector<LayerImpl*> CreateLayers(int layer_count,
                                        int tiles_per_layer_count) {
     // Compute the width/height required for high res to get
@@ -386,6 +436,64 @@ TEST_F(TileManagerPerfTest, RasterTileQueueConstructAndIterate) {
   RunRasterQueueConstructAndIterateTest("2_128", 128);
 }
 
+TEST_F(TileManagerPerfTest, EvictionTileQueueConstruct) {
+  SetupDefaultTrees(gfx::Size(1000, 1000));
+  active_root_layer_->CreateDefaultTilingsAndTiles();
+  for (size_t i = 0; i < active_root_layer_->GetTilings()->num_tilings(); ++i) {
+    tile_manager()->InitializeTilesWithResourcesForTesting(
+        active_root_layer_->GetTilings()->tiling_at(i)->AllTilesForTesting());
+  }
+  pending_root_layer_->CreateDefaultTilingsAndTiles();
+  for (size_t i = 0; i < pending_root_layer_->GetTilings()->num_tilings();
+       ++i) {
+    tile_manager()->InitializeTilesWithResourcesForTesting(
+        pending_root_layer_->GetTilings()->tiling_at(i)->AllTilesForTesting());
+  }
+
+  RunEvictionQueueConstructTest("2");
+
+  int number_of_tilings = 2;
+  for (; number_of_tilings < 10; ++number_of_tilings) {
+    PictureLayerTiling* tiling =
+        active_root_layer_->AddTiling(1.0f + number_of_tilings * 0.3f);
+    tiling->CreateAllTilesForTesting();
+    tile_manager()->InitializeTilesWithResourcesForTesting(
+        tiling->AllTilesForTesting());
+  }
+
+  RunEvictionQueueConstructTest("10");
+
+  for (; number_of_tilings < 50; ++number_of_tilings) {
+    PictureLayerTiling* tiling =
+        active_root_layer_->AddTiling(1.0f + number_of_tilings * 0.3f);
+    tiling->CreateAllTilesForTesting();
+    tile_manager()->InitializeTilesWithResourcesForTesting(
+        tiling->AllTilesForTesting());
+  }
+
+  RunEvictionQueueConstructTest("50");
+}
+
+TEST_F(TileManagerPerfTest, EvictionTileQueueConstructAndIterate) {
+  SetupDefaultTrees(gfx::Size(10000, 10000));
+  active_root_layer_->CreateDefaultTilingsAndTiles();
+  for (size_t i = 0; i < active_root_layer_->GetTilings()->num_tilings(); ++i) {
+    tile_manager()->InitializeTilesWithResourcesForTesting(
+        active_root_layer_->GetTilings()->tiling_at(i)->AllTilesForTesting());
+  }
+  pending_root_layer_->CreateDefaultTilingsAndTiles();
+  for (size_t i = 0; i < pending_root_layer_->GetTilings()->num_tilings();
+       ++i) {
+    tile_manager()->InitializeTilesWithResourcesForTesting(
+        pending_root_layer_->GetTilings()->tiling_at(i)->AllTilesForTesting());
+  }
+
+  RunEvictionQueueConstructAndIterateTest("2_16", 16);
+  RunEvictionQueueConstructAndIterateTest("2_32", 32);
+  RunEvictionQueueConstructAndIterateTest("2_64", 64);
+  RunEvictionQueueConstructAndIterateTest("2_128", 128);
+}
+
 }  // namespace
 
 }  // namespace cc

cc/test/fake_picture_layer_impl.h

@@ -93,6 +93,7 @@ class FakePictureLayerImpl : public PictureLayerImpl {
   void SetAllTilesReady();
   void SetAllTilesReadyInTiling(PictureLayerTiling* tiling);
   void ResetAllTilesPriorities();
+  PictureLayerTilingSet* GetTilings() { return tilings_.get(); }
 
  protected:
   FakePictureLayerImpl(