GrMemoryPool Class Reference

#include <GrMemoryPool.h>

Public Member Functions
	~GrMemoryPool ()
void	operator delete (void *p)
void *	allocate (size_t size)
void	release (void *p)
bool	isEmpty () const
void	reportLeaks () const
size_t	size () const
size_t	preallocSize () const
void	resetScratchSpace ()

Static Public Member Functions
static std::unique_ptr< GrMemoryPool >	Make (size_t preallocSize, size_t minAllocSize)

Static Public Attributes
static constexpr size_t	kAlignment = alignof(std::max_align_t)
static constexpr size_t	kMinAllocationSize = 1 << 10

Detailed Description

Allocates memory in blocks and parcels out space in the blocks for allocation requests. It is optimized for allocate / release speed over memory efficiency. The interface is designed to be used to implement operator new and delete overrides. All allocations are expected to be released before the pool's destructor is called. Allocations will be aligned to sizeof(std::max_align_t).

All allocated objects must be released back to the memory pool before it can be destroyed.

Definition at line 31 of file GrMemoryPool.h.

Constructor & Destructor Documentation

~GrMemoryPool()

GrMemoryPool::~GrMemoryPool

(

)

Definition at line 43 of file GrMemoryPool.cpp.

                            {
    this->reportLeaks();
    SkASSERT(0 == fDebug->fAllocationCount);
    SkASSERT(this->isEmpty());
    SkDEBUGCODE(delete fDebug;)
}

Member Function Documentation

allocate()

void * GrMemoryPool::allocate

(

size_t

size

)

Allocates memory. The memory must be freed with release() before the GrMemoryPool is deleted.

Definition at line 67 of file GrMemoryPool.cpp.

                                        {
    static_assert(alignof(Header) <= kAlignment);
    SkDEBUGCODE(this->validate();)
 
    SkBlockAllocator::ByteRange alloc = fAllocator.allocate<kAlignment, sizeof(Header)>(size);
 
    // Initialize GrMemoryPool's custom header at the start of the allocation
    Header* header = static_cast<Header*>(alloc.fBlock->ptr(alloc.fAlignedOffset - sizeof(Header)));
    header->fStart = alloc.fStart;
    header->fEnd = alloc.fEnd;
 
    // Update live count within the block
    alloc.fBlock->setMetadata(alloc.fBlock->metadata() + 1);
 
#if defined(SK_SANITIZE_ADDRESS)
    sk_asan_poison_memory_region(&header->fSentinel, sizeof(header->fSentinel));
#elif defined(SK_DEBUG)
    header->fSentinel = SkBlockAllocator::kAssignedMarker;
#endif
 
#if defined(SK_DEBUG)
    header->fID = []{
        static std::atomic<int> nextID{1};
        return nextID.fetch_add(1, std::memory_order_relaxed);
    }();
 
    // You can set a breakpoint here when a leaked ID is allocated to see the stack frame.
    fDebug->fAllocatedIDs.add(header->fID);
    fDebug->fAllocationCount++;
#endif
 
    // User-facing pointer is after the header padding
    return alloc.fBlock->ptr(alloc.fAlignedOffset);
}

isEmpty()

bool GrMemoryPool::isEmpty ( ) const

inline

Returns true if there are no unreleased allocations.

Definition at line 73 of file GrMemoryPool.h.

                         {
        // If size is the same as preallocSize, there aren't any heap blocks, so currentBlock()
        // is the inline head block.
        return fAllocator.currentBlock() == fAllocator.headBlock() &&
               fAllocator.currentBlock()->metadata() == 0;
    }

Make()

std::unique_ptr< GrMemoryPool > GrMemoryPool::Make ( size_t  preallocSize, size_t  minAllocSize  )

static

Prealloc size is the amount of space to allocate at pool creation time and keep around until pool destruction. The min alloc size is the smallest allowed size of additional allocations. Both sizes are adjusted to ensure that they are at least as large as kMinAllocationSize and less than SkBlockAllocator::kMaxAllocationSize.

Both sizes are what the pool will end up allocating from the system, and portions of the allocated memory is used for internal bookkeeping.

Definition at line 23 of file GrMemoryPool.cpp.

                                                                                       {
    static_assert(sizeof(GrMemoryPool) < GrMemoryPool::kMinAllocationSize);
 
    preallocSize = SkTPin(preallocSize, kMinAllocationSize,
                          (size_t) SkBlockAllocator::kMaxAllocationSize);
    minAllocSize = SkTPin(minAllocSize, kMinAllocationSize,
                          (size_t) SkBlockAllocator::kMaxAllocationSize);
    void* mem = operator new(preallocSize);
    return std::unique_ptr<GrMemoryPool>(new (mem) GrMemoryPool(preallocSize, minAllocSize));
}

