standard_allocator.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_MEMORY_STANDARD_ALLOCATOR_HPP__
#define NEFORCE_CORE_MEMORY_STANDARD_ALLOCATOR_HPP__

 
#include <new>
#include "NeForce/core/exception/debug.hpp"
#include "NeForce/core/exception/exception.hpp"
NEFORCE_BEGIN_NAMESPACE__


NEFORCE_INLINE17 constexpr size_t MEMORY_ALIGN_THRESHHOLD = 16;

NEFORCE_INLINE17 constexpr size_t MEMORY_BIG_ALLOC_THRESHHOLD = 4096;

NEFORCE_BEGIN_INNER__

using alloc_size_t =
#ifdef NEFORCE_COMPILER_GCC
        uint32_t;
#else
        size_t;
#endif
 
 
#ifdef NEFORCE_COMPILER_MSVC

NEFORCE_INLINE17 constexpr size_t MEMORY_BIG_ALLOC_ALIGN = 32;

NEFORCE_INLINE17 constexpr size_t MEMORY_NO_USER_SIZE = sizeof(void*) + MEMORY_BIG_ALLOC_ALIGN -
                                                        static_cast<size_t>(1)
#    ifdef NEFORCE_STATE_DEBUG
                                                                * static_cast<size_t>(2)
#    endif
        ;

NEFORCE_INLINE17 constexpr size_t MEMORY_BIG_ALLOC_SENTINEL =
#    ifdef NEFORCE_ARCH_BITS_64
        0xFAFAFAFAFAFAFAFAUL;
#    else
        0xFAFAFAFAUL;
#    endif
 
#endif // NEFORCE_COMPILER_MSVC
 

template <size_t Align>
NEFORCE_ALLOC_OPTIMIZE NEFORCE_CONSTEXPR20 void* __allocate_aux(const alloc_size_t bytes) {
#ifdef NEFORCE_COMPILER_MSVC
    if (bytes >= MEMORY_BIG_ALLOC_THRESHHOLD) {
        const size_t block_size = MEMORY_NO_USER_SIZE + bytes;
        if (block_size <= bytes) {
            NEFORCE_THROW_EXCEPTION(memory_exception("invalid block size."));
        }
        const auto holder = reinterpret_cast<uintptr_t>(operator new(block_size));
        NEFORCE_DEBUG_VERIFY(holder != 0, "invalid argument");
        auto* const ptr = reinterpret_cast<void*>((holder + MEMORY_NO_USER_SIZE) & ~(MEMORY_BIG_ALLOC_ALIGN - 1));
        static_cast<uintptr_t*>(ptr)[-1] = holder;
#    ifdef NEFORCE_STATE_DEBUG
        static_cast<uintptr_t*>(ptr)[-2] = MEMORY_BIG_ALLOC_SENTINEL;
#    endif
        return ptr;
    }
#endif
    return operator new(bytes);
}
 
#ifdef NEFORCE_STANDARD_17

template <size_t Align, enable_if_t<(Align > MEMORY_ALIGN_THRESHHOLD), int> = 0>
NEFORCE_ALLOC_OPTIMIZE NEFORCE_CONSTEXPR20 void* __allocate_dispatch(const alloc_size_t bytes) {
    size_t align = Align;
#    ifdef NEFORCE_COMPILER_MSVC
    if (bytes >= MEMORY_BIG_ALLOC_THRESHHOLD) {
        align = Align > MEMORY_BIG_ALLOC_ALIGN ? Align : MEMORY_BIG_ALLOC_ALIGN;
    }
#    endif
#    if defined(NEFORCE_COMPILER_CLANG) && defined(NEFORCE_STANDARD_20)
    if (_NEFORCE is_constant_evaluated()) {
        return operator new(bytes);
    }
#    endif
    return operator new(bytes, std::align_val_t{align});
}

template <size_t Align, enable_if_t<Align <= MEMORY_ALIGN_THRESHHOLD, int> = 0>
NEFORCE_ALLOC_OPTIMIZE NEFORCE_CONSTEXPR20 void* __allocate_dispatch(const alloc_size_t bytes) {
    return inner::__allocate_aux<Align>(bytes);
}
 
#endif
 
NEFORCE_END_INNER__

template <size_t Align>
NEFORCE_ALLOC_OPTIMIZE NEFORCE_CONSTEXPR20 void* allocate(const inner::alloc_size_t bytes) {
    if (bytes == 0) {
        return nullptr;
    }
#ifdef NEFORCE_STANDARD_20
    if (_NEFORCE is_constant_evaluated()) {
        return operator new(bytes);
    }
#endif // NEFORCE_STANDARD_20
 
#ifdef NEFORCE_STANDARD_17
    return inner::__allocate_dispatch<Align>(bytes);
#else
    return inner::__allocate_aux<Align>(bytes);
#endif // NEFORCE_STANDARD_17
}
 

NEFORCE_BEGIN_INNER__

template <size_t Align>
void __deallocate_aux(void*& ptr, inner::alloc_size_t& bytes) noexcept {
#ifdef NEFORCE_COMPILER_MSVC
    if (bytes >= MEMORY_BIG_ALLOC_THRESHHOLD) {
        bytes += MEMORY_NO_USER_SIZE;
        const uintptr_t* const user_ptr = static_cast<uintptr_t*>(ptr);
        const uintptr_t holder = user_ptr[-1];
        NEFORCE_DEBUG_VERIFY(user_ptr[-2] == MEMORY_BIG_ALLOC_SENTINEL, "invalid sentinel.");
#    ifdef NEFORCE_STATE_DEBUG
        constexpr uintptr_t min_shift = 2 * sizeof(void*);
#    else
        constexpr uintptr_t min_shift = sizeof(void*);
#    endif
        const uintptr_t shift = reinterpret_cast<uintptr_t>(ptr) - holder;
        NEFORCE_DEBUG_VERIFY(shift >= min_shift && shift <= MEMORY_NO_USER_SIZE, "invalid argument.");
        ptr = reinterpret_cast<void*>(holder);
    }
#endif
#if defined(NEFORCE_STANDARD_14) && defined(NEFORCE_COMPILER_MSVC)
    operator delete(ptr, bytes);
#else
    operator delete(ptr);
#endif
}
 
