gpu: Reuse transfer buffers more aggresively

gpu/command_buffer/client/fenced_allocator.h

 // 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 definition of the FencedAllocator class.
 
 #ifndef GPU_COMMAND_BUFFER_CLIENT_FENCED_ALLOCATOR_H_
 #define GPU_COMMAND_BUFFER_CLIENT_FENCED_ALLOCATOR_H_
 
 #include <vector>
@@ skipping 17 matching lines @@
 // (see http://www.corp.google.com/eng/doc/cpp_primer.html#thread_safety).
 class GPU_EXPORT FencedAllocator {
  public:
   typedef unsigned int Offset;
   // Invalid offset, returned by Alloc in case of failure.
   static const Offset kInvalidOffset = 0xffffffffU;
 
   // Creates a FencedAllocator. Note that the size of the buffer is passed, but
   // not its base address: everything is handled as offsets into the buffer.
   FencedAllocator(unsigned int size,
+                  bool aggressive_reuse,

[epennerAtGoogle, 2013/12/18 19:21:15]

Rather than a separate allocator, do you think it would be possible to flag
deletions for immediate reuse (ie. skip free-pending state)?  This is partially
a question for reveman/sievers (as to how best this could be communicated from
the client).

                   CommandBufferHelper *helper);
 
   ~FencedAllocator();
 
   // Allocates a block of memory. If the buffer is out of directly available
   // memory, this function may wait until memory that was freed "pending a
   // token" can be re-used.
   //
   // Parameters:
   //   size: the size of the memory block to allocate.
@@ skipping 32 matching lines @@
   // testing.
   bool CheckConsistency();
 
   // True if any memory is allocated.
   bool InUse();
 
   // Return bytes of memory that is IN_USE
   size_t bytes_in_use() const { return bytes_in_use_; }
 
  private:
+  Offset AggressiveAlloc(unsigned int size);
+
   // Status of a block of memory, for book-keeping.
   enum State {
     IN_USE,
     FREE,
     FREE_PENDING_TOKEN
   };
 
   // Book-keeping sturcture that describes a block of memory.
   struct Block {
     State state;
@@ skipping 30 matching lines @@
 
   // Allocates a block of memory inside a given block, splitting it in two
   // (unless that block is of the exact requested size).
   // NOTE: this will invalidate block indices.
   // Returns the offset of the allocated block (NOTE: this is different from
   // the other functions that return a block index).
   Offset AllocInBlock(BlockIndex index, unsigned int size);
 
   CommandBufferHelper *helper_;
   Container blocks_;
+  bool aggressive_reuse_;
   size_t bytes_in_use_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(FencedAllocator);
 };
 
 // This class functions just like FencedAllocator, but its API uses pointers
 // instead of offsets.
 class FencedAllocatorWrapper {
  public:
   FencedAllocatorWrapper(unsigned int size,
+                         bool aggressive_reuse,
                          CommandBufferHelper* helper,
                          void* base)
-      : allocator_(size, helper),
+      : allocator_(size, aggressive_reuse, helper),
         base_(base) { }
 
   // Allocates a block of memory. If the buffer is out of directly available
   // memory, this function may wait until memory that was freed "pending a
   // token" can be re-used.
   //
   // Parameters:
   //   size: the size of the memory block to allocate.
   //
   // Returns:
@@ skipping 88 matching lines @@
 
  private:
   FencedAllocator allocator_;
   void* base_;
   DISALLOW_IMPLICIT_CONSTRUCTORS(FencedAllocatorWrapper);
 };
 
 }  // namespace gpu
 
 #endif  // GPU_COMMAND_BUFFER_CLIENT_FENCED_ALLOCATOR_H_