From 2fc6b14bab0090eb84dd1f7a3f24d1e67918e3ff Mon Sep 17 00:00:00 2001 From: Daan Date: Thu, 6 Mar 2025 21:03:51 -0800 Subject: [PATCH 01/27] bump version to 1.9.3 for further development --- cmake/mimalloc-config-version.cmake | 2 +- include/mimalloc.h | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/cmake/mimalloc-config-version.cmake b/cmake/mimalloc-config-version.cmake index 7f3bd631..aeea621f 100644 --- a/cmake/mimalloc-config-version.cmake +++ b/cmake/mimalloc-config-version.cmake @@ -1,6 +1,6 @@ set(mi_version_major 1) set(mi_version_minor 9) -set(mi_version_patch 2) +set(mi_version_patch 3) set(mi_version ${mi_version_major}.${mi_version_minor}) set(PACKAGE_VERSION ${mi_version}) diff --git a/include/mimalloc.h b/include/mimalloc.h index 4e9c3156..8ccfcec3 100644 --- a/include/mimalloc.h +++ b/include/mimalloc.h @@ -8,7 +8,7 @@ terms of the MIT license. A copy of the license can be found in the file #ifndef MIMALLOC_H #define MIMALLOC_H -#define MI_MALLOC_VERSION 192 // major + 2 digits minor +#define MI_MALLOC_VERSION 193 // major + 2 digits minor // ------------------------------------------------------ // Compiler specific attributes From 2b895f4e97aa089db3e9012708a5c26492cce88e Mon Sep 17 00:00:00 2001 From: Daan Date: Thu, 6 Mar 2025 21:04:32 -0800 Subject: [PATCH 02/27] bump version to 2.2.3 for further development --- cmake/mimalloc-config-version.cmake | 2 +- include/mimalloc.h | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/cmake/mimalloc-config-version.cmake b/cmake/mimalloc-config-version.cmake index 286ec0ba..daac7a5d 100644 --- a/cmake/mimalloc-config-version.cmake +++ b/cmake/mimalloc-config-version.cmake @@ -1,6 +1,6 @@ set(mi_version_major 2) set(mi_version_minor 2) -set(mi_version_patch 2) +set(mi_version_patch 3) set(mi_version ${mi_version_major}.${mi_version_minor}) set(PACKAGE_VERSION ${mi_version}) diff --git a/include/mimalloc.h b/include/mimalloc.h index ae6ae262..ff6f0568 100644 --- a/include/mimalloc.h +++ b/include/mimalloc.h @@ -8,7 +8,7 @@ terms of the MIT license. A copy of the license can be found in the file #ifndef MIMALLOC_H #define MIMALLOC_H -#define MI_MALLOC_VERSION 222 // major + 2 digits minor +#define MI_MALLOC_VERSION 223 // major + 2 digits minor // ------------------------------------------------------ // Compiler specific attributes From 4aae566191b9443d53995245b637ce28d617710a Mon Sep 17 00:00:00 2001 From: daanx Date: Mon, 10 Mar 2025 12:17:46 -0700 Subject: [PATCH 03/27] fix link error with msvc in C mode (issue #1030) --- ide/vs2022/mimalloc-lib.vcxproj | 2 +- include/mimalloc/atomic.h | 7 +++++++ 2 files changed, 8 insertions(+), 1 deletion(-) diff --git a/ide/vs2022/mimalloc-lib.vcxproj b/ide/vs2022/mimalloc-lib.vcxproj index abdac1d1..95b516ec 100644 --- a/ide/vs2022/mimalloc-lib.vcxproj +++ b/ide/vs2022/mimalloc-lib.vcxproj @@ -308,7 +308,7 @@ false false Default - CompileAsCpp + CompileAsC true stdcpp20 diff --git a/include/mimalloc/atomic.h b/include/mimalloc/atomic.h index 6eaa6f99..2984f50f 100644 --- a/include/mimalloc/atomic.h +++ b/include/mimalloc/atomic.h @@ -266,6 +266,13 @@ static inline int64_t mi_atomic_addi64_relaxed(volatile _Atomic(int64_t)*p, int6 return current; #endif } +static inline void mi_atomic_void_addi64_relaxed(volatile int64_t* p, const volatile int64_t* padd) { + const int64_t add = *padd; + if (add != 0) { + mi_atomic_addi64_relaxed((volatile _Atomic(int64_t)*)p, add); + } +} + static inline void mi_atomic_maxi64_relaxed(volatile _Atomic(int64_t)*p, int64_t x) { int64_t current; do { From f11732acdfe3e33f64f4aa3e7db657ffd80dea8f Mon Sep 17 00:00:00 2001 From: Daan Leijen Date: Mon, 10 Mar 2025 12:39:09 -0700 Subject: [PATCH 04/27] set default compilation to c++ mode on msvc --- ide/vs2022/mimalloc-lib.vcxproj | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ide/vs2022/mimalloc-lib.vcxproj b/ide/vs2022/mimalloc-lib.vcxproj index 95b516ec..abdac1d1 100644 --- a/ide/vs2022/mimalloc-lib.vcxproj +++ b/ide/vs2022/mimalloc-lib.vcxproj @@ -308,7 +308,7 @@ false false Default - CompileAsC + CompileAsCpp true stdcpp20 From 9a35bca55645a131092a91797f851794423175f6 Mon Sep 17 00:00:00 2001 From: Daan Date: Wed, 19 Mar 2025 16:12:17 -0700 Subject: [PATCH 05/27] possible fix for wrong accounting of committed bytes (issue #1035) --- src/arena.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/arena.c b/src/arena.c index 9d40a271..1f6f6d9d 100644 --- a/src/arena.c +++ b/src/arena.c @@ -648,15 +648,16 @@ void _mi_arena_free(void* p, size_t size, size_t committed_size, mi_memid_t memi if (p==NULL) return; if (size==0) return; const bool all_committed = (committed_size == size); + const bool decommitted_size = (committed_size <= size ? size - committed_size : 0); // need to set all memory to undefined as some parts may still be marked as no_access (like padding etc.) mi_track_mem_undefined(p,size); if (mi_memkind_is_os(memid.memkind)) { // was a direct OS allocation, pass through - if (!all_committed && committed_size > 0) { - // if partially committed, adjust the committed stats (as `_mi_os_free` will increase decommit by the full size) - _mi_stat_decrease(&_mi_stats_main.committed, committed_size); + if (!all_committed && decommitted_size > 0) { + // if partially committed, adjust the committed stats (as `_mi_os_free` will decrease commit by the full size) + _mi_stat_increase(&_mi_stats_main.committed, decommitted_size); } _mi_os_free(p, size, memid); } @@ -695,7 +696,7 @@ void _mi_arena_free(void* p, size_t size, size_t committed_size, mi_memid_t memi mi_track_mem_noaccess(p,size); if (committed_size > 0) { // if partially committed, adjust the committed stats (is it will be recommitted when re-using) - // in the delayed purge, we now need to not count a decommit if the range is not marked as committed. + // in the delayed purge, we do no longer decrease the commit if the range is not marked entirely as committed. _mi_stat_decrease(&_mi_stats_main.committed, committed_size); } // note: if not all committed, it may be that the purge will reset/decommit the entire range From 26fa8be42759ac39f7b4869b4e0936bd35a8be17 Mon Sep 17 00:00:00 2001 From: Daan Date: Wed, 19 Mar 2025 18:50:53 -0700 Subject: [PATCH 06/27] improved accounting of committed bytes (issue #1035) --- include/mimalloc/internal.h | 16 +++++++++++ src/arena.c | 39 ++++++++++++++++--------- src/bitmap.c | 28 +++++++++++------- src/bitmap.h | 4 +-- src/libc.c | 57 +++++++++++++++++++++++++++++++++++++ src/stats.c | 1 + 6 files changed, 119 insertions(+), 26 deletions(-) diff --git a/include/mimalloc/internal.h b/include/mimalloc/internal.h index 106da0d1..5b3e7e23 100644 --- a/include/mimalloc/internal.h +++ b/include/mimalloc/internal.h @@ -127,6 +127,7 @@ bool _mi_os_has_virtual_reserve(void); bool _mi_os_reset(void* addr, size_t size); bool _mi_os_commit(void* p, size_t size, bool* is_zero); +bool _mi_os_commit_ex(void* addr, size_t size, bool* is_zero, size_t stat_size); bool _mi_os_decommit(void* addr, size_t size); bool _mi_os_protect(void* addr, size_t size); bool _mi_os_unprotect(void* addr, size_t size); @@ -947,6 +948,21 @@ static inline size_t mi_bsr(size_t x) { return (x==0 ? MI_SIZE_BITS : MI_SIZE_BITS - 1 - mi_clz(x)); } +size_t _mi_popcount_generic(size_t x); + +static inline size_t mi_popcount(size_t x) { + if (x<=1) return x; + if (x==SIZE_MAX) return MI_SIZE_BITS; + #if defined(__GNUC__) + #if (SIZE_MAX == ULONG_MAX) + return __builtin_popcountl(x); + #else + return __builtin_popcountll(x); + #endif + #else + return _mi_popcount_generic(x); + #endif +} // --------------------------------------------------------------------------------- // Provide our own `_mi_memcpy` for potential performance optimizations. diff --git a/src/arena.c b/src/arena.c index 1f6f6d9d..a7c20764 100644 --- a/src/arena.c +++ b/src/arena.c @@ -255,7 +255,7 @@ static mi_decl_noinline void* mi_arena_try_alloc_at(mi_arena_t* arena, size_t ar // set the dirty bits (todo: no need for an atomic op here?) if (arena->memid.initially_zero && arena->blocks_dirty != NULL) { - memid->initially_zero = _mi_bitmap_claim_across(arena->blocks_dirty, arena->field_count, needed_bcount, bitmap_index, NULL); + memid->initially_zero = _mi_bitmap_claim_across(arena->blocks_dirty, arena->field_count, needed_bcount, bitmap_index, NULL, NULL); } // set commit state @@ -267,10 +267,14 @@ static mi_decl_noinline void* mi_arena_try_alloc_at(mi_arena_t* arena, size_t ar // commit requested, but the range may not be committed as a whole: ensure it is committed now memid->initially_committed = true; bool any_uncommitted; - _mi_bitmap_claim_across(arena->blocks_committed, arena->field_count, needed_bcount, bitmap_index, &any_uncommitted); + size_t already_committed = 0; + _mi_bitmap_claim_across(arena->blocks_committed, arena->field_count, needed_bcount, bitmap_index, &any_uncommitted, &already_committed); if (any_uncommitted) { + mi_assert_internal(already_committed < needed_bcount); + const size_t commit_size = mi_arena_block_size(needed_bcount); + const size_t stat_commit_size = commit_size - mi_arena_block_size(already_committed); bool commit_zero = false; - if (!_mi_os_commit(p, mi_arena_block_size(needed_bcount), &commit_zero)) { + if (!_mi_os_commit_ex(p, commit_size, &commit_zero, stat_commit_size)) { memid->initially_committed = false; } else { @@ -280,7 +284,14 @@ static mi_decl_noinline void* mi_arena_try_alloc_at(mi_arena_t* arena, size_t ar } else { // no need to commit, but check if already fully committed - memid->initially_committed = _mi_bitmap_is_claimed_across(arena->blocks_committed, arena->field_count, needed_bcount, bitmap_index); + size_t already_committed = 0; + memid->initially_committed = _mi_bitmap_is_claimed_across(arena->blocks_committed, arena->field_count, needed_bcount, bitmap_index, &already_committed); + if (!memid->initially_committed && already_committed > 0) { + // partially committed: as it will be committed at some time, adjust the stats and pretend the range is fully uncommitted. + mi_assert_internal(already_committed < needed_bcount); + _mi_stat_decrease(&_mi_stats_main.committed, mi_arena_block_size(already_committed)); + _mi_bitmap_unclaim_across(arena->blocks_committed, arena->field_count, needed_bcount, bitmap_index); + } } return p; @@ -464,17 +475,19 @@ static void mi_arena_purge(mi_arena_t* arena, size_t bitmap_idx, size_t blocks) const size_t size = mi_arena_block_size(blocks); void* const p = mi_arena_block_start(arena, bitmap_idx); bool needs_recommit; - if (_mi_bitmap_is_claimed_across(arena->blocks_committed, arena->field_count, blocks, bitmap_idx)) { + size_t already_committed = 0; + if (_mi_bitmap_is_claimed_across(arena->blocks_committed, arena->field_count, blocks, bitmap_idx, &already_committed)) { // all blocks are committed, we can purge freely + mi_assert_internal(already_committed == blocks); needs_recommit = _mi_os_purge(p, size); } else { // some blocks are not committed -- this can happen when a partially committed block is freed // in `_mi_arena_free` and it is conservatively marked as uncommitted but still scheduled for a purge - // we need to ensure we do not try to reset (as that may be invalid for uncommitted memory), - // and also undo the decommit stats (as it was already adjusted) + // we need to ensure we do not try to reset (as that may be invalid for uncommitted memory). + mi_assert_internal(already_committed < blocks); mi_assert_internal(mi_option_is_enabled(mi_option_purge_decommits)); - needs_recommit = _mi_os_purge_ex(p, size, false /* allow reset? */, 0); + needs_recommit = _mi_os_purge_ex(p, size, false /* allow reset? */, mi_arena_block_size(already_committed)); } // clear the purged blocks @@ -508,7 +521,7 @@ static void mi_arena_schedule_purge(mi_arena_t* arena, size_t bitmap_idx, size_t else { // already an expiration was set } - _mi_bitmap_claim_across(arena->blocks_purge, arena->field_count, blocks, bitmap_idx, NULL); + _mi_bitmap_claim_across(arena->blocks_purge, arena->field_count, blocks, bitmap_idx, NULL, NULL); } } @@ -648,7 +661,7 @@ void _mi_arena_free(void* p, size_t size, size_t committed_size, mi_memid_t memi if (p==NULL) return; if (size==0) return; const bool all_committed = (committed_size == size); - const bool decommitted_size = (committed_size <= size ? size - committed_size : 0); + const size_t decommitted_size = (committed_size <= size ? size - committed_size : 0); // need to set all memory to undefined as some parts may still be marked as no_access (like padding etc.) mi_track_mem_undefined(p,size); @@ -691,14 +704,14 @@ void _mi_arena_free(void* p, size_t size, size_t committed_size, mi_memid_t memi mi_assert_internal(arena->blocks_purge != NULL); if (!all_committed) { - // mark the entire range as no longer committed (so we recommit the full range when re-using) + // mark the entire range as no longer committed (so we will recommit the full range when re-using) _mi_bitmap_unclaim_across(arena->blocks_committed, arena->field_count, blocks, bitmap_idx); mi_track_mem_noaccess(p,size); - if (committed_size > 0) { + //if (committed_size > 0) { // if partially committed, adjust the committed stats (is it will be recommitted when re-using) // in the delayed purge, we do no longer decrease the commit if the range is not marked entirely as committed. _mi_stat_decrease(&_mi_stats_main.committed, committed_size); - } + //} // note: if not all committed, it may be that the purge will reset/decommit the entire range // that contains already decommitted parts. Since purge consistently uses reset or decommit that // works (as we should never reset decommitted parts). diff --git a/src/bitmap.c b/src/bitmap.c index 9ef784d6..50f4df2b 100644 --- a/src/bitmap.c +++ b/src/bitmap.c @@ -351,7 +351,7 @@ bool _mi_bitmap_unclaim_across(mi_bitmap_t bitmap, size_t bitmap_fields, size_t // Set `count` bits at `bitmap_idx` to 1 atomically // Returns `true` if all `count` bits were 0 previously. `any_zero` is `true` if there was at least one zero bit. -bool _mi_bitmap_claim_across(mi_bitmap_t bitmap, size_t bitmap_fields, size_t count, mi_bitmap_index_t bitmap_idx, bool* pany_zero) { +bool _mi_bitmap_claim_across(mi_bitmap_t bitmap, size_t bitmap_fields, size_t count, mi_bitmap_index_t bitmap_idx, bool* pany_zero, size_t* already_set) { size_t idx = mi_bitmap_index_field(bitmap_idx); size_t pre_mask; size_t mid_mask; @@ -359,28 +359,31 @@ bool _mi_bitmap_claim_across(mi_bitmap_t bitmap, size_t bitmap_fields, size_t co size_t mid_count = mi_bitmap_mask_across(bitmap_idx, bitmap_fields, count, &pre_mask, &mid_mask, &post_mask); bool all_zero = true; bool any_zero = false; + size_t one_count = 0; _Atomic(size_t)*field = &bitmap[idx]; size_t prev = mi_atomic_or_acq_rel(field++, pre_mask); - if ((prev & pre_mask) != 0) all_zero = false; + if ((prev & pre_mask) != 0) { all_zero = false; one_count += mi_popcount(prev & pre_mask); } if ((prev & pre_mask) != pre_mask) any_zero = true; while (mid_count-- > 0) { prev = mi_atomic_or_acq_rel(field++, mid_mask); - if ((prev & mid_mask) != 0) all_zero = false; + if ((prev & mid_mask) != 0) { all_zero = false; one_count += mi_popcount(prev & mid_mask); } if ((prev & mid_mask) != mid_mask) any_zero = true; } if (post_mask!=0) { prev = mi_atomic_or_acq_rel(field, post_mask); - if ((prev & post_mask) != 0) all_zero = false; + if ((prev & post_mask) != 0) { all_zero = false; one_count += mi_popcount(prev & post_mask); } if ((prev & post_mask) != post_mask) any_zero = true; } if (pany_zero != NULL) { *pany_zero = any_zero; } + if (already_set != NULL) { *already_set = one_count; }; + mi_assert_internal(all_zero ? one_count == 0 : one_count <= count); return all_zero; } // Returns `true` if all `count` bits were 1. // `any_ones` is `true` if there was at least one bit set to one. -static bool mi_bitmap_is_claimedx_across(mi_bitmap_t bitmap, size_t bitmap_fields, size_t count, mi_bitmap_index_t bitmap_idx, bool* pany_ones) { +static bool mi_bitmap_is_claimedx_across(mi_bitmap_t bitmap, size_t bitmap_fields, size_t count, mi_bitmap_index_t bitmap_idx, bool* pany_ones, size_t* already_set) { size_t idx = mi_bitmap_index_field(bitmap_idx); size_t pre_mask; size_t mid_mask; @@ -388,30 +391,33 @@ static bool mi_bitmap_is_claimedx_across(mi_bitmap_t bitmap, size_t bitmap_field size_t mid_count = mi_bitmap_mask_across(bitmap_idx, bitmap_fields, count, &pre_mask, &mid_mask, &post_mask); bool all_ones = true; bool any_ones = false; + size_t one_count = 0; mi_bitmap_field_t* field = &bitmap[idx]; size_t prev = mi_atomic_load_relaxed(field++); if ((prev & pre_mask) != pre_mask) all_ones = false; - if ((prev & pre_mask) != 0) any_ones = true; + if ((prev & pre_mask) != 0) { any_ones = true; one_count += mi_popcount(prev & pre_mask); } while (mid_count-- > 0) { prev = mi_atomic_load_relaxed(field++); if ((prev & mid_mask) != mid_mask) all_ones = false; - if ((prev & mid_mask) != 0) any_ones = true; + if ((prev & mid_mask) != 0) { any_ones = true; one_count += mi_popcount(prev & mid_mask); } } if (post_mask!=0) { prev = mi_atomic_load_relaxed(field); if ((prev & post_mask) != post_mask) all_ones = false; - if ((prev & post_mask) != 0) any_ones = true; + if ((prev & post_mask) != 0) { any_ones = true; one_count += mi_popcount(prev & post_mask); } } if (pany_ones != NULL) { *pany_ones = any_ones; } + if (already_set != NULL) { *already_set = one_count; } + mi_assert_internal(all_ones ? one_count == count : one_count < count); return all_ones; } -bool _mi_bitmap_is_claimed_across(mi_bitmap_t bitmap, size_t bitmap_fields, size_t count, mi_bitmap_index_t bitmap_idx) { - return mi_bitmap_is_claimedx_across(bitmap, bitmap_fields, count, bitmap_idx, NULL); +bool _mi_bitmap_is_claimed_across(mi_bitmap_t bitmap, size_t bitmap_fields, size_t count, mi_bitmap_index_t bitmap_idx, size_t* already_set) { + return mi_bitmap_is_claimedx_across(bitmap, bitmap_fields, count, bitmap_idx, NULL, already_set); } bool _mi_bitmap_is_any_claimed_across(mi_bitmap_t bitmap, size_t bitmap_fields, size_t count, mi_bitmap_index_t bitmap_idx) { bool any_ones; - mi_bitmap_is_claimedx_across(bitmap, bitmap_fields, count, bitmap_idx, &any_ones); + mi_bitmap_is_claimedx_across(bitmap, bitmap_fields, count, bitmap_idx, &any_ones, NULL); return any_ones; } diff --git a/src/bitmap.h b/src/bitmap.h index d60668cb..60b38815 100644 --- a/src/bitmap.h +++ b/src/bitmap.h @@ -102,9 +102,9 @@ bool _mi_bitmap_unclaim_across(mi_bitmap_t bitmap, size_t bitmap_fields, size_t // Set `count` bits at `bitmap_idx` to 1 atomically // Returns `true` if all `count` bits were 0 previously. `any_zero` is `true` if there was at least one zero bit. -bool _mi_bitmap_claim_across(mi_bitmap_t bitmap, size_t bitmap_fields, size_t count, mi_bitmap_index_t bitmap_idx, bool* pany_zero); +bool _mi_bitmap_claim_across(mi_bitmap_t bitmap, size_t bitmap_fields, size_t count, mi_bitmap_index_t bitmap_idx, bool* pany_zero, size_t* already_set); -bool _mi_bitmap_is_claimed_across(mi_bitmap_t bitmap, size_t bitmap_fields, size_t count, mi_bitmap_index_t bitmap_idx); +bool _mi_bitmap_is_claimed_across(mi_bitmap_t bitmap, size_t bitmap_fields, size_t count, mi_bitmap_index_t bitmap_idx, size_t* already_set); bool _mi_bitmap_is_any_claimed_across(mi_bitmap_t bitmap, size_t bitmap_fields, size_t count, mi_bitmap_index_t bitmap_idx); #endif diff --git a/src/libc.c b/src/libc.c index 1bd97aa3..52d095eb 100644 --- a/src/libc.c +++ b/src/libc.c @@ -275,3 +275,60 @@ int _mi_snprintf(char* buf, size_t buflen, const char* fmt, ...) { va_end(args); return written; } + + +#if MI_SIZE_SIZE == 4 +#define mi_mask_even_bits32 (0x55555555) +#define mi_mask_even_pairs32 (0x33333333) +#define mi_mask_even_nibbles32 (0x0F0F0F0F) + +// sum of all the bytes in `x` if it is guaranteed that the sum < 256! +static size_t mi_byte_sum32(uint32_t x) { + // perform `x * 0x01010101`: the highest byte contains the sum of all bytes. + x += (x << 8); + x += (x << 16); + return (size_t)(x >> 24); +} + +static size_t mi_popcount_generic32(uint32_t x) { + // first count each 2-bit group `a`, where: a==0b00 -> 00, a==0b01 -> 01, a==0b10 -> 01, a==0b11 -> 10 + // in other words, `a - (a>>1)`; to do this in parallel, we need to mask to prevent spilling a bit pair + // into the lower bit-pair: + x = x - ((x >> 1) & mi_mask_even_bits32); + // add the 2-bit pair results + x = (x & mi_mask_even_pairs32) + ((x >> 2) & mi_mask_even_pairs32); + // add the 4-bit nibble results + x = (x + (x >> 4)) & mi_mask_even_nibbles32; + // each byte now has a count of its bits, we can sum them now: + return mi_byte_sum32(x); +} + +mi_decl_noinline size_t _mi_popcount_generic(size_t x) { + return mi_popcount_generic32(x); +} + +#else +#define mi_mask_even_bits64 (0x5555555555555555) +#define mi_mask_even_pairs64 (0x3333333333333333) +#define mi_mask_even_nibbles64 (0x0F0F0F0F0F0F0F0F) + +// sum of all the bytes in `x` if it is guaranteed that the sum < 256! +static size_t mi_byte_sum64(uint64_t x) { + x += (x << 8); + x += (x << 16); + x += (x << 32); + return (size_t)(x >> 56); +} + +static size_t mi_popcount_generic64(uint64_t x) { + x = x - ((x >> 1) & mi_mask_even_bits64); + x = (x & mi_mask_even_pairs64) + ((x >> 2) & mi_mask_even_pairs64); + x = (x + (x >> 4)) & mi_mask_even_nibbles64; + return mi_byte_sum64(x); +} + +mi_decl_noinline size_t _mi_popcount_generic(size_t x) { + return mi_popcount_generic64(x); +} +#endif + diff --git a/src/stats.c b/src/stats.c index 1cfc3104..6a480816 100644 --- a/src/stats.c +++ b/src/stats.c @@ -30,6 +30,7 @@ static void mi_stat_update(mi_stat_count_t* stat, int64_t amount) { { // add atomically (for abandoned pages) int64_t current = mi_atomic_addi64_relaxed(&stat->current, amount); + // if (stat == &_mi_stats_main.committed) { mi_assert_internal(current + amount >= 0); }; mi_atomic_maxi64_relaxed(&stat->peak, current + amount); if (amount > 0) { mi_atomic_addi64_relaxed(&stat->total,amount); From 47bf3a5b1b5dd1f85a1ff75bb046f9f8e6dfcdb1 Mon Sep 17 00:00:00 2001 From: Daan Date: Wed, 19 Mar 2025 19:06:21 -0700 Subject: [PATCH 07/27] potential fix for sporadic assertion failure on random returning 0 (issue #1039) --- src/random.c | 22 +++++++++++++--------- 1 file changed, 13 insertions(+), 9 deletions(-) diff --git a/src/random.c b/src/random.c index 4fc8b2f8..f17698ba 100644 --- a/src/random.c +++ b/src/random.c @@ -143,13 +143,17 @@ void _mi_random_split(mi_random_ctx_t* ctx, mi_random_ctx_t* ctx_new) { uintptr_t _mi_random_next(mi_random_ctx_t* ctx) { mi_assert_internal(mi_random_is_initialized(ctx)); - #if MI_INTPTR_SIZE <= 4 - return chacha_next32(ctx); - #elif MI_INTPTR_SIZE == 8 - return (((uintptr_t)chacha_next32(ctx) << 32) | chacha_next32(ctx)); - #else - # error "define mi_random_next for this platform" - #endif + uintptr_t r; + do { + #if MI_INTPTR_SIZE <= 4 + r = chacha_next32(ctx); + #elif MI_INTPTR_SIZE == 8 + r = (((uintptr_t)chacha_next32(ctx) << 32) | chacha_next32(ctx)); + #else + # error "define mi_random_next for this platform" + #endif + } while (r==0); + return r; } @@ -163,7 +167,7 @@ uintptr_t _mi_os_random_weak(uintptr_t extra_seed) { x ^= _mi_prim_clock_now(); // and do a few randomization steps uintptr_t max = ((x ^ (x >> 17)) & 0x0F) + 1; - for (uintptr_t i = 0; i < max; i++) { + for (uintptr_t i = 0; i < max || x==0; i++, x++) { x = _mi_random_shuffle(x); } mi_assert_internal(x != 0); @@ -179,7 +183,7 @@ static void mi_random_init_ex(mi_random_ctx_t* ctx, bool use_weak) { if (!use_weak) { _mi_warning_message("unable to use secure randomness\n"); } #endif uintptr_t x = _mi_os_random_weak(0); - for (size_t i = 0; i < 8; i++) { // key is eight 32-bit words. + for (size_t i = 0; i < 8; i++, x++) { // key is eight 32-bit words. x = _mi_random_shuffle(x); ((uint32_t*)key)[i] = (uint32_t)x; } From 1aa88e0d9ad631ce7ed737a41aca873a61534939 Mon Sep 17 00:00:00 2001 From: Daan Date: Wed, 19 Mar 2025 19:11:38 -0700 Subject: [PATCH 08/27] try to fix pipeline trigger --- azure-pipelines.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/azure-pipelines.yml b/azure-pipelines.yml index a803cd15..c4dc1627 100644 --- a/azure-pipelines.yml +++ b/azure-pipelines.yml @@ -7,9 +7,9 @@ trigger: branches: include: - master - - dev - - dev2 - dev3 + - dev2 + - dev tags: include: - v* From afbc581f8dfdc92f69faa2ec57e18128c54fcd44 Mon Sep 17 00:00:00 2001 From: Daan Date: Wed, 19 Mar 2025 19:16:10 -0700 Subject: [PATCH 09/27] add Windows x86 to the build pipeline --- azure-pipelines.yml | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/azure-pipelines.yml b/azure-pipelines.yml index c4dc1627..25d4a6e0 100644 --- a/azure-pipelines.yml +++ b/azure-pipelines.yml @@ -34,6 +34,14 @@ jobs: BuildType: secure cmakeExtraArgs: -DCMAKE_BUILD_TYPE=Release -DMI_SECURE=ON MSBuildConfiguration: Release + Debug x86: + BuildType: debug + cmakeExtraArgs: -DCMAKE_BUILD_TYPE=Debug -DMI_DEBUG_FULL=ON -A Win32 + MSBuildConfiguration: Debug + Release x86: + BuildType: release + cmakeExtraArgs: -DCMAKE_BUILD_TYPE=Release -A Win32 + MSBuildConfiguration: Release steps: - task: CMake@1 inputs: From b2dcab58f7d1696795bae0e5bf33ffc229662ee9 Mon Sep 17 00:00:00 2001 From: Daan Date: Wed, 19 Mar 2025 20:20:36 -0700 Subject: [PATCH 10/27] fix assertion failure (issue #1031) --- src/segment.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/segment.c b/src/segment.c index e2730b7f..75f8dacb 100644 --- a/src/segment.c +++ b/src/segment.c @@ -523,7 +523,7 @@ static void mi_segment_os_free(mi_segment_t* segment, size_t segment_size, mi_se void _mi_segments_collect(bool force, mi_segments_tld_t* tld) { mi_pages_try_purge(force,tld); #if MI_DEBUG>=2 - if (!_mi_is_main_thread()) { + if (!_mi_is_main_thread() && force) { mi_assert_internal(tld->pages_purge.first == NULL); mi_assert_internal(tld->pages_purge.last == NULL); } From 7eafaa968598fc6b1261103f0f53b0db2bc56139 Mon Sep 17 00:00:00 2001 From: Daan Date: Wed, 19 Mar 2025 20:22:02 -0700 Subject: [PATCH 11/27] fix visibility warning (issue #1031) --- src/init.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/init.c b/src/init.c index 215eed20..8a48ae5e 100644 --- a/src/init.c +++ b/src/init.c @@ -95,7 +95,7 @@ const mi_page_t _mi_page_empty = { // may lead to allocation itself on some platforms) // -------------------------------------------------------- -mi_decl_hidden mi_decl_cache_align const mi_heap_t _mi_heap_empty = { +mi_decl_cache_align const mi_heap_t _mi_heap_empty = { NULL, MI_ATOMIC_VAR_INIT(NULL), 0, // tid From 660d749d77822e54b77acecf82f1aa8f348625ae Mon Sep 17 00:00:00 2001 From: Daan Date: Wed, 19 Mar 2025 20:29:29 -0700 Subject: [PATCH 12/27] do not default to MI_DEBUG=2 in release mode builds even when NDEBUG is not defined by defininig MI_BUILD_RELEASE (issue #1037) --- CMakeLists.txt | 4 +++- include/mimalloc/types.h | 6 +++--- 2 files changed, 6 insertions(+), 4 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 0d780fa1..2b1292cc 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -532,7 +532,9 @@ if(MI_TRACK_ASAN) endif() string(TOLOWER "${CMAKE_BUILD_TYPE}" CMAKE_BUILD_TYPE_LC) list(APPEND mi_defines "MI_CMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE_LC}") #todo: multi-config project needs $ ? -if(NOT(CMAKE_BUILD_TYPE_LC MATCHES "^(release|relwithdebinfo|minsizerel|none)$")) +if(CMAKE_BUILD_TYPE_LC MATCHES "^(release|relwithdebinfo|minsizerel|none)$") + list(APPEND mi_defines MI_BUILD_RELEASE) +else() set(mi_libname "${mi_libname}-${CMAKE_BUILD_TYPE_LC}") #append build type (e.g. -debug) if not a release version endif() diff --git a/include/mimalloc/types.h b/include/mimalloc/types.h index 9f743149..5bcdb07f 100644 --- a/include/mimalloc/types.h +++ b/include/mimalloc/types.h @@ -66,10 +66,10 @@ terms of the MIT license. A copy of the license can be found in the file // #define MI_DEBUG 2 // + internal assertion checks // #define MI_DEBUG 3 // + extensive internal invariant checking (cmake -DMI_DEBUG_FULL=ON) #if !defined(MI_DEBUG) -#if !defined(NDEBUG) || defined(_DEBUG) -#define MI_DEBUG 2 -#else +#if defined(MI_BUILD_RELEASE) || defined(NDEBUG) #define MI_DEBUG 0 +#else +#define MI_DEBUG 2 #endif #endif From cf08c27d2b6b82232dcfc0882642b5983efd95f9 Mon Sep 17 00:00:00 2001 From: Jo Bates <29763794+jbatez@users.noreply.github.com> Date: Thu, 20 Mar 2025 11:24:59 -0700 Subject: [PATCH 13/27] support MI_OPT_ARCH when using CMAKE_OSX_ARCHITECTURES with non-Apple Clang --- CMakeLists.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 2b1292cc..b7154b20 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -434,7 +434,7 @@ endif() if(CMAKE_C_COMPILER_ID MATCHES "AppleClang|Clang|GNU|Intel" AND NOT CMAKE_SYSTEM_NAME MATCHES "Haiku") if(MI_OPT_ARCH) - if(APPLE AND CMAKE_C_COMPILER_ID STREQUAL "AppleClang" AND CMAKE_OSX_ARCHITECTURES) # to support multi-arch binaries (#999) + if(APPLE AND CMAKE_C_COMPILER_ID MATCHES "AppleClang|Clang" AND CMAKE_OSX_ARCHITECTURES) # to support multi-arch binaries (#999) if("arm64" IN_LIST CMAKE_OSX_ARCHITECTURES) list(APPEND MI_OPT_ARCH_FLAGS "-Xarch_arm64;-march=armv8.1-a") endif() From 01ee3568c1a2d82779887577e4427b8d65df47ce Mon Sep 17 00:00:00 2001 From: Daan Date: Fri, 21 Mar 2025 16:19:54 -0700 Subject: [PATCH 14/27] name anonymous mmap address ranges for debugging on Linux (based on PR #1032 by @zhuker) --- src/prim/unix/prim.c | 26 ++++++++++++++++++-------- 1 file changed, 18 insertions(+), 8 deletions(-) diff --git a/src/prim/unix/prim.c b/src/prim/unix/prim.c index 8e3180e6..994dbb93 100644 --- a/src/prim/unix/prim.c +++ b/src/prim/unix/prim.c @@ -205,14 +205,24 @@ static int unix_madvise(void* addr, size_t size, int advice) { return (res==0 ? 0 : errno); } -static void* unix_mmap_prim(void* addr, size_t size, size_t try_alignment, int protect_flags, int flags, int fd) { +static void* unix_mmap_prim(void* addr, size_t size, int protect_flags, int flags, int fd) { + void* p = mmap(addr, size, protect_flags, flags, fd, 0 /* offset */); + #if (defined(__linux__) || defined(__ANDROID__)) + if (p!=MAP_FAILED && p!=NULL) { + prctl(PR_SET_VMA, PR_SET_VMA_ANON_NAME, p, size, "mimalloc"); + } + #endif + return p; +} + +static void* unix_mmap_prim_aligned(void* addr, size_t size, size_t try_alignment, int protect_flags, int flags, int fd) { MI_UNUSED(try_alignment); void* p = NULL; #if defined(MAP_ALIGNED) // BSD if (addr == NULL && try_alignment > 1 && (try_alignment % _mi_os_page_size()) == 0) { size_t n = mi_bsr(try_alignment); if (((size_t)1 << n) == try_alignment && n >= 12 && n <= 30) { // alignment is a power of 2 and 4096 <= alignment <= 1GiB - p = mmap(addr, size, protect_flags, flags | MAP_ALIGNED(n), fd, 0); + p = unix_mmap_prim(addr, size, protect_flags, flags | MAP_ALIGNED(n), fd); if (p==MAP_FAILED || !_mi_is_aligned(p,try_alignment)) { int err = errno; _mi_trace_message("unable to directly request aligned OS memory (error: %d (0x%x), size: 0x%zx bytes, alignment: 0x%zx, hint address: %p)\n", err, err, size, try_alignment, addr); @@ -223,7 +233,7 @@ static void* unix_mmap_prim(void* addr, size_t size, size_t try_alignment, int p } #elif defined(MAP_ALIGN) // Solaris if (addr == NULL && try_alignment > 1 && (try_alignment % _mi_os_page_size()) == 0) { - p = mmap((void*)try_alignment, size, protect_flags, flags | MAP_ALIGN, fd, 0); // addr parameter is the required alignment + p = unix_mmap_prim((void*)try_alignment, size, protect_flags, flags | MAP_ALIGN, fd); // addr parameter is the required alignment if (p!=MAP_FAILED) return p; // fall back to regular mmap } @@ -233,7 +243,7 @@ static void* unix_mmap_prim(void* addr, size_t size, size_t try_alignment, int p if (addr == NULL) { void* hint = _mi_os_get_aligned_hint(try_alignment, size); if (hint != NULL) { - p = mmap(hint, size, protect_flags, flags, fd, 0); + p = unix_mmap_prim(hint, size, protect_flags, flags, fd); if (p==MAP_FAILED || !_mi_is_aligned(p,try_alignment)) { #if MI_TRACK_ENABLED // asan sometimes does not instrument errno correctly? int err = 0; @@ -248,7 +258,7 @@ static void* unix_mmap_prim(void* addr, size_t size, size_t try_alignment, int p } #endif // regular mmap - p = mmap(addr, size, protect_flags, flags, fd, 0); + p = unix_mmap_prim(addr, size, protect_flags, flags, fd); if (p!=MAP_FAILED) return p; // failed to allocate return NULL; @@ -319,7 +329,7 @@ static void* unix_mmap(void* addr, size_t size, size_t try_alignment, int protec if (large_only || lflags != flags) { // try large OS page allocation *is_large = true; - p = unix_mmap_prim(addr, size, try_alignment, protect_flags, lflags, lfd); + p = unix_mmap_prim_aligned(addr, size, try_alignment, protect_flags, lflags, lfd); #ifdef MAP_HUGE_1GB if (p == NULL && (lflags & MAP_HUGE_1GB) == MAP_HUGE_1GB) { mi_huge_pages_available = false; // don't try huge 1GiB pages again @@ -327,7 +337,7 @@ static void* unix_mmap(void* addr, size_t size, size_t try_alignment, int protec _mi_warning_message("unable to allocate huge (1GiB) page, trying large (2MiB) pages instead (errno: %i)\n", errno); } lflags = ((lflags & ~MAP_HUGE_1GB) | MAP_HUGE_2MB); - p = unix_mmap_prim(addr, size, try_alignment, protect_flags, lflags, lfd); + p = unix_mmap_prim_aligned(addr, size, try_alignment, protect_flags, lflags, lfd); } #endif if (large_only) return p; @@ -340,7 +350,7 @@ static void* unix_mmap(void* addr, size_t size, size_t try_alignment, int protec // regular allocation if (p == NULL) { *is_large = false; - p = unix_mmap_prim(addr, size, try_alignment, protect_flags, flags, fd); + p = unix_mmap_prim_aligned(addr, size, try_alignment, protect_flags, flags, fd); if (p != NULL) { #if defined(MADV_HUGEPAGE) // Many Linux systems don't allow MAP_HUGETLB but they support instead From 6ed451c555da0725bd660440a584188370f46b8b Mon Sep 17 00:00:00 2001 From: Daan Date: Fri, 21 Mar 2025 16:48:50 -0700 Subject: [PATCH 15/27] fix linux compile by including linux/prctl.h --- src/prim/unix/prim.c | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/src/prim/unix/prim.c b/src/prim/unix/prim.c index 994dbb93..32004fe4 100644 --- a/src/prim/unix/prim.c +++ b/src/prim/unix/prim.c @@ -31,11 +31,12 @@ terms of the MIT license. A copy of the license can be found in the file #if defined(__linux__) #include + #include // PR_SET_VMA //#if defined(MI_NO_THP) - #include // THP disable + #include // THP disable //#endif #if defined(__GLIBC__) - #include // linux mmap flags + #include // linux mmap flags #else #include #endif @@ -207,7 +208,7 @@ static int unix_madvise(void* addr, size_t size, int advice) { static void* unix_mmap_prim(void* addr, size_t size, int protect_flags, int flags, int fd) { void* p = mmap(addr, size, protect_flags, flags, fd, 0 /* offset */); - #if (defined(__linux__) || defined(__ANDROID__)) + #if (defined(__linux__) && defined(PR_SET_VMA)) if (p!=MAP_FAILED && p!=NULL) { prctl(PR_SET_VMA, PR_SET_VMA_ANON_NAME, p, size, "mimalloc"); } From 02607f2b8d6fa70dfa632d3851930dadeeb5079f Mon Sep 17 00:00:00 2001 From: Daan Date: Fri, 21 Mar 2025 17:22:36 -0700 Subject: [PATCH 16/27] reduce test sizes for 32-bit --- test/test-api.c | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/test/test-api.c b/test/test-api.c index 15484544..6f5d6722 100644 --- a/test/test-api.c +++ b/test/test-api.c @@ -203,7 +203,11 @@ int main(void) { CHECK_BODY("malloc-aligned9") { // test large alignments bool ok = true; void* p[8]; - size_t sizes[8] = { 8, 512, 1024 * 1024, MI_BLOCK_ALIGNMENT_MAX, MI_BLOCK_ALIGNMENT_MAX + 1, 2 * MI_BLOCK_ALIGNMENT_MAX, 8 * MI_BLOCK_ALIGNMENT_MAX, 0 }; + size_t sizes[8] = { 8, 512, 1024 * 1024, MI_BLOCK_ALIGNMENT_MAX, MI_BLOCK_ALIGNMENT_MAX + 1, + #if SIZE_MAX > UINT32_MAX + 2 * MI_BLOCK_ALIGNMENT_MAX, 8 * MI_BLOCK_ALIGNMENT_MAX, + #endif + 0 }; for (int i = 0; i < 28 && ok; i++) { int align = (1 << i); for (int j = 0; j < 8 && ok; j++) { From d48bafe2bb63120c1327fe61a13aafd893c97760 Mon Sep 17 00:00:00 2001 From: Daan Date: Fri, 21 Mar 2025 19:21:41 -0700 Subject: [PATCH 17/27] print statistics nicer --- src/stats.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/stats.c b/src/stats.c index 6a480816..70f16ef3 100644 --- a/src/stats.c +++ b/src/stats.c @@ -215,7 +215,7 @@ static void mi_stat_counter_print_avg(const mi_stat_counter_t* stat, const char* static void mi_print_header(mi_output_fun* out, void* arg ) { - _mi_fprintf(out, arg, "%10s: %11s %11s %11s %11s %11s\n", "heap stats", "peak ", "total ", "current ", "unit ", "total# "); + _mi_fprintf(out, arg, "%10s: %11s %11s %11s %11s %11s\n", "heap stats", "peak ", "total ", "current ", "block ", "total# "); } #if MI_STAT>1 @@ -284,10 +284,10 @@ static void _mi_stats_print(mi_stats_t* stats, mi_output_fun* out0, void* arg0) // and print using that mi_print_header(out,arg); #if MI_STAT>1 - mi_stats_print_bins(stats->malloc_bins, MI_BIN_HUGE, "normal",out,arg); + mi_stats_print_bins(stats->malloc_bins, MI_BIN_HUGE, "bin",out,arg); #endif #if MI_STAT - mi_stat_print(&stats->malloc_normal, "normal", (stats->malloc_normal_count.total == 0 ? 1 : -1), out, arg); + mi_stat_print(&stats->malloc_normal, "binned", (stats->malloc_normal_count.total == 0 ? 1 : -1), out, arg); mi_stat_print(&stats->malloc_huge, "huge", (stats->malloc_huge_count.total == 0 ? 1 : -1), out, arg); mi_stat_count_t total = { 0,0,0 }; mi_stat_count_add_mt(&total, &stats->malloc_normal); @@ -295,7 +295,7 @@ static void _mi_stats_print(mi_stats_t* stats, mi_output_fun* out0, void* arg0) mi_stat_print_ex(&total, "total", 1, out, arg, ""); #endif #if MI_STAT>1 - mi_stat_print_ex(&stats->malloc_requested, "malloc req", 1, out, arg, ""); + mi_stat_peak_print(&stats->malloc_requested, "malloc req", 1, out, arg); _mi_fprintf(out, arg, "\n"); #endif mi_stat_print_ex(&stats->reserved, "reserved", 1, out, arg, ""); From a077311a5ec418e2e11c5cb99b82a41c188045b3 Mon Sep 17 00:00:00 2001 From: Daan Date: Fri, 21 Mar 2025 19:40:44 -0700 Subject: [PATCH 18/27] improve tracking of malloc_requested count --- include/mimalloc/types.h | 5 ++++- src/alloc-aligned.c | 3 ++- src/alloc.c | 17 ++++------------- src/free.c | 14 ++++++-------- src/heap.c | 10 +++++----- src/stats.c | 28 +++++++++++++++++++++++++++- 6 files changed, 48 insertions(+), 29 deletions(-) diff --git a/include/mimalloc/types.h b/include/mimalloc/types.h index 5bcdb07f..ab697f23 100644 --- a/include/mimalloc/types.h +++ b/include/mimalloc/types.h @@ -625,22 +625,25 @@ void _mi_assert_fail(const char* assertion, const char* fname, unsigned int line // add to stat keeping track of the peak void _mi_stat_increase(mi_stat_count_t* stat, size_t amount); void _mi_stat_decrease(mi_stat_count_t* stat, size_t amount); +void _mi_stat_adjust_decrease(mi_stat_count_t* stat, size_t amount); // counters can just be increased void _mi_stat_counter_increase(mi_stat_counter_t* stat, size_t amount); #if (MI_STAT) #define mi_stat_increase(stat,amount) _mi_stat_increase( &(stat), amount) #define mi_stat_decrease(stat,amount) _mi_stat_decrease( &(stat), amount) +#define mi_stat_adjust_decrease(stat,amount) _mi_stat_adjust_decrease( &(stat), amount) #define mi_stat_counter_increase(stat,amount) _mi_stat_counter_increase( &(stat), amount) #else #define mi_stat_increase(stat,amount) ((void)0) #define mi_stat_decrease(stat,amount) ((void)0) +#define mi_stat_adjust_decrease(stat,amount) ((void)0) #define mi_stat_counter_increase(stat,amount) ((void)0) #endif #define mi_heap_stat_counter_increase(heap,stat,amount) mi_stat_counter_increase( (heap)->tld->stats.stat, amount) #define mi_heap_stat_increase(heap,stat,amount) mi_stat_increase( (heap)->tld->stats.stat, amount) #define mi_heap_stat_decrease(heap,stat,amount) mi_stat_decrease( (heap)->tld->stats.stat, amount) - +#define mi_heap_stat_adjust_decrease(heap,stat,amount) mi_stat_adjust_decrease( (heap)->tld->stats.stat, amount) #endif diff --git a/src/alloc-aligned.c b/src/alloc-aligned.c index d0e691b3..e28cb0de 100644 --- a/src/alloc-aligned.c +++ b/src/alloc-aligned.c @@ -191,10 +191,11 @@ static void* mi_heap_malloc_zero_aligned_at(mi_heap_t* const heap, const size_t const bool is_aligned = (((uintptr_t)page->free + offset) & align_mask)==0; if mi_likely(is_aligned) { + void* p = (zero ? _mi_page_malloc_zeroed(heap,page,padsize) : _mi_page_malloc(heap,page,padsize)); // call specific page malloc for better codegen #if MI_STAT>1 + mi_heap_stat_adjust_decrease(heap, malloc_requested, padsize); mi_heap_stat_increase(heap, malloc_requested, size); #endif - void* p = (zero ? _mi_page_malloc_zeroed(heap,page,padsize) : _mi_page_malloc(heap,page,padsize)); // call specific page malloc for better codegen mi_assert_internal(p != NULL); mi_assert_internal(((uintptr_t)p + offset) % alignment == 0); mi_track_malloc(p,size,zero); diff --git a/src/alloc.c b/src/alloc.c index 15867315..0c4e4391 100644 --- a/src/alloc.c +++ b/src/alloc.c @@ -30,6 +30,7 @@ terms of the MIT license. A copy of the license can be found in the file // Note: in release mode the (inlined) routine is about 7 instructions with a single test. extern inline void* _mi_page_malloc_zero(mi_heap_t* heap, mi_page_t* page, size_t size, bool zero) mi_attr_noexcept { + mi_assert_internal(size >= MI_PADDING_SIZE); mi_assert_internal(page->block_size == 0 /* empty heap */ || mi_page_block_size(page) >= size); // check the free list @@ -88,6 +89,7 @@ extern inline void* _mi_page_malloc_zero(mi_heap_t* heap, mi_page_t* page, size_ #if (MI_STAT>1) const size_t bin = _mi_bin(bsize); mi_heap_stat_increase(heap, malloc_bins[bin], 1); + mi_heap_stat_increase(heap, malloc_requested, size - MI_PADDING_SIZE); #endif } #endif @@ -146,12 +148,6 @@ static inline mi_decl_restrict void* mi_heap_malloc_small_zero(mi_heap_t* heap, void* const p = _mi_page_malloc_zero(heap, page, size + MI_PADDING_SIZE, zero); mi_track_malloc(p,size,zero); - #if MI_STAT>1 - if (p != NULL) { - if (!mi_heap_is_initialized(heap)) { heap = mi_prim_get_default_heap(); } - mi_heap_stat_increase(heap, malloc_requested, mi_usable_size(p)); - } - #endif #if MI_DEBUG>3 if (p != NULL && zero) { mi_assert_expensive(mi_mem_is_zero(p, size)); @@ -188,12 +184,6 @@ extern inline void* _mi_heap_malloc_zero_ex(mi_heap_t* heap, size_t size, bool z void* const p = _mi_malloc_generic(heap, size + MI_PADDING_SIZE, zero, huge_alignment); // note: size can overflow but it is detected in malloc_generic mi_track_malloc(p,size,zero); - #if MI_STAT>1 - if (p != NULL) { - if (!mi_heap_is_initialized(heap)) { heap = mi_prim_get_default_heap(); } - mi_heap_stat_increase(heap, malloc_requested, mi_usable_size(p)); - } - #endif #if MI_DEBUG>3 if (p != NULL && zero) { mi_assert_expensive(mi_mem_is_zero(p, size)); @@ -666,7 +656,8 @@ mi_decl_restrict void* _mi_heap_malloc_guarded(mi_heap_t* heap, size_t size, boo if (p != NULL) { if (!mi_heap_is_initialized(heap)) { heap = mi_prim_get_default_heap(); } #if MI_STAT>1 - mi_heap_stat_increase(heap, malloc_requested, mi_usable_size(p)); + mi_heap_stat_adjust_decrease(heap, malloc_requested, req_size); + mi_heap_stat_increase(heap, malloc_requested, size); #endif _mi_stat_counter_increase(&heap->tld->stats.malloc_guarded_count, 1); } diff --git a/src/free.c b/src/free.c index a1732e8c..7e529530 100644 --- a/src/free.c +++ b/src/free.c @@ -514,20 +514,18 @@ static void mi_check_padding(const mi_page_t* page, const mi_block_t* block) { // only maintain stats for smaller objects if requested #if (MI_STAT>0) static void mi_stat_free(const mi_page_t* page, const mi_block_t* block) { -#if (MI_STAT < 2) 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_requested, usize); -#endif + // #if (MI_STAT>1) + // const size_t usize = mi_page_usable_size_of(page, block); + // mi_heap_stat_decrease(heap, malloc_requested, usize); + // #endif if (bsize <= MI_LARGE_OBJ_SIZE_MAX) { mi_heap_stat_decrease(heap, malloc_normal, bsize); -#if (MI_STAT > 1) + #if (MI_STAT > 1) mi_heap_stat_decrease(heap, malloc_bins[_mi_bin(bsize)], 1); -#endif + #endif } else { const size_t bpsize = mi_page_block_size(page); // match stat in page.c:mi_huge_page_alloc diff --git a/src/heap.c b/src/heap.c index 7c235a7b..0ea9a2ff 100644 --- a/src/heap.c +++ b/src/heap.c @@ -331,17 +331,17 @@ static bool _mi_heap_page_destroy(mi_heap_t* heap, mi_page_queue_t* pq, mi_page_ if (bsize > MI_LARGE_OBJ_SIZE_MAX) { mi_heap_stat_decrease(heap, malloc_huge, bsize); } -#if (MI_STAT) + #if (MI_STAT>0) _mi_page_free_collect(page, false); // update used count const size_t inuse = page->used; if (bsize <= MI_LARGE_OBJ_SIZE_MAX) { mi_heap_stat_decrease(heap, malloc_normal, bsize * inuse); -#if (MI_STAT>1) + #if (MI_STAT>1) mi_heap_stat_decrease(heap, malloc_bins[_mi_bin(bsize)], inuse); -#endif + #endif } - mi_heap_stat_decrease(heap, malloc_requested, bsize * inuse); // todo: off for aligned blocks... -#endif + // mi_heap_stat_decrease(heap, malloc_requested, bsize * inuse); // todo: off for aligned blocks... + #endif /// pretend it is all free now mi_assert_internal(mi_page_thread_free(page) == NULL); diff --git a/src/stats.c b/src/stats.c index 70f16ef3..07ce7d16 100644 --- a/src/stats.c +++ b/src/stats.c @@ -62,6 +62,25 @@ void _mi_stat_decrease(mi_stat_count_t* stat, size_t amount) { } +static void mi_stat_adjust(mi_stat_count_t* stat, int64_t amount) { + if (amount == 0) return; + if mi_unlikely(mi_is_in_main(stat)) + { + // adjust atomically + mi_atomic_addi64_relaxed(&stat->current, amount); + mi_atomic_addi64_relaxed(&stat->total,amount); + } + else { + // adjust local + stat->current += amount; + stat->total += amount; + } +} + +void _mi_stat_adjust_decrease(mi_stat_count_t* stat, size_t amount) { + mi_stat_adjust(stat, -((int64_t)amount)); +} + // must be thread safe as it is called from stats_merge static void mi_stat_count_add_mt(mi_stat_count_t* stat, const mi_stat_count_t* src) { @@ -199,6 +218,13 @@ static void mi_stat_peak_print(const mi_stat_count_t* stat, const char* msg, int _mi_fprintf(out, arg, "\n"); } +static void mi_stat_total_print(const mi_stat_count_t* stat, const char* msg, int64_t unit, mi_output_fun* out, void* arg) { + _mi_fprintf(out, arg, "%10s:", msg); + _mi_fprintf(out, arg, "%12s", " "); // no peak + mi_print_amount(stat->total, unit, out, arg); + _mi_fprintf(out, arg, "\n"); +} + static void mi_stat_counter_print(const mi_stat_counter_t* stat, const char* msg, mi_output_fun* out, void* arg ) { _mi_fprintf(out, arg, "%10s:", msg); mi_print_amount(stat->total, -1, out, arg); @@ -295,7 +321,7 @@ static void _mi_stats_print(mi_stats_t* stats, mi_output_fun* out0, void* arg0) mi_stat_print_ex(&total, "total", 1, out, arg, ""); #endif #if MI_STAT>1 - mi_stat_peak_print(&stats->malloc_requested, "malloc req", 1, out, arg); + mi_stat_total_print(&stats->malloc_requested, "malloc req", 1, out, arg); _mi_fprintf(out, arg, "\n"); #endif mi_stat_print_ex(&stats->reserved, "reserved", 1, out, arg, ""); From 26b792d93b4e8f389a5c724feeabb86038b39e53 Mon Sep 17 00:00:00 2001 From: Daan Date: Fri, 21 Mar 2025 20:07:16 -0700 Subject: [PATCH 19/27] fix aligned malloc_requested statistic --- src/alloc-aligned.c | 4 ---- 1 file changed, 4 deletions(-) diff --git a/src/alloc-aligned.c b/src/alloc-aligned.c index e28cb0de..8d2bde74 100644 --- a/src/alloc-aligned.c +++ b/src/alloc-aligned.c @@ -192,10 +192,6 @@ static void* mi_heap_malloc_zero_aligned_at(mi_heap_t* const heap, const size_t if mi_likely(is_aligned) { void* p = (zero ? _mi_page_malloc_zeroed(heap,page,padsize) : _mi_page_malloc(heap,page,padsize)); // call specific page malloc for better codegen - #if MI_STAT>1 - mi_heap_stat_adjust_decrease(heap, malloc_requested, padsize); - mi_heap_stat_increase(heap, malloc_requested, size); - #endif mi_assert_internal(p != NULL); mi_assert_internal(((uintptr_t)p + offset) % alignment == 0); mi_track_malloc(p,size,zero); From 34cc5c8fd9e84fbfdfa45ed5db5b09f74a448a3b Mon Sep 17 00:00:00 2001 From: Peiyuan Song Date: Mon, 24 Mar 2025 09:39:42 +0800 Subject: [PATCH 20/27] remove the `lib` prefix when enabling mimalloc-redirect for mingw --- CMakeLists.txt | 3 +++ 1 file changed, 3 insertions(+) diff --git a/CMakeLists.txt b/CMakeLists.txt index b7154b20..283af66d 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -594,6 +594,9 @@ if(MI_BUILD_SHARED) # install(FILES "$/${mi_libname}.dll.pdb" DESTINATION ${CMAKE_INSTALL_LIBDIR}) endif() if(WIN32 AND MI_WIN_REDIRECT) + if(MINGW) + set_property(TARGET mimalloc PROPERTY PREFIX "") + endif() # On windows, link and copy the mimalloc redirection dll too. if(CMAKE_GENERATOR_PLATFORM STREQUAL "arm64ec") set(MIMALLOC_REDIRECT_SUFFIX "-arm64ec") From 797ca19ba93bb92f9c7c97923aa3e43485cbb3de Mon Sep 17 00:00:00 2001 From: Maksim Bondarenkov <119937608+ognevny@users.noreply.github.com> Date: Mon, 24 Mar 2025 08:35:15 +0300 Subject: [PATCH 21/27] cmake: don't change properties of import lib on Windows/MinGW CMake handles import lib for it automatically, and using `.dll.lib` extension is MSVC-specific hack --- CMakeLists.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index b7154b20..46435eca 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -584,7 +584,7 @@ if(MI_BUILD_SHARED) install(TARGETS mimalloc EXPORT mimalloc ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR} RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}) install(EXPORT mimalloc DESTINATION ${mi_install_cmakedir}) - if(WIN32) + if(WIN32 AND NOT MINGW) # On windows, the import library name for the dll would clash with the static mimalloc.lib library # so we postfix the dll import library with `.dll.lib` (and also the .pdb debug file) set_property(TARGET mimalloc PROPERTY ARCHIVE_OUTPUT_NAME "${mi_libname}.dll" ) From 632eab958bb91fb8bd273efe58995023e5087aaa Mon Sep 17 00:00:00 2001 From: Daan Date: Tue, 25 Mar 2025 16:02:29 -0700 Subject: [PATCH 22/27] fix for atomic_yield on arm 32-bit, issue #1046 --- include/mimalloc/atomic.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/include/mimalloc/atomic.h b/include/mimalloc/atomic.h index 2984f50f..c0425f67 100644 --- a/include/mimalloc/atomic.h +++ b/include/mimalloc/atomic.h @@ -380,7 +380,7 @@ static inline void mi_atomic_yield(void) { static inline void mi_atomic_yield(void) { __asm__ volatile("wfe"); } -#elif (defined(__arm__) && __ARM_ARCH__ >= 7) +#elif (defined(__arm__) && __ARM_ARCH >= 7) static inline void mi_atomic_yield(void) { __asm__ volatile("yield" ::: "memory"); } From 23fbee7ec69e9bf336a236ad7e85e0bbe41cfb5d Mon Sep 17 00:00:00 2001 From: Vincent Fazio Date: Fri, 28 Mar 2025 07:58:49 -0500 Subject: [PATCH 23/27] atomic: fix mi_atomic_yield for big-endian arm32 Previously, `mi_atomic_yield` would not be defined on ARM32 big-endian architectures if they were pre-ARMv7. Rework the #ifdef guard to be more readable and collapse the ARM guards so both little and big endian are handled via the same mechanism. Now, ARMv7+ will utilize `yield` while older targets will use `nop` regardless of endianness. Signed-off-by: Vincent Fazio --- include/mimalloc/atomic.h | 17 ++++++++++------- 1 file changed, 10 insertions(+), 7 deletions(-) diff --git a/include/mimalloc/atomic.h b/include/mimalloc/atomic.h index c0425f67..6289dc54 100644 --- a/include/mimalloc/atomic.h +++ b/include/mimalloc/atomic.h @@ -370,8 +370,9 @@ static inline void mi_atomic_yield(void) { _mm_pause(); } #elif (defined(__GNUC__) || defined(__clang__)) && \ - (defined(__x86_64__) || defined(__i386__) || defined(__arm__) || defined(__armel__) || defined(__ARMEL__) || \ - defined(__aarch64__) || defined(__powerpc__) || defined(__ppc__) || defined(__PPC__)) || defined(__POWERPC__) + (defined(__x86_64__) || defined(__i386__) || \ + defined(__aarch64__) || defined(__arm__) || \ + defined(__powerpc__) || defined(__ppc__) || defined(__PPC__)) || defined(__POWERPC__) #if defined(__x86_64__) || defined(__i386__) static inline void mi_atomic_yield(void) { __asm__ volatile ("pause" ::: "memory"); @@ -380,10 +381,16 @@ static inline void mi_atomic_yield(void) { static inline void mi_atomic_yield(void) { __asm__ volatile("wfe"); } -#elif (defined(__arm__) && __ARM_ARCH >= 7) +#elif defined(__arm__) +#if __ARM_ARCH >= 7 static inline void mi_atomic_yield(void) { __asm__ volatile("yield" ::: "memory"); } +#else +static inline void mi_atomic_yield(void) { + __asm__ volatile ("nop" ::: "memory"); +} +#endif #elif defined(__powerpc__) || defined(__ppc__) || defined(__PPC__) || defined(__POWERPC__) #ifdef __APPLE__ static inline void mi_atomic_yield(void) { @@ -394,10 +401,6 @@ static inline void mi_atomic_yield(void) { __asm__ __volatile__ ("or 27,27,27" ::: "memory"); } #endif -#elif defined(__armel__) || defined(__ARMEL__) -static inline void mi_atomic_yield(void) { - __asm__ volatile ("nop" ::: "memory"); -} #endif #elif defined(__sun) // Fallback for other archs From 1052c30f034017c67e5eea0ab45e032feb1e4e1e Mon Sep 17 00:00:00 2001 From: Daan Date: Fri, 28 Mar 2025 13:09:24 -0700 Subject: [PATCH 24/27] fix parenthesis in #if condition --- include/mimalloc/atomic.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/include/mimalloc/atomic.h b/include/mimalloc/atomic.h index 6289dc54..39ff5c90 100644 --- a/include/mimalloc/atomic.h +++ b/include/mimalloc/atomic.h @@ -372,7 +372,7 @@ static inline void mi_atomic_yield(void) { #elif (defined(__GNUC__) || defined(__clang__)) && \ (defined(__x86_64__) || defined(__i386__) || \ defined(__aarch64__) || defined(__arm__) || \ - defined(__powerpc__) || defined(__ppc__) || defined(__PPC__)) || defined(__POWERPC__) + defined(__powerpc__) || defined(__ppc__) || defined(__PPC__) || defined(__POWERPC__)) #if defined(__x86_64__) || defined(__i386__) static inline void mi_atomic_yield(void) { __asm__ volatile ("pause" ::: "memory"); From b843fead226505f8aaba05724880a3e99cd500c8 Mon Sep 17 00:00:00 2001 From: Daan Date: Fri, 28 Mar 2025 13:11:37 -0700 Subject: [PATCH 25/27] update mimalloc-redirect to v1.3.3; fix issue #1049 --- bin/mimalloc-redirect-arm64.dll | Bin 61440 -> 61440 bytes bin/mimalloc-redirect-arm64.lib | Bin 2976 -> 2976 bytes bin/mimalloc-redirect-arm64ec.dll | Bin 104960 -> 104960 bytes bin/mimalloc-redirect-arm64ec.lib | Bin 3308 -> 3308 bytes bin/mimalloc-redirect.dll | Bin 59904 -> 60416 bytes bin/mimalloc-redirect.lib | Bin 2874 -> 2874 bytes bin/mimalloc-redirect32.dll | Bin 38912 -> 38912 bytes bin/mimalloc-redirect32.lib | Bin 2928 -> 2928 bytes 8 files changed, 0 insertions(+), 0 deletions(-) mode change 100644 => 100755 bin/mimalloc-redirect-arm64.dll mode change 100644 => 100755 bin/mimalloc-redirect-arm64.lib mode change 100644 => 100755 bin/mimalloc-redirect-arm64ec.dll mode change 100644 => 100755 bin/mimalloc-redirect-arm64ec.lib mode change 100644 => 100755 bin/mimalloc-redirect.dll mode change 100644 => 100755 bin/mimalloc-redirect.lib mode change 100644 => 100755 bin/mimalloc-redirect32.dll mode change 100644 => 100755 bin/mimalloc-redirect32.lib diff --git a/bin/mimalloc-redirect-arm64.dll b/bin/mimalloc-redirect-arm64.dll old mode 100644 new mode 100755 index e636028591dd8bcf7614a6cd3202121c1913df81..27172d2c0d5f24e2b1a4cccc931bbf530c20860c GIT binary patch delta 7098 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 HmvQ=kBa@Zy delta 6972 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 U*Vo(Kn+|0{5H^SL&No5+7m$5by#N3J diff --git a/bin/mimalloc-redirect-arm64.lib b/bin/mimalloc-redirect-arm64.lib old mode 100644 new mode 100755 index 11d71ef9ea2aace6dce34616131ab0e5654f45d4..dca80b9b855c57735600d925e005a34cc88b21b9 GIT binary patch delta 97 zcmZ1=zCe6~84JsV@&~6TTd^Eq{5jc{U1PE`s}qow$1c6OkyW0NGssTz&PfIa2ByjO nEYg#YuvLJS8Gw~kuw2+4^=a}ec8Fe;$>%vZpn5-ZtYrcKos1)) delta 97 zcmZ1=zCe6~84C;No=-<6Td^Eq{4v>v8 nvq(=q!d3xRW&l=F!6Ki$_{ro~>=3;wlh1Q-K=pp+Sjz+exUD1A diff --git a/bin/mimalloc-redirect-arm64ec.dll b/bin/mimalloc-redirect-arm64ec.dll old mode 100644 new mode 100755 index f5ee4e4765225f8725fb77330abdecc19bcbe172..a228af39d5a094c6c4c7d257fb6184c7d66b72ca GIT binary patch delta 10127 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 G>Hh+r993HY delta 10026 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 a73wN&mA)#cs;t^k?XLD$<9q*C>Hh*9LnR6T diff --git a/bin/mimalloc-redirect-arm64ec.lib b/bin/mimalloc-redirect-arm64ec.lib old mode 100644 new mode 100755 index b88e8fc11d671ae0aac56ea260ca608dd311cbcf..0ce7743647b158d25a8dd82854e6fc34a0b6b28c GIT binary patch delta 98 zcmaDO`9^ZXKNe1jwv9ja85tNjCLiQ5n{3P4&iHdOKZnNTx2!HemIH_MW?wdCM%HH5 qoKvSK@8yu6JcYdqti%8;UBU8%bN9{3dpHgOx%HenP(8;vRha?%|0F8_ delta 98 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 delta 7813 zcmb_hdwf$>w%$85G=;VVOKnPlrV?m?0%;30D325h9y>LK z4lDTm39o{Quc-KgqA%LI!Kw5O8Tzf6)pn@+i8x;|As-Mz+-xUJN)2g2dw)Jk%o;)@ z7a_yg7n-aX5b01xTHFNprV=;2a@hAYleV!`P38da4H!I-J#4;aM4}SNLkZ~*(`W1v zO(wm}UcmM1z&Xv`^pHjOY|P@RuUA;f2Py6XU`Gn__aFI>DCH`Nby~>wE zuE=KXano5SDK>r%H)3xP`5wg>Fb*+l=&3;do%d3DHgGWIQA*!pG_{k?W^bkzB>sH^ zPv$9;5q;!*Hf-ov{pNu%9n^len5QuPo5gJDP;>qZT&qm}Eq6aSgbq4UV9G(>X&pL@ zh5bOWANHs|8_udeaCgF@rnrXvY3O7+lU*B{OXJy?w8Ba6EJE(?tS9NW;@U{k3#{O=WP-iYgTKAWAMp_iAdzAnZ0>T>2zA4T71N7C)|NT55tfzpTB z;f!ZWtNOuj-zifAkhtRqy|Ulr2gQ98n;X2c1liuYt*{o{?OY7ft~hM+@vfDHCYStg zd4!zgGm|QxGIQ)aTyO~$R#!9tTxD*M*SCxZI8lnHV7vy*Pluh3+d-w*c| z$J~KhDyff^DhrS&hOzLBZ9HSMoQf@62xcurt2y^V?iEIHRzBh?-US}jx#Ssyl@L#*H44#skQYeHo1&2o5?>rbI<56_QCVU>ir9k|zEbjq=(Xm8VpNG)zule;7Sd zbLAQfjvkp>c9v)I+FN)`C`)cp@3~KN7|kr8zhiSVN6-egDbreNJ&(B92n1*Za5Qn` zb2ss#7}cT-$iYOg2W;4{xI-~8YAhY3+$Irs5^SbX(I_E&=M-Y69i%Xs@yxQ`Dwgu> z+I*{G``9Y8Tl4J$?1H&f^XdJpY|K406gWL*7p1MtGH&`?Vjz!9_(d0E&_R+W=7Rq{3_-o=?t4bZ*35uQ{|n48?Q`S)1uxP=3nnf}zoKv8Qm)Wy(7Wcn*GTNVI z-E*WN&zmVJj`hCTi&rMoI3^BUL8PR1BT+H~*ssHg@lY zb>7XsGjH{kZuWii6Q%D&(YN_#Uu?AG@v2(}o>Bd7b++8>{IuFRC7adHH%`zByGC&m21yJ>?cKX3(hVzDBY(37hmcF9d+RnaOD$x^c!m>2_2R47%uTt|;6o0<` z|M3l;k;2|yw#@MEoxd3ERW_|?dFtk0ZnWRY+KMh|{@8-C#;{Y%(>3N~HgVZdO+qre zzC71B^DrUN;&{2_ZN3`XY^Z$i*rci2QQ*ZaI(-uJtcc0#iG$;)8_M-3<@$H!O7QH9 zj?yUC80Ff3K;ZbtA-Ya}gg*ue`AJ~nqpEHeI7{GCf!hQ=DNyxRuQlksIurIebl8S*+b(V+ zWFtGiDrG8<&Bsu!ragQ1Y+TO=@7Rgu$9r}{iR#_^IWb|As=FCooix52vo-LT>NvTe z#0T3yjEx%ykzhN=@>eHikUj8LLlAO<5U&UN`rW&^7r}ub6ewOjn8qz2bg+gDri0lt zYtrd%*1l#0UC-WGGcG{aGR;E88%AbR9; z7i1F86|$0jy6(3LJoDaPE!(+1z4ZTURS(20a&McreXBcv`|hoa-MhAK-$F`A;l^F} zZgLlF+a|5szH!?oa)I9Ow(r{E-n7BJbn7m6@w$QA7HoQW$F9c+c`$~#oCcP)VJu7B zFoONp`k`^#-5a-Un*hNl+~Suunly1aS;o1W)*G{P1LHTJr?*u0^OjZGoH3Xh`;Bu2 z|8T=E@R@UwHqQ1rFFGMb?D&p6Y7Fe$o=2&ZWpAIU^)5qGVB!8;${Kdqw82}dai>ii zxusU^vQdxHGcGK`MU-%M)kwnX7zTEzIFI^Oqgfbjicud}=+2{Yc42fW#xOjsR3~gc z#b#3-JA^T$7+tDS7DgRg_b++Wry7l4sDs-SV^}p731f+3)CUH8Ft}G3{fg198s8Ge zu0a0&9W?H;P$P<(LB3Rj>jWAEDh0;H9yn9JjAmpBvsIw2kDFd~vkP;PKxZE}kLu~dkQ z64;x1#G#JTtNTTJQDEKk_tNa3P(yvX+1K6PO&0AAwOfx+^Sq&JVnv zKQ;5^$6u6KxY@v;8>*JtApAP|_~RKQ{6lR9il>LrB)@*JPF7Q}tyVD<*x8D$WfW$M zKuI7GZeG>RA>V)r`Vy z6=)OK8%0-AA%Q_LuvZy)ctn`>SJk|F2P9%2tfUzh(PS6s z5@_Qt@b{}zs1oK5fnk9j;TBTd0>O_T3$;gJZz{Hpx5w0953G3pemcf@UA0>T z_WJitT?!ok=m9#WNVqxsxc5!DL~$QbF5IfFv%BBLSGXFaLs&ce1nHY&SaDbD?7a9Y zEyYoB0mQHi2QOgkU>uQf(9;87gXmxn0n_gwqz85*a1MmPZU=TlEZ`Af#}GoS;GSec zu0q1_j{rB^i5TE6U|I?xojeZkc}S@Y#RqZ)!cUkH;58f|yTC~*AS&!z>QP!F#_>(A7B~&`apOb;L|g)RNM|Mx50U=apaR8^{ z?lP;znTL@j?WLJqR@4k9CFJ0!(}WL3n52K|87f?ggeTMDpN9;O`-J za365(Vw4@+0i5?B_7=DuxNj*c4(?rw_5bxUl!z<9mmqqc1n?V(0UYOQl2U}=;6`8} z#0+i+J_@mbdw|stE4Uwc0b&CW12xOB>A>~C9Ecs<2HXNEDuv<#c@E+L_W|F7IKjif z_!Vde*8}q*{GUN~U>U>%juRJYfRuy#ffpcNa2(i3{7NhhxE?qQ;^Y3n^NX zfKNesz`ejT5K@fw4}tsy(G|n61|P%_JviQ)WER8#ZU^p#7{NWj;}A1AUYF!Yhy@() zM3N1$g5%{!9)Z}nKQIW9xIgeqh#frQz^%9r>r(^;M@w=N;^0oeuJu>~aJ(|eiVY|` zxC8hm!~>3Z1G#4-$_|c4Jo(Kg%nIBG)NICVi}49)3nYI1BP}%{H+_?#$=+1n>}~FB zCat&zc(%#cfyhsi{7N4`)Roze>J}MtI))dt`YO88P$GVQ`>!f;neR+Mb zp|gQBTAOT5B~AY3j^;?Sxz*C@Z1uG@w1wLcz^BGB_>4Ypbyc;lMqgv7F_+eOYRhZA zwZ7V(W28=3XQ*@4m(+Xez4dZKq@kxl*XU?+Hgz?Jo9(Sdt(|S5HsZ(R5zpq6e0HD1 z*HIm;?yT;rw$xZ_Y&BAiy{4hoU)xa|tnI8d)|u-pb=EptT~)oW-d`WA@2uB18XC=w z)<#=nd6T!P)Ys&1>S!V@x|WhwPiuK=RcoZJr;W7h+ewfRY#ZYAxqKzQa$mSwu8vgq zRFk7cHIAB4ZC7o$Hc~6q+3SkxoOL{OS3M7FZ{!g>o6Iei7F&z2wV~DD+R++pHMASs z&Fz+UYdeC5u(AMesjtfC^ELSVKHX9MQR7ihO?i#CrmDtQ(^E^1>5dtWx#~*lJay%D z-a5HHQr}Zg8gvbgMrUJ5V^>qSNp6ZX^)%UAidq~k&K6e-31g`cSl?`DHaAd8-P`VKZ)i7@2sSG^M0`CyUA3XwdDL~(bJTk@TqD=? U)aYu9jyaCGj(LvZ+oOyAAIj4H1^@s6 diff --git a/bin/mimalloc-redirect.lib b/bin/mimalloc-redirect.lib old mode 100644 new mode 100755 index 1d710c011bf7273a3d693106fffe03f4c5b5a1ab..785fa4751353bc3375ee9b77b6942505053f63c1 GIT binary patch delta 88 zcmdlbwo7b-1Pe<=?vksMWmtAG{+!Int}*#Piw)z?%{Huhj4U+@Hg6~Au}uQY7ywBd hR_V#U?6EAimrlHzypA2BMP+g?2M0uQ^G1$NCIFTDAIty% delta 88 zcmdlbwo7b-1PhC+gZJObGAz3oe@td%*O>gD#fI_6W*b&LMwb1@9(|si$2JKpV*n&= hSfwZXvd6L*mPy>4ypA2BMP+g?2M0uQ^G1$NCIFkzAE5vM diff --git a/bin/mimalloc-redirect32.dll b/bin/mimalloc-redirect32.dll old mode 100644 new mode 100755 index 32799ffeb37474d9b899f1c34482a6034580014a..92578f240e430f5baffc000ae3c366db690fb75a GIT binary patch delta 5587 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 atlXriQ`i+w#R61MYQGHCliJ}VcK;t|AO9-= diff --git a/bin/mimalloc-redirect32.lib b/bin/mimalloc-redirect32.lib old mode 100644 new mode 100755 index e29272506cf314ede4bff04eb7a1d7949739c43d..bf64978793de2eb34b5ec714fcffa813c7188d88 GIT binary patch delta 106 zcmew$_Caie84Js^=+G;ZtyuOj{+z7It}$7j)sFG!<~UX(MozuEdu|?OU|?XHY|kP+ wc?(+!Scw6UjANCaT*@BHx!9)l;X|kjv&n)SjbIfrlh<=_KvZqM%rTb<0OMsOVgLXD delta 106 zcmew$_Caie84F9)#;yyKtyuOj{+O)Et}$7j)sFGU<~UX(Mow+}6ZelYFfcGpwr7!^ wyoId Date: Fri, 28 Mar 2025 13:28:10 -0700 Subject: [PATCH 26/27] update readme --- readme.md | 3 +++ 1 file changed, 3 insertions(+) diff --git a/readme.md b/readme.md index 81f2057e..0727fba9 100644 --- a/readme.md +++ b/readme.md @@ -84,6 +84,9 @@ Enjoy! ### Releases +* 2025-03-28, `v1.9.3`, `v2.2.3`, `v3.0.3-beta`: Various small bug and build fixes, including: + fix arm32 pre v7 builds, fix mingw build, get runtime statistics, improve statistic commit counts, + fix execution on non BMI1 x64 systems. * 2025-03-06, `v1.9.2`, `v2.2.2`, `v3.0.2-beta`: Various small bug and build fixes. Add `mi_options_print`, `mi_arenas_print`, and the experimental `mi_stat_get` and `mi_stat_get_json`. Add `mi_thread_set_in_threadpool` and `mi_heap_set_numa_affinity` (v3 only). Add vcpkg portfile. From 8a81fc73c88750085ea40ae4dfb49955bdf93c71 Mon Sep 17 00:00:00 2001 From: Daan Date: Fri, 28 Mar 2025 14:18:28 -0700 Subject: [PATCH 27/27] update readme --- readme.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/readme.md b/readme.md index 0727fba9..87cee98d 100644 --- a/readme.md +++ b/readme.md @@ -12,9 +12,9 @@ is a general purpose allocator with excellent [performance](#performance) charac Initially developed by Daan Leijen for the runtime systems of the [Koka](https://koka-lang.github.io) and [Lean](https://github.com/leanprover/lean) languages. -Latest release : `v3.0.2` (beta) (2025-03-06). -Latest v2 release: `v2.2.2` (2025-03-06). -Latest v1 release: `v1.9.2` (2024-03-06). +Latest release : `v3.0.3` (beta) (2025-03-28). +Latest v2 release: `v2.2.3` (2025-03-28). +Latest v1 release: `v1.9.3` (2024-03-28). mimalloc is a drop-in replacement for `malloc` and can be used in other programs without code changes, for example, on dynamically linked ELF-based systems (Linux, BSD, etc.) you can use it as: