Allocator.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2022 Rogiel Sulzbach. All rights reserved.
//
 
// The MIT License (MIT)
//
// Copyright (c) 2015 Howard Hinnant
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
 
#pragma once
 
#include "CeresEngine/Macros.hpp"
 
#include <cassert>
#include <cstddef>
#include <cstdint>
#include <foonathan/memory/aligned_allocator.hpp>
#include <foonathan/memory/deleter.hpp>
#include <foonathan/memory/fallback_allocator.hpp>
#include <foonathan/memory/iteration_allocator.hpp>
#include <foonathan/memory/joint_allocator.hpp>
#include <foonathan/memory/memory_arena.hpp>
#include <foonathan/memory/memory_pool.hpp>
#include <foonathan/memory/memory_pool_collection.hpp>
#include <foonathan/memory/memory_resource_adapter.hpp>
#include <foonathan/memory/segregator.hpp>
#include <foonathan/memory/static_allocator.hpp>
#include <foonathan/memory/std_allocator.hpp>
#include <foonathan/memory/temporary_allocator.hpp>
#include <foonathan/memory/tracking.hpp>
#include <memory>
#include <scoped_allocator>
 
namespace CeresEngine {
 
    using MemoryBlock = foonathan::memory::memory_block;
 
    template<typename Allocator> using AllocatorTraits = foonathan::memory::allocator_traits<Allocator>;
 
    template<typename Allocator> using ComposableAllocatorTraits = foonathan::memory::composable_allocator_traits<Allocator>;
 
    struct CE_EXPORT DefaultAllocator {
        using is_stateful = std::integral_constant<bool, false>; // NOLINT
 
        [[nodiscard]] static void* allocate_node(std::size_t size, std::size_t alignment); // NOLINT
        static void deallocate_node(void* node, std::size_t size, // NOLINT
            std::size_t alignment) noexcept;
 
        [[nodiscard]] static void* allocate_array(std::size_t count, std::size_t size, // NOLINT
            std::size_t alignment);
        static void deallocate_array(void* ptr, std::size_t count, std::size_t size, // NOLINT
            std::size_t alignment) noexcept;
 
        [[nodiscard]] static std::size_t max_node_size(); // NOLINT
        [[nodiscard]] static std::size_t max_array_size(); // NOLINT
        [[nodiscard]] static std::size_t max_alignment(); // NOLINT
    };
 
    template<class StoragePolicy, class Mutex> using AllocatorStorage = foonathan::memory::allocator_storage<StoragePolicy, Mutex>;
 
    template<class RawAllocator> using DirectStorage = foonathan::memory::direct_storage<RawAllocator>;
 
    template<class RawAllocator> using ReferenceStorage = foonathan::memory::reference_storage<RawAllocator>;
 
    template<class RawAllocator> using AllocatorReference = foonathan::memory::allocator_reference<RawAllocator>;
 
    using AnyAllocator = foonathan::memory::any_allocator;
 
    using AnyAllocatorReference = foonathan::memory::any_allocator_reference;
 
    template<class RawAllocator> using AllocatorAdapter = foonathan::memory::allocator_adapter<RawAllocator>;
 
    template<class RawAllocator, class Mutex = std::mutex> using ThreadSafeAllocator = foonathan::memory::thread_safe_allocator<RawAllocator, Mutex>;
 
    template<class RawAllocator> using AlignedAllocator = foonathan::memory::aligned_allocator<RawAllocator>;
 
    using TemporaryAllocator = foonathan::memory::temporary_allocator;
 
    using TemporaryStackInitializer = foonathan::memory::temporary_stack_initializer;
 
    template<class Default, class Fallback> using FallbackAllocator = foonathan::memory::fallback_allocator<Default, Fallback>;
 
    using HeapAllocator = foonathan::memory::heap_allocator;
 
    template<std::size_t N, class BlockOrRawAllocator = DefaultAllocator>
    using IterationAllocator = foonathan::memory::iteration_allocator<N, BlockOrRawAllocator>;
 
    template<class BlockOrRawAllocator = DefaultAllocator> using DoubleFrameAllocator = foonathan::memory::double_frame_allocator<BlockOrRawAllocator>;
 
    using MallocAllocator = foonathan::memory::malloc_allocator;
 
    template<class BlockAllocator = DefaultAllocator, bool Cached = true> using MemoryArena = foonathan::memory::memory_arena<BlockAllocator, Cached>;
 
    template<class RawAllocator = DefaultAllocator, unsigned Num = 2, unsigned Den = 1>
    using GrowingBlockAllocator = foonathan::memory::growing_block_allocator<RawAllocator, Num, Den>;
 
