picture_layer_tiling_perftest.cc revision 424c4d7b64af9d0d8fd9624f381f469654d5e3d2 
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
10namespace cc {
11
12namespace {
13
14static const int kTimeLimitMillis = 2000;
15static const int kWarmupRuns = 5;
16static const int kTimeCheckInterval = 10;
17
18class PictureLayerTilingPerfTest : public testing::Test {
19 public:
20  PictureLayerTilingPerfTest() : num_runs_(0) {}
21
22  virtual void SetUp() OVERRIDE {
23    picture_layer_tiling_client_.SetTileSize(gfx::Size(256, 256));
24    picture_layer_tiling_ = PictureLayerTiling::Create(
25        1, gfx::Size(256 * 50, 256 * 50), &picture_layer_tiling_client_);
26    picture_layer_tiling_->CreateAllTilesForTesting();
27  }
28
29  virtual void TearDown() OVERRIDE {
30    picture_layer_tiling_.reset(NULL);
31  }
32
33  void EndTest() {
34    elapsed_ = base::TimeTicks::HighResNow() - start_time_;
35  }
36
37  void AfterTest(const std::string& test_name) {
38    printf("*RESULT %s: %.2f runs/s\n",
39           test_name.c_str(),
40           num_runs_ / elapsed_.InSecondsF());
41  }
42
43  bool DidRun() {
44    ++num_runs_;
45    if (num_runs_ == kWarmupRuns)
46      start_time_ = base::TimeTicks::HighResNow();
47
48    if (!start_time_.is_null() && (num_runs_ % kTimeCheckInterval) == 0) {
49      base::TimeDelta elapsed = base::TimeTicks::HighResNow() - start_time_;
50      if (elapsed >= base::TimeDelta::FromMilliseconds(kTimeLimitMillis)) {
51        elapsed_ = elapsed;
52        return false;
53      }
54    }
55    return true;
56  }
57
58  void RunInvalidateTest(const std::string& test_name, const Region& region) {
59    start_time_ = base::TimeTicks();
60    num_runs_ = 0;
61    do {
62      picture_layer_tiling_->Invalidate(region);
63    } while (DidRun());
64
65    AfterTest(test_name);
66  }
67
68  void RunUpdateTilePrioritiesStationaryTest(
69      const std::string& test_name,
70      const gfx::Transform& transform) {
71    start_time_ = base::TimeTicks();
72    num_runs_ = 0;
73
74    gfx::Size layer_bounds(50 * 256, 50 * 256);
75    do {
76      picture_layer_tiling_->UpdateTilePriorities(
77        ACTIVE_TREE,
78        layer_bounds,
79        gfx::Rect(layer_bounds),
80        gfx::Rect(layer_bounds),
81        layer_bounds,
82        layer_bounds,
83        1.f,
84        1.f,
85        transform,
86        transform,
87        num_runs_ + 1,
88        250);
89    } while (DidRun());
90
91    AfterTest(test_name);
92  }
93
94  void RunUpdateTilePrioritiesScrollingTest(
95      const std::string& test_name,
96      const gfx::Transform& transform) {
97    start_time_ = base::TimeTicks();
98    num_runs_ = 0;
99
100    gfx::Size layer_bounds(50 * 256, 50 * 256);
101    gfx::Size viewport_size(1024, 768);
102    gfx::Rect viewport_rect(viewport_size);
103    int xoffsets[] = {10, 0, -10, 0};
104    int yoffsets[] = {0, 10, 0, -10};
105    int offsetIndex = 0;
106    int offsetCount = 0;
107    const int maxOffsetCount = 1000;
108    do {
109      picture_layer_tiling_->UpdateTilePriorities(
110        ACTIVE_TREE,
111        viewport_size,
112        viewport_rect,
113        gfx::Rect(layer_bounds),
114        layer_bounds,
115        layer_bounds,
116        1.f,
117        1.f,
118        transform,
119        transform,
120        num_runs_ + 1,
121        250);
122
123      viewport_rect = gfx::Rect(
124        viewport_rect.x() + xoffsets[offsetIndex],
125        viewport_rect.y() + yoffsets[offsetIndex],
126        viewport_rect.width(),
127        viewport_rect.height());
128
129      if (++offsetCount > maxOffsetCount) {
130        offsetCount = 0;
131        offsetIndex = (offsetIndex + 1) % 4;
132      }
133    } while (DidRun());
134
135    AfterTest(test_name);
136  }
137
138 private:
139  FakePictureLayerTilingClient picture_layer_tiling_client_;
140  scoped_ptr<PictureLayerTiling> picture_layer_tiling_;
141
142  base::TimeTicks start_time_;
143  base::TimeDelta elapsed_;
144  int num_runs_;
145};
146
147TEST_F(PictureLayerTilingPerfTest, Invalidate) {
148  Region one_tile(gfx::Rect(256, 256));
149  RunInvalidateTest("invalidation_1x1", one_tile);
150
151  Region half_region(gfx::Rect(25 * 256, 50 * 256));
152  RunInvalidateTest("invalidation_25x50", half_region);
153
154  Region full_region(gfx::Rect(50 * 256, 50 * 256));
155  RunInvalidateTest("invalidation_50x50", full_region);
156}
157
158TEST_F(PictureLayerTilingPerfTest, UpdateTilePriorities) {
159  gfx::Transform transform;
160  RunUpdateTilePrioritiesStationaryTest(
161      "update_tile_priorities_stationary_no_transform",
162      transform);
163  RunUpdateTilePrioritiesScrollingTest(
164      "update_tile_priorities_scrolling_no_transform",
165      transform);
166
167  transform.Rotate(10);
168  RunUpdateTilePrioritiesStationaryTest(
169      "update_tile_priorities_stationary_rotation",
170      transform);
171  RunUpdateTilePrioritiesScrollingTest(
172      "update_tile_priorities_scrolling_rotation",
173      transform);
174
175  transform.ApplyPerspectiveDepth(10);
176  RunUpdateTilePrioritiesStationaryTest(
177      "update_tile_priorities_stationary_perspective",
178      transform);
179  RunUpdateTilePrioritiesScrollingTest(
180      "update_tile_priorities_scrolling_perspective",
181      transform);
182}
183
184}  // namespace
185
186}  // namespace cc
187