tiny.profiling.analyze.evidence

1const std = @import("std");2const budget = @import("../root.zig").budget;3const coz = @import("../capture/root.zig").coz;4const memory = @import("../root.zig").memory;5const metric = @import("../root.zig").metric;6const priority = @import("../root.zig").priority;7const Comparison = @import("root.zig").model.Comparison;8const CounterShift = @import("root.zig").model.CounterShift;9const EnergyShift = @import("root.zig").model.EnergyShift;10const NamedCapture = @import("root.zig").model.NamedCapture;11const OrderEffects = @import("root.zig").model.OrderEffects;12const Run = @import("root.zig").model.Run;13const Workload = @import("root.zig").model.Workload;14const WorkloadComparisonSkip = @import("root.zig").model.WorkloadComparisonSkip;15const allocationBudgetChecks = @import("root.zig").compare.allocationBudgetChecks;16const buildOrderEffects = @import("root.zig").ordering.buildOrderEffects;17const compareCounterRuns = @import("root.zig").compare.compareCounterRuns;18const compareEnergyRuns = @import("root.zig").compare.compareEnergyRuns;19const compareMemoryRuns = @import("root.zig").compare.compareMemoryRuns;20const compareMetricRuns = @import("root.zig").compare.compareMetricRuns;21const compareRuns = @import("root.zig").compare.compareRuns;22const supportedBaseline = @import("root.zig").compare.supportedBaseline;23const workloadComparisonSkips = @import("root.zig").compare.workloadComparisonSkips;2425const ComparisonEvidence = struct {26    order_effects: ?OrderEffects,27    workload: []const Comparison,28    skips: []const WorkloadComparisonSkip,29    metrics: []const metric.Comparison,30    memory_metrics: []const memory.Comparison,31    allocation_budgets: []const budget.Check,32    energy: []const EnergyShift,33    counters: []const CounterShift,34    priority_report: priority.Report,35};3637pub fn comparisonEvidence(38    allocator: std.mem.Allocator,39    candidate: Run,40    baseline_run: ?Run,41    threshold_percent: f64,42    causal: []const coz.Result,43) !ComparisonEvidence {44    const order_effects = if (baseline_run) |base|45        try buildOrderEffects(allocator, base, candidate)46    else47        null;48    const comparable_base = supportedBaseline(baseline_run, candidate);49    const regression_base = if (order_effects == null) comparable_base else null;50    const workload = if (regression_base) |base|51        try compareRuns(allocator, base, candidate, threshold_percent)52    else53        &.{};54    const skips = if (comparable_base) |base|55        try workloadComparisonSkips(allocator, base, candidate)56    else57        &.{};58    const metrics = if (regression_base) |base|59        try compareMetricRuns(allocator, base, candidate, threshold_percent)60    else61        &.{};62    const memory_metrics = if (regression_base) |base|63        try compareMemoryRuns(allocator, base, candidate, threshold_percent)64    else65        &.{};66    const allocation_budgets = try allocationBudgetChecks(67        allocator,68        candidate,69        baseline_run,70    );71    const energy = if (regression_base) |base|72        try compareEnergyRuns(allocator, base, candidate, threshold_percent)73    else74        &.{};75    const counters = if (regression_base) |base|76        try compareCounterRuns(allocator, base, candidate, threshold_percent)77    else78        &.{};79    const report = if (regression_base != null)80        try priority.build(81            allocator,82            try priorityWorkloads(allocator, candidate),83            workload,84            metrics,85            memory_metrics,86            causal,87        )88    else89        priority.Report{};90    return .{91        .order_effects = order_effects,92        .workload = workload,93        .skips = skips,94        .metrics = metrics,95        .memory_metrics = memory_metrics,96        .allocation_budgets = allocation_budgets,97        .energy = energy,98        .counters = counters,99        .priority_report = report,100    };101}102103pub fn flattenCaptures(allocator: std.mem.Allocator, run_value: Run) ![]const NamedCapture {104    var rows: std.ArrayList(NamedCapture) = .empty;105    for (run_value.workloads) |workload| {106        for (workload.captures) |row| try rows.append(allocator, .{ .workload = workload.name, .capture = row });107    }108    return try rows.toOwnedSlice(allocator);109}110111pub fn causal_result_descending(_: void, left: coz.Result, right: coz.Result) bool {112    const left_supported = left.support.status == .within_run_repeated_curve;113    const right_supported = right.support.status == .within_run_repeated_curve;114    if (left_supported != right_supported) return left_supported;115    if (left.max_program_speedup == right.max_program_speedup) {116        return std.mem.lessThan(u8, left.workload, right.workload);117    }118    return left.max_program_speedup > right.max_program_speedup;119}120121pub fn flattenCausal(allocator: std.mem.Allocator, run_value: Run) ![]const coz.Result {122    var result: std.ArrayList(coz.Result) = .empty;123    for (run_value.workloads) |workload| {124        for (workload.causal) |row| try result.append(allocator, row);125    }126    const slice = try result.toOwnedSlice(allocator);127    std.mem.sort(coz.Result, slice, {}, causal_result_descending);128    return slice;129}130131fn priorityWorkloads(allocator: std.mem.Allocator, run_value: Run) ![]const priority.WorkloadSummary {132    var result: std.ArrayList(priority.WorkloadSummary) = .empty;133    for (run_value.workloads) |workload| {134        try result.append(allocator, .{135            .name = workload.name,136            .package = workload.package,137            .step = workload.step,138            .wall_ns = workload.wall_ns,139            .max_rss_kib = workload.max_rss_kib,140        });141    }142    return try result.toOwnedSlice(allocator);143}144145fn workload_wall_descending(items: []const Workload, left: usize, right: usize) bool {146    return items[left].wall_ns > items[right].wall_ns;147}148149fn workload_rss_value(item: Workload) i64 {150    return item.max_rss_kib orelse -1;151}152153fn workload_rss_descending(items: []const Workload, left: usize, right: usize) bool {154    return workload_rss_value(items[left]) > workload_rss_value(items[right]);155}156157pub fn sortedByWall(allocator: std.mem.Allocator, workloads: []const Workload) ![]usize {158    const indices = try ordinalIndices(allocator, workloads.len);159    std.mem.sort(usize, indices, workloads, workload_wall_descending);160    return indices;161}162163pub fn sortedByRss(allocator: std.mem.Allocator, workloads: []const Workload) ![]usize {164    const indices = try ordinalIndices(allocator, workloads.len);165    std.mem.sort(usize, indices, workloads, workload_rss_descending);166    return indices;167}168169pub fn outliersByWall(allocator: std.mem.Allocator, workloads: []const Workload) ![]usize {170    if (workloads.len < 3) return &.{};171    const median = (try medianWall(allocator, workloads)) orelse return &.{};172    if (median == 0) return &.{};173    var result: std.ArrayList(usize) = .empty;174    for (workloads, 0..) |workload, index| {175        if (@as(f64, @floatFromInt(workload.wall_ns)) > @as(f64, @floatFromInt(median)) * 3) try result.append(allocator, index);176    }177    return try result.toOwnedSlice(allocator);178}179180pub fn outliersByRss(allocator: std.mem.Allocator, workloads: []const Workload) ![]usize {181    if (workloads.len < 3) return &.{};182    const median = (try medianRss(allocator, workloads)) orelse return &.{};183    if (median <= 0) return &.{};184    var result: std.ArrayList(usize) = .empty;185    for (workloads, 0..) |workload, index| {186        const rss = workload.max_rss_kib orelse continue;187        if (@as(f64, @floatFromInt(rss)) > @as(f64, @floatFromInt(median)) * 3) try result.append(allocator, index);188    }189    return try result.toOwnedSlice(allocator);190}191192fn medianWall(allocator: std.mem.Allocator, workloads: []const Workload) !?u64 {193    const values = try allocator.alloc(u64, workloads.len);194    for (workloads, 0..) |workload, index| values[index] = workload.wall_ns;195    std.mem.sort(u64, values, {}, std.sort.asc(u64));196    return values[values.len / 2];197}198199fn medianRss(allocator: std.mem.Allocator, workloads: []const Workload) !?i64 {200    var values: std.ArrayList(i64) = .empty;201    for (workloads) |workload| {202        if (workload.max_rss_kib) |rss| try values.append(allocator, rss);203    }204    if (values.items.len == 0) return null;205    std.mem.sort(i64, values.items, {}, std.sort.asc(i64));206    return values.items[values.items.len / 2];207}208209fn ordinalIndices(allocator: std.mem.Allocator, count: usize) ![]usize {210    const indices = try allocator.alloc(usize, count);211    for (indices, 0..) |*slot, index| slot.* = index;212    return indices;213}

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