The multiplier: shift and add, one bit at a time, 3977 characters
clb_mul was repeated addition -- add MC into the product, MUL times. That is
the shortest thing to write, but the runtime is proportional to MUL's value:
255 * 255 took 733428 steps, and 2047 * 2047 ran into the 5000000 step ceiling
and hung outright (tape_run: HANG after 5000000 steps). So the multiplier was
a ceiling on what any program could compute.
The new body is the plain binary multiplication from school: hold the
multiplicand, look at the multiplier's low bit, add the multiplicand into the
high half of the product when that bit is 1, then shift the whole product one
place right -- the multiplier lives in the low half of that register, so its
bits fall out one at a time. The loop runs _CELL_SIZE rounds whatever the
operands are, and the tape got shorter as well:
82 * 141 358586 -> 8374 steps
255 * 255 733428 -> 17785 steps
2047 * 2047 HANG -> 26123 steps
tape 5007 -> 3977 characters
(Step counts are the tape's own, with no trailing newline -- tape_run counts
one if the file has one, which is where the first draft of this message got
numbers two out.)
Counter, carry and cross cell shift are the three pieces that needed care:
* the round counter is _CELL_SIZE ones in NR, one eaten per round by
set_0 + ror -- the same trick clb_inc_ip counts rotations with, so "how
many rounds" costs no tape length, only runtime;
* the carry out of the W bit add is not scratch: it is the top bit of the
2W+1 bit shift register, and the next shift moves it into PH's top bit;
* (F:PH:PL) >>= 1 is a cross cell shift. ror all three, bring the bit to
inject down to bit 0 with rol, move it with clb_bit_mov, ror back. The
low pair (PH -> PL) moves first, otherwise PH's bit 0 has already been
overwritten by the carry.
And biz/rnz is a loop pair, not an if/else: a one shot conditional has to eat
the bit it tested (a trailing flb) or rnz jumps straight back. The first
version of this hung exactly there -- no output at all, counter still 0x7ff.
The bit eaten is PL's low bit, which the shift discards anyway.
r8forge_byte_op_test now sweeps 0..255 x 0..255 exhaustively (65536/65536 ok,
6.7s instead of 1.5s) instead of sampling 64 combinations: the cost no longer
grows with the multiplier, so sampling was the only reason not to. asm/
test.r8asm still prints 1322 1786 1600 5 94 127, now as 28729 characters and
57330 steps (was 31901 and about two million), and derive and tape_run agree.
AGENTS.md and README record all of it, plus one correction: the old note said
shift and add had been dismissed because "only tape length is the target". It
is in fact 1000 characters shorter, so the reason given was wrong -- the
tradeoff was not. What changed is the target function: the 5000000 step
ceiling is part of it, and a loop whose length does not depend on its operands
can still have a runtime that does.
This commit is contained in:
1 parent
9b326f3b4b
commit
6e67eb4678
5 files changed
+175
-78
No files matched your search
@@ -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 项 |
|
||||
|
||||
@@ -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 处回绕)。
|
||||
|
||||
+92
-23
@@ -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
|
||||
|
||||
+4
-6
@@ -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(乘)。没有位运算,
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
|
||||
Reference in new issue
Block a user