Implemented new fence syncs which replaces the old sync points.

gpu/command_buffer/service/in_process_command_buffer.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 "gpu/command_buffer/service/in_process_command_buffer.h"
 
 #include <queue>
 #include <set>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/weak_ptr.h"
 #include "base/sequence_checker.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "gpu/command_buffer/client/gpu_memory_buffer_manager.h"
+#include "gpu/command_buffer/common/gles2_cmd_format.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/gpu_scheduler.h"
 #include "gpu/command_buffer/service/gpu_switches.h"
 #include "gpu/command_buffer/service/image_factory.h"
 #include "gpu/command_buffer/service/image_manager.h"
 #include "gpu/command_buffer/service/mailbox_manager.h"
 #include "gpu/command_buffer/service/memory_program_cache.h"
@@ skipping 143 matching lines @@
 }
 
 InProcessCommandBuffer::InProcessCommandBuffer(
     const scoped_refptr<Service>& service)
     : command_buffer_id_(g_next_command_buffer_id.GetNext()),
       context_lost_(false),
       delayed_work_pending_(false),
       image_factory_(nullptr),
       last_put_offset_(-1),
       gpu_memory_buffer_manager_(nullptr),
+      next_fence_sync_release_(1),
+      flushed_fence_sync_release_(0),
       flush_event_(false, false),
       service_(GetInitialService(service)),
+      fence_sync_wait_event_(false, false),
       gpu_thread_weak_ptr_factory_(this) {
   DCHECK(service_.get());
   next_image_id_.GetNext();
 }
 
 InProcessCommandBuffer::~InProcessCommandBuffer() {
   Destroy();
 }
 
 void InProcessCommandBuffer::OnResizeView(gfx::Size size, float scale_factor) {
@@ skipping 140 matching lines @@
     else
       surface_ = gfx::GLSurface::CreateViewGLSurface(params.window);
   }
 
   if (!surface_.get()) {
     LOG(ERROR) << "Could not create GLSurface.";
     DestroyOnGpuThread();
     return false;
   }
 
