cc: Add tiling eviction iterator perftests.

cc/resources/picture_layer_tiling_perftest.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/debug/lap_timer.h"
 #include "cc/resources/picture_layer_tiling.h"
 #include "cc/test/fake_picture_layer_tiling_client.h"
 
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/perf/perf_test.h"
@@ skipping 123 matching lines @@
     } while (!timer_.HasTimeLimitExpired());
 
     perf_test::PrintResult("tiling_raster_tile_iterator",
                            "",
                            test_name,
                            timer_.LapsPerSecond(),
                            "runs/s",
                            true);
   }
 
+  void RunTilingEvictionTileIteratorConstructionTest(
+      const std::string& test_name,
+      const gfx::Rect& viewport) {
+    gfx::Size bounds(viewport.size());
+    picture_layer_tiling_ =
+        PictureLayerTiling::Create(1, bounds, &picture_layer_tiling_client_);
+    picture_layer_tiling_->UpdateTilePriorities(
+        ACTIVE_TREE, viewport, 1.0f, 1.0, NULL, NULL, gfx::Transform());
+
+    timer_.Reset();
+    const int num_tree_priorities = 3;

[reveman, 2014/07/16 20:17:05]

nit: can you remove this and just do "priorities[] = {...}" and use arraysize?

[vmpstr, 2014/07/16 20:35:22]

Done.

+    TreePriority priorities[num_tree_priorities] = {
+        SAME_PRIORITY_FOR_BOTH_TREES, SMOOTHNESS_TAKES_PRIORITY,
+        NEW_CONTENT_TAKES_PRIORITY};
+    int priority_count = 0;
+    do {
+      PictureLayerTiling::TilingEvictionTileIterator it(
+          picture_layer_tiling_.get(), priorities[priority_count]);
+      priority_count = (priority_count + 1) % num_tree_priorities;
+      timer_.NextLap();
+    } while (!timer_.HasTimeLimitExpired());
+
+    perf_test::PrintResult("tiling_eviction_tile_iterator_construction",
+                           "",
+                           test_name,
+                           timer_.LapsPerSecond(),
+                           "runs/s",
+                           true);
+  }
+
+  void RunTilingEvictionTileIteratorTest(const std::string& test_name,
+                                         int num_tiles,
+                                         const gfx::Rect& viewport) {
+    gfx::Size bounds(10000, 10000);
+    picture_layer_tiling_ =
+        PictureLayerTiling::Create(1, bounds, &picture_layer_tiling_client_);
+    picture_layer_tiling_->UpdateTilePriorities(
+        ACTIVE_TREE, viewport, 1.0f, 1.0, NULL, NULL, gfx::Transform());
+
+    timer_.Reset();
+    const int num_tree_priorities = 3;

[reveman, 2014/07/16 20:17:05]

nit: remove and use arraysize?

[vmpstr, 2014/07/16 20:35:22]

Done.

+    TreePriority priorities[num_tree_priorities] = {
+        SAME_PRIORITY_FOR_BOTH_TREES, SMOOTHNESS_TAKES_PRIORITY,
+        NEW_CONTENT_TAKES_PRIORITY};
+    int priority_count = 0;
+    do {
+      int count = num_tiles;
+      for (PictureLayerTiling::TilingEvictionTileIterator it(
+               picture_layer_tiling_.get(), priorities[priority_count]);
+           it && count;

[reveman, 2014/07/16 20:17:05]

can you DHCECK(it) instead as the result would not be what we expect if
something changes that cause count to not drop to 0?

[vmpstr, 2014/07/16 20:35:22]

That's the reason it needs resources. The iterator doesn't return tiles with no
resources. So in effect here count is unchanged. The work done by the iterator
is equivalent to finding a tile with resources, which it doesn't so it returns
false.

it uses tile->HasResources(), which under the covers returns true if one of the
tile versions' resource_ is not null. 

Short of using resources, one approach would be to say something like
tile->SetHasResourcesForTesting(); but then that would result in a somewhat ugly
HasResources implementation:

bool HasResources() {
 if (has_resources_for_testing_)
   return true;
 // check tile versions
}

which would run in non test code as well...

Alternatively we can just change the test to do "ASSERT_FALSE(it);" so that it
still does the work, but doesn't mislead people into thinking this returns
something.

Wdyt?

[reveman, 2014/07/16 22:03:34]

Can you set it to a fake resource? It seems better to mimic the real usage as
close as possible and not assume that the implementation does basically the same
when no resources are set.

[vmpstr, 2014/07/16 23:43:29]

Done.

+           ++it) {
+        --count;
+      }
+      priority_count = (priority_count + 1) % num_tree_priorities;
+      timer_.NextLap();
+    } while (!timer_.HasTimeLimitExpired());
+
+    perf_test::PrintResult("tiling_eviction_tile_iterator",
+                           "",
+                           test_name,
+                           timer_.LapsPerSecond(),
+                           "runs/s",
+                           true);
+  }

