tiny.profiling.record

1const std = @import("std");2const builtin = @import("builtin");3const capture = @import("capture");4const pretty = @import("pretty");5const sys = @import("sys");67const catalog = @import("root.zig").catalog;8const environment = @import("root.zig").environment;9const execute = @import("root.zig").execute;10const host = @import("root.zig").host;11const json_util = @import("root.zig").json;12const order = @import("root.zig").order;13const plan = @import("root.zig").plan;14const perturbation = @import("root.zig").perturbation;15const reducer = @import("root.zig").reduction;1617const pretty_json = pretty.json;1819pub const run_schema = "tiny.profiling.run/v1";20pub const workload_schema = "tiny.profiling.workload/v4";21pub const default_output_dir = "zig-out/profiling";22pub const retention_policy = "local-kept-until-cleaned-ci-14-days";23pub const maximum_reset_receipts: usize = host.process.max_executions * 2;2425pub const Metadata = struct {26    run_id: []const u8,27    artifact_root: []const u8,28    suite: catalog.Suite,29    filters: []const []const u8,30    workload_count: usize,31    started_unix_ns: i128,32    git_sha: ?[]const u8,33    git_branch: ?[]const u8,34    git_dirty: ?bool,35    zig_version: []const u8,36    host: environment.Host,37    host_state_start: host.state.Snapshot = .{},38    optimize: std.builtin.OptimizeMode,39};4041pub const Paths = struct {42    root: []const u8,43    manifest: []const u8,44    results: []const u8,45    workloads: []const u8,46};4748pub const WorkloadPaths = struct {49    root: []const u8,50    command: []const u8,51    result: []const u8,52    stdout: []const u8,53    stderr: []const u8,54    setup_stdout: []const u8,55    setup_stderr: []const u8,56    prepare_stdout: []const u8,57    prepare_stderr: []const u8,58    bench_jsonl: []const u8,59    coz_jsonl: []const u8,60    coz_analysis: []const u8,61    tracy_jsonl: []const u8,62    tracy_summary: []const u8,63    allocations: []const u8,64    allocations_summary: []const u8,65    allocation_repetitions: []const u8,66    structured: []const u8,67    warmup: WarmupPaths,68};6970pub const ExecutionPaths = struct {71    root: []const u8,72    stdout: []const u8,73    stderr: []const u8,74    bench_jsonl: []const u8,75    coz_jsonl: []const u8,76    coz_analysis: []const u8,77    tracy_jsonl: []const u8,78    tracy_summary: []const u8,79    allocations: []const u8,80    structured: []const u8,81};8283pub const MeasuredExecution = struct {84    index: usize,85    result: execute.Result,86    paths: ?ExecutionPaths,87    acquisition_position: ?usize = null,88    structured_rows: usize = 0,89    structured_parse_errors: usize = 0,90};9192pub const WarmupPaths = struct {93    root: []const u8,94    stdout: []const u8,95    stderr: []const u8,96    bench_jsonl: []const u8,97    coz_jsonl: []const u8,98    coz_analysis: []const u8,99    tracy_jsonl: []const u8,100    tracy_summary: []const u8,101    allocations: []const u8,102};103104pub const Setup = struct {105    command: []const u8,106    pid: ?u64,107    exit_code: i64,108    wall_ns: u64,109    stdout_path: []const u8,110    stderr_path: []const u8,111};112113pub const ResetPhase = enum {114    warmup,115    measurement,116    counter,117    capture,118    capture_control,119};120121pub const ResetPaths = struct {122    stdout: []const u8,123    stderr: []const u8,124};125126pub const Reset = struct {127    sequence: usize,128    phase: ResetPhase,129    phase_index: usize,130    command: execute.CommandResult,131};132133pub const Workload = struct {134    index: usize,135    acquisition: order.Context,136    workload: catalog.Workload,137    runtime: catalog.Runtime,138    argv: []const []const u8,139    command: []const u8,140    cwd: ?[]const u8 = null,141    scope: []const u8 = host.scope,142    causal: bool = false,143    tracy: bool = false,144    trace_allocations: bool = false,145    bench_min_time_ns: ?u64 = null,146    causal_filter: ?[]const u8 = null,147    setup: ?Setup = null,148    prepare: ?execute.CommandResult = null,149    artifact_root: []const u8,150    command_path: []const u8,151    result_path: []const u8,152    stdout_path: []const u8,153    stderr_path: []const u8,154    bench_jsonl_path: []const u8,155    coz_jsonl_path: []const u8,156    coz_analysis_path: []const u8,157    tracy_jsonl_path: []const u8,158    tracy_summary_path: []const u8,159    allocations_path: []const u8,160    allocation_repetitions_path: []const u8,161    structured_path: []const u8,162    structured_rows: usize,163    structured_parse_errors: usize,164    started_unix_ns: i128,165    finished_unix_ns: i128,166    execution: execute.Result,167    executions: []const MeasuredExecution = &.{},168    benchmark_process_domain: reducer.DomainDeclaration,169    benchmark_process_reduction: reducer.Result,170    host_state_windows: []const host.state.Window = &.{},171    warmup_executions: []const execute.Result = &.{},172    warmup_paths: ?WarmupPaths = null,173    resets: []const Reset = &.{},174    perturbation: ?perturbation.Measurement = null,175    captures: []const host.Capture = &.{},176};177178pub const Summary = struct {179    selected: usize,180    ran: usize,181    passed: usize,182    failed: usize,183    stopped_early: bool,184    exit_code: u8,185    started_unix_ns: i128,186    finished_unix_ns: i128,187    wall_ns: u64,188};189190pub fn defaultRunId(allocator: std.mem.Allocator, process_io: std.Io) ![]const u8 {191    return try prefixedRunId(allocator, process_io, "run");192}193194pub fn prefixedRunId(allocator: std.mem.Allocator, process_io: std.Io, prefix: []const u8) ![]const u8 {195    const millis = sys.time.realMilliTimestamp();196    if (try gitCapture(allocator, process_io, &.{ "git", "rev-parse", "--short=12", "HEAD" })) |sha| {197        return try std.fmt.allocPrint(allocator, "{s}-{d}-{s}", .{ prefix, millis, sha });198    }199    return try std.fmt.allocPrint(allocator, "{s}-{d}", .{ prefix, millis });200}201202pub fn makePaths(allocator: std.mem.Allocator, output_dir: []const u8, run_id: []const u8) !Paths {203    const root = try std.fs.path.join(allocator, &.{ output_dir, run_id });204    return .{205        .root = root,206        .manifest = try std.fs.path.join(allocator, &.{ root, "manifest.json" }),207        .results = try std.fs.path.join(allocator, &.{ root, "results.jsonl" }),208        .workloads = try std.fs.path.join(allocator, &.{ root, "workloads" }),209    };210}211212pub fn collectMetadata(213    allocator: std.mem.Allocator,214    process_io: std.Io,215    paths: Paths,216    selection: plan.Selection,217    optimize: std.builtin.OptimizeMode,218) !Metadata {219    return .{220        .run_id = std.fs.path.basename(paths.root),221        .artifact_root = paths.root,222        .suite = selection.suite,223        .filters = selection.filters,224        .workload_count = selection.count(),225        .started_unix_ns = sys.time.realNanoTimestamp(),226        .git_sha = try gitCapture(allocator, process_io, &.{ "git", "rev-parse", "HEAD" }),227        .git_branch = try gitCapture(allocator, process_io, &.{ "git", "branch", "--show-current" }),228        .git_dirty = try gitDirty(allocator, process_io),229        .zig_version = builtin.zig_version_string,230        .host = try environment.collect(allocator, process_io),231        .host_state_start = host.state.capture(),232        .optimize = optimize,233    };234}235236pub fn init(allocator: std.mem.Allocator, paths: Paths, metadata: Metadata) !void {237    try sys.fs.createDirPath(paths.workloads);238    try appendRunStart(allocator, paths, metadata);239}240241pub fn workloadPaths(allocator: std.mem.Allocator, paths: Paths, name: []const u8) !WorkloadPaths {242    const segment = try sanitizeSegment(allocator, name);243    const root = try std.fs.path.join(allocator, &.{ paths.workloads, segment });244    const warmup_root = try std.fs.path.join(allocator, &.{ root, "warmup" });245    return .{246        .root = root,247        .command = try std.fs.path.join(allocator, &.{ root, "command.json" }),248        .result = try std.fs.path.join(allocator, &.{ root, "result.json" }),249        .stdout = try std.fs.path.join(allocator, &.{ root, "stdout.txt" }),250        .stderr = try std.fs.path.join(allocator, &.{ root, "stderr.txt" }),251        .setup_stdout = try std.fs.path.join(allocator, &.{ root, "setup.stdout.txt" }),252        .setup_stderr = try std.fs.path.join(allocator, &.{ root, "setup.stderr.txt" }),253        .prepare_stdout = try std.fs.path.join(allocator, &.{ root, "prepare.stdout.txt" }),254        .prepare_stderr = try std.fs.path.join(allocator, &.{ root, "prepare.stderr.txt" }),255        .bench_jsonl = try std.fs.path.join(allocator, &.{ root, "bench.jsonl" }),256        .coz_jsonl = try std.fs.path.join(allocator, &.{ root, "bench.coz.jsonl" }),257        .coz_analysis = try std.fs.path.join(allocator, &.{ root, "bench.coz.analysis.json" }),258        .tracy_jsonl = try std.fs.path.join(allocator, &.{ root, "bench.tracy.jsonl" }),259        .tracy_summary = try std.fs.path.join(allocator, &.{ root, "bench.tracy.summary.jsonl" }),260        .allocations = try std.fs.path.join(allocator, &.{ root, "allocations.jsonl" }),261        .allocations_summary = try std.fs.path.join(262            allocator,263            &.{ root, "allocations.summary.jsonl" },264        ),265        .allocation_repetitions = try std.fs.path.join(266            allocator,267            &.{ root, "allocations.repetitions.jsonl" },268        ),269        .structured = try std.fs.path.join(allocator, &.{ root, "structured.jsonl" }),270        .warmup = .{271            .root = warmup_root,272            .stdout = try std.fs.path.join(allocator, &.{ warmup_root, "stdout.txt" }),273            .stderr = try std.fs.path.join(allocator, &.{ warmup_root, "stderr.txt" }),274            .bench_jsonl = try std.fs.path.join(allocator, &.{ warmup_root, "bench.jsonl" }),275            .coz_jsonl = try std.fs.path.join(allocator, &.{ warmup_root, "bench.coz.jsonl" }),276            .coz_analysis = try std.fs.path.join(allocator, &.{ warmup_root, "bench.coz.analysis.json" }),277            .tracy_jsonl = try std.fs.path.join(allocator, &.{ warmup_root, "bench.tracy.jsonl" }),278            .tracy_summary = try std.fs.path.join(allocator, &.{ warmup_root, "bench.tracy.summary.jsonl" }),279            .allocations = try std.fs.path.join(allocator, &.{ warmup_root, "allocations.jsonl" }),280        },281    };282}283284pub fn makeWorkloadPaths(allocator: std.mem.Allocator, paths: Paths, name: []const u8) !WorkloadPaths {285    const result = try workloadPaths(allocator, paths, name);286    try sys.fs.createDirPath(result.root);287    return result;288}289290pub fn executionPaths(291    allocator: std.mem.Allocator,292    workload_paths: WorkloadPaths,293    execution_count: usize,294    execution_index: usize,295) !ExecutionPaths {296    if (execution_count == 0 or execution_count > host.process.max_executions) {297        return error.InvalidExecutionArtifactCount;298    }299    if (execution_index == 0 or execution_index > execution_count) {300        return error.InvalidExecutionArtifactIndex;301    }302    if (execution_count == 1) return rootExecutionPaths(workload_paths);303    const segment = try std.fmt.allocPrint(allocator, "{d:0>3}", .{execution_index});304    defer allocator.free(segment);305    const root = try std.fs.path.join(306        allocator,307        &.{ workload_paths.root, "executions", segment },308    );309    return try pathsAtRoot(allocator, root);310}311312fn rootExecutionPaths(paths: WorkloadPaths) ExecutionPaths {313    return .{314        .root = paths.root,315        .stdout = paths.stdout,316        .stderr = paths.stderr,317        .bench_jsonl = paths.bench_jsonl,318        .coz_jsonl = paths.coz_jsonl,319        .coz_analysis = paths.coz_analysis,320        .tracy_jsonl = paths.tracy_jsonl,321        .tracy_summary = paths.tracy_summary,322        .allocations = paths.allocations,323        .structured = paths.structured,324    };325}326327fn pathsAtRoot(328    allocator: std.mem.Allocator,329    root: []const u8,330) !ExecutionPaths {331    return .{332        .root = root,333        .stdout = try std.fs.path.join(allocator, &.{ root, "stdout.txt" }),334        .stderr = try std.fs.path.join(allocator, &.{ root, "stderr.txt" }),335        .bench_jsonl = try std.fs.path.join(allocator, &.{ root, "bench.jsonl" }),336        .coz_jsonl = try std.fs.path.join(allocator, &.{ root, "bench.coz.jsonl" }),337        .coz_analysis = try std.fs.path.join(338            allocator,339            &.{ root, "bench.coz.analysis.json" },340        ),341        .tracy_jsonl = try std.fs.path.join(allocator, &.{ root, "bench.tracy.jsonl" }),342        .tracy_summary = try std.fs.path.join(343            allocator,344            &.{ root, "bench.tracy.summary.jsonl" },345        ),346        .allocations = try std.fs.path.join(allocator, &.{ root, "allocations.jsonl" }),347        .structured = try std.fs.path.join(allocator, &.{ root, "structured.jsonl" }),348    };349}350351pub fn resetPaths(352    allocator: std.mem.Allocator,353    workload_root: []const u8,354    sequence: usize,355    phase: ResetPhase,356    phase_index: usize,357) !ResetPaths {358    std.debug.assert(workload_root.len > 0);359    std.debug.assert(sequence > 0);360    std.debug.assert(sequence <= maximum_reset_receipts);361    std.debug.assert(phase_index > 0);362    const root = try std.fs.path.join(allocator, &.{ workload_root, "resets" });363    try sys.fs.createDirPath(root);364    const prefix = try std.fmt.allocPrint(365        allocator,366        "{d:0>3}-{s}-{d:0>3}",367        .{ sequence, @tagName(phase), phase_index },368    );369    return .{370        .stdout = try std.fs.path.join(371            allocator,372            &.{ root, try std.fmt.allocPrint(allocator, "{s}.stdout.txt", .{prefix}) },373        ),374        .stderr = try std.fs.path.join(375            allocator,376            &.{ root, try std.fmt.allocPrint(allocator, "{s}.stderr.txt", .{prefix}) },377        ),378    };379}380381pub fn appendWorkload(allocator: std.mem.Allocator, paths: Paths, metadata: Metadata, value: Workload) !void {382    const line = try renderJsonLine(allocator, writeWorkloadJson, .{ metadata, value });383    defer allocator.free(line);384    try sys.fs.appendFile(paths.results, &.{line});385386    const result_json = try renderJsonDocument(allocator, writeWorkloadJson, .{ metadata, value });387    defer allocator.free(result_json);388    try sys.fs.writeFile(value.result_path, result_json);389390    const command_json = try renderJsonDocument(allocator, writeCommandJson, .{value});391    defer allocator.free(command_json);392    try sys.fs.writeFile(value.command_path, command_json);393}394395pub fn finish(allocator: std.mem.Allocator, paths: Paths, metadata: Metadata, summary: Summary) !void {396    const line = try renderJsonLine(allocator, writeRunEndJson, .{ metadata, summary });397    defer allocator.free(line);398    try sys.fs.appendFile(paths.results, &.{line});399400    const manifest = try renderJsonDocument(allocator, writeManifestJson, .{ metadata, summary, paths });401    defer allocator.free(manifest);402    try sys.fs.writeFile(paths.manifest, manifest);403}404405fn appendRunStart(allocator: std.mem.Allocator, paths: Paths, metadata: Metadata) !void {406    const line = try renderJsonLine(allocator, writeRunStartJson, .{metadata});407    defer allocator.free(line);408    try sys.fs.writeFile(paths.results, line);409}410411fn renderJsonLine(412    allocator: std.mem.Allocator,413    comptime writer_fn: anytype,414    args: anytype,415) ![]const u8 {416    var out: std.Io.Writer.Allocating = .init(allocator);417    errdefer out.deinit();418    var json = pretty_json.Writer.init(&out.writer, .minified);419    try @call(.auto, writer_fn, .{&json} ++ args);420    try out.writer.writeByte('\n');421    return try out.toOwnedSlice();422}423424fn renderJsonDocument(425    allocator: std.mem.Allocator,426    comptime writer_fn: anytype,427    args: anytype,428) ![]const u8 {429    var out: std.Io.Writer.Allocating = .init(allocator);430    errdefer out.deinit();431    var json = pretty_json.Writer.init(&out.writer, .minified);432    try @call(.auto, writer_fn, .{&json} ++ args);433    try out.writer.writeByte('\n');434    return try out.toOwnedSlice();435}436437fn writeRunStartJson(out: *pretty_json.Writer, metadata: Metadata) !void {438    try out.beginObject();439    try writeRunHeader(out, metadata, "run_start");440    try out.objectField("selection");441    try writeSelectionJson(out, metadata);442    try out.objectField("environment");443    try writeEnvironmentJson(out, metadata);444    try out.objectField("artifacts");445    try out.beginObject();446    try out.objectField("root");447    try out.write(metadata.artifact_root);448    try out.objectField("results");449    try out.write("results.jsonl");450    try out.objectField("manifest");451    try out.write("manifest.json");452    try out.objectField("retention");453    try writeRetentionJson(out);454    try out.endObject();455    try out.endObject();456}457458fn writeRunEndJson(out: *pretty_json.Writer, metadata: Metadata, summary: Summary) !void {459    try out.beginObject();460    try writeRunHeader(out, metadata, "run_end");461    try out.objectField("summary");462    try writeSummaryJson(out, summary);463    try out.endObject();464}465466fn writeManifestJson(out: *pretty_json.Writer, metadata: Metadata, summary: Summary, paths: Paths) !void {467    try out.beginObject();468    try writeRunHeader(out, metadata, "manifest");469    try out.objectField("selection");470    try writeSelectionJson(out, metadata);471    try out.objectField("environment");472    try writeEnvironmentJson(out, metadata);473    try out.objectField("summary");474    try writeSummaryJson(out, summary);475    try out.objectField("artifacts");476    try out.beginObject();477    try out.objectField("root");478    try out.write(paths.root);479    try out.objectField("results");480    try out.write(paths.results);481    try out.objectField("manifest");482    try out.write(paths.manifest);483    try out.objectField("workloads");484    try out.write(paths.workloads);485    try out.objectField("retention");486    try writeRetentionJson(out);487    try out.endObject();488    try out.endObject();489}490491fn writeRetentionJson(out: *pretty_json.Writer) !void {492    try out.beginObject();493    try out.objectField("policy");494    try out.write(retention_policy);495    try out.objectField("local");496    try out.write("kept under zig-out/profiling until cleaned by the developer or workspace");497    try out.objectField("ci_upload");498    try out.write("uploaded as the profiling workflow artifact with 14 day retention");499    try out.endObject();500}501502fn writeRunHeader(out: *pretty_json.Writer, metadata: Metadata, event: []const u8) !void {503    try out.objectField("schema");504    try out.write(run_schema);505    try out.objectField("event");506    try out.write(event);507    try out.objectField("run_id");508    try out.write(metadata.run_id);509    try out.objectField("started_unix_ns");510    try out.write(metadata.started_unix_ns);511}512513fn writeSelectionJson(out: *pretty_json.Writer, metadata: Metadata) !void {514    try out.beginObject();515    try out.objectField("suite");516    try out.write(metadata.suite.name());517    try out.objectField("filters");518    try out.beginArray();519    for (metadata.filters) |filter| try out.write(filter);520    try out.endArray();521    try out.objectField("workload_count");522    try out.write(metadata.workload_count);523    try out.endObject();524}525526fn writeEnvironmentJson(out: *pretty_json.Writer, metadata: Metadata) !void {527    try out.beginObject();528    try out.objectField("git");529    try out.beginObject();530    try out.objectField("commit");531    try out.write(metadata.git_sha);532    try out.objectField("branch");533    try out.write(metadata.git_branch);534    try out.objectField("dirty");535    try out.write(metadata.git_dirty);536    try out.endObject();537    try out.objectField("zig");538    try out.beginObject();539    try out.objectField("version");540    try out.write(metadata.zig_version);541    try out.endObject();542    try out.objectField("build");543    try out.beginObject();544    try out.objectField("optimize");545    try out.write(optimizeName(metadata.optimize));546    try out.endObject();547    try out.objectField("host");548    try environment.writeJson(out, metadata.host);549    try out.objectField("host_state_start");550    try host.state.writeJson(out, metadata.host_state_start);551    try out.endObject();552}553554fn optimizeName(optimize: std.builtin.OptimizeMode) []const u8 {555    return switch (optimize) {556        .debug => "Debug",557        .safe => "ReleaseSafe",558        .fast => "ReleaseFast",559        .small => "ReleaseSmall",560    };561}562563fn writeSummaryJson(out: *pretty_json.Writer, summary: Summary) !void {564    try out.beginObject();565    try out.objectField("selected");566    try out.write(summary.selected);567    try out.objectField("ran");568    try out.write(summary.ran);569    try out.objectField("passed");570    try out.write(summary.passed);571    try out.objectField("failed");572    try out.write(summary.failed);573    try out.objectField("stopped_early");574    try out.write(summary.stopped_early);575    try out.objectField("exit_code");576    try out.write(summary.exit_code);577    try out.objectField("started_unix_ns");578    try out.write(summary.started_unix_ns);579    try out.objectField("finished_unix_ns");580    try out.write(summary.finished_unix_ns);581    try out.objectField("wall_ns");582    try out.write(summary.wall_ns);583    try out.endObject();584}585586fn writeWorkloadJson(out: *pretty_json.Writer, metadata: Metadata, value: Workload) !void {587    try out.beginObject();588    try out.objectField("schema");589    try out.write(workload_schema);590    try out.objectField("event");591    try out.write("workload");592    try out.objectField("run_id");593    try out.write(metadata.run_id);594    try out.objectField("index");595    try out.write(value.index);596    try out.objectField("acquisition");597    try order.writeJson(out, value.acquisition);598    try out.objectField("workload");599    try writeCatalogWorkloadJson(out, value.workload);600    try out.objectField("runtime");601    try writeRuntimeJson(out, value.runtime);602    try out.objectField("command");603    try writeCommandJson(out, value);604    try writeWorkloadConfigurationFields(out, value);605    try out.objectField("setup");606    try writeSetupJson(out, value.setup);607    try out.objectField("prepare");608    try writePrepareJson(out, value.prepare);609    try out.objectField("status");610    try writeStatusJson(out, value.execution);611    try out.objectField("timing");612    try writeTimingJson(out, value);613    try out.objectField("resources");614    try out.beginObject();615    try writeResourceUsageFields(out, value.execution);616    try out.endObject();617    try out.objectField("measurement");618    try writeMeasurementJson(619        out,620        value.executions,621        value.acquisition,622        value.trace_allocations,623        value.artifact_root,624        value.benchmark_process_domain,625        value.benchmark_process_reduction,626    );627    try out.objectField("host_state");628    try host.state.writeWindowsJson(out, value.host_state_windows);629    try out.objectField("warmup");630    try writeWarmupJson(out, value.warmup_executions, value.warmup_paths);631    try out.objectField("resets");632    try writeResetsJson(out, value.resets);633    try out.objectField("capture_perturbation");634    try writeCapturePerturbationJson(out, value.perturbation);635    try out.objectField("artifacts");636    try writeArtifactsJson(out, value);637    try out.objectField("captures");638    try writeCapturesJson(out, value.captures);639    try out.endObject();640}641642fn writeWorkloadConfigurationFields(out: *pretty_json.Writer, value: Workload) !void {643    try out.objectField("scope");644    try out.write(value.scope);645    try out.objectField("causal");646    try out.write(value.causal);647    try out.objectField("tracy");648    try out.write(value.tracy);649    try out.objectField("trace_allocations");650    try out.write(value.trace_allocations);651    if (value.bench_min_time_ns) |min_time_ns| {652        try out.objectField("bench_min_time_ns");653        try out.write(min_time_ns);654    }655    if (value.causal_filter) |filter| {656        try out.objectField("causal_filter");657        try out.write(filter);658    }659}660661fn writeSetupJson(out: *pretty_json.Writer, setup: ?Setup) !void {662    if (setup) |actual| {663        try out.beginObject();664        try out.objectField("command");665        try out.write(actual.command);666        try out.objectField("pid");667        try out.write(actual.pid);668        try out.objectField("exit_code");669        try out.write(actual.exit_code);670        try out.objectField("wall_ns");671        try out.write(actual.wall_ns);672        try out.objectField("stdout");673        try out.write(actual.stdout_path);674        try out.objectField("stderr");675        try out.write(actual.stderr_path);676        try out.endObject();677    } else {678        try out.write(null);679    }680}681682fn writePrepareJson(683    out: *pretty_json.Writer,684    prepare: ?execute.CommandResult,685) !void {686    const actual = prepare orelse {687        try out.write(null);688        return;689    };690    try out.beginObject();691    try out.objectField("policy");692    try out.write("once_after_successful_build_setup_before_acquisitions");693    try out.objectField("timing");694    try out.write("outside_measured_child_wait");695    try writeRecordedCommandFields(out, actual);696    try out.endObject();697}698699fn writeStatusJson(out: *pretty_json.Writer, result: execute.Result) !void {700    try out.beginObject();701    try out.objectField("state");702    try out.write(if (result.exit_code == 0) "passed" else "failed");703    try out.objectField("pid");704    try out.write(result.pid);705    try out.objectField("exit_code");706    try out.write(result.exit_code);707    try out.endObject();708}709710fn writeTimingJson(out: *pretty_json.Writer, value: Workload) !void {711    try out.beginObject();712    try out.objectField("started_unix_ns");713    try out.write(value.started_unix_ns);714    try out.objectField("finished_unix_ns");715    try out.write(value.finished_unix_ns);716    try out.objectField("wall_ns");717    try out.write(value.execution.wall_ns);718    try out.endObject();719}720721fn writeArtifactsJson(out: *pretty_json.Writer, value: Workload) !void {722    try out.beginObject();723    try out.objectField("root");724    try out.write(value.artifact_root);725    try out.objectField("command");726    try out.write(value.command_path);727    try out.objectField("result");728    try out.write(value.result_path);729    try out.objectField("allocation_repetitions");730    try out.write(value.allocation_repetitions_path);731    if (measuredArtifactMode(value.executions) == .profiler_capture_contract) {732        try writeProfilerArtifactsJson(out, value);733    }734    try out.endObject();735}736737fn writeProfilerArtifactsJson(out: *pretty_json.Writer, value: Workload) !void {738    inline for (.{739        .{ "stdout", value.stdout_path },740        .{ "stderr", value.stderr_path },741        .{ "bench_jsonl", value.bench_jsonl_path },742        .{ "coz_jsonl", value.coz_jsonl_path },743        .{ "coz_analysis", value.coz_analysis_path },744        .{ "tracy_jsonl", value.tracy_jsonl_path },745        .{ "tracy_summary", value.tracy_summary_path },746        .{ "allocations", value.allocations_path },747        .{ "structured", value.structured_path },748    }) |field| {749        try out.objectField(field[0]);750        try out.write(field[1]);751    }752    try out.objectField("structured_rows");753    try out.write(value.structured_rows);754    try out.objectField("structured_parse_errors");755    try out.write(value.structured_parse_errors);756}757758fn writeCapturesJson(out: *pretty_json.Writer, captures: []const host.Capture) !void {759    try out.beginArray();760    for (captures) |row| {761        try out.beginObject();762        try out.objectField("kind");763        try out.write(row.kind);764        try out.objectField("tool");765        try out.write(row.tool);766        try out.objectField("tool_version");767        try out.write(row.tool_version);768        try out.objectField("scope");769        try out.write(row.scope);770        try out.objectField("capture");771        try out.write(row.capture_path);772        try out.objectField("summary");773        try out.write(row.summary_path);774        try out.objectField("state");775        try out.write(row.state);776        try out.objectField("caveat_kind");777        try out.write(row.caveat_kind);778        try out.objectField("caveat_message");779        try out.write(row.caveat_message);780        try out.endObject();781    }782    try out.endArray();783}784785fn writeCapturePerturbationJson(786    out: *pretty_json.Writer,787    measurement: ?perturbation.Measurement,788) !void {789    const actual = measurement orelse {790        try out.write(null);791        return;792    };793    std.debug.assert(actual.pairs.len <= perturbation.max_pairs);794    std.debug.assert(actual.configuration.any());795    try out.beginObject();796    try out.objectField("state");797    try out.write(@tagName(actual.state));798    try out.objectField("method");799    try out.write("same_build_matched_control_capture");800    try out.objectField("effect_method");801    try out.write(perturbation.effect_method);802    try out.objectField("effect_bootstrap_iterations");803    try out.write(capture.compare.effect.bootstrap_iterations);804    try out.objectField("effect_confidence_per_mille");805    try out.write(capture.compare.effect.confidence_per_mille);806    try out.objectField("pair_count_requested");807    try out.write(actual.pairs.len);808    try out.objectField("base_seed");809    try out.write(actual.base_seed);810    try out.objectField("workload_seed");811    try out.write(actual.workload_seed);812    try out.objectField("order");813    try out.write("seeded_balanced_within_pair");814    try out.objectField("setup_reuse");815    try out.write("single_setup");816    try out.objectField("binary_identity");817    try out.write("same_built_binary");818    try out.objectField("capture_artifact_retention");819    try out.write("last_capture_execution");820    try out.objectField("control_output_retention");821    try out.write("last_control_execution");822    try out.objectField("active_configuration");823    try out.beginObject();824    try out.objectField("host_kind");825    try out.write(actual.configuration.host_kind);826    try out.objectField("tracy");827    try out.write(actual.configuration.tracy);828    try out.objectField("allocations");829    try out.write(actual.configuration.allocations);830    try out.endObject();831    try out.objectField("control_artifacts");832    try writeControlArtifactsJson(out, actual);833    try out.objectField("pairs");834    try out.beginArray();835    for (actual.pairs) |pair| {836        try out.beginObject();837        try out.objectField("index");838        try out.write(pair.index);839        try out.objectField("order");840        try out.write(@tagName(pair.order));841        try out.objectField("control");842        try writeExecutionResultJson(out, pair.control);843        try out.objectField("capture");844        try writeExecutionResultJson(out, pair.capture);845        try out.endObject();846    }847    try out.endArray();848    try out.endObject();849}850851fn writeControlArtifactsJson(852    out: *pretty_json.Writer,853    measurement: perturbation.Measurement,854) !void {855    const paths = measurement.control_artifacts;856    try out.beginObject();857    try out.objectField("stdout");858    try out.write(paths.stdout);859    try out.objectField("stderr");860    try out.write(paths.stderr);861    try out.objectField("bench_jsonl");862    try out.write(paths.bench_jsonl);863    try out.objectField("coz_jsonl");864    try out.write(paths.coz_jsonl);865    try out.objectField("coz_analysis");866    try out.write(paths.coz_analysis);867    try out.objectField("tracy_jsonl");868    try out.write(paths.tracy_jsonl);869    try out.objectField("tracy_summary");870    try out.write(paths.tracy_summary);871    try out.objectField("allocations");872    try out.write(paths.allocations);873    try out.objectField("structured");874    try out.write(paths.structured);875    try out.objectField("structured_rows");876    try out.write(measurement.control_structured_rows);877    try out.objectField("structured_parse_errors");878    try out.write(measurement.control_structured_parse_errors);879    try out.endObject();880}881882fn writeExecutionResultJson(883    out: *pretty_json.Writer,884    result: ?execute.Result,885) !void {886    const actual = result orelse {887        try out.write(null);888        return;889    };890    try out.beginObject();891    try writeSpawnStateJson(out, actual);892    try out.objectField("pid");893    try out.write(actual.pid);894    try out.objectField("exit_code");895    try out.write(actual.exit_code);896    try out.objectField("wall_ns");897    try out.write(actual.wall_ns);898    try writeResourceUsageFields(out, actual);899    try out.endObject();900}901902fn writeSpawnStateJson(out: *pretty_json.Writer, result: execute.Result) !void {903    try out.objectField("spawn_state");904    try out.write(if (result.pid == null) "spawn_failed" else "spawned");905}906907fn writeResourceUsageFields(out: *pretty_json.Writer, result: execute.Result) !void {908    try out.objectField("resource_usage_source");909    if (result.resource_usage_source) |source| {910        try out.write(@tagName(source));911    } else {912        try out.write(null);913    }914    try out.objectField("max_rss_kib");915    try out.write(result.maxrss_kib);916    try out.objectField("user_s");917    try out.write(result.user_s);918    try out.objectField("system_s");919    try out.write(result.system_s);920    try out.objectField("minor_page_faults");921    try out.write(result.minor_page_faults);922    try out.objectField("major_page_faults");923    try out.write(result.major_page_faults);924    try out.objectField("voluntary_context_switches");925    try out.write(result.voluntary_context_switches);926    try out.objectField("involuntary_context_switches");927    try out.write(result.involuntary_context_switches);928}929930fn writeAggregateReductionJson(out: *pretty_json.Writer) !void {931    try out.beginObject();932    try out.objectField("pid");933    try out.write("null_for_multiple_executions_or_external_failure");934    try out.objectField("wall_ns");935    try out.write("sum");936    try out.objectField("resource_usage_source");937    try out.write("require_equal");938    try out.objectField("max_rss_kib");939    try out.write("maximum");940    const sum_fields = [_][]const u8{941        "user_s",942        "system_s",943        "minor_page_faults",944        "major_page_faults",945        "voluntary_context_switches",946        "involuntary_context_switches",947    };948    for (sum_fields) |field| {949        try out.objectField(field);950        try out.write("sum");951    }952    try out.endObject();953}954955fn writeMeasurementJson(956    out: *pretty_json.Writer,957    executions: []const MeasuredExecution,958    acquisition: order.Context,959    trace_allocations: bool,960    workload_root: []const u8,961    benchmark_process_domain: reducer.DomainDeclaration,962    benchmark_process_reduction: reducer.Result,963) !void {964    std.debug.assert(executions.len <= host.process.max_executions);965    try out.beginObject();966    try out.objectField("execution_count");967    try out.write(executions.len);968    try out.objectField("acquisition_order");969    try out.write(acquisition.method().acquisitionName());970    try out.objectField("workload_output_retention");971    const artifact_mode = measuredArtifactMode(executions);972    try out.write(artifact_mode.name());973    try out.objectField("measured_artifact_layout");974    try out.write(measuredArtifactLayout(executions, artifact_mode, workload_root));975    try out.objectField("allocation_summary_retention");976    try out.write(if (!trace_allocations)977        "disabled"978    else if (artifact_mode == .no_measured_execution)979        "no_measured_execution"980    else if (artifact_mode == .profiler_capture_contract)981        "profiler_capture_contract"982    else if (executions.len > 1)983        "all_measured_executions"984    else985        "single_measured_execution");986    try out.objectField("aggregate_reduction");987    try writeAggregateReductionJson(out);988    try out.objectField("benchmark_process_domain");989    try reducer.writeDomainJson(out, benchmark_process_domain);990    try out.objectField("benchmark_process_reduction");991    try reducer.writeJson(out, benchmark_process_reduction);992    try out.objectField("executions");993    try out.beginArray();994    for (executions) |execution| {995        try out.beginObject();996        try out.objectField("index");997        try out.write(execution.index);998        if (execution.acquisition_position) |position| {999            try out.objectField("acquisition_position");1000            try out.write(position);1001        }1002        try writeSpawnStateJson(out, execution.result);1003        try out.objectField("pid");1004        try out.write(execution.result.pid);1005        try out.objectField("exit_code");1006        try out.write(execution.result.exit_code);1007        try out.objectField("wall_ns");1008        try out.write(execution.result.wall_ns);1009        try writeResourceUsageFields(out, execution.result);1010        try out.objectField("artifacts");1011        try writeExecutionArtifactsJson(out, execution);1012        try out.endObject();1013    }1014    try out.endArray();1015    try out.endObject();1016}10171018fn writeExecutionArtifactsJson(1019    out: *pretty_json.Writer,1020    execution: MeasuredExecution,1021) !void {1022    const paths = execution.paths orelse {1023        try out.write(null);1024        return;1025    };1026    try out.beginObject();1027    inline for (.{1028        .{ "root", paths.root },1029        .{ "stdout", paths.stdout },1030        .{ "stderr", paths.stderr },1031        .{ "bench_jsonl", paths.bench_jsonl },1032        .{ "coz_jsonl", paths.coz_jsonl },1033        .{ "coz_analysis", paths.coz_analysis },1034        .{ "tracy_jsonl", paths.tracy_jsonl },1035        .{ "tracy_summary", paths.tracy_summary },1036        .{ "allocations", paths.allocations },1037        .{ "structured", paths.structured },1038    }) |field| {1039        try out.objectField(field[0]);1040        try out.write(field[1]);1041    }1042    try out.objectField("structured_rows");1043    try out.write(execution.structured_rows);1044    try out.objectField("structured_parse_errors");1045    try out.write(execution.structured_parse_errors);1046    try out.endObject();1047}10481049const MeasuredArtifactMode = enum {1050    all_measured_executions,1051    profiler_capture_contract,1052    no_measured_execution,10531054    fn name(self: MeasuredArtifactMode) []const u8 {1055        return @tagName(self);1056    }1057};10581059fn measuredArtifactMode(executions: []const MeasuredExecution) MeasuredArtifactMode {1060    if (executions.len == 0) return .no_measured_execution;1061    var retained: usize = 0;1062    for (executions) |execution| {1063        if (execution.paths != null) retained += 1;1064    }1065    if (retained == executions.len) return .all_measured_executions;1066    std.debug.assert(retained == 0);1067    return .profiler_capture_contract;1068}10691070fn measuredArtifactLayout(1071    executions: []const MeasuredExecution,1072    mode: MeasuredArtifactMode,1073    workload_root: []const u8,1074) []const u8 {1075    if (mode != .all_measured_executions) return "none";1076    const first = executions[0].paths.?;1077    if (std.mem.eql(u8, first.root, workload_root)) return "workload_root";1078    for (executions) |execution| {1079        const paths = execution.paths.?;1080        std.debug.assert(!std.mem.eql(u8, paths.root, workload_root));1081    }1082    return "numbered_execution_directories";1083}10841085fn writeResetsJson(out: *pretty_json.Writer, resets: []const Reset) !void {1086    std.debug.assert(resets.len <= maximum_reset_receipts);1087    try out.beginObject();1088    try out.objectField("policy");1089    try out.write("before_each_warmup_and_measured_child");1090    try out.objectField("timing");1091    try out.write("outside_measured_child_wait");1092    try out.objectField("receipt_count");1093    try out.write(resets.len);1094    try out.objectField("receipts");1095    try out.beginArray();1096    for (resets) |reset| {1097        std.debug.assert(reset.sequence > 0);1098        std.debug.assert(reset.phase_index > 0);1099        try out.beginObject();1100        try out.objectField("sequence");1101        try out.write(reset.sequence);1102        try out.objectField("phase");1103        try out.write(@tagName(reset.phase));1104        try out.objectField("phase_index");1105        try out.write(reset.phase_index);1106        try writeRecordedCommandFields(out, reset.command);1107        try out.endObject();1108    }1109    try out.endArray();1110    try out.endObject();1111}11121113fn writeRecordedCommandFields(1114    out: *pretty_json.Writer,1115    command: execute.CommandResult,1116) !void {1117    try out.objectField("command");1118    try out.beginObject();1119    try out.objectField("text");1120    try out.write(command.command);1121    try out.objectField("cwd");1122    try out.write(command.cwd);1123    try out.objectField("argv");1124    try out.write(command.argv);1125    try out.endObject();1126    try out.objectField("stdout");1127    try out.write(command.stdout_path);1128    try out.objectField("stderr");1129    try out.write(command.stderr_path);1130    try out.objectField("execution");1131    try writeExecutionResultJson(out, command.execution);1132}11331134fn writeWarmupJson(1135    out: *pretty_json.Writer,1136    executions: []const execute.Result,1137    paths: ?WarmupPaths,1138) !void {1139    std.debug.assert(executions.len <= host.process.max_executions);1140    try out.beginObject();1141    try out.objectField("purpose");1142    try out.write("unmeasured_process_preconditioning");1143    try out.objectField("execution_count");1144    try out.write(executions.len);1145    try out.objectField("acquisition_order");1146    try out.write("fixed_warmup_index_order");1147    try out.objectField("workload_output_retention");1148    try out.write("last_warmup_execution");1149    try out.objectField("executions");1150    try writeExecutionResultsJson(out, executions);1151    try out.objectField("artifacts");1152    if (paths) |actual| {1153        try out.beginObject();1154        try out.objectField("root");1155        try out.write(actual.root);1156        try out.objectField("stdout");1157        try out.write(actual.stdout);1158        try out.objectField("stderr");1159        try out.write(actual.stderr);1160        try out.objectField("bench_jsonl");1161        try out.write(actual.bench_jsonl);1162        try out.objectField("coz_jsonl");1163        try out.write(actual.coz_jsonl);1164        try out.objectField("coz_analysis");1165        try out.write(actual.coz_analysis);1166        try out.objectField("tracy_jsonl");1167        try out.write(actual.tracy_jsonl);1168        try out.objectField("tracy_summary");1169        try out.write(actual.tracy_summary);1170        try out.objectField("allocations");1171        try out.write(actual.allocations);1172        try out.endObject();1173    } else {1174        try out.write(null);1175    }1176    try out.endObject();1177}11781179fn writeExecutionResultsJson(1180    out: *pretty_json.Writer,1181    executions: []const execute.Result,1182) !void {1183    try out.beginArray();1184    for (executions, 0..) |execution, index| {1185        try out.beginObject();1186        try out.objectField("index");1187        try out.write(index + 1);1188        try out.objectField("pid");1189        try out.write(execution.pid);1190        try out.objectField("exit_code");1191        try out.write(execution.exit_code);1192        try out.objectField("wall_ns");1193        try out.write(execution.wall_ns);1194        try writeResourceUsageFields(out, execution);1195        try out.endObject();1196    }1197    try out.endArray();1198}11991200fn writeCatalogWorkloadJson(out: *pretty_json.Writer, workload: catalog.Workload) !void {1201    try out.beginObject();1202    try out.objectField("name");1203    try out.write(workload.name);1204    try out.objectField("package");1205    try out.write(workload.package);1206    try out.objectField("step");1207    try out.write(workload.step);1208    try out.objectField("local_step");1209    try out.write(workload.localStep());1210    try out.objectField("cwd");1211    try out.write(workload.cwd);1212    try out.objectField("summary");1213    try out.write(workload.summary);1214    try out.objectField("tier");1215    try out.write(@tagName(workload.tier));1216    try out.objectField("surface");1217    try out.write(@tagName(workload.surface));1218    try out.objectField("forwards_args");1219    try out.write(workload.forwards_args);1220    try out.objectField("bin");1221    try writeCatalogBinJson(out, workload.bin);1222    try out.objectField("prepare");1223    try writeCatalogCommandJson(out, workload.prepare);1224    try out.objectField("reset");1225    try writeCatalogCommandJson(out, workload.reset);1226    try out.objectField("environment");1227    try writeEnvironmentOverridesJson(out, workload.environment);1228    try out.objectField("allocation_tracking");1229    try out.beginObject();1230    try out.objectField("counters");1231    try out.write(@tagName(workload.allocation_tracking.counters));1232    try out.objectField("trace");1233    try out.write(@tagName(workload.allocation_tracking.trace));1234    try out.objectField("baseline");1235    try out.write(@tagName(workload.allocationBaselinePolicy()));1236    try out.objectField("regression_budget_percent");1237    try out.write(workload.allocationBudgetPercent());1238    try out.endObject();1239    try out.objectField("trace_allocations");1240    try out.write(workload.tracesAllocationsByDefault());1241    try out.objectField("thresholds");1242    try out.beginObject();1243    try out.objectField("wall_percent");1244    try out.write(workload.wall_threshold_percent);1245    try out.objectField("rss_percent");1246    try out.write(workload.rss_threshold_percent);1247    try out.objectField("metric_percent");1248    try out.write(workload.metric_threshold_percent);1249    try out.endObject();1250    try out.endObject();1251}12521253fn writeRuntimeJson(out: *pretty_json.Writer, runtime: catalog.Runtime) !void {1254    try out.beginObject();1255    try out.objectField("workload_root");1256    try out.write(runtime.workload_root);1257    try out.objectField("bin_args");1258    try out.write(runtime.bin_args);1259    try out.objectField("prepare");1260    try writeCatalogCommandJson(out, runtime.prepare);1261    try out.objectField("reset");1262    try writeCatalogCommandJson(out, runtime.reset);1263    try out.objectField("environment");1264    try writeEnvironmentOverridesJson(out, runtime.environment);1265    try out.endObject();1266}12671268fn writeCatalogBinJson(out: *pretty_json.Writer, optional: ?catalog.Bin) !void {1269    const bin = optional orelse {1270        try out.write(null);1271        return;1272    };1273    try out.beginObject();1274    try out.objectField("step");1275    try out.write(bin.step);1276    try out.objectField("path");1277    try out.write(bin.path);1278    try out.objectField("args");1279    try out.write(bin.args);1280    try out.objectField("cwd");1281    try out.write(bin.cwd);1282    try out.endObject();1283}12841285fn writeEnvironmentOverridesJson(1286    out: *pretty_json.Writer,1287    overrides: []const catalog.EnvironmentOverride,1288) !void {1289    try out.beginArray();1290    for (overrides) |entry| {1291        try out.beginObject();1292        try out.objectField("name");1293        try out.write(entry.name);1294        try out.objectField("operation");1295        try out.write(entry.operation());1296        if (entry.value) |value| {1297            try out.objectField("value");1298            try out.write(value);1299        }1300        try out.endObject();1301    }1302    try out.endArray();1303}13041305fn writeCatalogCommandJson(1306    out: *pretty_json.Writer,1307    command: ?catalog.Command,1308) !void {1309    const actual = command orelse {1310        try out.write(null);1311        return;1312    };1313    try out.beginObject();1314    try out.objectField("argv");1315    try out.write(actual.argv);1316    try out.objectField("cwd");1317    try out.write(actual.cwd);1318    try out.endObject();1319}13201321fn writeCommandJson(out: *pretty_json.Writer, value: Workload) !void {1322    try out.beginObject();1323    try out.objectField("text");1324    try out.write(value.command);1325    try out.objectField("cwd");1326    try out.write(value.cwd orelse value.workload.cwd);1327    try out.objectField("argv");1328    try out.beginArray();1329    for (value.argv) |arg| try out.write(arg);1330    try out.endArray();1331    try out.endObject();1332}13331334fn gitCapture(allocator: std.mem.Allocator, process_io: std.Io, argv: []const []const u8) !?[]const u8 {1335    const result = sys.process.run(allocator, process_io, .{1336        .argv = argv,1337        .stdout_limit = .limited(4096),1338        .stderr_limit = .limited(4096),1339    }) catch return null;1340    defer allocator.free(result.stderr);1341    if (sys.process.exitCode(result.term) != 0) {1342        allocator.free(result.stdout);1343        return null;1344    }1345    const trimmed = std.mem.trim(u8, result.stdout, " \t\r\n");1346    const copy = try allocator.dupe(u8, trimmed);1347    allocator.free(result.stdout);1348    return copy;1349}13501351fn gitDirty(allocator: std.mem.Allocator, process_io: std.Io) !?bool {1352    const result = sys.process.run(allocator, process_io, .{1353        .argv = &.{ "git", "status", "--porcelain" },1354        .stdout_limit = .limited(1024 * 1024),1355        .stderr_limit = .limited(4096),1356    }) catch return null;1357    defer allocator.free(result.stdout);1358    defer allocator.free(result.stderr);1359    if (sys.process.exitCode(result.term) != 0) return null;1360    return result.stdout.len != 0;1361}13621363pub fn sanitizeSegment(allocator: std.mem.Allocator, value: []const u8) ![]const u8 {1364    const result = try allocator.alloc(u8, value.len);1365    for (value, 0..) |byte, index| {1366        result[index] = if (std.ascii.isAlphanumeric(byte) or byte == '.' or byte == '_' or byte == '-') byte else '_';1367    }1368    return result;1369}13701371test "profiling record builds stable artifact paths" {1372    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);1373    defer arena_state.deinit();1374    const allocator = arena_state.allocator();1375    const paths = try makePaths(allocator, "zig-out/profiling", "run-test");13761377    try std.testing.expectEqualStrings("zig-out/profiling/run-test", paths.root);1378    try std.testing.expectEqualStrings("zig-out/profiling/run-test/results.jsonl", paths.results);13791380    const workload_paths = try workloadPaths(allocator, paths, "w");1381    try std.testing.expectEqualStrings(1382        "zig-out/profiling/run-test/workloads/w/warmup/stdout.txt",1383        workload_paths.warmup.stdout,1384    );1385    try std.testing.expectEqualStrings(1386        "zig-out/profiling/run-test/workloads/w/prepare.stdout.txt",1387        workload_paths.prepare_stdout,1388    );1389    const single = try executionPaths(allocator, workload_paths, 1, 1);1390    try std.testing.expectEqualStrings(workload_paths.stdout, single.stdout);1391    try std.testing.expectEqualStrings(workload_paths.structured, single.structured);1392    const repeated = try executionPaths(allocator, workload_paths, 100, 100);1393    try std.testing.expectEqualStrings(1394        "zig-out/profiling/run-test/workloads/w/executions/100/stdout.txt",1395        repeated.stdout,1396    );1397    try std.testing.expectEqualStrings(1398        "zig-out/profiling/run-test/workloads/w/executions/100/structured.jsonl",1399        repeated.structured,1400    );1401    try std.testing.expectError(1402        error.InvalidExecutionArtifactCount,1403        executionPaths(allocator, workload_paths, 0, 1),1404    );1405    try std.testing.expectError(1406        error.InvalidExecutionArtifactCount,1407        executionPaths(allocator, workload_paths, 101, 1),1408    );1409    try std.testing.expectError(1410        error.InvalidExecutionArtifactIndex,1411        executionPaths(allocator, workload_paths, 2, 0),1412    );1413    try std.testing.expectError(1414        error.InvalidExecutionArtifactIndex,1415        executionPaths(allocator, workload_paths, 100, 101),1416    );1417    const reset = try resetPaths(allocator, workload_paths.root, 2, .capture, 1);1418    try std.testing.expectEqualStrings(1419        "zig-out/profiling/run-test/workloads/w/resets/002-capture-001.stdout.txt",1420        reset.stdout,1421    );1422}14231424test "profiling record bounds reset receipts for maximum warmup and acquisition counts" {1425    try std.testing.expectEqual(@as(usize, 200), maximum_reset_receipts);1426    try std.testing.expectEqual(1427        host.process.max_executions * 2,1428        maximum_reset_receipts,1429    );1430}14311432test "profiling record bounds measured execution artifacts" {1433    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);1434    defer arena_state.deinit();1435    const allocator = arena_state.allocator();1436    const paths = try workloadPaths(1437        allocator,1438        try makePaths(allocator, "zig-out/profiling", "run-test"),1439        "w",1440    );1441    var roots: [host.process.max_executions][]const u8 = undefined;1442    for (&roots, 0..) |*root, index| {1443        const first = try executionPaths(allocator, paths, roots.len, index + 1);1444        const second = try executionPaths(allocator, paths, roots.len, index + 1);1445        try std.testing.expectEqualStrings(first.root, second.root);1446        for (roots[0..index]) |previous| {1447            try std.testing.expect(!std.mem.eql(u8, previous, first.root));1448        }1449        root.* = first.root;1450    }1451    try std.testing.expect(std.mem.endsWith(u8, roots[0], "/executions/001"));1452    try std.testing.expect(std.mem.endsWith(u8, roots[99], "/executions/100"));1453}14541455test "profiling record sanitizes workload path segments" {1456    const allocator = std.testing.allocator;1457    const segment = try sanitizeSegment(allocator, "a/b c");1458    defer allocator.free(segment);1459    try std.testing.expectEqualStrings("a_b_c", segment);1460}14611462test "profiling record writes the selected optimization mode" {1463    const allocator = std.testing.allocator;1464    const metadata = Metadata{1465        .run_id = "run-a",1466        .artifact_root = "zig-out/profiling/run-a",1467        .suite = .smoke,1468        .filters = &.{},1469        .workload_count = 1,1470        .started_unix_ns = 1,1471        .git_sha = null,1472        .git_branch = null,1473        .git_dirty = null,1474        .zig_version = "0.16.0",1475        .host = .{1476            .hostname = "bench-a",1477            .os = "linux",1478            .kernel = "7.0.11",1479            .arch = "x86_64",1480            .cpu_model = "AMD Ryzen 7 7800X3D",1481            .cpu_count = 8,1482            .cpu_frequency_policy = "policy-a",1483            .process_cpu_affinity = "0-7",1484            .process_memory_affinity = "0",1485        },1486        .host_state_start = .{1487            .realtime_unix_ns = 2,1488            .monotonic_ns = 3,1489            .observer_cpu_id = 4,1490            .observer_cpu_frequency_khz = 4_800_000,1491        },1492        .optimize = .fast,1493    };1494    const text = try renderJsonDocument(allocator, writeRunStartJson, .{metadata});1495    defer allocator.free(text);1496    try std.testing.expect(1497        std.mem.indexOf(u8, text, "\"build\":{\"optimize\":\"ReleaseFast\"}") != null,1498    );1499    try std.testing.expect(1500        std.mem.indexOf(u8, text, "\"hostname\":\"bench-a\"") != null,1501    );1502    try std.testing.expect(1503        std.mem.indexOf(u8, text, "\"cpu_frequency_policy\":\"policy-a\"") != null,1504    );1505    try std.testing.expect(1506        std.mem.indexOf(u8, text, "\"process_cpu_affinity\":\"0-7\"") != null,1507    );1508    try std.testing.expect(1509        std.mem.indexOf(u8, text, "\"process_memory_affinity\":\"0\"") != null,1510    );1511    try std.testing.expect(1512        std.mem.indexOf(1513            u8,1514            text,1515            "\"schema\":\"tiny.profiling.host-state/v1\"",1516        ) != null,1517    );1518    try std.testing.expect(1519        std.mem.indexOf(u8, text, "\"observer_cpu_id\":4") != null,1520    );1521}15221523test "profiling record retains external profiler versions" {1524    const allocator = std.testing.allocator;1525    const captures = [_]host.Capture{.{1526        .kind = host.counters.kind,1527        .tool = host.counters.tool,1528        .tool_version = "perf version 7.0",1529        .capture_path = "perf-stat.csv",1530        .summary_path = "perf-stat.summary.json",1531        .state = "summary_written",1532    }};1533    const text = try renderJsonDocument(allocator, writeCapturesJson, .{&captures});1534    defer allocator.free(text);1535    try std.testing.expect(1536        std.mem.indexOf(u8, text, "\"tool_version\":\"perf version 7.0\"") != null,1537    );1538}15391540fn mappedExecutionFixture(1541    index: usize,1542    position: usize,1543    paths: ExecutionPaths,1544) MeasuredExecution {1545    const second = index == 2;1546    return .{1547        .index = index,1548        .acquisition_position = position,1549        .paths = paths,1550        .result = .{1551            .pid = 100 + index,1552            .exit_code = 0,1553            .wall_ns = if (second) 30 else 10,1554            .resource_usage_source = .wait4_rusage,1555            .maxrss_kib = if (second) 40 else 20,1556            .user_s = if (second) 0.3 else 0.1,1557            .system_s = if (second) 0.4 else 0.2,1558            .minor_page_faults = if (second) 13 else 11,1559            .major_page_faults = if (second) 2 else 1,1560            .voluntary_context_switches = if (second) 5 else 3,1561            .involuntary_context_switches = if (second) 4 else 2,1562        },1563        .structured_rows = if (second) 7 else 0,1564        .structured_parse_errors = if (second) 1 else 0,1565    };1566}15671568fn expectMappedMeasurementPolicy(text: []const u8) !void {1569    try std.testing.expect(std.mem.indexOf(u8, text, "\"execution_count\":2") != null);1570    try std.testing.expect(std.mem.indexOf(u8, text, "\"pid\":101") != null);1571    try std.testing.expect(std.mem.indexOf(u8, text, "\"pid\":102") != null);1572    try std.testing.expect(1573        std.mem.indexOf(u8, text, "\"acquisition_order\":\"random_interleaved\"") != null,1574    );1575    try std.testing.expect(1576        std.mem.indexOf(1577            u8,1578            text,1579            "\"workload_output_retention\":\"all_measured_executions\"",1580        ) != null,1581    );1582    try std.testing.expect(1583        std.mem.indexOf(u8, text, "\"allocation_trace\":true") != null,1584    );1585    try std.testing.expect(1586        std.mem.indexOf(1587            u8,1588            text,1589            "\"allocation_summary_retention\":\"all_measured_executions\"",1590        ) != null,1591    );1592    try std.testing.expect(1593        std.mem.indexOf(u8, text, "\"resource_usage_source\":\"require_equal\"") != null,1594    );1595    try std.testing.expect(std.mem.indexOf(u8, text, "\"minor_page_faults\":\"sum\"") != null);1596    try std.testing.expect(1597        std.mem.indexOf(u8, text, "\"resource_usage_source\":\"wait4_rusage\"") != null,1598    );1599    try std.testing.expect(std.mem.indexOf(u8, text, "\"voluntary_context_switches\":3") != null);1600    try std.testing.expect(std.mem.indexOf(1601        u8,1602        text,1603        "\"root\":\"zig-out/profiling/run-test/workloads/w/executions/001\"",1604    ) != null);1605    try std.testing.expect(std.mem.indexOf(1606        u8,1607        text,1608        "\"structured_rows\":7,\"structured_parse_errors\":1",1609    ) != null);1610}16111612fn expectMappedMeasurementRows(1613    allocator: std.mem.Allocator,1614    text: []const u8,1615) !void {1616    const document = try std.json.parseFromSliceLeaky(1617        std.json.Value,1618        allocator,1619        text,1620        .{},1621    );1622    const measurement_object = try json_util.object(document);1623    const rows = try json_util.array(measurement_object.get("executions").?);1624    try std.testing.expectEqual(@as(usize, 2), rows.items.len);1625    const first = try json_util.object(rows.items[0]);1626    const second = try json_util.object(rows.items[1]);1627    try std.testing.expectEqual(@as(u64, 101), json_util.asU64(first.get("pid")).?);1628    try std.testing.expectEqual(1629        @as(u64, 1),1630        json_util.asU64(first.get("acquisition_position")).?,1631    );1632    try std.testing.expectEqual(@as(u64, 102), json_util.asU64(second.get("pid")).?);1633    try std.testing.expectEqual(1634        @as(u64, 4),1635        json_util.asU64(second.get("acquisition_position")).?,1636    );1637    const first_artifacts = try json_util.object(first.get("artifacts").?);1638    const second_artifacts = try json_util.object(second.get("artifacts").?);1639    try std.testing.expect(std.mem.endsWith(1640        u8,1641        json_util.string(first_artifacts.get("root")).?,1642        "/001",1643    ));1644    try std.testing.expect(std.mem.endsWith(1645        u8,1646        json_util.string(second_artifacts.get("root")).?,1647        "/002",1648    ));1649    try std.testing.expectEqual(1650        @as(u64, 7),1651        json_util.asU64(second_artifacts.get("structured_rows")).?,1652    );1653}16541655test "profiling record maps measured execution artifacts to each process" {1656    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);1657    defer arena_state.deinit();1658    const allocator = arena_state.allocator();1659    const paths = try workloadPaths(1660        allocator,1661        try makePaths(allocator, "zig-out/profiling", "run-test"),1662        "w",1663    );1664    const positions = [_]usize{ 1, 4 };1665    const acquisition = order.Context{ .random_interleaved = .{1666        .seed = 42,1667        .repeat_count = 2,1668        .workload_count = 2,1669        .selected_workloads = &.{ "w", "x" },1670        .positions = &positions,1671    } };1672    const executions = [_]MeasuredExecution{1673        mappedExecutionFixture(1, positions[0], try executionPaths(allocator, paths, 2, 1)),1674        mappedExecutionFixture(2, positions[1], try executionPaths(allocator, paths, 2, 2)),1675    };1676    const text = try renderJsonDocument(1677        allocator,1678        writeMeasurementJson,1679        .{1680            executions[0..],1681            acquisition,1682            true,1683            paths.root,1684            reducer.DomainDeclaration{1685                .benchmark_surface = true,1686                .direct_execution = true,1687                .host_profiler = false,1688                .tracy = false,1689                .causal = false,1690                .allocation_trace = true,1691                .capture_control = false,1692            },1693            reducer.Result{ .not_applicable = .{1694                .reason = .outside_direct_benchmark_domain,1695                .process_count = 2,1696            } },1697        },1698    );1699    defer allocator.free(text);1700    try expectMappedMeasurementPolicy(text);1701    try expectMappedMeasurementRows(allocator, text);1702}17031704test "profiling record writes v4 waited-command resource evidence" {1705    const allocator = std.testing.allocator;1706    const text = try renderJsonDocument(1707        allocator,1708        writeExecutionResultJson,1709        .{execute.Result{1710            .pid = 404,1711            .exit_code = 0,1712            .wall_ns = 50,1713            .resource_usage_source = .wait4_rusage,1714            .maxrss_kib = 40,1715            .user_s = 0.1,1716            .system_s = 0.2,1717            .minor_page_faults = 96,1718            .major_page_faults = 1,1719            .voluntary_context_switches = 2,1720            .involuntary_context_switches = 1,1721        }},1722    );1723    defer allocator.free(text);1724    try std.testing.expectEqualStrings("tiny.profiling.workload/v4", workload_schema);1725    try std.testing.expect(std.mem.indexOf(u8, text, "\"pid\":404") != null);1726    try std.testing.expect(1727        std.mem.indexOf(u8, text, "\"resource_usage_source\":\"wait4_rusage\"") != null,1728    );1729    try std.testing.expect(std.mem.indexOf(u8, text, "\"minor_page_faults\":96") != null);1730    try std.testing.expect(std.mem.indexOf(u8, text, "\"major_page_faults\":1") != null);1731    try std.testing.expect(std.mem.indexOf(u8, text, "\"voluntary_context_switches\":2") != null);1732    try std.testing.expect(std.mem.indexOf(u8, text, "\"involuntary_context_switches\":1") != null);1733}17341735test "profiling record retains setup child process identity" {1736    const allocator = std.testing.allocator;1737    const text = try renderJsonDocument(1738        allocator,1739        writeSetupJson,1740        .{Setup{1741            .command = "zig build bench-bin",1742            .pid = 303,1743            .exit_code = 0,1744            .wall_ns = 12,1745            .stdout_path = "setup.stdout.txt",1746            .stderr_path = "setup.stderr.txt",1747        }},1748    );1749    defer allocator.free(text);1750    try std.testing.expect(std.mem.indexOf(1751        u8,1752        text,1753        "\"command\":\"zig build bench-bin\",\"pid\":303",1754    ) != null);1755}17561757test "profiling record writes exact acquisition context" {1758    const allocator = std.testing.allocator;1759    const text = try renderJsonDocument(1760        allocator,1761        order.writeJson,1762        .{order.Context{ .blocked = .{1763            .position = 3,1764            .workload_count = 4,1765            .predecessors = &.{ "a", "b" },1766        } }},1767    );1768    defer allocator.free(text);1769    try std.testing.expectEqualStrings(1770        "{\"position\":3,\"workload_count\":4,\"predecessors\":[\"a\",\"b\"]}\n",1771        text,1772    );1773}17741775test "profiling record writes exact interleaved acquisition context" {1776    const allocator = std.testing.allocator;1777    const text = try renderJsonDocument(1778        allocator,1779        order.writeJson,1780        .{order.Context{ .random_interleaved = .{1781            .seed = 42,1782            .repeat_count = 3,1783            .workload_count = 2,1784            .selected_workloads = &.{ "a", "b" },1785            .positions = &.{ 1, 3, 6 },1786        } }},1787    );1788    defer allocator.free(text);1789    try std.testing.expectEqualStrings(1790        "{\"method\":\"random_interleaved\",\"schedule_algorithm\":\"xoshiro256_flat_multiset_fisher_yates\",\"setup_order\":\"selected_workload_order_before_measurement\",\"warmup_placement\":\"before_first_scheduled_measurement\",\"failure_policy\":\"skip_failed_workload_remaining_positions\",\"seed\":42,\"repeat_count\":3,\"workload_count\":2,\"selected_workloads\":[\"a\",\"b\"],\"positions\":[1,3,6]}\n",1791        text,1792    );1793}17941795test "profiling record retains unmeasured warmup executions separately" {1796    const allocator = std.testing.allocator;1797    const executions = [_]execute.Result{1798        .{ .exit_code = 0, .wall_ns = 5 },1799        .{ .exit_code = 0, .wall_ns = 7 },1800    };1801    const paths = WarmupPaths{1802        .root = "workloads/w/warmup",1803        .stdout = "workloads/w/warmup/stdout.txt",1804        .stderr = "workloads/w/warmup/stderr.txt",1805        .bench_jsonl = "workloads/w/warmup/bench.jsonl",1806        .coz_jsonl = "workloads/w/warmup/bench.coz.jsonl",1807        .coz_analysis = "workloads/w/warmup/bench.coz.analysis.json",1808        .tracy_jsonl = "workloads/w/warmup/bench.tracy.jsonl",1809        .tracy_summary = "workloads/w/warmup/bench.tracy.summary.jsonl",1810        .allocations = "workloads/w/warmup/allocations.jsonl",1811    };1812    const text = try renderJsonDocument(1813        allocator,1814        writeWarmupJson,1815        .{ executions[0..], @as(?WarmupPaths, paths) },1816    );1817    defer allocator.free(text);1818    try std.testing.expect(std.mem.indexOf(u8, text, "\"purpose\":\"unmeasured_process_preconditioning\"") != null);1819    try std.testing.expect(std.mem.indexOf(u8, text, "\"execution_count\":2") != null);1820    try std.testing.expect(std.mem.indexOf(u8, text, "\"workload_output_retention\":\"last_warmup_execution\"") != null);1821    try std.testing.expect(std.mem.indexOf(u8, text, "\"wall_ns\":5") != null);1822    try std.testing.expect(std.mem.indexOf(u8, text, "\"stdout\":\"workloads/w/warmup/stdout.txt\"") != null);1823    try std.testing.expect(std.mem.indexOf(u8, text, "aggregate_reduction") == null);1824}18251826test "profiling record separates runtime preparation from catalog templates" {1827    const allocator = std.testing.allocator;1828    const workload = catalog.Workload{1829        .name = "fixture",1830        .package = "lib/fixture",1831        .step = "fixture-bench",1832        .summary = "fixture",1833        .tier = .smoke,1834        .surface = .benchmark,1835        .bin = .{1836            .path = "zig-out/bin/fixture",1837            .args = &.{ "consume", "{workload_root}/live" },1838        },1839        .prepare = .{1840            .argv = &.{ "zig-out/bin/fixture-helper", "prepare", "{workload_root}" },1841        },1842        .reset = .{1843            .argv = &.{ "zig-out/bin/fixture-helper", "reset", "{workload_root}" },1844        },1845        .environment = &.{1846            .{ .name = "HOME", .value = "{workload_root}/home" },1847            .{ .name = "FIXTURE_OBSERVATION_PATH" },1848        },1849    };1850    const catalog_text = try renderJsonDocument(1851        allocator,1852        writeCatalogWorkloadJson,1853        .{workload},1854    );1855    defer allocator.free(catalog_text);1856    try std.testing.expect(std.mem.indexOf(1857        u8,1858        catalog_text,1859        "\"args\":[\"consume\",\"{workload_root}/live\"]",1860    ) != null);1861    try std.testing.expect(std.mem.indexOf(1862        u8,1863        catalog_text,1864        "\"prepare\":{\"argv\":[\"zig-out/bin/fixture-helper\",\"prepare\",\"{workload_root}\"]",1865    ) != null);1866    try std.testing.expect(std.mem.indexOf(1867        u8,1868        catalog_text,1869        "\"reset\":{\"argv\":[\"zig-out/bin/fixture-helper\",\"reset\",\"{workload_root}\"]",1870    ) != null);1871    try std.testing.expect(std.mem.indexOf(1872        u8,1873        catalog_text,1874        "\"name\":\"HOME\",\"operation\":\"set\",\"value\":\"{workload_root}/home\"",1875    ) != null);1876    try std.testing.expect(std.mem.indexOf(1877        u8,1878        catalog_text,1879        "\"name\":\"FIXTURE_OBSERVATION_PATH\",\"operation\":\"unset\"",1880    ) != null);18811882    const runtime = catalog.Runtime{1883        .workload_root = "/tmp/profile/run/workloads/fixture",1884        .bin_args = &.{ "consume", "/tmp/profile/run/workloads/fixture/live" },1885        .prepare = .{1886            .argv = &.{1887                "zig-out/bin/fixture-helper",1888                "prepare",1889                "/tmp/profile/run/workloads/fixture",1890            },1891            .cwd = "lib/fixture",1892        },1893        .reset = .{1894            .argv = &.{1895                "zig-out/bin/fixture-helper",1896                "reset",1897                "/tmp/profile/run/workloads/fixture",1898            },1899            .cwd = "lib/fixture",1900        },1901        .environment = &.{1902            .{ .name = "HOME", .value = "/tmp/profile/run/workloads/fixture/home" },1903            .{ .name = "FIXTURE_OBSERVATION_PATH" },1904        },1905    };1906    const runtime_text = try renderJsonDocument(1907        allocator,1908        writeRuntimeJson,1909        .{runtime},1910    );1911    defer allocator.free(runtime_text);1912    try std.testing.expect(std.mem.indexOf(1913        u8,1914        runtime_text,1915        "\"workload_root\":\"/tmp/profile/run/workloads/fixture\"",1916    ) != null);1917    try std.testing.expect(std.mem.indexOf(1918        u8,1919        runtime_text,1920        "\"value\":\"/tmp/profile/run/workloads/fixture/home\"",1921    ) != null);19221923    const prepare = execute.CommandResult{1924        .command = "zig-out/bin/fixture-helper prepare /tmp/profile/run/workloads/fixture",1925        .argv = runtime.prepare.?.argv,1926        .cwd = runtime.prepare.?.cwd,1927        .stdout_path = "prepare.stdout.txt",1928        .stderr_path = "prepare.stderr.txt",1929        .execution = .{ .pid = 404, .exit_code = 0, .wall_ns = 11 },1930    };1931    const prepare_text = try renderJsonDocument(1932        allocator,1933        writePrepareJson,1934        .{@as(?execute.CommandResult, prepare)},1935    );1936    defer allocator.free(prepare_text);1937    try std.testing.expect(std.mem.indexOf(u8, prepare_text, "\"pid\":404") != null);1938    try std.testing.expect(std.mem.indexOf(1939        u8,1940        prepare_text,1941        "\"stdout\":\"prepare.stdout.txt\"",1942    ) != null);1943    try std.testing.expect(std.mem.indexOf(u8, prepare_text, "\"wall_ns\":11") != null);19441945    const resets = [_]Reset{.{1946        .sequence = 1,1947        .phase = .measurement,1948        .phase_index = 1,1949        .command = .{1950            .command = "/bin/true",1951            .argv = &.{"/bin/true"},1952            .cwd = "/tmp/fixture",1953            .stdout_path = "resets/001.stdout.txt",1954            .stderr_path = "resets/001.stderr.txt",1955            .execution = .{ .pid = 505, .exit_code = 0, .wall_ns = 12 },1956        },1957    }};1958    const reset_text = try renderJsonDocument(1959        allocator,1960        writeResetsJson,1961        .{resets[0..]},1962    );1963    defer allocator.free(reset_text);1964    try std.testing.expect(std.mem.indexOf(u8, reset_text, "\"receipt_count\":1") != null);1965    try std.testing.expect(std.mem.indexOf(u8, reset_text, "\"pid\":505") != null);1966    try std.testing.expect(std.mem.indexOf(u8, reset_text, "\"stdout\":\"resets/001.stdout.txt\"") != null);1967    try std.testing.expect(std.mem.indexOf(u8, reset_text, "\"wall_ns\":12") != null);1968}19691970test "profiling record retains capture controls and matched execution order" {1971    const allocator = std.testing.allocator;1972    const pairs = [_]perturbation.Pair{.{1973        .index = 1,1974        .order = .capture_first,1975        .control = .{ .pid = 201, .exit_code = 0, .wall_ns = 10 },1976        .capture = .{ .pid = 202, .exit_code = 0, .wall_ns = 12 },1977    }};1978    const text = try renderJsonDocument(1979        allocator,1980        writeCapturePerturbationJson,1981        .{@as(?perturbation.Measurement, .{1982            .state = .complete,1983            .base_seed = 7,1984            .workload_seed = 8,1985            .pairs = &pairs,1986            .configuration = .{ .tracy = true },1987            .control_artifacts = .{1988                .stdout = "control.stdout.txt",1989                .stderr = "control.stderr.txt",1990                .bench_jsonl = "control.bench.jsonl",1991                .coz_jsonl = "control.coz.jsonl",1992                .coz_analysis = "control.coz.analysis.json",1993                .tracy_jsonl = "control.tracy.jsonl",1994                .tracy_summary = "control.tracy.summary.jsonl",1995                .allocations = "control.allocations.jsonl",1996                .structured = "control.structured.jsonl",1997            },1998            .control_structured_rows = 2,1999        })},2000    );2001    defer allocator.free(text);2002    try std.testing.expect(std.mem.indexOf(u8, text, "\"method\":\"same_build_matched_control_capture\"") != null);2003    try std.testing.expect(std.mem.indexOf(u8, text, "\"binary_identity\":\"same_built_binary\"") != null);2004    try std.testing.expect(std.mem.indexOf(u8, text, "\"control_output_retention\":\"last_control_execution\"") != null);2005    try std.testing.expect(std.mem.indexOf(u8, text, "\"active_configuration\":{\"host_kind\":null,\"tracy\":true,\"allocations\":false}") != null);2006    try std.testing.expect(std.mem.indexOf(u8, text, "\"structured_rows\":2") != null);2007    try std.testing.expect(std.mem.indexOf(u8, text, "\"index\":1,\"order\":\"capture_first\"") != null);2008    try std.testing.expect(std.mem.indexOf(2009        u8,2010        text,2011        "\"control\":{\"spawn_state\":\"spawned\",\"pid\":201," ++2012            "\"exit_code\":0,\"wall_ns\":10",2013    ) != null);2014    try std.testing.expect(std.mem.indexOf(2015        u8,2016        text,2017        "\"capture\":{\"spawn_state\":\"spawned\",\"pid\":202," ++2018            "\"exit_code\":0,\"wall_ns\":12",2019    ) != null);2020}