AlignedMemoryResource.cpp File Reference

#include "pma/resources/AlignedMemoryResource.h"
#include <cassert>
#include <cstddef>
#include <cstdint>
#include <cstdlib>

Include dependency graph for AlignedMemoryResource.cpp:

Namespaces
namespace	pma

Macros
#define	ALIGNED_ALLOC(ptr, alignment, size)   ptr = alignedAlloc(size, alignment)
#define	ALIGNED_FREE(ptr)   alignedFree(ptr)

Functions
std::uintptr_t	alignAddress (std::uintptr_t address, std::size_t alignment)
template<typename T >
T *	alignPointer (T *ptr, std::size_t alignment)
void *	alignedAlloc (std::size_t size, std::size_t alignment)
void	alignedFree (void *ptr)

Macro Definition Documentation

ALIGNED_ALLOC

#define ALIGNED_ALLOC	(		ptr,
			alignment,
			size
	)		ptr = alignedAlloc(size, alignment)

ALIGNED_FREE

#define ALIGNED_FREE

(

ptr

)

alignedFree(ptr)

Function Documentation

alignAddress()

std::uintptr_t alignAddress ( std::uintptr_t  address, std::size_t  alignment  )

inline

                                                                                {
        const std::size_t mask = alignment - 1ul;
        assert((alignment & mask) == 0ul);
        return (address + mask) & ~mask;
    }

Referenced by alignPointer().

alignedAlloc()

void * alignedAlloc	(	std::size_t	size,
		std::size_t	alignment
	)

                                                            {
        const std::size_t actualSize = size + alignment;
        char* pUnalignedChunk = new char[actualSize];
        char* pAlignedChunk = alignPointer(pUnalignedChunk, alignment);
        if (pAlignedChunk == pUnalignedChunk) {
            // There was no need for additional alignment, so an artifical gap
            // must be added to make room for the shift value
            pAlignedChunk += alignment;
        }
        // Compute and write the shift value into the buffer (it is needed during
        // deallocation to reconstruct by which amount was the given pointer
        // offset to meet the alignment requirement)
        std::ptrdiff_t shift = pAlignedChunk - pUnalignedChunk;
        // The guaranteed storage size for the shift value is only one byte
        assert(shift > 0 && shift <= 256);
        pAlignedChunk[-1] = static_cast<char>(shift & 0xFF);
        return static_cast<void*>(pAlignedChunk);
    }

References alignPointer().

alignedFree()

void alignedFree

(

void *

ptr

)

                                {
        if (ptr) {
            auto pAlignedChunk = reinterpret_cast<char*>(ptr);
            std::ptrdiff_t shift = pAlignedChunk[-1];
            // There is no 0 alignment, so the value is reused to actually denote alignment by 256
            if (shift == 0) {
                shift = 256;
            }
            // Compute the actual start address of the chunk, prior to aligning it's address
            auto pUnalignedChunk = pAlignedChunk - shift;
            delete[] pUnalignedChunk;
        }
    }

alignPointer()

template<typename T >

T * alignPointer ( T *  ptr, std::size_t  alignment  )

inline

                                                        {
        const std::uintptr_t address = reinterpret_cast<std::uintptr_t>(ptr);
        const std::uintptr_t aligned = alignAddress(address, alignment);
        return reinterpret_cast<T*>(aligned);
    }

References alignAddress().

Referenced by alignedAlloc().