tiny.profiling.analyze.load

1const std = @import("std");2const capture = @import("capture");3const sys = @import("sys");4const baseline = @import("../root.zig").baseline;5const allocation_trace = @import("../capture/root.zig").memtrace;6const catalog = @import("../root.zig").catalog;7const coz = @import("../capture/root.zig").coz;8const environment = @import("../root.zig").environment;9const host = @import("../root.zig").host;10const json = @import("../root.zig").json;11const measurement = @import("../root.zig").measurement;12const memory = @import("../root.zig").memory;13const metric = @import("../root.zig").metric;14const order = @import("../root.zig").order;15const plan = @import("../root.zig").plan;16const perturbation = @import("../root.zig").perturbation;17const record = @import("../root.zig").record;18const reducer = @import("../root.zig").reduction;19const trace_capture = @import("../capture/root.zig").tracy;20const ReductionDomainTestCase = @import("fixture/root.zig").ReductionDomainTestCase;21const Run = @import("root.zig").model.Run;22const Workload = @import("root.zig").model.Workload;23const interleavedTestSamples = @import("fixture/root.zig").interleavedTestSamples;24const measuredTestWorkload = @import("fixture/root.zig").measuredTestWorkload;25const relocated_coz_analysis_json = @import("fixture/root.zig").relocated_coz_analysis_json;26const relocated_run_start_json = @import("fixture/root.zig").relocated_run_start_json;27const relocated_workload_json = @import("fixture/root.zig").relocated_workload_json;28const repeated_measurement_workload_json = @import("fixture/root.zig").repeated_measurement_workload_json;29const writeReductionTestRun = @import("fixture/root.zig").writeReductionTestRun;3031const max_results_bytes = 128 * 1024 * 1024;32pub fn loadRun(allocator: std.mem.Allocator, input: []const u8) !Run {33    const run_ref = try baseline.resolveRun(allocator, input);34    const text = try sys.fs.readFileAlloc(allocator, run_ref.results_path, max_results_bytes);35    var workloads: std.ArrayList(Workload) = .empty;36    var suite: catalog.Suite = if (run_ref.suite) |suite_text| catalog.Suite.parse(suite_text) orelse .all else .all;37    var filters: []const []const u8 = &.{};38    var selection_known = false;39    var selected_workload_count: usize = 0;40    var git = GitIdentity{ .sha = null, .dirty = null };41    var optimize: ?[]const u8 = null;42    var run_host = environment.Host{};4344    var recorded_root: ?[]const u8 = null;45    var lines = std.mem.splitScalar(u8, text, '\n');46    while (lines.next()) |line| {47        if (std.mem.trim(u8, line, " \t\r").len == 0) continue;48        const value = try std.json.parseFromSliceLeaky(std.json.Value, allocator, line, .{});49        const object = try json.object(value);50        const event = json.string(object.get("event")) orelse continue;51        if (std.mem.eql(u8, event, "run_start")) {52            if (object.get("selection")) |selection_value| {53                const selection = try json.object(selection_value);54                if (json.string(selection.get("suite"))) |suite_text| suite = catalog.Suite.parse(suite_text) orelse suite;55                filters = try json.strings(allocator, selection.get("filters"));56                selected_workload_count = std.math.cast(57                    usize,58                    json.asU64(selection.get("workload_count")) orelse 0,59                ) orelse return error.InvalidProfilingJson;60                if (selected_workload_count > plan.max_workloads_per_run) {61                    return error.InvalidProfilingJson;62                }63                selection_known = true;64            }65            if (object.get("artifacts")) |artifacts_value| {66                const artifacts = try json.object(artifacts_value);67                recorded_root = json.string(artifacts.get("root"));68            }69            git = parseGit(object);70            optimize = parseOptimize(object);71            run_host = environment.parse(object.get("environment"));72        } else if (std.mem.eql(u8, event, "workload")) {73            if (workloads.items.len >= plan.max_workloads_per_run) {74                return error.InvalidProfilingJson;75            }76            const workload = try loadWorkload(77                allocator,78                object,79                workloads.items,80                selected_workload_count,81                recorded_root,82                run_ref.root,83            );84            try workloads.append(allocator, workload);85        }86    }8788    try normalizeRunOrder(allocator, workloads.items, selected_workload_count);8990    return .{91        .ref = run_ref,92        .suite = suite,93        .filters = filters,94        .selection_known = selection_known,95        .git_sha = git.sha,96        .git_dirty = git.dirty,97        .optimize = optimize,98        .host = run_host,99        .workloads = try workloads.toOwnedSlice(allocator),100    };101}102103fn loadWorkload(104    allocator: std.mem.Allocator,105    object: std.json.ObjectMap,106    preceding_workloads: []const Workload,107    selected_workload_count: usize,108    recorded_root: ?[]const u8,109    actual_root: []const u8,110) !Workload {111    var workload = try parseWorkload(112        allocator,113        object,114        preceding_workloads,115        selected_workload_count,116    );117    try relocateWorkload(allocator, &workload, recorded_root, actual_root);118    workload.perf_stat = try loadCounterSummary(allocator, workload);119    try finalizeExecutionSummary(&workload);120    try verifyBenchmarkReduction(allocator, workload);121    const artifacts = workload.analysisArtifacts();122    const structured_path = if (artifacts) |actual| actual.structured else null;123    workload.metrics = switch (workload.benchmark_process_reduction) {124        .not_applicable => try metric.load(allocator, structured_path),125        .complete => |complete| try reductionMetrics(126            allocator,127            workload.name,128            complete,129        ),130    };131    workload.memory_metrics = try memory.load(allocator, .{132        .structured_path = structured_path,133        .allocation_repetitions_path = workload.allocation_repetitions_path,134        .expected_executions = workload.execution_count,135        .workload = workload.name,136    });137    const coz_analysis_path = if (artifacts) |actual| actual.coz_analysis else null;138    workload.causal = try coz.load(allocator, workload.name, coz_analysis_path);139    return workload;140}141142fn verifyBenchmarkReduction(143    allocator: std.mem.Allocator,144    workload: Workload,145) !void {146    if (workload.executions.len > reducer.max_processes) {147        return error.InvalidProfilingJson;148    }149    var inputs: [reducer.max_processes]reducer.Execution = undefined;150    for (workload.executions, inputs[0..workload.executions.len]) |execution, *input| {151        const artifacts = execution.artifacts;152        input.* = .{153            .index = execution.index,154            .acquisition_position = execution.acquisition_position,155            .exit_code = execution.exit_code,156            .bench_jsonl = if (artifacts) |actual| actual.bench_jsonl else "",157            .structured = if (artifacts) |actual| actual.structured else "",158        };159    }160    try reducer.verify(161        allocator,162        workload.benchmark_process_reduction,163        inputs[0..workload.executions.len],164        directBenchmarkReductionDomain(workload),165    );166}167168pub fn directBenchmarkReductionDomain(workload: Workload) bool {169    return reducer.directBenchmarkDomain(workload.benchmark_process_domain);170}171172fn reductionMetrics(173    allocator: std.mem.Allocator,174    workload_name: []const u8,175    complete: reducer.Complete,176) ![]const metric.Metric {177    const result = try allocator.alloc(metric.Metric, complete.benchmarks.len);178    for (complete.benchmarks, result) |benchmark_value, *row| {179        row.* = .{180            .workload = workload_name,181            .key = benchmark_value.key,182            .label = try std.fmt.allocPrint(183                allocator,184                "{s} {s}",185                .{ benchmark_value.suite, benchmark_value.id },186            ),187            .source_kind = "benchmark_process_reduction",188            .source_path = complete.sources[0].bench_jsonl.path,189            .source_line = 0,190            .sample_count = @intCast(benchmark_value.sample_ns.len),191            .mean_ns = benchmark_value.statistics.mean_ns,192            .median_ns = @floatFromInt(benchmark_value.statistics.median_ns),193            .p75_ns = @floatFromInt(benchmark_value.statistics.p75_ns),194            .p95_ns = @floatFromInt(benchmark_value.statistics.p95_ns),195            .p99_ns = @floatFromInt(benchmark_value.statistics.p99_ns),196            .min_ns = @floatFromInt(benchmark_value.statistics.min_ns),197            .max_ns = @floatFromInt(benchmark_value.statistics.max_ns),198            .mean_interval = null,199            .median_interval = .{200                .low_ns = benchmark_value.statistics.median_interval.low_ns,201                .high_ns = benchmark_value.statistics.median_interval.high_ns,202            },203            .p95_interval = null,204            .p99_interval = null,205            .samples_ns = benchmark_value.sample_ns,206            .sample_sequence = .{207                .order = .measured_acquisition_order,208                .index_origin = 0,209            },210            .distribution = .confidence_interval,211        };212    }213    return result;214}215216fn normalizeRunOrder(217    allocator: std.mem.Allocator,218    workloads: []Workload,219    selected_workload_count: usize,220) !void {221    if (selected_workload_count != 0 and workloads.len > selected_workload_count) {222        return error.InvalidProfilingJson;223    }224    const acquired_workload_count = @max(selected_workload_count, workloads.len);225    for (workloads) |*workload| switch (workload.acquisition) {226        .blocked => |*blocked| blocked.workload_count = @max(227            blocked.workload_count,228            acquired_workload_count,229        ),230        .random_interleaved => {},231    };232    try validateOrderRun(allocator, workloads, selected_workload_count);233}234235const GitIdentity = struct {236    sha: ?[]const u8,237    dirty: ?bool,238};239240fn parseGit(object: std.json.ObjectMap) GitIdentity {241    const environment_object = json.object(object.get("environment") orelse return .{242        .sha = null,243        .dirty = null,244    }) catch return .{ .sha = null, .dirty = null };245    const git = json.object(environment_object.get("git") orelse return .{246        .sha = null,247        .dirty = null,248    }) catch return .{ .sha = null, .dirty = null };249    return .{250        .sha = json.string(git.get("commit")),251        .dirty = json.asBool(git.get("dirty")),252    };253}254255fn parseOptimize(object: std.json.ObjectMap) ?[]const u8 {256    const environment_object = json.object(object.get("environment") orelse return null) catch257        return null;258    const build = json.object(environment_object.get("build") orelse return null) catch259        return null;260    return json.string(build.get("optimize"));261}262263pub fn parseWorkload(264    allocator: std.mem.Allocator,265    object: std.json.ObjectMap,266    preceding_workloads: []const Workload,267    selected_workload_count: usize,268) !Workload {269    const schema_name = json.string(object.get("schema")) orelse270        return error.UnsupportedProfilingWorkloadSchema;271    if (!std.mem.eql(u8, schema_name, record.workload_schema)) {272        return error.UnsupportedProfilingWorkloadSchema;273    }274    const workload = try json.object(object.get("workload") orelse return error.InvalidProfilingJson);275    const status = try json.object(object.get("status") orelse return error.InvalidProfilingJson);276    const timing = try json.object(object.get("timing") orelse return error.InvalidProfilingJson);277    const resources = if (object.get("resources")) |value| try json.object(value) else null;278    const artifacts = try json.object(279        object.get("artifacts") orelse return error.InvalidProfilingJson,280    );281    const artifact_root = try requiredArtifactPath(artifacts, "root");282    const warmup = if (object.get("warmup")) |value| try json.object(value) else null;283    const warmup_artifacts = if (warmup) |actual|284        if (actual.get("artifacts")) |value| json.object(value) catch null else null285    else286        null;287    const total_wall_ns = json.asU64(timing.get("wall_ns")) orelse 0;288    const name = json.string(workload.get("name")) orelse return error.InvalidProfilingJson;289    const capture_perturbation = try perturbation.parseMeasurement(allocator, object);290    const executions = try measurement.parseExecutions(291        allocator,292        object,293        artifact_root,294    );295    const measurement_object = try json.object(object.get("measurement").?);296    const output_retention = try measurement.outputRetention(measurement_object);297    var result = Workload{298        .name = name,299        .package = json.string(workload.get("package")) orelse "",300        .step = json.string(workload.get("step")) orelse "",301        .surface = std.meta.stringToEnum(302            catalog.Surface,303            json.string(workload.get("surface")) orelse304                return error.InvalidProfilingJson,305        ) orelse return error.InvalidProfilingJson,306        .acquisition = try parseAcquisition(307            allocator,308            object,309            name,310            preceding_workloads,311            selected_workload_count,312        ),313        .status = json.string(status.get("state")) orelse "unknown",314        .exit_code = json.asI64(status.get("exit_code")) orelse -1,315        .wall_ns = total_wall_ns,316        .total_wall_ns = total_wall_ns,317        .executions = executions,318        .measurement_recorded = object.get("measurement") != null,319        .warmups = try measurement.parseWarmups(allocator, object),320        .warmup_stdout_path = if (warmup_artifacts) |actual| json.string(actual.get("stdout")) else null,321        .warmup_stderr_path = if (warmup_artifacts) |actual| json.string(actual.get("stderr")) else null,322        .resource_usage_source = try parseResourceUsageSource(resources),323        .max_rss_kib = if (resources) |actual| json.asI64(actual.get("max_rss_kib")) else null,324        .user_s = if (resources) |actual| json.asF64(actual.get("user_s")) else null,325        .system_s = if (resources) |actual| json.asF64(actual.get("system_s")) else null,326        .minor_page_faults = resourceValue(resources, "minor_page_faults"),327        .major_page_faults = resourceValue(resources, "major_page_faults"),328        .voluntary_context_switches = resourceValue(resources, "voluntary_context_switches"),329        .involuntary_context_switches = resourceValue(resources, "involuntary_context_switches"),330        .result_path = json.string(artifacts.get("result")),331        .allocation_repetitions_path = json.string(332            artifacts.get("allocation_repetitions"),333        ),334        .profiler_artifacts = try parseProfilerArtifacts(335            artifacts,336            output_retention,337            artifact_root,338        ),339        .benchmark_process_reduction = try reducer.parse(340            allocator,341            measurement_object.get("benchmark_process_reduction") orelse342                return error.InvalidProfilingJson,343        ),344        .benchmark_process_domain = try reducer.parseDomain(345            measurement_object.get("benchmark_process_domain") orelse346                return error.InvalidProfilingJson,347        ),348        .captures = try parseCaptures(allocator, object),349        .capture_perturbation = capture_perturbation,350        .capture_perturbation_summary = if (capture_perturbation) |actual|351            try perturbation.summarize(allocator, actual, name)352        else353            null,354    };355    try retainWorkloadIdentity(allocator, object, &result);356    try validateBenchmarkReductionDomain(result);357    try validateMeasurementOrder(object, result.acquisition.method());358    try validateWorkloadOrder(result);359    return result;360}361362fn parseProfilerArtifacts(363    artifacts: std.json.ObjectMap,364    retention: measurement.OutputRetention,365    workload_root: []const u8,366) !?measurement.ExecutionArtifacts {367    if (retention != .profiler_capture_contract) {368        if (hasProfilerArtifactFields(artifacts)) {369            return error.InvalidProfilingJson;370        }371        return null;372    }373    const result = measurement.ExecutionArtifacts{374        .root = workload_root,375        .stdout = try requiredArtifactPath(artifacts, "stdout"),376        .stderr = try requiredArtifactPath(artifacts, "stderr"),377        .bench_jsonl = try requiredArtifactPath(artifacts, "bench_jsonl"),378        .coz_jsonl = try requiredArtifactPath(artifacts, "coz_jsonl"),379        .coz_analysis = try requiredArtifactPath(artifacts, "coz_analysis"),380        .tracy_jsonl = try requiredArtifactPath(artifacts, "tracy_jsonl"),381        .tracy_summary = try requiredArtifactPath(artifacts, "tracy_summary"),382        .allocations = try requiredArtifactPath(artifacts, "allocations"),383        .structured = try requiredArtifactPath(artifacts, "structured"),384        .structured_rows = try artifactCount(artifacts, "structured_rows"),385        .structured_parse_errors = try artifactCount(386            artifacts,387            "structured_parse_errors",388        ),389    };390    try measurement.validateProfilerArtifacts(result, workload_root);391    return result;392}393394fn hasProfilerArtifactFields(artifacts: std.json.ObjectMap) bool {395    inline for (.{396        "stdout",397        "stderr",398        "bench_jsonl",399        "coz_jsonl",400        "coz_analysis",401        "tracy_jsonl",402        "tracy_summary",403        "allocations",404        "structured",405        "structured_rows",406        "structured_parse_errors",407    }) |field| {408        if (artifacts.get(field) != null) return true;409    }410    return false;411}412413fn requiredArtifactPath(414    object: std.json.ObjectMap,415    field: []const u8,416) ![]const u8 {417    const path = json.string(object.get(field)) orelse418        return error.InvalidProfilingJson;419    if (path.len == 0) return error.InvalidProfilingJson;420    return path;421}422423fn artifactCount(object: std.json.ObjectMap, field: []const u8) !usize {424    return std.math.cast(425        usize,426        json.asU64(object.get(field)) orelse return error.InvalidProfilingJson,427    ) orelse error.InvalidProfilingJson;428}429430fn parseResourceUsageSource(431    resources: ?std.json.ObjectMap,432) !?sys.process.ResourceUsageSource {433    const object = resources orelse return null;434    const text = json.string(object.get("resource_usage_source")) orelse return null;435    return std.meta.stringToEnum(sys.process.ResourceUsageSource, text) orelse436        error.InvalidProfilingJson;437}438439fn resourceValue(resources: ?std.json.ObjectMap, field: []const u8) ?f64 {440    const object = resources orelse return null;441    return json.asF64(object.get(field));442}443444fn retainWorkloadIdentity(445    allocator: std.mem.Allocator,446    object: std.json.ObjectMap,447    result: *Workload,448) !void {449    const command = if (object.get("command")) |value|450        try json.object(value)451    else452        null;453    result.command_argv = if (command) |actual|454        try json.strings(allocator, actual.get("argv"))455    else456        &.{};457    result.command_cwd = if (command) |actual| json.string(actual.get("cwd")) else null;458    result.command_identity_recorded = if (command) |actual|459        actual.get("cwd") != null and actual.get("argv") != null460    else461        false;462    result.scope = json.string(object.get("scope")) orelse463        return error.InvalidProfilingJson;464    result.scope_recorded = true;465    result.causal_enabled = json.asBool(object.get("causal")) orelse466        return error.InvalidProfilingJson;467    result.tracy_enabled = json.asBool(object.get("tracy")) orelse468        return error.InvalidProfilingJson;469    result.allocations_enabled = json.asBool(object.get("trace_allocations")) orelse470        return error.InvalidProfilingJson;471    result.profiler_configuration_recorded = true;472    result.warmup_recorded = object.get("warmup") != null;473}474475fn validateBenchmarkReductionDomain(workload: Workload) !void {476    const declaration = workload.benchmark_process_domain;477    if (declaration.benchmark_surface != (workload.surface == .benchmark) or478        declaration.direct_execution !=479            std.mem.eql(u8, workload.scope, host.direct_scope) or480        declaration.tracy != workload.tracy_enabled or481        declaration.causal != workload.causal_enabled or482        declaration.allocation_trace != workload.allocations_enabled)483    {484        return error.InvalidProfilingJson;485    }486    if (workload.profiler_artifacts != null and !declaration.host_profiler) {487        return error.InvalidProfilingJson;488    }489    if (workload.capture_perturbation != null and !declaration.capture_control) {490        return error.InvalidProfilingJson;491    }492    if (reducer.directBenchmarkDomain(declaration) and workload.captures.len != 0) {493        return error.InvalidProfilingJson;494    }495    for (workload.captures) |capture_value| {496        if (!captureMatchesDomain(capture_value.kind, declaration)) {497            return error.InvalidProfilingJson;498        }499    }500}501502fn captureMatchesDomain(503    kind: []const u8,504    declaration: reducer.DomainDeclaration,505) bool {506    inline for (.{507        host.counters.kind,508        host.sampling.kind,509        host.dhat.kind,510        host.offcpu.kind,511        host.coverage.kind,512    }) |host_kind| {513        if (std.mem.eql(u8, kind, host_kind)) return declaration.host_profiler;514    }515    if (std.mem.eql(u8, kind, trace_capture.kind)) return declaration.tracy;516    if (std.mem.eql(u8, kind, coz.capture_kind)) return declaration.causal;517    if (std.mem.eql(u8, kind, allocation_trace.kind)) {518        return declaration.allocation_trace;519    }520    return true;521}522523fn validateMeasurementOrder(524    object: std.json.ObjectMap,525    method: order.Method,526) !void {527    const measurement_value = object.get("measurement") orelse {528        if (method == .random_interleaved) return error.InvalidProfilingJson;529        return;530    };531    const measurement_object = try json.object(measurement_value);532    const recorded = json.string(measurement_object.get("acquisition_order")) orelse {533        if (method == .random_interleaved) return error.InvalidProfilingJson;534        return;535    };536    if (std.mem.eql(u8, recorded, method.acquisitionName())) return;537    return error.InvalidProfilingJson;538}539540fn parseAcquisition(541    allocator: std.mem.Allocator,542    object: std.json.ObjectMap,543    workload_name: []const u8,544    preceding_workloads: []const Workload,545    selected_workload_count: usize,546) !order.Context {547    const position = preceding_workloads.len + 1;548    if (object.get("index")) |index_value| {549        const recorded_index = json.asU64(index_value) orelse550            return error.InvalidProfilingJson;551        if (recorded_index != preceding_workloads.len) return error.InvalidProfilingJson;552    }553    const predecessors = try allocator.alloc([]const u8, preceding_workloads.len);554    for (preceding_workloads, 0..) |workload, index| predecessors[index] = workload.name;555    const acquisition_value = object.get("acquisition") orelse return .{556        .blocked = .{557            .position = position,558            .workload_count = @max(selected_workload_count, position),559            .predecessors = predecessors,560        },561    };562    const recorded = try order.parse(allocator, acquisition_value);563    switch (recorded) {564        .blocked => |blocked| {565            if (blocked.position != position or566                (selected_workload_count != 0 and567                    blocked.workload_count != selected_workload_count) or568                blocked.predecessors.len != predecessors.len)569            {570                return error.InvalidProfilingJson;571            }572            for (blocked.predecessors, predecessors) |actual, expected| {573                if (!std.mem.eql(u8, actual, expected)) {574                    return error.InvalidProfilingJson;575                }576            }577        },578        .random_interleaved => |interleaved| {579            if ((selected_workload_count != 0 and580                interleaved.workload_count != selected_workload_count) or581                preceding_workloads.len >= interleaved.selected_workloads.len or582                !std.mem.eql(583                    u8,584                    interleaved.selected_workloads[preceding_workloads.len],585                    workload_name,586                ))587            {588                return error.InvalidProfilingJson;589            }590        },591    }592    return recorded;593}594595fn validateWorkloadOrder(workload: Workload) !void {596    switch (workload.acquisition) {597        .blocked => {598            for (workload.executions) |execution| {599                if (execution.acquisition_position != null) {600                    return error.InvalidProfilingJson;601                }602            }603        },604        .random_interleaved => |interleaved| {605            if (workload.executions.len > interleaved.repeat_count or606                (workload.exit_code == 0 and607                    workload.executions.len != interleaved.repeat_count))608            {609                return error.InvalidProfilingJson;610            }611            for (workload.executions, 0..) |execution, index| {612                if (execution.acquisition_position != interleaved.positions[index]) {613                    return error.InvalidProfilingJson;614                }615            }616        },617    }618}619620fn validateOrderRun(621    allocator: std.mem.Allocator,622    workloads: []const Workload,623    selected_workload_count: usize,624) !void {625    if (workloads.len == 0) return;626    const first = switch (workloads[0].acquisition) {627        .blocked => {628            for (workloads[1..]) |workload| switch (workload.acquisition) {629                .blocked => {},630                .random_interleaved => return error.InvalidProfilingJson,631            };632            return;633        },634        .random_interleaved => |value| value,635    };636    if (selected_workload_count != 0 and637        first.workload_count != selected_workload_count)638    {639        return error.InvalidProfilingJson;640    }641    if (workloads.len > first.workload_count) return error.InvalidProfilingJson;642    _ = allocator;643    var positions_seen: [order.max_schedule_entries]bool = @splat(false);644    const schedule_len = first.workload_count * @as(usize, first.repeat_count);645    for (workloads, 0..) |workload, index| {646        const context = switch (workload.acquisition) {647            .blocked => return error.InvalidProfilingJson,648            .random_interleaved => |value| value,649        };650        if (context.seed != first.seed or651            !order.sameDesign(652                .{ .random_interleaved = first },653                .{ .random_interleaved = context },654            ))655        {656            return error.InvalidProfilingJson;657        }658        if (!std.mem.eql(u8, workload.name, first.selected_workloads[index])) {659            return error.InvalidProfilingJson;660        }661        for (context.positions) |position| {662            if (positions_seen[position - 1]) return error.InvalidProfilingJson;663            positions_seen[position - 1] = true;664        }665    }666    if (workloads.len == first.workload_count) {667        for (positions_seen[0..schedule_len]) |seen| {668            if (!seen) return error.InvalidProfilingJson;669        }670    }671}672673pub fn parseCaptures(allocator: std.mem.Allocator, object: std.json.ObjectMap) ![]const host.Capture {674    const value = object.get("captures") orelse return &.{};675    const rows = json.array(value) catch return &.{};676    var result: std.ArrayList(host.Capture) = .empty;677    for (rows.items) |item| {678        const row = json.object(item) catch continue;679        try result.append(allocator, .{680            .kind = json.string(row.get("kind")) orelse continue,681            .tool = json.string(row.get("tool")) orelse "",682            .tool_version = json.string(row.get("tool_version")),683            .scope = json.string(row.get("scope")) orelse host.scope,684            .capture_path = json.string(row.get("capture")) orelse "",685            .summary_path = json.string(row.get("summary")) orelse "",686            .state = json.string(row.get("state")) orelse "unknown",687            .caveat_kind = json.string(row.get("caveat_kind")),688            .caveat_message = json.string(row.get("caveat_message")),689        });690    }691    return try result.toOwnedSlice(allocator);692}693694pub fn relocateWorkload(allocator: std.mem.Allocator, workload: *Workload, recorded_root: ?[]const u8, actual_root: []const u8) !void {695    workload.result_path = try relocatePath(allocator, workload.result_path, recorded_root, actual_root);696    workload.warmup_stdout_path = try relocatePath(allocator, workload.warmup_stdout_path, recorded_root, actual_root);697    workload.warmup_stderr_path = try relocatePath(allocator, workload.warmup_stderr_path, recorded_root, actual_root);698    workload.allocation_repetitions_path = try relocatePath(699        allocator,700        workload.allocation_repetitions_path,701        recorded_root,702        actual_root,703    );704    const executions = try allocator.dupe(measurement.Execution, workload.executions);705    for (executions) |*execution| {706        if (execution.artifacts) |artifacts| {707            execution.artifacts = try relocateExecutionArtifacts(708                allocator,709                artifacts,710                recorded_root,711                actual_root,712            );713        }714    }715    workload.executions = executions;716    try reducer.relocate(717        allocator,718        &workload.benchmark_process_reduction,719        recorded_root,720        actual_root,721    );722    if (workload.profiler_artifacts) |artifacts| {723        workload.profiler_artifacts = try relocateExecutionArtifacts(724            allocator,725            artifacts,726            recorded_root,727            actual_root,728        );729    }730    try relocateCapturePerturbation(allocator, workload, recorded_root, actual_root);731    const rows = try allocator.dupe(host.Capture, workload.captures);732    for (rows) |*row| {733        row.capture_path = (try relocatePath(allocator, row.capture_path, recorded_root, actual_root)) orelse row.capture_path;734        row.summary_path = (try relocatePath(allocator, row.summary_path, recorded_root, actual_root)) orelse row.summary_path;735    }736    workload.captures = rows;737}738739fn relocateExecutionArtifacts(740    allocator: std.mem.Allocator,741    artifacts: measurement.ExecutionArtifacts,742    recorded_root: ?[]const u8,743    actual_root: []const u8,744) !measurement.ExecutionArtifacts {745    var result = artifacts;746    inline for (.{747        "root",748        "stdout",749        "stderr",750        "bench_jsonl",751        "coz_jsonl",752        "coz_analysis",753        "tracy_jsonl",754        "tracy_summary",755        "allocations",756        "structured",757    }) |field| {758        @field(result, field) = (try relocatePath(759            allocator,760            @field(result, field),761            recorded_root,762            actual_root,763        )).?;764    }765    return result;766}767768fn relocateCapturePerturbation(769    allocator: std.mem.Allocator,770    workload: *Workload,771    recorded_root: ?[]const u8,772    actual_root: []const u8,773) !void {774    var measurement_value = workload.capture_perturbation orelse return;775    var paths = measurement_value.control_artifacts;776    paths.stdout = (try relocatePath(allocator, paths.stdout, recorded_root, actual_root)).?;777    paths.stderr = (try relocatePath(allocator, paths.stderr, recorded_root, actual_root)).?;778    paths.bench_jsonl = (try relocatePath(allocator, paths.bench_jsonl, recorded_root, actual_root)).?;779    paths.coz_jsonl = (try relocatePath(allocator, paths.coz_jsonl, recorded_root, actual_root)).?;780    paths.coz_analysis = (try relocatePath(allocator, paths.coz_analysis, recorded_root, actual_root)).?;781    paths.tracy_jsonl = (try relocatePath(allocator, paths.tracy_jsonl, recorded_root, actual_root)).?;782    paths.tracy_summary = (try relocatePath(allocator, paths.tracy_summary, recorded_root, actual_root)).?;783    paths.allocations = (try relocatePath(allocator, paths.allocations, recorded_root, actual_root)).?;784    paths.structured = (try relocatePath(allocator, paths.structured, recorded_root, actual_root)).?;785    measurement_value.control_artifacts = paths;786    workload.capture_perturbation = measurement_value;787}788789fn relocatePath(allocator: std.mem.Allocator, recorded: ?[]const u8, recorded_root: ?[]const u8, actual_root: []const u8) !?[]const u8 {790    const path = recorded orelse return null;791    const from = recorded_root orelse return path;792    if (std.mem.eql(u8, from, actual_root)) return path;793    if (!pathHasPrefix(path, from)) return path;794    return try std.fmt.allocPrint(allocator, "{s}{s}", .{ actual_root, path[from.len..] });795}796797fn pathHasPrefix(path: []const u8, prefix: []const u8) bool {798    if (prefix.len == 0 or !std.mem.startsWith(u8, path, prefix)) return false;799    if (path.len == prefix.len) return true;800    return path[prefix.len] == std.fs.path.sep;801}802803pub fn loadCounterSummary(allocator: std.mem.Allocator, workload: Workload) !?capture.perfstat.Summary {804    if (workload.perf_stat) |summary| return summary;805    return measurement.loadPerfStatSummary(allocator, workload.captures);806}807808pub fn finalizeExecutionSummary(workload: *Workload) !void {809    workload.warmup_count = workload.warmups.len;810    workload.warmup_total_wall_ns = measurement.totalWallNs(workload.warmups);811    if (workload.warmups.len != 0) {812        const warmup_stats = try measurement.summarize(813            workload.warmup_total_wall_ns,814            .{},815            workload.warmups,816            null,817        );818        workload.warmup_distribution = warmup_stats.wall_distribution;819    }820    if (workload.measurement_recorded and workload.executions.len == 0) {821        workload.wall_ns = 0;822        workload.total_wall_ns = 0;823        workload.execution_count = 0;824        workload.wall_distribution = null;825        workload.resource_usage_source = null;826        workload.user_s = null;827        workload.system_s = null;828        workload.minor_page_faults = null;829        workload.major_page_faults = null;830        workload.voluntary_context_switches = null;831        workload.involuntary_context_switches = null;832        return;833    }834    const stats = try measurement.summarize(835        workload.total_wall_ns,836        .{837            .source = workload.resource_usage_source,838            .user_s = workload.user_s,839            .system_s = workload.system_s,840            .minor_page_faults = workload.minor_page_faults,841            .major_page_faults = workload.major_page_faults,842            .voluntary_context_switches = workload.voluntary_context_switches,843            .involuntary_context_switches = workload.involuntary_context_switches,844        },845        workload.executions,846        workload.perf_stat,847    );848    workload.wall_ns = stats.wall_ns;849    workload.total_wall_ns = stats.total_wall_ns;850    workload.execution_count = stats.execution_count;851    workload.executions = stats.executions;852    workload.wall_distribution = stats.wall_distribution;853    workload.resource_usage_source = stats.resource_usage_source;854    workload.user_s = stats.user_s;855    workload.system_s = stats.system_s;856    workload.minor_page_faults = stats.minor_page_faults;857    workload.major_page_faults = stats.major_page_faults;858    workload.voluntary_context_switches = stats.voluntary_context_switches;859    workload.involuntary_context_switches = stats.involuntary_context_switches;860}861862test "profiling analysis rebases relocated run artifacts onto the resolved root" {863    var tmp = std.testing.tmpDir(.{});864    defer tmp.cleanup();865    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);866    defer arena_state.deinit();867    const allocator = arena_state.allocator();868869    const base = try std.fs.path.join(allocator, &.{ ".zig-cache", "tmp", tmp.sub_path[0..] });870    const root = try std.fs.path.join(allocator, &.{ base, "run-a" });871    const workload_dir = try std.fs.path.join(allocator, &.{ root, "workloads", "w" });872    try sys.fs.createDirPath(workload_dir);873874    const manifest_path = try std.fs.path.join(allocator, &.{ root, "manifest.json" });875    try sys.fs.writeFile(manifest_path,876        \\{"schema":"tiny.profiling.run/v1","event":"manifest","run_id":"run-a","selection":{"suite":"smoke","filters":[]},"artifacts":{"root":"zig-out/profiling/run-a","results":"zig-out/profiling/run-a/results.jsonl","manifest":"zig-out/profiling/run-a/manifest.json"}}877        \\878    );879    const results_path = try std.fs.path.join(allocator, &.{ root, "results.jsonl" });880    const workload_line = try std.mem.replaceOwned(881        u8,882        allocator,883        relocated_workload_json,884        "\n",885        "",886    );887    try sys.fs.writeFile(888        results_path,889        try std.fmt.allocPrint(890            allocator,891            "{s}\n{s}\n",892            .{ relocated_run_start_json, workload_line },893        ),894    );895    const structured_path = try std.fs.path.join(allocator, &.{ workload_dir, "structured.jsonl" });896    try sys.fs.writeFile(structured_path,897        \\{"schema":"tiny.profiling.structured/v1","workload":{"name":"w","package":"lib/w","step":"w-bench"},"source":{"kind":"bench_jsonl","path":"bench.jsonl","line":1},"row":{"schema":"tiny.profiling.metric/v1","event":"bench_end","family":"timing","metric":"duration_ns","unit":"ns","suite":"bench","name":"case","sample_ns":[10,20,30]}}898        \\899    );900    const coz_path = try std.fs.path.join(allocator, &.{ workload_dir, "bench.coz.analysis.json" });901    try sys.fs.writeFile(coz_path, relocated_coz_analysis_json);902903    const run_value = try loadRun(allocator, root);904    try std.testing.expectEqualStrings(root, run_value.ref.root);905    try std.testing.expectEqualStrings("abcdef", run_value.git_sha.?);906    try std.testing.expectEqual(false, run_value.git_dirty.?);907    try std.testing.expectEqualStrings("ReleaseFast", run_value.optimize.?);908    try std.testing.expectEqualStrings("bench-a", run_value.host.hostname.?);909    try std.testing.expectEqualStrings("policy-a", run_value.host.cpu_frequency_policy.?);910    try std.testing.expectEqualStrings("0-15", run_value.host.process_cpu_affinity.?);911    try std.testing.expectEqualStrings("0", run_value.host.process_memory_affinity.?);912    try std.testing.expectEqual(@as(usize, 1), run_value.workloads.len);913    try std.testing.expectEqualStrings("lib/w", run_value.workloads[0].command_cwd.?);914    try std.testing.expectEqualStrings("w-bench", run_value.workloads[0].command_argv[2]);915    try std.testing.expect(run_value.workloads[0].command_identity_recorded);916    try std.testing.expect(run_value.workloads[0].scope_recorded);917    try std.testing.expect(!directBenchmarkReductionDomain(run_value.workloads[0]));918    try std.testing.expect(run_value.workloads[0].warmup_recorded);919    try std.testing.expect(run_value.workloads[0].profiler_configuration_recorded);920    try std.testing.expect(run_value.workloads[0].allocations_enabled);921    const artifacts = run_value.workloads[0].analysisArtifacts().?;922    try std.testing.expectEqualStrings(structured_path, artifacts.structured);923    const expected_stdout = try std.fs.path.join(allocator, &.{ workload_dir, "stdout.txt" });924    try std.testing.expectEqualStrings(expected_stdout, artifacts.stdout);925    try std.testing.expectEqual(@as(usize, 1), run_value.workloads[0].metrics.len);926    try std.testing.expectEqual(@as(f64, 20), run_value.workloads[0].metrics[0].median_ns.?);927    try std.testing.expectEqual(@as(usize, 1), run_value.workloads[0].causal.len);928    try std.testing.expectEqual(@as(f64, 0.25), run_value.workloads[0].causal[0].max_program_speedup);929    try std.testing.expectEqual(@as(usize, 1), run_value.causalCount());930}931932pub fn expectExcludedReductionTestRun(933    allocator: std.mem.Allocator,934    output_root: []const u8,935    case: ReductionDomainTestCase,936) !void {937    const fixture = try writeReductionTestRun(938        allocator,939        output_root,940        case.run_id,941        case.declaration,942    );943    const run_value = try loadRun(allocator, fixture.results);944    const workload = run_value.workloads[0];945    try std.testing.expect(!directBenchmarkReductionDomain(workload));946    try std.testing.expect(std.meta.eql(947        case.declaration,948        workload.benchmark_process_domain,949    ));950    try std.testing.expectEqual(@as(usize, 2), workload.executions.len);951    try std.testing.expect(workload.executions[0].artifacts != null);952    try std.testing.expect(workload.profiler_artifacts == null);953    try std.testing.expect(workload.capture_perturbation == null);954    try std.testing.expectEqual(955        @as(usize, if (case.declaration.host_profiler) 1 else 0),956        workload.captures.len,957    );958    try std.testing.expectEqual(959        reducer.NotApplicableReason.outside_direct_benchmark_domain,960        workload.benchmark_process_reduction.not_applicable.reason,961    );962    if (!case.declaration.host_profiler) return;963    const recorded = try sys.fs.readFileAlloc(964        allocator,965        fixture.results,966        max_results_bytes,967    );968    const direct = try std.mem.replaceOwned(969        u8,970        allocator,971        recorded,972        "\"host_profiler\":true",973        "\"host_profiler\":false",974    );975    const unknown = try std.mem.replaceOwned(976        u8,977        allocator,978        direct,979        "\"kind\":\"dhat\"",980        "\"kind\":\"future_capture\"",981    );982    try sys.fs.writeFile(fixture.results, unknown);983    try std.testing.expectError(984        error.InvalidProfilingJson,985        loadRun(allocator, fixture.results),986    );987}988989test "profiling analysis loads verified process reduction and rejects tampering" {990    var tmp = std.testing.tmpDir(.{});991    defer tmp.cleanup();992    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);993    defer arena_state.deinit();994    const allocator = arena_state.allocator();995    const output_root = try tmp.parent_dir.realPathFileAlloc(996        std.testing.io,997        tmp.sub_path[0..],998        allocator,999    );1000    const declaration = reducer.DomainDeclaration{1001        .benchmark_surface = true,1002        .direct_execution = true,1003        .host_profiler = false,1004        .tracy = false,1005        .causal = false,1006        .allocation_trace = false,1007        .capture_control = false,1008    };1009    const fixture = try writeReductionTestRun(1010        allocator,1011        output_root,1012        "direct",1013        declaration,1014    );1015    const run_value = try loadRun(allocator, fixture.results);1016    try std.testing.expectEqual(@as(usize, 1), run_value.workloads.len);1017    const workload = run_value.workloads[0];1018    try std.testing.expect(directBenchmarkReductionDomain(workload));1019    try std.testing.expectEqualStrings(1020        "multiple_execution_receipts_reduced",1021        workload.structuredAnalysisState(),1022    );1023    try std.testing.expectEqual(@as(usize, 1), workload.metrics.len);1024    try std.testing.expectEqualSlices(1025        u64,1026        &.{ 10, 10 },1027        workload.metrics[0].samples_ns,1028    );1029    try std.testing.expectEqual(1030        metric.Distribution.confidence_interval,1031        workload.metrics[0].distribution,1032    );1033    try sys.fs.appendFile(fixture.first_bench, &.{" "});1034    try std.testing.expectError(1035        error.ArtifactDigestMismatch,1036        loadRun(allocator, fixture.results),1037    );1038}10391040test "profiling analysis accepts a partial numbered execution receipt" {1041    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);1042    defer arena_state.deinit();1043    const allocator = arena_state.allocator();1044    var value = try std.json.parseFromSliceLeaky(1045        std.json.Value,1046        allocator,1047        repeated_measurement_workload_json,1048        .{},1049    );1050    const status = value.object.getPtr("status").?;1051    status.object.getPtr("state").?.* = .{ .string = "failed" };1052    status.object.getPtr("exit_code").?.* = .{ .integer = 23 };1053    const group = value.object.getPtr("measurement").?;1054    group.object.getPtr("execution_count").?.* = .{ .integer = 1 };1055    const executions = group.object.getPtr("executions").?;1056    executions.array.items.len = 1;1057    executions.array.items[0].object.getPtr("exit_code").?.* = .{ .integer = 23 };1058    const workload = try parseWorkload(1059        allocator,1060        try json.object(value),1061        &.{},1062        1,1063    );1064    try std.testing.expectEqual(@as(usize, 1), workload.executions.len);1065    try std.testing.expectEqual(@as(i64, 23), workload.executions[0].exit_code);1066    try std.testing.expectEqualStrings(1067        "old/workloads/w/executions/001",1068        workload.executions[0].artifacts.?.root,1069    );1070    try std.testing.expectEqualStrings(1071        "single_execution_receipt",1072        workload.structuredAnalysisState(),1073    );1074}10751076test "profiling analysis rejects unsupported workload schema" {1077    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);1078    defer arena_state.deinit();1079    const allocator = arena_state.allocator();1080    inline for (.{1081        \\{"schema":"tiny.profiling.workload/v2","event":"workload"}1082        ,1083        \\{"schema":"tiny.profiling.workload/v3","event":"workload"}1084        ,1085        \\{"event":"workload"}1086        ,1087    }) |text| {1088        const value = try std.json.parseFromSliceLeaky(1089            std.json.Value,1090            allocator,1091            text,1092            .{},1093        );1094        try std.testing.expectError(1095            error.UnsupportedProfilingWorkloadSchema,1096            parseWorkload(allocator, try json.object(value), &.{}, 1),1097        );1098    }1099}11001101test "profiling analysis rejects malformed v4 measurement and artifact shapes" {1102    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);1103    defer arena_state.deinit();1104    const allocator = arena_state.allocator();1105    const missing_measurement = try std.json.parseFromSliceLeaky(1106        std.json.Value,1107        allocator,1108        \\{"schema":"tiny.profiling.workload/v4","event":"workload",1109        \\ "workload":{"name":"w"},"status":{},"timing":{},1110        \\ "artifacts":{"root":"workloads/w"}}1111    ,1112        .{},1113    );1114    try std.testing.expectError(1115        error.InvalidProfilingJson,1116        parseWorkload(allocator, try json.object(missing_measurement), &.{}, 1),1117    );1118    const aliased_text = try std.mem.replaceOwned(1119        u8,1120        allocator,1121        repeated_measurement_workload_json,1122        "\"artifacts\":{\"root\":\"old/workloads/w\"}",1123        "\"artifacts\":{\"root\":\"old/workloads/w\"," ++1124            "\"structured\":\"old/workloads/w/structured.jsonl\"}",1125    );1126    const aliased = try std.json.parseFromSliceLeaky(1127        std.json.Value,1128        allocator,1129        aliased_text,1130        .{},1131    );1132    try std.testing.expectError(1133        error.InvalidProfilingJson,1134        parseWorkload(allocator, try json.object(aliased), &.{}, 1),1135    );1136}11371138test "profiling analysis validates recorded acquisition context" {1139    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);1140    defer arena_state.deinit();1141    const allocator = arena_state.allocator();1142    const previous = Workload{1143        .name = "a",1144        .package = "p",1145        .step = "bench",1146        .status = "passed",1147        .exit_code = 0,1148        .wall_ns = 1,1149        .max_rss_kib = null,1150        .user_s = null,1151        .system_s = null,1152        .result_path = null,1153    };1154    const valid_value = try std.json.parseFromSliceLeaky(1155        std.json.Value,1156        allocator,1157        \\{"schema":"tiny.profiling.workload/v4","event":"workload","index":1,1158        \\ "acquisition":{"position":2,"workload_count":3,"predecessors":["a"]},1159        \\ "workload":{"name":"target","package":"p","step":"bench",1160        \\ "surface":"benchmark"},1161        \\ "scope":"workload-binary","causal":false,"tracy":false,1162        \\ "trace_allocations":false,1163        \\ "status":{"state":"passed","exit_code":0},"timing":{"wall_ns":10},1164        \\ "measurement":{"execution_count":0,"acquisition_order":"fixed_plan_order",1165        \\ "workload_output_retention":"no_measured_execution",1166        \\ "measured_artifact_layout":"none",1167        \\ "allocation_summary_retention":"disabled",1168        \\ "benchmark_process_domain":{"benchmark_surface":true,1169        \\ "direct_execution":true,"host_profiler":false,"tracy":false,1170        \\ "causal":false,"allocation_trace":false,"capture_control":false},1171        \\ "benchmark_process_reduction":{1172        \\ "schema":"tiny.profiling.benchmark-process-reduction/v1",1173        \\ "state":"not_applicable","process_count":0,1174        \\ "reason":"fewer_than_two_executions"},"executions":[]},1175        \\ "artifacts":{"root":"workloads/target"}}1176    ,1177        .{},1178    );1179    const workload = try parseWorkload(1180        allocator,1181        try json.object(valid_value),1182        &.{previous},1183        3,1184    );1185    try std.testing.expectEqual(@as(usize, 2), workload.acquisition.blocked.position);1186    try std.testing.expectEqual(@as(usize, 3), workload.acquisition.blocked.workload_count);1187    try std.testing.expectEqualStrings("a", workload.acquisition.blocked.predecessors[0]);11881189    const invalid_value = try std.json.parseFromSliceLeaky(1190        std.json.Value,1191        allocator,1192        \\{"schema":"tiny.profiling.workload/v4","event":"workload","index":1,1193        \\ "acquisition":{"position":2,"workload_count":3,"predecessors":["b"]},1194        \\ "workload":{"name":"target","package":"p","step":"bench",1195        \\ "surface":"benchmark"},1196        \\ "scope":"workload-binary","causal":false,"tracy":false,1197        \\ "trace_allocations":false,1198        \\ "status":{"state":"passed","exit_code":0},"timing":{"wall_ns":10},1199        \\ "measurement":{"execution_count":0,"acquisition_order":"fixed_plan_order",1200        \\ "workload_output_retention":"no_measured_execution",1201        \\ "measured_artifact_layout":"none",1202        \\ "allocation_summary_retention":"disabled",1203        \\ "benchmark_process_domain":{"benchmark_surface":true,1204        \\ "direct_execution":true,"host_profiler":false,"tracy":false,1205        \\ "causal":false,"allocation_trace":false,"capture_control":false},1206        \\ "benchmark_process_reduction":{1207        \\ "schema":"tiny.profiling.benchmark-process-reduction/v1",1208        \\ "state":"not_applicable","process_count":0,1209        \\ "reason":"fewer_than_two_executions"},"executions":[]},1210        \\ "artifacts":{"root":"workloads/target"}}1211    ,1212        .{},1213    );1214    try std.testing.expectError(1215        error.InvalidProfilingJson,1216        parseWorkload(allocator, try json.object(invalid_value), &.{previous}, 3),1217    );1218}12191220test "profiling analysis validates deterministic interleaved schedules" {1221    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);1222    defer arena_state.deinit();1223    const allocator = arena_state.allocator();1224    const entries = try order.schedule(allocator, 2, 3, 42);1225    const names = [_][]const u8{ "a", "b" };1226    const first_acquisition = try order.interleavedContext(1227        allocator,1228        &names,1229        entries,1230        0,1231        3,1232        42,1233    );1234    const second_acquisition = try order.interleavedContext(1235        allocator,1236        &names,1237        entries,1238        1,1239        3,1240        42,1241    );1242    const first_positions = first_acquisition.random_interleaved.positions;1243    const second_positions = second_acquisition.random_interleaved.positions;1244    const first_samples = interleavedTestSamples(first_positions);1245    const second_samples = interleavedTestSamples(second_positions);1246    var first = try measuredTestWorkload("a", &first_samples);1247    first.acquisition = first_acquisition;1248    var second = try measuredTestWorkload("b", &second_samples);1249    second.acquisition = second_acquisition;1250    try validateWorkloadOrder(first);1251    try validateWorkloadOrder(second);1252    try validateOrderRun(allocator, &.{ first, second }, 2);12531254    var tampered_samples = first_samples;1255    tampered_samples[1].acquisition_position = first_positions[1] + 1;1256    var tampered_receipt = try measuredTestWorkload("a", &tampered_samples);1257    tampered_receipt.acquisition = first_acquisition;1258    try std.testing.expectError(1259        error.InvalidProfilingJson,1260        validateWorkloadOrder(tampered_receipt),1261    );12621263    const tampered_first = first;1264    var tampered_second = second;1265    tampered_second.acquisition.random_interleaved.positions =1266        tampered_first.acquisition.random_interleaved.positions;1267    try std.testing.expectError(1268        error.InvalidProfilingJson,1269        validateOrderRun(allocator, &.{ tampered_first, tampered_second }, 2),1270    );1271}12721273test "profiling analysis rejects measurement order token mismatch" {1274    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);1275    defer arena_state.deinit();1276    const allocator = arena_state.allocator();1277    const value = try std.json.parseFromSliceLeaky(1278        std.json.Value,1279        allocator,1280        \\{"measurement":{"acquisition_order":"fixed_plan_order"}}1281    ,1282        .{},1283    );1284    const object = try json.object(value);1285    try validateMeasurementOrder(object, .blocked);1286    try std.testing.expectError(1287        error.InvalidProfilingJson,1288        validateMeasurementOrder(object, .random_interleaved),1289    );1290}12911292test "profiling analysis keeps failed warmups out of measurement timing" {1293    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);1294    defer arena_state.deinit();1295    const allocator = arena_state.allocator();1296    const value = try std.json.parseFromSliceLeaky(1297        std.json.Value,1298        allocator,1299        \\{"schema":"tiny.profiling.workload/v4","event":"workload",1300        \\ "workload":{"name":"w","package":"p","step":"bench",1301        \\ "surface":"benchmark"},1302        \\ "scope":"workload-binary","causal":false,"tracy":false,1303        \\ "trace_allocations":false,1304        \\ "status":{"state":"failed","exit_code":9},"timing":{"wall_ns":7},1305        \\ "warmup":{"execution_count":1,1306        \\ "executions":[{"index":1,"exit_code":9,"wall_ns":7}]},1307        \\ "measurement":{"execution_count":0,"acquisition_order":"fixed_plan_order",1308        \\ "workload_output_retention":"no_measured_execution",1309        \\ "measured_artifact_layout":"none",1310        \\ "allocation_summary_retention":"disabled",1311        \\ "benchmark_process_domain":{"benchmark_surface":true,1312        \\ "direct_execution":true,"host_profiler":false,"tracy":false,1313        \\ "causal":false,"allocation_trace":false,"capture_control":false},1314        \\ "benchmark_process_reduction":{1315        \\ "schema":"tiny.profiling.benchmark-process-reduction/v1",1316        \\ "state":"not_applicable","process_count":0,1317        \\ "reason":"fewer_than_two_executions"},"executions":[]},1318        \\ "artifacts":{"root":"workloads/w"}}1319    ,1320        .{},1321    );1322    var workload = try parseWorkload(allocator, try json.object(value), &.{}, 1);1323    try finalizeExecutionSummary(&workload);1324    try std.testing.expectEqual(@as(usize, 1), workload.warmup_count);1325    try std.testing.expectEqual(@as(u64, 7), workload.warmup_total_wall_ns);1326    try std.testing.expectEqual(@as(usize, 0), workload.execution_count);1327    try std.testing.expectEqual(@as(u64, 0), workload.total_wall_ns);1328}13291330test "profiling analysis keeps failed setup out of measurement timing" {1331    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);1332    defer arena_state.deinit();1333    const allocator = arena_state.allocator();1334    const value = try std.json.parseFromSliceLeaky(1335        std.json.Value,1336        allocator,1337        \\{"schema":"tiny.profiling.workload/v4","event":"workload",1338        \\ "workload":{"name":"w","package":"p","step":"bench",1339        \\ "surface":"benchmark"},1340        \\ "scope":"workload-binary","causal":false,"tracy":false,1341        \\ "trace_allocations":false,1342        \\ "status":{"state":"failed","exit_code":7},"timing":{"wall_ns":19},1343        \\ "measurement":{"execution_count":0,"acquisition_order":"fixed_plan_order",1344        \\ "workload_output_retention":"no_measured_execution",1345        \\ "measured_artifact_layout":"none",1346        \\ "allocation_summary_retention":"disabled",1347        \\ "benchmark_process_domain":{"benchmark_surface":true,1348        \\ "direct_execution":true,"host_profiler":false,"tracy":false,1349        \\ "causal":false,"allocation_trace":false,"capture_control":false},1350        \\ "benchmark_process_reduction":{1351        \\ "schema":"tiny.profiling.benchmark-process-reduction/v1",1352        \\ "state":"not_applicable","process_count":0,1353        \\ "reason":"fewer_than_two_executions"},"executions":[]},1354        \\ "artifacts":{"root":"workloads/w"}}1355    ,1356        .{},1357    );1358    var workload = try parseWorkload(allocator, try json.object(value), &.{}, 1);1359    try finalizeExecutionSummary(&workload);1360    try std.testing.expectEqual(@as(usize, 0), workload.execution_count);1361    try std.testing.expectEqual(@as(u64, 0), workload.wall_ns);1362    try std.testing.expectEqual(@as(u64, 0), workload.total_wall_ns);1363    try std.testing.expect(workload.wall_distribution == null);1364}13651366test "profiling analysis keeps recorded paths when roots already agree" {1367    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);1368    defer arena_state.deinit();1369    const allocator = arena_state.allocator();1370    try std.testing.expectEqualStrings(1371        "zig-out/profiling/run-a/workloads/w/structured.jsonl",1372        (try relocatePath(allocator, "zig-out/profiling/run-a/workloads/w/structured.jsonl", "zig-out/profiling/run-a", "zig-out/profiling/run-a")).?,1373    );1374    try std.testing.expectEqualStrings(1375        "elsewhere/file.jsonl",1376        (try relocatePath(allocator, "elsewhere/file.jsonl", "zig-out/profiling/run-a", "moved/run-a")).?,1377    );1378    try std.testing.expectEqualStrings(1379        "moved/run-a/workloads/w/structured.jsonl",1380        (try relocatePath(allocator, "zig-out/profiling/run-a/workloads/w/structured.jsonl", "zig-out/profiling/run-a", "moved/run-a")).?,1381    );1382    try std.testing.expect(!pathHasPrefix("zig-out/profiling/run-ab/x", "zig-out/profiling/run-a"));1383}13841385test "profiling analysis relocates allocation repetition evidence" {1386    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);1387    defer arena_state.deinit();1388    const allocator = arena_state.allocator();1389    const value = try std.json.parseFromSliceLeaky(1390        std.json.Value,1391        allocator,1392        \\{"schema":"tiny.profiling.workload/v4","event":"workload",1393        \\ "workload":{"name":"w","package":"p","step":"bench",1394        \\ "surface":"benchmark"},1395        \\ "scope":"workload-binary","causal":false,"tracy":false,1396        \\ "trace_allocations":false,1397        \\ "status":{"state":"passed","exit_code":0},1398        \\ "timing":{"wall_ns":10},1399        \\ "measurement":{"execution_count":0,"acquisition_order":"fixed_plan_order",1400        \\ "workload_output_retention":"no_measured_execution",1401        \\ "measured_artifact_layout":"none",1402        \\ "allocation_summary_retention":"disabled",1403        \\ "benchmark_process_domain":{"benchmark_surface":true,1404        \\ "direct_execution":true,"host_profiler":false,"tracy":false,1405        \\ "causal":false,"allocation_trace":false,"capture_control":false},1406        \\ "benchmark_process_reduction":{1407        \\ "schema":"tiny.profiling.benchmark-process-reduction/v1",1408        \\ "state":"not_applicable","process_count":0,1409        \\ "reason":"fewer_than_two_executions"},"executions":[]},1410        \\ "artifacts":{"root":"old/workloads/w","allocation_repetitions":1411        \\   "old/workloads/w/allocations.repetitions.jsonl"}}1412    ,1413        .{},1414    );1415    var workload = try parseWorkload(allocator, try json.object(value), &.{}, 1);1416    try relocateWorkload(allocator, &workload, "old", "moved");1417    try std.testing.expectEqualStrings(1418        "moved/workloads/w/allocations.repetitions.jsonl",1419        workload.allocation_repetitions_path.?,1420    );1421}

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