-  sync_point_client_state_ = SyncPointClientState::Create();
+  sync_point_order_data_ = SyncPointOrderData::Create();
   sync_point_client_ = service_->sync_point_manager()->CreateSyncPointClient(
-      sync_point_client_state_,
-      GetNamespaceID(), GetCommandBufferID());
+      sync_point_order_data_, GetNamespaceID(), GetCommandBufferID());
 
   if (service_->UseVirtualizedGLContexts() ||
       decoder_->GetContextGroup()
           ->feature_info()
           ->workarounds()
           .use_virtualized_gl_contexts) {
     context_ = gl_share_group_->GetSharedContext();
     if (!context_.get()) {
       context_ = gfx::GLContext::CreateGLContext(
           gl_share_group_.get(), surface_.get(), params.gpu_preference);
@@ skipping 46 matching lines @@
   }
   *params.capabilities = decoder_->GetCapabilities();
 
   if (!params.is_offscreen) {
     decoder_->SetResizeCallback(base::Bind(
         &InProcessCommandBuffer::OnResizeView, gpu_thread_weak_ptr_));
   }
   decoder_->SetWaitSyncPointCallback(
       base::Bind(&InProcessCommandBuffer::WaitSyncPointOnGpuThread,
                  base::Unretained(this)));
+  decoder_->SetFenceSyncReleaseCallback(
+      base::Bind(&InProcessCommandBuffer::FenceSyncReleaseOnGpuThread,
+                 base::Unretained(this)));
+  decoder_->SetWaitFenceSyncCallback(
+      base::Bind(&InProcessCommandBuffer::WaitFenceSyncOnGpuThread,
+                 base::Unretained(this)));
 
   image_factory_ = params.image_factory;
 
   return true;
 }
 
 void InProcessCommandBuffer::Destroy() {
   CheckSequencedThread();
 
   base::WaitableEvent completion(true, false);
@@ skipping 11 matching lines @@
   command_buffer_.reset();
   // Clean up GL resources if possible.
   bool have_context = context_.get() && context_->MakeCurrent(surface_.get());
   if (decoder_) {
     decoder_->Destroy(have_context);
     decoder_.reset();
   }
   context_ = NULL;
   surface_ = NULL;
   sync_point_client_ = NULL;
-  sync_point_client_state_ = NULL;
+  if (sync_point_order_data_) {
+    sync_point_order_data_->Destroy();
+    sync_point_order_data_ = nullptr;
+  }
   gl_share_group_ = NULL;
 #if defined(OS_ANDROID)
   stream_texture_manager_.reset();
 #endif
 
   return true;
 }
 
 void InProcessCommandBuffer::CheckSequencedThread() {
   DCHECK(!sequence_checker_ ||
@@ skipping 28 matching lines @@
   GetStateFast();
   return last_state_.token;
 }
 
 void InProcessCommandBuffer::FlushOnGpuThread(int32 put_offset,
                                               uint32_t order_num) {
   CheckSequencedThread();
   ScopedEvent handle_flush(&flush_event_);
   base::AutoLock lock(command_buffer_lock_);
 
-  sync_point_client_state_->BeginProcessingOrderNumber(order_num);
+  sync_point_order_data_->BeginProcessingOrderNumber(order_num);
   command_buffer_->Flush(put_offset);
   {
     // Update state before signaling the flush event.
     base::AutoLock lock(state_after_last_flush_lock_);
     state_after_last_flush_ = command_buffer_->GetLastState();
   }
   DCHECK((!error::IsError(state_after_last_flush_.error) && !context_lost_) ||
          (error::IsError(state_after_last_flush_.error) && context_lost_));
 
   // Currently the in process command buffer does not support being descheduled,
   // if it does we would need to back off on calling the finish processing
   // order number function until the message is rescheduled and finished
   // processing. This DCHECK is to enforce this.
   DCHECK(context_lost_ || put_offset == state_after_last_flush_.get_offset);
-  sync_point_client_state_->FinishProcessingOrderNumber(order_num);
+  sync_point_order_data_->FinishProcessingOrderNumber(order_num);
 
   // If we've processed all pending commands but still have pending queries,
   // pump idle work until the query is passed.
   if (put_offset == state_after_last_flush_.get_offset &&
       (gpu_scheduler_->HasMoreIdleWork() ||
        gpu_scheduler_->HasPendingQueries())) {
     ScheduleDelayedWorkOnGpuThread();
   }
 }
 
@@ skipping 23 matching lines @@
 void InProcessCommandBuffer::Flush(int32 put_offset) {
   CheckSequencedThread();
   if (last_state_.error != gpu::error::kNoError)
     return;
 
   if (last_put_offset_ == put_offset)
     return;
 
   SyncPointManager* sync_manager = service_->sync_point_manager();
   const uint32_t order_num =
-      sync_point_client_state_->GenerateUnprocessedOrderNumber(sync_manager);
+      sync_point_order_data_->GenerateUnprocessedOrderNumber(sync_manager);
   last_put_offset_ = put_offset;
   base::Closure task = base::Bind(&InProcessCommandBuffer::FlushOnGpuThread,
                                   gpu_thread_weak_ptr_,
                                   put_offset,
                                   order_num);
   QueueTask(task);
+
+  flushed_fence_sync_release_ = next_fence_sync_release_ - 1;
 }
 
 void InProcessCommandBuffer::OrderingBarrier(int32 put_offset) {
   Flush(put_offset);
 }
 
 void InProcessCommandBuffer::WaitForTokenInRange(int32 start, int32 end) {
   CheckSequencedThread();
   while (!InRange(start, end, GetLastToken()) &&
          last_state_.error == gpu::error::kNoError)
@@ skipping 218 matching lines @@
 
 void InProcessCommandBuffer::RetireSyncPointOnGpuThread(uint32 sync_point) {
   gles2::MailboxManager* mailbox_manager =
       decoder_->GetContextGroup()->mailbox_manager();
   if (mailbox_manager->UsesSync()) {
     bool make_current_success = false;
     {
       base::AutoLock lock(command_buffer_lock_);
       make_current_success = MakeCurrent();
     }
-    if (make_current_success)
-      mailbox_manager->PushTextureUpdates(sync_point);
+    if (make_current_success) {
+      // Old sync points are global and do not have a command buffer ID,
+      // We can simply use the GPUIO namespace with 0 for the command buffer ID
+      // (under normal circumstances 0 is  invalid so  will not be used) until
+      // the old sync points are replaced.
+      gles2::SyncToken sync_token = {gpu::CommandBufferNamespace::GPU_IO, 0,
+                                     sync_point};
+      mailbox_manager->PushTextureUpdates(sync_token);
+    }
   }
   service_->sync_point_manager()->RetireSyncPoint(sync_point);
 }
 
 void InProcessCommandBuffer::SignalSyncPoint(unsigned sync_point,
                                              const base::Closure& callback) {
   CheckSequencedThread();
   QueueTask(base::Bind(&InProcessCommandBuffer::SignalSyncPointOnGpuThread,
                        base::Unretained(this),
                        sync_point,
                        WrapCallback(callback)));
 }
 
 bool InProcessCommandBuffer::WaitSyncPointOnGpuThread(unsigned sync_point) {
   service_->sync_point_manager()->WaitSyncPoint(sync_point);
   gles2::MailboxManager* mailbox_manager =
       decoder_->GetContextGroup()->mailbox_manager();
-  mailbox_manager->PullTextureUpdates(sync_point);
+  // Old sync points are global and do not have a command buffer ID,
+  // We can simply use the GPUIO namespace with 0 for the command buffer ID
+  // (under normal circumstances 0 is  invalid so  will not be used) until
+  // the old sync points are replaced.
+  gles2::SyncToken sync_token = {gpu::CommandBufferNamespace::GPU_IO, 0,
+                                 sync_point};
+  mailbox_manager->PullTextureUpdates(sync_token);
   return true;
 }
 
+void InProcessCommandBuffer::FenceSyncReleaseOnGpuThread(uint64_t release) {
+  DCHECK(!sync_point_client_->client_state()->IsFenceSyncReleased(release));
+  gles2::MailboxManager* mailbox_manager =
+      decoder_->GetContextGroup()->mailbox_manager();
+  if (mailbox_manager->UsesSync()) {
+    bool make_current_success = false;
+    {
+      base::AutoLock lock(command_buffer_lock_);
+      make_current_success = MakeCurrent();
+    }
+    if (make_current_success) {
+      gles2::SyncToken sync_token = {GetNamespaceID(), GetCommandBufferID(),
+                                     release};
+      mailbox_manager->PushTextureUpdates(sync_token);
+    }
+  }
+
+  sync_point_client_->ReleaseFenceSync(release);
+}
+
+bool InProcessCommandBuffer::WaitFenceSyncOnGpuThread(
+    gpu::CommandBufferNamespace namespace_id,
+    uint64_t command_buffer_id,
+    uint64_t release) {
+  gpu::SyncPointManager* sync_point_manager = service_->sync_point_manager();
+  DCHECK(sync_point_manager);
+
+  scoped_refptr<gpu::SyncPointClientState> release_state =
+      sync_point_manager->GetSyncPointClientState(namespace_id,
+                                                  command_buffer_id);
+
+  if (!release_state)
+    return true;
+
+  if (!release_state->IsFenceSyncReleased(release)) {
+    // Use waitable event which is signalled when the release fence is released.
+    sync_point_client_->Wait(
+        release_state.get(), release,
+        base::Bind(&base::WaitableEvent::Signal,
+                   base::Unretained(&fence_sync_wait_event_)));
+    fence_sync_wait_event_.Wait();
+  }
+
+  gles2::MailboxManager* mailbox_manager =
+      decoder_->GetContextGroup()->mailbox_manager();
+  gles2::SyncToken sync_token = {namespace_id, command_buffer_id, release};
+  mailbox_manager->PullTextureUpdates(sync_token);
+  return true;
+}
+
 void InProcessCommandBuffer::SignalSyncPointOnGpuThread(
     unsigned sync_point,
     const base::Closure& callback) {
   service_->sync_point_manager()->AddSyncPointCallback(sync_point, callback);
 }
 
 void InProcessCommandBuffer::SignalQuery(unsigned query_id,
                                          const base::Closure& callback) {
   CheckSequencedThread();
   QueueTask(base::Bind(&InProcessCommandBuffer::SignalQueryOnGpuThread,
@@ skipping 40 matching lines @@
 }
 
 CommandBufferNamespace InProcessCommandBuffer::GetNamespaceID() const {
   return CommandBufferNamespace::IN_PROCESS;
 }
 
 uint64_t InProcessCommandBuffer::GetCommandBufferID() const {
   return command_buffer_id_;
 }
 
+uint64_t InProcessCommandBuffer::GenerateFenceSyncRelease() {
+  return next_fence_sync_release_++;
+}
+
+bool InProcessCommandBuffer::IsFenceSyncRelease(uint64_t release) {
+  return release != 0 && release < next_fence_sync_release_;
+}
+
+bool InProcessCommandBuffer::IsFenceSyncFlushed(uint64_t release) {
+  return release <= flushed_fence_sync_release_;
+}
+
 uint32 InProcessCommandBuffer::CreateStreamTextureOnGpuThread(
     uint32 client_texture_id) {
 #if defined(OS_ANDROID)
   return stream_texture_manager_->CreateStreamTexture(
       client_texture_id, decoder_->GetContextGroup()->texture_manager());
 #else
   return 0;
 #endif
 }
 
@@ skipping 94 matching lines @@
     framebuffer_completeness_cache_ =
         new gpu::gles2::FramebufferCompletenessCache;
   return framebuffer_completeness_cache_;
 }
 
 SyncPointManager* GpuInProcessThread::sync_point_manager() {
   return sync_point_manager_;
 }
 
 }  // namespace gpu