R8Forge had no spec of its own: the language lives in r8asm_rev/SPEC.md, the assembler
and the search were documented in README.md, and the macro contracts were only in the
comments above each %macro. This adds SPEC.md, pointed at the standard library:
* what this spec covers and what stays upstream (so the two do not drift);
* the five parameter types, the naming prefixes/suffixes, and the measurement
convention for tape lengths (a minimal driver, contiguous cells, no output lines);
* %synth: the full grammar, what map and stat mean, the three metrics, the cache key
and kModelVersion rule, and the four limits (8 params, 8 layers, no byte level
tables, no unconditional flip);
* all 41 macros in asm/ in tables with signature, which cells they eat, cell count,
tape length and implementation (hand written or %synth block + its stat table);
* the warts: clb_and leaves B & ~A behind while clb_or/clb_xor are clean, layout being
silently ignored when its length is not params, and set_0 clearing one bit only;
* a verification matrix saying which test proves what, and the known dead ends.
Every number in the tables was measured for this commit with one uniform driver
(measure_macros.ps1 shape, deleted afterwards), e.g. clb_not_ip 22, clb_add_ip 722,
clb_mul 3964 minimal vs 3977 through drv/mul_byte.r8asm. AGENTS.md and README.md now
point at SPEC.md instead of saying the %synth docs only live in the README.
34 KiB
给接手的 agent 的话
动手之前,先把这份文件从头读完,再看
SPEC.md(本仓库自己的:%synth指令 +asm/里每个宏的契约、纸带长度、验证口径)、上游语言规格 (C:\Users\peng0\git\r8asm_rev-fork\SPEC.md)和asm/lib.r8asm里的宏注释。 这条不是客套:上一轮我没先读,把「位移-加法乘法器比重复加法快」当成新发现又推了一遍。 那次它被否掉了(当时只认纸带长度),后来乘数一大就撞 500 万步上限,真的换成了移位-加法 —— 而且它比重复加法还短(5007 → 3977 字符),见「乘法器」。 下面「乘法器」「指令集语义」两节把要命的地方都写了 ——dp净位移、flb吃条件、rol= 10 次ror、 位串行要的跨格移位该怎么拼。尤其把「已经确认走不通的」那节看完, 别把别人踩过的坑再踩一遍;想推翻某条结论,先照它写的验证方法实测一遍再改文字。
这个文件是给下一个会话(或者下一个 agent)看的交接说明。内容都是这个仓库里实测过的结论, 不是推测;每条后面基本都跟着一次失败的尝试,别再踩。
工作方式(上一轮踩到的)
-
超过 ~30 秒的命令一律丢后台(
run_in_background),前台只做短轮询。 一次搜索可以跑 680 秒、缓存预热 885 秒,前台干等会撞上客户端和 API 的传输超时。 -
别让大段 stderr 进上下文。PowerShell 遇到原生命令出错会吐一整套
NativeCommandError堆栈;用2>$null收干净,判断结果靠$LASTEXITCODE和 stdout。 -
写含中文的文件用编辑工具(UTF-8)。不要用 PowerShell 做"读-改-写":这台机器上
Get-Content默认按 GBK 读 UTF-8 文件,再Set-Content -Encoding utf8写回去就是 二次转码、整篇变乱码(AGENTS.md就这么被我毁过一次,靠git checkout -- AGENTS.md救回来)。Set-Content -Encoding ascii更糟,汉字直接变?(examples/full_add_flat*.r8asm就这么坏过一次)。 -
构建要用 VS 自带的 cmake:
build/是Visual Studio 18 2026生成器配的, 直接敲 PATH 上的 scoop cmake(4.4)会因为版本不一致重新配置,然后死在No preprocessor test for "PellesC"。用这个:"C:/Program Files/Microsoft Visual Studio/18/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/bin/cmake.exe" \ --build build --config Release -
%synth的临时文件:汇编器把生成的宏写到系统临时目录再 import,然后删掉。这台机器上 这一步偶尔会失败(r8asm: cannot open 'C:\Users\...\Temp\xxx.synth.r8asm';同目录下cmd能写、r8forge不能,原因没查清,重跑一次可能就好了)。现在代码会退回到当前工作 目录重试,stderr 留一句<临时目录> is not writable, using <cwd>。看到这句不用管; 看到cannot write the synthesised macro anywhere才是真坏了。*.synth.r8asm已在.gitignore里。 -
会话很长时传输容易失败,重要结论要落到 commit message 和文件注释里,别只留在对话里。
-
写结论之前先对虚拟机:这个仓库最贵的一次事故就是虚拟机语义写错,然后在错的东西上 写了一整套"实测结论"(见「字节级运算」)。字节级结论必须能被 ROT-8-viz (
C:\Users\peng0\git\ROT-8-viz,权威实现)复现。 -
提交身份:这个 repo 和
C:\Users\peng0\git\ROT-8-viz的 local config 都是user.name = dsh、user.email = dsh@gitea.local(凭证里那条git:https://gitea.starcells.ltd就是dsh@gitea.local)。agent 的提交用 dsh,不要用StarCells <peng080306@foxmail.com>—— 那是仓库主人的身份。这条踩过:ROT-8-viz 一开始没配 user.name,我照抄了历史作者, 结果两个 repo 的提交都挂在了主人名下,后来用rebase --reset-author/filter-branch改回 dsh 并 force-push 才修好。git commit报Author identity unknown就是这条配置又没了, 补git config user.name dsh+git config user.email dsh@gitea.local就行。 ROT-8-viz 上这个 local config 被清掉过两次(原因没查清),所以那边提交时更稳的写法是 直接带上:git -c user.name=dsh -c user.email=dsh@gitea.local commit ...。 -
推代码:
origin=https://gitea.starcells.ltd/dsh/R8Forge.git。这台机器上 schannel 会报schannel: AcquireCredentialsHandle failed: SEC_E_NO_CREDENTIALS,fetch/push都得走 openssl 后端 —— 已经写在这个 repo 的 local config 里 (git config http.sslBackend openssl),正常git push就行。 如果当前会话的沙箱是 workspace-write,push还要一次提权:git 的凭证助手要开命名管道, 沙箱会拒绝(sh.exe: fatal error - couldn't create signal pipe, Win32 error 5+could not read Username);danger-full-access 下不需要。fetch两种模式都不需要 (仓库可匿名读)。
构建与自检
# MSVC Release
cmake -S . -B build -G "Visual Studio 18 2026" -A x64
cmake --build build --config Release
# clang-cl(scoop 的 llvm,比 MSVC 严格,能抓出模板推导问题)
clang-cl /nologo /std:c++20 /EHsc /O2 /I include src/r8asm.cc src/synth.cc tests/asm_test.cc /Fe:r8forge.exe
自检:
r8forge asm/test.r8asm # 应 exit 0,28729 字符(3 轮 hash)
r8forge_synth_test examples/full_add.r8asm # all eight combinations ok
r8forge verify_clb_bit_add_nc.r8asm # 4 cell 加法切片(进位进->出)
r8forge verify_clb_bit_inc_nc.r8asm # 3 cell 自增切片,进位同样进->出
r8forge_byte_op_test # 字节级库:17 个操作穷举/抽样,1.5 秒
r8forge_macro_docs_test # asm/ 里每个宏的注释格式
r8forge_byte_op_test 是唯一按返回值判断字节级对错的;前三个只证明"汇编得出来"或
"位级正确"。
r8forge_derive 是验证工具:
r8forge_derive <file.r8asm> 4 0 2 # 按输入组合跑,打印 stat
r8forge_derive <file.r8asm> -1 0=100 1=50 # 指定 cell 初值跑一遍,打印 out
r8forge_derive <file.r8asm> -2 0=100 # 同上,另外倒出所有非零 cell
注意 -1/-2 是拿汇编源码跑的(内部会先 import_file),不能直接喂 .rot8 纸带。
r8forge_tape_run <file.rot8> [addr=value...] 是第二个实现,直接喂纸带,用来交叉验证
derive(两个实现同时写错的可能性比一个低)。
指令集语义(这些搞错会浪费一整轮)
'-' flb 翻转最低位 cells[dp] ^= 1
'+' ror 右旋整个 cell
'[' biz 最低位为 0 -> 跳到匹配的 ']' 之后
']' rnz 最低位为 1 -> 跳回匹配的 '['
最后两条的关键在"最低位"三个字:biz/rnz 判的是 cell & 1,不是"整格是否为零"。
权威实现是 ROT-8-viz/src/rot8.c:
void rot8_biz(rot8_iter *iter) { if ((*(iter->mem_now) & 1) == 0) { ... } }
void rot8_rnz(rot8_iter *iter) { if ((*(iter->mem_now) & 1) == 1) { ... } }
由此推出两条关键约束:
set_0=[-]清的是最低位,不是整个 cell。set_0把 255 变成 254、把 128 原样留着、把 5 变成 4。要清整个字节就%rep _CELL_SIZE { set_0; ror }(erase就是这么写的)。一个字节的位能读:ror若干次把目标位转到最低位,再biz。- 合成的程序只碰每个 cell 的低 K 位(K = 参与运算的输入位数),高位不追踪。
所以
%synth出来的块只适用于"每格一位"的世界。
写手写宏还有第三条:dp 是汇编期算的常量,而 [...] 的 body 在运行期可能被跳过。
所以每个条件块的身体必须回到它自己的条件 cell(净位移 0),否则跳过路径和进入路径的
dp 会不一致,之后所有 .tp 全部错位 —— 症状是 dp 跑到 1023 这种地方(
r8forge_tape_run --trace 能直接看到)。库里的宏都遵守:set_0 的身体不移动、clb_bit_mov
的身体最后 .tp before 再 flb(顺便把条件吃掉)。
曾经这里还写过第三条("多字节 cell 的位读不出来")—— 那是把 biz 当成 Brainfuck 的
整格零判断推出来的,错的,已删。
cell_size 与纸带长度是怎么用的
位宽叫 cell_size(一个 cell 多少 bit),纸带长度叫 kDefaultMemoryCells;
搜索器里"有多少个 CellBit 形参"叫 cell_argc(r8veritas<cell_argc>)。这三个名字
在两边的仓库里是统一的:C/C++ 侧 cell_size、搜索器侧 cell_argc、.r8asm 程序里看到的
常量仍是 _CELL_SIZE(那是源语言的常量,属于宏库的公开词汇,不要跟着改)。
两个默认值集中在 include/r8forge/geometry.hh,现在是 11 位 / 259 格:
inline constexpr size_t kDefaultCellSize = 11;
inline constexpr size_t kDefaultMemoryCells = 259;
inline constexpr uint32_t kDefaultCellMask = (1u << kDefaultCellSize) - 1u;
位宽和长度都不在指令集里(ROR 只是在一个 cell 里转圈,纸带是环),所以它们只以
"参数 + 常量"的形式存在,落在三处。改位宽时照这个清单走:
- 汇编器:
import_file(path, cell_size)的第二个参数就是位宽,6 个调用点都传kDefaultCellSize。set_cell_size顺手把三个名字注入程序作用域:_CELL_SIZE(位宽)、_CELL_MAX = (1 << 位宽) - 1、_ROL_STEP = 位宽 - 1。 宏里写%rep _CELL_SIZE { … }就自动跟着位宽走(erase、rol、所有字节级驱动都这么写), 所以位级宏、%synth切片、位运算天然与位宽无关 —— 实测r8forge_synth_test在 11 位下照样 8/8 全过。 - 四份虚拟机(
tests/synth_test.cc、tests/byte_op_test.cc、src/derive.cc、tests/tape_run.cc):cell 存uint16_t、数组长kDefaultMemoryCells、 旋转必须是(v >> 1) | ((v & 1) << (kDefaultCellSize - 1))、输入输出掩码用kDefaultCellMask。四份要一起改,少改一份就会出现"两个实现不一致"的假象。 - 测试期望:一律用
kCellMask/kCellSize写,不要出现0xff、>> 8、256 - a。 注意 2048 % 256 == 0,所以不少 8 位期望在 11 位下碰巧还成立(and/or/xor/not/dec/sub 就是),别把"没报错"当成"不用改" ——neg、add、inc、mul一改位宽当场就错。
踩过的坑:
.xor的常数按当前位宽解释。asm/test.r8asm原来写.xor (~126)+1想置 130, 11 位下变成2048-126 = 1922;改成直接写.xor 130。- 纸带会变长:
%rep _CELL_SIZE从 8 轮变 11 轮,raw_add1647 → 2199 字符,fibonacci8761 → 11959。写死的长度断言要跟着改。 output打印整个 cell 的值,不再是一个字节;out里出现 257、1088 这种数是对的 (127+130 = 257、200*200 = 19*2048 + 1088)。- 交叉验证要先对齐几何:几何一致时同一条纸带输出完全相同(
asm/test.r8asm两边都是1322 1786 1600 5 94 127);不一致时不是谁错了,是两台不同的机器。workspace 里的ROT-8-viz/是 upstreamstarcells/ROT-8的 fork(origin=dsh/ROT-8-viz,main), 默认 11 位 x 259 格,几何还能运行期改(--cell/--mem;默认值与字段在include/rot8/rot8.h,名字就是cell_size/mem_size)。对答案的办法:ROT-8-viz/build/Release/rot8_test.exe <tape.rot8>把每个OUT按行打出来, 和r8forge_derive <src.r8asm> -1的out逐位比即可。 - 位宽变大还有个正面效果:
fibonacci不再在 256 处回绕,现在跑出 13 项(到 233)。 - 旧 tape 换到新位宽上不只是算错,还可能永远跑不完:按 8 位写死的程序里
%rep 8只转了 8 圈,在 11 位下 cell 没转回原位,"循环到某位清零"的条件于是永远不成立。 实测把改默认值之前的test.r8asm纸带喂给 11 位的rot8_test --dump,它会一直跑 (ROT-8-viz 的普通/--dump模式没有步数上限)。换位宽就重新汇编,别复用旧纸带。
字节级运算(一个 cell 一个机器字,默认 11 位)
结论:库里的字节级宏是对的,穷举全过。r8forge_byte_op_test 实测(1.5 秒)。
下面的纸带长度都是 11 位 cell 下的值(8 位时代的数字见 git 历史):
| 宏 | 驱动 | 纸带 | 结果 |
|---|---|---|---|
raw_add(a+b,含进位) |
drv/raw_add_byte.r8asm |
2199 字符 | 65536/65536 |
raw_and |
drv/raw_and_byte.r8asm |
870 字符 | 65536/65536 |
raw_or |
drv/raw_or_byte.r8asm |
782 字符 | 65536/65536 |
raw_xor |
drv/raw_xor_byte.r8asm |
628 字符 | 65536/65536 |
raw_inc(a+进位) |
drv/raw_inc_byte.r8asm |
1619 字符 | 512/512 |
clb_add_nc(a+b+进位,4 cell) |
drv/raw_add_nc_byte.r8asm |
937 字符 | 65536/65536 |
clb_inc_nc(a+进位,3 cell) |
drv/raw_inc_nc_byte.r8asm |
586 字符 | 256/256 |
clb_neg_nc(~a+进位,3 cell) |
drv/raw_neg_nc_byte.r8asm |
610 字符 | 256/256(取负) |
| 同上,进位 0 | drv/raw_not_nc_byte.r8asm |
609 字符 | 256/256(反码 ~a) |
clb_sub_nc(a-b,4 cell) |
drv/raw_sub_nc_byte.r8asm |
962 字符 | 65536/65536 |
clb_not_ip(~a,原地,1 cell) |
drv/not_ip_byte.r8asm |
23 字符 | 256/256 |
clb_inc_ip(a+1,原地,2 cell) |
drv/inc_ip_byte.r8asm |
89 字符 | 256/256 |
clb_neg_ip(-a,原地,2 cell) |
drv/neg_ip_byte.r8asm |
111 字符 | 256/256 |
clb_dec_ip(a-1,原地,2 cell) |
drv/dec_ip_byte.r8asm |
133 字符 | 256/256 |
clb_nonzero(a!=0 的标志,原地) |
drv/nonzero_byte.r8asm |
284 字符 | 256/256 |
clb_add_ip(a+=b,原地,4 cell) |
drv/add_ip_byte.r8asm |
726 字符 | 2048 抽样全过(O(b) 运行) |
clb_mul(mc×mul → 两 cell 积,10 cell) |
drv/mul_byte.r8asm |
3977 字符 | 65536/65536(O(位宽) 运行) |
asm/fibonacci.r8asm |
— | 11959 字符 | 跑出 13 项 1 1 2 3 5 8 13 21 34 55 89 144 233 |
raw_* 保留操作数(A、B 原样还回来),clb_*_nc 把 A、B 吃干净 —— 所以后者能省掉
Co 和 tmp:4 cell 加法/减法、3 cell 自增/取负。两者都用轮转驱动,差别只在
"操作数要不要还回去"。
clb_*_nc 的进位 cell 是真正的进位输入:宏自己不动它的初值(曾经写错过 ——
加法里 set_0、自增里 set_1,那就不是输入了,而且把多字节串接堵死了)。
调用者给 0 就是普通运算,给 1 就是"自带 +1"的那种,或者把上一字节的进位输出接过来串。
补码
-A = ~A + 1、A - B = A + ~B + 1,所以取负/减法都是"取反 + 加法/自增",
那个 +1 由调用者通过进位输入给:
| 宏 | 做法 | Ci=1 | Ci=0 |
|---|---|---|---|
clb_neg_nc A S Ci |
先 clb_not_ip A 把整个字节原地取反,再走 clb_inc_nc |
-A(补码取负) |
~A(反码) |
clb_sub_nc A B S Ci |
先 clb_not_ip B 把整个字节原地取反,再走 clb_add_nc |
A - B |
A - B - 1 |
取调整字节一次、提到循环外面,比"每 bit 取反一次"更短(也少两个 flb 包装):
8 位时代是 468 → 448、467 → 447、725 → 707;11 位下的实测值见上表(610 / 609 / 962)。
B 本来就会被加法吃掉,所以在原地取反它没有任何代价。
clb_sub_nc 的进位输出是没有借位(A >= B 时为 1),所以它顺带就是无符号比较;
clb_neg_nc 的进位输出只在 A 原本是 0 时为 1(-0 = 0 但确实进了位)。
取反必须发生在切片外面:想让 %synth 自己取反(表 S=~A^Ci、进位 ~A&Ci,3 参数)
报 no program up to 8 layers。原因是模型只会"牺牲一个 cell → 条件翻转别的 cell",
A=0 时整块跳过、S 只能留在 0,而取反要求 A=0 时 S=1 —— "无条件翻转"表达不出来。
原地(结果回到原来的 cell)
| 宏 | 干什么 | cell | 纸带(11 位) | 穷举 |
|---|---|---|---|---|
clb_not_ip A |
A = ~A(反码) |
1 | 23 | 256/256 |
clb_inc_ip A T |
A = A + 1 |
2 | 89 | 256/256 |
clb_neg_ip A T |
A = -A(补码取负) |
2 | 111 | 256/256 |
clb_dec_ip A T |
A = A - 1 |
2 | 133 | 256/256 |
clb_nonzero B F T |
F = (B != 0),B 不动 |
3 | 284 | 256/256 |
clb_add_ip A B T F |
A += B,B 被吃掉 |
4 | 726 | 2048 抽样 |
对比写回 S 的切片版:clb_inc_nc 586(3 cell)、clb_neg_nc 610(3 cell)——
原地版短 5 倍、少一个 cell。clb_neg_ip 就是 clb_not_ip + clb_inc_ip。
"原地补码不可能"这个结论是错的,这里记一下它是怎么错的(别再复现同样的推理):
%synth的四个原地表(A←~A^Ci、A←A^Ci、A←A^B^Ci、A←A^~B^Ci)确实全部报no program up to 8 layers,原因是一个合成块只有一个条件 cell,区分不了 "A=1 且 Ci=0" 和 "A=1 且 Ci=1"。这一步是实测,没问题。- 错在把它当成了整条路的结论。手写不一定要照逐位进位链写。
真正可行的算法换个思路,不去逐位测进位:
- 用
[ ... ]的自然语义(最低位非零就继续)把最低位连续的 1 清掉(flb+ror), 遇到第一个 0 时退出循环; - 那个 0 翻成 1 —— 输入是全 1(0xFF)时跳过,正好就是回绕那一格;
- 剩下的位置只旋转,转满八格为止。
卡点变成"还要转几格",而 cell 只有两个。解法是把计数塞进 T 的位里:T 先做成 0xFF,
每转一格就 set_0 + ror 消掉一个 1 —— 一串 1 的长度就是剩余圈数(每步 3 字符的移位寄存器
计数器,一圈正好数八格)。于是两个 cell 够用,而且比切片版短得多。
顺带纠正另一半:[ ... ] 的"跑了就必然消耗被测位"不是死路 —— 只要被测的是计数器,
不是数据。这条以前被写成"手写也做不到(2 cell)",错的。
原地取反仍然是最便宜的一个:%rep _CELL_SIZE { flb; ror },一个 cell、23 字符。
自减用补码恒等式拼出来,不用新算法:B - 1 = ~(-B),所以 clb_dec_ip = clb_neg_ip + clb_not_ip(133 字符)。
原地加法,以及"只有纸带长度是目标"这条
clb_add_ip A B T F:A += B,原地,4 个 cell(A、B、T、F),726 字符,
B 被吃干净。对比:raw_add 2199(6 cell,保留操作数)、clb_add_nc 937 + 每轮一次 copy。
没有去写逐位的进位链加法:全加器的进位是 maj(a,b,c),也就是两两的合取,而每个条件测试
都会吃掉被测的那一位,所以要么先拷贝好几份位、要么嵌套测试 —— 又长又脆。
改成利用一件在本仓库里成立的事:只有纸带长度是目标,运行步数不是。
while B != 0: A += 1 ; B -= 1
循环体在纸带里只出现一次,所以长度和 B 的大小无关;代价是运行 O(B)(B=255 时约 30 万步,
r8forge 的上限是 500 万)。这个取舍在别处也能用 —— 凡是"长度优先"的地方都可以想
"能不能用循环把代码压掉"。
剩下的难点是"B != 0"怎么测(biz 只测最低位)。clb_nonzero B F T 的做法:每位先把它
搬进工作位 T(这一步清掉 B 的那一位),若 T 是 1 就把 F 置一并还原 B 的那一位,
转一格看下一位;八轮后 B 原样、F = (B != 0)。注意是 set_1 不是 flb —— 这里踩过:
flb 是翻转,偶数个 1 位会把标志翻回 0(3、5、255 都测错过)。
乘法器(asm/mul.r8asm)
clb_mul MC MUL PL PH MCA S Ci T F NR:(PH:PL) = MC * MUL,10 个 cell,3977 字符,
r8forge_byte_op_test 现在穷举 65536 组(0..255 × 0..255)全对,最坏运行 26123 步
(2047 * 2047,11 位下的整个域)。
用的是二进制移位-加法(竖式乘法),一位一位串:
A:PH = 0 ; C:F = 0 ; Q:PL = MUL
repeat _CELL_SIZE:
if Q & 1: (C:PH) += MC ; 一次 W 位加法,进位出到 F
(C:PH:PL) >>= 1 ; 跨格右移,最高位补 0,最低位(刚看的那位)丢掉
W 轮之后 (PH:PL) 就是积;PL(原来的 Q)被移空,所以 MUL 结束为 0,和原来的约定一样。
为什么换掉重复加法:重复加法的轮数 = MUL 的值,成本 ∝ MUL。MUL = 2047 时实测直接
HANG after 5000000 steps——也就是大乘数根本算不完。移位-加法的轮数 = 位宽,跟操作数的
值无关,11 位下封顶 26123 步:
| 算式 | 重复加法(旧) | 移位-加法(现在) |
|---|---|---|
82 * 141(MC=82, MUL=141) |
358586 步 | 8374 步 |
82 * 141(MC=141, MUL=82) |
214741 步 | 6974 步 |
255 * 255 |
733428 步 | 17785 步 |
100 * 403 |
1026648 步 | 10208 步 |
2047 * 2047 |
HANG(>500 万步) | 26123 步 |
2047 * 0 |
270 步 | 1863 步 |
纸带同时短了:5007 → 3977 字符。代价只有一条:乘数是 0/1 这种小值时反而慢一点点
(旧版循环 0/1 次就完了,新版固定要转满 _CELL_SIZE 轮)——拿它换「乘数再大也不会挂」。
所以 asm/test.r8asm 里那条"永远把小操作数放 MUL"的规矩已经没用了(保留 141 只是
为了跟历史结果对得上)。
拼法上踩过两个坑:
- 跨格移位:
(C:PH:PL) >>= 1得当成一个 2W+1 位的寄存器来移。做法是三格先各ror一格,把要注入的那一位搬到 bit0(rol回来),用clb_bit_mov搬过去,再ror回去。 顺序必须是低位那对先搬(PH→PL 先做),否则 PH 的 bit0 已经被 F 覆盖了。 biz/rnz是循环对,不是 if/else:条件块的身体必须把被测位吃掉(最后一条flb), 否则rnz看到还是 1 就跳回去 —— 第一版就是这么写成死循环的(现象:out一个都没有、 计数器停在 0x7ff 没动)。被测的正好是PL的最低位,而它本来就要被右移丢掉,吃掉它 不影响移位。set_0/clb_bit_mov身体里那个flb是同一个道理。
轮数用什么数:计数器 NR 先做成 _CELL_SIZE 个 1(%rep _CELL_SIZE { set_1; ror }),
每轮 set_0 + ror 吃掉一个 —— 和 clb_inc_ip 数圈数是同一个法子。一串 1 的长度就是
剩余轮数,所以"做几轮"不占纸带长度,只占运行时间。
设计上的教训(这一版):上一轮把"移位-加法"否掉了,理由是「只有纸带长度是目标」——
可那只说明当时的取舍,而且结论其实反了:移位-加法不但更短(3977 < 5007),
步数还少一到两个数量级。真正的原因不是它更长,而是把"跨格移位 + 条件累加"想复杂了 ——
rol/ror 加一条 clb_bit_mov 就能拼,三行的事。
先看目标函数再选算法这条本身没错,但目标函数里得把「500 万步上限」写进去:
长度优先的循环写法(clb_add_ip、旧的 clb_mul)在纸带上不吃亏,运行时间上会随值线性长大。
顺带纠正一个流传下来的说法:raw_add 不吃掉操作数。实测 5+3 → A=5 B=3 S=8,
255+255 → A=255 B=255 S=254 Co=1。asm/fibonacci.r8asm 里"每圈都要重新复印"的注释
是过度保守(它确实复印了,但不复印也对)。
这次差点被写进文档的错误诊断(别再犯)
有一轮里,raw_add / raw_and / copy / fibonacci 全被判定"运行时是坏的",
理由是 set_0 对多字节 cell 不收敛、纸带跑到步数上限。那是虚拟机写错了:
仓库里有三份解释器(tests/synth_test.cc、src/derive.cc、tests/tape_run.cc)
把 biz/rnz 实现成了"整格是否为零"(Brainfuck 直觉),于是每个字节级程序
都变成死循环。改回 & 1 之后全部通过。
为什么之前没被发现:位级程序在两种语义下行为完全一样(0/1 的最低位就是它自己),
%synth 的表、asm/test.r8asm、full_add 全都不受影响;只有字节级驱动能区分。
所以以后凡是"字节级看起来跑不动",第一个怀疑对象是虚拟机,不是库。
验证方法:拿 ROT-8-viz/build/rot8_test.exe 跑同一条纸带对答案。
tests/tape_run.cc 现在是正确语义(& 1),可以直接对。
另一位一 cell 的实现在这里被删过一次(别再加回来)
"每个 bit 一个 cell、用 clb_bit_add_nc 串成 8 位加法器"这条路能跑通(32 cell,
1308 字符,65536 组合全对),但它是上面那个错误诊断的产物:既然一个 cell 能放一个字节、
位读得出来,就没必要为每个 bit 花一个 cell。R8Forge 之前也删过一次同样的东西
(交接文档原话:"8 位加法 25 个 cell,没有实用价值")。
要拼字节级运算就用 raw_* / clb_*_nc / clb_*_ip。
%synth 相关
- 语法:
params N+mode tape|layers+metric chars|flat|blocks+layout ...(可选)- 目标表
stat ...或map ...。stat的项数必须是2^params(3 参数要 8 项)。 参数是输入位%1..%K、输出位、剩余草稿位(草稿位必须结束为 0,语义见compress_stat_space)。
- 目标表
metric flat:不计.tp行走代价 → 结果与 cell 布局无关、缓存可跨调用点复用。metric chars才是按实际布局最优。库里的块统一用flat。- 缓存:
.r8forge_cache/(已入库,克隆下来直接命中)。键 = 模型版本 + params + mode + metric + 解析后的整张目标表(+ layout,仅 chars)。改指令模型时要 bumpkModelVersion(src/synth.cc)。 - 缓存代价参考:
bit_raw_add的 flat 搜索 990,636,137 状态 / 680 秒 / ~22 GB 内存。 层数上限现在是 8(原来是 5,5 会把一些可行的表误判成不可能)。
已经验证可行的东西
| 东西 | 结论 |
|---|---|
| 库里的 7 个位运算块(and/or/xor/inc/add) | 合成版比手写短(8 位时代 1714 → 1666;位宽改了以后位级块不受影响,长度变的是字节级那层) |
asm/test.r8asm 现在是一个 hash |
11 位下 28729 字符,h = (h + c) * 141 mod 2048 滚过 "R8F",跑出 1322 1786 1600 5 94 127(前三 = 三轮的 h,后三 = 三轮的 PH,即 (h+c)*141 >> 11)。只用 clb_add_nc + clb_mul,没有位运算 —— "会加减乘就能算 hash"的最小证明。derive 与 ROT-8-viz 两边逐位一致,57330 步(乘法器换成移位-加法之后,原来约 207 万步) |
clb_bit_add_nc(4 cell 忽略进位切片) |
flat 代价 27,完整全加器切片是 38;8/8 组合正确(与位宽无关) |
clb_bit_inc_nc(3 cell 自增切片) |
表 0 4 4 2 0 4 4 2(3 参数)缓存里就有,4 blocks;4/4 组合正确(与位宽无关) |
clb_add_nc(4 cell 加法) |
11 位下 937 字符,65536 组合全对;比 6 cell 的 raw_add 少 2 个 cell |
clb_inc_nc(3 cell 自增/加 0-1) |
586 字符,256 组合全对;比 5 cell 的 raw_inc 少 2 个 cell |
clb_neg_nc(3 cell 取负/取反) |
610 / 609 字符,各 256 组合全对(Ci=1 取负、Ci=0 反码) |
clb_sub_nc(4 cell 减法) |
962 字符,65536 组合全对;进位输出顺带是无符号比较(A >= B) |
clb_not_ip(1 cell 原地取反) |
23 字符,256 组合全对 |
clb_inc_ip(2 cell 原地自增) |
89 字符,256 组合全对;切片版 clb_inc_nc 是 586 |
clb_neg_ip(2 cell 原地取负) |
111 字符,256 组合全对;切片版 clb_neg_nc 是 610 |
clb_dec_ip(2 cell 原地自减) |
133 字符 = neg + not(B-1 = ~(-B)),256 全对 |
clb_nonzero(非零标志) |
284 字符,256 全对,B 保持原样 |
clb_add_ip(4 cell 原地加) |
726 字符,2048 抽样全对;raw_add 2199 |
clb_mul(10 cell 乘法,积占两个 cell) |
3977 字符,65536 组穷举全对;轮数只跟位宽有关(最坏 26123 步),跟 MUL 的值无关 |
bit_raw_add(6 cell 全加器切片) |
保留 A、B;字节级 raw_add 2199 字符,65536 组合全对 |
raw_and / raw_or / raw_xor / raw_inc |
870 / 782 / 628 / 1619 字符,各 65536(inc 512)全对 |
asm/fibonacci.r8asm |
11959 字符,跑出 13 项(… 89 144 233),比 8 位时代多 3 项 |
已经确认走不通的(别重试)
- 3 个 cell 做加法切片:层数上限 5 和 8 都报
no program up to N layers(3 cell 的自增/取负切片是有解的,两个操作数塞不进 3 个 cell)。 - 原地写回的
%synth表:A←~A^Ci、A←A^Ci、A←A^B^Ci、A←A^~B^Ci四个表全部报no program up to 8 layers。原因是一个合成块只有一个条件 cell,区分不了 "A=1 且 Ci=0" 和 "A=1 且 Ci=1"。但手写可以:换成"清连续 1 + 计数器旋转"的算法,2 cell 就够 (clb_inc_ip89 字符、clb_neg_ip111 字符,见「原地」)。别把这条读成"手写也不行"。 - 让切片自己在输入上取反(表
S=~A^Ci、进位~A&Ci,3 参数):no program up to 8 layers。 模型只会"牺牲一个 cell → 条件翻转别的 cell",输入为 0 时整块被跳过、S 只能保持 0, 表达不出"无条件翻转"。取反只能放在切片外面(一条flb)。 - 4 cell 的加法切片要做到"保留 A、B":表改成保留 A、B 后报
no program up to 8 layers。 想拿回操作数只能用 6 cell 的bit_raw_add。 但这不等于"轮转需要保留操作数" —— 这句以前写错过。轮转只是 "读走最低位 → 丢掉 →ror",吃掉操作数完全没问题:clb_add_nc(4 cell)就是这么跑的, 65536 组合全过。 - 字节级(2^16 项真值表)交给
%synth:搜索空间不可行。
命名与注释格式(照 SPEC.md,别自己发明)
规格分两份:
- 本仓库的
SPEC.md:%synth指令、机器几何、asm/里每个宏的契约 (签名 / 参数类型 / 吃什么留什么 / cell 数 / 纸带长度 / 由哪个测试验证)、 纸带长度的测量口径。加宏、改宏、写文档之前先看它。 - 上游语言规格:
C:\Users\peng0\git\r8asm_rev-fork\SPEC.md(r8asm_rev里那份一模一样)。 语言、内建指令、运算符优先级、作用域、标准宏前缀都在里面。%synth不在里面 —— 那是 R8Forge 自己的扩展,看本仓库的SPEC.md。 - ROT-8 指令集规格:
C:\Users\peng0\git\ROT-8-viz\README.md("1-Bit Brainfuck 变体", 指令表里写明BIZ/RNZ判 LSB)。
SPEC 第 136-150 行的标准宏前缀:
| 前缀 | 全称 | 含义 |
|---|---|---|
clb |
clobber | 破坏性宏,会破坏原始输入(多数情况是清零) |
bit |
bit | 对 cell 的 LSB 操作的宏 |
raw |
raw | 未经封装的宏,通常要手动传入 tmp cell 作为实参 |
raw 不是"暴露 cell 作为参数"(这条以前写错过):raw_add 之所以叫 raw,
是因为它要你自己给 Co 和 tmp 那两个草稿 cell。bit 则说明所有 CellBit 形参
指的都是最低位 —— 这跟 biz/rnz 判 & 1 是同一件事:整套语言是围绕"1 位"设计的。
既有宏对号入座:
| 宏 | 为什么这么叫 |
|---|---|
raw_add / raw_and / raw_or / raw_xor / raw_inc |
字节级,且草稿 cell 由调用者传 |
bit_raw_add(6 cell) |
位级,且 %6: buf 是真正的草稿:内容无关,结束是垃圾 |
clb_bit_add_nc(4 cell) |
四个 cell 都有意义,没有草稿 cell(所以没 raw),而 A、B 被吃掉(所以有 clb):第 3 个是"进→出"的进位,A=0 B=0 进位入=1 时 S=1 |
clb_bit_inc_nc(3 cell) |
同样:A 被吃掉,进位进→出,没有草稿 cell |
clb_add_nc(4 cell)/ clb_inc_nc(3 cell) |
字节级版本,同样吃 A、B |
clb_neg_nc(3 cell)/ clb_sub_nc(4 cell) |
补码取负/减法,同样吃 A(和 B) |
clb_not_ip / clb_inc_ip / clb_neg_ip / clb_dec_ip / clb_add_ip |
同上再加 _ip(in place):结果回到原来的 cell,草稿 cell 由调用者传 |
clb_nonzero |
破坏性的纯计算(把 B 抄成"非零"标志),不带 _ip 后缀 |
clb_bit_mov |
位级搬运,并且把源吃掉 |
bit_copy / copy |
位级/字节级拷贝,缓冲由调用者传(历史命名,少了 raw) |
set_0 / set_1 / erase / rol / step / back / output |
基础操作,不带前缀 |
%synth 块名 = <宏名>_synth,包装的 %macro 用不带 _synth 的名字。
后缀不是前缀:_nc 是手写库留下的历史命名,_ip 是本仓库加的(in place,结果写回原来的
cell)。选名字时先按 SPEC 的三个前缀定位,再挑后缀。
宏里的注释:
; Macro clb_bit_add_nc
; %1: CellBit A
; %2: CellBit B
%this表示"dp 当前所指的 cell"(set_0、clb_bit_mov都这么写)。- 新宏先按上表选前缀。套不上的(块级、自己管草稿 cell 的)就在注释里写清吃什么、留下什么。
- 参数类型只用这五个:
Cell、CellBit、Unit、UnitBit、Count(纯数字,比如step的重复次数)。注释块贴在%macro上方,或者贴在生成它的%synth块上方,都行。 r8forge_macro_docs_test会检查asm/里每个%macro:有没有注释块、; Macro <名字>和实际宏名是否一致、参数条数是否等于 argc、类型是否在上面这五个里。 加完新宏跑一下,别让它的输出从全绿变红。