gpu: Reuse transfer buffers more aggresively

gpu/command_buffer/client/fenced_allocator.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 FencedAllocator class.
 
 #include "gpu/command_buffer/client/fenced_allocator.h"
 
 #include <algorithm>
 
@@ skipping 24 matching lines @@
 
 FencedAllocator::FencedAllocator(unsigned int size,
                                  CommandBufferHelper *helper)
     : helper_(helper),
       bytes_in_use_(0) {
   Block block = { FREE, 0, RoundDown(size), kUnusedToken };
   blocks_.push_back(block);
 }
 
 FencedAllocator::~FencedAllocator() {
-  // Free blocks pending tokens.
+  // Free blocks pending tokens and serials.
   for (unsigned int i = 0; i < blocks_.size(); ++i) {
     if (blocks_[i].state == FREE_PENDING_TOKEN) {
       i = WaitForTokenAndFreeBlock(i);
+    } else if (blocks_[i].state == FREE_PENDING_SERIAL) {
+      Block &block = blocks_[i];
+      block.state = FREE;
+      CollapseFreeBlock(i);

[piman, 2014/01/11 02:02:32]

This is probably ok in the current use, if we can assume that the
FencedAllocator is destroyed as we delete the SHM it manages allocations on. In
that case it would actually be ok to not WaitForToken in the FREE_PENDING_TOKEN
case, either.

We should document the behavior though. It does mean that the user can't reuse
the SHM (e.g. if we keep a pool of open SHMs) without a Finish(). Alternatively,
I suppose we could extract the set of serials/tokens to wait for, and let the
client deal with waiting - though we don't have a way to wait-for-a-serial, I'm
not sure the client could really do anything. Mmh.

[jadahl, 2014/01/16 16:24:39]

Where do you suggest we document this? Here?

     }
   }
   // These checks are not valid if the service has crashed or lost the context.
   // DCHECK_EQ(blocks_.size(), 1u);
   // DCHECK_EQ(blocks_[0].state, FREE);
 }
 
 // Looks for a non-allocated block that is big enough. Search in the FREE
 // blocks first (for direct usage), first-fit, then in the FREE_PENDING_TOKEN
 // blocks, waiting for them. The current implementation isn't smart about
@@ skipping 47 matching lines @@
 void FencedAllocator::FreePendingToken(
     FencedAllocator::Offset offset, int32 token) {
   BlockIndex index = GetBlockByOffset(offset);
   Block &block = blocks_[index];
   if (block.state == IN_USE)
     bytes_in_use_ -= block.size;
   block.state = FREE_PENDING_TOKEN;
   block.token = token;
 }
 
+void FencedAllocator::FreePendingSerial(
+    FencedAllocator::Offset offset, uint32 serial) {
+  BlockIndex index = GetBlockByOffset(offset);
+  Block &block = blocks_[index];
+  if (block.state == IN_USE)
+    bytes_in_use_ -= block.size;
+  block.state = FREE_PENDING_SERIAL;
+  block.serial = serial;
+}
+
 // Gets the max of the size of the blocks marked as free.
 unsigned int FencedAllocator::GetLargestFreeSize() {
   FreeUnused();
   unsigned int max_size = 0;
   for (unsigned int i = 0; i < blocks_.size(); ++i) {
     Block &block = blocks_[i];
     if (block.state == FREE)
       max_size = std::max(max_size, block.size);
   }
   return max_size;
 }
 
 // Gets the size of the largest segment of blocks that are either FREE or
 // FREE_PENDING_TOKEN.
 unsigned int FencedAllocator::GetLargestFreeOrPendingSize() {
   unsigned int max_size = 0;
   unsigned int current_size = 0;
   for (unsigned int i = 0; i < blocks_.size(); ++i) {
     Block &block = blocks_[i];
-    if (block.state == IN_USE) {
+    if (block.state == IN_USE || block.state == FREE_PENDING_SERIAL) {
       max_size = std::max(max_size, current_size);
       current_size = 0;
     } else {
       DCHECK(block.state == FREE || block.state == FREE_PENDING_TOKEN);
       current_size += block.size;
     }
   }
   return std::max(max_size, current_size);
 }
 
@@ skipping 51 matching lines @@
   Block &block = blocks_[index];
   DCHECK_EQ(block.state, FREE_PENDING_TOKEN);
   helper_->WaitForToken(block.token);
   block.state = FREE;
   return CollapseFreeBlock(index);
 }
 
 // Frees any blocks pending a token for which the token has been read.
 void FencedAllocator::FreeUnused() {
   int32 last_token_read = helper_->last_token_read();
+  uint32 last_serial_read = helper_->last_serial_read();
   for (unsigned int i = 0; i < blocks_.size();) {
     Block& block = blocks_[i];
     if (block.state == FREE_PENDING_TOKEN && block.token <= last_token_read) {
       block.state = FREE;
       i = CollapseFreeBlock(i);
+    } else if (block.state == FREE_PENDING_SERIAL &&
+               block.serial <= last_serial_read) {

[reveman, 2014/01/11 23:39:04]

maybe use a switch statement here and above

+      block.state = FREE;
+      i = CollapseFreeBlock(i);
     } else {
       ++i;
     }
   }
 }
 
 // If the block is exactly the requested size, simply mark it IN_USE, otherwise
 // split it and mark the first one (of the requested size) IN_USE.
 FencedAllocator::Offset FencedAllocator::AllocInBlock(BlockIndex index,
                                                       unsigned int size) {
   Block &block = blocks_[index];
   DCHECK_GE(block.size, size);
   DCHECK_EQ(block.state, FREE);
   Offset offset = block.offset;
   bytes_in_use_ += size;
   if (block.size == size) {
     block.state = IN_USE;
     return offset;
   }
-  Block newblock = { FREE, offset + size, block.size - size, kUnusedToken};
+  Block newblock = {
+    FREE, offset + size,
+    block.size - size,
+    kUnusedToken,
+    kUnusedSerial
+  };
   block.state = IN_USE;
   block.size = size;
   // this is the last thing being done because it may invalidate block;
   blocks_.insert(blocks_.begin() + index + 1, newblock);
   return offset;
 }
 
 // The blocks are in offset order, so we can do a binary search.
 FencedAllocator::BlockIndex FencedAllocator::GetBlockByOffset(Offset offset) {
-  Block templ = { IN_USE, offset, 0, kUnusedToken };
+  Block templ = {
+    IN_USE,
+    offset,
+    0,
+    kUnusedToken,
+    kUnusedSerial
+  };
   Container::iterator it = std::lower_bound(blocks_.begin(), blocks_.end(),
                                             templ, OffsetCmp());
   DCHECK(it != blocks_.end() && it->offset == offset);
   return it-blocks_.begin();
 }
 
 }  // namespace gpu