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