diff --git a/AGENTS.md b/AGENTS.md index 0503002..7678a48 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -59,7 +59,7 @@ r8forge asm/test.r8asm # 应 exit 0,1666 字符,7 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 # 字节级库:12 个操作穷举,0.8 秒 +r8forge_byte_op_test # 字节级库:16 个操作穷举/抽样,1.5 秒 r8forge_macro_docs_test # asm/ 里每个宏的注释格式 ``` @@ -115,7 +115,7 @@ void rot8_rnz(rot8_iter *iter) { if ((*(iter->mem_now) & 1) == 1) { ... } } ## 字节级运算(一个 cell 一个字节) -结论:**库里的字节级宏是对的,穷举全过**。`r8forge_byte_op_test` 实测(0.7 秒): +结论:**库里的字节级宏是对的,穷举全过**。`r8forge_byte_op_test` 实测(1.5 秒): | 宏 | 驱动 | 纸带 | 结果 | |---|---|---|---| @@ -132,6 +132,9 @@ void rot8_rnz(rot8_iter *iter) { if ((*(iter->mem_now) & 1) == 1) { ... } } | **`clb_not_ip`(~a,原地,1 cell)** | `drv/not_ip_byte.r8asm` | **17 字符** | **256/256** | | **`clb_inc_ip`(a+1,原地,2 cell)** | `drv/inc_ip_byte.r8asm` | **74 字符** | **256/256** | | **`clb_neg_ip`(-a,原地,2 cell)** | `drv/neg_ip_byte.r8asm` | **90 字符** | **256/256** | +| **`clb_dec_ip`(a-1,原地,2 cell)** | `drv/dec_ip_byte.r8asm` | **106 字符** | **256/256** | +| **`clb_nonzero`(a!=0 的标志,原地)** | `drv/nonzero_byte.r8asm` | **209 字符** | **256/256** | +| **`clb_add_ip`(a+=b,原地,4 cell)** | `drv/add_ip_byte.r8asm` | **558 字符** | **2048 抽样全过**(O(b) 运行) | | `asm/fibonacci.r8asm` | — | 8761 字符 | 跑出 `1 1 2 3 5 8 13 21 34 55`,和文件注释一致 | `raw_*` 保留操作数(A、B 原样还回来),`clb_*_nc` 把 A、B 吃干净 —— 所以后者能省掉 @@ -170,6 +173,9 @@ A=0 时整块跳过、S 只能留在 0,而取反要求 A=0 时 S=1 —— "无 | `clb_not_ip A` | `A = ~A`(反码) | 1 | **17** | 256/256 | | `clb_inc_ip A T` | `A = A + 1` | 2 | **74** | 256/256 | | `clb_neg_ip A T` | `A = -A`(补码取负) | 2 | **90** | 256/256 | +| `clb_dec_ip A T` | `A = A - 1` | 2 | **106** | 256/256 | +| `clb_nonzero B F T` | `F = (B != 0)`,B 不动 | 3 | **209** | 256/256 | +| `clb_add_ip A B T F` | `A += B`,B 被吃掉 | 4 | **558** | 2048 抽样 | 对比写回 S 的切片版:`clb_inc_nc` 430(3 cell)、`clb_neg_nc` 448(3 cell)—— **原地版短 5 倍、少一个 cell**。`clb_neg_ip` 就是 `clb_not_ip` + `clb_inc_ip`。 @@ -196,6 +202,28 @@ A=0 时整块跳过、S 只能留在 0,而取反要求 A=0 时 S=1 —— "无 不是数据。这条以前被写成"手写也做不到(2 cell)",错的。 原地取反仍然是最便宜的一个:`%rep _CELL_SIZE { flb; ror }`,一个 cell、17 字符。 +自减用补码恒等式拼出来,不用新算法:`B - 1 = ~(-B)`,所以 `clb_dec_ip` = `clb_neg_ip` + `clb_not_ip`(106 字符)。 + +### 原地加法,以及"只有纸带长度是目标"这条 + +`clb_add_ip A B T F`:`A += B`,原地,4 个 cell(A、B、T、F),**558 字符**, +B 被吃干净。对比:`raw_add` 1647(6 cell,保留操作数)、`clb_add_nc` 688 + 每轮 `copy` 364。 + +**没有去写逐位的进位链加法**:全加器的进位是 `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 都测错过)。 顺带纠正一个流传下来的说法:`raw_add` **不**吃掉操作数。实测 `5+3 → A=5 B=3 S=8`, `255+255 → A=255 B=255 S=254 Co=1`。`asm/fibonacci.r8asm` 里"每圈都要重新复印"的注释 @@ -251,6 +279,9 @@ A=0 时整块跳过、S 只能留在 0,而取反要求 A=0 时 S=1 —— "无 | `clb_not_ip`(1 cell 原地取反) | **17 字符**,256 组合全对;比走切片那条路快 26 倍 | | `clb_inc_ip`(2 cell 原地自增) | **74 字符**,256 组合全对;切片版 `clb_inc_nc` 是 430 | | `clb_neg_ip`(2 cell 原地取负) | **90 字符**,256 组合全对;切片版 `clb_neg_nc` 是 448 | +| `clb_dec_ip`(2 cell 原地自减) | **106 字符** = `neg` + `not`(`B-1 = ~(-B)`),256 全对 | +| `clb_nonzero`(非零标志) | **209 字符**,256 全对,B 保持原样 | +| `clb_add_ip`(4 cell 原地加) | **558 字符**,2048 抽样全对;`raw_add` 1647 / `clb_add_nc`+copy 1052 | | `bit_raw_add`(6 cell 全加器切片) | 保留 A、B;字节级 `raw_add` 1647 字符,65536 组合全对 | | `raw_and` / `raw_or` / `raw_xor` / `raw_inc` | 639 / 575 / 463 / 1214 字符,各 65536(inc 512)全对 | | `asm/fibonacci.r8asm` | 8761 字符,跑出 10 项斐波那契,和注释一致 | @@ -305,7 +336,8 @@ SPEC 第 136-150 行的标准宏前缀: | `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` | 同上再加 `_ip`(in place):结果回到原来的 cell,只借一个草稿 cell | +| `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` | 基础操作,不带前缀 | diff --git a/README.md b/README.md index 4046505..a00fc89 100644 --- a/README.md +++ b/README.md @@ -241,6 +241,9 @@ byte level library ok | `clb_not_ip A` | `A = ~A`(反码,**原地**,不占额外 cell) | 1 | **17** | | `clb_inc_ip A T` | `A = A + 1`(**原地**,T 是草稿) | 2 | **74** | | `clb_neg_ip A T` | `A = -A`(**原地**补码取负) | 2 | **90** | +| `clb_dec_ip A T` | `A = A - 1`(**原地**;`B-1 = ~(-B)`) | 2 | **106** | +| `clb_nonzero B F T` | `F = (B != 0)`,B 不动 | 3 | **209** | +| `clb_add_ip A B T F` | `A += B`(**原地**,B 被吃掉) | 4 | **558** | **进位 cell 是真正的进位输入**:宏不动它的初值,由调用者给。所以可以串 —— 上一字节的 进位输出直接接到下一字节的进位输入,多字节加法/减法/取负都能这么拼。 @@ -264,6 +267,20 @@ byte level library ok "还要转几格"用 **T 的位**计数:T 先做 0xFF,每转一格 `set_0` + `ror` 消掉一个 1, 一串 1 的长度就是剩余圈数。于是两个 cell 就够,而且没有"无条件翻转"那种表达不出的动作。 +### 原地加法:只算长度,不算步数 + +`clb_add_ip A B T F` 把 `A += B` 做在 4 个 cell 里,**558 字符**(`raw_add` 是 1647 / 6 cell)。 +没有逐位写进位链(全加器的进位是 `maj(a,b,c)`,两两的合取,而每次条件测试都会吃掉被测的 +那一位),而是利用了本仓库的一个取舍 —— **只有纸带长度是目标,运行步数不是**: + +``` +while B != 0: A += 1 ; B -= 1 +``` + +循环体在纸带里只出现一次,长度与 B 的大小无关;代价是运行 O(B)(B=255 时约 30 万步, +上限 500 万)。`clb_nonzero` 负责"B != 0"的判断(`biz` 只测最低位,得把八位都看一遍, +还不能把 B 吃掉)。 + `asm/fibonacci.r8asm` 也是这条路上的:8761 字符,跑出 `1 1 2 3 5 8 13 21 34 55`。 ### 一个坑:`biz`/`rnz` 看的是最低位 diff --git a/asm/add_ip.r8asm b/asm/add_ip.r8asm new file mode 100644 index 0000000..5e9f146 --- /dev/null +++ b/asm/add_ip.r8asm @@ -0,0 +1,81 @@ +%include "asm/dec_ip.r8asm" + +; 原地加法:A <- A + B,结果留在 A 里。 +; +; 没有去写"逐位的进位链"加法(那需要 maj(a,b,c),也就是两两的合取,而每个条件测试 +; 都会吃掉被测的那一位,所以要么先拷贝好几份位、要么嵌套测试,又长又脆)。 +; 这里利用一件在本仓库里成立的事:**只有纸带长度是目标,运行步数不是**。 +; 于是加法可以写成 +; +; while B != 0: A += 1 ; B -= 1 +; +; 循环体在纸带里只出现一次,长度和 B 的大小无关。代价是运行步数 O(B)(B=255 时约 30 万步, +; 上限 500 万,够用)。 +; +; 剩下的问题是"B != 0"怎么测 —— 只有 `biz` 测最低位,要测整格是否为零得把八位都看一遍, +; 而且看的时候不能把 B 吃掉。做法是每看一位: +; 1. 若该位是 1,把它搬到工作位 T(这一步会清掉 B 的这一位); +; 2. 若 T 是 1,就把它记进 F(累加,不清),并把 B 的那一位还原; +; 3. B 转一格,看下一位;八轮之后 B 回到原位、一位不少,F = (B != 0)。 +; 为什么"还原"要放在测试之后:`]` 只能落在最低位为 0 的格子上,所以测试那一步必须先把 +; 被测位清掉;还原放在块外面,靠 T 的值来决定要不要翻回来。 + +; Macro clb_nonzero +; %1: Cell B +; %2: Cell F +; %3: Cell T +; +; F = (B != 0),B 保持原样。T 结束时是 0。 +%macro clb_nonzero 3 +.anchor before_clb_nonzero + +.tp %2 +set_0 + +.tp %1 +%rep _CELL_SIZE + biz + .tp %3 + flb + .tp %1 + flb + rnz + .tp %3 + biz + .tp %2 + set_1 + .tp %1 + flb + .tp %3 + flb + .tp %3 + rnz + .tp %1 + ror +%endrep + +.tp before_clb_nonzero +%endmacro + +; Macro clb_add_ip +; %1: Cell A +; %2: Cell B +; %3: Cell T +; %4: Cell F +; +; A <- A + B(mod 256),原地;B 被吃干净(结束时为 0),T 和 F 结束都是 0。 +%macro clb_add_ip 4 +.anchor before_clb_add_ip + +clb_nonzero %2 %4 %3 + +.tp %4 +biz + clb_inc_ip %1 %3 + clb_dec_ip %2 %3 + clb_nonzero %2 %4 %3 + .tp %4 +rnz + +.tp before_clb_add_ip +%endmacro diff --git a/asm/dec_ip.r8asm b/asm/dec_ip.r8asm new file mode 100644 index 0000000..d7d2d83 --- /dev/null +++ b/asm/dec_ip.r8asm @@ -0,0 +1,21 @@ +%include "asm/inc_ip.r8asm" + +; 原地自减:A <- A - 1。 +; +; 没写新的位级算法,而是用补码的恒等式: +; B - 1 = ~(-B) +; 先原地取负(clb_neg_ip),再原地取反(clb_not_ip),两步都是原地、都只要一个草稿 cell。 + +; Macro clb_dec_ip +; %1: Cell A +; %2: Cell T +; +; A <- A - 1,原地。T 是草稿 cell,只要求原来是干净的。 +%macro clb_dec_ip 2 +.anchor before_clb_dec_ip + +clb_neg_ip %1 %2 +clb_not_ip %1 + +.tp before_clb_dec_ip +%endmacro diff --git a/drv/add_ip_byte.r8asm b/drv/add_ip_byte.r8asm new file mode 100644 index 0000000..6d3555e --- /dev/null +++ b/drv/add_ip_byte.r8asm @@ -0,0 +1,16 @@ +%include "asm/add_ip.r8asm" + +; clb_add_ip 的驱动:A 原地加 B,B 被吃干净。 +; +; r8forge_derive drv/add_ip_byte.r8asm -2 0=5 1=3 +; +; out 依次是 A、B。A 应是 8,B 应是 0。 +.var A 0 +.var B 1 +.var T 2 +.var F 3 + +clb_add_ip A B T F + +output A +output B diff --git a/drv/dec_ip_byte.r8asm b/drv/dec_ip_byte.r8asm new file mode 100644 index 0000000..d15c518 --- /dev/null +++ b/drv/dec_ip_byte.r8asm @@ -0,0 +1,13 @@ +%include "asm/dec_ip.r8asm" + +; clb_dec_ip 的驱动:A 原地减 1。 +; +; r8forge_derive drv/dec_ip_byte.r8asm -1 0=0 # 得 255 +; +; out 只有 A。 +.var A 0 +.var T 1 + +clb_dec_ip A T + +output A diff --git a/drv/nonzero_byte.r8asm b/drv/nonzero_byte.r8asm new file mode 100644 index 0000000..52a4530 --- /dev/null +++ b/drv/nonzero_byte.r8asm @@ -0,0 +1,15 @@ +%include "asm/add_ip.r8asm" + +; clb_nonzero 的驱动:F = (B != 0),B 应保持原样。 +; +; r8forge_derive drv/nonzero_byte.r8asm -2 0=5 +; +; out 依次是 B、F。B 应还是 5,F 应是 1。 +.var B 0 +.var F 1 +.var T 2 + +clb_nonzero B F T + +output B +output F diff --git a/tests/byte_op_test.cc b/tests/byte_op_test.cc index f90bcb0..12af2a8 100644 --- a/tests/byte_op_test.cc +++ b/tests/byte_op_test.cc @@ -384,6 +384,79 @@ int test_neg_ip(const std::string &file) { return bad; } +// clb_dec_ip: A = A - 1, in place. +int test_dec_ip(const std::string &file) { + const std::string tape = assemble(file); + std::cout << "clb_dec_ip: " << tape.size() << " characters\n"; + int bad = 0; + for (int a = 0; a < 256; a++) { + machine m; + m.cells[0] = uint8_t(a); + m.run(tape, 100'000); + const int want = (a - 1) & 0xff; + const bool ok = m.finished && m.out.size() == 1 && m.out[0] == want; + if (!ok) { + bad++; + if (bad <= 3) + report("clb_dec_ip", a, 0, m, std::to_string(want)); + } + } + std::cout << " " << (bad ? "FAILED" : "all 256 combinations ok") + << (bad ? " (" + std::to_string(bad) + " wrong)" : "") << "\n"; + return bad; +} + +// clb_nonzero: F = (B != 0), B untouched. +int test_nonzero(const std::string &file) { + const std::string tape = assemble(file); + std::cout << "clb_nonzero: " << tape.size() << " characters\n"; + int bad = 0; + for (int b = 0; b < 256; b++) { + machine m; + m.cells[0] = uint8_t(b); // B + m.run(tape, 100'000); + const bool ok = m.finished && m.out.size() == 2 && m.out[0] == b && + m.out[1] == (b != 0 ? 1 : 0); + if (!ok) { + bad++; + if (bad <= 3) + report("clb_nonzero", b, 0, m, + std::to_string(b) + " " + std::to_string(b != 0 ? 1 : 0)); + } + } + std::cout << " " << (bad ? "FAILED" : "all 256 combinations ok") + << (bad ? " (" + std::to_string(bad) + " wrong)" : "") << "\n"; + return bad; +} + +// clb_add_ip: A = A + B in place, B is eaten. The loop runs B times, so this +// one is sampled rather than exhaustive -- 256 addends x 8 accumulators. +int test_add_ip(const std::string &file) { + const std::string tape = assemble(file); + std::cout << "clb_add_ip: " << tape.size() << " characters (sampled)\n"; + const int accs[] = {0, 1, 5, 127, 128, 200, 254, 255}; + int bad = 0, n = 0; + for (int a : accs) + for (int b = 0; b < 256; b++) { + machine m; + m.cells[0] = uint8_t(a); // A + m.cells[1] = uint8_t(b); // B + m.run(tape, 5'000'000); + n++; + const int want = (a + b) & 0xff; + const bool ok = m.finished && m.out.size() == 2 && m.out[0] == want && + m.out[1] == 0; + if (!ok) { + bad++; + if (bad <= 3) + report("clb_add_ip", a, b, m, std::to_string(want) + " 0"); + } + } + std::cout << " " << (bad ? "FAILED" : "all " + std::to_string(n) + " sampled combinations ok") + << (bad ? " (" + std::to_string(bad) + " wrong)" : "") << "\n"; + return bad; +} + } // namespace int main(int argc, char **argv) { @@ -401,6 +474,9 @@ int main(int argc, char **argv) { test_not_ip(drv + "not_ip_byte.r8asm") + test_inc_ip(drv + "inc_ip_byte.r8asm") + test_neg_ip(drv + "neg_ip_byte.r8asm") + + test_dec_ip(drv + "dec_ip_byte.r8asm") + + test_nonzero(drv + "nonzero_byte.r8asm") + + test_add_ip(drv + "add_ip_byte.r8asm") + test_sub_nc(drv + "raw_sub_nc_byte.r8asm"); std::cout << (bad ? "FAILED\n" : "byte level library ok\n"); return bad ? 1 : 0;