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 = "09fed41b098f2f329b2d8cfa0ee4fb55b21c53fa";
 
 export const mimalloc: Dependency = {
   name: "mimalloc",
@@ -91,10 +91,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 +121,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

@@ -91,9 +91,10 @@
 __aarch64_ldadd8_rel      [LSE]
 __aarch64_ldadd8_relax    [LSE]
 __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_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_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;

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

@@ -68,6 +68,6 @@ describe("static initializers", () => {
     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" ? 2 : 3);
   });
 });