    template<class RawAllocator = DefaultAllocator> using FixedBlockAllocator = foonathan::memory::fixed_block_allocator<RawAllocator>;
 
    using NodePool = foonathan::memory::node_pool;
 
    using ArrayPool = foonathan::memory::array_pool;
 
    using SmallNodePool = foonathan::memory::small_node_pool;
 
    template<typename PoolType = foonathan::memory::node_pool, class BlockOrRawAllocator = DefaultAllocator>
    using MemoryPool = foonathan::memory::memory_pool<PoolType, BlockOrRawAllocator>;
 
    namespace BucketDistribution {
        using IdentityBuckets = foonathan::memory::identity_buckets;
 
        using Log2Buckets = foonathan::memory::log2_buckets;
    } // namespace BucketDistribution
 
    template<class PoolType, class BucketDistribution, class BlockOrRawAllocator = DefaultAllocator>
    using MemoryPoolCollection = foonathan::memory::memory_pool_collection<PoolType, BucketDistribution, BlockOrRawAllocator>;
 
    template<class PoolType = NodePool, class BlockOrRawAllocator = DefaultAllocator>
    using BucketAllocator = foonathan::memory::bucket_allocator<PoolType, BlockOrRawAllocator>;
 
    template<class BlockOrRawAllocator = DefaultAllocator> using MemoryStack = foonathan::memory::memory_stack<BlockOrRawAllocator>;
 
    template<class Stack = MemoryStack<>> using MemoryStackScope = foonathan::memory::memory_stack_raii_unwind<Stack>;
 
    using NewAllocator = foonathan::memory::new_allocator;
 
    template<class RawAllocator> using ThresholdSegregatable = foonathan::memory::threshold_segregatable<RawAllocator>;
 
    using NullAllocator = foonathan::memory::null_allocator;
 
    template<class Segregatable, class RawAllocator> using BinarySegregator = foonathan::memory::binary_segregator<Segregatable, RawAllocator>;
 
    template<std::size_t Size> using StaticAllocatorStorage = foonathan::memory::static_allocator_storage<Size>;
 
    using StaticAllocator = foonathan::memory::static_allocator;
 
    using StaticBlockAllocator = foonathan::memory::static_block_allocator;
 
    template<class Tracker, class RawAllocator> using TrackedAllocator = foonathan::memory::tracked_allocator<Tracker, RawAllocator>;
 
    template<class Tracker, class BlockOrRawAllocator> using TrackedBlockAllocator = foonathan::memory::tracked_block_allocator<Tracker, BlockOrRawAllocator>;
 
    template<class Tracker, class BlockOrRawAllocator>
    using DeeplyTrackedBlockAllocator = foonathan::memory::deeply_tracked_block_allocator<Tracker, BlockOrRawAllocator>;
 
    using VirtualMemoryAllocator = foonathan::memory::virtual_memory_allocator;
 
    using VirtualBlockAllocator = foonathan::memory::virtual_block_allocator;
 
    template<typename T, class RawAllocator> using JointPtr = foonathan::memory::joint_ptr<T, RawAllocator>;
 
    template<typename T> using JointArray = foonathan::memory::joint_array<T>;
 
    template<typename T, class RawAllocator> using JointAllocator = foonathan::memory::joint_allocator;
 
    // ---------------------------------------------------------------------------------------------
 
    template<typename T, class RawAllocator = DefaultAllocator> using StdAllocator = foonathan::memory::std_allocator<T, RawAllocator>;
 
    template<typename T> using AnyStdAllocator = foonathan::memory::any_std_allocator<T>;
 
    template<class RawAllocator> using MemoryResourceAdapter = foonathan::memory::memory_resource_adapter<RawAllocator>;
 
    using MemoryResourceAllocator = foonathan::memory::memory_resource_allocator;
 
    template<typename Type, class RawAllocator> using AllocatorDeallocator = foonathan::memory::allocator_deallocator<Type, RawAllocator>;
 
    template<typename BaseType, class RawAllocator>
    using AllocatorPolymorphicDeallocator = foonathan::memory::allocator_polymorphic_deallocator<BaseType, RawAllocator>;
 
    template<typename Type, class RawAllocator> using AllocatorDeleter = foonathan::memory::allocator_deleter<Type, RawAllocator>;
 
    template<typename BaseType, class RawAllocator>
    using AllocatorPolymorphicDeleter = foonathan::memory::allocator_polymorphic_deleter<BaseType, RawAllocator>;
 
    // ---------------------------------------------------------------------------------------------
 
    DefaultAllocator& gDefaultAllocator();
 
    // ---------------------------------------------------------------------------------------------
 
    using AllocatorInfo = foonathan::memory::allocator_info;
 
    using OutOfMemoryError = foonathan::memory::out_of_memory;
 
