tiny.memtrace.AllocationLedger

1pub const AllocationLedger = struct {2    backing: Allocator,3    records: []Record,4    count: usize = 0,5    sequence: Sequence = 0,67    pub fn init(backing: Allocator, records: []Record) AllocationLedger {8        std.debug.assert(records.len != 0);9        return .{10            .backing = backing,11            .records = records,12        };13    }1415    pub fn allocator(self: *AllocationLedger) Allocator {16        return .{ .ptr = self, .vtable = &vtable };17    }1819    pub fn exhausted(self: *const AllocationLedger) bool {20        return self.count == self.records.len;21    }2223    pub fn allocationCount(self: *const AllocationLedger) usize {24        return self.count;25    }2627    pub fn allocation(28        self: *const AllocationLedger,29        id: usize,30    ) Record {31        std.debug.assert(id < self.count);32        return self.records[id];33    }3435    pub fn allocationContaining(36        self: *const AllocationLedger,37        pointer: anytype,38        len: usize,39    ) ?usize {40        const address = @intFromPtr(pointer);41        var index = self.count;42        while (index != 0) {43            index -= 1;44            if (rangeContains(self.records[index], address, len)) return index;45        }46        return null;47    }4849    pub fn liveAllocationContaining(50        self: *const AllocationLedger,51        pointer: anytype,52        len: usize,53    ) ?usize {54        const address = @intFromPtr(pointer);55        var index = self.count;56        while (index != 0) {57            index -= 1;58            const record = self.records[index];59            if (record.active and rangeContains(record, address, len)) {60                return index;61            }62        }63        return null;64    }6566    pub fn isActive(67        self: *const AllocationLedger,68        id: usize,69    ) bool {70        return self.allocation(id).active;71    }7273    pub fn freeSequence(74        self: *const AllocationLedger,75        id: usize,76    ) Sequence {77        const record = self.allocation(id);78        std.debug.assert(!record.active);79        return record.free_sequence;80    }8182    fn nextSequence(self: *AllocationLedger) Sequence {83        std.debug.assert(self.sequence != std.math.maxInt(Sequence));84        self.sequence += 1;85        return self.sequence;86    }8788    fn append(89        self: *AllocationLedger,90        pointer: [*]u8,91        len: usize,92        return_address: usize,93    ) void {94        std.debug.assert(self.count < self.records.len);95        self.records[self.count] = .{96            .address = @intFromPtr(pointer),97            .len = len,98            .allocation_sequence = self.nextSequence(),99            .allocation_return_address = return_address,100            .active = true,101        };102        self.count += 1;103    }104105    fn findActiveExact(106        self: *const AllocationLedger,107        pointer: [*]u8,108    ) usize {109        const address = @intFromPtr(pointer);110        var index = self.count;111        while (index != 0) {112            index -= 1;113            const record = self.records[index];114            if (record.active and record.address == address) return index;115        }116        unreachable;117    }118119    fn rawAlloc(120        context: *anyopaque,121        len: usize,122        alignment: std.mem.Alignment,123        return_address: usize,124    ) ?[*]u8 {125        const self: *AllocationLedger = @ptrCast(@alignCast(context));126        if (self.exhausted()) return null;127        const result = self.backing.rawAlloc(128            len,129            alignment,130            return_address,131        ) orelse return null;132        self.append(result, len, return_address);133        return result;134    }135136    fn rawResize(137        context: *anyopaque,138        memory: []u8,139        alignment: std.mem.Alignment,140        new_len: usize,141        return_address: usize,142    ) bool {143        const self: *AllocationLedger = @ptrCast(@alignCast(context));144        const resized = self.backing.rawResize(145            memory,146            alignment,147            new_len,148            return_address,149        );150        if (resized) {151            const id = self.findActiveExact(memory.ptr);152            _ = self.nextSequence();153            self.records[id].len = new_len;154            self.records[id].resize_return_address = return_address;155        }156        return resized;157    }158159    fn rawRemap(160        context: *anyopaque,161        memory: []u8,162        alignment: std.mem.Alignment,163        new_len: usize,164        return_address: usize,165    ) ?[*]u8 {166        const self: *AllocationLedger = @ptrCast(@alignCast(context));167        const id = self.findActiveExact(memory.ptr);168        const result = self.backing.rawRemap(169            memory,170            alignment,171            new_len,172            return_address,173        ) orelse return null;174        _ = self.nextSequence();175        self.records[id].address = @intFromPtr(result);176        self.records[id].len = new_len;177        self.records[id].remap_return_address = return_address;178        return result;179    }180181    fn rawFree(182        context: *anyopaque,183        memory: []u8,184        alignment: std.mem.Alignment,185        return_address: usize,186    ) void {187        const self: *AllocationLedger = @ptrCast(@alignCast(context));188        const id = self.findActiveExact(memory.ptr);189        self.backing.rawFree(memory, alignment, return_address);190        const sequence = self.nextSequence();191        self.records[id].active = false;192        self.records[id].free_sequence = sequence;193        self.records[id].free_return_address = return_address;194    }195196    const vtable: Allocator.VTable = .{197        .alloc = rawAlloc,198        .resize = rawResize,199        .remap = rawRemap,200        .free = rawFree,201    };202};

1pub const AllocationLedger = ledger_mod.AllocationLedger;