tiny.profiling.report.model

1const std = @import("std");2const capture = @import("capture");3const memtrace = @import("memtrace");4const pretty = @import("pretty");5const sys = @import("sys");67const profiling = @import("../root.zig");8const analysis = @import("root.zig").analysis;910const analyze = profiling.analyze;11const environment = profiling.environment;12const json = profiling.json;13const pretty_json = pretty.json;1415const fs_io = sys.fs.debugIo();16const max_manifest_bytes = 16 * 1024 * 1024;1718pub const Manifest = struct {19    run_id: []const u8,20    started_unix_ns: i128,21    wall_ns: ?u64,22    suite: []const u8,23    git_sha: ?[]const u8,24    git_branch: ?[]const u8,25    git_dirty: ?bool,26    zig_version: ?[]const u8,27    optimize: ?[]const u8,28    host: environment.Host,29};3031pub const Entry = struct {32    dir: []const u8,33    root: []const u8,34    manifest: Manifest,35    run: analyze.Run,36    recorded: ?analysis.Recorded,3738    pub fn findWorkload(self: *const Entry, name: []const u8) ?*const analyze.Workload {39        for (self.run.workloads) |*workload| {40            if (std.mem.eql(u8, workload.name, name)) return workload;41        }42        return null;43    }44};4546pub const MetricHistory = struct {47    key: []const u8,48    label: []const u8,49    primary: []?f64,50    low: []?f64,51    high: []?f64,52};5354pub const MemoryHistory = struct {55    key: []const u8,56    label: []const u8,57    unit: []const u8,58    values: []?f64,59};6061pub const WorkloadHistory = struct {62    name: []const u8,63    package: []const u8,64    wall: []?f64,65    rss: []?f64,66    metrics: []MetricHistory,67    memory: []MemoryHistory,68};6970pub const Site = struct {71    runs: []Entry,72    histories: []WorkloadHistory,7374    pub fn latest(self: Site) ?*const Entry {75        if (self.runs.len == 0) return null;76        return &self.runs[self.runs.len - 1];77    }7879    pub fn findHistory(self: Site, name: []const u8) ?*const WorkloadHistory {80        for (self.histories) |*history| {81            if (std.mem.eql(u8, history.name, name)) return history;82        }83        return null;84    }85};8687pub fn load(allocator: std.mem.Allocator, profiling_dir: []const u8) !Site {88    var entries: std.ArrayList(Entry) = .empty;89    const listing = sys.fs.listDirAlloc(allocator, profiling_dir) catch |err| switch (err) {90        error.FileNotFound => return .{ .runs = &.{}, .histories = &.{} },91        else => |actual| return actual,92    };93    for (listing) |item| {94        if (item.kind != .directory) continue;95        const manifest_path = try std.fs.path.join(allocator, &.{ item.path, "manifest.json" });96        if (!sys.fs.exists(manifest_path)) continue;97        const manifest = (try loadManifest(allocator, manifest_path, item.name)) orelse continue;98        const run = analyze.loadRun(allocator, item.path) catch continue;99        try entries.append(allocator, .{100            .dir = item.name,101            .root = item.path,102            .manifest = manifest,103            .run = run,104            .recorded = try analysis.load(allocator, item.path),105        });106    }107108    const runs = try entries.toOwnedSlice(allocator);109    std.mem.sort(Entry, runs, {}, startedBefore);110    return .{111        .runs = runs,112        .histories = try buildHistories(allocator, runs),113    };114}115116fn startedBefore(_: void, left: Entry, right: Entry) bool {117    return left.manifest.started_unix_ns < right.manifest.started_unix_ns;118}119120fn loadManifest(allocator: std.mem.Allocator, path: []const u8, dir_name: []const u8) !?Manifest {121    const text = sys.fs.readFileAlloc(allocator, path, max_manifest_bytes) catch |err| switch (err) {122        error.FileNotFound => return null,123        else => |actual| return actual,124    };125    const value = std.json.parseFromSliceLeaky(std.json.Value, allocator, text, .{}) catch return null;126    const object = json.object(value) catch return null;127    const selection = if (object.get("selection")) |actual| json.object(actual) catch null else null;128    const environment_object = if (object.get("environment")) |actual|129        json.object(actual) catch null130    else131        null;132    const summary = if (object.get("summary")) |actual| json.object(actual) catch null else null;133    const git = if (environment_object) |env|134        (if (env.get("git")) |actual| json.object(actual) catch null else null)135    else136        null;137    const zig_info = if (environment_object) |env|138        (if (env.get("zig")) |actual| json.object(actual) catch null else null)139    else140        null;141    const build = if (environment_object) |env|142        (if (env.get("build")) |actual| json.object(actual) catch null else null)143    else144        null;145    return .{146        .run_id = json.string(object.get("run_id")) orelse dir_name,147        .started_unix_ns = json.asI128(object.get("started_unix_ns")) orelse 0,148        .wall_ns = if (summary) |actual| json.asU64(actual.get("wall_ns")) else null,149        .suite = if (selection) |actual| json.string(actual.get("suite")) orelse "unknown" else "unknown",150        .git_sha = if (git) |actual| json.string(actual.get("commit")) else null,151        .git_branch = if (git) |actual| json.string(actual.get("branch")) else null,152        .git_dirty = if (git) |actual| json.asBool(actual.get("dirty")) else null,153        .zig_version = if (zig_info) |actual| json.string(actual.get("version")) else null,154        .optimize = if (build) |actual| json.string(actual.get("optimize")) else null,155        .host = profiling.environment.parse(object.get("environment")),156    };157}158159fn buildHistories(allocator: std.mem.Allocator, runs: []const Entry) ![]WorkloadHistory {160    var names: std.StringArrayHashMapUnmanaged(void) = .empty;161    for (runs, 0..) |entry, run_index| {162        if (!compatibleWithLatest(runs, run_index)) continue;163        for (entry.run.workloads) |workload| try names.put(allocator, workload.name, {});164    }165166    var histories: std.ArrayList(WorkloadHistory) = .empty;167    for (names.keys()) |name| {168        try histories.append(allocator, try buildWorkloadHistory(allocator, runs, name));169    }170    return try histories.toOwnedSlice(allocator);171}172173fn buildWorkloadHistory(allocator: std.mem.Allocator, runs: []const Entry, name: []const u8) !WorkloadHistory {174    const wall = try allocator.alloc(?f64, runs.len);175    const rss = try allocator.alloc(?f64, runs.len);176    var package: []const u8 = "";177178    var metric_keys: std.StringArrayHashMapUnmanaged([]const u8) = .empty;179    var memory_keys: std.StringArrayHashMapUnmanaged(MemoryHistory) = .empty;180181    for (runs, 0..) |entry, run_index| {182        wall[run_index] = null;183        rss[run_index] = null;184        if (!compatibleWithLatest(runs, run_index)) continue;185        const workload = entry.findWorkload(name) orelse continue;186        if (workload.package.len != 0) package = workload.package;187        if (workloadComparableWithLatest(runs, run_index, name)) {188            wall[run_index] = @floatFromInt(workload.wall_ns);189            if (workload.max_rss_kib) |value| rss[run_index] = @floatFromInt(value);190        }191        for (workload.metrics) |metric| {192            if (metric.primaryNs() == null) continue;193            if (!metric_keys.contains(metric.key)) try metric_keys.put(allocator, metric.key, metric.label);194        }195        for (workload.memory_metrics) |metric| {196            if (!memory_keys.contains(metric.key)) {197                try memory_keys.put(allocator, metric.key, .{198                    .key = metric.key,199                    .label = metric.label,200                    .unit = metric.unit.name(),201                    .values = &.{},202                });203            }204        }205    }206207    var metrics: std.ArrayList(MetricHistory) = .empty;208    var key_iterator = metric_keys.iterator();209    while (key_iterator.next()) |pair| {210        const primary = try allocator.alloc(?f64, runs.len);211        const low = try allocator.alloc(?f64, runs.len);212        const high = try allocator.alloc(?f64, runs.len);213        for (runs, 0..) |entry, run_index| {214            primary[run_index] = null;215            low[run_index] = null;216            high[run_index] = null;217            if (!compatibleWithLatest(runs, run_index)) continue;218            const workload = entry.findWorkload(name) orelse continue;219            for (workload.metrics) |metric| {220                if (!std.mem.eql(u8, metric.key, pair.key_ptr.*)) continue;221                primary[run_index] = metric.primaryNs();222                if (metric.primaryInterval()) |interval| {223                    low[run_index] = interval.low_ns;224                    high[run_index] = interval.high_ns;225                }226                break;227            }228        }229        try metrics.append(allocator, .{230            .key = pair.key_ptr.*,231            .label = pair.value_ptr.*,232            .primary = primary,233            .low = low,234            .high = high,235        });236    }237238    var memory: std.ArrayList(MemoryHistory) = .empty;239    var memory_iterator = memory_keys.iterator();240    while (memory_iterator.next()) |pair| {241        const values = try allocator.alloc(?f64, runs.len);242        for (runs, 0..) |entry, run_index| {243            values[run_index] = null;244            if (!compatibleWithLatest(runs, run_index)) continue;245            const workload = entry.findWorkload(name) orelse continue;246            for (workload.memory_metrics) |metric| {247                if (!std.mem.eql(u8, metric.key, pair.key_ptr.*)) continue;248                values[run_index] = metric.value;249                break;250            }251        }252        var history = pair.value_ptr.*;253        history.values = values;254        try memory.append(allocator, history);255    }256257    return .{258        .name = name,259        .package = package,260        .wall = wall,261        .rss = rss,262        .metrics = try metrics.toOwnedSlice(allocator),263        .memory = try memory.toOwnedSlice(allocator),264    };265}266267fn compatibleWithLatest(runs: []const Entry, run_index: usize) bool {268    if (runs.len == 0) return false;269    std.debug.assert(run_index < runs.len);270    return analyze.comparisonSupport(runs[run_index].run, runs[runs.len - 1].run) == .supported;271}272273fn workloadComparableWithLatest(274    runs: []const Entry,275    run_index: usize,276    name: []const u8,277) bool {278    if (runs.len == 0 or !compatibleWithLatest(runs, run_index)) return false;279    const workload = runs[run_index].findWorkload(name) orelse return false;280    const latest = runs[runs.len - 1].findWorkload(name) orelse return false;281    return analyze.workloadComparisonSupport(workload.*, latest.*) == .supported;282}283284fn writeFixtureSymbolSummary(285    allocator: std.mem.Allocator,286    workload_dir: []const u8,287    quality: ?capture.stackcollapse.Summary,288) !void {289    const symbols_path = try std.fs.path.join(290        allocator,291        &.{ workload_dir, "perf.symbols.summary.json" },292    );293    try capture.perfreport.writeSymbolSummaryFile(symbols_path, .{294        .source_path = "perf.symbols.tsv",295        .total_lost_samples = 0,296        .sample_count_text = "10",297        .sample_count_approx = 10,298        .call_graph = "fp",299        .sampling_frequency_hz = 99,300        .minimum_sample_count = 400,301        .report_percent_limit = 0.5,302        .maximum_two_sigma_share_half_width_percentage_points = 31.622776601683793,303        .callchain_quality = quality,304        .event = "cycles:P",305        .event_count_approx = 1000,306        .rows = &.{.{307            .overhead_percent = 12.25,308            .samples = 2,309            .symbol = "[.] alloc.refill",310            .shared_object = "gpalloc-bench",311            .ipc = null,312            .ipc_coverage_percent = null,313        }},314    });315}316317fn writeFixtureResults(318    allocator: std.mem.Allocator,319    root: []const u8,320    workload_dir: []const u8,321    run_id: []const u8,322    started_unix_ns: i128,323    wall_ns: u64,324    hostname: []const u8,325    has_captures: bool,326) !void {327    const results_path = try std.fs.path.join(allocator, &.{ root, "results.jsonl" });328    const finished_unix_ns = started_unix_ns + wall_ns;329    const empty_strings: []const []const u8 = &.{};330    const command_argv: []const []const u8 = &.{ "zig", "build", "gpalloc-bench" };331    var file = try sys.fs.cwd().createFile(fs_io, results_path, .{ .truncate = true });332    defer file.close(fs_io);333    var buffer: [8192]u8 = undefined;334    var file_writer = file.writer(fs_io, &buffer);335    const writer = &file_writer.interface;336337    {338        var json_writer = pretty_json.Writer.init(writer, .minified);339        const row = try json_writer.object();340        try row.fields(.{341            .schema = "tiny.profiling.run/v1",342            .event = "run_start",343            .run_id = run_id,344            .started_unix_ns = started_unix_ns,345        });346        try row.field("selection", .{347            .suite = "smoke",348            .filters = empty_strings,349            .workload_count = @as(u8, 1),350        });351        try row.field("environment", .{352            .build = .{ .optimize = "ReleaseFast" },353            .host = .{354                .hostname = hostname,355                .os = "linux",356                .kernel = "7.0.11",357                .arch = "x86_64",358                .cpu_model = "AMD Ryzen 7 7800X3D",359                .cpu_count = @as(u8, 16),360                .cpu_frequency_policy = "policy-a",361                .process_cpu_affinity = "0-15",362                .process_memory_affinity = "0",363            },364        });365        try row.field("artifacts", .{366            .root = root,367            .results = "results.jsonl",368            .manifest = "manifest.json",369        });370        try row.endLine();371    }372373    {374        var json_writer = pretty_json.Writer.init(writer, .minified);375        const row = try json_writer.object();376        try row.fields(.{377            .schema = profiling.record.workload_schema,378            .event = "workload",379            .run_id = run_id,380            .index = @as(u8, 0),381        });382        try row.field("acquisition", .{383            .position = @as(u8, 1),384            .workload_count = @as(u8, 1),385            .predecessors = empty_strings,386        });387        try row.field("workload", .{388            .name = "gpalloc.allocator",389            .package = "lib/gpalloc",390            .step = "gpalloc-bench",391            .surface = "benchmark",392        });393        try row.fields(.{394            .scope = "whole-step",395            .causal = false,396            .tracy = false,397            .trace_allocations = false,398        });399        try row.field("command", .{400            .text = "zig build gpalloc-bench",401            .cwd = @as(?[]const u8, null),402            .argv = command_argv,403        });404        try row.field("status", .{405            .state = "passed",406            .exit_code = @as(u8, 0),407        });408        try row.field("timing", .{409            .started_unix_ns = started_unix_ns,410            .finished_unix_ns = finished_unix_ns,411            .wall_ns = wall_ns,412        });413        try row.field("resources", .{414            .resource_usage_source = "wait4_rusage",415            .max_rss_kib = @as(u32, 49_836),416            .user_s = @as(f64, 0.3),417            .system_s = @as(f64, 0.4),418            .minor_page_faults = @as(u8, 96),419            .major_page_faults = @as(u8, 0),420            .voluntary_context_switches = @as(u8, 2),421            .involuntary_context_switches = @as(u8, 1),422        });423        const measurement_row = try row.object("measurement");424        try measurement_row.fields(.{425            .execution_count = @as(u8, 1),426            .acquisition_order = "fixed_plan_order",427            .workload_output_retention = "all_measured_executions",428            .measured_artifact_layout = "workload_root",429            .allocation_summary_retention = "disabled",430        });431        try measurement_row.field("benchmark_process_domain", .{432            .benchmark_surface = true,433            .direct_execution = false,434            .host_profiler = has_captures,435            .tracy = false,436            .causal = false,437            .allocation_trace = false,438            .capture_control = false,439        });440        try measurement_row.field("benchmark_process_reduction", .{441            .schema = profiling.reduction.schema,442            .state = "not_applicable",443            .process_count = @as(u8, 1),444            .reason = "outside_direct_benchmark_domain",445        });446        const executions = try measurement_row.array("executions");447        const execution = try executions.object();448        try execution.fields(.{449            .index = @as(u8, 1),450            .spawn_state = "spawned",451            .pid = @as(u16, 101),452            .exit_code = @as(u8, 0),453            .wall_ns = wall_ns,454        });455        const artifacts = try execution.object("artifacts");456        try artifacts.field("root", workload_dir);457        inline for (.{458            .{ "stdout", "/stdout.txt" },459            .{ "stderr", "/stderr.txt" },460            .{ "bench_jsonl", "/bench.jsonl" },461            .{ "coz_jsonl", "/bench.coz.jsonl" },462            .{ "coz_analysis", "/bench.coz.analysis.json" },463            .{ "tracy_jsonl", "/bench.tracy.jsonl" },464            .{ "tracy_summary", "/bench.tracy.summary.jsonl" },465        }) |field| {466            try artifacts.stringParts(field[0], &.{ workload_dir, field[1] });467        }468        try artifacts.stringParts(469            "structured",470            &.{ workload_dir, "/structured.jsonl" },471        );472        try artifacts.stringParts(473            "allocations",474            &.{ workload_dir, "/allocations.jsonl" },475        );476        try artifacts.fields(.{477            .structured_rows = @as(u8, 2),478            .structured_parse_errors = @as(u8, 0),479        });480        try artifacts.end();481        try execution.end();482        try executions.end();483        try measurement_row.end();484        const workload_artifacts = try row.object("artifacts");485        try workload_artifacts.field("root", workload_dir);486        try workload_artifacts.end();487        const captures = try row.array("captures");488        if (has_captures) {489            const perf = try captures.object();490            try perf.fields(.{491                .kind = "perf_record",492                .tool = "perf",493                .scope = "whole-step",494            });495            try perf.stringParts("capture", &.{ workload_dir, "/perf.data" });496            try perf.stringParts(497                "summary",498                &.{ workload_dir, "/perf.symbols.summary.json" },499            );500            try perf.field("state", "summary_written");501            try perf.end();502503            const offcpu = try captures.object();504            try offcpu.fields(.{505                .kind = "offcpu_time",506                .tool = "offcputime-bpfcc",507                .scope = "workload-binary",508            });509            try offcpu.stringParts(510                "capture",511                &.{ workload_dir, "/offcpu.time.txt" },512            );513            try offcpu.stringParts(514                "summary",515                &.{ workload_dir, "/offcpu.summary.json" },516            );517            try offcpu.field("state", "summary_written");518            try offcpu.end();519        }520        try captures.end();521        try row.endLine();522    }523524    {525        var json_writer = pretty_json.Writer.init(writer, .minified);526        const row = try json_writer.object();527        try row.fields(.{528            .schema = "tiny.profiling.run/v1",529            .event = "run_end",530            .run_id = run_id,531            .started_unix_ns = started_unix_ns,532        });533        try row.field("summary", .{534            .selected = @as(u8, 1),535            .ran = @as(u8, 1),536            .passed = @as(u8, 1),537            .failed = @as(u8, 0),538            .stopped_early = false,539            .exit_code = @as(u8, 0),540            .started_unix_ns = started_unix_ns,541            .finished_unix_ns = finished_unix_ns,542            .wall_ns = wall_ns,543        });544        try row.endLine();545    }546547    try writer.flush();548}549550fn writeFixtureCaptureArtifacts(551    allocator: std.mem.Allocator,552    workload_dir: []const u8,553    folded_text: []const u8,554    callchain_quality: ?capture.stackcollapse.Summary,555) !void {556    const folded_path = try std.fs.path.join(557        allocator,558        &.{ workload_dir, "perf.folded.txt" },559    );560    try sys.fs.writeFile(folded_path, folded_text);561    try writeFixtureSymbolSummary(allocator, workload_dir, callchain_quality);562563    const children_path = try std.fs.path.join(564        allocator,565        &.{ workload_dir, "perf.children.summary.json" },566    );567    const children_rows = [_]capture.perfreport.ChildrenRow{.{568        .children_overhead_percent = 88.5,569        .self_overhead_percent = 12.25,570        .samples = 9,571        .symbol = "[.] alloc.refill",572        .shared_object = "gpalloc-bench",573        .ipc = null,574        .ipc_coverage_percent = null,575    }};576    try capture.perfreport.writeChildrenSummaryFile(children_path, .{577        .source_path = "perf.children.tsv",578        .total_lost_samples = 0,579        .sample_count_text = "10",580        .sample_count_approx = 10,581        .event = "cycles:P",582        .event_count_approx = 1000,583        .rows = &children_rows,584    });585586    const allocations_path = try std.fs.path.join(587        allocator,588        &.{ workload_dir, "allocations.jsonl" },589    );590    var allocations_file = try sys.fs.cwd().createFile(591        fs_io,592        allocations_path,593        .{ .truncate = true },594    );595    defer allocations_file.close(fs_io);596    var allocations_buffer: [8192]u8 = undefined;597    var allocations_writer = allocations_file.writer(fs_io, &allocations_buffer);598    const trace_rows = [_]struct {599        event: memtrace.Event,600        scope: ?[]const u8 = null,601    }{602        .{ .event = .{ .seq = 1, .kind = .trace_start } },603        .{ .event = .{604            .seq = 2,605            .kind = .allocator,606            .allocator_id = 1,607            .retains_freed_memory = true,608        } },609        .{610            .event = .{611                .seq = 3,612                .kind = .alloc,613                .allocator_id = 1,614                .allocation_id = 1,615                .address = 128,616                .len = 4096,617                .return_address = 2748,618            },619            .scope = "root/refill",620        },621        .{622            .event = .{623                .seq = 4,624                .kind = .alloc,625                .allocator_id = 1,626                .allocation_id = 2,627                .address = 8320,628                .len = 1024,629                .return_address = 2749,630            },631            .scope = "root/free",632        },633        .{634            .event = .{635                .seq = 5,636                .kind = .free,637                .allocator_id = 1,638                .allocation_id = 2,639                .address = 8320,640                .len = 1024,641                .return_address = 2749,642            },643            .scope = "root/free",644        },645        .{ .event = .{ .seq = 6, .kind = .trace_stop } },646    };647    for (trace_rows) |row| {648        try row.event.writeJsonLine(&allocations_writer.interface, null, row.scope);649    }650    try allocations_writer.interface.flush();651652    const srcline_path = try std.fs.path.join(653        allocator,654        &.{ workload_dir, "perf.srcline.summary.json" },655    );656    const srcline_rows = [_]capture.perfreport.SrclineRow{.{657        .overhead_percent = 12.25,658        .samples = 2,659        .source_line = "heap.zig:212",660        .symbol = "[.] alloc.refill",661        .shared_object = "gpalloc-bench",662        .ipc = null,663        .ipc_coverage_percent = null,664    }};665    try capture.perfreport.writeSrclineSummaryFile(srcline_path, .{666        .source_path = "perf.srcline.tsv",667        .total_lost_samples = 0,668        .sample_count_text = "10",669        .sample_count_approx = 10,670        .event = "cycles:P",671        .event_count_approx = 1000,672        .rows = &srcline_rows,673    });674675    const offcpu_path = try std.fs.path.join(676        allocator,677        &.{ workload_dir, "offcpu.summary.json" },678    );679    const blocked_frames: []const []const u8 = &.{ "futex_wait", "do_futex" };680    const blocked_rows = [_]capture.offcpu.BlockedRow{.{681        .key = "a",682        .source = "offcputime",683        .subclass = "synchronization",684        .task = "gpalloc-bench",685        .stack_kind = "folded",686        .weight = 9000,687        .weight_unit = "nanoseconds",688        .duration_ns = 9000,689        .count = null,690        .frames = blocked_frames,691    }};692    try capture.offcpu.writeBlockedSummaryFile(offcpu_path, .{693        .source_path = "offcpu.time.txt",694        .source = "offcputime",695        .weight_unit = "nanoseconds",696        .total_weight = 9000,697        .total_duration_ns = 9000,698        .total_count = null,699        .rows = &blocked_rows,700    });701}702703fn writeFixtureManifest(704    allocator: std.mem.Allocator,705    root: []const u8,706    run_id: []const u8,707    started_unix_ns: i128,708    wall_ns: u64,709    hostname: []const u8,710) !void {711    const manifest_path = try std.fs.path.join(712        allocator,713        &.{ root, "manifest.json" },714    );715    const finished_unix_ns = started_unix_ns + wall_ns;716    const empty_strings: []const []const u8 = &.{};717    var file = try sys.fs.cwd().createFile(fs_io, manifest_path, .{ .truncate = true });718    defer file.close(fs_io);719    var buffer: [8192]u8 = undefined;720    var file_writer = file.writer(fs_io, &buffer);721    const writer = &file_writer.interface;722    var json_writer = pretty_json.Writer.init(writer, .minified);723    const document = try json_writer.object();724    try document.fields(.{725        .schema = "tiny.profiling.run/v1",726        .event = "manifest",727        .run_id = run_id,728        .started_unix_ns = started_unix_ns,729    });730    try document.field("selection", .{731        .suite = "smoke",732        .filters = empty_strings,733        .workload_count = @as(u8, 1),734    });735    try document.field("environment", .{736        .git = .{737            .commit = "abcdef123456",738            .branch = "main",739            .dirty = false,740        },741        .zig = .{ .version = "0.16.0" },742        .build = .{ .optimize = "ReleaseFast" },743        .host = .{744            .hostname = hostname,745            .os = "linux",746            .kernel = "7.0.11",747            .arch = "x86_64",748            .cpu_model = "AMD Ryzen 7 7800X3D",749            .cpu_count = @as(u8, 16),750            .cpu_frequency_policy = "policy-a",751            .process_cpu_affinity = "0-15",752            .process_memory_affinity = "0",753        },754    });755    try document.field("summary", .{756        .selected = @as(u8, 1),757        .ran = @as(u8, 1),758        .passed = @as(u8, 1),759        .failed = @as(u8, 0),760        .stopped_early = false,761        .exit_code = @as(u8, 0),762        .started_unix_ns = started_unix_ns,763        .finished_unix_ns = finished_unix_ns,764        .wall_ns = wall_ns,765    });766    const artifacts = try document.object("artifacts");767    try artifacts.field("root", root);768    try artifacts.stringParts("results", &.{ root, "/results.jsonl" });769    try artifacts.stringParts("manifest", &.{ root, "/manifest.json" });770    try artifacts.stringParts("workloads", &.{ root, "/workloads" });771    try artifacts.end();772    try document.end();773    try writer.flush();774}775776fn writeFixtureStructured(777    allocator: std.mem.Allocator,778    workload_dir: []const u8,779    median_ns: u64,780) !void {781    const structured_path = try std.fs.path.join(782        allocator,783        &.{ workload_dir, "structured.jsonl" },784    );785    var file = try sys.fs.cwd().createFile(fs_io, structured_path, .{ .truncate = true });786    defer file.close(fs_io);787    var buffer: [8192]u8 = undefined;788    var file_writer = file.writer(fs_io, &buffer);789    const writer = &file_writer.interface;790    try pretty_json.writeMinifiedLine(writer, .{791        .schema = "tiny.profiling.structured/v1",792        .workload = .{793            .name = "gpalloc.allocator",794            .package = "lib/gpalloc",795            .step = "gpalloc-bench",796        },797        .source = .{798            .kind = "bench_jsonl",799            .path = "x",800            .line = @as(u8, 1),801        },802        .row = .{803            .schema = "tiny.profiling.metric/v1",804            .family = "timing",805            .unit = "ns",806            .id = "alloc-free",807            .name = "alloc-free",808            .median_ns = median_ns,809            .sample_count = @as(u8, 10),810            .confidence_intervals = .{811                .median_ns = .{812                    .low_ns = median_ns - 5,813                    .high_ns = median_ns + 5,814                },815            },816        },817    });818    try pretty_json.writeMinifiedLine(writer, .{819        .schema = "tiny.profiling.structured/v1",820        .workload = .{821            .name = "gpalloc.allocator",822            .package = "lib/gpalloc",823            .step = "gpalloc-bench",824        },825        .source = .{826            .kind = "bench_jsonl",827            .path = "x",828            .line = @as(u8, 2),829        },830        .row = .{831            .schema = "tiny.profiling.metric/v1",832            .family = "memory",833            .unit = "bytes",834            .metric = "allocated_bytes",835            .name = "allocated_bytes",836            .value = @as(u64, 4096),837        },838    });839    try writer.flush();840}841842fn writeFixtureRun(843    allocator: std.mem.Allocator,844    profiling_dir: []const u8,845    run_id: []const u8,846    started_unix_ns: i128,847    wall_ns: u64,848    median_ns: u64,849    hostname: []const u8,850    folded: ?[]const u8,851    callchain_quality: ?capture.stackcollapse.Summary,852) !void {853    const root = try std.fs.path.join(allocator, &.{ profiling_dir, run_id });854    const workload_dir = try std.fs.path.join(allocator, &.{ root, "workloads", "gpalloc.allocator" });855    try sys.fs.createDirPath(workload_dir);856857    if (folded) |folded_text| {858        try writeFixtureCaptureArtifacts(859            allocator,860            workload_dir,861            folded_text,862            callchain_quality,863        );864    }865866    try writeFixtureManifest(867        allocator,868        root,869        run_id,870        started_unix_ns,871        wall_ns,872        hostname,873    );874    try writeFixtureStructured(allocator, workload_dir, median_ns);875    try writeFixtureResults(876        allocator,877        root,878        workload_dir,879        run_id,880        started_unix_ns,881        wall_ns,882        hostname,883        folded != null,884    );885}886887pub fn writeTestFixture(allocator: std.mem.Allocator, profiling_dir: []const u8) !void {888    const baseline_folded =889        \\gpalloc-bench;main;alloc;refill 5890        \\gpalloc-bench;main;free 5891        \\892    ;893    const baseline_quality: capture.stackcollapse.Summary = .{894        .sample_count = 10,895        .unique_callchain_count = 2,896        .weighted_frame_count = 25,897        .resolved_frame_count = 25,898        .maximum_depth_frames = 3,899    };900    try writeFixtureRun(901        allocator,902        profiling_dir,903        "run-100-aaa",904        100_000,905        60_000_000,906        1_000,907        "bench-a",908        baseline_folded,909        baseline_quality,910    );911    const candidate_folded =912        \\gpalloc-bench;main;[unknown];alloc;refill 6913        \\gpalloc-bench;main;alloc 3914        \\gpalloc-bench;main;free 1915        \\916    ;917    const candidate_quality: capture.stackcollapse.Summary = .{918        .sample_count = 10,919        .unique_callchain_count = 3,920        .weighted_frame_count = 32,921        .resolved_frame_count = 26,922        .unresolved_frame_count = 6,923        .samples_with_unresolved_frames = 6,924        .maximum_depth_frames = 4,925    };926    try writeFixtureRun(927        allocator,928        profiling_dir,929        "run-200-bbb",930        200_000,931        66_000_000,932        1_200,933        "bench-a",934        candidate_folded,935        candidate_quality,936    );937}938939test "model loads runs chronologically and builds histories" {940    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);941    defer arena_state.deinit();942    const allocator = arena_state.allocator();943    const profiling_dir = ".zig-cache/profile-web-model-test";944    defer sys.fs.deleteTree(profiling_dir) catch {};945    try writeTestFixture(allocator, profiling_dir);946947    const site = try load(allocator, profiling_dir);948    try std.testing.expectEqual(@as(usize, 2), site.runs.len);949    try std.testing.expectEqualStrings("run-100-aaa", site.runs[0].manifest.run_id);950    try std.testing.expectEqualStrings("run-200-bbb", site.runs[1].manifest.run_id);951    try std.testing.expectEqualStrings("smoke", site.runs[0].manifest.suite);952    try std.testing.expectEqual(@as(u64, 60_000_000), site.runs[0].manifest.wall_ns.?);953    try std.testing.expectEqualStrings("bench-a", site.runs[0].manifest.host.hostname.?);954    try std.testing.expectEqualStrings("policy-a", site.runs[0].manifest.host.cpu_frequency_policy.?);955    try std.testing.expectEqualStrings("run-200-bbb", site.latest().?.manifest.run_id);956957    try std.testing.expectEqual(@as(usize, 1), site.histories.len);958    const history = site.findHistory("gpalloc.allocator").?;959    try std.testing.expectEqualStrings("lib/gpalloc", history.package);960    try std.testing.expectEqual(@as(usize, 2), history.wall.len);961    try std.testing.expectEqual(@as(f64, 60_000_000), history.wall[0].?);962    try std.testing.expectEqual(@as(f64, 66_000_000), history.wall[1].?);963    try std.testing.expectEqual(@as(usize, 1), history.metrics.len);964    try std.testing.expectEqual(@as(f64, 1_000), history.metrics[0].primary[0].?);965    try std.testing.expectEqual(@as(f64, 1_200), history.metrics[0].primary[1].?);966    try std.testing.expectEqual(@as(f64, 1_205), history.metrics[0].high[1].?);967    try std.testing.expectEqual(@as(usize, 1), history.memory.len);968    try std.testing.expectEqual(@as(f64, 4096), history.memory[0].values[1].?);969    try std.testing.expectEqual(@as(usize, 2), site.runs[0].run.workloads[0].captures.len);970    try std.testing.expectEqual(@as(usize, 2), site.runs[1].run.workloads[0].captures.len);971    try std.testing.expectEqualStrings("perf_record", site.runs[1].run.workloads[0].captures[0].kind);972    try std.testing.expectEqual(973        @as(usize, 1),974        site.runs[1].run.workloads[0].acquisition.blocked.position,975    );976}977978test "model fixture JSON escapes dynamic host strings" {979    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);980    defer arena_state.deinit();981    const allocator = arena_state.allocator();982    const profiling_dir = ".zig-cache/profile-web-model-json-escaping-test";983    defer sys.fs.deleteTree(profiling_dir) catch {};984    try writeFixtureRun(985        allocator,986        profiling_dir,987        "run-escaped",988        100_000,989        60_000_000,990        1_000,991        "bench\"line\nhost",992        null,993        null,994    );995    const site = try load(allocator, profiling_dir);996    try std.testing.expectEqualStrings(997        "bench\"line\nhost",998        site.runs[0].manifest.host.hostname.?,999    );1000    try std.testing.expectEqualStrings(1001        "bench\"line\nhost",1002        site.runs[0].run.host.hostname.?,1003    );1004}10051006test "model retains the process placement envelope" {1007    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);1008    defer arena_state.deinit();1009    const allocator = arena_state.allocator();1010    const profiling_dir = ".zig-cache/profile-web-model-placement-test";1011    defer sys.fs.deleteTree(profiling_dir) catch {};1012    try writeTestFixture(allocator, profiling_dir);1013    const site = try load(allocator, profiling_dir);1014    const host = site.runs[0].manifest.host;1015    try std.testing.expectEqualStrings("0-15", host.process_cpu_affinity.?);1016    try std.testing.expectEqualStrings("0", host.process_memory_affinity.?);1017}10181019test "model leaves acquisition-context wall history gaps" {1020    const host_value = environment.Host{1021        .hostname = "bench-a",1022        .os = "linux",1023        .kernel = "7.0.11",1024        .arch = "x86_64",1025        .cpu_model = "CPU",1026        .cpu_count = 8,1027        .cpu_frequency_policy = "policy-a",1028        .process_cpu_affinity = "0-7",1029        .process_memory_affinity = "0",1030    };1031    const base_workloads = [_]analyze.Workload{.{1032        .name = "target",1033        .package = "p",1034        .step = "bench",1035        .acquisition = .{ .blocked = .{1036            .position = 2,1037            .workload_count = 2,1038            .predecessors = &.{"a"},1039        } },1040        .status = "passed",1041        .exit_code = 0,1042        .wall_ns = 10,1043        .max_rss_kib = null,1044        .user_s = null,1045        .system_s = null,1046        .result_path = null,1047    }};1048    const candidate_workloads = [_]analyze.Workload{.{1049        .name = "target",1050        .package = "p",1051        .step = "bench",1052        .acquisition = .{ .blocked = .{1053            .position = 2,1054            .workload_count = 2,1055            .predecessors = &.{"b"},1056        } },1057        .status = "passed",1058        .exit_code = 0,1059        .wall_ns = 20,1060        .max_rss_kib = null,1061        .user_s = null,1062        .system_s = null,1063        .result_path = null,1064    }};1065    const entries = [_]Entry{1066        .{1067            .dir = "base",1068            .root = "base",1069            .manifest = .{1070                .run_id = "base",1071                .started_unix_ns = 1,1072                .wall_ns = 1,1073                .suite = "smoke",1074                .git_sha = null,1075                .git_branch = null,1076                .git_dirty = null,1077                .zig_version = null,1078                .optimize = "ReleaseFast",1079                .host = host_value,1080            },1081            .run = .{1082                .ref = .{1083                    .run_id = "base",1084                    .root = "base",1085                    .manifest_path = "base/manifest.json",1086                    .results_path = "base/results.jsonl",1087                },1088                .optimize = "ReleaseFast",1089                .host = host_value,1090                .workloads = &base_workloads,1091            },1092            .recorded = null,1093        },1094        .{1095            .dir = "candidate",1096            .root = "candidate",1097            .manifest = .{1098                .run_id = "candidate",1099                .started_unix_ns = 2,1100                .wall_ns = 1,1101                .suite = "smoke",1102                .git_sha = null,1103                .git_branch = null,1104                .git_dirty = null,1105                .zig_version = null,1106                .optimize = "ReleaseFast",1107                .host = host_value,1108            },1109            .run = .{1110                .ref = .{1111                    .run_id = "candidate",1112                    .root = "candidate",1113                    .manifest_path = "candidate/manifest.json",1114                    .results_path = "candidate/results.jsonl",1115                },1116                .optimize = "ReleaseFast",1117                .host = host_value,1118                .workloads = &candidate_workloads,1119            },1120            .recorded = null,1121        },1122    };1123    try std.testing.expect(!workloadComparableWithLatest(&entries, 0, "target"));1124    try std.testing.expect(workloadComparableWithLatest(&entries, 1, "target"));1125}11261127test "model leaves incompatible host runs as trend gaps" {1128    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);1129    defer arena_state.deinit();1130    const allocator = arena_state.allocator();1131    const profiling_dir = ".zig-cache/profile-web-host-cohort-test";1132    defer sys.fs.deleteTree(profiling_dir) catch {};1133    try writeFixtureRun(1134        allocator,1135        profiling_dir,1136        "run-100-aaa",1137        100_000,1138        60_000_000,1139        1_000,1140        "bench-a",1141        null,1142        null,1143    );1144    try writeFixtureRun(1145        allocator,1146        profiling_dir,1147        "run-200-bbb",1148        200_000,1149        66_000_000,1150        1_200,1151        "bench-b",1152        null,1153        null,1154    );11551156    const site = try load(allocator, profiling_dir);1157    const history = site.findHistory("gpalloc.allocator").?;1158    try std.testing.expectEqual(@as(?f64, null), history.wall[0]);1159    try std.testing.expectEqual(@as(f64, 66_000_000), history.wall[1].?);1160    try std.testing.expectEqual(@as(?f64, null), history.metrics[0].primary[0]);1161    try std.testing.expectEqual(@as(f64, 1_200), history.metrics[0].primary[1].?);1162}11631164test "model tolerates a missing profiling directory" {1165    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);1166    defer arena_state.deinit();1167    const allocator = arena_state.allocator();1168    const site = try load(allocator, ".zig-cache/profile-web-does-not-exist");1169    try std.testing.expectEqual(@as(usize, 0), site.runs.len);1170    try std.testing.expectEqual(@as(usize, 0), site.histories.len);1171}

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