SkBlockAllocator Class Reference

#include <SkBlockAllocator.h>

Inheritance diagram for SkBlockAllocator:

Classes
class	Block
class	BlockIter
struct	ByteRange

Public Types
enum class	GrowthPolicy : int {   kFixed , kLinear , kFibonacci , kExponential ,   kLast = kExponential }
enum	ReserveFlags : unsigned { kIgnoreGrowthPolicy_Flag = 0b01 , kIgnoreExistingBytes_Flag = 0b10 , kNo_ReserveFlags = 0b00 }

Public Member Functions
	SkBlockAllocator (GrowthPolicy policy, size_t blockIncrementBytes, size_t additionalPreallocBytes=0)
	~SkBlockAllocator ()
void	operator delete (void *p)
size_t	totalSize () const
size_t	totalUsableSpace () const
size_t	totalSpaceInUse () const
size_t	preallocSize () const
size_t	preallocUsableSpace () const
int	metadata () const
void	setMetadata (int value)
template<size_t Align, size_t Padding = 0>
ByteRange	allocate (size_t size)
template<size_t Align = 1, size_t Padding = 0>
void	reserve (size_t size, ReserveFlags flags=kNo_ReserveFlags)
const Block *	currentBlock () const
Block *	currentBlock ()
const Block *	headBlock () const
Block *	headBlock ()
template<size_t Align, size_t Padding = 0>
Block *	owningBlock (const void *ptr, int start)
template<size_t Align, size_t Padding = 0>
const Block *	owningBlock (const void *ptr, int start) const
Block *	findOwningBlock (const void *ptr)
const Block *	findOwningBlock (const void *ptr) const
void	releaseBlock (Block *block)
void	stealHeapBlocks (SkBlockAllocator *other)
void	reset ()
void	resetScratchSpace ()
BlockIter< true, false >	blocks ()
BlockIter< true, true >	blocks () const
BlockIter< false, false >	rblocks ()
BlockIter< false, true >	rblocks () const

Static Public Member Functions
template<size_t Align = 1, size_t Padding = 0>
static constexpr size_t	BlockOverhead ()
template<size_t Align = 1, size_t Padding = 0>
static constexpr size_t	Overhead ()

Static Public Attributes
static constexpr int	kMaxAllocationSize = 1 << 29
static constexpr int	kGrowthPolicyCount = static_cast<int>(GrowthPolicy::kLast) + 1

Friends
class	BlockAllocatorTestAccess
class	TBlockListTestAccess

Detailed Description

SkBlockAllocator provides low-level support for a block allocated arena with a dynamic tail that tracks space reservations within each block. Its APIs provide the ability to reserve space, resize reservations, and release reservations. It will automatically create new blocks if needed and destroy all remaining blocks when it is destructed. It assumes that anything allocated within its blocks has its destructors called externally. It is recommended that SkBlockAllocator is wrapped by a higher-level allocator that uses the low-level APIs to implement a simpler, purpose-focused API w/o having to worry as much about byte-level concerns.

