gpu: Thread-safe command buffer state lookup.

gpu/command_buffer/client/cmd_buffer_helper.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.
 
 // This file contains the implementation of the command buffer helper class.
 
 #include "gpu/command_buffer/client/cmd_buffer_helper.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "base/trace_event/memory_allocator_dump.h"
 #include "base/trace_event/memory_dump_manager.h"
 #include "base/trace_event/process_memory_dump.h"
 #include "base/trace_event/trace_event.h"
 #include "gpu/command_buffer/common/buffer.h"
 #include "gpu/command_buffer/common/command_buffer.h"
 #include "gpu/command_buffer/common/constants.h"
 
 namespace gpu {
 
 CommandBufferHelper::CommandBufferHelper(CommandBuffer* command_buffer)
     : command_buffer_(command_buffer),
       ring_buffer_id_(-1),
       ring_buffer_size_(0),
-      entries_(NULL),
+      entries_(nullptr),
       total_entry_count_(0),
       immediate_entry_count_(0),
       token_(0),
       put_(0),
       last_put_sent_(0),
+      cached_last_token_read_(0),
+      cached_get_offset_(0),
 #if defined(CMD_HELPER_PERIODIC_FLUSH_CHECK)
       commands_issued_(0),
 #endif
       usable_(true),
       context_lost_(false),
       flush_automatically_(true),
       flush_generation_(0) {
-  // In certain cases, ThreadTaskRunnerHandle isn't set (Android Webview).
-  // Don't register a dump provider in these cases.
-  // TODO(ericrk): Get this working in Android Webview. crbug.com/517156
-  if (base::ThreadTaskRunnerHandle::IsSet()) {
-    base::trace_event::MemoryDumpManager::GetInstance()->RegisterDumpProvider(
-        this, "gpu::CommandBufferHelper", base::ThreadTaskRunnerHandle::Get());
-  }
 }
 
 void CommandBufferHelper::SetAutomaticFlushes(bool enabled) {
   flush_automatically_ = enabled;
   CalcImmediateEntries(0);
 }
 
 bool CommandBufferHelper::IsContextLost() {
-  if (!context_lost_) {
-    context_lost_ = error::IsError(command_buffer()->GetLastError());
-  }
+  if (!context_lost_)
+    context_lost_ = error::IsError(command_buffer()->GetLastState().error);
   return context_lost_;
 }
 
 void CommandBufferHelper::CalcImmediateEntries(int waiting_count) {
   DCHECK_GE(waiting_count, 0);
 
   // Check if usable & allocated.
   if (!usable() || !HaveRingBuffer()) {
     immediate_entry_count_ = 0;
     return;
   }
 
   // Get maximum safe contiguous entries.
-  const int32_t curr_get = get_offset();
+  const int32_t curr_get = cached_get_offset_;
   if (curr_get > put_) {
     immediate_entry_count_ = curr_get - put_ - 1;
   } else {
     immediate_entry_count_ =
         total_entry_count_ - put_ - (curr_get == 0 ? 1 : 0);
   }
 
   // Limit entry count to force early flushing.
   if (flush_automatically_) {
     int32_t limit =
@@ skipping 24 matching lines @@
 
   if (HaveRingBuffer()) {
     return true;
   }
 
   int32_t id = -1;
   scoped_refptr<Buffer> buffer =
       command_buffer_->CreateTransferBuffer(ring_buffer_size_, &id);
   if (id < 0) {
     ClearUsable();
-    DCHECK(error::IsError(command_buffer()->GetLastError()));
+    DCHECK(context_lost_);
     return false;
   }
 
   ring_buffer_ = buffer;
   ring_buffer_id_ = id;
   command_buffer_->SetGetBuffer(id);
   entries_ = static_cast<CommandBufferEntry*>(ring_buffer_->memory());
   total_entry_count_ = ring_buffer_size_ / sizeof(CommandBufferEntry);
   // Call to SetGetBuffer(id) above resets get and put offsets to 0.
   // No need to query it through IPC.
   put_ = 0;
+  cached_get_offset_ = 0;
   CalcImmediateEntries(0);
   return true;
 }
 
 void CommandBufferHelper::FreeResources() {
   if (HaveRingBuffer()) {
     command_buffer_->DestroyTransferBuffer(ring_buffer_id_);
     ring_buffer_id_ = -1;
     CalcImmediateEntries(0);
     entries_ = nullptr;
     ring_buffer_ = nullptr;
   }
 }
 
 void CommandBufferHelper::FreeRingBuffer() {
-  CHECK((put_ == get_offset()) ||
-      error::IsError(command_buffer_->GetLastState().error));
+  CHECK((put_ == cached_get_offset_) ||
+        error::IsError(command_buffer_->GetLastState().error));
   FreeResources();
 }
 
 bool CommandBufferHelper::Initialize(int32_t ring_buffer_size) {
   ring_buffer_size_ = ring_buffer_size;
   return AllocateRingBuffer();
 }
 
 CommandBufferHelper::~CommandBufferHelper() {
-  base::trace_event::MemoryDumpManager::GetInstance()->UnregisterDumpProvider(
-      this);
   FreeResources();
 }
 
 bool CommandBufferHelper::WaitForGetOffsetInRange(int32_t start, int32_t end) {
   DCHECK(start >= 0 && start <= total_entry_count_);
   DCHECK(end >= 0 && end <= total_entry_count_);
   if (!usable()) {
     return false;
   }
-  command_buffer_->WaitForGetOffsetInRange(start, end);
-  return command_buffer_->GetLastError() == gpu::error::kNoError;
+  CommandBuffer::State last_state =
+      command_buffer_->WaitForGetOffsetInRange(start, end);
+  cached_last_token_read_ = last_state.token;
+  cached_get_offset_ = last_state.get_offset;
+  context_lost_ = gpu::error::IsError(last_state.error);
+  return !context_lost_;
 }
 
 void CommandBufferHelper::Flush() {
   // Wrap put_ before flush.
   if (put_ == total_entry_count_)
     put_ = 0;
 
   if (usable()) {
     last_flush_time_ = base::TimeTicks::Now();
     last_put_sent_ = put_;
@@ skipping 26 matching lines @@
 #endif
 
 // Calls Flush() and then waits until the buffer is empty. Break early if the
 // error is set.
 bool CommandBufferHelper::Finish() {
   TRACE_EVENT0("gpu", "CommandBufferHelper::Finish");
   if (!usable()) {
     return false;
   }
   // If there is no work just exit.
-  if (put_ == get_offset()) {
+  if (put_ == cached_get_offset_) {
     return true;
   }
   DCHECK(HaveRingBuffer() ||
          error::IsError(command_buffer_->GetLastState().error));
   Flush();
   if (!WaitForGetOffsetInRange(put_, put_))
     return false;
-  DCHECK_EQ(get_offset(), put_);
+  DCHECK_EQ(cached_get_offset_, put_);
 
   CalcImmediateEntries(0);
 
   return true;
 }
 
 // Inserts a new token into the command stream. It uses an increasing value
 // scheme so that we don't lose tokens (a token has passed if the current token
 // value is higher than that token). Calls Finish() if the token value wraps,
 // which will be rare.
 int32_t CommandBufferHelper::InsertToken() {
   AllocateRingBuffer();
   if (!usable()) {
     return token_;
   }
   DCHECK(HaveRingBuffer());
   // Increment token as 31-bit integer. Negative values are used to signal an
   // error.
   token_ = (token_ + 1) & 0x7FFFFFFF;
   cmd::SetToken* cmd = GetCmdSpace<cmd::SetToken>();
   if (cmd) {
     cmd->Init(token_);
     if (token_ == 0) {
       TRACE_EVENT0("gpu", "CommandBufferHelper::InsertToken(wrapped)");
-      // we wrapped
-      Finish();
-      DCHECK_EQ(token_, last_token_read());
+      bool finished = Finish();  // we wrapped
+      DCHECK(!finished || (cached_last_token_read_ == 0));
     }
   }
   return token_;
 }
 
+bool CommandBufferHelper::HasTokenPassed(int32_t token) {
+  // If token_ wrapped around we Finish'd.
+  if (token > token_)
+    return true;
+  // Don't update state if we don't have to.
+  if (token <= cached_last_token_read_)
+    return true;
+  CommandBuffer::State last_state = command_buffer_->GetLastState();
+  cached_last_token_read_ = last_state.token;
+  cached_get_offset_ = last_state.get_offset;
+  context_lost_ = gpu::error::IsError(last_state.error);
+  return token <= cached_last_token_read_;
+}
+
 // Waits until the current token value is greater or equal to the value passed
 // in argument.
 void CommandBufferHelper::WaitForToken(int32_t token) {
   if (!usable() || !HaveRingBuffer()) {
     return;
   }
   // Return immediately if corresponding InsertToken failed.
   if (token < 0)
     return;
-  if (token > token_) return;  // we wrapped
-  if (last_token_read() >= token)
+  if (token > token_)
+    return;  // we wrapped
+  if (cached_last_token_read_ >= token)
     return;

[jbauman, 2016/12/09 03:16:03]

We should try to update the state here one last time before flushing.

[sunnyps, 2016/12/09 04:09:37]

Done.

   Flush();
-  command_buffer_->WaitForTokenInRange(token, token_);
+  CommandBuffer::State last_state =
+      command_buffer_->WaitForTokenInRange(token, token_);
+  cached_last_token_read_ = last_state.token;
+  cached_get_offset_ = last_state.get_offset;
+  context_lost_ = gpu::error::IsError(last_state.error);
 }
 
 // Waits for available entries, basically waiting until get >= put + count + 1.
 // It actually waits for contiguous entries, so it may need to wrap the buffer
 // around, adding a noops. Thus this function may change the value of put_. The
 // function will return early if an error occurs, in which case the available
 // space may not be available.
 void CommandBufferHelper::WaitForAvailableEntries(int32_t count) {
   AllocateRingBuffer();
   if (!usable()) {
     return;
   }
   DCHECK(HaveRingBuffer());
   DCHECK(count < total_entry_count_);
   if (put_ + count > total_entry_count_) {
     // There's not enough room between the current put and the end of the
     // buffer, so we need to wrap. We will add noops all the way to the end,
     // but we need to make sure get wraps first, actually that get is 1 or
     // more (since put will wrap to 0 after we add the noops).
     DCHECK_LE(1, put_);
-    int32_t curr_get = get_offset();
+    int32_t curr_get = cached_get_offset_;
     if (curr_get > put_ || curr_get == 0) {
       TRACE_EVENT0("gpu", "CommandBufferHelper::WaitForAvailableEntries");
       Flush();
       if (!WaitForGetOffsetInRange(1, put_))
         return;
-      curr_get = get_offset();
+      curr_get = cached_get_offset_;
       DCHECK_LE(curr_get, put_);
       DCHECK_NE(0, curr_get);
     }
     // Insert Noops to fill out the buffer.
     int32_t num_entries = total_entry_count_ - put_;
     while (num_entries > 0) {
       int32_t num_to_skip = std::min(CommandHeader::kMaxSize, num_entries);
       cmd::Noop::Set(&entries_[put_], num_to_skip);
       put_ += num_to_skip;
       num_entries -= num_to_skip;
@@ skipping 13 matching lines @@
       if (!WaitForGetOffsetInRange((put_ + count + 1) % total_entry_count_,
                                    put_))
         return;
       CalcImmediateEntries(count);
       DCHECK_GE(immediate_entry_count_, count);
     }
   }
 }
 
 int32_t CommandBufferHelper::GetTotalFreeEntriesNoWaiting() const {
-  int32_t current_get_offset = get_offset();
+  int32_t current_get_offset = cached_get_offset_;
   if (current_get_offset > put_) {
     return current_get_offset - put_ - 1;
   } else {
     return current_get_offset + total_entry_count_ - put_ -
            (current_get_offset == 0 ? 1 : 0);
   }
 }
 
 bool CommandBufferHelper::OnMemoryDump(
     const base::trace_event::MemoryDumpArgs& args,
@@ skipping 20 matching lines @@
     auto guid = GetBufferGUIDForTracing(tracing_process_id, ring_buffer_id_);
     const int kImportance = 2;
     pmd->CreateSharedGlobalAllocatorDump(guid);
     pmd->AddOwnershipEdge(dump->guid(), guid, kImportance);
   }
 
   return true;
 }
 
 }  // namespace gpu