pure/docs/design/023-optimizing-tier.md, branch masterVerified execution runtime unifying state, persistence, and replication.
http://git.yeowoo.org/pure/atom?h=master2026-10-05T18:36:25Z125: forms and newton runs named; BFS's time after the graph's load is the generic code's (steps 0.1%), what the tier needs for it (a list's count as a changing value); 023 cites words at e2e56dd2026-10-05T18:36:25Zeunhhunecpition205@gmail.com2026-10-05T18:36:25Zurn:sha1:a099d63e2322f5ae17e8fbdc51d6cc020638a5dcPointer induction (023): an inner count's access by a key affine in its round, in range for every round (its opening found it) and in a full list, reads its cell through a pointer, a phi at the loop's head: the column (read from the list) plus the key at round 0 times four where the loop opens, its key's step a round times four added at its latch. The key's nodes, in range, give up nowhere (no snapshot kept), so a key read by such accesses alone is not made; a list found by key alone with such an access is full where the tier begins (else the generic code runs the nest). matmul 23.0 to 14.2 ms (3.1x to 1.9x C)2026-10-05T18:14:08Zeunhhunecpition205@gmail.com2026-10-05T18:14:08Zurn:sha1:b5c275f6b908aad08b98bc0cc643f8602ebfb157
module_tier's programs sweep lists by keys stepping with a round (in range or not, a list full or not)
040 forms.c: matmul's inner loop in the forms the tier may make it (index 20.7 ms, pointer with multiply-add 13.1, apart 10.0, with checks 10.2, a bit tested before each load 13.4): the position's multiply and the pre-load branch cost, the checks hardly; 023 section 5 says so and what comes first (pointer induction, then a full list's copy)2026-10-05T17:53:24Zeunhhunecpition205@gmail.com2026-10-05T17:53:24Zurn:sha1:8c0c409ec5032a39bf9181198a24f25cca90d5fbThe tier's numbers' arithmetic in a run, each read by the next alone (constants between), checks only the last is finite, giving up at the run's first snapshot (the executor makes the run again and fails where it does); a snapshot's constants written as the constants they are, not kept in registers; the generic code's append in a loop keeping its books puts into a HASHED list as append does (its headroom kept). roots 12.2 to 10.9 ms (1.59x C), join 84 to 74 (2.5x)2026-10-05T17:08:56Zeunhhunecpition205@gmail.com2026-10-05T17:08:56Zurn:sha1:49b6196d883a2b69cb4b6fb437af71544ba3bc93
module_assumptions: a run of products and sums past the largest number (CHAIN_SOURCE)
A HASHED list's table four fifths full at most (100,000 keys in 1 MB of slots, as C's table: in the L3), the generic code's APPEND into a HASHED list at its key's slot while its table need not grow, a whole number over a whole one above 0 never -0 (so MINSTD's floor(x * 48271 / p) is whole and x an integer in the tier). join 108 to 84 ms (2.8x C), sort 58 to 37 (1.4x)2026-10-05T16:47:43Zeunhhunecpition205@gmail.com2026-10-05T16:47:43Zurn:sha1:4f6ce04d7986f45c8f0910262b6a48cb864577ffText keys (023): a list knows the text field it is keyed by; an event's list keyed by a text is HASHED from its first item, its table's slots holding the texts' hashes (FNV-1a), a match the key cell's bytes too; HAS and a field by key read the table; its order made by a merge sort (the first eight bytes as a number, then all). A FIND whose index only an ITEM_SET of its list takes, the code between in a line finding by key alone, sets the item where it was found (PLAN_ROW: a HASHED list's slot, no position made). words 453 to 217 ms (5.8x C)2026-10-05T16:38:03Zeunhhunecpition205@gmail.com2026-10-05T16:38:03Zurn:sha1:b81d8bc8249ee35e87ea630413a311460e85eec0
text_keys_equivalence: adds, has, fields by key, sets where found, positions, runs, removes and clears against a tree keyed by the text
HASHED (023): an event's list keyed by numbers that came out of order keeps each item's cells at its key's slot in its members' table, found by key there (the key and its cells read at one slot, as C's table); its order made by a radix sort of the slots' keys when something asks for a position (twice an event, then FLAT or a tree). The tier finds by key alone in a HASHED list (its bits' bit 1, its limit all ones: the bounds checked at a loop's opening still hold) out of the line; a list keyed by each count in order is DENSE from its first item. join 531 to 108 ms (3.5x C), sort 98 to 58 (2.1x)2026-10-05T16:24:28Zeunhhunecpition205@gmail.com2026-10-05T16:24:28Zurn:sha1:f7d369e77d999a0e60f3de2b5511b99c81b266bb
arrays_equivalence counts the HASHED form against a tree; module_tier's programs read a HASHED list by key
023: near C is the aim (each within 1.25x, the geometric mean within 1.1x), not past it; representation first, since a keyed list given keys in order stays FLAT and is searched by halves (knapsack's and matmul's 300x)2026-10-05T13:31:30Zeunhhunecpition205@gmail.com2026-10-05T13:31:30Zurn:sha1:c2b955ddf87b1057095b8fa7ca8917190daac82c023: only checks the tier moved know just that they fail (those left in place fault where they are; now is the host's per-event value); value numbering of pure operations, which words' floor assumes2026-10-05T12:38:08Zeunhhunecpition205@gmail.com2026-10-05T12:38:08Zurn:sha1:b2b7f849d6ab80fceb7d3c3c312fae859613a913Design 023, before building it: a tier that lifts every block to SSA, knows types and ranges, hoists the meaning's checks out of loops, counts work per loop, allocates registers; criteria on research 124's suite of seven kinds of work against C (each within 1.25x, the geometric mean below 1.0, the meaning's checks within 5%), from floors at 0.90x C2026-10-05T12:35:30Zeunhhunecpition205@gmail.com2026-10-05T12:35:30Zurn:sha1:2945d2c0d6661d3602a2950825179331cb0ce4e0