(not for commit) Simplified multi-threaded Ganesh with lock on Flush only.

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 "base/time/time.h"
 #include "gpu/command_buffer/common/command_buffer.h"
 #include "gpu/command_buffer/common/trace_event.h"
 
 namespace gpu {
 
 CommandBufferHelper::CommandBufferHelper(CommandBuffer* command_buffer)
     : command_buffer_(command_buffer),
       ring_buffer_id_(-1),
       ring_buffer_size_(0),
       entries_(NULL),
       total_entry_count_(0),
       immediate_entry_count_(0),
       token_(0),
       put_(0),
       last_put_sent_(0),
+      safe_put_point_(0),
 #if defined(CMD_HELPER_PERIODIC_FLUSH_CHECK)
       commands_issued_(0),
 #endif
       usable_(true),
       context_lost_(false),
       flush_automatically_(true),
       flush_generation_(0) {
 }
 
 void CommandBufferHelper::SetAutomaticFlushes(bool enabled) {
@@ skipping 21 matching lines @@
   const int32 curr_get = get_offset();
   if (curr_get > put_) {
     immediate_entry_count_ = curr_get - put_ - 1;
   } else {
     immediate_entry_count_ =
         total_entry_count_ - put_ - (curr_get == 0 ? 1 : 0);
   }
 
   // Limit entry count to force early flushing.
   if (flush_automatically_) {
+    // Cache last_put_sent, as it may change via SafeFlush().
+    int32 last_put_sent = last_put_sent_;
     int32 limit =
         total_entry_count_ /
-        ((curr_get == last_put_sent_) ? kAutoFlushSmall : kAutoFlushBig);
+        ((curr_get == last_put_sent) ? kAutoFlushSmall : kAutoFlushBig);
 
     int32 pending =
-        (put_ + total_entry_count_ - last_put_sent_) % total_entry_count_;
+        (put_ + total_entry_count_ - last_put_sent) % total_entry_count_;
 
     if (pending > 0 && pending >= limit) {
       // Time to force flush.
       immediate_entry_count_ = 0;
     } else {
       // Limit remaining entries, but not lower than waiting_count entries to
       // prevent deadlock when command size is greater than the flush limit.
       limit -= pending;
       limit = limit < waiting_count ? waiting_count : limit;
       immediate_entry_count_ =
@@ skipping 56 matching lines @@
 
 bool CommandBufferHelper::WaitForGetOffsetInRange(int32 start, int32 end) {
   if (!usable()) {
     return false;
   }
   command_buffer_->WaitForGetOffsetInRange(start, end);
   return command_buffer_->GetLastError() == gpu::error::kNoError;
 }
 
 void CommandBufferHelper::Flush() {
+  base::AutoLock scoped_lock(flush_lock_);
   // Wrap put_ before flush.
   if (put_ == total_entry_count_)
     put_ = 0;
 
   if (usable() && last_put_sent_ != put_) {
     last_flush_time_ = base::TimeTicks::Now();
     last_put_sent_ = put_;
+    safe_put_point_ = put_;
     command_buffer_->Flush(put_);
     ++flush_generation_;
     CalcImmediateEntries(0);
   }
 }
 
+void CommandBufferHelper::SetSafeFlushPoint() {
+  base::AutoLock scoped_lock(flush_lock_);
+  safe_put_point_ = put_;
+  if (safe_put_point_ == total_entry_count_)
+    safe_put_point_ = 0;
+}
+
+void CommandBufferHelper::SafeFlush() {
+  base::AutoLock scoped_lock(flush_lock_);
+  if (usable() && last_put_sent_ != safe_put_point_) {
+    last_flush_time_ = base::TimeTicks::Now();
+    last_put_sent_ = safe_put_point_;
+    command_buffer_->Flush(safe_put_point_);
+    //++flush_generation_;
+  }
+}
+
 #if defined(CMD_HELPER_PERIODIC_FLUSH_CHECK)
 void CommandBufferHelper::PeriodicFlushCheck() {
   base::TimeTicks current_time = base::TimeTicks::Now();
   if (current_time - last_flush_time_ >
       base::TimeDelta::FromMicroseconds(kPeriodicFlushDelayInMicroseconds)) {
     Flush();
   }
 }
 #endif
 
@@ skipping 112 matching lines @@
       if (!WaitForGetOffsetInRange(put_ + count + 1, put_))
         return;
       CalcImmediateEntries(count);
       DCHECK_GE(immediate_entry_count_, count);
     }
   }
 }
 
 
 }  // namespace gpu