tiny.profiling.ingest.event

1const std = @import("std");2const profiling = @import("../root.zig");34pub const EventKind = enum(u8) {5    alloc,6    free,7    resize,8    remap,9    allocator,10    summary,11};1213pub const Field = enum(u8) {14    schema,15    event,16    kind,17    summary,18    sample_ns,19    mean_ns,20    median_ns,21    p95_ns,22    p99_ns,23    alloc_bytes,24    alloc_count,25    value,26    mean,27    median,28    allocated_bytes,29    retained_bytes,30    high_water_live_bytes,31    len,32    old_len,33    new_len,34    other,35};3637comptime {38    std.debug.assert(@typeInfo(EventKind).@"enum".field_names.len == 6);39    std.debug.assert(@typeInfo(Field).@"enum".field_names.len == 21);40    std.debug.assert(@sizeOf(EventKind) == 1);41    std.debug.assert(@sizeOf(Field) == 1);42    std.debug.assert(@typeInfo(Field).@"enum".field_names.len <= @bitSizeOf(u32));43}4445pub const Event = struct {46    schema_metric: bool = false,47    event_bench_end: bool = false,48    summary_memory: bool = false,49    sample_ns_array: bool = false,50    numeric_fields: u32 = 0,51    kind: ?EventKind = null,52    alloc_bytes: ?u64 = null,53    allocated_bytes: ?u64 = null,54    len: ?u64 = null,55    old_len: ?u64 = null,56    new_len: ?u64 = null,5758    pub fn clear(self: *Event, field: Field) void {59        std.debug.assert(@backingInt(field) < 21);60        self.numeric_fields &= ~fieldBit(field);61        switch (field) {62            .schema => self.schema_metric = false,63            .event => self.event_bench_end = false,64            .kind => self.kind = null,65            .summary => self.summary_memory = false,66            .sample_ns => self.sample_ns_array = false,67            .alloc_bytes => self.alloc_bytes = null,68            .allocated_bytes => self.allocated_bytes = null,69            .len => self.len = null,70            .old_len => self.old_len = null,71            .new_len => self.new_len = null,72            else => {},73        }74        switch (field) {75            .schema => std.debug.assert(!self.schema_metric),76            .event => std.debug.assert(!self.event_bench_end),77            .kind => std.debug.assert(self.kind == null),78            .summary => std.debug.assert(!self.summary_memory),79            .sample_ns => std.debug.assert(!self.sample_ns_array),80            else => {},81        }82        std.debug.assert(!self.hasNumber(field));83        std.debug.assert(fieldValue(self.*, field) == null);84    }8586    pub fn assignNumber(self: *Event, field: Field, bytes: []const u8) void {87        std.debug.assert(bytes.len > 0);88        self.numeric_fields |= fieldBit(field);89        const value = numberAsU64(bytes);90        switch (field) {91            .alloc_bytes => self.alloc_bytes = value,92            .allocated_bytes => self.allocated_bytes = value,93            .len => self.len = value,94            .old_len => self.old_len = value,95            .new_len => self.new_len = value,96            else => {},97        }98        switch (field) {99            .alloc_bytes => std.debug.assert(self.alloc_bytes == value),100            .allocated_bytes => std.debug.assert(self.allocated_bytes == value),101            .len => std.debug.assert(self.len == value),102            .old_len => std.debug.assert(self.old_len == value),103            .new_len => std.debug.assert(self.new_len == value),104            else => {},105        }106        std.debug.assert(self.hasNumber(field));107    }108109    pub fn assignArray(self: *Event, field: Field) void {110        if (field == .sample_ns) self.sample_ns_array = true;111        if (field == .sample_ns) std.debug.assert(self.sample_ns_array);112    }113114    pub fn hasNumber(self: Event, field: Field) bool {115        return self.numeric_fields & fieldBit(field) != 0;116    }117118    pub fn benchmarkAllocatedBytes(self: Event) ?u64 {119        const suite_bytes = self.alloc_bytes orelse return self.allocated_bytes;120        const metric_bytes = self.allocated_bytes orelse return suite_bytes;121        return @max(suite_bytes, metric_bytes);122    }123};124125pub fn record(totals: *profiling.allocation.Totals, value: Event) void {126    if (!isAllocation(value)) return;127    const kind = value.kind orelse return;128    const before = totals.*;129    totals.saw = true;130    switch (kind) {131        .alloc => {132            totals.allocation_events +|= 1;133            totals.allocated_bytes += value.len orelse 0;134        },135        .free => totals.free_events +|= 1,136        .resize => {137            totals.resize_events +|= 1;138            recordGrowth(totals, value);139        },140        .remap => {141            totals.remap_events +|= 1;142            recordGrowth(totals, value);143        },144        .allocator => {},145        .summary => unreachable,146    }147    std.debug.assert(totals.saw);148    std.debug.assert(totals.allocation_events >= before.allocation_events);149    std.debug.assert(totals.free_events >= before.free_events);150    std.debug.assert(totals.resize_events >= before.resize_events);151    std.debug.assert(totals.remap_events >= before.remap_events);152    std.debug.assert(totals.allocated_bytes >= before.allocated_bytes);153}154155fn isAllocation(value: Event) bool {156    if (value.schema_metric) return false;157    const legacy_timing = value.event_bench_end and value.sample_ns_array or158        value.kind == .summary and hasAnyNumber(value, &.{159            .mean_ns,160            .median_ns,161            .p95_ns,162            .p99_ns,163        });164    if (legacy_timing) return false;165    const legacy_memory = value.event_bench_end and hasAnyNumber(value, &.{166        .alloc_bytes,167        .alloc_count,168    }) or value.kind == .summary and value.summary_memory and hasAnyNumber(value, &.{169        .value,170        .mean,171        .median,172        .alloc_bytes,173        .alloc_count,174        .allocated_bytes,175        .retained_bytes,176        .high_water_live_bytes,177    });178    if (legacy_memory) return false;179    return switch (value.kind orelse return false) {180        .alloc, .free, .resize, .remap, .allocator => true,181        .summary => false,182    };183}184185fn hasAnyNumber(value: Event, fields: []const Field) bool {186    std.debug.assert(fields.len > 0);187    std.debug.assert(fields.len <= 8);188    for (fields) |field| {189        if (value.hasNumber(field)) return true;190    }191    return false;192}193194fn numberAsU64(bytes: []const u8) ?u64 {195    std.debug.assert(bytes.len > 0);196    if (std.mem.indexOfAny(u8, bytes, ".eE") == null) {197        return std.fmt.parseInt(u64, bytes, 10) catch null;198    }199    const value = std.fmt.parseFloat(f64, bytes) catch return null;200    if (!std.math.isFinite(value) or value < 0 or @floor(value) != value) return null;201    if (value >= 18_446_744_073_709_551_616.0) return null;202    return @intFromFloat(value);203}204205fn recordGrowth(totals: *profiling.allocation.Totals, value: Event) void {206    std.debug.assert(totals.saw);207    const new_len = value.new_len orelse return;208    const old_len = value.old_len orelse value.len orelse return;209    if (new_len <= old_len) return;210    totals.allocated_bytes += new_len - old_len;211}212213fn fieldValue(value: Event, field: Field) ?u64 {214    return switch (field) {215        .alloc_bytes => value.alloc_bytes,216        .allocated_bytes => value.allocated_bytes,217        .len => value.len,218        .old_len => value.old_len,219        .new_len => value.new_len,220        else => null,221    };222}223224fn fieldBit(field: Field) u32 {225    const shift: u5 = @intCast(@backingInt(field));226    return @as(u32, 1) << shift;227}

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