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"
+

[no sievers, 2013/08/20 02:46:54]

nit: whitespace change

[kaanb, 2013/08/20 22:15:46]

Whitespace is advised per the style guide:
http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml#Names_and_Orde...

 #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);
+
+  if (blocks_[index].state == IN_USE)

[piman, 2013/08/20 02:56:16]

nit: only do map lookup once (like in FreePendingToken)

[kaanb, 2013/08/20 22:15:46]

Done.

+    bytes_in_use_ -= blocks_[index].size;
+
   blocks_[index].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 35 matching lines @@
       return false;
     if (next.offset != current.offset + current.size)
       return false;
     if (current.state == FREE && next.state == FREE)
       return false;
   }
   return true;
 }
 
 bool FencedAllocator::InUse() {
   return blocks_.size() != 1 || blocks_[0].state != FREE;

[no sievers, 2013/08/20 02:46:54]

Hmm, this function is misleading, right? If you have one free and one
free_pending_token block, it would return true here?

[kaanb, 2013/08/20 22:15:46]

Done.

[piman, 2013/08/20 22:26:13]

Not sure we should change this - I actually don't think the way it's been
changed differs from how it was.

InUse is used by MappedMemoryManager to know when it can safely destroy the
underlying shm. It can only do so when all the blocks are actually FREE (i.e. no
FREE_PENDING_TOKEN either). When they're all FREE, they get coalesced so there's
only 1 FREE block - what the  condition used to test.

The new version would only give a different result if there's >1 block and
they're all FREE, which can't happen due to coalescing. So it's needlessly
slower and more complex.

[no sievers, 2013/08/20 22:39:37]

My bad. Shouldn't have commented on this at all. It was just a very mild
irritation about Kaan was adding the notion of bytes 'in use' vs. how this
InUse() mismatches :)

Just leave as is.

[kaanb, 2013/08/20 22:40:53]

Done.

 }
 
 // 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];
     if (next.state == FREE) {
       blocks_[index].size += next.size;
@@ skipping 37 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;
   if (block.size == size) {
+    bytes_in_use_ += size;
     block.state = IN_USE;
     return offset;
   }
   Block newblock = { FREE, offset + size, block.size - size, kUnusedToken};
+  bytes_in_use_ += size;

[piman, 2013/08/20 02:56:16]

nit: factor this to before the if?

[kaanb, 2013/08/20 22:15:46]

Done.

   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