diff --git a/AGENTS.md b/AGENTS.md index 5c42c31..628d11b 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 # 字节级库:65536×4 + 512 全过,0.5 秒 +r8forge_byte_op_test # 字节级库:9 个操作穷举,0.7 秒 r8forge_macro_docs_test # asm/ 里每个宏的注释格式 ``` @@ -109,7 +109,7 @@ void rot8_rnz(rot8_iter *iter) { if ((*(iter->mem_now) & 1) == 1) { ... } } ## 字节级运算(一个 cell 一个字节) -结论:**库里的字节级宏是对的,穷举全过**。`r8forge_byte_op_test` 实测(0.5 秒): +结论:**库里的字节级宏是对的,穷举全过**。`r8forge_byte_op_test` 实测(0.7 秒): | 宏 | 驱动 | 纸带 | 结果 | |---|---|---|---| @@ -118,26 +118,33 @@ void rot8_rnz(rot8_iter *iter) { if ((*(iter->mem_now) & 1) == 1) { ... } } | `raw_or` | `drv/raw_or_byte.r8asm` | 575 字符 | **65536/65536** | | `raw_xor` | `drv/raw_xor_byte.r8asm` | 463 字符 | **65536/65536** | | `raw_inc`(a+进位) | `drv/raw_inc_byte.r8asm` | 1214 字符 | **512/512** | -| **`clb_add_nc`(a+b,4 cell)** | `drv/raw_add_nc_byte.r8asm` | **693 字符** | **65536/65536** | -| **`clb_inc_nc`(a+1,3 cell)** | `drv/raw_inc_nc_byte.r8asm` | **433 字符** | **256/256** | -| **`clb_neg_nc`(-a,补码,3 cell)** | `drv/raw_neg_nc_byte.r8asm` | **471 字符** | **256/256** | -| **`clb_sub_nc`(a-b,4 cell)** | `drv/raw_sub_nc_byte.r8asm` | **730 字符** | **65536/65536** | +| **`clb_add_nc`(a+b+进位,4 cell)** | `drv/raw_add_nc_byte.r8asm` | **688 字符** | **65536/65536** | +| **`clb_inc_nc`(a+进位,3 cell)** | `drv/raw_inc_nc_byte.r8asm` | **430 字符** | **256/256** | +| **`clb_neg_nc`(~a+进位,3 cell)** | `drv/raw_neg_nc_byte.r8asm` | **468 字符** | **256/256**(取负) | +| 同上,进位 0 | `drv/raw_not_nc_byte.r8asm` | **467 字符** | **256/256**(反码 `~a`) | +| **`clb_sub_nc`(a-b,4 cell)** | `drv/raw_sub_nc_byte.r8asm` | **725 字符** | **65536/65536** | | `asm/fibonacci.r8asm` | — | 8761 字符 | 跑出 `1 1 2 3 5 8 13 21 34 55`,和文件注释一致 | `raw_*` 保留操作数(A、B 原样还回来),`clb_*_nc` 把 A、B 吃干净 —— 所以后者能省掉 -`Co` 和 `tmp`:**4 cell 加法、3 cell 自增/取负**。两者都用轮转驱动,差别只在 -"操作数要不要还回去"。`clb_inc_nc` 的关键是把进位 cell 先置 **1**(那个 1 就是"加 1"), -加法那版才是置 0。 +`Co` 和 `tmp`:**4 cell 加法/减法、3 cell 自增/取负**。两者都用轮转驱动,差别只在 +"操作数要不要还回去"。 + +**`clb_*_nc` 的进位 cell 是真正的进位输入**:宏自己**不动**它的初值(曾经写错过 —— +加法里 `set_0`、自增里 `set_1`,那就不是输入了,而且把多字节串接堵死了)。 +调用者给 0 就是普通运算,给 1 就是"自带 +1"的那种,或者把上一字节的进位输出接过来串。 ### 补码 -`-A = ~A + 1`、`A - B = A + ~B + 1`,所以取负/减法都是"取反 + 加法/自增",进位 cell -的初值就是那个 +1: +`-A = ~A + 1`、`A - B = A + ~B + 1`,所以取负/减法都是"取反 + 加法/自增", +那个 +1 由调用者通过进位输入给: -| 宏 | 做法 | 进位输出 | -|---|---|---| -| `clb_neg_nc A S Ci` | 每轮 `flb` 取反 A 的最低位,再 `clb_bit_inc_nc` | 只有 A 原本是 0 时是 1(`-0 = 0` 但确实进了位) | -| `clb_sub_nc A B S Ci` | 每轮 `flb` 取反 B 的最低位,再 `clb_bit_add_nc` | **没有借位**:A >= B 时 1,否则 0 —— 顺带就是无符号比较 | +| 宏 | 做法 | Ci=1 | Ci=0 | +|---|---|---|---| +| `clb_neg_nc A S Ci` | 每轮 `flb` 取反 A 的最低位,再 `clb_bit_inc_nc` | `-A`(补码取负) | `~A`(反码) | +| `clb_sub_nc A B S Ci` | 每轮 `flb` 取反 B 的最低位,再 `clb_bit_add_nc` | `A - B` | `A - B - 1` | + +`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", @@ -190,8 +197,10 @@ A=0 时整块跳过、S 只能留在 0,而取反要求 A=0 时 S=1 —— "无 | 库里的 7 个位运算块(and/or/xor/inc/add) | 合成版比手写短:`asm/test.r8asm` 1714 → 1666 字符 | | `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;纸带 54 字符,4/4 组合正确 | -| `clb_add_nc`(4 cell 字节加法) | 693 字符,65536 组合全对;比 6 cell 的 `raw_add` 少 2 个 cell、短 954 字符 | -| `clb_inc_nc`(3 cell 字节自增) | 433 字符,256 组合全对;比 5 cell 的 `raw_inc` 少 2 个 cell | +| `clb_add_nc`(4 cell 字节加法) | 688 字符,65536 组合全对;比 6 cell 的 `raw_add` 少 2 个 cell、短 959 字符 | +| `clb_inc_nc`(3 cell 字节自增/加 0-1) | 430 字符,256 组合全对;比 5 cell 的 `raw_inc` 少 2 个 cell | +| `clb_neg_nc`(3 cell 取负/取反) | 468 / 467 字符,各 256 组合全对(Ci=1 取负、Ci=0 反码) | +| `clb_sub_nc`(4 cell 减法) | 725 字符,65536 组合全对;进位输出顺带是无符号比较(A >= B) | | `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 项斐波那契,和注释一致 | diff --git a/README.md b/README.md index 369a035..6470f83 100644 --- a/README.md +++ b/README.md @@ -211,17 +211,38 @@ output Co `raw_add` 把 A、B、S 各当一个**字节**:每轮把当前最低位送进 4~6 cell 的位级切片, 然后把整个字节 `ror` 一格,8 轮走完。`raw_and` / `raw_or` / `raw_xor` / `raw_inc` 同理。 -`r8forge_byte_op_test` 在 ROT-8 虚拟机上把每种输入都跑一遍(0.5 秒): +`r8forge_byte_op_test` 在 ROT-8 虚拟机上把每种输入都跑一遍(0.7 秒): ``` raw_xor: 463 characters all 65536 combinations ok raw_or: 575 characters all 65536 combinations ok raw_and: 639 characters all 65536 combinations ok +clb_sub_nc: 725 characters all 65536 combinations ok +clb_neg_nc (carry 0): 467 all 256 combinations ok ~A +clb_neg_nc: 468 characters all 256 combinations ok -A +clb_inc_nc: 430 characters all 256 combinations ok +clb_add_nc: 688 characters all 65536 combinations ok raw_inc: 1214 characters all 512 combinations ok raw_add: 1647 characters all 65536 combinations ok byte level library ok ``` +### 省 cell 的那一族:`clb_*_nc` + +`raw_add` 要 6 个 cell(A、B、进位、S、进位输出、草稿)是因为它**保留** A、B。 +如果调用者不在乎操作数被吃掉,4 个 cell 就够: + +| 宏 | 含义 | cell | 纸带 | +|---|---|---|---| +| `clb_add_nc A B S Ci` | `S = A + B + Ci` | 4 | 688 | +| `clb_inc_nc A S Ci` | `S = A + Ci`(`Ci=1` 就是自增) | 3 | 430 | +| `clb_neg_nc A S Ci` | `S = ~A + Ci`(`Ci=1` → `-A`,`Ci=0` → `~A`) | 3 | 468 | +| `clb_sub_nc A B S Ci` | `S = A + ~B + Ci`(`Ci=1` → `A-B`) | 4 | 725 | + +**进位 cell 是真正的进位输入**:宏不动它的初值,由调用者给。所以可以串 —— 上一字节的 +进位输出直接接到下一字节的进位输入,多字节加法/减法/取负都能这么拼。 +`clb_sub_nc` 的进位输出是"没有借位"(`A >= B` 时为 1),顺带就是无符号比较。 + `asm/fibonacci.r8asm` 也是这条路上的:8761 字符,跑出 `1 1 2 3 5 8 13 21 34 55`。 ### 一个坑:`biz`/`rnz` 看的是最低位 diff --git a/asm/raw_add_nc.r8asm b/asm/raw_add_nc.r8asm index a4dac62..8e59a01 100644 --- a/asm/raw_add_nc.r8asm +++ b/asm/raw_add_nc.r8asm @@ -44,15 +44,13 @@ ; %3: Cell S ; %4: CellBit Ci ; -; 字节级加法:A + B -> S,进位进->出。每轮把 A、B 的当前最低位喂进 clb_bit_add_nc, -; 和写进 S 的最低位,然后 A、B、S 各 ror 一格。A、B 结束为 0, -; Ci 在最后一轮之后就是整个加法的进位输出。 +; 字节级加法:S = A + B + Ci。进位 cell 是**真正的进位输入** —— 调用者决定初值 +; (普通加法给 0;多字节串起来时给上一字节的进位输出),宏只负责把它变成进位输出。 +; 每轮把 A、B 的当前最低位喂进 clb_bit_add_nc,和写进 S 的最低位, +; 然后 A、B、S 各 ror 一格。A、B 结束为 0。 %macro clb_add_nc 4 .anchor before_clb_add_nc -.tp %4 -set_0 - %rep _CELL_SIZE clb_bit_add_nc %1 %2 %4 %3 .tp %1 diff --git a/asm/raw_inc_nc.r8asm b/asm/raw_inc_nc.r8asm index 098e9dd..2090469 100644 --- a/asm/raw_inc_nc.r8asm +++ b/asm/raw_inc_nc.r8asm @@ -39,14 +39,12 @@ ; %2: Cell S ; %3: CellBit Ci ; -; 字节级自增:A + 1 -> S,A 被吃干净。进位 cell 先置 **1** —— 那个 1 就是"加 1", -; 所以这里不能像加法那样清零。最后一轮之后 Ci 是进位输出。 +; 字节级"加一个 0/1":S = A + Ci,A 被吃干净。进位 cell 是**真正的进位输入** —— +; 要自增就由调用者先 `set_1`(那一位就是"加 1"),要加 0 就 `set_0`。 +; 宏自己不碰初值,所以多字节可以串起来:上一字节的进位输出直接当下一字节的进位输入。 %macro clb_inc_nc 3 .anchor before_clb_inc_nc -.tp %3 -set_1 - %rep _CELL_SIZE clb_bit_inc_nc %1 %3 %2 .tp %1 diff --git a/asm/raw_neg_nc.r8asm b/asm/raw_neg_nc.r8asm index 531eec8..53a6de6 100644 --- a/asm/raw_neg_nc.r8asm +++ b/asm/raw_neg_nc.r8asm @@ -26,14 +26,13 @@ ; %2: Cell S ; %3: CellBit Ci ; -; 字节级补码取负:S = -A(mod 256)。进位 cell 先置 **1** —— 那个 1 就是 +1。 -; A 被吃干净。最后一轮之后 Ci 为 1 只有一种情况:A 原本是 0(0 的负数还是 0,但"有进位")。 +; 字节级取负/取反:S = ~A + Ci。进位 cell 是**真正的进位输入**,宏自己不动初值: +; Ci = 1 -> S = -A(补码取负) +; Ci = 0 -> S = ~A(反码,逐位取反) +; A 被吃干净。不硬置初值的另一个好处:多字节取负也能串(进位接进位)。 %macro clb_neg_nc 3 .anchor before_clb_neg_nc -.tp %3 -set_1 - %rep _CELL_SIZE clb_bit_neg_nc %1 %3 %2 .tp %1 diff --git a/asm/raw_sub_nc.r8asm b/asm/raw_sub_nc.r8asm index 0697e72..52cbe5f 100644 --- a/asm/raw_sub_nc.r8asm +++ b/asm/raw_sub_nc.r8asm @@ -25,15 +25,14 @@ ; %3: Cell S ; %4: CellBit Ci ; -; 字节级补码减法:S = A - B(mod 256),A、B 都被吃干净。 -; 最后一轮之后 Ci 的意义是"没有借位":A >= B 时 Ci = 1,否则 0 —— 所以它顺带就是 -; 一个无符号比较(A >= B)。 +; 字节级减法:S = A + ~B + Ci。进位 cell 是**真正的进位输入**,宏自己不动初值: +; Ci = 1 -> S = A - B(补码减法) +; Ci = 0 -> S = A - B - 1 +; A、B 都被吃干净。最后一轮之后 Ci 是"没有借位"(A >= B 时为 1)—— 顺带就是无符号比较, +; 而且多字节减法可以把这一位直接接到下一字节的进位输入。 %macro clb_sub_nc 4 .anchor before_clb_sub_nc -.tp %4 -set_1 - %rep _CELL_SIZE clb_bit_sub_nc %1 %2 %4 %3 .tp %1 diff --git a/drv/raw_add_nc_byte.r8asm b/drv/raw_add_nc_byte.r8asm index 6b6b764..5828d08 100644 --- a/drv/raw_add_nc_byte.r8asm +++ b/drv/raw_add_nc_byte.r8asm @@ -1,15 +1,21 @@ %include "asm/raw_add_nc.r8asm" -; clb_add_nc 的字节级驱动:操作数直接放在 A、B 里,不预置任何常量。 +; clb_add_nc 的字节级驱动:操作数直接放在 A、B 里。 ; ; r8forge_derive drv/raw_add_nc_byte.r8asm -2 0=5 2=3 ; ; out 依次是 A、B、S、Ci。和 raw_add 的驱动不同,A、B 是被吃掉的(结束为 0)。 +; +; 进位 cell 是真正的进位输入,这里先清零 = 普通加法。要多字节串接就把上一字节的 +; 进位输出接在这个 cell 上,别再清它。 .var A 0 .var Ci 1 .var B 2 .var S 4 +.tp Ci +set_0 + clb_add_nc A B S Ci output A diff --git a/drv/raw_inc_nc_byte.r8asm b/drv/raw_inc_nc_byte.r8asm index 5f8788e..a94f015 100644 --- a/drv/raw_inc_nc_byte.r8asm +++ b/drv/raw_inc_nc_byte.r8asm @@ -1,14 +1,18 @@ %include "asm/raw_inc_nc.r8asm" -; clb_inc_nc 的字节级驱动。A 被吃掉,S = A + 1,Ci 是进位输出。 +; clb_inc_nc 的字节级驱动。A 被吃掉,S = A + Ci。 ; ; r8forge_derive drv/raw_inc_nc_byte.r8asm -2 0=255 ; +; 自增就是"加一个 1",所以进位输入先置 1(宏自己不碰这一位)。 ; out 依次是 A、S、Ci。 .var A 0 .var Ci 1 .var S 2 +.tp Ci +set_1 + clb_inc_nc A S Ci output A diff --git a/drv/raw_neg_nc_byte.r8asm b/drv/raw_neg_nc_byte.r8asm index fc6ebe6..0c60d64 100644 --- a/drv/raw_neg_nc_byte.r8asm +++ b/drv/raw_neg_nc_byte.r8asm @@ -1,14 +1,19 @@ %include "asm/raw_neg_nc.r8asm" -; clb_neg_nc 的字节级驱动。A 被吃掉,S = -A(补码),Ci 只在 A 原本是 0 时为 1。 +; clb_neg_nc 的字节级驱动(S = ~A + Ci)。A 被吃掉。 ; -; r8forge_derive drv/raw_neg_nc_byte.r8asm -2 0=1 +; r8forge_derive drv/raw_neg_nc_byte.r8asm -2 0=1 # ci=1:取负,得 255 ; +; 补码取负 = ~A + 1,所以进位输入置 1。这个 cell 是真正的进位输入, +; 置 0 的话同一个宏算的是逐位取反(~A,见 drv/raw_not_nc_byte.r8asm)。 ; out 依次是 A、S、Ci。 .var A 0 .var Ci 1 .var S 2 +.tp Ci +set_1 + clb_neg_nc A S Ci output A diff --git a/drv/raw_not_nc_byte.r8asm b/drv/raw_not_nc_byte.r8asm new file mode 100644 index 0000000..bd19352 --- /dev/null +++ b/drv/raw_not_nc_byte.r8asm @@ -0,0 +1,19 @@ +%include "asm/raw_neg_nc.r8asm" + +; clb_neg_nc 的另一个用法:进位输入置 0,算的就是逐位取反(~A,反码)。 +; +; r8forge_derive drv/raw_not_nc_byte.r8asm -2 0=5 # 得 250 +; +; out 依次是 A、S、Ci。 +.var A 0 +.var Ci 1 +.var S 2 + +.tp Ci +set_0 + +clb_neg_nc A S Ci + +output A +output S +output Ci diff --git a/drv/raw_sub_nc_byte.r8asm b/drv/raw_sub_nc_byte.r8asm index 3edf01e..8ba0b7a 100644 --- a/drv/raw_sub_nc_byte.r8asm +++ b/drv/raw_sub_nc_byte.r8asm @@ -1,16 +1,19 @@ %include "asm/raw_sub_nc.r8asm" -; clb_sub_nc 的字节级驱动。A、B 都被吃掉,S = A - B(补码), -; Ci = 1 表示没有借位(A >= B)。 +; clb_sub_nc 的字节级驱动。A、B 都被吃掉,S = A + ~B + Ci。 ; -; r8forge_derive drv/raw_sub_nc_byte.r8asm -2 0=5 2=3 +; r8forge_derive drv/raw_sub_nc_byte.r8asm -2 0=5 2=3 # ci=1:A-B ; +; A - B = A + ~B + 1,所以进位输入置 1。输出里 Ci = 1 表示没有借位(A >= B)。 ; out 依次是 A、B、S、Ci。 .var A 0 .var Ci 1 .var B 2 .var S 4 +.tp Ci +set_1 + clb_sub_nc A B S Ci output A diff --git a/tests/byte_op_test.cc b/tests/byte_op_test.cc index 5fd5bd2..37c86fb 100644 --- a/tests/byte_op_test.cc +++ b/tests/byte_op_test.cc @@ -293,6 +293,29 @@ int test_sub_nc(const std::string &file) { return bad; } +// Same macro with its carry in at 0 is the ones' complement: S = ~A. +int test_not_nc(const std::string &file) { + const std::string tape = assemble(file); + std::cout << "clb_neg_nc (carry 0): " << tape.size() << " characters\n"; + int bad = 0; + for (int a = 0; a < 256; a++) { + machine m; + m.cells[0] = uint8_t(a); // A + m.run(tape, 100'000); + const int inv = (~a) & 0xff; + const bool ok = m.finished && m.out.size() == 3 && m.out[0] == 0 && + m.out[1] == inv && m.out[2] == 0; + if (!ok) { + bad++; + if (bad <= 3) + report("clb_neg_nc/0", a, 0, m, "0 " + std::to_string(inv) + " 0"); + } + } + std::cout << " " << (bad ? "FAILED" : "all 256 combinations ok") + << (bad ? " (" + std::to_string(bad) + " wrong)" : "") << "\n"; + return bad; +} + } // namespace int main(int argc, char **argv) { @@ -306,6 +329,7 @@ int main(int argc, char **argv) { test_add_nc(drv + "raw_add_nc_byte.r8asm") + test_inc_nc(drv + "raw_inc_nc_byte.r8asm") + test_neg_nc(drv + "raw_neg_nc_byte.r8asm") + + test_not_nc(drv + "raw_not_nc_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;