docs/mimalloc-doc_8h_source.html
| | mi-malloc 3.5/2.5/1.15 | |
Loading...
Searching...
No Matches
mimalloc-doc.h
1/* ----------------------------------------------------------------------------
2Copyright (c) 2018-2026, Microsoft Research, Daan Leijen
3This is free software; you can redistribute it and/or modify it under the
4terms of the MIT license. A copy of the license can be found in the file
5"LICENSE" at the root of this distribution.
6-----------------------------------------------------------------------------*/
7
8#error "documentation file only!"
9
10
123
124
132
138
143void* mi_malloc(size_t size);
144
149void* mi_zalloc(size_t size);
150
160void* mi_calloc(size_t count, size_t size);
161
175void* mi_realloc(void* p, size_t newsize);
176
190void* mi_expand(void* p, size_t newsize);
191
201void* mi_mallocn(size_t count, size_t size);
202
212void* mi_reallocn(void* p, size_t count, size_t size);
213
230void* mi_reallocf(void* p, size_t newsize);
231
232
241char* mi_strdup(const char* s);
242
252char* mi_strndup(const char* s, size_t n);
253
266char* mi_realpath(const char* fname, char* resolved_name);
267
281size_t mi_usable_size(void* p);
282
292size_t mi_good_size(size_t size);
293
295
296
297// ------------------------------------------------------
298// Aligned allocation
299// ------------------------------------------------------
300
308
326void* mi_malloc_aligned(size_t size, size_t alignment);
327void* mi_zalloc_aligned(size_t size, size_t alignment);
328void* mi_calloc_aligned(size_t count, size_t size, size_t alignment);
329void* mi_realloc_aligned(void* p, size_t newsize, size_t alignment);
330
342void* mi_malloc_aligned_at(size_t size, size_t alignment, size_t offset);
343void* mi_zalloc_aligned_at(size_t size, size_t alignment, size_t offset);
344void* mi_calloc_aligned_at(size_t count, size_t size, size_t alignment, size_t offset);
345void* mi_realloc_aligned_at(void* p, size_t newsize, size_t alignment, size_t offset);
346
348
349
359
373#define mi_malloc_tp(tp) ((tp*)mi_malloc_csize(sizeof(tp)))
374
381#define mi_free_tp(tp,p) (mi_free_csize(p,sizeof(tp)))
382
384#define mi_zalloc_tp(tp) ((tp*)mi_zalloc_csize(sizeof(tp)))
385
387#define mi_calloc_tp(tp,count) ((tp*)mi_calloc(count,sizeof(tp)))
388
390#define mi_mallocn_tp(tp,count) ((tp*)mi_mallocn(count,sizeof(tp)))
391
393#define mi_reallocn_tp(p,tp,count) ((tp*)mi_reallocn(p,count,sizeof(tp)))
394
396#define mi_heap_malloc_tp(tp,hp) ((tp*)mi_heap_malloc(hp,sizeof(tp)))
397
399#define mi_heap_zalloc_tp(tp,hp) ((tp*)mi_heap_zalloc(hp,sizeof(tp)))
400
402#define mi_heap_calloc_tp(tp,hp,count) ((tp*)mi_heap_calloc(hp,count,sizeof(tp)))
403
405#define mi_heap_mallocn_tp(tp,hp,count) ((tp*)mi_heap_mallocn(hp,count,sizeof(tp)))
406
408#define mi_heap_reallocn_tp(tp,hp,p,count) ((tp*)mi_heap_reallocn(p,count,sizeof(tp)))
409
411#define mi_heap_recalloc_tp(tp,hp,p,count) ((tp*)mi_heap_recalloc(p,count,sizeof(tp)))
412
414
428
434void* mi_malloc_csize(size_t size);
435
436void* mi_zalloc_csize(size_t size);
437
438void* mi_theap_malloc_csize(mi_theap_t* theap, size_t size);
439
440void* mi_theap_zalloc_csize(mi_theap_t* theap, size_t size);
441
448void mi_free_csize(void* p, size_t size);
449
456void mi_free_csize_nonnull(void* p, size_t size);
457
459
469
480void* mi_recalloc(void* p, size_t count, size_t size);
481
482void* mi_rezalloc(void* p, size_t newsize);
483void* mi_recalloc(void* p, size_t newcount, size_t size) ;
484
485void* mi_rezalloc_aligned(void* p, size_t newsize, size_t alignment);
486void* mi_rezalloc_aligned_at(void* p, size_t newsize, size_t alignment, size_t offset);
487void* mi_recalloc_aligned(void* p, size_t newcount, size_t size, size_t alignment);
488void* mi_recalloc_aligned_at(void* p, size_t newcount, size_t size, size_t alignment, size_t offset);
489
490void* mi_heap_rezalloc(mi_heap_t* heap, void* p, size_t newsize);
491void* mi_heap_recalloc(mi_heap_t* heap, void* p, size_t newcount, size_t size);
492
493void* mi_heap_rezalloc_aligned(mi_heap_t* heap, void* p, size_t newsize, size_t alignment);
494void* mi_heap_rezalloc_aligned_at(mi_heap_t* heap, void* p, size_t newsize, size_t alignment, size_t offset);
495void* mi_heap_recalloc_aligned(mi_heap_t* heap, void* p, size_t newcount, size_t size, size_t alignment);
496void* mi_heap_recalloc_aligned_at(mi_heap_t* heap, void* p, size_t newcount, size_t size, size_t alignment, size_t offset);
497
499
500
501
519
525struct mi_heap_s;
526
532typedef struct mi_heap_s mi_heap_t;
533
536
543void mi_heap_delete(mi_heap_t* heap);
544
551void mi_heap_destroy(mi_heap_t* heap);
552
557mi_heap_t* mi_heap_set_default(mi_heap_t* heap);
558
562mi_heap_t* mi_heap_get_default();
563
570mi_heap_t* mi_heap_get_backing();
571
575void mi_heap_set_numa_affinity(mi_heap_t* heap, int numa_node);
576
582mi_heap_t* mi_heap_main(void);
583
589mi_heap_t* mi_heap_of(const void* p);
590
595bool mi_heap_contains(const mi_heap_t* heap, const void* p);
596
600bool mi_any_heap_contains(const void* p);
601
602
608bool mi_is_in_heap_region(const void* p);
609
615bool mi_check_owned(const void* p);
616
623bool mi_heap_contains_block(mi_heap_t* heap, const void* p);
624
631bool mi_heap_check_owned(mi_heap_t* heap, const void* p);
632
634void mi_heap_collect(mi_heap_t* heap, bool force);
635
638void* mi_heap_malloc(mi_heap_t* heap, size_t size);
639
643void* mi_heap_malloc_small(mi_heap_t* heap, size_t size);
644
647void* mi_heap_zalloc(mi_heap_t* heap, size_t size);
648
652void* mi_heap_zalloc_small(mi_heap_t* heap, size_t size);
653
656void* mi_heap_calloc(mi_heap_t* heap, size_t count, size_t size);
657
660void* mi_heap_mallocn(mi_heap_t* heap, size_t count, size_t size);
661
664char* mi_heap_strdup(mi_heap_t* heap, const char* s);
665
668char* mi_heap_strndup(mi_heap_t* heap, const char* s, size_t n);
669
672char* mi_heap_realpath(mi_heap_t* heap, const char* fname, char* resolved_name);
673
674void* mi_heap_realloc(mi_heap_t* heap, void* p, size_t newsize);
675void* mi_heap_reallocn(mi_heap_t* heap, void* p, size_t count, size_t size);
676void* mi_heap_reallocf(mi_heap_t* heap, void* p, size_t newsize);
677
678void* mi_heap_malloc_aligned(mi_heap_t* heap, size_t size, size_t alignment);
679void* mi_heap_malloc_aligned_at(mi_heap_t* heap, size_t size, size_t alignment, size_t offset);
680void* mi_heap_zalloc_aligned(mi_heap_t* heap, size_t size, size_t alignment);
681void* mi_heap_zalloc_aligned_at(mi_heap_t* heap, size_t size, size_t alignment, size_t offset);
682void* mi_heap_calloc_aligned(mi_heap_t* heap, size_t count, size_t size, size_t alignment);
683void* mi_heap_calloc_aligned_at(mi_heap_t* heap, size_t count, size_t size, size_t alignment, size_t offset);
684void* mi_heap_realloc_aligned(mi_heap_t* heap, void* p, size_t newsize, size_t alignment);
685void* mi_heap_realloc_aligned_at(mi_heap_t* heap, void* p, size_t newsize, size_t alignment, size_t offset);
686
688
689
690
695
696
699typedef struct mi_heap_area_s {
704size_t block_size;
705size_t full_block_size;
707} [mi_heap_area_t](group analysis.html#structmi heap area t);
708
716typedef bool (mi_block_visit_fun)(const mi_heap_t* heap, const [mi_heap_area_t](group__analysis.html#structmi heap area__t)* area, void* block, size_t block_size, void* arg);
717
732bool mi_heap_visit_blocks(const mi_heap_t* heap, bool visit_blocks, mi_block_visit_fun* visitor, void* arg);
733
749bool mi_abandoned_visit_blocks(mi_subproc_id_t subproc_id, int heap_tag, bool visit_blocks, mi_block_visit_fun* visitor, void* arg);
750
752
753// ------------------------------------------------------
754// Arenas
755// ------------------------------------------------------
756
764
766typedef int mi_arena_id_t;
767
776intmi_reserve_os_memory(size_t size, bool commit, bool allow_large);
777
785int mi_reserve_os_memory_ex(size_t size, bool commit, bool allow_large, bool exclusive, mi_arena_id_t* arena_id);
786
799int mi_reserve_huge_os_pages_interleave(size_t pages, size_t numa_nodes, size_t timeout_msecs);
800
813int mi_reserve_huge_os_pages_at(size_t pages, int numa_node, size_t timeout_msecs);
814
822intmi_reserve_huge_os_pages_at_ex(size_t pages, int numa_node, size_t timeout_msecs, bool exclusive, mi_arena_id_t* arena_id);
823
826size_t mi_arena_min_alignment(void);
827
839bool mi_manage_os_memory(void* start, size_t size, bool is_committed, bool is_large, bool is_zero, int numa_node);
840
851boolmi_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);
852
853
855void mi_debug_show_arenas(void);
856
861void* mi_arena_area(mi_arena_id_t arena_id, size_t* size);
862
863
864
868mi_heap_t* mi_heap_new_in_arena(mi_arena_id_t arena_id);
869
881mi_heap_t* mi_heap_new_ex(int heap_tag, bool allow_destroy, mi_arena_id_t arena_id);
882
884
885
894
899typedef void* mi_subproc_id_t;
900
902mi_subproc_id_t mi_subproc_main(void);
903
905mi_subproc_id_t mi_subproc_current(void);
906
909mi_subproc_id_t mi_subproc_new(void);
910
914void mi_subproc_destroy(mi_subproc_id_t subproc);
915
920void mi_subproc_delete(mi_subproc_id_t subproc);
921
925void mi_subproc_add_current_thread(mi_subproc_id_t subproc);
926
930typedef bool (mi_heap_visit_fun)(mi_heap_t* heap, void* arg);
931
937bool mi_subproc_visit_heaps(mi_subproc_id_t subproc, mi_heap_visit_fun* visitor, void* arg);
938
940
941
942// ------------------------------------------------------
943// Extended functionality
944// ------------------------------------------------------
945
950
954#define MI_SMALL_SIZE_MAX (128*sizeof(void*))
955
959intmi_version(void);
960
968void mi_collect(bool force);
969
975void mi_thread_set_in_threadpool(void);
976
981bool mi_is_redirected();
982
986void mi_thread_init(void);
987
992void mi_thread_done(void);
993
1000typedef void (mi_deferred_free_fun)(bool force, unsigned long long heartbeat, void* arg);
1001
1017voidmi_register_deferred_free(mi_deferred_free_fun* deferred_free, void* arg);
1018
1024typedef void (mi_output_fun)(const char* msg, void* arg);
1025
1032void mi_register_output(mi_output_fun* out, void* arg);
1033
1039typedef void (mi_error_fun)(int err, void* arg);
1040
1056void mi_register_error(mi_error_fun* errfun, void* arg);
1057
1065void* mi_malloc_small(size_t size);
1066
1074void* mi_zalloc_small(size_t size);
1075
1091void mi_free_small(void* p);
1092
1108void mi_free_small_nonnull(void* p);
1109
1111
1112
1113
1114
1115
1116// ------------------------------------------------------
1117// Statistics
1118// ------------------------------------------------------
1119
1123
1125#define MI_STAT_VERSION 4
1126
1136#define mi_stats_t_decl(name)
1137
1139struct [mi_stats_s](group__stats.html#structmi stats s) {
1144};
1145
1147typedef struct [mi_stats_s](group stats.html#structmi stats__s) mi_stats_t;
1148
1149
1152void mi_process_info_print(void);
1153
1158void mi_process_info_print_out(mi_output_fun* out, void* arg);
1159
1173void mi_process_info(size_t* elapsed_msecs, size_t* user_msecs, size_t* system_msecs, size_t* current_rss, size_t* peak_rss, size_t* current_commit, size_t* peak_commit, size_t* page_faults);
1174
1175
1180void mi_stats_print(void* out);
1181
1187void mi_stats_print_out(mi_output_fun* out, void* arg);
1188
1194bool mi_stats_get(mi_stats_t* stats);
1195
1201char* mi_stats_get_json(size_t buf_size, char* buf);
1202
1204size_tmi_stats_get_bin_size(size_t bin);
1205
1212bool mi_heap_stats_get(mi_heap_t* heap, mi_stats_t* stats);
1213
1220char* mi_heap_stats_get_json(mi_heap_t* heap, size_t buf_size, char* buf); // use mi_free to free the result if the input buf == NULL
1221
1226void mi_heap_stats_print_out(mi_heap_t* heap, mi_output_fun* out, void* arg);
1227
1231void mi_heap_stats_merge_to_subproc(mi_heap_t* heap);
1232
1239bool mi_subproc_stats_get(mi_subproc_id_t subproc_id, mi_stats_t* stats);
1240
1247char* mi_subproc_stats_get_json(mi_subproc_id_t subproc_id, size_t buf_size, char* buf); // use mi_free to free the result if the input buf == NULL
1248
1253voidmi_subproc_stats_print_out(mi_subproc_id_t subproc_id, mi_output_fun* out, void* arg);
1254
1255
1260void mi_subproc_heap_stats_print_out(mi_subproc_id_t subproc_id, mi_output_fun* out, void* arg);
1261
1268char* mi_stats_as_json( mi_stats_t* stats, size_t buf_size, char* buf);
1269
1271void mi_stats_reset(void);
1272
1274void mi_stats_merge(void);
1275
1277
1278// ------------------------------------------------------
1279// Runtime Options
1280// ------------------------------------------------------
1281
1286
1289void mi_options_print(void);
1290
1296void mi_options_print_out(mi_output_fun* out, void* arg);
1297
1298
1300typedef enum mi_option_e {
1301// stable options
1307
1308// advanced options
1309mi_option_reserve_huge_os_pages,
1310mi_option_reserve_huge_os_pages_at,
1311mi_option_reserve_os_memory,
1312mi_option_allow_large_os_pages,
1313mi_option_purge_decommits,
1317mi_option_generic_collect,
1319
1320// guard pages
1323mi_option_guarded_precise,
1324mi_option_guarded_sample_rate,
1325mi_option_guarded_sample_seed,
1326
1327// experimental options
1329mi_option_eager_commit_delay,
1330mi_option_arena_eager_commit,
1331mi_option_abandoned_page_purge,
1334mi_option_disallow_os_alloc,
1335mi_option_max_segment_reclaim,
1336mi_option_destroy_on_exit,
1337mi_option_arena_purge_mult,
1338mi_option_abandoned_reclaim_on_free,
1339mi_option_purge_extend_delay,
1340mi_option_disallow_arena_alloc,
1341mi_option_visit_abandoned,
1342mi_option_target_segments_per_thread,
1343
1344// v3 options
1345mi_option_page_reclaim_on_free,
1346mi_option_page_full_retain,
1347mi_option_page_max_candidates,
1350mi_option_page_commit_on_demand,
1351mi_option_page_max_reclaim,
1352mi_option_page_cross_thread_max_reclaim,
1353mi_option_minimal_purge_size,
1354mi_option_arena_max_object_size,
1355
1356_mi_option_last
1358
1359
1360boolmi_option_is_enabled(mi_option_t option);
1361voidmi_option_enable(mi_option_t option);
1362voidmi_option_disable(mi_option_t option);
1363voidmi_option_set_enabled(mi_option_t option, bool enable);
1364voidmi_option_set_enabled_default(mi_option_t option, bool enable);
1365
1366longmi_option_get(mi_option_t option);
1367longmi_option_get_clamp(mi_option_t option, long min, long max);
1368size_t mi_option_get_size(mi_option_t option);
1369
1370voidmi_option_set(mi_option_t option, long value);
1371voidmi_option_set_default(mi_option_t option, long value);
1372
1374
1387
1389struct mi_theap_s;
1390
1392typedef struct mi_theap_s mi_theap_t;
1393
1400mi_theap_t* mi_heap_theap(mi_heap_t* heap);
1401
1403void mi_theap_collect(mi_theap_t* theap, bool force);
1404
1409mi_theap_t* mi_theap_set_default(mi_theap_t* theap);
1410
1413mi_theap_t* mi_theap_get_default();
1414
1417void* mi_theap_malloc(mi_theap_t* theap, size_t size);
1418
1422void* mi_theap_malloc_small(mi_theap_t* theap, size_t size);
1423
1426void* mi_theap_zalloc(mi_theap_t* theap, size_t size);
1427
1431void* mi_theap_zalloc_small(mi_theap_t* theap, size_t size);
1432
1433void* mi_theap_calloc(mi_theap_t* theap, size_t count, size_t size);
1434void* mi_theap_malloc_aligned(mi_theap_t* theap, size_t size, size_t alignment);
1435void* mi_theap_realloc(mi_theap_t* theap, void* p, size_t newsize);
1436
1438
1439
1445
1446void* mi__expand(void* p, size_t newsize);
1447
1448size_t mi_malloc_size(const void* p);
1449size_t mi_malloc_good_size(size_t size);
1450size_t mi_malloc_usable_size(const void *p);
1451
1452int mi_posix_memalign(void** p, size_t alignment, size_t size);
1453int mi__posix_memalign(void** p, size_t alignment, size_t size);
1454void* mi_memalign(size_t alignment, size_t size);
1455void* mi_valloc(size_t size);
1456void* mi_pvalloc(size_t size);
1457void* mi_aligned_alloc(size_t alignment, size_t size);
1458
1459unsigned short* mi_wcsdup(const unsigned short* s);
1460unsigned char* mi_mbsdup(const unsigned char* s);
1461int mi_dupenv_s(char** buf, size_t* size, const char* name);
1462int mi_wdupenv_s(unsigned short** buf, size_t* size, const unsigned short* name);
1463
1466void* mi_reallocarray(void* p, size_t count, size_t size);
1467
1469intmi_reallocarr(void* p, size_t count, size_t size);
1470
1471void* mi_aligned_recalloc(void* p, size_t newcount, size_t size, size_t alignment);
1472void* mi_aligned_offset_recalloc(void* p, size_t newcount, size_t size, size_t alignment, size_t offset);
1473
1482void mi_free_size(void* p, size_t size);
1483
1491void mi_free_size_nonnull(void* p, size_t size);
1492
1498void mi_free_size_aligned(void* p, size_t size, size_t alignment);
1499
1500void mi_free_aligned(void* p, size_t alignment);
1501
1503
1516
1518void* mi_new(std::size_t n) noexcept(false);
1519
1521void* mi_new_n(size_t count, size_t size) noexcept(false);
1522
1524void* mi_new_aligned(std::size_t n, std::align_val_t alignment) noexcept(false);
1525
1527void* mi_new_nothrow(size_t n);
1528
1530void* mi_new_aligned_nothrow(size_t n, size_t alignment);
1531
1533void* mi_new_realloc(void* p, size_t newsize);
1534
1536void* mi_new_reallocn(void* p, size_t newcount, size_t size);
1537
1545template<class T> struct [mi_stl_allocator](group__cpp.html#structmi stl allocator) { }
1546
1548
void * mi_malloc_aligned_at(size_t size, size_t alignment, size_t offset)
Allocate size bytes aligned by alignment at a specified offset.
void * mi_calloc_aligned(size_t count, size_t size, size_t alignment)
void * mi_realloc_aligned(void *p, size_t newsize, size_t alignment)
void * mi_malloc_aligned(size_t size, size_t alignment)
Allocate size bytes aligned by alignment.
void * mi_zalloc_aligned_at(size_t size, size_t alignment, size_t offset)
void * mi_calloc_aligned_at(size_t count, size_t size, size_t alignment, size_t offset)
void * mi_zalloc_aligned(size_t size, size_t alignment)
void * mi_realloc_aligned_at(void *p, size_t newsize, size_t alignment, size_t offset)
int heap_tag
heap tag associated with this area (see mi_heap_new_ex)
Definition mimalloc-doc.h:706
size_t block_size
size in bytes of one block
Definition mimalloc-doc.h:704
size_t committed
current committed bytes of this area
Definition mimalloc-doc.h:702
mi_heap_area_t::full_block_size
size_t full_block_size
size in bytes of a full block including padding and metadata.
Definition mimalloc-doc.h:705
size_t used
bytes in use by allocated blocks
Definition mimalloc-doc.h:703
void * blocks
start of the area containing heap blocks
Definition mimalloc-doc.h:700
size_t reserved
bytes reserved for this area
Definition mimalloc-doc.h:701
bool mi_abandoned_visit_blocks(mi_subproc_id_t subproc_id, int heap_tag, bool visit_blocks, mi_block_visit_fun *visitor, void *arg)
v1,v2: Visit all areas and blocks in abandoned heaps.
bool mi_block_visit_fun(const mi_heap_t *heap, const mi_heap_area_t *area, void *block, size_t block_size, void *arg)
Visitor function passed to mi_heap_visit_blocks()
Definition mimalloc-doc.h:716
bool mi_heap_visit_blocks(const mi_heap_t *heap, bool visit_blocks, mi_block_visit_fun *visitor, void *arg)
Visit all areas and blocks in a heap.
[mi_heap_area_t](group analysis.html#structmi heap area t)
An area of heap space contains blocks of a single size.
Definition mimalloc-doc.h:699
int mi_reserve_os_memory(size_t size, bool commit, bool allow_large)
Reserve OS memory for use by mimalloc.
mi_reserve_huge_os_pages_interleave
int mi_reserve_huge_os_pages_interleave(size_t pages, size_t numa_nodes, size_t timeout_msecs)
Reserve pages of huge OS pages (1GiB) evenly divided over numa_nodes nodes, but stops after at most t...
int mi_reserve_os_memory_ex(size_t size, bool commit, bool allow_large, bool exclusive, mi_arena_id_t *arena_id)
Reserve OS memory to be managed in an arena.
mi_heap_t * mi_heap_new_ex(int heap_tag, bool allow_destroy, mi_arena_id_t arena_id)
v1,v2: Create a new heap.
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)
Manage externally allocated memory as a mimalloc arena.
bool mi_manage_os_memory(void *start, size_t size, bool is_committed, bool is_large, bool is_zero, int numa_node)
Manage a particular memory area for use by mimalloc.
mi_reserve_huge_os_pages_at_ex
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)
Reserve huge OS pages (1GiB) into a single arena.
int mi_reserve_huge_os_pages_at(size_t pages, int numa_node, size_t timeout_msecs)
Reserve pages of huge OS pages (1GiB) at a specific numa_node, but stops after at most timeout_msecs ...
void mi_debug_show_arenas(void)
Show all current arena's.
int mi_arena_id_t
Each arena has an associated identifier.
Definition mimalloc-doc.h:766
void * mi_arena_area(mi_arena_id_t arena_id, size_t *size)
Return the start and size of an arena.
size_t mi_arena_min_alignment(void)
Return the minimal alignment required for managed OS memory.
mi_heap_t * mi_heap_new_in_arena(mi_arena_id_t arena_id)
Create a new heap that only allocates in the specified arena.
void * mi_theap_malloc_csize(mi_theap_t *theap, size_t size)
void * mi_theap_zalloc_csize(mi_theap_t *theap, size_t size)
void mi_free_csize_nonnull(void *p, size_t size)
v3: Free a non-null pointer with a known constant size.
void mi_free_csize(void *p, size_t size)
v3: Free a pointer with a known constant size.
void * mi_malloc_csize(size_t size)
v3: Allocate a constant size object.
void * mi_zalloc_csize(size_t size)
void * mi_new_nothrow(size_t n)
like mi_malloc, but when out of memory, use std::get_new_handler but return NULL on failure.
void * mi_new(std::size_t n) noexcept(false)
like mi_malloc(), but when out of memory, use std::get_new_handler and raise std::bad_alloc exception...
void * mi_new_realloc(void *p, size_t newsize)
like mi_realloc(), but when out of memory, use std::get_new_handler and raise std::bad_alloc exceptio...
void * mi_new_aligned(std::size_t n, std::align_val_t alignment) noexcept(false)
like mi_malloc_aligned(), but when out of memory, use std::get_new_handler and raise std::bad_alloc e...
void * mi_new_aligned_nothrow(size_t n, size_t alignment)
like mi_malloc_aligned, but when out of memory, use std::get_new_handler but return NULL on failure.
void * mi_new_reallocn(void *p, size_t newcount, size_t size)
like mi_reallocn(), but when out of memory, use std::get_new_handler and raise std::bad_alloc excepti...
void * mi_new_n(size_t count, size_t size) noexcept(false)
like mi_mallocn(), but when out of memory, use std::get_new_handler and raise std::bad_alloc exceptio...
[mi_stl_allocator](group cpp.html#structmi stl__allocator)
std::allocator implementation for mimalloc for use in STL containers. For example:
Definition mimalloc-doc.h:1545
void mi_thread_done(void)
Uninitialize mimalloc on a thread.
void mi_free_small_nonnull(void *p)
v3: Can be used to free an object that was allocated with mi_malloc_small() or any allocation with a ...
void mi_deferred_free_fun(bool force, unsigned long long heartbeat, void *arg)
Type of deferred free functions.
Definition mimalloc-doc.h:1000
void mi_free_small(void *p)
v3: Can be used to free an object that was allocated with mi_malloc_small() or any allocation with a ...
void mi_register_deferred_free(mi_deferred_free_fun *deferred_free, void *arg)
Register a deferred free function.
void mi_collect(bool force)
Eagerly free memory.
void * mi_zalloc_small(size_t size)
Allocate a zero initialized small object.
void * mi_malloc_small(size_t size)
Allocate a small object.
void mi_error_fun(int err, void *arg)
Type of error callback functions.
Definition mimalloc-doc.h:1039
void mi_register_error(mi_error_fun *errfun, void *arg)
Register an error callback function.
bool mi_is_redirected()
Is the C runtime malloc API redirected?
void mi_thread_set_in_threadpool(void)
v3: Communicate that a thread is in a threadpool.
void mi_output_fun(const char *msg, void *arg)
Type of output functions.
Definition mimalloc-doc.h:1024
void mi_register_output(mi_output_fun *out, void *arg)
Register an output function.
int mi_version(void)
Return the mimalloc version.
void mi_thread_init(void)
Initialize mimalloc on a thread.
void * mi_heap_malloc_small(mi_heap_t *heap, size_t size)
Allocate a small object in a specific heap.
void * mi_heap_zalloc_small(mi_heap_t *heap, size_t size)
Allocate a small object in a specific heap.
bool mi_heap_check_owned(mi_heap_t *heap, const void *p)
v1,v2: Check safely if any pointer is part of a heap.
mi_heap_t * mi_heap_get_default()
v1,v2: Get the default heap that is used for mi_malloc() et al.
bool mi_any_heap_contains(const void *p)
v3: is a pointer pointing into mimalloc managed memory?
void mi_heap_delete(mi_heap_t *heap)
Delete a previously allocated heap.
void * mi_heap_malloc_aligned(mi_heap_t *heap, size_t size, size_t alignment)
mi_heap_t * mi_heap_set_default(mi_heap_t *heap)
v1,v2: Set the default heap to use in the current thread for mi_malloc() et al.
struct mi_heap_s mi_heap_t
Type of first-class heaps.
Definition mimalloc-doc.h:532
mi_heap_t * mi_heap_of(const void *p)
v3: return the heap that contains the given pointer.
void * mi_heap_zalloc_aligned_at(mi_heap_t *heap, size_t size, size_t alignment, size_t offset)
char * mi_heap_realpath(mi_heap_t *heap, const char *fname, char *resolved_name)
Resolve a file path name using a specific heap to allocate the result.
char * mi_heap_strdup(mi_heap_t *heap, const char *s)
Duplicate a string in a specific heap.
bool mi_is_in_heap_region(const void *p)
v1,v2: Is a pointer part of our heap?
bool mi_check_owned(const void *p)
v1,v2: Check if any pointer is part of the default heap of this thread.
void * mi_heap_zalloc_aligned(mi_heap_t *heap, size_t size, size_t alignment)
void * mi_heap_realloc_aligned_at(mi_heap_t *heap, void *p, size_t newsize, size_t alignment, size_t offset)
void mi_heap_collect(mi_heap_t *heap, bool force)
Release outstanding resources in a specific heap.
mi_heap_t * mi_heap_main(void)
v3: the main heap (of the current sub-process)
void mi_heap_destroy(mi_heap_t *heap)
Destroy a heap, freeing all its still allocated blocks.
void * mi_heap_calloc_aligned_at(mi_heap_t *heap, size_t count, size_t size, size_t alignment, size_t offset)
mi_heap_t * mi_heap_new()
Create a new heap that can be used for allocation.
bool mi_heap_contains_block(mi_heap_t *heap, const void *p)
v1,v2: Does a heap contain a pointer to a previously allocated block?
void mi_heap_set_numa_affinity(mi_heap_t *heap, int numa_node)
v3: set NUMA affinity for a heap.
void * mi_heap_mallocn(mi_heap_t *heap, size_t count, size_t size)
Allocate count elements in a specific heap.
void * mi_heap_malloc(mi_heap_t *heap, size_t size)
Allocate in a specific heap.
void * mi_heap_zalloc(mi_heap_t *heap, size_t size)
Allocate zero-initialized in a specific heap.
void * mi_heap_calloc(mi_heap_t *heap, size_t count, size_t size)
Allocate count zero-initialized elements in a specific heap.
void * mi_heap_realloc(mi_heap_t *heap, void *p, size_t newsize)
mi_heap_t * mi_heap_get_backing()
v1,v2: Get the backing heap.
bool mi_heap_contains(const mi_heap_t *heap, const void *p)
v3: does a heap contain a specific pointer?
void * mi_heap_calloc_aligned(mi_heap_t *heap, size_t count, size_t size, size_t alignment)
void * mi_heap_reallocn(mi_heap_t *heap, void *p, size_t count, size_t size)
void * mi_heap_realloc_aligned(mi_heap_t *heap, void *p, size_t newsize, size_t alignment)
char * mi_heap_strndup(mi_heap_t *heap, const char *s, size_t n)
Duplicate a string of at most length n in a specific heap.
void * mi_heap_reallocf(mi_heap_t *heap, void *p, size_t newsize)
void * mi_heap_malloc_aligned_at(mi_heap_t *heap, size_t size, size_t alignment, size_t offset)
void * mi_realloc(void *p, size_t newsize)
Re-allocate memory to newsize bytes.
size_t mi_usable_size(void *p)
Return the available bytes in a memory block.
void * mi_expand(void *p, size_t newsize)
Try to re-allocate memory to newsize bytes in place.
char * mi_strdup(const char *s)
Allocate and duplicate a string.
char * mi_strndup(const char *s, size_t n)
Allocate and duplicate a string up to n bytes.
void * mi_reallocf(void *p, size_t newsize)
Re-allocate memory to newsize bytes,.
void * mi_mallocn(size_t count, size_t size)
Allocate count elements of size bytes.
void * mi_calloc(size_t count, size_t size)
Allocate zero-initialized count elements of size bytes.
void mi_cfree(void *p)
Checked free: just as mi_free() but always checks if the pointer p belongs to our heap.
void * mi_reallocn(void *p, size_t count, size_t size)
Re-allocate memory to count elements of size bytes.
char * mi_realpath(const char *fname, char *resolved_name)
Resolve a file path name.
size_t mi_good_size(size_t size)
Return the probable allocation block size for a given required size.
void * mi_malloc(size_t size)
Allocate size bytes.
void * mi_zalloc(size_t size)
Allocate zero-initialized size bytes.
void mi_free(void *p)
Free previously allocated memory.
void mi_option_enable(mi_option_t option)
void mi_options_print_out(mi_output_fun *out, void *arg)
Print out all process info.
size_t mi_option_get_size(mi_option_t option)
bool mi_option_is_enabled(mi_option_t option)
void mi_option_set_enabled_default(mi_option_t option, bool enable)
long mi_option_get(mi_option_t option)
void mi_option_set_default(mi_option_t option, long value)
long mi_option_get_clamp(mi_option_t option, long min, long max)
void mi_option_set_enabled(mi_option_t option, bool enable)
void mi_option_disable(mi_option_t option)
void mi_options_print(void)
Print out all runtime parameters for mimalloc. Also printed with MIMALLOC_VERBOSE=1 at startup.
void mi_option_set(mi_option_t option, long value)
mi_option_t
Runtime options.
Definition mimalloc-doc.h:1300
@ mi_option_guarded_min
only used when building with MI_GUARDED: minimal rounded object size for guarded objects (=0)
Definition mimalloc-doc.h:1321
mi_option_abandoned_reclaim_on_free
@ mi_option_abandoned_reclaim_on_free
v1,v2: allow to reclaim an abandoned segment on a free (=1)
Definition mimalloc-doc.h:1338
@ mi_option_purge_extend_delay
v1,v2: extend purge delay on each subsequent delay (=1)
Definition mimalloc-doc.h:1339
@ mi_option_allow_thp
allow transparent huge pages? (=1) (on Android =0 by default). Set to 0 to disable THP for the proces...
Definition mimalloc-doc.h:1318
@ mi_option_show_stats
Print statistics on termination.
Definition mimalloc-doc.h:1303
@ mi_option_use_numa_nodes
0 = use all available numa nodes, otherwise use at most N nodes.
Definition mimalloc-doc.h:1333
@ mi_option_page_max_reclaim
v3: don't reclaim pages of the same originating theap if we already own N pages (in that size class) ...
Definition mimalloc-doc.h:1351
mi_option_abandoned_page_purge
@ mi_option_abandoned_page_purge
v1,v2: immediately purge delayed purges on thread termination
Definition mimalloc-doc.h:1331
@ mi_option_eager_commit_delay
v2: the first N segments per thread are not eagerly committed (but per page in the segment on demand)
Definition mimalloc-doc.h:1329
@ mi_option_eager_commit
v1,v2: eager commit segments? (after eager_commit_delay segments) (enabled by default).
Definition mimalloc-doc.h:1328
@ mi_option_guarded_precise
disregard minimal alignment requirement to always place guarded blocks exactly in front of a guard pa...
Definition mimalloc-doc.h:1323
@ mi_option_visit_abandoned
allow visiting heap blocks from abandoned threads (=0)
Definition mimalloc-doc.h:1341
@ mi_option_os_tag
tag used for OS logging (macOS only for now) (=100)
Definition mimalloc-doc.h:1315
mi_option_arena_max_object_size
@ mi_option_arena_max_object_size
v3: set maximal object size that can be allocated in an arena (in KiB) (=2GiB on 64-bit).
Definition mimalloc-doc.h:1354
@ mi_option_minimal_purge_size
v3: set minimal purge size (in KiB) (=0). By default set to either 64 or 2048 if THP is enabled....
Definition mimalloc-doc.h:1353
@ _mi_option_last
Definition mimalloc-doc.h:1356
@ mi_option_destroy_on_exit
if set, release all memory on exit; sometimes used for dynamic unloading but can be unsafe
Definition mimalloc-doc.h:1336
mi_option_page_cross_thread_max_reclaim
@ mi_option_page_cross_thread_max_reclaim
v3: don't reclaim pages across threads if we already own N pages (in that size class) (=16)
Definition mimalloc-doc.h:1352
mi_option_page_commit_on_demand
@ mi_option_page_commit_on_demand
v3: commit page memory on-demand (=0)
Definition mimalloc-doc.h:1350
@ mi_option_guarded_sample_seed
can be set to allow for a (more) deterministic re-execution when a guard page is triggered (=0)
Definition mimalloc-doc.h:1325
@ mi_option_verbose
Print verbose messages.
Definition mimalloc-doc.h:1304
mi_option_allow_large_os_pages
@ mi_option_allow_large_os_pages
allow large (2 or 4 MiB) OS pages, implies eager commit.
Definition mimalloc-doc.h:1312
@ mi_option_arena_purge_mult
multiplier for purge_delay for the purging delay for arenas (=10)
Definition mimalloc-doc.h:1337
mi_option_target_segments_per_thread
@ mi_option_target_segments_per_thread
v1,v2: experimental (=0)
Definition mimalloc-doc.h:1342
@ mi_option_generic_collect
collect heaps every N (=10000) generic allocation calls
Definition mimalloc-doc.h:1317
@ mi_option_retry_on_oom
retry on out-of-memory for N milli seconds (=400), set to 0 to disable retries. (only on windows)
Definition mimalloc-doc.h:1316
@ mi_option_guarded_max
only used when building with MI_GUARDED: maximal rounded object size for guarded objects (=0)
Definition mimalloc-doc.h:1322
@ mi_option_purge_decommits
should a memory purge decommit? (=1). Set to 0 to use memory reset on a purge (instead of decommit)
Definition mimalloc-doc.h:1313
mi_option_reserve_huge_os_pages_at
@ mi_option_reserve_huge_os_pages_at
Reserve N huge OS pages at a specific NUMA node N.
Definition mimalloc-doc.h:1310
@ mi_option_pagemap_commit
v3: commit the full pagemap (to always catch invalid pointer uses) (=0)
Definition mimalloc-doc.h:1349
@ mi_option_max_segment_reclaim
v2: max. percentage of the abandoned segments can be reclaimed per try (=10%)
Definition mimalloc-doc.h:1335
@ mi_option_max_vabits
v3: max user space virtual address bits to consider (=48)
Definition mimalloc-doc.h:1348
@ mi_option_arena_reserve
initial memory size for arena reservation (= 1 GiB on 64-bit) (internally, this value is in KiB; use ...
Definition mimalloc-doc.h:1314
mi_option_page_reclaim_on_free
@ mi_option_page_reclaim_on_free
v3: reclaim abandoned pages on a free (=0). -1 disallowr always, 0 allows if the page originated from...
Definition mimalloc-doc.h:1345
mi_option_reserve_huge_os_pages
@ mi_option_reserve_huge_os_pages
reserve N huge OS pages (1GiB pages) at startup
Definition mimalloc-doc.h:1309
@ mi_option_page_max_candidates
v3: max candidate pages to consider for allocation (=4)
Definition mimalloc-doc.h:1347
@ mi_option_disallow_os_alloc
1 = do not use OS memory for allocation (but only programmatically reserved arenas)
Definition mimalloc-doc.h:1334
@ mi_option_purge_delay
memory purging is delayed by N milli seconds; use 0 for immediate purging or -1 for no purging at all...
Definition mimalloc-doc.h:1332
mi_option_disallow_arena_alloc
@ mi_option_disallow_arena_alloc
1 = do not use arena's for allocation (except if using specific arena id's)
Definition mimalloc-doc.h:1340
@ mi_option_guarded_sample_rate
1 out of N allocations in the min/max range will be guarded (=1000)
Definition mimalloc-doc.h:1324
@ mi_option_max_errors
issue at most N error messages
Definition mimalloc-doc.h:1305
@ mi_option_page_full_retain
v3: retain N full (small) pages per size class (=2). Use -1 for infinite (as in v1,...
Definition mimalloc-doc.h:1346
@ mi_option_max_warnings
issue at most N warning messages
Definition mimalloc-doc.h:1306
@ mi_option_show_errors
Print error messages.
Definition mimalloc-doc.h:1302
@ mi_option_reserve_os_memory
reserve specified amount of OS memory in an arena at startup (internally, this value is in KiB; use m...
Definition mimalloc-doc.h:1311
@ mi_option_arena_eager_commit
eager commit arenas? Use 2 to enable just on overcommit systems (=2)
Definition mimalloc-doc.h:1330
size_t mi_malloc_usable_size(const void *p)
void mi_free_aligned(void *p, size_t alignment)
void * mi_aligned_offset_recalloc(void *p, size_t newcount, size_t size, size_t alignment, size_t offset)
void * mi_aligned_alloc(size_t alignment, size_t size)
size_t mi_malloc_size(const void *p)
void * mi_valloc(size_t size)
void * mi_pvalloc(size_t size)
void * mi__expand(void *p, size_t newsize)
int mi_wdupenv_s(unsigned short **buf, size_t *size, const unsigned short *name)
void * mi_memalign(size_t alignment, size_t size)
void mi_free_size_aligned(void *p, size_t size, size_t alignment)
Free an object that was allocated aligned.
void mi_free_size_nonnull(void *p, size_t size)
Free a non-NULL pointer that was allocated with a known size.
unsigned char * mi_mbsdup(const unsigned char *s)
int mi_reallocarr(void *p, size_t count, size_t size)
Corresponds to reallocarr in NetBSD.
size_t mi_malloc_good_size(size_t size)
unsigned short * mi_wcsdup(const unsigned short *s)
int mi_dupenv_s(char **buf, size_t *size, const char *name)
int mi_posix_memalign(void **p, size_t alignment, size_t size)
int mi__posix_memalign(void **p, size_t alignment, size_t size)
void * mi_reallocarray(void *p, size_t count, size_t size)
Correspond s to reallocarray in FreeBSD.
void mi_free_size(void *p, size_t size)
Free a block that was allocated with a known size.
void * mi_aligned_recalloc(void *p, size_t newcount, size_t size, size_t alignment)
size_t version
initialize with `MI_STAT_VERSION (so linking dynamically with a separately compiled mimalloc is safe)
Definition mimalloc-doc.h:1143
size_t size
initialize with sizeof(mi_stats_t) (so linking dynamically with a separately compiled mimalloc is saf...
Definition mimalloc-doc.h:1141
void mi_process_info_print_out(mi_output_fun *out, void *arg)
Print out all process info.
mi_subproc_heap_stats_print_out
void mi_subproc_heap_stats_print_out(mi_subproc_id_t subproc_id, mi_output_fun *out, void *arg)
v3: Print statistics for a given subprocess with each heap separately printed.
bool mi_heap_stats_get(mi_heap_t *heap, mi_stats_t *stats)
v3: Return statistics for a given heap.
void mi_stats_print(void *out)
Deprecated.
void mi_stats_reset(void)
v1,v2: Reset statistics.
void mi_stats_print_out(mi_output_fun *out, void *arg)
Print statistics of the current subprocess aggregated over all its heaps.
void mi_subproc_stats_print_out(mi_subproc_id_t subproc_id, mi_output_fun *out, void *arg)
v3: Print the subproc statistics aggregated over all its heaps.
mi_heap_stats_merge_to_subproc
void mi_heap_stats_merge_to_subproc(mi_heap_t *heap)
v3: xplicitly merge the statistics of the current heap with the subprocess.
bool mi_subproc_stats_get(mi_subproc_id_t subproc_id, mi_stats_t *stats)
v3: Get statistics for a given subprocess aggregated over all its heaps.
char * mi_stats_as_json(mi_stats_t *stats, size_t buf_size, char *buf)
v3: Show the given statistics as JSON.
void mi_process_info(size_t *elapsed_msecs, size_t *user_msecs, size_t *system_msecs, size_t *current_rss, size_t *peak_rss, size_t *current_commit, size_t *peak_commit, size_t *page_faults)
Return process information (time and memory usage).
void mi_stats_merge(void)
v1,v2: Merge thread local statistics with the main statistics and reset.
bool mi_stats_get(mi_stats_t *stats)
Get the statistics for the current subprocess aggregated over all its heaps.
char * mi_heap_stats_get_json(mi_heap_t *heap, size_t buf_size, char *buf)
v3: Get the statistics for a heap as JSON.
char * mi_subproc_stats_get_json(mi_subproc_id_t subproc_id, size_t buf_size, char *buf)
v3: Show the subproc statistics aggregated over all its heaps as JSON.
char * mi_stats_get_json(size_t buf_size, char *buf)
Get the statistics for the current subprocess aggregated over all its heaps as JSON.
size_t mi_stats_get_bin_size(size_t bin)
v3: Return the block size for the given bin.
void mi_process_info_print(void)
Print out all process info.
void mi_heap_stats_print_out(mi_heap_t *heap, mi_output_fun *out, void *arg)
v3: Show the heap statistics as JSON.
[mi_stats_s](group stats.html#structmi stats__s)
Statistics. See include/mimalloc-stats.h for the full definition.
Definition mimalloc-doc.h:1139
mi_subproc_id_t mi_subproc_main(void)
Get the main sub-process identifier.
bool mi_heap_visit_fun(mi_heap_t *heap, void *arg)
The type of a heap visitor function.
Definition mimalloc-doc.h:930
mi_subproc_id_t mi_subproc_new(void)
Create a fresh sub-process (with no associated threads yet).
void * mi_subproc_id_t
A process can associate threads with sub-processes.
Definition mimalloc-doc.h:899
void mi_subproc_delete(mi_subproc_id_t subproc)
v1,v2: Delete a previously created sub-process.
mi_subproc_id_t mi_subproc_current(void)
Get the current sub-process identifier of this thread.
void mi_subproc_destroy(mi_subproc_id_t subproc)
v3: Destroy a previously created sub-process.
void mi_subproc_add_current_thread(mi_subproc_id_t subproc)
Add the current thread to the given sub-process.
bool mi_subproc_visit_heaps(mi_subproc_id_t subproc, mi_heap_visit_fun *visitor, void *arg)
Visit all heaps belonging to a subprocess.
mi_theap_t * mi_theap_set_default(mi_theap_t *theap)
Set the default thread-local theap to use in the current thread for mi_malloc() et al.
void * mi_theap_realloc(mi_theap_t *theap, void *p, size_t newsize)
void * mi_theap_malloc_small(mi_theap_t *theap, size_t size)
Allocate a small object in a specific theap. size must be smaller or equal to MI_SMALL_SIZE_MAX().
mi_theap_t * mi_theap_get_default()
Get the default theap that is used for mi_malloc() et al. for the current thread.
mi_theap_t * mi_heap_theap(mi_heap_t *heap)
Return the thread-local theap for the given heap.
void * mi_theap_malloc_aligned(mi_theap_t *theap, size_t size, size_t alignment)
struct mi_theap_s mi_theap_t
Type of thread-local heaps.
Definition mimalloc-doc.h:1392
void mi_theap_collect(mi_theap_t *theap, bool force)
Release outstanding resources in a specific theap.
void * mi_theap_zalloc(mi_theap_t *theap, size_t size)
Allocate zero-initialized in a specific heap.
void * mi_theap_zalloc_small(mi_theap_t *theap, size_t size)
Allocate a small object in a specific theap. size must be smaller or equal to MI_SMALL_SIZE_MAX().
void * mi_theap_malloc(mi_theap_t *theap, size_t size)
Allocate in a specific theap.
void * mi_theap_calloc(mi_theap_t *theap, size_t count, size_t size)
void * mi_heap_recalloc_aligned_at(mi_heap_t *heap, void *p, size_t newcount, size_t size, size_t alignment, size_t offset)
void * mi_recalloc(void *p, size_t count, size_t size)
Re-allocate memory to count elements of size bytes, with extra memory initialized to zero.
void * mi_heap_rezalloc_aligned_at(mi_heap_t *heap, void *p, size_t newsize, size_t alignment, size_t offset)
void * mi_recalloc_aligned(void *p, size_t newcount, size_t size, size_t alignment)
void * mi_rezalloc_aligned(void *p, size_t newsize, size_t alignment)
void * mi_heap_rezalloc_aligned(mi_heap_t *heap, void *p, size_t newsize, size_t alignment)
void * mi_rezalloc_aligned_at(void *p, size_t newsize, size_t alignment, size_t offset)
void * mi_heap_recalloc_aligned(mi_heap_t *heap, void *p, size_t newcount, size_t size, size_t alignment)
void * mi_heap_rezalloc(mi_heap_t *heap, void *p, size_t newsize)
void * mi_recalloc_aligned_at(void *p, size_t newcount, size_t size, size_t alignment, size_t offset)
void * mi_heap_recalloc(mi_heap_t *heap, void *p, size_t newcount, size_t size)
void * mi_rezalloc(void *p, size_t newsize)