diff options
Diffstat (limited to 'anim/README.md')
| -rw-r--r-- | anim/README.md | 330 |
1 files changed, 210 insertions, 120 deletions
diff --git a/anim/README.md b/anim/README.md index 39a035f..bfc4f95 100644 --- a/anim/README.md +++ b/anim/README.md @@ -17,6 +17,7 @@ zig build test # unit tests, each scene run headless, zig build gallery # the gallery's pictures drawn anew into test/gallery zig build bench # what a recording costs a frame zig build bench -- NAME BY [FUNCTION] # a recording's steps (BY: moment, line, over), with what each changed +zig build bench -- relations # the relations' passes timed on a working frame's tables and a map's (CANIM_RELATIONS=1 on a scene: each frame's counts) python3 tools/chart.py chart out/fib-1080.mp4 --out out/motion/fib # the designer's timing chart and checks (POP, CROWD, METRONOME, CAPTION, AIR) CANIM_MAP=1 zig build export -Dscene=fib -- DIR --size 3840x2160 # every frame the scene's map filling it, as `list` opens on it: a map at 1:1 ``` @@ -113,10 +114,17 @@ before a walk and put it back after: ```zig at.levels = .{ .idea = .calls, .source_rows = 8, .annotation = .whole }; // before canim.context at.levels.carry = .arrow; at.walk(s, .moment, to); at.levels.carry = .off; // the value's way, for one beat +at.aim(s, .standing); /* ... */ at.aim(s, .off); // a word holding a code address tied to its row, for some beats ``` -**The text column, an experiment** (`src/column.zig`, design/README.md -"column (an experiment)"). A scene can tell its beats with the panes a beat +`aim` is off by default everywhere (design/README.md, "4. Ties": the +author's to turn on, never the budget's): `.standing` draws, for the words +on screen in memory that hold the address of an instruction whose row is +shown, one tie to that row, in and out with the knob (18 f, over what +follows); `.step` the one of the word a walked step writes or reads. + +**The text column** (`src/column.zig`, design/README.md "column"). A +scene can tell its beats with the panes a beat is about in the left column and its text beside them, level with the row it speaks of, every other pane folded to its tag on the shelf (y 48), a register struck on its tag as on its row. It is the author's instrument: @@ -129,12 +137,20 @@ row the beat's first step is on; `.{ .row = addr }`, `.{ .head = "open" }`, 744 }`) and where its stem points (`.level`, `.none`, `.{ .to = … }`), and the folded panes' notes (the registers', the source's and the disassembly's are computed where the beat gives none). Between beats, in a rest, the last -text dims, the panes that leave fade and fold to the shelf, those that stay -glide (a pane that changes its rows fades out and in round its glide), those -that come unfold and fade in; an older text in the way glides up (or down -where there is no room above), the new one arrives with its stem, and the -stem draws back as the step fires. Three texts stand at most; at a run only -the newest. `scenes/column.zig` is the trial (`open` followed down), +text dims; the panes that leave fade (6 f) and fold where they stand, closing +to their tags, which then travel to the shelf (18 f: only a tag crosses +another pane, never a panel); those that stay glide (24 f; a pane crossing to +the other column 24 f down its own, 24 f across), one that changes its height +keeping its rows (a descent's rows glide between its two heights' layouts, +the rest fading at the moving edge; a source's window glides); those that +come unfold (18 f) and fade in (6 f); an older text in the way glides up (or +down where there is no room above), the new one arrives with its stem, and +the stem draws back as the step fires. A bubble about a folded pane (its +level a row of a folded disassembly, a block of a folded drawing) points at +the pane's tag on the shelf. A bubble still being read more than 84 f after +its beat's steps is said once on stderr (`column: bubble N is still read +…`), unless the beat says its rest is meant (`.held = true`). Three texts +stand at most; at a run only the newest. `scenes/column.zig` is the trial (`open` followed down), `scenes/column_sort.zig` the wide placements on sort's rings: ```zig @@ -164,8 +180,12 @@ canim.descent.step(cur, s, .moment); | `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 (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`) | -| `column` | the trial of the text column (design/motion.md, "A scene in the column"): `syscalls`' story on the same recording and steps, beat by beat as the storyboard's table C1 to C12 has it: the opening `below` (the working frame whole, its caption); the arguments beside the source and the disassembly over the registers; the call and the stub's jmp beside the descent over a stack of twenty words (the touch from the call row down the gutter to the free word, rsp's pin climbing); the wrapper at a run, the text level with open's head; its last three beside the registers; the crossing beside a descent of twenty-four rows, the text level with the kernel's floor; back up, the text at main's call row; `read`, `close`, `write` stepped over, the bytes over the source, each text beside its call row; the close `below`. Every other pane on the shelf, the registers' strikes on their tag | the column (`column.zig`), the working frame `beside` at the opening and the close | `hello` | +| `column` | the text column (design/motion.md, "A scene in the column"): `syscalls`' story on the same recording and steps, beat by beat as the storyboard's table C1 to C12 has it, its texts as it cuts them (C4's 57 characters): the opening `below` (the working frame whole, its caption); the arguments beside the source and the disassembly over the registers; the call and the stub's jmp beside the descent over a stack of twenty words (the touch from the call row down the gutter to the free word, rsp's pin climbing); the wrapper at a run over a source of two lines, the text level with open's head; its last three beside the registers; the crossing beside a descent of twenty-four rows, the text level with the kernel's floor; back up, the text at main's call row; `read`, `close`, `write` stepped over, the bytes over the source, each text beside its call row; the close `below`. Every other pane on the shelf, the registers' strikes on their tag | the column (`column.zig`), the working frame `beside` at the opening and the close | `hello` | | `column_sort` | the column's wide placements on sort's first trip: the opening `below`, then the rings across both columns twice their size, the others on the shelf (`sort.c line 12`, `disassembly jne …`), a text `on` the drawing in the corner the rings leave free with its stem round the drawing's top to the pc's block; then a text `above` it; then the working frame again | `blocks`, then the drawing across both columns (`Stage.zoom`) | `sort` | +| `intro_memory` | the introduction's first chapter (design/motion.md, "A scene: the introduction", I1 to I10): the 128 bytes at the top of the stack under the camera at x2; `regroup`, sixteen a row to eight (the return address walked, the rest at a run); three words that hold addresses framed; into the column, the dump folded to a tag; the address space to scale (`segments`: a slim bar, then `enlarge` a cluster at a time, the stack, the libraries, the tracer's 64 MiB ring in a box of its own, the program by segment, start, end and size on every band), texts beside; back to the working frame: the dump's `tie` and `link` onto the stack's box, a visit at x4, `ink`, three chains | the working frame (`below`), the column for I4 to I6 | `list`, moment 77 (reverse's first `call`) | +| `intro_stack` | chapter II, from I's last picture: the words become the stack panel; the call's push walked as the tied stack walks it; `main+50` framed and the offsets counted; rbp's pin and the panel's tag; the registers built row by row; texts beside on the left, in the program column | the working frame without a backtrace, texts on the left | `list`, 77 to 78 | +| `intro_code` | chapter III: the code's bytes as a dump row in code's ink, an instruction's four framed; `decode` into `aligned` (`interleaved`, mock 33), the neighbours at a run; `align` to `columns` (mock 36); the working frame with the list's nodes, the camera at x1.5 and back; `surface` to the map | `aligned`, texts above; then `subject`, `nodes`; the map | `list`, moment 582 (the load on line 21) | +| `asan` | plain against AddressSanitizer on `overflow.c` (design/motion.md, "A scene: ASan against a plain build", A1 to A16): a `pair` (A1 to A9, A14 to A16: the shared source, each run's disassembly, registers and frame as bytes eight a row with ASan's shadow byte beside each row, `only here` and `differs` bars, the parting framed `attention`, ASan's stderr in place of its registers once stopped) and the column for A10 to A13 (ASan folded to one shelf tag, its report's first line on it; plain's disassembly a descent, main's window over fill's whole; plain's frame the column's rest; each text level with the field the letter lands in; `aim = .standing`: the return address aims at main's row after the call, glides to `fill+1` at i = 24 and frays at i = 25); i = 27 held 4.9 s (mock 38, the poster); the fault at `ret` (SIGSEGV, rip stays) | `pair.split`, then the column | `overflow`, `overflow_asan`, `overflow_report` | ## The blocks @@ -179,8 +199,8 @@ every state the code has in the `gallery` scene. | | `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 ranged right to 172 (under `tied` from the frame's base, the call frame information's CFA register: `context.frameBase`; under `whole` from rsp; a `free` word's crossfading), 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`; `i, n` where locals share a word (`Slot.also`); the stack protector's copy `canary`; 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`). The annotation's form is the scene's knob (`Levels.annotation`, above): under `tied` a word the stack shows by its role and one hop (`tiedWord`; a local's name, the one of a shared word that holds the bytes accessed; an unnamed word, a spill, by its address and one hop; a store's value cut with `…`, never dropped), a heap word with a view on screen by its address and one hop, a word no pane shows its whole chain with its data name in place of the address (`head → 407050 ← 9`); a register set its first value; a move of rsp or rbp first (`stackMove`: `rsp -8 · saved rbp`, the role from the push's own stop, `rsp -0x20 4 words`, `rbp = rsp`, `leave`'s, `fib(4) · rsp -8`, `→ 4011ad main+45 · rsp +8`), the amount struck as rsp's pin lands; the row publishes where the touch leaves it (`ties.touch_row`); under `whole` the row as before | -| | `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`) | +| | `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`). The annotation's form is the scene's knob (`Levels.annotation`, above): under `tied` a word the stack shows by its role and one hop (`tiedWord`; a local's name, the one of a shared word that holds the bytes accessed; an unnamed word, a spill, by its address and one hop; a store's value cut with `…`, never dropped), a heap word with a view on screen by its address and one hop, a word no pane shows its whole chain with its data name in place of the address (`head → 407050 ← 9`); a register set its first value; a move of rsp or rbp first (`stackMove`: `rsp -8 · saved rbp`, the role from the push's own stop, `rsp -0x20 4 words`, `rbp = rsp`, `leave`'s, `fib(4) · rsp -8`, `→ 4011ad main+45 · rsp +8`), the amount struck as rsp's pin lands; the row publishes where the touch leaves it (`ties.touch_row`); under `whole` the row as before. What the step leaves on its own row (`lea`'s `=`, a register's first value, a compare's flags, the canary's word, `rbp = rsp`'s value) fades in from its strike (12 f; at a run the run's ease); a row the advance changes (its state, its trail, its line number) is drawn as before and as after the advance and crossfades over its middle | +| | `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 a change of the panel's height at rest the rows both heights' layouts have, `Stage.resizing`; a row's shared digits are of its own window's rows that show) 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` | 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`. Under `tied` the window has two `free` words of headroom over rsp (a leaf's locals under rsp are the frame's), the tag says the base (`· offsets from rbp`, crossfading as it changes), and when rsp or rbp moves the rows hold while the pin travels (`Plan.pins`: the amount on it, `rsp -18`, counting row by row, a vermilion bracket over the rows crossed, each row gained or released as it passes, the newest frame's span riding it, the register struck as it lands; rbp's pin flies to rsp's, `pop rbp` moves rbp first), and only then the window follows (`Plan.follow`); under `whole` as before | | | `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) | @@ -189,10 +209,15 @@ every state the code has in the `gallery` scene. | | `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`, 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. Under `tied`, `touch` (`Plan.touch`): from the row's right rule along the gutter's middle lane (x 956) to the word, onto the stack's rule nearer the lane (its right one where the stack stands under the disassembly, a column's beat), in read's or write's colour, the first of the three lines to give way; `carry` (`Levels.carry`, `Plan.carry`): the value's way between a stack word and a register along x 962, primary, an open chevron, `.value` its digits on a raised chip. Places a column's text is level with: `row` (a disassembly's row by its address, a descent's head by `descent.headKey`), `floor`, `block` | +| 4 tie | the relations: `thread`, `link` (and its `pin`), `projection`, `touch`, `carry`, `aim`, `echo` | `src/relations.zig` (the tables and the pure passes), `src/ties.zig` (`Ties`, the resolver; `anchor`, `show`, `find`, `of`) | the relations are one data problem (design/README.md, "4. Ties"): each frame's tables are in the frame's own scratch (`sk.Frame.user`, made at its first place: no process globals, two players at once each have theirs): `places` (a key, the place's kind in its top byte and its address below, its box, its pane; struct of arrays) that panels say as they draw (`anchor`), `values` (what a pane shows that may be an address: the value, its box, its pane, the word holding it, a register's index, its panel's rules: `show`, from the registers, the stack's words, a pair's frame), and the facts the panels publish beside them (the stack's window, the touch's row, the thread waiting); both sorted once by key (or value) after a change, a lookup a binary search (`find`), a join a merge of the two sorted sides (`relations.join`). `Ties`, added last, is the resolver, six passes, each a loop over one table: candidates (each kind's join, or the step's events against the places), the knobs (`relations.filter`: a kind whose default is off, `carry` and `aim`, only where the scene turned it on; the budget never turns one on), priority (`byPriority`), the budget (`cut`: the thread; one beat; a link, a projection and a touch, two of them, the touch giving way first; a carry; one aim), then each kind's route and drawing. The kinds are one table of data (`relations.specs`: knob, class, priority, most). Map panels say their places into the map's own tables. `CANIM_RELATIONS=1` says each frame's counts and times on stderr; `zig build bench -- relations` times the passes on a working frame's tables and a map's. The kinds' pictures and timings are as they were: fib, list, zoom, sqlite and column render identical frames before and after (every frame compared). `aim` (`Cursor.aim(s, .standing | .step | .off)`, off by default): a word in memory holding a code address whose row is on screen, out of its panel's rule nearer the gutter, up the left lane (x 950), onto the disassembly's right rule, the row's address framed in code's ink; standing at 60% toward the page, in and out with the knob over 18 f; the step's full ink after the word's strike, back with the advance; written again, its head glides to the new row 24 f after the strike, or it frays (dashed over 12 f, gone over 18 more) where the new value is no code. 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. Under `tied`, `touch` (`Plan.touch`): from the row's right rule along the gutter's middle lane (x 956) to the word, onto the stack's rule nearer the lane (its right one where the stack stands under the disassembly, a column's beat), in read's or write's colour, the first of the three lines to give way; `carry` (`Levels.carry`, `Plan.carry`): the value's way between a stack word and a register along x 962, primary, an open chevron, `.value` its digits on a raised chip. Places a column's text is level with: `row` (a disassembly's row by its address, a descent's head by `descent.headKey`), `floor`, `block` | | 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; `glide` (a column's moves: no fit, no fade), `column` (the clock under the text column), `zoom` (the band's drawing drawn larger, its tag not: `graph.Blocks`) | -| | `column` (an experiment) | `src/column.zig` (`Column`, `canim.column`, `beat`) | the shelf (y 48: each folded pane's tag in the frame's order, its note: the scene's, or computed for the registers (those the step changed, the first's value struck as on its row, crossfading with the strike), the source (`line 12`) and the disassembly (`jne 4011af`), crossfading with the advance); the panes from 84 to 1032, 12 apart; texts: `beside` (Go 40 on 54, at most 40 characters a line, 16 of padding, on `raised` while newest, dimming to `dim` without paper, three at most, level with their row, riding it until the panes change or the row goes, an older one gliding above the newest's place or under it), `below` (the caption band), `above` (a band over the drawing), `on` (where the scene puts it, its stem round the drawing's top lane); the change between beats (`change`: fade 12 f, fold 24 f, glide 24 f (48 f between kinds of placement, a pane crossing to the other column going down its own first, then across), unfold 24 f, fade in 12 f; a pane that changes its rows fades out and in round its glide) | +| | `column` | `src/column.zig` (`Column`, `canim.column`, `beat`) | the shelf (y 48: each folded pane's tag in the frame's order, its note: the scene's, or computed for the registers (those the step changed, the first's value struck as on its row, crossfading with the strike), the source (`line 12`) and the disassembly (`jne 4011af`), crossfading with the advance); the panes from 84 to 1032, 12 apart; texts: `beside` (Go 40 on 54, at most 40 characters a line, 16 of padding, on `raised` while newest, dimming to `dim` without paper, three at most, level with their row, riding it until the panes change or the row goes, an older one gliding above the newest's place or under it), `below` (the caption band), `above` (a band over the drawing), `on` (where the scene puts it, its stem round the drawing's top lane); the change between beats (`change`: fade 6 f, fold where it stands and the tag to the shelf 18 f, glide 24 f (a pane crossing to the other column going down its own first, then across, 24 f each), unfold 18 f, fade in 6 f; a pane that changes its height keeps its rows: `Stage.resizing`, the descent's two layouts glided between, the source's window glided); a stem about a folded pane to its tag; `Beat.held`, and a bubble read past its beat flagged on stderr | +| | `segments` | `src/segments.zig` (`read`, `Segments`, `Place`) | the address space to true scale from the recording's mappings (permissions, file offsets): a slim bar the column's height, its ends' addresses and its size; clusters split at gaps of 16 MiB or more, and a band eight times the rest of its cluster in a box of its own; `enlarge` a box at a time (its bands with start, end and size, leaders to the bar), 108 wide; kept above y 888 under the camera (`clipStage`) | +| | the introduction's dump | `src/regroup.zig` (`Words`) | 128 bytes sixteen a row, no ink, the addresses faint; `regroup` to eight a row (bytes become words, low byte last), `ink`, `extend`, `become` (the words into the stack panel's rows) | +| | `aligned` | `src/aligned.zig` | the source and its instructions in one panel, each line level with its code: `interleaved` and `columns`; `decode` (an instruction's bytes to its row) and `align` (one form to the other) | +| | a text standing alone | `src/aside.zig` (`Aside`, `Asides`) | a column's bubble where no `Column` stands (the introduction's texts beside); `shortcut:` it repeats `column.zig`'s bubble drawing | +| | `pair` | `src/pair.zig` (`split`, `Frame`, `Report`, `Marks`, `Clock`, `Shelf`) | two runs on either side of the seam (design/README.md, `pair`): `split` each side's stage; `Frame` a frame as bytes eight a row read by its fields (`hexdump` `eight`: fields live from a moment, the letters keeping a string's ink in a pointer's field, the shadow byte of each row beside it, tall in the column, its words said as values for the relations); `Report` a stopped run's stderr in place of its registers; `Marks` `only here`, `differs`, `attention` and the `fault` (hazard bands round an ink plaque, SIGSEGV); `Clock` one rule and each run's moment; `Shelf` a folded side's tag | | | `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`; `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 | @@ -203,7 +228,7 @@ and read (a debugger's `touch` reads count), each moment's `touch` and ## The recordings -`build.zig` records six programs of `tools/` under `ztrace record` (the +`build.zig` records the programs of `tools/` under `ztrace record` (the debugger: registers, the stack, what they point at, the instructions round the pc with their lines and callees' parameter counts, what each stack word is (`zt.telescope.slots`), at every stop: `--stack 1024 --around 256 @@ -253,6 +278,9 @@ before. The source panel follows the pc into any file it has | `musl` | `hello.c` again, built by Zig for `x86_64-linux-musl`, static, `-O0 -g` (musl compiled from its sources with it: no PLT, its lines its own) | every instruction, `--from main`, `--steps 166` (to main's return) | 173, 55 KB | reads `tools/note` | | `gallery` | the old `list` by line, kept in `test/gallery/list.ztrace`; for the graph pages `sort` and `hello` as recorded on 11 November (with blocks), kept in `test/gallery/sort.ztrace` and `hello.ztrace` (`gallery_sort`, `gallery_hello`) | | 134, 88 KB; 776 KB; 87 KB | the gallery's pictures depend on the drawing only | | `sqlite` | `sqlite.c` (three rows into a table, committed) with SQLite 3.50.4's amalgamation, system clang `-O2 -g -fno-omit-frame-pointer -no-pie -fno-stack-protector -Wl,-z,now`, glibc | `--by break`: `sqlite3_step`, `sqlite3BtreeInsert`, `unixWrite`, and the instruction after its `pwrite64` (found by objdump); every syscall recorded, `-s 4096` | 181 (42 stops, 138 syscalls), 494 KB | made only with `-Dsqlite=DIR` (default `~/05-genizah/sqlite/sqlite-amalgamation-3500400`), in a new temporary directory each time; `sqlite3.c` is embedded as the source | +| `overflow` | `overflow.c` (design/mock/overflow.c: a loop writing 32 bytes into `char buf[16]`), the system's clang `-O0 -g -fno-omit-frame-pointer -no-pie -fno-stack-protector`, glibc | every instruction, `--from main`, to the fault | 298, 60 KB | the recorder says `exit 139`; the SIGSEGV on the moment after `ret`, rip unchanged | +| `overflow_asan` | the same with `-fsanitize=address`, `ASAN_OPTIONS=detect_leaks=0` | every instruction, `--from main`, `--steps 582` (to `__asan_report_store1`'s first instruction) | 785, 257 KB | `--asan` (the shadow); the fake frame's header parsed by the scene from memory | +| `overflow_report` | the same run | `--by syscall --stack 0 --telescope 0 -s 4096` | 707, 401 KB | the report: its `write(2, …)`s, shown from their capture; `exit 1` | What builds each program: `fib.c` (`steps`) and `hello.c` for `musl`, Zig's build (`addExecutable`, musl, static); `hello.c` for `hello`, @@ -322,121 +350,183 @@ 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. -| | fib | list | sort | syscalls | musl | zoom | sqlite | heap | gallery | title | column | column_sort | -| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | -| POP, before / after | 7 / 10 | 12 / 13 | 5 / 3 | 7 / 21 | 16 / 16 | 4 / 5 | 4 / 7 | 16 / 17 | 9 / 9 | 0 / 0 | – / 9 | – / 6 | -| of them the strips' | 0 / 1 | 2 / 4 | 4 / 2 | 0 / 8 | 4 / 1 | 0 / 2 | 0 / 0 | 7 / 6 | 3 / 3 | 0 / 0 | – / 4 | – / 3 | -| POP exempt, before / after | | | | | | | | | cut 5 / cut 5 | | | | -| CROWD, before / after | 3 / 3 | 9 / 8 | 8 / 6 | 4 / 4 | 3 / 8 | 2 / 4 | 1 / 2 | 17 / 18 | 6 / 6 | 0 / 0 | – / 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 | – / 0 | – / 0 | -| CAPTION up over 720 f, before / after | 0 / 1 | 0 / 2 | 0 / 1 | 0 / 0 | 0 / 0 | 0 / 1 | 0 / 0 | 0 / 0 | 0 / 0 | | – / 0 | – / 1 | -| CAPTION under its reading time, before / after | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | | | not checked | not checked | -| 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 | | not checked | – / 1 | -| AIR, before / after | 0 / 0 | 0 / 0 | 1 / 1 | 0 / 0 | 0 / 0 | 1 / 1 | 1 / 1 | 0 / 0 | 1 / 1 | 1 / 1 | – / 1 | – / 0 | -| seconds, before / after | 42.1 / 50.2 | 82.1 / 88.0 | 70.5 / 72.9 | 83.8 / 85.4 | 68.9 / 77.5 | 33.5 / 38.0 | 62.9 / 62.9 | 79.2 / 80.2 | 27.0 / 27.0 | 12.3 / 12.3 | – / 104.8 | – / 30.6 | +| | fib | list | sort | syscalls | musl | zoom | sqlite | heap | gallery | title | column | column_sort | asan | +| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | +| POP, before / after | 10 / 3 | 13 / 10 | 3 / 4 | 21 / 14 | 16 / 7 | 5 / 2 | 7 / 6 | 17 / 15 | 9 / 9 | 0 / 0 | 9 / 4 | 6 / 6 | – / 29 | +| of them the strips', before / after | 1 / 1 | 4 / 4 | 2 / 3 | 8 / 9 | 1 / 1 | 2 / 1 | 0 / 0 | 6 / 5 | 3 / 3 | 0 / 0 | 4 / 2 | 3 / 3 | – / 0 | +| POP exempt, before / after | | – / keyframe 1 | | | | | | | cut 5 / cut 5 | | | | | +| CROWD, before / after | 3 / 3 | 8 / 7 | 6 / 8 | 4 / 4 | 8 / 6 | 4 / 3 | 2 / 2 | 18 / 17 | 6 / 5 | 0 / 0 | 0 / 0 | 0 / 0 | – / 15 | +| METRONOME, before / after | 0 / 0 | 0 / 0 | 0 / 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 | 1 / 0 | 2 / 0 | 1 / 0 | 0 / 0 | 0 / 0 | 1 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | | 0 / 0 | 1 / 1 | – / 1 | +| CAPTION under its reading time, before / after | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | | | not checked | not checked | not checked | +| 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 | | not checked | 1 / 1 | not checked | +| AIR, before / after | 0 / 0 | 0 / 0 | 1 / 1 | 0 / 0 | 0 / 0 | 1 / 1 | 1 / 1 | 0 / 0 | 1 / 1 | 1 / 1 | 1 / 0 | 0 / 0 | – / 1 | +| seconds, before / after | 50.2 / 48.2 | 88.0 / 83.9 | 72.9 / 74.5 | 85.4 / 85.4 | 77.5 / 66.8 | 38.0 / 34.9 | 62.9 / 62.9 | 80.2 / 80.2 | 27.0 / 27.0 | 12.3 / 12.3 | 104.8 / 95.3 | 30.6 / 29.5 | – / 120.0 | + +"Before" is the last pass's "after" (its gallery and title were the pass +before's: this pass exports every scene again). `asan` is new; the +introduction's three scenes (`intro_memory`, `intro_stack`, `intro_code`) +are built and tested but not exported (the round's order moved them to the +next). The column's, column_sort's and asan's "caption" regions are not a +caption's (the text column, a drawing's band), so their CAPTION lines are +not a caption's; the column's own check is the renderer's (`column: bubble N +is still read …`): C2's bubble (74 characters) 1.8 s past its three steps. + +What this pass changed, a kind of one-frame change at a time, each at its +block (the catalogue's rule: nothing changes in one frame): -"Before" is the last pass's "after". The gallery and the title were not -exported again (the gallery keeps `.whole` and its old recordings: its test -against its pictures passes); every other scene was, on the tracer's new -recordings. The scenes that walk stack code are longer: under `tied` a step -that touches the stack or moves rsp plays its verbs one after another -(touch, word, pin, window), and a call or a return walked in a descent takes -the stack's timetable before its windows move (fib +8.1 s, musl +8.6, list -+5.9, zoom +4.5, sort +2.4, syscalls +1.6; heap +1.0 under `.whole`, its new -pop and ret reads taking a memory slot). Five captions now stand over 720 f -(fib, list twice, sort, zoom): the steps under them grew longer, not the -captions. The column's regions are its own (`design/motion/motion.py`: -the shelf, the panes' column and its strips, the text column, the clock and -the caption band); its "caption" region is the text column, which in its -opening and close is the state column and where an older text dims and -glides: its CAPTION counts are not a caption's (the instrument finds 39 -"arrivals" for twelve texts), and are not checked. +- An instruction's in-step annotation (`lea`'s `= 402004 ← "note"`, a + register's first value, a compare's flags, the canary's word, `rbp = + rsp`'s value) fades in from its strike (12 f; at a run with the run's + ease) (`disasm.zig`); a row the advance changes (its state, its trail, its + line number) is drawn as before and as after and crossfades over the + advance's middle (`disasm.zig`, `descent.zig`); a descent's plaque lands + over the advance's second half; a descent window's shared digits are of + its own rows that show. +- Scrolls of the source and the disassembly move at least a pixel a frame + from rest (`cursor.glidePixels`): a glide's first frames, each under a + pixel, stood still a frame on whole pixels. +- The stack's `call` spans are matched by the frame they are (its foot), not + by depth: a call's step drew `_start_c` twice in its first frame; a new + frame comes in with rsp's pin, a frame taken off shrinks to its foot and + goes, the newest from the pin's middle. rsp's amount on its pin comes in + over 6 f; a stub arc (a pointer past the window) and a saved rbp's arc come + in over 12 f with their step and go with its advance; a write's arm frame + comes in over 4 f (the catalogue's 2 f left a few pixels for one frame). +- What the kernel fills (a `read`'s buffer) strikes a byte every 2 f by its + own landing times, each value at s+3, the fill under it; the list's view + scrolls its dump's window (24 f) where it jumped; a node's lone pin name + that had kept the right goes over to the left fading out and in, and two + names whose order a step turns crossfade; the shelf's struck digits + crossfade to bold; heap's own drawing lets its count's and the top's marks + leave as marks leave. +- The column: panes that leave fold where they stand and only their tags + travel to the shelf (6 f rows, 18 f fold), panes glide 24 f, one that + changes its height keeps its rows (the descent was empty 40 f at C7), a + source window of one or two lines shows its line (it showed lines 1 and 2 + of the file at C5 and C6); a drawing's tag note fades where it no longer + fits; C1 to C12's texts as the storyboard cuts them. +- Lengths: the steps the captions do not name run (musl's prologue, its + arguments, `__syscall_cp`'s frame; zoom's `mov rbp, rsp` and `sub rsp`; + list's last loop test said faster), and long captions retimed: fib's first + walks to its frame made (13.6 to 11.6 s), list's two end at the loop's test + (12.07 to under 12 s), sort's last value split in two (12.8 s), zoom's + frame-building one (14.3 to 11.1 s). sort is 1.6 s longer for its split. +- The relations (Part 1.5, above): their pictures and timings are as they + were, every frame of fib, list, zoom, sqlite and column compared before + and after. -What this pass built (design/README.md's "column (an experiment)", `insn`, -`slot`, `stack`, "4. Ties" (`touch`, `carry`); motion.md's "A scene in the -column", "A word touched", "A call pushed", "A return", "The stack's own -instructions"; mocks 44 to 56): +The relations' cost, measured (`CANIM_RELATIONS=1`, a line a frame; `zig +build bench -- relations`): -- The text column (`src/column.zig`, above): the shelf, the panes in one - column, texts `beside` (level with their row, riding it, dimming, three at - most), `below`, `above`, `on`; the change between beats in its order - (fade, fold, glide, unfold, fade in), a pane crossing to the other column - going down its own first, a pane that changes its rows faded round its - glide; `Stage.glide`, `Stage.column` (the clock under the text column), - `Stage.zoom` (a drawing across both columns, its tag at its size); places - for a text to be level with (`ties.Place.row`, `floor`, `block`). The - trial `column` (the storyboard's C1 to C12) and `column_sort` (`on` and - `above` sort's rings). -- The disassembly tied to the stack, the knob `annotation` (`.tied` the - default; `.whole` in heap, sqlite and the gallery): the row's names and one - hop, its moves of rsp and rbp, the stack's offsets from the frame's base - and its two words of headroom, the `touch`, the pin's travel (rows held, - the amount on the pin, rows gained or released, the span riding) and the - window following after, every verb in motion.md's order; the knob `carry` - (`.off` by default; `.arrow` on zoom's first beat). On the tracer's new - recordings: the touches of `push`, `pop`, `call`, `ret`, `leave`, data - names (`head`), the push's role at its own stop, shared words (`i, n`), - the canary. +| | places | values | candidates | drawn | sort | the resolver's passes | all, a frame | +| --- | --- | --- | --- | --- | --- | --- | --- | +| fib, the working frame, each frame | 64 (74 at most) | 27 | 3 at most | 3 at most | 5.5 µs | | 23 µs mean, 69 µs at the 95th, drawing included | +| list, the working frame | 87 (96) | 28 | 5 | 3 | 5.6 µs | | 16 µs, 52 µs | +| list, the map (269 frames) | 790 (827) | 288 | | | | | sort and join 57 µs mean, 81 µs at most | +| bench, a working frame's tables | 300 | 120 | 16 pairs | | 21 µs | join 0.9 µs, passes 0.6 µs | the old table: 11 µs (a lookup a scan) | +| bench, a map's | 4,000 | 6,000 | 746 pairs | | 516 µs | join 19 µs, passes 29 µs | 0.56 ms; the old table 5.7 ms | -Right in one frame, and exempted by name: the encoder's keyframes and the -gallery's cuts (above). +The old table's real cost a frame was not measured (it held under 512 +places and was scanned per lookup): at the working frame's size it was as +cheap; the tables' gain is the map's size and the frame owning them. -What fires still (this pass's exports; located where it says so, the rest -counted, not looked at): +What fires still (the finals; located where it says so): -- The column: four in the panes' strips (12 to 38 pixels, 16.90 to 91.53); - 35.73, a library address's shared digits changing in a frame as the run - enters libc (looked at: the disassembly's own `lead`, as in musl); 82.85, - the read's first byte landing over the buffer's dots (looked at, as in - syscalls before); 59.55 and 91.65, a tag note's struck digits turning - bold (20 to 28 pixels on the shelf, looked at); 20.32 (12 pixels) not - looked at. No CROWD: the panes change one move after another. AIR at - 28.93 (4.9 s): the stub's text (104 characters) is still being read after - its step. -- syscalls: 21, of them 8 in the strips. Looked at: 9.45 and 38.27, a row's - in-step annotation (the `lea`'s `= 402004 ← "note"`, a register set's - `r8 0`) appearing in one frame as the CPU's strike lands, not faded; 59.32, - the source and the disassembly scrolling to line 7 (its first frame the - largest). 11.05, 39.87, 41.47 (the disassembly), 16.62, 59.48, 81.70 (the - stack, 22 to 25 pixels), 44.88 and 49.80 (registers, 12 and 16 pixels), - 49.53 (source, 17), 65.85 (the view, 72: the read's first byte) not - looked at. The new ones are the tie's: they want the in-step annotation - faded in with its strike (`disasm.zig`'s `value_at`), for the same - instruction under `whole` too. -- fib 10, list 13, musl 16, heap 17, sqlite 7, zoom 5, sort 3, - column_sort 6: counted, not located this pass (their timings all moved). - musl's sixteen are mostly in the disassembly, 1.6 s apart in its walks: - likely the same in-step annotations. -- CAPTION over 720 f (fib 15.78, list 39.45 and 68.18, sort 45.48, zoom 1.25, - column_sort 9.67): the steps under a caption grew with the tie's order. -- AIR: sort's, zoom's and sqlite's last pictures (held by design), the - gallery's atoms page and the title's card (not exported again). -- CROWD: the advance (thread, plaques and rip as one mark), the veil over - three panels at a run's first step, sort's `surface` and `dive`; musl's - eight and zoom's four not looked at. +- asan, 29: A6's run, 14 in ASan's disassembly (12 to 29 pixels, 0.3 s + apart: the advance's crossfade at a run is 4 f, small text); plain's + registers' chain string growing at each store of A15 (80 pixels, every + 0.8 s, its rbp and rsp hops reading the letters); 100 pixels at 66.6 s in + plain's disassembly (into the column); the rest single. Its CAPTION over + 720 f is the column part (no caption band there), its AIR the poster's + held rest (meant). +- syscalls 14, 9 of them in the strips: six the disassembly's strip region + crossed by a touch's head (12 to 15 pixels, looked at: the touch leaving + the row's rule over the strip), three the stack's and the source's strips + (38 pixels, not looked at); 4.07, 59.48, 81.70 the stack (23 to 25 pixels, + not looked at); 44.88 and 49.80 registers (12, 19, not looked at). The + read's first byte landing in one frame (65.85) is gone. +- column 4: 28.53 the source's strip as the pane shrinks to two lines at + rest (its strip is drawn at the pane's height, not lagged: looked at); + 52.92 and 82.77 the shelf (106 pixels, not looked at); 60.98 a strip. +- fib 3, list 10, musl 7, sort 4, zoom 2, sqlite 6, heap 15, column_sort 6: + list's 13.62, 42.52 and 71.55 the nodes (120 to 280 pixels: 71.55 a pin's + names, now crossfaded, the others not looked at); musl's 55.68 and 64.28 + in the descent (112 pixels, not looked at); heap's drawing (88 to 197) and + its stack strip (68 to 71) not looked at; zoom's 17.40 registers (12 + pixels) and 24.67 its stack strip. +- The gallery's 12.62 and 15.40 are its relayouts (a page a state), 9.00 its + step. ## What is not done -- The column (an experiment): a text `on` a drawing sits where the scene - puts it (`Beat.where`) and its stem goes along the drawing's top lane and - down to the part it speaks of; nothing checks that it keeps 16 clear of - every element and path, nor falls back to `above` where it cannot. A text - about a folded pane does not point at its tag on the shelf; at a sprint - the scene does not surface to the map with a text `on` it. Only the - registers', the source's and the disassembly's tag notes are computed - (the lens's and the stack's are the scene's). A text rides its row until - the panes change or the row goes, then stays: remembered by the process - as frames are drawn in order (`last_level`, `latched`: an export, a - player playing), so after a seek a text whose row has gone sits at 400 - until its row is seen again. A pane that changes its rows fades them out - and in round its glide (they are laid out for its height), so the - descent is empty for about 40 f as it grows to the kernel's floor. The - panes keep their minimaps (mocks 49 to 53 draw none). The lens is one - object: its view can stand with its drawing folded (the bytes over the - source), not the other way round. The trial is 104.8 s against the - working frame's 85.3 (`syscalls` this pass): the storyboard's longer - texts' reading times and about 9.6 s of pane changes (seven of them); a - sixth longer would be 99.5 s. +- The column: a text `on` a drawing sits where the scene puts it + (`Beat.where`) and its stem goes along the drawing's top lane and down to + the part it speaks of; nothing checks that it keeps 16 clear of every + element and path, nor falls back to `above` where it cannot (the + catalogue asks the renderer to find and check the place). On the way back + to the working frame a drawing whose working box is the band (y 48) glides + over the shelf's tags before they unfold (`column_sort`, 26.6 to 27 s): the + order is the catalogue's (glide, then unfold), but the band's box and the + shelf are at one height; its tag's note now fades where it no longer fits. + A strip of a pane that changes its height at rest is drawn at the pane's + height now, not lagged and averaged (the source's strip at C5, one frame). + At a sprint the scene does not surface to the map with a text `on` it. + Only the registers', the source's and the disassembly's tag notes are + computed (the lens's and the stack's are the scene's). A text rides its + row until the panes change or the row goes, then stays: remembered by the + process as frames are drawn in order (`last_level`, `latched`: an export, + a player playing), so after a seek a text whose row has gone sits at 400 + until its row is seen again. The panes keep their minimaps (mocks 49 to 53 + draw none). The lens is one object: its view can stand with its drawing + folded (the bytes over the source), not the other way round. The bubble + check is the renderer's own (stderr, once a process), not chart.py's: the + instrument still cannot pair the column's texts with what it sees (its + "caption" region is the text column, where texts dim and glide). C2's + bubble (74 characters) is flagged: 1.8 s past its three steps. +- The ASan pair (`asan`): `never returned` on ASan's stopped call is not + drawn (its row keeps the plaque and its call); the disassemblies' tags say + `fill`, not `plain · fill`; plain's registers read rbp's and rsp's chain as + a string of A's (the mock's `← 0x4141414141414141` is not `rows.chain`'s); + a field keeps one held corner (the newest write's), not one a byte; the two + disassemblies keep their own windows round their pcs, not aligned by line; + the clock says `i 27 · plain moment N · asan moment M`. In the column, plain's + descent follows the frame chain, which the overwritten return address ends + in `fill` from i = 24: main's window goes over 82.4 to 83 s, after the aim + has glided to `fill+1`. The scene is 120 s against the storyboard's 112: + the two-line captions' reading times and the column's changes. A6's run + and A15's stores leave one-frame changes (above). The recorder cannot stop + a run by instruction at a function: ASan's is cut by a count (`--steps + 582`), which moves with the compiler; the fake frame's header is parsed by + the scene from memory, plain's fields from the instructions' rbp offsets, + and the two runs' stops are matched by pc. +- The introduction (`intro_memory`, `intro_stack`, `intro_code`): built and + tested before the round's order moved it to the next round; not exported, + and its chapters II and III not looked at again after their last texts + were cut. Chapter I follows its storyboard (68 s against 66): the bytes + under the camera, `regroup`, `segments` and `enlarge` (with a box of its + own for the tracer's 64 MiB ring, which the recording's mappings hold), + the tie, the visit, `ink`, the chains. II has no touch line (no + disassembly row on screen), its roles and spans come with the rows, its + stack shows 23 words (16 asked), its registers are canim's folded layout + (not mock 31's seventeen rows). III has no annotation column (mock 33's + chain) and no keyword ink in its source, `stack` is a crossfade (not a + morph), the minimaps do not draw themselves last, and the map's text is a + caption, not `on` the map. All three use `list` (moment 77; 582 for III): + `--from reverse` stops past the prologue, so the `push rbp` the storyboard + names is the call's push of its return address. +- The relations: arcs within a panel (the stack's, a dump's, a loupe's) + are still each panel's own (`rows.Arcs`, lanes per panel), not rows of + the frame's tables; the column's stems are drawn by the column, their + targets found in the tables; a loupe's stem and a dump's place are not + kinds yet. The beat's `emphasis` is not built; the carry keeps its own + budget (it was drawn beside a link and a projection before, and is still: + the catalogue counts it among the two active lines). The tables are made + and sorted every frame, not cached per moment and window. An aim for the + step (`.step`) has no slot of its own in the step's timetable (it draws + after the word's strike, over what follows). The map's places and values + are tabled and measured (`CANIM_RELATIONS=1`), but the map draws no + relation of the frame's: its thread and arcs are its panels' own. - The tie to the stack (Part B's leftovers): the window's scroll to a touched word outside it happens in the fire's frames, with no slot of its own; in a step by line all writes land before the pins and the call row does not |
