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 16 matching lines @@
   return (size + (kAllocAlignment - 1)) & ~(kAllocAlignment - 1);
 }
 
 }  // namespace
 
 #ifndef _MSC_VER
 const FencedAllocator::Offset FencedAllocator::kInvalidOffset;
 #endif
 
 FencedAllocator::FencedAllocator(unsigned int size,
+                                 bool aggressive_reuse,
                                  CommandBufferHelper *helper)
     : helper_(helper),
+      aggressive_reuse_(aggressive_reuse),
       bytes_in_use_(0) {
   Block block = { FREE, 0, RoundDown(size), kUnusedToken };
   blocks_.push_back(block);
 }
 
 FencedAllocator::~FencedAllocator() {
   // Free blocks pending tokens.
   for (unsigned int i = 0; i < blocks_.size(); ++i) {
     if (blocks_[i].state == FREE_PENDING_TOKEN) {
       i = WaitForTokenAndFreeBlock(i);
@@ skipping 12 matching lines @@
 FencedAllocator::Offset FencedAllocator::Alloc(unsigned int size) {
   // size of 0 is not allowed because it would be inconsistent to only sometimes
   // have it succeed. Example: Alloc(SizeOfBuffer), Alloc(0).
   if (size == 0)  {
     return kInvalidOffset;
   }
 
   // Round up the allocation size to ensure alignment.
   size = RoundUp(size);
 
+  if (aggressive_reuse_) {
+    return AggressiveAlloc(size);
+  }
+
   // Try first to allocate in a free block.
   for (unsigned int i = 0; i < blocks_.size(); ++i) {
     Block &block = blocks_[i];
     if (block.state == FREE && block.size >= size) {
       return AllocInBlock(i, size);
     }
   }
 
   // No free block is available. Look for blocks pending tokens, and wait for
   // them to be re-usable.
   for (unsigned int i = 0; i < blocks_.size(); ++i) {
     if (blocks_[i].state != FREE_PENDING_TOKEN)
       continue;
     i = WaitForTokenAndFreeBlock(i);
     if (blocks_[i].size >= size)
       return AllocInBlock(i, size);
   }
   return kInvalidOffset;
 }
 
+FencedAllocator::Offset FencedAllocator::AggressiveAlloc(unsigned int size) {
+  // Find first series of blocks that together make a large enough area.
+  unsigned int range_start = 0, range_stop = 0;
+  unsigned int current_size = 0;
+  for (unsigned int i = 0; i < blocks_.size(); ++i) {
+    Block &block = blocks_[i];
+    if (block.state == IN_USE) {
+      current_size = 0;
+    } else {
+      DCHECK(block.state == FREE || block.state == FREE_PENDING_TOKEN);
+
+      if (current_size == 0)
+        range_start = i;
+      range_stop = i;
+
+      current_size += block.size;
+      if (current_size >= size)
+        break;
+    }
+  }
+
+  if (current_size < size)
+    return kInvalidOffset;
+
+  // Collapse the blocks in the range |range_start| -> |range_stop| into
+  // one block. Override the previous state, as we don't care whether
+  // the block was FREE or FREE_PENDING_TOKEN here.
+  unsigned int new_size = blocks_[range_start].size;
+  const unsigned int second_in_range = range_start + 1;
+  for (unsigned int i = range_start; i < range_stop; ++i) {
+    new_size += blocks_[second_in_range].size;
+    blocks_.erase(blocks_.begin() + second_in_range);
+  }
+  blocks_[range_start].size = new_size;
+  blocks_[range_start].state = FREE;
+
+  return AllocInBlock(range_start, size);
+}
+
 // Looks for the corresponding block, mark it FREE, and collapse it if
 // necessary.
 void FencedAllocator::Free(FencedAllocator::Offset offset) {
   BlockIndex index = GetBlockByOffset(offset);
   DCHECK_NE(blocks_[index].state, FREE);
   Block &block = blocks_[index];
 
   if (block.state == IN_USE)
     bytes_in_use_ -= block.size;
 
@@ skipping 120 matching lines @@
                                                       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 = {
+    block.state,
+    offset + size,
+    block.size - size,
+    kUnusedToken
+  };
   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 };
   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