gpu: Thread-safe command buffer state lookup.

gpu/ipc/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/ipc/in_process_command_buffer.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <queue>
@@ skipping 525 matching lines @@
       sync_point_order_data_->PauseProcessingOrderNumber(task->order_number);
       return;
     }
     sync_point_order_data_->FinishProcessingOrderNumber(task->order_number);
     task_queue_.pop();
   }
 }
 
 CommandBuffer::State InProcessCommandBuffer::GetLastState() {
   CheckSequencedThread();
+  GetStateFast();
   return last_state_;

[piman, 2016/12/07 20:30:13]

nit: this whole function is fully equivalent to GetStateFast() - maybe combine?

 }
 
-int32_t InProcessCommandBuffer::GetLastToken() {
-  CheckSequencedThread();
-  GetStateFast();
-  return last_state_.token;
-}
-
 void InProcessCommandBuffer::FlushOnGpuThread(int32_t put_offset) {
   CheckSequencedThread();
   ScopedEvent handle_flush(&flush_event_);
   base::AutoLock lock(command_buffer_lock_);
 
   {
     command_buffer_->Flush(put_offset);
     {
       // Update state before signaling the flush event.
       base::AutoLock lock(state_after_last_flush_lock_);
@@ skipping 45 matching lines @@
                                   gpu_thread_weak_ptr_, put_offset);
   QueueTask(false, task);
 
   flushed_fence_sync_release_ = next_fence_sync_release_ - 1;
 }
 
 void InProcessCommandBuffer::OrderingBarrier(int32_t put_offset) {
   Flush(put_offset);
 }
 
-void InProcessCommandBuffer::WaitForTokenInRange(int32_t start, int32_t end) {
+CommandBuffer::State InProcessCommandBuffer::WaitForTokenInRange(int32_t start,
+                                                                 int32_t end) {
   CheckSequencedThread();
-  while (!InRange(start, end, GetLastToken()) &&
-         last_state_.error == gpu::error::kNoError) {
+  while (!InRange(start, end, GetLastState().token) &&
+         GetLastState().error == gpu::error::kNoError) {

[piman, 2016/12/07 20:30:13]

Should we avoid taking the lock twice (2 calls to GetLastState) per loop?
Something like:

State state = GetLastState();
while (!InRange(start, end, state.token) &&
       state.error == gpu::error::kNoError) {
  flush_event_.Wait();
  state = GetLastState();
}

[sunnyps, 2016/12/08 01:14:16]

Done.

     flush_event_.Wait();
   }
+  return last_state_;
 }
 
-void InProcessCommandBuffer::WaitForGetOffsetInRange(int32_t start,
-                                                     int32_t end) {
+CommandBuffer::State InProcessCommandBuffer::WaitForGetOffsetInRange(
+    int32_t start,
+    int32_t end) {
   CheckSequencedThread();
-
-  GetStateFast();
-  while (!InRange(start, end, last_state_.get_offset) &&
-         last_state_.error == gpu::error::kNoError) {
+  while (!InRange(start, end, GetLastState().get_offset) &&
+         GetLastState().error == gpu::error::kNoError) {

[piman, 2016/12/07 20:30:13]

Ditto

[sunnyps, 2016/12/08 01:14:16]

Done.

     flush_event_.Wait();
-    GetStateFast();
   }
+  return last_state_;
 }
 
 void InProcessCommandBuffer::SetGetBuffer(int32_t shm_id) {
   CheckSequencedThread();
   if (last_state_.error != gpu::error::kNoError)
     return;
 
   base::WaitableEvent completion(
       base::WaitableEvent::ResetPolicy::MANUAL,
       base::WaitableEvent::InitialState::NOT_SIGNALED);
@@ skipping 375 matching lines @@
 }
 
 bool InProcessCommandBuffer::IsFenceSyncFlushed(uint64_t release) {
   return release <= flushed_fence_sync_release_;
 }
 
 bool InProcessCommandBuffer::IsFenceSyncFlushReceived(uint64_t release) {
   return IsFenceSyncFlushed(release);
 }
 
+bool InProcessCommandBuffer::IsFenceSyncReleased(uint64_t release) {

[piman, 2016/12/07 20:30:13]

We will need this one to be thread-safe too for mus things. I think it should be
fairly straightforward (a lock around last_state_, similar to
CommandBufferProxyImpl). Maybe it's ok to leave as a TODO?

I guess that answers my question of whether or not there are non-thread-safe
implementations, but it means we need to be honest about it all the way to
ContextSupport - and maybe provide a way to introspect, or at least DCHECK that
capability.

[sunnyps, 2016/12/08 01:14:16]

Made this thread-safe although there's no real benefit to it right now because
last_state_ is only updated after a flush. We can make last_state_ SharedState
if we need to.

+  State state = GetStateFast();
+  return release <= state.release_count;
+}
+
 void InProcessCommandBuffer::SignalSyncToken(const SyncToken& sync_token,
                                              const base::Closure& callback) {
   CheckSequencedThread();
   QueueTask(
       true,
       base::Bind(&InProcessCommandBuffer::SignalSyncTokenOnGpuThread,
                  base::Unretained(this), sync_token, WrapCallback(callback)));
 }
 
 bool InProcessCommandBuffer::CanWaitUnverifiedSyncToken(
@@ skipping 82 matching lines @@
 void InProcessCommandBuffer::SetSwapBuffersCompletionCallback(
     const SwapBuffersCompletionCallback& callback) {
   swap_buffers_completion_callback_ = callback;
 }
 
 void InProcessCommandBuffer::SetUpdateVSyncParametersCallback(
     const UpdateVSyncParametersCallback& callback) {
   update_vsync_parameters_completion_callback_ = callback;
 }
 
-gpu::error::Error InProcessCommandBuffer::GetLastError() {
-  CheckSequencedThread();
-  return last_state_.error;
-}
-
 namespace {
 
 void PostCallback(
     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
     const base::Closure& callback) {
   // The task_runner.get() check is to support using InProcessCommandBuffer on
   // a thread without a message loop.
   if (task_runner.get() && !task_runner->BelongsToCurrentThread()) {
     task_runner->PostTask(FROM_HERE, callback);
   } else {
@@ skipping 23 matching lines @@
   return wrapped_callback;
 }
 
 InProcessCommandBuffer::GpuTask::GpuTask(const base::Closure& callback,
                                          uint32_t order_number)
     : callback(callback), order_number(order_number) {}
 
 InProcessCommandBuffer::GpuTask::~GpuTask() {}
 
 }  // namespace gpu