hxmemory_manager.h

Go to the documentation of this file.

#pragma once
// SPDX-FileCopyrightText: © 2017-2026 Adrian Johnston.
// SPDX-License-Identifier: MIT
// This file is licensed under the MIT license found in the LICENSE.md file.

 
#if !LIBHATCHET_VER
#error #include <hx/libhatchet.h> instead.
#endif
 
#if HX_CPLUSPLUS && (HX_USE_LIBCXX)
#include <new>
#endif
 
HX_C_BEGIN_

typedef unsigned int hxalignment_t;
 
#if HX_CPLUSPLUS >= 202002L
inline constexpr hxalignment_t hxalignment = static_cast<hxalignment_t>(alignof(max_align_t ));
#elif HX_CPLUSPLUS
#define hxalignment static_cast<hxalignment_t>(alignof(max_align_t ))
#else
#define hxalignment (hxalignment_t)_Alignof(max_align_t )
#endif

typedef int hxsystem_allocator_t;
 
enum {
    hxsystem_allocator_current = -1,
    hxsystem_allocator_heap,
    hxsystem_allocator_permanent,
    hxsystem_allocator_stack_0
};

void hxfree(void* ptr_) hxattr_noexcept hxattr_hot;

hxattr_allocator(hxfree) hxattr_noexcept hxattr_hot
void* hxmalloc(size_t size_);

hxattr_noexcept hxattr_allocator(hxfree) hxattr_hot
void* hxmalloc_ext(size_t size_, hxsystem_allocator_t allocator_,
    hxalignment_t alignment_/*=hxalignment*/);

hxattr_noexcept hxattr_allocator(hxfree) hxattr_nonnull(1) hxattr_hot
char* hxstring_duplicate(const char* string_,
    hxsystem_allocator_t allocator_ /*=hxsystem_allocator_current*/);
 
HX_C_END_
#if HX_CPLUSPLUS

hxinline void* hxmalloc(size_t size_, hxsystem_allocator_t allocator_,
        hxalignment_t alignment_=hxalignment) {
    return hxmalloc_ext(size_, allocator_, alignment_);
}

hxinline char* hxstring_duplicate(const char* s_) {
    return hxstring_duplicate(s_, hxsystem_allocator_current);
}
 
// Memory Manager C++ API
 
#if !(HX_USE_LIBCXX)
// Declare placement new. These are not built into the compiler.
// HX_PROVIDE_NEW_DELETE is concerned with the other versions of new and delete.
#if HX_CPLUSPLUS >= 202002L
constexpr void* operator new(size_t, void* ptr_) noexcept { return ptr_; }
constexpr void* operator new[](size_t, void* ptr_) noexcept { return ptr_; }
#else
hxinline void* operator new(size_t, void* ptr_) noexcept { return ptr_; }
hxinline void* operator new[](size_t, void* ptr_) noexcept { return ptr_; }
#endif
 
#if (HX_PROVIDE_NEW_DELETE) != -1
// Provide these for constant evaluation/consteval. Link errors may still result.
// Use HX_PROVIDE_NEW_DELETE=-1 when compiling a module to prevent declaration.
void* operator new(size_t size_) hxattr_nodiscard;
void* operator new[](size_t size_) hxattr_nodiscard;
void operator delete(void* ptr_) noexcept;
void operator delete[](void* ptr_) noexcept;
#endif
#endif
 
HX_NS_BEGIN_

class hxsystem_allocator_scope
{
public:
    hxsystem_allocator_scope(hxsystem_allocator_t allocator_) hxattr_noexcept;

    ~hxsystem_allocator_scope(void) hxattr_noexcept;

    hxattr_nodiscard size_t get_current_allocation_count(void) const;

    hxattr_nodiscard size_t get_current_bytes_allocated(void) const;

    hxattr_nodiscard size_t get_initial_allocation_count(void) const {
        return m_initial_allocation_count_;
    }

    hxattr_nodiscard size_t get_initial_bytes_allocated(void) const {
        return m_initial_bytes_allocated_;
    }
 
private:
    // The hxsystem_allocator_* classes are responsible for setting
    // m_initial_allocation_count_ and m_initial_bytes_allocated_.
    // This avoids a number of potential cache misses.
    friend hxinline void hxsystem_allocator_scope_init_(hxsystem_allocator_scope* scope_,
        size_t allocation_count_, size_t bytes_allocated_);
 
    // Deleted copy constructor to prevent copying.
    hxsystem_allocator_scope(const hxsystem_allocator_scope&) = delete;
 
    // Deleted assignment operator to prevent copying.
    void operator=(const hxsystem_allocator_scope&) = delete;
 
    hxsystem_allocator_t m_this_allocator_;
    hxsystem_allocator_t m_initial_allocator_;
    size_t m_initial_allocation_count_;
    size_t m_initial_bytes_allocated_;
};

template <typename T_, hxsystem_allocator_t allocator_=hxsystem_allocator_current,
    hxalignment_t align_=hxalignment, typename... Args_>
T_* hxnew(Args_&&... args_) noexcept {
    // Implements hxforward.
    return ::new(hxmalloc_ext(sizeof(T_), allocator_, align_)) T_(static_cast<Args_&&>(args_)...);
}

template <typename T_>
void hxdelete(T_* t_) noexcept {
    if(t_) {
        t_->~T_();
        hxfree(const_cast<void*>(static_cast<const void*>(t_)));
    }
}

class hxdefault_delete {
public:
    template <typename T_>
    void operator()(T_* t_) const { hxdelete(t_); }

    operator bool(void) const { return true; }
};

class hxdo_not_delete {
public:
    template <typename T_>
    void operator()(T_*) const { }

    operator bool(void) const { return false; }
};
 
#if HX_CPLUSPLUS >= 201402L
class hxconsteval_delete {
public:
    // GCOVR_EXCL_START. No coverage at compile time.
    template <typename T_>
    constexpr void operator()(T_* t_) const { ::delete t_; }

    constexpr operator bool(void) const { return true; }
    // GCOVR_EXCL_STOP
};
#endif
 
// `hxmemory_manager_init_` - WARNING: Not intended for direct use. This is
// called by hxinit(). Initializes the memory manager. Must be called before
// using any memory manager functions.
void hxmemory_manager_init_(void) hxattr_cold;
 
// `hxmemory_manager_shut_down_` - WARNING: Not intended for direct use. Shuts
// down the memory manager. Frees any remaining resources.
void hxmemory_manager_shut_down_(void) hxattr_cold;

void hxmemory_manager_allocate_stacks(const size_t* sizes_, size_t stack_count_) hxattr_cold;

template<size_t stack_count_>
void hxmemory_manager_allocate_stacks(const size_t(&list_)[stack_count_]) {
    hxmemory_manager_allocate_stacks(list_, stack_count_);
}

class hxmemory_manager_stats {
public:
    size_t allocations_outstanding;
    size_t bytes_outstanding;
    size_t allocator_overflows;
};

hxmemory_manager_stats hxmemory_manager_utilization(bool stacks_only_, bool log_) hxattr_cold;
 
HX_NS_END_
#endif // HX_CPLUSPLUS