Implemented new fence syncs which replaces the old sync points.

gpu/command_buffer/tests/gl_manager.cc

 // Copyright (c) 2012 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 "gpu/command_buffer/tests/gl_manager.h"
 
 #include <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>
 #include <GLES2/gl2extchromium.h>
 
@@ skipping 10 matching lines @@
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
 #include "gpu/command_buffer/common/value_state.h"
 #include "gpu/command_buffer/service/command_buffer_service.h"
 #include "gpu/command_buffer/service/context_group.h"
 #include "gpu/command_buffer/service/gl_context_virtual.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 #include "gpu/command_buffer/service/gpu_scheduler.h"
 #include "gpu/command_buffer/service/image_manager.h"
 #include "gpu/command_buffer/service/mailbox_manager_impl.h"
 #include "gpu/command_buffer/service/memory_tracking.h"
+#include "gpu/command_buffer/service/sync_point_manager.h"
 #include "gpu/command_buffer/service/transfer_buffer_manager.h"
 #include "gpu/command_buffer/service/valuebuffer_manager.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/buffer_format_util.h"
 #include "ui/gfx/gpu_memory_buffer.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_image_ref_counted_memory.h"
 #include "ui/gl/gl_share_group.h"
 #include "ui/gl/gl_surface.h"
 
 namespace gpu {
 namespace {
 
+uint64_t g_next_command_buffer_id = 0;
+
 class GpuMemoryBufferImpl : public gfx::GpuMemoryBuffer {
  public:
   GpuMemoryBufferImpl(base::RefCountedBytes* bytes,
                       const gfx::Size& size,
                       gfx::BufferFormat format)
       : bytes_(bytes), size_(size), format_(format), mapped_(false) {}
 
   static GpuMemoryBufferImpl* FromClientBuffer(ClientBuffer buffer) {
     return reinterpret_cast<GpuMemoryBufferImpl*>(buffer);
   }
@@ skipping 42 matching lines @@
 
 }  // namespace
 
 int GLManager::use_count_;
 scoped_refptr<gfx::GLShareGroup>* GLManager::base_share_group_;
 scoped_refptr<gfx::GLSurface>* GLManager::base_surface_;
 scoped_refptr<gfx::GLContext>* GLManager::base_context_;
 
 GLManager::Options::Options()
     : size(4, 4),
+      sync_point_manager(NULL),
       share_group_manager(NULL),
       share_mailbox_manager(NULL),
       virtual_manager(NULL),
       bind_generates_resource(false),
       lose_context_when_out_of_memory(false),
       context_lost_allowed(false),
       context_type(gles2::CONTEXT_TYPE_OPENGLES2) {}
 
-GLManager::GLManager() : context_lost_allowed_(false) {
+GLManager::GLManager()
+    : sync_point_manager_(nullptr),
+      context_lost_allowed_(false),
+      command_buffer_id_(g_next_command_buffer_id++),
+      next_fence_sync_release_(1) {
   SetupBaseContext();
 }
 
 GLManager::~GLManager() {
   --use_count_;
   if (!use_count_) {
     if (base_share_group_) {
       delete base_context_;
       base_context_ = NULL;
     }
@@ skipping 14 matching lines @@
     gfx::BufferFormat format) {
   std::vector<uint8> data(gfx::BufferSizeForBufferFormat(size, format), 0);
   scoped_refptr<base::RefCountedBytes> bytes(new base::RefCountedBytes(data));
   return make_scoped_ptr<gfx::GpuMemoryBuffer>(
       new GpuMemoryBufferImpl(bytes.get(), size, format));
 }
 
 void GLManager::Initialize(const GLManager::Options& options) {
   InitializeWithCommandLine(options, nullptr);
 }
+
 void GLManager::InitializeWithCommandLine(const GLManager::Options& options,
                                           base::CommandLine* command_line) {
   const int32 kCommandBufferSize = 1024 * 1024;
   const size_t kStartTransferBufferSize = 4 * 1024 * 1024;
   const size_t kMinTransferBufferSize = 1 * 256 * 1024;
   const size_t kMaxTransferBufferSize = 16 * 1024 * 1024;
 
   context_lost_allowed_ = options.context_lost_allowed;
 
   gles2::MailboxManager* mailbox_manager = NULL;
@@ skipping 87 matching lines @@
   }
   ASSERT_TRUE(context_.get() != NULL) << "could not create GL context";
 
   ASSERT_TRUE(context_->MakeCurrent(surface_.get()));
 
   if (!decoder_->Initialize(surface_.get(), context_.get(), true, options.size,
                             ::gpu::gles2::DisallowedFeatures(), attribs)) {
     return;
   }
 
+  if (options.sync_point_manager) {
+    sync_point_manager_ = options.sync_point_manager;
+    sync_point_order_data_ = SyncPointOrderData::Create();
+    sync_point_client_ = sync_point_manager_->CreateSyncPointClient(
+        sync_point_order_data_, GetNamespaceID(), GetCommandBufferID());
+
+    decoder_->SetFenceSyncReleaseCallback(
+        base::Bind(&GLManager::OnFenceSyncRelease, base::Unretained(this)));
+    decoder_->SetWaitFenceSyncCallback(
+        base::Bind(&GLManager::OnWaitFenceSync, base::Unretained(this)));
+  } else {
+    sync_point_manager_ = nullptr;
+    sync_point_order_data_ = nullptr;
+    sync_point_client_ = nullptr;
+  }
+
   command_buffer_->SetPutOffsetChangeCallback(
       base::Bind(&GLManager::PumpCommands, base::Unretained(this)));
   command_buffer_->SetGetBufferChangeCallback(
       base::Bind(&GLManager::GetBufferChanged, base::Unretained(this)));
 
   // Create the GLES2 helper, which writes the command buffer protocol.
   gles2_helper_.reset(new gles2::GLES2CmdHelper(command_buffer_.get()));
   ASSERT_TRUE(gles2_helper_->Initialize(kCommandBufferSize));
 
   // Create a transfer buffer.
@@ skipping 31 matching lines @@
       gfx::GpuPreference gpu_preference(gfx::PreferDiscreteGpu);
       base_context_ = new scoped_refptr<gfx::GLContext>(
           gfx::GLContext::CreateGLContext(base_share_group_->get(),
                                           base_surface_->get(),
                                           gpu_preference));
     #endif
   }
   ++use_count_;
 }
 
+void GLManager::OnFenceSyncRelease(uint64_t release) {
+  DCHECK(sync_point_client_);
+  DCHECK(!sync_point_client_->client_state()->IsFenceSyncReleased(release));
+  sync_point_client_->ReleaseFenceSync(release);
+}
+
+bool GLManager::OnWaitFenceSync(gpu::CommandBufferNamespace namespace_id,
+                                uint64_t command_buffer_id,
+                                uint64_t release) {
+  DCHECK(sync_point_client_);
+  scoped_refptr<gpu::SyncPointClientState> release_state =
+      sync_point_manager_->GetSyncPointClientState(namespace_id,
+                                                   command_buffer_id);
+  if (!release_state)
+    return true;
+
+  // GLManager does not support being multithreaded at this point, so the fence
+  // sync must be released by the time wait is called.
+  DCHECK(release_state->IsFenceSyncReleased(release));
+  return true;
+}
+
 void GLManager::MakeCurrent() {
   ::gles2::SetGLContext(gles2_implementation_.get());
 }
 
 void GLManager::SetSurface(gfx::GLSurface* surface) {
   decoder_->SetSurface(surface);
 }
 
 void GLManager::Destroy() {
   if (gles2_implementation_.get()) {
     MakeCurrent();
     EXPECT_TRUE(glGetError() == GL_NONE);
     gles2_implementation_->Flush();
     gles2_implementation_.reset();
   }
   transfer_buffer_.reset();
   gles2_helper_.reset();
   command_buffer_.reset();
+  sync_point_manager_ = nullptr;
+  sync_point_client_ = nullptr;
+  if (sync_point_order_data_) {
+    sync_point_order_data_->Destroy();
+    sync_point_order_data_ = nullptr;
+  }
   if (decoder_.get()) {
     bool have_context = decoder_->GetGLContext() &&
                         decoder_->GetGLContext()->MakeCurrent(surface_.get());
     decoder_->Destroy(have_context);
     decoder_.reset();
   }
 }
 
 const gpu::gles2::FeatureInfo::Workarounds& GLManager::workarounds() const {
   return decoder_->GetContextGroup()->feature_info()->workarounds();
 }
 
 void GLManager::PumpCommands() {
   if (!decoder_->MakeCurrent()) {
     command_buffer_->SetContextLostReason(decoder_->GetContextLostReason());
     command_buffer_->SetParseError(::gpu::error::kLostContext);
     return;
   }
+  uint32_t order_num = 0;
+  if (sync_point_manager_) {
+    // If sync point manager is supported, assign order numbers to commands.
+    order_num = sync_point_order_data_->GenerateUnprocessedOrderNumber(
+        sync_point_manager_);
+    sync_point_order_data_->BeginProcessingOrderNumber(order_num);
+  }
+
   gpu_scheduler_->PutChanged();
   ::gpu::CommandBuffer::State state = command_buffer_->GetLastState();
   if (!context_lost_allowed_) {
     ASSERT_EQ(::gpu::error::kNoError, state.error);
   }
+
+  if (sync_point_manager_) {
+    // Finish processing order number here.
+    sync_point_order_data_->FinishProcessingOrderNumber(order_num);
+  }
 }
 
 bool GLManager::GetBufferChanged(int32 transfer_buffer_id) {
   return gpu_scheduler_->SetGetBuffer(transfer_buffer_id);
 }
 
 Capabilities GLManager::GetCapabilities() {
   return decoder_->GetCapabilities();
 }
 
@@ skipping 76 matching lines @@
 bool GLManager::IsGpuChannelLost() {
   NOTIMPLEMENTED();
   return false;
 }
 
 gpu::CommandBufferNamespace GLManager::GetNamespaceID() const {
   return gpu::CommandBufferNamespace::IN_PROCESS;
 }
 
 uint64_t GLManager::GetCommandBufferID() const {
-  return 0;
+  return command_buffer_id_;
+}
+
+uint64_t GLManager::GenerateFenceSyncRelease() {
+  return next_fence_sync_release_++;
+}
+
+bool GLManager::IsFenceSyncRelease(uint64_t release) {
+  return release > 0 && release < next_fence_sync_release_;
+}
+
+bool GLManager::IsFenceSyncFlushed(uint64_t release) {
+  return IsFenceSyncRelease(release);
 }
 
 }  // namespace gpu