[reveman, 2014/07/16 20:17:05]

It's a bit hard to evaluate this test when the result also includes ctor cost.
ie. a change that improves ctor perf but regress iteration perf will look like
it only improved ctor perf and iteration perf was unaffected.

Unless there's an easy way to make this only test iteration cost I think we
should rename it to something like
tiling_eviction_tile_iterator_construct_and_iterate to avoid confusion.

[vmpstr, 2014/07/16 20:35:22]

I've changed the name, since I think it's kind of hard to separate construction,
and then do repeated iteration

+
  private:
   FakePictureLayerTilingClient picture_layer_tiling_client_;
   scoped_ptr<PictureLayerTiling> picture_layer_tiling_;
 
   LapTimer timer_;
 };
 
 TEST_F(PictureLayerTilingPerfTest, Invalidate) {
   Region one_tile(gfx::Rect(256, 256));
   RunInvalidateTest("1x1", one_tile);
@@ skipping 25 matching lines @@
   RunUpdateTilePrioritiesScrollingTest("perspective", transform);
 }
 
 TEST_F(PictureLayerTilingPerfTest, TilingRasterTileIterator) {
   RunTilingRasterTileIteratorTest("32_100x100", 32, gfx::Rect(0, 0, 100, 100));
   RunTilingRasterTileIteratorTest("32_500x500", 32, gfx::Rect(0, 0, 500, 500));
   RunTilingRasterTileIteratorTest("64_100x100", 64, gfx::Rect(0, 0, 100, 100));
   RunTilingRasterTileIteratorTest("64_500x500", 64, gfx::Rect(0, 0, 500, 500));
 }
 
+TEST_F(PictureLayerTilingPerfTest, TilingEvictionTileIteratorConstruction) {
+  RunTilingEvictionTileIteratorConstructionTest("0_0_100x100",
+                                                gfx::Rect(0, 0, 100, 100));
+  RunTilingEvictionTileIteratorConstructionTest("50_0_100x100",
+                                                gfx::Rect(50, 0, 100, 100));
+  RunTilingEvictionTileIteratorConstructionTest("100_0_100x100",
+                                                gfx::Rect(100, 0, 100, 100));
+  RunTilingEvictionTileIteratorConstructionTest("150_0_100x100",
+                                                gfx::Rect(150, 0, 100, 100));
+}
+
+TEST_F(PictureLayerTilingPerfTest, TilingEvictionTileIterator) {
+  RunTilingEvictionTileIteratorTest(
+      "32_100x100", 32, gfx::Rect(0, 0, 100, 100));
+  RunTilingEvictionTileIteratorTest(
+      "32_500x500", 32, gfx::Rect(0, 0, 500, 500));
+  RunTilingEvictionTileIteratorTest(
+      "64_100x100", 64, gfx::Rect(0, 0, 100, 100));
+  RunTilingEvictionTileIteratorTest(
+      "64_500x500", 64, gfx::Rect(0, 0, 500, 500));
+}
+
 }  // namespace
 
 }  // namespace cc