pure/research/experiments, branch masterVerified execution runtime unifying state, persistence, and replication.
http://git.yeowoo.org/pure/atom?h=master2026-10-19T13:50:05Z030: the numbers from one build (the runtime 40,847 and the hand path 813, cycles 15,735 and 348, beside Vega's 251 and 93; other builds 1-2% apart) and 602 named as the substituted algorithm (373 cycles); 9.43x said to be the emitted chain's factor, the executor's share step 1's first measurement; 009's tension stated once (sparse updates in the log's delta, whole numbers zigzag there: a second shape, the cheaper one); the caveats of 047 together; model.py's import where imports go2026-10-19T13:50:05Zeunhhunecpition205@gmail.com2026-10-19T13:50:05Zurn:sha1:91ab9a09db49be3c6f1259d3ef453c893b7ba0bd047: "the leaf is the commit" measured against the bars set before: appends pass, sparse updates do not, as said beforehand that means two units, not one: list bytes a message at 1 / 16 / 256 a commit, entries' appends today 65.5 / 15.7 / 12.4, leaves cow 1,636 / 102 / 14.5, leaves with appends in place past every kept snapshot's count (tail) 25.9 / 10.9 / 10.0; the bank's transfers today 122 / 35.6 / 30.1 (bars 244 / 71 / 60), cow 7,428 / 2,098 / 996, tail 4,826 / 1,975 / 992, cells written in place 186 / 126 / 122 but seen by kept snapshots (933,888 / 542,208 / 10,848 times); after the run, a leaf with room for changes (delta, 16 B each, the leaf written anew when full): 739 / 545 / 292 with room 8, 363 / 268 / 176 with 32, 249 / 161 / 136 with 128, every one over (today's log puts a change in about 7.5 B: varint places, zigzag wholes, one frame a commit); no kept snapshot sees a write of cow, tail or delta; rows as leaves (packet.c): 44.4 machine instructions a row to check and take 32-row column chunks against pure_list_read's 1,318 (cycles 14.2 against 372), every cell the same2026-10-19T13:47:10Zeunhhunecpition205@gmail.com2026-10-19T13:47:10Zurn:sha1:415bc5af13f6658ac44a0d135bb0f290191a44f6047: "the leaf is the commit" (feedback 009) set up before it runs: today's store measured as the base (baseline.py, 046's shim and journal: list bytes a message, the log and images, at 1 / 16 / 256 messages a commit: entries' appends 65.5 / 15.7 / 12.4, the bank's transfers 122 / 35.6 / 30.1, the tree apart), and a byte-accounting model (model.py) of commits writing the leaves they changed in memory's own bytes (leaf 296 to 1,320 B, inner node 680 B, cow; tail appends in place past every kept snapshot's count; inplace, which may not be, to show why), its bars written before the run (appends at most today's, sparse updates at most twice, no write a kept snapshot sees) and what a pass for appends with a miss for updates would mean (two units, not one); 046's Run takes pure-run's arguments; 045's keyed file says 24 refused, not the 26 its commit said2026-10-19T13:44:13Zeunhhunecpition205@gmail.com2026-10-19T13:44:13Zurn:sha1:a93891ee72bb1793eb1845d6d49369cb9f1e8806045: the app keyed and its range found by a seek, emitted as it says (no algorithm the app does not state, nothing copied out of the tree): aup takes ranges as a list keyed by last and first(x in ranges where x.last >= code) as its range, the executor answers every line and is itself 40,258 to 27,934 machine instructions a point; the hand rungs on it (the seek by each level's guide keys and the leaf's key column, the found item's fields read from it, the other ranges read by key): keyed_shared 788 a point, end to end 813 with 348 cycles (the position-halving seek of a1382de, another program, 604 with 373 cycles; Vega's C 251 with 93)2026-10-19T13:37:55Zeunhhunecpition205@gmail.com2026-10-19T13:37:55Zurn:sha1:519df326fe131c94a706c0d8b8f23ca8f093af3b045: feedback 009's zero copy measured: ranges read where its tree keeps it instead of copied out (stored_flat, which 009 forbids): through pure_list_run 7,931 machine instructions a point, the tree's layout read directly (the descent by the guides' counts) 7,135, both above the copy's 6,136, and on them the later rungs worse (shared 1,576 against the copy's 564): a positional halving descends the tree each probe; the halving done by the tree's own order (each inner node's children by their first items' starts, read in place, then within the leaf) 6,137 and shared 578, the copy's within 2.5% (cycles 388 against 312), end to end 602 a point (2.5x Vega's C, cycles 4.1x); that needs ranges ordered by start (the data is; a keyed list's seek would say it); the list's code built into the harness for it (-O2, inlinable: exact 8,532, the runtime 40,745)2026-10-19T13:23:37Zeunhhunecpition205@gmail.com2026-10-19T13:23:37Zurn:sha1:a1382deee0f7dccfb1c6d342bacb1649203d046e046, 029: the taken-over store sent a message too (opened() works on a copy: show, add, show; 20 more kill -9s: all open and take it as owners; 667 prefixes again with it: all pass); the price measured again without the fold that inflated it (entries.aup's summed view folded every entry each message): 48.5 to 232 us a message on tmpfs, 146 us of the 183 waiting for acks; the shim never stopped across the runs2026-10-19T13:16:33Zeunhhunecpition205@gmail.com2026-10-19T13:16:33Zurn:sha1:d5107e9e61d1083f945edb64ec619c333024a43f046: 029's principle 2 put to its breaking experiment on one Pi, the tools and the numbers: an owner (pure-run --store) with shim.so preloaded ships every change its store makes to its files (ops.h: create, write, truncate, allocate, rename, unlink, mkdir), cut at each fsync or fdatasync, over pure link (shipper.c, follower.c), and its sync returns once the follower has the cut (synchronous: one cut in flight, no log); identity: 100,000 messages (200,081 cuts; 34 compactions, an image written again) and 200,000 (400,149 cuts; 67 compactions, a second log segment), the stores compared byte for byte every 1,999 and 3,001 cuts and at the end: 0 differences, the follower's store opened as owner holding every message; takeover: 70 kill -9s (owner alone, the whole node, the node with cuts of 512 and 64 B records): all open, hold every message the owner said done, none not sent, the entries in order (and equal to the owner's own store each time); prefixes: 867 op boundaries of a 100,000-message stream (568 within cuts, 266 around installs) opened as stores: all pass; the price: 204 to 400 us a message on tmpfs (155 us waiting for acks, two cuts a message), 903 bytes shipped a message, 42% of them zeros written ahead (a compaction's new file and the tree's tail)2026-10-19T13:08:53Zeunhhunecpition205@gmail.com2026-10-19T13:08:53Zurn:sha1:cbfec0d3ac239e050597bdb080645ffb53bad66e045, 029: a message end to end, the event's border written by hand too (app.c's BORDER: rows whole and finite, the budget and memory begun again, the one state the handler changes written apart and made the state's at a faultless end into a buffer no reader holds, events and changes counted; every end answers all 18,672 lines, the broken-rule build refused at both hand ends): machine instructions a code point, the runtime 40,365, its empty handler 1,595, the hand border with shared 592 and with plain 379, Vega's C given the same payload 240: 68x, 2.5x C (cycles 3.2x), the border 1,595 to about 22; what went: the rows rebuilt into a tree each message (pure_list_read's make_tree), 54 states walked five times an event (40 of them t.X's registers), the last event's nested lists, a bytes state set whole through a text's piece tree; no new fact (N2, today's proof, the language, forms chosen)2026-10-19T12:41:28Zeunhhunecpition205@gmail.com2026-10-19T12:41:28Zurn:sha1:de1d30da1203cae9cd857052c339ac026f18cffa045: UAX #14's whole app emitted by hand, the chain (app.c, app-way.h: on line, decide and its fns written once against a rung's macros; every rung answers all 18,672 lines as the test and exactly as exact; with LB18 made wrong every rung is refused): machine instructions a code point, the handler: exact 8,785 (registers and plain calls; doubles, fmod, whole and bounds checks twice, the event's lists FLAT PureLists with list_held and grows at each append, Text's lists copied, ranges the stored tree, the budget), integers 7,979, ranges' columns flat 6,561, the event's lists typed buffers 696, Text sharing them 564, no bounds checks 502, no charges 362 (the same algorithm in C), Vega's C 225; the executor 40,189 and stitched 28,089 hold the event's own 1,566 besides (an empty handler: decoding the points into a list, clearing and freeing the event's lists, malloc, the breaks state through the store tree)2026-10-19T12:05:34Zeunhhunecpition205@gmail.com2026-10-19T12:05:34Zurn:sha1:2634e067cd2411078d61c7f737dcd7b06121d5df045: range() emitted by hand, Pure's meaning kept or dropped where the proof could license it (range.c; every way's answers the executor's and the stitched build's, for all 61,285 points): a code point's machine instructions in the executor 14,488, stitched 8,144, exact (registers, a plain call; doubles, fmod, the finite and whole checks, the tree read, the budget) 2,474, integers 1,587, a flat column 1,083, both 226, C 129; a round of halving exact 217, both 19.8, C 11.3: the bar (3x C's round) missed by exact, passed by both2026-10-19T11:27:55Zeunhhunecpition205@gmail.com2026-10-19T11:27:55Zurn:sha1:a2800def1bdc4060bd06f22db94d7968e2791de7