standard_allocator.hpp

浏览该文件的文档.

#ifndef MSTL_CORE_MEMORY_STANDARD_ALLOCATOR_HPP__
#define MSTL_CORE_MEMORY_STANDARD_ALLOCATOR_HPP__

 
#include "MSTL/core/exception/exception.hpp"
#include <new>
MSTL_BEGIN_NAMESPACE__


MSTL_ERROR_BUILD_FINAL_CLASS(allocate_exception, memory_exception, "Memory Allocation Failed.")
 
 // Exceptions
 

 

MSTL_INLINE17 constexpr size_t MEMORY_ALIGN_THRESHHOLD = 16;

MSTL_INLINE17 constexpr size_t MEMORY_BIG_ALLOC_THRESHHOLD = 4096;

MSTL_BEGIN_INNER__

using alloc_size_t = size_t;

// #ifdef MSTL_COMPILER_GCC__
// using alloc_size_t = uint32_t;
// #else
// using alloc_size_t = size_t;
// #endif
 
 
#ifdef MSTL_COMPILER_MSVC__

MSTL_INLINE17 constexpr size_t MEMORY_BIG_ALLOC_ALIGN = 32;

MSTL_INLINE17 constexpr size_t MEMORY_NO_USER_SIZE =
    sizeof(void*) + MEMORY_BIG_ALLOC_ALIGN - 1
#ifdef MSTL_STATE_DEBUG__
    * 2
#endif
;

MSTL_INLINE17 constexpr size_t MEMORY_BIG_ALLOC_SENTINEL =
#ifdef MSTL_DATA_BUS_WIDTH_64__
    0xFAFAFAFAFAFAFAFAUL;
#else
    0xFAFAFAFAUL;
#endif
 
#endif // MSTL_COMPILER_MSVC__
 

template <size_t Align>
MSTL_ALLOC_OPTIMIZE MSTL_CONSTEXPR20 void* __allocate_aux(const alloc_size_t bytes) {
#ifdef MSTL_COMPILER_MSVC__
    if (bytes >= MEMORY_BIG_ALLOC_THRESHHOLD) {
        const size_t block_size = MEMORY_NO_USER_SIZE + bytes;
        if (block_size <= bytes)
            throw_exception(memory_exception("invalid block size."));
        const auto holder = reinterpret_cast<uintptr_t>(operator new(block_size));
        MSTL_DEBUG_VERIFY(holder != 0, "invalid argument");
        const auto ptr = reinterpret_cast<void*>(
            (holder + MEMORY_NO_USER_SIZE) & ~(MEMORY_BIG_ALLOC_ALIGN - 1)); // align the memory address
        static_cast<uintptr_t*>(ptr)[-1] = holder;
#ifdef MSTL_STATE_DEBUG__
        static_cast<uintptr_t*>(ptr)[-2] = MEMORY_BIG_ALLOC_SENTINEL;
#endif
        return ptr;
    }
#endif
    return operator new(bytes);
}
 
#ifdef MSTL_STANDARD_17__

