| OLD | NEW |
|---|
| (Empty) |
| 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 <stddef.h> | |
| 6 #include <stdint.h> | |
| 7 | |
| 8 #include "base/macros.h" | |
| 9 #include "base/memory/ptr_util.h" | |
| 10 #include "base/test/test_simple_task_runner.h" | |
| 11 #include "base/time/time.h" | |
| 12 #include "cc/debug/lap_timer.h" | |
| 13 #include "cc/output/context_provider.h" | |
| 14 #include "cc/raster/bitmap_tile_task_worker_pool.h" | |
| 15 #include "cc/raster/gpu_rasterizer.h" | |
| 16 #include "cc/raster/gpu_tile_task_worker_pool.h" | |
| 17 #include "cc/raster/one_copy_tile_task_worker_pool.h" | |
| 18 #include "cc/raster/synchronous_task_graph_runner.h" | |
| 19 #include "cc/raster/tile_task_worker_pool.h" | |
| 20 #include "cc/raster/zero_copy_tile_task_worker_pool.h" | |
| 21 #include "cc/resources/resource_pool.h" | |
| 22 #include "cc/resources/resource_provider.h" | |
| 23 #include "cc/resources/scoped_resource.h" | |
| 24 #include "cc/test/fake_output_surface.h" | |
| 25 #include "cc/test/fake_output_surface_client.h" | |
| 26 #include "cc/test/fake_resource_provider.h" | |
| 27 #include "cc/test/test_context_support.h" | |
| 28 #include "cc/test/test_gpu_memory_buffer_manager.h" | |
| 29 #include "cc/test/test_shared_bitmap_manager.h" | |
| 30 #include "cc/test/test_web_graphics_context_3d.h" | |
| 31 #include "testing/gtest/include/gtest/gtest.h" | |
| 32 #include "testing/perf/perf_test.h" | |
| 33 #include "third_party/khronos/GLES2/gl2.h" | |
| 34 #include "third_party/skia/include/gpu/GrContext.h" | |
| 35 #include "third_party/skia/include/gpu/gl/GrGLInterface.h" | |
| 36 | |
| 37 namespace cc { | |
| 38 namespace { | |
| 39 | |
| 40 class PerfGLES2Interface : public gpu::gles2::GLES2InterfaceStub { | |
| 41 // Overridden from gpu::gles2::GLES2Interface: | |
| 42 GLuint CreateImageCHROMIUM(ClientBuffer buffer, | |
| 43 GLsizei width, | |
| 44 GLsizei height, | |
| 45 GLenum internalformat) override { | |
| 46 return 1u; | |
| 47 } | |
| 48 void GenBuffers(GLsizei n, GLuint* buffers) override { | |
| 49 for (GLsizei i = 0; i < n; ++i) | |
| 50 buffers[i] = 1u; | |
| 51 } | |
| 52 void GenTextures(GLsizei n, GLuint* textures) override { | |
| 53 for (GLsizei i = 0; i < n; ++i) | |
| 54 textures[i] = 1u; | |
| 55 } | |
| 56 void GetIntegerv(GLenum pname, GLint* params) override { | |
| 57 if (pname == GL_MAX_TEXTURE_SIZE) | |
| 58 *params = INT_MAX; | |
| 59 } | |
| 60 void GenQueriesEXT(GLsizei n, GLuint* queries) override { | |
| 61 for (GLsizei i = 0; i < n; ++i) | |
| 62 queries[i] = 1u; | |
| 63 } | |
| 64 void GetQueryObjectuivEXT(GLuint query, | |
| 65 GLenum pname, | |
| 66 GLuint* params) override { | |
| 67 if (pname == GL_QUERY_RESULT_AVAILABLE_EXT) | |
| 68 *params = 1; | |
| 69 } | |
| 70 }; | |
| 71 | |
| 72 class PerfContextProvider : public ContextProvider { | |
| 73 public: | |
| 74 PerfContextProvider() : context_gl_(new PerfGLES2Interface) {} | |
| 75 | |
| 76 bool BindToCurrentThread() override { return true; } | |
| 77 gpu::Capabilities ContextCapabilities() override { | |
| 78 gpu::Capabilities capabilities; | |
| 79 capabilities.image = true; | |
| 80 capabilities.sync_query = true; | |
| 81 return capabilities; | |
| 82 } | |
| 83 gpu::gles2::GLES2Interface* ContextGL() override { return context_gl_.get(); } | |
| 84 gpu::ContextSupport* ContextSupport() override { return &support_; } | |
| 85 class GrContext* GrContext() override { | |
| 86 if (gr_context_) | |
| 87 return gr_context_.get(); | |
| 88 | |
| 89 sk_sp<const GrGLInterface> null_interface(GrGLCreateNullInterface()); | |
| 90 gr_context_ = sk_sp<class GrContext>(GrContext::Create( | |
| 91 kOpenGL_GrBackend, | |
| 92 reinterpret_cast<GrBackendContext>(null_interface.get()))); | |
| 93 return gr_context_.get(); | |
| 94 } | |
| 95 void InvalidateGrContext(uint32_t state) override { | |
| 96 if (gr_context_) | |
| 97 gr_context_.get()->resetContext(state); | |
| 98 } | |
| 99 void SetupLock() override {} | |
| 100 base::Lock* GetLock() override { return &context_lock_; } | |
| 101 void DeleteCachedResources() override {} | |
| 102 void SetLostContextCallback(const LostContextCallback& cb) override {} | |
| 103 | |
| 104 private: | |
| 105 ~PerfContextProvider() override {} | |
| 106 | |
| 107 std::unique_ptr<PerfGLES2Interface> context_gl_; | |
| 108 sk_sp<class GrContext> gr_context_; | |
| 109 TestContextSupport support_; | |
| 110 base::Lock context_lock_; | |
| 111 }; | |
| 112 | |
| 113 enum TileTaskWorkerPoolType { | |
| 114 TILE_TASK_WORKER_POOL_TYPE_ZERO_COPY, | |
| 115 TILE_TASK_WORKER_POOL_TYPE_ONE_COPY, | |
| 116 TILE_TASK_WORKER_POOL_TYPE_GPU, | |
| 117 TILE_TASK_WORKER_POOL_TYPE_BITMAP | |
| 118 }; | |
| 119 | |
| 120 static const int kTimeLimitMillis = 2000; | |
| 121 static const int kWarmupRuns = 5; | |
| 122 static const int kTimeCheckInterval = 10; | |
| 123 | |
| 124 class PerfImageDecodeTaskImpl : public TileTask { | |
| 125 public: | |
| 126 PerfImageDecodeTaskImpl() : TileTask(true) {} | |
| 127 | |
| 128 // Overridden from Task: | |
| 129 void RunOnWorkerThread() override {} | |
| 130 | |
| 131 // Overridden from TileTask: | |
| 132 void ScheduleOnOriginThread(RasterBufferProvider* provider) override {} | |
| 133 void CompleteOnOriginThread(RasterBufferProvider* provider) override { | |
| 134 Reset(); | |
| 135 } | |
| 136 | |
| 137 void Reset() { | |
| 138 state().Reset(); | |
| 139 did_complete_ = false; | |
| 140 } | |
| 141 | |
| 142 protected: | |
| 143 ~PerfImageDecodeTaskImpl() override {} | |
| 144 | |
| 145 private: | |
| 146 DISALLOW_COPY_AND_ASSIGN(PerfImageDecodeTaskImpl); | |
| 147 }; | |
| 148 | |
| 149 class PerfRasterTaskImpl : public TileTask { | |
| 150 public: | |
| 151 PerfRasterTaskImpl(std::unique_ptr<ScopedResource> resource, | |
| 152 TileTask::Vector* dependencies) | |
| 153 : TileTask(true, dependencies), resource_(std::move(resource)) {} | |
| 154 | |
| 155 // Overridden from Task: | |
| 156 void RunOnWorkerThread() override {} | |
| 157 | |
| 158 // Overridden from TileTask: | |
| 159 void ScheduleOnOriginThread(RasterBufferProvider* provider) override { | |
| 160 // No tile ids are given to support partial updates. | |
| 161 raster_buffer_ = provider->AcquireBufferForRaster(resource_.get(), 0, 0); | |
| 162 } | |
| 163 void CompleteOnOriginThread(RasterBufferProvider* provider) override { | |
| 164 provider->ReleaseBufferForRaster(std::move(raster_buffer_)); | |
| 165 Reset(); | |
| 166 } | |
| 167 | |
| 168 void Reset() { | |
| 169 state().Reset(); | |
| 170 did_complete_ = false; | |
| 171 } | |
| 172 | |
| 173 protected: | |
| 174 ~PerfRasterTaskImpl() override {} | |
| 175 | |
| 176 private: | |
| 177 std::unique_ptr<ScopedResource> resource_; | |
| 178 std::unique_ptr<RasterBuffer> raster_buffer_; | |
| 179 | |
| 180 DISALLOW_COPY_AND_ASSIGN(PerfRasterTaskImpl); | |
| 181 }; | |
| 182 | |
| 183 class TileTaskWorkerPoolPerfTestBase { | |
| 184 public: | |
| 185 typedef std::vector<scoped_refptr<TileTask>> RasterTaskVector; | |
| 186 | |
| 187 enum NamedTaskSet { REQUIRED_FOR_ACTIVATION, REQUIRED_FOR_DRAW, ALL }; | |
| 188 | |
| 189 TileTaskWorkerPoolPerfTestBase() | |
| 190 : context_provider_(make_scoped_refptr(new PerfContextProvider)), | |
| 191 task_runner_(new base::TestSimpleTaskRunner), | |
| 192 task_graph_runner_(new SynchronousTaskGraphRunner), | |
| 193 timer_(kWarmupRuns, | |
| 194 base::TimeDelta::FromMilliseconds(kTimeLimitMillis), | |
| 195 kTimeCheckInterval) {} | |
| 196 | |
| 197 void CreateImageDecodeTasks(unsigned num_image_decode_tasks, | |
| 198 TileTask::Vector* image_decode_tasks) { | |
| 199 for (unsigned i = 0; i < num_image_decode_tasks; ++i) | |
| 200 image_decode_tasks->push_back(new PerfImageDecodeTaskImpl); | |
| 201 } | |
| 202 | |
| 203 void CreateRasterTasks(unsigned num_raster_tasks, | |
| 204 unsigned num_image_decode_tasks, | |
| 205 RasterTaskVector* raster_tasks) { | |
| 206 const gfx::Size size(1, 1); | |
| 207 | |
| 208 for (unsigned i = 0; i < num_raster_tasks; ++i) { | |
| 209 TileTask::Vector image_decode_tasks; | |
| 210 CreateImageDecodeTasks(num_image_decode_tasks, &image_decode_tasks); | |
| 211 std::unique_ptr<ScopedResource> resource( | |
| 212 ScopedResource::Create(resource_provider_.get())); | |
| 213 resource->Allocate(size, ResourceProvider::TEXTURE_HINT_IMMUTABLE, | |
| 214 RGBA_8888); | |
| 215 | |
| 216 raster_tasks->push_back( | |
| 217 new PerfRasterTaskImpl(std::move(resource), &image_decode_tasks)); | |
| 218 } | |
| 219 } | |
| 220 | |
| 221 void BuildTileTaskGraph(TaskGraph* graph, | |
| 222 const RasterTaskVector& raster_tasks) { | |
| 223 uint16_t priority = 0; | |
| 224 | |
| 225 for (auto& raster_task : raster_tasks) { | |
| 226 priority++; | |
| 227 | |
| 228 for (auto& decode_task : raster_task->dependencies()) { | |
| 229 graph->nodes.push_back( | |
| 230 TaskGraph::Node(decode_task.get(), 0u /* group */, priority, 0u)); | |
| 231 graph->edges.push_back( | |
| 232 TaskGraph::Edge(raster_task.get(), decode_task.get())); | |
| 233 } | |
| 234 | |
| 235 graph->nodes.push_back(TaskGraph::Node( | |
| 236 raster_task.get(), 0u /* group */, priority, | |
| 237 static_cast<uint32_t>(raster_task->dependencies().size()))); | |
| 238 } | |
| 239 } | |
| 240 | |
| 241 protected: | |
| 242 scoped_refptr<ContextProvider> context_provider_; | |
| 243 FakeOutputSurfaceClient output_surface_client_; | |
| 244 std::unique_ptr<FakeOutputSurface> output_surface_; | |
| 245 std::unique_ptr<ResourceProvider> resource_provider_; | |
| 246 scoped_refptr<base::TestSimpleTaskRunner> task_runner_; | |
| 247 std::unique_ptr<SynchronousTaskGraphRunner> task_graph_runner_; | |
| 248 LapTimer timer_; | |
| 249 }; | |
| 250 | |
| 251 class TileTaskWorkerPoolPerfTest | |
| 252 : public TileTaskWorkerPoolPerfTestBase, | |
| 253 public testing::TestWithParam<TileTaskWorkerPoolType> { | |
| 254 public: | |
| 255 // Overridden from testing::Test: | |
| 256 void SetUp() override { | |
| 257 switch (GetParam()) { | |
| 258 case TILE_TASK_WORKER_POOL_TYPE_ZERO_COPY: | |
| 259 Create3dOutputSurfaceAndResourceProvider(); | |
| 260 tile_task_worker_pool_ = ZeroCopyTileTaskWorkerPool::Create( | |
| 261 task_runner_.get(), task_graph_runner_.get(), | |
| 262 resource_provider_.get(), PlatformColor::BestTextureFormat()); | |
| 263 break; | |
| 264 case TILE_TASK_WORKER_POOL_TYPE_ONE_COPY: | |
| 265 Create3dOutputSurfaceAndResourceProvider(); | |
| 266 tile_task_worker_pool_ = OneCopyTileTaskWorkerPool::Create( | |
| 267 task_runner_.get(), task_graph_runner_.get(), | |
| 268 context_provider_.get(), resource_provider_.get(), | |
| 269 std::numeric_limits<int>::max(), false, | |
| 270 std::numeric_limits<int>::max(), | |
| 271 PlatformColor::BestTextureFormat()); | |
| 272 break; | |
| 273 case TILE_TASK_WORKER_POOL_TYPE_GPU: | |
| 274 Create3dOutputSurfaceAndResourceProvider(); | |
| 275 tile_task_worker_pool_ = GpuTileTaskWorkerPool::Create( | |
| 276 task_runner_.get(), task_graph_runner_.get(), | |
| 277 context_provider_.get(), resource_provider_.get(), false, 0); | |
| 278 break; | |
| 279 case TILE_TASK_WORKER_POOL_TYPE_BITMAP: | |
| 280 CreateSoftwareOutputSurfaceAndResourceProvider(); | |
| 281 tile_task_worker_pool_ = BitmapTileTaskWorkerPool::Create( | |
| 282 task_runner_.get(), task_graph_runner_.get(), | |
| 283 resource_provider_.get()); | |
| 284 break; | |
| 285 } | |
| 286 | |
| 287 DCHECK(tile_task_worker_pool_); | |
| 288 } | |
| 289 void TearDown() override { | |
| 290 tile_task_worker_pool_->Shutdown(); | |
| 291 tile_task_worker_pool_->CheckForCompletedTasks(); | |
| 292 } | |
| 293 | |
| 294 void RunMessageLoopUntilAllTasksHaveCompleted() { | |
| 295 task_graph_runner_->RunUntilIdle(); | |
| 296 task_runner_->RunUntilIdle(); | |
| 297 } | |
| 298 | |
| 299 void RunScheduleTasksTest(const std::string& test_name, | |
| 300 unsigned num_raster_tasks, | |
| 301 unsigned num_image_decode_tasks) { | |
| 302 RasterTaskVector raster_tasks; | |
| 303 CreateRasterTasks(num_raster_tasks, num_image_decode_tasks, &raster_tasks); | |
| 304 | |
| 305 // Avoid unnecessary heap allocations by reusing the same graph. | |
| 306 TaskGraph graph; | |
| 307 | |
| 308 timer_.Reset(); | |
| 309 do { | |
| 310 graph.Reset(); | |
| 311 BuildTileTaskGraph(&graph, raster_tasks); | |
| 312 tile_task_worker_pool_->ScheduleTasks(&graph); | |
| 313 tile_task_worker_pool_->CheckForCompletedTasks(); | |
| 314 timer_.NextLap(); | |
| 315 } while (!timer_.HasTimeLimitExpired()); | |
| 316 | |
| 317 TaskGraph empty; | |
| 318 tile_task_worker_pool_->ScheduleTasks(&empty); | |
| 319 RunMessageLoopUntilAllTasksHaveCompleted(); | |
| 320 | |
| 321 perf_test::PrintResult("schedule_tasks", TestModifierString(), test_name, | |
| 322 timer_.LapsPerSecond(), "runs/s", true); | |
| 323 } | |
| 324 | |
| 325 void RunScheduleAlternateTasksTest(const std::string& test_name, | |
| 326 unsigned num_raster_tasks, | |
| 327 unsigned num_image_decode_tasks) { | |
| 328 const size_t kNumVersions = 2; | |
| 329 RasterTaskVector raster_tasks[kNumVersions]; | |
| 330 for (size_t i = 0; i < kNumVersions; ++i) { | |
| 331 CreateRasterTasks(num_raster_tasks, num_image_decode_tasks, | |
| 332 &raster_tasks[i]); | |
| 333 } | |
| 334 | |
| 335 // Avoid unnecessary heap allocations by reusing the same graph. | |
| 336 TaskGraph graph; | |
| 337 | |
| 338 size_t count = 0; | |
| 339 timer_.Reset(); | |
| 340 do { | |
| 341 graph.Reset(); | |
| 342 BuildTileTaskGraph(&graph, raster_tasks[count % kNumVersions]); | |
| 343 tile_task_worker_pool_->ScheduleTasks(&graph); | |
| 344 tile_task_worker_pool_->CheckForCompletedTasks(); | |
| 345 ++count; | |
| 346 timer_.NextLap(); | |
| 347 } while (!timer_.HasTimeLimitExpired()); | |
| 348 | |
| 349 TaskGraph empty; | |
| 350 tile_task_worker_pool_->ScheduleTasks(&empty); | |
| 351 RunMessageLoopUntilAllTasksHaveCompleted(); | |
| 352 | |
| 353 perf_test::PrintResult("schedule_alternate_tasks", TestModifierString(), | |
| 354 test_name, timer_.LapsPerSecond(), "runs/s", true); | |
| 355 } | |
| 356 | |
| 357 void RunScheduleAndExecuteTasksTest(const std::string& test_name, | |
| 358 unsigned num_raster_tasks, | |
| 359 unsigned num_image_decode_tasks) { | |
| 360 RasterTaskVector raster_tasks; | |
| 361 CreateRasterTasks(num_raster_tasks, num_image_decode_tasks, &raster_tasks); | |
| 362 | |
| 363 // Avoid unnecessary heap allocations by reusing the same graph. | |
| 364 TaskGraph graph; | |
| 365 | |
| 366 timer_.Reset(); | |
| 367 do { | |
| 368 graph.Reset(); | |
| 369 BuildTileTaskGraph(&graph, raster_tasks); | |
| 370 tile_task_worker_pool_->ScheduleTasks(&graph); | |
| 371 RunMessageLoopUntilAllTasksHaveCompleted(); | |
| 372 timer_.NextLap(); | |
| 373 } while (!timer_.HasTimeLimitExpired()); | |
| 374 | |
| 375 TaskGraph empty; | |
| 376 tile_task_worker_pool_->ScheduleTasks(&empty); | |
| 377 RunMessageLoopUntilAllTasksHaveCompleted(); | |
| 378 | |
| 379 perf_test::PrintResult("schedule_and_execute_tasks", TestModifierString(), | |
| 380 test_name, timer_.LapsPerSecond(), "runs/s", true); | |
| 381 } | |
| 382 | |
| 383 private: | |
| 384 void Create3dOutputSurfaceAndResourceProvider() { | |
| 385 output_surface_ = FakeOutputSurface::Create3d(context_provider_); | |
| 386 CHECK(output_surface_->BindToClient(&output_surface_client_)); | |
| 387 resource_provider_ = FakeResourceProvider::Create( | |
| 388 output_surface_.get(), nullptr, &gpu_memory_buffer_manager_); | |
| 389 } | |
| 390 | |
| 391 void CreateSoftwareOutputSurfaceAndResourceProvider() { | |
| 392 output_surface_ = FakeOutputSurface::CreateSoftware( | |
| 393 base::WrapUnique(new SoftwareOutputDevice)); | |
| 394 CHECK(output_surface_->BindToClient(&output_surface_client_)); | |
| 395 resource_provider_ = FakeResourceProvider::Create( | |
| 396 output_surface_.get(), &shared_bitmap_manager_, nullptr); | |
| 397 } | |
| 398 | |
| 399 std::string TestModifierString() const { | |
| 400 switch (GetParam()) { | |
| 401 case TILE_TASK_WORKER_POOL_TYPE_ZERO_COPY: | |
| 402 return std::string("_zero_copy_tile_task_worker_pool"); | |
| 403 case TILE_TASK_WORKER_POOL_TYPE_ONE_COPY: | |
| 404 return std::string("_one_copy_tile_task_worker_pool"); | |
| 405 case TILE_TASK_WORKER_POOL_TYPE_GPU: | |
| 406 return std::string("_gpu_tile_task_worker_pool"); | |
| 407 case TILE_TASK_WORKER_POOL_TYPE_BITMAP: | |
| 408 return std::string("_bitmap_tile_task_worker_pool"); | |
| 409 } | |
| 410 NOTREACHED(); | |
| 411 return std::string(); | |
| 412 } | |
| 413 | |
| 414 std::unique_ptr<TileTaskWorkerPool> tile_task_worker_pool_; | |
| 415 TestGpuMemoryBufferManager gpu_memory_buffer_manager_; | |
| 416 TestSharedBitmapManager shared_bitmap_manager_; | |
| 417 }; | |
| 418 | |
| 419 TEST_P(TileTaskWorkerPoolPerfTest, ScheduleTasks) { | |
| 420 RunScheduleTasksTest("1_0", 1, 0); | |
| 421 RunScheduleTasksTest("32_0", 32, 0); | |
| 422 RunScheduleTasksTest("1_1", 1, 1); | |
| 423 RunScheduleTasksTest("32_1", 32, 1); | |
| 424 RunScheduleTasksTest("1_4", 1, 4); | |
| 425 RunScheduleTasksTest("32_4", 32, 4); | |
| 426 } | |
| 427 | |
| 428 TEST_P(TileTaskWorkerPoolPerfTest, ScheduleAlternateTasks) { | |
| 429 RunScheduleAlternateTasksTest("1_0", 1, 0); | |
| 430 RunScheduleAlternateTasksTest("32_0", 32, 0); | |
| 431 RunScheduleAlternateTasksTest("1_1", 1, 1); | |
| 432 RunScheduleAlternateTasksTest("32_1", 32, 1); | |
| 433 RunScheduleAlternateTasksTest("1_4", 1, 4); | |
| 434 RunScheduleAlternateTasksTest("32_4", 32, 4); | |
| 435 } | |
| 436 | |
| 437 TEST_P(TileTaskWorkerPoolPerfTest, ScheduleAndExecuteTasks) { | |
| 438 RunScheduleAndExecuteTasksTest("1_0", 1, 0); | |
| 439 RunScheduleAndExecuteTasksTest("32_0", 32, 0); | |
| 440 RunScheduleAndExecuteTasksTest("1_1", 1, 1); | |
| 441 RunScheduleAndExecuteTasksTest("32_1", 32, 1); | |
| 442 RunScheduleAndExecuteTasksTest("1_4", 1, 4); | |
| 443 RunScheduleAndExecuteTasksTest("32_4", 32, 4); | |
| 444 } | |
| 445 | |
| 446 INSTANTIATE_TEST_CASE_P(TileTaskWorkerPoolPerfTests, | |
| 447 TileTaskWorkerPoolPerfTest, | |
| 448 ::testing::Values(TILE_TASK_WORKER_POOL_TYPE_ZERO_COPY, | |
| 449 TILE_TASK_WORKER_POOL_TYPE_ONE_COPY, | |
| 450 TILE_TASK_WORKER_POOL_TYPE_GPU, | |
| 451 TILE_TASK_WORKER_POOL_TYPE_BITMAP)); | |
| 452 | |
| 453 class TileTaskWorkerPoolCommonPerfTest : public TileTaskWorkerPoolPerfTestBase, | |
| 454 public testing::Test { | |
| 455 public: | |
| 456 // Overridden from testing::Test: | |
| 457 void SetUp() override { | |
| 458 output_surface_ = FakeOutputSurface::Create3d(context_provider_); | |
| 459 CHECK(output_surface_->BindToClient(&output_surface_client_)); | |
| 460 resource_provider_ = | |
| 461 FakeResourceProvider::Create(output_surface_.get(), nullptr); | |
| 462 } | |
| 463 | |
| 464 void RunBuildTileTaskGraphTest(const std::string& test_name, | |
| 465 unsigned num_raster_tasks, | |
| 466 unsigned num_image_decode_tasks) { | |
| 467 RasterTaskVector raster_tasks; | |
| 468 CreateRasterTasks(num_raster_tasks, num_image_decode_tasks, &raster_tasks); | |
| 469 | |
| 470 // Avoid unnecessary heap allocations by reusing the same graph. | |
| 471 TaskGraph graph; | |
| 472 | |
| 473 timer_.Reset(); | |
| 474 do { | |
| 475 graph.Reset(); | |
| 476 BuildTileTaskGraph(&graph, raster_tasks); | |
| 477 timer_.NextLap(); | |
| 478 } while (!timer_.HasTimeLimitExpired()); | |
| 479 | |
| 480 perf_test::PrintResult("build_raster_task_graph", "", test_name, | |
| 481 timer_.LapsPerSecond(), "runs/s", true); | |
| 482 } | |
| 483 }; | |
| 484 | |
| 485 TEST_F(TileTaskWorkerPoolCommonPerfTest, BuildTileTaskGraph) { | |
| 486 RunBuildTileTaskGraphTest("1_0", 1, 0); | |
| 487 RunBuildTileTaskGraphTest("32_0", 32, 0); | |
| 488 RunBuildTileTaskGraphTest("1_1", 1, 1); | |
| 489 RunBuildTileTaskGraphTest("32_1", 32, 1); | |
| 490 RunBuildTileTaskGraphTest("1_4", 1, 4); | |
| 491 RunBuildTileTaskGraphTest("32_4", 32, 4); | |
| 492 } | |
| 493 | |
| 494 } // namespace | |
| 495 } // namespace cc | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1910213005:
cc: Refactor TileTaskWorkerPool. (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@task_states