Make CommandBuffer::Flush asynchronous, and add CommandBuffer::FlushSync with former semantics.

gpu/command_buffer/client/cmd_buffer_helper.cc

 // Copyright (c) 2009 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 "../client/cmd_buffer_helper.h"
 #include "../common/command_buffer.h"
 
 namespace gpu {
@@ skipping 27 matching lines @@
   total_entry_count_ = num_ring_buffer_entries;
   usable_entry_count_ = total_entry_count_ - kJumpEntries;
   put_ = state.put_offset;
   SynchronizeState(state);
   return true;
 }
 
 CommandBufferHelper::~CommandBufferHelper() {
 }
 
-bool CommandBufferHelper::Flush() {
-  CommandBuffer::State state = command_buffer_->Flush(put_);
+bool CommandBufferHelper::FlushSync() {
+  CommandBuffer::State state = command_buffer_->FlushSync(put_);
   SynchronizeState(state);
   return state.error == error::kNoError;
 }
 
+void CommandBufferHelper::Flush() {
+  command_buffer_->Flush(put_);
+}
+
 // Calls Flush() and then waits until the buffer is empty. Break early if the
 // error is set.
 bool CommandBufferHelper::Finish() {
   do {
     // Do not loop forever if the flush fails, meaning the command buffer reader
     // has shutdown.
-    if (!Flush())
+    if (!FlushSync())
       return false;
   } while (put_ != get_);
 
   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.
@@ skipping 20 matching lines @@
   if (last_token_read_ >= token) return;  // fast path.
   if (token > token_) return;  // we wrapped
   Flush();
   while (last_token_read_ < token) {
     if (get_ == put_) {
       GPU_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 (!Flush())
+    if (!FlushSync())
       return;
   }
 }
 
 // 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 jump. 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) {
   GPU_CHECK(count < usable_entry_count_);

[apatrick, 2011/01/14 18:31:34]

I was thinking about putting an async flush in here once the command buffer is,
say, half full. If you're in the area :)

[Antoine Labour, 2011/01/14 21:35:33]

Done. (added at the end of the function)

   if (put_ + count > usable_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 a jump back to the start, 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 jump).
     GPU_DCHECK_LE(1, put_);
     Flush();

[apatrick, 2011/01/14 18:31:34]

Won't this async flush likely be immediately followed by the sync flush below?

[Antoine Labour, 2011/01/14 21:35:33]

Done. You're right we don't need to do it, and it makes the code simpler.

     while (get_ > put_ || get_ == 0) {
       // Do not loop forever if the flush fails, meaning the command buffer
       // reader has shutdown.
-      if (!Flush())
+      if (!FlushSync())
         return;
     }
     // Insert a jump back to the beginning.
     cmd::Jump::Set(&entries_[put_], 0);
     put_ = 0;
   }
   // If we have enough room, return immediatly.
   if (count <= AvailableEntries()) return;
   // Otherwise flush, and wait until we do have enough room.
   Flush();

[apatrick, 2011/01/14 18:31:34]

Same here. And some other places in this file.

[Antoine Labour, 2011/01/14 21:35:33]

Done.

   while (AvailableEntries() < count) {
     // Do not loop forever if the flush fails, meaning the command buffer reader
     // has shutdown.
-    if (!Flush())
+    if (!FlushSync())
       return;
   }
 }
 
 CommandBufferEntry* CommandBufferHelper::GetSpace(uint32 entries) {
   WaitForAvailableEntries(entries);
   CommandBufferEntry* space = &entries_[put_];
   put_ += entries;
   GPU_DCHECK_LE(put_, usable_entry_count_);
   if (put_ == usable_entry_count_) {
     cmd::Jump::Set(&entries_[put_], 0);
     put_ = 0;
   }
   return space;
 }
 
 error::Error CommandBufferHelper::GetError() {
   CommandBuffer::State state = command_buffer_->GetState();
   SynchronizeState(state);
   return static_cast<error::Error>(state.error);
 }
 
 void CommandBufferHelper::SynchronizeState(CommandBuffer::State state) {
   get_ = state.get_offset;
   last_token_read_ = state.token;
 }
 
 }  // namespace gpu