template <size_t Align, enable_if_t<(Align > MEMORY_ALIGN_THRESHHOLD) ,int> = 0>
MSTL_ALLOC_OPTIMIZE MSTL_CONSTEXPR20 void* __allocate_dispatch(const alloc_size_t bytes) {
    size_t align = Align;
#ifdef MSTL_COMPILER_MSVC__
    if (bytes >= MEMORY_BIG_ALLOC_THRESHHOLD)
        align = Align > MEMORY_BIG_ALLOC_ALIGN ? Align : MEMORY_BIG_ALLOC_ALIGN;
#endif
#if defined(MSTL_COMPILER_CLANG__) && defined(MSTL_STANDARD_20__)
    if (_MSTL 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>
MSTL_ALLOC_OPTIMIZE MSTL_CONSTEXPR20 void* __allocate_dispatch(const alloc_size_t bytes) {
    return _INNER __allocate_aux<Align>(bytes);
}
 
#endif
 
MSTL_END_INNER__

template <size_t Align>
MSTL_ALLOC_OPTIMIZE MSTL_CONSTEXPR20 void* allocate(const _INNER alloc_size_t bytes) {
    if (bytes == 0) return nullptr;
#ifdef MSTL_STANDARD_20__
    if (_MSTL is_constant_evaluated())
        return operator new(bytes);
#endif // MSTL_STANDARD_20__
 
#ifdef MSTL_STANDARD_17__
    return _INNER __allocate_dispatch<Align>(bytes);
#else
    return _INNER __allocate_aux<Align>(bytes);
#endif // MSTL_STANDARD_17__
}
 

MSTL_BEGIN_INNER__

template <size_t Align>
void __deallocate_aux(void*& ptr, _INNER alloc_size_t& bytes) noexcept {
#ifdef MSTL_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];
        MSTL_DEBUG_VERIFY(user_ptr[-2] == MEMORY_BIG_ALLOC_SENTINEL, "invalid sentinel.");
#ifdef MSTL_STATE_DEBUG__
        constexpr uintptr_t min_shift = 2 * sizeof(void*);
#else
        constexpr uintptr_t min_shift = sizeof(void*);
#endif // MSTL_STATE_DEBUG__
        const uintptr_t shift = reinterpret_cast<uintptr_t>(ptr) - holder;
        MSTL_DEBUG_VERIFY(shift >= min_shift && shift <= MEMORY_NO_USER_SIZE, "invalid argument.");
        ptr = reinterpret_cast<void*>(holder);
    }
#endif
    operator delete(ptr
#if defined(MSTL_STANDARD_14__) && defined(MSTL_COMPILER_MSVC__)
        , bytes
#endif
        );
}
 
#ifdef MSTL_STANDARD_17__

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

template <size_t Align, enable_if_t<Align <= MEMORY_ALIGN_THRESHHOLD, int> = 0>
MSTL_CONSTEXPR20 void __deallocate_dispatch(void*& ptr, _INNER alloc_size_t& bytes) noexcept {
    _INNER __deallocate_aux<Align>(ptr, bytes);
}
 
#endif // MSTL_STANDARD_17__
 
MSTL_END_INNER__

template <size_t Align>
MSTL_CONSTEXPR20 void deallocate(void* ptr, _INNER alloc_size_t bytes) noexcept {
#ifdef MSTL_STANDARD_20__
    if (_MSTL is_constant_evaluated()) {
        operator delete(ptr);
        return;
    }
#endif // MSTL_STANDARD_20__
 
#ifdef MSTL_STANDARD_17__
    _INNER __deallocate_dispatch<Align>(ptr, bytes);
#else
    _INNER __deallocate_aux<Align>(ptr, bytes);
#endif // MSTL_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 FINAL_ALIGN_SIZE =
        alignof(T) > MEMORY_ALIGN_THRESHHOLD ? alignof(T) : MEMORY_ALIGN_THRESHHOLD;\
 
    static constexpr size_type VALUE_SIZE = sizeof(value_type);  
 
public:
    MSTL_CONSTEXPR20 standard_allocator() noexcept = default;  

    template <typename U>
    MSTL_CONSTEXPR20 standard_allocator(const standard_allocator<U>&) noexcept {}
 
    MSTL_CONSTEXPR20 ~standard_allocator() noexcept = default;  
 
    MSTL_CONSTEXPR20 standard_allocator& operator =(const standard_allocator&) noexcept = default;  

    MSTL_ALLOC_NODISCARD MSTL_CONSTEXPR20 MSTL_ALLOC_OPTIMIZE static pointer allocate(const size_type n) {
        const size_type alloc_size = VALUE_SIZE * n;
        MSTL_DEBUG_VERIFY(
            alloc_size <= static_cast<size_type>(-1),
            "allocation will cause memory overflow.");
        try {
            return static_cast<T*>(_MSTL allocate<FINAL_ALIGN_SIZE>(alloc_size));
        } catch (...) {
            throw_exception(allocate_exception("standard allocate failed"));
        }
        MSTL_UNREACHABLE;
    }

    MSTL_ALLOC_NODISCARD MSTL_CONSTEXPR20 MSTL_ALLOC_OPTIMIZE static pointer allocate() {
        return standard_allocator::allocate(1);
    }

    MSTL_CONSTEXPR20 static void deallocate(pointer p, const size_type n) noexcept {
        MSTL_DEBUG_VERIFY(p != nullptr || n == 0, "null pointer cannot point to a block of non-zero size");
        _MSTL deallocate<FINAL_ALIGN_SIZE>(p, n * VALUE_SIZE);
    }

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

template <typename T, typename U>
MSTL_NODISCARD MSTL_CONSTEXPR20 bool operator ==(
    const standard_allocator<T>&, const standard_allocator<U>&) noexcept {
    return true;
}

template <typename T, typename U>
MSTL_NODISCARD MSTL_CONSTEXPR20 bool operator !=(
    const standard_allocator<T>&, const standard_allocator<U>&) noexcept {
    return false;
}
 

template <typename T>
using allocator = standard_allocator<T>;
 // MemoryAllocator
 
MSTL_END_NAMESPACE__
#endif // MSTL_CORE_MEMORY_STANDARD_ALLOCATOR_HPP__