    using OutOfFixedMemoryError = foonathan::memory::out_of_fixed_memory;
 
    using BadAllocationSizeError = foonathan::memory::bad_allocation_size;
 
    using BadNodeSizeError = foonathan::memory::bad_node_size;
 
    using BadArraySizeError = foonathan::memory::bad_array_size;
 
    using BadAlignmentError = foonathan::memory::bad_alignment;
 
    // ---------------------------------------------------------------------------------------------
 
    using foonathan::memory::allocate_joint;
    using foonathan::memory::clone_joint;
    using foonathan::memory::get_temporary_stack;
    using foonathan::memory::make_aligned_allocator;
    using foonathan::memory::make_allocator_adapter;
    using foonathan::memory::make_allocator_reference;
    using foonathan::memory::make_any_allocator_reference;
    using foonathan::memory::make_any_std_allocator;
    using foonathan::memory::make_block_allocator;
    using foonathan::memory::make_deeply_tracked_allocator;
    using foonathan::memory::make_segregator;
    using foonathan::memory::make_std_allocator;
    using foonathan::memory::make_thread_safe_allocator;
    using foonathan::memory::make_tracked_allocator;
    using foonathan::memory::threshold;
 
    // ---------------------------------------------------------------------------------------------
 
    template<typename OuterAlloc, typename... InnerAlloc> using ScopedAllocatorAdaptor = std::scoped_allocator_adaptor<OuterAlloc, InnerAlloc...>;
 
    // ---------------------------------------------------------------------------------------------
 
    template<std::size_t N, std::size_t Alignment = alignof(std::max_align_t)> class Arena {
        alignas(Alignment) char mBuffer[N];
        char* mPointer;
 
    public:
        ~Arena() { mPointer = nullptr; }
        Arena() noexcept : mPointer(mBuffer) {}
        Arena(const Arena&) = delete;
        Arena& operator=(const Arena&) = delete;
 
        template<std::size_t ReqAlign> char* allocate(std::size_t n);
        void deallocate(char* p, std::size_t n) noexcept;
 
        static constexpr std::size_t size() noexcept { return N; }
        std::size_t used() const noexcept { return static_cast<std::size_t>(mPointer - mBuffer); }
        void reset() noexcept { mPointer = mBuffer; }
 
    private:
        static std::size_t align_up(const std::size_t n) noexcept { return (n + (Alignment - 1)) & ~(Alignment - 1); }
        bool pointer_in_buffer(char* p) noexcept { return std::uintptr_t(mBuffer) <= std::uintptr_t(p) && std::uintptr_t(p) <= std::uintptr_t(mBuffer) + N; }
    };
 
    template<std::size_t N, std::size_t Alignment> template<std::size_t ReqAlign> char* Arena<N, Alignment>::allocate(const std::size_t n) {
        static_assert(ReqAlign <= Alignment, "alignment is too small for this arena");
        assert(pointer_in_buffer(mPointer) && "short_alloc has outlived arena");
        auto const aligned_n = align_up(n);
        if(static_cast<decltype(aligned_n)>(mBuffer + N - mPointer) >= aligned_n) {
            char* r = mPointer;
            mPointer += aligned_n;
            return r;
        }
 
        static_assert(Alignment <= alignof(std::max_align_t),
            "you've chosen an "
            "alignment that is larger than alignof(std::max_align_t), and "
            "cannot be guaranteed by normal operator new");
        return static_cast<char*>(::operator new(n));
    }
 
    template<std::size_t N, std::size_t Alignment> void Arena<N, Alignment>::deallocate(char* p, std::size_t n) noexcept {
        assert(pointer_in_buffer(mPointer) && "short_alloc has outlived arena");
        if(pointer_in_buffer(p)) {
            n = align_up(n);
            if(p + n == mPointer) {
                mPointer = p;
            }
        } else {
            ::operator delete(p);
        }
    }
 
    template<class T, std::size_t N, std::size_t Align = alignof(std::max_align_t)> class ShortAllocator {
    public:
        static auto constexpr alignment = Align;
        static auto constexpr size = N;
 
        using ValueType = T;
        using ArenaType = Arena<size * sizeof(T), alignment>;
 
        using value_type = ValueType;
 
    private:
        ArenaType mArena;
 
    public:
        ShortAllocator(const ShortAllocator&) = default;
        ShortAllocator& operator=(const ShortAllocator&) = delete;
 
        ShortAllocator(ArenaType& a) noexcept : mArena(a) { static_assert(size % alignment == 0, "size N needs to be a multiple of alignment Align"); }
        template<class U> ShortAllocator(const ShortAllocator<U, N, alignment>& a) noexcept : mArena(a.mArena) {}
 
        template<class Up> struct rebind { using other = ShortAllocator<Up, N, alignment>; };
 
        [[nodiscard]] T* allocate(const std::size_t n) { return reinterpret_cast<T*>(mArena.template allocate<alignof(T)>(n * sizeof(T))); }
        void deallocate(T* p, const std::size_t n) noexcept { mArena.deallocate(reinterpret_cast<char*>(p), n * sizeof(T)); }
 
        template<class T1, std::size_t N1, std::size_t A1, class U, std::size_t M, std::size_t A2>
        friend bool operator==(const ShortAllocator<T1, N1, A1>& x, const ShortAllocator<U, M, A2>& y) noexcept;
 
        template<class U, std::size_t M, std::size_t A> friend class ShortAllocator;
    };
 
