tiny.memtrace.Census

1pub const Census = struct {2    storage: *Storage,3    slots: []model.Slot,4    summary: []Entry,5    labels: []u8,6    joined_label: []u8,7    category_count: usize = 0,8    label_bytes_used: usize = 0,910    pub fn init(storage: *Storage) storage_mod.Exhaustion!Census {11        const regions = try storage.acquire();12        return .{13            .storage = storage,14            .slots = regions.slots,15            .summary = regions.summary,16            .labels = regions.labels,17            .joined_label = regions.joined_label,18        };19    }2021    pub fn deinit(self: *Census) void {22        const storage = self.storage;23        self.* = undefined;24        storage.release();25    }2627    pub fn record(self: *Census, label: []const u8, bytes: usize) Exhaustion!void {28        try self.recordCount(label, 1, bytes);29    }3031    pub fn recordPrefixed(32        self: *Census,33        prefix: []const u8,34        label: []const u8,35        bytes: usize,36    ) Exhaustion!void {37        try self.recordCountPrefixed(prefix, label, 1, bytes);38    }3940    pub fn recordCount(41        self: *Census,42        label: []const u8,43        count: usize,44        bytes: usize,45    ) Exhaustion!void {46        const hash = std.hash.Wyhash.hash(0, label);47        switch (self.locate(label, hash)) {48            .existing => |slot| {49                const next_items = std.math.add(usize, slot.entry.items, count) catch50                    return error.CensusCounterOverflow;51                const next_bytes = std.math.add(usize, slot.entry.bytes, bytes) catch52                    return error.CensusCounterOverflow;53                slot.entry.items = next_items;54                slot.entry.bytes = next_bytes;55            },56            .vacant => |slot| {57                if (self.category_count >= self.summary.len) return error.CategoryCapacityExceeded;58                if (label.len > self.labels.len - self.label_bytes_used) {59                    return error.LabelBytesCapacityExceeded;60                }61                const start = self.label_bytes_used;62                const end = start + label.len;63                const owned = self.labels[start..end];64                @memcpy(owned, label);65                slot.* = .{66                    .entry = .{67                        .label = owned,68                        .items = count,69                        .bytes = bytes,70                    },71                    .hash = hash,72                    .occupied = true,73                };74                self.label_bytes_used = end;75                self.category_count += 1;76            },77        }78    }7980    pub fn recordCountPrefixed(81        self: *Census,82        prefix: []const u8,83        label: []const u8,84        count: usize,85        bytes: usize,86    ) Exhaustion!void {87        if (prefix.len == 0) return try self.recordCount(label, count, bytes);88        const joined_len = std.math.add(usize, prefix.len, label.len) catch89            return error.JoinedLabelCapacityExceeded;90        if (joined_len > self.joined_label.len) return error.JoinedLabelCapacityExceeded;91        @memcpy(self.joined_label[0..prefix.len], prefix);92        @memcpy(self.joined_label[prefix.len..joined_len], label);93        try self.recordCount(self.joined_label[0..joined_len], count, bytes);94    }9596    pub fn writeSummary(97        self: *Census,98        writer: *std.Io.Writer,99        options: SummaryOptions,100    ) !void {101        var item_count: usize = 0;102        for (self.slots) |slot| {103            if (!slot.occupied or slot.entry.bytes < options.min_bytes) continue;104            std.debug.assert(item_count < self.summary.len);105            self.summary[item_count] = slot.entry;106            item_count += 1;107        }108        const items = self.summary[0..item_count];109        std.mem.sort(Entry, items, {}, entryGreaterThan);110111        try writer.print("memtrace census categories={d}\n", .{items.len});112        const limit = @min(options.top, items.len);113        for (items[0..limit]) |entry| {114            try writer.print(115                "{s} items={d} bytes={d}\n",116                .{ entry.label, entry.items, entry.bytes },117            );118        }119    }120121    pub fn writeJsonl(self: *const Census, writer: *std.Io.Writer) !void {122        var seq: u64 = 0;123        for (self.slots) |slot| {124            if (!slot.occupied) continue;125            seq = std.math.add(u64, seq, 1) catch return error.CensusCounterOverflow;126            var stream = pretty_json.Writer.init(writer, .minified);127            const object = try stream.object();128            try object.field("v", memtrace.event.format_version);129            try object.field("seq", seq);130            try object.field("kind", "census");131            try object.field("label", slot.entry.label);132            try object.field("items", slot.entry.items);133            try object.field("bytes", slot.entry.bytes);134            try object.endLine();135        }136    }137138    pub fn status(self: *const Census) Status {139        return .{140            .categories = self.category_count,141            .category_capacity = self.summary.len,142            .label_bytes_used = self.label_bytes_used,143            .label_bytes_capacity = self.labels.len,144            .joined_label_bytes_capacity = self.joined_label.len,145            .storage_bytes = self.storage.capacity.storage_bytes,146        };147    }148149    fn locate(self: *Census, label: []const u8, hash: u64) Lookup {150        std.debug.assert(self.slots.len >= 2);151        std.debug.assert(std.math.isPowerOfTwo(self.slots.len));152        const mask = self.slots.len - 1;153        const start = @as(usize, @truncate(hash)) & mask;154        for (0..self.slots.len) |probe| {155            const slot = &self.slots[(start +% probe) & mask];156            if (!slot.occupied) return .{ .vacant = slot };157            if (slot.hash == hash and std.mem.eql(u8, slot.entry.label, label)) {158                return .{ .existing = slot };159            }160        }161        unreachable;162    }163};

1pub const Census = census_mod.Census;