Skip to documentation
SLOP

tiny.profiling.report.analysis

Reference tiny.profiling report analysis

Defined in report.

API (17)

Actions

Public operations.

Types and contracts

Public types and contracts.

Values and defaults

Public values and defaults.

No direct callersNo direct callsreportanalysis
Static calls · unresolved targets: unknown · external targets: unknown.

Source

Called byCallstest; no linksrc.profiling.report.analysistest: analysis tolerates junk and wro...report.modelloadreport.analysisparsereport.analysisload
Static calls · unresolved targets: 0 · external targets: 1.
Called byCallsreport.analysisloadtest; no linksrc.profiling.report.analysistest: analysis parses fixed versus ra...test; no linksrc.profiling.report.analysistest: analysis parses recorded regres...test; no linksrc.profiling.report.analysistest: analysis tolerates junk and wro...jsonobjectprivate; no linksrc.profiling.report.analysisparseComparisonSupportprivate; no linksrc.profiling.report.analysisparseOrderEffectsprivate; no linksrc.profiling.report.analysisparseRowsprivate; no linksrc.profiling.report.analysisparseRunSummary+2 morereport.analysisparse
Static calls · unresolved targets: 1 · external targets: 1.

Source: src/profiling/report/analysis.zig

zig
const std = @import("std");const sys = @import("sys");const profiling = @import("../root.zig");const json = profiling.json;pub const schema = "tiny.profiling.analysis/v1";const max_analysis_bytes = 64 * 1024 * 1024;pub const RunSummary = struct {    run_id: []const u8,    ran: u64,    passed: u64,    failed: u64,    structured_metrics: u64,    memory_metrics: u64,};pub const ComparisonSupport = struct {    state: []const u8,    supported: bool,};pub const OrderEffectRow = struct {    workload: []const u8,    fixed_acquisition: profiling.order.Context,    random_acquisition: profiling.order.Context,    fixed_count: u64,    random_count: u64,    fixed_mean_ns: ?f64,    random_mean_ns: ?f64,    mean_percent_change: ?f64,    effect_low_percent: ?f64,    effect_high_percent: ?f64,    classification: []const u8,};pub const OrderEffects = struct {    support: ComparisonSupport,    status: []const u8,    fixed_run_id: []const u8,    random_run_id: []const u8,    fixed_is_baseline: bool,    supports_ordersage_test: bool,    reset_policy: []const u8,    effect_method: []const u8,    effect_confidence_per_mille: u64,    order_sensitive_workloads: u64,    limits: []const []const u8,    rows: []const OrderEffectRow,};pub const WallRegression = struct {    workload: []const u8,    kind: []const u8,    wall_status: []const u8,    baseline_wall_ns: ?f64,    candidate_wall_ns: ?f64,    wall_percent_change: ?f64,    baseline_wall_samples: u64,    candidate_wall_samples: u64,    baseline_wall_distribution: []const u8,    candidate_wall_distribution: []const u8,    wall_effect_low_percent: ?f64,    wall_effect_high_percent: ?f64,    wall_effect_method: ?[]const u8,    wall_effect_confidence_per_mille: ?u64,    baseline_max_rss_kib: ?f64,    candidate_max_rss_kib: ?f64,    rss_percent_change: ?f64,};pub const MetricRegression = struct {    workload: []const u8,    label: []const u8,    status: []const u8,    baseline_ns: f64,    candidate_ns: f64,    percent_change: f64,    threshold_percent: f64,    effect_low_percent: ?f64,    effect_high_percent: ?f64,    candidate_distribution: []const u8,};pub const MemoryRegression = struct {    workload: []const u8,    label: []const u8,    status: []const u8,    unit: []const u8,    baseline_value: f64,    candidate_value: f64,    percent_change: f64,    threshold_percent: f64,    baseline_samples: u64,    candidate_samples: u64,    baseline_distribution: []const u8,    candidate_distribution: []const u8,    effect_low_percent: ?f64,    effect_high_percent: ?f64,};pub const CounterShift = struct {    workload: []const u8,    event: []const u8,    baseline_value: f64,    candidate_value: f64,    percent_change: f64,    status: []const u8,};pub const EnergyShift = struct {    workload: []const u8,    event: []const u8,    baseline_joules: f64,    candidate_joules: f64,    energy_percent_change: f64,    baseline_watts: ?f64,    candidate_watts: ?f64,    power_percent_change: ?f64,    baseline_energy_range_percent: ?f64,    candidate_energy_range_percent: ?f64,    baseline_power_range_percent: ?f64,    candidate_power_range_percent: ?f64,    status: []const u8,};pub const WorkloadComparisonSkip = struct {    workload: []const u8,    state: []const u8,    reason: []const u8,    baseline_acquisition: profiling.order.Context = .{ .blocked = .{} },    candidate_acquisition: profiling.order.Context = .{ .blocked = .{} },    baseline_execution_count: u64,    candidate_execution_count: u64,    baseline_warmup_count: u64,    candidate_warmup_count: u64,};pub const PriorityItem = struct {    rank: u64,    score: f64,    reason: []const u8,    kind: []const u8,    workload: []const u8,    component: []const u8,    label: []const u8,    evidence: []const u8,    confidence: []const u8,    percent_change: ?f64,    absolute_change: ?f64,    unit: []const u8,    causal_max_program_speedup: ?f64,};pub const PriorityComponent = struct {    component: []const u8,    workloads: u64,    issues: u64,    strongest_workload: []const u8,    strongest_label: []const u8,    total_score: f64,    reason: []const u8,};pub const Recorded = struct {    candidate: RunSummary,    baseline: ?RunSummary,    comparison_support: ?ComparisonSupport,    order_effects: ?OrderEffects = null,    regressions: []const WallRegression,    metric_regressions: []const MetricRegression,    memory_regressions: []const MemoryRegression,    energy_shifts: []const EnergyShift,    counter_shifts: []const CounterShift,    workload_comparison_skips: []const WorkloadComparisonSkip,    priority_items: []const PriorityItem,    priority_components: []const PriorityComponent,    pub fn findings(self: Recorded) usize {        return self.regressions.len + self.metric_regressions.len + self.memory_regressions.len;    }};pub fn load(allocator: std.mem.Allocator, run_root: []const u8) !?Recorded {    const path = try std.fs.path.join(allocator, &.{ run_root, "analysis.json" });    const text = sys.fs.readFileAlloc(allocator, path, max_analysis_bytes) catch |err| switch (err) {        error.FileNotFound => return null,        else => |actual| return actual,    };    return try parse(allocator, text);}pub fn parse(allocator: std.mem.Allocator, text: []const u8) !?Recorded {    const value = std.json.parseFromSliceLeaky(std.json.Value, allocator, text, .{}) catch return null;    const object = json.object(value) catch return null;    const schema_name = json.string(object.get("schema")) orelse return null;    if (!std.mem.eql(u8, schema_name, schema)) return null;    const candidate = parseRunSummary(object.get("candidate")) orelse return null;    return .{        .candidate = candidate,        .baseline = parseRunSummary(object.get("baseline")),        .comparison_support = parseComparisonSupport(object.get("comparison_support")),        .order_effects = try parseOrderEffects(allocator, object.get("order_effects")),        .regressions = try parseRows(WallRegression, allocator, object.get("regressions"), parseWallRegression),        .metric_regressions = try parseRows(MetricRegression, allocator, object.get("metric_regressions"), parseMetricRegression),        .memory_regressions = try parseRows(MemoryRegression, allocator, object.get("memory_regressions"), parseMemoryRegression),        .energy_shifts = try parseRows(EnergyShift, allocator, object.get("energy_shifts"), parseEnergyShift),        .counter_shifts = try parseRows(CounterShift, allocator, object.get("counter_shifts"), parseCounterShift),        .workload_comparison_skips = try parseWorkloadComparisonSkips(            allocator,            object.get("workload_comparison_skips"),        ),        .priority_items = try parseRows(PriorityItem, allocator, priorityField(object, "items"), parsePriorityItem),        .priority_components = try parseRows(PriorityComponent, allocator, priorityField(object, "components"), parsePriorityComponent),    };}fn parseComparisonSupport(value: ?std.json.Value) ?ComparisonSupport {    const object = json.object(value orelse return null) catch return null;    return .{        .state = json.string(object.get("state")) orelse return null,        .supported = json.asBool(object.get("supported")) orelse return null,    };}fn parseOrderEffects(    allocator: std.mem.Allocator,    value: ?std.json.Value,) !?OrderEffects {    const object = json.object(value orelse return null) catch return null;    const support = parseComparisonSupport(object.get("support")) orelse return null;    const rows_value = object.get("rows") orelse return null;    const rows_json = json.array(rows_value) catch return null;    if (rows_json.items.len > profiling.plan.max_workloads_per_run) return null;    const rows = try allocator.alloc(OrderEffectRow, rows_json.items.len);    for (rows_json.items, rows) |item, *row| {        const row_object = json.object(item) catch return null;        row.* = .{            .workload = json.string(row_object.get("workload")) orelse return null,            .fixed_acquisition = try parseAcquisition(                allocator,                row_object.get("fixed_acquisition"),            ),            .random_acquisition = try parseAcquisition(                allocator,                row_object.get("random_acquisition"),            ),            .fixed_count = json.asU64(row_object.get("fixed_count")) orelse 0,            .random_count = json.asU64(row_object.get("random_count")) orelse 0,            .fixed_mean_ns = json.asF64(row_object.get("fixed_mean_ns")),            .random_mean_ns = json.asF64(row_object.get("random_mean_ns")),            .mean_percent_change = json.asF64(row_object.get("mean_percent_change")),            .effect_low_percent = json.asF64(row_object.get("effect_low_percent")),            .effect_high_percent = json.asF64(row_object.get("effect_high_percent")),            .classification = json.string(row_object.get("classification")) orelse                "insufficient_repetitions",        };    }    return .{        .support = support,        .status = json.string(object.get("status")) orelse "unsupported",        .fixed_run_id = json.string(object.get("fixed_run_id")) orelse return null,        .random_run_id = json.string(object.get("random_run_id")) orelse return null,        .fixed_is_baseline = json.asBool(object.get("fixed_is_baseline")) orelse false,        .supports_ordersage_test = json.asBool(object.get("supports_ordersage_test")) orelse false,        .reset_policy = json.string(object.get("reset_policy")) orelse "none_recorded",        .effect_method = json.string(object.get("effect_method")) orelse "",        .effect_confidence_per_mille = json.asU64(            object.get("effect_confidence_per_mille"),        ) orelse 0,        .order_sensitive_workloads = json.asU64(            object.get("order_sensitive_workloads"),        ) orelse 0,        .limits = try json.strings(allocator, object.get("limits")),        .rows = rows,    };}fn priorityField(object: std.json.ObjectMap, name: []const u8) ?std.json.Value {    const priority = json.object(object.get("priority") orelse return null) catch return null;    return priority.get(name);}fn parseRows(    comptime Row: type,    allocator: std.mem.Allocator,    value: ?std.json.Value,    comptime parseRow: fn (std.json.ObjectMap) ?Row,) ![]const Row {    const actual = value orelse return &.{};    const rows = json.array(actual) catch return &.{};    var result: std.ArrayList(Row) = .empty;    for (rows.items) |item| {        const object = json.object(item) catch continue;        if (parseRow(object)) |row| try result.append(allocator, row);    }    return try result.toOwnedSlice(allocator);}fn parseRunSummary(value: ?std.json.Value) ?RunSummary {    const object = json.object(value orelse return null) catch return null;    return .{        .run_id = json.string(object.get("run_id")) orelse return null,        .ran = json.asU64(object.get("ran")) orelse 0,        .passed = json.asU64(object.get("passed")) orelse 0,        .failed = json.asU64(object.get("failed")) orelse 0,        .structured_metrics = json.asU64(object.get("structured_metrics")) orelse 0,        .memory_metrics = json.asU64(object.get("memory_metrics")) orelse 0,    };}fn parseWallRegression(object: std.json.ObjectMap) ?WallRegression {    return .{        .workload = json.string(object.get("workload")) orelse return null,        .kind = json.string(object.get("kind")) orelse "wall",        .wall_status = json.string(object.get("wall_status")) orelse "legacy_unclassified",        .baseline_wall_ns = json.asF64(object.get("baseline_wall_ns")),        .candidate_wall_ns = json.asF64(object.get("candidate_wall_ns")),        .wall_percent_change = json.asF64(object.get("wall_percent_change")),        .baseline_wall_samples = json.asU64(object.get("baseline_wall_samples")) orelse 0,        .candidate_wall_samples = json.asU64(object.get("candidate_wall_samples")) orelse 0,        .baseline_wall_distribution = json.string(            object.get("baseline_wall_distribution"),        ) orelse "unknown",        .candidate_wall_distribution = json.string(            object.get("candidate_wall_distribution"),        ) orelse "unknown",        .wall_effect_low_percent = json.asF64(object.get("wall_effect_low_percent")),        .wall_effect_high_percent = json.asF64(object.get("wall_effect_high_percent")),        .wall_effect_method = json.string(object.get("wall_effect_method")),        .wall_effect_confidence_per_mille = json.asU64(            object.get("wall_effect_confidence_per_mille"),        ),        .baseline_max_rss_kib = json.asF64(object.get("baseline_max_rss_kib")),        .candidate_max_rss_kib = json.asF64(object.get("candidate_max_rss_kib")),        .rss_percent_change = json.asF64(object.get("rss_percent_change")),    };}fn parseMetricRegression(object: std.json.ObjectMap) ?MetricRegression {    return .{        .workload = json.string(object.get("workload")) orelse return null,        .label = json.string(object.get("label")) orelse return null,        .status = json.string(object.get("status")) orelse "regressed",        .baseline_ns = json.asF64(object.get("baseline_ns")) orelse return null,        .candidate_ns = json.asF64(object.get("candidate_ns")) orelse return null,        .percent_change = json.asF64(object.get("percent_change")) orelse 0,        .threshold_percent = json.asF64(object.get("threshold_percent")) orelse 0,        .effect_low_percent = json.asF64(object.get("effect_low_percent")),        .effect_high_percent = json.asF64(object.get("effect_high_percent")),        .candidate_distribution = json.string(object.get("candidate_distribution")) orelse "",    };}fn parseMemoryRegression(object: std.json.ObjectMap) ?MemoryRegression {    return .{        .workload = json.string(object.get("workload")) orelse return null,        .label = json.string(object.get("label")) orelse return null,        .status = json.string(object.get("status")) orelse "regressed",        .unit = json.string(object.get("unit")) orelse "",        .baseline_value = json.asF64(object.get("baseline_value")) orelse return null,        .candidate_value = json.asF64(object.get("candidate_value")) orelse return null,        .percent_change = json.asF64(object.get("percent_change")) orelse 0,        .threshold_percent = json.asF64(object.get("threshold_percent")) orelse 0,        .baseline_samples = json.asU64(object.get("baseline_samples")) orelse 1,        .candidate_samples = json.asU64(object.get("candidate_samples")) orelse 1,        .baseline_distribution = json.string(object.get("baseline_distribution")) orelse            "point_estimate",        .candidate_distribution = json.string(object.get("candidate_distribution")) orelse            "point_estimate",        .effect_low_percent = json.asF64(object.get("effect_low_percent")),        .effect_high_percent = json.asF64(object.get("effect_high_percent")),    };}fn parseCounterShift(object: std.json.ObjectMap) ?CounterShift {    return .{        .workload = json.string(object.get("workload")) orelse return null,        .event = json.string(object.get("event")) orelse return null,        .baseline_value = json.asF64(object.get("baseline_value")) orelse 0,        .candidate_value = json.asF64(object.get("candidate_value")) orelse 0,        .percent_change = json.asF64(object.get("percent_change")) orelse 0,        .status = json.string(object.get("status")) orelse "",    };}fn parseEnergyShift(object: std.json.ObjectMap) ?EnergyShift {    return .{        .workload = json.string(object.get("workload")) orelse return null,        .event = json.string(object.get("event")) orelse return null,        .baseline_joules = json.asF64(object.get("baseline_joules")) orelse return null,        .candidate_joules = json.asF64(object.get("candidate_joules")) orelse return null,        .energy_percent_change = json.asF64(            object.get("energy_percent_change"),        ) orelse return null,        .baseline_watts = json.asF64(object.get("baseline_watts")),        .candidate_watts = json.asF64(object.get("candidate_watts")),        .power_percent_change = json.asF64(object.get("power_percent_change")),        .baseline_energy_range_percent = json.asF64(            object.get("baseline_energy_range_percent"),        ),        .candidate_energy_range_percent = json.asF64(            object.get("candidate_energy_range_percent"),        ),        .baseline_power_range_percent = json.asF64(            object.get("baseline_power_range_percent"),        ),        .candidate_power_range_percent = json.asF64(            object.get("candidate_power_range_percent"),        ),        .status = json.string(object.get("status")) orelse return null,    };}fn parseWorkloadComparisonSkips(    allocator: std.mem.Allocator,    value: ?std.json.Value,) ![]const WorkloadComparisonSkip {    const actual = value orelse return &.{};    const rows = json.array(actual) catch return &.{};    var result: std.ArrayList(WorkloadComparisonSkip) = .empty;    for (rows.items) |item| {        const object = json.object(item) catch continue;        if (try parseWorkloadComparisonSkip(allocator, object)) |row| {            try result.append(allocator, row);        }    }    return try result.toOwnedSlice(allocator);}fn parseWorkloadComparisonSkip(    allocator: std.mem.Allocator,    object: std.json.ObjectMap,) !?WorkloadComparisonSkip {    return .{        .workload = json.string(object.get("workload")) orelse return null,        .state = json.string(object.get("state")) orelse return null,        .reason = json.string(object.get("reason")) orelse return null,        .baseline_acquisition = try parseAcquisition(            allocator,            object.get("baseline_acquisition"),        ),        .candidate_acquisition = try parseAcquisition(            allocator,            object.get("candidate_acquisition"),        ),        .baseline_execution_count = json.asU64(object.get("baseline_execution_count")) orelse 0,        .candidate_execution_count = json.asU64(object.get("candidate_execution_count")) orelse 0,        .baseline_warmup_count = json.asU64(object.get("baseline_warmup_count")) orelse 0,        .candidate_warmup_count = json.asU64(object.get("candidate_warmup_count")) orelse 0,    };}fn parseAcquisition(    allocator: std.mem.Allocator,    value: ?std.json.Value,) !profiling.order.Context {    return profiling.order.parse(        allocator,        value orelse return .{ .blocked = .{} },    ) catch .{ .blocked = .{} };}fn parsePriorityItem(object: std.json.ObjectMap) ?PriorityItem {    return .{        .rank = json.asU64(object.get("rank")) orelse 0,        .score = json.asF64(object.get("score")) orelse 0,        .reason = json.string(object.get("reason")) orelse "",        .kind = json.string(object.get("kind")) orelse "",        .workload = json.string(object.get("workload")) orelse return null,        .component = json.string(object.get("component")) orelse "",        .label = json.string(object.get("label")) orelse "",        .evidence = json.string(object.get("evidence")) orelse "",        .confidence = json.string(object.get("confidence")) orelse "",        .percent_change = json.asF64(object.get("percent_change")),        .absolute_change = json.asF64(object.get("absolute_change")),        .unit = json.string(object.get("unit")) orelse "",        .causal_max_program_speedup = json.asF64(object.get("causal_max_program_speedup")),    };}fn parsePriorityComponent(object: std.json.ObjectMap) ?PriorityComponent {    return .{        .component = json.string(object.get("component")) orelse return null,        .workloads = json.asU64(object.get("affected_workloads")) orelse 0,        .issues = json.asU64(object.get("issue_count")) orelse 0,        .strongest_workload = json.string(object.get("strongest_workload")) orelse "",        .strongest_label = json.string(object.get("strongest_label")) orelse "",        .total_score = json.asF64(object.get("score")) orelse 0,        .reason = json.string(object.get("reason")) orelse "",    };}test "analysis parses recorded regressions and priority" {    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);    defer arena_state.deinit();    const allocator = arena_state.allocator();    const text =        \\{"schema":"tiny.profiling.analysis/v1",        \\ "candidate":{"run_id":"cycle-b","ran":2,"passed":2,"failed":0,"structured_metrics":10,"memory_metrics":4},        \\ "baseline":{"run_id":"cycle-a","ran":2,"passed":2,"failed":0,"structured_metrics":10,"memory_metrics":4},        \\ "comparison_support":{"state":"supported","supported":true},        \\ "regressions":[{"workload":"smg.graph","kind":"wall","wall_status":"sample_regression","baseline_wall_ns":100,"candidate_wall_ns":130,"wall_percent_change":30,"wall_threshold_percent":10,"baseline_wall_samples":4,"candidate_wall_samples":4,"baseline_wall_distribution":"raw_executions","candidate_wall_distribution":"raw_executions","wall_effect_low_percent":25,"wall_effect_high_percent":35,"wall_effect_method":"deterministic_percentile_bootstrap_unpaired_mean_percent_change","wall_effect_confidence_per_mille":950,"baseline_max_rss_kib":10,"candidate_max_rss_kib":11,"rss_percent_change":10,"rss_threshold_percent":10}],        \\ "workload_comparison_skips":[{"workload":"mprompt.smoke","state":"warmup_design_mismatch","reason":"unmeasured process warmup counts differ","baseline_acquisition":{"position":2,"workload_count":2,"predecessors":["smg.graph"]},"candidate_acquisition":{"position":2,"workload_count":3,"predecessors":["smg.graph"]},"baseline_execution_count":1,"candidate_execution_count":4,"baseline_warmup_count":1,"candidate_warmup_count":2}],        \\ "metric_regressions":[{"workload":"smg.graph","key":"k","label":"smg.graph load","status":"regressed","baseline_ns":50,"candidate_ns":75,"percent_change":50,"threshold_percent":10,"baseline_samples":10,"candidate_samples":10,"baseline_distribution":"raw_samples","candidate_distribution":"raw_samples","effect_low_percent":40,"effect_high_percent":61}],        \\ "memory_regressions":[{        \\   "workload":"smg.graph","key":"allocations|allocated_bytes",        \\   "label":"allocated bytes","status":"allocation_sample_regression",        \\   "unit":"bytes","baseline_value":100,"candidate_value":130,        \\   "percent_change":30,"threshold_percent":10,        \\   "baseline_samples":4,"candidate_samples":4,        \\   "baseline_distribution":"raw_executions",        \\   "candidate_distribution":"raw_executions",        \\   "effect_low_percent":20,"effect_high_percent":40        \\ }],        \\ "energy_shifts":[{"workload":"smg.graph","event":"power/energy-pkg/u",        \\   "baseline_joules":10,"candidate_joules":11,"energy_percent_change":10,        \\   "baseline_watts":5,"candidate_watts":6,"power_percent_change":20,        \\   "baseline_energy_range_percent":2,"candidate_energy_range_percent":3,        \\   "baseline_power_range_percent":4,"candidate_power_range_percent":5,        \\   "threshold_percent":10,"status":"energy_shift_caveated"}],        \\ "counter_shifts":[{"workload":"smg.graph","event":"instructions","baseline_value":100,"candidate_value":140,"percent_change":40,"threshold_percent":10,"status":"counter_shift"}],        \\ "priority":{"items":[{"rank":1,"score":9.5,"reason":"wall regressed","kind":"wall","workload":"smg.graph","package":"tools/smg","component":"tools/smg","label":"smg.graph wall","key":"wall","evidence":"observed","confidence":"high","workload_weight":1,"percent_change":30,"threshold_percent":10,"absolute_change":30,"unit":"ns"}],        \\   "components":[{"rank":1,"component":"tools/smg","score":9.5,"affected_workloads":1,"issue_count":1,"strongest_workload":"smg.graph","strongest_label":"smg.graph wall","strongest_score":9.5,"reason":"1 issue"}]}}    ;    const recorded = (try parse(allocator, text)).?;    try std.testing.expectEqualStrings("cycle-b", recorded.candidate.run_id);    try std.testing.expectEqualStrings("cycle-a", recorded.baseline.?.run_id);    try std.testing.expect(recorded.comparison_support.?.supported);    try std.testing.expectEqual(@as(usize, 1), recorded.regressions.len);    try std.testing.expectEqual(@as(f64, 30), recorded.regressions[0].wall_percent_change.?);    try std.testing.expectEqualStrings("sample_regression", recorded.regressions[0].wall_status);    try std.testing.expectEqual(@as(u64, 4), recorded.regressions[0].candidate_wall_samples);    try std.testing.expectEqual(@as(f64, 25), recorded.regressions[0].wall_effect_low_percent.?);    try std.testing.expectEqual(@as(usize, 1), recorded.metric_regressions.len);    try std.testing.expectEqual(@as(f64, 61), recorded.metric_regressions[0].effect_high_percent.?);    try std.testing.expectEqual(@as(usize, 1), recorded.memory_regressions.len);    try std.testing.expectEqual(        @as(u64, 4),        recorded.memory_regressions[0].candidate_samples,    );    try std.testing.expectEqual(        @as(f64, 20),        recorded.memory_regressions[0].effect_low_percent.?,    );    try std.testing.expectEqual(@as(usize, 1), recorded.energy_shifts.len);    try std.testing.expectEqual(@as(f64, 20), recorded.energy_shifts[0].power_percent_change.?);    try std.testing.expectEqual(        @as(f64, 5),        recorded.energy_shifts[0].candidate_power_range_percent.?,    );    try std.testing.expectEqual(@as(usize, 1), recorded.counter_shifts.len);    try std.testing.expectEqual(@as(usize, 1), recorded.workload_comparison_skips.len);    try std.testing.expectEqual(@as(u64, 4), recorded.workload_comparison_skips[0].candidate_execution_count);    try std.testing.expectEqual(@as(u64, 2), recorded.workload_comparison_skips[0].candidate_warmup_count);    try std.testing.expectEqual(        @as(usize, 2),        recorded.workload_comparison_skips[0].baseline_acquisition.blocked.position,    );    try std.testing.expectEqualStrings(        "smg.graph",        recorded.workload_comparison_skips[0].candidate_acquisition.blocked.predecessors[0],    );    try std.testing.expectEqual(@as(usize, 1), recorded.priority_items.len);    try std.testing.expectEqualStrings("smg.graph wall", recorded.priority_items[0].label);    try std.testing.expectEqual(@as(usize, 1), recorded.priority_components.len);    try std.testing.expectEqual(@as(u64, 1), recorded.priority_components[0].workloads);    try std.testing.expectEqual(@as(u64, 1), recorded.priority_components[0].issues);    try std.testing.expectEqual(@as(f64, 9.5), recorded.priority_components[0].total_score);    try std.testing.expectEqual(@as(usize, 3), recorded.findings());}const order_effect_analysis_json =    \\{"schema":"tiny.profiling.analysis/v1",    \\ "candidate":{"run_id":"random","ran":2,"passed":2,"failed":0},    \\ "order_effects":{    \\   "support":{"state":"supported","supported":true},    \\   "status":"order_sensitive_candidate",    \\   "supports_ordersage_test":false,    \\   "fixed_run_id":"fixed",    \\   "random_run_id":"random",    \\   "fixed_is_baseline":true,    \\   "reset_policy":"none_recorded",    \\   "effect_method":"bootstrap",    \\   "effect_confidence_per_mille":950,    \\   "order_sensitive_workloads":1,    \\   "limits":["one pair"],    \\   "rows":[{    \\     "workload":"smg.graph",    \\     "fixed_acquisition":{    \\       "position":1,"workload_count":2,"predecessors":[]    \\     },    \\     "random_acquisition":{    \\       "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":["smg.graph","mprompt.smoke"],    \\       "positions":[1,3,6]    \\     },    \\     "fixed_count":3,"random_count":3,    \\     "fixed_mean_ns":100,"random_mean_ns":130,    \\     "mean_percent_change":30,    \\     "effect_low_percent":20,"effect_high_percent":40,    \\     "classification":"order_sensitive_candidate"    \\   }]    \\ }    \\};test "analysis parses fixed versus random acquisition diagnostics" {    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);    defer arena_state.deinit();    const recorded = (try parse(arena_state.allocator(), order_effect_analysis_json)).?;    const effects = recorded.order_effects.?;    try std.testing.expect(effects.support.supported);    try std.testing.expectEqualStrings("order_sensitive_candidate", effects.status);    try std.testing.expectEqual(@as(u64, 1), effects.order_sensitive_workloads);    try std.testing.expectEqual(@as(usize, 1), effects.rows.len);    try std.testing.expectEqual(@as(u64, 3), effects.rows[0].random_count);    try std.testing.expectEqual(        @as(usize, 3),        effects.rows[0].random_acquisition.random_interleaved.positions.len,    );}test "analysis tolerates junk and wrong schema" {    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);    defer arena_state.deinit();    const allocator = arena_state.allocator();    try std.testing.expect((try parse(allocator, "not json")) == null);    try std.testing.expect((try parse(allocator, "{\"schema\":\"other/v1\"}")) == null);    try std.testing.expect((try load(allocator, ".zig-cache/profile-web-missing-run")) == null);}

Source: src/profiling/report/root.zig:1

zig
pub const analysis = @import("analysis.zig");

Complete call list for report.analysis.parse

7 direct calls.

Audit

Definitions18
Public names18
Members132
Version26.7.0
Revisiondaab053ee433