Enforce a memory limit on MappedMemoryManager

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>
+
 #include "gpu/command_buffer/client/cmd_buffer_helper.h"
 
 namespace gpu {
 
 namespace {
 
 // Allocation alignment, must be a power of two.
 const unsigned int kAllocAlignment = 16;
 
 // Round down to the largest multiple of kAllocAlignment no greater than |size|.
 unsigned int RoundDown(unsigned int size) {
   return size & ~(kAllocAlignment - 1);
 }
 
 // Round up to the smallest multiple of kAllocAlignment no smaller than |size|.
 unsigned int RoundUp(unsigned int size) {
   return (size + (kAllocAlignment - 1)) & ~(kAllocAlignment - 1);
 }
 
 }  // namespace
 
 #ifndef _MSC_VER
 const FencedAllocator::Offset FencedAllocator::kInvalidOffset;
 #endif
 
 FencedAllocator::FencedAllocator(unsigned int size,
                                  CommandBufferHelper *helper)
-    : helper_(helper) {
+    : helper_(helper),
+      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 36 matching lines @@
       return AllocInBlock(i, size);
   }
   return kInvalidOffset;
 }
 
 // Looks for the corresponding block, mark it FREE, and collapse it if
 // necessary.
 void FencedAllocator::Free(FencedAllocator::Offset offset) {
   BlockIndex index = GetBlockByOffset(offset);
   GPU_DCHECK_NE(blocks_[index].state, FREE);
-  blocks_[index].state = FREE;
+  Block &block = blocks_[index];
+
+  if (block.state == IN_USE)
+    bytes_in_use_ -= block.size;
+
+  block.state = FREE;
   CollapseFreeBlock(index);
 }
 
 // Looks for the corresponding block, mark it FREE_PENDING_TOKEN.
 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;
 }
 
 // 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];
@@ skipping 34 matching lines @@
     if (next.offset <= current.offset)
       return false;
     if (next.offset != current.offset + current.size)
       return false;
     if (current.state == FREE && next.state == FREE)
       return false;
   }
   return true;
 }
 
+// Returns false if all blocks are actually FREE, in which
+// case they would be coalesced into one block, true otherwise.
 bool FencedAllocator::InUse() {
   return blocks_.size() != 1 || blocks_[0].state != FREE;
 }
 
 // Collapse the block to the next one, then to the previous one. Provided the
 // structure is consistent, those are the only blocks eligible for collapse.
 FencedAllocator::BlockIndex FencedAllocator::CollapseFreeBlock(
     BlockIndex index) {
   if (index + 1 < blocks_.size()) {
     Block &next = blocks_[index + 1];
@@ skipping 38 matching lines @@
 }
 
 // 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];
   GPU_DCHECK_GE(block.size, size);
   GPU_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.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());
   GPU_DCHECK(it != blocks_.end() && it->offset == offset);
   return it-blocks_.begin();
 }
 
 }  // namespace gpu