sktext::gpu::BagOfBytes Class Reference

#include <SubRunAllocator.h>

Public Types
template<int size>
using	Storage = std::array< char, PlatformMinimumSizeWithOverhead(size, 1)>

Public Member Functions
	BagOfBytes (char *block, size_t blockSize, size_t firstHeapAllocation)
	BagOfBytes (size_t firstHeapAllocation=0)
	BagOfBytes (const BagOfBytes &)=delete
BagOfBytes &	operator= (const BagOfBytes &)=delete
	BagOfBytes (BagOfBytes &&that)
BagOfBytes &	operator= (BagOfBytes &&that)
	~BagOfBytes ()
template<typename T >
char *	allocateBytesFor (int n=1)
void *	alignedBytes (int unsafeSize, int unsafeAlignment)

Static Public Member Functions
static constexpr int	PlatformMinimumSizeWithOverhead (int requestedSize, int assumedAlignment)
static constexpr int	MinimumSizeWithOverhead (int requestedSize, int assumedAlignment, int blockSize, int maxAlignment)
template<typename T >
static bool	WillCountFit (int n)

Detailed Description

Definition at line 34 of file SubRunAllocator.h.

Member Typedef Documentation

Storage

template<int size>

using sktext::gpu::BagOfBytes::Storage = std::array<char, PlatformMinimumSizeWithOverhead(size, 1)>

Definition at line 98 of file SubRunAllocator.h.

Constructor & Destructor Documentation

BagOfBytes() [1/4]

sktext::gpu::BagOfBytes::BagOfBytes	(	char *	block,
		size_t	blockSize,
		size_t	firstHeapAllocation
	)

Definition at line 20 of file SubRunAllocator.cpp.

        : fFibProgression(size, firstHeapAllocation) {
    SkASSERT_RELEASE(size < kMaxByteSize);
    SkASSERT_RELEASE(firstHeapAllocation < kMaxByteSize);
 
    std::size_t space = size;
    void* ptr = bytes;
    if (bytes && std::align(kMaxAlignment, sizeof(Block), ptr, space)) {
        this->setupBytesAndCapacity(bytes, size);
        new (fEndByte) Block(nullptr, nullptr);
    }
}

BagOfBytes() [2/4]

sktext::gpu::BagOfBytes::BagOfBytes ( size_t  firstHeapAllocation = 0 )

explicit

Definition at line 33 of file SubRunAllocator.cpp.

        : BagOfBytes(nullptr, 0, firstHeapAllocation) {}

BagOfBytes() [3/4]

sktext::gpu::BagOfBytes::BagOfBytes ( const BagOfBytes &  )

delete

BagOfBytes() [4/4]

sktext::gpu::BagOfBytes::BagOfBytes ( BagOfBytes &&  that )

inline

Definition at line 40 of file SubRunAllocator.h.

            : fEndByte{std::exchange(that.fEndByte, nullptr)}
            , fCapacity{that.fCapacity}
            , fFibProgression{that.fFibProgression} {}

~BagOfBytes()

sktext::gpu::BagOfBytes::~BagOfBytes

(

)

Definition at line 36 of file SubRunAllocator.cpp.

                        {
    Block* cursor = reinterpret_cast<Block*>(fEndByte);
    while (cursor != nullptr) {
        char* toDelete = cursor->fBlockStart;
        cursor = cursor->fPrevious;
        delete [] toDelete;
    }
}

Member Function Documentation

alignedBytes()

void * sktext::gpu::BagOfBytes::alignedBytes	(	int	unsafeSize,
		int	unsafeAlignment
	)

Definition at line 49 of file SubRunAllocator.cpp.

                                                      {
    SkASSERT_RELEASE(0 < size && size < kMaxByteSize);
    SkASSERT_RELEASE(0 < alignment && alignment <= kMaxAlignment);
    SkASSERT_RELEASE(SkIsPow2(alignment));
 
    return this->allocateBytes(size, alignment);
}

allocateBytesFor()

template<typename T >

char * sktext::gpu::BagOfBytes::allocateBytesFor ( int  n = 1 )

inline

