bump_allocator.hpp

Go to the documentation of this file.

 
#ifndef JOIN_CORE_BUMP_ALLOCATOR_HPP
#define JOIN_CORE_BUMP_ALLOCATOR_HPP
 
// libjoin.
#include <join/memory.hpp>
#include <join/utils.hpp>
 
// C++.
#include <type_traits>
#include <algorithm>
#include <utility>
#include <atomic>
#include <new>
 
// C.
#include <cstdint>
#include <cstddef>
 
namespace join
{
    template <typename Backend, size_t Capacity, typename SyncPolicy>
    class BasicBumpAllocator
    {
        static_assert (Capacity > 0, "capacity must be at least 1");
 
    public:
        template <typename... Args>
        BasicBumpAllocator (Args&&... args)
        : _backend (Capacity, std::forward<Args> (args)...)
        , _base (static_cast<char*> (_backend.get ()))
        {
        }
 
        BasicBumpAllocator (const BasicBumpAllocator& other) = delete;
 
        BasicBumpAllocator& operator= (const BasicBumpAllocator& other) = delete;
 
        BasicBumpAllocator (BasicBumpAllocator&& other) noexcept
        : _backend (std::move (other._backend))
        , _previous (other._previous)
        , _base (other._base)
        , _capacity (other._capacity)
        , _cursor (std::move (other._cursor))
        {
            other._previous = nullptr;
            other._base = nullptr;
            other._capacity = Capacity;
            other._cursor.store (0);
        }
 
        BasicBumpAllocator& operator= (BasicBumpAllocator&& other) noexcept
        {
            if (this != &other)
            {
                release ();
 
                _backend = std::move (other._backend);
                _previous = other._previous;
                _base = other._base;
                _capacity = other._capacity;
                _cursor = std::move (other._cursor);
 
                other._previous = nullptr;
                other._base = nullptr;
                other._capacity = Capacity;
                other._cursor.store (0);
            }
 
            return *this;
        }
 
        ~BasicBumpAllocator ()
        {
            release ();
        }
 
        void* allocate (size_t size) noexcept
        {
            const size_t bits = size | alignof (std::max_align_t);
            return allocate (size, bits & (~bits + 1));
        }
 
        void* allocate (size_t size, size_t alignment) noexcept
        {
            if (JOIN_UNLIKELY ((_base == nullptr) || !isPow2 (alignment)))
            {
                return nullptr;
            }
 
            const uintptr_t base = reinterpret_cast<uintptr_t> (_base);
            uint64_t current = _cursor.load ();
            uint64_t offset;
 
            do
            {
                offset = ((base + current + alignment - 1) & ~(alignment - 1)) - base;
 
                if (JOIN_UNLIKELY ((offset > _capacity) || (size > _capacity - offset)))
                {
                    if constexpr (std::is_same_v<SyncPolicy, BumpPlain>)
                    {
                        return grow (size, alignment);
                    }
                    return nullptr;
                }
            }
            while (!_cursor.advance (current, offset + size));
 
            return _base + offset;
        }
 
        void deallocate ([[maybe_unused]] void* p, [[maybe_unused]] size_t size) noexcept
        {
        }
 
        void reset () noexcept
        {
            release ();
            _cursor.store (0);
        }
 
        static constexpr size_t capacity () noexcept
        {
            return Capacity;
        }
 
        size_t used () const noexcept
        {
            return _cursor.load ();
        }
 
        bool hasBackend () const noexcept
        {
            return _backend.mapped ();
        }
 
#ifdef JOIN_HAS_NUMA
        int mbind (int numa) const noexcept
        {
            return _backend.mbind (numa);
        }
#endif
 
        int mlock () const noexcept
        {
            return _backend.mlock ();
        }
 
    private:
        void* grow (size_t size, size_t alignment) noexcept
        {
            if (JOIN_UNLIKELY (size + alignment + sizeof (BasicBumpAllocator) + alignof (BasicBumpAllocator) < size))
            {
                return nullptr;
            }
 
            try
            {
                const uint64_t capacity =
                    (std::max<uint64_t> (_capacity * 2, size + alignment) + alignof (BasicBumpAllocator) - 1) &
                    ~(alignof (BasicBumpAllocator) - 1);
                Backend backend (capacity + sizeof (BasicBumpAllocator));
                _previous =
                    ::new (static_cast<char*> (backend.get ()) + capacity) BasicBumpAllocator (std::move (*this));
                _backend = std::move (backend);
                _base = static_cast<char*> (_backend.get ());
                _capacity = capacity;
                _cursor.store (0);
            }
            catch (...)
            {
                return nullptr;
            }
            return allocate (size, alignment);
        }
 
        void release () noexcept
        {
            if (_previous != nullptr)
            {
                _previous->~BasicBumpAllocator ();
                _previous = nullptr;
            }
        }
 
        Backend _backend;
 
        BasicBumpAllocator* _previous = nullptr;
 
        char* _base = nullptr;
 
        uint64_t _capacity = Capacity;
 
        SyncPolicy _cursor;
    };
 
    class BumpAtomic
    {
    public:
        BumpAtomic () noexcept = default;
 
        BumpAtomic (BumpAtomic&& other) noexcept
        : _value (other._value.load (std::memory_order_relaxed))
        {
        }
 
        BumpAtomic& operator= (BumpAtomic&& other) noexcept
        {
            _value.store (other._value.load (std::memory_order_relaxed), std::memory_order_relaxed);
            return *this;
        }
 
        uint64_t load () const noexcept
        {
            return _value.load (std::memory_order_relaxed);
        }
 
        void store (uint64_t value) noexcept
        {
            _value.store (value, std::memory_order_relaxed);
        }
 
        bool advance (uint64_t& expected, uint64_t desired) noexcept
        {
            return _value.compare_exchange_weak (expected, desired, std::memory_order_relaxed);
        }
 
    private:
        alignas (64) std::atomic_uint64_t _value{0};
    };
 
    class BumpPlain
    {
    public:
        uint64_t load () const noexcept
        {
            return _value;
        }
 
        void store (uint64_t value) noexcept
        {
            _value = value;
        }
 
        bool advance ([[maybe_unused]] uint64_t& expected, uint64_t desired) noexcept
        {
            _value = desired;
            return true;
        }
 
    private:
        uint64_t _value = 0;
    };
}
 
#endif