memory.h

Go to the documentation of this file.

#pragma once
 
#include "Common/assertion.h"
 
#include <cstddef>
#include <memory>
#include <array>
 
namespace ph
{
 
namespace detail
{
 
[[nodiscard]]
void* allocate_aligned_memory(std::size_t numBytes, std::size_t alignmentInBytes);
 
void free_aligned_memory(void* ptr);
 
struct AlignedMemoryDeleter
{
    inline void operator () (void* const ptr) const
    {
        free_aligned_memory(ptr);
    }
 
    inline void operator () (const void* const ptr) const
    {
        // `const_cast` to support const overload. This is fine as aligned memory is only returned as
        // a non-const pointer (see `allocate_aligned_memory()`), and casting an originally non-const
        // type is safe.
        free_aligned_memory(const_cast<void*>(ptr));
    }
};
 
}// end namespace detail
 
template<typename T>
using TAlignedMemoryUniquePtr = std::unique_ptr<T, detail::AlignedMemoryDeleter>;
 
// Note that `detail::AlignedMemoryDeleter` is for empty base optimization on `std::unique_ptr`, 
// see https://stackoverflow.com/questions/42715492/stdunique-ptr-and-custom-deleters.
// This would reduce the size of the resulting `unique_ptr` to the size of a single pointer.
// Reference: https://stackoverflow.com/questions/45341371/memory-efficient-custom-deleter-for-stdunique-ptr
// 
// The following test will ensure this is true:
static_assert(sizeof(TAlignedMemoryUniquePtr<void>) == sizeof(void*));
 
template<typename T, std::size_t N, std::size_t ALIGNMENT_IN_BYTES = sizeof(T)>
struct alignas(ALIGNMENT_IN_BYTES) TAlignedArray : public std::array<T, N>
{
    inline static constexpr std::size_t ALIGNMENT = ALIGNMENT_IN_BYTES;
 
    // Do not add any other member here. This struct must be a standard-layout type and nothing else
    // but being an aligned alias to `std::array`.
};
 
template<typename T = void>
inline auto make_aligned_memory(std::size_t numBytes, std::size_t alignmentInBytes)
-> TAlignedMemoryUniquePtr<T>;
 
template<typename T>
void from_bytes(const std::byte* srcBytes, T* out_dstValue);
 
template<typename T>
void to_bytes(const T& srcValue, std::byte* out_dstBytes);
 
template<std::size_t N>
void reverse_bytes(std::byte* bytes);
 
template<typename T>
T* start_implicit_lifetime_as(void* ptr) noexcept;
 
template<typename T>
T* start_implicit_lifetime_as_array(void* ptr, std::size_t numArrayElements) noexcept;
 
}// end namespace ph
 
#include "Common/memory.ipp"