codekingpro/portable-devtools

1/* ----------------------------------------------------------------------------2Copyright (c) 2018-2023, Microsoft Research, Daan Leijen3This is free software; you can redistribute it and/or modify it under the4terms of the MIT license. A copy of the license can be found in the file5"LICENSE" at the root of this distribution.6-----------------------------------------------------------------------------*/7#pragma once8#ifndef MIMALLOC_H9#define MIMALLOC_H10 11#define MI_MALLOC_VERSION 212   // major + 2 digits minor12 13// ------------------------------------------------------14// Compiler specific attributes15// ------------------------------------------------------16 17#ifdef __cplusplus18  #if (__cplusplus >= 201103L) || (_MSC_VER > 1900)  // C++1119    #define mi_attr_noexcept   noexcept20  #else21    #define mi_attr_noexcept   throw()22  #endif23#else24  #define mi_attr_noexcept25#endif26 27#if defined(__cplusplus) && (__cplusplus >= 201703)28  #define mi_decl_nodiscard    [[nodiscard]]29#elif (defined(__GNUC__) && (__GNUC__ >= 4)) || defined(__clang__)  // includes clang, icc, and clang-cl30  #define mi_decl_nodiscard    __attribute__((warn_unused_result))31#elif defined(_HAS_NODISCARD)32  #define mi_decl_nodiscard    _NODISCARD33#elif (_MSC_VER >= 1700)34  #define mi_decl_nodiscard    _Check_return_35#else36  #define mi_decl_nodiscard37#endif38 39#if defined(_MSC_VER) || defined(__MINGW32__)40  #if !defined(MI_SHARED_LIB)41    #define mi_decl_export42  #elif defined(MI_SHARED_LIB_EXPORT)43    #define mi_decl_export              __declspec(dllexport)44  #else45    #define mi_decl_export              __declspec(dllimport)46  #endif47  #if defined(__MINGW32__)48    #define mi_decl_restrict49    #define mi_attr_malloc              __attribute__((malloc))50  #else51    #if (_MSC_VER >= 1900) && !defined(__EDG__)52      #define mi_decl_restrict          __declspec(allocator) __declspec(restrict)53    #else54      #define mi_decl_restrict          __declspec(restrict)55    #endif56    #define mi_attr_malloc57  #endif58  #define mi_cdecl                      __cdecl59  #define mi_attr_alloc_size(s)60  #define mi_attr_alloc_size2(s1,s2)61  #define mi_attr_alloc_align(p)62#elif defined(__GNUC__)                 // includes clang and icc63  #if defined(MI_SHARED_LIB) && defined(MI_SHARED_LIB_EXPORT)64    #define mi_decl_export              __attribute__((visibility("default")))65  #else66    #define mi_decl_export67  #endif68  #define mi_cdecl                      // leads to warnings... __attribute__((cdecl))69  #define mi_decl_restrict70  #define mi_attr_malloc                __attribute__((malloc))71  #if (defined(__clang_major__) && (__clang_major__ < 4)) || (__GNUC__ < 5)72    #define mi_attr_alloc_size(s)73    #define mi_attr_alloc_size2(s1,s2)74    #define mi_attr_alloc_align(p)75  #elif defined(__INTEL_COMPILER)76    #define mi_attr_alloc_size(s)       __attribute__((alloc_size(s)))77    #define mi_attr_alloc_size2(s1,s2)  __attribute__((alloc_size(s1,s2)))78    #define mi_attr_alloc_align(p)79  #else80    #define mi_attr_alloc_size(s)       __attribute__((alloc_size(s)))81    #define mi_attr_alloc_size2(s1,s2)  __attribute__((alloc_size(s1,s2)))82    #define mi_attr_alloc_align(p)      __attribute__((alloc_align(p)))83  #endif84#else85  #define mi_cdecl86  #define mi_decl_export87  #define mi_decl_restrict88  #define mi_attr_malloc89  #define mi_attr_alloc_size(s)90  #define mi_attr_alloc_size2(s1,s2)91  #define mi_attr_alloc_align(p)92#endif93 94// ------------------------------------------------------95// Includes96// ------------------------------------------------------97 98#include <stddef.h>     // size_t99#include <stdbool.h>    // bool100#include <stdint.h>     // INTPTR_MAX101 102#ifdef __cplusplus103extern "C" {104#endif105 106// ------------------------------------------------------107// Standard malloc interface108// ------------------------------------------------------109 110mi_decl_nodiscard mi_decl_export mi_decl_restrict void* mi_malloc(size_t size)  mi_attr_noexcept mi_attr_malloc mi_attr_alloc_size(1);111mi_decl_nodiscard mi_decl_export mi_decl_restrict void* mi_calloc(size_t count, size_t size)  mi_attr_noexcept mi_attr_malloc mi_attr_alloc_size2(1,2);112mi_decl_nodiscard mi_decl_export void* mi_realloc(void* p, size_t newsize)      mi_attr_noexcept mi_attr_alloc_size(2);113mi_decl_export void* mi_expand(void* p, size_t newsize)                         mi_attr_noexcept mi_attr_alloc_size(2);114 115mi_decl_export void mi_free(void* p) mi_attr_noexcept;116mi_decl_nodiscard mi_decl_export mi_decl_restrict char* mi_strdup(const char* s) mi_attr_noexcept mi_attr_malloc;117mi_decl_nodiscard mi_decl_export mi_decl_restrict char* mi_strndup(const char* s, size_t n) mi_attr_noexcept mi_attr_malloc;118mi_decl_nodiscard mi_decl_export mi_decl_restrict char* mi_realpath(const char* fname, char* resolved_name) mi_attr_noexcept mi_attr_malloc;119 120// ------------------------------------------------------121// Extended functionality122// ------------------------------------------------------123#define MI_SMALL_WSIZE_MAX  (128)124#define MI_SMALL_SIZE_MAX   (MI_SMALL_WSIZE_MAX*sizeof(void*))125 126mi_decl_nodiscard mi_decl_export mi_decl_restrict void* mi_malloc_small(size_t size) mi_attr_noexcept mi_attr_malloc mi_attr_alloc_size(1);127mi_decl_nodiscard mi_decl_export mi_decl_restrict void* mi_zalloc_small(size_t size) mi_attr_noexcept mi_attr_malloc mi_attr_alloc_size(1);128mi_decl_nodiscard mi_decl_export mi_decl_restrict void* mi_zalloc(size_t size)       mi_attr_noexcept mi_attr_malloc mi_attr_alloc_size(1);129 130mi_decl_nodiscard mi_decl_export mi_decl_restrict void* mi_mallocn(size_t count, size_t size) mi_attr_noexcept mi_attr_malloc mi_attr_alloc_size2(1,2);131mi_decl_nodiscard mi_decl_export void* mi_reallocn(void* p, size_t count, size_t size)        mi_attr_noexcept mi_attr_alloc_size2(2,3);132mi_decl_nodiscard mi_decl_export void* mi_reallocf(void* p, size_t newsize)                   mi_attr_noexcept mi_attr_alloc_size(2);133 134mi_decl_nodiscard mi_decl_export size_t mi_usable_size(const void* p) mi_attr_noexcept;135mi_decl_nodiscard mi_decl_export size_t mi_good_size(size_t size)     mi_attr_noexcept;136 137 138// ------------------------------------------------------139// Internals140// ------------------------------------------------------141 142typedef void (mi_cdecl mi_deferred_free_fun)(bool force, unsigned long long heartbeat, void* arg);143mi_decl_export void mi_register_deferred_free(mi_deferred_free_fun* deferred_free, void* arg) mi_attr_noexcept;144 145typedef void (mi_cdecl mi_output_fun)(const char* msg, void* arg);146mi_decl_export void mi_register_output(mi_output_fun* out, void* arg) mi_attr_noexcept;147 148typedef void (mi_cdecl mi_error_fun)(int err, void* arg);149mi_decl_export void mi_register_error(mi_error_fun* fun, void* arg);150 151mi_decl_export void mi_collect(bool force)    mi_attr_noexcept;152mi_decl_export int  mi_version(void)          mi_attr_noexcept;153mi_decl_export void mi_stats_reset(void)      mi_attr_noexcept;154mi_decl_export void mi_stats_merge(void)      mi_attr_noexcept;155mi_decl_export void mi_stats_print(void* out) mi_attr_noexcept;  // backward compatibility: `out` is ignored and should be NULL156mi_decl_export void mi_stats_print_out(mi_output_fun* out, void* arg) mi_attr_noexcept;157 158mi_decl_export void mi_process_init(void)     mi_attr_noexcept;159mi_decl_export void mi_thread_init(void)      mi_attr_noexcept;160mi_decl_export void mi_thread_done(void)      mi_attr_noexcept;161mi_decl_export void mi_thread_stats_print_out(mi_output_fun* out, void* arg) mi_attr_noexcept;162 163mi_decl_export void mi_process_info(size_t* elapsed_msecs, size_t* user_msecs, size_t* system_msecs,164                                    size_t* current_rss, size_t* peak_rss,165                                    size_t* current_commit, size_t* peak_commit, size_t* page_faults) mi_attr_noexcept;166 167// -------------------------------------------------------------------------------------168// Aligned allocation169// Note that `alignment` always follows `size` for consistency with unaligned170// allocation, but unfortunately this differs from `posix_memalign` and `aligned_alloc`.171// -------------------------------------------------------------------------------------172 173mi_decl_nodiscard mi_decl_export mi_decl_restrict void* mi_malloc_aligned(size_t size, size_t alignment) mi_attr_noexcept mi_attr_malloc mi_attr_alloc_size(1) mi_attr_alloc_align(2);174mi_decl_nodiscard mi_decl_export mi_decl_restrict void* mi_malloc_aligned_at(size_t size, size_t alignment, size_t offset) mi_attr_noexcept mi_attr_malloc mi_attr_alloc_size(1);175mi_decl_nodiscard mi_decl_export mi_decl_restrict void* mi_zalloc_aligned(size_t size, size_t alignment) mi_attr_noexcept mi_attr_malloc mi_attr_alloc_size(1) mi_attr_alloc_align(2);176mi_decl_nodiscard mi_decl_export mi_decl_restrict void* mi_zalloc_aligned_at(size_t size, size_t alignment, size_t offset) mi_attr_noexcept mi_attr_malloc mi_attr_alloc_size(1);177mi_decl_nodiscard mi_decl_export mi_decl_restrict void* mi_calloc_aligned(size_t count, size_t size, size_t alignment) mi_attr_noexcept mi_attr_malloc mi_attr_alloc_size2(1,2) mi_attr_alloc_align(3);178mi_decl_nodiscard mi_decl_export mi_decl_restrict void* mi_calloc_aligned_at(size_t count, size_t size, size_t alignment, size_t offset) mi_attr_noexcept mi_attr_malloc mi_attr_alloc_size2(1,2);179mi_decl_nodiscard mi_decl_export void* mi_realloc_aligned(void* p, size_t newsize, size_t alignment) mi_attr_noexcept mi_attr_alloc_size(2) mi_attr_alloc_align(3);180mi_decl_nodiscard mi_decl_export void* mi_realloc_aligned_at(void* p, size_t newsize, size_t alignment, size_t offset) mi_attr_noexcept mi_attr_alloc_size(2);181 182 183// -------------------------------------------------------------------------------------184// Heaps: first-class, but can only allocate from the same thread that created it.185// -------------------------------------------------------------------------------------186 187struct mi_heap_s;188typedef struct mi_heap_s mi_heap_t;189 190mi_decl_nodiscard mi_decl_export mi_heap_t* mi_heap_new(void);191mi_decl_export void       mi_heap_delete(mi_heap_t* heap);192mi_decl_export void       mi_heap_destroy(mi_heap_t* heap);193mi_decl_export mi_heap_t* mi_heap_set_default(mi_heap_t* heap);194mi_decl_export mi_heap_t* mi_heap_get_default(void);195mi_decl_export mi_heap_t* mi_heap_get_backing(void);196mi_decl_export void       mi_heap_collect(mi_heap_t* heap, bool force) mi_attr_noexcept;197 198mi_decl_nodiscard mi_decl_export mi_decl_restrict void* mi_heap_malloc(mi_heap_t* heap, size_t size) mi_attr_noexcept mi_attr_malloc mi_attr_alloc_size(2);199mi_decl_nodiscard mi_decl_export mi_decl_restrict void* mi_heap_zalloc(mi_heap_t* heap, size_t size) mi_attr_noexcept mi_attr_malloc mi_attr_alloc_size(2);200mi_decl_nodiscard mi_decl_export mi_decl_restrict void* mi_heap_calloc(mi_heap_t* heap, size_t count, size_t size) mi_attr_noexcept mi_attr_malloc mi_attr_alloc_size2(2, 3);201mi_decl_nodiscard mi_decl_export mi_decl_restrict void* mi_heap_mallocn(mi_heap_t* heap, size_t count, size_t size) mi_attr_noexcept mi_attr_malloc mi_attr_alloc_size2(2, 3);202mi_decl_nodiscard mi_decl_export mi_decl_restrict void* mi_heap_malloc_small(mi_heap_t* heap, size_t size) mi_attr_noexcept mi_attr_malloc mi_attr_alloc_size(2);203 204mi_decl_nodiscard mi_decl_export void* mi_heap_realloc(mi_heap_t* heap, void* p, size_t newsize)              mi_attr_noexcept mi_attr_alloc_size(3);205mi_decl_nodiscard mi_decl_export void* mi_heap_reallocn(mi_heap_t* heap, void* p, size_t count, size_t size)  mi_attr_noexcept mi_attr_alloc_size2(3,4);206mi_decl_nodiscard mi_decl_export void* mi_heap_reallocf(mi_heap_t* heap, void* p, size_t newsize)             mi_attr_noexcept mi_attr_alloc_size(3);207 208mi_decl_nodiscard mi_decl_export mi_decl_restrict char* mi_heap_strdup(mi_heap_t* heap, const char* s)            mi_attr_noexcept mi_attr_malloc;209mi_decl_nodiscard mi_decl_export mi_decl_restrict char* mi_heap_strndup(mi_heap_t* heap, const char* s, size_t n) mi_attr_noexcept mi_attr_malloc;210mi_decl_nodiscard mi_decl_export mi_decl_restrict char* mi_heap_realpath(mi_heap_t* heap, const char* fname, char* resolved_name) mi_attr_noexcept mi_attr_malloc;211 212mi_decl_nodiscard mi_decl_export mi_decl_restrict void* mi_heap_malloc_aligned(mi_heap_t* heap, size_t size, size_t alignment) mi_attr_noexcept mi_attr_malloc mi_attr_alloc_size(2) mi_attr_alloc_align(3);213mi_decl_nodiscard mi_decl_export mi_decl_restrict void* mi_heap_malloc_aligned_at(mi_heap_t* heap, size_t size, size_t alignment, size_t offset) mi_attr_noexcept mi_attr_malloc mi_attr_alloc_size(2);214mi_decl_nodiscard mi_decl_export mi_decl_restrict void* mi_heap_zalloc_aligned(mi_heap_t* heap, size_t size, size_t alignment) mi_attr_noexcept mi_attr_malloc mi_attr_alloc_size(2) mi_attr_alloc_align(3);215mi_decl_nodiscard mi_decl_export mi_decl_restrict void* mi_heap_zalloc_aligned_at(mi_heap_t* heap, size_t size, size_t alignment, size_t offset) mi_attr_noexcept mi_attr_malloc mi_attr_alloc_size(2);216mi_decl_nodiscard mi_decl_export mi_decl_restrict void* mi_heap_calloc_aligned(mi_heap_t* heap, size_t count, size_t size, size_t alignment) mi_attr_noexcept mi_attr_malloc mi_attr_alloc_size2(2, 3) mi_attr_alloc_align(4);217mi_decl_nodiscard mi_decl_export mi_decl_restrict void* mi_heap_calloc_aligned_at(mi_heap_t* heap, size_t count, size_t size, size_t alignment, size_t offset) mi_attr_noexcept mi_attr_malloc mi_attr_alloc_size2(2, 3);218mi_decl_nodiscard mi_decl_export void* mi_heap_realloc_aligned(mi_heap_t* heap, void* p, size_t newsize, size_t alignment) mi_attr_noexcept mi_attr_alloc_size(3) mi_attr_alloc_align(4);219mi_decl_nodiscard mi_decl_export void* mi_heap_realloc_aligned_at(mi_heap_t* heap, void* p, size_t newsize, size_t alignment, size_t offset) mi_attr_noexcept mi_attr_alloc_size(3);220 221 222// --------------------------------------------------------------------------------223// Zero initialized re-allocation.224// Only valid on memory that was originally allocated with zero initialization too.225// e.g. `mi_calloc`, `mi_zalloc`, `mi_zalloc_aligned` etc.226// see <https://github.com/microsoft/mimalloc/issues/63#issuecomment-508272992>227// --------------------------------------------------------------------------------228 229mi_decl_nodiscard mi_decl_export void* mi_rezalloc(void* p, size_t newsize)                mi_attr_noexcept mi_attr_alloc_size(2);230mi_decl_nodiscard mi_decl_export void* mi_recalloc(void* p, size_t newcount, size_t size)  mi_attr_noexcept mi_attr_alloc_size2(2,3);231 232mi_decl_nodiscard mi_decl_export void* mi_rezalloc_aligned(void* p, size_t newsize, size_t alignment) mi_attr_noexcept mi_attr_alloc_size(2) mi_attr_alloc_align(3);233mi_decl_nodiscard mi_decl_export void* mi_rezalloc_aligned_at(void* p, size_t newsize, size_t alignment, size_t offset) mi_attr_noexcept mi_attr_alloc_size(2);234mi_decl_nodiscard mi_decl_export void* mi_recalloc_aligned(void* p, size_t newcount, size_t size, size_t alignment) mi_attr_noexcept mi_attr_alloc_size2(2,3) mi_attr_alloc_align(4);235mi_decl_nodiscard mi_decl_export void* mi_recalloc_aligned_at(void* p, size_t newcount, size_t size, size_t alignment, size_t offset) mi_attr_noexcept mi_attr_alloc_size2(2,3);236 237mi_decl_nodiscard mi_decl_export void* mi_heap_rezalloc(mi_heap_t* heap, void* p, size_t newsize)                mi_attr_noexcept mi_attr_alloc_size(3);238mi_decl_nodiscard mi_decl_export void* mi_heap_recalloc(mi_heap_t* heap, void* p, size_t newcount, size_t size)  mi_attr_noexcept mi_attr_alloc_size2(3,4);239 240mi_decl_nodiscard mi_decl_export void* mi_heap_rezalloc_aligned(mi_heap_t* heap, void* p, size_t newsize, size_t alignment) mi_attr_noexcept mi_attr_alloc_size(3) mi_attr_alloc_align(4);241mi_decl_nodiscard mi_decl_export void* mi_heap_rezalloc_aligned_at(mi_heap_t* heap, void* p, size_t newsize, size_t alignment, size_t offset) mi_attr_noexcept mi_attr_alloc_size(3);242mi_decl_nodiscard mi_decl_export void* mi_heap_recalloc_aligned(mi_heap_t* heap, void* p, size_t newcount, size_t size, size_t alignment) mi_attr_noexcept mi_attr_alloc_size2(3,4) mi_attr_alloc_align(5);243mi_decl_nodiscard mi_decl_export void* mi_heap_recalloc_aligned_at(mi_heap_t* heap, void* p, size_t newcount, size_t size, size_t alignment, size_t offset) mi_attr_noexcept mi_attr_alloc_size2(3,4);244 245 246// ------------------------------------------------------247// Analysis248// ------------------------------------------------------249 250mi_decl_export bool mi_heap_contains_block(mi_heap_t* heap, const void* p);251mi_decl_export bool mi_heap_check_owned(mi_heap_t* heap, const void* p);252mi_decl_export bool mi_check_owned(const void* p);253 254// An area of heap space contains blocks of a single size.255typedef struct mi_heap_area_s {256  void*  blocks;      // start of the area containing heap blocks257  size_t reserved;    // bytes reserved for this area (virtual)258  size_t committed;   // current available bytes for this area259  size_t used;        // number of allocated blocks260  size_t block_size;  // size in bytes of each block261  size_t full_block_size; // size in bytes of a full block including padding and metadata.262} mi_heap_area_t;263 264typedef bool (mi_cdecl mi_block_visit_fun)(const mi_heap_t* heap, const mi_heap_area_t* area, void* block, size_t block_size, void* arg);265 266mi_decl_export bool mi_heap_visit_blocks(const mi_heap_t* heap, bool visit_all_blocks, mi_block_visit_fun* visitor, void* arg);267 268// Experimental269mi_decl_nodiscard mi_decl_export bool mi_is_in_heap_region(const void* p) mi_attr_noexcept;270mi_decl_nodiscard mi_decl_export bool mi_is_redirected(void) mi_attr_noexcept;271 272mi_decl_export int mi_reserve_huge_os_pages_interleave(size_t pages, size_t numa_nodes, size_t timeout_msecs) mi_attr_noexcept;273mi_decl_export int mi_reserve_huge_os_pages_at(size_t pages, int numa_node, size_t timeout_msecs) mi_attr_noexcept;274 275mi_decl_export int  mi_reserve_os_memory(size_t size, bool commit, bool allow_large) mi_attr_noexcept;276mi_decl_export bool mi_manage_os_memory(void* start, size_t size, bool is_committed, bool is_large, bool is_zero, int numa_node) mi_attr_noexcept;277 278mi_decl_export void mi_debug_show_arenas(void) mi_attr_noexcept;279 280// Experimental: heaps associated with specific memory arena's281typedef int mi_arena_id_t;282mi_decl_export void* mi_arena_area(mi_arena_id_t arena_id, size_t* size);283mi_decl_export int   mi_reserve_huge_os_pages_at_ex(size_t pages, int numa_node, size_t timeout_msecs, bool exclusive, mi_arena_id_t* arena_id) mi_attr_noexcept;284mi_decl_export int   mi_reserve_os_memory_ex(size_t size, bool commit, bool allow_large, bool exclusive, mi_arena_id_t* arena_id) mi_attr_noexcept;285mi_decl_export bool  mi_manage_os_memory_ex(void* start, size_t size, bool is_committed, bool is_large, bool is_zero, int numa_node, bool exclusive, mi_arena_id_t* arena_id) mi_attr_noexcept;286 287#if MI_MALLOC_VERSION >= 182288// Create a heap that only allocates in the specified arena289mi_decl_nodiscard mi_decl_export mi_heap_t* mi_heap_new_in_arena(mi_arena_id_t arena_id);290#endif291 292// deprecated293mi_decl_export int  mi_reserve_huge_os_pages(size_t pages, double max_secs, size_t* pages_reserved) mi_attr_noexcept;294 295 296// ------------------------------------------------------297// Convenience298// ------------------------------------------------------299 300#define mi_malloc_tp(tp)                ((tp*)mi_malloc(sizeof(tp)))301#define mi_zalloc_tp(tp)                ((tp*)mi_zalloc(sizeof(tp)))302#define mi_calloc_tp(tp,n)              ((tp*)mi_calloc(n,sizeof(tp)))303#define mi_mallocn_tp(tp,n)             ((tp*)mi_mallocn(n,sizeof(tp)))304#define mi_reallocn_tp(p,tp,n)          ((tp*)mi_reallocn(p,n,sizeof(tp)))305#define mi_recalloc_tp(p,tp,n)          ((tp*)mi_recalloc(p,n,sizeof(tp)))306 307#define mi_heap_malloc_tp(hp,tp)        ((tp*)mi_heap_malloc(hp,sizeof(tp)))308#define mi_heap_zalloc_tp(hp,tp)        ((tp*)mi_heap_zalloc(hp,sizeof(tp)))309#define mi_heap_calloc_tp(hp,tp,n)      ((tp*)mi_heap_calloc(hp,n,sizeof(tp)))310#define mi_heap_mallocn_tp(hp,tp,n)     ((tp*)mi_heap_mallocn(hp,n,sizeof(tp)))311#define mi_heap_reallocn_tp(hp,p,tp,n)  ((tp*)mi_heap_reallocn(hp,p,n,sizeof(tp)))312#define mi_heap_recalloc_tp(hp,p,tp,n)  ((tp*)mi_heap_recalloc(hp,p,n,sizeof(tp)))313 314 315// ------------------------------------------------------316// Options317// ------------------------------------------------------318 319typedef enum mi_option_e {320  // stable options321  mi_option_show_errors,              // print error messages322  mi_option_show_stats,               // print statistics on termination323  mi_option_verbose,                  // print verbose messages324  // the following options are experimental (see src/options.h)325  mi_option_eager_commit,             // eager commit segments? (after `eager_commit_delay` segments) (=1)326  mi_option_arena_eager_commit,       // eager commit arenas? Use 2 to enable just on overcommit systems (=2)327  mi_option_purge_decommits,          // should a memory purge decommit (or only reset) (=1)328  mi_option_allow_large_os_pages,     // allow large (2MiB) OS pages, implies eager commit329  mi_option_reserve_huge_os_pages,    // reserve N huge OS pages (1GiB/page) at startup330  mi_option_reserve_huge_os_pages_at, // reserve huge OS pages at a specific NUMA node331  mi_option_reserve_os_memory,        // reserve specified amount of OS memory in an arena at startup332  mi_option_deprecated_segment_cache,333  mi_option_deprecated_page_reset,334  mi_option_abandoned_page_purge,     // immediately purge delayed purges on thread termination335  mi_option_deprecated_segment_reset,336  mi_option_eager_commit_delay,337  mi_option_purge_delay,              // memory purging is delayed by N milli seconds; use 0 for immediate purging or -1 for no purging at all.338  mi_option_use_numa_nodes,           // 0 = use all available numa nodes, otherwise use at most N nodes.339  mi_option_limit_os_alloc,           // 1 = do not use OS memory for allocation (but only programmatically reserved arenas)340  mi_option_os_tag,                   // tag used for OS logging (macOS only for now)341  mi_option_max_errors,               // issue at most N error messages342  mi_option_max_warnings,             // issue at most N warning messages343  mi_option_max_segment_reclaim,344  mi_option_destroy_on_exit,          // if set, release all memory on exit; sometimes used for dynamic unloading but can be unsafe.345  mi_option_arena_reserve,            // initial memory size in KiB for arena reservation (1GiB on 64-bit)346  mi_option_arena_purge_mult,347  mi_option_purge_extend_delay,348  _mi_option_last,349  // legacy option names350  mi_option_large_os_pages = mi_option_allow_large_os_pages,351  mi_option_eager_region_commit = mi_option_arena_eager_commit,352  mi_option_reset_decommits = mi_option_purge_decommits,353  mi_option_reset_delay = mi_option_purge_delay,354  mi_option_abandoned_page_reset = mi_option_abandoned_page_purge355} mi_option_t;356 357 358mi_decl_nodiscard mi_decl_export bool mi_option_is_enabled(mi_option_t option);359mi_decl_export void mi_option_enable(mi_option_t option);360mi_decl_export void mi_option_disable(mi_option_t option);361mi_decl_export void mi_option_set_enabled(mi_option_t option, bool enable);362mi_decl_export void mi_option_set_enabled_default(mi_option_t option, bool enable);363 364mi_decl_nodiscard mi_decl_export long   mi_option_get(mi_option_t option);365mi_decl_nodiscard mi_decl_export long   mi_option_get_clamp(mi_option_t option, long min, long max);366mi_decl_nodiscard mi_decl_export size_t mi_option_get_size(mi_option_t option);367mi_decl_export void mi_option_set(mi_option_t option, long value);368mi_decl_export void mi_option_set_default(mi_option_t option, long value);369 370 371// -------------------------------------------------------------------------------------------------------372// "mi" prefixed implementations of various posix, Unix, Windows, and C++ allocation functions.373// (This can be convenient when providing overrides of these functions as done in `mimalloc-override.h`.)374// note: we use `mi_cfree` as "checked free" and it checks if the pointer is in our heap before free-ing.375// -------------------------------------------------------------------------------------------------------376 377mi_decl_export void  mi_cfree(void* p) mi_attr_noexcept;378mi_decl_export void* mi__expand(void* p, size_t newsize) mi_attr_noexcept;379mi_decl_nodiscard mi_decl_export size_t mi_malloc_size(const void* p)        mi_attr_noexcept;380mi_decl_nodiscard mi_decl_export size_t mi_malloc_good_size(size_t size)     mi_attr_noexcept;381mi_decl_nodiscard mi_decl_export size_t mi_malloc_usable_size(const void *p) mi_attr_noexcept;382 383mi_decl_export int mi_posix_memalign(void** p, size_t alignment, size_t size)   mi_attr_noexcept;384mi_decl_nodiscard mi_decl_export mi_decl_restrict void* mi_memalign(size_t alignment, size_t size) mi_attr_noexcept mi_attr_malloc mi_attr_alloc_size(2) mi_attr_alloc_align(1);385mi_decl_nodiscard mi_decl_export mi_decl_restrict void* mi_valloc(size_t size)  mi_attr_noexcept mi_attr_malloc mi_attr_alloc_size(1);386mi_decl_nodiscard mi_decl_export mi_decl_restrict void* mi_pvalloc(size_t size) mi_attr_noexcept mi_attr_malloc mi_attr_alloc_size(1);387mi_decl_nodiscard mi_decl_export mi_decl_restrict void* mi_aligned_alloc(size_t alignment, size_t size) mi_attr_noexcept mi_attr_malloc mi_attr_alloc_size(2) mi_attr_alloc_align(1);388 389mi_decl_nodiscard mi_decl_export void* mi_reallocarray(void* p, size_t count, size_t size) mi_attr_noexcept mi_attr_alloc_size2(2,3);390mi_decl_nodiscard mi_decl_export int   mi_reallocarr(void* p, size_t count, size_t size) mi_attr_noexcept;391mi_decl_nodiscard mi_decl_export void* mi_aligned_recalloc(void* p, size_t newcount, size_t size, size_t alignment) mi_attr_noexcept;392mi_decl_nodiscard mi_decl_export void* mi_aligned_offset_recalloc(void* p, size_t newcount, size_t size, size_t alignment, size_t offset) mi_attr_noexcept;393 394mi_decl_nodiscard mi_decl_export mi_decl_restrict unsigned short* mi_wcsdup(const unsigned short* s) mi_attr_noexcept mi_attr_malloc;395mi_decl_nodiscard mi_decl_export mi_decl_restrict unsigned char*  mi_mbsdup(const unsigned char* s)  mi_attr_noexcept mi_attr_malloc;396mi_decl_export int mi_dupenv_s(char** buf, size_t* size, const char* name)                      mi_attr_noexcept;397mi_decl_export int mi_wdupenv_s(unsigned short** buf, size_t* size, const unsigned short* name) mi_attr_noexcept;398 399mi_decl_export void mi_free_size(void* p, size_t size)                           mi_attr_noexcept;400mi_decl_export void mi_free_size_aligned(void* p, size_t size, size_t alignment) mi_attr_noexcept;401mi_decl_export void mi_free_aligned(void* p, size_t alignment)                   mi_attr_noexcept;402 403// The `mi_new` wrappers implement C++ semantics on out-of-memory instead of directly returning `NULL`.404// (and call `std::get_new_handler` and potentially raise a `std::bad_alloc` exception).405mi_decl_nodiscard mi_decl_export mi_decl_restrict void* mi_new(size_t size)                   mi_attr_malloc mi_attr_alloc_size(1);406mi_decl_nodiscard mi_decl_export mi_decl_restrict void* mi_new_aligned(size_t size, size_t alignment) mi_attr_malloc mi_attr_alloc_size(1) mi_attr_alloc_align(2);407mi_decl_nodiscard mi_decl_export mi_decl_restrict void* mi_new_nothrow(size_t size)           mi_attr_noexcept mi_attr_malloc mi_attr_alloc_size(1);408mi_decl_nodiscard mi_decl_export mi_decl_restrict void* mi_new_aligned_nothrow(size_t size, size_t alignment) mi_attr_noexcept mi_attr_malloc mi_attr_alloc_size(1) mi_attr_alloc_align(2);409mi_decl_nodiscard mi_decl_export mi_decl_restrict void* mi_new_n(size_t count, size_t size)   mi_attr_malloc mi_attr_alloc_size2(1, 2);410mi_decl_nodiscard mi_decl_export void* mi_new_realloc(void* p, size_t newsize)                mi_attr_alloc_size(2);411mi_decl_nodiscard mi_decl_export void* mi_new_reallocn(void* p, size_t newcount, size_t size) mi_attr_alloc_size2(2, 3);412 413mi_decl_nodiscard mi_decl_export mi_decl_restrict void* mi_heap_alloc_new(mi_heap_t* heap, size_t size)                mi_attr_malloc mi_attr_alloc_size(2);414mi_decl_nodiscard mi_decl_export mi_decl_restrict void* mi_heap_alloc_new_n(mi_heap_t* heap, size_t count, size_t size) mi_attr_malloc mi_attr_alloc_size2(2, 3);415 416#ifdef __cplusplus417}418#endif419 420// ---------------------------------------------------------------------------------------------421// Implement the C++ std::allocator interface for use in STL containers.422// (note: see `mimalloc-new-delete.h` for overriding the new/delete operators globally)423// ---------------------------------------------------------------------------------------------424#ifdef __cplusplus425 426#include <cstddef>     // std::size_t427#include <cstdint>     // PTRDIFF_MAX428#if (__cplusplus >= 201103L) || (_MSC_VER > 1900)  // C++11429#include <type_traits> // std::true_type430#include <utility>     // std::forward431#endif432 433template<class T> struct _mi_stl_allocator_common {434  typedef T                 value_type;435  typedef std::size_t       size_type;436  typedef std::ptrdiff_t    difference_type;437  typedef value_type&       reference;438  typedef value_type const& const_reference;439  typedef value_type*       pointer;440  typedef value_type const* const_pointer;441 442  #if ((__cplusplus >= 201103L) || (_MSC_VER > 1900))  // C++11443  using propagate_on_container_copy_assignment = std::true_type;444  using propagate_on_container_move_assignment = std::true_type;445  using propagate_on_container_swap            = std::true_type;446  template <class U, class ...Args> void construct(U* p, Args&& ...args) { ::new(p) U(std::forward<Args>(args)...); }447  template <class U> void destroy(U* p) mi_attr_noexcept { p->~U(); }448  #else449  void construct(pointer p, value_type const& val) { ::new(p) value_type(val); }450  void destroy(pointer p) { p->~value_type(); }451  #endif452 453  size_type     max_size() const mi_attr_noexcept { return (PTRDIFF_MAX/sizeof(value_type)); }454  pointer       address(reference x) const        { return &x; }455  const_pointer address(const_reference x) const  { return &x; }456};457 458template<class T> struct mi_stl_allocator : public _mi_stl_allocator_common<T> {459  using typename _mi_stl_allocator_common<T>::size_type;460  using typename _mi_stl_allocator_common<T>::value_type;461  using typename _mi_stl_allocator_common<T>::pointer;462  template <class U> struct rebind { typedef mi_stl_allocator<U> other; };463 464  mi_stl_allocator()                                             mi_attr_noexcept = default;465  mi_stl_allocator(const mi_stl_allocator&)                      mi_attr_noexcept = default;466  template<class U> mi_stl_allocator(const mi_stl_allocator<U>&) mi_attr_noexcept { }467  mi_stl_allocator  select_on_container_copy_construction() const { return *this; }468  void              deallocate(T* p, size_type) { mi_free(p); }469 470  #if (__cplusplus >= 201703L)  // C++17471  mi_decl_nodiscard T* allocate(size_type count) { return static_cast<T*>(mi_new_n(count, sizeof(T))); }472  mi_decl_nodiscard T* allocate(size_type count, const void*) { return allocate(count); }473  #else474  mi_decl_nodiscard pointer allocate(size_type count, const void* = 0) { return static_cast<pointer>(mi_new_n(count, sizeof(value_type))); }475  #endif476 477  #if ((__cplusplus >= 201103L) || (_MSC_VER > 1900))  // C++11478  using is_always_equal = std::true_type;479  #endif480};481 482template<class T1,class T2> bool operator==(const mi_stl_allocator<T1>& , const mi_stl_allocator<T2>& ) mi_attr_noexcept { return true; }483template<class T1,class T2> bool operator!=(const mi_stl_allocator<T1>& , const mi_stl_allocator<T2>& ) mi_attr_noexcept { return false; }484 485 486#if (__cplusplus >= 201103L) || (_MSC_VER >= 1900)  // C++11487#define MI_HAS_HEAP_STL_ALLOCATOR 1488 489#include <memory>      // std::shared_ptr490 491// Common base class for STL allocators in a specific heap492template<class T, bool _mi_destroy> struct _mi_heap_stl_allocator_common : public _mi_stl_allocator_common<T> {493  using typename _mi_stl_allocator_common<T>::size_type;494  using typename _mi_stl_allocator_common<T>::value_type;495  using typename _mi_stl_allocator_common<T>::pointer;496 497  _mi_heap_stl_allocator_common(mi_heap_t* hp) : heap(hp) { }    /* will not delete nor destroy the passed in heap */498 499  #if (__cplusplus >= 201703L)  // C++17500  mi_decl_nodiscard T* allocate(size_type count) { return static_cast<T*>(mi_heap_alloc_new_n(this->heap.get(), count, sizeof(T))); }501  mi_decl_nodiscard T* allocate(size_type count, const void*) { return allocate(count); }502  #else503  mi_decl_nodiscard pointer allocate(size_type count, const void* = 0) { return static_cast<pointer>(mi_heap_alloc_new_n(this->heap.get(), count, sizeof(value_type))); }504  #endif505 506  #if ((__cplusplus >= 201103L) || (_MSC_VER > 1900))  // C++11507  using is_always_equal = std::false_type;508  #endif509 510  void collect(bool force) { mi_heap_collect(this->heap.get(), force); }511  template<class U> bool is_equal(const _mi_heap_stl_allocator_common<U, _mi_destroy>& x) const { return (this->heap == x.heap); }512 513protected:514  std::shared_ptr<mi_heap_t> heap;515  template<class U, bool D> friend struct _mi_heap_stl_allocator_common;516 517  _mi_heap_stl_allocator_common() {518    mi_heap_t* hp = mi_heap_new();519    this->heap.reset(hp, (_mi_destroy ? &heap_destroy : &heap_delete));  /* calls heap_delete/destroy when the refcount drops to zero */520  }521  _mi_heap_stl_allocator_common(const _mi_heap_stl_allocator_common& x) mi_attr_noexcept : heap(x.heap) { }522  template<class U> _mi_heap_stl_allocator_common(const _mi_heap_stl_allocator_common<U, _mi_destroy>& x) mi_attr_noexcept : heap(x.heap) { }523 524private:525  static void heap_delete(mi_heap_t* hp)  { if (hp != NULL) { mi_heap_delete(hp); } }526  static void heap_destroy(mi_heap_t* hp) { if (hp != NULL) { mi_heap_destroy(hp); } }527};528 529// STL allocator allocation in a specific heap530template<class T> struct mi_heap_stl_allocator : public _mi_heap_stl_allocator_common<T, false> {531  using typename _mi_heap_stl_allocator_common<T, false>::size_type;532  mi_heap_stl_allocator() : _mi_heap_stl_allocator_common<T, false>() { } // creates fresh heap that is deleted when the destructor is called533  mi_heap_stl_allocator(mi_heap_t* hp) : _mi_heap_stl_allocator_common<T, false>(hp) { }  // no delete nor destroy on the passed in heap534  template<class U> mi_heap_stl_allocator(const mi_heap_stl_allocator<U>& x) mi_attr_noexcept : _mi_heap_stl_allocator_common<T, false>(x) { }535 536  mi_heap_stl_allocator select_on_container_copy_construction() const { return *this; }537  void deallocate(T* p, size_type) { mi_free(p); }538  template<class U> struct rebind { typedef mi_heap_stl_allocator<U> other; };539};540 541template<class T1, class T2> bool operator==(const mi_heap_stl_allocator<T1>& x, const mi_heap_stl_allocator<T2>& y) mi_attr_noexcept { return (x.is_equal(y)); }542template<class T1, class T2> bool operator!=(const mi_heap_stl_allocator<T1>& x, const mi_heap_stl_allocator<T2>& y) mi_attr_noexcept { return (!x.is_equal(y)); }543 544 545// STL allocator allocation in a specific heap, where `free` does nothing and546// the heap is destroyed in one go on destruction -- use with care!547template<class T> struct mi_heap_destroy_stl_allocator : public _mi_heap_stl_allocator_common<T, true> {548  using typename _mi_heap_stl_allocator_common<T, true>::size_type;549  mi_heap_destroy_stl_allocator() : _mi_heap_stl_allocator_common<T, true>() { } // creates fresh heap that is destroyed when the destructor is called550  mi_heap_destroy_stl_allocator(mi_heap_t* hp) : _mi_heap_stl_allocator_common<T, true>(hp) { }  // no delete nor destroy on the passed in heap551  template<class U> mi_heap_destroy_stl_allocator(const mi_heap_destroy_stl_allocator<U>& x) mi_attr_noexcept : _mi_heap_stl_allocator_common<T, true>(x) { }552 553  mi_heap_destroy_stl_allocator select_on_container_copy_construction() const { return *this; }554  void deallocate(T*, size_type) { /* do nothing as we destroy the heap on destruct. */ }555  template<class U> struct rebind { typedef mi_heap_destroy_stl_allocator<U> other; };556};557 558template<class T1, class T2> bool operator==(const mi_heap_destroy_stl_allocator<T1>& x, const mi_heap_destroy_stl_allocator<T2>& y) mi_attr_noexcept { return (x.is_equal(y)); }559template<class T1, class T2> bool operator!=(const mi_heap_destroy_stl_allocator<T1>& x, const mi_heap_destroy_stl_allocator<T2>& y) mi_attr_noexcept { return (!x.is_equal(y)); }560 561#endif // C++11562 563#endif // __cplusplus564 565#endif566