tiny.profiling.report.page

1const std = @import("std");2const sys = @import("sys");3const zen = @import("zen");45const profiling = @import("../root.zig");6const analysis = @import("root.zig").analysis;7const chart = @import("root.zig").chart;8const flame = @import("root.zig").flame;9const format = @import("root.zig").format;10const model = @import("root.zig").model;1112const analyze = profiling.analyze;13const Allocator = std.mem.Allocator;1415pub const log_tail_bytes = 8 * 1024;1617const Html = struct {18    allocator: Allocator,19    out: std.ArrayList(u8) = .empty,2021    fn raw(self: *Html, text: []const u8) Allocator.Error!void {22        try self.out.appendSlice(self.allocator, text);23    }2425    fn esc(self: *Html, text: []const u8) Allocator.Error!void {26        try zen.html.appendEscaped(&self.out, self.allocator, text);27    }2829    fn fmt(self: *Html, comptime f: []const u8, args: anytype) Allocator.Error!void {30        const text = try std.fmt.allocPrint(self.allocator, f, args);31        defer self.allocator.free(text);32        try self.out.appendSlice(self.allocator, text);33    }3435    fn take(self: *Html) Allocator.Error![]u8 {36        return try self.out.toOwnedSlice(self.allocator);37    }38};3940pub fn index(allocator: Allocator, site: model.Site) ![]u8 {41    var html = Html{ .allocator = allocator };42    try html.raw("<nav class=\"crumbs\"><a href=\"index.html\">tiny profiling</a></nav>");43    try html.raw("<h1>Profiling</h1>");44    try indexLede(&html, site);45    try indexVerdict(&html, site);46    try indexTrends(&html, allocator, site);47    try indexRuns(&html, allocator, site);48    return try html.take();49}5051fn indexLede(html: *Html, site: model.Site) !void {52    const latest = site.latest() orelse {53        try html.raw("<p class=\"lede\">No profiling runs found. Run <code>zig build profile-cycle</code> or <code>zig build profile-run</code> first.</p>");54        return;55    };56    try html.fmt("<p class=\"lede\">{d} run(s) · latest <a href=\"runs/", .{site.runs.len});57    try html.esc(latest.dir);58    try html.raw("/index.html\">");59    try html.esc(latest.manifest.run_id);60    try html.raw("</a> started ");61    try html.esc(try format.timestamp(html.allocator, latest.manifest.started_unix_ns));62    try html.raw(" · suite ");63    try html.esc(latest.manifest.suite);64    try html.fmt(" · {d}/{d} passed</p>", .{ latest.run.passed(), latest.run.ran() });65}6667fn indexVerdict(html: *Html, site: model.Site) !void {68    const latest = site.latest() orelse return;69    try html.raw("<section><h2>Latest verdict</h2>");70    const recorded = latest.recorded orelse {71        try html.raw("<p class=\"verdict muted\">The latest run has no recorded analysis. Cycle runs (<code>zig build profile-cycle</code>) record one against the previous cycle.</p></section>");72        return;73    };74    const baseline = recorded.baseline orelse {75        try html.raw("<p class=\"verdict muted\">First cycle: baseline recorded, nothing to compare against yet.</p></section>");76        return;77    };78    if (recorded.comparison_support) |support| {79        if (!support.supported) {80            try html.raw("<p class=\"verdict warn\">Comparison unsupported vs baseline <b>");81            try html.esc(baseline.run_id);82            try html.raw("</b>: ");83            try html.esc(try tokenLabel(html.allocator, support.state));84            try html.raw(85                ". Runs remain inspectable, but no regression verdict was computed.</p></section>",86            );87            return;88        }89    }90    if (recorded.order_effects) |effects| {91        if (!effects.support.supported) {92            try html.raw("<p class=\"verdict warn\">Fixed-vs-random diagnostic unsupported: ");93            try html.esc(try tokenLabel(html.allocator, effects.support.state));94            try html.raw(".</p>");95        } else if (std.mem.eql(u8, effects.status, "order_sensitive_candidate")) {96            try html.fmt(97                "<p class=\"verdict warn\">{d} order-sensitive workload " ++98                    "candidate(s); product regression verdicts remain suppressed.</p>",99                .{effects.order_sensitive_workloads},100            );101        } else {102            try html.raw("<p class=\"verdict muted\">Fixed-vs-random diagnostic: ");103            try html.esc(try tokenLabel(html.allocator, effects.status));104            try html.raw(". This does not establish independence.</p>");105        }106    }107    if (recorded.priority_items.len == 0 and recorded.findings() == 0) {108        if (recorded.workload_comparison_skips.len == 0) {109            try html.raw("<p class=\"verdict ok\">No regressions above threshold vs baseline <b>");110            try html.esc(baseline.run_id);111            try html.raw("</b>.</p>");112        } else {113            try html.fmt("<p class=\"verdict warn\">No supported regressions above threshold; {d} workload comparison(s) skipped vs baseline <b>", .{recorded.workload_comparison_skips.len});114            try html.esc(baseline.run_id);115            try html.raw("</b>. Details on the <a href=\"runs/");116            try html.esc(latest.dir);117            try html.raw("/index.html\">run page</a>.</p>");118        }119    } else {120        try html.fmt("<p class=\"verdict warn\">{d} priority item(s), {d} finding(s) vs baseline <b>", .{ recorded.priority_items.len, recorded.findings() });121        try html.esc(baseline.run_id);122        try html.raw("</b>. Details on the <a href=\"runs/");123        try html.esc(latest.dir);124        try html.raw("/index.html\">run page</a>.</p>");125        try priorityTable(html, recorded.priority_items, 5);126    }127    try html.raw("</section>");128}129130fn indexTrends(html: *Html, allocator: Allocator, site: model.Site) !void {131    if (site.histories.len == 0 or site.runs.len == 0) return;132    try html.raw("<section><h2>Trends</h2><p class=\"hint\">");133    try html.raw("Mean measured-process wall and peak memory across runs compatible with ");134    try html.raw("the latest build and host context, oldest to newest. Incompatible retained ");135    try html.raw("runs appear as gaps. ");136    try html.raw("Hover points for exact values.</p><div class=\"cards\">");137    for (site.histories) |*history| {138        try trendCard(html, allocator, site, history);139    }140    try html.raw("</div></section>");141}142143fn trendCard(html: *Html, allocator: Allocator, site: model.Site, history: *const model.WorkloadHistory) !void {144    const latest_dir = latestDirWith(site, history.name) orelse return;145    const file = try workloadFile(allocator, history.name);146    try html.raw("<div class=\"card\"><h3><a href=\"runs/");147    try html.esc(latest_dir);148    try html.raw("/workloads/");149    try html.esc(file);150    try html.raw("\">");151    try html.esc(history.name);152    try html.raw("</a></h3><p class=\"card-meta\">");153    try html.esc(history.package);154    if (lastValue(history.wall)) |wall| {155        try html.raw(" · mean wall ");156        try html.esc(try format.ns(allocator, wall));157    }158    if (lastDeltaPercent(history.wall)) |delta| {159        try html.fmt("<span class=\"{s}\"> ({s})</span>", .{ deltaClass(delta), try format.percent(allocator, delta) });160    }161    try html.raw("</p>");162    try html.raw("<div class=\"trend\"><span class=\"trend-label\">mean wall</span>");163    try html.raw(try seriesChart(allocator, site, history.wall, null, null, format.ns, .{ .width = 250, .height = 56 }));164    try html.raw("</div>");165    if (definedCount(history.rss) > 0) {166        try html.raw("<div class=\"trend\"><span class=\"trend-label\">rss</span>");167        try html.raw(try seriesChart(allocator, site, history.rss, null, null, format.kib, .{ .width = 250, .height = 40 }));168        try html.raw("</div>");169    }170    try html.raw("</div>");171}172173fn indexRuns(html: *Html, allocator: Allocator, site: model.Site) !void {174    if (site.runs.len == 0) return;175    try html.raw("<section><h2>Runs</h2><table class=\"data\"><thead><tr>");176    try html.raw("<th data-sort>run</th><th data-sort>started</th><th>git</th><th>suite</th><th data-sort>workloads</th><th data-sort>failed</th><th data-sort>wall</th><th data-sort>metrics</th><th data-sort>analysis</th>");177    try html.raw("</tr></thead><tbody>");178    var display = site.runs.len;179    while (display > 0) {180        display -= 1;181        const entry = &site.runs[display];182        try html.raw("<tr><td><a href=\"runs/");183        try html.esc(entry.dir);184        try html.raw("/index.html\">");185        try html.esc(entry.manifest.run_id);186        try html.raw("</a></td>");187        try html.fmt("<td data-v=\"{d}\">", .{entry.manifest.started_unix_ns});188        try html.esc(try format.timestamp(allocator, entry.manifest.started_unix_ns));189        try html.raw("</td><td><code>");190        try html.esc(format.shortSha(entry.manifest.git_sha));191        try html.raw("</code>");192        if (entry.manifest.git_dirty orelse false) try html.raw(" <span class=\"badge badge-dirty\">dirty</span>");193        try html.raw("</td><td>");194        try html.esc(entry.manifest.suite);195        try html.fmt("</td><td class=\"num\" data-v=\"{d}\">{d}</td>", .{ entry.run.ran(), entry.run.ran() });196        const failed = entry.run.failed();197        if (failed == 0) {198            try html.fmt("<td class=\"num\" data-v=\"0\">0</td>", .{});199        } else {200            try html.fmt("<td class=\"num fail\" data-v=\"{d}\">{d}</td>", .{ failed, failed });201        }202        const wall: f64 = @floatFromInt(entry.manifest.wall_ns orelse 0);203        try html.fmt("<td class=\"num\" data-v=\"{d:.0}\">", .{wall});204        try html.esc(try format.ns(allocator, wall));205        try html.fmt("</td><td class=\"num\" data-v=\"{d}\">{d}</td>", .{ entry.run.metricCount(), entry.run.metricCount() });206        if (entry.recorded) |recorded| {207            if (recorded.baseline != null) {208                try html.fmt("<td data-v=\"{d}\">recorded</td>", .{recorded.priority_items.len});209            } else {210                try html.raw("<td data-v=\"0\" class=\"muted\">first cycle</td>");211            }212        } else {213            try html.raw("<td data-v=\"-1\" class=\"muted\">none</td>");214        }215        try html.raw("</tr>");216    }217    try html.raw("</tbody></table></section>");218}219220pub fn run(allocator: Allocator, entry: *const model.Entry, has_memory: bool) ![]u8 {221    var html = Html{ .allocator = allocator };222    try html.raw("<nav class=\"crumbs\"><a href=\"../../index.html\">tiny profiling</a> / <span>");223    try html.esc(entry.manifest.run_id);224    try html.raw("</span></nav><h1>");225    try html.esc(entry.manifest.run_id);226    try html.raw("</h1>");227    try runMeta(&html, allocator, entry);228    if (has_memory) {229        try html.raw("<p class=\"hint\"><a href=\"memory.html\">Memory accountability</a>: allocation traces reconciled against peak RSS.</p>");230    }231    try runWorkloads(&html, allocator, entry);232    try runAnalysis(&html, allocator, entry);233    return try html.take();234}235236pub const memory_file = "memory.html";237238pub fn memoryPage(allocator: Allocator, entry: *const model.Entry, report: profiling.report.memory.Report) ![]u8 {239    var html = Html{ .allocator = allocator };240    try html.raw("<nav class=\"crumbs\"><a href=\"../../index.html\">tiny profiling</a> / <a href=\"index.html\">");241    try html.esc(entry.manifest.run_id);242    try html.raw("</a> / <span>memory</span></nav><h1>");243    try html.esc(entry.manifest.run_id);244    try html.raw(" memory accountability</h1>");245    try html.raw("<p class=\"hint\">Retained bytes from complete allocation traces, " ++246        "reconciled against each workload&#39;s peak RSS. Partial traces are shown but " ++247        "excluded from coverage. Unclassified is RSS the traces cannot explain: binaries, " ++248        "stacks, page-cache, and untraced allocators.</p>");249    try memoryMeta(&html, allocator, report.totals);250    try memoryWorkloadTable(&html, allocator, report.workloads);251    for (report.workloads) |row| try memoryScopeSection(&html, allocator, row);252    return try html.take();253}254255fn memoryMeta(256    html: *Html,257    allocator: Allocator,258    totals: profiling.report.memory.Totals,259) !void {260    try html.raw("<dl class=\"meta\">");261    try metaItem(html, "workloads", try std.fmt.allocPrint(allocator, "{d}", .{totals.workloads}));262    try metaItem(263        html,264        "traced",265        try std.fmt.allocPrint(allocator, "{d}", .{totals.traced_workloads}),266    );267    try metaItem(268        html,269        "complete",270        try std.fmt.allocPrint(allocator, "{d}", .{totals.complete_traces}),271    );272    try metaItem(273        html,274        "partial",275        try std.fmt.allocPrint(allocator, "{d}", .{totals.partial_traces}),276    );277    try metaItem(html, "rss sum", try format.bytes(allocator, @floatFromInt(totals.rss_bytes_sum)));278    try metaItem(279        html,280        "attributed retained",281        try format.bytes(allocator, @floatFromInt(totals.attributed_retained_bytes_sum)),282    );283    try metaItem(284        html,285        "unclassified",286        try format.bytes(allocator, @floatFromInt(totals.unclassified_bytes_sum)),287    );288    try html.raw("</dl>");289}290291fn memoryWorkloadTable(292    html: *Html,293    allocator: Allocator,294    workloads: []const profiling.report.memory.Workload,295) !void {296    try html.raw("<section><h2>Workloads</h2><table class=\"data\"><thead><tr>" ++297        "<th data-sort>workload</th><th data-sort>state</th><th data-sort>integrity</th>" ++298        "<th data-sort>max rss</th><th data-sort>retained</th>" ++299        "<th data-sort>unclassified</th><th data-sort>coverage</th></tr></thead><tbody>");300    var max_unclassified: f64 = 1;301    for (workloads) |row| {302        if (row.accounting.unclassified_bytes) |bytes| max_unclassified = @max(max_unclassified, @as(f64, @floatFromInt(bytes)));303    }304    for (workloads) |row| try memoryWorkloadRow(html, allocator, row, max_unclassified);305    try html.raw("</tbody></table></section>");306}307308fn memoryWorkloadRow(309    html: *Html,310    allocator: Allocator,311    row: profiling.report.memory.Workload,312    max_unclassified: f64,313) !void {314    const file = try workloadFile(allocator, row.name);315    try html.raw("<tr><td><a href=\"workloads/");316    try html.esc(file);317    try html.raw("\">");318    try html.esc(row.name);319    try html.raw("</a></td><td>");320    try html.esc(row.accounting.state);321    try html.raw("</td><td>");322    if (row.trace) |trace| {323        try html.esc(trace.integrity.status);324    } else {325        try html.raw("<span class=\"muted\">&#8212;</span>");326    }327    try html.raw("</td>");328    try optionalBytesCell(html, allocator, row.accounting.rss_bytes);329    try optionalBytesCell(html, allocator, row.accounting.attributed_retained_bytes);330    if (row.accounting.unclassified_bytes) |bytes| {331        try barCell(332            html,333            @floatFromInt(bytes),334            max_unclassified,335            try format.bytes(allocator, @floatFromInt(bytes)),336        );337    } else {338        try html.raw("<td class=\"num muted\" data-v=\"-1\">&#8212;</td>");339    }340    if (row.accounting.coverage_percent) |coverage| {341        try html.fmt(342            "<td class=\"num\" data-v=\"{d:.2}\">{d:.1}%</td>",343            .{ coverage, coverage },344        );345    } else {346        try html.raw("<td class=\"num muted\" data-v=\"-1\">&#8212;</td>");347    }348    try html.raw("</tr>");349}350351fn memoryScopeSection(352    html: *Html,353    allocator: Allocator,354    row: profiling.report.memory.Workload,355) !void {356    const trace = row.trace orelse return;357    try html.raw("<section><h3>");358    try html.esc(row.name);359    try html.raw(" scopes</h3><p class=\"hint\">");360    try html.esc(try format.count(allocator, @floatFromInt(trace.summary.events)));361    try html.raw(" trace events &#183; ");362    try html.esc(try format.count(allocator, @floatFromInt(trace.summary.allocations)));363    try html.raw(" allocations &#183; high water ");364    try html.esc(try format.bytes(allocator, @floatFromInt(trace.summary.high_water_live_bytes)));365    try html.raw(" live &#183; integrity ");366    try html.esc(trace.integrity.status);367    try html.raw("</p>");368    if (trace.integrity.message) |message| {369        try html.raw("<p class=\"hint\">Capture caveat: ");370        try html.esc(message);371        try html.raw(" Action: ");372        try html.esc(trace.integrity.action);373        try html.raw(".</p>");374    }375    if (trace.scopes.len == 0) {376        try html.raw("<p class=\"muted\">No scopes above the byte floor.</p></section>");377        return;378    }379    try html.raw("<table class=\"data\"><thead><tr><th>scope</th>" ++380        "<th data-sort>retained</th><th data-sort>live</th>" ++381        "<th data-sort>high water live</th><th data-sort>allocated</th>" ++382        "<th data-sort>allocations</th><th data-sort>byte-event area</th>" ++383        "<th data-sort>mean lifetime</th>" ++384        "</tr></thead><tbody>");385    for (trace.scopes) |scope| try memoryScopeRow(html, allocator, scope);386    try html.raw("</tbody></table></section>");387}388389fn memoryScopeRow(390    html: *Html,391    allocator: Allocator,392    scope: profiling.report.memory.Scope,393) !void {394    try html.raw("<tr><td class=\"label\"><code>");395    try html.esc(scope.scope);396    try html.raw("</code></td>");397    try bytesCell(html, allocator, scope.retained_bytes);398    try bytesCell(html, allocator, scope.live_bytes);399    try bytesCell(html, allocator, scope.high_water_live_bytes);400    try bytesCell(html, allocator, scope.allocated_bytes);401    try html.fmt(402        "<td class=\"num\" data-v=\"{d}\">{d}</td>",403        .{ scope.allocations, scope.allocations },404    );405    try html.fmt(406        "<td class=\"num\" data-v=\"{d}\">",407        .{scope.lifetime_total_byte_events},408    );409    try html.esc(try format.count(410        allocator,411        @floatFromInt(scope.lifetime_total_byte_events),412    ));413    try html.raw(" byte-events</td>");414    try html.fmt(415        "<td class=\"num\" data-v=\"{d}\">{d} events</td>",416        .{ scope.lifetime_mean_events, scope.lifetime_mean_events },417    );418    try html.raw("</tr>");419}420421fn bytesCell(html: *Html, allocator: Allocator, bytes: u64) !void {422    const value: f64 = @floatFromInt(bytes);423    try html.fmt("<td class=\"num\" data-v=\"{d:.0}\">", .{value});424    try html.esc(try format.bytes(allocator, value));425    try html.raw("</td>");426}427428fn optionalBytesCell(html: *Html, allocator: Allocator, bytes: ?u64) !void {429    const actual = bytes orelse {430        try html.raw("<td class=\"num muted\" data-v=\"-1\">&#8212;</td>");431        return;432    };433    try bytesCell(html, allocator, actual);434}435436fn runMeta(html: *Html, allocator: Allocator, entry: *const model.Entry) !void {437    try html.raw("<dl class=\"meta\">");438    try metaItem(html, "started", try format.timestamp(allocator, entry.manifest.started_unix_ns));439    if (entry.manifest.wall_ns) |wall| try metaItem(html, "wall", try format.ns(allocator, @floatFromInt(wall)));440    try metaItem(html, "suite", entry.manifest.suite);441    var git: std.ArrayList(u8) = .empty;442    try git.appendSlice(allocator, format.shortSha(entry.manifest.git_sha));443    if (entry.manifest.git_branch) |branch| {444        try git.appendSlice(allocator, " on ");445        try git.appendSlice(allocator, branch);446    }447    if (entry.manifest.git_dirty orelse false) try git.appendSlice(allocator, " (dirty)");448    try metaItem(html, "git", git.items);449    if (entry.manifest.zig_version) |version| try metaItem(html, "zig", version);450    if (entry.manifest.optimize) |optimize| try metaItem(html, "optimize", optimize);451    var host_text: std.ArrayList(u8) = .empty;452    if (entry.manifest.host.hostname) |hostname| {453        try host_text.appendSlice(allocator, hostname);454        try host_text.appendSlice(allocator, ", ");455    }456    try host_text.appendSlice(allocator, entry.manifest.host.os orelse "unknown");457    if (entry.manifest.host.kernel) |kernel| {458        try host_text.appendSlice(allocator, " ");459        try host_text.appendSlice(allocator, kernel);460    }461    try host_text.appendSlice(allocator, ", ");462    try host_text.appendSlice(allocator, entry.manifest.host.arch orelse "unknown");463    try metaItem(html, "host", host_text.items);464    var cpu_text: std.ArrayList(u8) = .empty;465    try cpu_text.appendSlice(allocator, entry.manifest.host.cpu_model orelse "unknown");466    if (entry.manifest.host.cpu_count) |cpus| {467        const logical = try std.fmt.allocPrint(allocator, ", {d} logical", .{cpus});468        try cpu_text.appendSlice(allocator, logical);469    }470    try metaItem(html, "cpu", cpu_text.items);471    if (entry.manifest.host.cpu_frequency_policy) |policy| {472        try metaItem(html, "frequency policy", policy);473    }474    var placement_text: std.ArrayList(u8) = .empty;475    if (entry.manifest.host.process_cpu_affinity) |affinity| {476        try placement_text.appendSlice(allocator, "CPUs ");477        try placement_text.appendSlice(allocator, affinity);478    }479    if (entry.manifest.host.process_memory_affinity) |affinity| {480        if (placement_text.items.len != 0) try placement_text.appendSlice(allocator, ", ");481        try placement_text.appendSlice(allocator, "memory nodes ");482        try placement_text.appendSlice(allocator, affinity);483    }484    if (placement_text.items.len != 0) {485        try metaItem(html, "process placement", placement_text.items);486    }487    const passed_text = try std.fmt.allocPrint(allocator, "{d}/{d}", .{ entry.run.passed(), entry.run.ran() });488    try metaItem(html, "passed", passed_text);489    try html.raw("</dl>");490}491492fn metaItem(html: *Html, key: []const u8, value: []const u8) !void {493    try html.raw("<div><dt>");494    try html.esc(key);495    try html.raw("</dt><dd>");496    try html.esc(value);497    try html.raw("</dd></div>");498}499500fn runWorkloads(html: *Html, allocator: Allocator, entry: *const model.Entry) !void {501    try html.raw("<section><h2>Workloads</h2>");502    if (entry.run.workloads.len == 0) {503        try html.raw("<p class=\"muted\">No workload rows recorded.</p></section>");504        return;505    }506    var max_wall: f64 = 1;507    var max_rss: f64 = 1;508    for (entry.run.workloads) |workload_row| {509        max_wall = @max(max_wall, @as(f64, @floatFromInt(workload_row.wall_ns)));510        if (workload_row.max_rss_kib) |rss| max_rss = @max(max_rss, @as(f64, @floatFromInt(rss)));511    }512    try html.raw("<table class=\"data\"><thead><tr><th data-sort>workload</th><th data-sort>package</th><th data-sort>state</th><th data-sort>acquisition</th><th data-sort>mean wall</th><th data-sort>max rss</th><th data-sort>mean cpu</th><th data-sort>warmups</th><th data-sort>executions</th><th data-sort>wall samples</th><th data-sort>timing</th><th data-sort>memory</th><th data-sort>causal</th><th>captures</th></tr></thead><tbody>");513    for (entry.run.workloads) |*workload_row| {514        const file = try workloadFile(allocator, workload_row.name);515        try html.raw("<tr><td><a href=\"workloads/");516        try html.esc(file);517        try html.raw("\">");518        try html.esc(workload_row.name);519        try html.raw("</a></td><td>");520        try html.esc(workload_row.package);521        try html.raw("</td><td>");522        try stateBadge(html, workload_row.status, workload_row.exit_code);523        const acquisition_sort = switch (workload_row.acquisition) {524            .blocked => |blocked| blocked.position,525            .random_interleaved => |interleaved| interleaved.positions[0],526        };527        try html.fmt(528            "</td><td data-v=\"{d}\"><code>",529            .{acquisition_sort},530        );531        try html.esc(try acquisitionLabel(allocator, workload_row.acquisition));532        try html.raw("</code></td>");533        if (workload_row.execution_count == 0) {534            try html.raw("<td class=\"num muted\" data-v=\"-1\">—</td>");535        } else {536            const wall: f64 = @floatFromInt(workload_row.wall_ns);537            try barCell(html, wall, max_wall, try format.ns(allocator, wall));538        }539        if (workload_row.max_rss_kib) |rss| {540            const rss_value: f64 = @floatFromInt(rss);541            try barCell(html, rss_value, max_rss, try format.kib(allocator, rss_value));542        } else {543            try html.raw("<td class=\"num muted\" data-v=\"-1\">—</td>");544        }545        if (workload_row.user_s != null or workload_row.system_s != null) {546            const cpu = (workload_row.user_s orelse 0) + (workload_row.system_s orelse 0);547            try html.fmt("<td class=\"num\" data-v=\"{d:.3}\">", .{cpu});548            try html.esc(try format.seconds(allocator, cpu));549        } else {550            try html.raw("<td class=\"num muted\" data-v=\"-1\">—");551        }552        try html.fmt("</td><td class=\"num\" data-v=\"{d}\">{d}</td>", .{ workload_row.warmup_count, workload_row.warmup_count });553        try html.fmt("<td class=\"num\" data-v=\"{d}\">{d}</td>", .{ workload_row.execution_count, workload_row.execution_count });554        if (workload_row.execution_count == 0) {555            try html.raw("<td class=\"num muted\" data-v=\"0\">—</td>");556        } else {557            const wall_distribution = workloadWallDistribution(workload_row);558            try html.fmt(559                "<td class=\"num\" data-v=\"{d}\">{d}<br><span class=\"muted\">",560                .{ wall_distribution.sample_count, wall_distribution.sample_count },561            );562            try html.esc(try tokenLabel(allocator, wall_distribution.kind.name()));563            try html.raw("</span></td>");564        }565        try html.fmt("<td class=\"num\" data-v=\"{d}\">{d}</td>", .{ workload_row.metrics.len, workload_row.metrics.len });566        try html.fmt("<td class=\"num\" data-v=\"{d}\">{d}</td>", .{ workload_row.memory_metrics.len, workload_row.memory_metrics.len });567        try html.fmt("<td class=\"num\" data-v=\"{d}\">{d}</td>", .{ workload_row.causal.len, workload_row.causal.len });568        try html.raw("<td>");569        if (workload_row.captures.len == 0) {570            try html.raw("<span class=\"muted\">—</span>");571        } else {572            for (workload_row.captures, 0..) |capture, capture_index| {573                if (capture_index != 0) try html.raw(", ");574                try html.esc(capture.kind);575                try html.raw(" (");576                try html.esc(capture.state);577                try html.raw(")");578            }579        }580        try html.raw("</td></tr>");581    }582    try html.raw("</tbody></table></section>");583}584585fn runAnalysis(html: *Html, allocator: Allocator, entry: *const model.Entry) !void {586    const recorded = entry.recorded orelse return;587    try html.raw("<section><h2>Recorded analysis</h2>");588    const baseline = recorded.baseline orelse {589        try html.raw("<p class=\"verdict muted\">First cycle: this run recorded the baseline, so there is no comparison yet.</p></section>");590        return;591    };592    if (recorded.comparison_support) |support| {593        if (!support.supported) {594            try html.raw("<p class=\"verdict warn\">Comparison unsupported against baseline <b>");595            try html.esc(baseline.run_id);596            try html.raw("</b>: ");597            try html.esc(try tokenLabel(allocator, support.state));598            try html.raw(599                ". Evidence remains available for inspection, but regressions and " ++600                    "differential views are suppressed.</p></section>",601            );602            return;603        }604    }605    try html.raw("<p>Compared against baseline <b>");606    try html.esc(baseline.run_id);607    try html.raw("</b>.</p>");608    if (recorded.order_effects) |effects| {609        try orderEffectsTable(html, allocator, effects);610    }611    if (recorded.priority_items.len == 0 and recorded.findings() == 0 and612        recorded.energy_shifts.len == 0 and recorded.counter_shifts.len == 0 and613        recorded.workload_comparison_skips.len == 0)614    {615        try html.raw("<p class=\"verdict ok\">No regressions above threshold.</p></section>");616        return;617    }618    if (recorded.priority_items.len != 0) {619        try html.raw("<h3>Priority</h3>");620        try priorityTable(html, recorded.priority_items, recorded.priority_items.len);621    }622    if (recorded.priority_components.len != 0) {623        try html.raw("<h3>Components</h3><table class=\"data\"><thead><tr><th>component</th><th data-sort>workloads</th><th data-sort>issues</th><th>strongest</th><th data-sort>total score</th><th>reason</th></tr></thead><tbody>");624        for (recorded.priority_components) |component| {625            try html.raw("<tr><td>");626            try html.esc(component.component);627            try html.fmt("</td><td class=\"num\">{d}</td><td class=\"num\">{d}</td><td>", .{ component.workloads, component.issues });628            try html.esc(component.strongest_label);629            try html.fmt("</td><td class=\"num\" data-v=\"{d:.2}\">{d:.2}</td><td>", .{ component.total_score, component.total_score });630            try html.esc(component.reason);631            try html.raw("</td></tr>");632        }633        try html.raw("</tbody></table>");634    }635    if (recorded.workload_comparison_skips.len != 0) {636        try html.raw("<h3>Skipped workload comparisons</h3><p class=\"hint\">Outer mean wall and peak RSS were not compared across incompatible measurement or acquisition designs. Structured metrics and profiler evidence keep their own support rules.</p><table class=\"data\"><thead><tr><th>workload</th><th>reason</th><th>baseline acquisition</th><th>candidate acquisition</th><th data-sort>baseline executions</th><th data-sort>candidate executions</th><th data-sort>baseline warmups</th><th data-sort>candidate warmups</th></tr></thead><tbody>");637        for (recorded.workload_comparison_skips) |row| {638            try html.raw("<tr><td>");639            try html.esc(row.workload);640            try html.raw("</td><td>");641            try html.esc(row.reason);642            try html.raw("</td><td><code>");643            try html.esc(try acquisitionLabel(allocator, row.baseline_acquisition));644            try html.raw("</code></td><td><code>");645            try html.esc(try acquisitionLabel(allocator, row.candidate_acquisition));646            try html.fmt("</code></td><td class=\"num\" data-v=\"{d}\">{d}</td><td class=\"num\" data-v=\"{d}\">{d}</td><td class=\"num\" data-v=\"{d}\">{d}</td><td class=\"num\" data-v=\"{d}\">{d}</td></tr>", .{647                row.baseline_execution_count,648                row.baseline_execution_count,649                row.candidate_execution_count,650                row.candidate_execution_count,651                row.baseline_warmup_count,652                row.baseline_warmup_count,653                row.candidate_warmup_count,654                row.candidate_warmup_count,655            });656        }657        try html.raw("</tbody></table>");658    }659    if (recorded.regressions.len != 0) {660        try html.raw("<h3>Mean wall and peak RSS regressions</h3><p class=\"hint\">Wall status uses the independent repetition level. Supported sample regressions have a 95% bootstrap effect interval above threshold; uncertain, summary, and point candidates remain lower-confidence evidence.</p><table class=\"data\"><thead><tr><th>workload</th><th>kind</th><th>status</th><th data-sort>baseline</th><th data-sort>candidate</th><th data-sort>change</th><th>wall samples</th><th>95% wall effect</th></tr></thead><tbody>");661        for (recorded.regressions) |row| {662            try html.raw("<tr><td>");663            try html.esc(row.workload);664            try html.raw("</td><td>");665            try html.esc(row.kind);666            try html.raw("</td><td>");667            if (std.mem.indexOf(u8, row.kind, "wall") != null) {668                try html.esc(try tokenLabel(allocator, row.wall_status));669            } else {670                try html.raw("<span class=\"muted\">—</span>");671            }672            try html.raw("</td><td class=\"num\">");673            try html.esc(try format.ns(allocator, row.baseline_wall_ns orelse 0));674            try html.raw("</td><td class=\"num\">");675            try html.esc(try format.ns(allocator, row.candidate_wall_ns orelse 0));676            try html.raw("</td>");677            try percentCell(html, allocator, row.wall_percent_change);678            try html.raw("<td class=\"num\">");679            if (row.baseline_wall_samples != 0 and row.candidate_wall_samples != 0) {680                try html.fmt("{d} ", .{row.baseline_wall_samples});681                try html.esc(try tokenLabel(allocator, row.baseline_wall_distribution));682                try html.fmt("<br>→ {d} ", .{row.candidate_wall_samples});683                try html.esc(try tokenLabel(allocator, row.candidate_wall_distribution));684            } else {685                try html.raw("<span class=\"muted\">—</span>");686            }687            try html.raw("</td><td class=\"num\">");688            if (row.wall_effect_low_percent != null and row.wall_effect_high_percent != null) {689                try html.esc(try format.percent(allocator, row.wall_effect_low_percent.?));690                try html.raw(" .. ");691                try html.esc(try format.percent(allocator, row.wall_effect_high_percent.?));692            } else {693                try html.raw("<span class=\"muted\">—</span>");694            }695            try html.raw("</td></tr>");696        }697        try html.raw("</tbody></table>");698    }699    if (recorded.metric_regressions.len != 0) {700        try html.raw("<h3>Timing metric regressions</h3><table class=\"data\"><thead><tr><th>metric</th><th>status</th><th data-sort>baseline</th><th data-sort>candidate</th><th data-sort>change</th><th>effect</th></tr></thead><tbody>");701        for (recorded.metric_regressions) |row| {702            try html.raw("<tr><td>");703            try html.esc(row.label);704            try html.raw("</td><td>");705            try html.esc(row.status);706            try html.raw("</td><td class=\"num\">");707            try html.esc(try format.ns(allocator, row.baseline_ns));708            try html.raw("</td><td class=\"num\">");709            try html.esc(try format.ns(allocator, row.candidate_ns));710            try html.raw("</td>");711            try percentCell(html, allocator, row.percent_change);712            try html.raw("<td class=\"num\">");713            if (row.effect_low_percent != null and row.effect_high_percent != null) {714                try html.esc(try format.percent(allocator, row.effect_low_percent.?));715                try html.raw(" .. ");716                try html.esc(try format.percent(allocator, row.effect_high_percent.?));717            } else {718                try html.raw("<span class=\"muted\">—</span>");719            }720            try html.raw("</td></tr>");721        }722        try html.raw("</tbody></table>");723    }724    if (recorded.memory_regressions.len != 0) {725        try html.raw(726            "<h3>Memory regressions</h3><table class=\"data\"><thead><tr>" ++727                "<th>metric</th><th>status</th><th data-sort>baseline</th>" ++728                "<th data-sort>candidate</th><th data-sort>change</th>" ++729                "<th>evidence</th><th>95% effect</th></tr></thead><tbody>",730        );731        for (recorded.memory_regressions) |row| {732            try html.raw("<tr><td>");733            try html.esc(row.label);734            try html.raw("</td><td>");735            try html.esc(try tokenLabel(allocator, row.status));736            try html.raw("</td><td class=\"num\">");737            try html.esc(try formatMemory(allocator, row.baseline_value, row.unit));738            try html.raw("</td><td class=\"num\">");739            try html.esc(try formatMemory(allocator, row.candidate_value, row.unit));740            try html.raw("</td>");741            try percentCell(html, allocator, row.percent_change);742            try html.raw("<td><code>");743            try html.esc(try tokenLabel(allocator, row.baseline_distribution));744            try html.raw(" &#8594; ");745            try html.esc(try tokenLabel(allocator, row.candidate_distribution));746            try html.fmt(747                "</code><br><span class=\"muted\">{d} / {d} samples</span></td>",748                .{ row.baseline_samples, row.candidate_samples },749            );750            try html.raw("<td class=\"num\">");751            if (row.effect_low_percent != null and752                row.effect_high_percent != null)753            {754                try html.esc(try format.percent(allocator, row.effect_low_percent.?));755                try html.raw(" .. ");756                try html.esc(try format.percent(allocator, row.effect_high_percent.?));757            } else {758                try html.raw("<span class=\"muted\">&#8212;</span>");759            }760            try html.raw("</td></tr>");761        }762        try html.raw("</tbody></table>");763    }764    try energyShiftsTable(html, allocator, recorded.energy_shifts);765    if (recorded.counter_shifts.len != 0) {766        try html.raw("<h3>Counter shifts</h3><p class=\"hint\">Attribution evidence, never priority input.</p><table class=\"data\"><thead><tr><th>workload</th><th>event</th><th data-sort>baseline</th><th data-sort>candidate</th><th data-sort>change</th><th>status</th></tr></thead><tbody>");767        for (recorded.counter_shifts) |row| {768            try html.raw("<tr><td>");769            try html.esc(row.workload);770            try html.raw("</td><td><code>");771            try html.esc(row.event);772            try html.raw("</code></td><td class=\"num\">");773            try html.esc(try format.count(allocator, row.baseline_value));774            try html.raw("</td><td class=\"num\">");775            try html.esc(try format.count(allocator, row.candidate_value));776            try html.raw("</td>");777            try percentCell(html, allocator, row.percent_change);778            try html.raw("<td>");779            try html.esc(row.status);780            try html.raw("</td></tr>");781        }782        try html.raw("</tbody></table>");783    }784    try html.raw("</section>");785}786787fn energyShiftsTable(788    html: *Html,789    allocator: Allocator,790    rows: []const analysis.EnergyShift,791) !void {792    if (rows.len == 0) return;793    try html.raw(794        "<h3>Energy shifts</h3><p class=\"hint\">Repeated system hardware-domain " ++795            "evidence, never process attribution or priority input. Caveated rows include " ++796            "incomplete or unstable repetition evidence.</p><table class=\"data\"><thead><tr>" ++797            "<th>workload</th><th>domain</th><th data-sort>baseline energy</th>" ++798            "<th data-sort>candidate energy</th><th data-sort>energy change</th>" ++799            "<th data-sort>baseline power</th><th data-sort>candidate power</th>" ++800            "<th data-sort>power change</th><th>energy range</th><th>power range</th>" ++801            "<th>status</th></tr></thead><tbody>",802    );803    for (rows) |row| {804        try html.raw("<tr><td>");805        try html.esc(row.workload);806        try html.raw("</td><td><code>");807        try html.esc(row.event);808        try html.raw("</code></td>");809        try energyValueCell(html, row.baseline_joules, "J");810        try energyValueCell(html, row.candidate_joules, "J");811        try percentCell(html, allocator, row.energy_percent_change);812        try optionalEnergyValueCell(html, row.baseline_watts, "W");813        try optionalEnergyValueCell(html, row.candidate_watts, "W");814        try optionalPercentCell(html, allocator, row.power_percent_change);815        try rangePairCell(816            html,817            allocator,818            row.baseline_energy_range_percent,819            row.candidate_energy_range_percent,820        );821        try rangePairCell(822            html,823            allocator,824            row.baseline_power_range_percent,825            row.candidate_power_range_percent,826        );827        try html.raw("<td>");828        try html.esc(try tokenLabel(allocator, row.status));829        try html.raw("</td></tr>");830    }831    try html.raw("</tbody></table>");832}833834fn energyValueCell(html: *Html, value: f64, unit: []const u8) !void {835    try html.fmt("<td class=\"num\" data-v=\"{d}\">{d:.3} {s}</td>", .{ value, value, unit });836}837838fn optionalEnergyValueCell(html: *Html, value: ?f64, unit: []const u8) !void {839    const actual = value orelse {840        try html.raw("<td class=\"num muted\">—</td>");841        return;842    };843    try energyValueCell(html, actual, unit);844}845846fn optionalPercentCell(html: *Html, allocator: Allocator, value: ?f64) !void {847    const actual = value orelse {848        try html.raw("<td class=\"num muted\">—</td>");849        return;850    };851    try percentCell(html, allocator, actual);852}853854fn rangePairCell(855    html: *Html,856    allocator: Allocator,857    baseline: ?f64,858    candidate: ?f64,859) !void {860    try html.raw("<td class=\"num\">");861    if (baseline) |value| {862        try html.esc(try format.percent(allocator, value));863    } else {864        try html.raw("<span class=\"muted\">—</span>");865    }866    try html.raw(" → ");867    if (candidate) |value| {868        try html.esc(try format.percent(allocator, value));869    } else {870        try html.raw("<span class=\"muted\">—</span>");871    }872    try html.raw("</td>");873}874875fn orderEffectsTable(876    html: *Html,877    allocator: Allocator,878    effects: analysis.OrderEffects,879) !void {880    try html.raw("<h3>Fixed vs random acquisition diagnostic</h3><p>");881    try html.esc(effects.fixed_run_id);882    try html.raw(" fixed vs ");883    try html.esc(effects.random_run_id);884    try html.raw(": <b>");885    try html.esc(try tokenLabel(allocator, effects.status));886    try html.raw("</b>.</p>");887    if (!effects.support.supported) {888        try html.raw("<p class=\"verdict warn\">Unsupported: ");889        try html.esc(try tokenLabel(allocator, effects.support.state));890        try html.raw(".</p>");891    } else {892        try html.raw(893            "<table class=\"data\"><thead><tr><th>workload</th>" ++894                "<th>classification</th><th>fixed acquisition</th>" ++895                "<th>random acquisition</th><th data-sort>fixed mean</th>" ++896                "<th data-sort>random mean</th><th data-sort>change</th>" ++897                "<th>95% effect</th><th>samples</th></tr></thead><tbody>",898        );899        for (effects.rows) |row| {900            try html.raw("<tr><td>");901            try html.esc(row.workload);902            try html.raw("</td><td>");903            try html.esc(try tokenLabel(allocator, row.classification));904            try html.raw("</td><td><code>");905            try html.esc(try acquisitionLabel(allocator, row.fixed_acquisition));906            try html.raw("</code></td><td><code>");907            try html.esc(try acquisitionLabel(allocator, row.random_acquisition));908            try html.raw("</code></td><td class=\"num\">");909            if (row.fixed_mean_ns) |mean| {910                try html.esc(try format.ns(allocator, mean));911            } else {912                try html.raw("<span class=\"muted\">—</span>");913            }914            try html.raw("</td><td class=\"num\">");915            if (row.random_mean_ns) |mean| {916                try html.esc(try format.ns(allocator, mean));917            } else {918                try html.raw("<span class=\"muted\">—</span>");919            }920            try html.raw("</td>");921            try percentCell(html, allocator, row.mean_percent_change);922            try html.raw("<td class=\"num\">");923            if (row.effect_low_percent != null and row.effect_high_percent != null) {924                try html.esc(try format.percent(allocator, row.effect_low_percent.?));925                try html.raw(" .. ");926                try html.esc(try format.percent(allocator, row.effect_high_percent.?));927            } else {928                try html.raw("<span class=\"muted\">—</span>");929            }930            try html.fmt(931                "</td><td class=\"num\">{d} fixed / {d} random</td></tr>",932                .{ row.fixed_count, row.random_count },933            );934        }935        try html.raw("</tbody></table>");936    }937    try html.raw("<p class=\"hint\">Diagnostic limits: ");938    for (effects.limits, 0..) |limit, limit_index| {939        if (limit_index != 0) try html.raw(" · ");940        try html.esc(limit);941    }942    try html.raw(".</p>");943}944945fn acquisitionLabel(946    allocator: Allocator,947    acquisition: profiling.order.Context,948) ![]const u8 {949    std.debug.assert(acquisition.valid());950    return switch (acquisition) {951        .blocked => |blocked| blocked_label: {952            const predecessors = if (blocked.predecessors.len == 0)953                "none"954            else955                try std.mem.join(allocator, ", ", blocked.predecessors);956            break :blocked_label try std.fmt.allocPrint(957                allocator,958                "blocked {d}/{d} after [{s}]",959                .{ blocked.position, blocked.workload_count, predecessors },960            );961        },962        .random_interleaved => |interleaved| try std.fmt.allocPrint(963            allocator,964            "interleaved {d}x/{d}, positions [{s}]",965            .{966                interleaved.repeat_count,967                interleaved.workload_count,968                try positionsLabel(allocator, interleaved.positions),969            },970        ),971    };972}973974fn positionsLabel(allocator: Allocator, positions: []const usize) ![]const u8 {975    const labels = try allocator.alloc([]const u8, positions.len);976    for (positions, 0..) |position, position_index| {977        labels[position_index] = try std.fmt.allocPrint(allocator, "{d}", .{position});978    }979    return try std.mem.join(allocator, ", ", labels);980}981982fn priorityTable(html: *Html, items: []const analysis.PriorityItem, limit: usize) !void {983    try html.raw("<table class=\"data\"><thead><tr><th data-sort>rank</th><th data-sort>score</th><th>kind</th><th>workload</th><th>finding</th><th data-sort>change</th><th>evidence</th><th>reason</th></tr></thead><tbody>");984    for (items[0..@min(limit, items.len)]) |item| {985        try html.fmt("<tr><td class=\"num\">{d}</td><td class=\"num\" data-v=\"{d:.2}\">{d:.2}</td><td>", .{ item.rank, item.score, item.score });986        try html.esc(item.kind);987        try html.raw("</td><td>");988        try html.esc(item.workload);989        try html.raw("</td><td>");990        try html.esc(item.label);991        try html.raw("</td>");992        try percentCell(html, html.allocator, item.percent_change);993        try html.raw("<td>");994        try html.esc(item.evidence);995        if (item.confidence.len != 0) {996            try html.raw(" / ");997            try html.esc(item.confidence);998        }999        try html.raw("</td><td>");1000        try html.esc(item.reason);1001        try html.raw("</td></tr>");1002    }1003    try html.raw("</tbody></table>");1004}10051006pub fn workload(1007    allocator: Allocator,1008    site: model.Site,1009    entry: *const model.Entry,1010    row: *const analyze.Workload,1011    flame_sources: flame.Sources,1012) ![]u8 {1013    var html = Html{ .allocator = allocator };1014    try html.raw("<nav class=\"crumbs\"><a href=\"../../../index.html\">tiny profiling</a> / <a href=\"../index.html\">");1015    try html.esc(entry.manifest.run_id);1016    try html.raw("</a> / <span>");1017    try html.esc(row.name);1018    try html.raw("</span></nav><h1>");1019    try html.esc(row.name);1020    try html.raw(" ");1021    try stateBadge(&html, row.status, row.exit_code);1022    try html.raw("</h1>");10231024    try html.raw("<dl class=\"meta\">");1025    try metaItem(&html, "package", row.package);1026    try metaItem(&html, "step", row.step);1027    try workloadAcquisitionMetadata(&html, allocator, row.acquisition);1028    try metaItem(1029        &html,1030        "mean wall",1031        if (row.execution_count == 0)1032            "not measured"1033        else1034            try format.ns(allocator, @floatFromInt(row.wall_ns)),1035    );1036    try metaItem(&html, "measurement executions", try std.fmt.allocPrint(allocator, "{d}", .{row.execution_count}));1037    if (row.execution_count != 0) try workloadWallMetadata(&html, allocator, row);1038    try workloadWarmupMetadata(&html, allocator, row);1039    if (row.execution_count > 1) {1040        try metaItem(&html, "acquisition wall", try format.ns(allocator, @floatFromInt(row.total_wall_ns)));1041        try metaItem(1042            &html,1043            "workload outputs",1044            if (retainsAllExecutionArtifacts(row))1045                "all measured executions"1046            else1047                "profiler capture contract",1048        );1049    }1050    try workloadStructuredAnalysisMetadata(&html, row);1051    if (row.max_rss_kib) |rss| try metaItem(&html, "max rss", try format.kib(allocator, @floatFromInt(rss)));1052    if (row.user_s) |user| try metaItem(&html, "mean user cpu", try format.seconds(allocator, user));1053    if (row.system_s) |system| try metaItem(&html, "mean system cpu", try format.seconds(allocator, system));1054    try workloadResourceMetadata(&html, allocator, row);1055    if (row.capture_perturbation) |measurement| {1056        try metaItem(&html, "capture-control state", try tokenLabel(allocator, @tagName(measurement.state)));1057        try metaItem(&html, "capture-control pairs", try std.fmt.allocPrint(allocator, "{d}", .{measurement.pairs.len}));1058    }1059    try html.raw("</dl>");10601061    try workloadCapturePerturbation(&html, allocator, row);1062    try workloadBenchmarkReduction(&html, allocator, row);1063    try workloadTiming(&html, allocator, site, row);1064    try workloadMemory(&html, allocator, site, row);1065    try workloadCausal(&html, allocator, row);1066    try workloadFlameLinks(&html, allocator, row, flame_sources);1067    try workloadCaptures(&html, row);1068    try workloadExecutionArtifacts(&html, allocator, row);1069    try workloadLogs(&html, allocator, row);1070    return try html.take();1071}10721073fn retainsAllExecutionArtifacts(row: *const analyze.Workload) bool {1074    if (row.executions.len == 0) return false;1075    for (row.executions) |execution| {1076        if (execution.artifacts == null) return false;1077    }1078    return true;1079}10801081fn workloadStructuredAnalysisMetadata(1082    html: *Html,1083    row: *const analyze.Workload,1084) !void {1085    switch (row.benchmark_process_reduction) {1086        .complete => |complete| try metaItem(1087            html,1088            "benchmark process reduction",1089            try std.fmt.allocPrint(1090                html.allocator,1091                "{d} process medians · deterministic 95% bootstrap",1092                .{complete.sources.len},1093            ),1094        ),1095        .not_applicable => |value| {1096            if (row.executions.len < 2) return;1097            try metaItem(1098                html,1099                "benchmark process reduction",1100                try tokenLabel(html.allocator, @tagName(value.reason)),1101            );1102        },1103    }1104}11051106fn workloadBenchmarkReduction(1107    html: *Html,1108    allocator: Allocator,1109    row: *const analyze.Workload,1110) !void {1111    const complete = switch (row.benchmark_process_reduction) {1112        .not_applicable => return,1113        .complete => |value| value,1114    };1115    try html.raw("<section id=\"benchmark-process-reduction\">");1116    try html.raw("<h2>Benchmark process reduction</h2>");1117    try html.raw(1118        "<p class=\"hint\">Each value is one verified lib/bench process median " ++1119            "in measured acquisition order. The center is their median; " ++1120            "uncertainty is a deterministic 95% percentile-bootstrap interval.</p>",1121    );1122    try html.raw("<table class=\"data\"><thead><tr>");1123    try html.raw("<th>benchmark</th><th>process medians (ns)</th>");1124    try html.raw("<th data-sort>median</th><th>95% interval</th>");1125    try html.raw("<th>allocation maxima</th></tr></thead><tbody>");1126    for (complete.benchmarks) |benchmark_value| {1127        try benchmarkReductionRow(html, allocator, benchmark_value);1128    }1129    try html.raw("</tbody></table>");1130    try benchmarkReductionSources(html, complete.sources);1131    try html.raw("</section>");1132}11331134fn benchmarkReductionRow(1135    html: *Html,1136    allocator: Allocator,1137    benchmark_value: profiling.reduction.Benchmark,1138) !void {1139    try html.raw("<tr><td class=\"label\"><code>");1140    try html.esc(benchmark_value.suite);1141    try html.raw(" / ");1142    try html.esc(benchmark_value.id);1143    try html.raw("</code></td><td><code>");1144    for (benchmark_value.sample_ns, 0..) |sample, sample_index| {1145        if (sample_index != 0) try html.raw(" → ");1146        try html.fmt("{d}", .{sample});1147    }1148    try html.raw("</code></td><td class=\"num\" data-v=\"");1149    try html.fmt("{d}\">", .{benchmark_value.statistics.median_ns});1150    try html.esc(try format.ns(1151        allocator,1152        @floatFromInt(benchmark_value.statistics.median_ns),1153    ));1154    try html.raw("</td><td>");1155    try html.esc(try format.ns(1156        allocator,1157        benchmark_value.statistics.median_interval.low_ns,1158    ));1159    try html.raw(" – ");1160    try html.esc(try format.ns(1161        allocator,1162        benchmark_value.statistics.median_interval.high_ns,1163    ));1164    try html.raw("</td><td>");1165    try benchmarkAllocationMaxima(html, benchmark_value.allocation_maxima);1166    try html.raw("</td></tr>");1167}11681169fn benchmarkAllocationMaxima(1170    html: *Html,1171    maxima: profiling.reduction.AllocationMaxima,1172) !void {1173    if (maxima.alloc_count == null) {1174        try html.raw("not tracked");1175        return;1176    }1177    try html.fmt(1178        "{d} alloc / {d} free · {d} B",1179        .{ maxima.alloc_count.?, maxima.free_count.?, maxima.alloc_bytes.? },1180    );1181    try html.raw("<br><span class=\"muted\">");1182    try html.fmt(1183        "{d} alloc / {d} free · {d} B per eval",1184        .{1185            maxima.alloc_count_per_eval.?,1186            maxima.free_count_per_eval.?,1187            maxima.alloc_bytes_per_eval.?,1188        },1189    );1190    try html.raw("</span>");1191}11921193fn benchmarkReductionSources(1194    html: *Html,1195    sources: []const profiling.reduction.Source,1196) !void {1197    try html.fmt(1198        "<details><summary>Digest-bound source receipts ({d})</summary>",1199        .{sources.len},1200    );1201    try html.raw("<table class=\"data\"><thead><tr>");1202    try html.raw("<th data-sort>execution</th><th data-sort>acquisition</th>");1203    try html.raw("<th>bench JSONL</th><th>structured wrapper</th>");1204    try html.raw("</tr></thead><tbody>");1205    for (sources) |source| try benchmarkReductionSourceRow(html, source);1206    try html.raw("</tbody></table></details>");1207}12081209fn benchmarkReductionSourceRow(1210    html: *Html,1211    source: profiling.reduction.Source,1212) !void {1213    const bench_digest = source.bench_jsonl.identity.hex();1214    const structured_digest = source.structured.identity.hex();1215    try html.fmt("<tr><td class=\"num\">{d}</td><td class=\"num\">", .{1216        source.execution_index,1217    });1218    if (source.acquisition_position) |position| {1219        try html.fmt("{d}", .{position});1220    } else {1221        try html.raw("fixed");1222    }1223    try html.raw("</td><td><code>");1224    try html.esc(source.bench_jsonl.path);1225    try html.raw("</code><br><span class=\"muted\"><code>");1226    try html.esc(bench_digest[0..12]);1227    try html.fmt("…</code> · {d} B</span></td><td><code>", .{1228        source.bench_jsonl.identity.bytes,1229    });1230    try html.esc(source.structured.path);1231    try html.raw("</code><br><span class=\"muted\"><code>");1232    try html.esc(structured_digest[0..12]);1233    try html.fmt("…</code> · {d} B</span></td></tr>", .{1234        source.structured.identity.bytes,1235    });1236}12371238fn workloadAcquisitionMetadata(1239    html: *Html,1240    allocator: Allocator,1241    acquisition: profiling.order.Context,1242) !void {1243    std.debug.assert(acquisition.valid());1244    try metaItem(html, "measurement order", acquisition.method().name());1245    switch (acquisition) {1246        .blocked => |blocked| {1247            try metaItem(1248                html,1249                "acquisition position",1250                try std.fmt.allocPrint(1251                    allocator,1252                    "{d} of {d}",1253                    .{ blocked.position, blocked.workload_count },1254                ),1255            );1256            try metaItem(1257                html,1258                "preceded by",1259                if (blocked.predecessors.len == 0)1260                    "none"1261                else1262                    try std.mem.join(allocator, " → ", blocked.predecessors),1263            );1264        },1265        .random_interleaved => |interleaved| {1266            try metaItem(1267                html,1268                "schedule algorithm",1269                profiling.order.schedule_algorithm,1270            );1271            try metaItem(1272                html,1273                "interleave seed",1274                try std.fmt.allocPrint(allocator, "{d}", .{interleaved.seed}),1275            );1276            try metaItem(1277                html,1278                "acquisition design",1279                try std.fmt.allocPrint(1280                    allocator,1281                    "{d} workload(s) × {d} repetitions",1282                    .{ interleaved.workload_count, interleaved.repeat_count },1283                ),1284            );1285            try metaItem(1286                html,1287                "selected cohort",1288                try std.mem.join(allocator, " → ", interleaved.selected_workloads),1289            );1290            try metaItem(1291                html,1292                "planned positions",1293                try positionsLabel(allocator, interleaved.positions),1294            );1295            try metaItem(html, "setup order", profiling.order.setup_order);1296            try metaItem(1297                html,1298                "warmup placement",1299                profiling.order.warmup_placement,1300            );1301            try metaItem(html, "failure policy", profiling.order.failure_policy);1302        },1303    }1304}13051306fn workloadCapturePerturbation(1307    html: *Html,1308    allocator: Allocator,1309    row: *const analyze.Workload,1310) !void {1311    const measurement = row.capture_perturbation orelse return;1312    const summary = row.capture_perturbation_summary orelse return;1313    try html.raw("<section><h2>Capture perturbation</h2><p class=\"hint\">Matched control and capture executions reuse one setup and the same built binary. A seeded balanced order limits drift; the paired interval estimates active-capture wall-time perturbation and is not product-regression priority evidence.</p>");1314    try html.raw("<dl class=\"meta\">");1315    try metaItem(html, "effect state", try tokenLabel(allocator, summary.state));1316    try metaItem(html, "pair order", "seeded balanced within pair");1317    if (measurement.configuration.host_kind) |kind| {1318        try metaItem(html, "active host capture", try tokenLabel(allocator, kind));1319    }1320    if (measurement.configuration.tracy) {1321        try metaItem(html, "active Tracy capture", "enabled");1322    }1323    if (measurement.configuration.allocations) {1324        try metaItem(html, "active allocation trace", "enabled");1325    }1326    try metaItem(html, "capture artifacts", "last capture execution");1327    try metaItem(html, "control outputs", "last control execution");1328    if (summary.control_mean_ns) |value| {1329        try metaItem(html, "control mean", try format.ns(allocator, value));1330    }1331    if (summary.capture_mean_ns) |value| {1332        try metaItem(html, "capture mean", try format.ns(allocator, value));1333    }1334    if (summary.mean_delta_ns) |value| {1335        try metaItem(html, "mean delta", try signedNs(allocator, value));1336    }1337    if (summary.mean_percent_change) |value| {1338        try metaItem(html, "mean change", try signedPercent(allocator, value));1339    }1340    if (summary.effect_low_percent != null and summary.effect_high_percent != null) {1341        try metaItem(1342            html,1343            "95% paired effect",1344            try std.fmt.allocPrint(1345                allocator,1346                "{s} .. {s}",1347                .{1348                    try signedPercent(allocator, summary.effect_low_percent.?),1349                    try signedPercent(allocator, summary.effect_high_percent.?),1350                },1351            ),1352        );1353    }1354    try html.raw("</dl><table class=\"data\"><thead><tr><th data-sort>pair</th><th>order</th><th data-sort>control wall</th><th data-sort>capture wall</th><th data-sort>change</th><th>status</th></tr></thead><tbody>");1355    for (measurement.pairs) |pair| {1356        try html.fmt("<tr><td class=\"num\" data-v=\"{d}\">{d}</td><td>", .{ pair.index, pair.index });1357        try html.esc(try tokenLabel(allocator, @tagName(pair.order)));1358        try html.raw("</td>");1359        try executionWallCell(html, allocator, pair.control);1360        try executionWallCell(html, allocator, pair.capture);1361        try html.raw("<td class=\"num\">");1362        if (pairPercentChange(pair)) |value| {1363            try html.esc(try signedPercent(allocator, value));1364        } else {1365            try html.raw("<span class=\"muted\">—</span>");1366        }1367        try html.raw("</td><td>");1368        try html.esc(pairState(pair));1369        try html.raw("</td></tr>");1370    }1371    try html.raw("</tbody></table></section>");1372}13731374fn signedNs(allocator: Allocator, value: f64) ![]const u8 {1375    return try std.fmt.allocPrint(1376        allocator,1377        "{s}{s}",1378        .{ if (value >= 0) "+" else "", try format.ns(allocator, value) },1379    );1380}13811382fn signedPercent(allocator: Allocator, value: f64) ![]const u8 {1383    return try std.fmt.allocPrint(1384        allocator,1385        "{s}{d:.2}%",1386        .{ if (value >= 0) "+" else "", value },1387    );1388}13891390fn executionWallCell(1391    html: *Html,1392    allocator: Allocator,1393    result: ?profiling.execute.Result,1394) !void {1395    const actual = result orelse {1396        try html.raw("<td class=\"num muted\">—</td>");1397        return;1398    };1399    try html.fmt("<td class=\"num\" data-v=\"{d}\">", .{actual.wall_ns});1400    try html.esc(try format.ns(allocator, @floatFromInt(actual.wall_ns)));1401    try html.raw("</td>");1402}14031404fn pairPercentChange(pair: profiling.perturbation.Pair) ?f64 {1405    const control = pair.control orelse return null;1406    const captured = pair.capture orelse return null;1407    if (control.wall_ns == 0) return null;1408    return ((@as(f64, @floatFromInt(captured.wall_ns)) /1409        @as(f64, @floatFromInt(control.wall_ns))) - 1.0) * 100.0;1410}14111412fn pairState(pair: profiling.perturbation.Pair) []const u8 {1413    const control = pair.control orelse return "not run";1414    if (control.exit_code != 0) return "control failed";1415    const captured = pair.capture orelse return "not run";1416    if (captured.exit_code != 0) return "capture failed";1417    return "complete";1418}14191420fn workloadWallMetadata(1421    html: *Html,1422    allocator: Allocator,1423    row: *const analyze.Workload,1424) !void {1425    const wall_distribution = workloadWallDistribution(row);1426    try metaItem(1427        html,1428        "wall sample shape",1429        try tokenLabel(allocator, wall_distribution.kind.name()),1430    );1431    try metaItem(1432        html,1433        "wall samples",1434        try std.fmt.allocPrint(1435            allocator,1436            "{d}",1437            .{wall_distribution.sample_count},1438        ),1439    );1440    if (wall_distribution.median_ns) |value| {1441        try metaItem(html, "wall median", try format.ns(allocator, value));1442    }1443    if (wall_distribution.p95_ns) |value| {1444        try metaItem(html, "wall p95", try format.ns(allocator, value));1445    }1446    if (wall_distribution.p99_ns) |value| {1447        try metaItem(html, "wall p99", try format.ns(allocator, value));1448    }1449    if (wall_distribution.stddev_ns) |value| {1450        try metaItem(1451            html,1452            "wall standard deviation",1453            try format.ns(allocator, value),1454        );1455    }1456    if (wall_distribution.coefficient_of_variation_percent) |value| {1457        try metaItem(1458            html,1459            "wall coefficient of variation",1460            try std.fmt.allocPrint(allocator, "{d:.2}%", .{value}),1461        );1462    }1463    if (wall_distribution.min_ns != null and wall_distribution.max_ns != null) {1464        try metaItem(1465            html,1466            "wall range",1467            try std.fmt.allocPrint(1468                allocator,1469                "{s} .. {s}",1470                .{1471                    try format.ns(allocator, wall_distribution.min_ns.?),1472                    try format.ns(allocator, wall_distribution.max_ns.?),1473                },1474            ),1475        );1476    }1477}14781479fn workloadWarmupMetadata(1480    html: *Html,1481    allocator: Allocator,1482    row: *const analyze.Workload,1483) !void {1484    if (row.warmup_count == 0) return;1485    try metaItem(html, "unmeasured warmups", try std.fmt.allocPrint(allocator, "{d}", .{row.warmup_count}));1486    try metaItem(html, "warmup wall total", try format.ns(allocator, @floatFromInt(row.warmup_total_wall_ns)));1487    try metaItem(html, "warmup outputs", "last warmup execution");1488    const distribution = row.warmup_distribution orelse return;1489    if (distribution.median_ns) |value| {1490        try metaItem(html, "warmup wall median", try format.ns(allocator, value));1491    }1492    if (distribution.min_ns != null and distribution.max_ns != null) {1493        try metaItem(1494            html,1495            "warmup wall range",1496            try std.fmt.allocPrint(1497                allocator,1498                "{s} .. {s}",1499                .{1500                    try format.ns(allocator, distribution.min_ns.?),1501                    try format.ns(allocator, distribution.max_ns.?),1502                },1503            ),1504        );1505    }1506}15071508fn workloadResourceMetadata(1509    html: *Html,1510    allocator: Allocator,1511    row: *const analyze.Workload,1512) !void {1513    if (row.resource_usage_source) |source| {1514        try metaItem(html, "resource usage source", try tokenLabel(allocator, @tagName(source)));1515    }1516    if (row.voluntary_context_switches != null and row.involuntary_context_switches != null) {1517        const switches = row.voluntary_context_switches.? + row.involuntary_context_switches.?;1518        try metaItem(1519            html,1520            "mean context switches",1521            try std.fmt.allocPrint(1522                allocator,1523                "{d:.2} voluntary + {d:.2} involuntary",1524                .{ row.voluntary_context_switches.?, row.involuntary_context_switches.? },1525            ),1526        );1527        try resourceRateMetadata(html, allocator, "context switches / s", switches, row.wall_ns);1528    }1529    if (row.minor_page_faults != null and row.major_page_faults != null) {1530        const faults = row.minor_page_faults.? + row.major_page_faults.?;1531        try metaItem(1532            html,1533            "mean page faults",1534            try std.fmt.allocPrint(1535                allocator,1536                "{d:.2} minor + {d:.2} major",1537                .{ row.minor_page_faults.?, row.major_page_faults.? },1538            ),1539        );1540        try resourceRateMetadata(html, allocator, "page faults / s", faults, row.wall_ns);1541    }1542}15431544fn resourceRateMetadata(1545    html: *Html,1546    allocator: Allocator,1547    label: []const u8,1548    value: f64,1549    wall_ns: u64,1550) !void {1551    if (wall_ns == 0) return;1552    const rate = value * @as(f64, std.time.ns_per_s) /1553        @as(f64, @floatFromInt(wall_ns));1554    try metaItem(1555        html,1556        label,1557        try std.fmt.allocPrint(allocator, "{d:.2} process rate", .{rate}),1558    );1559}15601561fn workloadWallDistribution(1562    row: *const analyze.Workload,1563) profiling.measurement.WallDistribution {1564    return row.wall_distribution orelse1565        profiling.measurement.pointWallDistribution(row.wall_ns);1566}15671568fn tokenLabel(allocator: Allocator, token: []const u8) ![]const u8 {1569    const label = try allocator.dupe(u8, token);1570    for (label) |*byte| {1571        if (byte.* == '_') byte.* = ' ';1572    }1573    return label;1574}15751576fn workloadFlameLinks(html: *Html, allocator: Allocator, row: *const analyze.Workload, flame_sources: flame.Sources) !void {1577    if (!flame_sources.any()) return;1578    const file = try flameFile(allocator, row.name);1579    try html.raw("<section><h2>Flame graphs</h2><p class=\"hint\">");1580    if (flame_sources.cpu_folded != null) {1581        try html.raw("<a href=\"");1582        try html.esc(file);1583        try html.raw("#cpu\">On-CPU samples</a>");1584    }1585    if (flame_sources.offcpu_summary != null) {1586        if (flame_sources.cpu_folded != null) try html.raw(" · ");1587        try html.raw("<a href=\"");1588        try html.esc(file);1589        try html.raw("#offcpu\">Off-CPU time</a>");1590    }1591    try html.raw("</p></section>");1592}15931594fn workloadTiming(1595    html: *Html,1596    allocator: Allocator,1597    site: model.Site,1598    row: *const analyze.Workload,1599) !void {1600    if (row.metrics.len == 0) return;1601    const order = try sortedMetricIndices(allocator, row.metrics);1602    try html.raw(1603        "<section><h2>Timing metrics</h2><p class=\"hint\">History runs oldest to " ++1604            "newest. Within-run lines connect explicitly ordered acquisition indices, not " ++1605            "elapsed time; unordered rows use a distribution strip. Shading is the median " ++1606            "confidence interval.</p>",1607    );1608    try html.raw(1609        "<table class=\"data\"><thead><tr><th data-sort>metric</th><th>history</th>" ++1610            "<th>within run</th><th data-sort>median</th><th>95% CI</th>" ++1611            "<th data-sort>samples</th><th data-sort>min</th><th data-sort>p95</th>" ++1612            "<th data-sort>max</th></tr></thead><tbody>",1613    );1614    const history = site.findHistory(row.name);1615    for (order) |metric_index| {1616        const metric = row.metrics[metric_index];1617        const primary = metric.primaryNs() orelse continue;1618        try html.raw("<tr><td class=\"label\">");1619        try html.esc(metric.label);1620        try html.raw("</td><td>");1621        try metricHistoryChart(html, allocator, site, history, metric.key);1622        try html.raw("</td><td>");1623        try metricWithinRunChart(html, allocator, metric, primary);1624        try html.fmt("</td><td class=\"num\" data-v=\"{d:.0}\">", .{primary});1625        try html.esc(try format.ns(allocator, primary));1626        try html.raw("</td><td class=\"num\">");1627        if (metric.primaryInterval()) |interval| {1628            try html.esc(try format.ns(allocator, interval.low_ns));1629            try html.raw(" .. ");1630            try html.esc(try format.ns(allocator, interval.high_ns));1631        } else {1632            try html.raw("<span class=\"muted\">—</span>");1633        }1634        try html.raw("</td>");1635        if (metric.sample_count) |samples| {1636            try html.fmt("<td class=\"num\" data-v=\"{d}\">{d}</td>", .{ samples, samples });1637        } else {1638            try html.raw("<td class=\"num muted\" data-v=\"0\">—</td>");1639        }1640        try optionalNsCell(html, allocator, metric.min_ns);1641        try optionalNsCell(html, allocator, metric.p95_ns);1642        try optionalNsCell(html, allocator, metric.max_ns);1643        try html.raw("</tr>");1644    }1645    try html.raw("</tbody></table></section>");1646}16471648fn metricWithinRunChart(1649    html: *Html,1650    allocator: Allocator,1651    metric: profiling.metric.Metric,1652    primary: f64,1653) !void {1654    const interval = metric.primaryInterval();1655    const low = if (interval) |actual| actual.low_ns else null;1656    const high = if (interval) |actual| actual.high_ns else null;1657    if (metric.samples_ns.len != 0) {1658        if (metric.sample_sequence) |sample_sequence| {1659            switch (sample_sequence.order) {1660                .measured_acquisition_order => {1661                    try html.raw(try chart.sequence(1662                        allocator,1663                        metric.samples_ns,1664                        primary,1665                        low,1666                        high,1667                        .{1668                            .format = format.ns,1669                            .width = 200,1670                            .height = 34,1671                            .index_origin = sample_sequence.index_origin,1672                        },1673                    ));1674                    return;1675                },1676            }1677        }1678    }1679    if (metric.samples_ns.len != 0 or interval != null) {1680        try html.raw(try chart.strip(1681            allocator,1682            metric.samples_ns,1683            primary,1684            low,1685            high,1686            .{ .format = format.ns, .width = 200, .height = 34 },1687        ));1688        return;1689    }1690    try html.raw("<span class=\"muted\">");1691    try distributionName(html, metric.distribution);1692    try html.raw("</span>");1693}16941695fn workloadMemory(1696    html: *Html,1697    allocator: Allocator,1698    site: model.Site,1699    row: *const analyze.Workload,1700) !void {1701    if (row.memory_metrics.len == 0) return;1702    try html.raw("<section><h2>Memory metrics</h2><table class=\"data\"><thead><tr><th data-sort>metric</th><th>history</th><th data-sort>value</th></tr></thead><tbody>");1703    const history = site.findHistory(row.name);1704    for (row.memory_metrics) |metric| {1705        try html.raw("<tr><td class=\"label\">");1706        try html.esc(metric.label);1707        try html.raw("</td><td>");1708        try memoryHistoryChart(html, allocator, site, history, metric.key, metric.unit.name());1709        try html.fmt("</td><td class=\"num\" data-v=\"{d:.0}\">", .{metric.value});1710        try html.esc(try formatMemory(allocator, metric.value, metric.unit.name()));1711        try html.raw("</td></tr>");1712    }1713    try html.raw("</tbody></table></section>");1714}17151716fn workloadCausal(html: *Html, allocator: Allocator, row: *const analyze.Workload) !void {1717    if (row.causal.len == 0) return;1718    try html.raw("<section><h2>Causal (Coz)</h2>");1719    try causalIntegrityNotice(html, row.captures);1720    try html.raw(1721        "<p class=\"hint\">Max program speedup predicted by virtually speeding this line up. " ++1722            "Larger is a better optimization target. The curve plots program speedup against " ++1723            "virtual speedup; a rising curve means the line is on the critical path. Experiment " ++1724            "support counts randomized performance experiments; samples count selected profiler " ++1725            "samples. Point-only and unreplicated curves are exploratory and do not affect " ++1726            "regression priority. Repeated curves are directional and require validation with " ++1727            "independent runs.</p>",1728    );1729    try html.raw("<table class=\"data\"><thead><tr><th>location</th>" ++1730        "<th>progress point</th><th>kind</th><th data-sort>support</th><th>curve</th>" ++1731        "<th data-sort>max speedup</th><th data-sort>slope</th>" ++1732        "<th data-sort>experiments</th><th data-sort>samples</th>" ++1733        "</tr></thead><tbody>");1734    for (row.causal) |result| {1735        try html.raw("<tr><td><code>");1736        try html.esc(result.file);1737        try html.fmt(":{d}</code></td><td>", .{result.line});1738        try html.esc(result.progress_point);1739        try html.raw("</td><td>");1740        try html.esc(result.kind);1741        try html.raw("</td>");1742        try causalSupportCell(html, result.support);1743        try html.raw("<td>");1744        try causalCurve(html, allocator, result.measurements);1745        try html.raw("</td>");1746        const speedup = result.max_program_speedup * 100;1747        try html.fmt("<td class=\"num\" data-v=\"{d:.2}\">", .{speedup});1748        try html.esc(try format.percent(allocator, speedup));1749        try html.raw("</td><td class=\"num\">");1750        if (result.slope) |slope| {1751            try html.fmt("{d:.2}", .{slope});1752        } else {1753            try html.raw("<span class=\"muted\">—</span>");1754        }1755        try html.fmt("</td><td class=\"num\" data-v=\"{d}\">{d}</td>", .{1756            result.support.experiment_count,1757            result.support.experiment_count,1758        });1759        try html.fmt("<td class=\"num\" data-v=\"{d}\">{d}</td></tr>", .{1760            result.total_selected_samples,1761            result.total_selected_samples,1762        });1763    }1764    try html.raw("</tbody></table></section>");1765}17661767fn causalSupportCell(html: *Html, support: profiling.capture.coz.Support) !void {1768    if (support.status == .within_run_repeated_curve) {1769        try html.raw("<td>");1770    } else {1771        try html.raw("<td class=\"warn\">");1772    }1773    try html.esc(supportLabel(support.status));1774    try html.fmt(1775        "<br><span class=\"muted\">{d} {s}; {d} baseline; " ++1776            "{d} min/point</span></td>",1777        .{1778            support.speedup_point_count,1779            if (support.speedup_point_count == 1) "point" else "points",1780            support.baseline_experiment_count,1781            support.minimum_experiments_per_point,1782        },1783    );1784}17851786fn supportLabel(status: profiling.capture.coz.SupportStatus) []const u8 {1787    return switch (status) {1788        .point_only => "point only",1789        .unreplicated_curve => "unreplicated curve",1790        .within_run_repeated_curve => "within-run repeated curve",1791    };1792}17931794fn causalIntegrityNotice(html: *Html, captures: []const profiling.host.Capture) !void {1795    for (captures) |capture| {1796        if (!std.mem.eql(u8, capture.kind, profiling.capture.coz.capture_kind)) continue;1797        const message = capture.caveat_message orelse {1798            try html.raw("<p class=\"hint\">Sampling integrity: complete.</p>");1799            return;1800        };1801        try html.raw("<p class=\"verdict warn\">Sampling integrity caveat: ");1802        try html.esc(message);1803        try html.raw("</p>");1804        return;1805    }1806}18071808fn causalCurve(html: *Html, allocator: Allocator, measurements: []const profiling.capture.coz.Measurement) !void {1809    if (measurements.len == 0) {1810        try html.raw("<span class=\"muted\">—</span>");1811        return;1812    }1813    const points = try allocator.alloc(chart.XyPoint, measurements.len);1814    for (points, measurements) |*point, measurement| {1815        const virtual = measurement.virtual_speedup * 100;1816        const program = measurement.program_speedup * 100;1817        point.* = .{1818            .x = virtual,1819            .y = program,1820            .label = try std.fmt.allocPrint(allocator, "virtual {s}: program {s}", .{1821                try format.percent(allocator, virtual),1822                try format.percent(allocator, program),1823            }),1824        };1825    }1826    try html.raw(try chart.xy(allocator, points, .{}));1827}18281829fn workloadCaptures(html: *Html, row: *const analyze.Workload) !void {1830    if (row.captures.len == 0) return;1831    try html.raw("<section><h2>Host captures</h2><table class=\"data\"><thead><tr><th>kind</th><th>tool</th><th>scope</th><th>state</th><th>caveat</th></tr></thead><tbody>");1832    for (row.captures) |capture| {1833        try html.raw("<tr><td>");1834        try html.esc(capture.kind);1835        try html.raw("</td><td>");1836        try html.esc(capture.tool);1837        try html.raw("</td><td>");1838        try html.esc(capture.scope);1839        try html.raw("</td><td>");1840        try html.esc(capture.state);1841        try html.raw("</td><td>");1842        if (capture.caveat_message) |message| {1843            try html.esc(message);1844        } else {1845            try html.raw("<span class=\"muted\">—</span>");1846        }1847        try html.raw("</td></tr>");1848    }1849    try html.raw("</tbody></table></section>");1850}18511852fn workloadLogs(html: *Html, allocator: Allocator, row: *const analyze.Workload) !void {1853    try logDetails(1854        html,1855        allocator,1856        "warmup stdout (last warmup execution)",1857        row.warmup_stdout_path,1858    );1859    try logDetails(1860        html,1861        allocator,1862        "warmup stderr (last warmup execution)",1863        row.warmup_stderr_path,1864    );1865    if (row.executions.len == 1) {1866        const execution = row.executions[0];1867        if (execution.artifacts) |artifacts| {1868            const prefix = try std.fmt.allocPrint(1869                allocator,1870                "measured execution {d}",1871                .{execution.index},1872            );1873            try logDetails(1874                html,1875                allocator,1876                try std.fmt.allocPrint(allocator, "{s} stdout", .{prefix}),1877                artifacts.stdout,1878            );1879            try logDetails(1880                html,1881                allocator,1882                try std.fmt.allocPrint(allocator, "{s} stderr", .{prefix}),1883                artifacts.stderr,1884            );1885        }1886    }1887    if (row.profiler_artifacts) |artifacts| {1888        try logDetails(html, allocator, "profiler stdout (last execution)", artifacts.stdout);1889        try logDetails(html, allocator, "profiler stderr (last execution)", artifacts.stderr);1890    }1891    if (row.capture_perturbation) |measurement| {1892        try logDetails(1893            html,1894            allocator,1895            "control stdout (last control execution)",1896            measurement.control_artifacts.stdout,1897        );1898        try logDetails(1899            html,1900            allocator,1901            "control stderr (last control execution)",1902            measurement.control_artifacts.stderr,1903        );1904    }1905}19061907fn workloadExecutionArtifacts(1908    html: *Html,1909    allocator: Allocator,1910    row: *const analyze.Workload,1911) !void {1912    var retained: usize = 0;1913    for (row.executions) |execution| {1914        if (execution.artifacts != null) retained += 1;1915    }1916    if (retained == 0) return;1917    try html.raw("<details><summary>Measured execution artifacts (");1918    try html.esc(try std.fmt.allocPrint(allocator, "{d}", .{retained}));1919    try html.raw(")</summary><table class=\"data\"><thead><tr>");1920    try html.raw("<th>sample</th><th>PID</th><th>position</th>");1921    try html.raw("<th>exit</th><th>wall</th><th>stdout</th><th>stderr</th>");1922    try html.raw("<th>benchmark JSONL</th><th>structured receipt</th>");1923    try html.raw("<th>rows/errors</th></tr></thead><tbody>");1924    for (row.executions) |execution| {1925        const artifacts = execution.artifacts orelse continue;1926        try html.raw("<tr><td>");1927        try html.esc(try std.fmt.allocPrint(allocator, "{d}", .{execution.index}));1928        try html.raw("</td><td>");1929        try optionalInteger(html, allocator, execution.pid);1930        try html.raw("</td><td>");1931        try optionalInteger(html, allocator, execution.acquisition_position);1932        try html.raw("</td><td>");1933        try html.esc(try std.fmt.allocPrint(allocator, "{d}", .{execution.exit_code}));1934        try html.raw("</td><td>");1935        try html.esc(try format.ns(allocator, @floatFromInt(execution.wall_ns)));1936        inline for (.{1937            artifacts.stdout,1938            artifacts.stderr,1939            artifacts.bench_jsonl,1940            artifacts.structured,1941        }) |path| {1942            try html.raw("</td><td><code>");1943            try html.esc(path);1944            try html.raw("</code>");1945        }1946        try html.raw("</td><td>");1947        try html.esc(try std.fmt.allocPrint(1948            allocator,1949            "{d}/{d}",1950            .{ artifacts.structured_rows, artifacts.structured_parse_errors },1951        ));1952        try html.raw("</td></tr>");1953    }1954    try html.raw("</tbody></table></details>");1955}19561957fn optionalInteger(html: *Html, allocator: Allocator, value: anytype) !void {1958    if (value) |actual| {1959        try html.esc(try std.fmt.allocPrint(allocator, "{d}", .{actual}));1960    } else {1961        try html.raw("<span class=\"muted\">—</span>");1962    }1963}19641965fn logDetails(html: *Html, allocator: Allocator, name: []const u8, path: ?[]const u8) !void {1966    const actual_path = path orelse return;1967    const text = sys.fs.readFileAlloc(allocator, actual_path, 256 * 1024 * 1024) catch return;1968    if (std.mem.trim(u8, text, " \t\r\n").len == 0) return;1969    const tail = text[text.len - @min(text.len, log_tail_bytes) ..];1970    try html.raw("<details class=\"log\"><summary>");1971    try html.esc(name);1972    if (tail.len < text.len) {1973        try html.fmt(" (last {d} of {d} bytes)", .{ tail.len, text.len });1974    } else {1975        try html.fmt(" ({d} bytes)", .{text.len});1976    }1977    try html.raw("</summary><pre>");1978    try html.esc(tail);1979    try html.raw("</pre></details>");1980}19811982fn metricHistoryChart(1983    html: *Html,1984    allocator: Allocator,1985    site: model.Site,1986    history: ?*const model.WorkloadHistory,1987    key: []const u8,1988) !void {1989    const actual = history orelse {1990        try html.raw("<span class=\"muted\">—</span>");1991        return;1992    };1993    for (actual.metrics) |metric_history| {1994        if (!std.mem.eql(u8, metric_history.key, key)) continue;1995        try html.raw(try seriesChart(allocator, site, metric_history.primary, metric_history.low, metric_history.high, format.ns, .{ .width = 170, .height = 34 }));1996        return;1997    }1998    try html.raw("<span class=\"muted\">—</span>");1999}20002001fn memoryHistoryChart(2002    html: *Html,2003    allocator: Allocator,2004    site: model.Site,2005    history: ?*const model.WorkloadHistory,2006    key: []const u8,2007    unit: []const u8,2008) !void {2009    const actual = history orelse {2010        try html.raw("<span class=\"muted\">—</span>");2011        return;2012    };2013    for (actual.memory) |memory_history| {2014        if (!std.mem.eql(u8, memory_history.key, key)) continue;2015        const formatter: chart.Format = if (std.mem.eql(u8, unit, "bytes")) format.bytes else format.count;2016        try html.raw(try seriesChart(allocator, site, memory_history.values, null, null, formatter, .{ .width = 170, .height = 34 }));2017        return;2018    }2019    try html.raw("<span class=\"muted\">—</span>");2020}20212022const SeriesOptions = struct {2023    width: f64,2024    height: f64,2025};20262027fn seriesChart(2028    allocator: Allocator,2029    site: model.Site,2030    values: []?f64,2031    low: ?[]?f64,2032    high: ?[]?f64,2033    formatter: chart.Format,2034    options: SeriesOptions,2035) ![]u8 {2036    const points = try allocator.alloc(chart.Point, values.len);2037    for (points, 0..) |*point, run_index| {2038        const entry = &site.runs[run_index];2039        const label = try std.fmt.allocPrint(allocator, "{s} ({s})", .{2040            entry.manifest.run_id,2041            try format.timestamp(allocator, entry.manifest.started_unix_ns),2042        });2043        point.* = .{2044            .label = label,2045            .value = values[run_index],2046            .low = if (low) |actual| actual[run_index] else null,2047            .high = if (high) |actual| actual[run_index] else null,2048        };2049    }2050    return try chart.line(allocator, points, .{2051        .width = options.width,2052        .height = options.height,2053        .format = formatter,2054    });2055}20562057fn sortedMetricIndices(allocator: Allocator, metrics: []const profiling.metric.Metric) ![]usize {2058    const order = try allocator.alloc(usize, metrics.len);2059    for (order, 0..) |*slot, metric_index| slot.* = metric_index;2060    std.mem.sort(usize, order, metrics, metricGreater);2061    return order;2062}20632064fn metricGreater(metrics: []const profiling.metric.Metric, left: usize, right: usize) bool {2065    const left_value = metrics[left].primaryNs() orelse -1;2066    const right_value = metrics[right].primaryNs() orelse -1;2067    return left_value > right_value;2068}20692070fn stateBadge(html: *Html, status: []const u8, exit_code: i64) !void {2071    if (exit_code == 0) {2072        try html.raw("<span class=\"badge badge-passed\">");2073        try html.esc(status);2074        try html.raw("</span>");2075    } else {2076        try html.fmt("<span class=\"badge badge-failed\">", .{});2077        try html.esc(status);2078        try html.fmt(" (exit {d})</span>", .{exit_code});2079    }2080}20812082fn barCell(html: *Html, value: f64, max: f64, text: []const u8) !void {2083    const fraction = if (max > 0) @min(value / max, 1.0) else 0;2084    try html.fmt("<td class=\"num bar-cell\" data-v=\"{d:.0}\"><span class=\"cellbar\" style=\"width:{d:.1}%\"></span><span class=\"cellval\">", .{ value, fraction * 100 });2085    try html.esc(text);2086    try html.raw("</span></td>");2087}20882089fn distributionName(html: *Html, distribution: profiling.metric.Distribution) !void {2090    for (distribution.name()) |byte| {2091        try html.esc(if (byte == '_') " " else &[_]u8{byte});2092    }2093}20942095fn optionalNsCell(html: *Html, allocator: Allocator, value: ?f64) !void {2096    const actual = value orelse {2097        try html.raw("<td class=\"num muted\" data-v=\"-1\">—</td>");2098        return;2099    };2100    try html.fmt("<td class=\"num\" data-v=\"{d:.0}\">", .{actual});2101    try html.esc(try format.ns(allocator, actual));2102    try html.raw("</td>");2103}21042105fn percentCell(html: *Html, allocator: Allocator, value: ?f64) !void {2106    const actual = value orelse {2107        try html.raw("<td class=\"num muted\" data-v=\"0\">—</td>");2108        return;2109    };2110    try html.fmt("<td class=\"num {s}\" data-v=\"{d:.2}\">", .{ deltaClass(actual), actual });2111    try html.esc(try format.percent(allocator, actual));2112    try html.raw("</td>");2113}21142115fn deltaClass(percent: f64) []const u8 {2116    if (percent >= 2) return "delta-up";2117    if (percent <= -2) return "delta-down";2118    return "delta-flat";2119}21202121fn formatMemory(allocator: Allocator, value: f64, unit: []const u8) ![]u8 {2122    if (std.mem.eql(u8, unit, "bytes")) return try format.bytes(allocator, value);2123    return try format.count(allocator, value);2124}21252126pub fn flamePage(2127    allocator: Allocator,2128    site: model.Site,2129    entry: *const model.Entry,2130    row: *const analyze.Workload,2131    flame_sources: flame.Sources,2132) ![]u8 {2133    var html = Html{ .allocator = allocator };2134    const file = try workloadFile(allocator, row.name);2135    try html.raw("<nav class=\"crumbs\"><a href=\"../../../index.html\">tiny profiling</a> / <a href=\"../index.html\">");2136    try html.esc(entry.manifest.run_id);2137    try html.raw("</a> / <a href=\"");2138    try html.esc(file);2139    try html.raw("\">");2140    try html.esc(row.name);2141    try html.raw("</a> / <span>flame graphs</span></nav><h1>");2142    try html.esc(row.name);2143    try html.raw(" flame graphs</h1><p class=\"hint\">Frame width is inclusive weight, merged left-heavy. Click a frame to zoom into its subtree; click the root frame to reset. Hover for exact weights.</p>");21442145    if (flame_sources.cpu_folded) |path| {2146        const stacks = try flame.loadFolded(allocator, path);2147        try html.raw("<section id=\"cpu\"><h2>On-CPU samples</h2><p class=\"hint\">Where CPU time went while the workload was running, from perf call-graph samples. Reported depth excludes the command root. An unresolved leaf limits direct attribution; unresolved anywhere means some calling context is missing.</p>");2148        try callchainQuality(&html, allocator, flame_sources);2149        try html.raw(try flame.render(allocator, stacks, .{2150            .class = "flame-cpu",2151            .palette = .warm,2152            .format = format.count,2153            .unit = "samples",2154        }));2155        try html.raw("</section>");2156        if (try flame.previousCpuFolded(allocator, site, entry, row.name)) |previous| {2157            const baseline_stacks = try flame.loadFolded(allocator, previous.path);2158            try html.raw("<section id=\"cpu-diff\"><h2>On-CPU change vs ");2159            try html.esc(previous.run_id);2160            try html.raw("</h2><p class=\"hint\">Layout is this run; color is the shift in sample share against the earlier run: red grew, blue shrank, near-white unchanged. Frames that vanished entirely tint their ancestors blue.</p>");2161            try html.raw(try flame.render(allocator, stacks, .{2162                .class = "flame-diff",2163                .palette = .warm,2164                .format = format.count,2165                .unit = "samples",2166                .baseline = baseline_stacks,2167            }));2168            try html.raw("</section>");2169        }2170    }2171    if (flame_sources.offcpu_summary) |path| {2172        if (try flame.loadBlocked(allocator, path)) |blocked| {2173            const nanoseconds = std.mem.eql(u8, blocked.weight_unit, "nanoseconds");2174            try html.raw("<section id=\"offcpu\"><h2>Off-CPU time</h2><p class=\"hint\">Where the workload was blocked instead of running: synchronization, blocking I/O, and scheduling.</p>");2175            try html.raw(try flame.render(allocator, blocked.stacks, .{2176                .class = "flame-offcpu",2177                .palette = .cool,2178                .format = if (nanoseconds) format.ns else format.count,2179                .unit = if (nanoseconds) "blocked" else "events",2180            }));2181            try html.raw("</section>");2182        }2183    }2184    try flameSummaries(&html, allocator, flame_sources);2185    try html.raw("<script>");2186    try html.raw(flame.script);2187    try html.raw("</script>");2188    return try html.take();2189}21902191fn callchainQuality(2192    html: *Html,2193    allocator: Allocator,2194    flame_sources: flame.Sources,2195) !void {2196    const path = flame_sources.symbols_summary orelse {2197        try html.raw("<p class=\"hint\">Callchain quality was not recorded for this capture.</p>");2198        return;2199    };2200    const summary = (try flame.loadSymbols(allocator, path)) orelse {2201        try html.raw("<p class=\"hint\">Callchain quality was not recorded for this capture.</p>");2202        return;2203    };2204    const quality = summary.callchain_quality orelse {2205        try html.raw("<p class=\"hint\">Callchain quality was not recorded for this capture.</p>");2206        return;2207    };2208    try html.raw("<dl class=\"meta callchain-quality\">");2209    const samples = if (summary.sample_count_text) |reported|2210        try std.fmt.allocPrint(2211            allocator,2212            "{d} extracted · {s} reported",2213            .{ quality.sample_count, reported },2214        )2215    else2216        try std.fmt.allocPrint(allocator, "{d} extracted", .{quality.sample_count});2217    try metaItem(html, "callchain samples", samples);2218    try metaItem(2219        html,2220        "unique callchains",2221        try std.fmt.allocPrint(allocator, "{d}", .{quality.unique_callchain_count}),2222    );2223    if (quality.meanDepthFrames()) |mean_depth| try metaItem(2224        html,2225        "depth",2226        try std.fmt.allocPrint(2227            allocator,2228            "{d:.1} mean · {d} max",2229            .{ mean_depth, quality.maximum_depth_frames },2230        ),2231    );2232    if (quality.resolvedFramePercent()) |resolved_percent| try metaItem(2233        html,2234        "resolved frames",2235        try std.fmt.allocPrint(2236            allocator,2237            "{d:.2}% · {d} / {d}",2238            .{2239                resolved_percent,2240                quality.resolved_frame_count,2241                quality.weighted_frame_count,2242            },2243        ),2244    );2245    if (quality.unresolvedLeafPercent()) |unresolved_leaf_percent| try metaItem(2246        html,2247        "unresolved leaves",2248        try std.fmt.allocPrint(2249            allocator,2250            "{d} · {d:.2}%",2251            .{ quality.unresolved_leaf_samples, unresolved_leaf_percent },2252        ),2253    );2254    if (quality.unresolvedContextPercent()) |unresolved_context_percent| try metaItem(2255        html,2256        "unresolved anywhere",2257        try std.fmt.allocPrint(2258            allocator,2259            "{d} · {d:.2}%",2260            .{2261                quality.samples_with_unresolved_frames,2262                unresolved_context_percent,2263            },2264        ),2265    );2266    try html.raw("</dl>");2267}22682269fn flameSummaries(html: *Html, allocator: Allocator, flame_sources: flame.Sources) !void {2270    if (flame_sources.children_summary) |path| {2271        if (try flame.loadChildren(allocator, path)) |summary| {2272            if (summary.rows.len != 0) {2273                try html.raw("<section id=\"symbols\"><h2>Hot symbols</h2><p class=\"hint\">Recorded perf report rows above the lane's percent floor. Children counts a symbol and everything it calls; self counts the symbol alone.</p>");2274                try html.raw("<table class=\"data\"><thead><tr><th data-sort>children</th><th data-sort>self</th><th>symbol</th><th data-sort>object</th></tr></thead><tbody>");2275                for (summary.rows) |row| {2276                    try html.fmt("<tr><td class=\"num\" data-v=\"{d:.2}\">{d:.2}%</td><td class=\"num\" data-v=\"{d:.2}\">{d:.2}%</td><td class=\"label\"><code>", .{ row.children_overhead_percent, row.children_overhead_percent, row.self_overhead_percent, row.self_overhead_percent });2277                    try html.esc(row.symbol);2278                    try html.raw("</code></td><td>");2279                    try html.esc(row.shared_object);2280                    try html.raw("</td></tr>");2281                }2282                try html.raw("</tbody></table></section>");2283            }2284        }2285    } else if (flame_sources.symbols_summary) |path| {2286        if (try flame.loadSymbols(allocator, path)) |summary| {2287            if (summary.rows.len != 0) {2288                try html.raw("<section id=\"symbols\"><h2>Hot symbols</h2><p class=\"hint\">Recorded perf report rows above the lane's percent floor, self overhead only.</p>");2289                try html.raw("<table class=\"data\"><thead><tr><th data-sort>self</th><th>symbol</th><th data-sort>object</th></tr></thead><tbody>");2290                for (summary.rows) |row| {2291                    try html.fmt("<tr><td class=\"num\" data-v=\"{d:.2}\">{d:.2}%</td><td class=\"label\"><code>", .{ row.overhead_percent, row.overhead_percent });2292                    try html.esc(row.symbol);2293                    try html.raw("</code></td><td>");2294                    try html.esc(row.shared_object);2295                    try html.raw("</td></tr>");2296                }2297                try html.raw("</tbody></table></section>");2298            }2299        }2300    }2301    if (flame_sources.srcline_summary) |path| {2302        if (try flame.loadSrcline(allocator, path)) |summary| {2303            if (summary.rows.len != 0) {2304                try html.raw("<section id=\"srclines\"><h2>Hot source lines</h2>");2305                try html.raw("<table class=\"data\"><thead><tr><th data-sort>self</th><th>source line</th><th>symbol</th></tr></thead><tbody>");2306                for (summary.rows) |row| {2307                    try html.fmt("<tr><td class=\"num\" data-v=\"{d:.2}\">{d:.2}%</td><td class=\"label\"><code>", .{ row.overhead_percent, row.overhead_percent });2308                    try html.esc(row.source_line);2309                    try html.raw("</code></td><td class=\"label\"><code>");2310                    try html.esc(row.symbol);2311                    try html.raw("</code></td></tr>");2312                }2313                try html.raw("</tbody></table></section>");2314            }2315        }2316    }2317}23182319pub fn workloadFile(allocator: Allocator, name: []const u8) ![]u8 {2320    const segment = try profiling.record.sanitizeSegment(allocator, name);2321    defer allocator.free(segment);2322    return try std.fmt.allocPrint(allocator, "{s}.html", .{segment});2323}23242325pub fn flameFile(allocator: Allocator, name: []const u8) ![]u8 {2326    const segment = try profiling.record.sanitizeSegment(allocator, name);2327    defer allocator.free(segment);2328    return try std.fmt.allocPrint(allocator, "{s}.flame.html", .{segment});2329}23302331fn latestDirWith(site: model.Site, workload_name: []const u8) ?[]const u8 {2332    var run_index = site.runs.len;2333    while (run_index > 0) {2334        run_index -= 1;2335        const entry = &site.runs[run_index];2336        if (entry.findWorkload(workload_name) != null) return entry.dir;2337    }2338    return null;2339}23402341fn lastValue(values: []?f64) ?f64 {2342    var value_index = values.len;2343    while (value_index > 0) {2344        value_index -= 1;2345        if (values[value_index]) |value| return value;2346    }2347    return null;2348}23492350fn lastDeltaPercent(values: []?f64) ?f64 {2351    var defined: [2]f64 = undefined;2352    var seen: usize = 0;2353    var value_index = values.len;2354    while (value_index > 0 and seen < 2) {2355        value_index -= 1;2356        if (values[value_index]) |value| {2357            defined[seen] = value;2358            seen += 1;2359        }2360    }2361    if (seen < 2) return null;2362    if (defined[1] == 0) return null;2363    return (defined[0] - defined[1]) / defined[1] * 100;2364}23652366fn definedCount(values: []?f64) usize {2367    var total: usize = 0;2368    for (values) |value| {2369        if (value != null) total += 1;2370    }2371    return total;2372}23732374test "page causal curve plots measurements and dashes empty results" {2375    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);2376    defer arena_state.deinit();2377    const allocator = arena_state.allocator();23782379    var with_points = Html{ .allocator = allocator };2380    const measurements = [_]profiling.capture.coz.Measurement{2381        .{ .virtual_speedup = 0.0, .program_speedup = 0.0, .experiment_count = 2 },2382        .{ .virtual_speedup = 0.2, .program_speedup = 0.14, .experiment_count = 2 },2383        .{ .virtual_speedup = 0.5, .program_speedup = 0.31, .experiment_count = 2 },2384    };2385    try causalCurve(&with_points, allocator, &measurements);2386    const curve = try with_points.take();2387    try std.testing.expect(std.mem.indexOf(u8, curve, "chart-xy-figure") != null);2388    try std.testing.expect(std.mem.indexOf(u8, curve, "virtual +50.0%: program +31.0%") != null);23892390    var without_points = Html{ .allocator = allocator };2391    try causalCurve(&without_points, allocator, &.{});2392    try std.testing.expect(std.mem.indexOf(u8, try without_points.take(), "muted") != null);2393}23942395test "page distinguishes exploratory and repeated causal support" {2396    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);2397    defer arena_state.deinit();2398    const allocator = arena_state.allocator();2399    var exploratory = Html{ .allocator = allocator };2400    try causalSupportCell(&exploratory, .{2401        .status = .unreplicated_curve,2402        .speedup_point_count = 2,2403        .experiment_count = 2,2404        .baseline_experiment_count = 1,2405        .minimum_experiments_per_point = 1,2406    });2407    const exploratory_content = try exploratory.take();2408    try std.testing.expect(std.mem.indexOf(u8, exploratory_content, "class=\"warn\"") != null);2409    try std.testing.expect(std.mem.indexOf(u8, exploratory_content, "unreplicated curve") != null);2410    try std.testing.expect(std.mem.indexOf(2411        u8,2412        exploratory_content,2413        "2 points; 1 baseline",2414    ) != null);24152416    var repeated = Html{ .allocator = allocator };2417    try causalSupportCell(&repeated, .{2418        .status = .within_run_repeated_curve,2419        .speedup_point_count = 3,2420        .experiment_count = 9,2421        .baseline_experiment_count = 3,2422        .minimum_experiments_per_point = 3,2423    });2424    const repeated_content = try repeated.take();2425    try std.testing.expect(std.mem.indexOf(u8, repeated_content, "class=\"warn\"") == null);2426    try std.testing.expect(std.mem.indexOf(2427        u8,2428        repeated_content,2429        "within-run repeated curve",2430    ) != null);2431}24322433test "page renders causal sampling integrity beside results" {2434    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);2435    defer arena_state.deinit();2436    const allocator = arena_state.allocator();2437    var html = Html{ .allocator = allocator };2438    const captures = [_]profiling.host.Capture{.{2439        .kind = profiling.capture.coz.capture_kind,2440        .tool = profiling.capture.coz.capture_tool,2441        .capture_path = "bench.coz.jsonl",2442        .summary_path = "bench.coz.analysis.json",2443        .state = "summary_written",2444        .caveat_kind = "sample_loss",2445        .caveat_message = "perf reported lost sampling events",2446    }};24472448    try causalIntegrityNotice(&html, &captures);2449    const content = try html.take();24502451    try std.testing.expect(std.mem.indexOf(u8, content, "Sampling integrity caveat") != null);2452    try std.testing.expect(std.mem.indexOf(u8, content, "lost sampling events") != null);24532454    var complete_html = Html{ .allocator = allocator };2455    var complete_capture = captures[0];2456    complete_capture.caveat_kind = null;2457    complete_capture.caveat_message = null;2458    try causalIntegrityNotice(&complete_html, &.{complete_capture});2459    try std.testing.expect(std.mem.indexOf(2460        u8,2461        try complete_html.take(),2462        "Sampling integrity: complete",2463    ) != null);2464}24652466test "page index renders lede trends and runs" {2467    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);2468    defer arena_state.deinit();2469    const allocator = arena_state.allocator();2470    const profiling_dir = ".zig-cache/profile-web-page-index-test";2471    defer sys.fs.deleteTree(profiling_dir) catch {};2472    try model.writeTestFixture(allocator, profiling_dir);2473    const site = try model.load(allocator, profiling_dir);24742475    const content = try index(allocator, site);2476    try std.testing.expect(std.mem.indexOf(u8, content, "2 run(s)") != null);2477    try std.testing.expect(std.mem.indexOf(u8, content, "runs/run-200-bbb/index.html") != null);2478    try std.testing.expect(std.mem.indexOf(u8, content, "gpalloc.allocator") != null);2479    try std.testing.expect(std.mem.indexOf(u8, content, "chart-line-figure") != null);2480    try std.testing.expect(std.mem.indexOf(u8, content, "no recorded analysis") != null);2481}24822483test "page renders unsupported outer comparisons without a regression verdict" {2484    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);2485    defer arena_state.deinit();2486    const allocator = arena_state.allocator();2487    const profiling_dir = ".zig-cache/profile-web-page-context-test";2488    defer sys.fs.deleteTree(profiling_dir) catch {};2489    try model.writeTestFixture(allocator, profiling_dir);2490    const analysis_path = try std.fs.path.join(2491        allocator,2492        &.{ profiling_dir, "run-200-bbb", "analysis.json" },2493    );2494    try sys.fs.writeFile(analysis_path,2495        \\{"schema":"tiny.profiling.analysis/v1",2496        \\ "candidate":{"run_id":"run-200-bbb","ran":1,"passed":1,"failed":0,2497        \\   "structured_metrics":1,"memory_metrics":1},2498        \\ "baseline":{"run_id":"run-100-aaa","ran":1,"passed":1,"failed":0,2499        \\   "structured_metrics":1,"memory_metrics":1},2500        \\ "comparison_support":{"state":"hostname_mismatch","supported":false},2501        \\ "regressions":[],"metric_regressions":[],"memory_regressions":[],2502        \\ "counter_shifts":[],"workload_comparison_skips":[],2503        \\ "priority":{"items":[],"components":[]}}2504    );2505    const site = try model.load(allocator, profiling_dir);2506    const index_content = try index(allocator, site);2507    try std.testing.expect(std.mem.indexOf(u8, index_content, "Comparison unsupported") != null);2508    try std.testing.expect(std.mem.indexOf(u8, index_content, "hostname mismatch") != null);2509    try std.testing.expect(2510        std.mem.indexOf(u8, index_content, "No regressions above threshold vs baseline") == null,2511    );25122513    const run_content = try run(allocator, site.latest().?, true);2514    try std.testing.expect(std.mem.indexOf(u8, run_content, "Comparison unsupported") != null);2515    try std.testing.expect(2516        std.mem.indexOf(u8, run_content, "differential views are suppressed") != null,2517    );2518}25192520test "page renders exact skipped acquisition contexts" {2521    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);2522    defer arena_state.deinit();2523    const allocator = arena_state.allocator();2524    const profiling_dir = ".zig-cache/profile-web-page-acquisition-test";2525    defer sys.fs.deleteTree(profiling_dir) catch {};2526    try model.writeTestFixture(allocator, profiling_dir);2527    const analysis_path = try std.fs.path.join(2528        allocator,2529        &.{ profiling_dir, "run-200-bbb", "analysis.json" },2530    );2531    try sys.fs.writeFile(analysis_path,2532        \\{"schema":"tiny.profiling.analysis/v1",2533        \\ "candidate":{"run_id":"run-200-bbb","ran":1,"passed":1,"failed":0,2534        \\   "structured_metrics":1,"memory_metrics":1},2535        \\ "baseline":{"run_id":"run-100-aaa","ran":1,"passed":1,"failed":0,2536        \\   "structured_metrics":1,"memory_metrics":1},2537        \\ "comparison_support":{"state":"supported","supported":true},2538        \\ "regressions":[],"metric_regressions":[],"memory_regressions":[],2539        \\ "counter_shifts":[],"workload_comparison_skips":[{2540        \\   "workload":"gpalloc.allocator","state":"measurement_order_mismatch",2541        \\   "reason":"measurement acquisition designs differ",2542        \\   "baseline_acquisition":{"position":2,"workload_count":2,"predecessors":["choir.compiler"]},2543        \\   "candidate_acquisition":{"position":2,"workload_count":2,"predecessors":["choir.wasm-emitter"]},2544        \\   "baseline_execution_count":1,"candidate_execution_count":1,2545        \\   "baseline_warmup_count":0,"candidate_warmup_count":0}],2546        \\ "priority":{"items":[],"components":[]}}2547    );2548    const site = try model.load(allocator, profiling_dir);2549    const content = try run(allocator, site.latest().?, true);2550    try std.testing.expect(std.mem.indexOf(u8, content, "baseline acquisition") != null);2551    try std.testing.expect(2552        std.mem.indexOf(u8, content, "2/2 after [choir.compiler]") != null,2553    );2554    try std.testing.expect(2555        std.mem.indexOf(u8, content, "2/2 after [choir.wasm-emitter]") != null,2556    );2557}25582559test "page renders energy and power shifts with repetition ranges" {2560    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);2561    defer arena_state.deinit();2562    const allocator = arena_state.allocator();2563    const profiling_dir = ".zig-cache/profile-web-page-energy-test";2564    defer sys.fs.deleteTree(profiling_dir) catch {};2565    try model.writeTestFixture(allocator, profiling_dir);2566    const analysis_path = try std.fs.path.join(2567        allocator,2568        &.{ profiling_dir, "run-200-bbb", "analysis.json" },2569    );2570    try sys.fs.writeFile(analysis_path,2571        \\{"schema":"tiny.profiling.analysis/v1",2572        \\ "candidate":{"run_id":"run-200-bbb","ran":1,"passed":1,"failed":0,2573        \\   "structured_metrics":1,"memory_metrics":1},2574        \\ "baseline":{"run_id":"run-100-aaa","ran":1,"passed":1,"failed":0,2575        \\   "structured_metrics":1,"memory_metrics":1},2576        \\ "comparison_support":{"state":"supported","supported":true},2577        \\ "regressions":[],"metric_regressions":[],"memory_regressions":[],2578        \\ "energy_shifts":[{"workload":"smg.graph","event":"power/energy-pkg/u",2579        \\   "baseline_joules":10,"candidate_joules":10.5,"energy_percent_change":5,2580        \\   "baseline_watts":5,"candidate_watts":7,"power_percent_change":40,2581        \\   "baseline_energy_range_percent":2,"candidate_energy_range_percent":3,2582        \\   "baseline_power_range_percent":4,"candidate_power_range_percent":5,2583        \\   "status":"energy_shift_caveated"}],2584        \\ "counter_shifts":[],"workload_comparison_skips":[],2585        \\ "priority":{"items":[],"components":[]}}2586    );2587    const site = try model.load(allocator, profiling_dir);2588    const content = try run(allocator, site.latest().?, true);2589    try std.testing.expect(std.mem.indexOf(u8, content, "Energy shifts") != null);2590    try std.testing.expect(std.mem.indexOf(u8, content, "power/energy-pkg/u") != null);2591    try std.testing.expect(std.mem.indexOf(u8, content, "10.000 J") != null);2592    try std.testing.expect(std.mem.indexOf(u8, content, "7.000 W") != null);2593    try std.testing.expect(std.mem.indexOf(u8, content, "+2.0% → +3.0%") != null);2594    try std.testing.expect(std.mem.indexOf(u8, content, "energy shift caveated") != null);2595}25962597test "page renders measured execution artifacts" {2598    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);2599    defer arena_state.deinit();2600    const allocator = arena_state.allocator();2601    const artifacts = profiling.measurement.ExecutionArtifacts{2602        .root = "workloads/w/executions/001",2603        .stdout = "workloads/w/executions/001/stdout.txt",2604        .stderr = "workloads/w/executions/001/stderr.txt",2605        .bench_jsonl = "workloads/w/executions/001/bench.jsonl",2606        .coz_jsonl = "workloads/w/executions/001/bench.coz.jsonl",2607        .coz_analysis = "workloads/w/executions/001/bench.coz.analysis.json",2608        .tracy_jsonl = "workloads/w/executions/001/bench.tracy.jsonl",2609        .tracy_summary = "workloads/w/executions/001/bench.tracy.summary.jsonl",2610        .allocations = "workloads/w/executions/001/allocations.jsonl",2611        .structured = "workloads/w/executions/001/structured.jsonl",2612        .structured_rows = 7,2613        .structured_parse_errors = 1,2614    };2615    const executions = [_]profiling.measurement.Execution{.{2616        .index = 1,2617        .acquisition_position = 4,2618        .pid = 101,2619        .exit_code = 0,2620        .wall_ns = 10,2621        .artifacts = artifacts,2622    }};2623    const row = analyze.Workload{2624        .name = "w",2625        .package = "p",2626        .step = "bench",2627        .status = "passed",2628        .exit_code = 0,2629        .wall_ns = 10,2630        .executions = &executions,2631        .result_path = null,2632    };2633    var html = Html{ .allocator = allocator };2634    try workloadExecutionArtifacts(&html, allocator, &row);2635    const content = try html.take();2636    try std.testing.expect(2637        std.mem.indexOf(u8, content, "Measured execution artifacts (1)") != null,2638    );2639    try std.testing.expect(std.mem.indexOf(u8, content, "structured.jsonl") != null);2640    try std.testing.expect(std.mem.indexOf(u8, content, "7/1") != null);2641    try std.testing.expect(std.mem.indexOf(u8, content, "last execution") == null);2642    const repeated = [_]profiling.measurement.Execution{2643        executions[0],2644        executions[0],2645    };2646    var repeated_row = row;2647    repeated_row.executions = &repeated;2648    repeated_row.benchmark_process_reduction = .{ .not_applicable = .{2649        .reason = .outside_direct_benchmark_domain,2650        .process_count = repeated.len,2651    } };2652    var metadata = Html{ .allocator = allocator };2653    try workloadStructuredAnalysisMetadata(&metadata, &repeated_row);2654    const metadata_content = try metadata.take();2655    try std.testing.expect(2656        std.mem.indexOf(u8, metadata_content, "outside direct benchmark domain") != null,2657    );2658}26592660fn expectBenchmarkReductionContent(content: []const u8) !void {2661    try std.testing.expect(std.mem.indexOf(2662        u8,2663        content,2664        "Benchmark process reduction",2665    ) != null);2666    try std.testing.expect(std.mem.indexOf(u8, content, "10 → 20") != null);2667    try std.testing.expect(std.mem.indexOf(u8, content, "128 B") != null);2668    try std.testing.expect(2669        std.mem.indexOf(u8, content, "Digest-bound source") != null,2670    );2671    try std.testing.expect(std.mem.indexOf(u8, content, "abababababab") != null);2672}26732674test "page renders benchmark process reduction evidence" {2675    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);2676    defer arena_state.deinit();2677    const allocator = arena_state.allocator();2678    const identity = profiling.fingerprint.File{2679        .bytes = 42,2680        .sha256 = @splat(0xab),2681    };2682    const sources = [_]profiling.reduction.Source{2683        .{2684            .execution_index = 1,2685            .acquisition_position = 2,2686            .structured_bench_path = "one/bench.jsonl",2687            .bench_jsonl = .{ .path = "one/bench.jsonl", .identity = identity },2688            .structured = .{ .path = "one/structured.jsonl", .identity = identity },2689        },2690        .{2691            .execution_index = 2,2692            .acquisition_position = 5,2693            .structured_bench_path = "two/bench.jsonl",2694            .bench_jsonl = .{ .path = "two/bench.jsonl", .identity = identity },2695            .structured = .{ .path = "two/structured.jsonl", .identity = identity },2696        },2697    };2698    const samples = [_]u64{ 10, 20 };2699    const counts = [_]u32{ 4, 4 };2700    const benchmarks = [_]profiling.reduction.Benchmark{.{2701        .key = "5:suite4:parse",2702        .suite = "suite",2703        .id = "parse",2704        .allocation_attribution = .sample_call,2705        .sample_ns = &samples,2706        .inner_sample_count = &counts,2707        .statistics = .{2708            .min_ns = 10,2709            .max_ns = 20,2710            .mean_ns = 15,2711            .median_ns = 20,2712            .p75_ns = 20,2713            .p95_ns = 20,2714            .p99_ns = 20,2715            .total_ns = 30,2716            .median_interval = .{ .low_ns = 10, .high_ns = 20 },2717        },2718        .allocation_maxima = .{2719            .alloc_count = 4,2720            .free_count = 4,2721            .alloc_bytes = 128,2722            .alloc_count_per_eval = 1,2723            .free_count_per_eval = 1,2724            .alloc_bytes_per_eval = 32,2725        },2726    }};2727    const row = analyze.Workload{2728        .name = "w",2729        .package = "p",2730        .step = "bench",2731        .status = "passed",2732        .exit_code = 0,2733        .wall_ns = 10,2734        .benchmark_process_reduction = .{ .complete = .{2735            .sources = &sources,2736            .benchmarks = &benchmarks,2737        } },2738        .result_path = null,2739    };2740    var html = Html{ .allocator = allocator };2741    try workloadBenchmarkReduction(&html, allocator, &row);2742    try expectBenchmarkReductionContent(try html.take());2743}27442745test "page renders unmeasured warmup metadata" {2746    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);2747    defer arena_state.deinit();2748    const allocator = arena_state.allocator();2749    const row = analyze.Workload{2750        .name = "w",2751        .package = "p",2752        .step = "bench",2753        .status = "passed",2754        .exit_code = 0,2755        .wall_ns = 10,2756        .warmup_count = 2,2757        .warmup_total_wall_ns = 12,2758        .warmup_distribution = .{2759            .kind = .raw_executions,2760            .sample_count = 2,2761            .mean_ns = 6,2762            .min_ns = 5,2763            .median_ns = 6,2764            .max_ns = 7,2765        },2766        .max_rss_kib = null,2767        .user_s = null,2768        .system_s = null,2769        .result_path = null,2770    };2771    var html = Html{ .allocator = allocator };2772    try workloadWarmupMetadata(&html, allocator, &row);2773    const content = try html.take();2774    try std.testing.expect(std.mem.indexOf(u8, content, "unmeasured warmups") != null);2775    try std.testing.expect(std.mem.indexOf(u8, content, "last warmup execution") != null);2776    try std.testing.expect(std.mem.indexOf(u8, content, "warmup wall median") != null);2777    try std.testing.expect(std.mem.indexOf(u8, content, "warmup wall range") != null);2778}27792780test "page renders waited-command scheduler and fault resources" {2781    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);2782    defer arena_state.deinit();2783    const allocator = arena_state.allocator();2784    const row = analyze.Workload{2785        .name = "w",2786        .package = "p",2787        .step = "bench",2788        .status = "passed",2789        .exit_code = 0,2790        .wall_ns = std.time.ns_per_s,2791        .resource_usage_source = .wait4_rusage,2792        .minor_page_faults = 96,2793        .major_page_faults = 1,2794        .voluntary_context_switches = 2,2795        .involuntary_context_switches = 1,2796        .result_path = null,2797    };2798    var html = Html{ .allocator = allocator };2799    try workloadResourceMetadata(&html, allocator, &row);2800    const content = try html.take();2801    try std.testing.expect(std.mem.indexOf(u8, content, "wait4 rusage") != null);2802    try std.testing.expect(2803        std.mem.indexOf(u8, content, "2.00 voluntary + 1.00 involuntary") != null,2804    );2805    try std.testing.expect(std.mem.indexOf(u8, content, "3.00 process rate") != null);2806    try std.testing.expect(std.mem.indexOf(u8, content, "96.00 minor + 1.00 major") != null);2807    try std.testing.expect(std.mem.indexOf(u8, content, "97.00 process rate") != null);2808}28092810test "page renders exact workload acquisition context" {2811    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);2812    defer arena_state.deinit();2813    const allocator = arena_state.allocator();2814    var html = Html{ .allocator = allocator };2815    try workloadAcquisitionMetadata(&html, allocator, .{ .blocked = .{2816        .position = 3,2817        .workload_count = 4,2818        .predecessors = &.{ "a", "b" },2819    } });2820    const content = try html.take();2821    try std.testing.expect(std.mem.indexOf(u8, content, "acquisition position") != null);2822    try std.testing.expect(std.mem.indexOf(u8, content, "3 of 4") != null);2823    try std.testing.expect(std.mem.indexOf(u8, content, "a → b") != null);2824    try std.testing.expectEqualStrings(2825        "blocked 3/4 after [a, b]",2826        try acquisitionLabel(allocator, .{ .blocked = .{2827            .position = 3,2828            .workload_count = 4,2829            .predecessors = &.{ "a", "b" },2830        } }),2831    );2832}28332834test "page renders exact interleaved acquisition context" {2835    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);2836    defer arena_state.deinit();2837    const allocator = arena_state.allocator();2838    const acquisition = profiling.order.Context{ .random_interleaved = .{2839        .seed = 42,2840        .repeat_count = 3,2841        .workload_count = 2,2842        .selected_workloads = &.{ "a", "b" },2843        .positions = &.{ 1, 3, 6 },2844    } };2845    var html = Html{ .allocator = allocator };2846    try workloadAcquisitionMetadata(&html, allocator, acquisition);2847    const content = try html.take();2848    try std.testing.expect(std.mem.indexOf(u8, content, "random_interleaved") != null);2849    try std.testing.expect(std.mem.indexOf(u8, content, "xoshiro256") != null);2850    try std.testing.expect(std.mem.indexOf(u8, content, "interleave seed") != null);2851    try std.testing.expect(std.mem.indexOf(u8, content, "42") != null);2852    try std.testing.expect(std.mem.indexOf(u8, content, "a → b") != null);2853    try std.testing.expect(std.mem.indexOf(u8, content, "1, 3, 6") != null);2854    try std.testing.expectEqualStrings(2855        "interleaved 3x/2, positions [1, 3, 6]",2856        try acquisitionLabel(allocator, acquisition),2857    );2858}28592860test "page renders fixed versus random acquisition diagnostic and limits" {2861    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);2862    defer arena_state.deinit();2863    const allocator = arena_state.allocator();2864    const random_acquisition = profiling.order.Context{ .random_interleaved = .{2865        .seed = 42,2866        .repeat_count = 3,2867        .workload_count = 2,2868        .selected_workloads = &.{ "a", "b" },2869        .positions = &.{ 1, 3, 6 },2870    } };2871    const rows = [_]analysis.OrderEffectRow{.{2872        .workload = "a",2873        .fixed_acquisition = .{ .blocked = .{2874            .position = 1,2875            .workload_count = 2,2876        } },2877        .random_acquisition = random_acquisition,2878        .fixed_count = 3,2879        .random_count = 3,2880        .fixed_mean_ns = 100,2881        .random_mean_ns = 130,2882        .mean_percent_change = 30,2883        .effect_low_percent = 20,2884        .effect_high_percent = 40,2885        .classification = "order_sensitive_candidate",2886    }};2887    const effects = analysis.OrderEffects{2888        .support = .{ .state = "supported", .supported = true },2889        .status = "order_sensitive_candidate",2890        .fixed_run_id = "fixed",2891        .random_run_id = "random",2892        .fixed_is_baseline = true,2893        .supports_ordersage_test = false,2894        .reset_policy = "none_recorded",2895        .effect_method = "bootstrap",2896        .effect_confidence_per_mille = 950,2897        .order_sensitive_workloads = 1,2898        .limits = &.{ "one unreset pair", "absence is not proved" },2899        .rows = &rows,2900    };2901    var html = Html{ .allocator = allocator };2902    try orderEffectsTable(&html, allocator, effects);2903    const content = try html.take();2904    try std.testing.expect(std.mem.indexOf(2905        u8,2906        content,2907        "Fixed vs random acquisition diagnostic",2908    ) != null);2909    try std.testing.expect(std.mem.indexOf(u8, content, "order sensitive candidate") != null);2910    try std.testing.expect(std.mem.indexOf(u8, content, "blocked 1/2") != null);2911    try std.testing.expect(std.mem.indexOf(u8, content, "positions [1, 3, 6]") != null);2912    try std.testing.expect(std.mem.indexOf(u8, content, "+30.0%") != null);2913    try std.testing.expect(std.mem.indexOf(u8, content, "one unreset pair") != null);2914    try std.testing.expect(std.mem.indexOf(u8, content, "absence is not proved") != null);2915}29162917test "page renders failed warmup acquisition as not measured" {2918    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);2919    defer arena_state.deinit();2920    const allocator = arena_state.allocator();2921    const rows = [_]analyze.Workload{.{2922        .name = "w",2923        .package = "p",2924        .step = "bench",2925        .status = "failed",2926        .exit_code = 9,2927        .wall_ns = 0,2928        .total_wall_ns = 0,2929        .execution_count = 0,2930        .warmup_count = 1,2931        .warmup_total_wall_ns = 7,2932        .warmup_distribution = .{2933            .kind = .raw_executions,2934            .sample_count = 1,2935            .mean_ns = 7,2936            .min_ns = 7,2937            .median_ns = 7,2938            .max_ns = 7,2939        },2940        .max_rss_kib = 4,2941        .user_s = null,2942        .system_s = null,2943        .result_path = null,2944    }};2945    const entry = model.Entry{2946        .dir = "run",2947        .root = "run",2948        .manifest = .{2949            .run_id = "run",2950            .started_unix_ns = 0,2951            .wall_ns = null,2952            .suite = "smoke",2953            .git_sha = null,2954            .git_branch = null,2955            .git_dirty = null,2956            .zig_version = null,2957            .optimize = null,2958            .host = .{},2959        },2960        .run = .{2961            .ref = .{2962                .run_id = "run",2963                .root = "run",2964                .manifest_path = "run/manifest.json",2965                .results_path = "run/results.jsonl",2966            },2967            .workloads = &rows,2968        },2969        .recorded = null,2970    };2971    var table = Html{ .allocator = allocator };2972    try runWorkloads(&table, allocator, &entry);2973    const table_content = try table.take();2974    try std.testing.expect(std.mem.indexOf(u8, table_content, "point estimate") == null);2975    const content = try workload(2976        allocator,2977        .{ .runs = &.{}, .histories = &.{} },2978        &entry,2979        &rows[0],2980        .{},2981    );2982    try std.testing.expect(std.mem.indexOf(u8, content, "mean wall</dt><dd>not measured") != null);2983    try std.testing.expect(std.mem.indexOf(u8, content, "wall sample shape") == null);2984    try std.testing.expect(std.mem.indexOf(u8, content, "measurement executions</dt><dd>0") != null);2985}29862987test "page renders matched capture perturbation evidence apart from priority" {2988    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);2989    defer arena_state.deinit();2990    const allocator = arena_state.allocator();2991    const pairs = [_]profiling.perturbation.Pair{2992        .{ .index = 1, .order = .control_first, .control = .{ .exit_code = 0, .wall_ns = 10 }, .capture = .{ .exit_code = 0, .wall_ns = 11 } },2993        .{ .index = 2, .order = .capture_first, .control = .{ .exit_code = 0, .wall_ns = 10 }, .capture = .{ .exit_code = 0, .wall_ns = 13 } },2994    };2995    const measurement = profiling.perturbation.Measurement{2996        .state = .complete,2997        .base_seed = 7,2998        .workload_seed = 8,2999        .pairs = &pairs,3000        .configuration = .{ .tracy = true },3001        .control_artifacts = .{3002            .stdout = "",3003            .stderr = "",3004            .bench_jsonl = "",3005            .coz_jsonl = "",3006            .coz_analysis = "",3007            .tracy_jsonl = "",3008            .tracy_summary = "",3009            .allocations = "",3010            .structured = "",3011        },3012    };3013    const row = analyze.Workload{3014        .name = "w",3015        .package = "p",3016        .step = "bench",3017        .status = "passed",3018        .exit_code = 0,3019        .wall_ns = 12,3020        .max_rss_kib = null,3021        .user_s = null,3022        .system_s = null,3023        .result_path = null,3024        .capture_perturbation = measurement,3025        .capture_perturbation_summary = try profiling.perturbation.summarize(3026            allocator,3027            measurement,3028            "w",3029        ),3030    };3031    var html = Html{ .allocator = allocator };3032    try workloadCapturePerturbation(&html, allocator, &row);3033    const content = try html.take();3034    try std.testing.expect(std.mem.indexOf(u8, content, "Capture perturbation") != null);3035    try std.testing.expect(std.mem.indexOf(u8, content, "not product-regression priority evidence") != null);3036    try std.testing.expect(std.mem.indexOf(u8, content, "95% paired effect") != null);3037    try std.testing.expect(std.mem.indexOf(u8, content, "active Tracy capture") != null);3038    try std.testing.expect(std.mem.indexOf(u8, content, "+20.00%") != null);3039    try std.testing.expect(std.mem.indexOf(u8, content, "control first") != null);3040    try std.testing.expect(std.mem.indexOf(u8, content, "capture first") != null);3041}30423043test "page renders explicitly ordered timing samples as a sequence" {3044    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);3045    defer arena_state.deinit();3046    const allocator = arena_state.allocator();3047    const samples = [_]u64{ 30, 10, 20 };3048    const metrics = [_]profiling.metric.Metric{.{3049        .workload = "w",3050        .key = "duration",3051        .label = "duration",3052        .source_kind = "bench_jsonl",3053        .source_path = "bench.jsonl",3054        .source_line = 1,3055        .sample_count = 3,3056        .mean_ns = 20,3057        .median_ns = 20,3058        .p75_ns = 30,3059        .p95_ns = 30,3060        .p99_ns = 30,3061        .min_ns = 10,3062        .max_ns = 30,3063        .mean_interval = null,3064        .median_interval = .{ .low_ns = 10, .high_ns = 30 },3065        .p95_interval = null,3066        .p99_interval = null,3067        .samples_ns = &samples,3068        .sample_sequence = .{ .order = .measured_acquisition_order, .index_origin = 0 },3069        .distribution = .confidence_interval,3070    }};3071    const row = analyze.Workload{3072        .name = "w",3073        .package = "p",3074        .step = "bench",3075        .status = "passed",3076        .exit_code = 0,3077        .wall_ns = 60,3078        .result_path = null,3079        .metrics = &metrics,3080    };3081    var html = Html{ .allocator = allocator };3082    try workloadTiming(&html, allocator, .{ .runs = &.{}, .histories = &.{} }, &row);3083    const content = try html.take();3084    try std.testing.expect(std.mem.indexOf(u8, content, "chart-sequence-figure") != null);3085    try std.testing.expect(std.mem.indexOf(u8, content, "sample 0: 30 ns") != null);3086    try std.testing.expect(std.mem.indexOf(u8, content, "sample 1: 10 ns") != null);3087    try std.testing.expect(std.mem.indexOf(u8, content, "acquisition indices") != null);3088    try std.testing.expect(std.mem.indexOf(u8, content, "chart-strip-figure") == null);3089}30903091test "page run and workload render tables" {3092    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);3093    defer arena_state.deinit();3094    const allocator = arena_state.allocator();3095    const profiling_dir = ".zig-cache/profile-web-page-run-test";3096    defer sys.fs.deleteTree(profiling_dir) catch {};3097    try model.writeTestFixture(allocator, profiling_dir);3098    const site = try model.load(allocator, profiling_dir);3099    const entry = site.latest().?;31003101    const run_content = try run(allocator, entry, true);3102    try std.testing.expect(std.mem.indexOf(u8, run_content, "run-200-bbb") != null);3103    try std.testing.expect(std.mem.indexOf(u8, run_content, "memory.html") != null);3104    try std.testing.expect(std.mem.indexOf(u8, run_content, "workloads/gpalloc.allocator.html") != null);3105    try std.testing.expect(std.mem.indexOf(u8, run_content, "badge-passed") != null);3106    try std.testing.expect(std.mem.indexOf(u8, run_content, "cellbar") != null);3107    try std.testing.expect(std.mem.indexOf(u8, run_content, "wall samples") != null);3108    try std.testing.expect(std.mem.indexOf(u8, run_content, "warmups") != null);3109    try std.testing.expect(std.mem.indexOf(u8, run_content, "raw executions") != null);3110    try std.testing.expect(std.mem.indexOf(u8, run_content, "process placement") != null);3111    try std.testing.expect(std.mem.indexOf(u8, run_content, "CPUs 0-15, memory nodes 0") != null);3112    try std.testing.expect(std.mem.indexOf(u8, run_content, "frequency policy") != null);3113    try std.testing.expect(std.mem.indexOf(u8, run_content, "policy-a") != null);31143115    const workload_row = entry.findWorkload("gpalloc.allocator").?;3116    const workload_content = try workload(allocator, site, entry, workload_row, try flame.sources(allocator, workload_row));3117    try std.testing.expect(std.mem.indexOf(u8, workload_content, "Timing metrics") != null);3118    try std.testing.expect(std.mem.indexOf(u8, workload_content, "1.2 µs") != null);3119    try std.testing.expect(std.mem.indexOf(u8, workload_content, "Memory metrics") != null);3120    try std.testing.expect(std.mem.indexOf(u8, workload_content, "4 KiB") != null);3121    try std.testing.expect(std.mem.indexOf(u8, workload_content, "wall sample shape") != null);3122    try std.testing.expect(std.mem.indexOf(u8, workload_content, "chart-strip-figure") != null);3123    try std.testing.expect(std.mem.indexOf(u8, workload_content, "Flame graphs") != null);3124    try std.testing.expect(std.mem.indexOf(u8, workload_content, "gpalloc.allocator.flame.html#offcpu") != null);31253126    const flame_sources = try flame.sources(allocator, workload_row);3127    const flame_content = try flamePage(allocator, site, entry, workload_row, flame_sources);3128    try std.testing.expect(std.mem.indexOf(u8, flame_content, "id=\"cpu\"") != null);3129    try std.testing.expect(std.mem.indexOf(u8, flame_content, "id=\"offcpu\"") != null);3130    try std.testing.expect(std.mem.indexOf(u8, flame_content, "data-zw=\"10\"") != null);3131    try std.testing.expect(std.mem.indexOf(u8, flame_content, "callchain-quality") != null);3132    try std.testing.expect(std.mem.indexOf(u8, flame_content, "10 extracted · 10 reported") != null);3133    try std.testing.expect(std.mem.indexOf(u8, flame_content, "3.2 mean · 4 max") != null);3134    try std.testing.expect(std.mem.indexOf(u8, flame_content, "81.25%") != null);3135    try std.testing.expect(std.mem.indexOf(u8, flame_content, "6 · 60.00%") != null);3136    try std.testing.expect(std.mem.indexOf(u8, flame_content, "<script>") != null);3137    try std.testing.expect(std.mem.indexOf(u8, flame_content, "id=\"cpu-diff\"") != null);3138    try std.testing.expect(std.mem.indexOf(u8, flame_content, "On-CPU change vs run-100-aaa") != null);3139    try std.testing.expect(std.mem.indexOf(u8, flame_content, "pp vs baseline") != null);3140    try std.testing.expect(std.mem.indexOf(u8, flame_content, "Hot symbols") != null);3141    try std.testing.expect(std.mem.indexOf(u8, flame_content, "88.50%") != null);3142    try std.testing.expect(std.mem.indexOf(u8, flame_content, "Hot source lines") != null);3143    try std.testing.expect(std.mem.indexOf(u8, flame_content, "heap.zig:212") != null);31443145    const memory_report = try profiling.report.memory.load(allocator, .{ .input = entry.root, .top = 25 });3146    try std.testing.expectEqual(@as(usize, 1), memory_report.totals.traced_workloads);3147    const memory_content = try memoryPage(allocator, entry, memory_report);3148    try std.testing.expect(std.mem.indexOf(u8, memory_content, "memory accountability") != null);3149    try std.testing.expect(std.mem.indexOf(u8, memory_content, "root/refill") != null);3150    try std.testing.expect(std.mem.indexOf(u8, memory_content, "4 KiB") != null);3151    try std.testing.expect(std.mem.indexOf(u8, memory_content, "coverage") != null);3152    try std.testing.expect(std.mem.indexOf(u8, memory_content, "integrity complete") != null);3153}31543155test "flame page explains missing historical callchain quality" {3156    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);3157    defer arena_state.deinit();3158    const allocator = arena_state.allocator();3159    var html = Html{ .allocator = allocator };3160    try callchainQuality(&html, allocator, .{});3161    const content = try html.take();3162    try std.testing.expect(std.mem.indexOf(3163        u8,3164        content,3165        "Callchain quality was not recorded for this capture.",3166    ) != null);3167}