diff options
Diffstat (limited to 'design/README.md')
| -rw-r--r-- | design/README.md | 171 |
1 files changed, 110 insertions, 61 deletions
diff --git a/design/README.md b/design/README.md index dcaaf37..86a217e 100644 --- a/design/README.md +++ b/design/README.md @@ -84,8 +84,8 @@ this table. | | [`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` | -| | [`segments`](#segments) | the process's address space, its mappings a row each | the ink's source; a mapping framed when a word is inked | -| | [`aligned`](#aligned) | the source and the disassembly side by side, each line level with its code | a split a scene chooses | +| | [`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`; the shadow on an ASan run's stack | | | [`map`](#the-map-and-the-minimap) | the working frame unfolded, every panel whole: 3840 by 2160 | the key | | | [`minimap`](#the-map-and-the-minimap) | the map at a twentieth, in the working frame's corner | windows, marks, `flash` | @@ -96,7 +96,7 @@ this table. | 6 verb | [`fire` `arm` `strike` `cool` `read` `extend` `link` `project` `travel` `advance`](#6-verbs) | what one block does | | | | [`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` `column` `frame up` `decode` `align`](#6-verbs) | what building a view does (the introduction) | | +| | [`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 | | | | [`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 | | @@ -1148,7 +1148,7 @@ one pane a thing in another is. | Tie | Says | Between | When | Form | | --- | --- | --- | --- | --- | | `thread` | this line is these instructions, and the machine is here | the source's current line; every run of its instructions in the disassembly | standing; moves with the current mark | gold, 3 units: a `tie` bracket on the line, one on each run, a line in the left margin (x 54) between them. On the map, where source and disassembly are side by side, across their gutter (x 1008) | -| `link` | this register now points at that | the `reg` just struck; the row or node whose address it holds | for the step that set it | 3 units, in the ink of the region pointed into, head on the target; ends in the target's `pin` and leaves it behind | +| `link` | this register now points at that; these bytes are there | the `reg` just struck; the row or node whose address it holds. In the introduction, a dump's rows and their place in [`segments`](#segments) | for the step that set it; a dump's place stands while both are on screen | 3 units, in the ink of the region pointed into, head on the target; ends in the target's `pin` and leaves it behind. From a dump, from a `tie` bracket on its rows | | `projection` | these bytes are that part of the drawing | a run a step read or wrote, in the dump; or the return address of a frame made or ended, on the stack; the part of the drawing made of them (a node's address, a cell, a call's node) | for that step | 2 units in the mark's colour (read, write): a `tie` bracket on the row, a line, a bracket at the part (over a node's address; under a call's node); and the mark itself on the run and on the part | | `echo` | these are one event | the same mark at the same instant in two panels: the annotation's address and the dump's run | for that step | no line | | ink, digits | these are one thing | an address anywhere and its row, node or name; a call's arguments on its span, its backtrace row and its node | always | no line | @@ -1321,60 +1321,78 @@ What stays, and why: ### segments -The address space to true scale, for its physicality, then magnified -until its parts can be named (the powers of ten). High addresses on top, -as the textbook draws it; 0 at the foot. +The address space to true scale, for its size, and each end enlarged once +until its parts can be named. High addresses on top, as the textbook draws +it; 0 at the foot. No rulers: the whole's two ends and the edges of every +named band carry their addresses, and the bands their sizes. -| Level | Drawn | +| Part | Drawn | | --- | --- | -| the whole | a rectangle 60 wide, the user half, 0 to 0x7fffffffffff (128 TiB), linear, a ruler every 16 TiB on its left; above its top, faint, `16 EiB not canonical, then the kernel's half` (to scale they would make the user half 1/131 072 of the bar). Every mapping where it is, at least a 1-unit hairline in its ink: at this scale that is all they are, and that is the point. No text in it but the ruler | -| a magnification | a second rectangle beside, joined to the stretch it enlarges by the two lines of the magnification (2, `rule`), its own linear ruler, its factor over it (`the top 256 MiB · × 500 000`). Two clusters, two magnifications: the top (the libraries and the stack) and the bottom 20 MiB (the program and its heap); a third where a cluster still crowds (`the libraries, 4 MiB · × 32`) | -| names | only at the level where a band is 6 tall or more: a leader, permissions, the file or `[stack]`, the size. A file's mappings touch, its parts split by a page line. What stays a hairline even magnified (the stack, 132 KiB) is named by a leader to empty page | -| live | rsp and rip pinned at the level that names their band; a band framed as read when a word is inked into it; growth arrows in the stack (down) and the heap (up); `brk` and `mmap` as before | +| the whole | the user half, `0` to `7fffffffffff`, in a bar 20 wide the stage's height (mock 34: 72 to 864), framed 2 in `dim`. Its ends' addresses and its size (`128 TiB`, at its middle) in mono 20 `dim`, ranged right 12 left of it; nothing else. Every mapping is where it is, which at this scale is a 2-unit line in its ink inside one end: the stack, then the libraries 128 MiB under it, at the top; the heap over the program, 16 MiB above 0, at the foot | +| a cluster | the mappings at one place: the stack; the libraries (libc, ld.so, its cache, the vDSO); the program and its heap. Each is enlarged once, and only once | +| an enlargement | the cluster from its lowest start to its highest end, linear: a box 180 wide (108 in a column of 880), framed 2 in `dim`, 2 out; the boxes' left edges on one x, in address order down the stage, about 48 apart, each as tall as its names need (mock 34: the stack 72, the libraries 368, the program and its heap 252). A mapping is a band in its ink 30% over the page; touching mappings of one file and one permission are one band; between two bands of one file a 2-unit page line where both are 6 tall. What is not mapped is page: the 1.3 MiB between libc and the loader is as empty in the box as it is in the process | +| the magnification | two 2-unit `rule` lines from the cluster's line on the whole (at its right edge) to the box's left corners. Nothing else is drawn between the whole and the boxes | +| the names | right of the box, from 64 past it (the leaders' room). A row for each edge of a named band: its address in mono 20, in the ink of the band it bounds, and a leader (2, `rule`) from the edge, 8 out, straight to 20 short of the address, 12 in. Between two edges a row for the band, indented 24: its permissions and its size (`dim`, ranged right 132 in), and its file in primary at 252 (`[stack]`, `libc.so.6`); a file of several named bands once, on a `quiet` bracket over their rows. Rows 24 apart, each as near its edge as the others let it (crowded rows pooled round their mean), inside the box's share of the stage; a leader never crosses another, as the rows keep the edges' order | +| what is named | the program by segment: each of its mappings a band with its two addresses, permissions and size, under a bracket with its name, because the scenes point into them (its code, its data). Every other file once: its mappings as one (an anonymous mapping after a file's data, its bss, with it; the vDSO with its data), its start, stop, size and name, its permissions where they are one (`rw-` for the stack and the heap), and where they differ, each part's written inside its band, centred, where the band is 28 tall. A band under 6 tall is drawn and not named (an anonymous page; in mock 34 the vDSO) | +| live | rsp an `under` pin in the stack's band; rip a row pin at the end of its band's row (`◂ rip`). In the introduction's first chapter neither: there are no registers yet | +| a dump's place | in the introduction, where the dump the scene has built stands beside it: a `tie` bracket on the dump's rows, and a [`link`](#4-ties) in the stack's ink from the bracket's top, up into the stage's top margin (y 56), across, and down onto the stack's box at the dump's address, its head on it. It draws in its own beat and then stands, quiet (60% toward the page), while both are on screen | +| `ink`'s echo | the band a word points into, framed as read inside the box (2 units, 4 in from its sides, 6 over and under the band), and that band's row of names framed with it | + +The physical comparison is the caption's, worked from the recording: if +the bar were the Eiffel Tower (330 m), everything mapped would be 7 µm, a +tenth of a hair, split between its two ends; the introduction's 128 bytes +would be 0.3 nm, about an atom. -It is the `loupe` for addresses: a place enlarged beside where it is, -tied to it; levels in depth instead of pointers. In motion it is a real -zoom: the camera goes into the whole along the magnification lines, the -ruler's unit changing as it passes (TiB to MiB to KiB), 72 f a level, -`glide`, and the insets are its resting pictures. The caption gives the -scale as a body: if the space were as tall as the Eiffel Tower, all the -program maps would be thinner than a hair, the stack a third of a micron. -Mocks 30, 34, and 35 (three treatments: A this, B one strip of levels -left to right, C true scale alone with distances written). +Three treatments say less and less (mock 35): **A**, this (mock 34); +**B**, every file once, the program too, and no pins; **C**, the whole +alone, each cluster one label at its end (where it starts, its size, its +name). A is the default: the program's segments are what the scenes point +into, and every other file is said once. `segments` is a frame of its own +(mock 34) or, in the introduction, the program column (mock 30, the boxes +108 wide). In motion each box rides out of its line along the +magnification ([`enlarge`](#6-verbs)). ### aligned -The source with the instructions it compiled to, as one panel and one -listing, as `objdump -S` prints it: each run of a line's instructions is a -group, its head a row with the line on `raised` paper, its rows under it, -indented one step under the line's text. Lines and addresses share one -column, the place column (ranged right at 196: `21` over `1001926`): both -say where. A 2-unit `rule` across over every head marks where a line's -group starts and ends; nothing alternates. +The source with the instructions it compiled to, in one panel with one +tag, each line level with its code. A split a scene chooses, the default +nowhere: the panel spans both columns (1792), the band and the state giving +way while it lasts. It has two forms, and a scene names the one it wants: -- A group of one row: its head and one row; of many: its head and all of - them, never folded in the working frame. -- A line's second run (a `for`'s step, a `while` tested again after its - body): its head again, on the page, faint, `again: its second run`. -- Rows of no line (padding, another function without source): a faint head - with the function's name, `_init · no line`. -- A line with no code of its own has no group; the gap in the numbers says - so. -- The pc's row has the wash and the plaque, its line's number the gold - plaque in its head. The grouping is the thread. +- **`interleaved`** (mock 33), as `objdump -S` prints it: each run of a + line's instructions is a group, its head a row with the line on `raised` + paper, its rows under it, indented one step under the line's text. Lines + and addresses share one place column (ranged right at 196: `21` over + `1001926`): both say where. +- **`columns`** (mock 36): the source on the left and its instructions on + the right, a 2-unit `rule` the seam, 48 after the longest line the window + shows, so that the two stay close. A line stands level with the first row + of its run, its cell as tall as the run, its first row on `raised` paper + (the head of `interleaved`, beside its rows instead of over them). Each + column begins with its place, ranged right 132 into it in mono 20: the + line's number in the one, the instruction's address in the other: one + slot, one face, one distance in, so the two read as the same kind of + thing. -It replaces the side-by-side rows first drawn: the user asked for one -panel, the two closer, a line's start and end unmistakable, and the line -number and the address in one column, and the interleaved listing gives -all four while keeping what was liked, each instruction level with its -line, right under it. A `pair` puts the source in the middle and each -build's rows aligned to it on its side. +In both a 2-unit `rule` across the panel over every group marks where a +line's code starts and ends; nothing alternates. The grouping is the +thread. + +| | `interleaved` | `columns` | +| --- | --- | --- | +| a run of one row; of many | its head and its rows, never folded in the working frame | the line beside its first row, its cell as tall as the run | +| a line's second run (a `for`'s step, a `while` tested again after its body) | its head again, on the page, faint, `again: its second run` | the line again in its cell, on the page, faint, `again: its second run` | +| rows of no line (padding, a function without source) | a faint head with the function's name, `_init · no line` | the cell empty but for `_init · no line`, faint | +| a line with no code of its own | no group: the gap in the numbers says so | in source order after the line before it, faint, the instruction cell empty, `no code of their own` on the first of a run of them: the source column reads as the file does | +| the pc | its row's wash and plaque; its line's number the gold plaque in its head | its row's wash and plaque in the instruction column, the wash across both where it is its line's first row; its line's number the gold plaque | -A split a scene chooses, the default nowhere: the panel spans both columns -(1792), the band and the state giving way while it lasts. Reach for it to -teach what a line compiles to, in the introduction, and in a pair. `align` -and `stack` change between it and the stacked form; it scrolls as one. -Mocks 32 and 33. +`interleaved` reads down one listing and puts each instruction right under +its line; `columns` keeps the source readable as source, at the cost of an +empty cell under a long run. Reach for either to teach what a line compiles +to, in the introduction, and in a pair (a `pair` puts the source in the +middle and each build's rows aligned to it on its side). `align` and +`stack` change between `aligned` and the stacked form, and between its two +forms; it scrolls as one. Mocks 32, 33 and 36. ### pair @@ -1552,12 +1570,13 @@ Frames at 60 a second. `s` is the frame a strike lands. Curves: | `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) | -| `regroup` | bytes into a word (the introduction) | the eight bytes of a word slide together and reverse in place, the low byte to the right (24 f, `glide`), the spaces between them closing; the word's digits fade in over them as they land (12 f), the bytes staying behind, faint, for the rest of the beat. The first walked, the rest at a run (8 f each) | -| `ink` | a word becoming an address | its digits go from primary to its region's ink (12 f), and the mapping it points into in `segments` is framed as read (6 f): an echo, no line | +| `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)) | | `column` | rows gaining a column (offsets, roles, pins, lines) | the rows make room (18 f, as rows do), then the column's values fade in top down, 2 f apart, 12 f each | | `frame up` | a panel arriving round rows already built | its rule draws round them (12 f), then its tag fades in (12 f): the last thing, never the first | | `decode` | an instruction's bytes becoming its row | the bytes of one instruction gather (12 f), the mnemonic and operands fade in beside them (12 f), and the bytes dim; the row then travels to its place (`glide`, 24 f) | -| `align` | the stacked program column to `aligned`, and back (`stack`) | the band and the state column fade out (12 f); the panel widens to both columns (24 f, `glide`); the source's lines glide to their heads and the instructions glide in under them (36 f, rows making room), each instruction from its row in the disassembly to its row under its line; the heads' paper and rules fade in last (12 f). `stack` is the reverse | +| `align` | the stacked program column to `aligned`, and back (`stack`); one form of `aligned` to the other | the band and the state column fade out (12 f); the panel widens to both columns (24 f, `glide`); the source's lines glide to their heads and the instructions glide in under them (36 f, rows making room), each instruction from its row in the disassembly to its row under its line; the heads' paper and rules fade in last (12 f). `stack` is the reverse. `interleaved` to `columns`: the addresses and instructions glide right into the instruction column (24 f, `glide`), then every row glides to its height in the new form, each line level with its run's first row (24 f, `glide`); the rules move with their groups; the lines with no code fade into the room made for them (12 f). Back, the same in reverse, the no-code lines first | | `arc` | a pointer to a row of its panel | written: with the arm (s−12) the old arc goes dashed; from s+6 it fades (12 f) while the new one draws from the pointer's row along its lane to the target, head first, 12 f, `standard`, at full ink; with the cool at the advance it quiets to standing (24 f). Read: to full ink with the read (6 f), back with the advance. Overwritten with a target off the panel or NULL: it fades from s+6 (12 f). A lane change glides 12 f. Scrolled: it rides its rows, fading as its target leaves. At a run 8 f, at a sprint none | | `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 | @@ -1650,7 +1669,9 @@ recording of `targets/list` (9 to 11, 21), the map (19) and the dive (20); (15); `mock/graph.py` draws the graphs (22 to 25) from `sort-O0.dis`, `reverse-O0.dis` and `libc-open.dis` and the paths their runs took; `mock/heap.py` draws the heap scene's storyboard (18) from a -recording of `mock/heap.c`; `mock/gen.py` draws 1 to 8. Each working frame +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; +`mock/gen.py` draws 1 to 8. Each working frame has a `-480.png` beside it; the map has its 1080p (`19-map-1080.png`). ```sh @@ -1661,7 +1682,9 @@ 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 pair.py && for n in 26-pair-rest 27-pair-store 28-pair-part; 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; do resvg $n.svg $n.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 +for n in 30-intro-words 34-segments 36-aligned-columns; do resvg -w 480 $n.svg $n-480.png; done python3 -B dense.py && resvg 15-marks.svg 15-marks.png python3 -B map.py && for n in 09-context 10-context-step 11-context-lens 21-loupe 19-map; do resvg $n.svg $n.png && resvg -w 480 $n.svg $n-480.png; done # 20-dive.png it composes itself @@ -1693,10 +1716,14 @@ python3 -B gen.py # 1 to 8, then resvg the same way | [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 | | [28](mock/28-pair-part.png) | i = 16, the step in which they part | plain's store struck into the saved rbp's low byte; ASan's shadow load framed reading `f3`, its compare and the branch not taken; `differs` on the facing rows | | [29](mock/29-intro-bytes.png) | the introduction's first picture, the camera at x2: 128 bytes of the stack, nothing else | a raw hexdump, before any ink | -| [30](mock/30-intro-words.png) | eight bytes a row, each row's word read right to left beside it, inked; the address space beside | `regroup` landed; `ink`; `segments`, the code mapping framed for the return address | +| [30](mock/30-intro-words.png) | the `ink` beat: the words, eight bytes a row, where the stack will be; the address space in the program column | `regroup` landed, each word ranged right; `segments` at 108 wide, no pins; a dump's place, the `link` standing; `ink`'s echo: the return address and list's code band, with its row | | [31](mock/31-intro-stack.png) | the same words as the stack panel, the registers built over it, at x1.25 | the stack's conventions: rsp and rbp pins, offsets, roles, spans | | [32](mock/32-intro-code.png) | the code chapter: `aligned` with each instruction's bytes between its address and mnemonic | an instruction as bytes, decoded, level with its line | -| [33](mock/33-aligned.png) | the `aligned` split: reverse and its neighbours, the pc at the load | a line with two runs (20), lines with no code, rows of no line, the band as the thread | +| [33](mock/33-aligned.png) | the `aligned` split, `interleaved`: reverse and its neighbours, the pc at the load | a line with two runs (20), lines with no code, rows of no line, the band as the thread | +| [34](mock/34-segments.png) | `segments` as a frame, treatment A: the list recording's mappings (`ztrace show`) | the whole with its ends and size; three boxes; the program by segment under its bracket, every other file once; addresses at the edges, sizes, permissions in a row or inside a band; leaders pooled; rsp and rip | +| [35](mock/35-segments-abc.png) | the three treatments as frames, saying less and less | A as 34; B every file once; C the whole alone | +| [36](mock/36-aligned-columns.png) | the `aligned` split, `columns`, on 33's data and `_init` after it | the seam after the longest line; places at each column's start; line 20's cell eight rows tall; its second run; lines 23 to 25 with no code; rows of no line; the pc's wash across both columns | +| [37](mock/37-regroup.png) | `regroup` walked on the return address, `b0 18 00 01 00 00 00 00`: eight instants with their frames | the reflow to eight a row; the offsets and the low and high byte; the flight on nested arcs; landed reversed; the gaps closed; the zeros gone; the run; the ink | | [1](mock/01-fib-recursion.png) | first pass | `calls` at camera scale | | [2](mock/02-list-insert.png) | first pass | `nodes` at camera scale; `allocated` | | [3](mock/03-syscall-write.png) | first pass | `syscalls`; `kernel` (the kernel's side is now the descent's floor, 16) | @@ -1737,6 +1764,10 @@ the band. - The minimaps of 12 to 18: their recordings hold a stack of 64 words or less and no bytes round targets, so their maps would be mostly gaps. - `surface`, `flash`, a window's outline gliding on the minimap. +- `enlarge` and a dump's place in motion (charts only); treatments B and C + of `segments` at their own sizes (the sheet has them as frames); `align` + between `interleaved` and `columns`; `columns` with a pc in a long run, + away from its line's row. - A local's name as a slot's role (the recording has none at these pcs). - `pin` with a count; `rwx`. - Every verb: the mocks are stills. `establish`, `link` and `project` @@ -1823,9 +1854,21 @@ is not checked here. The tokens are under [Token changes](#token-changes). fortieth, the stopped side holding, a run's stderr as a panel; steps matched by source line or loop turn. 9. **The introduction's blocks** ([`segments`](#segments), [`aligned`](#aligned)): - the address space from the mappings; the aligned split; `regroup`, - `ink`, `column`, `frame up`, `decode`, `align`; a hexdump with no ink - (the first picture only). + `segments` from the mappings: the whole (a bar, its two ends' addresses + and its size, every mapping a 2-unit line at its end); a box for each + cluster with the two lines of its magnification; its names, a row for + each edge and each band, rows 24 apart pooled round their edges, the + leaders; the program by segment, every other file once, permissions in + the row or inside a band 28 tall, nothing named under 6; rsp's and rip's + pins; a dump's place (the bracket and the standing `link` over the + stage's top); `ink`'s echo on a band and its row; treatments B and C as + options. `aligned` in its two forms, `interleaved` and `columns` (the + seam set by the longest line in the window, both places 132 into their + columns, cells as tall as their runs, the lines with no code in source + order). The verbs `regroup` (walked, and at a run), `ink`, `enlarge`, + `column`, `frame up`, `decode`, `align` (also between the two forms of + `aligned`). A hexdump with no ink (the first picture only), and a word + field ranged right, eight pairs wide. 10. **Still from before**: the calls tree's small size and folds, `metric.span.name_max` 300, `time.caption_max` 12 s and `time.first_step` 4 s (5 s when a scene opens on the map), `time.dive` @@ -1857,8 +1900,10 @@ is not checked here. The tokens are under [Token changes](#token-changes). - For the heap scene: see [the scene](motion.md#a-scene-libcs-heap-from-the-inside). - For a pair (the ASan scene): see [the scene](motion.md#a-scene-asan-against-a-plain-build). - For the introduction: the mappings with their permissions and their - file offsets (to say code, read-only data, data), not only their ranges - and paths (`ztrace show` prints ranges and paths); the bytes of the + file offsets (to say code, read-only data, data): `ztrace show` prints + them now (this round's recording of `targets/list` under `env -i setarch + -R`; the kernel now splits `[vvar]` in two, `[vvar_vclock]` its second + page pair); the bytes of the instructions in the window (or the binary, for the renderer to read them); and a recording of the program by instruction from `main` to the stop, so that a real `push`, a real `call` and the moment rsp moves are @@ -1902,6 +1947,10 @@ loupe's and the arc's tokens, the lift's colours, the clock's count at | `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 | +| `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 with the marks of the last round (`wash`, `struck` `b54f42`, the corner), |
