diff options
| author | Gabriel Schneider <[email protected]> | 2026-11-11 09:41:45 -0300 |
|---|---|---|
| committer | Gabriel Schneider <[email protected]> | 2026-11-11 10:14:30 -0300 |
| commit | 390872b7bb9cdcf3e8095442af88af0dfcb40602 (patch) | |
| tree | ab767cf46dfca036e61e0e19bb5e1c4772cb1d4d /anim/README.md | |
| parent | 378379807fb4cd751e90808c8363caddb365bcd8 (diff) | |
| download | computeranim-390872b7bb9cdcf3e8095442af88af0dfcb40602.tar.gz computeranim-390872b7bb9cdcf3e8095442af88af0dfcb40602.zip | |
canim: what the verification review found, fixed
A register's chain reads memory as its panel shows it, and follows again
only after the bytes land: rsi no longer shows what read returns before
the kernel writes it. Bytes keep their old value through the arm and
change at their own strike, in every dump, stack word and loupe. The
dive lands once. Captions lead what they name: the longest still in the
syscalls scene is 2.8 s where it was 13. Pins hold through a sprint; a
row of a view carries the pin of the register that points at it; a left
child's badge sits on its left shoulder; a log scrolls with the row that
arrives. The zoom scene's camera holds the disassembly's rows and the
stack in one view. Six programs, the title says now.
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.md | 236 |
1 files changed, 129 insertions, 107 deletions
diff --git a/anim/README.md b/anim/README.md index f4a5a2b..cffb7aa 100644 --- a/anim/README.md +++ b/anim/README.md @@ -11,7 +11,7 @@ a block of the catalogue is a function or a component of the same name here. zig build record # the recordings, into zig-out/recordings zig build run -Dscene=fib # a scene in a window, hot reload (zig build lib --watch) zig build export -Dscene=fib -- DIR --fps 60 --size 1920x1080 # frames as PNGs (or - for raw RGBA) -zig build videos -Doptimize=ReleaseFast # every scene: out/NAME-1080.mp4 and out/NAME-2160.mp4 (x264, 60 fps) +zig build videos -Doptimize=ReleaseFast # every scene: out/NAME-1080.mp4 and out/NAME-2160.mp4 (x264, 60 fps, aq-mode=0) zig build test # unit tests, each scene run headless, and the gallery against its pictures zig build gallery # the gallery's pictures drawn anew into test/gallery zig build bench # what a recording costs a frame @@ -72,7 +72,11 @@ before (after the last of its registers, which strike 6 f apart), in the order C the step did not touch, or touched nothing drawn, gives up its slot; a drawing made of bytes strikes when the projection from them arrives, 24 f after them, and its write 12 f later still; a call's node when the -projection from its return address does, 36 f after); the writes of one step strike 6 f apart; a hold to read; the +projection from its return address does, 36 f after); the writes of one step strike 6 f apart (those that take a +place: not a stack frame the step has already left, a callee's words under rsp), each keeping its old value through +its arm until its own strike lands (s+3: `Now.struckAgo`, `shownAt`; what the kernel fills, once the last byte of the +word lands); a register's chain reads memory as the panels show it: from the bytes' strike its later hops fade +out (3 f), and 4 f after they land they are followed again (`extend`, `Now.following`); a hold to read; the mark advances last; a rest. `walk` plays steps in full, `hurry` ramps the pace down and up again (each step 0.6 of the one before) to a run (0.30 s a step: nothing struck, no held corner, no arc, a dump's values crossfading @@ -91,15 +95,15 @@ on a primary onset's frame and nothing on it changes in one. | Scene | Shows | Split, lens | Recording | | --- | --- | --- | --- | -| `title` | the series and the legend of marks | a card | | +| `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: compares and swaps | `subject`, `array` | `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, 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` | | `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 x2; 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`; the backtrace lens drawn on its map | `sqlite` | -| `gallery` | every block in its states | all three | `gallery` | +| `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 | all three | `gallery` | ## The blocks @@ -109,19 +113,19 @@ 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 | -| 1 atom | `address` (`lead`, `name`, `rwx`), `value` (and `Ui.typed`: `fd`, `bool`, `char`), `arrow` (`points`, `holds`, `more`), `mark`s, `plaque` (`chip`), `pin` (`row`, `under`), `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) | -| 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`. `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, 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 | +| 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, 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; 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 · 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` (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) | -| 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, and what it brings, and what changed before it, is plain; 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` | +| 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 whole file in a window, its middle third; the trail's bars crossfading with the advance; numbers as wide as the program's largest line (SQLite's six digits), the text moved right by as much; a window going farther than its own height fades out and in | | | `disasm` | `src/disasm.zig` | 17 rows (9 as subject), fewer above near a function's start; the line column as wide as the source's; two windows that overlap scroll, others fade out and in; its tag's function (a descent's tag too) crossfading with the advance | | | `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) 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 | -| 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; a projection from the view's bytes, or from a frame's return address to its call's node | +| | 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`), 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`, `minimap`), `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`); the minimap the same at a twentieth under the clock (text as 1-unit strokes at 45% toward the page, marks as blocks; `ui.strokes`), drawn six times into the host's images, each from the cursor's mirror a frame later (6 to 11 f behind: `Cursor.lagInto`, `time.minimap_fade`) and averaged, so that every change on it fades in over 6 f and nothing on it changes in a frame; its outlines on whole pixels at rest and between them only as they glide; a mark no working window shows (a word struck or read on the stack or in a dump the map draws) flashing on it (a ring 8 to 14 in the mark's colour, 12 f), the count ranged right at 1648; `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 at the end; the map falls into the minimap's corner over 72 f, its scale on the logarithm, its corner going toward the minimap's as the scale does, small it is drawn over the panels with its edge, and crossfades into the minimap's drawing at 90–96; 120 f and 30 f still), `.surface` (the dive back, 84 f, then 30 f still); per-panel transforms through `context.at` (`context.zoomed`) | | | `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 | | | `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` | @@ -179,115 +183,112 @@ that is right is counted apart by name (`POP exempt`), never dropped: region, under 200 pixels moved (motion.py reads the video's I frames with ffprobe; the caption check skips such a frame and the one after it too); `cut`, the gallery's pages, which are the catalogue's pictures cut one to -the next (chart.py names their times). CAPTION: up over 720 f, up under +the next (chart.py names their times). The videos are x264 without +adaptive quantization (`aq-mode=0`, 18% larger): with it a still glyph's +edge was re-quantized as the rest of the frame moved, a one-pixel column +flickering in fib's caption band at 7.45 s that the instrument took for an +extra caption (the rendered frames there are identical; with `aq-mode=0` +fib's first 600 frames have no such column). CAPTION: up over 720 f, up under 90 f + 3.6 f a character (chart.py counts the characters of the scene's `says.line` strings as shown; where the video's arrivals and the scene's captions do not pair up it says so and checks no reading time), or the picture moving within 60 f of its arrival; chart.py does not count the list's dive (150 to 300 f) as a caption's change: the falling map passes -under the caption, which does not change. "Before" is the last pass's -exports (as the brief counted them; the same exports by this instrument -in brackets: the keyframes and cuts apart); "after" this pass's. +under the caption, which does not change. | | fib | list | sort | syscalls | zoom | sqlite | heap | gallery | | --- | --- | --- | --- | --- | --- | --- | --- | --- | -| POP, before / after | 44 (44) / 14 | 43 (40) / 14 | 32 (32) / 8 | 66 (65) / 26 | 22 (22) / 7 | 14 (13) / 7 | 72 (71) / 21 | 10 (7) / 5 | -| of them the minimap's, before / after | 16 / 5 | 26 / 7 | 15 / 2 | 47 / 16 | 14 / 4 | 8 / 3 | 48 / 9 | 5 / 3 | -| POP exempt, after | | keyframe 3 | | keyframe 2 | | keyframe 2 | | cut 3 | -| CROWD, before / after | 2 / 4 | 8 / 8 | 5 / 6 | 2 / 3 | 3 / 3 | 0 / 0 | 7 / 15 | 4 / 4 | -| METRONOME, before / after | 0 / 0 | 0 / 0 | 0 / 0 | 9 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | -| CAPTION up over 720 f, before / after | 0 / 0 | 2 / 0 | 0 / 0 | 0 / 0 | 1 / 0 | 0 / 0 | 1 / 0 | 0 / 0 | -| CAPTION under its reading time, after | not paired | 0 | 0 | 0 | 0 | 0 | 0 | | -| CAPTION picture moving within 60 f, before / after | 0 / 1 | 1 / 0 | 0 / 0 | 1 / 0 | 0 / 0 | 2 / 0 | 1 / 0 | 0 / 0 | -| AIR, before / after | 0 / 0 | 0 / 2 | 0 / 0 | 2 / 2 | 1 / 1 | 5 / 5 | 0 / 0 | 0 / 0 | -| seconds, before / after | 42.0 / 42.0 | 71.1 / 84.5 | 42.2 / 42.2 | 89.2 / 89.2 | 32.0 / 33.6 | 64.6 / 64.6 | 96.8 / 78.1 | 11.0 / 11.0 | +| POP, before / after | 14 / 11 | 14 / 13 | 8 / 6 | 26 / 25 | 7 / 11 | 7 / 8 | 21 / 17 | 5 / 8 | +| of them the minimap's, before / after | 5 / 5 | 7 / 6 | 2 / 1 | 16 / 17 | 4 / 6 | 3 / 3 | 9 / 8 | 3 / 4 | +| POP exempt, before / after | | keyframe 3 / | | keyframe 2 / | | keyframe 2 / | | cut 3 / cut 3 | +| CROWD, before / after | 4 / 4 | 8 / 9 | 6 / 7 | 3 / 3 | 3 / 1 | 0 / 1 | 15 / 16 | 4 / 4 | +| METRONOME, before / after | 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 | +| CAPTION under its reading time, before / after | not paired / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | | +| CAPTION picture moving within 60 f, before / after | 1 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | +| AIR, before / after | 0 / 0 | 2 / 0 | 0 / 1 | 2 / 0 | 1 / 1 | 5 / 2 | 0 / 0 | 0 / 1 | +| seconds, before / after | 42.0 / 42.0 | 84.5 / 81.7 | 42.2 / 42.2 | 89.2 / 83.8 | 33.6 / 33.5 | 64.6 / 62.9 | 78.1 / 78.6 | 11.0 / 21.0 | -The kinds of one-frame change, each fixed at its block (every scene that -draws the block gets it), counted on the last pass's exports: +"Before" is the last pass's "after", measured with x264's adaptive +quantization, whose keyframes re-quantized still regions (the `keyframe` +exemptions, and a still picture broken in two: sort's last 4.6 s, an AIR +now). zoom's POPs grew because its camera now shows the disassembly and +the stack's chains with the stack (annotations taking their value in +place, 18.10 and 19.60 s; offsets crossfading, 12.80 and 16.40 s); +the gallery's because each state is held 3 s and its view re-windows at a +state's first frame (9.00, 12.62, 15.40 s), as before. -- The minimap (about half of every scene's): its strokes, blocks and gold - rows followed the cursor 6 f late but changed in one frame. Now it is the - average of six drawings from the cursor's mirrors 6 to 11 f behind - (`map.minimap`, `Cursor.lagInto`), so every change on it fades in over - 6 f; its windows' outlines glide with their scrolls (`map.window` takes - where the window was and how far it has gone), on whole pixels at rest; - the backtrace's box is packed once, by the deepest chain of the scene's - way, not grown under the eye. -- rip's value swapped at the advance: it crossfades over the advance; a - flag set or cleared crossfades over the 6 f it lands in (`rows.RipWas`). -- A held corner dropped when a run rewrote its value, a sprint's ember - coming at once, the last ember's fade cut off by a short step: the - corner goes with the run's ease, the ember comes in over the step, the - fade fits its step (`Now.heat`, `left`). -- The backtrace: in the calls lens's view the chain swapped in a frame; - everywhere a kept row's depth, pc offset or line, and the tag's count, - changed in place. One block now (`backtraceRows`): leave, slide, arrive, - and what a row says crossfading over the 12 f before the advance - (`Now.renaming`: from the step's start where that is sooner, a run's). -- The calls tree: a node gold, ringed or done switched with the tree's - moment; at a sprint a node came at once. Crossfaded (6 f), and over its - step at a sprint (`Now.moving` at a sprint). -- A tag's note changed in place: the disassembly's function, a descent's - tag, the stack's range: crossfaded with the advance or memory's strike. -- A stack word's role (`saved rbp`, a local's name) and its offset from - rsp changed in place: crossfaded from memory's strike (12 f, - `rows.Role`); a saved rbp's arc vanished at the next step: it goes with - its own step's advance. -- A pin's names swapped as a register joined or left (the `+1`, a name - taking the other's side): the names fade through the middle of the - change (`Pins.text`); at a run a pin changes over 8 f (`ties.pinShows`). -- At a run a register's or a stack word's value changed in a frame: they - crossfade (8 f), as a dump's did. -- A dump row whose bytes changed with no write the recording saw (memory - nothing watches, read anew at a stop) or that became known: crossfaded - (12 f, `rowPasses`). -- The source's trail bars moved in a frame: crossfaded with the advance. -- The heap's own drawing: a node's look as it changed lists, its value - and its link: crossfaded (it lands, then turns, 12 f). -- An arc's lane: it glides while the arc that moves it draws or fades. +What this pass fixed at the block (every scene that draws the block gets +it), an effect shown before its cause first, found on the last pass's +exports: + +- A write's bytes took their new value at memory's landing, before their + own arm (any write 6 f or more after the first of its step: sort's first + swap, the heap's first free, its chunk's words and the tcache's header). + Each run now keeps its old bytes, and their reading (by its old field + where the step retypes it), through its arm until its own strike lands + (`hexdump.keepOld`, `Now.shownAt`, a stack word too); a write on a frame + the step has already left (a callee's words under rsp) takes no place + among the strikes, so sort's two elements strike 6 f apart, not on one frame. +- A register's chain read memory as of the stop after the step from the + CPU's strike: rsi's `Hello, k` 2 s before `read` wrote it. It reads it as + the panels show it; its later hops fade out from the bytes' strike and + are followed again 4 f after the word's last byte lands (`Now.following`), + never gone in a frame. +- What a crossing's first part struck had its cool cut as the crossing + began (read, write): the crossing's plan carries the cool on + (`Plan.cooling`); an fd's `"note"` fades in with its framing. +- The list's dive played twice: the minimap's drawings overwrote where the + falling map's windows are, which the panels set off from (`map.minimap` + keeps `window_px`); the thread, which came in a frame at the landing, + fades in after it (`context.thread_shows`). +- A stack window going far at a run faded out in a frame (the 12 f before + memory's strike lie before a run step's start): it fades out and in round + a turn that fits the step (syscalls 56 s). +- Rows sliding out of the stack's window lost their roles (fib 6.50, + `saved rbp`, `saved rbx`), and an arc was drawn from the row above the + window that is there only for a slide: the roles of both windows are + read; arcs join rows on show; a word becoming a saved rbp has its arc go + with its role. +- The system calls' log scrolled a row in a frame as a crossing began + (sqlite 38.67): it scrolls with the row's arrival, its count crossfading. +- sort's source jumped 3 lines at a sprint's phrase end: the mark travels + over the sprint's step. +- Under the camera a free word rsp reached became a slot in a frame (zoom + 19.6 s): it crossfades as memory strikes. +- `changedBytes` read its own result as it wrote it (a Zig result-location + hazard): a strike could cover bytes that kept their value (a Debug build + panicked on it). Right in one frame, and exempted by name: the encoder's keyframes and the gallery's cuts (above). -What fires still, by kind (looked at on the exports): +What fires still, by kind (located on this pass's exports): -- The minimap: a repack of the map (a panel that wants more rows than so - far, a frame behind: the disassembly's box, a loupe opening that moves - the key) lands in one frame for all six drawings; heap 9, syscalls' - descent the most. Packing every box once from the whole scene would end - them. -- The stack (fib 7): at fib 6.50 two roles (`saved rbp`, `saved rbx`) - and the saved rbp's arc go together in one frame, which the roles' - crossfade and the arc's fade with its advance should have caught (not - found); the rest are a few pixels in the arcs' lanes and the spans' - names (8.20, 19.50, 21.70, 24.90, 35.93, 39.13). -- Registers: a held corner (fib 21.10; sort 14.88, 32.62), a few pixels - at a value's top left. -- The drawing: the calls tree's badge corner (fib 33.63), sort's index - pins sliding (21.98, 30.43), the heap's `+1` and a pin's name over a - travelling tag. -- The view: sqlite's row (21.12, 23.75): bytes the dump's marks do not - strike (its marks begin at the stop it came in at) changing at a - continue; heap 13.48 and 36.68, the tcache's row as malloc rewrites it. -- The source: sort 24.18 and 24.52, its line numbers' column as the - window goes farther than its height (out and in through the advance); - syscalls 13.42 and 61.02, the line going `waiting` and back; not looked - at further. -- fib's caption: a 1-pixel column at the panels' left edge (x 66 and - 978) flickers in the caption band as the hurry begins (7.45 s; also in - the last pass's export, smaller): the instrument takes it for a sixth - caption, so fib's captions are not paired and 7.50 is "the picture - moving". Not found. +- The minimap (about half of every scene's): a repack of the map (a panel + that wants more rows, a frame behind) lands in one frame for all six + drawings; and a working window's outline, drawn from the frame's own + scroll and not averaged, moving a pixel with a pause where its glide's + sub-pixel steps round alike (syscalls' run through `open`). +- 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). +- Registers: a held corner, a few pixels at a value's top left (fib 21.10, + sort 14.88, syscalls 44.32, sqlite 38.67). +- The source and the disassembly: syscalls 17.92 and 55.62, 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. +- 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. +- The drawing: fib 33.63 the calls tree's badge corner; sort's index pins + sliding where a sprint's phrase ends; the heap's runs (its 16 CROWDs + too: the calls and returns it does not narrate). +- AIR: sort's and zoom's last picture (the last caption read, then held); + sqlite 32.95, after the continue to `unixWrite`, and 46.02, where the + chart misses the read frame on one byte (`0d`) at 47.5 s: the picture is + still 1.5 s and then 2 s; the gallery's atoms page, 3 s by design. - CROWD: the advance (thread, plaques and rip as one mark, the source and - the disassembly scrolling with it), the veil coming over three panels at - a run's first step; heap's runs (the calls and returns it does not - narrate) are its 15. METRONOME is gone from syscalls: the run through - libc's `open` crossfades its values now. -- AIR: syscalls 13.72 and 20.10, the stage still under the two captions - that recount the descend and lead the stub's `jmp`; sqlite's four dense - captions and its last; zoom's last; list 21.87 and 30.32, the loop's - caption read over its one step and the loupes held under theirs (list is - 84.5 s now: four captions more, so that none is up over 12 s). + the disassembly scrolling with it), the veil over three panels at a + run's first step. ## What is not done @@ -390,8 +391,29 @@ What fires still, by kind (looked at on the exports): stack, `23 rows`, 5.0 s; in a continue a link sets off with memory's strike, when the window is at its new place). One to a slot above the window would put its count over the panel's tag. -- The calls tree's leaf spacing holds for fib(5); past about ten leaves - nodes and badges collide (the catalogue's known case). +- A call's result badge is on its outer shoulder (a left child's left, off + its parent's disc; it lay on the parent, fib 24 s on): in fib(5) none + lies on a node, but two neighbours' badges between their nodes are 4 + units apart (`1][1`). Past about ten leaves nodes and badges collide + (the catalogue's known case). +- A view's row a register points into carries its pin at the row's end, + its head toward the row (`Ui.pinEnd`): the catalogue's `row` pin has no + lane in a dump, whose bracket and address take its first 34 units. The + reading gives way to it (the read buffer's text reads `"Hello, …` while + rsi's pin is on its row; the top's `top` note goes while a register + points into its row), and a link to the row ends at its left edge, not + at the pin. +- The zoom scene's camera goes to x1.16, not the x1.5 decided: the stage + (1792 wide) holds the instructions' mnemonics to the stack's roles at + x1.16; at x1.5 the stack's chains (`fib+42`) and roles (`saved rbp`, `n`) + the captions name fall off its right edge, or the mnemonics off its left; + the stack's call spans are off its right edge at x1.16. +- A working window's outline on the minimap is drawn from the frame's own + scroll, not averaged with the six drawings: a one-pixel scroll there + moves over a few frames with a pause where the glide's sub-pixel steps + round alike (most of syscalls' minimap POPs, in the run through `open`). +- Bytes the recorder merged into one written span (a free's link and key, + stored by two instructions next to each other) strike as one. - The `pages` lens is not in the band (`Timeline` is the old far view). - The map's and minimap's drawing flags (`ui.mapping`, `ui.strokes`, `ui.chrome`), a dive's per-panel transforms (`context.zoomed`), the |
