gpu: Thread-safe command buffer state lookup.

gpu/command_buffer/client/cmd_buffer_helper.h

 // 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 command buffer helper class.
 
 #ifndef GPU_COMMAND_BUFFER_CLIENT_CMD_BUFFER_HELPER_H_
 #define GPU_COMMAND_BUFFER_CLIENT_CMD_BUFFER_HELPER_H_
 
 #include <stddef.h>
@@ skipping 163 matching lines @@
   T* GetImmediateCmdSpaceTotalSize(size_t total_space) {
     static_assert(T::kArgFlags == cmd::kAtLeastN,
                   "T::kArgFlags should equal cmd::kAtLeastN");
     int32_t space_needed = ComputeNumEntries(total_space);
     T* data = static_cast<T*>(GetSpace(space_needed));
     return data;
   }
 
   int32_t last_token_read() const { return command_buffer_->GetLastToken(); }
 
-  int32_t get_offset() const {
-    return command_buffer_->GetLastState().get_offset;
-  }
-
   // Common Commands
   void Noop(uint32_t skip_count) {
     cmd::Noop* cmd = GetImmediateCmdSpace<cmd::Noop>(
         (skip_count - 1) * sizeof(CommandBufferEntry));
     if (cmd) {
       cmd->Init(skip_count);
     }
   }
 
   void SetToken(uint32_t token) {
@@ skipping 93 matching lines @@
     CalcImmediateEntries(0);
   }
 
   // Overridden from base::trace_event::MemoryDumpProvider:
   bool OnMemoryDump(const base::trace_event::MemoryDumpArgs& args,
                     base::trace_event::ProcessMemoryDump* pmd) override;
 
  private:
   // Returns the number of available entries (they may not be contiguous).
   int32_t AvailableEntries() {
-    return (get_offset() - put_ - 1 + total_entry_count_) % total_entry_count_;
+    return (last_get_ - put_ - 1 + total_entry_count_) % total_entry_count_;
   }
 
   void CalcImmediateEntries(int waiting_count);
   bool AllocateRingBuffer();
   void FreeResources();
 
   // Waits for the get offset to be in a specific range, inclusive. Returns
   // false if there was an error.
   bool WaitForGetOffsetInRange(int32_t start, int32_t end);
 
 #if defined(CMD_HELPER_PERIODIC_FLUSH_CHECK)
   // Calls Flush if automatic flush conditions are met.
   void PeriodicFlushCheck();
 #endif
 
   int32_t GetTotalFreeEntriesNoWaiting() const;
 
   CommandBuffer* command_buffer_;
   int32_t ring_buffer_id_;
   int32_t ring_buffer_size_;
   scoped_refptr<gpu::Buffer> ring_buffer_;
   CommandBufferEntry* entries_;
   int32_t total_entry_count_;  // the total number of entries
   int32_t immediate_entry_count_;
   int32_t token_;
   int32_t put_;
+  int32_t last_get_;

[sunnyps, 2016/12/02 02:52:03]

bikeshed: cached_get_offset_?

[piman, 2016/12/02 19:21:48]

I like cached_get_offset_

[sunnyps, 2016/12/07 03:31:22]

Done.

   int32_t last_put_sent_;
   int32_t last_barrier_put_sent_;
 
 #if defined(CMD_HELPER_PERIODIC_FLUSH_CHECK)
   int commands_issued_;
 #endif
 
   bool usable_;
   bool context_lost_;
   bool flush_automatically_;
 
   base::TimeTicks last_flush_time_;
 
   // Incremented every time the helper flushes the command buffer.
   // Can be used to track when prior commands have been flushed.
   uint32_t flush_generation_;
 
   friend class CommandBufferHelperTest;
   DISALLOW_COPY_AND_ASSIGN(CommandBufferHelper);
 };
 
 }  // namespace gpu
 
 #endif  // GPU_COMMAND_BUFFER_CLIENT_CMD_BUFFER_HELPER_H_