SkArenaAlloc Class Reference

#include <SkArenaAlloc.h>

Inheritance diagram for SkArenaAlloc:

Classes
struct	Footer

Public Member Functions
	SkArenaAlloc (char *block, size_t blockSize, size_t firstHeapAllocation)
	SkArenaAlloc (size_t firstHeapAllocation)
	SkArenaAlloc (const SkArenaAlloc &)=delete
SkArenaAlloc &	operator= (const SkArenaAlloc &)=delete
	SkArenaAlloc (SkArenaAlloc &&)=delete
SkArenaAlloc &	operator= (SkArenaAlloc &&)=delete
	~SkArenaAlloc ()
template<typename Ctor >
auto	make (Ctor &&ctor) -> decltype(ctor(nullptr))
template<typename T , typename... Args>
T *	make (Args &&... args)
template<typename T >
T *	make ()
template<typename T >
T *	makeArrayDefault (size_t count)
template<typename T >
T *	makeArray (size_t count)
template<typename T , typename Initializer >
T *	makeInitializedArray (size_t count, Initializer initializer)
void *	makeBytesAlignedTo (size_t size, size_t align)

Protected Types
using	FooterAction = char *(char *)

Protected Member Functions
char *	cursor ()
char *	end ()

Detailed Description

Definition at line 105 of file SkArenaAlloc.h.

Member Typedef Documentation

FooterAction

using SkArenaAlloc::FooterAction = char* (char*)

protected

Definition at line 209 of file SkArenaAlloc.h.

Constructor & Destructor Documentation

SkArenaAlloc() [1/4]

SkArenaAlloc::SkArenaAlloc	(	char *	block,
		size_t	blockSize,
		size_t	firstHeapAllocation
	)

Definition at line 18 of file SkArenaAlloc.cpp.

    : fDtorCursor {block}
    , fCursor     {block}
    , fEnd        {block + SkToU32(size)}
    , fFibonacciProgression{SkToU32(size), SkToU32(firstHeapAllocation)}
{
    if (size < sizeof(Footer)) {
        fEnd = fCursor = fDtorCursor = nullptr;
    }
 
    if (fCursor != nullptr) {
        this->installFooter(end_chain, 0);
        sk_asan_poison_memory_region(fCursor, fEnd - fCursor);
    }
}

SkArenaAlloc() [2/4]

SkArenaAlloc::SkArenaAlloc ( size_t  firstHeapAllocation )

inlineexplicit

Definition at line 109 of file SkArenaAlloc.h.

        : SkArenaAlloc(nullptr, 0, firstHeapAllocation) {}

SkArenaAlloc() [3/4]

SkArenaAlloc::SkArenaAlloc ( const SkArenaAlloc &  )

delete

SkArenaAlloc() [4/4]

SkArenaAlloc::SkArenaAlloc ( SkArenaAlloc &&  )

delete

~SkArenaAlloc()

SkArenaAlloc::~SkArenaAlloc

(

)

Definition at line 34 of file SkArenaAlloc.cpp.

                            {
    RunDtorsOnBlock(fDtorCursor);
}

Member Function Documentation

cursor()

char * SkArenaAlloc::cursor ( )

inlineprotected

Definition at line 215 of file SkArenaAlloc.h.

{ return fCursor; }

end()

char * SkArenaAlloc::end ( )

inlineprotected

Definition at line 216 of file SkArenaAlloc.h.

{ return fEnd; }

make() [1/3]

template<typename T >

T * SkArenaAlloc::make ( )

inline

Definition at line 158 of file SkArenaAlloc.h.

              {
        if constexpr (std::is_standard_layout<T>::value && std::is_trivial<T>::value) {
            // Just allocate some aligned bytes. This generates smaller code.
            return (T*)this->makeBytesAlignedTo(sizeof(T), alignof(T));
        } else {
            // This isn't a POD type, so construct the object properly.
            return this->make([&](void* objStart) {
                return new(objStart) T();
            });
        }
    }

make() [2/3]

template<typename T , typename... Args>

T * SkArenaAlloc::make ( Args &&...  args )

inline

Definition at line 151 of file SkArenaAlloc.h.

                            {
        return this->make([&](void* objStart) {
            return new(objStart) T(std::forward<Args>(args)...);
        });
    }

make() [3/3]

template<typename Ctor >

auto SkArenaAlloc::make ( Ctor &&  ctor ) -> decltype(ctor(nullptr))

inline

Definition at line 120 of file SkArenaAlloc.h.

                                                      {
        using T = std::remove_pointer_t<decltype(ctor(nullptr))>;
 
        uint32_t size      = SkToU32(sizeof(T));
        uint32_t alignment = SkToU32(alignof(T));
        char* objStart;
        if (std::is_trivially_destructible<T>::value) {
            objStart = this->allocObject(size, alignment);
            fCursor = objStart + size;
            sk_asan_unpoison_memory_region(objStart, size);
        } else {
            objStart = this->allocObjectWithFooter(size + sizeof(Footer), alignment);
            // Can never be UB because max value is alignof(T).
            uint32_t padding = SkToU32(objStart - fCursor);
 
            // Advance to end of object to install footer.
            fCursor = objStart + size;
            sk_asan_unpoison_memory_region(objStart, size);
            FooterAction* releaser = [](char* objEnd) {
                char* objStart = objEnd - (sizeof(T) + sizeof(Footer));
                ((T*)objStart)->~T();
                return objStart;
            };
            this->installFooter(releaser, padding);
        }
 
        // This must be last to make objects with nested use of this allocator work.
        return ctor(objStart);
    }

makeArray()

template<typename T >

T * SkArenaAlloc::makeArray ( size_t  count )

inline

Definition at line 181 of file SkArenaAlloc.h.

                               {
        T* array = this->allocUninitializedArray<T>(count);
        for (size_t i = 0; i < count; i++) {
            // Value initialization: if T is primitive then the value is zero-initialized.
            new (&array[i]) T();
        }
        return array;
    }

makeArrayDefault()

template<typename T >

T * SkArenaAlloc::makeArrayDefault ( size_t  count )

inline

Definition at line 171 of file SkArenaAlloc.h.

                                      {
        T* array = this->allocUninitializedArray<T>(count);
        for (size_t i = 0; i < count; i++) {
            // Default initialization: if T is primitive then the value is left uninitialized.
            new (&array[i]) T;
        }
        return array;
    }

makeBytesAlignedTo()

void * SkArenaAlloc::makeBytesAlignedTo ( size_t  size, size_t  align  )

inline

Definition at line 200 of file SkArenaAlloc.h.

                                                        {
        AssertRelease(SkTFitsIn<uint32_t>(size));
        auto objStart = this->allocObject(SkToU32(size), SkToU32(align));
        fCursor = objStart + size;
        sk_asan_unpoison_memory_region(objStart, size);
        return objStart;
    }

makeInitializedArray()

template<typename T , typename Initializer >

T * SkArenaAlloc::makeInitializedArray ( size_t  count, Initializer  initializer  )

inline

Definition at line 191 of file SkArenaAlloc.h.

                                                                   {
        T* array = this->allocUninitializedArray<T>(count);
        for (size_t i = 0; i < count; i++) {
            new (&array[i]) T(initializer(i));
        }
        return array;
    }

operator=() [1/2]

SkArenaAlloc & SkArenaAlloc::operator= ( const SkArenaAlloc &  )

delete

operator=() [2/2]

SkArenaAlloc & SkArenaAlloc::operator= ( SkArenaAlloc &&  )

delete

---

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

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