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 bool resourceless_software_draw = false;
193 for (unsigned i = 0; i < layers.size(); ++i) {
194 layers[i]->UpdateTiles(Occlusion(), resourceless_software_draw);
199 RasterTilePriorityQueue queue;
200 host_impl_.BuildRasterQueue(&queue, priorities[priority_count]);
201 priority_count = (priority_count + 1) % arraysize(priorities);
203 } while (!timer_.HasTimeLimitExpired());
205 perf_test::PrintResult("tile_manager_raster_tile_queue_construct",
208 timer_.LapsPerSecond(),
213 void RunRasterQueueConstructAndIterateTest(const std::string& test_name,
215 unsigned tile_count) {
216 TreePriority priorities[] = {SAME_PRIORITY_FOR_BOTH_TREES,
217 SMOOTHNESS_TAKES_PRIORITY,
218 NEW_CONTENT_TAKES_PRIORITY};
220 std::vector<LayerImpl*> layers = CreateLayers(layer_count, 100);
221 bool resourceless_software_draw = false;
222 for (unsigned i = 0; i < layers.size(); ++i) {
223 layers[i]->UpdateTiles(Occlusion(), resourceless_software_draw);
226 int priority_count = 0;
229 int count = tile_count;
230 RasterTilePriorityQueue queue;
231 host_impl_.BuildRasterQueue(&queue, priorities[priority_count]);
233 ASSERT_FALSE(queue.IsEmpty());
234 ASSERT_TRUE(queue.Top() != NULL);
237 priority_count = (priority_count + 1) % arraysize(priorities);
239 } while (!timer_.HasTimeLimitExpired());
241 perf_test::PrintResult(
242 "tile_manager_raster_tile_queue_construct_and_iterate",
245 timer_.LapsPerSecond(),
250 void RunEvictionQueueConstructTest(const std::string& test_name,
252 TreePriority priorities[] = {SAME_PRIORITY_FOR_BOTH_TREES,
253 SMOOTHNESS_TAKES_PRIORITY,
254 NEW_CONTENT_TAKES_PRIORITY};
255 int priority_count = 0;
257 std::vector<LayerImpl*> layers = CreateLayers(layer_count, 10);
258 bool resourceless_software_draw = false;
259 for (unsigned i = 0; i < layers.size(); ++i) {
260 FakePictureLayerImpl* layer =
261 static_cast<FakePictureLayerImpl*>(layers[i]);
262 layer->UpdateTiles(Occlusion(), resourceless_software_draw);
263 for (size_t j = 0; j < layer->GetTilings()->num_tilings(); ++j) {
264 tile_manager()->InitializeTilesWithResourcesForTesting(
265 layer->GetTilings()->tiling_at(j)->AllTilesForTesting());
271 EvictionTilePriorityQueue queue;
272 host_impl_.BuildEvictionQueue(&queue, priorities[priority_count]);
273 priority_count = (priority_count + 1) % arraysize(priorities);
275 } while (!timer_.HasTimeLimitExpired());
277 perf_test::PrintResult("tile_manager_eviction_tile_queue_construct",
280 timer_.LapsPerSecond(),
285 void RunEvictionQueueConstructAndIterateTest(const std::string& test_name,
287 unsigned tile_count) {
288 TreePriority priorities[] = {SAME_PRIORITY_FOR_BOTH_TREES,
289 SMOOTHNESS_TAKES_PRIORITY,
290 NEW_CONTENT_TAKES_PRIORITY};
291 int priority_count = 0;
293 std::vector<LayerImpl*> layers = CreateLayers(layer_count, tile_count);
294 bool resourceless_software_draw = false;
295 for (unsigned i = 0; i < layers.size(); ++i) {
296 FakePictureLayerImpl* layer =
297 static_cast<FakePictureLayerImpl*>(layers[i]);
298 layer->UpdateTiles(Occlusion(), resourceless_software_draw);
299 for (size_t j = 0; j < layer->GetTilings()->num_tilings(); ++j) {
300 tile_manager()->InitializeTilesWithResourcesForTesting(
301 layer->GetTilings()->tiling_at(j)->AllTilesForTesting());
307 int count = tile_count;
308 EvictionTilePriorityQueue queue;
309 host_impl_.BuildEvictionQueue(&queue, priorities[priority_count]);
311 ASSERT_FALSE(queue.IsEmpty());
312 ASSERT_TRUE(queue.Top() != NULL);
315 priority_count = (priority_count + 1) % arraysize(priorities);
317 } while (!timer_.HasTimeLimitExpired());
319 perf_test::PrintResult(
320 "tile_manager_eviction_tile_queue_construct_and_iterate",
323 timer_.LapsPerSecond(),
328 std::vector<LayerImpl*> CreateLayers(int layer_count,
329 int tiles_per_layer_count) {
330 // Compute the width/height required for high res to get
331 // tiles_per_layer_count tiles.
332 float width = std::sqrt(static_cast<float>(tiles_per_layer_count));
333 float height = tiles_per_layer_count / width;
335 // Adjust the width and height to account for the fact that tiles
336 // are bigger than 1x1. Also, account for the fact that that we
337 // will be creating one high res and one low res tiling. That is,
338 // width and height should be smaller by sqrt(1 + low_res_scale).
339 // This gives us _approximately_ correct counts.
340 width *= settings_.default_tile_size.width() /
341 std::sqrt(1 + settings_.low_res_contents_scale_factor);
342 height *= settings_.default_tile_size.height() /
343 std::sqrt(1 + settings_.low_res_contents_scale_factor);
345 // Ensure that we start with blank trees and no tiles.
346 host_impl_.ResetTreesForTesting();
347 tile_manager()->FreeResourcesAndCleanUpReleasedTilesForTesting();
349 gfx::Size layer_bounds(width, height);
350 gfx::Size viewport(width / 5, height / 5);
351 host_impl_.SetViewportSize(viewport);
352 SetupDefaultTreesWithFixedTileSize(layer_bounds,
353 settings_.default_tile_size);
355 active_root_layer_->CreateDefaultTilingsAndTiles();
356 pending_root_layer_->CreateDefaultTilingsAndTiles();
358 std::vector<LayerImpl*> layers;
360 // Pending layer counts as one layer.
361 layers.push_back(pending_root_layer_);
362 int next_id = id_ + 1;
364 // Create the rest of the layers as children of the root layer.
365 while (static_cast<int>(layers.size()) < layer_count) {
366 scoped_ptr<FakePictureLayerImpl> layer =
367 FakePictureLayerImpl::CreateWithPile(
368 host_impl_.pending_tree(), next_id, picture_pile_);
369 layer->SetBounds(layer_bounds);
370 layers.push_back(layer.get());
371 pending_root_layer_->AddChild(layer.PassAs<LayerImpl>());
373 FakePictureLayerImpl* fake_layer =
374 static_cast<FakePictureLayerImpl*>(layers.back());
376 fake_layer->SetDrawsContent(true);
377 fake_layer->DoPostCommitInitializationIfNeeded();
378 fake_layer->CreateDefaultTilingsAndTiles();
385 GlobalStateThatImpactsTilePriority GlobalStateForTest() {
386 GlobalStateThatImpactsTilePriority state;
387 gfx::Size tile_size = settings_.default_tile_size;
388 state.soft_memory_limit_in_bytes =
390 static_cast<size_t>(tile_size.width() * tile_size.height());
391 state.hard_memory_limit_in_bytes = state.soft_memory_limit_in_bytes;
392 state.num_resources_limit = 10000;
393 state.memory_limit_policy = ALLOW_ANYTHING;
394 state.tree_priority = SMOOTHNESS_TAKES_PRIORITY;
398 void RunManageTilesTest(const std::string& test_name,
400 int approximate_tile_count_per_layer) {
401 std::vector<LayerImpl*> layers =
402 CreateLayers(layer_count, approximate_tile_count_per_layer);
404 bool resourceless_software_draw = false;
406 BeginFrameArgs args = CreateBeginFrameArgsForTesting();
407 host_impl_.UpdateCurrentBeginFrameArgs(args);
408 for (unsigned i = 0; i < layers.size(); ++i) {
409 layers[i]->UpdateTiles(Occlusion(), resourceless_software_draw);
412 GlobalStateThatImpactsTilePriority global_state(GlobalStateForTest());
413 tile_manager()->ManageTiles(global_state);
414 tile_manager()->UpdateVisibleTiles();
416 host_impl_.ResetCurrentBeginFrameArgsForNextFrame();
417 } while (!timer_.HasTimeLimitExpired());
419 perf_test::PrintResult(
420 "manage_tiles", "", test_name, timer_.LapsPerSecond(), "runs/s", true);
423 TileManager* tile_manager() { return host_impl_.tile_manager(); }
426 GlobalStateThatImpactsTilePriority global_state_;
428 TestSharedBitmapManager shared_bitmap_manager_;
429 TileMemoryLimitPolicy memory_limit_policy_;
432 FakeImplProxy proxy_;
433 FakeLayerTreeHostImpl host_impl_;
434 FakePictureLayerImpl* pending_root_layer_;
435 FakePictureLayerImpl* active_root_layer_;
437 scoped_refptr<FakePicturePileImpl> picture_pile_;
438 LayerTreeSettings settings_;
441 TEST_F(TileManagerPerfTest, ManageTiles) {
442 RunManageTilesTest("2_100", 2, 100);
443 RunManageTilesTest("2_500", 2, 500);
444 RunManageTilesTest("2_1000", 2, 1000);
445 RunManageTilesTest("10_100", 10, 100);
446 RunManageTilesTest("10_500", 10, 500);
447 RunManageTilesTest("10_1000", 10, 1000);
448 RunManageTilesTest("50_100", 100, 100);
449 RunManageTilesTest("50_500", 100, 500);
450 RunManageTilesTest("50_1000", 100, 1000);
453 TEST_F(TileManagerPerfTest, RasterTileQueueConstruct) {
454 RunRasterQueueConstructTest("2", 2);
455 RunRasterQueueConstructTest("10", 10);
456 RunRasterQueueConstructTest("50", 50);
459 TEST_F(TileManagerPerfTest, RasterTileQueueConstructAndIterate) {
460 RunRasterQueueConstructAndIterateTest("2_16", 2, 16);
461 RunRasterQueueConstructAndIterateTest("2_32", 2, 32);
462 RunRasterQueueConstructAndIterateTest("2_64", 2, 64);
463 RunRasterQueueConstructAndIterateTest("2_128", 2, 128);
464 RunRasterQueueConstructAndIterateTest("10_16", 10, 16);
465 RunRasterQueueConstructAndIterateTest("10_32", 10, 32);
466 RunRasterQueueConstructAndIterateTest("10_64", 10, 64);
467 RunRasterQueueConstructAndIterateTest("10_128", 10, 128);
468 RunRasterQueueConstructAndIterateTest("50_16", 50, 16);
469 RunRasterQueueConstructAndIterateTest("50_32", 50, 32);
470 RunRasterQueueConstructAndIterateTest("50_64", 50, 64);
471 RunRasterQueueConstructAndIterateTest("50_128", 50, 128);
474 TEST_F(TileManagerPerfTest, EvictionTileQueueConstruct) {
475 RunEvictionQueueConstructTest("2", 2);
476 RunEvictionQueueConstructTest("10", 10);
477 RunEvictionQueueConstructTest("50", 50);
480 TEST_F(TileManagerPerfTest, EvictionTileQueueConstructAndIterate) {
481 RunEvictionQueueConstructAndIterateTest("2_16", 2, 16);
482 RunEvictionQueueConstructAndIterateTest("2_32", 2, 32);
483 RunEvictionQueueConstructAndIterateTest("2_64", 2, 64);
484 RunEvictionQueueConstructAndIterateTest("2_128", 2, 128);
485 RunEvictionQueueConstructAndIterateTest("10_16", 10, 16);
486 RunEvictionQueueConstructAndIterateTest("10_32", 10, 32);
487 RunEvictionQueueConstructAndIterateTest("10_64", 10, 64);
488 RunEvictionQueueConstructAndIterateTest("10_128", 10, 128);
489 RunEvictionQueueConstructAndIterateTest("50_16", 50, 16);
490 RunEvictionQueueConstructAndIterateTest("50_32", 50, 32);
491 RunEvictionQueueConstructAndIterateTest("50_64", 50, 64);
492 RunEvictionQueueConstructAndIterateTest("50_128", 50, 128);