The Tor Browser: gfx/angle/src/compiler/PoolAlloc.cpp@141e0f1194b1 (annotated)

gfx/angle/src/compiler/PoolAlloc.cpp@141e0f1194b1 (annotated)

gfx/angle/src/compiler/PoolAlloc.cpp

Wed, 31 Dec 2014 07:16:47 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 07:16:47 +0100
branch: TOR_BUG_9701
changeset 3: 141e0f1194b1
permissions: -rw-r--r--

Revert simplistic fix pending revisit of Mozilla integration attempt.

 //
 // Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 //
 #include "compiler/PoolAlloc.h"
 #ifndef _MSC_VER
 #include <stdint.h>
 #endif
 #include <stdio.h>
 #include "common/angleutils.h"
 #include "compiler/InitializeGlobals.h"
 #include "compiler/osinclude.h"
 OS_TLSIndex PoolIndex = OS_INVALID_TLS_INDEX;
 bool InitializePoolIndex()
 {
     assert(PoolIndex == OS_INVALID_TLS_INDEX);
     PoolIndex = OS_AllocTLSIndex();
     return PoolIndex != OS_INVALID_TLS_INDEX;
 }
 void FreePoolIndex()
 {
     assert(PoolIndex != OS_INVALID_TLS_INDEX);
     OS_FreeTLSIndex(PoolIndex);
     PoolIndex = OS_INVALID_TLS_INDEX;
 }
 TPoolAllocator* GetGlobalPoolAllocator()
 {
     assert(PoolIndex != OS_INVALID_TLS_INDEX);
     return static_cast<TPoolAllocator*>(OS_GetTLSValue(PoolIndex));
 }
 void SetGlobalPoolAllocator(TPoolAllocator* poolAllocator)
 {
     assert(PoolIndex != OS_INVALID_TLS_INDEX);
     OS_SetTLSValue(PoolIndex, poolAllocator);
 }
 //
 // Implement the functionality of the TPoolAllocator class, which
 // is documented in PoolAlloc.h.
 //
 TPoolAllocator::TPoolAllocator(int growthIncrement, int allocationAlignment) :
     pageSize(growthIncrement),
     alignment(allocationAlignment),
     freeList(0),
     inUseList(0),
     numCalls(0),
     totalBytes(0)
 {
     //
     // Don't allow page sizes we know are smaller than all common
     // OS page sizes.
     //
     if (pageSize < 4*1024)
         pageSize = 4*1024;
     //
     // A large currentPageOffset indicates a new page needs to
     // be obtained to allocate memory.
     //
     currentPageOffset = pageSize;
     //
     // Adjust alignment to be at least pointer aligned and
     // power of 2.
     //
     size_t minAlign = sizeof(void*);
     alignment &= ~(minAlign - 1);
     if (alignment < minAlign)
         alignment = minAlign;
     size_t a = 1;
     while (a < alignment)
         a <<= 1;
     alignment = a;
     alignmentMask = a - 1;
     //
     // Align header skip
     //
     headerSkip = minAlign;
     if (headerSkip < sizeof(tHeader)) {
         headerSkip = (sizeof(tHeader) + alignmentMask) & ~alignmentMask;
     }
 }
 TPoolAllocator::~TPoolAllocator()
 {
     while (inUseList) {
         tHeader* next = inUseList->nextPage;
         inUseList->~tHeader();
         delete [] reinterpret_cast<char*>(inUseList);
         inUseList = next;
     }
     // We should not check the guard blocks
     // here, because we did it already when the block was
     // placed into the free list.
     //
     while (freeList) {
         tHeader* next = freeList->nextPage;
         delete [] reinterpret_cast<char*>(freeList);
         freeList = next;
     }
 }
 // Support MSVC++ 6.0
 const unsigned char TAllocation::guardBlockBeginVal = 0xfb;
 const unsigned char TAllocation::guardBlockEndVal   = 0xfe;
 const unsigned char TAllocation::userDataFill       = 0xcd;
 #ifdef GUARD_BLOCKS
     const size_t TAllocation::guardBlockSize = 16;
 #else
     const size_t TAllocation::guardBlockSize = 0;
 #endif
 //
 // Check a single guard block for damage
 //
 void TAllocation::checkGuardBlock(unsigned char* blockMem, unsigned char val, const char* locText) const
 {
 #ifdef GUARD_BLOCKS
     for (size_t x = 0; x < guardBlockSize; x++) {
         if (blockMem[x] != val) {
             char assertMsg[80];
             // We don't print the assert message.  It's here just to be helpful.
 #if defined(_MSC_VER)
             snprintf(assertMsg, sizeof(assertMsg), "PoolAlloc: Damage %s %Iu byte allocation at 0x%p\n",
                     locText, size, data());
 #else
             snprintf(assertMsg, sizeof(assertMsg), "PoolAlloc: Damage %s %zu byte allocation at 0x%p\n",
                     locText, size, data());
 #endif
             assert(0 && "PoolAlloc: Damage in guard block");
         }
     }
 #endif
 }
 void TPoolAllocator::push()
 {
     tAllocState state = { currentPageOffset, inUseList };
     stack.push_back(state);
     //
     // Indicate there is no current page to allocate from.
     //
     currentPageOffset = pageSize;
 }
 //
 // Do a mass-deallocation of all the individual allocations
 // that have occurred since the last push(), or since the
 // last pop(), or since the object's creation.
 //
 // The deallocated pages are saved for future allocations.
 //
 void TPoolAllocator::pop()
 {
     if (stack.size() < 1)
         return;
     tHeader* page = stack.back().page;
     currentPageOffset = stack.back().offset;
     while (inUseList != page) {
         // invoke destructor to free allocation list
         inUseList->~tHeader();
         tHeader* nextInUse = inUseList->nextPage;
         if (inUseList->pageCount > 1)
             delete [] reinterpret_cast<char*>(inUseList);
         else {
             inUseList->nextPage = freeList;
             freeList = inUseList;
         }
         inUseList = nextInUse;
     }
     stack.pop_back();
 }
 //
 // Do a mass-deallocation of all the individual allocations
 // that have occurred.
 //
 void TPoolAllocator::popAll()
 {
     while (stack.size() > 0)
         pop();
 }
 void* TPoolAllocator::allocate(size_t numBytes)
 {
     //
     // Just keep some interesting statistics.
     //
     ++numCalls;
     totalBytes += numBytes;
     // If we are using guard blocks, all allocations are bracketed by
     // them: [guardblock][allocation][guardblock].  numBytes is how
     // much memory the caller asked for.  allocationSize is the total
     // size including guard blocks.  In release build,
     // guardBlockSize=0 and this all gets optimized away.
     size_t allocationSize = TAllocation::allocationSize(numBytes);
     // Detect integer overflow.
     if (allocationSize < numBytes)
         return 0;
     //
     // Do the allocation, most likely case first, for efficiency.
     // This step could be moved to be inline sometime.
     //
     if (allocationSize <= pageSize - currentPageOffset) {
         //
         // Safe to allocate from currentPageOffset.
         //
         unsigned char* memory = reinterpret_cast<unsigned char *>(inUseList) + currentPageOffset;
         currentPageOffset += allocationSize;
         currentPageOffset = (currentPageOffset + alignmentMask) & ~alignmentMask;
         return initializeAllocation(inUseList, memory, numBytes);
     }
     if (allocationSize > pageSize - headerSkip) {
         //
         // Do a multi-page allocation.  Don't mix these with the others.
         // The OS is efficient and allocating and free-ing multiple pages.
         //
         size_t numBytesToAlloc = allocationSize + headerSkip;
         // Detect integer overflow.
         if (numBytesToAlloc < allocationSize)
             return 0;
         tHeader* memory = reinterpret_cast<tHeader*>(::new char[numBytesToAlloc]);
         if (memory == 0)
             return 0;
         // Use placement-new to initialize header
         new(memory) tHeader(inUseList, (numBytesToAlloc + pageSize - 1) / pageSize);
         inUseList = memory;
         currentPageOffset = pageSize;  // make next allocation come from a new page
         // No guard blocks for multi-page allocations (yet)
         return reinterpret_cast<void*>(reinterpret_cast<uintptr_t>(memory) + headerSkip);
     }
     //
     // Need a simple page to allocate from.
     //
     tHeader* memory;
     if (freeList) {
         memory = freeList;
         freeList = freeList->nextPage;
     } else {
         memory = reinterpret_cast<tHeader*>(::new char[pageSize]);
         if (memory == 0)
             return 0;
     }
     // Use placement-new to initialize header
     new(memory) tHeader(inUseList, 1);
     inUseList = memory;
     unsigned char* ret = reinterpret_cast<unsigned char *>(inUseList) + headerSkip;
     currentPageOffset = (headerSkip + allocationSize + alignmentMask) & ~alignmentMask;
     return initializeAllocation(inUseList, ret, numBytes);
 }
 //
 // Check all allocations in a list for damage by calling check on each.
 //
 void TAllocation::checkAllocList() const
 {
     for (const TAllocation* alloc = this; alloc != 0; alloc = alloc->prevAlloc)
         alloc->check();
 }

The Tor Browser / annotate

gfx/angle/src/compiler/PoolAlloc.cpp@141e0f1194b1 (annotated)

gfx/angle/src/compiler/PoolAlloc.cpp