SkBlockAllocator has no limit to its total size, but each allocation is limited to 512MB (which should be sufficient for Skia's use cases). This upper allocation limit allows all internal operations to be performed using 'int' and avoid many overflow checks. Static asserts are used to ensure that those operations would not overflow when using the largest possible values.

Possible use modes:

1. No upfront allocation, either on the stack or as a field SkBlockAllocator allocator(policy, heapAllocSize);
2. In-place new'd void* mem = operator new(totalSize); SkBlockAllocator* allocator = new (mem) SkBlockAllocator(policy, heapAllocSize, totalSize- sizeof(SkBlockAllocator)); delete allocator;
3. Use SkSBlockAllocator to increase the preallocation size SkSBlockAllocator<1024> allocator(policy, heapAllocSize); sizeof(allocator) == 1024;

Definition at line 56 of file SkBlockAllocator.h.

Member Enumeration Documentation

GrowthPolicy

enum class SkBlockAllocator::GrowthPolicy : int

strong

Enumerator
kFixed
kLinear
kFibonacci
kExponential
kLast

Definition at line 62 of file SkBlockAllocator.h.

                            : int {
        kFixed,       // Next block size = N
        kLinear,      //   = #blocks * N
        kFibonacci,   //   = fibonacci(#blocks) * N
        kExponential, //   = 2^#blocks * N
        kLast = kExponential
    };

ReserveFlags

enum SkBlockAllocator::ReserveFlags : unsigned

Enumerator
kIgnoreGrowthPolicy_Flag
kIgnoreExistingBytes_Flag
kNo_ReserveFlags

Definition at line 285 of file SkBlockAllocator.h.

                      : unsigned {
        // If provided to reserve(), the input 'size' will be rounded up to the next size determined
        // by the growth policy of the SkBlockAllocator. If not, 'size' will be aligned to max_align
        kIgnoreGrowthPolicy_Flag  = 0b01,
        // If provided to reserve(), the number of available bytes of the current block  will not
        // be used to satisfy the reservation (assuming the contiguous range was long enough to
        // begin with).
        kIgnoreExistingBytes_Flag = 0b10,
 
        kNo_ReserveFlags          = 0b00
    };

Constructor & Destructor Documentation

SkBlockAllocator()

SkBlockAllocator::SkBlockAllocator	(	GrowthPolicy	policy,
		size_t	blockIncrementBytes,
		size_t	additionalPreallocBytes = 0
	)

Definition at line 17 of file SkBlockAllocator.cpp.

        : fTail(&fHead)
        // Round up to the nearest max-aligned value, and then divide so that fBlockSizeIncrement
        // can effectively fit higher byte counts in its 16 bits of storage
        , fBlockIncrement(SkTo<uint16_t>(
                std::min(SkAlignTo(blockIncrementBytes, kAddressAlign) / kAddressAlign,
                         (size_t) std::numeric_limits<uint16_t>::max())))
        , fGrowthPolicy(static_cast<uint64_t>(policy))
        , fN0((policy == GrowthPolicy::kLinear || policy == GrowthPolicy::kExponential) ? 1 : 0)
        , fN1(1)
        // The head block always fills remaining space from SkBlockAllocator's size, because it's
        // inline, but can take over the specified number of bytes immediately after it.
        , fHead(/*prev=*/nullptr, additionalPreallocBytes + BaseHeadBlockSize()) {
    SkASSERT(fBlockIncrement >= 1);
    SkASSERT(additionalPreallocBytes <= kMaxAllocationSize);
}

~SkBlockAllocator()

SkBlockAllocator::~SkBlockAllocator ( )

inline

Definition at line 187 of file SkBlockAllocator.h.

{ this->reset(); }

Member Function Documentation

allocate()

template<size_t Align, size_t Padding>

SkBlockAllocator::ByteRange SkBlockAllocator::allocate

(

size_t

size

)

Reserve space that will hold 'size' bytes. This will automatically allocate a new block if there is not enough available space in the current block to provide 'size' bytes. The returned ByteRange tuple specifies the Block owning the reserved memory, the full byte range, and the aligned offset within that range to use for the user-facing pointer. The following invariants hold:

1. block->ptr(alignedOffset) is aligned to Align
2. end - alignedOffset == size
3. Padding <= alignedOffset - start <= Padding + Align - 1

Invariant #3, when Padding > 0, allows intermediate allocators to embed metadata along with the allocations. If the Padding bytes are used for some 'struct Meta', then ptr(alignedOffset - sizeof(Meta)) can be safely used as a Meta* if Meta's alignment requirements are less than or equal to the alignment specified in allocate<>. This can be easily guaranteed by using the pattern:

allocate<max(UserAlign, alignof(Meta)), sizeof(Meta)>(userSize);

This ensures that ptr(alignedOffset) will always satisfy UserAlign and ptr(alignedOffset - sizeof(Meta)) will always satisfy alignof(Meta). Alternatively, memcpy can be used to read and write values between start and alignedOffset without worrying about alignment requirements of the metadata.

For over-aligned allocations, the alignedOffset (as an int) may not be a multiple of Align, but the result of ptr(alignedOffset) will be a multiple of Align.

Definition at line 566 of file SkBlockAllocator.h.

                                                                {
    // Amount of extra space for a new block to make sure the allocation can succeed.
    static constexpr int kBlockOverhead = (int) BlockOverhead<Align, Padding>();
 
    // Ensures 'offset' and 'end' calculations will be valid
    static_assert((kMaxAllocationSize + SkAlignTo(MaxBlockSize<Align, Padding>(), Align))
                        <= (size_t) std::numeric_limits<int32_t>::max());
    // Ensures size + blockOverhead + addBlock's alignment operations will be valid
    static_assert(kMaxAllocationSize + kBlockOverhead + ((1 << 12) - 1) // 4K align for large blocks
                        <= std::numeric_limits<int32_t>::max());
 
    if (size > kMaxAllocationSize) {
        SK_ABORT("Allocation too large (%zu bytes requested)", size);
    }
 
    int iSize = (int) size;
    int offset = fTail->cursor<Align, Padding>();
    int end = offset + iSize;
    if (end > fTail->fSize) {
        this->addBlock(iSize + kBlockOverhead, MaxBlockSize<Align, Padding>());
        offset = fTail->cursor<Align, Padding>();
        end = offset + iSize;
    }
 
    // Check invariants
    SkASSERT(end <= fTail->fSize);
    SkASSERT(end - offset == iSize);
    SkASSERT(offset - fTail->fCursor >= (int) Padding &&
             offset - fTail->fCursor <= (int) (Padding + Align - 1));
    SkASSERT(reinterpret_cast<uintptr_t>(fTail->ptr(offset)) % Align == 0);
 
    int start = fTail->fCursor;
    fTail->fCursor = end;
 
    fTail->unpoisonRange(offset - Padding, end);
 
    return {fTail, start, offset, end};
}

BlockOverhead()

template<size_t Align, size_t Padding>

constexpr size_t SkBlockAllocator::BlockOverhead

staticconstexpr

Helper to calculate the minimum number of bytes needed for heap block size, under the assumption that Align will be the requested alignment of the first call to allocate(). Ex. To store N instances of T in a heap block, the 'blockIncrementBytes' should be set to BlockOverhead<alignof(T)>() + N * sizeof(T) when making the SkBlockAllocator.

Definition at line 521 of file SkBlockAllocator.h.

                                                 {
    static_assert(SkAlignTo(kDataStart + Padding, Align) >= sizeof(Block));
    return SkAlignTo(kDataStart + Padding, Align);
}

blocks() [1/2]

SkBlockAllocator::BlockIter< true, false > SkBlockAllocator::blocks ( )

inline

Clients can iterate over all active Blocks in the SkBlockAllocator using for loops:

Forward iteration from head to tail block (or non-const variant): for (const Block* b : this->blocks()) { } Reverse iteration from tail to head block: for (const Block* b : this->rblocks()) { }

It is safe to call releaseBlock() on the active block while looping.

Definition at line 741 of file SkBlockAllocator.h.

                                                                {
    return BlockIter<true, false>(this);
}

blocks() [2/2]

SkBlockAllocator::BlockIter< true, true > SkBlockAllocator::blocks ( ) const

inline

Definition at line 744 of file SkBlockAllocator.h.

                                                                     {
    return BlockIter<true, true>(this);
}

currentBlock() [1/2]

Block * SkBlockAllocator::currentBlock ( )

inline

Definition at line 316 of file SkBlockAllocator.h.

{ return fTail; }

currentBlock() [2/2]

const Block * SkBlockAllocator::currentBlock ( ) const

inline

Return a pointer to the start of the current block. This will never be null.

Definition at line 315 of file SkBlockAllocator.h.

{ return fTail; }

findOwningBlock() [1/2]

SkBlockAllocator::Block * SkBlockAllocator::findOwningBlock

(

const void *

ptr

)

Find the owning block of the allocated pointer, 'p'. Without any additional information this is O(N) on the number of allocated blocks.

Definition at line 86 of file SkBlockAllocator.cpp.

                                                                      {
    // When in doubt, search in reverse to find an overlapping block.
    uintptr_t ptr = reinterpret_cast<uintptr_t>(p);
    for (Block* b : this->rblocks()) {
        uintptr_t lowerBound = reinterpret_cast<uintptr_t>(b) + kDataStart;
        uintptr_t upperBound = reinterpret_cast<uintptr_t>(b) + b->fSize;
        if (lowerBound <= ptr && ptr < upperBound) {
            SkASSERT(b->fSentinel == kAssignedMarker);
            return b;
        }
    }
    return nullptr;
}

findOwningBlock() [2/2]

const Block * SkBlockAllocator::findOwningBlock ( const void *  ptr ) const

inline

Definition at line 346 of file SkBlockAllocator.h.

                                                        {
        return const_cast<SkBlockAllocator*>(this)->findOwningBlock(ptr);
    }

headBlock() [1/2]

Block * SkBlockAllocator::headBlock ( )

inline

Definition at line 319 of file SkBlockAllocator.h.

{ return &fHead; }

headBlock() [2/2]

const Block * SkBlockAllocator::headBlock ( ) const

inline

Definition at line 318 of file SkBlockAllocator.h.

{ return &fHead; }

metadata()

int SkBlockAllocator::metadata ( ) const

inline

Get the current value of the allocator-level metadata (a user-oriented slot). This is separate from any block-level metadata, but can serve a similar purpose to compactly support data collections on top of SkBlockAllocator.

Definition at line 248 of file SkBlockAllocator.h.

{ return fHead.fAllocatorMetadata; }

operator delete()

void SkBlockAllocator::operator delete ( void *  p )

inline

Definition at line 188 of file SkBlockAllocator.h.

{ ::operator delete(p); }

Overhead()

template<size_t Align, size_t Padding>

constexpr size_t SkBlockAllocator::Overhead

staticconstexpr

Helper to calculate the minimum number of bytes needed for a preallocation, under the assumption that Align will be the requested alignment of the first call to allocate(). Ex. To preallocate a SkSBlockAllocator to hold N instances of T, its arge should be Overhead<alignof(T)>() + N * sizeof(T)

Definition at line 527 of file SkBlockAllocator.h.

                                            {
    // NOTE: On most platforms, SkBlockAllocator is packed; this is not the case on debug builds
    // due to extra fields, or on WASM due to 4byte pointers but 16byte max align.
    return std::max(sizeof(SkBlockAllocator),
                    offsetof(SkBlockAllocator, fHead) + BlockOverhead<Align, Padding>());
}

owningBlock() [1/2]

template<size_t Align, size_t Padding>

SkBlockAllocator::Block * SkBlockAllocator::owningBlock	(	const void *	ptr,
		int	start
	)

Return the block that owns the allocated 'ptr'. Assuming that earlier, an allocation was returned as {b, start, alignedOffset, end}, and 'p = b->ptr(alignedOffset)', then a call to 'owningBlock<Align, Padding>(p, start) == b'.

If calling code has already made a pointer to their metadata, i.e. 'm = p - Padding', then 'owningBlock<Align, 0>(m, start)' will also return b, allowing you to recover the block from the metadata pointer.

If calling code has access to the original alignedOffset, this function should not be used since the owning block is just 'p - alignedOffset', regardless of original Align or Padding.

Definition at line 606 of file SkBlockAllocator.h.

                                                                             {
    // 'p' was originally formed by aligning 'block + start + Padding', producing the inequality:
    //     block + start + Padding <= p <= block + start + Padding + Align-1
    // Rearranging this yields:
    //     block <= p - start - Padding <= block + Align-1
    // Masking these terms by ~(Align-1) reconstructs 'block' if the alignment of the block is
    // greater than or equal to Align (since block & ~(Align-1) == (block + Align-1) & ~(Align-1)
    // in that case). Overalignment does not reduce to inequality unfortunately.
    if /* constexpr */ (Align <= kAddressAlign) {
        Block* block = reinterpret_cast<Block*>(
                (reinterpret_cast<uintptr_t>(p) - start - Padding) & ~(Align - 1));
        SkASSERT(block->fSentinel == kAssignedMarker);
        return block;
    } else {
        // There's not a constant-time expression available to reconstruct the block from 'p',
        // but this is unlikely to happen frequently.
        return this->findOwningBlock(p);
    }
}

owningBlock() [2/2]

template<size_t Align, size_t Padding = 0>

const Block * SkBlockAllocator::owningBlock ( const void *  ptr, int  start  ) const

inline

Definition at line 337 of file SkBlockAllocator.h.

                                                               {
        return const_cast<SkBlockAllocator*>(this)->owningBlock<Align, Padding>(ptr, start);
    }

preallocSize()

size_t SkBlockAllocator::preallocSize ( ) const

inline

Return the total number of bytes that were pre-allocated for the SkBlockAllocator. This will include 'additionalPreallocBytes' passed to the constructor, and represents what the total size would become after a call to reset().

Definition at line 230 of file SkBlockAllocator.h.

                                {
        // Don't double count fHead's Block overhead in both sizeof(SkBlockAllocator) and fSize.
        return sizeof(SkBlockAllocator) + fHead.fSize - BaseHeadBlockSize();
    }

preallocUsableSpace()

size_t SkBlockAllocator::preallocUsableSpace ( ) const

inline

Return the usable size of the inline head block; this will be equal to 'additionalPreallocBytes' plus any alignment padding that the system had to add to Block. The returned value represents what could be allocated before a heap block is be created.

Definition at line 239 of file SkBlockAllocator.h.

                                       {
        return fHead.fSize - kDataStart;
    }

rblocks() [1/2]

SkBlockAllocator::BlockIter< false, false > SkBlockAllocator::rblocks ( )

inline

Definition at line 747 of file SkBlockAllocator.h.

                                                                  {
    return BlockIter<false, false>(this);
}

rblocks() [2/2]

SkBlockAllocator::BlockIter< false, true > SkBlockAllocator::rblocks ( ) const

inline

Definition at line 750 of file SkBlockAllocator.h.

                                                                       {
    return BlockIter<false, true>(this);
}

releaseBlock()

void SkBlockAllocator::releaseBlock

(

Block *

block

)

Explicitly free an entire block, invalidating any remaining allocations from the block. SkBlockAllocator will release all alive blocks automatically when it is destroyed, but this function can be used to reclaim memory over the lifetime of the allocator. The provided 'block' pointer must have previously come from a call to currentBlock() or allocate().

If 'block' represents the inline-allocated head block, its cursor and metadata are instead reset to their defaults.

If the block is not the head block, it may be kept as a scratch block to be reused for subsequent allocation requests, instead of making an entirely new block. A scratch block is not visible when iterating over blocks but is reported in the total size of the allocator.

Definition at line 100 of file SkBlockAllocator.cpp.

                                                {
     if (block == &fHead) {
        // Reset the cursor of the head block so that it can be reused if it becomes the new tail
        block->fCursor = kDataStart;
        block->fMetadata = 0;
        block->poisonRange(kDataStart, block->fSize);
        // Unlike in reset(), we don't set the head's next block to null because there are
        // potentially heap-allocated blocks that are still connected to it.
    } else {
        SkASSERT(block->fPrev);
        block->fPrev->fNext = block->fNext;
        if (block->fNext) {
            SkASSERT(fTail != block);
            block->fNext->fPrev = block->fPrev;
        } else {
            SkASSERT(fTail == block);
            fTail = block->fPrev;
        }
 
        // The released block becomes the new scratch block (if it's bigger), or delete it
        if (this->scratchBlockSize() < block->fSize) {
            SkASSERT(block != fHead.fPrev); // shouldn't already be the scratch block
            if (fHead.fPrev) {
                delete fHead.fPrev;
            }
            block->markAsScratch();
            fHead.fPrev = block;
        } else {
            delete block;
        }
    }
 
    // Decrement growth policy (opposite of addBlock()'s increment operations)
    GrowthPolicy gp = static_cast<GrowthPolicy>(fGrowthPolicy);
    if (fN0 > 0 && (fN1 > 1 || gp == GrowthPolicy::kFibonacci)) {
        SkASSERT(gp != GrowthPolicy::kFixed); // fixed never needs undoing, fN0 always is 0
        if (gp == GrowthPolicy::kLinear) {
            fN1 = fN1 - fN0;
        } else if (gp == GrowthPolicy::kFibonacci) {
            // Subtract n0 from n1 to get the prior 2 terms in the fibonacci sequence
            int temp = fN1 - fN0; // yields prior fN0
            fN1 = fN1 - temp;     // yields prior fN1
            fN0 = temp;
        } else {
            SkASSERT(gp == GrowthPolicy::kExponential);
            // Divide by 2 to undo the 2N update from addBlock
            fN1 = fN1 >> 1;
            fN0 = fN1;
        }
    }
 
    SkASSERT(fN1 >= 1 && fN0 >= 0);
}

reserve()

template<size_t Align, size_t Padding>

void SkBlockAllocator::reserve	(	size_t	size,
		ReserveFlags	flags = kNo_ReserveFlags
	)

Ensure the block allocator has 'size' contiguous available bytes. After calling this function, currentBlock()->avail<Align, Padding>() may still report less than 'size' if the reserved space was added as a scratch block. This is done so that anything remaining in the current block can still be used if a smaller-than-size allocation is requested. If 'size' is requested by a subsequent allocation, the scratch block will automatically be activated and the request will not itself trigger any malloc.

The optional 'flags' controls how the input size is allocated; by default it will attempt to use available contiguous bytes in the current block and will respect the growth policy of the allocator.

Definition at line 543 of file SkBlockAllocator.h.

                                                              {
    if (size > kMaxAllocationSize) {
        SK_ABORT("Allocation too large (%zu bytes requested)", size);
    }
    int iSize = (int) size;
    if ((flags & kIgnoreExistingBytes_Flag) ||
        this->currentBlock()->avail<Align, Padding>() < iSize) {
 
        int blockSize = BlockOverhead<Align, Padding>() + iSize;
        int maxSize = (flags & kIgnoreGrowthPolicy_Flag) ? blockSize
                                                         : MaxBlockSize<Align, Padding>();
        SkASSERT((size_t) maxSize <= (MaxBlockSize<Align, Padding>()));
 
        SkDEBUGCODE(auto oldTail = fTail;)
        this->addBlock(blockSize, maxSize);
        SkASSERT(fTail != oldTail);
        // Releasing the just added block will move it into scratch space, allowing the original
        // tail's bytes to be used first before the scratch block is activated.
        this->releaseBlock(fTail);
    }
}

reset()

void SkBlockAllocator::reset

(

)

Explicitly free all blocks (invalidating all allocations), and resets the head block to its default state. The allocator-level metadata is reset to 0 as well.

Definition at line 169 of file SkBlockAllocator.cpp.

                             {
    for (Block* b : this->rblocks()) {
        if (b == &fHead) {
            // Reset metadata and cursor, tail points to the head block again
            fTail = b;
            b->fNext = nullptr;
            b->fCursor = kDataStart;
            b->fMetadata = 0;
            // For reset(), but NOT releaseBlock(), the head allocatorMetadata and scratch block
            // are reset/destroyed.
            b->fAllocatorMetadata = 0;
            b->poisonRange(kDataStart, b->fSize);
            this->resetScratchSpace();
        } else {
            delete b;
        }
    }
    SkASSERT(fTail == &fHead && fHead.fNext == nullptr && fHead.fPrev == nullptr &&
             fHead.metadata() == 0 && fHead.fCursor == kDataStart);
 
    GrowthPolicy gp = static_cast<GrowthPolicy>(fGrowthPolicy);
    fN0 = (gp == GrowthPolicy::kLinear || gp == GrowthPolicy::kExponential) ? 1 : 0;
    fN1 = 1;
}

resetScratchSpace()

void SkBlockAllocator::resetScratchSpace

(

)

Remove any reserved scratch space, either from calling reserve() or releaseBlock().

Definition at line 194 of file SkBlockAllocator.cpp.

                                         {
    if (fHead.fPrev) {
        delete fHead.fPrev;
        fHead.fPrev = nullptr;
    }
}

setMetadata()

void SkBlockAllocator::setMetadata ( int  value )

inline

Set the current value of the allocator-level metadata.

Definition at line 253 of file SkBlockAllocator.h.

{ fHead.fAllocatorMetadata = value; }

stealHeapBlocks()

void SkBlockAllocator::stealHeapBlocks

(

SkBlockAllocator *

other

)

Detach every heap-allocated block owned by 'other' and concatenate them to this allocator's list of blocks. This memory is now managed by this allocator. Since this only transfers ownership of a Block, and a Block itself does not move, any previous allocations remain valid and associated with their original Block instances. SkBlockAllocator-level functions that accept allocated pointers (e.g. findOwningBlock), must now use this allocator and not 'other' for these allocations.

The head block of 'other' cannot be stolen, so higher-level allocators and memory structures must handle that data differently.

Definition at line 154 of file SkBlockAllocator.cpp.

                                                              {
    Block* toSteal = other->fHead.fNext;
    if (toSteal) {
        // The other's next block connects back to this allocator's current tail, and its new tail
        // becomes the end of other's block linked list.
        SkASSERT(other->fTail != &other->fHead);
        toSteal->fPrev = fTail;
        fTail->fNext = toSteal;
        fTail = other->fTail;
        // The other allocator becomes just its inline head block
        other->fTail = &other->fHead;
        other->fHead.fNext = nullptr;
    } // else no block to steal
}

totalSize()

size_t SkBlockAllocator::totalSize

(

)

const

Return the total number of bytes of the allocator, including its instance overhead, per-block overhead and space used for allocations.

Definition at line 55 of file SkBlockAllocator.cpp.

                                         {
    // Use size_t since the sum across all blocks could exceed 'int', even though each block won't
    size_t size = offsetof(SkBlockAllocator, fHead) + this->scratchBlockSize();
    for (const Block* b : this->blocks()) {
        size += b->fSize;
    }
    SkASSERT(size >= this->preallocSize());
    return size;
}

totalSpaceInUse()

size_t SkBlockAllocator::totalSpaceInUse

(

)

const

Return the total number of usable bytes that have been reserved by allocations. This will be less than or equal to totalUsableSpace().

Definition at line 77 of file SkBlockAllocator.cpp.

                                               {
    size_t size = 0;
    for (const Block* b : this->blocks()) {
        size += (b->fCursor - kDataStart);
    }
    SkASSERT(size <= this->totalUsableSpace());
    return size;
}

totalUsableSpace()

size_t SkBlockAllocator::totalUsableSpace

(

)

const

Return the total number of bytes usable for allocations. This includes bytes that have been reserved already by a call to allocate() and bytes that are still available. It is totalSize() minus all allocator and block-level overhead.

Definition at line 65 of file SkBlockAllocator.cpp.

                                                {
    size_t size = this->scratchBlockSize();
    if (size > 0) {
        size -= kDataStart; // scratchBlockSize reports total block size, not usable size
    }
    for (const Block* b : this->blocks()) {
        size += (b->fSize - kDataStart);
    }
    SkASSERT(size >= this->preallocUsableSpace());
    return size;
}

Friends And Related Function Documentation

BlockAllocatorTestAccess

friend class BlockAllocatorTestAccess

friend

Definition at line 414 of file SkBlockAllocator.h.

TBlockListTestAccess

friend class TBlockListTestAccess

friend

Definition at line 415 of file SkBlockAllocator.h.

Member Data Documentation

kGrowthPolicyCount

constexpr int SkBlockAllocator::kGrowthPolicyCount = static_cast<int>(GrowthPolicy::kLast) + 1

inlinestaticconstexpr

Definition at line 69 of file SkBlockAllocator.h.

kMaxAllocationSize

constexpr int SkBlockAllocator::kMaxAllocationSize = 1 << 29

inlinestaticconstexpr

Definition at line 60 of file SkBlockAllocator.h.

---

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

• third_party/skia/src/base/SkBlockAllocator.h
• third_party/skia/src/base/SkBlockAllocator.cpp