diff --git a/AGENTS.md b/AGENTS.md index be17888..7df2645 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -2,9 +2,11 @@ > **动手之前,先把这份文件从头读完**,再看 `README.md`、`SPEC.md` > (`C:\Users\peng0\git\r8asm_rev-fork\SPEC.md`)和 `asm/lib.r8asm` 里的宏注释。 -> 这条不是客套:上一轮我没先读,把「位移-加法乘法器比重复加法快」当成新发现又推了一遍, -> 而下面「乘法器」「指令集语义」两节其实已经把要命的地方都写了 —— -> `dp` 净位移、`flb` 吃条件、`rol` = 10 次 `ror`、乘法成本 ∝ `MUL` 的值、 +> 这条不是客套:上一轮我没先读,把「位移-加法乘法器比重复加法快」当成新发现又推了一遍。 +> 那次它被否掉了(当时只认纸带长度),后来乘数一大就撞 500 万步上限,真的换成了移位-加法 +> —— **而且它比重复加法还短**(5007 → 3977 字符),见「乘法器」。 +> 下面「乘法器」「指令集语义」两节把要命的地方都写了 —— +> `dp` 净位移、`flb` 吃条件、`rol` = 10 次 `ror`、 > 位串行要的跨格移位该怎么拼。**尤其把「已经确认走不通的」那节看完**, > 别把别人踩过的坑再踩一遍;想推翻某条结论,先照它写的验证方法实测一遍再改文字。 @@ -72,7 +74,7 @@ clang-cl /nologo /std:c++20 /EHsc /O2 /I include src/r8asm.cc src/synth.cc tests 自检: ```sh -r8forge asm/test.r8asm # 应 exit 0,31901 字符(3 轮 hash) +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 自增切片,进位同样进->出 @@ -197,7 +199,7 @@ inline constexpr uint32_t kDefaultCellMask = (1u << kDefaultCellBits) - 1u; | **`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` | **5007 字符** | **64 抽样全过**(O(mul) 运行) | +| **`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 吃干净 —— 所以后者能省掉 @@ -290,36 +292,57 @@ B 被吃干净。对比:`raw_add` 2199(6 cell,保留操作数)、`clb_ad ### 乘法器(`asm/mul.r8asm`) -`clb_mul MC MUL PL PH MCA S Ci T F NR`:`(PH:PL) = MC * MUL`,10 个 cell,**5007 字符**, -`r8forge_byte_op_test` 抽 64 组全对(含 `255*255 = 65025 = 31*2048 + 1473`),最坏运行约 100 万步。 +`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 位下的整个域)。 -用的是**重复加法**,不是移位-加法: +用的是**二进制移位-加法**(竖式乘法),一位一位串: - (PH:PL) = 0 - while MUL != 0: (PH:PL) += MC ; MUL -= 1 + 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,最低位(刚看的那位)丢掉 -理由还是「只有纸带长度是目标」:循环体在纸带里只出现一次,所以长度和 MUL 无关 —— -连 `fibonacci`(11 位下 11959 字符)都比它长。 +W 轮之后 `(PH:PL)` 就是积;`PL`(原来的 Q)被移空,所以 **MUL 结束为 0**,和原来的约定一样。 -**乘法可交换,成本不可交换**:循环次数 = **第二个操作数 `MUL`(被递减的那个)的值**, -跟位宽无关、跟第一个操作数的值也无关。实测同样算 `82 * 141`: +**为什么换掉重复加法**:重复加法的轮数 = `MUL` 的值,成本 ∝ MUL。`MUL = 2047` 时实测直接 +`HANG after 5000000 steps`——也就是大乘数根本算不完。移位-加法的轮数 = 位宽,**跟操作数的 +值无关**,11 位下封顶 26123 步: -| 写法 | 步数 | 纸带 | +| 算式 | 重复加法(旧) | 移位-加法(现在) | |---|---|---| -| MC=82, MUL=141 | **358598** | 5019 字符 | -| MC=141, MUL=82 | **214753** | 5019 字符 | +| `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 步 | -所以**永远把小操作数放 `MUL`**,每个循环体约 2400 步。这条踩过:`asm/test.r8asm` 的 -hash 一开始拿 FNV 的 403 当乘数,三轮直接顶穿 500 万步上限(`tape_run` 报 -`HANG after 5000000 steps`),换成 141 才跑完。 +纸带同时短了:**5007 → 3977 字符**。代价只有一条:乘数是 0/1 这种小值时反而慢一点点 +(旧版循环 0/1 次就完了,新版固定要转满 `_CELL_SIZE` 轮)——拿它换「乘数再大也不会挂」。 +所以 `asm/test.r8asm` 里那条"永远把小操作数放 MUL"的规矩**已经没用了**(保留 141 只是 +为了跟历史结果对得上)。 -16 位累加靠 `clb_add_nc` 的进位输出:低字节相加拿到进位,再用 `clb_add_ip` 把这一位加进高字节。 -`clb_add_nc` 会把操作数吃干净,所以每轮先 `copy` 一份被乘数(`clb_add_ip` 不输出进位, -所以低字节那一步只能用会吃操作数的那条)。 +拼法上踩过两个坑: -**设计上的教训**:我一开始以为乘法器缺"跨字节移位"和"条件累加"两件,实际上一件都不需要 —— -换成重复加法之后,移位整个消失了。缺的那件(保留加数的原地加)反而是关键,它逼出了 -`clb_add_ip` 和 `clb_nonzero`。**先看目标函数(长度)再选算法,别先照着硬件乘法的样子拼。** +* **跨格移位**:`(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`, @@ -367,7 +390,7 @@ hash 一开始拿 FNV 的 403 当乘数,三轮直接顶穿 500 万步上限( | 东西 | 结论 | |---|---| | 库里的 7 个位运算块(and/or/xor/inc/add) | 合成版比手写短(8 位时代 1714 → 1666;位宽改了以后位级块不受影响,长度变的是字节级那层) | -| `asm/test.r8asm` 现在是一个 hash | 11 位下 **31901 字符**,`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 两边逐位一致,约 207 万步 | +| `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 | @@ -380,7 +403,7 @@ hash 一开始拿 FNV 的 403 当乘数,三轮直接顶穿 500 万步上限( | `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) | **5007 字符**,64 抽样全对;和 MUL 的大小无关 | +| `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 项 | diff --git a/README.md b/README.md index a59c346..5e31e89 100644 --- a/README.md +++ b/README.md @@ -250,7 +250,7 @@ byte level library ok | `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** | -| `clb_mul MC MUL PL PH …` | `(PH:PL) = MC * MUL`,8 位乘法,16 位积 | 10 | **3729** | +| `clb_mul MC MUL PL PH …` | `(PH:PL) = MC * MUL`,一个 cell × 一个 cell → 两个 cell 的积 | 10 | **3977** | **进位 cell 是真正的进位输入**:宏不动它的初值,由调用者给。所以可以串 —— 上一字节的 进位输出直接接到下一字节的进位输入,多字节加法/减法/取负都能这么拼。 @@ -288,26 +288,31 @@ while B != 0: A += 1 ; B -= 1 上限 500 万)。`clb_nonzero` 负责"B != 0"的判断(`biz` 只测最低位,得把八位都看一遍, 还不能把 B 吃掉)。 -### 乘法器:8 位 × 8 位 → 16 位 +### 乘法器:`(PH:PL) = MC * MUL` -`clb_mul` 用的是**重复加法**,不是移位-加法: +`clb_mul` 用的是**二进制移位-加法**(竖式乘法),一位一位串: ``` -(PH:PL) = 0 -while MUL != 0: (PH:PL) += MC ; MUL -= 1 +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,最低位(刚看的那位)丢掉 ``` -**3729 字符、10 个 cell**,比 `fibonacci`(8761)短,而且长度和 MUL 多大无关 —— -循环体在纸带里只出现一次。16 位累加靠 `clb_add_nc` 的进位输出:低字节相加拿到进位, -再用 `clb_add_ip` 把它加进高字节;`clb_add_nc` 会吃操作数,所以每轮先 `copy` 一份被乘数。 +**3977 字符、10 个 cell**。轮数 = 位宽,**跟两个操作数的值都无关**:11 位下封顶 26123 步。 -`255 × 255 = 65025 = 0xFE01` ✓,`r8forge_byte_op_test` 抽 64 组全对。 -`asm/test.r8asm` 里也演了一遍:先 `raw_add` 算 `127+130`,再 `clb_mul` 算 `200×200`, -纸带 5417 字符,`r8forge_derive` 和 `r8forge_tape_run` 两个实现给出同样的 -`127 130 0 1 1 64 156`。 +早先那版是**重复加法**(`while MUL != 0: (PH:PL) += MC ; MUL -= 1`),轮数 = `MUL` 的值, +所以代价随乘数线性长大 —— `255 × 255` 是 73 万步,`2047 × 2047` 直接跑不完(撞 500 万步 +上限,`tape_run` 报 `HANG after 5000000 steps`)。换成移位-加法之后同一批算式都在 1 万步 +上下,纸带还短了 1000 字符(5007 → 3977),只有小乘数(0/1)比旧版慢一点点 —— 新版固定要 +转满位宽那么多轮。 -**这个设计本身是一条经验**:一开始以为乘法器缺"跨字节移位"和"条件累加",换成重复加法之后 -两样都不需要了。先看目标函数(纸带长度),再选算法,别照着硬件乘法的样子拼。 +`255 × 255 = 65025 = 31*2048 + 1473` ✓,`r8forge_byte_op_test` 现在**穷举 65536 组** +(0..255 × 0..255)全对 —— 步数不再随乘数增长,才敢这么放开测。 + +**这个设计本身是一条经验**:上一轮把移位-加法否掉了,理由是「重复加法更短」。实测反了: +移位-加法短 1000 字符,步数还少一到两个数量级。先看目标函数(纸带长度)再选算法没错, +但目标函数里得把「运行步数有 500 万上限」这一条写进去。 `asm/fibonacci.r8asm` 也是这条路上的:11 位下 11959 字符,跑出 `1 1 2 3 5 8 13 21 34 55 89 144 233`(13 项,位宽变大以后不再在 256 处回绕)。 diff --git a/asm/mul.r8asm b/asm/mul.r8asm index 412a364..b16cd0b 100644 --- a/asm/mul.r8asm +++ b/asm/mul.r8asm @@ -1,20 +1,35 @@ -%include "asm/add_ip.r8asm" +%include "asm/lib.r8asm" %include "asm/raw_add_nc.r8asm" -; 8 位乘法:MC * MUL -> (PH:PL),16 位积。 +; 一个 cell × 一个 cell -> 两个 cell 的积(11 位下是 22 位)。 ; -; 算法是**重复加法**,不是移位-加法: +; 算法是**二进制里最朴素的那条:移位-加法**,从乘数的最低位往上走一位一位串: ; -; 积 = 0 -; while MUL != 0: (PH:PL) += MC ; MUL -= 1 +; A:PH = 0 ; C:F = 0 ; Q:PL = MUL +; while 还剩一位没看: +; if Q 的最低位 == 1: (C:PH) += MC ; 一次 W 位加法,进位出到 F +; (C:PH:PL) 右移一位 ; 最高位补 0,C 移进 PH 的最高位 ; -; 为什么敢这么写 —— 和 clb_add_ip 同一个理由:**这里只有纸带长度是目标,运行步数不是**。 -; 循环体在纸带里只出现一次,所以长度不随 MUL 变化;代价是运行 O(MUL)(255 时约 100 万步, -; 上限 500 万)。 +; 这就是竖式乘法:被乘数不动,每轮只看乘数的一位,是 1 就把被乘数加到积的高半上, +; 然后把整个积往右挪一位,乘数也一起挪。W 轮之后 (PH:PL) 就是积,Q 的位被吃干净 +; (所以 MUL 结束为 0,和原来的约定一样)。 ; -; 16 位累加靠 clb_add_nc 的进位输出:低字节相加拿到进位,再用 clb_add_ip 把这一位加进高字节。 -; clb_add_nc 会把两个操作数吃掉,所以每轮先把被乘数复印一份(clb_add_ip 是原地加法,但它 -; 不输出进位,所以这一步只能用会吃操作数的那条)。 +; **为什么换掉原来的重复加法**:重复加法的轮数 = MUL 的值,所以运行代价 ∝ MUL +; (MUL=255 时约 100 万步,2047 时直接撞 500 万步上限,HANG)。移位-加法固定做 +; _CELL_SIZE 轮,每轮一次 W 位加法(乘数那一位是 0 时整段跳过),所以总步数有个 +; 上界:11 位下最坏 26123 步(2047 * 2047),**不随操作数的大小增长** —— +; 乘数再大也跑得完。代价是小乘数(0、1)反而比旧的重复加法慢一点点。 +; +; 两个 cell 的细节: +; * (C:PH:PL) 得当成一个 2W+1 位的移位寄存器,**跨格移位**这么拼:先 ror 三格, +; 再把各自要注入的那一位搬到 bit0 用 clb_bit_mov 搬过去,最后 ror 回来 —— +; F 的那一位进 PH 的最高位,PH 的最低位进 PL 的最高位,PL 的最低位(刚看过的 +; 乘数位)丢掉。顺序必须是"低位那对先搬",否则搬完 PH 的 bit0 就没了。 +; * 进位不能丢:W 位加法的进位出到 F,下一轮右移时它正好被移进 PH 的最高位。 +; 所以 F 不是草稿,是移位寄存器最高那一位。 +; +; 计数器 NR:_CELL_SIZE 个 1,每轮 set_0 + ror 吃掉一个(和 clb_inc_ip 的计数法子一样), +; 一串 1 的长度就是剩余轮数 —— 于是"做几轮"这件事不占纸带长度,只占纸带的运行时间。 ; Macro clb_mul ; %1: Cell MC @@ -29,27 +44,81 @@ ; %10: Cell NR ; ; (PH:PL) = MC * MUL。MC 保持原样,MUL 结束为 0。 +; MCA、S、Ci、T 是草稿;F 是移位寄存器的最高位(进位),NR 是轮数计数器。 %macro clb_mul 10 .anchor before_clb_mul -erase %3 +; A = PH = 0, C = F = 0, Q = PL = MUL +.tp %4 erase %4 +.tp %3 +erase %3 +.tp %9 +erase %9 +.tp %2 +copy %3 %8 +.tp %2 +erase %2 -clb_nonzero %2 %10 %8 +; 轮数计数器:_CELL_SIZE 个 1,每轮吃掉一个 +.tp %10 +%rep _CELL_SIZE + set_1 + ror +%endrep .tp %10 +.anchor mul_iter biz - .tp %1 - copy %5 %8 - .tp %7 - set_0 - clb_add_nc %3 %5 %6 %7 - .tp %6 - copy %3 %8 - clb_add_ip %4 %7 %8 %9 - clb_dec_ip %2 %8 - clb_nonzero %2 %10 %8 + ; ---- 1. 乘数这一位是 1 就把被乘数加到积的高半:(C:PH) += MC + ; 进位出到 Ci,再搬进 F(搬之前 F 一定是 0)。 + ; `biz`/`rnz` 是一对循环,不是 if/else:body 必须把被测位吃掉(最后那个 + ; flb),否则 rnz 看到还是 1 就跳回去。被测的正好是 PL 的最低位, + ; 而它本来就要在右移时被丢掉,吃掉它不影响移位。 + .tp %3 + biz + .tp %1 + copy %5 %8 + .tp %7 + set_0 + clb_add_nc %4 %5 %6 %7 + .tp %6 + copy %4 %8 + .tp %7 + clb_bit_mov %9 + .tp %3 + flb + rnz + + ; ---- 2. (F:PH:PL) 右移一位:C 补进 PH 的最高位,PH 的最低位补进 PL 的最高位, + ; PL 的最低位(这一轮刚看过的乘数位)丢掉。先低位那对,再高位那对。 + .tp %9 + ror + .tp %4 + ror + .tp %3 + ror + .tp %4 + rol + .tp %3 + rol + .tp %4 + clb_bit_mov %3 + .tp %9 + rol + clb_bit_mov %4 + .tp %9 + ror + .tp %4 + ror + .tp %3 + ror + + ; ---- 3. 这一轮结束,计数器吃掉一个 1 .tp %10 + set_0 + ror + .tp mul_iter rnz .tp before_clb_mul diff --git a/asm/test.r8asm b/asm/test.r8asm index 9d8fdeb..6724f61 100644 --- a/asm/test.r8asm +++ b/asm/test.r8asm @@ -2,12 +2,10 @@ ; ; 141 是奇数,所以乘它在 mod 2^11 上可逆 —— 每个输入位都能影响到结果, ; 这就是 hash 要的那种"雪崩"的弱化版(11 位也别指望真雪崩)。 -; 为什么不用 FNV 那个 403:乘法器是重复加法,循环次数 = **第二个操作数 -; (MUL,被递减的那个)的值**,跟位宽无关、跟第一个操作数的值也无关。 -; 403 放 MUL 会顶到 500 万步上限;141 放 MUL,三轮约 207 万步。 -; 乘法可交换,成本不可交换 —— 同样算 82*141,实测: -; 82 放 MUL → 214753 步; 141 放 MUL → 358598 步 -; 纸带都是 5019 字符,一个字节都不差。所以永远把小操作数放 MUL。 +; 为什么不用 FNV 那个 403:那是老乘法器的遗留 —— 老的 clb_mul 是重复加法, +; 轮数 = MUL 的值,403 放 MUL 会顶到 500 万步上限(141 那版三轮约 207 万步)。 +; 现在的 clb_mul 是移位-加法,轮数只跟位宽有关(MC=100、MUL=403 实测 10210 步), +; 乘数多大都不再影响能不能跑完;这里留着 141 只是为了跟以前的结果对得上。 ; **hash 的强度花在运行时间上,纸带长度完全不变** —— 这就是本仓库的取舍。 ; ; 只用两样东西:clb_add_nc(加)和 clb_mul(乘)。没有位运算, diff --git a/tests/byte_op_test.cc b/tests/byte_op_test.cc index 06e4f95..b2235f8 100644 --- a/tests/byte_op_test.cc +++ b/tests/byte_op_test.cc @@ -467,15 +467,17 @@ int test_add_ip(const std::string &file) { return bad; } -// clb_mul: (PH:PL) = MC * MUL, MC preserved. Repeated addition, so whatever -// MUL says is how many times the loop runs -- sampled, not exhaustive. +// clb_mul: (PH:PL) = MC * MUL, MC preserved. Shift and add: the loop runs +// once per bit of MUL whatever MUL's value is, so the classic 8 bit domain can +// be swept exhaustively. (The repeated addition version this replaced looped +// MUL times, so it could only be sampled -- and it hit the step limit outright +// for large multipliers.) int test_mul(const std::string &file) { const std::string tape = assemble(file); - std::cout << "clb_mul: " << tape.size() << " characters (sampled)\n"; - const int vals[] = {0, 1, 2, 3, 7, 13, 100, 255}; + std::cout << "clb_mul: " << tape.size() << " characters\n"; int bad = 0, n = 0; - for (int mc : vals) - for (int mu : vals) { + for (int mc = 0; mc < 256; mc++) + for (int mu = 0; mu < 256; mu++) { machine m; m.cells[0] = uint16_t(mc); // MC m.cells[1] = uint16_t(mu); // MUL @@ -493,7 +495,7 @@ int test_mul(const std::string &file) { " " + std::to_string(mc)); } } - std::cout << " " << (bad ? "FAILED" : "all " + std::to_string(n) + " sampled combinations ok") + std::cout << " " << (bad ? "FAILED" : "all " + std::to_string(n) + " combinations ok") << (bad ? " (" + std::to_string(bad) + " wrong)" : "") << "\n"; return bad; }