gpu: Implement the new fence syncs in mojo command buffer.

components/mus/gles2/command_buffer_local.cc

 // Copyright 2015 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 "components/mus/gles2/command_buffer_local.h"
 
+#include "base/atomic_sequence_num.h"
 #include "base/bind.h"
 #include "base/memory/shared_memory.h"
 #include "components/mus/gles2/command_buffer_local_client.h"
 #include "components/mus/gles2/gpu_memory_tracker.h"
 #include "components/mus/gles2/mojo_gpu_memory_buffer.h"
 #include "gpu/command_buffer/service/command_buffer_service.h"
 #include "gpu/command_buffer/service/context_group.h"
 #include "gpu/command_buffer/service/gpu_scheduler.h"
 #include "gpu/command_buffer/service/image_factory.h"
 #include "gpu/command_buffer/service/image_manager.h"
 #include "gpu/command_buffer/service/memory_tracking.h"
 #include "gpu/command_buffer/service/shader_translator_cache.h"
 #include "gpu/command_buffer/service/transfer_buffer_manager.h"
 #include "gpu/command_buffer/service/valuebuffer_manager.h"
 #include "ui/gfx/buffer_format_util.h"
 #include "ui/gfx/vsync_provider.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_image_shared_memory.h"
 #include "ui/gl/gl_surface.h"
 
 namespace mus {
 
+namespace {
+
+base::StaticAtomicSequenceNumber g_next_command_buffer_id;
+
+}
+
 const unsigned int GL_READ_WRITE_CHROMIUM = 0x78F2;
 
 CommandBufferLocal::CommandBufferLocal(CommandBufferLocalClient* client,
                                        gfx::AcceleratedWidget widget,
                                        const scoped_refptr<GpuState>& gpu_state)
-    : widget_(widget),
+    : command_buffer_id_(g_next_command_buffer_id.GetNext()),
+      widget_(widget),
       gpu_state_(gpu_state),
       client_(client),
       next_fence_sync_release_(1),
       weak_factory_(this) {}
 
 CommandBufferLocal::~CommandBufferLocal() {
   command_buffer_.reset();
   if (decoder_.get()) {
     bool have_context = decoder_->GetGLContext()->MakeCurrent(surface_.get());
     decoder_->Destroy(have_context);
@@ skipping 38 matching lines @@
           nullptr, bind_generates_resource);
 
   command_buffer_.reset(
       new gpu::CommandBufferService(context_group->transfer_buffer_manager()));
   bool result = command_buffer_->Initialize();
   DCHECK(result);
 
   decoder_.reset(::gpu::gles2::GLES2Decoder::Create(context_group.get()));
   scheduler_.reset(new gpu::GpuScheduler(command_buffer_.get(), decoder_.get(),
                                          decoder_.get()));
+  sync_point_order_data_ = gpu::SyncPointOrderData::Create();
+  sync_point_client_ = gpu_state_->sync_point_manager()->CreateSyncPointClient(
+      sync_point_order_data_, GetNamespaceID(), GetCommandBufferID());
   decoder_->set_engine(scheduler_.get());
   decoder_->SetWaitSyncPointCallback(
       base::Bind(&CommandBufferLocal::OnWaitSyncPoint, base::Unretained(this)));
   decoder_->SetFenceSyncReleaseCallback(base::Bind(
       &CommandBufferLocal::OnFenceSyncRelease, base::Unretained(this)));
   decoder_->SetWaitFenceSyncCallback(
       base::Bind(&CommandBufferLocal::OnWaitFenceSync, base::Unretained(this)));
 
   gpu::gles2::DisallowedFeatures disallowed_features;
 
@@ skipping 104 matching lines @@
 void CommandBufferLocal::SetLock(base::Lock* lock) {
   NOTIMPLEMENTED();
 }
 
 bool CommandBufferLocal::IsGpuChannelLost() {
   // This is only possible for out-of-process command buffers.
   return false;
 }
 
 gpu::CommandBufferNamespace CommandBufferLocal::GetNamespaceID() const {
-  NOTIMPLEMENTED();
-  return gpu::CommandBufferNamespace::INVALID;
+  return gpu::CommandBufferNamespace::MOJO_LOCAL;
 }
 
 uint64_t CommandBufferLocal::GetCommandBufferID() const {
-  NOTIMPLEMENTED();
-  return 0;
+  return command_buffer_id_;
 }
 
 uint64_t CommandBufferLocal::GenerateFenceSyncRelease() {
   return next_fence_sync_release_++;
 }
 
 bool CommandBufferLocal::IsFenceSyncRelease(uint64_t release) {
   return release > 0 && release < next_fence_sync_release_;
 }
 
 bool CommandBufferLocal::IsFenceSyncFlushed(uint64_t release) {
   return IsFenceSyncRelease(release);
 }
 
 void CommandBufferLocal::SignalSyncToken(const gpu::SyncToken& sync_token,
                                          const base::Closure& callback) {
   // TODO(dyen)
   NOTIMPLEMENTED();
 }
 
 bool CommandBufferLocal::IsFenceSyncFlushReceived(uint64_t release) {
   return IsFenceSyncRelease(release);
 }
 
 bool CommandBufferLocal::CanWaitUnverifiedSyncToken(
     const gpu::SyncToken* sync_token) {
   // All sync tokens must be flushed before being waited on.

[David Yen, 2015/11/23 22:06:03]

This can probably just return true if mojo never needs to synchronize with any
other process. Otherwise you can return true if sync_token->GetNamespace() is a
MOJO namespace. Once we support out of process commands this function will have
to check if the sync token is coming from the same process or not.

[piman, 2015/11/23 22:22:52]

The only sync tokens that are valid to wait unverified are the
CommandBufferLocal ones. The CommandBufferDriver ones come from out-of-process
untrusted clients.

At the same time, though, sync tokens on CommandBufferLocal are conceptually
automatically verified as soon as they're Flush'ed. Indeed, the fence is already
released.

[David Yen, 2015/11/23 22:40:32]

They would be automatically verified in that if the caller used "GenSyncToken()"
it would always return immediately without doing anything, but a caller could
still use "GenUnverifiedSyncToken()" and still expect it to work. In that case,
it would be marked as "unverified".

This should probably be "return sync_token->GetNamespaceID() ==
GetNamespaceID()".

[piman, 2015/11/23 22:41:46]

Ah, right, that sg.

[David Yen, 2015/11/23 22:42:18]

Actually, even then it would depend on if there could be multiple command
buffers per process. If there is always only 1 command buffer per process then
this should just return false. There is no point for a command buffer to wait on
itself.

[Peng, 2015/11/24 15:29:49]

Done.

   return false;
 }
 
 void CommandBufferLocal::PumpCommands() {
   if (!decoder_->MakeCurrent()) {
     command_buffer_->SetContextLostReason(decoder_->GetContextLostReason());
     command_buffer_->SetParseError(::gpu::error::kLostContext);
     return;
   }
+  gpu::SyncPointManager* sync_point_manager = gpu_state_->sync_point_manager();
+  const uint32_t order_num = sync_point_order_data_
+      ->GenerateUnprocessedOrderNumber(sync_point_manager);
+  sync_point_order_data_->BeginProcessingOrderNumber(order_num);
   scheduler_->PutChanged();
+  sync_point_order_data_->FinishProcessingOrderNumber(order_num);
 }
 
 void CommandBufferLocal::OnUpdateVSyncParameters(
     const base::TimeTicks timebase,
     const base::TimeDelta interval) {
   if (client_)
     client_->UpdateVSyncParameters(timebase.ToInternalValue(),
                                    interval.ToInternalValue());
 }
 
 bool CommandBufferLocal::OnWaitSyncPoint(uint32_t sync_point) {
   if (!sync_point)
     return true;
 
-  bool context_changed = false;
-  while (!gpu_state_->sync_point_manager()->IsSyncPointRetired(sync_point)) {
+  if (gpu_state_->sync_point_manager()->IsSyncPointRetired(sync_point))
+    return true;
+
+  do {
     gpu_state_->command_buffer_task_runner()->RunOneTask();
-    context_changed = true;
-  }
+  } while (!gpu_state_->sync_point_manager()->IsSyncPointRetired(sync_point));
 
   // RunOneTask() changes the current GL context, so we have to recover it.
-  if (context_changed) {
-    if (!decoder_->MakeCurrent()) {
-      command_buffer_->SetContextLostReason(decoder_->GetContextLostReason());
-      command_buffer_->SetParseError(::gpu::error::kLostContext);
-    }
+  if (!decoder_->MakeCurrent()) {
+    command_buffer_->SetContextLostReason(decoder_->GetContextLostReason());
+    command_buffer_->SetParseError(::gpu::error::kLostContext);
   }
   return true;
 }
 
 void CommandBufferLocal::OnFenceSyncRelease(uint64_t release) {
-  // TODO(dyen): Implement once CommandBufferID has been figured out and
-  // we have a SyncPointClient. It would probably look like what is commented
-  // out below:
-  // if (!sync_point_client_->client_state()->IsFenceSyncReleased(release))
-  //   sync_point_client_->ReleaseFenceSync(release);
-  NOTIMPLEMENTED();
+  if (!sync_point_client_->client_state()->IsFenceSyncReleased(release))
+    sync_point_client_->ReleaseFenceSync(release);
 }
 
 bool CommandBufferLocal::OnWaitFenceSync(
     gpu::CommandBufferNamespace namespace_id,
     uint64_t command_buffer_id,
     uint64_t release) {
   gpu::SyncPointManager* sync_point_manager = gpu_state_->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))
     return true;
 
-  // TODO(dyen): Implement once CommandBufferID has been figured out and
-  // we have a SyncPointClient. It would probably look like what is commented
-  // out below:
-  // scheduler_->SetScheduled(false);
-  // sync_point_client_->Wait(
-  //     release_state.get(),
-  //     release,
-  //     base::Bind(&CommandBufferLocal::OnSyncPointRetired,
-  //                weak_factory_.GetWeakPtr()));
-  NOTIMPLEMENTED();
-  return scheduler_->scheduled();
+  do {
+    gpu_state_->command_buffer_task_runner()->RunOneTask();
+  } while (!release_state->IsFenceSyncReleased(release));
+
+  // RunOneTask() changes the current GL context, so we have to recover it.
+  if (!decoder_->MakeCurrent()) {
+    command_buffer_->SetContextLostReason(decoder_->GetContextLostReason());
+    command_buffer_->SetParseError(::gpu::error::kLostContext);
+  }
+  return true;
 }
 
 void CommandBufferLocal::OnParseError() {
   gpu::CommandBuffer::State state = command_buffer_->GetLastState();
   OnContextLost(state.context_lost_reason);
 }
 
 void CommandBufferLocal::OnContextLost(uint32_t reason) {
   if (client_)
     client_->DidLoseContext();
 }
 
 }  // namespace mus