    template<class T, std::size_t N, std::size_t A1, class U, std::size_t M, std::size_t A2>
    inline bool operator==(const ShortAllocator<T, N, A1>& x, const ShortAllocator<U, M, A2>& y) noexcept {
        return N == M && A1 == A2 && &x.mArena == &y.mArena;
    }
 
    template<class T, std::size_t N, std::size_t A1, class U, std::size_t M, std::size_t A2>
    inline bool operator!=(const ShortAllocator<T, N, A1>& x, const ShortAllocator<U, M, A2>& y) noexcept {
        return !(x == y);
    }
 
} // namespace CeresEngine
 
[[nodiscard]] void* operator new(std::size_t count, std::align_val_t alignment);
[[nodiscard]] void* operator new(std::size_t count);
[[nodiscard]] void* operator new(std::size_t count, std::align_val_t alignment, const std::nothrow_t&) noexcept;
[[nodiscard]] void* operator new(std::size_t count, const std::nothrow_t&) noexcept;
 
[[nodiscard]] void* operator new[](std::size_t count, std::align_val_t alignment);
[[nodiscard]] void* operator new[](std::size_t count);
[[nodiscard]] void* operator new[](std::size_t count, std::align_val_t alignment, const std::nothrow_t&) noexcept;
[[nodiscard]] void* operator new[](std::size_t count, const std::nothrow_t&) noexcept;
 
void operator delete(void* ptr, std::align_val_t alignment) noexcept;
void operator delete(void* ptr) noexcept;
void operator delete(void* ptr, std::align_val_t alignment, const std::nothrow_t&) noexcept;
void operator delete(void* ptr, const std::nothrow_t&) noexcept;
 
void operator delete(void* ptr, std::size_t sz, std::align_val_t alignment) noexcept;
void operator delete(void* ptr, std::size_t sz) noexcept;
void operator delete(void* ptr, std::size_t sz, std::align_val_t alignment, const std::nothrow_t&) noexcept;
void operator delete(void* ptr, std::size_t sz, const std::nothrow_t&) noexcept;
 
void operator delete[](void* ptr, std::align_val_t alignment) noexcept;
void operator delete[](void* ptr) noexcept;
void operator delete[](void* ptr, const std::nothrow_t& tag) noexcept;
void operator delete[](void* ptr, std::align_val_t alignment, const std::nothrow_t&) noexcept;
 
void operator delete[](void* ptr, std::size_t sz, std::align_val_t alignment) noexcept;
void operator delete[](void* ptr, std::size_t sz) noexcept;
void operator delete[](void* ptr, std::size_t sz, const std::nothrow_t& tag) noexcept;
void operator delete[](void* ptr, std::size_t sz, std::align_val_t alignment, const std::nothrow_t&) noexcept;
 
template<> class foonathan::memory::allocator_traits<CeresEngine::DefaultAllocator> {
public:
    using allocator_type = CeresEngine::DefaultAllocator;
    using is_stateful = std::integral_constant<bool, false>;
 
    static void* allocate_node(allocator_type& state, const std::size_t size, const std::size_t alignment) { return state.allocate_node(size, alignment); }
    static void deallocate_node(allocator_type& state, void* node, const std::size_t size, const std::size_t alignment) noexcept {
        state.deallocate_node(node, size, alignment);
    }
 
    static void* allocate_array(allocator_type& state, const std::size_t count, const std::size_t size, const std::size_t alignment) {
        return state.allocate_array(count, size, alignment);
    }
    static void deallocate_array(allocator_type& state, void* array, const std::size_t count, const std::size_t size, const std::size_t alignment) noexcept {
        state.deallocate_array(array, count, size, alignment);
    }
 
    static std::size_t max_node_size(const allocator_type& state) { return state.max_node_size(); }
    static std::size_t max_array_size(const allocator_type& state) { return state.max_array_size(); }
    static std::size_t max_alignment(const allocator_type& state) { return state.max_alignment(); }
};