cc: Add tiling raster tile iterators.

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/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 49 matching lines @@
 
     perf_test::PrintResult("invalidation", "", test_name,
                            num_runs_ / elapsed_.InSecondsF(), "runs/s", true);
   }
 
   void RunUpdateTilePrioritiesStationaryTest(const std::string& test_name,
                                              const gfx::Transform& transform) {
     start_time_ = base::TimeTicks();
     num_runs_ = 0;
 
-    gfx::Size layer_bounds(50 * 256, 50 * 256);
     gfx::Rect viewport_rect(0, 0, 1024, 768);
     do {
       picture_layer_tiling_->UpdateTilePriorities(
           ACTIVE_TREE, viewport_rect, 1.f, num_runs_ + 1);
     } while (DidRun());
 
     perf_test::PrintResult("update_tile_priorities_stationary",
                            "",
                            test_name,
                            num_runs_ / elapsed_.InSecondsF(),
                            "runs/s",
                            true);
   }
 
   void RunUpdateTilePrioritiesScrollingTest(const std::string& test_name,
                                             const gfx::Transform& transform) {
     start_time_ = base::TimeTicks();
     num_runs_ = 0;
 
-    gfx::Size layer_bounds(50 * 256, 50 * 256);
     gfx::Size viewport_size(1024, 768);
     gfx::Rect viewport_rect(viewport_size);
     int xoffsets[] = {10, 0, -10, 0};
     int yoffsets[] = {0, 10, 0, -10};
     int offsetIndex = 0;
     int offsetCount = 0;
     const int maxOffsetCount = 1000;
     do {
       picture_layer_tiling_->UpdateTilePriorities(
           ACTIVE_TREE, viewport_rect, 1.f, num_runs_ + 1);
@@ skipping 10 matching lines @@
     } while (DidRun());
 
     perf_test::PrintResult("update_tile_priorities_scrolling",
                            "",
                            test_name,
                            num_runs_ / elapsed_.InSecondsF(),
                            "runs/s",
                            true);
   }
 
+  void RunTilingRasterTileIteratorTest(const std::string& test_name,
+                                       const gfx::Size& bounds,
+                                       const gfx::Rect& first_viewport,
+                                       const gfx::Rect& second_viewport) {
+    start_time_ = base::TimeTicks();
+    num_runs_ = 0;
+
+    picture_layer_tiling_ =
+        PictureLayerTiling::Create(1, bounds, &picture_layer_tiling_client_);
+    gfx::Rect viewports[2] = {first_viewport, second_viewport};
+
+    do {
+      picture_layer_tiling_->UpdateTilePriorities(
+          ACTIVE_TREE, viewports[num_runs_ % 2], 1.f, num_runs_ + 1);
+      for (PictureLayerTiling::TilingRasterTileIterator it(
+               picture_layer_tiling_.get(), ACTIVE_TREE);
+           it;
+           ++it)
+        continue;
+    } while (DidRun());
+
+    perf_test::PrintResult("tiling_raster_tile_iterator",
+                           "",
+                           test_name,
+                           num_runs_ / elapsed_.InSecondsF(),
+                           "runs/s",

[epenner, 2014/03/06 10:21:40]

Again no need to change if you don't want, but I'm a huge fan of reporting
absolute times. Firstly seconds isn't a relevant unit for CC (I hope! ;) ), and
second improvements are relative this way. For example, "I improved the frame
rate by 5fps" doesn't mean anything (maybe the framerate is already 1000fps),
whereas "I improved the frame time by 5ms" will always mean the same thing.

[vmpstr, 2014/03/07 18:22:23]

Hmm, that's a good point. I mean looking at our perf tests, a lot of them report
runs/s. Isn't ms/run just a 1000/this number? :P

[epennerAtGoogle, 2014/03/11 19:04:50]

I'm sure you jest, but I'm not sure in which direction.

It's indeed trivial to convert the number if that's what you mean. It's just bad
UX if 1,000/number or 1,000,000/number is what you always want to know. Or
perhaps you meant 1,000,000/number is not trivial to compute in one's head at
just a glance, in which case I agree.

Anyway, I'm used to runs/s so no worries if we keep it that way.

+                           true);
+  }
+
  private:
   FakePictureLayerTilingClient picture_layer_tiling_client_;
   scoped_ptr<PictureLayerTiling> picture_layer_tiling_;
 
   base::TimeTicks start_time_;
   base::TimeDelta elapsed_;
   int num_runs_;
 };
 
 TEST_F(PictureLayerTilingPerfTest, Invalidate) {
@@ skipping 20 matching lines @@
 
   transform.Rotate(10);
   RunUpdateTilePrioritiesStationaryTest("rotation", transform);
   RunUpdateTilePrioritiesScrollingTest("rotation", transform);
 
   transform.ApplyPerspectiveDepth(10);
   RunUpdateTilePrioritiesStationaryTest("perspective", transform);
   RunUpdateTilePrioritiesScrollingTest("perspective", transform);
 }
 
