diff options
| author | Gabriel Schneider <[email protected]> | 2026-11-11 02:11:12 -0300 |
|---|---|---|
| committer | Gabriel Schneider <[email protected]> | 2026-11-11 04:20:25 -0300 |
| commit | 5922ee911b9a6604f60dc83be36ba9e6c9abac98 (patch) | |
| tree | 310b983f5205709e5db173f9f1bc8e8d499d24fe /anim/README.md | |
| parent | 64e64c74be6a3e46abeae8a30dd42efff91aaf91 (diff) | |
| download | computeranim-5922ee911b9a6604f60dc83be36ba9e6c9abac98.tar.gz computeranim-5922ee911b9a6604f60dc83be36ba9e6c9abac98.zip | |
canim: what the second review found, fixed
A system call stepped over plays in order: the registers set, the
crossing from the call row with the kernel's window under it, the stores
after rax. A strike covers the bytes that changed. The band's view
changes with the argument framing. In the descent a callee sits under
its caller's return row, and rows fade before others glide. The heap
scene follows the storyboard's nine captions: pushes at a run without
marks, each free and the malloc that takes the head back walked, the
tcache's loupe over the stack and closed with each advance, a chunk in
neither list drawn, the freed node travelling to malloc's row. In the
dive the map falls into the corner and becomes the minimap; on the map
boxes are as long as their rows. A narrow read is shown at its width.
The chart checks captions and one-frame changes.
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 | 239 |
1 files changed, 118 insertions, 121 deletions
diff --git a/anim/README.md b/anim/README.md index 3e7c8f4..27b0983 100644 --- a/anim/README.md +++ b/anim/README.md @@ -16,7 +16,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 -python3 tools/chart.py chart out/fib-1080.mp4 --out out/motion/fib # the designer's timing chart and five checks +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) ``` Needs what sketchbook and ztrace need, and `setarch`, `clang` (the pass @@ -67,20 +67,23 @@ state at the cursor, at the box its `Stage` gives it now. a later one (`Recording.Stop`: `.moment`, `.line`, `.over`, `.call`, `.syscall`). For each step it writes a timetable, a `Plan`: the cascade. The line fires (12 f); each level the step touched strikes 18 f after the one -before, in the order CPU, memory, idea (a level the scene does not show, or +before (after the last of its registers, which strike 6 f apart), in the order CPU, memory, idea (a level the scene does not show, or 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 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) or a sprint, `step` takes an explicit `Plan` (`Array.swap`, +step: nothing struck, no held corner, no arc, a dump's values crossfading +over 8 f; the arcs fade back in as it ends) or a sprint, `step` takes an explicit `Plan` (`Array.swap`, `syscalls.step`), and `continue` goes to a stop far from this one (a breakpoint): the line it leaves fires, the registers it changed strike in a wave 2 f apart in pwndbg's order (fill 6 f, no arm, no pulse), then memory and the idea, a 36 f hold, the mark out and in (6 f each, the source fading through first if far), a 24 f rest. Components read it -through `Cursor.now(at)`. +through `Cursor.now(at)`; the minimap reads the same values 6 f behind +(`Cursor.lag`, `time.minimap_lag`), so nothing on it starts on a primary +onset's frame. ## The scenes @@ -90,8 +93,8 @@ through `Cursor.now(at)`. | `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, 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 crossing opening under its call | `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; the chunks by fields (`size`, `protected`, `key`), the program's list over the tcache's free list with its `bin`, the tcache in a loupe hung from its chunk's row | `subject`, the scene's own drawing (`nodes` in two rows) and view | `heap` | +| `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); 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 | `heap` | | `zoom` | one line of C as its instructions, the call's bytes | `none`, the camera at x2 | `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` | `sqlite` | | `gallery` | every block in its states | all three | `gallery` | @@ -105,19 +108,19 @@ every state the code has in the `gallery` scene. | --- | --- | --- | --- | | 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 | -| 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, `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 | +| | `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 | | | `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 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; 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`); 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) | -| | `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; 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 up the lane, the window drawing back at the advance. A crossing stepped over opens the same window at the floor under the call's line. 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: `descend` (2.7 s), on through a stub's `jmp` (2.0 s), `ascend` (2.3 s), `cross` (`syscalls.step`); with it the source's line `waiting` (ringed, the tag `main waits at line 6 · the pc is in libc's open`) and the thread waiting (primary, 2) | +| | `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` | 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; 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`), 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` | | | `source` | `src/source.zig` | the whole file in a window, its middle third; 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 | | | `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; 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; from a register, or from a pointer field of a loupe; `open` 36 f (read 6, stem and rise 18 with the shadow, the frame 6 f after), `close` 12 f | -| | 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 is given or fills, `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 | +| | `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 | | 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 | -| 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`: the drawing and the source, the disassembly 69, the view 32, the registers and the backtrace, the stack 69 from 16 words above rsp); its rows published while `ui.mapping`; the working windows outlined (2 `dim`, 4 out); 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`), 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 in reading order, opaque on the way, its rows on the window's rows, its tag and rules in at the end; the map falls to the minimap's rect over 72 f; 120 f and 30 f still), `.surface` (the dive back, 84 f, then 30 f still); per-panel transforms through `context.at` (`context.zoomed`) | +| 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 drawing, the source and under it the backtrace; the disassembly; the view, the registers, and in the column's rest the stack going on, `stack, continued`; the stack from 16 words above rsp); its rows published while `ui.mapping`; the working windows outlined (2 `dim`, 4 out); the thread across the gutter (x 1008), gold; 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`), 6 f behind the frame, a stack word struck outside the stack's window flashing on it (a ring 8 to 14, 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` | | 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` | `src/cursor.zig` (the timetable), 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`) | @@ -162,124 +165,118 @@ holds is named from its module's first mapping (`list+2c89`). ## Motion, as measured -`tools/chart.py chart` on the 1080p exports in `out/` (the designer's five -checks; its regions are the working frame's; the minimap, 1664 to 1856 by -912 to 1020, is in none; `syscalls` now has the `beside` split's regions, -`heap` the `subject`'s). Encoded with `-g 600`: x264's keyframe at 10, -20, 30 s is a one-frame fade the instrument sees. "Before" is the last -pass's exports; "after" this pass's: operands without size words, the -row's detail, the backtrace newest at the bottom, the syscalls scene -remade on glibc by instruction with the descent, the heap scene new, -`list` and `sort` recorded with `--stack 1024`. +`tools/chart.py chart` on the 1080p exports (the designer's +`design/motion/motion.py`, its checks and its regions told where canim's +panels are; the clock, ranged right at 1648, its own region, whose count +changing in a frame is no POP; the caption's box from 940, under the +clock's count and a run's step counter; the minimap its own region, +secondary action, and its one-frame changes POPs). POP: any region still +for 12 f that changes in one frame and is still again. 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. Encoded with +`-g 600`: x264's keyframe at 10, 20, 30 s is a one-frame fade the +instrument sees. "Before" is the last pass's exports charted by this +instrument (the old scenes' captions are not the sources' now: +syscalls' and heap's reading times not checked); "after" this pass's. -| | fib | list | sort | syscalls | zoom | sqlite | heap | -| --- | --- | --- | --- | --- | --- | --- | --- | -| POP, before / after | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | new / 0 | -| CROWD, before / after | 2 / 2 | 6 / 6 | 4 / 4 | 1 / 5 | 3 / 3 | 1 / 0 | new / 10 | -| RUSH, before / after | 2 / 0 | 2 / 2 | 0 / 0 | 1 / 2 | 0 / 0 | 2 / 2 | new / 3 | -| AIR, before / after | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 2 | 1 / 1 | 5 / 5 | new / 2 | -| METRONOME, after | 0 | 0 | 0 | 9 | 0 | 0 | 0 | -| seconds, after | 41.5 | 70.9 | 42.0 | 75.9 | 32.0 | 64.6 | 100.4 | +| | fib | list | sort | syscalls | zoom | sqlite | heap | gallery | +| --- | --- | --- | --- | --- | --- | --- | --- | --- | +| POP, before / after | 43 / 44 | 52 / 43 | 41 / 32 | 72 / 66 | 19 / 22 | 11 / 14 | 83 / 72 | 13 / 10 | +| of them the minimap's, before / after | 13 / 16 | 31 / 26 | 17 / 15 | 45 / 47 | 12 / 14 | 5 / 8 | 49 / 48 | 6 / 5 | +| CROWD, before / after | 2 / 2 | 6 / 8 | 4 / 5 | 5 / 2 | 3 / 3 | 0 / 0 | 10 / 7 | 3 / 4 | +| METRONOME, before / after | 0 / 0 | 0 / 0 | 0 / 0 | 9 / 9 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | +| CAPTION up over 720 f, before / after | 0 / 0 | 3 / 2 | 0 / 0 | 0 / 0 | 1 / 1 | 0 / 0 | 4 / 1 | 0 / 0 | +| CAPTION under its reading time, after | 0 | not paired | 0 | 0 | 0 | 0 | 0 | | +| CAPTION picture moving within 60 f, before / after | 0 / 0 | 1 / 1 | 0 / 0 | 1 / 1 | 0 / 0 | 2 / 2 | 1 / 1 | 0 / 0 | +| AIR, before / after | 0 / 0 | 0 / 0 | 0 / 0 | 2 / 2 | 1 / 1 | 5 / 5 | 2 / 0 | 0 / 0 | +| seconds, before / after | 41.5 / 42.0 | 70.9 / 71.1 | 42.0 / 42.2 | 76.0 / 89.2 | 32.0 / 32.0 | 64.6 / 64.6 | 100.4 / 96.8 | 11.0 / 11.0 | -New this pass, not examined frame by frame: syscalls' METRONOME (30.62 -to 33.00) is the run through libc's `open` to its `syscall`, steps 0.30 s -apart by design (a run); its AIRs at 13.42 (3.9 s) and 20.90 (5.0 s) are -the stage still under a long caption after a `descend` and after the -stub's `jmp`, which wait for the caption before them to be read; its -CROWDs (13.10, 59.80, 62.50, 68.50 and one more) are not examined. The -heap scene's CROWDs (10.00 the keyframe; 15.62, 26.62, 40.22 and six -more), its RUSHes (29.60, 29.93, 69.68) and its AIRs (65.62, 3.9 s; -70.03, 7.2 s: the tcache's loupe open under a caption of 120 -characters) are not examined. fib's two RUSHes of the last pass are gone. +What fires, and why it is left, by kind (examined this pass): -What fires, and why it is left (as examined the last pass: the times of -`list` and `sort` moved with their new recordings, and the syscalls scene -named below is the old one): - -- CROWD: fib 12.05 and 27.20, list 30.62 and 32.18, sort 17.60 are the - veil coming over the registers, stack and disassembly at the first - shortened step (one veil over three panels); zoom 9.65 and 21.55 the - camera (the regions are fixed on the screen); zoom 11.75 the stack's - window scrolling to its hold under the camera (the stack fills every - region there); sort 30.00 is x264's keyframe on a step's first frame. - The rest (list 15.92, 19.32 and the others like them, sort 11.68, - 29.42 and 36.13, syscalls 34.75, zoom 3.62) are an - `advance`: the thread, the plaques and rip move as one mark, the - source and the disassembly scroll with it, and a link or projection - goes back into its pin, all on the catalogue's one frame. (sqlite's, - the crossing's advance at 43.40, no longer starts with another panel.) -- RUSH: list 29.20 and 29.55, syscalls 29.32, sqlite 9.10: a caption - arrives, and the next change the instrument sees is the keyframe at - 30.00 (10.00) (a fade of every region over one frame, 0.00% at its - peak). -- AIR: a caption's reading time on a still picture: the last one's and - the 2 s on the finished picture (zoom 26.88, 3.1 s; sqlite 60.03, - 4.6 s), and in sqlite four more, each a dense caption over a stop - (11.38, 7.2 s: the arguments; 24.57, 3.2 s: the two more rows, now - that a continue is a wave and a 36 f hold and not a cascade's longest - hold; 32.95, 3.2 s: the commit's backtrace; 50.03, 4.9 s: the page's - header), its fields framed as it names them. +- POP, the minimap (about half of every scene's): it follows the frame + 6 f behind, but a row's stroke or a mark's block changes in one frame; + a fade of each change is not built. +- POP, registers, stack, view: a read frame that goes in one frame, a + value changing at a run (registers and stack are veiled then), a + stack window going farther than its height; the heap's drawing: a + node's value turning at the middle of its travel. The heap's pins + crossfade now; its dump comes in faded at the first malloc. +- 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, x264's keyframes; list 0.02 and 2.52, the map + coming in and the dive's first frame. +- METRONOME: syscalls 36.77 to 39.17 is the run through libc's `open` + to its last three instructions, 0.30 s a step by design (a run). +- CAPTION over 720 f: heap 9.83, malloc's caption over its five walked + steps (12.9 s); list 21.75 and 46.58 and zoom 8.38, the captions of + their walked trips. Picture moving within 60 f: the step firing 60 f + after the caption by the narrator's lead, which the check counts from + the frame after (heap 9.83), x264's keyframe (syscalls 9.95), and + list 3.63, the falling map crossing the caption band in the dive (it + also makes list's arrivals 7 to the scene's 6). +- AIR: syscalls 13.72 and 20.10, the stage still under the two captions + that recount the descend and lead the stub's `jmp` (the review's + split); sqlite's four dense captions and its last; zoom's last. ## What is not done -- The descent: a caller's three rows glide to the window's top only - where the deepest window leaves the caller no more rows (the nearest - caller keeps the rest round its call row, as mock 16's second panel - does); when the call row's plaque becomes the ring (72 f) its - arguments, which hung under it, go in one frame, as its annotation - turns to the call in C's form. The kernel's three rows are kept at the - floor from the `syscall` to the stop after it, so the rows under the - call move up again a step later. A crossing stepped over opens the - kernel's window at the panel's floor, over its last three rows, not - under the call row; its lane leaves from the pc's plaque. The fold - past three windows (`2 calls: fib fib`), a lazy PLT's resolver row and - the vDSO's window are written but no recording shows them; the descent - on the map is the same component at 69 rows, not checked. `cross` - keeps the crossing's timetable of the last pass (`syscalls.Plan`), - which is motion.md's within a few frames. +- The descent: the kernel's three rows are kept at the floor from the + `syscall` to the stop after it, so the rows under the call move up again + a step later. The fold past three windows (`2 calls: fib fib`), a lazy + PLT's resolver row and the vDSO's window are written but no recording + shows them; the descent on the map is the same component at 69 rows, not + checked. At a run the windows do not open and close in 8 f with no lane + (the syscalls scene walks every step of the descent). - `open("note", O_RDONLY) = 3` does not fit 880 from 564 (27 characters): the arguments go from the right, `open("note", …) = 3`. A call's arguments come from as many as the source's call writes, typed by the system call of the function's name (`open`, `read`): a libc function with no system call of its name has its arguments in hex. - The heap scene's drawing and view are the scene's own components - (`Lists`, `Chunks` in `scenes/heap.zig`), not blocks of `src/`. A node - travels between the rows only where both stops have it in a list: the - first free takes 9 out of the program's list (`head = n->next`) a line - before `free(n)` gives it to the tcache, so it leaves the top row and - comes into the bottom one instead of travelling. The bin's box turns - from dashed to raised, and its count changes, at the idea's slot with - no strike; a `size` bit that changes is not struck on its chip. Between - malloc's return and the push's store a chunk taken back is in neither - list and not drawn (mock 18's fifth panel draws it with its old link). - The heap's map shows no arena panel. - -- The map is packed into fixed places (`map.split`): a panel longer than - its column is a window of what fits; continuing in the next column's - free space under `continued`, the key in a column's foot, `memory` in - a scene without a lens, and loupes as panels on the map (and as lifted - blocks on the minimap) are not built. The sqlite scene's lenses (the - backtrace, the calls so far) and the zoom scene have no drawing on - their map. A disassembly of 69 rows shows what the recording decoded - round the pc, so a small function leaves rows empty. -- The minimap draws no thread and no `flash`; its windows are outlined a - frame behind the panels that publish them after the clock (the lens's - view). The scene's focus is not set on it. + (`Lists`, `Chunks` in `scenes/heap.zig`), not blocks of `src/`: no + second scene needs them. It is 96 s, not the storyboard's 79.4: its + steps are the engine's cascades (a call 3.1 s, a prologue 2.9 s), longer + than the storyboard's budget; its captions keep their order and leads. + `free` is stepped over as one step from its line (a continue's wave), + not as a cascade onto its call row and then the call (mock 18's + `free in libc, stepped over`). A `size` bit that changes is not struck + on its chip. The heap's map shows no arena panel and no drawing (the + scene adds its lens to the working frame only). +- The map is packed by content, but a column's rest after the + disassembly is page: the 5-row dumps round what the registers' and the + stack's pointers point at, loupes as panels on the map (and lifted + blocks on the minimap) and the map's key are not built; `continued` is + built for the stack alone. The boxes are as long as the most rows each + panel has wanted so far (`map.measure`, process-wide, a frame behind): + a scene's first frame packs by the defaults. The sqlite scene's lenses + (the backtrace, the calls so far), the heap's and the zoom scene's have + no drawing on their map. +- The minimap follows the frame 6 f behind, but its changes are not + faded: a row's stroke or a mark's block changes in one frame (most of + the instrument's POPs). A struck word outside every window flashes on + it only for the stack. Its windows are outlined a frame behind the + panels that publish them after the clock (the lens's view). The scene's + focus is not set on it. - `dive`: every panel travels 60 f (the catalogue's 72 f is the map's fall), so that seven of them 6 f apart land by 120 f; the drawing does - not crossfade between sizes (the list's are the same, subject on both); - panels draw in the scene's order (source, disassembly, registers, stack, - then the lens), not the reading order, so the stack passes over the - registers' lower rows, opaque, for about 0.35 s before it lands. Only - the list opens on the map; no scene surfaces, and no sprint or far + not crossfade between sizes (the list's are the same, subject on both). + Only the list opens on the map; no scene surfaces, and no sprint or far continue plays on the map. -- A loupe keeps to the stage but does not yet move past the current marks - or a changed row; on the 1920 stage a deeper loupe has 20, not 120, to - its right (the stage's edge), and covers most of the first. The - catalogue's stem is 3 in its strokes and 4 in the loupe's anatomy: it is - 4 here. +- A loupe hung from a register keeps to the stage but does not yet move + past the current marks or a changed row; on the 1920 stage a deeper one + hangs under the first, not 120 to its right. The catalogue's stem is 3 + in its strokes and 4 in the loupe's anatomy: it is 4 here. - An `arc`'s lane change does not glide (12 f): a lane is given each frame from the arcs then present. +- At a run only a dump's values crossfade (8 f); a register's, a slot's + and a node's change in a frame (the registers and the stack are veiled + at a run). +- The gallery keeps the old recording of the list + (`test/gallery/list.ztrace`): on the build's list (by instruction) its + loupe page has no second loupe, the nodes being 32 bytes apart and a + loupe's five rows holding the next one's target already. - Back pointers between nodes still run under the nodes: a page keyline round each pin's stub and head shows them passing behind it (there is @@ -318,12 +315,12 @@ named below is the old one): nodes and badges collide (the catalogue's known case). - 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`) and the - ties' table and the thread's waiting are process-wide globals, set and - read in one frame's drawing; two players at once would want them on - the frame. The gallery keeps the old recording of the list - (`test/gallery/list.ztrace`), so that its pictures change with the - drawing alone. + `ui.chrome`), a dive's per-panel transforms (`context.zoomed`), the + map's measured rows (`map.held`), the ties' table and the thread's + waiting are process-wide globals, set and read in one frame's drawing + (the measured rows a frame behind); two players at once would want them + on the frame. Not moved this pass: each is read by components that the + frame reaches only through `anim.Placed`, which carries no frame state. - A recording holds the bytes it has seen, each as last seen: it cannot tell a byte read again and unchanged from one not read since. Memory nothing watches (SQLite's page cache) is read at a stop only where a @@ -342,4 +339,4 @@ named below is the old one): kernel's side does not bring its elements in as at `establish`. - `zig build test` prints "failed command" for each scripted scene: that is the run echoing its stderr (the Vulkan headless warning), not a - failure; the summary line is the verdict. + failure; the summary line is the verdict (none printed when it passes). |
