summaryrefslogtreecommitdiff
path: root/anim/README.md
diff options
context:
space:
mode:
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