tiny.profiling.report.flame

1const std = @import("std");2const capture = @import("capture");3const sys = @import("sys");4const zen = @import("zen");56const profiling = @import("../root.zig");7const chart = @import("root.zig").chart;8const model = @import("root.zig").model;910const analyze = profiling.analyze;11const host = profiling.host;12const Allocator = std.mem.Allocator;1314const max_folded_bytes = 256 * 1024 * 1024;15const max_summary_bytes = 64 * 1024 * 1024;16const label_char_width = 6.6;17const label_pad = 4;18const min_label_width = 24;1920pub const Stack = struct {21    frames: []const []const u8,22    weight: u64,23};2425pub const Palette = enum {26    warm,27    cool,28};2930pub const Options = struct {31    class: []const u8,32    palette: Palette,33    format: chart.Format,34    unit: []const u8,35    baseline: ?[]const Stack = null,36    width: f64 = 1200,37    row_height: f64 = 17,38    min_fraction: f64 = 0.001,39};4041pub const Sources = struct {42    cpu_folded: ?[]const u8 = null,43    offcpu_summary: ?[]const u8 = null,44    symbols_summary: ?[]const u8 = null,45    children_summary: ?[]const u8 = null,46    srcline_summary: ?[]const u8 = null,4748    pub fn any(self: Sources) bool {49        return self.cpu_folded != null or self.offcpu_summary != null or50            self.symbols_summary != null or self.children_summary != null or51            self.srcline_summary != null;52    }53};5455pub fn sources(allocator: Allocator, row: *const analyze.Workload) !Sources {56    var result = Sources{};57    for (row.captures) |row_capture| {58        if (!std.mem.eql(u8, row_capture.state, "summary_written")) continue;59        if (std.mem.eql(u8, row_capture.kind, host.sampling.kind)) {60            const dir = std.fs.path.dirname(row_capture.capture_path) orelse continue;61            result.cpu_folded = try existingArtifact(allocator, dir, host.sampling.folded_name);62            result.symbols_summary = try existingArtifact(allocator, dir, host.sampling.symbols_summary_name);63            result.children_summary = try existingArtifact(allocator, dir, host.sampling.children_summary_name);64            result.srcline_summary = try existingArtifact(allocator, dir, host.sampling.srcline_summary_name);65        } else if (std.mem.eql(u8, row_capture.kind, host.offcpu.kind)) {66            if (row_capture.summary_path.len != 0 and sys.fs.exists(row_capture.summary_path)) {67                result.offcpu_summary = row_capture.summary_path;68            }69        }70    }71    return result;72}7374fn existingArtifact(allocator: Allocator, dir: []const u8, name: []const u8) !?[]const u8 {75    const path = try std.fs.path.join(allocator, &.{ dir, name });76    if (sys.fs.exists(path)) return path;77    allocator.free(path);78    return null;79}8081pub const Previous = struct {82    path: []const u8,83    run_id: []const u8,84};8586pub fn previousCpuFolded(87    allocator: Allocator,88    site: model.Site,89    entry: *const model.Entry,90    name: []const u8,91) !?Previous {92    var index = site.runs.len;93    var passed_current = false;94    while (index > 0) {95        index -= 1;96        const candidate = &site.runs[index];97        if (!passed_current) {98            if (candidate == entry) passed_current = true;99            continue;100        }101        if (analyze.comparisonSupport(candidate.run, entry.run) != .supported) continue;102        const workload = candidate.findWorkload(name) orelse continue;103        const found = try sources(allocator, workload);104        if (found.cpu_folded) |path| return .{ .path = path, .run_id = candidate.manifest.run_id };105    }106    return null;107}108109pub fn loadFolded(allocator: Allocator, path: []const u8) ![]Stack {110    const text = sys.fs.readFileAlloc(allocator, path, max_folded_bytes) catch |err| switch (err) {111        error.FileNotFound => return &.{},112        else => |actual| return actual,113    };114    return try parseFolded(allocator, text);115}116117pub fn parseFolded(allocator: Allocator, text: []const u8) ![]Stack {118    var stacks: std.ArrayList(Stack) = .empty;119    var lines = std.mem.splitScalar(u8, text, '\n');120    while (lines.next()) |raw_line| {121        const line = std.mem.trim(u8, raw_line, " \t\r");122        if (line.len == 0) continue;123        const split = std.mem.lastIndexOfScalar(u8, line, ' ') orelse continue;124        const stack_text = std.mem.trimEnd(u8, line[0..split], " \t");125        const weight = std.fmt.parseInt(u64, line[split + 1 ..], 10) catch continue;126        if (stack_text.len == 0) continue;127        var frames: std.ArrayList([]const u8) = .empty;128        var parts = std.mem.splitScalar(u8, stack_text, ';');129        while (parts.next()) |part| {130            if (part.len != 0) try frames.append(allocator, part);131        }132        if (frames.items.len == 0) continue;133        try stacks.append(allocator, .{134            .frames = try frames.toOwnedSlice(allocator),135            .weight = weight,136        });137    }138    return try stacks.toOwnedSlice(allocator);139}140141pub fn loadSymbols(allocator: Allocator, path: []const u8) !?capture.perfreport.SymbolSummary {142    const text = sys.fs.readFileAlloc(allocator, path, max_summary_bytes) catch |err| switch (err) {143        error.FileNotFound => return null,144        else => |actual| return actual,145    };146    return try capture.perfreport.parseSymbolSummaryText(allocator, path, text);147}148149pub fn loadChildren(allocator: Allocator, path: []const u8) !?capture.perfreport.ChildrenSummary {150    const text = sys.fs.readFileAlloc(allocator, path, max_summary_bytes) catch |err| switch (err) {151        error.FileNotFound => return null,152        else => |actual| return actual,153    };154    return try capture.perfreport.parseChildrenSummaryText(allocator, path, text);155}156157pub fn loadSrcline(allocator: Allocator, path: []const u8) !?capture.perfreport.SrclineSummary {158    const text = sys.fs.readFileAlloc(allocator, path, max_summary_bytes) catch |err| switch (err) {159        error.FileNotFound => return null,160        else => |actual| return actual,161    };162    return try capture.perfreport.parseSrclineSummaryText(allocator, path, text);163}164165pub const Blocked = struct {166    stacks: []Stack,167    weight_unit: []const u8,168};169170pub fn loadBlocked(allocator: Allocator, path: []const u8) !?Blocked {171    const text = sys.fs.readFileAlloc(allocator, path, max_summary_bytes) catch |err| switch (err) {172        error.FileNotFound => return null,173        else => |actual| return actual,174    };175    const summary = (capture.offcpu.parseBlockedSummaryText(allocator, path, text) catch return null) orelse return null;176    return .{177        .stacks = try fromBlocked(allocator, summary),178        .weight_unit = summary.weight_unit,179    };180}181182pub fn fromBlocked(allocator: Allocator, summary: capture.offcpu.BlockedSummary) ![]Stack {183    var stacks: std.ArrayList(Stack) = .empty;184    for (summary.rows) |row| {185        if (row.weight == 0) continue;186        var frames: std.ArrayList([]const u8) = .empty;187        if (row.task) |task| {188            try frames.append(allocator, task);189            try frames.appendSlice(allocator, row.frames);190        } else {191            try frames.append(allocator, row.stack_kind);192            var index = row.frames.len;193            while (index > 0) {194                index -= 1;195                try frames.append(allocator, row.frames[index]);196            }197        }198        try stacks.append(allocator, .{199            .frames = try frames.toOwnedSlice(allocator),200            .weight = row.weight,201        });202    }203    return try stacks.toOwnedSlice(allocator);204}205206const Node = struct {207    name: []const u8,208    total: u64 = 0,209    self: u64 = 0,210    base: u64 = 0,211    children: std.StringArrayHashMapUnmanaged(*Node) = .empty,212};213214const Side = enum {215    candidate,216    baseline,217};218219fn addStack(allocator: Allocator, node: *Node, frames: []const []const u8, weight: u64, side: Side) !void {220    switch (side) {221        .candidate => node.total += weight,222        .baseline => node.base += weight,223    }224    if (frames.len == 0) {225        if (side == .candidate) node.self += weight;226        return;227    }228    const slot = try node.children.getOrPut(allocator, frames[0]);229    if (!slot.found_existing) {230        const child = try allocator.create(Node);231        child.* = .{ .name = frames[0] };232        slot.value_ptr.* = child;233    }234    try addStack(allocator, slot.value_ptr.*, frames[1..], weight, side);235}236237fn sortedChildren(allocator: Allocator, node: *const Node) ![]*Node {238    const children = try allocator.dupe(*Node, node.children.values());239    std.mem.sort(*Node, children, {}, childBefore);240    return children;241}242243fn childBefore(_: void, left: *Node, right: *Node) bool {244    if (left.total == right.total) return std.mem.lessThan(u8, left.name, right.name);245    return left.total > right.total;246}247248fn prunedDepth(allocator: Allocator, node: *const Node, depth: usize, min_weight: u64) !usize {249    var deepest = depth;250    for (try sortedChildren(allocator, node)) |child| {251        if (child.total < min_weight) continue;252        deepest = @max(deepest, try prunedDepth(allocator, child, depth + 1, min_weight));253    }254    return deepest;255}256257pub fn render(allocator: Allocator, stacks: []const Stack, options: Options) ![]u8 {258    var out: std.ArrayList(u8) = .empty;259    var root = Node{ .name = "all" };260    for (stacks) |stack| try addStack(allocator, &root, stack.frames, stack.weight, .candidate);261    if (options.baseline) |baseline| {262        for (baseline) |stack| try addStack(allocator, &root, stack.frames, stack.weight, .baseline);263    }264265    if (root.total == 0) {266        try appendFmt(&out, allocator, "<svg class=\"flame {s}\" viewBox=\"0 0 {d:.0} 40\" width=\"100%\" role=\"img\">", .{ options.class, options.width });267        try appendFmt(&out, allocator, "<text class=\"chart-empty\" x=\"{d:.0}\" y=\"24\" text-anchor=\"middle\">no stacks recorded</text></svg>", .{options.width / 2});268        return try out.toOwnedSlice(allocator);269    }270271    const min_fraction_weight: f64 = @as(f64, @floatFromInt(root.total)) * options.min_fraction;272    const min_weight: u64 = @max(1, @as(u64, @intFromFloat(min_fraction_weight)));273    const depth = try prunedDepth(allocator, &root, 0, min_weight);274    const height = @as(f64, @floatFromInt(depth + 1)) * options.row_height + 2;275276    try appendFmt(&out, allocator, "<svg class=\"flame {s}\" viewBox=\"0 0 {d:.0} {d:.0}\" width=\"100%\" data-w=\"{d:.0}\" data-zs=\"0\" data-zw=\"{d}\" role=\"img\">", .{277        options.class,278        options.width,279        height,280        options.width,281        root.total,282    });283    const context = Emit{284        .allocator = allocator,285        .out = &out,286        .options = options,287        .total = root.total,288        .base_total = if (options.baseline != null) root.base else null,289        .max_shift = if (options.baseline != null) maxShift(allocator, &root, root.total, root.base, min_weight) catch 0 else 0,290        .min_weight = min_weight,291        .height = height,292    };293    try emitNode(context, &root, 0, 0);294    try out.appendSlice(allocator, "</svg>");295    return try out.toOwnedSlice(allocator);296}297298const Emit = struct {299    allocator: Allocator,300    out: *std.ArrayList(u8),301    options: Options,302    total: u64,303    base_total: ?u64,304    max_shift: f64,305    min_weight: u64,306    height: f64,307};308309fn shareShift(node: *const Node, total: u64, base_total: u64) f64 {310    const candidate_share = @as(f64, @floatFromInt(node.total)) / @as(f64, @floatFromInt(total));311    const base_share = if (base_total == 0) 0 else @as(f64, @floatFromInt(node.base)) / @as(f64, @floatFromInt(base_total));312    return (candidate_share - base_share) * 100;313}314315fn maxShift(allocator: Allocator, node: *const Node, total: u64, base_total: u64, min_weight: u64) !f64 {316    var largest: f64 = 0;317    for (try sortedChildren(allocator, node)) |child| {318        if (child.total < min_weight) continue;319        largest = @max(largest, @abs(shareShift(child, total, base_total)));320        largest = @max(largest, try maxShift(allocator, child, total, base_total, min_weight));321    }322    return largest;323}324325fn emitNode(context: Emit, node: *const Node, depth: usize, offset: u64) !void {326    const options = context.options;327    const total: f64 = @floatFromInt(context.total);328    const weight: f64 = @floatFromInt(node.total);329    const x = @as(f64, @floatFromInt(offset)) / total * options.width;330    const width = weight / total * options.width;331    const y = context.height - @as(f64, @floatFromInt(depth + 1)) * options.row_height - 1;332    const shift: ?f64 = if (context.base_total) |base_total| shareShift(node, context.total, base_total) else null;333    const color = if (shift) |actual| shiftColor(actual, context.max_shift) else frameColor(node.name, options.palette);334335    try appendFmt(context.out, context.allocator, "<g class=\"ff\" data-s=\"{d}\" data-w=\"{d}\" data-d=\"{d}\">", .{ offset, node.total, depth });336    try appendFmt(context.out, context.allocator, "<rect x=\"{d:.2}\" y=\"{d:.2}\" width=\"{d:.2}\" height=\"{d:.2}\" fill=\"rgb({d},{d},{d})\"/>", .{337        x,338        y,339        width,340        options.row_height - 1,341        color[0],342        color[1],343        color[2],344    });345    try context.out.appendSlice(context.allocator, "<title>");346    try appendEscaped(context.out, context.allocator, node.name);347    const value = try options.format(context.allocator, weight);348    const percent = weight / total * 100;349    try appendFmt(context.out, context.allocator, " \u{2014} {s} {s} ({d:.1}%)", .{ value, options.unit, percent });350    if (shift) |actual| {351        try appendFmt(context.out, context.allocator, ", {s}{d:.1}pp vs baseline", .{ if (actual >= 0) "+" else "", actual });352    }353    try context.out.appendSlice(context.allocator, "</title>");354    try appendFmt(context.out, context.allocator, "<text x=\"{d:.2}\" y=\"{d:.2}\">", .{ x + 3, y + options.row_height - 5 });355    if (width >= min_label_width) {356        try appendEscaped(context.out, context.allocator, try fitLabel(context.allocator, node.name, width));357    }358    try context.out.appendSlice(context.allocator, "</text></g>");359360    var child_offset = offset;361    for (try sortedChildren(context.allocator, node)) |child| {362        if (child.total >= context.min_weight) {363            try emitNode(context, child, depth + 1, child_offset);364        }365        child_offset += child.total;366    }367}368369fn fitLabel(allocator: Allocator, name: []const u8, width: f64) ![]const u8 {370    const capacity: usize = @intFromFloat(@max(0, (width - label_pad) / label_char_width));371    if (name.len <= capacity) return name;372    if (capacity < 3) return "";373    var end = capacity - 2;374    while (end > 0 and (name[end] & 0xC0) == 0x80) end -= 1;375    return try std.fmt.allocPrint(allocator, "{s}..", .{name[0..end]});376}377378fn shiftColor(shift_pp: f64, max_shift_pp: f64) [3]u8 {379    const neutral = [3]u8{ 246, 243, 238 };380    if (max_shift_pp <= 0) return neutral;381    const strength = @min(@abs(shift_pp) / max_shift_pp, 1.0);382    const target: [3]u8 = if (shift_pp >= 0) .{ 198, 44, 32 } else .{ 52, 92, 199 };383    var color: [3]u8 = undefined;384    for (&color, neutral, target) |*channel, from, to| {385        const from_f: f64 = @floatFromInt(from);386        const to_f: f64 = @floatFromInt(to);387        channel.* = @intFromFloat(from_f + (to_f - from_f) * strength);388    }389    return color;390}391392fn frameColor(name: []const u8, palette: Palette) [3]u8 {393    const hash = std.hash.Wyhash.hash(0, name);394    const h0: f64 = @floatFromInt(hash & 0xff);395    const h1: f64 = @floatFromInt((hash >> 8) & 0xff);396    const h2: f64 = @floatFromInt((hash >> 16) & 0xff);397    return switch (palette) {398        .warm => .{399            205 + @as(u8, @intFromFloat(h0 / 255 * 50)),400            90 + @as(u8, @intFromFloat(h1 / 255 * 120)),401            30 + @as(u8, @intFromFloat(h2 / 255 * 35)),402        },403        .cool => .{404            60 + @as(u8, @intFromFloat(h0 / 255 * 55)),405            120 + @as(u8, @intFromFloat(h1 / 255 * 70)),406            185 + @as(u8, @intFromFloat(h2 / 255 * 65)),407        },408    };409}410411pub const script =412    "(function () {\n" ++413    "  function refit(svg) {\n" ++414    "    var W = parseFloat(svg.dataset.w);\n" ++415    "    var zs = parseFloat(svg.dataset.zs);\n" ++416    "    var zw = parseFloat(svg.dataset.zw);\n" ++417    "    svg.querySelectorAll('g.ff').forEach(function (g) {\n" ++418    "      var s = parseFloat(g.dataset.s);\n" ++419    "      var w = parseFloat(g.dataset.w);\n" ++420    "      var rect = g.querySelector('rect');\n" ++421    "      var text = g.querySelector('text');\n" ++422    "      if (s + w <= zs || s >= zs + zw) { g.style.display = 'none'; return; }\n" ++423    "      g.style.display = '';\n" ++424    "      var cs = Math.max(s, zs);\n" ++425    "      var ce = Math.min(s + w, zs + zw);\n" ++426    "      var x = (cs - zs) / zw * W;\n" ++427    "      var px = (ce - cs) / zw * W;\n" ++428    "      rect.setAttribute('x', x);\n" ++429    "      rect.setAttribute('width', px);\n" ++430    "      text.setAttribute('x', x + 3);\n" ++431    "      var name = g.querySelector('title').textContent.split(' \\u2014 ')[0];\n" ++432    "      var chars = Math.floor((px - 4) / 6.6);\n" ++433    "      text.textContent = px < 24 || chars < 3 ? '' :\n" ++434    "        (name.length <= chars ? name : name.slice(0, chars - 2) + '..');\n" ++435    "    });\n" ++436    "  }\n" ++437    "  document.addEventListener('click', function (event) {\n" ++438    "    var g = event.target.closest('g.ff');\n" ++439    "    if (!g) return;\n" ++440    "    var svg = g.closest('svg.flame');\n" ++441    "    if (!svg) return;\n" ++442    "    svg.dataset.zs = g.dataset.s;\n" ++443    "    svg.dataset.zw = g.dataset.w;\n" ++444    "    refit(svg);\n" ++445    "  });\n" ++446    "})();\n";447448fn appendFmt(out: *std.ArrayList(u8), allocator: Allocator, comptime fmt: []const u8, args: anytype) Allocator.Error!void {449    const text = try std.fmt.allocPrint(allocator, fmt, args);450    defer allocator.free(text);451    try out.appendSlice(allocator, text);452}453454fn appendEscaped(out: *std.ArrayList(u8), allocator: Allocator, text: []const u8) Allocator.Error!void {455    try zen.html.appendEscaped(out, allocator, text);456}457458fn formatRaw(allocator: Allocator, value: f64) Allocator.Error![]u8 {459    return std.fmt.allocPrint(allocator, "{d:.0}", .{value});460}461462test "flame parses folded stacks and skips junk lines" {463    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);464    defer arena_state.deinit();465    const allocator = arena_state.allocator();466    const stacks = try parseFolded(allocator,467        \\bench;main;inner 3468        \\bench;main;other 1469        \\Tracing enabled470        \\471    );472    try std.testing.expectEqual(@as(usize, 2), stacks.len);473    try std.testing.expectEqual(@as(usize, 3), stacks[0].frames.len);474    try std.testing.expectEqualStrings("bench", stacks[0].frames[0]);475    try std.testing.expectEqualStrings("inner", stacks[0].frames[2]);476    try std.testing.expectEqual(@as(u64, 3), stacks[0].weight);477}478479test "flame render merges prefixes left-heavy with zoom metadata" {480    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);481    defer arena_state.deinit();482    const allocator = arena_state.allocator();483    const stacks = [_]Stack{484        .{ .frames = &.{ "main", "small" }, .weight = 1 },485        .{ .frames = &.{ "main", "big" }, .weight = 3 },486    };487    const svg = try render(allocator, &stacks, .{488        .class = "flame-cpu",489        .palette = .warm,490        .format = formatRaw,491        .unit = "samples",492    });493    try std.testing.expectEqual(@as(usize, 4), std.mem.count(u8, svg, "<g class=\"ff\""));494    try std.testing.expect(std.mem.indexOf(u8, svg, "data-zw=\"4\"") != null);495    try std.testing.expect(std.mem.indexOf(u8, svg, "all \u{2014} 4 samples (100.0%)") != null);496    try std.testing.expect(std.mem.indexOf(u8, svg, "big \u{2014} 3 samples (75.0%)") != null);497    const big = std.mem.indexOf(u8, svg, "data-s=\"0\" data-w=\"3\" data-d=\"2\"").?;498    const small = std.mem.indexOf(u8, svg, "data-s=\"3\" data-w=\"1\" data-d=\"2\"").?;499    try std.testing.expect(big < small);500}501502test "flame render prunes below the minimum fraction" {503    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);504    defer arena_state.deinit();505    const allocator = arena_state.allocator();506    const stacks = [_]Stack{507        .{ .frames = &.{ "main", "hot", "deep" }, .weight = 5000 },508        .{ .frames = &.{ "main", "rare" }, .weight = 1 },509    };510    const svg = try render(allocator, &stacks, .{511        .class = "flame-cpu",512        .palette = .warm,513        .format = formatRaw,514        .unit = "samples",515        .min_fraction = 0.01,516    });517    try std.testing.expect(std.mem.indexOf(u8, svg, ">deep<") != null);518    try std.testing.expect(std.mem.indexOf(u8, svg, "rare") == null);519}520521test "flame render reports empty stacks" {522    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);523    defer arena_state.deinit();524    const allocator = arena_state.allocator();525    const svg = try render(allocator, &.{}, .{526        .class = "flame-offcpu",527        .palette = .cool,528        .format = formatRaw,529        .unit = "events",530    });531    try std.testing.expect(std.mem.indexOf(u8, svg, "no stacks recorded") != null);532}533534test "flame blocked rows keep offcputime order and reverse bpftrace stacks" {535    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);536    defer arena_state.deinit();537    const allocator = arena_state.allocator();538    const rows = [_]capture.offcpu.BlockedRow{539        .{540            .key = "a",541            .source = "offcputime",542            .subclass = "blocking_io",543            .task = "worker",544            .stack_kind = "folded",545            .weight = 7000,546            .weight_unit = "nanoseconds",547            .duration_ns = 7000,548            .frames = &.{ "poll", "epoll_wait" },549        },550        .{551            .key = "b",552            .source = "bpftrace",553            .subclass = "cpu_scheduling",554            .task = null,555            .stack_kind = "kernel",556            .weight = 3,557            .weight_unit = "events",558            .count = 3,559            .frames = &.{ "finish_task_switch", "schedule", "start_thread" },560        },561    };562    const summary = capture.offcpu.BlockedSummary{563        .source_path = "offcpu.summary.json",564        .source = "offcputime",565        .weight_unit = "nanoseconds",566        .total_weight = 7003,567        .rows = &rows,568    };569    const stacks = try fromBlocked(allocator, summary);570    try std.testing.expectEqual(@as(usize, 2), stacks.len);571    try std.testing.expectEqualStrings("worker", stacks[0].frames[0]);572    try std.testing.expectEqualStrings("poll", stacks[0].frames[1]);573    try std.testing.expectEqualStrings("epoll_wait", stacks[0].frames[2]);574    try std.testing.expectEqualStrings("kernel", stacks[1].frames[0]);575    try std.testing.expectEqualStrings("start_thread", stacks[1].frames[1]);576    try std.testing.expectEqualStrings("finish_task_switch", stacks[1].frames[3]);577}578579test "flame diff colors grown frames red and shrunk frames blue" {580    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);581    defer arena_state.deinit();582    const allocator = arena_state.allocator();583    const candidate = [_]Stack{584        .{ .frames = &.{ "main", "grew" }, .weight = 6 },585        .{ .frames = &.{ "main", "shrank" }, .weight = 2 },586    };587    const baseline = [_]Stack{588        .{ .frames = &.{ "main", "grew" }, .weight = 2 },589        .{ .frames = &.{ "main", "shrank" }, .weight = 6 },590        .{ .frames = &.{ "main", "vanished" }, .weight = 4 },591    };592    const svg = try render(allocator, &candidate, .{593        .class = "flame-diff",594        .palette = .warm,595        .format = formatRaw,596        .unit = "samples",597        .baseline = &baseline,598    });599    const grew = std.mem.indexOf(u8, svg, ">grew \u{2014} 6 samples (75.0%), +58.3pp vs baseline<").?;600    const shrank = std.mem.indexOf(u8, svg, ">shrank \u{2014} 2 samples (25.0%), -25.0pp vs baseline<").?;601    try std.testing.expect(grew < shrank);602    try std.testing.expect(std.mem.indexOf(u8, svg, "vanished") == null);603    try std.testing.expect(std.mem.indexOf(u8, svg, "main \u{2014} 8 samples (100.0%), +0.0pp vs baseline") != null);604605    const grew_rect = std.mem.lastIndexOf(u8, svg[0..grew], "fill=\"rgb(").?;606    const grew_color = svg[grew_rect + 10 .. grew_rect + 20];607    try std.testing.expect(std.mem.startsWith(u8, grew_color, "198,44,32"));608    const shrank_rect = std.mem.lastIndexOf(u8, svg[0..shrank], "fill=\"rgb(").?;609    var shrank_channels = std.mem.splitScalar(u8, svg[shrank_rect + 10 ..], ',');610    const red = try std.fmt.parseInt(u16, shrank_channels.next().?, 10);611    try std.testing.expect(red < 198);612}613614test "flame differential baseline requires compatible host context" {615    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);616    defer arena_state.deinit();617    const allocator = arena_state.allocator();618    const profiling_dir = ".zig-cache/profile-flame-host-context-test";619    defer sys.fs.deleteTree(profiling_dir) catch {};620    try model.writeTestFixture(allocator, profiling_dir);621    var site = try model.load(allocator, profiling_dir);622    const latest = &site.runs[1];623    try std.testing.expect(624        try previousCpuFolded(allocator, site, latest, "gpalloc.allocator") != null,625    );626    site.runs[0].run.host.hostname = "bench-b";627    try std.testing.expectEqual(628        @as(?Previous, null),629        try previousCpuFolded(allocator, site, latest, "gpalloc.allocator"),630    );631}632633test "flame labels truncate to the frame width" {634    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);635    defer arena_state.deinit();636    const allocator = arena_state.allocator();637    try std.testing.expectEqualStrings("short", try fitLabel(allocator, "short", 200));638    const truncated = try fitLabel(allocator, "averyverylongsymbolname", 80);639    try std.testing.expect(std.mem.endsWith(u8, truncated, ".."));640    try std.testing.expect(truncated.len < "averyverylongsymbolname".len);641    try std.testing.expectEqualStrings("", try fitLabel(allocator, "abcdef", 10));642}

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