From 4862e778af7779bbdb047b9c71adfb62add319b2 Mon Sep 17 00:00:00 2001 From: Gabriel Schneider Date: Wed, 11 Nov 2026 14:17:43 -0300 Subject: design: the disassembly stays under the source; the graph as a track From the user, on the sort render. Registers a scene never changes fold three to a row, so the stack is twelve to fifteen slots and the disassembly keeps its place under the source with eleven to seventeen rows; a blocks lens has no view. The graph leaves the layered picture of the reverse-engineering tools: blocks are pills on one line in the order they run, a loop an arch over its blocks with the turn count at its centre, every bend a quarter circle; sort's eleven blocks and both loops are seen whole across the band. Sheets 42 and 43 set the layouts and the graph's forms side by side. Co-Authored-By: Claude Fable 5.2 Claude-Session: https://claude.ai/code/session_016Y9MNCKgYCGiANnEwcEQxa --- design/README.md | 468 +++++++++++++++++++++++++++++++++++++------------------ 1 file changed, 313 insertions(+), 155 deletions(-) (limited to 'design/README.md') diff --git a/design/README.md b/design/README.md index 027a1b5..084b9d6 100644 --- a/design/README.md +++ b/design/README.md @@ -11,7 +11,7 @@ scene that draws every block in every state is the test of this page. - The numbers are tokens in `anim/src/theme.zig`: [what to change there](#token-changes). -![the working frame, mid-step, each pane with its minimap](mock/10-context-step.png) +![the working frame, mid-step, each pane with its minimap](mock/41-frame-subject.png) ## The rules @@ -27,10 +27,11 @@ scene that draws every block in every state is the test of this page. 4. **Solid vellum is the kernel**, and nothing else. 5. **Panels are acme windows.** A tag, a 2-unit rule, a body. Square corners, no shadows, no gradients, no glow. -6. **The whole context, always.** Every register followed as far as it - points, the instructions round the pc, the source, the stack: in - the same place in every frame, as pwndbg shows them. A lens (a list, a - tree, an array) is drawn over that state and never instead of it. +6. **The whole context, always.** Every register (those the scene moves + followed as far as they point, the rest with their values), the + instructions round the pc under the source, the stack: in the same + place in every frame, as pwndbg shows them. A lens (a list, a tree, an + array) is drawn over that state and never instead of it. 7. **Panes are views of one machine, and the ties are drawn.** A source line and its instructions, a register and what it points at, a run of bytes and the node drawn from them: each relation has a form, a route @@ -70,12 +71,12 @@ this table. | | [`bytes`](#bytes) | sixteen bytes of a dump and what they read as | field runs (`size`, `protected` among them), marks per byte; wide address | | | [`call`](#call) | one frame of the call chain | `row`, `span`; `newest` | | | [`arc`](#arc) | a pointer to a row of the same panel, drawn | standing, `touched`; a stub | -| 3 panel | [`registers`](#registers) | all seventeen | | -| | [`stack`](#stack) | a window on the newest frame's words, and the frames they belong to | 8 or 6 slots | +| 3 panel | [`registers`](#registers) | all seventeen: a row each for those the scene moves, the rest three to a row | `quiet` | +| | [`stack`](#stack) | a window on the newest frame's words, and the frames they belong to | what the state column has left: 12 to 15 slots | | | [`backtrace`](#backtrace) | the call chain as rows, newest at the bottom | in the `none` split; the view of `calls`; a lens's drawing | -| | [`source`](#source) | a window on the file | 14, 8 or 10 lines | -| | [`disasm`](#disasm) | the instructions round the pc | 17 or 9 rows; a [`descent`](#descent): a window a call deep, the kernel at the floor; a [`graph`](#graph): the function's blocks | -| | [`lens`](#lenses) | a drawing of some state over the program's two columns, and in the third the pane it is a view of | `beside`, `subject` | +| | [`source`](#source) | a window on the file | 14 lines, 8 with a lens | +| | [`disasm`](#disasm) | the instructions round the pc, under the source | 17, 11 or 15 rows; a [`descent`](#descent): a window a call deep, the kernel at the floor; a [`graph`](#graph): the function's blocks as a track | +| | [`lens`](#lenses) | a drawing of some state over the program column, and over the state column the pane it is a view of; with no view, the band across both | `beside`, `subject`, `blocks` | | | [`hexdump`](#hexdump) | memory, a `bytes` row a line | typed or by `fields`; `eight` (a stack frame, a word a row); `more` rows; `seen`; `given`; `memory` | | | [`loupe`](#loupe) | the memory round a pointer's target, floating over the context | two at most, in depth | | | [`nodes`](#nodes) [`array`](#array) [`calls`](#calls) [`syscalls`](#syscalls) [`blocks`](#graph) `pages` | the drawings a lens can hold | `nodes` in two rows, a `bin` heading the second | @@ -83,7 +84,7 @@ this table. | | [`link`](#4-ties) | this register points at that | for a step; rests as a `pin`; a stub when that is out of view | | | [`projection`](#4-ties) | these bytes are that part of the drawing | for a step | | | [`echo`](#4-ties) | the same mark in two panels at once | for a step | -| 5 frame | [`stage`](#5-the-frame) | the working frame: the band and the two columns | split `none`, `beside`, `subject` | +| 5 frame | [`stage`](#5-the-frame) | the working frame: the band and the two columns | split `none`, `beside`, `subject`, `blocks` | | | [`segments`](#segments) | the process's address space to scale, each end enlarged, its bands' addresses at their edges | treatments A (default), B, C; the ink's source: a band framed when a word is inked; a dump's place | | | [`aligned`](#aligned) | the source and its instructions in one panel, each line level with its code | `interleaved`, `columns`; a split a scene chooses | | | [`pair`](#pair) | two runs of one program against each other, a seam between them | `only here`, `differs`; each run's frame as bytes, an ASan run's shadow beside its rows | @@ -97,7 +98,7 @@ this table. | | [`open` `close`](#6-verbs) | what a loupe does | | | | [`descend` `cross` `ascend`](#6-verbs) | what a descent does: a call followed down, a system call, a return | | | | [`regroup` `ink` `enlarge` `column` `frame up` `decode` `align`](#6-verbs) | what building a view does (the introduction) | | -| | [`leave` `turn` `spread` `gather`](#6-verbs) | what a graph does: a block left by an edge, a loop's turn, rows into blocks and back | | +| | [`leave` `turn` `spread` `gather`](#6-verbs) | what a graph does: a block left along the track, a loop's turn over its arch, rows into cards and back | | | | [`dive` `surface` `flash`](#6-verbs) | between the map and the working frame | | | | [`cascade` `continue` `run` `sprint` `establish` `scroll` `relayout` `visit` `say`](#6-verbs) | what a frame does | | @@ -656,13 +657,33 @@ make room. ### registers Seventeen `reg`s in pwndbg's order: rax rbx rcx rdx rsi rdi rbp rsp, r8 -to r15, rip (with the flags). Tag: the region legend. 440 high. Reads the -moment's registers and mappings. +to r15, rip (with the flags). Tag: the region legend. Reads the moment's +registers and mappings. + +**`quiet`.** A register no step of the scene changes is folded: the +scene's own registers (those it writes, by the recording over the scene's +moments) keep their rows and their whole chains, with rsp, rbp and rip +always among them; the quiet ones follow, three to a row on a pitch of +285, under a 2-unit `rule` across, in pwndbg's order, and rip is the last +row, as ever. A quiet cell: the name in faint at 12, the value from 60 in +its ink, and a pointer's chain cut at once to `more` (`r12 7fffffffee38 → +…`): its hops are on the map, whole. A quiet register a step reads is +framed as read in its cell; one a step writes was never quiet (a scene +with a `continue` changes them all, and folds none). The set is the +scene's, chosen once: no row comes or goes while it plays. + +The panel is as tall as its rows: sort moves eight (rax rcx rdx rsi rdi, +and rsp rbp rip) and folds nine into three rows, 11 rows, 296 high; the +list's `reverse` moves six and folds eleven into four, 10 rows; sqlite's +continues fold none, 17 rows, 440. Every row the panel folds is a slot +the stack gains. ### stack -`slot`s from rsp, low addresses on top: eight; six when the lens is the -subject. `call` spans down its right edge for every frame in view: the +`slot`s from rsp, low addresses on top: as many as the state column has +under the registers ([the frame](#5-the-frame): twelve as the subject +beside eleven rows of registers, fourteen beside a lens, fifteen with +none). `call` spans down its right edge for every frame in view: the backtrace, drawn on the words that are each frame. rsp and rbp are pins in its lane. Reads the stack words, each frame's extent (the frame-pointer chain, or the unwinder's CFA), and for the roles the saved @@ -678,9 +699,8 @@ runs from 16 words above rsp to the stack's top. and the caller's words fill the rest. - Where it is longer, the window scrolls down it by whole slots ([`scroll`](#6-verbs)) to keep the slot a step touches in its middle - rows (the third and fourth of six; third to sixth of eight), and stays - there until a step touches a slot outside them. Its top never passes - above rsp. + half (the fourth to ninth of twelve), and stays there until a step + touches a slot outside it. Its top never passes above rsp. - A push or a call moves the top with rsp: the rows slide one slot (18 f, as rows making room), at the memory level, before the new word is armed. A window going farther than its height fades through instead @@ -689,8 +709,8 @@ runs from 16 words above rsp to the stack's top. ([`visit`](#6-verbs)): pushes fill `free` slots in the middle of the frame, and rsp's pin climbs to them. -Tag: `six words from rsp`, or the range when scrolled (`rsp+20 to -rsp+48`), and `· the frames they belong to`. +Tag: `twelve words from rsp`, or the range when scrolled (`rsp+20 to +rsp+78`), and `· the frames they belong to`. ### backtrace @@ -715,9 +735,10 @@ identity: the slide is what says it is the same frame. ### source A window on the whole file, scrolled by whole lines to keep the current -line in its middle third. Fourteen lines; eight beside a lens (the loop -in hand); ten when the lens is the subject. Tag: the file, and `lines 19 -to 26 of 42`. A line farther than a window away (another function in a +line in its middle third. Fourteen lines; eight with a lens up, of any +kind (the loop in hand: the scenes' functions are eight to ten lines, and +the minimap has the rest). Tag: the file, and `lines 19 to 26 of 42`. A +line farther than a window away (another function in a file of 262 899 lines) is not scrolled to: the window fades through ([`scroll`](#6-verbs)). Line numbers are as wide as the program's largest ([`line`](#line)). On the map the file is whole, or 69 lines round @@ -725,8 +746,10 @@ the current one when it is longer. ### disasm -Seventeen `insn`s in address order: the pc's, eight above, eight below. -Nine (four, the pc, four) when the lens is the subject. +Under the source, in every split: a line over its instructions, the +thread between them in the margin. Seventeen `insn`s in address order: +the pc's, eight above, eight below (`none`, `beside`); eleven (five, the +pc, five) as the subject; fifteen with the `blocks` lens. - Rows above the pc are the function's own instructions where it has them; near its start the window stays full from below. @@ -735,6 +758,10 @@ Nine (four, the pc, four) when the lens is the subject. - The rows that ran in the last three steps are `ran`, above or below the pc: with the jump lane they show how control came here. - Tag: the function's name. +- Where the recording has the function's blocks, each block's first row + is under a 2-unit `rule` across, and its visits are ranged right in + that row's annotation room (`×11`, faint) when it is free: the + [graph](#graph)'s pill in its digits. On the map the column is 69 rows: the function whole when it fits, with its neighbours round it. @@ -791,42 +818,62 @@ Its motion is [`descend`, `cross`, `ascend`](#6-verbs). ### graph The disassembly's other form: a function as a graph of its basic blocks, -with what the run did on it. It is drawn with its rows at the map's size -(the larger scale), and as shapes in the working frame's `blocks` lens. -Execution flows down; the one thing that climbs is a loop's back edge. +with what the run did on it. Its form is the **track**: the blocks on one +line in the order they run, each loop closing over the line as an arch +whose blocks sit on its floor, a forward jump that passes blocks dipping +under them. Across in the working frame's `blocks` lens, a block a pill; +down on the map, a block a card that carries its rows. Execution goes +along the line (across in the band, down on the map), and the one thing +that goes back is a loop's arch. | Part | Drawn | | --- | --- | -| a block | a box of `insn` rows, a 2-unit `rule` frame; a head of 24, raised: its first address in code ink, its lines (Go 18, faint), ranged right how many times the run has entered it (`×11`, primary). Not yet reached at the moment shown: its head on the page, no count. The pc's: a 2-unit gold frame | -| its rows | the offset from the function's start (`+65`, faint, ranged right at 72) in place of the address, which the head carries; the line at 116, on a run's first row; the mnemonic at 128; the operands at 212, as [`insn`](#insn) draws them; a jump's or call's target an `address`. The annotation only in the pc's block (and its rows that ran in the last three steps). As wide as its widest row, 300 at least | -| a long block | over 16 rows: its first four and last four, a `more` row between (`→ … 9 rows`), unless the pc is in it | -| a call | not an edge: a hook out of the block's right side at the call's row and back in a row down (2, `dim`), the callee's name after it (`swap`) | -| the way out | under a block that returns, a stub 14 down and a bar 28 wide | -| a forward edge | taken, not taken, a jump, a fall-through: out of the block's bottom on the side its target lies on (40 in from that side, or the middle when it is straight below), along the middle of the gap under its layer, into the target's top; several into one top 48 apart in their sources' order; corners 8. One that would cross a block runs in the graph's right channel, 32 right of its widest layer | -| which is which | the jump's row names its target and the target's head shows the same digits; the fall-through is the other. No hue says it | -| a back edge | an edge to a block at its own layer or above: a loop. Out of the bottom, down 14, left to its loop's lane (left of every block, 16 apart, the outermost farthest), up it, into the header's head from the left. Its turns so far on the lane under the turn in, Go 18 faint (`×5`); a turn landing strikes it | +| a block, in the lens | a pill 24 high, its ends half circles, a 2-unit `rule` frame: its offset from the function's start at 12 (`+2f`, primary), its visits ranged right 12 from its end (`×11`, `dim`); as long as its rows at 10 a row, and its text at least. Reached: on `raised`; not yet: on the page, its offset faint, no count. The pc's: framed gold, 3 | +| a block, on the map | a card: a head of 24, raised (its first address in code ink, its lines in Go 18 faint, its visits ranged right), and its `insn` rows: the offset ranged right at 72 in place of the address, the line at 116 on a run's first row, the mnemonic at 128, the operands at 212 as [`insn`](#insn) draws them, a jump's or call's target an `address`; the annotation only in the pc's card (and its rows that ran in the last three steps). As wide as its widest row as drawn, 300 at least. The pc's: framed gold, 2 | +| a long block | on the map, over 16 rows: its first four and last four, a `more` row between (`→ … 9 rows`), unless the pc is in it | +| a call | not an edge. In the lens a hook under the pill where the call's row is (out and back, 10 wide, 6 deep, 2 in `dim`) and the callee's name after it (`swap`, primary); on the map the hook out of the card's right side at the call's row and back in a row down, the name after it | +| the way out | under a block that returns, a stub (14 on the map) and a bar 28 wide | +| a step along the line | an edge to the block next on the line: straight along it, end to end, its head on the target's end (8 by 8 in the lens; on the map 10 down the spine, 40 in from the cards' left). Two blocks next on the line that no edge joins have no line between them | +| a jump past blocks | a forward edge to a block further on: a **dip**, out of the source's foot (16 in from its end), down 10, a quarter circle to its level, along under the blocks it passes, a quarter circle up into the target's foot (16 in from its start), head up. Levels 44 under the line and 16 apart, the one that holds another a level deeper. On the map the same to the right: out of the card's right side at its last row, along to its channel (24 right of the widest card and its hooks, 32 a level), down it, into the target's right side at its head row | +| a loop | its back edge is an **arch**: out of the latch's top (16 in from its end), up 10, a quarter circle to its level, back over the loop's blocks, a quarter circle down into the header's top, head down. Levels 52 over the line and 36 apart, an outer loop's over an inner's. The arch and the floor it stands on are one closed shape: the loop. Its turns so far sit at its centre, under the arch (`×5`, `dim`; mono 20), struck when a turn lands. On the map the same to the left: out of the latch's left side at its last row, up a lane (48 left of the cards, 48 a level), into the header's left side at its head row, the turns in the lobe between the lane and what it holds | +| curves | quarter circles and straight runs only: a dip's or an arch's radius its level less 22 (30 and 66 for the lens's first two arches; 22 and 38 for its dips), 16 on the map. No square corner; nothing crosses a block, and the order and the levels keep edges from crossing where the code nests (two jumps whose spans interleave cross once, as jump arrows do); the map's lanes and channels are the arches and dips turned on their side, not routes found round blocks | +| which is which | the jump's row names its target and the target's head shows the same digits; the fall-through is the other. On the map a conditional's two ways are counted in its jump's row, in words: `taken 5 · not 6` (faint), but in the pc's card, where the row has its own annotation (`taken · reads zf`). No hue says it | | an indirect jump | `jmp rax`, a table: a stub 24 down and `more`'s dots, faint `targets not known`; each target the run takes becomes an edge as it is taken | -| a tail jump | a jump out of the function: a stub 24 down from the block's bottom and the function it goes to, its name in primary; no bar, since the function does not end here but in the one it jumped to | +| a tail jump | a jump out of the function: a stub 24 out of the block's end and the function it goes to, its name in primary; no bar | | a call that does not return | `abort`, `exit`, `__stack_chk_fail`: the call's hook goes out and does not come back, and the block has the way out's bar | -| ink | never taken in the recording: `rule`, 2. Taken: `dim`, 2, the run's count by a conditional's ports (`10`, `7`). The last three taken: the trail's golds, the newest 3 units | - -**Layout.** Back edges are found by a walk from the entry in address -order; every other edge goes down a layer or more: each block one layer -under the deepest that leads to it, and the blocks that return in the -last. In a layer a block sits under the predecessor that reached it most -often in the recording, so the hot path is straight down; then under the -fall-through's; a taken target to the right of it; then the order that -crosses fewest edges. A loop's body hangs between its header and the -block that turns back, right of its lane; nested loops nest their lanes. -Layers 48 apart, blocks 56 apart, lanes 16 apart from 24 inside the panel. - -**Too big for its place**, in this order: the blocks the whole recording -never reached fold, each connected run of them one dashed box, its -offsets and its count (`+5b to +b3 · 4 blocks never reached`) and, where -the scene names it, what it is (`multi-threaded: a cancellable call`); long -blocks fold; a loop the pc is not in and will not enter again folds to -one box (`loop at +5f · 3 blocks · 11 turns`); then the panel pans by -`scroll`'s rules, the pc's block in its middle third. +| ink | never taken in the whole recording: `rule`, dashed 12 on 8 (sort's `j > 0` failing). Not taken yet: `rule`, solid (the way out). Taken: `dim`, 2. The last three taken: the trail's golds, the newest 3 units. Taken and not are told by form (dashed, solid) and by the words in the jump's row; the golds say only how recent | + +**Order.** Back edges are found by a walk from the entry in address +order; a loop is a back edge's natural loop (its header and every block +that reaches its latch without passing the header), loops of one header +one loop. The line is the blocks by the longest path from the entry, then +by address; a loop's blocks are kept together from its header, so that +no block outside a loop sits on its floor (clang's sort: `+5d`, the inner +loop's way out, follows the swap's block `+5f`, though it is lower in +memory); the blocks that return come last. For code compiled at -O0 the +line is nearly the disassembly's order, so the pill under the band and +its rows under the source lie the same way. Sort, clang -O0, eleven +blocks: `+0 +12 +1e +24 +2f +56 +5f +5d +97 +99 +a7`, two arches (the +inner loop `+5f` to `+24`, the outer `+99` to `+12`), three dips (`j > 0` +failing past `+2f`, never taken; the inner loop's way out past `+5f`; the +function's way out past everything). + +**In the lens** the track is centred in the band, the line through its +middle with the arches' room over it and the dips' under it; 40 between +pills. Sort is 1622 by 150 in a band of 1792 by 200: whole, nothing to +pan. A function too long for the band is folded, in this order: the +blocks the whole recording never reached, each connected run of them one +dashed pill (`+5b to +b3 · 4 blocks`); a loop the pc is not in and will +not enter again, to one pill (`loop at +5f · 3 blocks · 11 turns`) with +its arch; then the line pans across, by `scroll`'s rules turned on their +side, the pc's pill in its middle third. + +**On the map** the track runs down one column (880), the cards in the +line's order 10 apart on their spine, the lanes on the left, the +channels on the right. Sort's is 1684 high: the column whole +([mock 22](mock/22-graph-sort.png)). A function taller than the column +folds as above, and then continues at the next column's top, `continued`, +as any panel. **What the recording knows.** By instruction, every jump and return carries the edge it took, so the path, the counts and the trail are exact. @@ -834,7 +881,7 @@ By line or by breakpoint only the blocks the stops are in are known: their visits are counted, the edges are drawn by kind in `rule` with no counts, and there is no trail. A function past 2 048 instructions has its blocks without their text (`sqlite3VdbeExec`, 2 510 blocks): it is drawn as the -`blocks` lens draws, its blocks as shapes, on the map too. Code with no +`blocks` lens draws, its blocks as pills, on the map too. Code with no bounds (start-up, JIT code) has no graph and stays linear. **What a static graph cannot show**, and this one does: how often each @@ -844,35 +891,30 @@ the run will reach but has not yet. **Where it lives.** -- **The map** draws the disassembly column in this form whenever the - recording has the function's blocks (the linear 69 rows otherwise, or - when the scene asks), two columns wide (1792); the panels after it - repack. The source is beside it; the thread is its digits (the gold - line number in the pc's block and the source's plaque): no line crosses - the lanes. A descent on the map stacks graphs: a caller folded to the - block that holds its waiting call and one block either side, the - callee's graph whole under it, the kernel's window under that. +- **The map** draws the disassembly column as the track, cards down one + column, whenever the recording has the function's blocks (the linear 69 + rows otherwise, or when the scene asks). The source is beside it; the + thread is its digits (the gold line number in the pc's card and the + source's plaque): no line crosses the lanes. A descent on the map + stacks tracks: a caller folded to the card that holds its waiting call + and one card either side, the callee's track under it, the kernel's + window under that. - **The disassembly's minimap** stays the linear column, each block's - first row ticked at its left (2, `rule`), the pc's row gold. A sprint - on the map reads on the map itself as the gold going from block to - block. -- **The working frame** keeps the linear rows (rule 6) and shows their - blocks: a 2-unit `rule` across over each block's first row, and the - block's visits ranged right in that row's annotation room (`×11`, - faint) when it is free. The graph with its rows is not drawn there: two - blocks' rows barely fit side by side in 880, and the same rows twice - are noise. + first row ticked at its left (2, `rule`), the pc's row gold. A sprint on + the map reads on the map itself as the gold going from card to card. +- **The working frame** keeps the linear rows under the source (rule 6), + each block's first row under a rule with its visits ([disasm](#disasm)). - **The `blocks` lens**, for a scene about control flow: its drawing the - graph without text, a block a box 24 high, as wide as its rows (10 a - row, 132 at least), its offset and visits, the pc's framed gold 3, the - edges, lanes and trail at half measure (layer gap 12, lanes 10 apart); - its view, over the state column, is the disassembly itself, seven rows - round the pc (five beside), moved out of the program column, which then - holds the source alone (twenty lines as subject). No row is drawn - twice: the box is the place, the view the text, and the pc's gold is on - both. + track, the band across both columns (1792 by 200), and no view: the + pc's block's rows are the disassembly under the source, fifteen rows, + the block's rule and count over its first row, the thread from the + source's line to its run. The pill and the rows are tied by the pc's + gold, by the count's digits, and by lying the same way. No row is drawn + twice. -Its motion is [`leave`, `turn`, `spread`, `gather`](#6-verbs). Mocks 22 to 25. +The comparison this form was chosen from, with the layered form it +replaced: [mock 43](mock/43-graph-forms.png). Its motion is [`leave`, +`turn`, `spread`, `gather`](#6-verbs). Mocks 22 to 25. ### lenses @@ -880,8 +922,12 @@ A lens is the band across the top of the stage: **a drawing, over the program column, and over the state column the pane the drawing is a view of**, each a panel with its own tag. The gutter between them is the ties', as it is below. Beside the context both are 152 high; as the subject the -drawing is 296 and its view 200 ([the frame](#5-the-frame)). On the map -the drawing keeps its subject size and the view is its region whole. +drawing is 296 and its view 200 ([the frame](#5-the-frame)). A lens with +no view of its own (`blocks`, whose rows are the disassembly under the +source) is one panel across the band, 1792 by 200. On the map the drawing +keeps its subject size and the view is its region whole; the `blocks` +lens's drawing is not on the map, whose disassembly column is the same +track with its rows. | Lens | Drawing | Its view | Mock | | --- | --- | --- | --- | @@ -890,6 +936,7 @@ the drawing keeps its subject size and the view is its region whole. | `calls` | a call tree under its caller, results on the shoulder | the `backtrace`; each node is also a `call` span on the stack, tied by `project`. Subject only: a tree needs the height | 12; 1 at camera scale | | `backtrace` | the call chain itself, as `call` rows (eleven as subject): how the program came to be here, when that is the story and no one function's calls are | a `hexdump` by `fields` of what the newest call was handed (the struct an argument points at, a buffer), at its stop | 13, 14 | | `syscalls` | the calls so far, as strace writes them, oldest on top; the kernel's own side is the [`descent`](#descent)'s floor | a `hexdump` of the buffer the call is given or fills; the `registers` that carried it, by `echo` | 14; 16; 3 at camera scale | +| `blocks` | the function's [graph](#graph) as a track: blocks as pills on a line, loops as arches, jumps past blocks as dips; the band across both columns | none: its rows are the disassembly under the source, fifteen | 25; 43 | | `pages` | the far view: pages, system calls over time | the mappings, a row each | 8 | | `hexdump` alone | bytes and their text | itself | 5, in its first-pass form | @@ -911,10 +958,13 @@ row reaches `pwrite64`. **What a new lens must provide** to fit the frame: -1. A drawing that fits 856 by 116 (`beside`) and by 260 (`subject`). +1. A drawing that fits 856 by 116 (`beside`) and by 260 (`subject`); or, + with no view, 1768 by 164 (the band across). 2. Its view, a pane of rows that fits the state column (five beside, seven as subject; the region whole on the map), and for every element - the bytes, slot or register it is drawn from. + the bytes, slot or register it is drawn from. A lens whose elements + are rows the context already shows (the `blocks` lens's are the + disassembly's) has no view and draws no row twice. 3. A `place` for every element, so ties can land. A 12-unit lane clear at the top of the drawing and one at the bottom: **bytes from its view arrive from above; pointers, and a frame from the stack, from below.** @@ -1151,8 +1201,8 @@ row the step changes, at any moment of the step; where the first place would, it moves down past them, then to the other side; it stays inside the stage. **One hung from the band's view** (a row of the drawing's bytes) never lies over the registers, which every step changes: it lies -over the stack, its tag's top on the stack's first row (clamped to the -stage: in `subject` 736 to 888), its left edge on the state column's, its +over the stack, its tag's top on the stack's first row (in `subject` 568 +to 720, over the first six of the stack's twelve), its left edge on the state column's, its stem down the gutter's right lane (x 962) from the foot of its row to the tag. Where the step changes a word of the stack under it, it does not open in that step. On the map it is @@ -1252,35 +1302,75 @@ The working frame: where a scene is told. No data below 888: the caption and the clock's count, which a player's controls may cover the foot of, and which the narration says again. -**The program column** (left): source over disassembly: what was written, -what runs. **The state column** (right): registers over stack: what they -act on. **The lens band** (top): what it means, over the program column, -and the pane that means it, over the state column. The split is the one +**The program column** (left): source over disassembly, in every split: +what was written, what runs. **The state column** (right): registers over +stack: what they act on. **The lens band** (top): what it means, over the +program column, and the pane that means it, over the state column; a lens +with no view of its own takes the band across both. The split is the one thing about the layout a scene chooses. +The rows below are for a registers panel of 11 rows (sort's: eight +registers the scene moves, nine folded three to a row); every row the +registers fold more is a slot more of stack (the list's `reverse`, 10 +rows: thirteen as the subject), and a scene that folds none (sqlite's +continues, 17 rows) has six fewer. Each pane with a minimap gives it 48 +of its width (the strip 40, 8 to the content); the strip's rows are the +map's, 4 units each, so a pane of n rows (its strip 24n + 6 high) +shows 6n rows of its column. + | Split | Drawing | Its view | Source | Disassembly | Registers | Stack | Backtrace | | --- | --- | --- | --- | --- | --- | --- | --- | -| `none` | | | 14 lines, 48 to 416 | 17, 428 to 868 | 48 to 488 | 8, 500 to 724 | 4, 736 to 864 | -| `beside` | 152, 48 to 200 | 152, 48 to 200: 5 rows | 8 lines, 212 to 436 | 17, 448 to 888 | 212 to 652 | 8, 664 to 888 | in the stack | -| `subject` | 296, 48 to 344 | 200, 48 to 248: 7 rows | 10 lines, 356 to 628 | 9, 640 to 888 | 260 to 700 | 6, 712 to 888 | in the stack; the view of `calls` | +| `none` | | | 14 lines, 48 to 416; strip 84 | 17, 428 to 868; strip 102 | 11, 48 to 344 | 15, 356 to 748; strip 90 | 4, 760 to 888 | +| `beside` | 152, 48 to 200 | 152, 48 to 200: 5 rows; strip 30 | 8 lines, 212 to 436; strip 48 | 17, 448 to 888; strip 102 | 11, 212 to 508 | 14, 520 to 888; strip 84 | in the stack | +| `subject` | 296, 48 to 344 | 200, 48 to 248: 7 rows; strip 42 | 8 lines, 356 to 580; strip 48 | 11, 592 to 888; strip 66 | 11, 260 to 556 | 12, 568 to 888; strip 72 | in the stack; the view of `calls` | +| `blocks` | 1792 by 200, 48 to 248, across | none | 8 lines, 260 to 484; strip 48 | 15, 496 to 888; strip 90 | 11, 260 to 556 | 12, 568 to 888; strip 72 | in the stack | Each panel is a window onto a column of the [map](#the-map-and-the-minimap), -and its minimap shows where. **What gave** for seventeen instructions: a -lens, the whole of a function and seventeen instructions do not fit one -column of 840. So the lens left the program column for a band of its own; -the backtrace became spans on the stack; the flags moved into rip's row; -a panel's padding went from 6 to 4; and beside a lens the source shows -eight lines. As the subject the drawing takes eight rows from the -disassembly, the source gets two back, and the view stops two rows short -of the drawing so that the stack keeps six slots. With a lens open the -source is a window of eight or ten lines on the file: the map holds the -rest, and the source's minimap shows it. - -| Of the frame | `none` | `beside` | `subject` | -| --- | --- | --- | --- | -| context | 68% | 56% | 48% | -| lens band (the drawing and its view) | | 13% | 21% | -| caption band | 10% | 10% | 10% | +and its minimap shows where. + +**Where the room comes from.** Measured on this round's renders (fib, +list, heap, sqlite, sort, syscalls: every scene in `subject` but syscalls, +in `beside`), the 840 of the state column went to the view (200), the +registers (440) and a stack of six (176); of the registers' seventeen +rows a stepped scene changed six to nine from its first frame to its last +(heap's, whose steps cross `malloc` and `free`, twelve; sqlite's +continues all seventeen), so eight to eleven rows, 190 to 260 units, held +values nobody read while the stack, which carries the frames, had six +slots. In the program column the source showed ten lines of functions of +eight to ten, and the disassembly nine; with the `blocks` lens the +disassembly had become the band's view over the state column, seven rows +across the frame from its source, and the graph (ten layers, 400 high) +panned in a drawing of 296. So: + +- the registers fold what the scene does not move ([`quiet`](#registers)): + six rows to the stack, which goes from six slots to twelve as the + subject (fourteen beside, fifteen alone); +- the source is eight lines with any lens up, and its two rows go to the + disassembly: eleven as the subject; +- the `blocks` lens has no view: the disassembly stays under the source, + fifteen rows, the band's height is 200, and its drawing, the + [track](#graph), takes the band's whole width, where sort's eleven + blocks and both loops are whole (1622 by 150) with nothing to pan. + +The band, the caption band (192 with its margin: what a player's +controls cover) and the margins are as they were; nothing else gave. + +| Of the frame | `none` | `beside` | `subject` | `blocks` | +| --- | --- | --- | --- | --- | +| context | 69% | 56% | 48% | 52% | +| of it, the registers / the stack | 18% / 24% (were 28% / 14%) | 22% / 28% (were 33% / 17%) | 26% / 28% (were 39% / 15%) | 24% / 26% (were 33% / 13%) | +| lens band (the drawing and its view) | | 13% | 21% | 17% (was 21%, the disassembly its view) | +| caption band | 10% | 10% | 10% | 10% | + +Three layouts were weighed ([mock 42](mock/42-frame-layouts.png)): **A**, +this one; **B**, every register a row and every chain whole, the source +at six lines to give the disassembly thirteen, which leaves the stack at +six; **C**, the registers in two columns of eight (440 each, every chain +cut to a hop and `more`), which gives the stack fourteen but takes the +telescopes from the registers that move. A keeps the chains that are +narrated and gives the stack and the disassembly the most that the +narration uses; the folded values are still on screen, and whole on the +map. ### Direction and nearness @@ -1330,6 +1420,8 @@ each pair in one place: | Where | Was | Now | Why | | --- | --- | --- | --- | +| the `blocks` lens | the disassembly moved over the state column as the band's view, seven rows; the source alone in the program column; the graph in boxes and square lanes over the program column, panning | the disassembly under the source, fifteen rows, the thread in the margin; the graph as a track across the band, whole | a line over its instructions is a pair, and the thread had crossed the frame; the pill and its rows lie the same way, one over the other (mocks 25, 43) | +| the registers | seventeen rows, always | the scene's own as rows, the rest three to a row (`quiet`) | the room went to the stack, which carries the frames the scene is about (mocks 40, 41) | | the `syscalls` lens | the kernel's side, on vellum, in the band over the program | the kernel under the `syscall` row, the descent's floor; the band holds the calls so far as strace writes them | the kernel is under the program, and a call's arguments and the kernel's side are now neighbours (mock 14) | | the backtrace: a panel, the calls lens's view, the backtrace lens, the map | newest on top | newest at the bottom, `#0` last | a call goes down: it reads as the tree beside it does, and the backtrace lens's `#0` sits over the source line it is at (12, 13, 19) | | a call followed into a function | the window went to the callee; the call row left the screen | the `descent`, when the scene follows the call | the call and its callee are neighbours, and the return has a row to come back to (16) | @@ -1484,7 +1576,8 @@ Mocks 26 to 28 and 38; [the scene](motion.md#a-scene-asan-against-a-plain-build) on a stage of 3840 by 2160 units (sides 112, top 96, the stage 3616 by 1688), at the context's type size. It is one picture of the program at a moment: the whole of a short file, the function round the pc and its -neighbours, all seventeen registers, the whole backtrace, the stack from +neighbours, all seventeen registers with their chains (the quiet ones +too, which the working frame folds), the whole backtrace, the stack from 16 words above rsp to its top, the regions the scene's steps touch, the lens's drawing, and the loupes open. @@ -1512,7 +1605,9 @@ lens's drawing, and the loupes open. process's start. Memory: each region the scene touches, up to 32 rows round what was touched, as many as hold something, fieldless rows folded. The drawing: its subject size, - 880 by 296. A loupe: nine rows, beside the memory it shows. + 880 by 296 (the `blocks` lens has none here: the disassembly column is + its track, with the rows). A loupe: nine rows, beside the memory it + shows. - **What it draws.** The rows as the working frame draws them, the marks of the moment (current, struck, read, held, trail), the thread across the gutter between source and disassembly, and an outline round each of the @@ -1529,8 +1624,10 @@ lens's drawing, and the loupes open. strip inside its frame at its right, the way a code editor shows a file beside its text. Every pane that shows less than its column has one: the source, the disassembly, the stack, a dump (the band's view, a hexdump -panel), a backtrace longer than twice its window. The registers show all -their rows and have none; a lens's drawing is whole and has none; a loupe +panel), a backtrace longer than twice its window. The registers have +none (every register is on screen; the quiet ones' chains are on the map, +a column the strip would only repeat); a lens's drawing is whole and has +none; a loupe has none (it is held over the frame for a step or two, and its tag says what it is). @@ -1575,9 +1672,9 @@ and the registers carry the longest chains. windows are other functions and not in it. A `descend` or `ascend` fades the strip through (12 f) as the new window opens. - The [`graph`](#graph) and the `blocks` lens: the lens's drawing is whole - and has none; its view, the disassembly round the pc, has the linear - column's strip with each block's first row ticked. The graph itself is - on the map, which is its own whole. + and has none; the disassembly under the source keeps the linear + column's strip, each block's first row ticked. The track with its rows + is on the map, which is its own whole. - [`aligned`](#aligned): one strip at the right of its 1792 panel, the listing's whole column, a row of the listing a row of the strip; in `columns` a row's two cells side by side, at the one scale. @@ -1648,15 +1745,15 @@ Frames at 60 a second. `s` is the frame a strike lands. Curves: | `travel` | a value, a card or a pin going from one place to another | `glide`. A value or card: 30 f to 200 units, 36 f to 400, 48 f beyond. A pin goes along its lane, 18 f after the strike that moved it: in a drawing 30 f to the next node or cell, 36 f to one farther; in the stack's lane 24 f to the next row and 2 f a further row, 36 f at most. A pin that comes fades in over 12 f rising 8 units; one that goes fades out over 12 f; a name joining or leaving a pin cross-fades over 12 f. On a `link` the pin rides the line's head instead. 8 f at a run; at a sprint only at a phrase's end | | `open` | a loupe, from a pointer | the pointer's hop framed `read` (6 f); the stem draws from it to the loupe's place, head first, 18 f (30 f over 600 units), `standard`; the loupe rises with the stem's head: it fades in over 12 f from 8 units lower, its shadow growing from nothing to its offset (18 f, `standard`); the target's bright frame lands 6 f after. From a pointer inside a loupe the same, over it, and a third closes the first as it starts. In the slot of the level that read the pointer, or on a beat the caption names | | `close` | a loupe | the deepest first: its stem draws back into its pointer (12 f) and the loupe sinks, fading out over 12 f as it falls 8 units and its shadow shrinks; with the advance of the step it opened in. A loupe the narration keeps across steps closes at each advance and opens again in the idea's slot of the next step that concerns it (36 f, as `open`): the steps between are not drawn under it. Open 120 f without a change is the most | -| `dive` | from the map to the working frame | one continuous move in which the windows become the panels and each pane's column of the map becomes its minimap. 0 to 6: the windows' outlines go bright. 6 to 24: the rest of the map takes the veil (50%). 24 to 96, `glide`: each window goes from its place on the map to its panel's place, its scale on a logarithm from the map's (half, filling the frame) to the frame's (whole), so its rows grow from 10 units to 20 under the eye, the panels 6 f apart in the frame's reading order (drawing, view, source, registers, disassembly, stack), each drawn over those before; on the same move the rest of each window's column (the map's panel it is a window on) squeezes into its pane's strip: from its place at half size to the strip's rect, its width and its height each on its logarithm (to 36 of 880, and 4 of 24 a row), so the text thins to strokes as it lands, the window's outline riding on it to become the strip's window; the map's parts no pane takes (the backtrace, the key, the memory round pointers, a loupe's panel) fade where they are, 24 to 72. 72 to 96: the drawing, whose sizes differ between the two, crossfades from the map's to the frame's within its box. 84 to 96: each squeezed column crossfades into its strip's strokes; the frame's tags, rules and lanes fade in; the veil goes with the last of the map. 96 to 132: still (mock 20) | +| `dive` | from the map to the working frame | one continuous move in which the windows become the panels and each pane's column of the map becomes its minimap. 0 to 6: the windows' outlines go bright. 6 to 24: the rest of the map takes the veil (50%). 24 to 96, `glide`: each window goes from its place on the map to its panel's place, its scale on a logarithm from the map's (half, filling the frame) to the frame's (whole), so its rows grow from 10 units to 20 under the eye, the panels 6 f apart in the frame's reading order (drawing, view, source, registers, disassembly, stack), each drawn over those before; on the same move the rest of each window's column (the map's panel it is a window on) squeezes into its pane's strip: from its place at half size to the strip's rect, its width and its height each on its logarithm (to 36 of 880, and 4 of 24 a row), so the text thins to strokes as it lands, the window's outline riding on it to become the strip's window; the map's parts no pane takes (the backtrace, the key, the memory round pointers, a loupe's panel) fade where they are, 24 to 72. On the same move the registers' window (the panel whole on the map, every chain) folds as it lands: each quiet register's row glides into its cell, three to a row, its chain past the first hop fading over the move's first 24 f, so that the panel arrives at its height in the frame. 72 to 96: the drawing, whose sizes differ between the two, crossfades from the map's to the frame's within its box; the `blocks` lens's track, which is no window of the map (the map's disassembly column is the track with its rows, and `gather`s into the pane's rows as it travels), fades in across the band. 84 to 96: each squeezed column crossfades into its strip's strokes; the frame's tags, rules and lanes fade in; the veil goes with the last of the map. 96 to 132: still (mock 20) | | `surface` | from the working frame to the map | the dive backwards, a little quicker: 0 to 12 the tags, rules and lanes fade out and each strip's strokes become its column's text; 12 to 84, `glide`, each pane shrinks into its window on the map as its strip unfolds into the column round it, the map's other parts fading in where they are; 84 to 96 the veil lifts; then the map is still 36 f before anything plays on it | | `flash` | a pane's minimap, at a mark its window does not show | a ring 8 across in the mark's colour, on the mark's row in the strip, draws out to 14 and is gone, 12 f, with the mark's own strike or read | | `descend` | a call the narration follows down | 0 to 12 fire on the call row; rsp struck (24); the stack slides and the return address is struck (30 to 60), as for any call; then the caller's window closes round its call row, in two moves and never both at once: 66 to 78 the rows it gives up fade (those after its return row, and from its top as many as the callee needs), then 78 to 96 the rows it keeps glide up to their places (`glide`), where they move at all; 84 to 96 the call row's plaque becomes the ring; 96 to 114 the call lane draws down from the ring, head first, `standard`; 108 to 120 the callee's head fades in rising 8 as the lane reaches it; 114 to 138 its rows, top down, 2 f apart, 12 f each; 138 to 150 the advance: the plaque lands on the callee's first row, and the source line goes `waiting` (6 f) where the callee has none. Through a stub's `jmp`: the stub's other rows fade (12 f), then its `jmp` row, `pass`, glides to its place (18 f, `glide`), the lane runs on to the next head (18 f), the next window comes in the same way. A label that changes with it (the stack span's name, the source's tag) crossfades, 12 f | | `cross` | a `syscall` row, in a descent | 0 to 12 fire; 18 to 36 the registers that carry the call framed as read, 6 f apart, the argument rows under the row with them (`echo`); 48 to 72 the crossing lane draws down, 3 units, vellum; 66 to 78 the kernel's window opens as it lands, the vellum filling down from the lane's head; 78 to 90 its head and the call fade in, 6 f apart; the work (bytes given or filled, motion.md's chart); `returns` struck; then the answer climbs the lane (24 f) and rax is struck as it lands, the clobbered registers 6 f apart after it, the log's new row fading in (secondary); hold 36; the advance: the kernel's window draws back up into the lane (12 f) and the lane into the plaque (12 f) as the plaque moves on | | `ascend` | a `ret` out of a descent's window | 0 to 12 fire; 18 to 24 the return address framed as read on the stack; rsp struck (36); 48 to 72 the window closes, its rows fading bottom up, 2 f apart, 12 f each, its head last; 72 to 84 the lane draws back up into the ring; the caller's window opens in the reverse order of its closing: 84 to 102 the rows it kept glide back down (`glide`), then 102 to 114 the rows it gave up fade in; 114 to 126 the ring becomes a trail bar, the call row's annotation takes the result (6 f), and the plaque lands on the row after the call; the source line from `waiting` to `current` | -| `leave` | a block of a graph, along an edge | 0 to 12 fire on its last row; a conditional's compare row has its chips framed as read (18 to 24): the cause; 24 to 42 the edge it takes draws gold (3 units) from the port to the target, head first, `standard`; then the mark travels it: the gold plaque leaves the row along the edge, `glide`, 12 f and 2 f a 100 units, 30 f at most, the row cooling to the trail as it goes; it lands on the target's first row (the advance) and 6 f after, the target's count is armed and struck; with the landing the oldest of the three trail edges cools to `dim` (18 f). A fall-through leaves the same way. At a walk, 1.5 s | -| `turn` | a loop's back edge | `leave` along the lane: out of the bottom, out to the lane, up it, in at the header's head; the lane's count struck as the mark goes in | -| `spread` | the rows into a graph (on the map, or in a `dive` or `surface` between a graph and the working frame's rows) | 0 to 36 every row glides from its place in the column to its place in its block, `glide`, the blocks 4 f apart in layer order; nothing fades while rows travel; 36 to 48 the blocks' frames and heads fade in round them; 48 to 72 the edges draw, layer by layer, 2 f apart, 12 f each. `gather` is the reverse: edges out (12 f), frames and heads out (12 f), then the rows glide home (36 f) | +| `leave` | a block of a graph, along the track | 0 to 12 fire on its last row (in the disassembly under the source; in the lens its pill's gold frame pulses with it); a conditional's compare row has its chips framed as read (18 to 24): the cause; 24 to 42 the edge it takes draws gold (3 units) from the source's end or foot to the target, head first, `standard`; then the mark travels it: the gold plaque (22, its point the way it goes) leaves the pill along the edge, `glide`, 12 f and 2 f a 100 units, 42 f at most (a step along the line, 40 units, 12 f; the inner loop's way out under the swap, 331, 18 f; on the map the same edges are 10 and 816), the pill cooling to the trail as it goes; it lands on the target (the advance) and 6 f after, the target's count is armed and struck; with the landing the oldest of the three trail edges cools to `dim` (18 f). A fall-through leaves the same way. At a walk, 1.5 s | +| `turn` | a loop's back edge | `leave` over the arch: up out of the latch, back over the loop's blocks, down into the header; the mark keeps its speed (the inner arch, 672 units, 26 f; the outer, 1433, 40 f), and the loop's count at its centre is armed as the mark comes over and struck as it lands. Going round, floor and arch, is the picture of iteration | +| `spread` | the rows into a graph (on the map, or in a `dive` or `surface` between the track's cards and the working frame's rows) | the track's order is the column's but where a loop's blocks are kept together, so the cards open where they stand: 0 to 24 the column parts at each block's first row, the rows below each break gliding down (`glide`), 10 a break and a head's 24, top down 2 f apart; a block whose place on the line is not its place in memory (clang's sort: `+5d` after `+5f`) glides to it on the same 24 f, only over page, never over text; 24 to 36 the cards' frames and heads fade in round their rows; 36 to 60 the edges draw along the line top down, then the lanes and channels, 2 f apart, 12 f each. `gather` is the reverse: edges out (12 f), frames and heads out (12 f), then the rows close up (24 f) | | `regroup` | bytes into a word (the introduction) | walked, on one word ([chart](motion.md#a-word-read), mock 37): the dump goes from sixteen bytes a row to eight (each right half down a row, then left); the other rows are veiled; the word's offsets fade in under its bytes, `low byte` under the first, `high byte` under the last; then the bytes themselves fly, the low byte first, 6 f apart, 36 f each, `glide`: straight up, over on nested arcs a quarter as high as they are long (34 to 120), straight down onto their pair's place in the word's field, 30 apart and ranged right, so that they land reversed, each offset and label going with its byte, and a faint copy fading into each one's place in the dump once it has left; the gaps close to sixteen digits (12 f); the zeros in front are bracketed, `zeros in front`, and fade (12 f). At a run (the other fifteen): each row's word fades in (8 f) as its bytes dim, rows 6 f apart. The word field is eight pairs wide, so a word is always ranged right, its low byte last | | `ink` | a word becoming an address | its digits go from primary to its region's ink (12 f), and the band it points into in `segments` is framed as read inside its box, with the band's row of names (6 f): an echo, no line. The first walked, held 60 f; the rest at a run, 2 f apart, each band framed 12 f | | `enlarge` | a box of `segments`, out of its line on the whole | 0 to 6 the cluster's line on the whole framed bright; 6 to 78, `glide`, the box rides out along the magnification: its left corners travel the two lines from the line to their places, the lines drawn behind them, the box as tall as they are apart and as wide as the ride is far (the bar's 20 to its 180), its bands drawn at its scale all the way (a mapping a 2-unit line until it is taller; the gaps opening); 78 to 90 its page lines fade in and the frame on the line goes; then its names, rows top down, 2 f apart: an edge's leader draws from the box (6 f), then its address fades in (12 f); a band's row fades in (12 f). The clusters in address order, each riding out as the one before lands ([chart](motion.md#the-address-space-enlarged)) | @@ -1668,10 +1765,10 @@ Frames at 60 a second. `s` is the frame a strike lands. Curves: | `advance` | the current marks | last. The thread, the plaques and rip move together: 12 f to an adjacent row, 24 f up to eight rows, `standard`; farther, out and in over 6 f. A taken jump's line draws in the jump lane with it | | `cascade` | a step | `fire` (12); then its effects a level at a time, 18 f apart: CPU (`reg`s, the pc's annotation), memory (`slot`s, `bytes`), the idea (the drawing, by `project`); each armed, then struck; hold 36 f after the last strike and 12 f a further value, 84 at most; `advance`; rest 24 f. A level with nothing on screen to change gives up its slot | | `continue` | a stop far from the last: a breakpoint, not a step. Where the windows' new places are farther than their own heights (another function, another file), it is told on the map: `surface`, the jump there, `dive` | `fire` on the line it leaves from; then the levels as in a `cascade`, but CPU is a wave: every register that changed is struck 2 f after the one above it, in pwndbg's order, the fill in over 6 f, no arm and no pulse (a dozen pulses at once are a flash, and a dozen arms a crowd); memory: the stack's window scrolls or fades to its new place, and the [backtrace](#backtrace)'s frames leave, slide and arrive; the idea; hold 36 f after the last strike; `advance`, the source and disassembly fading through if far; rest. Its marks are only on what was on screen to change | -| `run` | steps that need not be read | over a graph, the mark goes from block to block in 8 f, each edge taken flashes to gold and cools in 8 f, counts change in place; at a sprint (on the map) the gold moves only when the block changes, 4 f at most each, the trail's three edges following and the lanes' counts ticking, and the picture settles at the phrase's end. Elsewhere: 18 f a step; no fire, arm or pulse; the mark, cards, nodes and pins ease in 8 f; no strikes, no held corners and no arcs drawing: a value changes in place under an 8 f crossfade, unmarked, and what the run changed is shown settled when it ends (its arcs fade in, 8 f, standing; no corners); no ties but the thread. A caption never names what a run veils. Registers, stack and disassembly are veiled from the first shortened step to the last; the source, the band and the clock are not. 24 steps at most. A run longer than a phrase may `surface` and play on the map | +| `run` | steps that need not be read | over a graph, the mark goes from block to block in 8 f (over an arch, 12), each edge taken flashes to gold and cools in 8 f, counts change in place; at a sprint (on the map) the gold moves only when the block changes, 4 f at most each, the trail's three edges following and the loops' counts ticking at their centres, and the picture settles at the phrase's end. Elsewhere: 18 f a step; no fire, arm or pulse; the mark, cards, nodes and pins ease in 8 f; no strikes, no held corners and no arcs drawing: a value changes in place under an 8 f crossfade, unmarked, and what the run changed is shown settled when it ends (its arcs fade in, 8 f, standing; no corners); no ties but the thread. A caption never names what a run veils. Registers, stack and disassembly are veiled from the first shortened step to the last; the source, the band and the clock are not. 24 steps at most. A run longer than a phrase may `surface` and play on the map | | `sprint` | steps to be got through | 4 f a step. The drawing grows and the clock sweeps; the source and the band's view are veiled as well; the mark and the pins move only at a phrase's end. Each change of pace ramps at 0.6 of the step before. A sprint plays on the map: `surface` before it, `dive` after it, at the stop it reaches; the windows glide with the pc, the marks flash and fade | | `establish` | a scene's opening | done by 54 f: the panels fade in, 18 f each, 6 f apart (registers, stack, source, disassembly, the band's view, the drawing's panel: 0 to 48); from 30 f the drawing's elements fade in rising 8 units, 12 f each, 2 f apart in address order and all begun by 42 f, each with its row's quiet bracket (an `echo`: no lines). The first caption arrives at 60 f | -| `scroll` | a `source`, `disasm` or `stack` window | whole rows, 24 f, `glide`, before the level it makes room for; marks ride with their rows; the window on the pane's minimap glides with it, the same 24 f (a window fading through moves on its minimap with the fade's out, so the strip shows where it went first). A column's `lead` and the line numbers are the rows' on screen: they change on the scroll's first frame, never before. A window going farther than its own height (ten lines, nine instructions, six slots) does not scroll, which would only blur: it fades out (12 f) and in at its new place (12 f), and what it brings comes in with no marks | +| `scroll` | a `source`, `disasm` or `stack` window | whole rows, 24 f, `glide`, before the level it makes room for; marks ride with their rows; the window on the pane's minimap glides with it, the same 24 f (a window fading through moves on its minimap with the fade's out, so the strip shows where it went first). A column's `lead` and the line numbers are the rows' on screen: they change on the scroll's first frame, never before. A window going farther than its own height (eight lines, eleven instructions, twelve slots as the subject) does not scroll, which would only blur: it fades out (12 f) and in at its new place (12 f), and what it brings comes in with no marks | | `relayout` | a change of split | the drawing fades out (12 f); every panel moves to its new box, clipped to the box as it moves (48 f, `glide`); the drawing fades in at its new size (12 f). Nothing else moves under it | | `visit` | the camera | the target framed first (24 f), the rest veiled (18 f); the move 72 f, `glide`. The panel's tag and whole rows in frame, the rows the visit's steps change in its middle third, never at its edge; a stack visited holds its window still. A visit never veils or clears a panel a drawn tie starts or ends in: it waits until the tie has drawn back, or frames both ends. 120 f at most without a change; back | | `say` | the caption | out 12 f, gap 6 f, in 18 f; the numbers are under [caption](#clock-and-caption) | @@ -1692,7 +1789,7 @@ call down, 3.6 s for a crossing (4.9 s when it moves bytes), 2.5 s back up. **What may contain what.** - The working frame holds the band and two columns; the band is two - panels, one over each column. The map holds the same panels, whole, in + panels, one over each column, or one across both (a lens with no view). The map holds the same panels, whole, in four columns. A column holds panels. A panel holds a tag and rows, or (a lens) a tag and a drawing, or (a descent) a tag and windows of rows under their heads. A row holds atoms. Nothing nests deeper. @@ -1753,8 +1850,11 @@ call down, 3.6 s for a crossing (4.9 s when it moves bytes), 2.5 s back up. the block's name; `mock/map.py` draws the working frame from a fresh recording of `targets/list` (9 to 11, 21), the map (19) and the dive (20); `mock/dense.py` holds that recording's data and draws the marks sheet -(15); `mock/graph.py` draws the graphs (22 to 25) from `sort-O0.dis`, +(15); `mock/graph.py` draws the graphs (22 to 24, and the forms sheet 43) +from `sort-clang.dis` (sort as the scene builds it, clang -O0), `reverse-O0.dis` and `libc-open.dis` and the paths their runs took; +`mock/frame.py` draws the reworked frame (40, 41 from the list recording; +25 from sort's stop in `sort-dbg.txt`) and the layouts sheet (42); `mock/heap.py` draws the heap scene's storyboard (18) from a recording of `mock/heap.c`; `mock/intro.py` draws the introduction and its blocks (29 to 37) from the same list recording and its mappings; @@ -1767,7 +1867,9 @@ python3 -B context.py && for n in 12-calls-subject 13-sqlite-row 14-sqlite-page; resvg $n.svg $n.png && resvg -w 480 $n.svg $n-480.png; done; resvg 16-descent.svg 16-descent.png resvg 17-operands.svg 17-operands.png python3 -B heap.py && for n in 18-heap 18-heap-free; do resvg $n.svg $n.png && resvg -w 480 $n.svg $n-480.png; done -python3 -B graph.py && for n in 22-graph-sort 23-graph-open 24-graph-strip 25-blocks-lens; do resvg $n.svg $n.png; done +python3 -B graph.py && for n in 22-graph-sort 23-graph-open 24-graph-strip 43-graph-forms; do resvg $n.svg $n.png; done +python3 -B frame.py && for n in 40-frame-beside 41-frame-subject 25-blocks-lens; do # 42 it composes itself + resvg $n.svg $n.png && resvg -w 480 $n.svg $n-480.png; done python3 -B pair.py && for n in 26-pair-rest 27-pair-store 28-pair-part 38-pair-ret; do resvg $n.svg $n.png && resvg -w 480 $n.svg $n-480.png; done python3 -B intro.py && for n in 29-intro-bytes 30-intro-words 31-intro-stack 32-intro-code 33-aligned 34-segments \ 35-segments-abc 36-aligned-columns 37-regroup; do resvg $n.svg $n.png; done @@ -1781,9 +1883,12 @@ python3 -B gen.py # 1 to 8, then resvg the same way | Mock | Is | Blocks it shows | | --- | --- | --- | -| [9](mock/09-context.png) | `beside`, at rest: `targets/list` stopped at the load in `reverse` (`mock/list-dbg.txt`, moment 2) | every panel; the band as two panels; `address` with `lead`; `chain` cut by `more`; `reg`, rip with flags; `slot` with offsets and roles, `pin` row; `call` spans; `insn` current, ahead, outside under a rule and its name; `line`; `bytes` by fields with number, pointer, loose; an `arc` standing in the view; `nodes` with pins under, two names on one; `thread`; marks current, held; each pane's minimap (source, disassembly, stack, the view), its window, the current row; the registers and the drawing without | +| [40](mock/40-frame-beside.png) | 9 in the reworked frame: `beside`, at rest | the registers `quiet`: rax rcx rdi rbp rsp as rows with their chains, the eleven others three to a row under a rule, rip last; fifteen stack slots and the three frames they belong to; the source's eight lines over seventeen instructions; each pane's minimap | +| [41](mock/41-frame-subject.png) | 11 in the reworked frame: `subject`, mid-step | the band as before (296, a view of seven); eight lines over eleven instructions; ten rows of registers, rdi struck and its link climbing the gutter from its new row; thirteen stack slots | +| [42](mock/42-frame-layouts.png) | the frame three ways, at a third of their size: A (recommended), B, C, each as 41's moment and as 25's | A folds the quiet registers; B keeps all seventeen and gives the source's rows to the disassembly (the stack stays six); C sets the registers in two columns (chains cut to a hop); under each tile its rows | +| [9](mock/09-context.png) | `beside`, at rest, in the frame before this round's rework (40 is it reworked): `targets/list` stopped at the load in `reverse` (`mock/list-dbg.txt`, moment 2) | every panel; the band as two panels; `address` with `lead`; `chain` cut by `more`; `reg`, rip with flags; `slot` with offsets and roles, `pin` row; `call` spans; `insn` current, ahead, outside under a rule and its name; `line`; `bytes` by fields with number, pointer, loose; an `arc` standing in the view; `nodes` with pins under, two names on one; `thread`; marks current, held; each pane's minimap (source, disassembly, stack, the view), its window, the current row; the registers and the drawing without | | [10](mock/10-context-step.png) | the same, mid-step: the load done (moment 3) | `struck` on rdi; `read` on the annotation, the run and the node's half (`echo`); `link` ending in rdi's pin; `projection`; the read pointer's `arc` at full ink; the minimaps: the pc gold and the read cyan on the disassembly's, the read row on the view's; the annotation at 540, whole | -| [11](mock/11-context-lens.png) | `subject`, mid-step | the band at 296 and 200, the drawing a size up, a dump of seven, nine instructions, six slots; the minimaps at the subject's window sizes, the disassembly's and the stack's scrolled round their windows | +| [11](mock/11-context-lens.png) | `subject`, mid-step, in the frame before the rework (41 is it reworked) | the band at 296 and 200, the drawing a size up, a dump of seven, nine instructions, six slots; the minimaps at the subject's window sizes, the disassembly's and the stack's scrolled round their windows | | [12](mock/12-calls-subject.png) | `calls` as subject, mid-step: moments 752 to 753 of the fib scene, `fib(4)` calling `fib(2)` | `calls`: nodes current, waiting, done, the caller, results on the shoulder; the `backtrace` as its view, with arguments, newest at the bottom beside the tree; `call` spans with arguments; the stack's row with offsets and a role; a `projection` from the return address to the new node; operands of 27 characters whole | | [13](mock/13-sqlite-row.png) | the `backtrace` lens, at rest after a `continue`: stop 120 of the sqlite scene, at `sqlite3BtreeInsert+4` | the backtrace as the band's drawing, `#0` at the bottom over its source line; a `hexdump` by `fields` of a struct on the stack: twelve-digit addresses, pointer fields and `NULL`, `loose` padding and the bytes past the struct, `pad`, two fields framed as the caption names them, the reading as a list; wide line numbers in the source and the disassembly; frame names whole, shortening the chains beside them; `held` on every register the continue changed, none on the stack's window, which faded in | | [14](mock/14-sqlite-page.png) | `syscalls` as subject, at rest after the crossing: stop 169, `pwrite64` back in `unixWrite` | the calls so far in the band, strace's way, the newest whole and held; the call through a pointer by its target's name, `→ __pwrite64`; a page by `fields` as the kernel took it (`given`): big-endian numbers, bytes left to the eye, text, a `more` row of 253; the stack's window scrolled into the frame (`rsp+20 to rsp+48`), its span open above; flags and registers the crossing changed | @@ -1796,10 +1901,11 @@ python3 -B gen.py # 1 to 8, then resvg the same way | [17](mock/17-operands.png) | operands before and after, on real rows of list, hello and libc's `open`; then the row's detail | size words gone; `width` on an immediate store, a byte compare, a sign-extending load; padding faint; a compare's two values and the flags it leaves; conditionals reading them; `lea`'s sum; an indirect jump through `open@got` | | [18](mock/18-heap.png) | the heap scene, five instants of the band: `ztrace dbg` on `mock/heap.c`, glibc 2.44, after each malloc and free (2 a run's end, settled, unmarked) | `nodes` in two rows, a `bin` heading the second (`dummy tcache` before the first free); a free chunk drawn `freed`, its link in its first word; `bytes` read as `size` (`0x20 a m P`) and `protected` (`→ 405050 ^ 405`), notes (`key`, `the old link`); the free list and the program's list as `arc`s; struck bytes, one byte of a pointer struck alone | | [18, the free](mock/18-heap-free.png) | beat 3 in the working frame, mid-step | the register wave a stepped-over call leaves; a `loupe` from the band's view lying over the stack, never the registers, its stem down the gutter's right lane; `rdi` still on the freed chunk; the tcache's two fields, `0x2f8 bytes` | -| [22](mock/22-graph-sort.png) | the map's disassembly as sort's `graph`, two columns wide beside the source, at moment 370 of the stepped run (the sixth pass, its third compare) | blocks with heads, offsets, lines, visits; the pc's block gold with its annotations (a compare's values and flags, the `jg` reading them); the inner and outer loops' back edges climbing their lanes with their turns; a conditional's counts by its ports; the edge never taken (`jle` to the next pass) in `rule`; the right channel; a call's hook (`swap`); the exit not yet reached | -| [23](mock/23-graph-open.png) | libc's `open` at its `syscall` (mock 16's moment 4): 19 blocks, the run's 8, the 11 never reached folded into five boxes by what they are | folds of unreached blocks, named; blocks the run will reach but has not yet, plain; twelve-digit heads, offsets in the rows | -| [24](mock/24-graph-strip.png) | reverse's loop, four instants | `leave`: the condition's chips, the edge lit, the mark halfway along it; `turn`: the back edge climbing with the mark on it, its count struck; the way out | -| [25](mock/25-blocks-lens.png) | sort at moment 370 in the working frame with the `blocks` lens | the graph as shapes in the band, the pc's box gold, the trail; its view the disassembly round the pc, out of the program column, which holds the source alone; registers and stack of the moment | +| [22](mock/22-graph-sort.png) | the map's disassembly as sort's track (clang -O0, eleven blocks), one column beside the source, at the 11th compare (`sort-dbg.txt`) | cards on their spine in the line's order, `+5d` after the loop it leaves; heads with offsets, lines, visits; the pc's card gold with its annotations; the loops as lanes on the left with their turns in the lobes; the jumps past cards down the channels on the right; a conditional's two ways in words in its jump's row (`taken 0 · not 6`); the edge never taken dashed; a call's hook (`swap`); the way out not yet taken; 1684 high in the map's 1688 | +| [23](mock/23-graph-open.png) | libc's `open` at its `syscall` (mock 16's moment 4): 19 blocks, the run's 8, the 11 never reached folded into five cards by what they are | folds of unreached blocks, named, on the line where they lie; blocks the run will reach but has not yet, plain, their ways not counted; twelve-digit heads, offsets in the rows; interleaved jumps crossing once | +| [24](mock/24-graph-strip.png) | reverse's loop in the lens, four instants | `leave`: the condition, the edge lit gold and the mark on it; `turn`: the mark coming round the arch, the count at the loop's centre struck; the way out under the body, landed | +| [25](mock/25-blocks-lens.png) | sort at the 11th compare in the reworked frame with the `blocks` lens | the track across the band, whole: pills with offsets and visits, the pc's gold, two arches with their turns, three dips (one never taken, dashed), the swap's hook, the trail; no view: the disassembly under the source, fifteen rows, each block's rule and visits, the thread to line 12's run; registers `quiet` (eight rows and nine folded); twelve stack slots in sort's, main's and libc's frames; each pane's minimap, the disassembly's ticked at its blocks | +| [43](mock/43-graph-forms.png) | sort's graph four ways at the lens's scale: the present layers, the layers rounded, rings, the track (recommended) | what falls outside the box the frame gives each veiled; what each costs | | [26](mock/26-pair-rest.png) | the `pair` at the loop, i = 15: plain and ASan builds of `overflow.c` | the shared source with each run's mark on its side; two disassemblies aligned by line, ASan's `only here` rows; the line's registers; each frame as bytes (`hexdump` `eight`): plain's `i`, `buf` (`41`s and their `"AAAAAAA"`), the saved rbp and the return address under the span; ASan's fake frame, its header's fields and shadow beside each row, the real stack's way back under a rule; `buf` facing `buf`, the saved rbp facing the redzone (`differs`) | | [27](mock/27-pair-store.png) | one turn of the loop, row by row: plain's eight instructions each facing its counterpart among ASan's seventeen | `only here` bars; the page facing the check; the check's values (`0 : 0 ZF`, `taken`); the partial check and the report's call faint, off the path at 00; under each, its `buf` as bytes, the turn's one byte struck and the reading a letter longer, ASan's shadow framed as read | | [28](mock/28-pair-part.png) | i = 16, the step in which they part | plain's store struck on the saved rbp's first byte, `41` among its stack-ink bytes, its reading `→ 7fffffffed41`; ASan's shadow load framed reading `f3`, its compare and the branch not taken, its redzone still `00`; `differs` on the facing rows | @@ -1863,6 +1969,27 @@ the band. - `pin` with a count; `rwx`. - Every verb: the mocks are stills. `establish`, `link` and `project` have no chart from a render yet. +- The reworked frame in the mocks drawn before it: 10, 21 (a loupe from + rdi lies over the folded registers now, and the stack under them is + longer), 12 to 18 and 13's backtrace lens; the map (19) with the + reworked windows outlined, and the dive (20) with the registers folding + as they land. The `none` split reworked. A `quiet` cell read; a scene + that folds none. +- The track: a pan in the lens; a finished loop folded to one pill; a + third level of arches or dips; an indirect jump and a tail jump on the + line; a descent of tracks on the map; `spread` and `gather` in the new + form, and `leave` and `turn` from a render. + +**The data in 22, 24, 25 and 40 to 43** is the recordings' too: sort as +`anim/build.zig` builds it for the scene (clang -O0 -g -no-pie +-fno-stack-protector, less the instrumentation's calls, which add no +block), `objdump -dl` of it (`sort-clang.dis`), its path through the +blocks from `ztrace record --by insn --from sort` (the leaders it hit, +98 of them), and its stop at the 11th compare from `ztrace dbg` under +`env -i setarch -R` (`sort-dbg.txt`: the registers, the instructions, the +array, the stack from 16 words above rsp to its top). The render's +offsets differ (its build has the instrumentation's calls); its blocks +and edges are these. 40 and 41 are 9 and 11's recording. **The data in 9 to 21** is the recordings': registers, chains, stack, the instructions and their lines (12: `ztrace show` on @@ -1891,7 +2018,7 @@ still read. ## What this asks of the renderer What the documents say and `anim/src` does not do, as read on 10 November -at 23:07. Since the last round `theme.zig` has the map and the minimap +at 23:07 (7 and 12 on 11 November at 14:15). Since the last round `theme.zig` has the map and the minimap (`map.zig`), the loupe (`loupe.zig`), the `arc` and the dump's and the slot's new columns; whether `dive`, `surface` and `flash` are whole there is not checked here. The tokens are under [Token changes](#token-changes). @@ -1929,15 +2056,24 @@ is not checked here. The tokens are under [Token changes](#token-changes). free list, a node travelling between them, the free form (dashed, hatched `key`, its link from the first word), and the `bin` box heading the second row. -7. **The graph** ([`graph`](#graph)): basic blocks from the recording, - the layered layout (back edges by a walk from the entry, layers by the - longest path, the hot path straight down, loops' lanes on the left, the - right channel), blocks with heads and offset rows, the edges' ink by - what the run did, folds (never reached, long blocks, finished loops), - pan; on the map in place of the linear column, two columns wide; the - linear form's block rules and counts; the `blocks` lens with the - disassembly as its view; `leave`, `turn`, `spread`, `gather`; the run - and the sprint over it. +7. **The graph as a track** ([`graph`](#graph)), in place of the layered + form `graph.zig` draws now (as read on 11 November at 14:15): the + line's order (back edges by a walk from the entry, natural loops, + blocks by the longest path then address, a loop's blocks kept together + from its header, the returning blocks last); arches for back edges and + dips for forward jumps past blocks, each levelled by nesting; every + bend a quarter circle (the radius its level less 22 in the lens, 16 on + the map), no square corner; in the lens a pill a block (offset, visits, + 10 a row long), the call's hook under it, the loops' turns at their + centres; on the map the cards down one column on a spine 40 in, the + lanes 48 apart on the left, the channels 32 apart on the right, a + conditional's two ways in words in its jump's row; the ink with the + never-taken dashed; folds, then a pan along the line; `leave` and + `turn` along the curves at 2 f a 100 units, 42 f at most, the mark a + plaque that points the way it goes; `spread` and `gather` opening the + column at block breaks; the run and the sprint over it. On the map the + disassembly column is one column again, and the panels after it do not + repack. 8. **The pair** ([`pair`](#pair)): the split with a seam, the shared source with a mark per run, two columns of one run each, alignment by line and by variable, `only here` and `differs`, each run's frame as bytes @@ -1976,6 +2112,21 @@ is not checked here. The tokens are under [Token changes](#token-changes). back; the clock's count at 1856. The corner minimap and its `K = 1/20` go. +12. **The frame reworked** ([the frame](#5-the-frame)): the disassembly + under the source in every split, `blocks` included (no view: its band + across both columns, 1792 by 200, its drawing the track; the + disassembly fifteen rows); the source eight lines with any lens; the + disassembly eleven as the subject; the registers `quiet` + ([registers](#registers)): the scene's set found once from the + recording (the registers any of its moments changes, with rsp, rbp, + rip), the rest three to a row on a pitch of 285 under a rule, a quiet + cell's name faint at 12 and its value at 60 with `more` for a pointer; + the panel as tall as its rows and the stack taking the rest (`Split`'s + stack and registers from the scene, not fixed per split); the stack's + middle half for its scroll; the loupe from the view over the stack's + first six; in the `dive`, the registers folding as they land and the + `blocks` lens's track fading in across the band. + **What the recordings must hold**, with the tracer's options: - For the map, as before: `--stack 1024`, `--disasm 69`, `--around 256`; @@ -2027,13 +2178,20 @@ is not checked here. The tokens are under [Token changes](#token-changes). ## Token changes -Against `anim/src/theme.zig` as it is now (23:07): "In theme.zig" is what -is in the file, "Is" what the documents say. The map's, the minimap's, the -loupe's and the arc's tokens, the lift's colours, the clock's count at -1648, and `metric.bytes` and `metric.slot`'s new columns are in, as asked. +Against `anim/src/theme.zig`: "In theme.zig" is what is in the file, "Is" +what the documents say. The first five rows are this round's, read on 11 +November at 14:15; the rest were read on 10 November at 23:07, and some +may be in since (the pane's `strip` is: the corner minimap's row below is +done). The map's, the loupe's and the arc's tokens, the lift's colours, +and `metric.bytes` and `metric.slot`'s new columns are in, as asked. | Token | In theme.zig | Is | | --- | --- | --- | +| `layout.split` | `beside` (152, 152, 8 lines, 17, 8 slots, 5); `subject` (296, 200, 10, 9, 6, 7); `blocks`: `subject` with the disassembly 7 rows over the state column and the source 20 | `none` (14 lines, 17; registers, the stack the rest, a backtrace of 4 at the foot); `beside` (152, 152, 8, 17, 5); `subject` (296, 200, 8, 11, 7); `blocks` (a band of 1792 by 200 and no view; 8, 15). In every split the registers are `registers.rows` high and the stack has what the state column has left: `Split` takes the scene's register rows | +| `metric.registers.quiet` | none | three to a row, pitch 285 from 12; the name faint at 0, the value at 48 (60 from the panel's edge); a pointer's chain cut to `more` at once; a 2-unit `rule` over the first quiet row; rip last | +| `metric.graph` | the layered form's: layers 48 apart, blocks 56, lanes 16 from 24, back edge down 14, ports 40, arrivals 48, the channel 32, corners 8; the lens's boxes 24 high, 60 and 10 a row, columns 300 apart, layers 12, lanes 10 | the track's. Map: cards 10 apart on a spine 40 in; lanes 48 apart left of the cards (the first 48 out); channels 24 right of the widest card and its hooks, 32 apart; bends a quarter circle of 16; heads 10 by 10; a conditional's ways in its jump's row at 10 characters past the operands. Lens: pills 24 high, ends round, 10 a row long and the text at least (12 in, 12 from the end), 40 apart, the track centred; arches 52 over the line and 36 apart, dips 44 under and 16 apart, each leaving 16 in from an end, a stub of 10, then a quarter circle of its level less 22; heads 8 by 8; the call's hook 10 wide, 6 deep; the turns at a lobe's centre, 0.4 of the way up it. Kept: a block's head 24 and its rows' columns (72, 116, 128, 212), 300 wide at least, the fold past 16 rows, the way out's stub 14 and bar 28, a call's hook on the map 14 out and a row down, a fold of blocks never reached 520 | +| `time.leave` | chips 0.30, the edge 0.30, the mark 0.20 and 2 f a 100 units, 0.50 at most; count 0.10, trail 0.30, rest 0.70, at a run 0.13 | the same, the mark 0.70 at most (42 f): a lens's outer arch is 1433 units; `turn` the same over its arch, the loop's count armed as the mark comes over and struck as it lands; at a run an arch 0.20 | +| `time.spread` | none | the column parting 0.40 (`glide`, breaks 0.033 apart, top down), frames and heads 0.20, edges 0.20 each, 0.033 apart; `gather` the reverse, the rows closing 0.40 | | `time.dive` | none | `bright` 0.10, `veil` 0.30, `move` 1.20 (`glide`, 0.10 between panels), `fade` 0.20 at its end, `still` 0.60; `surface` the same, the move first | | `time.flash` | none | 0.20: a ring from 8 to 14 | | `time.caption_max`, `first_step` | none | 12.00; 4.00, 5.00 when a scene opens on the map | @@ -2045,17 +2203,17 @@ loupe's and the arc's tokens, the lift's colours, the clock's count at | `metric.node.two_rows`, `metric.bin` | none | rows 110 apart, nodes 136 wide; the bin box 160 by 44 at the row's left, its count on a 30 square on the shoulder; a free node's outline dashed 12 on 8 | | `time.descend` | none | `close` 0.20 then 0.30 (`glide`), `ring` 0.20, `lane` 0.30, `head` 0.20, `rows` 0.20 a row 0.03 apart, from 1.10 after the fire, the given-up rows fading before the kept glide, never both; the step 2.90 | | `time.cross` | none | the registers framed 0.10 apart from 0.30; `lane` 0.40 from 0.80; the kernel's window 0.20; the answer up 0.40; the step 3.60, 4.90 when it moves bytes | -| `metric.graph` | none | a block's head 24; rows: offset ranged right at 72, line at 116, mnemonic at 128, operands at 212; 300 wide at least; fold past 16 rows to 4, `more`, 4; layers 48 apart, blocks 56, lanes 16 from 24; back edge down 14; port 40 in; arrivals 48 apart; right channel 32 out; corners 8; the exit's stub 14 and bar 28; a call's hook 14 out, a row down. Lens: boxes 24 high, 10 a row, 132 at least; layer gap 12; lanes 10 | -| `time.leave` | none | chips 0.10 from 0.30; the edge 0.30; the mark 0.20 and 0.033 a 100 units, 0.50 at most; the count struck 0.10 after landing; the trail's cool 0.30; at a run 0.13 | -| `time.spread` | none | rows 0.60 (`glide`, blocks 0.067 apart), then frames 0.20, then edges 0.20 each, 0.033 apart | +>>> + | `time.ascend` | none | `close` 0.20 a row, 0.03 apart, from 0.80; the lane back 0.20; the caller's kept rows 0.30 (`glide`), then the given-back rows 0.20; the step 2.50 | | `metric.segments` | none | the whole 20 wide, the stage's height, its labels 12 left of it; a box 180 wide (108 in a column of 880), framed 2 out, 48 apart; bands 30% over the page, named from 6 tall, permissions inside from 28; the names 64 past the box, rows 24, a band's row indented 24, sizes ranged right 132 in, files at 252 on a bracket at 240; leaders 8 out, 20 short, 12 in; the magnification 2 `rule`; a dump's place: its link 3 in the stack's ink over y 56, standing at 60% toward the page | -| `metric.minimap` | the corner's: 192 by 108 at 1664, 912, a twentieth; the clock's count at 1648 | a pane's own: a strip 40 wide inside its frame at its right, 2 in, over its body, on `well`; the content 8 from it (832 of 880); a row 4 (a stroke 3), a row's 880 to 36; strokes 65% of their ink; the window 2 in primary; marks 4 by 4 at a row's left; three dots where a column goes on; no strip on the registers, a lens's drawing, a loupe. The disassembly's annotation at 540 in a pane with a strip. The clock's count at 1856 | +>>> + | `time.enlarge` | none | the line framed 0.10; the ride 1.20 (`glide`); page lines 0.20; names 0.20 each, 0.033 apart, a leader 0.10 before its address; the next cluster as one lands | | `time.regroup` | none | rows making room 0.30, down 0.20, left 0.30; veil 0.30; offsets 0.20 each, 0.033 apart; a byte's flight 0.60, 0.10 apart; the gaps 0.20; the zeros 0.20; at a run a word 0.133, rows 0.10 apart | | `metric.aligned` | `interleaved` only | `columns`: the seam 48 after the longest line in the window; each column's place ranged right 132 into it, its text 24 after; a line's first row `raised` | -Unchanged and already there: the 1920 stage and its splits, the palette +Unchanged and already there: the 1920 stage (its splits change, above), each pane's `strip`, the palette with the marks of the last round (`wash`, `struck` `b54f42`, the corner), `metric.slot` with its offset and role, `metric.bytes`, `metric.pin`, `metric.node`, `metric.calls` (full), `metric.tie` (54, 950, 962), @@ -2073,7 +2231,7 @@ camera's scales. 4. `bytes` and `hexdump`; `nodes` in the band; quiet brackets. 5. `strike`, `cool`, `read`, `extend` at density; the `cascade`. 6. `link` and `pin`; `project`; `echo`. -7. `call` spans; the three splits and `relayout`; the camera at x1.5. +7. `call` spans; the four splits (the registers `quiet`) and `relayout`; the camera at x1.5. 8. The other lenses in the band. 9. The map and the minimap; `dive` and `surface`; the loupe. 10. Operands without size words and `width`; the row's detail; the -- cgit v1.3