From d68a7fc3e6072f1f084a199aaf693acaa03026f4 Mon Sep 17 00:00:00 2001 From: Daan Date: Tue, 4 Jun 2024 17:04:33 -0700 Subject: [PATCH] update docs --- doc/mimalloc-doc.h | 1 - docs/group__extended.html | 3 +- docs/group__typed.html | 2 +- docs/mimalloc-doc_8h_source.html | 584 +++++++++++++++---------------- 4 files changed, 294 insertions(+), 296 deletions(-) diff --git a/doc/mimalloc-doc.h b/doc/mimalloc-doc.h index 0c19e7b8..e1c14b44 100644 --- a/doc/mimalloc-doc.h +++ b/doc/mimalloc-doc.h @@ -547,7 +547,6 @@ mi_heap_t* mi_heap_new_in_arena(mi_arena_id_t arena_id); /// /// The \a arena_id can be used by runtimes to allocate only in a specified pre-reserved arena. /// This is used for example for a compressed pointer heap in Koka. -/// /// The \a heap_tag enables heaps to keep objects of a certain type isolated to heaps with that tag. /// This is used for example in the CPython integration. mi_heap_t* mi_heap_new_ex(int heap_tag, bool allow_destroy, mi_arena_id_t arena_id); diff --git a/docs/group__extended.html b/docs/group__extended.html index 98aca4ec..6bc793f6 100644 --- a/docs/group__extended.html +++ b/docs/group__extended.html @@ -524,8 +524,7 @@ Functions
Returns
A new heap or NULL on failure.
-

The arena_id can be used by runtimes to allocate only in a specified pre-reserved arena. This is used for example for a compressed pointer heap in Koka.

-

The heap_tag enables heaps to keep objects of a certain type isolated to heaps with that tag. This is used for example in the CPython integration.

+

The arena_id can be used by runtimes to allocate only in a specified pre-reserved arena. This is used for example for a compressed pointer heap in Koka. The heap_tag enables heaps to keep objects of a certain type isolated to heaps with that tag. This is used for example in the CPython integration.

diff --git a/docs/group__typed.html b/docs/group__typed.html index aa91a12f..69f5278f 100644 --- a/docs/group__typed.html +++ b/docs/group__typed.html @@ -148,7 +148,7 @@ Macros

Detailed Description

Typed allocation macros. For example:

int* p = mi_malloc_tp(int)
-
mi_malloc_tp
#define mi_malloc_tp(tp)
Allocate a block of type tp.
Definition mimalloc-doc.h:785
+
mi_malloc_tp
#define mi_malloc_tp(tp)
Allocate a block of type tp.
Definition mimalloc-doc.h:784

Macro Definition Documentation

◆ mi_calloc_tp

