deps: bump mimalloc to dev3 (bun-dev3-v2)

scripts/build/deps/mimalloc.ts

@@ -5,7 +5,7 @@
 
 import type { Dependency, NestedCmakeBuild, Provides } from "../source.ts";
 
-const MIMALLOC_COMMIT = "1beadf9651a7bfdec6b5367c380ecc3fe1c40d1a";
+const MIMALLOC_COMMIT = "9a5e1f52cdf4662f9590b69de104a4469140796f";
 
 export const mimalloc: Dependency = {
   name: "mimalloc",
@@ -68,8 +68,13 @@ export const mimalloc: Dependency = {
       // so UBSan doesn't false-positive on mimalloc's type punning.
       args.MI_DEBUG_UBSAN = "ON";
     } else if (cfg.darwin) {
-      args.MI_OVERRIDE = "OFF";
-      args.MI_OSX_ZONE = "OFF";
+      // Register the mimalloc malloc_zone so leaks/heap/vmmap/Instruments can
+      // enumerate our allocations and the fork-prepare/child hooks fire.
+      // Interpose is OFF because we link the .o statically; the __interpose
+      // section only works for inserted dylibs. The zone-swap path in
+      // alloc-override-zone.c handles making mimalloc the default zone.
+      args.MI_OVERRIDE = "ON";
+      args.MI_OSX_ZONE = "ON";
       args.MI_OSX_INTERPOSE = "OFF";
     } else if (cfg.linux) {
       args.MI_OVERRIDE = "ON";
@@ -91,10 +96,10 @@ export const mimalloc: Dependency = {
       args.MI_TRACK_VALGRIND = "ON";
     }
 
-    // If mimalloc gets bumped to a version with MI_OPT_ARCH: pass
-    // MI_NO_OPT_ARCH=ON to stop it setting -march=armv8.1-a on arm64
-    // (SIGILLs on ARMv8.0 CPUs). Current pin has no arch-detection logic
-    // so our global -march=armv8-a+crc (via CMAKE_CXX_FLAGS) is sufficient.
+    // dev3 grew MI_OPT_ARCH which sets -march=armv8.1-a on arm64 — that
+    // SIGILLs on ARMv8.0 CPUs. Explicitly disable it; our global
+    // -march=armv8-a+crc (via CMAKE_CXX_FLAGS) is sufficient.
+    args.MI_NO_OPT_ARCH = "ON";
 
     // ─── Windows: silence the vendored-C-as-C++ warning flood ───
     // MI_USE_CXX=ON means .c files compile as C++. clang-cl then complains
@@ -121,7 +126,7 @@ export const mimalloc: Dependency = {
     // to override this, so we have to mirror its naming logic.
     let libname: string;
     if (cfg.windows) {
-      libname = cfg.debug ? "mimalloc-static-debug" : "mimalloc-static";
+      libname = cfg.debug ? "mimalloc-debug" : "mimalloc";
     } else if (cfg.debug) {
       libname = cfg.asan ? "mimalloc-asan-debug" : "mimalloc-debug";
     } else {

scripts/verify-baseline-static/allowlist-aarch64.txt

@@ -94,6 +94,7 @@ __aarch64_ldclr1_acq_rel  [LSE]
 __aarch64_ldclr2_acq_rel  [LSE]
 __aarch64_ldclr4_acq_rel  [LSE]
 __aarch64_ldclr8_acq_rel  [LSE]
+__aarch64_ldclr8_relax    [LSE]
 __aarch64_ldeor1_acq_rel  [LSE]
 __aarch64_ldeor2_acq_rel  [LSE]
 __aarch64_ldeor4_acq_rel  [LSE]
@@ -102,6 +103,7 @@ __aarch64_ldset1_acq_rel  [LSE]
 __aarch64_ldset2_acq_rel  [LSE]
 __aarch64_ldset4_acq_rel  [LSE]
 __aarch64_ldset8_acq_rel  [LSE]
+__aarch64_ldset8_relax    [LSE]
 __aarch64_swp1_acq        [LSE]
 __aarch64_swp1_acq_rel    [LSE]
 __aarch64_swp1_relax      [LSE]
@@ -110,6 +112,8 @@ __aarch64_swp4_acq        [LSE]
 __aarch64_swp4_acq_rel    [LSE]
 __aarch64_swp4_rel        [LSE]
 __aarch64_swp8_acq_rel    [LSE]
+__aarch64_swp8_rel        [LSE]
+__aarch64_swp8_relax      [LSE]
 
 
 # ----------------------------------------------------------------------------

src/allocators/MimallocArena.zig

@@ -8,9 +8,8 @@ const Self = @This();
 ///
 /// This type is a `GenericAllocator`; see `src/allocators.zig`.
 pub const Default = struct {
-    pub fn allocator(self: Default) std.mem.Allocator {
-        _ = self;
-        return Borrowed.getDefault().allocator();
+    pub fn allocator(_: Default) std.mem.Allocator {
+        return .{ .ptr = undefined, .vtable = &global_mimalloc_vtable };
     }
 };
 
@@ -23,11 +22,20 @@ pub const Borrowed = struct {
     #heap: BorrowedHeap,
 
     pub fn allocator(self: Borrowed) std.mem.Allocator {
-        return .{ .ptr = self.#heap, .vtable = &c_allocator_vtable };
+        return .{ .ptr = self.#heap, .vtable = &heap_allocator_vtable };
     }
 
+    /// Prefer `Default.allocator()` / `getThreadLocalDefault()` for a thread-safe
+    /// global allocator. This returns the process-wide main heap so that
+    /// `gc()` / `ownsPtr()` on the result remain meaningful.
     pub fn getDefault() Borrowed {
-        return .{ .#heap = getThreadHeap() };
+        const heap = mimalloc.mi_heap_main();
+        if (comptime !safety_checks) return .{ .#heap = heap };
+        const S = struct {
+            threadlocal var dbg: ?DebugHeap = null;
+        };
+        if (S.dbg == null) S.dbg = .{ .inner = heap, .thread_lock = .initLocked() };
+        return .{ .#heap = &S.dbg.? };
     }
 
     pub fn gc(self: Borrowed) void {
@@ -42,7 +50,7 @@ pub const Borrowed = struct {
     }
 
     pub fn ownsPtr(self: Borrowed, ptr: *const anyopaque) bool {
-        return mimalloc.mi_heap_check_owned(self.getMimallocHeap(), ptr);
+        return mimalloc.mi_heap_contains(self.getMimallocHeap(), ptr);
     }
 
     fn fromOpaque(ptr: *anyopaque) Borrowed {
@@ -81,8 +89,8 @@ pub const Borrowed = struct {
 
     pub fn downcast(std_alloc: std.mem.Allocator) Borrowed {
         bun.assertf(
-            isInstance(std_alloc),
-            "not a MimallocArena (vtable is {*})",
+            std_alloc.vtable == &heap_allocator_vtable,
+            "not an owned MimallocArena heap (vtable is {*})",
             .{std_alloc.vtable},
         );
         return .fromOpaque(std_alloc.ptr);
@@ -98,19 +106,6 @@ const DebugHeap = struct {
     pub const deinit = void;
 };
 
-threadlocal var thread_heap: if (safety_checks) ?DebugHeap else void = if (safety_checks) null;
-
-fn getThreadHeap() BorrowedHeap {
-    if (comptime !safety_checks) return mimalloc.mi_heap_get_default();
-    if (thread_heap == null) {
-        thread_heap = .{
-            .inner = mimalloc.mi_heap_get_default(),
-            .thread_lock = .initLocked(),
-        };
-    }
-    return &thread_heap.?;
-}
-
 const log = bun.Output.scoped(.mimalloc, .hidden);
 
 pub fn allocator(self: Self) std.mem.Allocator {
@@ -121,13 +116,11 @@ pub fn borrow(self: Self) Borrowed {
     return .{ .#heap = if (comptime safety_checks) self.#heap.get() else self.#heap };
 }
 
-/// Internally, mimalloc calls mi_heap_get_default()
-/// to get the default heap.
-/// It uses pthread_getspecific to do that.
-/// We can save those extra calls if we just do it once in here
+/// In v3, `mi_malloc`/`mi_free` are already thread-local-fast — there is no
+/// per-thread default heap to cache. Route through the global vtable.
 pub fn getThreadLocalDefault() std.mem.Allocator {
     if (bun.Environment.enable_asan) return bun.default_allocator;
-    return Borrowed.getDefault().allocator();
+    return .{ .ptr = undefined, .vtable = &global_mimalloc_vtable };
 }
 
 pub fn backingAllocator(_: Self) std.mem.Allocator {
@@ -251,17 +244,43 @@ fn vtable_remap(ptr: *anyopaque, buf: []u8, alignment: Alignment, new_len: usize
     return @ptrCast(value);
 }
 
+fn global_vtable_alloc(_: *anyopaque, len: usize, alignment: Alignment, _: usize) ?[*]u8 {
+    log("Malloc: {d}\n", .{len});
+    const ptr: ?*anyopaque = if (mimalloc.mustUseAlignedAlloc(alignment))
+        mimalloc.mi_malloc_aligned(len, alignment.toByteUnits())
+    else
+        mimalloc.mi_malloc(len);
+    return if (ptr) |p| @ptrCast(p) else null;
+}
+
+fn global_vtable_resize(_: *anyopaque, buf: []u8, _: Alignment, new_len: usize, _: usize) bool {
+    return mimalloc.mi_expand(buf.ptr, new_len) != null;
+}
+
+fn global_vtable_remap(_: *anyopaque, buf: []u8, alignment: Alignment, new_len: usize, _: usize) ?[*]u8 {
+    return @ptrCast(mimalloc.mi_realloc_aligned(buf.ptr, new_len, alignment.toByteUnits()));
+}
+
 pub fn isInstance(alloc: std.mem.Allocator) bool {
-    return alloc.vtable == &c_allocator_vtable;
+    return alloc.vtable == &heap_allocator_vtable or alloc.vtable == &global_mimalloc_vtable;
 }
 
-const c_allocator_vtable = std.mem.Allocator.VTable{
+/// VTable for owned heaps created with `mi_heap_new`.
+const heap_allocator_vtable = std.mem.Allocator.VTable{
     .alloc = vtable_alloc,
     .resize = vtable_resize,
     .remap = vtable_remap,
     .free = vtable_free,
 };
 
+/// VTable for the process-wide default allocator (`mi_malloc`/`mi_free`).
+const global_mimalloc_vtable = std.mem.Allocator.VTable{
+    .alloc = global_vtable_alloc,
+    .resize = global_vtable_resize,
+    .remap = global_vtable_remap,
+    .free = vtable_free,
+};
+
 const std = @import("std");
 const Alignment = std.mem.Alignment;
 

src/allocators/mimalloc.zig

@@ -60,16 +60,15 @@ pub const Heap = opaque {
         return mi_heap_realloc(self, p, newsize);
     }
 
-    pub fn isOwned(self: *Heap, p: ?*anyopaque) bool {
-        return mi_heap_check_owned(self, p);
+    pub fn isOwned(self: *Heap, p: ?*const anyopaque) bool {
+        return mi_heap_contains(self, p);
     }
 };
 pub extern fn mi_heap_new() ?*Heap;
 pub extern fn mi_heap_delete(heap: *Heap) void;
 pub extern fn mi_heap_destroy(heap: *Heap) void;
-pub extern fn mi_heap_set_default(heap: *Heap) *Heap;
-pub extern fn mi_heap_get_default() *Heap;
-pub extern fn mi_heap_get_backing() *Heap;
+pub extern fn mi_heap_main() *Heap;
+pub extern fn mi_heap_contains(heap: *const Heap, p: ?*const anyopaque) bool;
 pub extern fn mi_heap_collect(heap: *Heap, force: bool) void;
 pub extern fn mi_heap_malloc(heap: *Heap, size: usize) ?*anyopaque;
 pub extern fn mi_heap_zalloc(heap: *Heap, size: usize) ?*anyopaque;
@@ -102,8 +101,6 @@ pub extern fn mi_heap_rezalloc_aligned(heap: *Heap, p: ?*anyopaque, newsize: usi
 pub extern fn mi_heap_rezalloc_aligned_at(heap: *Heap, p: ?*anyopaque, newsize: usize, alignment: usize, offset: usize) ?*anyopaque;
 pub extern fn mi_heap_recalloc_aligned(heap: *Heap, p: ?*anyopaque, newcount: usize, size: usize, alignment: usize) ?*anyopaque;
 pub extern fn mi_heap_recalloc_aligned_at(heap: *Heap, p: ?*anyopaque, newcount: usize, size: usize, alignment: usize, offset: usize) ?*anyopaque;
-pub extern fn mi_heap_contains_block(heap: *Heap, p: *const anyopaque) bool;
-pub extern fn mi_heap_check_owned(heap: *Heap, p: *const anyopaque) bool;
 pub extern fn mi_check_owned(p: ?*const anyopaque) bool;
 pub const struct_mi_heap_area_s = extern struct {
     blocks: ?*anyopaque,
@@ -112,6 +109,7 @@ pub const struct_mi_heap_area_s = extern struct {
     used: usize,
     block_size: usize,
     full_block_size: usize,
+    reserved1: ?*anyopaque,
 };
 pub const mi_heap_area_t = struct_mi_heap_area_s;
 pub const mi_block_visit_fun = *const fn (?*const Heap, [*c]const mi_heap_area_t, ?*anyopaque, usize, ?*anyopaque) callconv(.c) bool;

src/bun.js/modules/BunJSCModule.h

@@ -46,6 +46,8 @@
 #include "JSDOMConvertBase.h"
 #include "ZigSourceProvider.h"
 #include "mimalloc.h"
+extern "C" char* mi_stats_get_json(size_t, char*);
+extern "C" char* mi_heap_dump_json(bool include_blocks, bool hash_addresses);
 
 #include <JavaScriptCore/ControlFlowProfiler.h>
 
@@ -219,7 +221,7 @@ createMemoryFootprintStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject)
 
 JSC_DECLARE_HOST_FUNCTION(functionMemoryUsageStatistics);
 JSC_DEFINE_HOST_FUNCTION(functionMemoryUsageStatistics,
-    (JSGlobalObject * globalObject, CallFrame*))
+    (JSGlobalObject * globalObject, CallFrame* callFrame))
 {
 
     auto& vm = JSC::getVM(globalObject);
@@ -356,6 +358,34 @@ JSC_DEFINE_HOST_FUNCTION(functionMemoryUsageStatistics,
 #endif
 #endif
 
+    mi_collect(false);
+    if (char* json = mi_stats_get_json(0, nullptr)) {
+        JSValue parsed = JSONParse(globalObject, String::fromUTF8(json));
+        mi_free(json);
+        object->putDirect(vm, Identifier::fromString(vm, "mimalloc"_s),
+            parsed.isEmpty() ? jsNull() : parsed);
+    }
+
+    // heapStats({ dump: true | "blocks" }) -> per-heap/per-page (and per-block) live snapshot.
+    JSValue arg0 = callFrame->argument(0);
+    if (arg0.isObject()) {
+        JSValue dump = arg0.getObject()->get(globalObject, Identifier::fromString(vm, "dump"_s));
+        if (dump.toBoolean(globalObject)) {
+            const bool includeBlocks = dump.isString() && dump.toWTFString(globalObject) == "blocks"_s;
+            #if BUN_DEBUG
+            const bool hashAddresses = false;
+            #else
+            const bool hashAddresses = true;
+            #endif
+            if (char* json = mi_heap_dump_json(includeBlocks, hashAddresses)) {
+                JSValue parsed = JSONParse(globalObject, String::fromUTF8(json));
+                mi_free(json);
+                object->putDirect(vm, Identifier::fromString(vm, "mimallocDump"_s),
+                    parsed.isEmpty() ? jsNull() : parsed);
+            }
+        }
+    }
+
     return JSValue::encode(object);
 }
 

test/js/bun/jsc/heapStats-mimalloc.test.ts

@@ -0,0 +1,65 @@
+import { heapStats } from "bun:jsc";
+import { describe, expect, test } from "bun:test";
+
+describe("heapStats() mimalloc integration", () => {
+  test("mimalloc aggregate stats are present", () => {
+    const s = heapStats();
+    expect(s.mimalloc).toBeDefined();
+    expect(s.mimalloc.mimalloc_version).toBeGreaterThan(3000);
+    expect(s.mimalloc.pages.current).toBeGreaterThan(0);
+    expect(s.mimalloc.committed.current).toBeGreaterThan(0);
+    expect(Array.isArray(s.mimalloc.malloc_bins)).toBe(true);
+  });
+
+  test("heapStats({dump: true}) returns per-heap pages", () => {
+    const s = heapStats({ dump: true });
+    expect(s.mimallocDump).toBeDefined();
+    expect(Array.isArray(s.mimallocDump.heaps)).toBe(true);
+    expect(s.mimallocDump.heaps.length).toBeGreaterThan(0);
+    const main = s.mimallocDump.heaps.find((h: any) => h.seq === 0);
+    expect(main).toBeDefined();
+    expect(Array.isArray(main.pages)).toBe(true);
+    expect(main.pages.length).toBeGreaterThan(0);
+    const page = main.pages[0];
+    expect(typeof page.id).toBe("number");
+    expect(page.block_size).toBeGreaterThan(0);
+    expect(page.used).toBeGreaterThanOrEqual(0);
+    expect(page.reserved).toBeGreaterThan(0);
+    expect(typeof page.thread_id).toBe("number");
+    // pages-only mode: no blocks
+    expect(main.blocks).toBeUndefined();
+  });
+
+  test("heapStats({dump: 'blocks'}) includes per-block ids", () => {
+    const s = heapStats({ dump: "blocks" });
+    const main = s.mimallocDump.heaps.find((h: any) => h.seq === 0);
+    expect(Array.isArray(main.blocks)).toBe(true);
+    expect(main.blocks.length).toBeGreaterThan(0);
+    const [id, size] = main.blocks[0];
+    expect(typeof id).toBe("number");
+    expect(size).toBeGreaterThan(0);
+    // every block size should match some page's block_size
+    const pageSizes = new Set(main.pages.map((p: any) => p.block_size));
+    for (const [, sz] of main.blocks.slice(0, 50)) {
+      expect(pageSizes.has(sz)).toBe(true);
+    }
+  });
+
+  test("dump reflects new heaps and allocations", () => {
+    const before = heapStats({ dump: true }).mimallocDump.heaps.length;
+    // MimallocArena is internal; trigger via something that creates a heap.
+    // Transpiler creates a per-call arena.
+    const t = new Bun.Transpiler();
+    const out = t.transformSync("export const x = 1");
+    expect(out.length).toBeGreaterThan(0);
+    const after = heapStats({ dump: true }).mimallocDump.heaps;
+    // Either a new heap was created (and may already be destroyed), or main grew.
+    // We assert the dump is still well-formed and >= before.
+    expect(after.length).toBeGreaterThanOrEqual(1);
+    for (const h of after) {
+      expect(typeof h.seq).toBe("number");
+      expect(Array.isArray(h.pages)).toBe(true);
+    }
+    void before;
+  });
+});

test/js/bun/perf/static-initializers.test.ts

@@ -59,15 +59,12 @@ describe("static initializers", () => {
       .map(a => a.trim())
       .filter(line => line.includes("running initializer") && line.includes(bunExe()));
 
-    // On both architectures, we have one initializer "__GLOBAL__sub_I_static.c".
-    // On arm64, mimalloc v3 adds one more static initializer (total: 2).
-    // On x86_64, we also have:
-    // - one from ___cpu_indicator_init due to our CPU feature detection
-    // - one from mimalloc v3
-    // (total: 3)
+    // mimalloc v3 with MI_OSX_ZONE=ON contributes three: __GLOBAL__sub_I_static.c,
+    // mi_process_attach, and _mi_macos_override_malloc (the zone-swap constructor).
+    // On x86_64 there is also ___cpu_indicator_init from CPU feature detection.
     expect(
       bunInitializers.length,
       `Do not add static initializers to Bun. Static initializers are called when Bun starts up, regardless of whether you use the variables or not. This makes Bun slower.`,
-    ).toBe(process.arch === "arm64" ? 1 : 2);
+    ).toBe(process.arch === "arm64" ? 3 : 4);
   });
 });