mi_option_deprecated_segment_cache,

mi_option_deprecated_page_reset,

mi_option_abandoned_page_purge, // immediately purge delayed purges on thread termination

mi_option_purge_delay, // memory purging is delayed by N milli seconds; use 0 for immediate purging or -1 for no purging at all.

mi_option_use_numa_nodes, // 0 = use all available numa nodes, otherwise use at most N nodes.

mi_option_limit_os_alloc, // 1 = do not use OS memory for allocation (but only programmatically reserved arenas)

mi_option_os_tag, // tag used for OS logging (macOS only for now)

mi_option_max_errors, // issue at most N error messages

mi_option_max_warnings, // issue at most N warning messages

mi_option_destroy_on_exit, // if set, release all memory on exit; sometimes used for dynamic unloading but can be unsafe.

mi_option_arena_reserve, // initial memory size in KiB for arena reservation (1GiB on 64-bit)

mi_option_purge_extend_delay,

_mi_option_last,

// legacy option names

std::shared_ptr<mi_heap_t> heap;

template<class U, bool D> friend struct _mi_heap_stl_allocator_common;

_mi_heap_stl_allocator_common() {

mi_heap_t* hp = mi_heap_new();

this->heap.reset(hp, (_mi_destroy ? &heap_destroy : &heap_delete)); /* calls heap_delete/destroy when the refcount drops to zero */

template<class T> struct mi_heap_stl_allocator : public _mi_heap_stl_allocator_common<T, false> {

using typename _mi_heap_stl_allocator_common<T, false>::size_type;

mi_heap_stl_allocator() : _mi_heap_stl_allocator_common<T, false>() { } // creates fresh heap that is deleted when the destructor is called

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) { }

mi_heap_stl_allocator select_on_container_copy_construction() const { return *this; }

template<class T> struct mi_heap_destroy_stl_allocator : public _mi_heap_stl_allocator_common<T, true> {

using typename _mi_heap_stl_allocator_common<T, true>::size_type;

mi_heap_destroy_stl_allocator() : _mi_heap_stl_allocator_common<T, true>() { } // creates fresh heap that is destroyed when the destructor is called

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) { }

mi_heap_destroy_stl_allocator select_on_container_copy_construction() const { return *this; }

static inline bool mi_atomic_once( mi_atomic_once_t* once ) {

uintptr_t expected = 0;

return mi_atomic_cas_strong_acq_rel(once, &expected, (uintptr_t)1); // try to set to 1

}

void _mi_os_init(void); // called from process init

void _mi_os_free(void* p, size_t size, mi_memid_t memid, mi_stats_t* stats);

void _mi_os_free_ex(void* p, size_t size, bool still_committed, mi_memid_t memid, mi_stats_t* stats);

int _mi_prim_free(void* addr, size_t size );

typedef struct mi_process_info_s {

mi_msecs_t elapsed;

mi_msecs_t utime;

size_t current_commit;

size_t page_faults;

} mi_process_info_t;

#define MI_TRACK_ENABLED 0

#define MI_TRACK_TOOL "none"

#define mi_track_malloc_size(p,reqsize,size,zero)

#define MI_SMALL_OBJ_SIZE_MAX (MI_SMALL_PAGE_SIZE/4) // 8KiB on 64-bit

#define MI_MEDIUM_OBJ_SIZE_MAX (MI_MEDIUM_PAGE_SIZE/4) // 128KiB on 64-bit

#define MI_LARGE_OBJ_SIZE_MAX (MI_SEGMENT_SIZE/2) // 32MiB on 64-bit

#define MI_LARGE_OBJ_WSIZE_MAX (MI_LARGE_OBJ_SIZE_MAX/MI_INTPTR_SIZE)

#define MI_HUGE_BLOCK_SIZE ((uint32_t)(2*MI_GiB))

typedef struct mi_page_s {

// "owned" by the segment

uint32_t slice_count; // slices in this page (0 if not a page)

uint8_t is_committed : 1; // `true` if the page virtual memory is committed

uint8_t is_zero_init : 1; // `true` if the page was initially zero initialized

uint8_t tag : 4; // heap tag (mi_heap_tag_t)

#define MI_COMMIT_SIZE (MI_SEGMENT_SLICE_SIZE) // 64KiB

#define MI_COMMIT_MASK_FIELD_BITS MI_SIZE_BITS

#define MI_COMMIT_MASK_FIELD_COUNT (MI_COMMIT_MASK_BITS / MI_COMMIT_MASK_FIELD_BITS)

// from here is zero initialized

struct mi_segment_s* next; // the list of freed segments in the cache (must be first field, see `segment.c:mi_segment_init`)

size_t abandoned; // abandoned pages (i.e. the original owning thread stopped) (`abandoned <= used`)

size_t abandoned_visits; // count how often this segment is visited in the abandoned list (to force reclaim it it is too long)

size_t used; // count of pages in use

size_t segment_slices; // for huge segments this may be different from `MI_SLICES_PER_SEGMENT`

size_t segment_info_slices; // initial slices we are using segment info and possible guard pages.

mi_page_queue_t pages[MI_BIN_FULL + 1]; // queue of pages for each size class (or "bin")

_Atomic(mi_block_t*) thread_delayed_free;

mi_threadid_t thread_id; // thread this heap belongs too

uintptr_t cookie; // random cookie to verify pointers (see `_mi_ptr_cookie`)

uintptr_t keys[2]; // two random keys used to encode the `thread_delayed_free` list

mi_random_ctx_t random; // random number context used for secure allocation

oversize = (size <= MI_SMALL_SIZE_MAX ? MI_SMALL_SIZE_MAX + 1 /* ensure we use generic malloc path */ : size);

p = _mi_heap_malloc_zero_ex(heap, oversize, false, alignment); // the page block size should be large enough to align in the single huge page block

// zero afterwards as only the area from the aligned_p may be committed!

}

else {

// otherwise over-allocate

mi_assert_internal(((uintptr_t)aligned_p + offset) % alignment == 0);

mi_assert_internal(mi_usable_size(aligned_p)>=size);

mi_assert_internal(mi_usable_size(p) == mi_usable_size(aligned_p)+adjust);

// now zero the block if needed

if (alignment > MI_ALIGNMENT_MAX) {

// for the tracker, on huge aligned allocations only from the start of the large block is defined

if (p != aligned_p) {

mi_track_align(p,aligned_p,adjust,mi_usable_size(aligned_p));

return aligned_p;

}

}

else {

_mi_memzero_aligned(block, page->xblock_size - MI_PADDING_SIZE);

}

#if (MI_DEBUG>0) && !MI_TRACK_ENABLED && !MI_TSAN

if (size == 0) { size = sizeof(void*); }

#endif

mi_page_t* page = _mi_heap_get_free_small_page(heap, size + MI_PADDING_SIZE);

mi_track_malloc(p,size,zero);

#if MI_STAT>1

if (p != NULL) {

#if (MI_STAT>0)

static void mi_stat_free(const mi_page_t* page, const mi_block_t* block) {

MI_UNUSED(block);

#endif

mi_heap_t* const heap = mi_heap_get_default();

const size_t bsize = mi_page_usable_block_size(page);

#if (MI_STAT>1)

const size_t usize = mi_page_usable_size_of(page, block);

mi_heap_stat_decrease(heap, malloc, usize);

if (bsize <= MI_MEDIUM_OBJ_SIZE_MAX) {

mi_heap_stat_decrease(heap, normal, bsize);

#if (MI_STAT > 1)

}

else {

mi_heap_stat_decrease(heap, huge, bsize);

}

static void mi_stat_free(const mi_page_t* page, const mi_block_t* block) {

// that is safe as these are constant and the page won't be freed (as the block is not freed yet).

mi_check_padding(page, block);

_mi_padding_shrink(page, block, sizeof(mi_block_t)); // for small size, ensure we can fit the delayed thread pointers without triggering overflow detection

// huge page segments are always abandoned and can be freed immediately

mi_segment_t* segment = _mi_page_segment(page);

if (segment->kind == MI_SEGMENT_HUGE) {

_mi_segment_huge_page_reset(segment, page, block);

#endif

}

#if (MI_DEBUG>0) && !MI_TRACK_ENABLED && !MI_TSAN // note: when tracking, cannot use mi_usable_size with multi-threading

if (segment->kind != MI_SEGMENT_HUGE) { // not for huge segments as we just reset the content

_mi_debug_fill(page, block, MI_DEBUG_FREED, mi_usable_size(block));