summaryrefslogtreecommitdiff
path: root/anim/README.md
diff options
context:
space:
mode:
authorGabriel Schneider <[email protected]>2026-11-11 00:06:30 -0300
committerGabriel Schneider <[email protected]>2026-11-11 01:16:48 -0300
commitc3d9f7ba5effd615374b1359ad98ecf801559f83 (patch)
tree07f85932abc1df23c722bcd1bd1b3b65bca28f2e /anim/README.md
parentc94ade9e77a811d3ff75ffc2889a65375262ab1f (diff)
downloadcomputeranim-c3d9f7ba5effd615374b1359ad98ecf801559f83.tar.gz
computeranim-c3d9f7ba5effd615374b1359ad98ecf801559f83.zip
canim: a call followed down to the kernel; rows that say what they do; the heap from the inside
From the user. The disassembly can descend: the syscalls scene is glibc's hello by instruction, and open is followed from main through its PLT stub, whose jmp reads the GOT, into libc's wrapper to the syscall row, which crosses to the kernel's window under it, and back up. The band keeps the calls so far as strace writes them. Operands lose their size words and show a width as byte cells only where nothing else says it. A compare shows its values and the flags it leaves, a jump the flags it reads, lea its result, an indirect jump its target and the slot it read, a call that has run its C form. The backtrace has its newest frame at the bottom. A new scene shows glibc 2.44's heap from blocks that exist: chunks read by fields (a size with its bits, a protected pointer), the free list as arcs, the tcache in a loupe, the program's list over malloc's own. 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.md124
1 files changed, 84 insertions, 40 deletions
diff --git a/anim/README.md b/anim/README.md
index c59630a..3e7c8f4 100644
--- a/anim/README.md
+++ b/anim/README.md
@@ -90,7 +90,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` | open, read, close, write: the kernel's side | `subject`, `syscalls` | `hello` |
+| `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` |
| `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` |
@@ -107,13 +108,14 @@ 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 |
| 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 |
| | `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; operands whole, the annotation from 564 or a character after them; then a size word goes, then the operands give way, never inside `[]`; `current`, `ran` (every instruction of the last three steps), `ahead`, `outside`; the jump lane from the jump just before the pc's moment |
-| 3 panel | `registers`, `stack`, `backtrace` | `src/context.zig` | 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` |
+| | `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) |
+| 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` | 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`) | 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 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 |
+| | `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 |
| 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`) |
| | `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 |
@@ -127,7 +129,7 @@ and read (a debugger's `touch` reads count), each moment's `touch` and
## The recordings
-`build.zig` records four programs of `tools/` under `ztrace record` (the
+`build.zig` records five 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
@@ -142,9 +144,10 @@ and no canary stepped through that the source does not say.
| Name | Program | Stops | Moments, bytes | Also |
| --- | --- | --- | --- | --- |
| `steps` | `fib.c`, static musl, `-O0` | every instruction | 1999, 431 KB (336 KB before) | |
-| `hello` | `hello.c`, static musl | every line | 233, 126 KB (101 KB) | reads `tools/note` |
-| `sort` | `sort.c`, `ztrace cc --instr vars --only sort,a` | every instruction, `--from main` | 5154, 799 KB (617 KB) | `--ring`: the variables' names and types; each `__zt_var` call is stepped (4 of them); `--stack 256` (below) |
-| `list` | `list.c`, `ztrace cc --instr vars --only push,reverse,head` | every instruction, `--from reverse` | 3369, 782 KB (528 KB) | `--alloc --preload` the agent: allocator headers are read; the pushes (the agent's and the runtime's first calls) run through; `--stack 256` (below) |
+| `hello` | `hello.c`, the system's clang and glibc, dynamic: `-O0 -g -no-pie -fstack-protector-strong -Wl,-z,now` (a PLT bound at load, no resolver; the canary) | every instruction, `--from main`, `--steps 132` (to main's return) | 166 (30 of them the loader's syscalls before main), 83 KB (233, 126 KB: static musl by line) | reads `tools/note`; PLT stubs and GOT slots named (`open@plt`, `open@got`) |
+| `heap` | `heap.c` (design/mock/heap.c), the system's clang and glibc, dynamic, as `hello` | every line, `--from main` | 75, 59 KB | `--heap` (`ztrace.heap.glibc`: chunks, the tcache, bins, the arena); `-w 0x405000,1024` (the chunks' bodies) and `-w head` (the global the list hangs from: unwatched, a recording keeps a global as last seen) |
+| `sort` | `sort.c`, `ztrace cc --instr vars --only sort,a` | every instruction, `--from main` | 4396, 751 KB (5154, 799 KB at `--stack 256`) | `--ring`: the variables' names and types; each `__zt_var` call is stepped (4 of them) |
+| `list` | `list.c`, `ztrace cc --instr vars --only push,reverse,head` | every instruction, `--from reverse` | 2913, 742 KB (3369, 782 KB at `--stack 256`) | `--alloc --preload` the agent: allocator headers are read; the pushes (the agent's and the runtime's first calls) run through |
| `gallery` | the old `list` by line, kept in `test/gallery/list.ztrace` | | 134, 88 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), 233 KB (139 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 |
@@ -153,42 +156,45 @@ its first stop (`Recording.index`, from the frame chain). Writes are the
bytes whose value changed, to the element the instruction stored (its
`touch`); a store of the same value is kept apart (`storedSame`) and
counts as assigning a local (and as a name coming to a node's pin). A register's change over a step is net: a
-call's rsp put back is not struck. The vDSO's `clock_gettime` is stepped
-through under the runtime and the agent: its retry loop makes the counts
-vary a little from one recording to the next, and with a slower stop it
-seldom gets out: `list` with `--stack 512` took 27 000 to 42 000 moments,
-with 1024 0.3 to 1.6 million (100 MB, minutes), against 3 900 at 256
-(`--around` and `--disasm` matter little). So the two instrumented
-programs keep `--stack 256` (48 words with the 128 bytes under rsp): their
-map's stack column is shorter. The tracer should run through a call into
-the vDSO as `step` runs through code without lines. An address no symbol
+call's rsp put back is not struck. A call into the vDSO (the runtime's clock) is one moment, as the tracer
+now records it: `list` and `sort` have `--stack 1024` like the rest. An address no symbol
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). Encoded with `-g 600`: x264's keyframe at 10,
+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: the new marks, the stack's row, arcs,
-the minimap, the list's map and dive and its loupes, the recordings remade.
+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`.
-| | fib | list | sort | syscalls | zoom | sqlite |
-| --- | --- | --- | --- | --- | --- | --- |
-| POP, before / after | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 |
-| CROWD, before / after | 2 / 2 | 7 / 6 | 5 / 4 | 1 / 1 | 4 / 3 | 0 / 1 |
-| RUSH, before / after | 0 / 2 | 2 / 2 | 0 / 0 | 1 / 1 | 0 / 0 | 1 / 2 |
-| AIR, before / after | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 1 / 1 | 5 / 5 |
-| seconds, after | 41.5 | 70.9 | 42.0 | 37.9 | 32.0 | 64.6 |
+| | 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 |
-New this pass: list's CROWD at 2.52 is the dive (the windows go bright,
-then every panel sets off within 0.5 s: by design one move); fib's RUSH at
-5.78 and 7.30 is x264 noise in the caption band (30 pixels changing by 6
-to 24 levels under the still caption while the panels move), not a
-caption arriving; sqlite's new RUSH at 19.05 is not examined. The rest are
-as below.
+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:
+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
@@ -216,12 +222,44 @@ What fires, and why it is left:
## 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.
+- `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 kernel's side) and the zoom scene have no drawing on
+ 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
@@ -278,8 +316,14 @@ What fires, and why it is left:
window would put its count over the panel's tag.
- The calls tree's leaf spacing holds for fib(5); past about ten leaves
nodes and badges collide (the catalogue's known case).
-- `heap` and `pages` lenses are not in the band (`Timeline` is the old
- far view).
+- 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.
- 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
@@ -293,7 +337,7 @@ What fires, and why it is left:
recording tells (an instrumented program's); at a breakpoint the
callee's are in its registers, which the scene's captions name.
- The sqlite scene changes what is over the band (the backtrace lens,
- then the kernel's side) and its view (the SQL at rbx, the row, the
+ then the calls so far) and its view (the SQL at rbx, the row, the
page) by fades scripted in the scene (12 f out, then 12 f in); the
kernel's side does not bring its elements in as at `establish`.
- `zig build test` prints "failed command" for each scripted scene: that