operator delete()

void GrMemoryPool::operator delete ( void *  p )

inline

Definition at line 59 of file GrMemoryPool.h.

{ ::operator delete(p); }

preallocSize()

size_t GrMemoryPool::preallocSize ( ) const

inline

Returns the preallocated size of the GrMemoryPool

Definition at line 95 of file GrMemoryPool.h.

                                {
        // Account for the debug-only fields in this count, the offset is 0 for release builds
        static_assert(std::is_standard_layout<GrMemoryPool>::value, "");
        return offsetof(GrMemoryPool, fAllocator) + fAllocator.preallocSize();
    }

release()

void GrMemoryPool::release

(

void *

p

)

p must have been returned by allocate().

Definition at line 102 of file GrMemoryPool.cpp.

                                  {
    Header* header = reinterpret_cast<Header*>(reinterpret_cast<intptr_t>(p) - sizeof(Header));
 
#if defined(SK_SANITIZE_ADDRESS)
    sk_asan_unpoison_memory_region(&header->fSentinel, sizeof(header->fSentinel));
#elif defined(SK_DEBUG)
    SkASSERT(SkBlockAllocator::kAssignedMarker == header->fSentinel);
    header->fSentinel = SkBlockAllocator::kFreedMarker;
#endif
 
#if defined(SK_DEBUG)
    fDebug->fAllocatedIDs.remove(header->fID);
    fDebug->fAllocationCount--;
#endif
 
    SkBlockAllocator::Block* block = fAllocator.owningBlock<kAlignment>(header, header->fStart);
 
#if defined(SK_DEBUG)
    // (p - block) matches the original alignedOffset value from SkBlockAllocator::allocate().
    intptr_t alignedOffset = (intptr_t)p - (intptr_t)block;
    SkASSERT(p == block->ptr(alignedOffset));
 
    // Scrub the block contents to prevent use-after-free errors.
    memset(p, 0xDD, header->fEnd - alignedOffset);
#endif
 
    int alive = block->metadata();
    if (alive == 1) {
        // This was last allocation in the block, so remove it
        fAllocator.releaseBlock(block);
    } else {
        // Update count and release storage of the allocation itself
        block->setMetadata(alive - 1);
        block->release(header->fStart, header->fEnd);
    }
}

reportLeaks()

void GrMemoryPool::reportLeaks

(

)

const

In debug mode, this reports the IDs of unfreed nodes via SkDebugf. This reporting is also performed automatically whenever a GrMemoryPool is destroyed. In release mode, this method is a no-op.

Definition at line 50 of file GrMemoryPool.cpp.

                                     {
#ifdef SK_DEBUG
    int i = 0;
    int n = fDebug->fAllocatedIDs.count();
    for (int id : fDebug->fAllocatedIDs) {
        if (++i == 1) {
            SkDebugf("Leaked %d IDs (in no particular order): %d%s", n, id, (n == i) ? "\n" : "");
        } else if (i < 11) {
            SkDebugf(", %d%s", id, (n == i ? "\n" : ""));
        } else if (i == 11) {
            SkDebugf(", ...\n");
            break;
        }
    }
#endif
}

resetScratchSpace()

void GrMemoryPool::resetScratchSpace ( )

inline

Frees any scratch blocks that are no longer being used.

Definition at line 104 of file GrMemoryPool.h.

                             {
        fAllocator.resetScratchSpace();
    }

size()

size_t GrMemoryPool::size ( ) const

inline

Returns the total allocated size of the GrMemoryPool minus any preallocated amount

Definition at line 90 of file GrMemoryPool.h.

{ return fAllocator.totalSize() - fAllocator.preallocSize(); }

Member Data Documentation

kAlignment

constexpr size_t GrMemoryPool::kAlignment = alignof(std::max_align_t)

staticconstexpr

Definition at line 40 of file GrMemoryPool.h.

kMinAllocationSize

constexpr size_t GrMemoryPool::kMinAllocationSize = 1 << 10

inlinestaticconstexpr

Definition at line 44 of file GrMemoryPool.h.

---

The documentation for this class was generated from the following files:

• third_party/skia/src/gpu/ganesh/GrMemoryPool.h
• third_party/skia/src/gpu/ganesh/GrMemoryPool.cpp