Allocator.hpp

Go to the documentation of this file.

#pragma once
#include <atomic>
#include <memory>
#include <stdexcept>
namespace Foundation::Core
{
    using size_type = std::size_t;
    using pointer = void*;
    constexpr uintptr_t AlignUp(const uintptr_t value, const uintptr_t alignment)
    {
        return value % alignment ? (value + alignment - value % alignment) : value;
    }
    constexpr uintptr_t AlignDown(const uintptr_t value, const uintptr_t alignment)
    {
        return value % alignment ? (value - value % alignment) : value;
    }
    struct Arena
    {
        pointer memory;
        size_type size;
    };
    class Allocator
    {
    public:
        virtual ~Allocator() = default;
        virtual pointer Allocate(size_type size, size_t alignment = alignof(std::max_align_t)) noexcept = 0;
        virtual void Deallocate(pointer ptr) noexcept = 0;
        virtual pointer Reallocate(pointer ptr, size_type new_size, size_t alignment) noexcept = 0;
 
        Arena AllocateArena(size_type size, size_t alignment) { return {Allocate(size, alignment), size}; }
        Arena AllocateArena(size_type size) { return {Allocate(size), size}; }
        void DeallocateArena(Arena arena)
        {
            if (arena.memory)
                Deallocate(arena.memory);
        }
        Allocator* Ptr() { return this; }
    };
    struct ScopedArena
    {
        Allocator* resource;
        Arena arena;
        ScopedArena(Allocator* res, size_t size, size_t alignment = alignof(std::max_align_t)) :
            resource(res), arena(res->AllocateArena(size, alignment)) {};
        ~ScopedArena() { resource->DeallocateArena(arena); }
        constexpr operator Arena() const { return arena; }
        constexpr operator bool() const noexcept { return arena.memory != nullptr; }
    };
    constexpr size_t kDefaultStackArenaSize = 12 * 1024; // 12 KiB
    template <size_t Size = kDefaultStackArenaSize>
    struct StackArena
    {
        alignas(std::max_align_t) std::byte data[Size];
        constexpr operator Arena() { return {reinterpret_cast<void*>(data), Size}; }
        constexpr operator Arena() const { return {reinterpret_cast<void*>(data), Size}; }
    };
 
    template <typename T = void>
    struct StlAllocator
    {
        using value_type = T;
        using size_type = std::size_t;
        using difference_type = std::ptrdiff_t;
        using pointer = T*;
        using const_pointer = const T*;
        using reference = T&;
        using const_reference = const T&;
 
        Allocator* mResource;
 
        template <typename U>
        friend struct StlAllocator; // Rebind ctor
        template <typename U>
        struct Rebind
        {
            using other = StlAllocator<U>;
        };
        StlAllocator(Allocator* resource) noexcept : mResource(resource) {}
        template <typename U>
        StlAllocator(const StlAllocator<U>& other) noexcept : mResource(other.mResource)
        {
        }
 
        pointer allocate(size_type n) noexcept
        {
            return static_cast<pointer>(mResource->Allocate(n * sizeof(T), alignof(T)));
        }
        void deallocate(pointer p, size_type n) noexcept { mResource->Deallocate(p); }
        void deallocate(pointer p) noexcept { mResource->Deallocate(p); }
        // Allocators are deemed equal if they point to the same resource
        friend bool operator==(const StlAllocator& lhs, const StlAllocator& rhs) noexcept
        {
            return lhs.mResource == rhs.mResource;
        }
        friend bool operator!=(const StlAllocator& lhs, const StlAllocator& rhs) noexcept { return !(lhs == rhs); }
    };
 
    template <typename T>
    struct StlDeleter
    {
        Allocator* mResource;
        void operator()(T* ptr) noexcept
        {
            if (ptr && mResource)
            {
                std::destroy_at(ptr);
                mResource->Deallocate(ptr);
            }
        }
    };
    template <typename Base, typename Derived, typename... Args>
    Base* ConstructBase(Allocator* resource, Args&&... args)
    {
        auto raw = resource->Allocate(sizeof(Derived), alignof(Derived));
        return std::construct_at(static_cast<Derived*>(raw), std::forward<Args>(args)...);
    }
    template <typename T, typename... Args>
    T* Construct(Allocator* resource, Args&&... args)
    {
        return ConstructBase<T, T>(resource, std::forward<Args>(args)...);
    }
    template <typename T>
    void Destruct(Allocator* resource, T* obj)
    {
        StlDeleter<T> deleter(resource);
        deleter(obj);
    }
    template <typename T, typename Deleter = StlDeleter<T>>
    using UniquePtr = std::unique_ptr<T, Deleter>;
 
    template <typename Base, typename Derived, typename... Args>
    UniquePtr<Base> ConstructUniqueBase(Allocator* resource, Args&&... args)
    {
        Base* obj = ConstructBase<Base, Derived>(resource, std::forward<Args>(args)...);
        return UniquePtr<Base>(obj, StlDeleter<Base>{resource});
    }
    template <typename T, typename... Args>
    UniquePtr<T> ConstructUnique(Allocator* resource, Args&&... args)
    {
        return ConstructUniqueBase<T, T>(resource, std::forward<Args>(args)...);
    }
 
    template <typename T>
    using SharedPtr = std::shared_ptr<T>;
    template <typename T>
    using WeakPtr = std::weak_ptr<T>;
 
    template <typename Base, typename Derived, typename... Args>
    SharedPtr<Base> ConstructSharedBase(Allocator* resource, Args&&... args)
    {
        return std::allocate_shared<Derived>(StlAllocator<Derived>{resource}, std::forward<Args>(args)...);
    }
 
    template <typename T, typename... Args>
    SharedPtr<T> ConstructShared(Allocator* resource, Args&&... args)
    {
        return ConstructSharedBase<T, T>(resource, std::forward<Args>(args)...);
    }
 
    extern Allocator* GetGlobalAllocator();
} // namespace Foundation::Core
 
#define GLOBAL_ALLOC Foundation::Core::GetGlobalAllocator()
namespace Foundation::Core
{
    // Default allocator for STL containers to be constructed with @ref GLOBAL_ALLOC
    template <typename T = void>
    struct StlDefaultAllocator
    {
        using value_type = T;
        using size_type = std::size_t;
        using difference_type = std::ptrdiff_t;
        using pointer = T*;
        using const_pointer = const T*;
        using reference = T&;
        using const_reference = const T&;
        StlDefaultAllocator() noexcept = default;
        ~StlDefaultAllocator() = default;
        template <typename U>
        constexpr StlDefaultAllocator(const StlDefaultAllocator<U>&) noexcept
        {
        }
 
        pointer allocate(size_type n) noexcept
        {
            return static_cast<pointer>(GLOBAL_ALLOC->Allocate(n * sizeof(T), alignof(T)));
        }
        void deallocate(pointer p, size_type n) noexcept { GLOBAL_ALLOC->Deallocate(p); }
        void deallocate(pointer p) noexcept { GLOBAL_ALLOC->Deallocate(p); }
        friend bool operator==(const StlDefaultAllocator& lhs, const StlDefaultAllocator& rhs) noexcept { return true; }
        friend bool operator!=(const StlDefaultAllocator& lhs, const StlDefaultAllocator& rhs) noexcept
        {
            return false;
        }
    };
 
} // namespace Foundation::Core