Cooperatively round robin GPU command buffers.

gpu/command_buffer/client/cmd_buffer_helper.cc

 // Copyright (c) 2011 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"
 #include "../common/trace_event.h"
 
 namespace gpu {
 
+namespace {
+const int kCommandsPerFlushCheck = 100;
+const double kFlushDelay = 1.0 / (5.0 * 60.0);
+}
+
 CommandBufferHelper::CommandBufferHelper(CommandBuffer* command_buffer)
     : command_buffer_(command_buffer),
       entries_(NULL),
       total_entry_count_(0),
       usable_entry_count_(0),
       token_(0),
       last_token_read_(-1),
       get_(0),
       put_(0),
-      last_put_sent_(0) {
+      last_put_sent_(0),
+      commands_issued_(0),
+      last_flush_time_(0) {
 }
 
 bool CommandBufferHelper::Initialize(int32 ring_buffer_size) {
   ring_buffer_ = command_buffer_->GetRingBuffer();
   if (!ring_buffer_.ptr)
     return false;
 
   CommandBuffer::State state = command_buffer_->GetState();
   entries_ = static_cast<CommandBufferEntry*>(ring_buffer_.ptr);
   int32 num_ring_buffer_entries = ring_buffer_size / sizeof(CommandBufferEntry);
   if (num_ring_buffer_entries > state.num_entries) {
     return false;
   }
 
   const int32 kJumpEntries =
       sizeof(cmd::Jump) / sizeof(*entries_);  // NOLINT
 
   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::FlushSync() {
+  time(&last_flush_time_);
   last_put_sent_ = put_;
   CommandBuffer::State state = command_buffer_->FlushSync(put_, get_);
   SynchronizeState(state);
   return state.error == error::kNoError;
 }
 
 void CommandBufferHelper::Flush() {
+  time(&last_flush_time_);
   last_put_sent_ = put_;
   command_buffer_->Flush(put_);
 }
 
 // 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");
   do {
     // Do not loop forever if the flush fails, meaning the command buffer reader
@@ skipping 77 matching lines @@
   }
   if (AvailableEntries() < count) {
     TRACE_EVENT0("gpu", "CommandBufferHelper::WaitForAvailableEntries1");
     while (AvailableEntries() < count) {
       // Do not loop forever if the flush fails, meaning the command buffer
       // reader has shutdown.
       if (!FlushSync())
         return;
     }
   }
-  // Force a flush if the buffer is getting half full, or even earlier if the
-  // reader is known to be idle.
-  int32 pending =
-      (put_ + usable_entry_count_ - last_put_sent_) % usable_entry_count_;
-  int32 limit = usable_entry_count_ / ((get_ == last_put_sent_) ? 16 : 2);
-  if (pending > limit) {
-    Flush();
+  // Allow this command buffer to be pre-empted by another if a "reasonable"
+  // amount of work has been done.
+  if (commands_issued_ % kCommandsPerFlushCheck == 0) {
+    clock_t current_time = time(NULL);
+    if (difftime(current_time, last_flush_time_) > kFlushDelay)
+      Flush();
   }
 }
 
 CommandBufferEntry* CommandBufferHelper::GetSpace(uint32 entries) {
+  ++commands_issued_;
   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(const CommandBuffer::State& state) {
   get_ = state.get_offset;
   last_token_read_ = state.token;
 }
 
 }  // namespace gpu