sktext::gpu::SubRunAllocator Class Reference

#include <SubRunAllocator.h>

Inheritance diagram for sktext::gpu::SubRunAllocator:

Classes
struct	ArrayDestroyer
struct	Destroyer

Public Member Functions
	SubRunAllocator (char *block, int blockSize, int firstHeapAllocation)
	SubRunAllocator (int firstHeapAllocation=0)
	SubRunAllocator (const SubRunAllocator &)=delete
SubRunAllocator &	operator= (const SubRunAllocator &)=delete
	SubRunAllocator (SubRunAllocator &&)=default
SubRunAllocator &	operator= (SubRunAllocator &&)=default
template<typename T , typename... Args>
T *	makePOD (Args &&... args)
template<typename T , typename... Args>
std::unique_ptr< T, Destroyer >	makeUnique (Args &&... args)
template<typename T >
T *	makePODArray (int n)
template<typename T >
SkSpan< T >	makePODSpan (SkSpan< const T > s)
template<typename T , typename Src , typename Map >
SkSpan< T >	makePODArray (const Src &src, Map map)
template<typename T >
std::unique_ptr< T[], ArrayDestroyer >	makeUniqueArray (int n)
template<typename T , typename I >
std::unique_ptr< T[], ArrayDestroyer >	makeUniqueArray (int n, I initializer)
template<typename T , typename U , typename Map >
std::unique_ptr< T[], ArrayDestroyer >	makeUniqueArray (SkSpan< const U > src, Map map)
void *	alignedBytes (int size, int alignment)

Static Public Member Functions
template<typename T >
static std::tuple< SubRunInitializer< T >, int, SubRunAllocator >	AllocateClassMemoryAndArena (int allocSizeHint)

Static Public Attributes
template<class T >
static constexpr bool	HasNoDestructor = std::is_trivially_destructible<T>::value

Detailed Description

Definition at line 208 of file SubRunAllocator.h.

Constructor & Destructor Documentation

SubRunAllocator() [1/4]

sktext::gpu::SubRunAllocator::SubRunAllocator	(	char *	block,
		int	blockSize,
		int	firstHeapAllocation
	)

Definition at line 83 of file SubRunAllocator.cpp.

        : fAlloc{bytes, SkTo<size_t>(size), SkTo<size_t>(firstHeapAllocation)} {
    SkASSERT_RELEASE(SkTFitsIn<size_t>(size));
    SkASSERT_RELEASE(SkTFitsIn<size_t>(firstHeapAllocation));
}

SubRunAllocator() [2/4]

sktext::gpu::SubRunAllocator::SubRunAllocator ( int  firstHeapAllocation = 0 )

explicit

Definition at line 89 of file SubRunAllocator.cpp.

        : SubRunAllocator(nullptr, 0, firstHeapAllocation) { }

SubRunAllocator() [3/4]

sktext::gpu::SubRunAllocator::SubRunAllocator ( const SubRunAllocator &  )

delete

SubRunAllocator() [4/4]

sktext::gpu::SubRunAllocator::SubRunAllocator ( SubRunAllocator &&  )

default

Member Function Documentation

alignedBytes()

void * sktext::gpu::SubRunAllocator::alignedBytes	(	int	size,
		int	alignment
	)

Definition at line 92 of file SubRunAllocator.cpp.

                                                                       {
    return fAlloc.alignedBytes(unsafeSize, unsafeAlignment);
}

AllocateClassMemoryAndArena()

template<typename T >

static std::tuple< SubRunInitializer< T >, int, SubRunAllocator > sktext::gpu::SubRunAllocator::AllocateClassMemoryAndArena ( int  allocSizeHint )

inlinestatic

Definition at line 235 of file SubRunAllocator.h.

                                                   {
        SkASSERT_RELEASE(allocSizeHint >= 0);
        // Round the size after the object the optimal amount.
        int extraSize = BagOfBytes::PlatformMinimumSizeWithOverhead(allocSizeHint, alignof(T));
 
        // Don't overflow or die.
        SkASSERT_RELEASE(INT_MAX - SkTo<int>(sizeof(T)) > extraSize);
        int totalMemorySize = sizeof(T) + extraSize;
 
        void* memory = ::operator new (totalMemorySize);
        SubRunAllocator alloc{SkTAddOffset<char>(memory, sizeof(T)), extraSize, extraSize/2};
        return {memory, totalMemorySize, std::move(alloc)};
    }

makePOD()

template<typename T , typename... Args>

T * sktext::gpu::SubRunAllocator::makePOD ( Args &&...  args )

inline

Definition at line 249 of file SubRunAllocator.h.

                                                                       {
        static_assert(HasNoDestructor<T>, "This is not POD. Use makeUnique.");
        char* bytes = fAlloc.template allocateBytesFor<T>();
        return new (bytes) T(std::forward<Args>(args)...);
    }

