summaryrefslogtreecommitdiff
path: root/anim/README.md
diff options
context:
space:
mode:
authorGabriel Schneider <[email protected]>2026-11-11 17:42:07 -0300
committerGabriel Schneider <[email protected]>2026-11-11 19:11:00 -0300
commitb54c6776953d3243ab5b8e676e747713827ab320 (patch)
treed53be6cef4587b94531880af6479a1b5fa1aac39 /anim/README.md
parent3093eb55ac4a7054f51f06ea2786b5f9c9ec73f6 (diff)
downloadcomputeranim-b54c6776953d3243ab5b8e676e747713827ab320.tar.gz
computeranim-b54c6776953d3243ab5b8e676e747713827ab320.zip
canim: the disassembly under the source everywhere; rings
From the user. In every split the disassembly stays under the source; registers a scene never changes fold three to a row, and the stack takes the room: nine to twenty slots where it had six. The graph's first form is rings: a loop a ring its blocks sit on, an inner loop a smaller ring touching its parent, a way out leaving along the tangent; layers stay for functions without loops. Its layout comes from the code alone and it shows nothing from after the moment: a block not reached yet is quiet and is reached, a fold of what is not reached yet opens when the run arrives. A pane unrolls from its strip into its whole column and rolls back. The sqlite scene's strips move before their panes. Co-Authored-By: Claude Fable 5.2 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNCKgYCGiANnEwcEQxa
Diffstat (limited to 'anim/README.md')
-rw-r--r--anim/README.md296
1 files changed, 156 insertions, 140 deletions
diff --git a/anim/README.md b/anim/README.md
index c6e55bc..8c18c82 100644
--- a/anim/README.md
+++ b/anim/README.md
@@ -101,13 +101,13 @@ on a primary onset's frame and nothing on it moves a pixel in one.
| `title` | the series (six programs, named) and the legend of the marks the scenes use | a card | |
| `fib` | recursion: each call a frame and a node | `subject`, `calls` | `steps` |
| `list` | a list reversed: each `next` turned; it opens on the map and dives into the frame; after the first load the pointer loaded opens in a loupe, and the `next` in it one deeper | `subject`, `nodes` | `list` |
-| `sort` | insertion sort as its blocks: one trip of the inner loop walked a block at a time (each block's rows a cascade onto its last, then `leave` along the edge it takes: the compare's chips framed, the edge drawn gold, the mark along it, the target's count struck; `turn` up the inner loop's lane), the next trip at a run, the long middle a sprint on the map (`surface`, the gold going block to block, the counts growing, `dive`), the last value's trip walked again, the way out run | `blocks` (`graph.Blocks`; the disassembly its view over the state column, the source alone in the program column); on the map the graph with its rows (`Context.Options.graph`) | `sort` |
+| `sort` | insertion sort as its blocks, its loops as rings: one trip of the inner loop walked a block at a time (each block's rows a cascade onto its last, then `leave` along the edge it takes: the compare's chips framed, the edge drawn gold, the mark round the ring, the target's count struck; the swap's block `reach`ed the first time, its pill filling; `turn` round the inner ring's foot, `1 turn` struck at its centre), the disassembly unrolled for a beat (the function whole, `unroll` and `roll`), the next trip at a run, the long middle a sprint on the map (`surface`, the gold going round the rings and down the linear column, the counts growing, `dive`), the last value's trip walked again, the way out run | `blocks` (`graph.Blocks`, `rings`: the drawing 880 by 344 over the program column, no view, the source six lines and the disassembly eleven under it, the registers and a stack of twenty beside); on the map the same drawing over the source, the disassembly linear beside it (`Context.Options.graph`) | `sort` |
| `syscalls` | glibc's `hello`, by instruction from main: `open` followed down (main's call ringed, the PLT's stub passed, libc's wrapper run to its last three instructions and those walked, its source beside it where the build has it (open64.c, and sysdep-cancel.h where the pc is in what that header's macro made; `zig build sources`), the kernel's window at the floor with the call in C's form and `returns`, and back up), then `read`, `close`, `write` stepped over, each in three parts: the instructions before the call a cascade onto the call row, the crossing from that row with the kernel's window opening under it (the rows after it making room), the stores after it 18 f after rax | `beside`, `syscalls` (the calls so far, as strace writes them); the disassembly a `descent` (`Context.Options.descent`) | `hello` |
| `musl` | the same `hello` built by Zig against musl, static: `open` followed down with no PLT and no GOT, the source panel following the pc through musl's own files (open.c, `__syscall_cp.c`, the one line of `syscall_arch.h` that is the `syscall`), the kernel's window, and back up to `main` | `beside`, `syscalls`; the disassembly a `descent` | `musl` |
| `heap` | glibc's malloc under a list of three: three pushes, two pops, a push, told by motion.md's storyboard (nine captions; pushes 2 and 3 at a run; each `free` and the `malloc` that takes the head back walked; what the storyboard does not narrate runs: the calls into push and pop with their prologues, the returns to main but the one under the second free's long caption); the chunks by fields (`size`, `protected`, `key`), the program's list over the tcache's free list with its `bin` (a chunk in neither list drawn in the program's row, unarrowed), the tcache in a loupe over the stack, its stem down the gutter from its chunk's row, opened in each step that changes the tcache and closed at its advance | `subject`, the scene's own drawing (`nodes` in two rows) and view, both on its map too | `heap` |
| `zoom` | one line of C as its instructions, the call's bytes | `none`, the camera at x1.16 on the instructions and the stack in one view, cause and effect (the stack's window set before the move and held); the map's drawing the calls of `fib` (`Map.drawing`) | `steps` |
| `sqlite` | a row's way to disk in SQLite: from `sqlite3_step` to `sqlite3BtreeInsert` (three continues, the row's struct on the stack), the commit's `unixWrite` nine calls under `main`, `pwrite64` of page 2 into the kernel, and the page read as a B-tree leaf | `subject`, `backtrace` (`Context.Options.backtrace`), then `syscalls`; its view a `hexdump.Dump`; as the caption names them, rdi's `BtCursor` opened in a loupe, then rsi linked to its row in the view (`Context.tiesWith`); the page's fields named a group at a time, 2 s apart; the backtrace lens drawn on its map | `sqlite` |
-| `gallery` | every block in its states, a page or a state each 3 s; at 21 s the `blocks` lens (at rest, `leave` mid-way, `turn` landing, libc's `open` folded), at 24 s the graph with its rows as the map draws it, at half size (sort's panned to its loop; `open` at its `syscall`, the blocks not reached folded) | all three, `blocks` | `gallery`, and for the graph pages `test/gallery/sort.ztrace` and `hello.ztrace` |
+| `gallery` | every block in its states, a page or a state each 3 s; at 21 s the `blocks` lens (sort's rings at rest, `leave` mid-way, a `turn` landing with its ring's count struck; libc's `open` in `layers` at its `syscall`, what it has not reached folded), at 24 s the moves of a first time (sort's first swap `reach`ed, its pill filling; `open` stepped past its `syscall`, its fold mid-`unfold`; sort in `layers` panned to the pc; the fold open, at rest). Its context pages fold the registers its one step does not change | all three, `blocks` | `gallery`, and for the graph pages `test/gallery/sort.ztrace` and `hello.ztrace` (the second page's picture keeps the old name `graph-map.png`) |
## The blocks
@@ -116,26 +116,26 @@ every state the code has in the `gallery` scene.
| Layer | Block | Where | Notes |
| --- | --- | --- | --- |
-| 0 tokens | grid, colour, type, the splits | `src/theme.zig` | per "Token changes" (`metric.calls`, `time.pin`, `time.continue_wave`, `time.relayout_fade` there; the insn's character counts gone); JetBrains Mono NL (`.code*` faces) for all mono, Medium under 30 |
+| 0 tokens | grid, colour, type, the splits | `src/theme.zig` | per "Token changes" (`layout.split` and `layout.fit`, `metric.registers` (the quiet cells), `time.unroll` (`unroll`, `roll`, a far jump's travel; the extend's 4 f is `time.extend` now), `metric.calls`, `time.pin`, `time.continue_wave`, `time.relayout_fade` there; the insn's character counts gone); JetBrains Mono NL (`.code*` faces) for all mono, Medium under 30 |
| 1 atom | `address` (`lead`, `name`, `rwx`), `value` (and `Ui.typed`: `fd`, `bool`, `char`), `arrow` (`points`, `holds`, `more`), `mark`s, `plaque` (`chip`), `pin` (`row`, `under`; and at a view's row's end, `Ui.pinEnd`), `bracket` (`quiet`, `tie`, `thread`), `tag` | `src/ui.zig` (`Ui.address`, `.value`, `.arrow`, `.written`, `.corner`, `.read`, `.cellWritten`, `.cellRead`, `.current`, `.trail`, `.unknown`, `.chip`, `.pinRow`, `.pinUnder`, `.bracket`, `.panel`) | marks as mock 15's column B: `current` the white wash (`color.wash`) and the gold plaque; `struck` the softened paper (`color.struck`) with bold bright digits; `held` a turned corner (9; 12 on a lens's cell), in over the cool's last 6 f (`Heat.corner`, `time.strike.corner`); `armed`, `read` |
| | `byte` | `src/rows.zig` `bytes` | `number`, `pointer`, `text` (a string's ink), `loose` (a byte of no field: the allocator's, padding, past what a dump is of), `unread`; `pad`; `bytesAt` moves the bytes right of a long (stack) address, by the dump's widest; a write's arm, strike and held corner cover the bytes whose value changed, first to last (`Run.changed`, `Now.changedBytes`), struck a byte a frame from the low address (what a read fills, 2 f apart); until its strike lands (s+3) a run keeps its old bytes and their reading, through the arm, read by its old field where the step retypes it (`hexdump.keepOld`, `Fields.was`) |
| 2 row | `chain`, `reg` (and `rip` with the flags), `slot`, `line`, `bytes`, `call` (`span`, `callRow`) | `src/rows.zig` | `chain` follows `zt.telescope.chase`; cut at its far end, `more`; a register's reads memory as the panels show it, the step's bytes from their strike (s+3): its later hops fade out from the strike and are followed again 4 f after the bytes land (`Now.following`, `Marks.hops`). `slot`: pins from 16, the offset from rsp ranged right to 172, the address at 184, the chain, its role ranged right where the room ends (48 sooner in a pane: its strip), from `zt.telescope.slots` (`saved rbx`, a local's name in primary, `n, high half` for a narrower local in the word's top four bytes, `argc`, `argv[0]`, `argv end`, `envp end`, `auxv`; nothing for a return address or `.none`). `bytes`: the bracket at 24, the address at 34, the bytes 12 after it and at 132 at least |
| | `arc` | `src/rows.zig` (`Arcs`), `src/hexdump.zig` (`pointerArcs`) | a pointer to a row of its own panel: lanes at 4, 10, 16 in a dump or a loupe, 4 and 10 on the stack; longest outermost, a chain in one lane; standing at 60% toward the page, full in the step that writes or reads it and always in a loupe; rewritten: the old dashed with the arm, fading from 6 f after the strike as the new draws (12 f), quieting with the cool; a lane change glides while the arc that causes it draws or fades (`Arcs.assign`, with and without the arcs on their way); a stub to the rule for a target in the region past the window, only in its step; a saved rbp's only in its step, going with its advance (18 f); a dump withholds the arcs an open loupe carries |
| | `insn` | `src/disasm.zig` | columns at 2, 31, 40, 134, 180, 264, 564 (540 in a pane, whose strip takes 48 of the row; `map.content`); size words dropped from every operand, a `width` of byte cells (`metric.width`) after the `]` where no register outside the brackets has the access's size and the mnemonic does not fix it; `nop` and `endbr64` faint; a PLT target named (`401070 open@plt`); the annotation from 564 or a character after the operands, then the operands give way, never inside `[]`; `current`, `ran` (every instruction of the last three steps), `ahead`, `outside`, `waiting`, `pass`; the jump lane from the jump just before the pc's moment. The row's detail, every value the recording's at that moment: a compare's two values and the flags it leaves as chips (those the conditional after it reads; CF ZF SF OF when none); a conditional's `taken`/`not taken · reads` and its flags, `→ target` when it leaves the window, and while it runs the setting row's chips and rip's framed as read (an echo); `lea`'s `= value`; a call through memory or a register `→ target name · read from open@got, 403fd8` (out of room the slot goes, then the digits); a call through a PLT stub by the function it reaches (`the resolver` while its slot is lazy); `fs:[0x28]` as the stack's canary (`canary` where the row has no room); a `rep`'s count and step; `syscall` with its name and number, its arguments under it by register, typed (`-100 AT_FDCWD`, `O_RDONLY`), the rows they hang over giving up their own annotation; a call that has run in C's form with its result (`read(3, …) = 15`: out of room the arguments go from the right, the result stays); a memory access narrower than a word read at its width (`rows.narrow`: `7fffffffecc4 ◂ 15`) |
| | `descent` | `src/descent.zig` (`Descent`, `step`) | the disassembly a call deep: the root's window on top (main), each callee's under the row that called it (that row `waiting`, ringed, its annotation the call in C's form), a PLT stub gone through kept as its `jmp`, `pass`; a head row over each window (the name at 40, Go Medium 18; what it is ranged right: `libc.so.6 · open64.c` (the file of its function's entry, where the build has the source), `libc.so.6 · no source`, `the PLT · its jmp reads open@got, 403fd8`, `the PLT, jumped through`); the call lane at x 14; the nearest caller takes the rows the deepest does not use, all above its call row (one row after it, the return row, the callee's head directly under that), and where its function starts first the rest go back to the deepest window; three code windows at most, the rest one `more` row; each window's addresses its own width; the tag the deepest function and its module (`open · libc.so.6`); at a `syscall` (and the stop after it) the floor's three rows are the kernel's: in a crossing the lane down from the plaque (3, vellum), the window filling down, `the kernel` and `openat, system call 257`, the call in C's form, `returns` struck, `rcx, r11: clobbered`, the answer climbing the lane (24 f, `glide`), the window drawing back at the advance. A crossing stepped over opens the same window under the call row, past the arguments hanging under it, the rows after them making room (18 f) and closing up with the window. Every row keyed (an address, a head), so a step is the rows both stops have gliding and the rest leaving or arriving on its verb's timetable, in two moves, never at once: `descend` (2.9 s: the given-up rows fade 66–78, the kept ones glide 78–96, ring 84–96, lane 96–114, head 108–120, rows 114–138), on through a stub's `jmp` (2.2 s), `ascend` (2.5 s: the window closes 48–72, lane back 72–84, the kept rows glide 84–102, the given-up ones fade in 102–114), `cross` (`syscalls.step`); a row whose state the verb changes (the call row to `waiting` with its hanging arguments, a jmp to `pass`, a waiting call taking its result) crossfades; with it the source's line `waiting` where the pc is in code without source (ringed, the tag `main waits at line 6 · the pc is in libc's open`, crossfading over the 12 f before the advance, as a stack span's name does) and the thread waiting (primary, 2); where the build has the library's source the panel goes on with the pc into it. Its strip is the deepest window's function's linear column (a `Disasm` drawn for the strip alone, `Map.In.strips`), that window framed on it; going down or up it fades through as the mark lands (`map.through`) |
-| 3 panel | `registers`, `stack`, `backtrace` | `src/context.zig` | rip's value crossfading over the advance, a flag set or cleared over the 6 f it lands in (`rows.RipWas`); the backtrace newest at the bottom, `#0` last, the oldest dropped from the top (`newest at the bottom · 2 more above`), as a panel, the calls lens's view, the backtrace lens and on the map, all one block (`backtraceRows`: frames leave, slide and arrive; what a kept row says that changes, its depth, its pc's offset, its line, and the tag's count, crossfades, 12 f before the advance); the stack's window on `[rsp, rbp+16)` keeping the touched word in view, its tag the first and last word shown (`rsp+20 to rsp+48`), a word's role and offset, and the tag, crossfading (12 f from memory's strike) where the step changes them, rsp and rbp's pins travelling 18 f after rsp's strike (`time.pin`, keeping their place among the names they leave and join), at rest only where the register points; a window that moves farther than its own height (six or eight slots) fades out and in round memory's strike (12 f each; at a run half its step each), and what it brings, and what changed before it, is plain; while rows slide they keep their roles (those of both windows are read), and a word becoming a saved rbp, or no longer one, has its arc go or come with its role; a frame's name longer than the spans' room shortens the chains beside it; `call` spans and the backtrace (`#n`, name, arguments at 384, file and line) from `zt.telescope.frames`, the frames two stops share sliding to their new depth; the backtrace as a lens's drawing with `Context.Options.backtrace` |
-| | `source` | `src/source.zig` | the file the pc is on a line of, of the recording's sources (`Recording.sources`, `shown`: the program's own, or a library's the build gave; else the last such line, a frame up, where the pc waits), whole in a window, its middle third; its lines cut at 63 characters in a pane (67 on the map); the trail's bars (of that file's lines) crossfading with the advance; numbers as wide as the widest file's largest line (SQLite's six digits), the text moved right by as much; another file: the panel fades through (12 f out, 12 f in), its tag's title and note crossfading with it, its strip with it (`map.through`); a window going farther than its own height in one file: the advance is 48 f, the window gliding on the strip for the first 24 (the gold lit on its new row there), then the pane out and in |
-| | `disasm` | `src/disasm.zig` | 17 rows (9 as subject), fewer above near a function's start; on the map 69 from the function's start where the pc is in its first three quarters (a strip's column stays still while the pc walks it), else round the pc; the line column as wide as the source's, a row's number where its line is of the file the source panel shows (libc's rows open64.c's while it shows open64.c, main's none then); two windows that overlap scroll, others fade out and in; its tag's function (a descent's tag too) crossfading with the advance; a 2-unit `rule` across over each block's first row (not its function's), and the block's visits by the moment shown ranged right, faint (`×3`), where the row's annotation leaves room, crossfading with the advance (`graph.Rules`, a descent's windows too); the rows clipped above the panel's padding (a row scrolling out takes its rule with it) |
-| | `graph` | `src/graph.zig` (`read`, `fold`, `place`, `layout`, `Blocks`, `Map`, `Rules`) | the function's blocks from the recording (`zt.telescope.blocks`; a block of `nop` padding nothing goes to left out), their edges by how each ends, and the run over them by the moment shown: each block's visits, each edge's count, the last three edges taken, the pc's block; counted where one stop in the function follows another across an edge, and only for a recording that stops at every instruction (`exact`; by line, visits only, every edge `rule`). Laid out (`place`, pure, by the whole recording's counts, so it never moves as they grow): back edges by a walk from the entry in address order, layers by the longest forward path, the blocks that return last; in a layer a block under the predecessor that reached it most often, then under the one it falls from, a taken target never taken right of it, the more travelled first where two want one column; columns a pitch apart (the map's as wide as the pc's block with its annotation, 928; the lens's 300); a forward edge out of the bottom on its target's side (40 in, 16 in the lens; the middle when straight below), along the gap's middle, into the target's top (arrivals 48 apart), through the right channel (32 out) where it would cross a block; a back edge down 14, out to its loop's lane (16 apart from 24, the outermost farthest), up, into its header's head. Too tall for its place (`layout`), in the catalogue's order: each run of blocks the whole recording never reached (neighbours in address order joined by an edge; split where folding would make a loop the code does not have) one dashed box, `+5b to +b9 · 5 blocks not reached` (said of the run so far: a graph says only what has happened by the moment shown, never what will not; which blocks fold, and where each block is placed, are still chosen by the whole recording); then blocks over 16 rows to four, `more`, four (not the pc's); then it pans, whole layers, to the largest loop the pc's block is in that fits, else the pc's block in the middle. The static part kept per function and form (`memo`), the moment's counts counted again each frame. `Blocks`: the lens's drawing, boxes 24 high, 60 and 10 a row wide (132 at least), the offset, the visits (`dim`), reached `raised`, not yet on the page, a fold dashed, the pc's framed gold 3; the edges never taken `rule`, taken `dim`, the trail's golds (the newest 3), a loop's turns on its lane (Go 18). `Map`: on the map two columns wide beside the source, each block a head (its address, `lines a to b`, `×n` primary) over `insn`'s rows moved 52 left, the offset where the address was (ranged right at 72); the annotation only in the pc's block (and its rows that ran in the last three steps, with their trail bars), which widens to its column, its rows' annotations kept inside it; a conditional's counts by its ports; a direct call's hook out of the block's side and back a row down, the callee named (`swap`); under a return the way out (stub 14, bar 28), a tail call's stub and name, an indirect jump's `targets not known` |
-| | `blocks` lens | `src/graph.zig` (`Blocks`), `theme.layout.split.blocks` | its drawing the graph as shapes over the program column (296 high), which then holds the source alone (twenty lines); its view the disassembly itself, seven rows over the state column; the registers over six words; no thread (the disassembly is not under the source: it fades with the distance between them) |
+| 3 panel | `registers`, `stack`, `backtrace` | `src/context.zig` | the registers `quiet` (`Registers.moves`, `movedBy`, `registerRows`): the scene's set chosen once, from its clock's way (`Cursor.journey`: the registers any of its steps of that kind changes, net, with rsp, rbp and rip), each a row with its chain; the rest folded three to a row on a pitch of 285 under a 2-unit rule, in pwndbg's order (`rows.quiet`: the name faint at 12, the value at 60, a pointer cut to `more` at once, a code address alone; framed as read while it carries a system call), rip last; the panel as tall as its rows and the stack the rest (`layout.fit`); in a `dive` it arrives whole from the map and folds as it lands (`Zoom.fold`: each quiet row gliding into its cell, the chain past its first hop gone over the first 40% of the move, a rule fading in); rip's value crossfading over the advance, a flag set or cleared over the 6 f it lands in (`rows.RipWas`); the backtrace newest at the bottom, `#0` last, the oldest dropped from the top (`newest at the bottom · 2 more above`), as a panel, the calls lens's view, the backtrace lens and on the map, all one block (`backtraceRows`: frames leave, slide and arrive; what a kept row says that changes, its depth, its pc's offset, its line, and the tag's count, crossfades, 12 f before the advance); the stack's window on `[rsp, rbp+16)` keeping the touched word in view, its tag the first and last word shown (`rsp+20 to rsp+48`), a word's role and offset, and the tag, crossfading (12 f from memory's strike) where the step changes them, rsp and rbp's pins travelling 18 f after rsp's strike (`time.pin`, keeping their place among the names they leave and join), at rest only where the register points; a window that moves farther than its own height (six or eight slots) fades out and in round memory's strike (12 f each; at a run half its step each), and what it brings, and what changed before it, is plain; while rows slide they keep their roles (those of both windows are read), and a word becoming a saved rbp, or no longer one, has its arc go or come with its role; a frame's name longer than the spans' room shortens the chains beside it; `call` spans and the backtrace (`#n`, name, arguments at 384, file and line) from `zt.telescope.frames`, the frames two stops share sliding to their new depth; the backtrace as a lens's drawing with `Context.Options.backtrace` |
+| | `source` | `src/source.zig` | fourteen lines alone, eight with a lens, six with `blocks`; the file the pc is on a line of, of the recording's sources (`Recording.sources`, `shown`: the program's own, or a library's the build gave; else the last such line, a frame up, where the pc waits), whole in a window, its middle third; its lines cut at 63 characters in a pane (67 on the map); the trail's bars (of that file's lines) crossfading with the advance; numbers as wide as the widest file's largest line (SQLite's six digits), the text moved right by as much; another file: the panel fades through (12 f out, 12 f in), its tag's title and note crossfading with it, its strip with it (`map.through`); a window going farther than its own height in one file: the advance is 48 f, the window gliding on the strip for the first 24 (the gold lit on its new row there), then the pane out and in |
+| | `disasm` | `src/disasm.zig` | under the source in every split: 17 rows (11 as subject and with `blocks`), fewer above near a function's start; on the map 69 from the function's start where the pc is in its first three quarters (a strip's column stays still while the pc walks it), else round the pc; the line column as wide as the source's, a row's number where its line is of the file the source panel shows (libc's rows open64.c's while it shows open64.c, main's none then); two windows that overlap scroll, others fade out and in; its tag's function (a descent's tag too) crossfading with the advance; a 2-unit `rule` across over each block's first row (not its function's), and the block's visits by the moment shown ranged right, faint (`×3`), where the row's annotation leaves room, crossfading with the advance (`graph.Rules`, a descent's windows too); the rows clipped above the panel's padding (a row scrolling out takes its rule with it) |
+| | `graph` | `src/graph.zig` (`read`, `layout`, `place`, `Blocks`, `Rules`, `leave`) | the function's blocks from the recording (`zt.telescope.blocks`; a block of `nop` padding nothing goes to left out), their edges by how each ends, and the run over them by the moment shown and nothing after (design/README.md, Forbidden): each block's visits, each edge's count, the last three edges taken, the pc's block, counted where one stop in the function follows another across an edge (`exact`: by instruction; by line, visits only). Laid out from the code alone (`place`: never the run's counts), in two forms (`Blocks.form`): `rings` wherever the function has a loop (natural loops merged by header, back edges by the walk from the entry in address order; each a ring, its pills upright at their centres clockwise from the header at 9 o'clock, radius as its pills need, 12 apart and 24 of arc between two; a nested loop a smaller ring outside its parent touching it at its header, the parent's 3 o'clock; an edge to the next pill an arc of its ring cut at the pills' frames, the back edge round the ring's foot, a fork inside a loop an arc 30 inside, a way out along the tangent out of the pill's foot 30 in from its far end, then quarter circles of 16; outside every loop the blocks as `layers` lays them, the entry left of the header, the blocks after under it; `3 turns` 30 under the ring's centre, from the first) and `layers` (layers by the longest path, a block under its fall-through predecessor, a taken target right of it, back edges up lanes on the left, every corner a quarter circle of 12; panning by thirds round the pc's pill where it is taller than its pane). A block a pill 24 high: its offset, the program's callees after it, faint (the tracer's `__zt_*` left out), its visits ranged right, room kept for `×99` so it never widens as the run counts; not reached yet on the page, `rule` framed, faint, no count; the pc's framed gold 3. Edges not taken yet `rule`, taken `dim`, the trail's golds, the newest 3. Too big for its pane (`layout`), the blocks not reached by the scene's first moment fold (`cursor.first`: the code beyond each way the run had not taken, `+5b … · 7`), keeping a fold's room; a fold opens when the run reaches a block of it and never closes (`unfold`: the pills beyond make room 24 f, `glide`, the fold's blocks fade in quiet 12 f, 2 f apart, then the mark lands). `leave` and `turn` along the curves (12 f and 2 f a 100 units, 12 to 42 f; the turn's count at the ring's centre armed as the mark leaves the latch, struck as it lands); `reach` (the edge from `rule` to gold under the mark, the pill filling page to `raised` 12 f, `×1` in 6 f and struck). Kept per function, form, room, first moment and open folds (`memo`), counted again each frame. On the map the drawing is the lens's at its size over the source, the disassembly linear beside it (`Rules`) |
+| | `blocks` lens | `src/graph.zig` (`Blocks`), `theme.layout.split.blocks` | its drawing the graph, 880 by 344 over the program column (`rings`, or `layers` for a function with no loop: `Blocks.form`); no view: its rows are the disassembly under the source (eleven), each block's first row ruled with its visits, the thread from the source's line to them; the state column the registers and a stack of twenty from its top |
| | `hexdump` | `src/hexdump.zig` | malloc's words: a field read as `size` (`0x20 a m P`, the bits as rip's flags) or `protected` (`→ 405050 ^ 405`, `NULL ^ 405`, its arc to the pointer it protects), and a field's `note` (Go 18 faint: `key`, `top`, `slots left`); a lens's view (`hexdump.panel`): `bytes` rows and their reading, veiled at a sprint; a row whose bytes the step changed where the recording saw no write (memory nothing watches, read anew at a stop), or that became known, crossfading over 12 f (`rowPasses`); one reading for every dump (`hexdump.reading`), a list a character apart, a typed number as its type reads (`char` quoted, `bool` by name); the address room once a dump, by its widest; `Dump`, a view of a region by the fields a scene gives it (`Field`: where, how long, read as a number, big-endian or not, a pointer, text, or left to the eye), the rows that hold a field and a `more` row for each stretch left out, and where those rows outnumber the window, a window kept round the first row a mark or the step is on, the rest folded into `more` rows; marks the scene plays, and the step's only from the stop it came in at (`since`); the bytes a syscall was given as the kernel took them (`given`), and only what the debugger read at the stop (`seen`) |
| | `loupe` | `src/loupe.zig` (`canim.loupe`, `Loupe.open`, `.close`) | from a register, a loupe's field, or a dump's row read by the scene's fields (`.row`: malloc's tcache, `num_slots[0]` and `entries[0]`, the rest `more`); five rows round a pointer's target, lifted (`color.lift`, `lift_tag`, `shade` 12 and 16; 20 and 26 deeper), hanging from its pointer (its tag on the row's foot, 92 left of the digits, clamped to the stage), a 4-high bracket under the digits its stem, the target's fields framed bright; one opened from the band's view lies over the stack, never the registers, its stem down the gutter's right lane (x 962), its fields struck once it has opened (6 f after, 6 f apart: `Fields.struck`); a deeper one with no room to the right hangs under the one it opens from, its stem down to its tag; a note that does not fit is cut at a word with `…`; `open` 36 f (read 6, stem and rise 18 with the shadow, the frame 6 f after), `close` 12 f; it opens again after a close |
-| | lenses: `nodes`, `array`, `calls`, `syscalls`, `backtrace` | `src/nodes.zig`, `src/array.zig`, `src/calls.zig` (`Tree`), `src/syscalls.zig` (`Crossing`), `src/context.zig` (`Backtrace`, `lens`) | the drawing in `band` (over the program column), its view in `view` (over the state column): `nodes` and `array` a dump (`hexdump.panel`), `calls` the backtrace with arguments, `syscalls` the calls so far as strace writes them (oldest on top, the newest coming in once it is back, held; the rows make room for it, a full log scrolling a row, 24 f, `glide`, the count above crossfading; out of room a row gives up its faint names first, then its arguments from the right, and keeps what it returned; a path by its string, the kernel's capture where the stop did not read it) over the bytes the call crossing in the step is given or fills (in with the argument framing, 12 f out and 12 f in; what a read fills landing a byte every 2 f, struck, the stack's words with them; a write's buffer framed as read while the kernel takes it; cleared with the log's new row: between crossings `no call crossing now`), `backtrace` (eleven rows as subject, five beside) a `Dump` the scene gives; an `under` pin's names in the order they came, the first left, faded out through the middle of a register's joining or leaving (`Pins.text`); a call node's look (gold, ringed, done) crossfading as the tree's moment changes (6 f), and at a sprint a new node coming in over its step; a left child's result on its left shoulder, off its parent; a view's row a register points into carries the register's `pin` at the row's end (`hexdump` `rowPin`; 48 to the left in a pane, its strip at the right), the reading ending before it; at a sprint the array's pins hold and move where a phrase ends |
+| | lenses: `nodes`, `array`, `calls`, `syscalls`, `backtrace` | `src/nodes.zig`, `src/array.zig`, `src/calls.zig` (`Tree`), `src/syscalls.zig` (`Crossing`), `src/context.zig` (`Backtrace`, `lens`) | the drawing in `band` (over the program column), its view in `view` (over the state column): `nodes` and `array` a dump (`hexdump.panel`), `calls` the backtrace with arguments, `syscalls` the calls so far as strace writes them (oldest on top, the newest coming in once it is back, held; the rows make room for it, a full log scrolling a row, 24 f, `glide`, but from rest at least a pixel a frame (the rows are drawn on whole pixels), the count above crossfading; out of room a row gives up its faint names first, then its arguments from the right, and keeps what it returned; a path by its string, the kernel's capture where the stop did not read it) over the bytes the call crossing in the step is given or fills (in with the argument framing, 12 f out and 12 f in; what a read fills landing a byte every 2 f, struck, the stack's words with them; a write's buffer framed as read while the kernel takes it; cleared with the log's new row: between crossings `no call crossing now`), `backtrace` (eleven rows as subject, five beside) a `Dump` the scene gives; an `under` pin's names in the order they came, the first left, faded out through the middle of a register's joining or leaving (`Pins.text`); a call node's look (gold, ringed, done) crossfading as the tree's moment changes (6 f), and at a sprint a new node coming in over its step; a left child's result on its left shoulder, off its parent; a view's row a register points into carries the register's `pin` at the row's end (`hexdump` `rowPin`; 48 to the left in a pane, its strip at the right), the reading ending before it; at a sprint the array's pins hold and move where a phrase ends |
| 4 tie | `thread`, `link` (and its `pin`), `projection`, `echo` | `src/ties.zig` | panels publish places (`anchor`); `Ties`, added last, draws in the channels: a link climbs to a node by the gutter's left lane and goes down to a slot by the right, its name riding its head, a target past the stack's window a stub and a row count; to a view's row (`dump_pin`) by the left lane, into the row's edge; on a beat the narration names (`Context.tiesWith`, `ties.Beat`): the register framed as read, then its link, held, drawn back with the frame; a projection from the view's bytes, or from a frame's return address to its call's node |
-| 5 frame | `map`, `minimap`, `dive`, `surface` | `src/map.zig` (`Map`, `split`, `strip`, `Map.strips`), `Context.map` | the working frame's panels bound to a stage of 3840 by 2160 (`map.split`, packed by content: each box as long as the most rows its panel has wanted, `measure`, the backtrace's as long as the deepest call chain of the scene's way, so that it is packed once; the drawing, the source and under it the backtrace; the disassembly; the view (none where nothing draws one), the registers, and in the column's rest the stack going on, `stack, continued`; the stack from 16 words above rsp; and the first two columns' rest (`Split.spare`) given, in the catalogue's order, to `map.Spare`: a five-row dump round each place the registers (pwndbg's order, not rsp or rbp) and the 64 words up from rsp point at outside the stack and the code, none within another's rows, then the loupes open (`Map.loupes`, lifted, nine rows), then the key (the recording and the moment, the marks as drawn, the inks); only then page); its rows published while `ui.mapping` (the dumps' too); the working windows outlined (2 `dim`, 4 out), each window published with where its step took it from and how far its scroll has gone, so its outline glides; the thread across the gutter (x 1008), gold; a scene without a band can put a drawing on its map (`Map.drawing`); with `Context.Options.graph` the disassembly is the function's graph (`graph.Map`), two columns wide beside the source, the registers over the stack in the last column, no band (the lens's window on it is the graph whole, the disassembly's the box round the rows it shows), no thread line (the gold line number is the thread). Each pane's minimap (`map.strip`): a strip 40 wide inside its frame at its right, under the tag, on `well` (`theme.strip`), drawn from its column of the map (the source's boxes, the stack's with `stack, continued`, the view's dump; the disassembly's the linear rows round the pc, drawn for the strips alone where the map has a graph or a descent: `Map.In.strips`) at 4 units a row and 36 of 880 across, from what the map drawn for it collects (`ui.strokes`, `ui.collected`: each run of text a stroke 3 high in its ink 65% from the page, the marks 4 by 4 at a row's left in the catalogue's order, an arc with an end off the window a 2-unit line down the left edge, a block's first row ticked); a column longer than the strip the rows round its window, the window in the middle, clamped to the ends, three faint dots where it goes on (fading in over its first row's scroll); the window framed 2 in primary; a mark no working window shows (a word struck or read on the stack or in the view's dump) flashing on its row (a ring 8 to 14 in the mark's colour, 12 f). The strips are one image a frame (`Map.strips`): the map drawn for them six times, each from the cursor's mirror a frame later (6 to 11 f behind: `Cursor.lagInto`) with the panes' windows as long ago (`past`), every strip drawn as it shows (its rows, dots and window in place) and the six averaged, so that every change on a strip fades in over 6 f from 6 f after its onset and nothing on it moves a pixel in a frame; the panes blit their part (source, disassembly and its descent and the `blocks` lens's view, stack, a dump's view: not the registers, a drawing, a loupe, the backtrace, the `syscalls` lens's log). A pane with a strip has 48 less for its rows (`map.content`). `Map.show`, `.dive` (outlines bright 6 f, veil to 24, each panel from its window to its place 60 f, 6 f apart, a panel drawn over another setting off first (drawing, view, disassembly, stack, source, registers) so that none in its place is crossed by one on its way, opaque on the way, its rows on the window's rows, its tag and rules in from 84 f; with each, the rest of its column (the rows its strip shows) squeezing from its place on the map into the strip, its width and height each on its logarithm (to 36 of 880, 4 of 24 a row), its window's outline riding on it, gone into the strip's own drawing over the 12 f before its pane lands (`Map.squeeze`, `stripShows`); the map's other parts fading where they are, 24 to 72; 120 f and 30 f still), `.surface` (the dive back, 84 f, then 30 f still); per-panel transforms through `context.at` (`context.zoomed`); the clock's count ranged right at 1856 |
-| | `stage` and `relayout` | `src/stage.zig` | splits `none`, `beside`, `subject` (`theme.layout.split`): the band is `band` (the drawing) and `view`; `relayout` fades the drawing round its move; `holdStack` holds the stack's window for the camera, with `free` slots |
+| 5 frame | `map`, `minimap`, `dive`, `surface` | `src/map.zig` (`Map`, `split`, `strip`, `Map.strips`), `Context.map` | the working frame's panels bound to a stage of 3840 by 2160 (`map.split`, packed by content: each box as long as the most rows its panel has wanted, `measure`, the backtrace's as long as the deepest call chain of the scene's way, so that it is packed once; the drawing, the source and under it the backtrace; the disassembly; the view (none where nothing draws one), the registers, and in the column's rest the stack going on, `stack, continued`; the stack from 16 words above rsp; and the first two columns' rest (`Split.spare`) given, in the catalogue's order, to `map.Spare`: a five-row dump round each place the registers (pwndbg's order, not rsp or rbp) and the 64 words up from rsp point at outside the stack and the code, none within another's rows, then the loupes open (`Map.loupes`, lifted, nine rows), then the key (the recording and the moment, the marks as drawn, the inks); only then page); its rows published while `ui.mapping` (the dumps' too); the working windows outlined (2 `dim`, 4 out), each window published with where its step took it from and how far its scroll has gone, so its outline glides; the thread across the gutter (x 1008), gold; a scene without a band can put a drawing on its map (`Map.drawing`); with `Context.Options.graph` the map's drawing is the `blocks` lens's (`graph.Blocks` at its size, 880 by 344, over the source: `split`'s band is the working frame's), the disassembly linear beside it with its blocks ruled. Each pane's minimap (`map.strip`): a strip 40 wide inside its frame at its right, under the tag, on `well` (`theme.strip`), drawn from its column of the map (the source's boxes, the stack's with `stack, continued`, the view's dump; the disassembly's the linear rows round the pc, drawn for the strips alone where the map has a graph or a descent: `Map.In.strips`) at 4 units a row and 36 of 880 across, from what the map drawn for it collects (`ui.strokes`, `ui.collected`: each run of text a stroke 3 high in its ink 65% from the page, the marks 4 by 4 at a row's left in the catalogue's order, an arc with an end off the window a 2-unit line down the left edge, a block's first row ticked); a column longer than the strip the rows round its window, the window in the middle, clamped to the ends, three faint dots where it goes on (fading in over its first row's scroll); the window framed 2 in primary; a mark no working window shows (a word struck or read on the stack or in the view's dump) flashing on its row (a ring 8 to 14 in the mark's colour, 12 f). The strips are one image a frame (`Map.strips`): the map drawn for them six times, each from the cursor's mirror a frame later (6 to 11 f behind: `Cursor.lagInto`) with the panes' windows as long ago (`past`), every strip drawn as it shows (its rows, dots and window in place) and the six averaged, so that every change on a strip fades in over 6 f from 6 f after its onset and nothing on it moves a pixel in a frame; the panes blit their part (source, disassembly and its descent and the `blocks` lens's view, stack, a dump's view: not the registers, a drawing, a loupe, the backtrace, the `syscalls` lens's log). A pane with a strip has 48 less for its rows (`map.content`). `Map.show`, `.dive` (outlines bright 6 f, veil to 24, each panel from its window to its place 60 f, 6 f apart, a panel drawn over another setting off first (drawing, view, disassembly, stack, source, registers) so that none in its place is crossed by one on its way, opaque on the way, its rows on the window's rows, its tag and rules in from 84 f; with each, the rest of its column (the rows its strip shows) squeezing from its place on the map into the strip, its width and height each on its logarithm (to 36 of 880, 4 of 24 a row), its window's outline riding on it, gone into the strip's own drawing over the 12 f before its pane lands (`Map.squeeze`, `stripShows`); the map's other parts fading where they are, 24 to 72; 120 f and 30 f still), `.surface` (the dive back, 84 f, then 30 f still); per-panel transforms through `context.at` (`context.zoomed`); the clock's count ranged right at 1856. `unroll` and `roll` (`Map.unroll`, `.roll`, `map.Unroll`, added over everything by `Context.ties`): the panes veiled and the strip's window framed bright (18 f), the pane's whole column growing out of its strip (36 f, `glide`) to as many rows as the stage holds (24 a row at most; right on the strip's edge, the window's rows level with the pane's where the stage allows), its scale on the logarithm from the strip's, the window's outline riding from the strip to the pane's rows in it; held as the scene says; `roll` the reverse (36 f), the veil lifting (18 f). A far jump in the same column at a walk (the source's window farther than its height to lines the map's column of the file holds too, `source.unrolling`, `inColumn`: no step said faster in a hurry) is `unroll`, the window travelling along the column (24 f, `glide`, the mark lighting gold at its new line as the window gets there, the tag's note changing then), `roll` (96 f: `Cursor.travel`), the pane going into the column and coming out of it at its new place, never a fade. Out of the column (another function, a long file) the map's column goes over as the advance starts, so the strip (6 to 11 f behind, a 6 f crossfade) shows where the pane goes before the pane fades through (`over`, `far` on the map at half its height); a window going farther than the column holds keeps its place on the strip until the column goes over (`spanOf2`); the tag's line range changes with the pane's fade; the map's disassembly is measured by the moment the pane shows (a continue repacks the map as the pane gets there), and a recording of breakpoints has its deepest chain read at every stop (`deepest`: the backtrace's box packed once) |
+| | `stage` and `relayout` | `src/stage.zig` | splits `none`, `beside`, `subject`, `blocks` (`theme.layout.split`, layout A: the disassembly under the source in every split; the source 14, 8, 8 and 6 lines, the disassembly 17, 17, 11 and 11 rows; `blocks` a drawing of 880 by 344 over the program column and no view, the state column the registers' and the stack's from the top), each for a registers panel of eleven rows; `layout.fit` gives the scene's registers their rows and the stack the rest above the backtrace, whole slots, any rest above it (`Stage.registers_rows`: every split a `relayout` goes to keeps them); the band is `band` (the drawing) and `view`; `relayout` fades the drawing round its move; `holdStack` holds the stack's window for the camera, with `free` slots |
| | `clock`, `caption`, `veil`, `card` | `src/words.zig`, `src/root.zig` (`Narrator`, `Camera`) | the clock still while a step plays, its piece fading in once the mark lands; a caption stays its reading time; the title card is `scenes/title.zig` |
-| 6 verb | `fire`, `arm`, `strike`, `cool`, `read`, `extend`, `link`, `project`, `travel` (pins), `advance`, `cascade`, `continue` (`Cursor.continue`, `Plan.wave`), `run`, `sprint`, `establish` (`Context.establish`: a drawing's elements fade in rising, no lines), `scroll`, `relayout`, `visit`, `say`; `leave` and `turn` (`graph.leave`, from a block's last row, `graph.toEnd` to get there: fire 0–12; the compare's chips framed as read from 18 (the CPU's slot, the jump's echo), held while the edge draws gold, head first, 24–42; the mark (a gold plaque, half size in the lens) along the edge 42 to 42 + 12 f and 2 f a 100 units of the lens's edge (30 f at most), up the lane for a turn; landing, the advance; the target's count armed and struck 6 f after (a turn's lane count as it lands), cooled to nothing by the step's end; the trail recoloured over 18 f from the landing; a rest of 42 f from the landing); over a graph at a walk of several blocks, a run or a sprint the trail, the counts and the gold crossfade with the advance (8 f at a run, the step at a sprint), the pan gliding with it | `src/cursor.zig` (the timetable), `src/graph.zig` (`leave`, `instant`), the blocks (each draws its state at the instant) | tokens in `theme.time`; a level gives up its slot when nothing it touched is drawn (`Recording.drawn`); a label that changes in place with a step crossfades over the 12 f before the advance, or from the step's start where that is sooner (`Now.renaming`); at a run what marked a value goes with the run's ease (8 f) and a pin changes over it; at a sprint an ember and what grows come in over the step (4 f), never in a frame |
+| 6 verb | `fire`, `arm`, `strike`, `cool`, `read`, `extend`, `link`, `project`, `travel` (pins), `advance`, `cascade`, `continue` (`Cursor.continue`, `Plan.wave`), `run`, `sprint`, `establish` (`Context.establish`: a drawing's elements fade in rising, no lines), `scroll`, `relayout`, `visit`, `say`; `unroll` and `roll` (`Map.unroll`, `Map.roll`, above); `reach` and `unfold` (`graph`, above); `leave` and `turn` (`graph.leave`, from a block's last row, `graph.toEnd` to get there, along the curves of `rings` or `layers`: fire 0–12; the compare's chips framed as read from 18 (the CPU's slot, the jump's echo), held while the edge draws gold, head first, 24–42; the mark (a gold plaque, its point the way it goes) along the edge 42 to 42 + 12 f and 2 f a 100 units of the drawing's edge (42 f at most), round the ring's foot for a turn; landing, the advance; the target's count armed and struck 6 f after (a ring's turns at its centre armed as the mark leaves the latch, struck as it lands), cooled to nothing by the step's end; the trail recoloured over 18 f from the landing; a rest of 42 f from the landing); over a graph at a walk of several blocks, a run or a sprint the trail, the counts and the gold crossfade with the advance (8 f at a run, the step at a sprint), the pan gliding with it | `src/cursor.zig` (the timetable), `src/graph.zig` (`leave`, `instant`), the blocks (each draws its state at the instant) | tokens in `theme.time`; a level gives up its slot when nothing it touched is drawn (`Recording.drawn`); a label that changes in place with a step crossfades over the 12 f before the advance, or from the step's start where that is sooner (`Now.renaming`); at a run what marked a value goes with the run's ease (8 f) and a pin changes over it; at a sprint an ember and what grows come in over the step (4 f), never in a frame |
`Recording` (`src/Recording.zig`) is the index every block reads: lines,
calls, syscalls, allocations, which registers and bytes each moment changed
@@ -222,8 +222,10 @@ holds is named from its module's first mapping (`list+2c89`).
`tools/chart.py chart` on the 1080p exports (the designer's
`design/motion/motion.py`, its checks and its regions told where canim's
-panels are (sort's the `blocks` split's: the drawing, the view that is
-the disassembly, the source alone, the registers and the stack), each
+panels are, by split and by each scene's registers panel (layout A: the
+registers as tall as the scene's rows, `chart.py`'s `split(…, regs)`;
+sort's the `blocks` split's: the drawing, the source and the disassembly
+under it, the registers and the stack), each
pane's strip a region of its own (`source strip`, `disasm strip`,
`stack strip`, and `view strip` where the view is a dump: `motion.strips`,
the pane's region stopping 42 short of its right edge), secondary action
@@ -253,47 +255,54 @@ list's dive (150 to 300 f) as a caption's change.
| | fib | list | sort | syscalls | musl | zoom | sqlite | heap | gallery | title |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
-| POP, before / after | 12 / 7 | 13 / 8 | 3 / 6 | 25 / 7 | – / 12 | 12 / 6 | 8 / 5 | 19 / 16 | 9 / 11 | – / 0 |
-| of them the corner minimap's / the strips' | 5 / 1 | 6 / 1 | 2 / 5 | 17 / 1 | – / 1 | 6 / 1 | 3 / 0 | 10 / 6 | 4 / 4 | – / 0 |
-| POP exempt, before / after | | | | | | | | | cut 5 / cut 5, keyframe 1 / keyframe 1 | |
-| CROWD, before / after | 3 / 4 | 8 / 8 | 10 / 10 | 3 / 4 | – / 2 | 1 / 1 | 1 / 1 | 16 / 16 | 5 / 5 | – / 0 |
-| METRONOME, before / after | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | – / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | – / 0 |
-| CAPTION up over 720 f, before / after | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | – / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | |
-| CAPTION under its reading time, before / after | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | – / 0 | 0 / 0 | 0 / 0 | 0 / 0 | | |
-| CAPTION picture moving within 60 f, before / after | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | – / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | |
-| AIR, before / after | 0 / 0 | 0 / 0 | 1 / 1 | 0 / 0 | – / 0 | 1 / 1 | 2 / 1 | 0 / 0 | 1 / 1 | – / 1 |
-| seconds, before / after | 42.0 / 42.0 | 81.7 / 81.7 | 63.8 / 63.8 | 83.8 / 83.8 | – / 68.9 | 33.5 / 33.5 | 62.9 / 62.9 | 78.6 / 78.6 | 27.0 / 27.0 | – / 12.3 |
+| POP, before / after | 7 / 7 | 8 / 12 | 6 / 5 | 7 / 7 | 12 / 16 | 6 / 4 | 5 / 4 | 16 / 16 | 11 / 9 | 0 / 0 |
+| of them the strips' | 1 / 0 | 1 / 2 | 5 / 4 | 1 / 0 | 1 / 4 | 1 / 0 | 0 / 0 | 6 / 7 | 4 / 3 | 0 / 0 |
+| POP exempt, before / after | | | | | | | | | cut 5, keyframe 1 / cut 5 | |
+| CROWD, before / after | 4 / 3 | 8 / 9 | 10 / 8 | 4 / 4 | 2 / 3 | 1 / 2 | 1 / 1 | 16 / 17 | 5 / 6 | 0 / 0 |
+| METRONOME, before / after | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 |
+| CAPTION up over 720 f, before / after | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | |
+| CAPTION under its reading time, before / after | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | | |
+| CAPTION picture moving within 60 f, before / after | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | |
+| AIR, before / after | 0 / 0 | 0 / 0 | 1 / 1 | 0 / 0 | 0 / 0 | 1 / 1 | 1 / 1 | 0 / 0 | 1 / 1 | 1 / 1 |
+| seconds, before / after | 42.0 / 42.1 | 81.7 / 82.1 | 63.8 / 70.5 | 83.8 / 83.8 | 68.9 / 68.9 | 33.5 / 33.5 | 62.9 / 62.9 | 78.6 / 79.2 | 27.0 / 27.0 | 12.3 / 12.3 |
-"Before" is the last pass's "after". The musl scene is new; the title's
-export is the last pass's size to the byte (it was not in that table). The
-corner minimap is gone and its fires with it (a repack landing in one
-frame for all six drawings; its windows' outlines drawn from the frame's
-own scroll): syscalls' 17 were most of its 25, in the run through `open`.
-The strips that replace it are each the average of six drawings a frame
-apart, their windows too (`past`), so a change on a strip fades over 6 f.
-sqlite's AIR at 32.95 is gone. Sort's and heap's strips' counts are
-mostly not the strips': see below.
+"Before" is the last pass's "after". Every scene's layout changed (layout
+A), so every count is of new pictures; a POP's place moved with its
+scene's timing. The title's export is the last pass's to the byte. Sort
+is 6.7 s longer: its first trip walks the swap's `reach` and the ring's
+first turn, then the disassembly unrolls for a beat under a caption of
+its own (its hold rolled back as the caption's reading time ends: no air
+over it).
-What this pass built (design/README.md's "The map and the minimap",
-mocks 10, 11, 20 and 39; the source following the pc):
+What this pass built (design/README.md's "The frame" (layout A),
+`registers`, `stack`, `source`, `disasm`, `graph`, the `blocks` lens, the
+verbs `reach`, `unfold`, `unroll`, `roll`, `leave`, `turn`, Forbidden's
+fact from after the moment; mocks 40 to 43, 22, 24, 25):
-- Each pane's strip (`map.strips`, `map.strip`, `map.through`): its
- column of the map at 4 units a row, the window framed, the gold, strikes
- and reads, an arc's end off the window down its edge, a flash where a
- word changes outside it; the corner minimap removed, the clock's count
- ranged right at 1856. `dive` squeezes each pane's column into its strip;
- `surface` the reverse. The strips' regions in `tools/chart.py` and
- `design/motion/motion.py`.
-- The source panel follows the pc into any file the build has the source
- of (`Recording.sources`, `tools/sources.zig`, `zig build sources`); the
- `musl` scene; libraries' frames named by file and line in the backtrace.
-- On the way: `rows.fitted` clamps an infinite width (a Debug panic,
- `integer part of floating point value out of bounds`, in musl); the
- sketchbook's text cache holds 4096 entries and 128 MB, not 512 and 16
- (the map's text drawn six times a frame thrashed it: the list's dive
- 0.46 s a frame, about 47 ms after); the heap's recording stops at 46
- steps (libc's lines carried it on through `exit`: 519 moments); the
- graph's counts, ink, trail and lane counts are by the moment shown.
+- Layout A in every split (`layout.split`, `layout.fit`): the
+ disassembly under the source; the registers the scene never changes
+ folded three to a row under a rule (`Registers.moves`, chosen once from
+ the clock's way), the panel as tall as its rows and the stack the rest:
+ fib 10 rows and 13 slots, list 9 and 14, sort 11 and 20, syscalls 14 and
+ 11, musl 15 and 10, zoom 9 and 17 (with the backtrace's four), heap 14
+ and 9, sqlite 17 and 6, the gallery 13 and 12 (beside). The `blocks`
+ split has no view; the thread is drawn in every split. In a `dive` the
+ registers fold as they land. The view's loupe lies over the stack's
+ first rows.
+- The graph from the code alone, `rings` and `layers` (`graph.zig`,
+ above), `reach` and `unfold`; on the map the lens's drawing beside the
+ linear disassembly (the graph-with-rows gone). Sort tells it with its
+ rings: the swap's first `reach`, the inner ring's first turn.
+- `unroll` and `roll` (`map.Unroll`); a far jump in the same column at a
+ walk unrolls, travels and rolls; the strips' faults at a far jump out of
+ the column (sqlite: the window lost through a continue, the step back
+ from `pwrite64`, the tag's range) and the system calls' log's first
+ pixel steps; a source tag's line range changing with its scroll.
+- On the way: a stack word too long for its row's room cut with `…`
+ (`rows.chain`), a breakpoint recording's deepest chain read at every
+ stop (sqlite's map no longer repacks as a continue sets off), the map's
+ disassembly measured by the moment the pane shows; `time.unroll` (the
+ extend's stagger is `time.extend`).
Right in one frame, and exempted by name: the encoder's keyframes and the
gallery's cuts (above).
@@ -301,85 +310,82 @@ gallery's cuts (above).
What fires still, by kind (located on this pass's exports; those not
looked at this pass say so):
-- The strips' regions: fib 30.37, list 3.87 (in the dive), syscalls
- 5.10, musl 63.23, zoom 23.18, 12 to 24 pixels each. Sort's 31.63,
- 32.18, 33.93 and 35.25 are the map's own panels under the source
- strip's region while the sprint plays on the map (as the view's 32.25);
- 52.50 is 14 pixels. Heap's six (12 to 98 pixels) are in the stack
- strip's region: 65.07 is a loupe passing over it at a step's first
- frame, the rest not looked at. The gallery's 12.22, 18.15 and 20.82 are
- at a state's first frame, as its view's re-windowing.
+- The strips' regions: list 3.13 and 3.87 (in the dive, 17 and 20
+ pixels); sort 0.43 (its opening) and 42.57 (the map's own panels under
+ the source strip's region while the sprint plays on the map), its 20.52
+ and 59.23 (12 and 14 pixels, the stack strip) not looked at; musl's four
+ (13 to 15 pixels, the stack strip) and heap's seven (the disassembly
+ strip at 3.62 and 28.62, the stack strip 37.17 to 65.47, 12 to 71
+ pixels) not looked at; the gallery's 12.27, 18.15 and 20.82 at a
+ state's first frame. The unroll's two that fired in a draft (its
+ window going bright in a frame, its page lifting off the strip in one)
+ are gone: both fade now.
- The stack: a few pixels in the arcs' lanes and the pins (fib 8.20,
- 19.50, 24.90, 39.13; syscalls 29.13, 57.72, 70.17; sqlite 20.43,
- 31.75); musl's five, list's 7.30, zoom's 19.25 and heap's 55.23 not
- looked at.
-- Registers: a held corner, a few pixels at a value's top left (fib 21.10,
- syscalls 44.32, sqlite 38.67); zoom's 12.80 and 16.40, list's 59.45 and
- 70.45, musl's 62.57, heap's 13.68 and the gallery's 22.38 not looked at.
-- The source and the disassembly: syscalls 17.92, the line going
- `waiting` and back with the descent's rows; zoom 18.10 and 19.60, an
- annotation taking its value in place under the camera; musl's five in
- the disassembly (31.33 to 66.35), the descent's rows, a library
- address's leading digits changing in a frame; heap 13.50, a scroll's
- first whole-pixel step from rest.
+ 25.07, 39.30; syscalls 57.72, 70.17; sqlite 20.43, 31.75; zoom 19.25;
+ the gallery's 24.62); fib's 3.32 and 19.67 (139 and 235 pixels),
+ syscalls' 29.13, musl's six, list's 7.30 and heap's 55.83 not looked at.
+- Registers: a held corner, a few pixels at a value's top left (fib 21.27,
+ syscalls 44.32, sqlite 38.67); zoom's 12.80, list's 70.85, musl's 62.57,
+ heap's 13.68 and the gallery's 26.23 not looked at.
+- The source and the disassembly: syscalls 17.92 and 28.23, the
+ descent's rows; zoom 18.10 and 19.60, an annotation taking its value in
+ place under the camera; musl's six in the disassembly, the descent's
+ rows, a library address's leading digits changing in a frame (17.03
+ looked at); list 62.97 and 78.87, the source's text changing in one
+ frame at a run's first step (about 7 400 pixels, not the trail and not
+ the tag: not identified); list's 46.22 and 51.95 (13 and 18 pixels in
+ the disassembly) not looked at.
- The view: syscalls 64.77, the read's first byte landing over the
- buffer's dots; the gallery's view re-windowing at a state's first frame;
- sqlite 55.83 (15 pixels) not looked at.
-- The drawing: fib 33.63, the calls tree's badge corner; the heap's runs
- (its 16 CROWDs too: the calls and returns it does not narrate); sqlite
- 42.47, the system calls' log scrolling a line up from rest by whole
- pixels (1 every other frame at first); list's 13.12, 40.82, 67.65 and
- 68.85 (120 to 277 pixels) not looked at.
-- AIR: sort's and zoom's last picture (the last caption read, then held);
- sqlite 46.02, where the chart misses the read frame on one byte (`0d`)
- at 47.5 s; the gallery's atoms page, 3 s by design; the title's card,
- held by design.
+ buffer's dots; the gallery's 9.00, 12.62 and 15.40, the nodes' dump
+ re-windowing by a row at a step's first frame (9.00 looked at); sqlite
+ 55.83 (15 pixels) not looked at. Sqlite's 42.47 (the system calls'
+ log's first whole-pixel step) is gone.
+- The drawing: fib 33.80, the calls tree's badge corner; the heap's eight
+ in its runs (its 17 CROWDs too: the calls and returns it does not
+ narrate); list's 13.12, 41.02, 68.05 and 69.25 (120 to 281 pixels) and
+ sort's 6.73 (18 pixels) not looked at.
+- AIR: sort's, zoom's and sqlite's last pictures (the last caption read,
+ then held), sqlite 46.02 too, where the chart misses the read frame on
+ one byte (`0d`) at 47.5 s; the gallery's atoms page, 3 s by design; the
+ title's card, held by design.
- CROWD: the advance (thread, plaques and rip as one mark, the source and
the disassembly scrolling with it), the veil over three panels at a
- run's first step; sort's `surface` and `dive`, every panel at once by
- design.
+ run's first step; zoom's two the camera coming back; sort's `surface`
+ and `dive`, every panel at once by design.
## What is not done
-- The graph's truth: what it shows is the run's by the moment shown (each
- block's visits and `seen` paper, each edge's count and ink, the trail,
- a loop's turns: `countBy` counts to the moment), and a fold of blocks no
- longer says `never reached` but `not reached`. What is still the whole
- recording's: where each block is placed (`place`, by the whole run's
- edge counts: the hot path straight down, so the picture does not move as
- the counts grow) and which blocks fold (the runs it never reached): both
- say something of the future to one who reads the layout. Left for the
- designer's revision of the graph.
-- The graph (`graph`): the map draws the disassembly as its graph only
- where the scene asks (`Context.Options.graph`: sort); the catalogue has
- it whenever the recording has the function's blocks. Not built for the
- rest: the descent on the map (graphs stacked, the caller folded to its
- call), a list scene that opens on the map and dives out of a graph, a
- 2 510-block `sqlite3VdbeExec`. `spread` and `gather` are not built: in a
- `surface` and a `dive` the working rows and the lens fade on their way
- (`context.Zoom.shows`) instead of gliding into their blocks. A finished
- loop is not folded; a fold is not named (`multi-threaded: a cancellable
- call`) since no scene names one; an indirect jump's taken targets do not
- become edges. The pan is by whole layers to the largest loop the pc's
- block is in that fits: sort's ten layers do not fit the lens (its outer
- loop is 284 of 270), so the lens pans three times a trip round the outer
- loop (24 f, `glide`). A function change (the pc going into another
- function with blocks) is not crossfaded: the graph changes in a frame,
- and sort ends at its `ret` for that. A count struck as the mark lands
- cools to nothing by the step's end (no held corner: the steps after do
- not keep it); at a walked step across several blocks the counts, the
- gold and the trail crossfade with the advance, nothing struck. On the
- map a `leave`'s plaque fades out of its row (6 f) as the mark sets off
- from the block's port, and in at the landing; it does not slide along
- the rows to the port. The pc's block widens no further than the right
- channel: a block in the last column has no annotation room. A
- `syscall`'s or call's arguments hang only as far as the block's last row.
+- The graph: the map draws the `blocks` drawing only where the scene asks
+ (`Context.Options.graph`: sort); the catalogue has it whenever the
+ recording has the function's blocks. Not built: the descent on the map
+ (the callee's drawing under its caller's), a list scene whose lens is
+ reverse's ring (the list's subject is its nodes; reverse's ring is
+ built and unit-tested, not drawn in a scene or the gallery), a 2 510-block
+ `sqlite3VdbeExec` (folded from the start to its reached blocks). At a
+ run the mark goes pill to pill along the edge only where a step
+ crosses one edge: sort's run steps by line, three edges a step, and
+ keeps the 8 f crossfade of the counts, the gold and the trail. In an
+ `unfold` the edges crossfade between the two layouts rather than ride
+ with the pills, and where the opened layout is wider than the pane the
+ drawing shifts sideways just enough (65 units in the gallery's).
+ `rings`' general cases beyond sort's two nested loops (a second loop in
+ one parent, a second loop at the top level, a way between the blocks
+ before and after a loop, a way out from a pill not at 9 or 3 o'clock)
+ are drawn but not kept clear of the rings (`shortcut:` in `graph.zig`).
+ Sort's angles are computed, not the mock's hand-placed ones (`+84` at
+ 256°, the mock's `+1e` at 225°; `+c5` at about 116°, the mock's `+5f` at
+ 75°); the header's way out leaves 30 in from its pill's end (the mock
+ draws 12); pills keep room for `×99`, 12 wider than the mock's; libc's
+ `open` in `layers` puts a taken target right, as the rule says (`+f0` in
+ the right column; the mock placed by the run's path). The map's frames
+ draw slower than before (about 0.35 s against 0.15 s: the 69 linear
+ rows the map now draws beside the drawing, not the graph's own code).
+ A finished loop is not folded; an indirect jump's taken targets do not
+ become edges; a function change is not crossfaded (sort ends at its
+ `ret` for that).
- Sort's recording is the instrumented build: eleven blocks (`setg`, a
- `test`/`jne`, two blocks of a lone `jmp`), not mock 22's eight; its
- prologue (25 rows, the instrumentation's calls) folds on the map to four,
- `more`, four, and the map pans to the outer loop. Mock 22's exit sits in
- the second column; here it is under its fall-through's block, as the
- catalogue's rule has it, and its edge runs in the right channel.
+ `test`/`jne`, two blocks of a lone `jmp`), as the mock now has them; its
+ prologue's calls are the tracer's (`__zt_var`), left out of `+0`'s pill.
- The descent: the kernel's three rows are kept at the floor from the
`syscall` to the stop after it, so the rows under the call move up again
@@ -443,23 +449,33 @@ looked at this pass say so):
conditional jump's annotation (`taken · reads zf sf`) is not cut by its
room: with a library's 12-digit addresses it runs under the strip by a
few characters (syscalls' hurried run through `open`, sort's view).
-- A far jump in one file (the source's window farther than its own
- height) takes 48 f: the window glides on the strip for the first 24,
- then the pane fades out and in. A far jump of the disassembly alone (no
- source window far) fades through over the advance with its window
- gliding on the strip over the same frames. A file change (another
- source) fades the panel and its strip through over 24 f; at a run over
- the run's 8 f advance (syscalls' hurry through open64.c and
- sysdep-cancel.h flips the file several times, each a fade). The far
- jumps seen in the finals are sqlite's, in its 262 899-line sqlite3.c,
- whose strip (the map's source panel, round the line the pc goes to)
- cannot hold both places: at a continue the strip goes over to the new
- place as the continue sets off (a 6 f fade, the gold lit there at once)
- and shows no window until the pane's lands there, about 2 s later; the
- step back from `pwrite64` (43.3 s) plays on the crossing's plan, whose
- travel is shorter, so the pane fades through in about 6 f, before the
- strip (6 to 11 f behind) shows it. The tag's note names the new lines
- over the 12 f before the advance, before the pane shows them.
+- A far jump in one file to lines the map's column also holds, at a walk,
+ is `unroll`, the window's travel and `roll` (96 f), built and seen in
+ frames, but no final shows one: heap's (line 15 to 30, 75.7 s) comes in a
+ hurry, a sentence said faster, where it fades through as at a run, and
+ sqlite's step back from `pwrite64` goes 44 lines in a column the map
+ packs at 38 (`inColumn` reads the map's own column). At a run, and out of
+ the column, the window glides on the strip for the advance's first half,
+ then the pane fades out and in (48 f); the catalogue's 24 f glide, then
+ 12 f out and 12 in, is that at a walk's 48 f, but a run's step is 18 f
+ and the fade has its share of it. A far jump of the disassembly alone
+ fades through over the advance, its strip going over as the advance
+ starts. A file change (another source) fades the panel and its strip
+ through over 24 f; at a run over the run's 8 f advance. A jump out of
+ the column at a walk is still not told on the map (`surface`, the jump,
+ `dive`): sqlite's continues fade through, the strips first. Its strips
+ now keep their windows through a continue, go over as its advance
+ starts (6 to 11 f behind it, a 6 f crossfade), about 20 f before the
+ pane's fade, and the tag's line range changes with the pane; the step
+ back from `pwrite64` advances over 48 f (the scene's plan; the
+ crossing's own travel is 12 f).
+- The stack's window does not keep the touched word in its middle half
+ until a step touches outside it (the catalogue's hysteresis): it is
+ still centred on the word the last three steps touched, wherever the
+ frame is longer than the window (with 12 to 20 slots, few are).
+- A quiet register is folded by the scene's clock's steps: a scene that
+ walks finer than its clock (sort, by blocks, its clock by line over
+ calls) could change one unmarked; none of the scenes does.
- The heap scene never stops inside malloc or free (they are run
through, by the PLT, at a line a stop): there is no frame of theirs to
name, and no line column of theirs to show. Their lines are in the