Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(961)

Side by Side Diff: cc/raster/raster_buffer_provider_perftest.cc

Issue 2106503002: Revert of cc: Add mailbox support to ResourceProvider write locks. (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@worker_context_sync_tokens_revert
Patch Set: Created 4 years, 5 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « cc/raster/raster_buffer_provider.h ('k') | cc/raster/raster_buffer_provider_unittest.cc » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
1 // Copyright 2013 The Chromium Authors. All rights reserved. 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 2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file. 3 // found in the LICENSE file.
4 4
5 #include <stddef.h> 5 #include <stddef.h>
6 #include <stdint.h> 6 #include <stdint.h>
7 7
8 #include "base/macros.h" 8 #include "base/macros.h"
9 #include "base/memory/ptr_util.h" 9 #include "base/memory/ptr_util.h"
10 #include "base/test/test_simple_task_runner.h" 10 #include "base/test/test_simple_task_runner.h"
11 #include "base/time/time.h" 11 #include "base/time/time.h"
12 #include "cc/debug/lap_timer.h" 12 #include "cc/debug/lap_timer.h"
13 #include "cc/output/context_provider.h" 13 #include "cc/output/context_provider.h"
14 #include "cc/raster/bitmap_raster_buffer_provider.h" 14 #include "cc/raster/bitmap_raster_buffer_provider.h"
15 #include "cc/raster/gpu_raster_buffer_provider.h" 15 #include "cc/raster/gpu_raster_buffer_provider.h"
16 #include "cc/raster/gpu_rasterizer.h"
16 #include "cc/raster/one_copy_raster_buffer_provider.h" 17 #include "cc/raster/one_copy_raster_buffer_provider.h"
17 #include "cc/raster/raster_buffer_provider.h" 18 #include "cc/raster/raster_buffer_provider.h"
18 #include "cc/raster/synchronous_task_graph_runner.h" 19 #include "cc/raster/synchronous_task_graph_runner.h"
19 #include "cc/raster/zero_copy_raster_buffer_provider.h" 20 #include "cc/raster/zero_copy_raster_buffer_provider.h"
20 #include "cc/resources/platform_color.h"
21 #include "cc/resources/resource_pool.h" 21 #include "cc/resources/resource_pool.h"
22 #include "cc/resources/resource_provider.h" 22 #include "cc/resources/resource_provider.h"
23 #include "cc/resources/scoped_resource.h" 23 #include "cc/resources/scoped_resource.h"
24 #include "cc/test/fake_output_surface.h" 24 #include "cc/test/fake_output_surface.h"
25 #include "cc/test/fake_output_surface_client.h" 25 #include "cc/test/fake_output_surface_client.h"
26 #include "cc/test/fake_resource_provider.h" 26 #include "cc/test/fake_resource_provider.h"
27 #include "cc/test/test_context_support.h" 27 #include "cc/test/test_context_support.h"
28 #include "cc/test/test_gpu_memory_buffer_manager.h" 28 #include "cc/test/test_gpu_memory_buffer_manager.h"
29 #include "cc/test/test_shared_bitmap_manager.h" 29 #include "cc/test/test_shared_bitmap_manager.h"
30 #include "cc/test/test_web_graphics_context_3d.h" 30 #include "cc/test/test_web_graphics_context_3d.h"
31 #include "cc/tiles/tile_task_manager.h" 31 #include "cc/tiles/tile_task_manager.h"
32 #include "gpu/command_buffer/common/sync_token.h"
33 #include "testing/gtest/include/gtest/gtest.h" 32 #include "testing/gtest/include/gtest/gtest.h"
34 #include "testing/perf/perf_test.h" 33 #include "testing/perf/perf_test.h"
35 #include "third_party/khronos/GLES2/gl2.h" 34 #include "third_party/khronos/GLES2/gl2.h"
36 #include "third_party/skia/include/gpu/GrContext.h" 35 #include "third_party/skia/include/gpu/GrContext.h"
37 #include "third_party/skia/include/gpu/gl/GrGLInterface.h" 36 #include "third_party/skia/include/gpu/gl/GrGLInterface.h"
38 37
39 namespace cc { 38 namespace cc {
40 namespace { 39 namespace {
41 40
42 class PerfGLES2Interface : public gpu::gles2::GLES2InterfaceStub { 41 class PerfGLES2Interface : public gpu::gles2::GLES2InterfaceStub {
(...skipping 19 matching lines...) Expand all
62 void GenQueriesEXT(GLsizei n, GLuint* queries) override { 61 void GenQueriesEXT(GLsizei n, GLuint* queries) override {
63 for (GLsizei i = 0; i < n; ++i) 62 for (GLsizei i = 0; i < n; ++i)
64 queries[i] = 1u; 63 queries[i] = 1u;
65 } 64 }
66 void GetQueryObjectuivEXT(GLuint query, 65 void GetQueryObjectuivEXT(GLuint query,
67 GLenum pname, 66 GLenum pname,
68 GLuint* params) override { 67 GLuint* params) override {
69 if (pname == GL_QUERY_RESULT_AVAILABLE_EXT) 68 if (pname == GL_QUERY_RESULT_AVAILABLE_EXT)
70 *params = 1; 69 *params = 1;
71 } 70 }
72 void GenUnverifiedSyncTokenCHROMIUM(GLuint64 fence_sync,
73 GLbyte* sync_token) override {
74 // Copy the data over after setting the data to ensure alignment.
75 gpu::SyncToken sync_token_data(gpu::CommandBufferNamespace::GPU_IO, 0,
76 gpu::CommandBufferId(), fence_sync);
77 memcpy(sync_token, &sync_token_data, sizeof(sync_token_data));
78 }
79 }; 71 };
80 72
81 class PerfContextProvider : public ContextProvider { 73 class PerfContextProvider : public ContextProvider {
82 public: 74 public:
83 PerfContextProvider() : context_gl_(new PerfGLES2Interface) {} 75 PerfContextProvider() : context_gl_(new PerfGLES2Interface) {}
84 76
85 bool BindToCurrentThread() override { return true; } 77 bool BindToCurrentThread() override { return true; }
86 gpu::Capabilities ContextCapabilities() override { 78 gpu::Capabilities ContextCapabilities() override {
87 gpu::Capabilities capabilities; 79 gpu::Capabilities capabilities;
88 capabilities.image = true; 80 capabilities.image = true;
(...skipping 223 matching lines...) Expand 10 before | Expand all | Expand 10 after
312 LapTimer timer_; 304 LapTimer timer_;
313 }; 305 };
314 306
315 class RasterBufferProviderPerfTest 307 class RasterBufferProviderPerfTest
316 : public RasterBufferProviderPerfTestBase, 308 : public RasterBufferProviderPerfTestBase,
317 public PerfRasterBufferProviderHelper, 309 public PerfRasterBufferProviderHelper,
318 public testing::TestWithParam<RasterBufferProviderType> { 310 public testing::TestWithParam<RasterBufferProviderType> {
319 public: 311 public:
320 // Overridden from testing::Test: 312 // Overridden from testing::Test:
321 void SetUp() override { 313 void SetUp() override {
314 std::unique_ptr<RasterBufferProvider> raster_buffer_provider;
322 switch (GetParam()) { 315 switch (GetParam()) {
323 case RASTER_BUFFER_PROVIDER_TYPE_ZERO_COPY: 316 case RASTER_BUFFER_PROVIDER_TYPE_ZERO_COPY:
324 Create3dOutputSurfaceAndResourceProvider(); 317 Create3dOutputSurfaceAndResourceProvider();
325 raster_buffer_provider_ = ZeroCopyRasterBufferProvider::Create( 318 raster_buffer_provider = ZeroCopyRasterBufferProvider::Create(
326 resource_provider_.get(), PlatformColor::BestTextureFormat()); 319 resource_provider_.get(), PlatformColor::BestTextureFormat());
327 break; 320 break;
328 case RASTER_BUFFER_PROVIDER_TYPE_ONE_COPY: 321 case RASTER_BUFFER_PROVIDER_TYPE_ONE_COPY:
329 Create3dOutputSurfaceAndResourceProvider(); 322 Create3dOutputSurfaceAndResourceProvider();
330 raster_buffer_provider_ = base::MakeUnique<OneCopyRasterBufferProvider>( 323 raster_buffer_provider = base::MakeUnique<OneCopyRasterBufferProvider>(
331 task_runner_.get(), compositor_context_provider_.get(), 324 task_runner_.get(), compositor_context_provider_.get(),
332 worker_context_provider_.get(), resource_provider_.get(), 325 worker_context_provider_.get(), resource_provider_.get(),
333 std::numeric_limits<int>::max(), false, 326 std::numeric_limits<int>::max(), false,
334 std::numeric_limits<int>::max(), PlatformColor::BestTextureFormat(), 327 std::numeric_limits<int>::max(),
335 false); 328 PlatformColor::BestTextureFormat());
336 break; 329 break;
337 case RASTER_BUFFER_PROVIDER_TYPE_GPU: 330 case RASTER_BUFFER_PROVIDER_TYPE_GPU:
338 Create3dOutputSurfaceAndResourceProvider(); 331 Create3dOutputSurfaceAndResourceProvider();
339 raster_buffer_provider_ = base::MakeUnique<GpuRasterBufferProvider>( 332 raster_buffer_provider = base::MakeUnique<GpuRasterBufferProvider>(
340 compositor_context_provider_.get(), worker_context_provider_.get(), 333 compositor_context_provider_.get(), worker_context_provider_.get(),
341 resource_provider_.get(), false, 0, false); 334 resource_provider_.get(), false, 0);
342 break; 335 break;
343 case RASTER_BUFFER_PROVIDER_TYPE_BITMAP: 336 case RASTER_BUFFER_PROVIDER_TYPE_BITMAP:
344 CreateSoftwareOutputSurfaceAndResourceProvider(); 337 CreateSoftwareOutputSurfaceAndResourceProvider();
345 raster_buffer_provider_ = 338 raster_buffer_provider =
346 BitmapRasterBufferProvider::Create(resource_provider_.get()); 339 BitmapRasterBufferProvider::Create(resource_provider_.get());
347 break; 340 break;
348 } 341 }
349 342
350 DCHECK(raster_buffer_provider_); 343 DCHECK(raster_buffer_provider);
351 344
352 tile_task_manager_ = TileTaskManagerImpl::Create(task_graph_runner_.get()); 345 tile_task_manager_ = TileTaskManagerImpl::Create(
346 std::move(raster_buffer_provider), task_graph_runner_.get());
353 } 347 }
354 void TearDown() override { 348 void TearDown() override {
355 tile_task_manager_->Shutdown(); 349 tile_task_manager_->Shutdown();
356 tile_task_manager_->CheckForCompletedTasks(); 350 tile_task_manager_->CheckForCompletedTasks();
357
358 raster_buffer_provider_->Shutdown();
359 } 351 }
360 352
361 // Overridden from PerfRasterBufferProviderHelper: 353 // Overridden from PerfRasterBufferProviderHelper:
362 std::unique_ptr<RasterBuffer> AcquireBufferForRaster( 354 std::unique_ptr<RasterBuffer> AcquireBufferForRaster(
363 const Resource* resource, 355 const Resource* resource,
364 uint64_t resource_content_id, 356 uint64_t resource_content_id,
365 uint64_t previous_content_id) override { 357 uint64_t previous_content_id) override {
366 return raster_buffer_provider_->AcquireBufferForRaster( 358 return tile_task_manager_->GetRasterBufferProvider()
367 resource, resource_content_id, previous_content_id); 359 ->AcquireBufferForRaster(resource, resource_content_id,
360 previous_content_id);
368 } 361 }
369 void ReleaseBufferForRaster(std::unique_ptr<RasterBuffer> buffer) override { 362 void ReleaseBufferForRaster(std::unique_ptr<RasterBuffer> buffer) override {
370 raster_buffer_provider_->ReleaseBufferForRaster(std::move(buffer)); 363 tile_task_manager_->GetRasterBufferProvider()->ReleaseBufferForRaster(
364 std::move(buffer));
371 } 365 }
372 366
373 void RunMessageLoopUntilAllTasksHaveCompleted() { 367 void RunMessageLoopUntilAllTasksHaveCompleted() {
374 task_graph_runner_->RunUntilIdle(); 368 task_graph_runner_->RunUntilIdle();
375 task_runner_->RunUntilIdle(); 369 task_runner_->RunUntilIdle();
376 } 370 }
377 371
378 void RunScheduleTasksTest(const std::string& test_name, 372 void RunScheduleTasksTest(const std::string& test_name,
379 unsigned num_raster_tasks, 373 unsigned num_raster_tasks,
380 unsigned num_image_decode_tasks) { 374 unsigned num_image_decode_tasks) {
381 TileTask::Vector image_decode_tasks; 375 TileTask::Vector image_decode_tasks;
382 RasterTaskVector raster_tasks; 376 RasterTaskVector raster_tasks;
383 CreateImageDecodeTasks(num_image_decode_tasks, &image_decode_tasks); 377 CreateImageDecodeTasks(num_image_decode_tasks, &image_decode_tasks);
384 CreateRasterTasks(this, num_raster_tasks, image_decode_tasks, 378 CreateRasterTasks(this, num_raster_tasks, image_decode_tasks,
385 &raster_tasks); 379 &raster_tasks);
386 380
387 // Avoid unnecessary heap allocations by reusing the same graph. 381 // Avoid unnecessary heap allocations by reusing the same graph.
388 TaskGraph graph; 382 TaskGraph graph;
389 383
390 timer_.Reset(); 384 timer_.Reset();
391 do { 385 do {
392 graph.Reset(); 386 graph.Reset();
393 ResetRasterTasks(raster_tasks); 387 ResetRasterTasks(raster_tasks);
394 BuildTileTaskGraph(&graph, raster_tasks); 388 BuildTileTaskGraph(&graph, raster_tasks);
395 raster_buffer_provider_->OrderingBarrier();
396 tile_task_manager_->ScheduleTasks(&graph); 389 tile_task_manager_->ScheduleTasks(&graph);
397 tile_task_manager_->CheckForCompletedTasks(); 390 tile_task_manager_->CheckForCompletedTasks();
398 timer_.NextLap(); 391 timer_.NextLap();
399 } while (!timer_.HasTimeLimitExpired()); 392 } while (!timer_.HasTimeLimitExpired());
400 393
401 TaskGraph empty; 394 TaskGraph empty;
402 raster_buffer_provider_->OrderingBarrier();
403 tile_task_manager_->ScheduleTasks(&empty); 395 tile_task_manager_->ScheduleTasks(&empty);
404 RunMessageLoopUntilAllTasksHaveCompleted(); 396 RunMessageLoopUntilAllTasksHaveCompleted();
405 tile_task_manager_->CheckForCompletedTasks(); 397 tile_task_manager_->CheckForCompletedTasks();
406 398
407 perf_test::PrintResult("schedule_tasks", TestModifierString(), test_name, 399 perf_test::PrintResult("schedule_tasks", TestModifierString(), test_name,
408 timer_.LapsPerSecond(), "runs/s", true); 400 timer_.LapsPerSecond(), "runs/s", true);
409 } 401 }
410 402
411 void RunScheduleAlternateTasksTest(const std::string& test_name, 403 void RunScheduleAlternateTasksTest(const std::string& test_name,
412 unsigned num_raster_tasks, 404 unsigned num_raster_tasks,
(...skipping 10 matching lines...) Expand all
423 // Avoid unnecessary heap allocations by reusing the same graph. 415 // Avoid unnecessary heap allocations by reusing the same graph.
424 TaskGraph graph; 416 TaskGraph graph;
425 417
426 size_t count = 0; 418 size_t count = 0;
427 timer_.Reset(); 419 timer_.Reset();
428 do { 420 do {
429 graph.Reset(); 421 graph.Reset();
430 // Reset the tasks as for scheduling new state tasks are needed. 422 // Reset the tasks as for scheduling new state tasks are needed.
431 ResetRasterTasks(raster_tasks[count % kNumVersions]); 423 ResetRasterTasks(raster_tasks[count % kNumVersions]);
432 BuildTileTaskGraph(&graph, raster_tasks[count % kNumVersions]); 424 BuildTileTaskGraph(&graph, raster_tasks[count % kNumVersions]);
433 raster_buffer_provider_->OrderingBarrier();
434 tile_task_manager_->ScheduleTasks(&graph); 425 tile_task_manager_->ScheduleTasks(&graph);
435 tile_task_manager_->CheckForCompletedTasks(); 426 tile_task_manager_->CheckForCompletedTasks();
436 ++count; 427 ++count;
437 timer_.NextLap(); 428 timer_.NextLap();
438 } while (!timer_.HasTimeLimitExpired()); 429 } while (!timer_.HasTimeLimitExpired());
439 430
440 TaskGraph empty; 431 TaskGraph empty;
441 raster_buffer_provider_->OrderingBarrier();
442 tile_task_manager_->ScheduleTasks(&empty); 432 tile_task_manager_->ScheduleTasks(&empty);
443 RunMessageLoopUntilAllTasksHaveCompleted(); 433 RunMessageLoopUntilAllTasksHaveCompleted();
444 tile_task_manager_->CheckForCompletedTasks(); 434 tile_task_manager_->CheckForCompletedTasks();
445 435
446 perf_test::PrintResult("schedule_alternate_tasks", TestModifierString(), 436 perf_test::PrintResult("schedule_alternate_tasks", TestModifierString(),
447 test_name, timer_.LapsPerSecond(), "runs/s", true); 437 test_name, timer_.LapsPerSecond(), "runs/s", true);
448 } 438 }
449 439
450 void RunScheduleAndExecuteTasksTest(const std::string& test_name, 440 void RunScheduleAndExecuteTasksTest(const std::string& test_name,
451 unsigned num_raster_tasks, 441 unsigned num_raster_tasks,
452 unsigned num_image_decode_tasks) { 442 unsigned num_image_decode_tasks) {
453 TileTask::Vector image_decode_tasks; 443 TileTask::Vector image_decode_tasks;
454 RasterTaskVector raster_tasks; 444 RasterTaskVector raster_tasks;
455 CreateImageDecodeTasks(num_image_decode_tasks, &image_decode_tasks); 445 CreateImageDecodeTasks(num_image_decode_tasks, &image_decode_tasks);
456 CreateRasterTasks(this, num_raster_tasks, image_decode_tasks, 446 CreateRasterTasks(this, num_raster_tasks, image_decode_tasks,
457 &raster_tasks); 447 &raster_tasks);
458 448
459 // Avoid unnecessary heap allocations by reusing the same graph. 449 // Avoid unnecessary heap allocations by reusing the same graph.
460 TaskGraph graph; 450 TaskGraph graph;
461 451
462 timer_.Reset(); 452 timer_.Reset();
463 do { 453 do {
464 graph.Reset(); 454 graph.Reset();
465 BuildTileTaskGraph(&graph, raster_tasks); 455 BuildTileTaskGraph(&graph, raster_tasks);
466 raster_buffer_provider_->OrderingBarrier();
467 tile_task_manager_->ScheduleTasks(&graph); 456 tile_task_manager_->ScheduleTasks(&graph);
468 RunMessageLoopUntilAllTasksHaveCompleted(); 457 RunMessageLoopUntilAllTasksHaveCompleted();
469 timer_.NextLap(); 458 timer_.NextLap();
470 } while (!timer_.HasTimeLimitExpired()); 459 } while (!timer_.HasTimeLimitExpired());
471 460
472 TaskGraph empty; 461 TaskGraph empty;
473 raster_buffer_provider_->OrderingBarrier();
474 tile_task_manager_->ScheduleTasks(&empty); 462 tile_task_manager_->ScheduleTasks(&empty);
475 RunMessageLoopUntilAllTasksHaveCompleted(); 463 RunMessageLoopUntilAllTasksHaveCompleted();
476 464
477 perf_test::PrintResult("schedule_and_execute_tasks", TestModifierString(), 465 perf_test::PrintResult("schedule_and_execute_tasks", TestModifierString(),
478 test_name, timer_.LapsPerSecond(), "runs/s", true); 466 test_name, timer_.LapsPerSecond(), "runs/s", true);
479 } 467 }
480 468
481 private: 469 private:
482 void Create3dOutputSurfaceAndResourceProvider() { 470 void Create3dOutputSurfaceAndResourceProvider() {
483 output_surface_ = FakeOutputSurface::Create3d(compositor_context_provider_, 471 output_surface_ = FakeOutputSurface::Create3d(compositor_context_provider_,
(...skipping 20 matching lines...) Expand all
504 case RASTER_BUFFER_PROVIDER_TYPE_GPU: 492 case RASTER_BUFFER_PROVIDER_TYPE_GPU:
505 return std::string("_gpu_raster_buffer_provider"); 493 return std::string("_gpu_raster_buffer_provider");
506 case RASTER_BUFFER_PROVIDER_TYPE_BITMAP: 494 case RASTER_BUFFER_PROVIDER_TYPE_BITMAP:
507 return std::string("_bitmap_raster_buffer_provider"); 495 return std::string("_bitmap_raster_buffer_provider");
508 } 496 }
509 NOTREACHED(); 497 NOTREACHED();
510 return std::string(); 498 return std::string();
511 } 499 }
512 500
513 std::unique_ptr<TileTaskManager> tile_task_manager_; 501 std::unique_ptr<TileTaskManager> tile_task_manager_;
514 std::unique_ptr<RasterBufferProvider> raster_buffer_provider_;
515 TestGpuMemoryBufferManager gpu_memory_buffer_manager_; 502 TestGpuMemoryBufferManager gpu_memory_buffer_manager_;
516 TestSharedBitmapManager shared_bitmap_manager_; 503 TestSharedBitmapManager shared_bitmap_manager_;
517 }; 504 };
518 505
519 TEST_P(RasterBufferProviderPerfTest, ScheduleTasks) { 506 TEST_P(RasterBufferProviderPerfTest, ScheduleTasks) {
520 RunScheduleTasksTest("1_0", 1, 0); 507 RunScheduleTasksTest("1_0", 1, 0);
521 RunScheduleTasksTest("32_0", 32, 0); 508 RunScheduleTasksTest("32_0", 32, 0);
522 RunScheduleTasksTest("1_1", 1, 1); 509 RunScheduleTasksTest("1_1", 1, 1);
523 RunScheduleTasksTest("32_1", 32, 1); 510 RunScheduleTasksTest("32_1", 32, 1);
524 RunScheduleTasksTest("1_4", 1, 4); 511 RunScheduleTasksTest("1_4", 1, 4);
(...skipping 68 matching lines...) Expand 10 before | Expand all | Expand 10 after
593 RunBuildTileTaskGraphTest("1_0", 1, 0); 580 RunBuildTileTaskGraphTest("1_0", 1, 0);
594 RunBuildTileTaskGraphTest("32_0", 32, 0); 581 RunBuildTileTaskGraphTest("32_0", 32, 0);
595 RunBuildTileTaskGraphTest("1_1", 1, 1); 582 RunBuildTileTaskGraphTest("1_1", 1, 1);
596 RunBuildTileTaskGraphTest("32_1", 32, 1); 583 RunBuildTileTaskGraphTest("32_1", 32, 1);
597 RunBuildTileTaskGraphTest("1_4", 1, 4); 584 RunBuildTileTaskGraphTest("1_4", 1, 4);
598 RunBuildTileTaskGraphTest("32_4", 32, 4); 585 RunBuildTileTaskGraphTest("32_4", 32, 4);
599 } 586 }
600 587
601 } // namespace 588 } // namespace
602 } // namespace cc 589 } // namespace cc
OLDNEW
« no previous file with comments | « cc/raster/raster_buffer_provider.h ('k') | cc/raster/raster_buffer_provider_unittest.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698