gpu: Reuse transfer buffers more aggresively

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 "base/logging.h"
 #include "gpu/command_buffer/common/command_buffer.h"
 #include "gpu/command_buffer/common/trace_event.h"
 
 namespace gpu {
 
 const int kCommandsPerFlushCheck = 100;
 
 #if !defined(OS_ANDROID)
 const double kFlushDelay = 1.0 / (5.0 * 60.0);
 #endif
 
 CommandBufferHelper::CommandBufferHelper(CommandBuffer* command_buffer)
     : command_buffer_(command_buffer),
       ring_buffer_id_(-1),
       ring_buffer_size_(0),
       entries_(NULL),
       total_entry_count_(0),
       token_(0),
+      async_token_(0),
       put_(0),
       last_put_sent_(0),
       commands_issued_(0),
       usable_(true),
       context_lost_(false),
       flush_automatically_(true),
       last_flush_time_(0) {
 }
 
 void CommandBufferHelper::SetAutomaticFlushes(bool enabled) {
@@ skipping 146 matching lines @@
       LOG(FATAL) << "Empty command buffer while waiting on a token.";
       return;
     }
     // Do not loop forever if the flush fails, meaning the command buffer reader
     // has shutdown.
     if (!FlushSync())
       return;
   }
 }
 
+uint32 CommandBufferHelper::InsertAsyncToken() {

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

Perhaps async token is meant to be more generic, but if it was
'async_upload_token', could we just use the async upload commands rather than
have a new command? 

If it is meant to be generic for other 'async things', it feels like we need an
indicator of what 'async thing' we are talking about, to be clear about who owns
the async_token and is allowed to change it. Perhaps there could be an enum of
async-token-types which currently only has ASYNC_TRANSFER?

+  AllocateRingBuffer();
+  if (!usable()) {
+    return async_token_;
+  }
+  DCHECK(HaveRingBuffer());
+
+  async_token_++;
+  if (async_token_ == 0)
+    async_token_++;
+
+  cmd::SetAsyncToken* cmd = GetCmdSpace<cmd::SetAsyncToken>();
+  if (cmd) {
+    cmd->Init(async_token_);
+  }
+  return async_token_;
+}
+
 // 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 count) {
   AllocateRingBuffer();
   if (!usable()) {
     return;
   }
@@ skipping 66 matching lines @@
   CommandBufferEntry* space = &entries_[put_];
   put_ += entries;
   DCHECK_LE(put_, total_entry_count_);
   if (put_ == total_entry_count_) {
     put_ = 0;
   }
   return space;
 }
 
 }  // namespace gpu