tiny.profiling.ingest.collection

1const std = @import("std");2const alloc_phase = @import("alloc_phase");3const sys = @import("sys");4const profiling = @import("../root.zig");5const ingest = @import("root.zig");67pub fn collect(8    allocator: std.mem.Allocator,9    workload: profiling.catalog.Workload,10    paths: ingest.Paths,11) !ingest.Summary {12    std.debug.assert(workload.name.len > 0);13    std.debug.assert(paths.structured.len > 0);14    const limits = try ingest.Limits.inspect(paths);15    var ingestion = try ingest.ArtifactIngestion.init(allocator, limits);16    defer ingestion.deinit(allocator);17    try ingestion.activate();18    return ingestion.write(workload);19}2021const OwnedPaths = struct {22    paths: ingest.Paths,2324    fn init(allocator: std.mem.Allocator, root: []const u8) !OwnedPaths {25        std.debug.assert(root.len > 0);26        const result = OwnedPaths{ .paths = .{27            .stdout = try std.fs.path.join(allocator, &.{ root, "stdout.txt" }),28            .stderr = try std.fs.path.join(allocator, &.{ root, "stderr.txt" }),29            .bench_jsonl = try std.fs.path.join(allocator, &.{ root, "bench.jsonl" }),30            .coz_jsonl = try std.fs.path.join(allocator, &.{ root, "coz.jsonl" }),31            .coz_analysis = try std.fs.path.join(allocator, &.{ root, "coz.analysis.json" }),32            .tracy_summary = try std.fs.path.join(allocator, &.{ root, "tracy.summary.jsonl" }),33            .allocations = try std.fs.path.join(allocator, &.{ root, "allocations.jsonl" }),34            .structured = try std.fs.path.join(allocator, &.{ root, "structured.jsonl" }),35        } };36        assertOwnedPaths(result.paths, root.len);37        return result;38    }3940    fn deinit(self: OwnedPaths, allocator: std.mem.Allocator) void {41        assertOwnedPaths(self.paths, 0);42        allocator.free(self.paths.stdout);43        allocator.free(self.paths.stderr);44        allocator.free(self.paths.bench_jsonl);45        allocator.free(self.paths.coz_jsonl);46        allocator.free(self.paths.coz_analysis);47        allocator.free(self.paths.tracy_summary);48        allocator.free(self.paths.allocations);49        allocator.free(self.paths.structured);50    }51};5253fn assertOwnedPaths(paths: ingest.Paths, minimum: usize) void {54    std.debug.assert(paths.stdout.len > minimum);55    std.debug.assert(paths.stderr.len > minimum);56    std.debug.assert(paths.bench_jsonl.len > minimum);57    std.debug.assert(paths.coz_jsonl.len > minimum);58    std.debug.assert(paths.coz_analysis.len > minimum);59    std.debug.assert(paths.tracy_summary.len > minimum);60    std.debug.assert(paths.allocations.len > minimum);61    std.debug.assert(paths.structured.len > minimum);62}6364const Fixture = struct {65    temporary: std.testing.TmpDir,66    root: [:0]u8,67    paths: OwnedPaths,68};6970fn testFixture(allocator: std.mem.Allocator) !Fixture {71    var temporary = std.testing.tmpDir(.{});72    errdefer temporary.cleanup();73    const root = try temporary.dir.realPathFileAlloc(sys.fs.debugIo(), ".", allocator);74    std.debug.assert(root.len > 0);75    errdefer allocator.free(root);76    const paths = try OwnedPaths.init(allocator, root);77    std.debug.assert(paths.paths.structured.len > root.len);78    return .{ .temporary = temporary, .root = root, .paths = paths };79}8081fn cleanupFixture(fixture: anytype, allocator: std.mem.Allocator) void {82    std.debug.assert(fixture.root.len > 0);83    fixture.paths.deinit(allocator);84    allocator.free(fixture.root);85    fixture.temporary.cleanup();86}8788fn initializeOwner(allocator: std.mem.Allocator, limits: ingest.Limits) !void {89    var ingestion = try ingest.ArtifactIngestion.init(allocator, limits);90    std.debug.assert(ingestion.phase == .initialization);91    defer ingestion.deinit(allocator);92    try ingestion.activate();93    std.debug.assert(ingestion.phase == .steady);94}9596test "profiling ingestion preserves structured rows and allocation counters" {97    const allocator = std.testing.allocator;98    var fixture = try testFixture(allocator);99    defer cleanupFixture(&fixture, allocator);100    const paths = fixture.paths.paths;101    try sys.fs.writeFile(102        paths.stdout,103        "human\n{\"event\":\"bench_end\",\"name\":\"a\",\"median_ns\":10}\n",104    );105    try sys.fs.writeFile(paths.stderr, "{\"broken\":}\n");106    try sys.fs.writeFile(paths.tracy_summary,107        \\{"kind":"zone","name":"bench.sample","count":1,"mean_ns":10}108        \\109    );110    try sys.fs.writeFile(paths.allocations,111        \\{"kind":"alloc","len":64}112        \\{"kind":"resize","old_len":64,"new_len":96}113        \\{"kind":"free","len":96}114        \\115    );116    const result = try collect(117        allocator,118        profiling.catalog.find("gpalloc.allocator").?,119        paths,120    );121    try std.testing.expectEqual(@as(usize, 7), result.rows);122    try std.testing.expectEqual(@as(usize, 1), result.parse_errors);123    try std.testing.expectEqual(@as(usize, 4), result.sources);124    const structured = try sys.fs.readFileAlloc(allocator, paths.structured, 4096);125    defer allocator.free(structured);126    try std.testing.expect(std.mem.indexOf(127        u8,128        structured,129        "\"schema\":\"tiny.profiling.structured/v1\"",130    ) != null);131    try std.testing.expect(std.mem.indexOf(132        u8,133        structured,134        "\"row\":{\"event\":\"bench_end\"",135    ) != null);136    try std.testing.expect(std.mem.indexOf(137        u8,138        structured,139        "\"metric\":\"allocated_bytes\"",140    ) != null);141    try std.testing.expect(std.mem.indexOf(142        u8,143        structured,144        "\"kind\":\"tracy_summary\"",145    ) != null);146    try std.testing.expect(std.mem.indexOf(147        u8,148        structured,149        "\"kind\":\"alloc\",\"len\"",150    ) == null);151}152153test "profiling ingestion retains a positive benchmark allocation witness" {154    const allocator = std.testing.allocator;155    var fixture = try testFixture(allocator);156    defer cleanupFixture(&fixture, allocator);157    const paths = fixture.paths.paths;158    try sys.fs.writeFile(159        paths.bench_jsonl,160        "{\"event\":\"bench_end\",\"sample_ns\":[1],\"alloc_bytes\":4096}\n" ++161            "{\"schema\":\"tiny.profiling.metric/v1\"," ++162            "\"allocated_bytes\":8192}\n",163    );164    try sys.fs.writeFile(165        paths.stdout,166        "{\"event\":\"bench_end\",\"sample_ns\":[1],\"alloc_bytes\":16384}\n",167    );168    const result = try collect(169        allocator,170        profiling.catalog.find("gpalloc.allocator").?,171        paths,172    );173    try std.testing.expectEqual(174        @as(?u64, 8_192),175        result.max_benchmark_allocated_bytes,176    );177}178179test "artifact ingestion rejects mutation before activation without touching output" {180    comptime {181        @stardustClaim(182            @import("alloc_phase").capacity.witness(@import("./root.zig").ArtifactIngestion, "profiling_ingestion_mutation"),183            null,184            null,185            null,186            null,187            null,188            null,189        );190    }191192    const allocator = std.testing.allocator;193    var fixture = try testFixture(allocator);194    defer cleanupFixture(&fixture, allocator);195    const paths = fixture.paths.paths;196    try sys.fs.writeFile(paths.stdout, "{}\n");197    try sys.fs.writeFile(paths.structured, "preserve");198    const limits = try ingest.Limits.inspect(paths);199    var ingestion = try ingest.ArtifactIngestion.init(allocator, limits);200    defer ingestion.deinit(allocator);201    try sys.fs.writeFile(paths.stdout, "{\"changed\":true}\n");202    try std.testing.expectError(error.InputChanged, ingestion.activate());203    const structured = try sys.fs.readFileAlloc(allocator, paths.structured, 64);204    defer allocator.free(structured);205    try std.testing.expectEqualStrings("preserve", structured);206}207208test "artifact ingestion rejects max plus one during steady rescan without replacing output" {209    comptime {210        @stardustClaim(211            @import("alloc_phase").capacity.witness(@import("./root.zig").ArtifactIngestion, "profiling_ingestion_max_plus_one"),212            null,213            null,214            null,215            null,216            null,217            null,218        );219    }220221    const allocator = std.testing.allocator;222    var fixture = try testFixture(allocator);223    defer cleanupFixture(&fixture, allocator);224    const paths = fixture.paths.paths;225    try sys.fs.writeFile(paths.stdout, "{}\n");226    try sys.fs.writeFile(paths.structured, "preserve");227    const limits = try ingest.Limits.inspect(paths);228    var ingestion = try ingest.ArtifactIngestion.init(allocator, limits);229    defer ingestion.deinit(allocator);230    try ingestion.activate();231    try sys.fs.writeFile(paths.stdout, "{}\r\n");232    try std.testing.expectError(233        error.InputChanged,234        ingestion.write(profiling.catalog.find("gpalloc.allocator").?),235    );236    const structured = try sys.fs.readFileAlloc(allocator, paths.structured, 64);237    defer allocator.free(structured);238    try std.testing.expectEqualStrings("preserve", structured);239}240241test "artifact ingestion acquires exact storage before a sealed steady write" {242    comptime {243        @stardustClaim(244            @import("alloc_phase").capacity.witness(@import("./root.zig").ArtifactIngestion, "profiling_ingestion_sealed_transitive_risk"),245            null,246            null,247            null,248            null,249            null,250            null,251        );252    }253    comptime {254        @stardustClaim(255            @import("alloc_phase").capacity.witness(@import("./root.zig").ArtifactIngestion, "profiling_ingestion_sealed_foreign_risk"),256            null,257            null,258            null,259            null,260            null,261            null,262        );263    }264265    const allocator = std.testing.allocator;266    var fixture = try testFixture(allocator);267    defer cleanupFixture(&fixture, allocator);268    const paths = fixture.paths.paths;269    try sys.fs.writeFile(paths.stdout, "{}\n");270    const limits = try ingest.Limits.inspect(paths);271    const capacity = try ingest.Capacity.derive(limits);272273    var phase_allocator = try alloc_phase.SealedPhaseAllocator.init(allocator);274    var ingestion = try ingest.ArtifactIngestion.init(275        phase_allocator.initializationAllocator(),276        limits,277    );278    try std.testing.expectEqual(capacity.working_bytes, ingestion.capacity.working_bytes);279    const line_pointer = ingestion.line_storage.ptr;280    const row_pointer = ingestion.row_bits.ptr;281    const scratch_pointer = ingestion.scratch_storage.ptr;282    phase_allocator.seal();283    try ingestion.activate();284    const result = try ingestion.write(profiling.catalog.find("gpalloc.allocator").?);285    try std.testing.expectEqual(@as(usize, 1), result.rows);286    try std.testing.expectEqual(line_pointer, ingestion.line_storage.ptr);287    try std.testing.expectEqual(row_pointer, ingestion.row_bits.ptr);288    try std.testing.expectEqual(scratch_pointer, ingestion.scratch_storage.ptr);289    try std.testing.expectEqual(capacity.line_bytes, ingestion.line_storage.len);290    try std.testing.expectEqual(capacity.row_bit_bytes, ingestion.row_bits.len);291    try std.testing.expectEqual(capacity.scratch_bytes, ingestion.scratch_storage.len);292    try std.testing.expectEqual(293        alloc_phase.PhaseViolations{},294        phase_allocator.violations(),295    );296    phase_allocator.beginTeardown();297    ingestion.deinit(phase_allocator.teardownAllocator());298    try std.testing.expectEqual(alloc_phase.capacity.Phase.teardown, ingestion.phase);299    try std.testing.expectEqual(300        alloc_phase.PhaseViolations{},301        phase_allocator.violations(),302    );303    phase_allocator.deinit();304}305306test "artifact ingestion reports cold zero capacity and survives every initialization OOM" {307    comptime {308        @stardustClaim(309            @import("alloc_phase").capacity.witness(@import("./root.zig").ArtifactIngestion, "profiling_ingestion_oom_retry"),310            null,311            null,312            null,313            null,314            null,315            null,316        );317    }318319    const allocator = std.testing.allocator;320    var fixture = try testFixture(allocator);321    defer cleanupFixture(&fixture, allocator);322    const paths = fixture.paths.paths;323    const cold_limits = try ingest.Limits.inspect(paths);324    const cold_capacity = try ingest.Capacity.derive(cold_limits);325    try std.testing.expectEqual(@as(usize, 0), cold_capacity.working_bytes);326    const cold = try collect(327        allocator,328        profiling.catalog.find("gpalloc.allocator").?,329        paths,330    );331    try std.testing.expectEqual(ingest.Summary{ .rows = 0, .parse_errors = 0, .sources = 0 }, cold);332333    try sys.fs.writeFile(paths.stdout, "{\"payload\":\"0123456789abcdef\"}\n");334    try sys.fs.writeFile(paths.structured, "preserve");335    const limits = try ingest.Limits.inspect(paths);336    try std.testing.checkAllAllocationFailures(337        allocator,338        initializeOwner,339        .{limits},340    );341    var retry = try ingest.ArtifactIngestion.init(allocator, limits);342    defer retry.deinit(allocator);343    try retry.activate();344    try std.testing.expectEqual(345        (try ingest.Capacity.derive(limits)).working_bytes,346        retry.capacity.working_bytes,347    );348    const structured = try sys.fs.readFileAlloc(allocator, paths.structured, 64);349    defer allocator.free(structured);350    try std.testing.expectEqualStrings("preserve", structured);351}

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