+TEST_F(PictureLayerTilingPerfTest, TilingRasterTileIterator) {

[enne (OOO), 2014/03/06 02:30:45]

This is a little weird.  Isn't this an UpdateTilePriorities test and not a
RasterTileIterator test? This test won't really be here in the end state, right?

[epenner, 2014/03/06 10:21:40]

Hmm, to represent final performance here, could we create different numbers of
layers and then pull a total of 32 tiles out of that set of layers?  That's the
real performance right?

[vmpstr, 2014/03/07 18:22:23]

Yeah, but I'd prefer to do that at the LayerRasterTileIterator level, not at the
tiling level. This should just run the iterator through all the tiles as fast as
it can, I think.

[vmpstr, 2014/03/07 18:22:23]

This tests calls update tile priorities (to create tiles and set the rects),
followed by iterating all tiles using raster tile iterator. I think this test
would still be here in the end.

I can move UpdateTilePriorities outside of the loop and remove "moving" versions
of the tests. Would you prefer that?

[enne (OOO), 2014/03/10 21:36:30]

But in the end state we're not going to iterate through all tiles.  We're going
to find n tiles, and it's not going to be via some universal
UpdateTilePriorities function that updates/finds everything.

[epennerAtGoogle, 2014/03/11 19:04:50]

I wanted to mention another thing I thought of here. Although we will only pull
k=32 tiles, in the steady-state we will walk all rastered tiles. So the real
perf should be O(n) based on memory limit (or perhaps maximum
skewport/eventually-rect sizes assuming the memory limit is large).

+  RunTilingRasterTileIteratorTest("1k_bounds_100_vp_stationary",
+                                  gfx::Size(1000, 1000),
+                                  gfx::Rect(0, 0, 100, 100),
+                                  gfx::Rect(0, 0, 100, 100));
+  RunTilingRasterTileIteratorTest("1k_bounds_100_vp_moving",
+                                  gfx::Size(1000, 1000),
+                                  gfx::Rect(0, 0, 100, 100),
+                                  gfx::Rect(0, 100, 100, 100));
+  RunTilingRasterTileIteratorTest("1k_bounds_500_vp_stationary",
+                                  gfx::Size(1000, 1000),
+                                  gfx::Rect(0, 0, 500, 500),
+                                  gfx::Rect(0, 0, 500, 500));
+  RunTilingRasterTileIteratorTest("1k_bounds_500_vp_moving",
+                                  gfx::Size(1000, 1000),
+                                  gfx::Rect(0, 0, 500, 500),
+                                  gfx::Rect(0, 100, 500, 500));
+  RunTilingRasterTileIteratorTest("2k_bounds_100_vp_stationary",
+                                  gfx::Size(2000, 2000),
+                                  gfx::Rect(0, 0, 100, 100),
+                                  gfx::Rect(0, 0, 100, 100));
+  RunTilingRasterTileIteratorTest("2k_bounds_100_vp_moving",
+                                  gfx::Size(2000, 2000),
+                                  gfx::Rect(0, 0, 100, 100),
+                                  gfx::Rect(0, 100, 100, 100));
+  RunTilingRasterTileIteratorTest("2k_bounds_500_vp_stationary",
+                                  gfx::Size(2000, 2000),
+                                  gfx::Rect(0, 0, 500, 500),
+                                  gfx::Rect(0, 0, 500, 500));
+  RunTilingRasterTileIteratorTest("2k_bounds_500_vp_moving",
+                                  gfx::Size(2000, 2000),
+                                  gfx::Rect(0, 0, 500, 500),
+                                  gfx::Rect(0, 100, 500, 500));
+}
+
 }  // namespace
 
 }  // namespace cc