mi_option_deprecated_segment_cache,

mi_option_deprecated_page_reset,

mi_option_abandoned_page_purge,// immediately purge delayed purges on thread termination

mi_option_deprecated_segment_reset,

mi_option_eager_commit_delay,

mi_option_deprecated_segment_reset,

mi_option_eager_commit_delay,

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_max_segment_reclaim,

mi_option_max_segment_reclaim,

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_arena_purge_mult,

mi_option_arena_purge_mult,

mi_option_purge_extend_delay,

_mi_option_last,

std::shared_ptr<mi_heap_t> heap;

template<classU,bool D>friendstruct_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<classT>structmi_heap_stl_allocator :public_mi_heap_stl_allocator_common<T,false> {

usingtypename _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

mi_heap_stl_allocator(mi_heap_t* hp) : _mi_heap_stl_allocator_common<T,false>(hp) { }// no delete nor destroy on the passed in heap

mi_heap_stl_allocator(mi_heap_t* hp) : _mi_heap_stl_allocator_common<T,false>(hp) { }// no delete nor destroy on the passed in heap

template<classU>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_allocatorselect_on_container_copy_construction()const {return *this; }

template<classT>structmi_heap_destroy_stl_allocator :public_mi_heap_stl_allocator_common<T,true> {

usingtypename _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

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 heap

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 heap

template<classU>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_allocatorselect_on_container_copy_construction()const {return *this; }

staticinlineboolmi_atomic_once(mi_atomic_once_t* once ) {

if (mi_atomic_load_relaxed(once) !=0)returnfalse;// quick test

if (mi_atomic_load_relaxed(once) !=0)returnfalse;// quick test

uintptr_t expected =0;

returnmi_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_alloc(size_t size,mi_memid_t* memid,mi_stats_t* stats);

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

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_tsize );

typedefstructmi_process_info_s {

mi_msecs_telapsed;

mi_msecs_tutime;

mi_msecs_tstime;

size_tcurrent_rss;

size_tpeak_rss;

mi_msecs_tstime;

size_tcurrent_rss;

size_tpeak_rss;

size_tcurrent_commit;

size_tpeak_commit;

size_tpeak_commit;

size_tpage_faults;

}mi_process_info_t;

#defineMI_TRACK_ENABLED 0

#defineMI_TRACK_HEAP_DESTROY 0

#defineMI_TRACK_HEAP_DESTROY 0

#defineMI_TRACK_TOOL "none"

#definemi_track_malloc_size(p,reqsize,size,zero)

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

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

#defineMI_MEDIUM_OBJ_WSIZE_MAX (MI_MEDIUM_OBJ_SIZE_MAX/MI_INTPTR_SIZE)

#defineMI_MEDIUM_OBJ_WSIZE_MAX (MI_MEDIUM_OBJ_SIZE_MAX/MI_INTPTR_SIZE)

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

#defineMI_LARGE_OBJ_WSIZE_MAX (MI_LARGE_OBJ_SIZE_MAX/MI_INTPTR_SIZE)

#defineMI_HUGE_BLOCK_SIZE ((uint32_t)(2*MI_GiB))

#defineMI_MAX_ALIGN_GUARANTEE (8*MI_MAX_ALIGN_SIZE)

#defineMI_MAX_ALIGN_GUARANTEE (8*MI_MAX_ALIGN_SIZE)

#defineMI_ALIGNMENT_MAX (MI_SEGMENT_SIZE >> 1)

#defineMI_ALIGNMENT_MAX (MI_SEGMENT_SIZE >> 1)

typedefstructmi_page_s {

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

uint32_tslice_offset;// distance from the actual page data slice (0 if a page)

uint32_tslice_offset;// distance from the actual page data slice (0 if a page)

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

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

uint8_ttag :4;// heap tag (mi_heap_tag_t)

#defineMI_MINIMAL_COMMIT_SIZE (1*MI_SEGMENT_SLICE_SIZE)

#defineMI_MINIMAL_COMMIT_SIZE (1*MI_SEGMENT_SLICE_SIZE)

#defineMI_COMMIT_SIZE (MI_SEGMENT_SLICE_SIZE) // 64KiB

#defineMI_COMMIT_MASK_BITS (MI_SEGMENT_SIZE / MI_COMMIT_SIZE)

#defineMI_COMMIT_MASK_BITS (MI_SEGMENT_SIZE / MI_COMMIT_SIZE)

#defineMI_COMMIT_MASK_FIELD_BITS MI_SIZE_BITS

#defineMI_COMMIT_MASK_FIELD_COUNT (MI_COMMIT_MASK_BITS / MI_COMMIT_MASK_FIELD_BITS)

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

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

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

size_tused;// count of pages in use

uintptr_tcookie;// verify addresses in debug mode: `mi_ptr_cookie(segment) == segment->cookie`

uintptr_tcookie;// verify addresses in debug mode: `mi_ptr_cookie(segment) == segment->cookie`

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

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

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

_Atomic(mi_block_t*)thread_delayed_free;

mi_threadid_tthread_id;// thread this heap belongs too

mi_arena_id_tarena_id;// arena id if the heap belongs to a specific arena (or 0)

mi_arena_id_tarena_id;// arena id if the heap belongs to a specific arena (or 0)

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

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

mi_random_ctx_trandom;// 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

if (p==NULL)returnNULL;

if (p==NULL)returnNULL;

}

else {

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);

if (alignment>MI_ALIGNMENT_MAX) {

if (p!=aligned_p) {

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

}

}

returnaligned_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*); }

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

void*constp=_mi_page_malloc(heap,page,size+MI_PADDING_SIZE,zero);

void*constp=_mi_page_malloc(heap,page,size+MI_PADDING_SIZE,zero);

mi_track_malloc(p,size,zero);

if (p!=NULL) {

#if (MI_STAT>0)

staticvoidmi_stat_free(constmi_page_t*page,constmi_block_t*block) {

#if (MI_STAT<2)

#if (MI_STAT<2)

MI_UNUSED(block);

mi_heap_t*constheap=mi_heap_get_default();

constsize_tbsize=mi_page_usable_block_size(page);

#if (MI_STAT>1)

constsize_tusize=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);

}

}

}

staticvoidmi_stat_free(constmi_page_t*page,constmi_block_t*block) {

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

mi_segment_t*segment=_mi_page_segment(page);

if (segment->kind==MI_SEGMENT_HUGE) {

_mi_segment_huge_page_reset(segment,page,block);

}

#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));