allocator.h

Go to the documentation of this file.

// =====================================================================================================================
//  fennec, a free and open source game engine
//  Copyright © 2025  Medusa Slockbower
//
//  This program is free software: you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation, either version 3 of the License, or
//  (at your option) any later version.
//
//  This program is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//
//  You should have received a copy of the GNU General Public License
//  along with this program.  If not, see <https://www.gnu.org/licenses/>.
// =====================================================================================================================
 
 
 
#ifndef FENNEC_MEMORY_ALLOCATOR_H
#define FENNEC_MEMORY_ALLOCATOR_H
 
#include <fennec/memory/pointer_traits.h>
#include <fennec/memory/new.h>
 
#include <fennec/lang/conditional_types.h>
#include <fennec/lang/numeric_transforms.h>
#include <fennec/lang/types.h>
#include <fennec/lang/type_traits.h>
 
#include <fennec/math/ext/constants.h>
#include <fennec/math/common.h>
 
 
#ifdef FENNEC_COMPILER_GCC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wchanges-meaning"
#endif
 
 
namespace fennec
{
 
template<class Alloc>
struct allocator_traits
{
private:
    // These help with using concepts in `detect_t`
    template<typename ClassT> using _pointer            = typename ClassT::pointer_t;
    template<typename ClassT> using _const_pointer      = typename ClassT::const_pointer_t;
    template<typename ClassT> using _void_pointer       = typename ClassT::void_pointer_t;
    template<typename ClassT> using _void_const_pointer = typename ClassT::void_const_pointer_t;
 
    // Propagation Patterns
    template<typename ClassT> using _propagate_on_containter_copy_assignment = typename ClassT::propagate_on_containter_copy_assignment;
    template<typename ClassT> using _propagate_on_containter_move_assignment = typename ClassT::propagate_on_containter_move_assignment;
    template<typename ClassT> using _propagate_on_containter_swap            = typename ClassT::propagate_on_containter_swap;
 
    template<typename ClassT> using _is_always_equal = typename ClassT::is_always_equal;
 
    template<typename AllocT, typename TypeT>
    struct _rebind : replace_first_element<AllocT, TypeT> {};
 
    template<typename AllocT, typename TypeT>
    requires requires { typename AllocT::template rebind<TypeT>::other; }
    struct _rebind<AllocT, TypeT> { using type = typename AllocT::template rebind<TypeT>::other; };
 
    // This detects AllocT::diff_t if present, otherwise uses the diff_t associated with PtrT
    // It works using SFINAE, 'typename = void' forces the second _diff to be evaluated first when
    // _diff is substituted using only two template arguments. That one uses 'type = typename AllocT::diff_t'
    // however, if it fails, the compiler moves on to the original definition. _size works in the same manner.
    template<typename AllocT, typename PtrT, typename = void>
    struct _diff { using type = typename pointer_traits<PtrT>::diff_t; };
 
    template<typename AllocT, typename PtrT>
    struct _diff<AllocT, PtrT, void_t<typename AllocT::diff_t>> { using type = typename AllocT::diff_t; };
 
    template<typename AllocT, typename DiffT, typename = void>
    struct _size : make_unsigned<DiffT> {};
 
    template<typename AllocT, typename DiffT>
    struct _size<AllocT, DiffT, void_t<typename AllocT::size_t>> { using type = typename AllocT::size_t; };
 
public:
 
    using alloc_t = Alloc;
 
    using value_t = typename Alloc::value_t;
 
    using pointer_t = detect_t<value_t*, _pointer, Alloc>;
 
    using const_pointer_t = detect_t<const value_t*, _const_pointer, Alloc>;
 
    using void_pointer_t = detect_t<void*, _void_pointer, Alloc>;
 
    using const_void_pointer_t = detect_t<const void*, _void_const_pointer, Alloc>;
 
    using diff_t = typename _diff<Alloc, pointer_t>::type;
 
    using size_t = typename _size<Alloc, pointer_t>::type;
 
    // TODO: Document propagation
    using propagate_on_container_copy_assignment = detect_t<false_type, _propagate_on_containter_copy_assignment, Alloc>;
    using propagate_on_container_move_assignment = detect_t<false_type, _propagate_on_containter_move_assignment, Alloc>;
    using propagate_on_container_swap = detect_t<false_type, _propagate_on_containter_swap, Alloc>;
 
    using is_always_equal = detect_t<false_type, _is_always_equal, Alloc>;
 
    template<typename TypeT> using rebind = typename _rebind<Alloc, TypeT>::type;
 
    // TODO: allocator_traits static functions
};
 
 
template<typename T>
class allocator
{
public:
    using value_t = T;
 
    template<typename R> using rebind = allocator<R>;
 
