summaryrefslogtreecommitdiff
path: root/anim/src
diff options
context:
space:
mode:
Diffstat (limited to 'anim/src')
-rw-r--r--anim/src/context.zig8
-rw-r--r--anim/src/descent.zig9
-rw-r--r--anim/src/disasm.zig37
-rw-r--r--anim/src/graph.zig1436
-rw-r--r--anim/src/map.zig59
-rw-r--r--anim/src/root.zig10
-rw-r--r--anim/src/theme.zig90
-rw-r--r--anim/src/ties.zig4
8 files changed, 1625 insertions, 28 deletions
diff --git a/anim/src/context.zig b/anim/src/context.zig
index 9829fa7..55ff9d6 100644
--- a/anim/src/context.zig
+++ b/anim/src/context.zig
@@ -44,7 +44,7 @@ pub const legend = blk: {
/// While a `dive` or a `surface` plays (`map.Map`): each working panel's
/// box, and the rect it is drawn into instead, on its way between its
/// window on the map and its place; its tags, rules and lanes how much shown.
-pub const Zoom = struct { box: Rect, to: Rect, chrome: f32 };
+pub const Zoom = struct { box: Rect, to: Rect, chrome: f32, shows: f32 = 1 };
pub var zoomed: [8]?Zoom = @splat(null);
/// How much the thread shows: it fades in (12 f) once a dive has landed, never in a frame.
pub var thread_shows: f32 = 1;
@@ -58,6 +58,7 @@ pub fn at(f: *sk.Frame, placed: anim.Placed, box: Rect) ui.Ui {
const k = zz.to.w / box.w;
p.xf = p.xf.mul(.translate(zz.to.x, zz.to.y)).mul(.scale(k, k)).mul(.translate(-box.x, -box.y));
p.scale *= k;
+ p.pose.opacity *= zz.shows;
// On its way it is opaque, over the panels that set off before it; its tag and rules come in at the end.
const u = (ui.Ui{ .f = f, .at = p }).moved(box.x, box.y);
u.fill(.{ .x = 0, .y = m.tag, .w = box.w, .h = box.h - m.tag }, theme.color.page);
@@ -667,8 +668,9 @@ pub const Stack = struct {
fn watched(now: cursors.Now, slots: usize, age: usize) usize {
const rec = now.rec;
for (age..now.stops.len - 1) |a| {
- const to = (rec.moment(now.stops[a]).regs(rec.tid) catch null) orelse return a;
- const from = (rec.moment(now.stops[a + 1]).regs(rec.tid) catch null) orelse return a;
+ // The index's registers: reading them from the trace was most of a frame's time.
+ const to = rec.registers[@min(now.stops[a], rec.end())];
+ const from = rec.registers[@min(now.stops[a + 1], rec.end())];
if (far(windowAt(now, to, slots, a), windowAt(now, from, slots, a + 1), slots)) return a;
}
return now.stops.len;
diff --git a/anim/src/descent.zig b/anim/src/descent.zig
index d435b59..53d46c5 100644
--- a/anim/src/descent.zig
+++ b/anim/src/descent.zig
@@ -22,6 +22,7 @@ const ties = @import("ties.zig");
const map = @import("map.zig");
const context = @import("context.zig");
const disasm = @import("disasm.zig");
+const graph = @import("graph.zig");
const syscalls = @import("syscalls.zig");
const Stage = @import("stage.zig").Stage;
const theme = ui.theme;
@@ -255,6 +256,8 @@ pub const Descent = struct {
var last_window: ?u8 = null;
const dd: disasm.Disasm = .{ .cursor = d.cursor, .stage = d.stage };
const base: usize = if (going >= 0.5) 0 else 1;
+ // Each window's blocks (`graph`), read once: a rule over each one's first row, its visits where the row has room.
+ var rules: [8]?graph.Rules = @splat(null);
for (placed_items.items) |p| {
const v = u.faded(p.shows);
const y = p.y + p.rise;
@@ -305,7 +308,11 @@ pub const Descent = struct {
}
runs.add(line != null and line.? == current_line, y, y + m.row);
// A row drawn twice (crossfading) counts once for the arguments that hang over the rows under it.
- const hangs = dd.insn(v, now, row, y, box.w, widen0 + wide, line, line != last_line, current_line, lead, state, base, if (p.twin) covered_before > 0 else covered > 0, .{ addrs[0], addrs[n -| 1] }, null);
+ const covers = if (p.twin) covered_before > 0 else covered > 0;
+ const hangs = dd.insn(v, now, row, y, box.w, widen0 + wide, line, line != last_line, current_line, lead, state, base, covers, .{ addrs[0], addrs[n -| 1] }, null);
+ const w = @min(p.item.window, rules.len - 1);
+ if (rules[w] == null) rules[w] = graph.Rules.init(u.f.scratch, rec, now.marks, .{ row.addr, row.addr }, going);
+ rules[w].?.draw(v, row.addr, y, box.w, !covers and !row.outside and !dd.noted(v, now, row, y, state, base, .{ addrs[0], addrs[n -| 1] }, null));
if (!p.twin) covered_before = covered;
covered = if (p.twin) @max(covered, hangs) else @max(covered -| 1, hangs);
last_line = line;
diff --git a/anim/src/disasm.zig b/anim/src/disasm.zig
index 4324b42..282c66e 100644
--- a/anim/src/disasm.zig
+++ b/anim/src/disasm.zig
@@ -19,6 +19,7 @@ const Recording = @import("Recording.zig");
const ties = @import("ties.zig");
const map = @import("map.zig");
const context = @import("context.zig");
+const graph = @import("graph.zig");
const Stage = @import("stage.zig").Stage;
const theme = ui.theme;
const time = theme.time;
@@ -40,6 +41,8 @@ pub const Insn = struct {
line: ?u32 = null,
/// A direct call's callee's parameter count.
params: ?u8 = null,
+ /// A graph's row: its block's head carries the address, the row its offset.
+ bare: bool = false,
/// Its mnemonic, with a prefix that is part of it (`rep stosq`).
pub fn mnemonic(i: Insn) []const u8 {
@@ -98,7 +101,8 @@ pub const Disasm = struct {
u.faded(going).tagNote(box.w, names[1]);
}
const top = body.y + m.pad;
- u.clip(.{ .x = theme.stroke.rule, .y = m.tag, .w = box.w - 2 * theme.stroke.rule, .h = box.h - m.tag - theme.stroke.rule });
+ // The rows' own room: a row going out of the window passes under the padding, its block's rule too.
+ u.clip(.{ .x = theme.stroke.rule, .y = m.tag, .w = box.w - 2 * theme.stroke.rule, .h = box.h - m.tag - m.pad });
defer u.unclip();
// The two windows as one list, if they are of one function: the
@@ -198,6 +202,8 @@ pub const Disasm = struct {
// What the window holds: a jump out of it says where it goes.
const window = [2]u64{ if (merged.len > 0) merged[0].addr else 0, if (merged.len > 0) merged[merged.len - 1].addr else 0 };
const echo = jumpEcho(now, base);
+ // The blocks (`graph`): a rule over each one's first row, its visits where the row has room.
+ const rules = graph.Rules.init(u.f.scratch, rec, now.marks, pc, going);
for (merged, 0..) |row, j| {
const y = top + (@as(f32, @floatFromInt(j)) - scroll) * m.row;
const line = if (row.outside) null else row.line;
@@ -215,7 +221,9 @@ pub const Disasm = struct {
const is_pc = row.addr == pc[if (going >= 0.5) 1 else 0];
const was = if (is_pc) null else ran[j];
if (was) |r| lit.trail(c.mark, y, r.k);
- const hangs = d.insn(lit, now, row, y, box.w, widen, line, line != last_line, current_line, lead, if (is_pc) .current else if (was) |r| .{ .ran = r } else .ahead, base, covered > 0, window, echo);
+ const state: State = if (is_pc) .current else if (was) |r| .{ .ran = r } else .ahead;
+ const hangs = d.insn(lit, now, row, y, box.w, widen, line, line != last_line, current_line, lead, state, base, covered > 0, window, echo);
+ rules.draw(lit, row.addr, y, box.w, covered == 0 and !row.outside and !d.noted(lit, now, row, y, state, base, window, echo));
covered = @max(covered -| 1, hangs);
last_line = if (above_body) null else line;
if (jumped == row.addr and !is_pc) lanes[0] = y;
@@ -268,7 +276,7 @@ pub const Disasm = struct {
u.text(.mono, size, x, base_y, name, t.faint);
return 0;
}
- _ = at.address(c.address, base_y, row.addr, .{ .ink = ui.rgb(code_ink), .lead = lead });
+ if (!row.bare) _ = at.address(c.address, base_y, row.addr, .{ .ink = ui.rgb(code_ink), .lead = lead });
if (first_of_line) if (line) |l| {
const num = u.print("{d}", .{l});
const now_line = l == current_line;
@@ -290,10 +298,15 @@ pub const Disasm = struct {
return if (need.drawn and !covered) d.annotation(u, now, row, y, x, room, state, base, window, echo).hangs else 0;
}
+ /// Whether `row` has an annotation: where it has none, its block's visits may be ranged right.
+ pub fn noted(d: *const Disasm, u: ui.Ui, now: cursors.Now, row: Insn, y: f32, state: State, base: usize, window: [2]u64, echo: ?Echo) bool {
+ return d.annotation(u.faded(0), now, row, y, c.annotation, std.math.inf(f32), state, base, window, echo).drawn;
+ }
+
const Note = struct { drawn: bool = false, end: f32 = 0, hangs: usize = 0 };
/// The row that set the flags a conditional jump reads, while the jump
/// runs: its chips are framed as read with it (an `echo`).
- const Echo = struct { addr: u64, shows: f32 };
+ pub const Echo = struct { addr: u64, shows: f32 };
/// The annotation: what it does, now, from `x`, cut where `room` ends.
/// What it left behind is shown only where the step ran this
@@ -781,7 +794,7 @@ fn flags(u: ui.Ui, x: f32, y: f32, eflags: u64, mask: u16, read: f32) f32 {
/// While a conditional jump runs (the mark on it, its step under way), the
/// row that set the flags it reads: the instruction just before it ran.
-fn jumpEcho(now: cursors.Now, base: usize) ?Disasm.Echo {
+pub fn jumpEcho(now: cursors.Now, base: usize) ?Disasm.Echo {
if (base != 1 or now.resting()) return null;
const flags_ = readsFlags(now.rec, now.stops[1]);
if (flags_ == 0 or now.stops[1] == 0) return null;
@@ -876,13 +889,17 @@ pub fn target(row: Insn) ?u64 {
/// (faint for padding) and its operands as canim draws them, at `y` in `u`
/// (the panel's origin). For the gallery's page of rows.
pub fn plainRow(u: ui.Ui, row: Insn, y: f32) void {
- const base_y = rows.baseline(y);
- _ = u.address(c.address, base_y, row.addr, .{ .ink = ui.rgb(theme.color.region.code_) });
+ _ = u.address(c.address, rows.baseline(y), row.addr, .{ .ink = ui.rgb(theme.color.region.code_) });
// A library's twelve digits move what is right of them, 12 a digit past seven.
- const v = u.moved(@as(f32, @floatFromInt(@max(ui.digits(row.addr), 7) - 7)) * adv, 0);
+ bareRow(u.moved(@as(f32, @floatFromInt(@max(ui.digits(row.addr), 7) - 7)) * adv, 0), row, y);
+}
+
+/// Its mnemonic and operands alone, at their columns (a graph's row, whose head carries the address).
+pub fn bareRow(u: ui.Ui, row: Insn, y: f32) void {
+ const base_y = rows.baseline(y);
const pad = row.padding();
- v.text(.mono_bold, size, c.mnemonic, base_y, row.mnemonic(), if (pad) t.faint else theme.color.code.keyword);
- operands(v, row, shorn(v, row), "", base_y, c.annotation - gap - c.operands, if (pad) t.faint else theme.color.code.plain);
+ u.text(.mono_bold, size, c.mnemonic, base_y, row.mnemonic(), if (pad) t.faint else theme.color.code.keyword);
+ operands(u, row, shorn(u, row), "", base_y, c.annotation - gap - c.operands, if (pad) t.faint else theme.color.code.plain);
}
/// Operands as canim draws them (design/README.md, `insn` and `width`):
diff --git a/anim/src/graph.zig b/anim/src/graph.zig
new file mode 100644
index 0000000..f4e61ea
--- /dev/null
+++ b/anim/src/graph.zig
@@ -0,0 +1,1436 @@
+//! `graph` (design/README.md, "graph"): the disassembly's other form, a
+//! function as its basic blocks with what the run did on them: how often
+//! each was entered, how often each edge was taken, the edges never taken,
+//! the last three taken (the trail), the block the pc is in. Execution
+//! flows down; the one thing that climbs is a loop's back edge.
+//!
+//! `read` takes a function's blocks from the recording (`zt.telescope.blocks`)
+//! and counts the run over them; `place` lays them out, a pure function of
+//! the blocks, their sizes and the counts of the whole recording (so the
+//! picture does not move as the counts grow): back edges by a walk from the
+//! entry in address order, layers by the longest forward path, in a layer
+//! each block under the predecessor that reached it most often (the hot
+//! path straight down), then under the one it falls from, a taken target
+//! to the right; back edges in their loops' lanes on the left, the
+//! outermost farthest out; an edge that would cross a block in the right
+//! channel. `layout` does both for a form (the map's rows, the lens's
+//! shapes), folding what is too big for its place in the catalogue's
+//! order: the runs of blocks the whole recording never reached, then long
+//! blocks. `Blocks` draws it as the `blocks` lens, `Map` with its rows on
+//! the map, `Rules` its blocks on the linear rows; `leave` (and `turn`) is
+//! the step across one edge.
+const std = @import("std");
+const sk = @import("sketch");
+const anim = @import("anim");
+const zt = @import("ztrace");
+const Recording = @import("Recording.zig");
+const ui = @import("ui.zig");
+const rows = @import("rows.zig");
+const cursors = @import("cursor.zig");
+const context = @import("context.zig");
+const disasm = @import("disasm.zig");
+const Stage = @import("stage.zig").Stage;
+const theme = ui.theme;
+const time = theme.time;
+const t = theme.color.text;
+
+pub const End = zt.Debugger.End;
+
+/// A block, or a fold of blocks never reached, and where it is drawn.
+pub const Node = struct {
+ start: u64,
+ len: u64,
+ end: End,
+ /// Where a tail call or a call that does not return goes (null: none, or not known).
+ out: ?u64 = null,
+ /// Its instructions (a fold's: of all its blocks).
+ rows: u32 = 0,
+ /// The rows drawn: a long block folded to its first four, `more` and its last four.
+ shown: u32 = 0,
+ /// How many blocks the whole recording never reached are folded into it (0: a block of its own).
+ folded: u32 = 0,
+ /// Times the run entered it, by the moment the graph is of; and in the whole recording.
+ visits: u32 = 0,
+ reached: bool = false,
+ layer: u32 = 0,
+ col: u32 = 0,
+ x: f32 = 0,
+ y: f32 = 0,
+ w: f32 = 0,
+ h: f32 = 0,
+
+ pub fn contains(n: Node, addr: u64) bool {
+ return addr -% n.start < n.len;
+ }
+};
+
+pub const Kind = enum { fall, taken, jump };
+
+pub const Edge = struct {
+ from: u32,
+ to: u32,
+ kind: Kind,
+ /// Times taken by the moment the graph is of; in the whole recording (what places the blocks).
+ count: u32 = 0,
+ total: u32 = 0,
+ /// To a block at its own layer or above: a loop's turn, in lane `lane` (0 the outermost).
+ back: bool = false,
+ lane: u32 = 0,
+ /// Its way, out of its block's bottom and into its target.
+ points: [6][2]f32 = undefined,
+ n: u8 = 0,
+
+ pub fn path(e: *const Edge) []const [2]f32 {
+ return e.points[0..e.n];
+ }
+
+ /// Its length along its way.
+ pub fn length(e: *const Edge) f32 {
+ var total: f32 = 0;
+ for (e.path()[0 .. e.n -| 1], e.path()[@min(1, e.n)..]) |a, b| total += @abs(b[0] - a[0]) + @abs(b[1] - a[1]);
+ return total;
+ }
+
+ /// The point `d` units along its way, and which way it goes there.
+ pub fn at(e: *const Edge, d: f32) struct { [2]f32, [2]f32 } {
+ var left = @max(d, 0);
+ const pts = e.path();
+ for (pts[0 .. pts.len - 1], pts[1..]) |a, b| {
+ const l = @abs(b[0] - a[0]) + @abs(b[1] - a[1]);
+ const dir = [2]f32{ std.math.sign(b[0] - a[0]), std.math.sign(b[1] - a[1]) };
+ if (left <= l or b[0] == pts[pts.len - 1][0] and b[1] == pts[pts.len - 1][1]) {
+ const f = if (l > 0) @min(left / l, 1) else 1;
+ return .{ .{ a[0] + (b[0] - a[0]) * f, a[1] + (b[1] - a[1]) * f }, dir };
+ }
+ left -= l;
+ }
+ return .{ pts[pts.len - 1], .{ 0, 1 } };
+ }
+};
+
+/// A function's graph at a moment.
+pub const Graph = struct {
+ start: u64,
+ len: u64,
+ nodes: []Node,
+ edges: []Edge,
+ /// The node the pc is in.
+ here: ?u32,
+ /// The last three edges taken, newest first.
+ trail: [3]?u32 = @splat(null),
+ /// Every instruction's text is recorded (a function of up to 2 048).
+ text: bool,
+ /// The recording stops at every instruction: the edges' counts and the trail are known.
+ exact: bool,
+ /// Its size, from its top left (the lanes' side).
+ w: f32 = 0,
+ h: f32 = 0,
+ /// The right channel's x, and how many lanes the back edges take.
+ channel: f32 = 0,
+ lanes: u32 = 0,
+ /// The blocks the function has, before any fold.
+ blocks: usize = 0,
+ /// How far apart the columns are.
+ pitch: f32 = 0,
+
+ pub fn nodeOf(g: Graph, addr: u64) ?u32 {
+ for (g.nodes, 0..) |n, i| if (n.contains(addr)) return @intCast(i);
+ return null;
+ }
+
+ pub fn edgeOf(g: Graph, from: u32, to: u32) ?u32 {
+ for (g.edges, 0..) |e, i| if (e.from == from and e.to == to) return @intCast(i);
+ return null;
+ }
+
+ /// How many blocks the folds hold.
+ pub fn foldedBlocks(g: Graph) usize {
+ var n: usize = 0;
+ for (g.nodes) |node| n += node.folded;
+ return n;
+ }
+};
+
+/// The sizes a form lays its graph out by (design/README.md, `metric.graph`).
+pub const Metric = struct {
+ layer_gap: f32,
+ block_gap: f32,
+ /// Columns are at least this far apart.
+ pitch: f32 = 0,
+ /// Lanes: the first this far in, then this far apart; the blocks this far right of the last.
+ lane_in: f32 = 24,
+ lane: f32,
+ blocks_in: f32,
+ /// The first layer, under the graph's top.
+ top: f32,
+ /// A port this far in from its block's side; arrivals into one top this far apart.
+ port: f32,
+ arrivals: f32,
+ /// The right channel, right of the widest layer.
+ channel: f32,
+ /// A back edge goes down this far before it turns to its lane, and enters its header this far down.
+ back_down: f32,
+ head_in: f32 = 12,
+ /// Edges sharing a gap run this far apart.
+ track: f32,
+};
+
+/// The disassembly's rows on the map, and the `blocks` lens's shapes.
+pub const Form = enum { map, lens };
+
+pub fn metricOf(form: Form) Metric {
+ const g = theme.metric.graph;
+ return switch (form) {
+ .map => .{ .layer_gap = g.layer_gap, .block_gap = g.block_gap, .pitch = theme.metric.insn.annotation - g.shift + g.note + g.block_gap, .lane = g.lane, .blocks_in = g.lane_in, .top = g.top, .port = g.port, .arrivals = g.arrivals, .channel = g.channel, .back_down = g.back_down, .track = 6 },
+ .lens => .{ .layer_gap = g.lens.layer_gap, .block_gap = g.block_gap, .pitch = g.lens.pitch, .lane = g.lens.lane, .blocks_in = g.lens.blocks_in, .top = g.lens.top, .port = g.lens.port, .arrivals = g.lens.port, .channel = g.lens.channel, .back_down = g.lens.back_down, .track = 4 },
+ };
+}
+
+// ---------------------------------------------------------------- reading
+
+/// The graph of the function that holds `pc`, at moment `i`: its blocks
+/// (padding no edge reaches left out), their edges by how each block ends,
+/// and what the run did on them by then (visits, edge counts, the trail)
+/// and in the whole recording (what it reached; the counts the layout is
+/// by). Unplaced. Null where the recording has no blocks for it.
+pub fn read(arena: std.mem.Allocator, rec: *const Recording, i: u64, pc: u64) ?Graph {
+ return readBlocks(arena, rec, i, pc) catch null;
+}
+
+fn readBlocks(arena: std.mem.Allocator, rec: *const Recording, i: u64, pc: u64) !?Graph {
+ const m = rec.moment(i);
+ const probe = zt.telescope.blocks(m, pc, &.{}) orelse return null;
+ const blocks = try arena.alloc(zt.telescope.Block, probe.count);
+ const found = zt.telescope.blocks(m, pc, blocks) orelse return null;
+ var nodes = try arena.alloc(Node, blocks.len);
+ for (blocks, nodes) |b, *n| n.* = .{ .start = b.start, .len = b.len, .end = b.end, .out = if (b.end == .tail or b.end == .noreturn) b.to else null };
+ // Every instruction's row, where the text is recorded; a block of
+ // padding alone (`nop`s between paths) that nothing goes to is none.
+ var reached_by = try arena.alloc(bool, blocks.len);
+ @memset(reached_by, false);
+ for (blocks) |b| for ([2]?u64{ b.to, b.falls }) |to| if (to) |at| if (blockAt(nodes, at)) |k| {
+ reached_by[k] = true;
+ };
+ var keep: usize = 0;
+ var buf: [256]u8 = undefined;
+ for (nodes, 0..) |*n, k| {
+ var at = n.start;
+ var padding = found.text;
+ while (found.text and at < n.start + n.len) : (n.rows += 1) {
+ const one = rec.instruction(i, at, &buf) orelse break;
+ padding = padding and std.mem.startsWith(u8, one.text, "nop");
+ at += one.len;
+ }
+ if (!found.text or n.rows == 0) n.rows = @intCast(@max(n.len / 4, 1));
+ n.shown = n.rows;
+ if (padding and !reached_by[k] and k > 0) continue;
+ nodes[keep] = n.*;
+ keep += 1;
+ }
+ nodes = nodes[0..keep];
+ var g: Graph = .{ .start = found.start, .len = found.len, .nodes = nodes, .edges = &.{}, .here = blockAt(nodes, pc), .text = found.text, .exact = false, .blocks = keep };
+ var edges: std.ArrayList(Edge) = .empty;
+ for (blocks) |b| {
+ const from = blockAt(nodes, b.start) orelse continue;
+ if (nodes[from].start != b.start) continue;
+ if (b.to) |to| if (b.end == .jump or b.end == .branch) if (blockAt(nodes, to)) |at| try edges.append(arena, .{ .from = from, .to = at, .kind = if (b.end == .jump) .jump else .taken });
+ if (b.falls) |to| if (blockAt(nodes, to)) |at| try edges.append(arena, .{ .from = from, .to = at, .kind = .fall });
+ }
+ g.edges = edges.items;
+ g.exact = stepsEach(rec, g);
+ count(rec, &g, i);
+ return g;
+}
+
+/// Whether the recording stopped at every instruction of the function:
+/// wherever one stop in it follows another in another block, the first was
+/// on the jump that went there, or on the last instruction of a block that
+/// falls into it. (By line a stop is where a line begins.)
+fn stepsEach(rec: *const Recording, g: Graph) bool {
+ var pairs: usize = 0;
+ var k: u64 = 0;
+ while (k + 1 < rec.len()) : (k += 1) {
+ const a = rec.registers[k].rip;
+ const b = rec.registers[k + 1].rip;
+ if (a == b) continue;
+ const from = blockAt(g.nodes, a) orelse continue;
+ const to = blockAt(g.nodes, b) orelse continue;
+ if (from == to and b != g.nodes[to].start) continue;
+ pairs += 1;
+ // A jump, a call of itself, a return into its caller.
+ if (rec.insn_branches[k]) |br| if (br.to == b or br.kind == .jump and !br.taken) continue;
+ const f = g.nodes[from];
+ if (f.end == .fall and b == f.start + f.len) continue;
+ return false;
+ }
+ return pairs > 0;
+}
+
+/// The function's blocks at moment `i` and how often the run had entered
+/// each by then: no rows, no edges. What the linear rows' block rules need.
+pub fn light(arena: std.mem.Allocator, rec: *const Recording, i: u64, pc: u64) ?Graph {
+ const m = rec.moment(i);
+ const probe = zt.telescope.blocks(m, pc, &.{}) orelse return null;
+ const blocks = arena.alloc(zt.telescope.Block, probe.count) catch return null;
+ const found = zt.telescope.blocks(m, pc, blocks) orelse return null;
+ const nodes = arena.alloc(Node, blocks.len) catch return null;
+ for (blocks, nodes) |b, *n| n.* = .{ .start = b.start, .len = b.len, .end = b.end };
+ var g: Graph = .{ .start = found.start, .len = found.len, .nodes = nodes, .edges = &.{}, .here = blockAt(nodes, pc), .text = found.text, .exact = false, .blocks = nodes.len };
+ g.exact = stepsEach(rec, g);
+ count(rec, &g, i);
+ return g;
+}
+
+/// The run over the graph: each block's visits and each edge's count, by
+/// moment `i` and in the whole recording; the blocks it ever reached; the
+/// last three edges taken by `i`. A block is entered at its start (by line,
+/// whenever a stop is in it after one in another block); an edge is
+/// counted where one stop in the function follows another across it (by
+/// instruction only: by line the stops between are not known).
+fn count(rec: *const Recording, g: *Graph, i: u64) void {
+ countBy(rec, g, i, true);
+}
+
+/// `count`; `whole`: the whole recording's too (what it reached, the totals the layout is by).
+fn countBy(rec: *const Recording, g: *Graph, i: u64, whole: bool) void {
+ var prev: ?u32 = null;
+ var prev_pc: u64 = 0;
+ var trail: [3]?u32 = @splat(null);
+ for (rec.registers, 0..) |regs, k| {
+ if (!whole and k > i) break;
+ const pc = regs.rip;
+ if (pc -% g.start >= g.len) continue;
+ const b = blockAt(g.nodes, pc) orelse continue;
+ const n = &g.nodes[b];
+ if (whole) n.reached = true;
+ // The first stop in it (a recording that begins inside it) is an entry too.
+ const entered = prev == null or if (g.exact) pc == n.start and prev_pc != pc else prev.? != b;
+ if (entered) {
+ if (k <= i) n.visits += 1;
+ if (g.exact) if (prev) |p| if (g.edgeOf(p, b)) |e| {
+ if (whole) g.edges[e].total += 1;
+ if (k <= i) {
+ g.edges[e].count += 1;
+ trail = .{ e, trail[0], trail[1] };
+ }
+ };
+ }
+ prev = b;
+ prev_pc = pc;
+ }
+ g.trail = trail;
+}
+
+/// The node holding `addr`, in nodes in address order.
+fn blockAt(nodes: []const Node, addr: u64) ?u32 {
+ var lo: usize = 0;
+ var hi: usize = nodes.len;
+ while (lo < hi) {
+ const mid = (lo + hi) / 2;
+ if (nodes[mid].start <= addr) lo = mid + 1 else hi = mid;
+ }
+ if (lo == 0 or !nodes[lo - 1].contains(addr)) return null;
+ return @intCast(lo - 1);
+}
+
+/// The blocks the whole recording never reached, each connected run of them
+/// (neighbours in address order joined by an edge) one node (`folded` its
+/// blocks, its rows all theirs), the edges to and from them joined. A run
+/// that would make a loop the code does not have (an edge into its middle
+/// from a block its rest cannot reach again) is split there.
+pub fn fold(arena: std.mem.Allocator, g: *Graph) !void {
+ const n = g.nodes.len;
+ // Where a run begins: at every unreached block not joined to the one before it.
+ const begins = try arena.alloc(bool, n);
+ for (begins, 0..) |*b, k| b.* = g.nodes[k].reached or k == 0 or g.nodes[k - 1].reached or !joined(g.*, @intCast(k - 1), @intCast(k));
+ const into = try arena.alloc(u32, n);
+ var folded: Graph = undefined;
+ for (0..8) |_| {
+ folded = try foldRuns(arena, g.*, begins, into);
+ var buf: [1 << 14]u8 = undefined;
+ var fba = std.heap.FixedBufferAllocator.init(&buf);
+ try backEdges(&folded, fba.allocator());
+ var split = false;
+ for (g.edges) |e| {
+ const a = into[e.from];
+ const b = into[e.to];
+ if (a == b or begins[e.to] or folded.nodes[b].folded == 0) continue;
+ const f = folded.edgeOf(a, b) orelse continue;
+ if (!folded.edges[f].back or reaches(g.*, e.to, e.from)) continue;
+ begins[e.to] = true;
+ split = true;
+ }
+ if (!split) break;
+ }
+ g.* = folded;
+}
+
+/// Whether blocks `a` and `b` have an edge between them, either way.
+fn joined(g: Graph, a: u32, b: u32) bool {
+ for (g.edges) |e| if (e.from == a and e.to == b or e.from == b and e.to == a) return true;
+ return false;
+}
+
+/// Whether block `to` can be reached from block `from` along the edges.
+fn reaches(g: Graph, from: u32, to: u32) bool {
+ var buf: [1 << 14]u8 = undefined;
+ var fba = std.heap.FixedBufferAllocator.init(&buf);
+ const seen = fba.allocator().alloc(bool, g.nodes.len) catch return true;
+ @memset(seen, false);
+ var stack: std.ArrayList(u32) = .empty;
+ stack.append(fba.allocator(), from) catch return true;
+ seen[from] = true;
+ while (stack.pop()) |at| {
+ if (at == to) return true;
+ for (g.edges) |e| if (e.from == at and !seen[e.to]) {
+ seen[e.to] = true;
+ stack.append(fba.allocator(), e.to) catch return true;
+ };
+ }
+ return false;
+}
+
+/// `g` with each run of unreached blocks (from a block `begins` to the next) one node; `into` each block's node.
+fn foldRuns(arena: std.mem.Allocator, g: Graph, begins: []const bool, into: []u32) !Graph {
+ var nodes: std.ArrayList(Node) = .empty;
+ for (g.nodes, 0..) |node, k| {
+ if (begins[k]) {
+ into[k] = @intCast(nodes.items.len);
+ var kept = node;
+ if (!node.reached) kept.folded = 1;
+ try nodes.append(arena, kept);
+ continue;
+ }
+ const f = &nodes.items[nodes.items.len - 1];
+ into[k] = @intCast(nodes.items.len - 1);
+ f.len = node.start + node.len - f.start;
+ f.rows += node.rows;
+ f.folded += 1;
+ }
+ for (nodes.items) |*f| if (f.folded > 0) {
+ f.end = .fall;
+ f.out = null;
+ f.shown = 1;
+ };
+ var edges: std.ArrayList(Edge) = .empty;
+ for (g.edges) |e| {
+ const a = into[e.from];
+ const b = into[e.to];
+ if (a == b) continue;
+ const dup = for (edges.items) |*d| {
+ if (d.from == a and d.to == b) break d;
+ } else null;
+ if (dup) |d| {
+ d.count += e.count;
+ d.total += e.total;
+ continue;
+ }
+ var kept = e;
+ kept.from = a;
+ kept.to = b;
+ kept.back = false;
+ try edges.append(arena, kept);
+ }
+ var out = g;
+ out.nodes = nodes.items;
+ out.edges = edges.items;
+ // The trail and the pc's block, renumbered.
+ for (&out.trail) |*tr| if (tr.*) |e| {
+ const old = g.edges[e];
+ tr.* = out.edgeOf(into[old.from], into[old.to]);
+ };
+ if (g.here) |h| out.here = into[h];
+ return out;
+}
+
+/// How far down a graph `room` high is scrolled with the pc in node
+/// `here`: not at all where it fits; else the largest loop the pc's block
+/// is in that fits, in the middle; else the pc's block in the middle.
+pub fn pan(g: Graph, room: f32, m: Metric) f32 {
+ if (g.h <= room) return 0;
+ const h = g.here orelse return 0;
+ const pc = g.nodes[h];
+ var top = pc.y - m.layer_gap / 2;
+ var bottom = pc.y + pc.h + m.layer_gap / 2;
+ var widest: f32 = 0;
+ for (g.edges) |e| if (e.back) {
+ const head = g.nodes[e.to];
+ const tail = g.nodes[e.from];
+ if (pc.layer < head.layer or pc.layer > tail.layer) continue;
+ var lb: f32 = 0;
+ for (g.nodes) |o| if (o.layer >= head.layer and o.layer <= tail.layer) {
+ lb = @max(lb, o.y + o.h);
+ };
+ const lt = head.y - m.layer_gap / 2;
+ lb += m.back_down + m.layer_gap / 2;
+ if (lb - lt <= room and lb - lt > widest) {
+ widest = lb - lt;
+ top = lt;
+ bottom = lb;
+ }
+ };
+ // Whole layers: the top of the one nearest where that would put the view's top.
+ const want = std.math.clamp((top + bottom - room) / 2, 0, g.h - room);
+ var best: f32 = 0;
+ for (g.nodes) |o| {
+ const at = std.math.clamp(o.y - m.top, 0, g.h - room);
+ if (@abs(at - want) < @abs(best - want)) best = at;
+ }
+ return best;
+}
+
+/// The linear rows' blocks (`disasm`, `descent`): a 2-unit rule across
+/// over each block's first row (not its function's), and where the row's
+/// annotation leaves it free the times the run had entered the block,
+/// ranged right, faint (`×11`), crossfading from the moment the mark
+/// leaves to the one it goes to.
+pub const Rules = struct {
+ of: [2]?Graph,
+ going: f32,
+
+ /// The blocks of the functions that hold `pc[0]` at `marks[0]` and `pc[1]` at `marks[1]`, `going` of the way between.
+ pub fn init(arena: std.mem.Allocator, rec: *const Recording, marks: [2]u64, pc: [2]u64, going: f32) Rules {
+ return .{ .of = .{ light(arena, rec, marks[0], pc[0]), light(arena, rec, marks[1], pc[1]) }, .going = going };
+ }
+
+ pub fn draw(r: Rules, u: ui.Ui, addr: u64, y: f32, w: f32, free: bool) void {
+ var visits: [2]?u32 = .{ null, null };
+ for (r.of, &visits) |maybe, *v| if (maybe) |g| if (blockAt(g.nodes, addr)) |k| if (g.nodes[k].start == addr and addr != g.start) {
+ v.* = g.nodes[k].visits;
+ };
+ if (visits[0] == null and visits[1] == null) return;
+ u.fill(.{ .x = theme.stroke.rule, .y = y, .w = w - 2 * theme.stroke.rule, .h = theme.stroke.rule }, theme.color.rule);
+ if (!free) return;
+ const size = theme.size.mono.context;
+ // The count the mark leaves, then the one it goes to; one that does not change, once.
+ const same = (visits[0] orelse 0) == (visits[1] orelse 0);
+ for (visits, [2]f32{ 1 - r.going, r.going }, 0..) |v, shows, k| {
+ const n = v orelse 0;
+ if (n == 0 or (same and k == 0)) continue;
+ const text = u.print("\u{00d7}{d}", .{n});
+ u.faded(if (same) 1 else shows).text(.mono, size, w - theme.metric.context.side - u.width(.mono, size, text), rows.baseline(y), text, theme.color.text.faint);
+ }
+ }
+};
+
+// ---------------------------------------------------------------- layout
+
+/// The graph of the pc's function at moment `i`, laid out for `form` in a
+/// place `room` high: folded first where it does not fit (the runs never
+/// reached, then long blocks: over 16 rows, their first four and last
+/// four, unless the pc is in it). Sizes from the form (`sizes`).
+/// shortcut: a loop the pc is not in and will not enter again is not folded, and nothing pans: a graph still too tall runs past its place.
+pub fn layout(arena: std.mem.Allocator, rec: *const Recording, i: u64, pc: u64, form: Form, room: f32) ?Graph {
+ const start = (zt.telescope.blocks(rec.moment(i), pc, &.{}) orelse return null).start;
+ for (memo) |maybe| if (maybe) |k| if (k.rec == rec and k.start == start and k.form == form and k.room == room) {
+ const here = blockAt(k.g.nodes, pc);
+ const spare: ?u32 = if (here) |h| (if (k.g.nodes[h].rows > theme.metric.graph.long) h else null) else null;
+ if (!k.long or spare == k.spared) return recount(arena, rec, k.g, i, pc) catch null;
+ };
+ var g = read(arena, rec, i, pc) orelse return null;
+ const m = metricOf(form);
+ sizes(rec, i, &g, form);
+ place(&g, m);
+ var long = false;
+ if (g.h > room) {
+ fold(arena, &g) catch return null;
+ sizes(rec, i, &g, form);
+ place(&g, m);
+ }
+ if (g.h > room) {
+ long = true;
+ for (g.nodes, 0..) |*n, k| if (n.folded == 0 and n.rows > theme.metric.graph.long and (g.here == null or g.here.? != k)) {
+ n.shown = 2 * theme.metric.graph.keep + 1;
+ };
+ sizes(rec, i, &g, form);
+ place(&g, m);
+ }
+ remember(.{ .rec = rec, .start = start, .form = form, .room = room, .long = long, .spared = if (g.here) |h| (if (g.nodes[h].rows > theme.metric.graph.long) h else null) else null, .g = g });
+ return g;
+}
+
+/// What `layout` made, kept: the blocks, their sizes and their places are
+/// the function's and the whole recording's, not the moment's (but for a
+/// long block the pc is in, which does not fold); a frame counts its own
+/// moment's visits again (`recount`).
+/// shortcut: process-wide, the last eight kept and never freed (a few KB each); two players at once would only share it.
+const Kept = struct { rec: *const Recording, start: u64, form: Form, room: f32, long: bool, spared: ?u32, g: Graph };
+var memo: [8]?Kept = @splat(null);
+var memo_next: usize = 0;
+var memo_memory: std.heap.ArenaAllocator = .init(std.heap.page_allocator);
+
+fn remember(k: Kept) void {
+ var copy = k;
+ const a = memo_memory.allocator();
+ copy.g.nodes = a.dupe(Node, k.g.nodes) catch return;
+ copy.g.edges = a.dupe(Edge, k.g.edges) catch return;
+ memo[memo_next] = copy;
+ memo_next = (memo_next + 1) % memo.len;
+}
+
+/// A kept graph with the run counted again by moment `i`, the pc at `pc`.
+fn recount(arena: std.mem.Allocator, rec: *const Recording, kept_g: Graph, i: u64, pc: u64) !Graph {
+ var g = kept_g;
+ g.nodes = try arena.dupe(Node, kept_g.nodes);
+ g.edges = try arena.dupe(Edge, kept_g.edges);
+ for (g.nodes) |*n| n.visits = 0;
+ for (g.edges) |*e| e.count = 0;
+ g.here = blockAt(g.nodes, pc);
+ countBy(rec, &g, i, false);
+ return g;
+}
+
+/// Each node's size in `form`: on the map a head and its rows, as wide as
+/// its widest row, 300 at least; in the lens a box 24 high, 10 a row. A
+/// fold: a dashed box of a head and a row.
+pub fn sizes(rec: *const Recording, i: u64, g: *Graph, form: Form) void {
+ const gm = theme.metric.graph;
+ const cm = theme.metric.context;
+ const adv = theme.size.mono.context * 3 / 5;
+ var buf: [256]u8 = undefined;
+ for (g.nodes) |*n| switch (form) {
+ .lens => {
+ n.w = @max(gm.lens.least, gm.lens.lead + gm.lens.per_row * @as(f32, @floatFromInt(n.rows)));
+ n.h = gm.lens.box;
+ },
+ .map => {
+ if (n.folded > 0) {
+ n.w = gm.fold_w;
+ n.h = cm.tag + cm.row + cm.pad;
+ continue;
+ }
+ var widest: usize = 0;
+ var at = n.start;
+ while (g.text and at < n.start + n.len) {
+ const one = rec.instruction(i, at, &buf) orelse break;
+ widest = @max(widest, operandChars(one.text));
+ at += one.len;
+ }
+ n.w = @max(gm.least, gm.operands + @as(f32, @floatFromInt(widest)) * adv + 2 * cm.side);
+ n.h = cm.tag + @as(f32, @floatFromInt(n.shown)) * cm.row + cm.pad;
+ },
+ };
+}
+
+/// How many characters an instruction's operands take as `insn` draws them:
+/// the size words gone, a jump's or call's target its digits, byte cells a few more.
+fn operandChars(text: []const u8) usize {
+ const space = std.mem.indexOfScalar(u8, text, ' ') orelse return 0;
+ var ops = std.mem.trim(u8, text[space..], " ");
+ // A prefix (`rep stosq`, `notrack jmp`): the mnemonic is the next word.
+ for ([_][]const u8{ "rep", "repe", "repz", "repne", "repnz", "lock", "notrack", "bnd" }) |p| if (std.mem.eql(u8, text[0..space], p)) {
+ ops = std.mem.trim(u8, ops[std.mem.indexOfScalar(u8, ops, ' ') orelse ops.len ..], " ");
+ };
+ var n = ops.len;
+ var rest = ops;
+ while (std.mem.indexOf(u8, rest, " ptr ")) |p| {
+ var word = p;
+ while (word > 0 and rest[word - 1] != ' ' and rest[word - 1] != ',') word -= 1;
+ // The word and " ptr " go; the width's cells come.
+ n = n - (p - word + 5) + 5;
+ rest = rest[p + 5 ..];
+ }
+ return n;
+}
+
+/// Lays `g` out (its nodes' `w` and `h` given): layers, columns, every
+/// edge's way. Pure: the same blocks, sizes and whole-recording counts
+/// give the same picture at every moment.
+pub fn place(g: *Graph, m: Metric) void {
+ const nodes = g.nodes;
+ if (nodes.len == 0) return;
+ var buf: [1 << 16]u8 = undefined;
+ var fba = std.heap.FixedBufferAllocator.init(&buf);
+ const tmp = fba.allocator();
+ backEdges(g, tmp) catch return;
+ layers(g, tmp) catch return;
+ columns(g, tmp) catch return;
+ // Lanes: the outermost loop (the longest span) farthest out.
+ var order: [64]u32 = undefined;
+ var nb: u32 = 0;
+ for (g.edges, 0..) |e, k| if (e.back and nb < order.len) {
+ order[nb] = @intCast(k);
+ nb += 1;
+ };
+ std.mem.sort(u32, order[0..nb], g, struct {
+ fn wider(gr: *Graph, a: u32, b: u32) bool {
+ const ea = gr.edges[a];
+ const eb = gr.edges[b];
+ const sa = gr.nodes[ea.from].layer - gr.nodes[ea.to].layer;
+ const sb = gr.nodes[eb.from].layer - gr.nodes[eb.to].layer;
+ return if (sa != sb) sa > sb else ea.to < eb.to;
+ }
+ }.wider);
+ for (order[0..nb], 0..) |e, k| g.edges[e].lane = @intCast(k);
+ g.lanes = nb;
+ // Columns a pitch apart, right of the lanes; layers a gap apart.
+ var widest: f32 = 0;
+ var last_layer: u32 = 0;
+ for (nodes) |n| {
+ widest = @max(widest, n.w);
+ last_layer = @max(last_layer, n.layer);
+ }
+ const pitch = @max(m.pitch, widest + m.block_gap);
+ g.pitch = pitch;
+ const x0 = m.lane_in + @as(f32, @floatFromInt(nb)) * m.lane + m.blocks_in;
+ const tops = tmp.alloc(f32, last_layer + 2) catch return;
+ const heights = tmp.alloc(f32, last_layer + 1) catch return;
+ @memset(heights, 0);
+ for (nodes) |n| heights[n.layer] = @max(heights[n.layer], n.h);
+ tops[0] = m.top;
+ for (heights, 0..) |h, k| tops[k + 1] = tops[k] + h + m.layer_gap;
+ var right: f32 = 0;
+ var bottom: f32 = 0;
+ for (nodes) |*n| {
+ n.x = x0 + @as(f32, @floatFromInt(n.col)) * pitch;
+ n.y = tops[n.layer];
+ right = @max(right, n.x + n.w);
+ bottom = @max(bottom, n.y + n.h);
+ }
+ g.channel = right + m.channel;
+ route(g, m, tops, heights, tmp) catch return;
+ g.w = g.channel + m.lane_in;
+ // Under the last layer the way out: a stub and a bar.
+ g.h = bottom + m.layer_gap;
+}
+
+/// Back edges: those a walk from the entry (then from each block not yet
+/// walked, in address order) finds going to a block on the walk's way.
+fn backEdges(g: *Graph, tmp: std.mem.Allocator) !void {
+ const n = g.nodes.len;
+ const state = try tmp.alloc(u8, n);
+ @memset(state, 0);
+ // Each node's out edges, by their targets' addresses.
+ const outs = try outEdges(g, tmp);
+ const Frame = struct { node: u32, next: u32 };
+ var stack: std.ArrayList(Frame) = .empty;
+ for (0..n) |root| {
+ if (state[root] != 0) continue;
+ state[root] = 1;
+ try stack.append(tmp, .{ .node = @intCast(root), .next = 0 });
+ while (stack.items.len > 0) {
+ const top = &stack.items[stack.items.len - 1];
+ const list = outs[top.node];
+ if (top.next == list.len) {
+ state[top.node] = 2;
+ _ = stack.pop();
+ continue;
+ }
+ const e = list[top.next];
+ top.next += 1;
+ const to = g.edges[e].to;
+ if (state[to] == 1) {
+ g.edges[e].back = true;
+ } else if (state[to] == 0) {
+ state[to] = 1;
+ try stack.append(tmp, .{ .node = to, .next = 0 });
+ }
+ }
+ }
+}
+
+fn outEdges(g: *const Graph, tmp: std.mem.Allocator) ![][]u32 {
+ const outs = try tmp.alloc([]u32, g.nodes.len);
+ const counts = try tmp.alloc(u32, g.nodes.len);
+ @memset(counts, 0);
+ for (g.edges) |e| counts[e.from] += 1;
+ for (outs, counts) |*o, c| o.* = try tmp.alloc(u32, c);
+ @memset(counts, 0);
+ for (g.edges, 0..) |e, k| {
+ outs[e.from][counts[e.from]] = @intCast(k);
+ counts[e.from] += 1;
+ }
+ for (outs) |o| std.mem.sort(u32, o, g, struct {
+ fn first(gr: *const Graph, a: u32, b: u32) bool {
+ return gr.nodes[gr.edges[a].to].start < gr.nodes[gr.edges[b].to].start;
+ }
+ }.first);
+ return outs;
+}
+
+/// Layers by the longest forward path from a block with none into it; the
+/// blocks that return in the last (one more where another is there).
+fn layers(g: *Graph, tmp: std.mem.Allocator) !void {
+ const n = g.nodes.len;
+ const ins = try tmp.alloc(u32, n);
+ @memset(ins, 0);
+ for (g.edges) |e| if (!e.back) {
+ ins[e.to] += 1;
+ };
+ var ready: std.ArrayList(u32) = .empty;
+ for (ins, 0..) |c, k| if (c == 0) try ready.append(tmp, @intCast(k));
+ for (g.nodes) |*node| node.layer = 0;
+ var head: usize = 0;
+ while (head < ready.items.len) : (head += 1) {
+ const a = ready.items[head];
+ for (g.edges) |e| if (!e.back and e.from == a) {
+ g.nodes[e.to].layer = @max(g.nodes[e.to].layer, g.nodes[a].layer + 1);
+ ins[e.to] -= 1;
+ if (ins[e.to] == 0) try ready.append(tmp, e.to);
+ };
+ }
+ var last: u32 = 0;
+ for (g.nodes) |node| if (node.end != .ret) {
+ last = @max(last, node.layer);
+ };
+ var any_ret = false;
+ for (g.nodes) |node| any_ret = any_ret or node.end == .ret;
+ if (!any_ret) return;
+ var deepest_ret: u32 = 0;
+ for (g.nodes) |node| if (node.end == .ret) {
+ deepest_ret = @max(deepest_ret, node.layer);
+ };
+ const others_last = for (g.nodes) |node| {
+ if (node.end != .ret and node.layer == @max(last, deepest_ret)) break true;
+ } else false;
+ const at = @max(last, deepest_ret) + @intFromBool(others_last);
+ for (g.nodes) |*node| if (node.end == .ret) {
+ node.layer = at;
+ };
+}
+
+/// Columns, a layer at a time: a block under the predecessor that reached
+/// it most often in the whole recording; else under the one it falls from;
+/// else (a taken target never taken) right of it. Where two want one
+/// column the more travelled has it, then the fall-through, then the
+/// lower address; the other the next free column to the right.
+fn columns(g: *Graph, tmp: std.mem.Allocator) !void {
+ const n = g.nodes.len;
+ var last: u32 = 0;
+ for (g.nodes) |node| last = @max(last, node.layer);
+ const Want = struct { node: u32, col: u32, total: u32, fall: bool };
+ var wants: std.ArrayList(Want) = .empty;
+ var used: std.ArrayList(u32) = .empty;
+ const placed = try tmp.alloc(bool, n);
+ @memset(placed, false);
+ for (0..last + 1) |layer| {
+ wants.clearRetainingCapacity();
+ for (g.nodes, 0..) |node, k| if (node.layer == layer) {
+ var best: ?Edge = null;
+ for (g.edges) |e| if (!e.back and e.to == k and placed[e.from]) {
+ const better = if (best) |b| e.total > b.total or (e.total == b.total and (e.kind == .fall and b.kind != .fall or (e.kind == .fall) == (b.kind == .fall) and g.nodes[e.from].start < g.nodes[b.from].start)) else true;
+ if (better) best = e;
+ };
+ const col: u32, const total: u32, const fall = if (best) |b|
+ .{ g.nodes[b.from].col + @intFromBool(b.total == 0 and b.kind != .fall), b.total, b.kind == .fall }
+ else
+ .{ 0, 0, false };
+ try wants.append(tmp, .{ .node = @intCast(k), .col = col, .total = total, .fall = fall });
+ };
+ std.mem.sort(Want, wants.items, g, struct {
+ fn first(gr: *Graph, a: Want, b: Want) bool {
+ if (a.total != b.total) return a.total > b.total;
+ if (a.fall != b.fall) return a.fall;
+ return gr.nodes[a.node].start < gr.nodes[b.node].start;
+ }
+ }.first);
+ used.clearRetainingCapacity();
+ for (wants.items) |w| {
+ var col = w.col;
+ while (std.mem.indexOfScalar(u32, used.items, col) != null) col += 1;
+ try used.append(tmp, col);
+ g.nodes[w.node].col = col;
+ placed[w.node] = true;
+ }
+ }
+}
+
+/// Every edge's way. Forward: out of the bottom on the side its target is
+/// on (`port` in from it, or the middle when it is straight below), along
+/// the middle of the gap under its layer, into its target's top (several
+/// into one top `arrivals` apart, in their sources' order); through the
+/// right channel where it would cross a block. Back: down `back_down`, out
+/// to its lane, up it, into its header's head from the left.
+fn route(g: *Graph, m: Metric, tops: []const f32, heights: []const f32, tmp: std.mem.Allocator) !void {
+ const n = g.nodes.len;
+ const tracks = try tmp.alloc(u32, heights.len);
+ @memset(tracks, 0);
+ const back_tracks = try tmp.alloc(u32, heights.len);
+ @memset(back_tracks, 0);
+ // The nodes by layer, then left to right: the edges of one gap take its tracks in that order.
+ const order = try tmp.alloc(u32, n);
+ for (order, 0..) |*o, k| o.* = @intCast(k);
+ std.mem.sort(u32, order, g, struct {
+ fn first(gr: *Graph, a: u32, b: u32) bool {
+ const na = gr.nodes[a];
+ const nb = gr.nodes[b];
+ return if (na.layer != nb.layer) na.layer < nb.layer else na.x < nb.x;
+ }
+ }.first);
+ for (order) |a| for (g.edges) |*e| if (e.from == a) {
+ const src = g.nodes[e.from];
+ const dst = g.nodes[e.to];
+ const under = tops[src.layer] + heights[src.layer];
+ if (e.back) {
+ const lx = m.lane_in + @as(f32, @floatFromInt(e.lane)) * m.lane;
+ const by = under + m.back_down + @as(f32, @floatFromInt(back_tracks[src.layer])) * 8;
+ back_tracks[src.layer] += 1;
+ const sx = src.x + m.port;
+ const hy = dst.y + m.head_in;
+ e.points[0..5].* = .{ .{ sx, src.y + src.h }, .{ sx, by }, .{ lx, by }, .{ lx, hy }, .{ dst.x - 1, hy } };
+ e.n = 5;
+ continue;
+ }
+ // Its place among the arrivals into its target's top.
+ var srcs: usize = 0;
+ var slot: usize = 0;
+ for (g.edges) |o| if (!o.back and o.to == e.to) {
+ srcs += 1;
+ const os = g.nodes[o.from];
+ if (os.x < src.x or (os.x == src.x and o.from < e.from)) slot += 1;
+ };
+ const tx = dst.x + dst.w / 2 + (@as(f32, @floatFromInt(slot)) - @as(f32, @floatFromInt(srcs - 1)) / 2) * m.arrivals;
+ const crosses = for (g.nodes) |o| {
+ if (o.layer > src.layer and o.layer < dst.layer and o.x - 8 < tx and tx < o.x + o.w + 8) break true;
+ } else false;
+ const side = if (crosses) 1 else (dst.x + dst.w / 2) - (src.x + src.w / 2);
+ const sx = if (!crosses and @abs(side) < src.w / 2 - m.port) src.x + src.w / 2 else if (side > 0) src.x + src.w - m.port else src.x + m.port;
+ const gy = under + m.layer_gap / 2 + @as(f32, @floatFromInt(tracks[src.layer])) * m.track;
+ tracks[src.layer] += 1;
+ if (crosses) {
+ const gy2 = tops[dst.layer] - m.layer_gap / 2;
+ e.points = .{ .{ sx, src.y + src.h }, .{ sx, gy }, .{ g.channel, gy }, .{ g.channel, gy2 }, .{ tx, gy2 }, .{ tx, dst.y } };
+ e.n = 6;
+ } else {
+ e.points[0..4].* = .{ .{ sx, src.y + src.h }, .{ sx, gy }, .{ tx, gy }, .{ tx, dst.y } };
+ e.n = 4;
+ }
+ };
+}
+
+// ---------------------------------------------------------------- an instant
+
+/// The graph as a frame shows it: at the stop shown (`g`, where everything
+/// is) and the stop the step came from (`was`, the same function), `p` of
+/// the way from the one to the other; a walked step across one edge is
+/// `leave`'s (or `turn`'s) frames; the panel's scroll.
+pub const Instant = struct {
+ g: Graph,
+ was: Graph,
+ p: f32,
+ leave: ?Leave = null,
+ pan: f32 = 0,
+ now: cursors.Now,
+};
+
+/// A step across one edge, at a walk (`leave`, `turn`): the edge drawn gold
+/// (`draw`, 0 to 1), the mark along it (`travel`), seconds since it landed.
+pub const Leave = struct { edge: u32, draw: f32, travel: f32, landed: f32 };
+
+/// The graph of the function the pc is in, in `form`, in a place `room` high, now.
+pub fn instant(arena: std.mem.Allocator, now: cursors.Now, form: Form, room: f32) ?Instant {
+ const rec = now.rec;
+ const at = [2]u64{ now.stops[1], now.stops[0] };
+ const pc = [2]u64{ rec.register(at[0], "rip"), rec.register(at[1], "rip") };
+ const g = layout(arena, rec, at[1], pc[1], form, room) orelse return null;
+ var was = g;
+ if (at[0] != at[1] and pc[0] -% g.start < g.len) was = layout(arena, rec, at[0], pc[0], form, room) orelse g;
+ // shortcut: a step into another function changes the graph in a frame (no crossfade between two); scenes keep to one.
+ if (was.nodes.len != g.nodes.len or was.edges.len != g.edges.len) was = g;
+ var out: Instant = .{ .g = g, .was = was, .p = now.advancing(), .now = now };
+ const m = metricOf(form);
+ var q = out.p;
+ // One instruction across an edge, walked: its frames are `leave`'s.
+ if (now.walking() and at[1] == at[0] + 1) if (was.here) |a| if (g.here) |b| if (a != b or pc[1] == g.nodes[b].start) if (g.edgeOf(a, b)) |e| {
+ const l = time.leave;
+ const plan = now.plan;
+ out.leave = .{
+ .edge = e,
+ .draw = cursors.standard(clamp01((now.time - (plan.advance - l.edge)) / l.edge)),
+ .travel = cursors.glide(clamp01((now.time - plan.advance) / @max(plan.travel, 1.0 / 60.0))),
+ .landed = now.time - plan.advance - plan.travel,
+ };
+ q = out.leave.?.travel;
+ };
+ out.pan = std.math.lerp(pan(was, room, m), pan(g, room, m), cursors.glide(q));
+ return out;
+}
+
+fn clamp01(v: f32) f32 {
+ return std.math.clamp(v, 0, 1);
+}
+
+/// How long the mark takes along edge `e`: 12 f and 2 f a 100 units, 30 f at most.
+pub fn markTime(e: *const Edge) f32 {
+ const l = time.leave;
+ return @min(l.mark + l.per_100 * e.length() / 100, l.mark_most);
+}
+
+/// `leave` (and `turn`, the same along a loop's lane): from a stop on a
+/// block's last instruction (a jump; or one that falls into the next
+/// block), one step across the edge it takes, to motion.md's frames: fire;
+/// the compare's chips framed as read (the CPU's slot, 18 f), the cause;
+/// the edge drawn gold, head first (24 to 42 f); the mark along it, 12 f
+/// and 2 f a 100 units of the lens's edge (30 f at most); landing, the
+/// advance; the target's count struck 6 f after (a turn's lane count as it
+/// lands); the oldest trail edge cooled (18 f); a rest to 42 f after the landing.
+pub fn leave(c: cursors.Cursor, s: *anim.Frame) void {
+ const from = c.moment(s);
+ const to = from + 1;
+ const l = time.leave;
+ var buf: [1 << 18]u8 = undefined;
+ var fba = std.heap.FixedBufferAllocator.init(&buf);
+ const rec = c.rec;
+ var mark: f32 = l.mark;
+ if (layout(fba.allocator(), rec, to, rec.register(to, "rip"), .lens, std.math.inf(f32))) |g| {
+ if (blockAt(g.nodes, rec.register(from, "rip"))) |a| if (g.here) |b| if (g.edgeOf(a, b)) |e| {
+ mark = markTime(&g.edges[e]);
+ };
+ }
+ const plan: cursors.Plan = .{ .at = @splat(l.chips), .advance = l.sets_off, .travel = mark, .total = l.sets_off + mark + l.rest };
+ c.step(s, to, plan, plan.total);
+}
+
+/// The stop on the last instruction of the block the cursor is in (where
+/// a `leave` sets off): the first moment from `from` at a jump in its
+/// function, or before a stop in another of its blocks.
+pub fn blockEnd(rec: *const Recording, from: u64) u64 {
+ var buf: [1 << 16]u8 = undefined;
+ var fba = std.heap.FixedBufferAllocator.init(&buf);
+ const g = light(fba.allocator(), rec, from, rec.register(from, "rip")) orelse return from;
+ var k = from;
+ while (k + 1 < rec.len()) : (k += 1) {
+ const pc = rec.register(k, "rip");
+ const here = blockAt(g.nodes, pc) orelse continue;
+ if (rec.insn_branches[k]) |b| if (b.kind == .jump or b.kind == .ret) return k;
+ const next = blockAt(g.nodes, rec.register(k + 1, "rip")) orelse continue;
+ if (next != here) return k;
+ }
+ return k;
+}
+
+/// One step from where the cursor is to the end of its block (`blockEnd`), walked: what the block does, as a cascade.
+pub fn toEnd(c: cursors.Cursor, s: *anim.Frame) void {
+ const from = c.moment(s);
+ const to = blockEnd(c.rec, from);
+ if (to == from) return;
+ const plan = c.reading(from, to);
+ c.step(s, to, plan, plan.total);
+}
+
+/// An edge's look in `g`: never taken `rule`, taken `dim`, the last three
+/// taken the trail's golds (the newest 3 wide). By line, all `rule`.
+fn edgeLook(g: Graph, e: u32) struct { ink: u24, w: f32 } {
+ const tr = theme.color.trail;
+ if (!g.exact) return .{ .ink = theme.color.rule, .w = theme.stroke.rule };
+ for (g.trail, 0..) |maybe, k| if (maybe) |te| if (te == e) return .{ .ink = tr[k], .w = if (k == 0) 3 else theme.stroke.rule };
+ return .{ .ink = if (g.edges[e].count > 0) t.dim else theme.color.rule, .w = theme.stroke.rule };
+}
+
+/// A count written as the mark lands: armed 12 f before `s`, struck at
+/// `s` (the fill in over 6 f, its edges out and back over 12 f), solid
+/// 12 f, then cooled to nothing by `end` (the step's end): no corner, the
+/// next step has nothing of it to keep.
+fn landing(now: cursors.Now, s: f32) ui.Heat {
+ const st = time.strike;
+ const tm = now.time;
+ if (tm < s - st.arm) return .none;
+ if (tm < s) return .{ .arm = clamp01((tm - (s - st.arm)) / time.stagger) };
+ const cool_from = s + st.pulse;
+ const end = @max(now.plan.total, cool_from + 6.0 / 60.0);
+ return .{ .level = 1, .solid = 1 - cursors.glide(clamp01((tm - cool_from) / (end - cool_from))), .in = clamp01((tm - s) / st.in), .out = if (tm - s < st.pulse) theme.pulse((tm - s) / st.pulse) else 0, .corner = 0 };
+}
+
+/// What a count shows: the old number until a strike's fill is half in,
+/// then the new; a strike's paper under it, on its `ground` (a box's,
+/// or the page). Crossfading (`p`) where it changes unstruck. `prefix`
+/// before the digits; ranged right of `x` when `right`.
+fn number(u: ui.Ui, face: sk.Face, size: f32, x: f32, base_y: f32, right: bool, was: u32, is: u32, ink: u24, heat: ?ui.Heat, ground: ?u24, p: f32, prefix: []const u8) void {
+ const one = struct {
+ fn draw(v: ui.Ui, fc: sk.Face, sz: f32, xx: f32, by: f32, r: bool, n: u32, c: anytype, pre: []const u8) void {
+ if (n == 0) return;
+ const text = v.print("{s}{d}", .{ pre, n });
+ v.text(fc, sz, if (r) xx - v.width(fc, sz, text) else xx, by, text, c);
+ }
+ }.draw;
+ if (was == is) return one(u, face, size, x, base_y, right, is, ink, prefix);
+ if (heat) |h| {
+ const text = u.print("{s}{d}", .{ prefix, is });
+ const w = u.width(face, size, text);
+ const left = if (right) x - w else x;
+ // Nothing under it but while it is armed or its paper shows: its ground is the box's own, or the page.
+ // Inside its box's frame: the frame never goes under the paper and back.
+ if (h.level > 0 and h.solid > 0 or h.arm > 0) _ = u.cellWritten(.{ .x = left - 3, .y = base_y - size * 0.7, .w = w + 6, .h = size * 0.8 }, h, ground);
+ if (h.level < 1 or h.in < 0.5) return one(u, face, size, x, base_y, right, was, ink, prefix);
+ // Bold and bright on the paper, cooling to its own ink and face with it.
+ const hot = h.solid * h.in;
+ const bold = hot >= 0.5;
+ return one(u, if (bold) (if (face == .sans) .sans_bold else .mono_bold) else face, size, x, base_y, right, is, ui.mix(ink, t.bright, hot), prefix);
+ }
+ one(u.faded(1 - p), face, size, x, base_y, right, was, ink, prefix);
+ one(u.faded(p), face, size, x, base_y, right, is, ink, prefix);
+}
+
+/// The edges of `v`, in `u` (the graph's origin): each in its look, mixed
+/// from the one before as the step lands; the one a leave takes drawn
+/// gold, head first, over its old look, and cooling to the trail's newest
+/// after the landing; each loop's turns under its turn into its header.
+fn drawEdges(u: ui.Ui, v: Instant, form: Form) void {
+ const g = v.g;
+ const lens = form == .lens;
+ const gm = theme.metric.graph;
+ const head: [2]f32 = if (lens) gm.lens.head else gm.head;
+ const radius: f32 = if (lens) gm.lens.corner else gm.corner;
+ // Recoloured with the landing (a leave's 18 f), else with the advance.
+ const q = if (v.leave) |l| clamp01(l.landed / time.leave.trail) else v.p;
+ for (g.edges, 0..) |e, k| {
+ const a = edgeLook(v.was, @intCast(k));
+ const b = edgeLook(g, @intCast(k));
+ const ink = ui.mix(a.ink, b.ink, q);
+ const w = std.math.lerp(a.w, b.w, q);
+ var pts: [6]ui.Vec = undefined;
+ for (e.path(), 0..) |pt, n| pts[n] = .{ pt[0], pt[1] };
+ u.route(pts[0..e.n], ink, .{ .width = if (ui.strokes) 20 else w, .head = if (ui.strokes) null else head, .radius = radius });
+ if (v.leave) |l| if (l.edge == k) {
+ const gold = theme.mark(.current).solid;
+ u.faded(1 - q).route(pts[0..e.n], gold, .{ .width = if (ui.strokes) 20 else 3, .head = if (ui.strokes) null else head, .radius = radius, .progress = l.draw });
+ };
+ // A loop's turns so far, on its lane under the turn into its header; struck as a turn lands.
+ if (e.back and (e.count > 0 or v.was.edges[k].count > 0) and !ui.strokes) {
+ const lx = pts[2][0];
+ const hy = pts[3][1];
+ const strike: ?ui.Heat = if (v.leave) |l| (if (l.edge == k) landing(v.now, v.now.plan.advance + v.now.plan.travel) else null) else null;
+ number(u, .sans, theme.size.sans.micro, lx + 5, hy + 22, false, v.was.edges[k].count, e.count, t.faint, strike, null, v.p, "\u{00d7}");
+ }
+ // On the map a conditional's counts by its ports.
+ if (!lens and !e.back and e.kind != .jump and g.exact and !ui.strokes) {
+ const outs = for (g.edges) |o| {
+ if (o.from == e.from and !o.back and o.to != e.to) break true;
+ } else false;
+ if (outs) number(u, .mono, theme.size.mono.context, pts[0][0] + 8, pts[0][1] + 20, false, v.was.edges[k].count, e.count, t.faint, null, null, v.p, "");
+ }
+ }
+}
+
+/// The mark on its way along the edge a leave takes: a gold plaque (half
+/// size in the lens) with an ink head pointing the way it goes.
+fn drawMark(u: ui.Ui, v: Instant, form: Form) void {
+ const l = v.leave orelse return;
+ if (l.travel <= 0 or l.travel >= 1) return;
+ const e = &v.g.edges[l.edge];
+ const at, const dir = e.at(l.travel * e.length());
+ const side: f32 = if (form == .lens) 12 else theme.metric.plaque.pc;
+ const gold = theme.mark(.current);
+ u.fill(.{ .x = at[0] - side / 2, .y = at[1] - side / 2, .w = side, .h = side }, gold.solid);
+ if (ui.strokes) return;
+ const h = side / 4;
+ const tip: ui.Vec = .{ at[0] + dir[0] * h, at[1] + dir[1] * h };
+ const back: ui.Vec = .{ at[0] - dir[0] * h, at[1] - dir[1] * h };
+ const across: ui.Vec = .{ -dir[1] * h, dir[0] * h };
+ sk.draw.polygon(u.f, &.{ tip, back + across, back - across }, u.at.pen(.{ .fill = ui.rgb(gold.on_solid) }));
+}
+
+/// How much node `k` is the pc's: as the mark leaves it and lands, or with the advance.
+fn golden(v: Instant, k: u32) f32 {
+ const was: f32 = if (v.was.here == k) 1 else 0;
+ const is: f32 = if (v.g.here == k) 1 else 0;
+ if (v.leave) |l| {
+ if (was > is) return 1 - l.travel;
+ if (is > was) return clamp01(l.landed / time.leave.count);
+ return is;
+ }
+ return std.math.lerp(was, is, v.p);
+}
+
+/// The `blocks` lens (design/README.md, `graph`): over the program column
+/// the function's graph without its text, a block a box 24 high, as wide
+/// as its rows (60 and 10 a row, 132 at least), its offset and its visits,
+/// the pc's framed gold 3; the edges, the lanes and the trail at half
+/// measure. Its view is the disassembly itself, over the state column
+/// (the split `blocks`).
+pub const Blocks = struct {
+ cursor: cursors.Cursor,
+ stage: *const Stage,
+ focus: bool = false,
+
+ pub fn draw(b: *const Blocks, f: *sk.Frame, placed: anim.Placed) void {
+ const box = b.stage.box(placed, .band);
+ const m = theme.metric.context;
+ if (box.h < m.tag + 24) return;
+ const u = context.at(f, placed, box).faded(placed.value(b.stage.drawing));
+ u.clip(.{ .x = 0, .y = 0, .w = box.w, .h = box.h });
+ defer u.unclip();
+ const now = b.cursor.now(placed);
+ const room = box.h - m.tag - theme.stroke.rule;
+ const v = instant(f.scratch, now, .lens, room) orelse {
+ _ = u.panel(box.w, box.h, "its blocks", .{ .focus = b.focus });
+ return;
+ };
+ const name = ui.symbol(u, b.cursor.rec.strings.get(v.g.start) orelse "");
+ _ = u.panel(box.w, box.h, u.print("the blocks of {s}", .{name[0 .. std.mem.lastIndexOfScalar(u8, name, '+') orelse name.len]}), .{ .focus = b.focus, .note = "its blocks \u{00b7} the visits \u{00b7} the path" });
+ u.clip(.{ .x = theme.stroke.rule, .y = m.tag, .w = box.w - 2 * theme.stroke.rule, .h = room });
+ const o = u.moved(0, m.tag - v.pan);
+ drawEdges(o, v, .lens);
+ const gm = theme.metric.graph.lens;
+ const size = theme.size.mono.context;
+ for (v.g.nodes, v.was.nodes, 0..) |n, was, k| {
+ const r: ui.Rect = .{ .x = n.x, .y = n.y, .w = n.w, .h = n.h };
+ const gold = golden(v, @intCast(k));
+ const seen = std.math.lerp(@as(f32, if (was.visits > 0) 1 else 0), @as(f32, if (n.visits > 0) 1 else 0), if (v.leave != null) clamp01(v.leave.?.landed / time.leave.count) else v.p);
+ o.fill(r, ui.mix(theme.color.page, theme.color.raised, seen));
+ if (n.folded > 0) o.dashedFrame(r, theme.color.rule, theme.stroke.rule) else o.frame(r, ui.mix(theme.color.rule, theme.mark(.current).solid, gold), std.math.lerp(theme.stroke.rule, gm.gold, gold));
+ const base_y = rows.baseline(n.y);
+ const off = o.print("+{x}", .{n.start - v.g.start});
+ o.text(.mono, size, n.x + 8, base_y, off, ui.mix(t.faint, t.primary, seen));
+ const strike: ?ui.Heat = if (v.leave) |l| (if (v.g.edges[l.edge].to == k) landing(now, now.plan.advance + now.plan.travel + time.leave.count) else null) else null;
+ number(o, .mono, size, n.x + n.w - 8, base_y, true, was.visits, n.visits, t.dim, strike, if (seen >= 0.5) theme.color.raised else theme.color.page, v.p, "\u{00d7}");
+ }
+ drawMark(o, v, .lens);
+ u.unclip();
+ }
+};
+
+/// The disassembly as its graph, on the map (design/README.md, `graph`;
+/// mock 22): two columns wide beside the source. A block is a head (its
+/// first address, its lines, how often the run entered it) over its rows,
+/// `insn`'s with the offset where the address was; the annotation only in
+/// the pc's block, which widens to its column; a call a hook out of the
+/// block's side and back a row down; under a return, the way out. Too tall,
+/// the runs never reached fold, then long blocks, then it pans.
+pub const Map = struct {
+ cursor: cursors.Cursor,
+ stage: *const Stage,
+
+ pub fn draw(gm: *const Map, f: *sk.Frame, placed: anim.Placed) void {
+ const box = gm.stage.box(placed, .disasm);
+ const m = theme.metric.context;
+ if (box.h < m.tag + m.row) return;
+ const u = context.at(f, placed, box);
+ const now = gm.cursor.now(placed);
+ const rec = gm.cursor.rec;
+ const room = box.h - m.tag - theme.stroke.rule;
+ const v = instant(f.scratch, now, .map, room) orelse {
+ _ = u.panel(box.w, box.h, "disassembly", .{});
+ return;
+ };
+ const g = v.g;
+ const full = rec.strings.get(g.start) orelse "";
+ const sym = ui.symbol(u, full);
+ const name = sym[0 .. std.mem.lastIndexOfScalar(u8, sym, '+') orelse sym.len];
+ const module: []const u8 = if (std.mem.indexOfScalar(u8, full, '!')) |bang| full[0..bang] else "";
+ const folded = g.foldedBlocks();
+ const title = if (module.len > 0) u.print("disassembly \u{00b7} {s} \u{00b7} {s}", .{ name, module }) else u.print("disassembly \u{00b7} {s}", .{name});
+ const note = if (folded > 0) u.print("{s}{d} blocks \u{00b7} folded: {d} never reached", .{ if (rec.sourced(now.stops[0])) "" else "no source \u{00b7} ", g.blocks, folded }) else if (g.exact) "its blocks \u{00b7} visits so far \u{00b7} the edges the run took" else "its blocks \u{00b7} visits so far";
+ _ = u.panel(box.w, box.h, title, .{ .note = note });
+ u.clip(.{ .x = theme.stroke.rule, .y = m.tag, .w = box.w - 2 * theme.stroke.rule, .h = room });
+ defer u.unclip();
+ const o = u.moved(0, m.tag - v.pan);
+ drawEdges(o, v, .map);
+ const d: disasm.Disasm = .{ .cursor = gm.cursor, .stage = gm.stage };
+ const body: ui.Rect = .{ .x = theme.stroke.rule, .y = v.pan, .w = box.w - 2 * theme.stroke.rule, .h = room };
+ for (g.nodes, 0..) |_, k| block(o, v, @intCast(k), d, body);
+ drawMark(o, v, .map);
+ }
+
+ /// Block `k`: its head, its rows, its hooks and its way out.
+ fn block(o: ui.Ui, v: Instant, k: u32, d: disasm.Disasm, body: ui.Rect) void {
+ const gm = theme.metric.graph;
+ const m = theme.metric.context;
+ const size = theme.size.mono.context;
+ const adv = size * 3 / 5;
+ const now = v.now;
+ const rec = now.rec;
+ const g = v.g;
+ const n = g.nodes[k];
+ const was = v.was.nodes[k];
+ const here = g.here == k or v.was.here == k;
+ // The pc's block widens to its column for the annotation, never into the channel.
+ const w = if (here and n.folded == 0) @max(n.w, @min(g.pitch - gm.block_gap, g.channel - gm.channel / 2 - n.x)) else n.w;
+ const r: ui.Rect = .{ .x = n.x, .y = n.y, .w = w, .h = n.h };
+ const landing_q = if (v.leave) |l| clamp01(l.landed / time.leave.count) else v.p;
+ const seen = std.math.lerp(@as(f32, if (was.visits > 0) 1 else 0), @as(f32, if (n.visits > 0) 1 else 0), landing_q);
+ const gold = golden(v, k);
+ o.fill(r, theme.color.page);
+ if (n.folded > 0) {
+ // Blocks the whole recording never reached: one dashed box, its offsets and its count.
+ o.dashedFrame(r, theme.color.rule, theme.stroke.rule);
+ const last = n.start + n.len - 1;
+ o.text(.mono, size, n.x + m.side, rows.baseline(n.y), o.print("+{x} to +{x}", .{ n.start - g.start, last - g.start }), t.faint);
+ const words = if (n.folded > 1) o.print("{d} blocks never reached", .{n.folded}) else "never reached";
+ const micro = theme.size.sans.micro;
+ o.text(.sans, micro, n.x + w - m.side - o.width(.sans, micro, words), n.y + m.tag - 6, words, t.faint);
+ return;
+ }
+ o.fill(.{ .x = r.x, .y = r.y, .w = r.w, .h = m.tag }, ui.mix(theme.color.page, theme.color.raised, seen));
+ o.frame(r, ui.mix(theme.color.rule, theme.mark(.current).solid, gold), theme.stroke.rule);
+ // The head: its first address, its lines, its visits.
+ const head_y = rows.baseline(n.y);
+ const end = o.address(n.x + m.side, head_y, n.start, .{ .ink = ui.rgb(theme.color.region.code_) });
+ var buf: [256]u8 = undefined;
+ var first_line: ?u32 = null;
+ var last_line: ?u32 = null;
+ var at = n.start;
+ const i = now.stops[0];
+ // Its rows, as `insn` takes them (a long block: four, `more`, four).
+ var list: std.ArrayList(disasm.Insn) = .empty;
+ while (at < n.start + n.len) {
+ const one = rec.instruction(i, at, &buf) orelse break;
+ list.append(o.f.scratch, .{ .addr = at, .len = one.len, .text = o.print("{s}", .{one.text}), .line = one.line, .params = one.params, .bare = true }) catch break;
+ if (one.line) |l| {
+ first_line = @min(first_line orelse l, l);
+ last_line = @max(last_line orelse l, l);
+ }
+ at += one.len;
+ }
+ const micro = theme.size.sans.micro;
+ if (first_line) |a| o.text(.sans, micro, end + 16, n.y + m.tag - 6, if (a == last_line.?) o.print("line {d}", .{a}) else o.print("lines {d} to {d}", .{ a, last_line.? }), t.faint);
+ const strike: ?ui.Heat = if (v.leave) |l| (if (v.g.edges[l.edge].to == k) landing(now, now.plan.advance + now.plan.travel + time.leave.count) else null) else null;
+ number(o, .mono, size, n.x + w - m.side, head_y, true, was.visits, n.visits, t.primary, strike, if (seen >= 0.5) theme.color.raised else theme.color.page, v.p, "\u{00d7}");
+
+ // Where the mark is, and was: the plaque leaves its row as the mark sets off, and lands with it.
+ const pcs = [2]u64{ rec.register(now.stops[1], "rip"), rec.register(now.stops[0], "rip") };
+ var shows = [2]f32{ 1 - v.p, v.p };
+ if (v.leave) |l| shows = .{ 1 - clamp01((now.time - now.plan.advance) / time.leave.count), clamp01(l.landed / time.leave.count) };
+ if (pcs[0] == pcs[1]) shows = .{ 0, 1 };
+ // What the annotation reads as current (the moment the mark stands for), and the rows that ran in the last three steps.
+ const going = now.advancing();
+ const base: usize = if (going >= 0.5) 0 else 1;
+ const current_line = rec.own[now.marked()];
+ const annotated = g.here == k and now.plan.gait != .sprint;
+ const sprinting = now.plan.gait == .sprint and !now.resting();
+ const echo = disasm.jumpEcho(now, base);
+ var covered: usize = 0;
+ var line_before: ?u32 = null;
+ const long = n.shown < n.rows;
+ // Its rows' annotations stay in it: a call's arguments hang no further than its last row.
+ const top = @max(n.y, body.y);
+ const under = @min(n.y + n.h, body.y + body.h);
+ if (under > top) o.clip(.{ .x = body.x, .y = top, .w = body.w, .h = under - top });
+ var y = n.y + m.tag;
+ for (list.items, 0..) |row, j| {
+ if (long and j >= gm.keep and j < list.items.len - gm.keep) {
+ if (j == gm.keep) {
+ _ = o.arrow(n.x + gm.offset - 36, y + m.row / 2, .more);
+ o.text(.mono, size, n.x + gm.mnemonic, rows.baseline(y), o.print("{d} rows", .{list.items.len - 2 * gm.keep}), t.faint);
+ y += m.row;
+ }
+ continue;
+ }
+ const rr: ui.Rect = .{ .x = n.x, .y = y, .w = w, .h = m.row };
+ @import("map.zig").row(.disasm, row.addr, o, rr);
+ for (pcs, shows) |pc, a| if (pc == row.addr and a > 0) {
+ const lit = o.faded(a);
+ lit.current(.{ .x = n.x + theme.stroke.rule, .y = y, .w = w - 2 * theme.stroke.rule, .h = m.row }, theme.metric.plaque.pc, now.fires(.disasm));
+ sk.draw.polygon(o.f, &.{ .{ n.x + 20, y + m.row / 2 }, .{ n.x + 10, y + 6 }, .{ n.x + 10, y + m.row - 6 } }, lit.at.pen(.{ .fill = ui.rgb(theme.mark(.current).on_solid) }));
+ };
+ const ran = if (annotated) ranAt(now, base, row.addr) else null;
+ if (ran) |rn| if (row.addr != pcs[1]) o.trail(n.x + theme.metric.insn.mark, y, rn.k);
+ // The offset where the address was.
+ const off = o.print("+{x}", .{row.addr - g.start});
+ o.text(.mono, size, n.x + gm.offset - o.width(.mono, size, off), rows.baseline(y), off, t.faint);
+ const lit = o.moved(n.x - gm.shift, 0);
+ if (annotated and !sprinting) {
+ const state: disasm.Disasm.State = if (row.addr == rec.register(now.marks[if (going >= 0.5) 1 else 0], "rip")) .current else if (ran) |rn| .{ .ran = rn } else .ahead;
+ const hangs = d.insn(lit, now, row, y, w + gm.shift, 0, row.line, row.line != line_before, current_line, 0, state, base, covered > 0, .{ g.start, g.start + g.len }, echo);
+ covered = @max(covered -| 1, hangs);
+ } else {
+ if (row.line) |l| if (row.line != line_before) {
+ const num = o.print("{d}", .{l});
+ o.text(.mono, size, n.x + gm.line - o.width(.mono, size, num), rows.baseline(y), num, t.faint);
+ };
+ disasm.bareRow(lit, row, y);
+ }
+ line_before = row.line;
+ // A call that comes back: out of the block's side and in again a row down, the callee named.
+ if (std.mem.eql(u8, row.mnemonic(), "call") and !ui.strokes) if (disasm.target(row)) |to| {
+ const ink = if (n.visits > 0) t.dim else theme.color.rule;
+ const back = !(j + 1 == list.items.len and n.end == .noreturn);
+ const hx = n.x + w;
+ if (back) o.route(&.{ .{ hx, y + m.row / 2 }, .{ hx + gm.hook + 6, y + m.row / 2 }, .{ hx + gm.hook + 6, y + 1.5 * m.row }, .{ hx + 1, y + 1.5 * m.row } }, ink, .{ .width = theme.stroke.rule, .head = .{ 7, 8 }, .radius = 6 }) else o.route(&.{ .{ hx, y + m.row / 2 }, .{ hx + gm.hook + 6, y + m.row / 2 } }, ink, .{ .width = theme.stroke.rule, .head = null });
+ const callee = ui.symbol(o, rec.strings.get(to) orelse "");
+ o.text(.mono, size, hx + gm.hook + 6 + adv, rows.baseline(y) + m.row / 2, callee[0 .. std.mem.lastIndexOfScalar(u8, callee, '+') orelse callee.len], t.primary);
+ };
+ y += m.row;
+ }
+ o.clip(body);
+ // How it ends, under it: the way out (a return, a call that does not return), a tail call, an indirect jump.
+ const ink = if (n.visits > 0) t.dim else theme.color.rule;
+ const cx = n.x + n.w / 2;
+ const bottom = n.y + n.h;
+ switch (n.end) {
+ .ret, .noreturn => {
+ o.fill(.{ .x = cx - 1, .y = bottom, .w = theme.stroke.rule, .h = gm.exit_stub }, ink);
+ o.fill(.{ .x = cx - gm.exit_bar / 2, .y = bottom + gm.exit_stub, .w = gm.exit_bar, .h = 3 }, ink);
+ },
+ .tail => {
+ o.fill(.{ .x = cx - 1, .y = bottom, .w = theme.stroke.rule, .h = 24 }, ink);
+ if (n.out) |to| {
+ const callee = ui.symbol(o, rec.strings.get(to) orelse "");
+ o.text(.mono, size, cx + 8, rows.baseline(bottom + 6), callee[0 .. std.mem.lastIndexOfScalar(u8, callee, '+') orelse callee.len], t.primary);
+ }
+ },
+ .indirect => {
+ o.fill(.{ .x = cx - 1, .y = bottom, .w = theme.stroke.rule, .h = 24 }, ink);
+ _ = o.arrow(cx - 8, bottom + 30, .more);
+ o.text(.sans, micro, cx + 60, bottom + 36, "targets not known", t.faint);
+ },
+ else => {},
+ }
+ }
+};
+
+/// The step (`k` steps ago, 0 newest) a row last ran in, of the three the
+/// mark's trail is (by the stops `base` on), and the moment it ran at.
+fn ranAt(now: cursors.Now, base: usize, addr: u64) ?disasm.Disasm.Ran {
+ for (0..3) |k| {
+ const first = now.stops[@min(base + 1 + k, now.stops.len - 1)];
+ const last = now.stops[base + k];
+ var at = last;
+ while (at > first and last - at < 4096) {
+ at -= 1;
+ if (now.rec.register(at, "rip") == addr) return .{ .k = k, .at = at };
+ }
+ }
+ return null;
+}
+
+test "a loop's back edge climbs, the hot path is straight down, a never-taken target sits right of its block" {
+ // sort's shape: entry, the outer loop's test, its body, the inner test,
+ // the compare, the swap, the outer step, the exit.
+ var nodes = [_]Node{
+ .{ .start = 0x00, .len = 0x17, .end = .jump }, // B0 jmp B6
+ .{ .start = 0x17, .len = 0x08, .end = .jump }, // B1 jmp B3
+ .{ .start = 0x1f, .len = 0x40, .end = .fall }, // B2 (swap) falls B3
+ .{ .start = 0x5f, .len = 0x06, .end = .branch }, // B3 jle B5, falls B4
+ .{ .start = 0x65, .len = 0x35, .end = .branch }, // B4 jg B2, falls B5
+ .{ .start = 0x9a, .len = 0x04, .end = .fall }, // B5 falls B6
+ .{ .start = 0x9e, .len = 0x0c, .end = .branch }, // B6 jl B1, falls B7
+ .{ .start = 0xaa, .len = 0x04, .end = .ret }, // B7
+ };
+ for (&nodes) |*nd| {
+ nd.w = 300;
+ nd.h = 52;
+ }
+ var edges = [_]Edge{
+ .{ .from = 0, .to = 6, .kind = .jump, .total = 1 },
+ .{ .from = 1, .to = 3, .kind = .jump, .total = 7 },
+ .{ .from = 2, .to = 3, .kind = .fall, .total = 10 },
+ .{ .from = 3, .to = 5, .kind = .taken, .total = 0 },
+ .{ .from = 3, .to = 4, .kind = .fall, .total = 17 },
+ .{ .from = 4, .to = 2, .kind = .taken, .total = 10 },
+ .{ .from = 4, .to = 5, .kind = .fall, .total = 7 },
+ .{ .from = 5, .to = 6, .kind = .fall, .total = 7 },
+ .{ .from = 6, .to = 1, .kind = .taken, .total = 7 },
+ .{ .from = 6, .to = 7, .kind = .fall, .total = 1 },
+ };
+ var g: Graph = .{ .start = 0, .len = 0xae, .nodes = &nodes, .edges = &edges, .here = null, .text = true, .exact = true };
+ place(&g, metricOf(.map));
+ // Two loops: the inner turns from the swap, the outer from its step.
+ try std.testing.expect(edges[2].back and edges[7].back);
+ for (edges, 0..) |e, k| if (k != 2 and k != 7) try std.testing.expect(!e.back);
+ // Layers by the longest path; the exit last, alone.
+ const want = [_]u32{ 0, 2, 5, 3, 4, 5, 1, 6 };
+ for (nodes, want) |nd, l| try std.testing.expectEqual(l, nd.layer);
+ // The hot path straight down; the step beside the swap.
+ for ([_]usize{ 0, 1, 2, 3, 4, 6, 7 }) |k| try std.testing.expectEqual(@as(u32, 0), nodes[k].col);
+ try std.testing.expectEqual(@as(u32, 1), nodes[5].col);
+ // The outer loop's lane outermost; a back edge climbs into its header's head from the left.
+ try std.testing.expect(edges[7].lane == 0 and edges[2].lane == 1);
+ const turn = edges[7].path();
+ try std.testing.expect(turn[3][1] < turn[2][1] and turn[4][0] < nodes[6].x);
+ // The exit's edge would cross the loop's blocks: it runs in the right channel.
+ try std.testing.expectEqual(@as(u8, 6), edges[9].n);
+ try std.testing.expectEqual(g.channel, edges[9].points[2][0]);
+ // Every forward edge ends on its target's top.
+ for (edges) |e| if (!e.back) try std.testing.expectEqual(nodes[e.to].y, e.points[e.n - 1][1]);
+}
diff --git a/anim/src/map.zig b/anim/src/map.zig
index c870d60..108bafd 100644
--- a/anim/src/map.zig
+++ b/anim/src/map.zig
@@ -96,7 +96,7 @@ pub fn row(panel: Panel, key: u64, u: ui.Ui, r: Rect) void {
/// lens's view, the registers, and in the rest the stack going on
/// (`continued`), in the third; the stack in the fourth, whole.
// shortcut: a column's rest after the disassembly is page: the 5-row dumps round what the registers point at, the open loupes and the key are not built.
-pub fn split(rec: *const Recording, lens: bool, way: [2]u64) Split {
+pub fn split(rec: *const Recording, lens: bool, way: [2]u64, graph: bool) Split {
const st = theme.map.stage;
const c = theme.map.columns;
const w = theme.map.column;
@@ -136,6 +136,25 @@ pub fn split(rec: *const Recording, lens: bool, way: [2]u64) Split {
return .{ .x = r.x, .y = y, .w = r.w, .h = @max(bottom - y, 0) };
}
}.under;
+ // The disassembly as its graph (`graph.Map`): two columns wide beside the
+ // source, the drawing it is (no band); the registers over the stack in the last.
+ if (graph) {
+ const regs: Rect = .{ .x = c[3], .y = st.y, .w = w, .h = panelH(17) };
+ const nothing: Rect = .{ .x = c[3], .y = st.y, .w = w, .h = 0 };
+ const src: Rect = .{ .x = c[0], .y = st.y, .w = w, .h = panelH(@floatFromInt(@min(rec.line_count, theme.layout.rowsIn(foot - st.y - gap - panelH(bt_rows))))) };
+ const bt: Rect = .{ .x = c[0], .y = src.y + src.h + gap, .w = w, .h = @min(panelH(bt_rows), foot - (src.y + src.h + gap)) };
+ return .{
+ .band = .{ .x = c[0], .y = st.y, .w = w, .h = 0 },
+ .view = nothing,
+ .source = src,
+ .disasm = .{ .x = c[1], .y = st.y, .w = c[2] + w - c[1], .h = st.h },
+ .registers = regs,
+ .stack = rest(regs, foot),
+ .backtrace = bt,
+ .dump_rows = theme.map.memory_rows,
+ .spare = .{ rest(bt, foot), .{ .x = c[1], .y = foot, .w = w, .h = 0 } },
+ };
+ }
return .{
.band = band,
.view = view,
@@ -322,6 +341,10 @@ pub const Map = struct {
cursor: ?@import("cursor.zig").Cursor = null,
/// The scene's loupes: open, each is a panel of its own on the map (`Spare`).
loupes: [2]?*const @import("loupe.zig").Loupe = .{ null, null },
+ /// The disassembly is its graph (`graph.Map`): the thread is its digits,
+ /// no line crosses the lanes; the band's window is the whole graph; the
+ /// disassembly's, the rows it shows.
+ graph: bool = false,
const Part = struct { ctx: *const anyopaque, draw: *const fn (*const anyopaque, *sk.Frame, anim.Placed) void };
@@ -340,7 +363,7 @@ pub const Map = struct {
/// Puts a drawing on the map, in a band of its own over the source,
/// for a scene whose working frame has none (its map is split anew).
pub fn drawing(m: *Map, s: *anim.Frame, rec: *const Recording, component: anytype) void {
- m.stage.first = split(rec, true, if (m.cursor) |c| .{ c.first, c.last } else .{ 0, 0 });
+ m.stage.first = split(rec, true, if (m.cursor) |c| .{ c.first, c.last } else .{ 0, 0 }, m.graph);
m.add(s, component);
}
@@ -371,7 +394,8 @@ pub const Map = struct {
/// `surface`: the dive backwards, a little quicker; then the map is
/// still before anything plays on it.
pub fn surface(m: *const Map, s: *anim.Frame) void {
- s.play(.{m.t.to(diving.land)}, .{ .seconds = 0 });
+ // A scene that did not open on it has not shown it yet: under the panels until it rises.
+ s.play(.{ m.t.to(diving.land), m.obj.fadeIn() }, .{ .seconds = 0 });
s.play(.{m.t.to(0)}, .{ .seconds = @as(f32, diving.surface) / 60.0, .ease = anim.ease.linear });
s.wait(@as(f32, diving.still) / 60.0);
}
@@ -414,7 +438,9 @@ pub const Map = struct {
const y = std.math.lerp(from.y, box.y, p);
// The tags, rules and lanes come in as the map lands.
const chrome = std.math.clamp((t - diving.lift) / 12, 0, 1);
- context.zoomed[i] = .{ .box = box, .to = .{ .x = x, .y = y, .w = box.w * scale, .h = box.h * scale }, .chrome = chrome };
+ // Out of a graph the rows and the lens are another form of what the map shows there: they come in on their way.
+ const other = m.graph and (i == @intFromEnum(Panel.disasm) or i == @intFromEnum(Panel.band));
+ context.zoomed[i] = .{ .box = box, .to = .{ .x = x, .y = y, .w = box.w * scale, .h = box.h * scale }, .chrome = chrome, .shows = if (other) p else 1 };
};
}
}
@@ -505,7 +531,7 @@ pub const Map = struct {
ui.strokes = mini;
counts = @splat(0);
for (m.parts[0..m.n]) |p| p.draw(p.ctx, f, at);
- if (m.cursor) |c| m.thread(f, at, c.now(at), mini);
+ if (m.cursor) |c| if (!m.graph) m.thread(f, at, c.now(at), mini);
ui.mapping = false;
ui.strokes = false;
}
@@ -559,13 +585,17 @@ pub const Map = struct {
/// The top and bottom of the map's rows of panel `i` with keys from `keys[0]` to `keys[1]`, in canvas pixels.
fn spanOf(i: usize, keys: [2]u64) ?[2]f32 {
- var top: f32 = std.math.inf(f32);
- var bottom: f32 = -std.math.inf(f32);
+ const r = boxOf(i, keys) orelse return null;
+ return .{ r[1], r[3] };
+ }
+
+ /// The box round the map's rows of panel `i` with keys from `keys[0]` to `keys[1]`, in canvas pixels.
+ fn boxOf(i: usize, keys: [2]u64) ?[4]f32 {
+ var r: [4]f32 = .{ std.math.inf(f32), std.math.inf(f32), -std.math.inf(f32), -std.math.inf(f32) };
for (rows[i][0..counts[i]]) |rw| if (rw.key >= keys[0] and rw.key <= keys[1]) {
- top = @min(top, rw.box[1]);
- bottom = @max(bottom, rw.box[3]);
+ r = .{ @min(r[0], rw.box[0]), @min(r[1], rw.box[1]), @max(r[2], rw.box[2]), @max(r[3], rw.box[3]) };
};
- return if (top < bottom) .{ top, bottom } else null;
+ return if (r[1] < r[3]) r else null;
}
/// Where the map's row of key `key` in `panel` is this frame, in canvas pixels.
@@ -585,7 +615,8 @@ pub const Map = struct {
inline for (.{ "band", "view", "source", "disasm", "registers", "stack", "backtrace" }) |name| {
const panel = @field(Panel, name);
const i = @intFromEnum(panel);
- const box = @field(split_, name);
+ // The lens drawing the graph is: its window is the graph whole.
+ const box = if (m.graph and panel == .band) split_.disasm else @field(split_, name);
if (box.h > 0) {
const a = at.xf.apply(.{ box.x, box.y });
const b = at.xf.apply(.{ box.x + box.w, box.y + box.h });
@@ -606,6 +637,12 @@ pub const Map = struct {
r[1] = std.math.lerp(snap(from[0], mini), snap(to[0], mini), win.p);
r[3] = std.math.lerp(snap(from[1], mini), snap(to[1], mini), win.p);
shown = true;
+ // In a graph the rows a window shows are in blocks: round them, not the panel's width.
+ if (m.graph and panel == .disasm) if (boxOf(i, win.now)) |round| {
+ const was_box = boxOf(i, win.was) orelse round;
+ r[0] = std.math.lerp(snap(was_box[0], mini), snap(round[0], mini), win.p);
+ r[2] = std.math.lerp(snap(was_box[2], mini), snap(round[2], mini), win.p);
+ };
}
}
// On the minimap on whole pixels (a window's ends already are, at rest).
diff --git a/anim/src/root.zig b/anim/src/root.zig
index 60ae6dc..b7be9b4 100644
--- a/anim/src/root.zig
+++ b/anim/src/root.zig
@@ -42,6 +42,7 @@ pub const contextLegend = contexts.legend;
pub const disasm = @import("disasm.zig");
pub const Disasm = disasm.Disasm;
pub const Descent = @import("descent.zig").Descent;
+pub const graph = @import("graph.zig");
pub const calls = @import("calls.zig");
pub const CallTree = calls.Tree;
pub const Nodes = @import("nodes.zig").Nodes;
@@ -246,6 +247,10 @@ pub const Context = struct {
/// callee's window under the call row, and a system call the
/// kernel's under the `syscall` (step with `descent.step`).
descent: bool = false,
+ /// On the map the disassembly as the function's graph (`graph.Map`),
+ /// two columns wide beside the source, the registers and the stack
+ /// in the last column.
+ graph: bool = false,
};
/// The ties between the panes, drawn over everything added before.
@@ -284,11 +289,11 @@ pub fn context(s: *anim.Frame, cursor_: Cursor, options: Context.Options) Contex
var at = cursor_;
at.levels.crossings = options.syscalls;
// The map first: while it fills the frame or falls to the minimap it is under the panels diving out of it.
- const whole = s.new(map.Map{ .stage = Stage.init(s, map.split(at.rec, options.split.band.h > 0, .{ at.first, at.last })), .frame = stage, .t = s.value(map.diving.land + map.diving.still), .cursor = at });
+ const whole = s.new(map.Map{ .stage = Stage.init(s, map.split(at.rec, options.split.band.h > 0, .{ at.first, at.last }, options.graph)), .frame = stage, .t = s.value(map.diving.land + map.diving.still), .cursor = at, .graph = options.graph });
whole.obj = s.custom(whole, .{ .x = -640, .y = -360, .scale = ui.scale });
whole.add(s, Source{ .cursor = at, .stage = whole.stage, .descent = options.descent });
whole.add(s, Source{ .cursor = at, .stage = whole.stage, .descent = options.descent, .part = .source_more });
- if (options.descent) whole.add(s, Descent{ .cursor = at, .stage = whole.stage }) else whole.add(s, Disasm{ .cursor = at, .stage = whole.stage });
+ if (options.graph) whole.add(s, graph.Map{ .cursor = at, .stage = whole.stage }) else if (options.descent) whole.add(s, Descent{ .cursor = at, .stage = whole.stage }) else whole.add(s, Disasm{ .cursor = at, .stage = whole.stage });
whole.add(s, Registers{ .cursor = at, .stage = whole.stage, .syscalls = options.syscalls, .quiet = options.quiet });
whole.add(s, Stack{ .cursor = at, .stage = whole.stage, .above = theme.map.stack_above });
// The stack goes on in the rest of the memory's column, from where its own column ends.
@@ -367,6 +372,7 @@ test {
_ = contexts;
_ = @import("disasm.zig");
_ = @import("descent.zig");
+ _ = graph;
_ = tying;
_ = @import("hexdump.zig");
_ = calls;
diff --git a/anim/src/theme.zig b/anim/src/theme.zig
index cb52287..7d505d7 100644
--- a/anim/src/theme.zig
+++ b/anim/src/theme.zig
@@ -134,6 +134,17 @@ pub const layout = struct {
/// its view 200 (a dump of seven); ten lines over nine
/// instructions; the registers over six words, a small frame whole.
pub const subject: Split = shared(296, 200, 10, 9, 6, 7);
+ /// The `blocks` lens: its drawing (the graph as shapes) 296 high
+ /// over the program column, which then holds the source alone
+ /// (twenty lines); its view the disassembly itself, seven rows over
+ /// the state column; the registers over six words.
+ pub const blocks: Split = blk: {
+ var s = subject;
+ s.disasm = .{ .x = state.x, .y = canvas.stage.y, .w = state.w, .h = panelH(7) };
+ s.view = .{ .x = state.x, .y = canvas.stage.y, .w = state.w, .h = 0 };
+ s.source.h = panelH(20);
+ break :blk s;
+ };
fn shared(drawing_h: f32, view_h: f32, source_rows: f32, disasm_rows: f32, slots: f32, dump_rows: u32) Split {
const band: Rect = .{ .x = program.x, .y = canvas.stage.y, .w = program.w, .h = drawing_h };
@@ -675,6 +686,66 @@ pub const metric = struct {
pub const bottom_lane = 8;
};
+ /// `graph` (design/README.md, "graph"): on the map a block is a head of
+ /// 24 and its rows: the offset ranged right at 72, the line at 116, the
+ /// mnemonic at 128, the operands at 212; 300 wide at least; over 16
+ /// rows, where the graph is too tall, its first four, `more` and its
+ /// last four. Layers 48 apart, blocks 56; lanes 16 apart from 24 in, the
+ /// blocks 24 right of the last; the first layer 36 under the tag; a back
+ /// edge down 14; ports 40 in; arrivals 48 apart; the right channel 32
+ /// out; corners 8; the way out's stub 14 and bar 28; a call's hook 14
+ /// out and back a row down. A fold of blocks never reached: 520 wide.
+ /// Columns are as far apart as the pc's block is wide with its annotation.
+ /// The `blocks` lens at half measure: boxes 24 high, 60 and 10 a row
+ /// wide, 132 at least, columns 300 apart; layers 12 apart, lanes 10.
+ pub const graph = struct {
+ pub const offset = 72;
+ pub const line = 116;
+ pub const mnemonic = 128;
+ pub const operands = 212;
+ pub const least = 300;
+ pub const long = 16;
+ pub const keep = 4;
+ pub const layer_gap = 48;
+ pub const block_gap = 56;
+ pub const lane = 16;
+ pub const lane_in = 24;
+ pub const top = 36;
+ pub const back_down = 14;
+ pub const port = 40;
+ pub const arrivals = 48;
+ pub const channel = 32;
+ pub const corner = 8;
+ pub const exit_stub = 14;
+ pub const exit_bar = 28;
+ pub const hook = 14;
+ pub const fold_w = 520;
+ pub const head = [2]f32{ 10, 10 };
+ /// The rows are `insn`'s, `shift` left (its address column given to
+ /// the offset); the pc's block widens to its column for the
+ /// annotation, 30 characters from where `insn` puts it.
+ pub const shift = 52;
+ pub const note = 360;
+ pub const lens = struct {
+ pub const box = 24;
+ pub const lead = 60;
+ pub const per_row = 10;
+ pub const least = 132;
+ pub const pitch = 300;
+ pub const layer_gap = 12;
+ pub const lane = 10;
+ pub const blocks_in = 76;
+ pub const top = 14;
+ pub const port = 16;
+ pub const channel = 20;
+ pub const back_down = 8;
+ pub const corner = 4;
+ pub const head = [2]f32{ 7, 8 };
+ /// The pc's box: framed gold this wide.
+ pub const gold = 3;
+ };
+ };
+
/// The ties' channels: the thread in the left margin, the gutter's two
/// lanes (a link comes up the left, a projection down the right).
pub const tie = struct {
@@ -932,6 +1003,25 @@ pub const time = struct {
pub const out = 0.20;
pub const names = 0.20;
};
+ /// `leave` (and `turn`, along a loop's lane): the jump fires; the
+ /// compare's chips framed as read from `chips` (the CPU's slot); the
+ /// edge it takes drawn gold over `edge`, ending as the mark sets off at
+ /// `sets_off`; the mark along it `mark` and `per_100` a 100 units,
+ /// `mark_most` at most (`run` at a run); the target's count struck
+ /// `count` after it lands; the oldest trail edge cooled over `trail`;
+ /// `rest` from the landing to the step's end.
+ pub const leave = struct {
+ pub const chips = 0.30;
+ pub const edge = 0.30;
+ pub const sets_off = 0.70;
+ pub const mark = 0.20;
+ pub const per_100 = 2.0 / 60.0;
+ pub const mark_most = 0.50;
+ pub const count = 0.10;
+ pub const trail = 0.30;
+ pub const rest = 0.70;
+ pub const run = 8.0 / 60.0;
+ };
/// A return in the calls tree: its frame leaves the backtrace as the
/// idea strikes, and the result on the node's shoulder this long after.
pub const badge_after = 0.20;
diff --git a/anim/src/ties.zig b/anim/src/ties.zig
index 58ada36..36dc635 100644
--- a/anim/src/ties.zig
+++ b/anim/src/ties.zig
@@ -197,7 +197,9 @@ pub const Ties = struct {
raw.at.xf = .identity;
const k = at.scale;
const split = g.stage.now(at);
- if (g.threaded) thread(raw.faded(@import("context.zig").thread_shows), at, k);
+ // No thread where the disassembly is not under the source (the `blocks` lens has it over the state column).
+ const apart = @abs(split.disasm.x - split.source.x) / (theme.layout.state.x - theme.layout.program.x);
+ if (g.threaded and apart < 1) thread(raw.faded(@import("context.zig").thread_shows * (1 - apart)), at, k);
if (g.beat) |b| named(raw, at, now, k, split, b);
if (!now.walking()) return;
if (!g.quiet) g.link(raw, at, now, k, split);