alloc_observe.ObservedAllocator

1/// A generic adapter wrapping a supplied backing allocator, instrumenting2/// allocation, resizing, remapping, and deallocation virtual table calls while3/// returning backing allocator outcomes unchanged. The adapter emits no4/// lifecycle records and enforces no independent memory reclamation policy.5/// Callers must keep both the adapter and its backing allocator at stable6/// memory addresses throughout use, and must ensure the installed sink can7/// handle concurrent invocations when the backing allocator is accessed across8/// multiple threads.9pub const ObservedAllocator = struct {10    backing: Allocator,11    producer_id: u64,12    producer: protocol.Producer,1314    /// Initializes the adapter by storing the backing allocator handle, an15    /// explicit producer identifier, and a producer kind. The constructor16    /// always asserts that the supplied producer identifier is nonzero, even in17    /// disabled builds. Callers must therefore avoid unconditionally passing18    /// `producerId`(), which evaluates to zero when observation is disabled.19    /// Initialization emits no observation events.20    pub fn init(21        backing: Allocator,22        producer_id: u64,23        producer: protocol.Producer,24    ) ObservedAllocator {25        std.debug.assert(producer_id != 0);26        return .{27            .backing = backing,28            .producer_id = producer_id,29            .producer = producer,30        };31    }3233    /// Returns an allocator interface handle borrowing a pointer to this34    /// adapter and its virtual table. The adapter and its underlying backing35    /// allocator must remain alive and at stable memory addresses for the36    /// lifetime of all issued handles. Relocating the owning adapter in memory37    /// does not update existing borrowed pointers.38    pub fn allocator(self: *ObservedAllocator) Allocator {39        return .{ .ptr = self, .vtable = &vtable };40    }4142    fn rawAlloc(43        context: *anyopaque,44        len: usize,45        alignment: Alignment,46        return_address: usize,47    ) ?[*]u8 {48        const self: *ObservedAllocator = @ptrCast(@alignCast(context));49        var span = self.begin(.alloc, 0, 0, len, alignment, return_address);50        const result = self.backing.rawAlloc(len, alignment, return_address);51        span.finish(.{52            .address = if (result) |ptr| @intFromPtr(ptr) else 0,53            .succeeded = result != null,54        });55        return result;56    }5758    fn rawResize(59        context: *anyopaque,60        memory: []u8,61        alignment: Alignment,62        new_len: usize,63        return_address: usize,64    ) bool {65        const self: *ObservedAllocator = @ptrCast(@alignCast(context));66        var span = self.begin(67            .resize,68            @intFromPtr(memory.ptr),69            memory.len,70            new_len,71            alignment,72            return_address,73        );74        const succeeded = self.backing.rawResize(75            memory,76            alignment,77            new_len,78            return_address,79        );80        span.finish(.{81            .address = if (succeeded) @intFromPtr(memory.ptr) else 0,82            .succeeded = succeeded,83        });84        return succeeded;85    }8687    fn rawRemap(88        context: *anyopaque,89        memory: []u8,90        alignment: Alignment,91        new_len: usize,92        return_address: usize,93    ) ?[*]u8 {94        const self: *ObservedAllocator = @ptrCast(@alignCast(context));95        var span = self.begin(96            .remap,97            @intFromPtr(memory.ptr),98            memory.len,99            new_len,100            alignment,101            return_address,102        );103        const result = self.backing.rawRemap(104            memory,105            alignment,106            new_len,107            return_address,108        );109        span.finish(.{110            .address = if (result) |ptr| @intFromPtr(ptr) else 0,111            .succeeded = result != null,112        });113        return result;114    }115116    fn rawFree(117        context: *anyopaque,118        memory: []u8,119        alignment: Alignment,120        return_address: usize,121    ) void {122        const self: *ObservedAllocator = @ptrCast(@alignCast(context));123        var span = self.begin(124            .free,125            @intFromPtr(memory.ptr),126            memory.len,127            0,128            alignment,129            return_address,130        );131        self.backing.rawFree(memory, alignment, return_address);132        span.finish(.{133            .address = @intFromPtr(memory.ptr),134            .succeeded = true,135        });136    }137138    fn begin(139        self: *ObservedAllocator,140        operation: protocol.Operation,141        old_address: usize,142        old_len: usize,143        len: usize,144        alignment: Alignment,145        return_address: usize,146    ) protocol.Span {147        return protocol.begin(148            self.producer_id,149            self.producer,150            operation,151            old_address,152            old_len,153            len,154            alignment.toByteUnits(),155            return_address,156        );157    }158159    const vtable: Allocator.VTable = .{160        .alloc = rawAlloc,161        .resize = rawResize,162        .remap = rawRemap,163        .free = rawFree,164    };165};

1/// A generic adapter wrapping a supplied backing allocator, instrumenting2/// allocation, resizing, remapping, and deallocation virtual table calls while3/// returning backing allocator outcomes unchanged. The adapter emits no4/// lifecycle records and enforces no independent memory reclamation policy.5/// Callers must keep both the adapter and its backing allocator at stable6/// memory addresses throughout use, and must ensure the installed sink can7/// handle concurrent invocations when the backing allocator is accessed across8/// multiple threads.9pub const ObservedAllocator = @import("allocator.zig").ObservedAllocator;