// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
+#include "cc/debug/lap_timer.h"
#include "cc/resources/picture_layer_tiling.h"
+#include "cc/resources/resource_provider.h"
+#include "cc/resources/scoped_resource.h"
+#include "cc/test/fake_output_surface.h"
+#include "cc/test/fake_output_surface_client.h"
#include "cc/test/fake_picture_layer_tiling_client.h"
+#include "cc/test/test_context_provider.h"
+#include "cc/test/test_shared_bitmap_manager.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "testing/perf/perf_test.h"
class PictureLayerTilingPerfTest : public testing::Test {
public:
- PictureLayerTilingPerfTest() : num_runs_(0) {}
+ PictureLayerTilingPerfTest()
+ : timer_(kWarmupRuns,
+ base::TimeDelta::FromMilliseconds(kTimeLimitMillis),
+ kTimeCheckInterval),
+ context_provider_(TestContextProvider::Create()) {
+ output_surface_ = FakeOutputSurface::Create3d(context_provider_).Pass();
+ CHECK(output_surface_->BindToClient(&output_surface_client_));
+
+ shared_bitmap_manager_.reset(new TestSharedBitmapManager());
+ resource_provider_ = ResourceProvider::Create(output_surface_.get(),
+ shared_bitmap_manager_.get(),
+ NULL,
+ 0,
+ false,
+ 1,
+ false).Pass();
+ }
virtual void SetUp() OVERRIDE {
picture_layer_tiling_client_.SetTileSize(gfx::Size(256, 256));
picture_layer_tiling_client_.set_max_tiles_for_interest_area(250);
+ picture_layer_tiling_client_.set_tree(PENDING_TREE);
picture_layer_tiling_ = PictureLayerTiling::Create(
1, gfx::Size(256 * 50, 256 * 50), &picture_layer_tiling_client_);
picture_layer_tiling_->CreateAllTilesForTesting();
picture_layer_tiling_.reset(NULL);
}
- void EndTest() {
- elapsed_ = base::TimeTicks::HighResNow() - start_time_;
- }
-
- bool DidRun() {
- ++num_runs_;
- if (num_runs_ == kWarmupRuns)
- start_time_ = base::TimeTicks::HighResNow();
-
- if (!start_time_.is_null() && (num_runs_ % kTimeCheckInterval) == 0) {
- base::TimeDelta elapsed = base::TimeTicks::HighResNow() - start_time_;
- if (elapsed >= base::TimeDelta::FromMilliseconds(kTimeLimitMillis)) {
- elapsed_ = elapsed;
- return false;
- }
- }
- return true;
- }
-
void RunInvalidateTest(const std::string& test_name, const Region& region) {
- start_time_ = base::TimeTicks();
- num_runs_ = 0;
+ timer_.Reset();
do {
- picture_layer_tiling_->Invalidate(region);
- } while (DidRun());
+ picture_layer_tiling_->UpdateTilesToCurrentPile(
+ region, picture_layer_tiling_->tiling_size());
+ timer_.NextLap();
+ } while (!timer_.HasTimeLimitExpired());
- perf_test::PrintResult("invalidation", "", test_name,
- num_runs_ / elapsed_.InSecondsF(), "runs/s", true);
+ perf_test::PrintResult(
+ "invalidation", "", test_name, timer_.LapsPerSecond(), "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);
+
+ timer_.Reset();
do {
picture_layer_tiling_->UpdateTilePriorities(
- ACTIVE_TREE, viewport_rect, 1.f, num_runs_ + 1);
- } while (DidRun());
+ PENDING_TREE, viewport_rect, 1.f, timer_.NumLaps() + 1, Occlusion());
+ timer_.NextLap();
+ } while (!timer_.HasTimeLimitExpired());
perf_test::PrintResult("update_tile_priorities_stationary",
"",
test_name,
- num_runs_ / elapsed_.InSecondsF(),
+ timer_.LapsPerSecond(),
"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 offsetIndex = 0;
int offsetCount = 0;
const int maxOffsetCount = 1000;
+
+ timer_.Reset();
do {
picture_layer_tiling_->UpdateTilePriorities(
- ACTIVE_TREE, viewport_rect, 1.f, num_runs_ + 1);
+ PENDING_TREE, viewport_rect, 1.f, timer_.NumLaps() + 1, Occlusion());
viewport_rect = gfx::Rect(viewport_rect.x() + xoffsets[offsetIndex],
viewport_rect.y() + yoffsets[offsetIndex],
offsetCount = 0;
offsetIndex = (offsetIndex + 1) % 4;
}
- } while (DidRun());
+ timer_.NextLap();
+ } while (!timer_.HasTimeLimitExpired());
perf_test::PrintResult("update_tile_priorities_scrolling",
"",
test_name,
- num_runs_ / elapsed_.InSecondsF(),
+ timer_.LapsPerSecond(),
+ "runs/s",
+ true);
+ }
+
+ void RunRasterIteratorConstructTest(const std::string& test_name,
+ const gfx::Rect& viewport) {
+ gfx::Size bounds(viewport.size());
+ picture_layer_tiling_ =
+ PictureLayerTiling::Create(1, bounds, &picture_layer_tiling_client_);
+ picture_layer_tiling_client_.set_tree(ACTIVE_TREE);
+ picture_layer_tiling_->UpdateTilePriorities(
+ ACTIVE_TREE, viewport, 1.0f, 1.0, Occlusion());
+
+ timer_.Reset();
+ do {
+ PictureLayerTiling::TilingRasterTileIterator it(
+ picture_layer_tiling_.get(), ACTIVE_TREE);
+ timer_.NextLap();
+ } while (!timer_.HasTimeLimitExpired());
+
+ perf_test::PrintResult("tiling_raster_tile_iterator_construct",
+ "",
+ test_name,
+ timer_.LapsPerSecond(),
+ "runs/s",
+ true);
+ }
+
+ void RunRasterIteratorConstructAndIterateTest(const std::string& test_name,
+ int num_tiles,
+ const gfx::Rect& viewport) {
+ gfx::Size bounds(10000, 10000);
+ picture_layer_tiling_ =
+ PictureLayerTiling::Create(1, bounds, &picture_layer_tiling_client_);
+ picture_layer_tiling_client_.set_tree(ACTIVE_TREE);
+ picture_layer_tiling_->UpdateTilePriorities(
+ ACTIVE_TREE, viewport, 1.0f, 1.0, Occlusion());
+
+ timer_.Reset();
+ do {
+ int count = num_tiles;
+ PictureLayerTiling::TilingRasterTileIterator it(
+ picture_layer_tiling_.get(), ACTIVE_TREE);
+ while (count--) {
+ ASSERT_TRUE(it) << "count: " << count;
+ ASSERT_TRUE(*it != NULL) << "count: " << count;
+ ++it;
+ }
+ timer_.NextLap();
+ } while (!timer_.HasTimeLimitExpired());
+
+ perf_test::PrintResult("tiling_raster_tile_iterator_construct_and_iterate",
+ "",
+ test_name,
+ timer_.LapsPerSecond(),
+ "runs/s",
+ true);
+ }
+
+ void RunEvictionIteratorConstructTest(const std::string& test_name,
+ const gfx::Rect& viewport) {
+ gfx::Size bounds(viewport.size());
+ picture_layer_tiling_ =
+ PictureLayerTiling::Create(1, bounds, &picture_layer_tiling_client_);
+ picture_layer_tiling_client_.set_tree(ACTIVE_TREE);
+ picture_layer_tiling_->UpdateTilePriorities(
+ ACTIVE_TREE, viewport, 1.0f, 1.0, Occlusion());
+
+ timer_.Reset();
+ TreePriority priorities[] = {SAME_PRIORITY_FOR_BOTH_TREES,
+ SMOOTHNESS_TAKES_PRIORITY,
+ NEW_CONTENT_TAKES_PRIORITY};
+ int priority_count = 0;
+ do {
+ PictureLayerTiling::TilingEvictionTileIterator it(
+ picture_layer_tiling_.get(),
+ priorities[priority_count],
+ PictureLayerTiling::NOW);
+ priority_count = (priority_count + 1) % arraysize(priorities);
+ timer_.NextLap();
+ } while (!timer_.HasTimeLimitExpired());
+
+ perf_test::PrintResult("tiling_eviction_tile_iterator_construct",
+ "",
+ test_name,
+ timer_.LapsPerSecond(),
"runs/s",
true);
}
+ void RunEvictionIteratorConstructAndIterateTest(const std::string& test_name,
+ int num_tiles,
+ const gfx::Rect& viewport) {
+ gfx::Size bounds(10000, 10000);
+ picture_layer_tiling_ =
+ PictureLayerTiling::Create(1, bounds, &picture_layer_tiling_client_);
+ picture_layer_tiling_client_.set_tree(ACTIVE_TREE);
+ picture_layer_tiling_->UpdateTilePriorities(
+ ACTIVE_TREE, viewport, 1.0f, 1.0, Occlusion());
+
+ TreePriority priorities[] = {SAME_PRIORITY_FOR_BOTH_TREES,
+ SMOOTHNESS_TAKES_PRIORITY,
+ NEW_CONTENT_TAKES_PRIORITY};
+
+ // Ensure all tiles have resources.
+ std::vector<Tile*> all_tiles = picture_layer_tiling_->AllTilesForTesting();
+ for (std::vector<Tile*>::iterator tile_it = all_tiles.begin();
+ tile_it != all_tiles.end();
+ ++tile_it) {
+ Tile* tile = *tile_it;
+ ManagedTileState::TileVersion& tile_version =
+ tile->GetTileVersionForTesting(tile->GetRasterModeForTesting());
+ tile_version.SetResourceForTesting(
+ ScopedResource::Create(resource_provider_.get()).Pass());
+ }
+
+ int priority_count = 0;
+ timer_.Reset();
+ do {
+ int count = num_tiles;
+ PictureLayerTiling::TilingEvictionTileIterator it(
+ picture_layer_tiling_.get(),
+ priorities[priority_count],
+ PictureLayerTiling::EVENTUALLY);
+ while (count--) {
+ ASSERT_TRUE(it) << "count: " << count;
+ ASSERT_TRUE(*it != NULL) << "count: " << count;
+ ++it;
+ }
+ priority_count = (priority_count + 1) % arraysize(priorities);
+ timer_.NextLap();
+ } while (!timer_.HasTimeLimitExpired());
+
+ // Remove all resources from tiles to make sure the tile version destructor
+ // doesn't complain.
+ for (std::vector<Tile*>::iterator tile_it = all_tiles.begin();
+ tile_it != all_tiles.end();
+ ++tile_it) {
+ Tile* tile = *tile_it;
+ ManagedTileState::TileVersion& tile_version =
+ tile->GetTileVersionForTesting(tile->GetRasterModeForTesting());
+ tile_version.SetResourceForTesting(scoped_ptr<ScopedResource>());
+ }
+
+ perf_test::PrintResult(
+ "tiling_eviction_tile_iterator_construct_and_iterate",
+ "",
+ test_name,
+ timer_.LapsPerSecond(),
+ "runs/s",
+ true);
+ }
+
private:
FakePictureLayerTilingClient picture_layer_tiling_client_;
scoped_ptr<PictureLayerTiling> picture_layer_tiling_;
- base::TimeTicks start_time_;
- base::TimeDelta elapsed_;
- int num_runs_;
+ LapTimer timer_;
+
+ scoped_refptr<ContextProvider> context_provider_;
+ FakeOutputSurfaceClient output_surface_client_;
+ scoped_ptr<FakeOutputSurface> output_surface_;
+ scoped_ptr<SharedBitmapManager> shared_bitmap_manager_;
+ scoped_ptr<ResourceProvider> resource_provider_;
};
TEST_F(PictureLayerTilingPerfTest, Invalidate) {
RunUpdateTilePrioritiesScrollingTest("perspective", transform);
}
+TEST_F(PictureLayerTilingPerfTest, TilingRasterTileIteratorConstruct) {
+ RunRasterIteratorConstructTest("0_0_100x100", gfx::Rect(0, 0, 100, 100));
+ RunRasterIteratorConstructTest("50_0_100x100", gfx::Rect(50, 0, 100, 100));
+ RunRasterIteratorConstructTest("100_0_100x100", gfx::Rect(100, 0, 100, 100));
+ RunRasterIteratorConstructTest("150_0_100x100", gfx::Rect(150, 0, 100, 100));
+}
+
+TEST_F(PictureLayerTilingPerfTest,
+ TilingRasterTileIteratorConstructAndIterate) {
+ RunRasterIteratorConstructAndIterateTest(
+ "32_100x100", 32, gfx::Rect(0, 0, 100, 100));
+ RunRasterIteratorConstructAndIterateTest(
+ "32_500x500", 32, gfx::Rect(0, 0, 500, 500));
+ RunRasterIteratorConstructAndIterateTest(
+ "64_100x100", 64, gfx::Rect(0, 0, 100, 100));
+ RunRasterIteratorConstructAndIterateTest(
+ "64_500x500", 64, gfx::Rect(0, 0, 500, 500));
+}
+
+TEST_F(PictureLayerTilingPerfTest, TilingEvictionTileIteratorConstruct) {
+ RunEvictionIteratorConstructTest("0_0_100x100", gfx::Rect(0, 0, 100, 100));
+ RunEvictionIteratorConstructTest("50_0_100x100", gfx::Rect(50, 0, 100, 100));
+ RunEvictionIteratorConstructTest("100_0_100x100",
+ gfx::Rect(100, 0, 100, 100));
+ RunEvictionIteratorConstructTest("150_0_100x100",
+ gfx::Rect(150, 0, 100, 100));
+}
+
+TEST_F(PictureLayerTilingPerfTest,
+ TilingEvictionTileIteratorConstructAndIterate) {
+ RunEvictionIteratorConstructAndIterateTest(
+ "32_100x100", 32, gfx::Rect(0, 0, 100, 100));
+ RunEvictionIteratorConstructAndIterateTest(
+ "32_500x500", 32, gfx::Rect(0, 0, 500, 500));
+ RunEvictionIteratorConstructAndIterateTest(
+ "64_100x100", 64, gfx::Rect(0, 0, 100, 100));
+ RunEvictionIteratorConstructAndIterateTest(
+ "64_500x500", 64, gfx::Rect(0, 0, 500, 500));
+}
+
} // namespace
} // namespace cc
projects / platform / framework / web / crosswalk.git / blobdiff