    constexpr allocator() = default;
 
    constexpr ~allocator() = default;
 
    constexpr allocator(const allocator&) = default;
 
    constexpr allocator& operator=(const allocator&) = default;
 
 
    constexpr bool_t operator==(const allocator&) {
        return true;
    }
 
    constexpr bool_t operator!=(const allocator&) {
        return false;
    }
 
    template<typename U> constexpr bool_t operator==(const allocator<U>&) {
        return true;
    }
 
    template<typename U> constexpr bool_t operator!=(const allocator<U>&) {
        return true;
    }
 
    constexpr T* allocate(size_t n) {
        return static_cast<T*>(::operator new(n * sizeof(T)));
    }
 
    constexpr T* allocate(size_t n, align_t align) {
        return static_cast<T*>(::operator new(n * sizeof(T), align));
    }
 
    constexpr void deallocate(T* ptr) {
        return ::operator delete(ptr);
    }
 
    constexpr void deallocate(T* ptr, align_t align) {
        return ::operator delete(ptr, align);
    }
};
 
 
template<typename T>
class allocator<T[]>
{
public:
    using value_t = T;
 
    template<typename R> using rebind = allocator<R>;
 
    constexpr allocator() = default;
 
    constexpr ~allocator() = default;
 
    constexpr allocator(const allocator&) = default;
 
    constexpr allocator& operator=(const allocator&) = default;
 
 
    constexpr bool_t operator==(const allocator&) {
        return true;
    }
 
    constexpr bool_t operator!=(const allocator&) {
        return false;
    }
 
    template<typename U> constexpr bool_t operator==(const allocator<U>&) {
        return true;
    }
 
    template<typename U> constexpr bool_t operator!=(const allocator<U>&) {
        return true;
    }
 
    constexpr T* allocate(size_t n) {
        return static_cast<T*>(::operator new[](n * sizeof(T)));
    }
 
    constexpr T* allocate(size_t n, align_t align) {
        return static_cast<T*>(::operator new[](n * sizeof(T), align));
    }
 
    constexpr void deallocate(T* ptr) {
        return ::operator delete[](ptr);
    }
 
    constexpr void deallocate(T* ptr, align_t align) {
        return ::operator delete[](ptr, align);
    }
};
 
 
template<typename T, class AllocT = allocator<T>>
struct allocation
{
public:
    using alloc_t = typename allocator_traits<AllocT>::template rebind<T>;
 
    using value_t = T;
 
    using size_t = size_t;
 
    using diff_t = ptrdiff_t;
 
 
    // Cosntructors ========================================================================================================
 
    constexpr allocation() noexcept
        : _data(nullptr), _capacity(0), _alignment(zero<align_t>()) {
    }
 
    explicit constexpr allocation(size_t n) noexcept
        : _data(nullptr), _capacity(0), _alignment(zero<align_t>()) {
        callocate(n);
    }
 
    constexpr allocation(const T* data, size_t n)
        : allocation(n) {
        fennec::memmove(_data, data, n);
    }
 
    constexpr allocation(size_t n, align_t align) noexcept
        : _data(nullptr)
        , _capacity(0)
        , _alignment(align) {
        callocate(n, align);
    }
 
    constexpr allocation(const T* data, size_t n, align_t align)
        : allocation(n, align) {
        fennec::memmove(static_cast<void*>(_data), data, n);
    }
 
    explicit constexpr allocation(const alloc_t& alloc) noexcept
        : _alloc(alloc)
        , _data(nullptr)
        , _capacity(0)
        , _alignment(zero<align_t>()){
    }
 
    constexpr allocation(size_t n, const alloc_t& alloc) noexcept
        : _alloc(alloc)
        , _data(nullptr)
        , _capacity(0)
        , _alignment(zero<align_t>()) {
        callocate(n);
    }
 
    constexpr allocation(const T* data, size_t n, const alloc_t& alloc)
        : allocation(n, alloc) {
        fennec::memmove(static_cast<void*>(_data), data, n);
    }
 
    constexpr allocation(size_t n, align_t align, const alloc_t& alloc) noexcept
        : _alloc(alloc)
        , _data(nullptr)
        , _capacity(0)
        , _alignment(zero<align_t>()) {
        callocate(n, align);
    }
 
    constexpr allocation(const T* data, size_t n, align_t align, const alloc_t& alloc)
        : allocation(n, align, alloc) {
        fennec::memmove(_data, data, n);
    }
 
    constexpr allocation(const allocation& alloc) noexcept
        : _alloc(alloc._alloc)
        , _data(_alloc.allocate(alloc._capacity))
        , _capacity(alloc._capacity)
        , _alignment(alloc._alignment) {
        fennec::memmove(static_cast<void*>(_data), alloc._data, alloc._capacity * sizeof(T));
    }
 
