gpu: Thread-safe command buffer state lookup.

gpu/command_buffer/client/ring_buffer.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 RingBuffer class.
 
 #include "gpu/command_buffer/client/ring_buffer.h"
 
 #include <stdint.h>
 
@@ skipping 128 matching lines @@
         in_use_offset_ = 0;
         free_offset_ = 0;
       }
       return;
     }
   }
   NOTREACHED() << "attempt to discard non-existant block";
 }
 
 unsigned int RingBuffer::GetLargestFreeSizeNoWaiting() {
-  unsigned int last_token_read = helper_->last_token_read();
   while (!blocks_.empty()) {
     Block& block = blocks_.front();
-    if (block.token > last_token_read || block.state == IN_USE) break;
+    if (!helper_->HasTokenPassed(block.token) || block.state == IN_USE) break;

[piman, 2016/12/07 20:30:12]

So, this would call GetLastState(), take the lock and do the TryUpdateState for
every single block, which seems very heavyweight for a call that is meant to be
reasonably fast.
Could we grab the latest token only once and then compare against it in the
loop?

[sunnyps, 2016/12/08 01:14:16]

I made HasTokenPassed faster by using the cached token first and then updating
the state if necessary. I don't like exposing the token directly because clients
might not perform the wrap-around check that HasTokenPassed does. Also, clients
have no way of doing the cached token early out.

     FreeOldestBlock();
   }
   if (free_offset_ == in_use_offset_) {
     if (blocks_.empty()) {
       // The entire buffer is free.
       DCHECK_EQ(free_offset_, 0u);
       return size_;
     } else {
       // The entire buffer is in use.
       return 0;
@@ skipping 11 matching lines @@
   unsigned int largest_free_size = GetLargestFreeSizeNoWaiting();
   if (free_offset_ > in_use_offset_) {
     // It's free from free_offset_ to size_ and from 0 to in_use_offset_.
     return size_ - free_offset_ + in_use_offset_;
   } else {
     return largest_free_size;
   }
 }
 
 }  // namespace gpu