#ifdef NEFORCE_STANDARD_17

template <size_t Align, enable_if_t<(Align > MEMORY_ALIGN_THRESHHOLD), int> = 0>
NEFORCE_CONSTEXPR20 void __deallocate_dispatch(void*& ptr, inner::alloc_size_t& bytes) noexcept {
    size_t align = Align;
#    ifdef NEFORCE_COMPILER_MSVC
    if (bytes > MEMORY_BIG_ALLOC_THRESHHOLD) {
        align = Align > MEMORY_BIG_ALLOC_ALIGN ? Align : MEMORY_BIG_ALLOC_ALIGN;
    }
#    endif
#    if defined(NEFORCE_STANDARD_14) && defined(NEFORCE_COMPILER_MSVC)
    operator delete(ptr, bytes, std::align_val_t{align});
#    else
    operator delete(ptr, std::align_val_t{align});
#    endif
}

template <size_t Align, enable_if_t<Align <= MEMORY_ALIGN_THRESHHOLD, int> = 0>
NEFORCE_CONSTEXPR20 void __deallocate_dispatch(void*& ptr, inner::alloc_size_t& bytes) noexcept {
    inner::__deallocate_aux<Align>(ptr, bytes);
}
 
#endif // NEFORCE_STANDARD_17
 
NEFORCE_END_INNER__

template <size_t Align>
NEFORCE_CONSTEXPR20 void deallocate(void* ptr, inner::alloc_size_t bytes) noexcept {
#ifdef NEFORCE_STANDARD_20
    if (_NEFORCE is_constant_evaluated()) {
        operator delete(ptr);
        return;
    }
#endif // NEFORCE_STANDARD_20
 
#ifdef NEFORCE_STANDARD_17
    inner::__deallocate_dispatch<Align>(ptr, bytes);
#else
    inner::__deallocate_aux<Align>(ptr, bytes);
#endif // NEFORCE_STANDARD_17
}
 

template <typename T>
class standard_allocator {
    static_assert(is_allocable_v<T>, "allocator can`t alloc void, reference, function or const type.");
 
public:
    using value_type = T;                  
    using pointer = T*;                    
    using size_type = inner::alloc_size_t; 

    template <typename U>
    struct rebind {
        using other = standard_allocator<U>;
    };
 
private:
    static constexpr inner::alloc_size_t align_size = alignof(T) > MEMORY_ALIGN_THRESHHOLD ? alignof(T)
                                                                                           : MEMORY_ALIGN_THRESHHOLD;
 
public:
    NEFORCE_CONSTEXPR20 standard_allocator() noexcept = default; 

    template <typename U>
    NEFORCE_CONSTEXPR20 standard_allocator(const standard_allocator<U>& /*unused*/) noexcept {}
 
    NEFORCE_CONSTEXPR20 ~standard_allocator() noexcept = default; 
 
    NEFORCE_CONSTEXPR20 standard_allocator& operator=(const standard_allocator&) noexcept = default; 

    NEFORCE_ALLOC_NODISCARD NEFORCE_CONSTEXPR20 NEFORCE_ALLOC_OPTIMIZE static pointer allocate(const size_type n) {
        const size_type alloc_size = sizeof(value_type) * n;
        NEFORCE_DEBUG_VERIFY(alloc_size <= static_cast<size_type>(-1), "allocation will cause memory overflow.");
        try {
            return static_cast<T*>(_NEFORCE allocate<align_size>(alloc_size));
        } catch (...) {
            NEFORCE_THROW_EXCEPTION(allocate_exception("standard allocate failed"));
        }
        unreachable();
    }

    NEFORCE_ALLOC_NODISCARD NEFORCE_CONSTEXPR20 NEFORCE_ALLOC_OPTIMIZE static pointer allocate() {
        return standard_allocator::allocate(1);
    }

    NEFORCE_CONSTEXPR20 static void deallocate(pointer p, const size_type n) noexcept {
        NEFORCE_DEBUG_VERIFY(p != nullptr || n == 0, "null pointer cannot point to a block of non-zero size");
        _NEFORCE deallocate<align_size>(p, n * sizeof(value_type));
    }

    NEFORCE_CONSTEXPR20 static void deallocate(pointer p) noexcept { standard_allocator::deallocate(p, 1); }

    NEFORCE_NODISCARD static constexpr size_type max_size() noexcept {
        return static_cast<size_type>(-1) / sizeof(value_type);
    }
};

template <typename T, typename U>
NEFORCE_NODISCARD NEFORCE_CONSTEXPR20 bool operator==(const standard_allocator<T>& /*unused*/,
                                                      const standard_allocator<U>& /*unused*/) noexcept {
    return true;
}

template <typename T, typename U>
NEFORCE_NODISCARD NEFORCE_CONSTEXPR20 bool operator!=(const standard_allocator<T>& /*unused*/,
                                                      const standard_allocator<U>& /*unused*/) noexcept {
    return false;
}
 

template <typename T>
using allocator = standard_allocator<T>;
 // MemoryAllocator
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_MEMORY_STANDARD_ALLOCATOR_HPP__