diff options
Diffstat (limited to 'anim/README.md')
| -rw-r--r-- | anim/README.md | 124 |
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 |
