diff options
author | bsalomon@google.com <bsalomon@google.com@2bbb7eff-a529-9590-31e7-b0007b416f81> | 2012-06-19 15:40:27 +0000 |
---|---|---|
committer | bsalomon@google.com <bsalomon@google.com@2bbb7eff-a529-9590-31e7-b0007b416f81> | 2012-06-19 15:40:27 +0000 |
commit | 4da34e36cb7a07c3a28ae2a135b1837c26fc7aea (patch) | |
tree | 36ba4b63893a5621fe1eb377ea7cb3f4692c42b3 /src/gpu/GrMemoryPool.cpp | |
parent | 50e4ce05521b0d95890e894691819882113aae86 (diff) |
Add GrMemoryPool as a helper to override operators new/delete
Review URL: http://codereview.appspot.com/6306090/
git-svn-id: http://skia.googlecode.com/svn/trunk@4282 2bbb7eff-a529-9590-31e7-b0007b416f81
Diffstat (limited to 'src/gpu/GrMemoryPool.cpp')
-rw-r--r-- | src/gpu/GrMemoryPool.cpp | 153 |
1 files changed, 153 insertions, 0 deletions
diff --git a/src/gpu/GrMemoryPool.cpp b/src/gpu/GrMemoryPool.cpp new file mode 100644 index 0000000000..597f88cbb8 --- /dev/null +++ b/src/gpu/GrMemoryPool.cpp @@ -0,0 +1,153 @@ +/* + * Copyright 2012 Google Inc. + * + * Use of this source code is governed by a BSD-style license that can be + * found in the LICENSE file. + */ + +#include "GrMemoryPool.h" + +#if GR_DEBUG + #define VALIDATE this->validate() +#else + #define VALIDATE +#endif + +GrMemoryPool::GrMemoryPool(size_t preallocSize, size_t minAllocSize) { + GR_DEBUGCODE(fAllocationCnt = 0); + + minAllocSize = GrMax<size_t>(minAllocSize, 1 << 10); + fMinAllocSize = GrSizeAlignUp(minAllocSize + kPerAllocPad, kAlignment), + fPreallocSize = GrSizeAlignUp(preallocSize + kPerAllocPad, kAlignment); + fPreallocSize = GrMax(fPreallocSize, fMinAllocSize); + + fHead = CreateBlock(fPreallocSize); + fTail = fHead; + fHead->fNext = NULL; + fHead->fPrev = NULL; + VALIDATE; +}; + +GrMemoryPool::~GrMemoryPool() { + VALIDATE; + GrAssert(0 == fAllocationCnt); + GrAssert(fHead == fTail); + GrAssert(0 == fHead->fLiveCount); + DeleteBlock(fHead); +}; + +void* GrMemoryPool::allocate(size_t size) { + VALIDATE; + size = GrSizeAlignUp(size, kAlignment); + size += kPerAllocPad; + if (fTail->fFreeSize < size) { + int blockSize = size; + blockSize = GrMax<size_t>(blockSize, fMinAllocSize); + BlockHeader* block = CreateBlock(blockSize); + + block->fPrev = fTail; + block->fNext = NULL; + GrAssert(NULL == fTail->fNext); + fTail->fNext = block; + fTail = block; + } + GrAssert(fTail->fFreeSize >= size); + intptr_t ptr = fTail->fCurrPtr; + // We stash a pointer to the block header, just before the allocated space, + // so that we can decrement the live count on delete in constant time. + *reinterpret_cast<BlockHeader**>(ptr) = fTail; + ptr += kPerAllocPad; + fTail->fCurrPtr += size; + fTail->fFreeSize -= size; + fTail->fLiveCount += 1; + GR_DEBUGCODE(++fAllocationCnt); + VALIDATE; + return reinterpret_cast<void*>(ptr); +} + +void GrMemoryPool::release(void* p) { + VALIDATE; + intptr_t ptr = reinterpret_cast<intptr_t>(p) - kPerAllocPad; + BlockHeader* block = *reinterpret_cast<BlockHeader**>(ptr); + if (1 == block->fLiveCount) { + // the head block is special, it is reset rather than deleted + if (fHead == block) { + fHead->fCurrPtr = reinterpret_cast<intptr_t>(fHead) + + kHeaderSize; + fHead->fLiveCount = 0; + fHead->fFreeSize = fPreallocSize; + } else { + BlockHeader* prev = block->fPrev; + BlockHeader* next = block->fNext; + GrAssert(prev); + prev->fNext = next; + if (next) { + next->fPrev = prev; + } else { + GrAssert(fTail == block); + fTail = prev; + } + DeleteBlock(block); + } + } else { + --block->fLiveCount; + } + GR_DEBUGCODE(--fAllocationCnt); + VALIDATE; +} + +GrMemoryPool::BlockHeader* GrMemoryPool::CreateBlock(size_t size) { + BlockHeader* block = + reinterpret_cast<BlockHeader*>(GrMalloc(size + kHeaderSize)); + // we assume malloc gives us aligned memory + GrAssert(!(reinterpret_cast<intptr_t>(block) % kAlignment)); + block->fLiveCount = 0; + block->fFreeSize = size; + block->fCurrPtr = reinterpret_cast<intptr_t>(block) + kHeaderSize; + return block; +} + +void GrMemoryPool::DeleteBlock(BlockHeader* block) { + GrFree(block); +} + +void GrMemoryPool::validate() { + BlockHeader* block = fHead; + BlockHeader* prev = NULL; + GrAssert(block); + int allocCount = 0; + do { + allocCount += block->fLiveCount; + GrAssert(prev == block->fPrev); + if (NULL != prev) { + GrAssert(prev->fNext == block); + } + + intptr_t b = reinterpret_cast<intptr_t>(block); + size_t ptrOffset = block->fCurrPtr - b; + size_t totalSize = ptrOffset + block->fFreeSize; + size_t userSize = totalSize - kHeaderSize; + intptr_t userStart = b + kHeaderSize; + + GrAssert(!(b % kAlignment)); + GrAssert(!(totalSize % kAlignment)); + GrAssert(!(userSize % kAlignment)); + GrAssert(!(block->fCurrPtr % kAlignment)); + if (fHead != block) { + GrAssert(block->fLiveCount); + GrAssert(userSize >= fMinAllocSize); + } else { + GrAssert(userSize == fPreallocSize); + } + if (!block->fLiveCount) { + GrAssert(ptrOffset == kHeaderSize); + GrAssert(userStart == block->fCurrPtr); + } else { + GrAssert(block == *reinterpret_cast<BlockHeader**>(userStart)); + } + prev = block; + } while ((block = block->fNext)); + GrAssert(allocCount == fAllocationCnt); + GrAssert(prev == fTail); +} + |