The cell width was CELL_SIZE on the C++ side, and the searcher's CellBit count
was CELL_ARGC. Both now match what the code and the docs around them already
called them:
* include/r8forge/r8asm.hh + src/r8asm.cc: CELL_SIZE -> cell_size
(set_cell_size assigns this->cell_size, its parameter already had that
name);
* include/r8forge/r8veritas.hh: the template parameter CELL_ARGC ->
cell_argc, 34 uses, so the searcher reads r8veritas<cell_argc>;
* AGENTS.md says which name means what, and why the name .r8asm programs
see is still _CELL_SIZE: that one belongs to the macro library, not to
the C++ side, and changing it would rewrite every macro in asm/;
* the cross check entry now says which ROT-8-viz is which: the author's fork
with --cell/--mem, and the upstream starcells/ROT-8 tree in the workspace,
whose geometry is compile time cell_size/mem_size -- it is 11 / 259 too
now, and `rot8_test <tape>` against `r8forge_derive ... -1` still gives
1322 1786 1600 5 94 127 on the hash tape.
All six self checks pass unchanged: 28729 character hash tape, synth_test 8/8,
both verify_ tapes, byte_op_test 65536/65536 for clb_mul and the rest of the
library, macro docs test green.
r8asm::ast::CELL_SIZE machine word width in bits, run time value
(import_file's second argument, 8 in the CLI)
r8veritas<CELL_ARGC> how many parameter cells a synth block has,
compile time, selected by 'params N'
set_cell_bits went back to set_cell_size for the same reason, and the .r8asm
visible names (_CELL_SIZE, _CELL_MAX, _ROL_STEP) are unchanged, so lib.r8asm
keeps working as written.
This time the string literal used by %rep and by the .xor masking is the one
the C++ member is now called too, which removes the trap the previous rename
walked into.
Regressions after the rename:
asm/test.r8asm exit 0, 1666 characters, 7/7 cached
examples/full_add_layers.r8asm eight combinations ok
derive bit_raw_add same table as the hand written version
clang-cl build of all five targets, and the clang built binaries produce the
same 1666 character tape and the same table.
There were two unrelated things under one name:
r8asm::ast::CELL_BITS the machine word width in bits, a run time number
(import_file(path, 8)), used by %rep and the .xor
argument masking
r8veritas<PARAMS> how many parameter cells a synth block has, a
compile time template argument selected by 'params N'
The first is now CELL_BITS, the second PARAMS. What a .r8asm program sees does
not change: _CELL_SIZE / _CELL_MAX / _ROL_STEP keep their names, because
lib.r8asm uses them.
Answering the actual question along the way: the machine word width is a run
time parameter (import_file's second argument, hardcoded to 8 by the CLI), not a
template argument -- the comment in r8asm.hh even apologises for that. The
synth block's 'params N' is the other one, and only that goes through the
template switch (1..8).
The first attempt at the rename also rewrote the _CELL_SIZE string used by %rep
into _CELL_BITS, so the lookup threw and the assembler died with a fastfail on
any file containing .xor or %rep. Caught by regressing test.r8asm (exit
0xC0000409, no tape); the string is restored and asm/test.r8asm is back to 1666
characters with all seven blocks cached.
Tried the obvious split -- one worker per possible first block, since a
program's first block is unique and the answers cannot overlap -- and measured
it on the full adder at limit 82:
workers wall total CPU peak memory
1 1350s 1350s 11 GB
8 ~10min 4600s 14 GB
32 -- 4870s 17 GB
So the answers do not overlap but the *search* does: every prefix walks into the
same middle of the graph, and with a table per worker that middle is explored
once per worker instead of once overall. Three to four times the work and more
memory, for a modest wall clock win.
Kept the code (opt.threads > 1) because it is correct and it is the right shape
for a machine with more memory, but the default is one worker. The parallel
split that should actually pay off is inside one shared table: expand the
current Dial bucket across threads, insert through a sharded table. That is
the next attempt, not this one.
First version scanned ahead for the next nonempty bucket but stopped one max
edge weight out, so a sparse frontier ended the search early and claimed
"nothing under the limit" while the queue still had work. Scanning further is
also wrong: the ring reuses a slot every ring.size steps, so a far bucket sits
where a near one would be. Plain Dial now: step one cost unit at a time.
The growth table in the README was measured with the broken version and was
wildly optimistic. Real numbers from the fixed build, full adder with
adjacent cells: cost 58 -> 80M states, 66 -> 220M, 70 -> 280M, about 27 bytes
per state and 650k states/s, so cost 75 / 450M states / 12GB is roughly the
ceiling on this machine.
Validated solve_cost on the small problems where the answer is known by hand:
copy comes out at cost 17 (sacrifice 0 into {2}, then sacrifice 2 into {0,1}),
which is the two block program, and it replays ok.
Layers are not characters. solve_cost runs Dijkstra over the same state graph
with an edge weight of what the block actually assembles to:
w = 3 (biz + flb + rnz) + 2 * span(cell addresses) + sum(op)
op = 1 for flb, 4 for set_1
Dial buckets, pop in cost order, the first pop of the goal is the shortest
tape. Give it max_cost and it becomes branch and bound: anything past the
bound never enters the queue.
Exhausted regions on the full adder with adjacent cells:
max_cost 20 1,086 states 0.0s
max_cost 40 128,528 states 0.1s
max_cost 50 999,448 states 0.7s
max_cost 60 7,671,626 states 12.8s
max_cost 65 20,153,459 states 47.6s
About 2.6x states per 5 cost, about 32 bytes per state, so max_cost 80 is
~350M states / 11GB and 82 would be ~600M / 19GB. The block weight leaves out
the hop from the previous sacrifice (that would make the cost depend on
history and Dijkstra would stop working); the emitter adds it when it reports
the real length -- the five layer program is 82 in the model, 87 on the tape.
The first version of the bucket ring only looked one max-edge-weight ahead for
work, so it declared 'nothing under the limit' while the queue still had
states further out. That made the small limits look sound when they were not;
advancing to the next nonempty bucket fixed it.
The searcher stops being a separate program: %synth is an assembly-time
directive. It describes a truth table, the assembler runs the search while
parsing, and the block list comes back as ready-to-paste r8asm.
Merging is what makes the cost model honest. The price of a layer is
cost = 2 (biz + rnz) + sum(move distance + op cost)
and the move distance depends on the call site's cell layout, not on anything
the assembler knows in advance: the same five-layer adder is 87 characters
with the cells adjacent and 136 with them two apart. Only the side that sees
the layout can price it, which is now the assembler itself.
Working: the assembler (asm/test.r8asm still assembles to the same 1714
characters), the searcher (bit planes + backward one-step lookup, full_add in
5 layers, proven shortest in 7.2s), and %synth parsing plus the search itself.
Not working yet: splicing the synthesised body into the tape -- a synth call
fails loudly with 'unknown macro' instead of emitting anything, so nothing can
silently assemble wrong. The two ways to finish it are in the README.
Also carries over the CMake fix: no set(CMAKE_CXX_FLAGS ...), which used to
drop /EHsc, push -O3 into Debug and fight /RTC1.