gpu: Reuse transfer buffers more aggresively

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 <string.h>
@@ skipping 65 matching lines @@
 
   // Inserts a new token into the command buffer. This token either has a value
   // different from previously inserted tokens, or ensures that previously
   // inserted tokens with that value have already passed through the command
   // stream.
   // Returns:
   //   the value of the new token or -1 if the command buffer reader has
   //   shutdown.
   int32 InsertToken();
 
+  // Returns true if the token has passed.
+  // Parameters:
+  //   the value of the token to check whether it has passed
+  bool HasTokenPassed(int32 token) const {
+    if (token > token_)
+      return true;  // we wrapped
+    return last_token_read() >= token;
+  }
+
   // Waits until the token of a particular value has passed through the command
   // stream (i.e. commands inserted before that token have been executed).
   // NOTE: This will call Flush if it needs to block.
   // Parameters:
   //   the value of the token to wait for.
   void WaitForToken(int32 token);
 
+  // Inserts a new async token to the command buffer. One can then check if the
+  // token has passed using HasAsyncTokenPassed(). It is guaranteed that the
+  // order of returned async tokens is the same as inserted, but it is
+  // implementation specific when a token is returned.
+  //
+  // NOTE: A async token is asynchronous in a way that Finish():ing the command
+  // buffer does mean it has passed.

[epenner, 2014/01/23 02:52:44]

Nit: 'doesn't'

+  uint32 InsertAsyncToken();
+
+  // Returns true if the async token has passed.
+  //
+  // NOTE: This will detect wrapped async tokens by checking if the most
+  // significant  bit of async token to check is 1 but the last read is 0, i.e.
+  // the uint32 wrapped.
+  //
+  // Parameters:
+  //   the value of the async token to check whether it has passed
+  bool HasAsyncTokenPassed(uint32 token) const {
+    uint32 last_async_token = last_async_token_read();
+    if (token <= last_async_token)
+      return true;
+    if (token & 0x80000000 && !(last_async_token & 0x80000000))
+      return true; // we wrapped
+    return false;
+  }
+
   // Called prior to each command being issued. Waits for a certain amount of
   // space to be available. Returns address of space.
   CommandBufferEntry* GetSpace(uint32 entries);
 
   // Typed version of GetSpace. Gets enough room for the given type and returns
   // a reference to it.
   template <typename T>
   T* GetCmdSpace() {
     COMPILE_ASSERT(T::kArgFlags == cmd::kFixed, Cmd_kArgFlags_not_kFixed);
     uint32 space_needed = ComputeNumEntries(sizeof(T));
@@ skipping 134 matching lines @@
   void WaitForGetChange();
 
   // Returns the number of available entries (they may not be contiguous).
   int32 AvailableEntries() {
     return (get_offset() - put_ - 1 + total_entry_count_) % total_entry_count_;
   }
 
   bool AllocateRingBuffer();
   void FreeResources();
 
+  // Get the async token number last read by the command buffer.
+  uint32 last_async_token_read() const {
+    return command_buffer_->GetLastState().async_token;
+  }
+
   CommandBuffer* command_buffer_;
   int32 ring_buffer_id_;
   int32 ring_buffer_size_;
   Buffer ring_buffer_;
   CommandBufferEntry* entries_;
   int32 total_entry_count_;  // the total number of entries
   int32 token_;
+  uint32 async_token_;
   int32 put_;
   int32 last_put_sent_;
   int commands_issued_;
   bool usable_;
   bool context_lost_;
   bool flush_automatically_;
 
   // Using C runtime instead of base because this file cannot depend on base.
   clock_t last_flush_time_;
 
   friend class CommandBufferHelperTest;
   DISALLOW_COPY_AND_ASSIGN(CommandBufferHelper);
 };
 
 }  // namespace gpu
 
 #endif  // GPU_COMMAND_BUFFER_CLIENT_CMD_BUFFER_HELPER_H_