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.
5 #include "base/time/time.h"
6 #include "cc/debug/lap_timer.h"
7 #include "cc/resources/raster_buffer.h"
8 #include "cc/resources/tile.h"
9 #include "cc/resources/tile_priority.h"
10 #include "cc/test/begin_frame_args_test.h"
11 #include "cc/test/fake_impl_proxy.h"
12 #include "cc/test/fake_layer_tree_host_impl.h"
13 #include "cc/test/fake_output_surface.h"
14 #include "cc/test/fake_output_surface_client.h"
15 #include "cc/test/fake_picture_layer_impl.h"
16 #include "cc/test/fake_picture_pile_impl.h"
17 #include "cc/test/fake_tile_manager.h"
18 #include "cc/test/fake_tile_manager_client.h"
19 #include "cc/test/impl_side_painting_settings.h"
20 #include "cc/test/test_shared_bitmap_manager.h"
21 #include "cc/test/test_tile_priorities.h"
22 #include "cc/trees/layer_tree_impl.h"
24 #include "testing/gtest/include/gtest/gtest.h"
25 #include "testing/perf/perf_test.h"
27 #include "ui/gfx/frame_time.h"
33 static const int kTimeLimitMillis = 2000;
34 static const int kWarmupRuns = 5;
35 static const int kTimeCheckInterval = 10;
37 class FakeRasterizerImpl : public Rasterizer, public RasterizerTaskClient {
39 // Overridden from Rasterizer:
40 virtual void SetClient(RasterizerClient* client) OVERRIDE {}
41 virtual void Shutdown() OVERRIDE {}
42 virtual void ScheduleTasks(RasterTaskQueue* queue) OVERRIDE {
43 for (RasterTaskQueue::Item::Vector::const_iterator it =
45 it != queue->items.end();
47 RasterTask* task = it->task;
50 task->ScheduleOnOriginThread(this);
53 completed_tasks_.push_back(task);
56 virtual void CheckForCompletedTasks() OVERRIDE {
57 for (RasterTask::Vector::iterator it = completed_tasks_.begin();
58 it != completed_tasks_.end();
60 RasterTask* task = it->get();
63 task->CompleteOnOriginThread(this);
66 task->RunReplyOnOriginThread();
68 completed_tasks_.clear();
71 // Overridden from RasterizerTaskClient:
72 virtual scoped_ptr<RasterBuffer> AcquireBufferForRaster(
73 const Resource* resource) OVERRIDE {
74 return scoped_ptr<RasterBuffer>();
76 virtual void ReleaseBufferForRaster(
77 scoped_ptr<RasterBuffer> buffer) OVERRIDE {}
80 RasterTask::Vector completed_tasks_;
82 base::LazyInstance<FakeRasterizerImpl> g_fake_rasterizer =
83 LAZY_INSTANCE_INITIALIZER;
85 class TileManagerPerfTest : public testing::Test {
88 : memory_limit_policy_(ALLOW_ANYTHING),
91 proxy_(base::MessageLoopProxy::current()),
92 host_impl_(ImplSidePaintingSettings(10000),
94 &shared_bitmap_manager_),
96 base::TimeDelta::FromMilliseconds(kTimeLimitMillis),
97 kTimeCheckInterval) {}
99 void SetTreePriority(TreePriority tree_priority) {
100 GlobalStateThatImpactsTilePriority state;
101 gfx::Size tile_size(256, 256);
103 state.soft_memory_limit_in_bytes = 100 * 1000 * 1000;
104 state.num_resources_limit = max_tiles_;
105 state.hard_memory_limit_in_bytes = state.soft_memory_limit_in_bytes * 2;
106 state.memory_limit_policy = memory_limit_policy_;
107 state.tree_priority = tree_priority;
109 global_state_ = state;
110 host_impl_.resource_pool()->SetResourceUsageLimits(
111 state.soft_memory_limit_in_bytes, 0, state.num_resources_limit);
112 host_impl_.tile_manager()->SetGlobalStateForTesting(state);
115 virtual void SetUp() OVERRIDE {
116 picture_pile_ = FakePicturePileImpl::CreateInfiniteFilledPile();
117 InitializeRenderer();
118 SetTreePriority(SAME_PRIORITY_FOR_BOTH_TREES);
121 virtual void InitializeRenderer() {
122 host_impl_.InitializeRenderer(
123 FakeOutputSurface::Create3d().PassAs<OutputSurface>());
124 tile_manager()->SetRasterizerForTesting(g_fake_rasterizer.Pointer());
127 void SetupDefaultTrees(const gfx::Size& layer_bounds) {
128 gfx::Size tile_size(100, 100);
130 scoped_refptr<FakePicturePileImpl> pending_pile =
131 FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
132 scoped_refptr<FakePicturePileImpl> active_pile =
133 FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
135 SetupTrees(pending_pile, active_pile);
138 void ActivateTree() {
139 host_impl_.ActivateSyncTree();
140 CHECK(!host_impl_.pending_tree());
141 pending_root_layer_ = NULL;
142 active_root_layer_ = static_cast<FakePictureLayerImpl*>(
143 host_impl_.active_tree()->LayerById(id_));
146 void SetupDefaultTreesWithFixedTileSize(const gfx::Size& layer_bounds,
147 const gfx::Size& tile_size) {
148 SetupDefaultTrees(layer_bounds);
149 pending_root_layer_->set_fixed_tile_size(tile_size);
150 active_root_layer_->set_fixed_tile_size(tile_size);
153 void SetupTrees(scoped_refptr<PicturePileImpl> pending_pile,
154 scoped_refptr<PicturePileImpl> active_pile) {
155 SetupPendingTree(active_pile);
157 SetupPendingTree(pending_pile);
160 void SetupPendingTree(scoped_refptr<PicturePileImpl> pile) {
161 host_impl_.CreatePendingTree();
162 LayerTreeImpl* pending_tree = host_impl_.pending_tree();
163 // Clear recycled tree.
164 pending_tree->DetachLayerTree();
166 scoped_ptr<FakePictureLayerImpl> pending_layer =
167 FakePictureLayerImpl::CreateWithPile(pending_tree, id_, pile);
168 pending_layer->SetDrawsContent(true);
169 pending_tree->SetRootLayer(pending_layer.PassAs<LayerImpl>());
171 pending_root_layer_ = static_cast<FakePictureLayerImpl*>(
172 host_impl_.pending_tree()->LayerById(id_));
173 pending_root_layer_->DoPostCommitInitializationIfNeeded();
176 void CreateHighLowResAndSetAllTilesVisible() {
177 // Active layer must get updated first so pending layer can share from it.
178 active_root_layer_->CreateDefaultTilingsAndTiles();
179 active_root_layer_->SetAllTilesVisible();
180 pending_root_layer_->CreateDefaultTilingsAndTiles();
181 pending_root_layer_->SetAllTilesVisible();
184 void RunRasterQueueConstructTest(const std::string& test_name,
186 TreePriority priorities[] = {SAME_PRIORITY_FOR_BOTH_TREES,
187 SMOOTHNESS_TAKES_PRIORITY,
188 NEW_CONTENT_TAKES_PRIORITY};
189 int priority_count = 0;
191 std::vector<LayerImpl*> layers = CreateLayers(layer_count, 10);
192 for (unsigned i = 0; i < layers.size(); ++i)
193 layers[i]->UpdateTiles(Occlusion());
197 RasterTilePriorityQueue queue;
198 host_impl_.BuildRasterQueue(&queue, priorities[priority_count]);
199 priority_count = (priority_count + 1) % arraysize(priorities);
201 } while (!timer_.HasTimeLimitExpired());
203 perf_test::PrintResult("tile_manager_raster_tile_queue_construct",
206 timer_.LapsPerSecond(),
211 void RunRasterQueueConstructAndIterateTest(const std::string& test_name,
213 unsigned tile_count) {
214 TreePriority priorities[] = {SAME_PRIORITY_FOR_BOTH_TREES,
215 SMOOTHNESS_TAKES_PRIORITY,
216 NEW_CONTENT_TAKES_PRIORITY};
218 std::vector<LayerImpl*> layers = CreateLayers(layer_count, 100);
219 for (unsigned i = 0; i < layers.size(); ++i)
220 layers[i]->UpdateTiles(Occlusion());
222 int priority_count = 0;
225 int count = tile_count;
226 RasterTilePriorityQueue queue;
227 host_impl_.BuildRasterQueue(&queue, priorities[priority_count]);
229 ASSERT_FALSE(queue.IsEmpty());
230 ASSERT_TRUE(queue.Top() != NULL);
233 priority_count = (priority_count + 1) % arraysize(priorities);
235 } while (!timer_.HasTimeLimitExpired());
237 perf_test::PrintResult(
238 "tile_manager_raster_tile_queue_construct_and_iterate",
241 timer_.LapsPerSecond(),
246 void RunEvictionQueueConstructTest(const std::string& test_name,
248 TreePriority priorities[] = {SAME_PRIORITY_FOR_BOTH_TREES,
249 SMOOTHNESS_TAKES_PRIORITY,
250 NEW_CONTENT_TAKES_PRIORITY};
251 int priority_count = 0;
253 std::vector<LayerImpl*> layers = CreateLayers(layer_count, 10);
254 for (unsigned i = 0; i < layers.size(); ++i) {
255 FakePictureLayerImpl* layer =
256 static_cast<FakePictureLayerImpl*>(layers[i]);
257 layer->UpdateTiles(Occlusion());
258 for (size_t j = 0; j < layer->GetTilings()->num_tilings(); ++j) {
259 tile_manager()->InitializeTilesWithResourcesForTesting(
260 layer->GetTilings()->tiling_at(j)->AllTilesForTesting());
266 EvictionTilePriorityQueue queue;
267 host_impl_.BuildEvictionQueue(&queue, priorities[priority_count]);
268 priority_count = (priority_count + 1) % arraysize(priorities);
270 } while (!timer_.HasTimeLimitExpired());
272 perf_test::PrintResult("tile_manager_eviction_tile_queue_construct",
275 timer_.LapsPerSecond(),
280 void RunEvictionQueueConstructAndIterateTest(const std::string& test_name,
282 unsigned tile_count) {
283 TreePriority priorities[] = {SAME_PRIORITY_FOR_BOTH_TREES,
284 SMOOTHNESS_TAKES_PRIORITY,
285 NEW_CONTENT_TAKES_PRIORITY};
286 int priority_count = 0;
288 std::vector<LayerImpl*> layers = CreateLayers(layer_count, tile_count);
289 for (unsigned i = 0; i < layers.size(); ++i) {
290 FakePictureLayerImpl* layer =
291 static_cast<FakePictureLayerImpl*>(layers[i]);
292 layer->UpdateTiles(Occlusion());
293 for (size_t j = 0; j < layer->GetTilings()->num_tilings(); ++j) {
294 tile_manager()->InitializeTilesWithResourcesForTesting(
295 layer->GetTilings()->tiling_at(j)->AllTilesForTesting());
301 int count = tile_count;
302 EvictionTilePriorityQueue queue;
303 host_impl_.BuildEvictionQueue(&queue, priorities[priority_count]);
305 ASSERT_FALSE(queue.IsEmpty());
306 ASSERT_TRUE(queue.Top() != NULL);
309 priority_count = (priority_count + 1) % arraysize(priorities);
311 } while (!timer_.HasTimeLimitExpired());
313 perf_test::PrintResult(
314 "tile_manager_eviction_tile_queue_construct_and_iterate",
317 timer_.LapsPerSecond(),
322 std::vector<LayerImpl*> CreateLayers(int layer_count,
323 int tiles_per_layer_count) {
324 // Compute the width/height required for high res to get
325 // tiles_per_layer_count tiles.
326 float width = std::sqrt(static_cast<float>(tiles_per_layer_count));
327 float height = tiles_per_layer_count / width;
329 // Adjust the width and height to account for the fact that tiles
330 // are bigger than 1x1. Also, account for the fact that that we
331 // will be creating one high res and one low res tiling. That is,
332 // width and height should be smaller by sqrt(1 + low_res_scale).
333 // This gives us _approximately_ correct counts.
334 width *= settings_.default_tile_size.width() /
335 std::sqrt(1 + settings_.low_res_contents_scale_factor);
336 height *= settings_.default_tile_size.height() /
337 std::sqrt(1 + settings_.low_res_contents_scale_factor);
339 // Ensure that we start with blank trees and no tiles.
340 host_impl_.ResetTreesForTesting();
341 tile_manager()->FreeResourcesAndCleanUpReleasedTilesForTesting();
343 gfx::Size layer_bounds(width, height);
344 gfx::Size viewport(width / 5, height / 5);
345 host_impl_.SetViewportSize(viewport);
346 SetupDefaultTreesWithFixedTileSize(layer_bounds,
347 settings_.default_tile_size);
349 active_root_layer_->CreateDefaultTilingsAndTiles();
350 pending_root_layer_->CreateDefaultTilingsAndTiles();
352 std::vector<LayerImpl*> layers;
354 // Pending layer counts as one layer.
355 layers.push_back(pending_root_layer_);
356 int next_id = id_ + 1;
358 // Create the rest of the layers as children of the root layer.
359 while (static_cast<int>(layers.size()) < layer_count) {
360 scoped_ptr<FakePictureLayerImpl> layer =
361 FakePictureLayerImpl::CreateWithPile(
362 host_impl_.pending_tree(), next_id, picture_pile_);
363 layer->SetBounds(layer_bounds);
364 layers.push_back(layer.get());
365 pending_root_layer_->AddChild(layer.PassAs<LayerImpl>());
367 FakePictureLayerImpl* fake_layer =
368 static_cast<FakePictureLayerImpl*>(layers.back());
370 fake_layer->SetDrawsContent(true);
371 fake_layer->DoPostCommitInitializationIfNeeded();
372 fake_layer->CreateDefaultTilingsAndTiles();
379 GlobalStateThatImpactsTilePriority GlobalStateForTest() {
380 GlobalStateThatImpactsTilePriority state;
381 gfx::Size tile_size = settings_.default_tile_size;
382 state.soft_memory_limit_in_bytes =
384 static_cast<size_t>(tile_size.width() * tile_size.height());
385 state.hard_memory_limit_in_bytes = state.soft_memory_limit_in_bytes;
386 state.num_resources_limit = 10000;
387 state.memory_limit_policy = ALLOW_ANYTHING;
388 state.tree_priority = SMOOTHNESS_TAKES_PRIORITY;
392 void RunManageTilesTest(const std::string& test_name,
394 int approximate_tile_count_per_layer) {
395 std::vector<LayerImpl*> layers =
396 CreateLayers(layer_count, approximate_tile_count_per_layer);
399 BeginFrameArgs args = CreateBeginFrameArgsForTesting();
400 host_impl_.UpdateCurrentBeginFrameArgs(args);
401 for (unsigned i = 0; i < layers.size(); ++i)
402 layers[i]->UpdateTiles(Occlusion());
404 GlobalStateThatImpactsTilePriority global_state(GlobalStateForTest());
405 tile_manager()->ManageTiles(global_state);
406 tile_manager()->UpdateVisibleTiles();
408 host_impl_.ResetCurrentBeginFrameArgsForNextFrame();
409 } while (!timer_.HasTimeLimitExpired());
411 perf_test::PrintResult(
412 "manage_tiles", "", test_name, timer_.LapsPerSecond(), "runs/s", true);
415 TileManager* tile_manager() { return host_impl_.tile_manager(); }
418 GlobalStateThatImpactsTilePriority global_state_;
420 TestSharedBitmapManager shared_bitmap_manager_;
421 TileMemoryLimitPolicy memory_limit_policy_;
424 FakeImplProxy proxy_;
425 FakeLayerTreeHostImpl host_impl_;
426 FakePictureLayerImpl* pending_root_layer_;
427 FakePictureLayerImpl* active_root_layer_;
429 scoped_refptr<FakePicturePileImpl> picture_pile_;
430 LayerTreeSettings settings_;
433 TEST_F(TileManagerPerfTest, ManageTiles) {
434 RunManageTilesTest("2_100", 2, 100);
435 RunManageTilesTest("2_500", 2, 500);
436 RunManageTilesTest("2_1000", 2, 1000);
437 RunManageTilesTest("10_100", 10, 100);
438 RunManageTilesTest("10_500", 10, 500);
439 RunManageTilesTest("10_1000", 10, 1000);
440 RunManageTilesTest("50_100", 100, 100);
441 RunManageTilesTest("50_500", 100, 500);
442 RunManageTilesTest("50_1000", 100, 1000);
445 TEST_F(TileManagerPerfTest, RasterTileQueueConstruct) {
446 RunRasterQueueConstructTest("2", 2);
447 RunRasterQueueConstructTest("10", 10);
448 RunRasterQueueConstructTest("50", 50);
451 TEST_F(TileManagerPerfTest, RasterTileQueueConstructAndIterate) {
452 RunRasterQueueConstructAndIterateTest("2_16", 2, 16);
453 RunRasterQueueConstructAndIterateTest("2_32", 2, 32);
454 RunRasterQueueConstructAndIterateTest("2_64", 2, 64);
455 RunRasterQueueConstructAndIterateTest("2_128", 2, 128);
456 RunRasterQueueConstructAndIterateTest("10_16", 10, 16);
457 RunRasterQueueConstructAndIterateTest("10_32", 10, 32);
458 RunRasterQueueConstructAndIterateTest("10_64", 10, 64);
459 RunRasterQueueConstructAndIterateTest("10_128", 10, 128);
460 RunRasterQueueConstructAndIterateTest("50_16", 50, 16);
461 RunRasterQueueConstructAndIterateTest("50_32", 50, 32);
462 RunRasterQueueConstructAndIterateTest("50_64", 50, 64);
463 RunRasterQueueConstructAndIterateTest("50_128", 50, 128);
466 TEST_F(TileManagerPerfTest, EvictionTileQueueConstruct) {
467 RunEvictionQueueConstructTest("2", 2);
468 RunEvictionQueueConstructTest("10", 10);
469 RunEvictionQueueConstructTest("50", 50);
472 TEST_F(TileManagerPerfTest, EvictionTileQueueConstructAndIterate) {
473 RunEvictionQueueConstructAndIterateTest("2_16", 2, 16);
474 RunEvictionQueueConstructAndIterateTest("2_32", 2, 32);
475 RunEvictionQueueConstructAndIterateTest("2_64", 2, 64);
476 RunEvictionQueueConstructAndIterateTest("2_128", 2, 128);
477 RunEvictionQueueConstructAndIterateTest("10_16", 10, 16);
478 RunEvictionQueueConstructAndIterateTest("10_32", 10, 32);
479 RunEvictionQueueConstructAndIterateTest("10_64", 10, 64);
480 RunEvictionQueueConstructAndIterateTest("10_128", 10, 128);
481 RunEvictionQueueConstructAndIterateTest("50_16", 50, 16);
482 RunEvictionQueueConstructAndIterateTest("50_32", 50, 32);
483 RunEvictionQueueConstructAndIterateTest("50_64", 50, 64);
484 RunEvictionQueueConstructAndIterateTest("50_128", 50, 128);