cc: Add mailbox support to ResourceProvider write locks.

cc/raster/raster_buffer_provider_perftest.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/test/test_simple_task_runner.h"
 #include "base/time/time.h"
 #include "cc/debug/lap_timer.h"
 #include "cc/output/context_provider.h"
 #include "cc/raster/bitmap_raster_buffer_provider.h"
 #include "cc/raster/gpu_raster_buffer_provider.h"
-#include "cc/raster/gpu_rasterizer.h"
 #include "cc/raster/one_copy_raster_buffer_provider.h"
 #include "cc/raster/raster_buffer_provider.h"
 #include "cc/raster/synchronous_task_graph_runner.h"
 #include "cc/raster/zero_copy_raster_buffer_provider.h"
+#include "cc/resources/platform_color.h"
 #include "cc/resources/resource_pool.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_resource_provider.h"
 #include "cc/test/test_context_support.h"
 #include "cc/test/test_gpu_memory_buffer_manager.h"
 #include "cc/test/test_shared_bitmap_manager.h"
 #include "cc/test/test_web_graphics_context_3d.h"
 #include "cc/tiles/tile_task_manager.h"
+#include "gpu/command_buffer/common/sync_token.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/perf/perf_test.h"
 #include "third_party/khronos/GLES2/gl2.h"
 #include "third_party/skia/include/gpu/GrContext.h"
 #include "third_party/skia/include/gpu/gl/GrGLInterface.h"
 
 namespace cc {
 namespace {
 
 class PerfGLES2Interface : public gpu::gles2::GLES2InterfaceStub {
@@ skipping 19 matching lines @@
   void GenQueriesEXT(GLsizei n, GLuint* queries) override {
     for (GLsizei i = 0; i < n; ++i)
       queries[i] = 1u;
   }
   void GetQueryObjectuivEXT(GLuint query,
                             GLenum pname,
                             GLuint* params) override {
     if (pname == GL_QUERY_RESULT_AVAILABLE_EXT)
       *params = 1;
   }
+  void GenUnverifiedSyncTokenCHROMIUM(GLuint64 fence_sync, GLbyte* sync_token) {
+    // Copy the data over after setting the data to ensure alignment.
+    gpu::SyncToken sync_token_data(gpu::CommandBufferNamespace::GPU_IO, 0,
+                                   gpu::CommandBufferId(), fence_sync);
+    memcpy(sync_token, &sync_token_data, sizeof(sync_token_data));
+  }
 };
 
 class PerfContextProvider : public ContextProvider {
  public:
   PerfContextProvider() : context_gl_(new PerfGLES2Interface) {}
 
   bool BindToCurrentThread() override { return true; }
   gpu::Capabilities ContextCapabilities() override {
     gpu::Capabilities capabilities;
     capabilities.image = true;
@@ skipping 223 matching lines @@
   LapTimer timer_;
 };
 
 class RasterBufferProviderPerfTest
     : public RasterBufferProviderPerfTestBase,
       public PerfRasterBufferProviderHelper,
       public testing::TestWithParam<RasterBufferProviderType> {
  public:
   // Overridden from testing::Test:
   void SetUp() override {
-    std::unique_ptr<RasterBufferProvider> raster_buffer_provider;
     switch (GetParam()) {
       case RASTER_BUFFER_PROVIDER_TYPE_ZERO_COPY:
         Create3dOutputSurfaceAndResourceProvider();
-        raster_buffer_provider = ZeroCopyRasterBufferProvider::Create(
+        raster_buffer_provider_ = ZeroCopyRasterBufferProvider::Create(
             resource_provider_.get(), PlatformColor::BestTextureFormat());
         break;
       case RASTER_BUFFER_PROVIDER_TYPE_ONE_COPY:
         Create3dOutputSurfaceAndResourceProvider();
-        raster_buffer_provider = base::MakeUnique<OneCopyRasterBufferProvider>(
+        raster_buffer_provider_ = base::MakeUnique<OneCopyRasterBufferProvider>(
             task_runner_.get(), compositor_context_provider_.get(),
             worker_context_provider_.get(), resource_provider_.get(),
             std::numeric_limits<int>::max(), false,
-            std::numeric_limits<int>::max(),
-            PlatformColor::BestTextureFormat());
+            std::numeric_limits<int>::max(), PlatformColor::BestTextureFormat(),
+            false);
         break;
       case RASTER_BUFFER_PROVIDER_TYPE_GPU:
         Create3dOutputSurfaceAndResourceProvider();
-        raster_buffer_provider = base::MakeUnique<GpuRasterBufferProvider>(
+        raster_buffer_provider_ = base::MakeUnique<GpuRasterBufferProvider>(
             compositor_context_provider_.get(), worker_context_provider_.get(),
-            resource_provider_.get(), false, 0);
+            resource_provider_.get(), false, 0, false);
         break;
       case RASTER_BUFFER_PROVIDER_TYPE_BITMAP:
         CreateSoftwareOutputSurfaceAndResourceProvider();
-        raster_buffer_provider =
+        raster_buffer_provider_ =
             BitmapRasterBufferProvider::Create(resource_provider_.get());
         break;
     }
 
-    DCHECK(raster_buffer_provider);
+    DCHECK(raster_buffer_provider_);
 
-    tile_task_manager_ = TileTaskManagerImpl::Create(
-        std::move(raster_buffer_provider), task_graph_runner_.get());
+    tile_task_manager_ = TileTaskManagerImpl::Create(task_graph_runner_.get());
   }
   void TearDown() override {
     tile_task_manager_->Shutdown();
     tile_task_manager_->CheckForCompletedTasks();
+
+    raster_buffer_provider_->Shutdown();
   }
 
   // Overridden from PerfRasterBufferProviderHelper:
   std::unique_ptr<RasterBuffer> AcquireBufferForRaster(
       const Resource* resource,
       uint64_t resource_content_id,
       uint64_t previous_content_id) override {
-    return tile_task_manager_->GetRasterBufferProvider()
-        ->AcquireBufferForRaster(resource, resource_content_id,
-                                 previous_content_id);
+    return raster_buffer_provider_->AcquireBufferForRaster(
+        resource, resource_content_id, previous_content_id);
   }
   void ReleaseBufferForRaster(std::unique_ptr<RasterBuffer> buffer) override {
-    tile_task_manager_->GetRasterBufferProvider()->ReleaseBufferForRaster(
-        std::move(buffer));
+    raster_buffer_provider_->ReleaseBufferForRaster(std::move(buffer));
   }
 
   void RunMessageLoopUntilAllTasksHaveCompleted() {
     task_graph_runner_->RunUntilIdle();
     task_runner_->RunUntilIdle();
   }
 
   void RunScheduleTasksTest(const std::string& test_name,
                             unsigned num_raster_tasks,
                             unsigned num_image_decode_tasks) {
     TileTask::Vector image_decode_tasks;
     RasterTaskVector raster_tasks;
     CreateImageDecodeTasks(num_image_decode_tasks, &image_decode_tasks);
     CreateRasterTasks(this, num_raster_tasks, image_decode_tasks,
                       &raster_tasks);
 
     // Avoid unnecessary heap allocations by reusing the same graph.
     TaskGraph graph;
 
     timer_.Reset();
     do {
       graph.Reset();
       ResetRasterTasks(raster_tasks);
       BuildTileTaskGraph(&graph, raster_tasks);
+      raster_buffer_provider_->OrderingBarrier();
       tile_task_manager_->ScheduleTasks(&graph);
       tile_task_manager_->CheckForCompletedTasks();
       timer_.NextLap();
     } while (!timer_.HasTimeLimitExpired());
 
     TaskGraph empty;
+    raster_buffer_provider_->OrderingBarrier();
     tile_task_manager_->ScheduleTasks(&empty);
     RunMessageLoopUntilAllTasksHaveCompleted();
     tile_task_manager_->CheckForCompletedTasks();
 
     perf_test::PrintResult("schedule_tasks", TestModifierString(), test_name,
                            timer_.LapsPerSecond(), "runs/s", true);
   }
 
   void RunScheduleAlternateTasksTest(const std::string& test_name,
                                      unsigned num_raster_tasks,
@@ skipping 10 matching lines @@
     // Avoid unnecessary heap allocations by reusing the same graph.
     TaskGraph graph;
 
     size_t count = 0;
     timer_.Reset();
     do {
       graph.Reset();
       // Reset the tasks as for scheduling new state tasks are needed.
       ResetRasterTasks(raster_tasks[count % kNumVersions]);
       BuildTileTaskGraph(&graph, raster_tasks[count % kNumVersions]);
+      raster_buffer_provider_->OrderingBarrier();
       tile_task_manager_->ScheduleTasks(&graph);
       tile_task_manager_->CheckForCompletedTasks();
       ++count;
       timer_.NextLap();
     } while (!timer_.HasTimeLimitExpired());
 
     TaskGraph empty;
+    raster_buffer_provider_->OrderingBarrier();
     tile_task_manager_->ScheduleTasks(&empty);
     RunMessageLoopUntilAllTasksHaveCompleted();
     tile_task_manager_->CheckForCompletedTasks();
 
     perf_test::PrintResult("schedule_alternate_tasks", TestModifierString(),
                            test_name, timer_.LapsPerSecond(), "runs/s", true);
   }
 
   void RunScheduleAndExecuteTasksTest(const std::string& test_name,
                                       unsigned num_raster_tasks,
                                       unsigned num_image_decode_tasks) {
     TileTask::Vector image_decode_tasks;
     RasterTaskVector raster_tasks;
     CreateImageDecodeTasks(num_image_decode_tasks, &image_decode_tasks);
     CreateRasterTasks(this, num_raster_tasks, image_decode_tasks,
                       &raster_tasks);
 
     // Avoid unnecessary heap allocations by reusing the same graph.
     TaskGraph graph;
 
     timer_.Reset();
     do {
       graph.Reset();
       BuildTileTaskGraph(&graph, raster_tasks);
+      raster_buffer_provider_->OrderingBarrier();
       tile_task_manager_->ScheduleTasks(&graph);
       RunMessageLoopUntilAllTasksHaveCompleted();
       timer_.NextLap();
     } while (!timer_.HasTimeLimitExpired());
 
     TaskGraph empty;
+    raster_buffer_provider_->OrderingBarrier();
     tile_task_manager_->ScheduleTasks(&empty);
     RunMessageLoopUntilAllTasksHaveCompleted();
 
     perf_test::PrintResult("schedule_and_execute_tasks", TestModifierString(),
                            test_name, timer_.LapsPerSecond(), "runs/s", true);
   }
 
  private:
   void Create3dOutputSurfaceAndResourceProvider() {
     output_surface_ = FakeOutputSurface::Create3d(compositor_context_provider_,
@@ skipping 20 matching lines @@
       case RASTER_BUFFER_PROVIDER_TYPE_GPU:
         return std::string("_gpu_raster_buffer_provider");
       case RASTER_BUFFER_PROVIDER_TYPE_BITMAP:
         return std::string("_bitmap_raster_buffer_provider");
     }
     NOTREACHED();
     return std::string();
   }
 
   std::unique_ptr<TileTaskManager> tile_task_manager_;
+  std::unique_ptr<RasterBufferProvider> raster_buffer_provider_;
   TestGpuMemoryBufferManager gpu_memory_buffer_manager_;
   TestSharedBitmapManager shared_bitmap_manager_;
 };
 
 TEST_P(RasterBufferProviderPerfTest, ScheduleTasks) {
   RunScheduleTasksTest("1_0", 1, 0);
   RunScheduleTasksTest("32_0", 32, 0);
   RunScheduleTasksTest("1_1", 1, 1);
   RunScheduleTasksTest("32_1", 32, 1);
   RunScheduleTasksTest("1_4", 1, 4);
@@ skipping 68 matching lines @@
   RunBuildTileTaskGraphTest("1_0", 1, 0);
   RunBuildTileTaskGraphTest("32_0", 32, 0);
   RunBuildTileTaskGraphTest("1_1", 1, 1);
   RunBuildTileTaskGraphTest("32_1", 32, 1);
   RunBuildTileTaskGraphTest("1_4", 1, 4);
   RunBuildTileTaskGraphTest("32_4", 32, 4);
 }
 
 }  // namespace
 }  // namespace cc