Death::Memory namespace

#include <Base/Memory.h>

template<class T, std::size_t alignment = alignof(T)>

Containers::Array<T> Death::Memory::AllocateAligned(std::size_t size)

Allocate aligned memory and value-initialize it.

Compared to the classic C std::malloc() or C++ new that commonly aligns only to 2*sizeof(void*), this function returns "overaligned" allocations, which is mainly useful for efficient SIMD operations.

The alignment is implicitly alignof(T), but can be overridden with the alignment template parameter. When specified explicitly, it is expected to be a power-of-two value, at most 256 bytes and the total byte size being a multiple of the alignment.

The returned pointer is always aligned to at least the desired value, but the alignment can be also higher. For example, allocating a 2 MB buffer may result in it being aligned to the whole memory page, or small alignment values could get rounded up to the default 2*sizeof(void*) alignment.

Array initialization

Like with Containers::Array, the returned array is by default value-initialized, which means that trivial types are zero-initialized and the default constructor is called on other types. Different behavior can be achieved with the following tags, compared to Containers::Array the initialization is performed separately from the allocation itself with either a loop or a call to std::memset().

• AllocateAligned(Containers::ValueInitT, std::size_t) is equivalent to the default case, zero-initializing trivial types and calling the default constructor elsewhere. Useful when you want to make the choice appear explicit.
• AllocateAligned(Containers::NoInitT, std::size_t) does not initialize anything. Useful for trivial types when you'll be overwriting the contents anyway, for non-trivial types this is the dangerous option and you need to call the constructor on all elements manually using placement new, std::uninitialized_copy() or similar.

template<class T, std::size_t alignment = alignof(T)>

Containers::Array<T> Death::Memory::AllocateAligned(Containers::ValueInitT, std::size_t size)

Allocate aligned memory and value-initialize it.

Same as AllocateAligned(std::size_t), just more explicit. Implemented via AllocateAligned(Containers::NoInitT, std::size_t) with either a std::memset() or a loop calling the constructors on the returned allocation.

template<class T, std::size_t alignment = alignof(T)>

Containers::Array<T> Death::Memory::AllocateAligned(Containers::NoInitT, std::size_t size)

Allocate aligned memory and leave it uninitialized.

Compared to AllocateAligned(std::size_t), the memory is left in an unitialized state. For non-trivial types, destruction is always done using a custom deleter that explicitly calls the destructor on all elements — which means that for non-trivial types you're expected to construct all elements using placement new (or for example std::uninitialized_copy()) in order to avoid calling destructors on uninitialized memory.

template<typename T>

T Death::Memory::AsBE(T value)

Converts a value from/to Big-Endian.

On Little-Endian systems calls SwapBytes(), on Big-Endian systems returns the value unchanged. Only trivial types of size 2, 4, or 8 bytes are supported.

template<typename T>

T Death::Memory::AsLE(T value)

Converts a value from/to Little-Endian.

On Big-Endian systems calls SwapBytes(), on Little-Endian systems returns the value unchanged. Only trivial types of size 2, 4, or 8 bytes are supported.

template<class T>

T Death::Memory::SwapBytes(T value)

Endian-swap bytes of given value.

Only trivial types of size 2, 4, or 8 bytes are supported.