makePODArray() [1/2]

template<typename T , typename Src , typename Map >

SkSpan< T > sktext::gpu::SubRunAllocator::makePODArray ( const Src &  src, Map  map  )

inline

Definition at line 280 of file SubRunAllocator.h.

                                                    {
        static_assert(HasNoDestructor<T>, "This is not POD. Use makeUniqueArray.");
        int size = SkTo<int>(src.size());
        T* result = this->template makePODArray<T>(size);
        for (int i = 0; i < size; i++) {
            new (&result[i]) T(map(src[i]));
        }
        return {result, src.size()};
    }

makePODArray() [2/2]

template<typename T >

T * sktext::gpu::SubRunAllocator::makePODArray ( int  n )

inline

Definition at line 262 of file SubRunAllocator.h.

                                                {
        static_assert(HasNoDestructor<T>, "This is not POD. Use makeUniqueArray.");
        return reinterpret_cast<T*>(fAlloc.template allocateBytesFor<T>(n));
    }

makePODSpan()

template<typename T >

SkSpan< T > sktext::gpu::SubRunAllocator::makePODSpan ( SkSpan< const T >  s )

inline

Definition at line 268 of file SubRunAllocator.h.

                                             {
        static_assert(HasNoDestructor<T>, "This is not POD. Use makeUniqueArray.");
        if (s.empty()) {
            return SkSpan<T>{};
        }
 
        T* result = this->makePODArray<T>(SkTo<int>(s.size()));
        memcpy(result, s.data(), s.size_bytes());
        return {result, s.size()};
    }

makeUnique()

template<typename T , typename... Args>

std::unique_ptr< T, Destroyer > sktext::gpu::SubRunAllocator::makeUnique ( Args &&...  args )

inline

Definition at line 256 of file SubRunAllocator.h.

                                                           {
        static_assert(!HasNoDestructor<T>, "This is POD. Use makePOD.");
        char* bytes = fAlloc.template allocateBytesFor<T>();
        return std::unique_ptr<T, Destroyer>{new (bytes) T(std::forward<Args>(args)...)};
    }

makeUniqueArray() [1/3]

template<typename T >

std::unique_ptr< T[], ArrayDestroyer > sktext::gpu::SubRunAllocator::makeUniqueArray ( int  n )

inline

Definition at line 291 of file SubRunAllocator.h.

                                                              {
        static_assert(!HasNoDestructor<T>, "This is POD. Use makePODArray.");
        T* array = reinterpret_cast<T*>(fAlloc.template allocateBytesFor<T>(n));
        for (int i = 0; i < n; i++) {
            new (&array[i]) T{};
        }
        return std::unique_ptr<T[], ArrayDestroyer>{array, ArrayDestroyer{n}};
    }

makeUniqueArray() [2/3]

template<typename T , typename I >

std::unique_ptr< T[], ArrayDestroyer > sktext::gpu::SubRunAllocator::makeUniqueArray ( int  n, I  initializer  )

inline

Definition at line 301 of file SubRunAllocator.h.

                                                                             {
        static_assert(!HasNoDestructor<T>, "This is POD. Use makePODArray.");
        T* array = reinterpret_cast<T*>(fAlloc.template allocateBytesFor<T>(n));
        for (int i = 0; i < n; i++) {
            new (&array[i]) T(initializer(i));
        }
        return std::unique_ptr<T[], ArrayDestroyer>{array, ArrayDestroyer{n}};
    }

makeUniqueArray() [3/3]

template<typename T , typename U , typename Map >

std::unique_ptr< T[], ArrayDestroyer > sktext::gpu::SubRunAllocator::makeUniqueArray ( SkSpan< const U >  src, Map  map  )

inline

Definition at line 311 of file SubRunAllocator.h.

                                                                                     {
        static_assert(!HasNoDestructor<T>, "This is POD. Use makePODArray.");
        int count = SkCount(src);
        T* array = reinterpret_cast<T*>(fAlloc.template allocateBytesFor<T>(src.size()));
        for (int i = 0; i < count; ++i) {
            new (&array[i]) T(map(src[i]));
        }
        return std::unique_ptr<T[], ArrayDestroyer>{array, ArrayDestroyer{count}};
    }

operator=() [1/2]

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

delete

operator=() [2/2]

SubRunAllocator & sktext::gpu::SubRunAllocator::operator= ( SubRunAllocator &&  )

default

Member Data Documentation

HasNoDestructor

template<class T >

constexpr bool sktext::gpu::SubRunAllocator::HasNoDestructor = std::is_trivially_destructible<T>::value

inlinestaticconstexpr

Definition at line 224 of file SubRunAllocator.h.

---

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