diff --git a/docs/mimalloc-doc_8h_source.html b/docs/mimalloc-doc_8h_source.html index 84549c54..d4d17d26 100644 --- a/docs/mimalloc-doc_8h_source.html +++ b/docs/mimalloc-doc_8h_source.html @@ -219,262 +219,262 @@ $(function(){initNavTree('mimalloc-doc_8h_source.html',''); initResizable(true);
536
540mi_heap_t* mi_heap_new_in_arena(mi_arena_id_t arena_id);
541
-
553mi_heap_t* mi_heap_new_ex(int heap_tag, bool allow_destroy, mi_arena_id_t arena_id);
-
554
-
558typedef void* mi_subproc_id_t;
-
559
-
561mi_subproc_id_t mi_subproc_main(void);
-
562
-
565mi_subproc_id_t mi_subproc_new(void);
-
566
-
570void mi_subproc_delete(mi_subproc_id_t subproc);
-
571
-
574void mi_subproc_add_current_thread(mi_subproc_id_t subproc);
+
552mi_heap_t* mi_heap_new_ex(int heap_tag, bool allow_destroy, mi_arena_id_t arena_id);
+
553
+
557typedef void* mi_subproc_id_t;
+
558
+
560mi_subproc_id_t mi_subproc_main(void);
+
561
+
564mi_subproc_id_t mi_subproc_new(void);
+
565
+
569void mi_subproc_delete(mi_subproc_id_t subproc);
+
570
+
573void mi_subproc_add_current_thread(mi_subproc_id_t subproc);
+
574
575
-
576
-
578
-
579// ------------------------------------------------------
-
580// Aligned allocation
-
581// ------------------------------------------------------
-
582
-
590
-
608void* mi_malloc_aligned(size_t size, size_t alignment);
-
609void* mi_zalloc_aligned(size_t size, size_t alignment);
-
610void* mi_calloc_aligned(size_t count, size_t size, size_t alignment);
-
611void* mi_realloc_aligned(void* p, size_t newsize, size_t alignment);
-
612
-
624void* mi_malloc_aligned_at(size_t size, size_t alignment, size_t offset);
-
625void* mi_zalloc_aligned_at(size_t size, size_t alignment, size_t offset);
-
626void* mi_calloc_aligned_at(size_t count, size_t size, size_t alignment, size_t offset);
-
627void* mi_realloc_aligned_at(void* p, size_t newsize, size_t alignment, size_t offset);
-
628
-
630
-
636
-
641struct mi_heap_s;
-
642
-
647typedef struct mi_heap_s mi_heap_t;
-
648
-
650mi_heap_t* mi_heap_new();
-
651
-
659void mi_heap_delete(mi_heap_t* heap);
-
660
-
668void mi_heap_destroy(mi_heap_t* heap);
-
669
-
673mi_heap_t* mi_heap_set_default(mi_heap_t* heap);
-
674
-
677mi_heap_t* mi_heap_get_default();
-
678
-
684mi_heap_t* mi_heap_get_backing();
-
685
-
687void mi_heap_collect(mi_heap_t* heap, bool force);
-
688
-
691void* mi_heap_malloc(mi_heap_t* heap, size_t size);
-
692
-
696void* mi_heap_malloc_small(mi_heap_t* heap, size_t size);
-
697
-
700void* mi_heap_zalloc(mi_heap_t* heap, size_t size);
-
701
-
704void* mi_heap_calloc(mi_heap_t* heap, size_t count, size_t size);
-
705
-
708void* mi_heap_mallocn(mi_heap_t* heap, size_t count, size_t size);
-
709
-
712char* mi_heap_strdup(mi_heap_t* heap, const char* s);
-
713
-
716char* mi_heap_strndup(mi_heap_t* heap, const char* s, size_t n);
-
717
-
720char* mi_heap_realpath(mi_heap_t* heap, const char* fname, char* resolved_name);
-
721
-
722void* mi_heap_realloc(mi_heap_t* heap, void* p, size_t newsize);
-
723void* mi_heap_reallocn(mi_heap_t* heap, void* p, size_t count, size_t size);
-
724void* mi_heap_reallocf(mi_heap_t* heap, void* p, size_t newsize);
-
725
-
726void* mi_heap_malloc_aligned(mi_heap_t* heap, size_t size, size_t alignment);
-
727void* mi_heap_malloc_aligned_at(mi_heap_t* heap, size_t size, size_t alignment, size_t offset);
-
728void* mi_heap_zalloc_aligned(mi_heap_t* heap, size_t size, size_t alignment);
-
729void* mi_heap_zalloc_aligned_at(mi_heap_t* heap, size_t size, size_t alignment, size_t offset);
-
730void* mi_heap_calloc_aligned(mi_heap_t* heap, size_t count, size_t size, size_t alignment);
-
731void* mi_heap_calloc_aligned_at(mi_heap_t* heap, size_t count, size_t size, size_t alignment, size_t offset);
-
732void* mi_heap_realloc_aligned(mi_heap_t* heap, void* p, size_t newsize, size_t alignment);
-
733void* mi_heap_realloc_aligned_at(mi_heap_t* heap, void* p, size_t newsize, size_t alignment, size_t offset);
-
734
+
577
+
578// ------------------------------------------------------
+
579// Aligned allocation
+
580// ------------------------------------------------------
+
581
+
589
+
607void* mi_malloc_aligned(size_t size, size_t alignment);
+
608void* mi_zalloc_aligned(size_t size, size_t alignment);
+
609void* mi_calloc_aligned(size_t count, size_t size, size_t alignment);
+
610void* mi_realloc_aligned(void* p, size_t newsize, size_t alignment);
+
611
+
623void* mi_malloc_aligned_at(size_t size, size_t alignment, size_t offset);
+
624void* mi_zalloc_aligned_at(size_t size, size_t alignment, size_t offset);
+
625void* mi_calloc_aligned_at(size_t count, size_t size, size_t alignment, size_t offset);
+
626void* mi_realloc_aligned_at(void* p, size_t newsize, size_t alignment, size_t offset);
+
627
+
629
+
635
+
640struct mi_heap_s;
+
641
+
646typedef struct mi_heap_s mi_heap_t;
+
647
+
649mi_heap_t* mi_heap_new();
+
650
+
658void mi_heap_delete(mi_heap_t* heap);
+
659
+
667void mi_heap_destroy(mi_heap_t* heap);
+
668
+
672mi_heap_t* mi_heap_set_default(mi_heap_t* heap);
+
673
+
676mi_heap_t* mi_heap_get_default();
+
677
+
683mi_heap_t* mi_heap_get_backing();
+
684
+
686void mi_heap_collect(mi_heap_t* heap, bool force);
+
687
+
690void* mi_heap_malloc(mi_heap_t* heap, size_t size);
+
691
+
695void* mi_heap_malloc_small(mi_heap_t* heap, size_t size);
+
696
+
699void* mi_heap_zalloc(mi_heap_t* heap, size_t size);
+
700
+
703void* mi_heap_calloc(mi_heap_t* heap, size_t count, size_t size);
+
704
+
707void* mi_heap_mallocn(mi_heap_t* heap, size_t count, size_t size);
+
708
+
711char* mi_heap_strdup(mi_heap_t* heap, const char* s);
+
712
+
715char* mi_heap_strndup(mi_heap_t* heap, const char* s, size_t n);
+
716
+
719char* mi_heap_realpath(mi_heap_t* heap, const char* fname, char* resolved_name);
+
720
+
721void* mi_heap_realloc(mi_heap_t* heap, void* p, size_t newsize);
+
722void* mi_heap_reallocn(mi_heap_t* heap, void* p, size_t count, size_t size);
+
723void* mi_heap_reallocf(mi_heap_t* heap, void* p, size_t newsize);
+
724
+
725void* mi_heap_malloc_aligned(mi_heap_t* heap, size_t size, size_t alignment);
+
726void* mi_heap_malloc_aligned_at(mi_heap_t* heap, size_t size, size_t alignment, size_t offset);
+
727void* mi_heap_zalloc_aligned(mi_heap_t* heap, size_t size, size_t alignment);
+
728void* mi_heap_zalloc_aligned_at(mi_heap_t* heap, size_t size, size_t alignment, size_t offset);
+
729void* mi_heap_calloc_aligned(mi_heap_t* heap, size_t count, size_t size, size_t alignment);
+
730void* mi_heap_calloc_aligned_at(mi_heap_t* heap, size_t count, size_t size, size_t alignment, size_t offset);
+
731void* mi_heap_realloc_aligned(mi_heap_t* heap, void* p, size_t newsize, size_t alignment);
+
732void* mi_heap_realloc_aligned_at(mi_heap_t* heap, void* p, size_t newsize, size_t alignment, size_t offset);
+
733
+
735
736
-
737
-
746
-
747void* mi_rezalloc(void* p, size_t newsize);
-
748void* mi_recalloc(void* p, size_t newcount, size_t size) ;
-
749
-
750void* mi_rezalloc_aligned(void* p, size_t newsize, size_t alignment);
-
751void* mi_rezalloc_aligned_at(void* p, size_t newsize, size_t alignment, size_t offset);
-
752void* mi_recalloc_aligned(void* p, size_t newcount, size_t size, size_t alignment);
-
753void* mi_recalloc_aligned_at(void* p, size_t newcount, size_t size, size_t alignment, size_t offset);
-
754
-
755void* mi_heap_rezalloc(mi_heap_t* heap, void* p, size_t newsize);
-
756void* mi_heap_recalloc(mi_heap_t* heap, void* p, size_t newcount, size_t size);
-
757
-
758void* mi_heap_rezalloc_aligned(mi_heap_t* heap, void* p, size_t newsize, size_t alignment);
-
759void* mi_heap_rezalloc_aligned_at(mi_heap_t* heap, void* p, size_t newsize, size_t alignment, size_t offset);
-
760void* mi_heap_recalloc_aligned(mi_heap_t* heap, void* p, size_t newcount, size_t size, size_t alignment);
-
761void* mi_heap_recalloc_aligned_at(mi_heap_t* heap, void* p, size_t newcount, size_t size, size_t alignment, size_t offset);
-
762
-
764
-
773
-
785#define mi_malloc_tp(tp) ((tp*)mi_malloc(sizeof(tp)))
-
786
-
788#define mi_zalloc_tp(tp) ((tp*)mi_zalloc(sizeof(tp)))
-
789
-
791#define mi_calloc_tp(tp,count) ((tp*)mi_calloc(count,sizeof(tp)))
-
792
-
794#define mi_mallocn_tp(tp,count) ((tp*)mi_mallocn(count,sizeof(tp)))
-
795
-
797#define mi_reallocn_tp(p,tp,count) ((tp*)mi_reallocn(p,count,sizeof(tp)))
-
798
-
800#define mi_heap_malloc_tp(hp,tp) ((tp*)mi_heap_malloc(hp,sizeof(tp)))
-
801
-
803#define mi_heap_zalloc_tp(hp,tp) ((tp*)mi_heap_zalloc(hp,sizeof(tp)))
-
804
-
806#define mi_heap_calloc_tp(hp,tp,count) ((tp*)mi_heap_calloc(hp,count,sizeof(tp)))
-
807
-
809#define mi_heap_mallocn_tp(hp,tp,count) ((tp*)mi_heap_mallocn(hp,count,sizeof(tp)))
-
810
-
812#define mi_heap_reallocn_tp(hp,p,tp,count) ((tp*)mi_heap_reallocn(p,count,sizeof(tp)))
-
813
-
815#define mi_heap_recalloc_tp(hp,p,tp,count) ((tp*)mi_heap_recalloc(p,count,sizeof(tp)))
-
816
-
818
-
824
-
831bool mi_heap_contains_block(mi_heap_t* heap, const void* p);
-
832
-
841bool mi_heap_check_owned(mi_heap_t* heap, const void* p);
-
842
-
850bool mi_check_owned(const void* p);
-
851
-
-
854typedef struct mi_heap_area_s {
-
855 void* blocks;
-
856 size_t reserved;
-
857 size_t committed;
-
858 size_t used;
-
859 size_t block_size;
-
860 size_t full_block_size;
-
861 int heap_tag;
-
862} mi_heap_area_t;
+
745
+
746void* mi_rezalloc(void* p, size_t newsize);
+
747void* mi_recalloc(void* p, size_t newcount, size_t size) ;
+
748
+
749void* mi_rezalloc_aligned(void* p, size_t newsize, size_t alignment);
+
750void* mi_rezalloc_aligned_at(void* p, size_t newsize, size_t alignment, size_t offset);
+
751void* mi_recalloc_aligned(void* p, size_t newcount, size_t size, size_t alignment);
+
752void* mi_recalloc_aligned_at(void* p, size_t newcount, size_t size, size_t alignment, size_t offset);
+
753
+
754void* mi_heap_rezalloc(mi_heap_t* heap, void* p, size_t newsize);
+
755void* mi_heap_recalloc(mi_heap_t* heap, void* p, size_t newcount, size_t size);
+
756
+
757void* mi_heap_rezalloc_aligned(mi_heap_t* heap, void* p, size_t newsize, size_t alignment);
+
758void* mi_heap_rezalloc_aligned_at(mi_heap_t* heap, void* p, size_t newsize, size_t alignment, size_t offset);
+
759void* mi_heap_recalloc_aligned(mi_heap_t* heap, void* p, size_t newcount, size_t size, size_t alignment);
+
760void* mi_heap_recalloc_aligned_at(mi_heap_t* heap, void* p, size_t newcount, size_t size, size_t alignment, size_t offset);
+
761
+
763
+
772
+
784#define mi_malloc_tp(tp) ((tp*)mi_malloc(sizeof(tp)))
+
785
+
787#define mi_zalloc_tp(tp) ((tp*)mi_zalloc(sizeof(tp)))
+
788
+
790#define mi_calloc_tp(tp,count) ((tp*)mi_calloc(count,sizeof(tp)))
+
791
+
793#define mi_mallocn_tp(tp,count) ((tp*)mi_mallocn(count,sizeof(tp)))
+
794
+
796#define mi_reallocn_tp(p,tp,count) ((tp*)mi_reallocn(p,count,sizeof(tp)))
+
797
+
799#define mi_heap_malloc_tp(hp,tp) ((tp*)mi_heap_malloc(hp,sizeof(tp)))
+
800
+
802#define mi_heap_zalloc_tp(hp,tp) ((tp*)mi_heap_zalloc(hp,sizeof(tp)))
+
803
+
805#define mi_heap_calloc_tp(hp,tp,count) ((tp*)mi_heap_calloc(hp,count,sizeof(tp)))
+
806
+
808#define mi_heap_mallocn_tp(hp,tp,count) ((tp*)mi_heap_mallocn(hp,count,sizeof(tp)))
+
809
+
811#define mi_heap_reallocn_tp(hp,p,tp,count) ((tp*)mi_heap_reallocn(p,count,sizeof(tp)))
+
812
+
814#define mi_heap_recalloc_tp(hp,p,tp,count) ((tp*)mi_heap_recalloc(p,count,sizeof(tp)))
+
815
+
817
+
823
+
830bool mi_heap_contains_block(mi_heap_t* heap, const void* p);
+
831
+
840bool mi_heap_check_owned(mi_heap_t* heap, const void* p);
+
841
+
849bool mi_check_owned(const void* p);
+
850
+
+
853typedef struct mi_heap_area_s {
+
854 void* blocks;
+
855 size_t reserved;
+
856 size_t committed;
+
857 size_t used;
+
858 size_t block_size;
+
859 size_t full_block_size;
+
860 int heap_tag;
+
861} mi_heap_area_t;
-
863
-
871typedef bool (mi_block_visit_fun)(const mi_heap_t* heap, const mi_heap_area_t* area, void* block, size_t block_size, void* arg);
-
872
-
884bool mi_heap_visit_blocks(const mi_heap_t* heap, bool visit_all_blocks, mi_block_visit_fun* visitor, void* arg);
-
885
-
901bool mi_abandoned_visit_blocks(mi_subproc_id_t subproc_id, int heap_tag, bool visit_blocks, mi_block_visit_fun* visitor, void* arg);
-
902
-
904
-
910
-
-
912typedef enum mi_option_e {
-
913 // stable options
-
914 mi_option_show_errors,
-
915 mi_option_show_stats,
-
916 mi_option_verbose,
-
917 mi_option_max_errors,
-
918 mi_option_max_warnings,
-
919
-
920 // advanced options
-
921 mi_option_reserve_huge_os_pages,
-
922 mi_option_reserve_huge_os_pages_at,
-
923 mi_option_reserve_os_memory,
-
924 mi_option_allow_large_os_pages,
-
925 mi_option_purge_decommits,
-
926 mi_option_arena_reserve,
-
927 mi_option_os_tag,
-
928 mi_option_retry_on_oom,
-
929
-
930 // experimental options
-
931 mi_option_eager_commit,
-
932 mi_option_eager_commit_delay,
-
933 mi_option_arena_eager_commit,
-
934 mi_option_abandoned_page_purge,
-
935 mi_option_purge_delay,
-
936 mi_option_use_numa_nodes,
-
937 mi_option_disallow_os_alloc,
-
938 mi_option_limit_os_alloc,
-
939 mi_option_max_segment_reclaim,
-
940 mi_option_destroy_on_exit,
-
941 mi_option_arena_purge_mult,
-
942 mi_option_abandoned_reclaim_on_free,
-
943 mi_option_purge_extend_delay,
-
944 mi_option_disallow_arena_alloc,
-
945 mi_option_visit_abandoned,
-
946
-
947 _mi_option_last
-
948} mi_option_t;
+
862
+
870typedef bool (mi_block_visit_fun)(const mi_heap_t* heap, const mi_heap_area_t* area, void* block, size_t block_size, void* arg);
+
871
+
883bool mi_heap_visit_blocks(const mi_heap_t* heap, bool visit_all_blocks, mi_block_visit_fun* visitor, void* arg);
+
884
+
900bool mi_abandoned_visit_blocks(mi_subproc_id_t subproc_id, int heap_tag, bool visit_blocks, mi_block_visit_fun* visitor, void* arg);
+
901
+
903
+
909
+ +
948
949
-
950
-
951bool mi_option_is_enabled(mi_option_t option);
-
952void mi_option_enable(mi_option_t option);
-
953void mi_option_disable(mi_option_t option);
-
954void mi_option_set_enabled(mi_option_t option, bool enable);
-
955void mi_option_set_enabled_default(mi_option_t option, bool enable);
-
956
-
957long mi_option_get(mi_option_t option);
-
958long mi_option_get_clamp(mi_option_t option, long min, long max);
-
959size_t mi_option_get_size(mi_option_t option);
-
960
-
961void mi_option_set(mi_option_t option, long value);
-
962void mi_option_set_default(mi_option_t option, long value);
+
950bool mi_option_is_enabled(mi_option_t option);
+
951void mi_option_enable(mi_option_t option);
+
952void mi_option_disable(mi_option_t option);
+
953void mi_option_set_enabled(mi_option_t option, bool enable);
+
954void mi_option_set_enabled_default(mi_option_t option, bool enable);
+
955
+
956long mi_option_get(mi_option_t option);
+
957long mi_option_get_clamp(mi_option_t option, long min, long max);
+
958size_t mi_option_get_size(mi_option_t option);
+
959
+
960void mi_option_set(mi_option_t option, long value);
+
961void mi_option_set_default(mi_option_t option, long value);
+
962
963
-
964
-
966
-
973
-
975void mi_cfree(void* p);
-
976void* mi__expand(void* p, size_t newsize);
-
977
-
978void* mi_recalloc(void* p, size_t count, size_t size);
-
979size_t mi_malloc_size(const void* p);
-
980size_t mi_malloc_good_size(size_t size);
-
981size_t mi_malloc_usable_size(const void *p);
-
982
-
983int mi_posix_memalign(void** p, size_t alignment, size_t size);
-
984int mi__posix_memalign(void** p, size_t alignment, size_t size);
-
985void* mi_memalign(size_t alignment, size_t size);
-
986void* mi_valloc(size_t size);
-
987void* mi_pvalloc(size_t size);
-
988void* mi_aligned_alloc(size_t alignment, size_t size);
-
989
-
990unsigned short* mi_wcsdup(const unsigned short* s);
-
991unsigned char* mi_mbsdup(const unsigned char* s);
-
992int mi_dupenv_s(char** buf, size_t* size, const char* name);
-
993int mi_wdupenv_s(unsigned short** buf, size_t* size, const unsigned short* name);
-
994
-
997void* mi_reallocarray(void* p, size_t count, size_t size);
-
998
-
1000int mi_reallocarr(void* p, size_t count, size_t size);
-
1001
-
1002void* mi_aligned_recalloc(void* p, size_t newcount, size_t size, size_t alignment);
-
1003void* mi_aligned_offset_recalloc(void* p, size_t newcount, size_t size, size_t alignment, size_t offset);
-
1004
-
1005void mi_free_size(void* p, size_t size);
-
1006void mi_free_size_aligned(void* p, size_t size, size_t alignment);
-
1007void mi_free_aligned(void* p, size_t alignment);
-
1008
-
1010
-
1023
-
1025void* mi_new(std::size_t n) noexcept(false);
-
1026
-
1028void* mi_new_n(size_t count, size_t size) noexcept(false);
-
1029
-
1031void* mi_new_aligned(std::size_t n, std::align_val_t alignment) noexcept(false);
-
1032
-
1034void* mi_new_nothrow(size_t n);
-
1035
-
1037void* mi_new_aligned_nothrow(size_t n, size_t alignment);
-
1038
-
1040void* mi_new_realloc(void* p, size_t newsize);
-
1041
-
1043void* mi_new_reallocn(void* p, size_t newcount, size_t size);
-
1044
-
1052template<class T> struct mi_stl_allocator { }
-
1053
-
1055
+
965
+
972
+
974void mi_cfree(void* p);
+
975void* mi__expand(void* p, size_t newsize);
+
976
+
977void* mi_recalloc(void* p, size_t count, size_t size);
+
978size_t mi_malloc_size(const void* p);
+
979size_t mi_malloc_good_size(size_t size);
+
980size_t mi_malloc_usable_size(const void *p);
+
981
+
982int mi_posix_memalign(void** p, size_t alignment, size_t size);
+
983int mi__posix_memalign(void** p, size_t alignment, size_t size);
+
984void* mi_memalign(size_t alignment, size_t size);
+
985void* mi_valloc(size_t size);
+
986void* mi_pvalloc(size_t size);
+
987void* mi_aligned_alloc(size_t alignment, size_t size);
+
988
+
989unsigned short* mi_wcsdup(const unsigned short* s);
+
990unsigned char* mi_mbsdup(const unsigned char* s);
+
991int mi_dupenv_s(char** buf, size_t* size, const char* name);
+
992int mi_wdupenv_s(unsigned short** buf, size_t* size, const unsigned short* name);
+
993
+
996void* mi_reallocarray(void* p, size_t count, size_t size);
+
997
+
999int mi_reallocarr(void* p, size_t count, size_t size);
+
1000
+
1001void* mi_aligned_recalloc(void* p, size_t newcount, size_t size, size_t alignment);
+
1002void* mi_aligned_offset_recalloc(void* p, size_t newcount, size_t size, size_t alignment, size_t offset);
+
1003
+
1004void mi_free_size(void* p, size_t size);
+
1005void mi_free_size_aligned(void* p, size_t size, size_t alignment);
+
1006void mi_free_aligned(void* p, size_t alignment);
+
1007
+
1009
+
1022
+
1024void* mi_new(std::size_t n) noexcept(false);
+
1025
+
1027void* mi_new_n(size_t count, size_t size) noexcept(false);
+
1028
+
1030void* mi_new_aligned(std::size_t n, std::align_val_t alignment) noexcept(false);
+
1031
+
1033void* mi_new_nothrow(size_t n);
+
1034
+
1036void* mi_new_aligned_nothrow(size_t n, size_t alignment);
+
1037
+
1039void* mi_new_realloc(void* p, size_t newsize);
+
1040
+
1042void* mi_new_reallocn(void* p, size_t newcount, size_t size);
+
1043
+
1051template<class T> struct mi_stl_allocator { }
+
1052
+
1054
mi_malloc_aligned_at
void * mi_malloc_aligned_at(size_t size, size_t alignment, size_t offset)
Allocate size bytes aligned by alignment at a specified offset.
mi_calloc_aligned
void * mi_calloc_aligned(size_t count, size_t size, size_t alignment)
mi_realloc_aligned
void * mi_realloc_aligned(void *p, size_t newsize, size_t alignment)
@@ -483,20 +483,20 @@ $(function(){initNavTree('mimalloc-doc_8h_source.html',''); initResizable(true);
mi_calloc_aligned_at
void * mi_calloc_aligned_at(size_t count, size_t size, size_t alignment, size_t offset)
mi_zalloc_aligned
void * mi_zalloc_aligned(size_t size, size_t alignment)
mi_realloc_aligned_at
void * mi_realloc_aligned_at(void *p, size_t newsize, size_t alignment, size_t offset)
-
mi_heap_area_t::heap_tag
int heap_tag
heap tag associated with this area (see mi_heap_new_ex)
Definition mimalloc-doc.h:861
-
mi_heap_area_t::block_size
size_t block_size
size in bytes of one block
Definition mimalloc-doc.h:859
-
mi_heap_area_t::committed
size_t committed
current committed bytes of this area
Definition mimalloc-doc.h:857
-
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:860
-
mi_heap_area_t::used
size_t used
bytes in use by allocated blocks
Definition mimalloc-doc.h:858
-
mi_heap_area_t::blocks
void * blocks
start of the area containing heap blocks
Definition mimalloc-doc.h:855
-
mi_heap_area_t::reserved
size_t reserved
bytes reserved for this area
Definition mimalloc-doc.h:856
+
mi_heap_area_t::heap_tag
int heap_tag
heap tag associated with this area (see mi_heap_new_ex)
Definition mimalloc-doc.h:860
+
mi_heap_area_t::block_size
size_t block_size
size in bytes of one block
Definition mimalloc-doc.h:858
+
mi_heap_area_t::committed
size_t committed
current committed bytes of this area
Definition mimalloc-doc.h:856
+
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:859
+
mi_heap_area_t::used
size_t used
bytes in use by allocated blocks
Definition mimalloc-doc.h:857
+
mi_heap_area_t::blocks
void * blocks
start of the area containing heap blocks
Definition mimalloc-doc.h:854
+
mi_heap_area_t::reserved
size_t reserved
bytes reserved for this area
Definition mimalloc-doc.h:855
mi_heap_check_owned
bool mi_heap_check_owned(mi_heap_t *heap, const void *p)
Check safely if any pointer is part of a heap.
mi_check_owned
bool mi_check_owned(const void *p)
Check safely if any pointer is part of the default heap of this thread.
mi_abandoned_visit_blocks
bool mi_abandoned_visit_blocks(mi_subproc_id_t subproc_id, int heap_tag, bool visit_blocks, mi_block_visit_fun *visitor, void *arg)
Visit all areas and blocks in abandoned heaps.
mi_heap_visit_blocks
bool mi_heap_visit_blocks(const mi_heap_t *heap, bool visit_all_blocks, mi_block_visit_fun *visitor, void *arg)
Visit all areas and blocks in a heap.
-
mi_block_visit_fun
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:871
+
mi_block_visit_fun
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:870
mi_heap_contains_block
bool mi_heap_contains_block(mi_heap_t *heap, const void *p)
Does a heap contain a pointer to a previously allocated block?
-
mi_heap_area_t
An area of heap space contains blocks of a single size.
Definition mimalloc-doc.h:854
+
mi_heap_area_t
An area of heap space contains blocks of a single size.
Definition mimalloc-doc.h:853
mi_new_nothrow
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.
mi_new
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...
mi_new_realloc
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...
@@ -504,7 +504,7 @@ $(function(){initNavTree('mimalloc-doc_8h_source.html',''); initResizable(true);
mi_new_aligned_nothrow
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.
mi_new_reallocn
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...
mi_new_n
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
std::allocator implementation for mimalloc for use in STL containers.
Definition mimalloc-doc.h:1052
+
mi_stl_allocator
std::allocator implementation for mimalloc for use in STL containers.
Definition mimalloc-doc.h:1051
mi_reserve_os_memory
int mi_reserve_os_memory(size_t size, bool commit, bool allow_large)
Reserve OS memory for use by mimalloc.
mi_usable_size
size_t mi_usable_size(void *p)
Return the available bytes in a memory block.
mi_thread_done
void mi_thread_done(void)
Uninitialize mimalloc on a thread.
@@ -529,7 +529,7 @@ $(function(){initNavTree('mimalloc-doc_8h_source.html',''); initResizable(true);
mi_subproc_new
mi_subproc_id_t mi_subproc_new(void)
Create a fresh sub-process (with no associated threads yet).
mi_error_fun
void mi_error_fun(int err, void *arg)
Type of error callback functions.
Definition mimalloc-doc.h:393
mi_stats_merge
void mi_stats_merge(void)
Merge thread local statistics with the main statistics and reset.
-
mi_subproc_id_t
void * mi_subproc_id_t
A process can associate threads with sub-processes.
Definition mimalloc-doc.h:558
+
mi_subproc_id_t
void * mi_subproc_id_t
A process can associate threads with sub-processes.
Definition mimalloc-doc.h:557
mi_arena_id_t
int mi_arena_id_t
Mimalloc uses large (virtual) memory areas, called "arena"s, from the OS to manage its memory.
Definition mimalloc-doc.h:499
mi_arena_area
void * mi_arena_area(mi_arena_id_t arena_id, size_t *size)
Return the size of an arena.
mi_register_error
void mi_register_error(mi_error_fun *errfun, void *arg)
Register an error callback function.
@@ -548,7 +548,7 @@ $(function(){initNavTree('mimalloc-doc_8h_source.html',''); initResizable(true);
mi_heap_delete
void mi_heap_delete(mi_heap_t *heap)
Delete a previously allocated heap.
mi_heap_malloc_aligned
void * mi_heap_malloc_aligned(mi_heap_t *heap, size_t size, size_t alignment)
mi_heap_set_default
mi_heap_t * mi_heap_set_default(mi_heap_t *heap)
Set the default heap to use in the current thread for mi_malloc() et al.
-
mi_heap_t
struct mi_heap_s mi_heap_t
Type of first-class heaps.
Definition mimalloc-doc.h:647
+
mi_heap_t
struct mi_heap_s mi_heap_t
Type of first-class heaps.
Definition mimalloc-doc.h:646
mi_heap_zalloc_aligned_at
void * mi_heap_zalloc_aligned_at(mi_heap_t *heap, size_t size, size_t alignment, size_t offset)
mi_heap_realpath
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.
mi_heap_strdup
char * mi_heap_strdup(mi_heap_t *heap, const char *s)
Duplicate a string in a specific heap.
@@ -593,36 +593,36 @@ $(function(){initNavTree('mimalloc-doc_8h_source.html',''); initResizable(true);
mi_option_set_enabled
void mi_option_set_enabled(mi_option_t option, bool enable)
mi_option_disable
void mi_option_disable(mi_option_t option)
mi_option_set
void mi_option_set(mi_option_t option, long value)
-
mi_option_t
mi_option_t
Runtime options.
Definition mimalloc-doc.h:912
-
mi_option_abandoned_reclaim_on_free
@ mi_option_abandoned_reclaim_on_free
allow to reclaim an abandoned segment on a free (=1)
Definition mimalloc-doc.h:942
-
mi_option_purge_extend_delay
@ mi_option_purge_extend_delay
extend purge delay on each subsequent delay (=1)
Definition mimalloc-doc.h:943
-
mi_option_show_stats
@ mi_option_show_stats
Print statistics on termination.
Definition mimalloc-doc.h:915
-
mi_option_use_numa_nodes
@ mi_option_use_numa_nodes
0 = use all available numa nodes, otherwise use at most N nodes.
Definition mimalloc-doc.h:936
-
mi_option_abandoned_page_purge
@ mi_option_abandoned_page_purge
immediately purge delayed purges on thread termination
Definition mimalloc-doc.h:934
-
mi_option_eager_commit_delay
@ mi_option_eager_commit_delay
the first N segments per thread are not eagerly committed (but per page in the segment on demand)
Definition mimalloc-doc.h:932
-
mi_option_eager_commit
@ mi_option_eager_commit
eager commit segments? (after eager_commit_delay segments) (enabled by default).
Definition mimalloc-doc.h:931
-
mi_option_visit_abandoned
@ mi_option_visit_abandoned
allow visiting heap blocks from abandoned threads (=0)
Definition mimalloc-doc.h:945
-
mi_option_os_tag
@ mi_option_os_tag
tag used for OS logging (macOS only for now) (=100)
Definition mimalloc-doc.h:927
-
_mi_option_last
@ _mi_option_last
Definition mimalloc-doc.h:947
-
mi_option_destroy_on_exit
@ 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:940
-
mi_option_verbose
@ mi_option_verbose
Print verbose messages.
Definition mimalloc-doc.h:916
-
mi_option_allow_large_os_pages
@ mi_option_allow_large_os_pages
allow large (2 or 4 MiB) OS pages, implies eager commit. If false, also disables THP for the process.
Definition mimalloc-doc.h:924
-
mi_option_arena_purge_mult
@ mi_option_arena_purge_mult
multiplier for purge_delay for the purging delay for arenas (=10)
Definition mimalloc-doc.h:941
-
mi_option_retry_on_oom
@ 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:928
-
mi_option_purge_decommits
@ 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:925
-
mi_option_limit_os_alloc
@ mi_option_limit_os_alloc
If set to 1, do not use OS memory for allocation (but only pre-reserved arenas)
Definition mimalloc-doc.h:938
-
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:922
-
mi_option_max_segment_reclaim
@ mi_option_max_segment_reclaim
max. percentage of the abandoned segments can be reclaimed per try (=10%)
Definition mimalloc-doc.h:939
-
mi_option_arena_reserve
@ 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:926
-
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:921
-
mi_option_disallow_os_alloc
@ mi_option_disallow_os_alloc
1 = do not use OS memory for allocation (but only programmatically reserved arenas)
Definition mimalloc-doc.h:937
-
mi_option_purge_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...
Definition mimalloc-doc.h:935
-
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:944
-
mi_option_max_errors
@ mi_option_max_errors
issue at most N error messages
Definition mimalloc-doc.h:917
-
mi_option_max_warnings
@ mi_option_max_warnings
issue at most N warning messages
Definition mimalloc-doc.h:918
-
mi_option_show_errors
@ mi_option_show_errors
Print error messages.
Definition mimalloc-doc.h:914
-
mi_option_reserve_os_memory
@ 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:923
-
mi_option_arena_eager_commit
@ mi_option_arena_eager_commit
eager commit arenas? Use 2 to enable just on overcommit systems (=2)
Definition mimalloc-doc.h:933
+
mi_option_t
mi_option_t
Runtime options.
Definition mimalloc-doc.h:911
+
mi_option_abandoned_reclaim_on_free
@ mi_option_abandoned_reclaim_on_free
allow to reclaim an abandoned segment on a free (=1)
Definition mimalloc-doc.h:941
+
mi_option_purge_extend_delay
@ mi_option_purge_extend_delay
extend purge delay on each subsequent delay (=1)
Definition mimalloc-doc.h:942
+
mi_option_show_stats
@ mi_option_show_stats
Print statistics on termination.
Definition mimalloc-doc.h:914
+
mi_option_use_numa_nodes
@ mi_option_use_numa_nodes
0 = use all available numa nodes, otherwise use at most N nodes.
Definition mimalloc-doc.h:935
+
mi_option_abandoned_page_purge
@ mi_option_abandoned_page_purge
immediately purge delayed purges on thread termination
Definition mimalloc-doc.h:933
+
mi_option_eager_commit_delay
@ mi_option_eager_commit_delay
the first N segments per thread are not eagerly committed (but per page in the segment on demand)
Definition mimalloc-doc.h:931
+
mi_option_eager_commit
@ mi_option_eager_commit
eager commit segments? (after eager_commit_delay segments) (enabled by default).
Definition mimalloc-doc.h:930
+
mi_option_visit_abandoned
@ mi_option_visit_abandoned
allow visiting heap blocks from abandoned threads (=0)
Definition mimalloc-doc.h:944
+
mi_option_os_tag
@ mi_option_os_tag
tag used for OS logging (macOS only for now) (=100)
Definition mimalloc-doc.h:926
+
_mi_option_last
@ _mi_option_last
Definition mimalloc-doc.h:946
+
mi_option_destroy_on_exit
@ 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:939
+
mi_option_verbose
@ mi_option_verbose
Print verbose messages.
Definition mimalloc-doc.h:915
+
mi_option_allow_large_os_pages
@ mi_option_allow_large_os_pages
allow large (2 or 4 MiB) OS pages, implies eager commit. If false, also disables THP for the process.
Definition mimalloc-doc.h:923
+
mi_option_arena_purge_mult
@ mi_option_arena_purge_mult
multiplier for purge_delay for the purging delay for arenas (=10)
Definition mimalloc-doc.h:940
+
mi_option_retry_on_oom
@ 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:927
+
mi_option_purge_decommits
@ 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:924
+
mi_option_limit_os_alloc
@ mi_option_limit_os_alloc
If set to 1, do not use OS memory for allocation (but only pre-reserved arenas)
Definition mimalloc-doc.h:937
+
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:921
+
mi_option_max_segment_reclaim
@ mi_option_max_segment_reclaim
max. percentage of the abandoned segments can be reclaimed per try (=10%)
Definition mimalloc-doc.h:938
+
mi_option_arena_reserve
@ 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:925
+
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:920
+
mi_option_disallow_os_alloc
@ mi_option_disallow_os_alloc
1 = do not use OS memory for allocation (but only programmatically reserved arenas)
Definition mimalloc-doc.h:936
+
mi_option_purge_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...
Definition mimalloc-doc.h:934
+
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:943
+
mi_option_max_errors
@ mi_option_max_errors
issue at most N error messages
Definition mimalloc-doc.h:916
+
mi_option_max_warnings
@ mi_option_max_warnings
issue at most N warning messages
Definition mimalloc-doc.h:917
+
mi_option_show_errors
@ mi_option_show_errors
Print error messages.
Definition mimalloc-doc.h:913
+
mi_option_reserve_os_memory
@ 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:922
+
mi_option_arena_eager_commit
@ mi_option_arena_eager_commit
eager commit arenas? Use 2 to enable just on overcommit systems (=2)
Definition mimalloc-doc.h:932
mi_malloc_usable_size
size_t mi_malloc_usable_size(const void *p)
mi_free_aligned
void mi_free_aligned(void *p, size_t alignment)
mi_aligned_offset_recalloc
void * mi_aligned_offset_recalloc(void *p, size_t newcount, size_t size, size_t alignment, size_t offset)