tiny.sys.allocator

1const std = @import("std");2const builtin = @import("builtin");3const capabilities = @import("capabilities.zig");4const memory = @import("memory.zig");56const Allocator = std.mem.Allocator;78pub const required_capabilities = capabilities.noLibc(&.{.allocator});910var process_allocator_override = std.atomic.Value(usize).init(0);11var process_allocator_readers = std.atomic.Value(usize).init(0);12var process_allocator_context: u8 = 0;1314const transition_address = 1;1516const process_allocator: Allocator = .{17    .ptr = &process_allocator_context,18    .vtable = &process_allocator_vtable,19};2021pub const ProcessAllocatorOverride = struct {22    handle: *const Allocator,23    active: bool = true,2425    pub fn deinit(self: *ProcessAllocatorOverride) void {26        if (!self.active) return;27        const address = @intFromPtr(self.handle);28        const previous = process_allocator_override.cmpxchgStrong(29            address,30            transition_address,31            .acq_rel,32            .acquire,33        );34        std.debug.assert(previous == null);35        while (process_allocator_readers.load(.acquire) != 0) {36            std.atomic.spinLoopHint();37        }38        process_allocator_override.store(0, .release);39        self.active = false;40    }41};4243pub fn processAllocator() Allocator {44    return process_allocator;45}4647pub fn observerControlAllocator() Allocator {48    return baseProcessAllocator();49}5051pub fn installProcessAllocatorOverride(52    handle: *const Allocator,53) error{AlreadyInstalled}!ProcessAllocatorOverride {54    const address = @intFromPtr(handle);55    std.debug.assert(address > transition_address);56    if (process_allocator_override.cmpxchgStrong(57        0,58        transition_address,59        .acq_rel,60        .acquire,61    ) != null) {62        return error.AlreadyInstalled;63    }64    while (process_allocator_readers.load(.acquire) != 0) {65        std.atomic.spinLoopHint();66    }67    process_allocator_override.store(address, .release);68    return .{ .handle = handle };69}7071pub fn hostInteropAllocator() Allocator {72    return processAllocator();73}7475pub fn hostInteropFreeRaw(ptr: ?*anyopaque) void {76    _ = ptr;77}7879pub fn hostInteropRawFreeAvailable() bool {80    return false;81}8283pub fn wasmHostAllocator(fallback: Allocator) Allocator {84    if (comptime builtin.cpu.arch.isWasm()) {85        return fallback;86    }87    return processAllocator();88}8990pub fn hostOwnedAllocator() Allocator {91    if (comptime builtin.cpu.arch.isWasm() and builtin.os.tag == .freestanding) {92        return std.heap.wasm_allocator;93    }94    return hostInteropAllocator();95}9697pub fn requiredHostInteropAllocator(comptime _: []const u8) Allocator {98    return hostInteropAllocator();99}100101pub fn benchmarkAllocator() Allocator {102    return processAllocator();103}104105pub fn moduleLocalAbiAllocator() Allocator {106    return processAllocator();107}108109pub fn preloadBackingAllocator() Allocator {110    return processAllocator();111}112113pub fn debugInfoScratchAllocator() Allocator {114    return memory.page_allocator;115}116117const ProcessAllocatorSelection = struct {118    allocator: Allocator,119120    fn release(_: @This()) void {121        _ = process_allocator_readers.fetchSub(1, .release);122    }123};124125fn selectProcessAllocator() ProcessAllocatorSelection {126    while (true) {127        const address = process_allocator_override.load(.acquire);128        if (address == transition_address) {129            std.atomic.spinLoopHint();130            continue;131        }132        _ = process_allocator_readers.fetchAdd(1, .acquire);133        if (process_allocator_override.load(.acquire) == address) {134            return .{135                .allocator = if (address == 0)136                    baseProcessAllocator()137                else138                    @as(*const Allocator, @ptrFromInt(address)).*,139            };140        }141        _ = process_allocator_readers.fetchSub(1, .release);142    }143}144145fn processAllocatorAlloc(146    _: *anyopaque,147    len: usize,148    alignment: std.mem.Alignment,149    return_address: usize,150) ?[*]u8 {151    const selected = selectProcessAllocator();152    defer selected.release();153    return selected.allocator.rawAlloc(len, alignment, return_address);154}155156fn processAllocatorResize(157    _: *anyopaque,158    memory_slice: []u8,159    alignment: std.mem.Alignment,160    new_len: usize,161    return_address: usize,162) bool {163    const selected = selectProcessAllocator();164    defer selected.release();165    return selected.allocator.rawResize(166        memory_slice,167        alignment,168        new_len,169        return_address,170    );171}172173fn processAllocatorRemap(174    _: *anyopaque,175    memory_slice: []u8,176    alignment: std.mem.Alignment,177    new_len: usize,178    return_address: usize,179) ?[*]u8 {180    const selected = selectProcessAllocator();181    defer selected.release();182    return selected.allocator.rawRemap(183        memory_slice,184        alignment,185        new_len,186        return_address,187    );188}189190fn processAllocatorFree(191    _: *anyopaque,192    memory_slice: []u8,193    alignment: std.mem.Alignment,194    return_address: usize,195) void {196    const selected = selectProcessAllocator();197    defer selected.release();198    selected.allocator.rawFree(199        memory_slice,200        alignment,201        return_address,202    );203}204205const process_allocator_vtable: Allocator.VTable = .{206    .alloc = processAllocatorAlloc,207    .resize = processAllocatorResize,208    .remap = processAllocatorRemap,209    .free = processAllocatorFree,210};211212fn baseProcessAllocator() Allocator {213    if (comptime builtin.cpu.arch.isWasm()) return std.heap.wasm_allocator;214    return std.heap.smp_allocator;215}216217fn expectSameAllocator(expected: Allocator, actual: Allocator) !void {218    try std.testing.expectEqual(expected.ptr, actual.ptr);219    try std.testing.expectEqual(expected.vtable, actual.vtable);220}221222test "process and host interop allocators use libc-free sys policy" {223    const expected = process_allocator;224    try expectSameAllocator(expected, processAllocator());225    try expectSameAllocator(expected, hostInteropAllocator());226    try expectSameAllocator(227        baseProcessAllocator(),228        observerControlAllocator(),229    );230}231232test "process allocator override is scoped and exclusive" {233    var storage: [64]u8 = undefined;234    var fixed = std.heap.FixedBufferAllocator.init(&storage);235    var handle = fixed.allocator();236    const process = processAllocator();237    var session = try installProcessAllocatorOverride(&handle);238    defer session.deinit();239240    const bytes = try process.alloc(u8, 16);241    try std.testing.expect(@intFromPtr(bytes.ptr) >= @intFromPtr(&storage));242    try std.testing.expect(243        @intFromPtr(bytes.ptr) + bytes.len <=244            @intFromPtr(&storage) + storage.len,245    );246    process.free(bytes);247    try std.testing.expectError(248        error.AlreadyInstalled,249        installProcessAllocatorOverride(&handle),250    );251    session.deinit();252    try expectSameAllocator(process_allocator, processAllocator());253}254255test "host interop raw free is unavailable without libc ownership" {256    hostInteropFreeRaw(null);257    try std.testing.expect(!hostInteropRawFreeAvailable());258}259260test "wasm host allocator uses fallback for wasm hosts" {261    const fallback = std.testing.allocator;262    const expected = if (comptime builtin.cpu.arch.isWasm())263        fallback264    else265        processAllocator();266    try expectSameAllocator(expected, wasmHostAllocator(fallback));267}268269test "host-owned allocator uses wasm allocation for browser-style targets" {270    const expected = if (comptime builtin.cpu.arch.isWasm() and builtin.os.tag == .freestanding)271        std.heap.wasm_allocator272    else273        hostInteropAllocator();274    try expectSameAllocator(expected, hostOwnedAllocator());275}276277test "module-local ABI and preload policies use the process seam" {278    try expectSameAllocator(processAllocator(), moduleLocalAbiAllocator());279    try expectSameAllocator(processAllocator(), preloadBackingAllocator());280}281282test "debug-info scratch policy avoids userspace allocator locks" {283    try expectSameAllocator(memory.page_allocator, debugInfoScratchAllocator());284}285286test "required host interop allocator uses sys policy" {287    try expectSameAllocator(hostInteropAllocator(), requiredHostInteropAllocator("test owner"));288}

1pub const allocator = @import("allocator.zig");