Make FencedAlloctor fail on size = 0.

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 "../client/fenced_allocator.h"
 #include <algorithm>
 #include "../client/cmd_buffer_helper.h"
 
 namespace gpu {
 
 #ifndef _MSC_VER
 const FencedAllocator::Offset FencedAllocator::kInvalidOffset;
 #endif
 
 FencedAllocator::FencedAllocator(unsigned int size,
                                  CommandBufferHelper *helper)
-    : helper_(helper) {
+    : helper_(helper),
+      zero_offset_(size) {
   Block block = { FREE, 0, 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);
     }
   }
   // These checks are not valid if the service has crashed or lost the context.
   // GPU_DCHECK_EQ(blocks_.size(), 1u);
   // GPU_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
 // optimizing what to wait for, just looks inside the block in order (first-fit
 // as well).
 FencedAllocator::Offset FencedAllocator::Alloc(unsigned int size) {
-  // Similarly to malloc, an allocation of 0 allocates at least 1 byte, to
-  // return different pointers every time.
-  if (size == 0) size = 1;
+  // Allocate zero size allocations outside the block. This is to satisfy 2
+  // issues. (1) that like malloc all ptrs are different (2) that
+  // Alloc(GetLargestFreeSize()) always works.
+  if (size == 0) {
+    for (size_t ii = 0; ii < zero_allocs_.size(); ++ii) {

[apatrick, 2012/12/03 20:45:43]

How common is allocating with zero size? You can't just keep incrementing
zero_offset_ on every zero allocation, CHECK it doesn't overflow and make
FreeZeroAlloc a no-op.

Alternatively, if zero allocs are common, how about have a std::set of free zero
offsets so it doesn't have to do a linear search each time?

+      if (!zero_allocs_[ii]) {
+        return zero_offset_ + ii;
+      }
+    }
+    zero_allocs_.push_back(true);
+    return zero_offset_ + zero_allocs_.size() - 1;
+  }
 
   // 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;
 }
 
+void FencedAllocator::FreeZeroAlloc(FencedAllocator::Offset offset) {
+  size_t index = offset - zero_offset_;
+  zero_allocs_[index] = false;

[apatrick, 2012/12/03 20:45:43]

Would DCHECK(zero_allocs_[index]) make sense here?

+}
+
 // Looks for the corresponding block, mark it FREE, and collapse it if
 // necessary.
 void FencedAllocator::Free(FencedAllocator::Offset offset) {
+  if (offset >= zero_offset_) {
+    FreeZeroAlloc(offset);
+    return;
+  }
   BlockIndex index = GetBlockByOffset(offset);
   GPU_DCHECK_NE(blocks_[index].state, FREE);
   blocks_[index].state = FREE;
   CollapseFreeBlock(index);
 }
 
 // Looks for the corresponding block, mark it FREE_PENDING_TOKEN.
 void FencedAllocator::FreePendingToken(
     FencedAllocator::Offset offset, int32 token) {
+  if (offset >= zero_offset_) {
+    FreeZeroAlloc(offset);
+    return;
+  }
   BlockIndex index = GetBlockByOffset(offset);
   Block &block = blocks_[index];
   block.state = FREE_PENDING_TOKEN;
   block.token = token;
 }
 
 // Gets the max of the size of the blocks marked as free.
 unsigned int FencedAllocator::GetLargestFreeSize() {
   unsigned int max_size = 0;
   for (unsigned int i = 0; i < blocks_.size(); ++i) {
@@ skipping 115 matching lines @@
 // 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