Definition at line 108 of file SubRunAllocator.h.

                                                            {
        static_assert(alignof(T) <= kMaxAlignment, "Alignment is too big for arena");
        static_assert(sizeof(T) < kMaxByteSize, "Size is too big for arena");
        SkASSERT_RELEASE(WillCountFit<T>(n));
 
        int size = n ? n * sizeof(T) : 1;
        return this->allocateBytes(size, alignof(T));
    }

MinimumSizeWithOverhead()

static constexpr int sktext::gpu::BagOfBytes::MinimumSizeWithOverhead ( int  requestedSize, int  assumedAlignment, int  blockSize, int  maxAlignment  )

inlinestaticconstexpr

Definition at line 59 of file SubRunAllocator.h.

                                                                                      {
        SkASSERT_RELEASE(0 <= requestedSize && requestedSize < kMaxByteSize);
        SkASSERT_RELEASE(SkIsPow2(assumedAlignment) && SkIsPow2(maxAlignment));
 
        const int minAlignment = std::min(maxAlignment, assumedAlignment);
        // There are two cases, one easy and one subtle. The easy case is when minAlignment ==
        // maxAlignment. When that happens, the term maxAlignment - minAlignment is zero, and the
        // block will be placed at the proper alignment because alignUp is properly
        // aligned.
        // The subtle case is where minAlignment < maxAlignment. Because
        // minAlignment < maxAlignment, alignUp(requestedSize, minAlignment) + blockSize does not
        // guarantee that block can be placed at a maxAlignment address. Block can be placed at
        // maxAlignment/minAlignment different address to achieve alignment, so we need
        // to add memory to allow the block to be placed on a maxAlignment address.
        // For example, if assumedAlignment = 4 and maxAlignment = 16 then block can be placed at
        // the following address offsets at the end of minimumSize bytes.
        //   0 * minAlignment =  0
        //   1 * minAlignment =  4
        //   2 * minAlignment =  8
        //   3 * minAlignment = 12
        // Following this logic, the equation for the additional bytes is
        //   (maxAlignment/minAlignment - 1) * minAlignment
        //     = maxAlignment - minAlignment.
        int minimumSize = SkToInt(AlignUp(requestedSize, minAlignment))
                          + blockSize
                          + maxAlignment - minAlignment;
 
        // If minimumSize is > 32k then round to a 4K boundary unless it is too close to the
        // maximum int. The > 32K heuristic is from the JEMalloc behavior.
        constexpr int k32K = (1 << 15);
        if (minimumSize >= k32K && minimumSize < std::numeric_limits<int>::max() - k4K) {
            minimumSize = SkToInt(AlignUp(minimumSize, k4K));
        }
 
        return minimumSize;
    }

operator=() [1/2]

BagOfBytes & sktext::gpu::BagOfBytes::operator= ( BagOfBytes &&  that )

inline

Definition at line 44 of file SubRunAllocator.h.

                                             {
        this->~BagOfBytes();
        new (this) BagOfBytes{std::move(that)};
        return *this;
    }

operator=() [2/2]

BagOfBytes & sktext::gpu::BagOfBytes::operator= ( const BagOfBytes &  )

delete

PlatformMinimumSizeWithOverhead()

static constexpr int sktext::gpu::BagOfBytes::PlatformMinimumSizeWithOverhead ( int  requestedSize, int  assumedAlignment  )

inlinestaticconstexpr

Definition at line 54 of file SubRunAllocator.h.

                                                                                                  {
        return MinimumSizeWithOverhead(
                requestedSize, assumedAlignment, sizeof(Block), kMaxAlignment);
    }

WillCountFit()

template<typename T >

static bool sktext::gpu::BagOfBytes::WillCountFit ( int  n )

inlinestatic

Definition at line 102 of file SubRunAllocator.h.

                                    {
        constexpr int kMaxN = kMaxByteSize / sizeof(T);
        return 0 <= n && n < kMaxN;
    }

---

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

• third_party/skia/src/text/gpu/SubRunAllocator.h
• third_party/skia/src/text/gpu/SubRunAllocator.cpp