    constexpr allocation(allocation&& alloc) noexcept
        : _alloc(alloc._alloc)
        , _data(alloc._data)
        , _capacity(alloc._capacity)
        , _alignment(alloc._alignment) {
        alloc._data = nullptr; alloc._capacity = 0;
    }
 
 
    constexpr ~allocation() noexcept {
        if (_data) {
            _alloc.deallocate(_data);
            _data = nullptr;
        }
    }
 
 
// Assignment ==========================================================================================================
 
    constexpr allocation& operator=(const allocation& alloc) {
        allocation::allocate(alloc.capacity(), alloc.alignment());
        fennec::memmove(_data, alloc, size());
        return *this;
    }
 
    constexpr allocation& operator=(allocation&& alloc) noexcept {
 
        // Copy contents
        fennec::swap(_alloc, alloc._alloc);
        fennec::swap(_data, alloc._data);
        fennec::swap(_capacity, alloc._capacity);
        fennec::swap(_alignment, alloc._alignment);
 
        return *this;
    }
 
 
// Allocation and Deallocation =========================================================================================
 
    constexpr void allocate(size_t n, align_t align = zero<align_t>()) noexcept {
        deallocate();
 
        if (align != zero<align_t>()) {
            _data = _alloc.allocate(_capacity = n, _alignment = align);
        } else {
            _data = _alloc.allocate(_capacity = n);
        }
    }
 
    constexpr void callocate(size_t n, align_t align = zero<align_t>()) noexcept {
        allocate(n, align);
        fennec::memset(static_cast<void*>(_data), 0, _capacity * sizeof(T));
    }
 
    constexpr void deallocate() noexcept {
        if (_data) {
            if (_alignment != zero<align_t>()) {
                _alloc.deallocate(_data, _alignment);
            } else {
                _alloc.deallocate(_data);
            }
        }
 
        _data = nullptr;
        _capacity = 0;
        _alignment = zero<align_t>();
    }
 
    constexpr void reallocate(size_t n, align_t align = zero<align_t>()) noexcept {
        if (_data == nullptr) {
            allocate(n, align);
            return;
        }
 
        value_t* old = _data; size_t old_cap = _capacity;
        _data = nullptr;
        allocate(n, align);
 
        fennec::memmove(static_cast<void*>(_data), old, min(_capacity, old_cap) * sizeof(T));
 
        _alloc.deallocate(old);
        _capacity = n;
    }
 
    constexpr void creallocate(size_t n, align_t align = zero<align_t>()) noexcept {
        if (_data == nullptr) {
            callocate(n, align);
            return;
        }
 
        value_t* old = _data; size_t old_cap = _capacity;
        _data = nullptr;
        allocate(n, align);
 
        fennec::memmove(static_cast<void*>(_data), old, min(_capacity, old_cap) * sizeof(T));
 
        if (_capacity > old_cap) {
            fennec::memset(static_cast<void*>(_data + old_cap), 0, _capacity - old_cap);
        }
 
        _alloc.deallocate(old);
        _capacity = n;
    }
 
 
// Access ==============================================================================================================
 
    constexpr value_t& operator[](size_t i) {
        assertd(i < capacity(), "Array Out of Bounds");
        return _data[i];
    }
 
    constexpr const value_t& operator[](size_t i) const {
        assertd(i < capacity(), "Array Out of Bounds");
        return _data[i];
    }
 
    constexpr operator value_t*() {
        return _data;
    }
 
    constexpr operator const value_t*() const {
        return _data;
    }
 
    value_t* begin() {
        return _data;
    }
 
    value_t* end() {
        return _data + capacity();
    }
 
    const value_t* begin() const {
        return _data;
    }
 
    const value_t* end() const {
        return _data + capacity();
    }
 
 
// Modification ========================================================================================================
 
    constexpr void clear() noexcept {
        fennec::memset(_data, 0, _capacity * sizeof(T));
    }
 
    constexpr size_t size() const {
        return _capacity * sizeof(T);
    }
 
    constexpr size_t capacity() const {
        return _capacity;
    }
 
    constexpr value_t* data() {
        return _data;
    }
 
    constexpr const value_t* data() const {
        return _data;
    }
 
    constexpr align_t alignment() const {
        return _alignment;
    }
 
protected:
    alloc_t     _alloc; // Allocator object
    value_t*     _data; // Handle for the memory block
    size_t   _capacity; // Capacity of the memory block in elements.
    align_t _alignment; // Alignment information
};
 
#ifdef FENNEC_COMPILER_GCC
#pragma GCC diagnostic pop
#endif
 
}
 
#endif // FENNEC_MEMORY_ALLOCATOR_H