clb_divmod: shift-and-restore division instead of repeated subtraction
Repeated subtraction ran N/D rounds and hit the 5M step ceiling for D = 1
(2047/1 hangs outright); it also cost 2.46M steps for 2047/2. Binary long
division is fixed at _CELL_SIZE rounds whatever the operands are:
R = 0 ; Q = 0
repeat _CELL_SIZE: R = (R << 1) | next bit (rol N hands the bits out
MSB first and restores N
after W rounds)
if R >= D: R -= D ; quotient bit = 1
The one non obvious part is the comparison. R needs W+1 bits after the shift,
but the high bit (H, the bit rol wraps out of Rlo) only has to decide the
commit: H = 1 means R >= 2^W > D, so commit = H | Bo, where Bo is raw_sub's "no
borrow" (Rlo >= D). SPEC 14's Shi = H & Bo is always 0 under the invariant "R
< D at the start of every round" (H = 1 and Bo = 1 together would need R >= 2D),
so that clb_bit_and and its copy do not exist in the built version.
Signature is now clb_divmod N D Q R S: N and D survive, Q and R each get their
own cell (the old version ate N into the remainder), and S is a 7 cell scratch
block (Rhi, Sd, Bo, Cm, Ci, buf, NR). Only S+5 (the copy buffer) has to be
clean on entry; the rest is rewritten or used as a single bit, which is what
lets clb_digits pass the same dirty block back in every round.
The order that cost clb_mul two reworks is the delicate bit: rol Rlo wraps its
top bit into bit 0, so clb_bit_mov has to move that bit into Rhi (which also
clears it) before bit_copy injects N's bit. bit_copy (not clb_bit_mov) is what
keeps N intact.
Measured on drv/divmod.r8asm (11 bit):
repeated subtraction shift-and-restore
2047/10 495,986 28,593
2047/2 2,461,650 31,997
999/7 340,086 28,661
2047/1 HANG (>5M) 32,383
Small N/D get slower (fixed W rounds) -- the same trade clb_mul made. Worst
case over the sweep is 32,383 steps; the tape grows 4189 -> 4499 characters.
About the numbers in SPEC 14 / AGENTS: the 1.48M steps claimed there do not
reproduce on this tree. Measured before the change, 2047/10 was 495,986 and
clb_digits(2047) was 740,695, so the docs now carry the measured values and say
where the old figure came from.
clb_digits keeps its shape (one divmod in a 4 round loop, written digits shift
up by one cell), with S grown to 13 cells: TEN, quotient, remainder, the 7
divmod scratch cells, the loop counter and add_ip's T/F. 2047 goes from
740,695 to 145,138 steps (worst 164,867) and 10829 -> 13717 characters. It
needs its own %include "asm/add_ip.r8asm" now: that used to arrive through the
old divmod.
Tests: test_divmod sweeps 8 divisors x all 2048 dividends (16384 pairs; the old
76 sample table is a subset) and also asserts N and D come back unchanged;
test_digits sweeps all 2048 values. Both print the worst step count.
Two traps found on the way:
* r8forge_derive (and byte_op_test/synth_test) checked the assembler error flag
before export_rot8(), but an unknown macro or a bad .tp target is found while
the tree is *expanded*: a missing %include left a truncated tape that still
ran and printed a plausible wrong answer (all four digits came out '0'). All
three now check after the export.
* raw_sub's comment claimed Bo = 1 means A < B; the code (and clb_sub_nc) mean
A >= B. Comment fixed, behaviour untouched.
Also adds drv/div_shift.r8asm, the single step check for the cross cell shift
plus injection, and records the measurements in SPEC 7.6/7.7/14 and AGENTS.
This commit is contained in:
1 parent
677878779a
commit
c2cd0e827f
10 files changed
+420
-191
No files matched your search
@@ -1,35 +1,45 @@
|
||||
# 给接手的 agent 的话
|
||||
|
||||
## 下一轮从这里开始(2026-11-07 交接)
|
||||
## 下一轮从这里开始(2026-11-07 交接:移位-恢复除法已落地)
|
||||
|
||||
**任务**:把 `clb_divmod` 从"重复减法"换成**移位-恢复除法**(二进制长除法)。
|
||||
目标:`2047 / 10` 从 **148 万步** 降到 **~35k 步**(W 轮 vs N/D 轮),纸带保持 ~4k。
|
||||
**完整设计在 `SPEC.md §14`,动手前先把那节读完**(状态布局、每轮骨架、四个坑、验收清单)。
|
||||
**上一轮的任务做完了**:`clb_divmod` 已经是二进制长除法(`asm/divmod.r8asm`)。
|
||||
契约看 `SPEC.md §7.6`,设计推理、踩过的坑和实测数据看 `§14`。摘要:
|
||||
|
||||
**第一步(不要跳)**:只做"R 的跨格左移 + 从 N 注入一位",单点验证确认顺序对:
|
||||
* 签名变成 `clb_divmod N D Q R S`:`Q` = 商、`R` = 余数,**N 和 D 都保持原样**,
|
||||
`S` 起 **7 个连续草稿格**。11 个 cell,最小驱动纸带 **4499**(旧 4189)。
|
||||
* 固定 **11 轮(位宽)**,`2047/1` 不再 HANG。步数(`drv/divmod.r8asm`):
|
||||
`2047/10` 49.6 万 → **2.86 万**、`2047/2` 246 万 → **3.2 万**、`999/7` 34 万 →
|
||||
**2.87 万**、`2047/1` HANG → **3.24 万**;16384 组里最坏 **32,383** 步。
|
||||
**小 N/D 反而慢**(旧版 N/D 轮就结束)——和 `clb_mul` 一样的取舍。
|
||||
* `clb_digits` 跟着换了布局(`S` 起 **13 格**,divmod 的草稿块从 `S+3` 开始):
|
||||
`0=2047` 从 74 万降到 **14.5 万**步(最坏 164,867),`test_digits` 现在**穷举
|
||||
全部 2048 个值**。纸带 10829 → 13717。
|
||||
* 单点验证驱动:`drv/div_shift.r8asm`(跨格左移 + 注入那一步,`SPEC §14.4` 第 1 条)。
|
||||
* 顺带修了两处**会骗人的东西**:`r8forge_derive` 以前不看汇编器的 error 位,漏
|
||||
`%include`(`unknown macro`)时会拿**截断的纸带**跑出一个看起来正常的错答案
|
||||
(这轮踩过一次,四个数字全变成 `'0'`);`raw_sub` 注释里把 Bo 的语义写反了
|
||||
(Bo = 1 是"没借位"= `A >= B`,实测 15-10 → 1、10-15 → 0)。
|
||||
|
||||
# R = (Rhi:Rlo) 左移一格,并把 N 的 LSB 注进 Rlo 的 bit0
|
||||
# 期望:Rlo 的 bit W-1 进 Rhi 的 bit0;Rlo 的 bit0 = N 的 LSB
|
||||
r8forge_derive drv/<新驱动>.r8asm -1 0=<Rlo> 2=<Rhi> 4=<N>
|
||||
**下一步可以做的(这轮没做)**:
|
||||
|
||||
顺序(`clb_mul` 当年在这里返工两轮):`rol` 把要注入的那位搬到 bit0、用 `bit_copy`
|
||||
(38 字符,保留源)搬过去、再 `ror` 回来;**先搬 Rlo→Rhi,再清 Rlo 的绕回位**。
|
||||
|
||||
**第二步**:按 §14.3 拼整轮 —— `raw_sub`(现成的,保留操作数)+ `clb_bit_or`(commit =
|
||||
`Rhi | Bo`)+ `clb_bit_and`(新高位 = `Rhi & Bo`)+ `biz` 门控提交 + `clb_bit_mov` 写商位。
|
||||
|
||||
**验收**(§14.5):和现有 `clb_divmod` 跑同一张 76 组抽样表逐对比 Q/R;步数前后对比
|
||||
(`2047/10`、`2047/2`、`999/7`、`2047/1` —— 最后一个现在会 HANG);`clb_digits` 换上新
|
||||
除法器后 11 位下 11 个值全对且步数从 1.48M 降到几万。**半成品不要提交**。
|
||||
* 想再快一档:`SPEC §14.6` 那条"开循环前预计算 `~D`、每轮走 `raw_add`",按单轮实测
|
||||
差值估计 `clb_divmod` 28.6k → 约 17.6k 步,纸带基本不变;没换是因为 §14.3 指名
|
||||
用 `raw_sub`,而它是上一轮专门为长除法加的。
|
||||
* 纸带还能短:`clb_digits` 的布局没优化过(13 格草稿跨得很开,`.tp` 行走占了纸带的
|
||||
七成);`clb_divmod` 里提交时那个 495 字符的 `copy` 也还是全展开的。
|
||||
* 小 N/D 的慢是"固定 W 轮"的必然代价。真要治,得加"跳过前导 0 轮"(`R == 0` 的轮
|
||||
只剩 Q 的旋转),但那会给**每一轮**加一次 `clb_nonzero`(约 300 步),大数反而更慢
|
||||
—— 这轮权衡过,没做。
|
||||
|
||||
**别动**:`asm/` 里其它宏;`%synth` 的指令模型(改了就 bump `kModelVersion`);
|
||||
`geometry.hh` 的位宽(真要改照 SPEC §13 的清单,四份虚拟机一起)。
|
||||
|
||||
|
||||
**当前基线(都通过,别弄坏)**:
|
||||
|
||||
```sh
|
||||
r8forge asm/test.r8asm # 28729 字符
|
||||
r8forge_byte_op_test # 20 项(含 clb_digits 的 11 个值)
|
||||
r8forge_byte_op_test # 20 项(clb_divmod 16384 组、clb_digits 2048 个值)
|
||||
r8forge_macro_docs_test # 47 macros in 21 files
|
||||
r8forge_synth_test examples/full_add.r8asm # all eight combinations ok
|
||||
r8forge_derive verify_loop.r8asm -1 0=5 # out 5 0
|
||||
@@ -119,13 +129,19 @@ 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_derive verify_loop.r8asm -1 0=5 # 动态循环:跑 5 次,out 应该是 5 0
|
||||
r8forge_byte_op_test # 字节级库:20 个操作穷举/抽样,1.5 秒
|
||||
r8forge_byte_op_test # 字节级库:20 个操作穷举/抽样,这台机器约 10 秒
|
||||
r8forge_macro_docs_test # asm/ 里每个宏的注释格式
|
||||
```
|
||||
|
||||
`r8forge_byte_op_test` 是**唯一按返回值判断字节级对错的**;前三个只证明"汇编得出来"或
|
||||
"位级正确"。
|
||||
|
||||
**`r8forge_derive` 会检查汇编错误**(2026-11 修的):`import_file` 只表示"文件打开了",
|
||||
漏一条 `%include` 时汇编器会报 `unknown macro '...'` 并把 error 位置上、纸带是**截断**的。
|
||||
以前 `derive` 不看这个标志,于是拿半截纸带跑出一个看起来正常的错答案(这轮实测踩到:
|
||||
`clb_digits` 少了 `add_ip` 的 include,四个数字全变成 `'0'`)。现在它会打印
|
||||
`could not assemble` 并返回 1 —— **看到 `out` 结果"太整齐"就先看 stderr**。
|
||||
|
||||
`r8forge_derive` 是验证工具:
|
||||
|
||||
```sh
|
||||
@@ -228,7 +244,8 @@ inline constexpr uint32_t kDefaultCellMask = (1u << kDefaultCellSize) - 1u;
|
||||
|
||||
## 字节级运算(一个 cell 一个机器字,默认 11 位)
|
||||
|
||||
结论:**库里的字节级宏是对的,穷举全过**。`r8forge_byte_op_test` 实测(1.5 秒)。
|
||||
结论:**库里的字节级宏是对的,穷举全过**。`r8forge_byte_op_test` 实测(这台机器约 10 秒;
|
||||
2026-11 把 `clb_divmod` 扩到 16384 组、`clb_digits` 扩到全部 2048 个值之后)。
|
||||
下面的纸带长度都是 **11 位 cell** 下的值(8 位时代的数字见 git 历史):
|
||||
|
||||
| 宏 | 驱动 | 纸带 | 结果 |
|
||||
@@ -251,8 +268,8 @@ inline constexpr uint32_t kDefaultCellMask = (1u << kDefaultCellSize) - 1u;
|
||||
| **`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(位宽) 运行) |
|
||||
| **`clb_ones`(数量 → 从末位起 N 个 1,4 cell)** | `drv/ones.r8asm` | **742 字符**(带 output)/ **828**(最小驱动) | **12 个计数全对**(N=0..11) |
|
||||
| **`clb_divmod`(N div D / N mod D,7 cell)** | `drv/divmod.r8asm` | **4189 字符**(最小驱动)/ 4195(带 output) | **76 组抽样全对**(O(N/D) 运行,`2047/1` 会撞步数上限) |
|
||||
| **`clb_digits`(整数 → 4 位 ASCII 十进制,16 cell)** | `drv/digits.r8asm` | **10829 字符**(最小驱动)/ 13743(带 output) | **11 个值全对**(0/7/10/99/100/512/1000/1234/2047 等) |
|
||||
| **`clb_divmod`(N div D / N mod D,11 cell)** | `drv/divmod.r8asm` | **4499 字符**(最小驱动)/ 4511(带 output) | **16384 组全对**(8 个除数 × 全部 2048 个被除数;固定 11 轮,最坏 32,383 步,`2047/1` 不再挂) |
|
||||
| **`clb_digits`(整数 → 4 位 ASCII 十进制,18 cell)** | `drv/digits.r8asm` | **13717 字符**(最小驱动)/ 13741(带 output) | **全部 2048 个值全对**(最坏 164,867 步;2047 是 14.5 万步) |
|
||||
| **`raw_sub`(A-B,**保留 A、B**,Bo = 没借位,7 cell)** | `drv/raw_sub.r8asm` | **≈2900 字符** | **9 组抽样全对**;长除法要用它(`clb_sub_nc` 会把操作数吃掉) |
|
||||
| `asm/fibonacci.r8asm` | — | 11959 字符 | 跑出 13 项 `1 1 2 3 5 8 13 21 34 55 89 144 233` |
|
||||
|
||||
@@ -520,7 +537,7 @@ SPEC 第 136-150 行的标准宏前缀:
|
||||
| `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_ones` | 破坏性的纯计算(把"数量"展开成从末位起的一串 1,输入被吃干净);结果写在另一个 cell 里,所以也不带 `_ip` |
|
||||
| `clb_divmod` | 破坏性的纯计算(除/取模,商和余数各落在自己的 cell 里);N、D 都被吃干净,所以不带 `_ip` |
|
||||
| `clb_divmod` | 破坏性的纯计算(除/取模,商 Q、余数 R 各落在自己的 cell 里,`S` 起 7 格草稿由调用者传);N、D 现在**保留**,`clb` 指的是 Q 和草稿块会被覆盖 |
|
||||
| `clb_digits` | 破坏性的纯计算(整数 → 一串 ASCII 数字),输入被吃干净、结果写在连续区域里,所以不带 `_ip` |
|
||||
| `loop` / `endloop` | 结构性的**宏对**(开/收一个运行时循环),不带前缀;不开 anchor 所以能嵌套,收口后 dp 停在计数器上 |
|
||||
| `clb_bit_mov` | 位级搬运,并且把源吃掉 |
|
||||
|
||||
@@ -414,36 +414,70 @@ A 的 12 个取值全对(`r8forge_byte_op_test` 的 `test_ones`)。
|
||||
|
||||
### 7.6 `clb_divmod`:除法与取模
|
||||
|
||||
`clb_divmod N D Q S`:`Q = N div D`、**`N` 结束时就是余数 R**,D 被吃干净。
|
||||
7 个 cell(3 个数据 + `S` 起的 4 个连续草稿),纸带 **4189 字符**
|
||||
(`drv/divmod.r8asm` 是 4195),76 组抽样全对(`r8forge_byte_op_test` 的 `test_divmod`)。
|
||||
`clb_divmod N D Q R S`:`Q = N div D`、`R = N mod D`,**N 和 D 都保持原样**。
|
||||
11 个 cell(N、D、Q、R 四个数据 + `S` 起的 7 个连续草稿),纸带 **4499 字符**
|
||||
(`drv/divmod.r8asm` 是 4511);`r8forge_byte_op_test` 的 `test_divmod` 现在扫
|
||||
**8 个除数 × 全部 2048 个被除数 = 16384 组**,全对(旧的 76 组抽样表是它的子集)。
|
||||
|
||||
算法是最钝的那招:
|
||||
草稿格里**只有 `S+5`(`buf`)进来必须是干净的**(它是 `copy`/`bit_copy` 的缓冲,
|
||||
缓冲带垃圾时拷贝结果是 0);其它格子脏了没关系 —— 要么整格重写(`raw_add` 逐位写
|
||||
`Sd`/`Bo`),要么只按一位用(`Rhi`/`Cm`/`Bo`),`NR` 每次进来都会重建成 W 个 1。
|
||||
`clb_digits` 就是这么反复用同一块草稿的。
|
||||
|
||||
Q = 0
|
||||
while N >= D: N -= D ; Q += 1
|
||||
算法是**二进制长除法(移位-恢复)**,从被除数的最高位往下一位一位串:
|
||||
|
||||
三处踩出来的设计:
|
||||
R = 0 ; Q = 0
|
||||
repeat _CELL_SIZE 轮:
|
||||
R = (R << 1) | (N 的下一位) ; 每轮 rol N,下一位落在 N 的 LSB
|
||||
if R >= D: R -= D ; 商位 = 1 else: 商位 = 0
|
||||
|
||||
1. **`clb_sub_nc` 会把 N 和 D 都吃掉**,而减法**不能用 `S == A` 的别名** —— 实测
|
||||
`clb_sub_nc A B A Ci`(A=15 B=10 Ci=1)直接给出 `0`。所以每轮都得 copy 出 `S = N`、
|
||||
`S+1 = D` 再减,三个 copy 里有两个是"过路费"。
|
||||
2. **首轮要能什么都不做**:`S+2` 预置成 `N`、`Q` 预置成 `-1`。于是第一轮"提交 `S+2 -> N`"是
|
||||
空操作,`Q += 1` 正好把 −1 补回 0;探测放在循环体**末尾**,所以零轮(`N < D`)和一轮
|
||||
(`N == D`)都对,而且**探测代码只出现一次**(不这么写要多 1.3k)。
|
||||
3. **草稿参数只给基址**:`.tp` 和宏实参都接受地址表达式(`S+1` 能编译,`copy %4+2 %4`
|
||||
就是 `.tp S+2` + `copy S S`),所以 4 个草稿格当一个块传。一开始写成 9 个参数
|
||||
(每个草稿单列 + 单独的拷贝缓冲和自增草稿),压成基址后**顺带短了 1.6k**。
|
||||
轮数 = 位宽,**跟 N、D 的值无关**。旧版是重复减法 O(N/D),`2047/1` 要 2047 轮、
|
||||
直接撞 500 万步上限(实测 HANG)。实测(同一条 `drv/divmod.r8asm`,11 位):
|
||||
|
||||
`O(N/D)` 的代价要记住:`2047 / 1` 会撞 500 万步上限(实测 HANG),每轮约 2.4k 步,
|
||||
所以 **N/D 最多到 1500 左右**;`2047 / 2` 是 1023 轮,正常返回 `1023 1`。
|
||||
除零没有定义,调用者保证 `D >= 1`。
|
||||
| 算式 | 重复减法(旧) | 移位-恢复(现在) |
|
||||
|---|---|---|
|
||||
| `2047/10` | 495,986 | **28,593** |
|
||||
| `2047/2` | 2,461,650 | **31,997** |
|
||||
| `999/7` | 340,086 | **28,661** |
|
||||
| `2047/1` | **HANG**(>500 万) | **32,383** |
|
||||
| `7/10` | 3,014 | 25,315 |
|
||||
| `100/7` | 34,940 | 27,460 |
|
||||
|
||||
代价和 `clb_mul` 一样:**N/D 很小时反而慢**(旧版 N/D 轮就结束,新版固定走满 11 轮),
|
||||
换来"除数和商再大也不会挂"。16384 组里实测最坏 **32,383** 步。
|
||||
|
||||
三个设计点:
|
||||
|
||||
1. **W+1 位比较拆成"一个 W 位减法 + 一个布尔"**:左移之后 R 最多 W+1 位,最高位
|
||||
(`Rlo` 左旋绕回来的那一位,记 H)落在 `Rhi` 里。H = 1 时 R >= 2^W > D **必然提交**,
|
||||
而且 R − D 的低 W 位正好是 `S = Rlo − D (mod 2^W)`;H = 0 时就是普通的
|
||||
"`Rlo >= D` 才提交"。所以**提交条件 = H | Bo**(一条 `clb_bit_or`),不用真去做
|
||||
W+1 位减法(§14.2)。
|
||||
2. **"提交后的新高位"恒为 0,不用算**:提交之后 R < D < 2^W,下一轮开头高位就是 0;
|
||||
而 H = 1、Bo = 1 这个组合在"每轮开头 R < D"的归纳下不可能出现(它会要求
|
||||
R = 2^W + Rlo >= 2D)。所以 §14.2 里写过的 `Shi = H & Bo`、那个 `clb_bit_and`
|
||||
和一次 copy 都可以省掉 —— `Rhi` 只是个轮内布尔,`clb_bit_or` 顺手就把它吃掉。
|
||||
3. **D 必须保留**:每轮都要拿同一个除数去比/减,所以走 `raw_sub`(保留操作数、
|
||||
只吃草稿)。这也是上一轮加 `raw_sub` 的原因(§7.8)。
|
||||
|
||||
踩过的三个坑:
|
||||
|
||||
* **R 的跨格左移顺序**:`rol` 把 `Rlo` 的最高位绕回 bit0,必须先 `clb_bit_mov` 把它
|
||||
搬进 `Rhi`(搬的同时清掉绕回位),**再** `bit_copy` 从 N 注一位。反了就丢位 ——
|
||||
`clb_mul` 当年在这里返工两轮。
|
||||
* **`biz`/`rnz` 是循环对**:门控提交的身体最后必须把条件吃掉(`flb`);商位那一步
|
||||
把"提交时 `set_1`、把条件清掉"合在同一个块里。条件块的身体都回到自己的条件 cell。
|
||||
* **N 不被消耗**:每轮 `rol` 一次,转满 11 轮自己复原;注入用 `bit_copy`(保留源,
|
||||
38 字符)。所以余数得单独占一格 R —— 旧版"余数就在 N 里"的约定没有了。
|
||||
|
||||
除零没有定义,调用者保证 `D >= 1`(D = 0 时 R >= 0 恒成立,商会变成全 1)。
|
||||
|
||||
### 7.7 `clb_digits`:整数转十进制字符串
|
||||
`clb_digits N REG S`:把 N 展开成 **`REG..REG+3` 四个连续 cell,每格一个 ASCII 数字
|
||||
(`'0'..'9'`),高位在前、定长 4 位、左边补 `'0'`**(11 位 cell 最大 2047,正好 4 位)。
|
||||
N 被吃干净;`REG` 起 4 格、`S` 起 8 格必须连续且干净。纸带 **10829 字符**(最小驱动),
|
||||
11 个值全对(`r8forge_byte_op_test` 的 `test_digits`)。
|
||||
N 被吃干净;`REG` 起 4 格、`S` 起 **13 格**必须连续且干净。纸带 **13717 字符**
|
||||
(最小驱动,旧版 10829 —— divmod 的草稿块从 4 格变成 7 格,而且多了一格余数),
|
||||
`r8forge_byte_op_test` 的 `test_digits` 现在**穷举全部 2048 个值**(最坏 164,867 步)。
|
||||
|
||||
2047 -> REG = '2' '0' '4' '7'
|
||||
7 -> REG = '0' '0' '0' '7'
|
||||
@@ -458,16 +492,31 @@ N 被吃干净;`REG` 起 4 格、`S` 起 8 格必须连续且干净。纸带 *
|
||||
挪的顺序必须**从高到低**(`REG+2 -> REG+3` 先做),否则会把还没搬的高位盖掉。
|
||||
4 轮之后 `REG+0..3` 正好是千、百、十、个。
|
||||
|
||||
`S` 起的 13 格是这么排的(`clb_divmod` 要一块 7 格的连续草稿,所以它从 `S+3` 开始):
|
||||
|
||||
S+0 TEN(除数) ; S+1 商 ; S+2 余数(这一位的数字)
|
||||
S+3..S+9 clb_divmod 的草稿块(Rhi、Sd、Bo、Cm、Ci、buf、NR)
|
||||
S+10 轮数计数器(loop) ; S+11/S+12 clb_add_ip 的 T、F
|
||||
|
||||
挪位链和"商 -> N"的拷贝都借 `S+8`(divmod 的 buf)当缓冲 —— 那个格子在 divmod 结束时
|
||||
是干净的。余数现在单独占一格(旧版是"余数就在 N 里"),所以 `REG+0 = '0' + 余数` 读的是
|
||||
`S+2`;下一轮的 N 还是靠 `copy` 从商搬回去。
|
||||
|
||||
第一版是"4 个分支 + one-hot flag 分派",**只写对了第一支**(其余三支没触发),换成
|
||||
整体挪位后不仅正确,还少了两层嵌套、4 个 cell 和一堆 flag 交接。教训:
|
||||
**在这台只有 `biz`/`rnz` 的机器上,"选一个格写"最好用位置移动表达,别用索引分派。**
|
||||
|
||||
两个搭这条宏时踩出来的坑(都写进了宏注释):
|
||||
三个搭这条宏时踩出来的坑(都写进了宏注释):
|
||||
|
||||
* **`copy` 的缓冲格必须是干净的**:缓冲里带垃圾时拷贝结果是 **0**(实测 `Q=4`、缓冲
|
||||
`0x7f8` → `N=0`)。库注释只说了"`b` 是借来的缓冲",没提这条。
|
||||
* **造常数不能分两次"置位再转"**:第二次旋转会把第一次放好的位一起带走。正确做法是
|
||||
**绕整圈走一次**(`W` 次 `ror`,转到目标位就 `set_1`,最后转回原位)。
|
||||
* **换了 divmod 之后要记得补 include**:`clb_add_ip` 原来是从旧的 `divmod.r8asm` 里
|
||||
间接 include 进来的,新的 `divmod.r8asm` 不再 include 它(它只 include `raw_sub` /
|
||||
`raw_or`),所以 `digits.r8asm` 现在自己 `%include "asm/add_ip.r8asm"`。
|
||||
漏了的话汇编器会报 `unknown macro '(clb_add_ip'`(**而 `r8forge_derive` 以前会忽略
|
||||
这个错误、接着跑半截纸带**,见 §11 的说明)。
|
||||
|
||||
### 7.8 `raw_sub`:保留操作数的减法(长除法的地基)
|
||||
|
||||
@@ -485,7 +534,9 @@ N 被吃干净;`REG` 起 4 格、`S` 起 8 格必须连续且干净。纸带 *
|
||||
|
||||
存在的理由:`clb_sub_nc` 会吃掉 A 和 B,所以"重复减法"的除法器每轮都得 copy 两个
|
||||
副本;二进制长除法每轮都要拿同一个除数去比/减,必须有个不破坏操作数的减法。
|
||||
这是把 `clb_divmod` 从 O(N/D) 换成 O(位宽) 的第一步。
|
||||
`clb_divmod` 换成长除法(§7.6)之后,每一轮开的就是它。另外实测过一次"预计算
|
||||
`~D` 再走 `raw_add`"的写法(同样的纸带、每轮少一次 copy,单轮 2019 → 973 步),
|
||||
但 §14.3 的设计指名用 `raw_sub`、而且它是上一轮专门为长除法加的,所以没有换。
|
||||
|
||||
---
|
||||
|
||||
@@ -568,16 +619,23 @@ clb_add_ip PH Ci S F ; 把进位加进高字节(Ci 被吃)
|
||||
|
||||
| 测试 | 覆盖 | 断言口径 |
|
||||
|---|---|---|
|
||||
| `r8forge_byte_op_test` | 20 个测试项 = 19 个宏(`clb_neg_nc` 的 Ci=1 / Ci=0 各算一项),见 §7.1、§7.2、§7.5、§7.6、§7.7、§8、§9 | **按返回值**:穷举 0..255(`clb_add_ip` 2048 抽样、`clb_mul` 65536 全穷举、`clb_ones` 12 个计数全穷举、`clb_divmod` 76 组抽样、`clb_digits` 11 个值全穷举),任一不符即退出码非 0 |
|
||||
| `r8forge_byte_op_test` | 20 个测试项 = 19 个宏(`clb_neg_nc` 的 Ci=1 / Ci=0 各算一项),见 §7.1、§7.2、§7.5、§7.6、§7.7、§8、§9 | **按返回值**:穷举 0..255(`clb_add_ip` 2048 抽样、`clb_mul` 65536 全穷举、`clb_ones` 12 个计数全穷举、`clb_divmod` 8 个除数 × 全部 2048 个被除数 = 16384 组全穷举、`clb_digits` 全部 2048 个值全穷举),任一不符即退出码非 0 |
|
||||
| `r8forge_synth_test examples/full_add.r8asm` | `%synth` 端到端:汇编 + 跑 8 种输入 | `all eight combinations ok` |
|
||||
| `r8forge verify_clb_bit_add_nc.r8asm` | 4 cell 加法切片(进位进→出) | 单点:`0+0+Ci` |
|
||||
| `r8forge verify_clb_bit_inc_nc.r8asm` | 3 cell 自增切片 | 单点 |
|
||||
| `r8forge_derive verify_loop.r8asm -1 0=N` | 动态循环:`N=0..11` 时循环体跑 `N` 次(`A = N`、`C = 0`) | 逐值 `out` |
|
||||
| `r8forge verify_set_0.r8asm` | `set_0` 只清 LSB | `-1 0=255 → 254`、`0=128 → 128` |
|
||||
| `r8forge_macro_docs_test` | `asm/` 里 46 个宏的注释格式 | 全绿或报错行号 |
|
||||
| `r8forge_macro_docs_test` | `asm/` 里 47 个宏的注释格式 | 全绿或报错行号 |
|
||||
| `r8forge_tape_run <tape.rot8>` | 第二个解释器,直接跑纸带 | 与 `r8forge_derive` 对答案 |
|
||||
| `r8forge_derive <src> -1/-2` | 拿汇编源码跑,打印 `out` / 非零 cell | 人工/脚本比对 |
|
||||
|
||||
`r8forge_derive` 现在**会检查汇编错误**:`import_file` 只表示"文件打开了",漏一条
|
||||
`%include`(`unknown macro`)时汇编器的 error 位会被置上、纸带是**截断**的 —— 以前
|
||||
`derive` 不看这个标志,于是会拿半截纸带跑出一个看起来正常的错答案(实测踩过:
|
||||
`clb_digits` 少 include `add_ip` 时四个数字全是 `'0'`)。现在它和其它入口一样打印
|
||||
`could not assemble` 并返回 1。**看到 `out` 结果"太整齐"就先看 stderr 有没有这句。**
|
||||
|
||||
|
||||
只有 `r8forge_byte_op_test` 是**按返回值**判断字节级对错的;其它要么只证明"汇编得出来"、
|
||||
"位级正确",要么是单点探针。改宏之后跑 §11 前四个(外加 docs test)。
|
||||
|
||||
@@ -609,56 +667,105 @@ clb_add_ip PH Ci S F ; 把进位加进高字节(Ci 被吃)
|
||||
|
||||
---
|
||||
|
||||
## 14. 下一步:把 `clb_divmod` 换成移位-恢复除法(设计已推完,未实现)
|
||||
## 14. 移位-恢复除法(已实现;这一节是设计推理 + 实测数据,契约看 §7.6)
|
||||
|
||||
现在 `clb_divmod` 是重复减法,O(N/D)。`2047 / 10` 要 205 轮、**148 万步**;
|
||||
`clb_digits` 的 1.48M 步几乎全花在这儿。换成二进制长除法是 **W 轮**(11 轮),
|
||||
预计 **~35k 步(快 40 倍)**,纸带大体相当(~4k)。
|
||||
`clb_divmod` 已经从重复减法换成二进制长除法(`asm/divmod.r8asm`)。
|
||||
|
||||
### 14.1 每轮的状态
|
||||
### 14.1 为什么换、每轮的状态
|
||||
|
||||
旧版 O(N/D):`2047/1` 要 2047 轮、每轮约 2.4k 步,直接撞 500 万步上限(实测 HANG)。
|
||||
新版固定 **W 轮**(11 轮),跟 N、D 的值无关。
|
||||
|
||||
N 被除数(W 位)。每轮 `rol N`,于是 N 的 LSB 就是**最高位起**的下一位
|
||||
(rol 把 bit W-1 转到 bit0) —— 转满 W 轮 N 自动复原,不被消耗
|
||||
R 部分余数,需要 **W+1 位** → 两格:Rlo(低 W 位)+ Rhi(只有 bit0)
|
||||
D 除数(W 位),**每轮都要拿它去比/减 → 必须保留** —— 这就是 `raw_sub` 存在的理由
|
||||
S 减法结果(W 位,Rlo - D)
|
||||
(rol 把 bit W-1 转到 bit0) —— 转满 W 轮 N 自动复原,所以 N 不被消耗
|
||||
R 部分余数 = (Rhi:Rlo),Rlo 是普通 cell,Rhi 只有 bit0 有意义(轮内布尔)
|
||||
D 除数(W 位),每轮都要拿它去比/减 → 必须保留 → 这就是 `raw_sub` 存在的理由
|
||||
Sd 减法结果(W 位,Rlo - D)
|
||||
Bo raw_sub 给的"没借位"(1 表示 Rlo >= D)
|
||||
|
||||
每轮: `R = (R << 1) | 位`,然后 `R >= D ? (R -= D, 商位 = 1) : (商位 = 0)`。
|
||||
每轮:`R = (R << 1) | 位`,然后 `R >= D ? (R -= D, 商位 = 1) : (商位 = 0)`。
|
||||
|
||||
### 14.2 关键推导:W+1 位比较拆成"一个 W 位减 + 两个布尔"
|
||||
### 14.2 W+1 位比较拆成"一个 W 位减 + 一个布尔"(实际用到的版本)
|
||||
|
||||
`R = (Rhi:Rlo)`、`D < 2^W`。先算 `S = Rlo - D` 与 `Bo = (Rlo >= D)`,那么
|
||||
`R = (Rhi:Rlo)`、`D < 2^W`。先算 `Sd = Rlo - D` 与 `Bo = (Rlo >= D)`,那么
|
||||
|
||||
提交(R >= D) ⟺ Rhi == 1 或 Bo == 1 → **commit = Rhi | Bo**
|
||||
提交后的新高位 ⟺ Rhi == 1 且 Bo == 1 → **Shi = Rhi & Bo**
|
||||
|
||||
四种情况都对得上(`Rhi = 0, Bo = 0` 就是 `R < D`,不提交)。所以**不需要真的做
|
||||
W+1 位减法**,只要一个 W 位 `raw_sub`(顺带给出 Bo)+ 一个按位或 + 一个按位与。
|
||||
W+1 位减法**,只要一个 W 位 `raw_sub`(顺带给出 Bo)+ 一个按位或。
|
||||
|
||||
### 14.3 每轮骨架
|
||||
原设计里还有一条 `Shi = Rhi & Bo`("提交后的新高位")和对应的 `clb_bit_and`,
|
||||
**实际实现把它省掉了**:每轮开头 R < D < 2^W(提交之后 R 一定小于 D),所以 Rhi
|
||||
在轮首恒为 0;而 `Rhi = 1 且 Bo = 1` 这个组合会要求 R = 2^W + Rlo >= 2D,与
|
||||
"轮首 R < D ⇒ 左移后 R < 2D" 矛盾,不可能出现。于是新高位恒为 0,Rhi 只是轮内的
|
||||
H,`clb_bit_or` 顺手把它清零就够了 —— 省一个 `clb_bit_and`、一次 copy 和一个变量。
|
||||
|
||||
rol N ; 下一位进 N 的 LSB
|
||||
<R 跨格左移一格,并把 N 的 LSB 注入 Rlo 的 bit0> ; bit_copy(38,保留源)
|
||||
raw_sub Rlo D S Bo Bc Ci buf ; ≈2200 步
|
||||
clb_bit_or Rhi Bo Commit
|
||||
clb_bit_and Rhi Bo Shi
|
||||
.tp Commit ; biz ; copy S -> Rlo ; copy Shi -> Rhi ; <吃掉条件> ; rnz
|
||||
rol Q
|
||||
.tp Commit ; clb_bit_mov Q ; 商位 = commit(顺带清 Q 的 bit0)
|
||||
### 14.3 每轮实际骨架(`asm/divmod.r8asm`)
|
||||
|
||||
### 14.4 风险与坑(按 `clb_mul` 的经验)
|
||||
.tp N ; rol ; 下一位进 N 的 LSB
|
||||
.tp R ; rol ; clb_bit_mov Rhi ; Rlo 左移,绕回位先搬进 Rhi(顺带清 bit0)
|
||||
.tp N ; bit_copy Rlo buf ; 注入这一位(38 字符,保留 N)
|
||||
raw_sub Rlo D Sd Bo Cm Ci buf ; Sd = Rlo - D,Bo = (Rlo >= D)
|
||||
clb_bit_or Rhi Bo Cm ; 提交条件(两个输入都被吃掉)
|
||||
.tp Q ; rol ; 商左旋一位(bit0 一定是 0)
|
||||
.tp Cm ; biz
|
||||
.tp Sd ; copy R buf ; R = Sd(495 字符,只在提交时跑)
|
||||
.tp Q ; set_1 ; 商位 = 1
|
||||
.tp Cm ; flb ; 吃掉条件
|
||||
rnz
|
||||
.tp NR ; set_0 ; ror ; 轮数吃掉一个
|
||||
|
||||
1. **R 的跨格左移是唯一会反复的地方**。`clb_mul` 当年在这里返工两轮:`rol` 会把
|
||||
Rlo 的最高位绕回 bit0,所以必须**先把它搬进 Rhi 的 bit0,再清掉 Rlo 的绕回位**,
|
||||
顺序错了就丢位。
|
||||
2. **`biz` 是循环对**:门控提交的 body 最后必须把条件吃掉(`flb`),否则 `rnz` 跳回去。
|
||||
7 个草稿格(`S+0..S+6`):Rhi、Sd、Bo、Cm(= `raw_sub` 的 Bc,兼提交标志)、Ci、
|
||||
buf、NR。固定代价里最大的是 `raw_sub` 的 2793 字符和提交时那个 `copy` 的 495 字符。
|
||||
|
||||
### 14.4 坑(都踩过或实测过)
|
||||
|
||||
1. **R 的跨格左移顺序**:`rol` 把 Rlo 的最高位绕回 bit0,必须**先**把它搬进 Rhi
|
||||
(`clb_bit_mov` 搬的同时清掉绕回位),**再** `bit_copy` 注入 N 的那一位。
|
||||
顺序错了就丢位 —— `clb_mul` 当年在这里返工两轮。单点验证驱动是
|
||||
`drv/div_shift.r8asm`(`r8forge_derive drv/div_shift.r8asm -1 0=1024 2=0 4=1`
|
||||
等三条,见文件头)。
|
||||
2. **`biz` 是循环对**:门控提交的 body 最后必须把条件吃掉(`flb`);商位的 `set_1`
|
||||
和那个 `flb` 合在同一个块里。条件块的身体都回到自己的条件 cell(净位移 0)。
|
||||
3. **Rhi 只有 bit0 有意义**,它当布尔用,别当字节。
|
||||
4. 轮数计数器:`%rep _CELL_SIZE { set_1; ror }` 造 W 个 1(那串 1 落在高位,要补一条
|
||||
`rol` 让 bit0 也是 1),或者用 `%for` + `clb_ones`。
|
||||
4. **轮数计数器**:`%rep _CELL_SIZE { set_1; ror }` 造出来的就是 W 个 1,轮首的 LSB
|
||||
已经是 1、**不用再补一条 `rol`** —— 原来的设计笔记里说要补,实测不需要
|
||||
(`clb_mul` 也是这么用的)。
|
||||
5. **N 要保留就得用 `bit_copy`**(保留源),不能用 `clb_bit_mov`(吃源);代价是
|
||||
每轮 38 字符 + 约 40 步。余数因此要单独一格 R(旧版"余数就在 N 里"的约定没有了)。
|
||||
|
||||
### 14.5 验收
|
||||
### 14.5 验收(实测)
|
||||
|
||||
* **Q/R 逐对比**:`byte_op_test` 的 `test_divmod` 现在跑 **8 个除数 × 全部 2048 个
|
||||
被除数 = 16384 组**(旧的 76 组抽样表是它的子集),全对;顺带断言 N、D 原样返回。
|
||||
* **步数**(`drv/divmod.r8asm`,11 位):
|
||||
|
||||
| 算式 | 旧(重复减法) | 新(移位-恢复) |
|
||||
|---|---|---|
|
||||
| `2047/10` | 495,986 | **28,593** |
|
||||
| `2047/2` | 2,461,650 | **31,997** |
|
||||
| `999/7` | 340,086 | **28,661** |
|
||||
| `2047/1` | **HANG**(>500 万) | **32,383** |
|
||||
| `7/10` | 3,014 | 25,315 |
|
||||
| `100/7` | 34,940 | 27,460 |
|
||||
|
||||
16384 组里最坏 **32,383** 步。**N/D 很小时反而慢**(固定 11 轮),和 `clb_mul`
|
||||
的取舍一样:拿它换"除数和商再大也不会挂"。
|
||||
* **`clb_digits`**:`test_digits` 现在**穷举全部 2048 个值**,全对;`0=2047` 从
|
||||
740,695 步降到 **145,138** 步(最坏 164,867 —— 小值反而慢,同上)。纸带
|
||||
`clb_digits` **13717**(旧 10829),`clb_divmod` **4499**(旧 4189)。
|
||||
|
||||
**纠正一个流传的数字**:本节原来写"`2047/10` 要 148 万步"、"`clb_digits` 的 1.48M 步"。
|
||||
按 §1.3 的口径实测旧实现是 **495,986**(`2047/10`)和 **740,695**(digits `0=2047`),
|
||||
没有 148 万 —— 那个数不知道是别的驱动还是别的版本量的,**别再引用**。
|
||||
|
||||
### 14.6 没做的优化(想让除法再快一档的话)
|
||||
|
||||
把"每轮 copy 一份 D 再取反"(`raw_sub` 内部,单轮 2019 步)换成**开循环前预计算
|
||||
`NegD = ~D`、每轮只跑 `raw_add Rlo NegD Ci Sd Bo buf`**:单轮 973 步(两者都是拿同一
|
||||
张驱动单独跑出来的),纸带基本不变(循环体 −594、循环外 +518,净 −76)。按这个差值
|
||||
估计 `clb_divmod` 28.6k → 约 **17.6k** 步(未实测)。没换的原因是 §14.3 指名用
|
||||
`raw_sub`、而它是上一轮专门为长除法加的(§7.8)。真要换的话注意:多一个 NegD 草稿格;
|
||||
`Ci = 1` 在循环外设一次就够(`raw_add` 结束会把 Ci 还原成进入时的值,实测两次调用都
|
||||
保持 1);`Bo` 语义不变(`A + ~D + 1` 的进位就是"没借位")。
|
||||
|
||||
* 和现在的 `clb_divmod` 跑同一张抽样表(76 组),逐对比 Q/R;
|
||||
* 步数对比:`2047/10`、`2047/2`、`999/7`、`2047/1`(最后这个现在会 HANG);
|
||||
* `clb_digits` 换上新除法器后,11 位下 11 个值全对、步数从 1.48M 降到几万。
|
||||
+23
-16
@@ -1,4 +1,5 @@
|
||||
%include "asm/divmod.r8asm"
|
||||
%include "asm/add_ip.r8asm"
|
||||
|
||||
; 整数 -> 十进制字符串:把值展开成 4 个连续 cell,每格低 8 位放一个 ASCII 数字。
|
||||
;
|
||||
@@ -7,7 +8,7 @@
|
||||
; 目标形态:**ASCII '0'..'9'、高位在前、定长 4 位、左边补 '0'**。
|
||||
; 11 位 cell 装得下 0..2047,也就是 4 位十进制,所以 L 写死 4。
|
||||
;
|
||||
; 朴素做法是 4 份 divmod(4x4189 ≈ 17k)。这里让 **divmod 只出现一次**:外面套一个
|
||||
; 朴素做法是 4 份 divmod(4x4499 ≈ 18k)。这里让 **divmod 只出现一次**:外面套一个
|
||||
; 跑 4 次的运行期循环,而且**不做"写哪一格"的分派** —— 每轮把已经写好的数字整体
|
||||
; 往高地址挪一格,新数字永远写 REG+0:
|
||||
;
|
||||
@@ -32,18 +33,24 @@
|
||||
; * **`copy` 的缓冲格必须是干净的**:缓冲带垃圾时拷贝结果是 0(实测)。
|
||||
; * **`%synth` 那句老话反过来**:造常数不能"置一位转到位、再置一位转到位" ——
|
||||
; 第二次旋转会把第一次放好的位一起带走;要**绕整圈走一次**。
|
||||
; * 区域格、S 起的草稿格进来时必须都是干净的(0)。
|
||||
; * **`clb_divmod` 的 N、D 现在都保留**,余数是单独一格;下一轮的 N 还是靠
|
||||
; `copy` 从商搬回去(旧版是"余数就在 N 里",这里多一格、少一次搬)。
|
||||
;
|
||||
; 前提:N = 值(结束时为 0);REG 起 4 格、S 起 8 格连续且干净。没有负数。
|
||||
; 前提:N = 值(结束时为 0);REG 起 4 格、S 起 13 格连续且干净。没有负数。
|
||||
;
|
||||
; S 起的格子是这么排的(divmod 要一块 7 格的连续草稿,所以它挪到 S+3):
|
||||
; S+0 TEN(除数) ; S+1 商 ; S+2 余数(这一位的数字)
|
||||
; S+3..S+9 clb_divmod 的草稿块(Rhi、Sd、Bo、Cm、Ci、buf、NR)
|
||||
; S+10 轮数计数器(loop) ; S+11/S+12 clb_add_ip 的 T、F
|
||||
|
||||
; Macro clb_digits
|
||||
; %1: Cell N
|
||||
; %2: Cell REG
|
||||
; %3: Cell S
|
||||
;
|
||||
; N 是值(被吃干净);REG..REG+3 是输出,ASCII 数字,高位在前;S 起的 8 个连续
|
||||
; cell 是草稿(S=10、S+1=商、S+2..S+5=divmod 的草稿块、S+6=轮数、S+7=拷贝缓冲),
|
||||
; 进来要求干净。
|
||||
; N 是值(被吃干净);REG..REG+3 是输出,ASCII 数字,高位在前;S 起的 13 个连续
|
||||
; cell 是草稿(S=10、S+1=商、S+2=余数、S+3..S+9=divmod 草稿块、S+10=轮数、
|
||||
; S+11/S+12=add_ip 的草稿),进来要求干净。
|
||||
%macro clb_digits 3
|
||||
.anchor before_clb_digits
|
||||
|
||||
@@ -52,7 +59,7 @@
|
||||
; L = 十进制位数 = floor(_CELL_SIZE * log10(2)) + 1,用 30103/100000 做整数近似:
|
||||
; 11 位 -> 4、16 位 -> 5、8 位 -> 3、32 位 -> 10,和 2^W-1 的真实位数一致。
|
||||
; **轮数因此自动跟着位宽走**,不用手改。
|
||||
.tp %3+6
|
||||
.tp %3+10
|
||||
set_1
|
||||
%rep _CELL_SIZE * 30103 / 100000
|
||||
rol
|
||||
@@ -60,7 +67,7 @@ set_1
|
||||
%endrep
|
||||
|
||||
; ---- 四位,一轮一位
|
||||
loop %3+6
|
||||
loop %3+10
|
||||
; 重建 TEN = 10(位 1、3):绕整圈,在 1 和 3 各置一个 1
|
||||
erase %3+0
|
||||
.tp %3+0
|
||||
@@ -74,15 +81,15 @@ loop %3+6
|
||||
ror
|
||||
%endrep
|
||||
|
||||
; N = 这位数字(0..9),Q = 商
|
||||
clb_divmod %1 %3+0 %3+1 %3+2
|
||||
; N = 这位数字(R,余数),Q = 商
|
||||
clb_divmod %1 %3+0 %3+1 %3+2 %3+3
|
||||
|
||||
; ---- 已有数字整体上移一格:从高到低搬。
|
||||
; 轮数 = L-1,用 %for 跟着位宽自动来(11 位 3 轮、16 位 4 轮)。
|
||||
%for k _CELL_SIZE * 30103 / 100000
|
||||
erase %3+7
|
||||
erase %3+8
|
||||
.tp %2 + _CELL_SIZE * 30103 / 100000 - 1 - k
|
||||
copy %2 + _CELL_SIZE * 30103 / 100000 - k %3+7
|
||||
copy %2 + _CELL_SIZE * 30103 / 100000 - k %3+8
|
||||
%endfor
|
||||
|
||||
; ---- REG+0 = '0' + 数字(位 4、5)。
|
||||
@@ -100,13 +107,13 @@ loop %3+6
|
||||
%rep _CELL_SIZE - 5
|
||||
ror
|
||||
%endrep
|
||||
clb_add_ip %2+0 %1 %3+2 %3+3
|
||||
clb_add_ip %2+0 %3+2 %3+11 %3+12
|
||||
|
||||
; ---- 下一位的被除数(缓冲要干净)
|
||||
erase %3+7
|
||||
erase %3+8
|
||||
.tp %3+1
|
||||
copy %1 %3+7
|
||||
endloop %3+6
|
||||
copy %1 %3+8
|
||||
endloop %3+10
|
||||
|
||||
.tp before_clb_digits
|
||||
%endmacro
|
||||
+79
-54
@@ -1,80 +1,105 @@
|
||||
%include "asm/raw_sub_nc.r8asm"
|
||||
%include "asm/add_ip.r8asm"
|
||||
%include "asm/raw_sub.r8asm"
|
||||
%include "asm/raw_or.r8asm"
|
||||
|
||||
; 除法/取模:Q = N div D,R 就是 N 自己。
|
||||
; 除法/取模:Q = N div D,R = N mod D。
|
||||
;
|
||||
; 用它自己那句老话:**只有纸带长度是目标**。所以这里不写长除法的移位/恢复,
|
||||
; 就是最钝的那招:
|
||||
; 算法是**二进制长除法(移位-恢复)**,从被除数的最高位往下一位一位串:
|
||||
;
|
||||
; Q = 0
|
||||
; while N >= D: N -= D ; Q += 1
|
||||
; R = 0 ; Q = 0
|
||||
; while 还剩一位没看:
|
||||
; R = (R << 1) | (N 的下一位)
|
||||
; if R >= D: R -= D ; 商位 = 1 else: 商位 = 0
|
||||
;
|
||||
; 循环体在纸带里只出现一次,长度和 N、D 的大小无关;代价是运行 O(N/D)
|
||||
; (N=2047、D=1 时约 2047 轮,会撞 500 万步上限,所以 N/D 别超过 1500 左右)。
|
||||
; 轮数 = 位宽(11 轮),**跟 N、D 的值无关** —— 这是它取代"重复减法"的唯一理由:
|
||||
; 旧版 O(N/D),`2047/1` 要 2047 轮、直接撞 500 万步上限(实测 HANG;`2047/2` 是
|
||||
; 246 万步)。现在 2047/10 和 2047/1 一样是十一轮。
|
||||
;
|
||||
; 三个关键点,都是踩出来的:
|
||||
; 三个细节(都是设计时推过、实测确认的):
|
||||
;
|
||||
; 1. **`clb_sub_nc` 会把 N 和 D 都吃掉**,而减法不能用 `S == A` 的别名
|
||||
; (实测 `clb_sub_nc A B A Ci` 直接给出 0)。所以每轮都要 copy 出 v = N、
|
||||
; d = D 再减 —— 三个 copy 里有两个是给它交的"过路费"。
|
||||
; 1. **W+1 位的比较拆成"一个 W 位减法 + 一个布尔"**:R 左移一格之后最多 W+1 位,
|
||||
; 最高位就是 Rlo 左旋绕回来的那一位(记 H)。H = 1 时 R >= 2^W > D 必然提交,
|
||||
; 而且 R - D 的低 W 位正好就是 S = Rlo - D(mod 2^W);H = 0 时就是普通的
|
||||
; "Rlo >= D 才提交"。所以**提交条件 = H | Bo**,一条 clb_bit_or 就够,不用真去
|
||||
; 做 W+1 位减法。H 只在轮内活着:提交之后 R < D < 2^W,下一轮开头高位是 0
|
||||
; (所以 §14.2 里那个"新高位 = H & Bo"恒为 0,不用算、也不用留 cell)。
|
||||
; 2. **R 的跨格左移**:rol 把 Rlo 的最高位绕回 bit0,所以先 clb_bit_mov 把它搬进
|
||||
; Rhi(搬的同时清掉绕回位),再 bit_copy 把 N 的 LSB 注进 Rlo 的 bit0。
|
||||
; 顺序反了就丢位 —— `clb_mul` 当年在这里返工两轮。
|
||||
; 3. **N 不被消耗**:每轮 rol 一次,转满 W 轮自己复原;注入用 bit_copy(保留源)。
|
||||
; D 每轮都要拿去比/减,所以用保留操作数的 raw_sub(这就是它存在的理由)。
|
||||
;
|
||||
; 2. **首轮要能"什么都不做"**:把 t 预置成 N,Q 预置成 -1。于是第一轮的
|
||||
; "提交 t -> N" 是空操作,"Q += 1" 正好把 -1 补回 0;探测放在循环体末尾,
|
||||
; 所以 `N < D`(零轮)和 `N == D`(一轮)都对,而且探测代码只出现一次。
|
||||
; 没有这个技巧就得在循环外面再写一遍探测,纸带多 1.3k。
|
||||
;
|
||||
; 3. **草稿只要一个基址**:`.tp` 和宏实参都接受地址表达式(`S+1` 能编译),
|
||||
; 所以 4 个草稿格当一块传进来就行,不用一个一个列。
|
||||
;
|
||||
; 除零没有定义:调用者保证 D >= 1,这里不检查(D = 0 会一直循环)。
|
||||
; 除零没有定义:调用者保证 D >= 1(D = 0 时 R >= 0 恒成立,商会变成全 1)。
|
||||
|
||||
; Macro clb_divmod
|
||||
; %1: Cell N
|
||||
; %2: Cell D
|
||||
; %3: Cell Q
|
||||
; %4: Cell S
|
||||
; %4: Cell R
|
||||
; %5: Cell S
|
||||
;
|
||||
; N 是被除数,结束时就是余数 R;D 是除数,会被吃干净;Q 是商(宏自己清零后累加)。
|
||||
; S 起的 4 个**连续** cell 是草稿(S、S+1、S+2、S+3),进来时要求是干净的。
|
||||
; Q = N div D,R = N mod D。**N 和 D 都保持原样**(旧版把 N 吃成余数)。
|
||||
; Q 由宏自己清零后累加。
|
||||
; S 起的 7 个**连续** cell 是草稿:**只有 S+5(buf) 进来必须干净** —— 它是 copy/bit_copy
|
||||
; 的缓冲,缓冲带垃圾时拷贝结果是 0。其它格子脏了没关系:要么整格重写(raw_add 逐位写
|
||||
; Sd/Bo),要么只按一位用(Rhi/Cm/Bo),NR 每次进来都会重建成 W 个 1。
|
||||
; (`clb_digits` 就是这么反复用同一块草稿的:第二轮起它是脏的。)
|
||||
; 前提 D >= 1(除零没有定义,这里不检查)。
|
||||
%macro clb_divmod 4
|
||||
%macro clb_divmod 5
|
||||
.anchor before_clb_divmod
|
||||
|
||||
; s = %4,s+1 = %4+1 ... 四个草稿格
|
||||
; s : N 的副本
|
||||
; s+1 : D 的副本
|
||||
; s+2 : 减法结果 / 拷贝缓冲
|
||||
; s+3 : 进位(= N >= D)
|
||||
; s+0 Rhi : 本轮左移出来的高位(轮内布尔)
|
||||
; s+1 Sd : 减法结果
|
||||
; s+2 Bo : raw_sub 的"没借位"(1 表示 Rlo >= D)
|
||||
; s+3 Cm : 提交标志 = Rhi | Bo(借 raw_sub 的 Bc 那个草稿格用)
|
||||
; s+4 Ci : raw_sub 的进位草稿
|
||||
; s+5 buf : 拷贝缓冲(bit_copy / copy 共用,先后用完都是干净的)
|
||||
; s+6 NR : 轮数计数器
|
||||
|
||||
; Q = -1:第一轮的 +1 把它补回 0
|
||||
erase %4
|
||||
erase %3
|
||||
clb_dec_ip %3 %4
|
||||
|
||||
; t = N:第一轮"提交"是空操作
|
||||
.tp %1
|
||||
copy %4+2 %4
|
||||
|
||||
; Ci = 1 只为让底下那个 biz 直接进循环体;
|
||||
; 真正的判断在体尾的 clb_sub_nc 里
|
||||
.tp %4+3
|
||||
set_1
|
||||
; 轮数:_CELL_SIZE 个 1,每轮 set_0 + ror 吃掉一个。一串 1 的长度就是剩余轮数,
|
||||
; 所以"做几轮"不占纸带长度,只占运行时间(和 clb_mul 一样的计数法子)。
|
||||
.tp %5+6
|
||||
%rep _CELL_SIZE
|
||||
set_1
|
||||
ror
|
||||
%endrep
|
||||
|
||||
.tp %5+6
|
||||
biz
|
||||
; ---- 体:提交上一轮减出来的 t,记一个商,再探一次
|
||||
.tp %4+2
|
||||
copy %1 %4 ; N = t
|
||||
|
||||
clb_inc_ip %3 %4+1 ; Q += 1
|
||||
|
||||
; ---- 1. R = (Rhi:Rlo) << 1 | (N 的下一位)
|
||||
.tp %1
|
||||
copy %4 %4+2 ; s = N
|
||||
.tp %2
|
||||
copy %4+1 %4+2 ; s+1 = D
|
||||
.tp %4+3
|
||||
set_1 ; 进位入 = 1,做的是普通减法
|
||||
clb_sub_nc %4 %4+1 %4+2 %4+3 ; t = N - D,Ci = (N >= D)
|
||||
rol ; 下一位进 N 的 LSB
|
||||
.tp %4
|
||||
rol ; Rlo 左移一格,最高位绕回 bit0
|
||||
clb_bit_mov %5+0 ; 绕回位 -> Rhi(先搬走,顺带清掉 Rlo 的 bit0)
|
||||
.tp %1
|
||||
bit_copy %4 %5+5 ; Rlo 的 bit0 = N 的 LSB(N 保留)
|
||||
|
||||
.tp %4+3
|
||||
; ---- 2. S = Rlo - D,Bo = (Rlo >= D)。D 不能被吃,所以走 raw_sub
|
||||
raw_sub %4 %2 %5+1 %5+2 %5+3 %5+4 %5+5
|
||||
|
||||
; ---- 3. 提交条件 = Rhi | Bo(clb_bit_or 把两个输入都吃掉,Rhi 因此归零)
|
||||
clb_bit_or %5+0 %5+2 %5+3
|
||||
|
||||
; ---- 4. 商左旋一位;提交时 R = S,商位记 1
|
||||
.tp %3
|
||||
rol ; rol 之后 Q 的 bit0 一定是 0(还没写满 W 位)
|
||||
.tp %5+3
|
||||
biz
|
||||
.tp %5+1
|
||||
copy %4 %5+5 ; R = S
|
||||
.tp %3
|
||||
set_1 ; 商位 = 1
|
||||
.tp %5+3
|
||||
flb ; 把条件吃掉(biz/rnz 是循环对)
|
||||
rnz
|
||||
|
||||
; ---- 5. 这一轮结束,轮数吃掉一个
|
||||
.tp %5+6
|
||||
set_0
|
||||
ror
|
||||
rnz
|
||||
|
||||
.tp before_clb_divmod
|
||||
|
||||
+3
-2
@@ -13,7 +13,8 @@
|
||||
; S = A + ~B + 1 = A - B
|
||||
;
|
||||
; 于是进位输出 Co 就是"没有借位"——`clb_sub_nc` 也是这样,但那个是破坏性的。
|
||||
; 本宏把 Co 取反留在 Bo 里,读起来更顺:**Bo = 1 表示 A < B**。
|
||||
; **Bo 就是 Co,不取反**:Bo = 1 表示 A >= B(实测 15-10 -> Bo=1、10-15 -> Bo=0)。
|
||||
; (早先这里写过"Bo = 1 表示 A < B",是错的;底下那段注释解释了为什么不能取反。)
|
||||
;
|
||||
; 前提:A、B 的值 < 2^_CELL_SIZE(B 取反后和 A 相加不会溢出到第 W+1 位以外的解释)。
|
||||
|
||||
@@ -26,7 +27,7 @@
|
||||
; %6: Cell Ci
|
||||
; %7: Cell buf
|
||||
;
|
||||
; S = A - B(mod 2^W),A、B 保持原样,Bo = (A < B ? 1 : 0)。
|
||||
; S = A - B(mod 2^W),A、B 保持原样,Bo = 1 表示 A >= B(没有借位)。
|
||||
; Bc、Ci、buf 是草稿(进来要干净),结束时 Ci 和 buf 是垃圾、Bc 是 ~B。
|
||||
%macro raw_sub 7
|
||||
.anchor before_raw_sub
|
||||
|
||||
@@ -0,0 +1,36 @@
|
||||
%include "asm/lib.r8asm"
|
||||
|
||||
; clb_divmod 的第一步单点验证:R = (Rhi:Rlo) 往左移一格,再把刚转到 bit0 的
|
||||
; 那一位(N 的 LSB)注进 Rlo 的 bit0。跨格左移是 `clb_mul` 当年返工过两轮的地方。
|
||||
;
|
||||
; 这一步就是长除法每轮的头三句,顺序不能换:
|
||||
; rol N ; N 左旋:下一位(最高位起)落在 N 的 LSB
|
||||
; rol Rlo ; Rlo 左旋:最高位绕回 bit0
|
||||
; 搬走绕回位 ; 先搬进 Rhi(**先搬,再清**),再补 N 的那一位
|
||||
;
|
||||
; 期望(N' = rol N 之后的值):
|
||||
; Rlo' = ((Rlo << 1) & _CELL_MAX) | (N' & 1) ; N' 的 LSB = 原来 N 的 bit W-1
|
||||
; Rhi' = (Rlo >> (_CELL_SIZE - 1)) & 1
|
||||
; N' = rol N
|
||||
;
|
||||
; r8forge_derive drv/div_shift.r8asm -1 0=1024 2=0 4=1 # 0 1 2
|
||||
; r8forge_derive drv/div_shift.r8asm -1 0=1023 2=0 4=2047 # 2047 0 2047
|
||||
; r8forge_derive drv/div_shift.r8asm -1 0=5 2=0 4=1 # 10 0 2
|
||||
;
|
||||
; out 依次是 Rlo、Rhi、N。
|
||||
.var Rlo 0
|
||||
.var Rhi 2
|
||||
.var N 4
|
||||
.var buf 6
|
||||
|
||||
.tp N
|
||||
rol ; 下一位进 N 的 LSB(转满 W 轮 N 复原,所以 N 不吃)
|
||||
.tp Rlo
|
||||
rol ; 最高位绕回 bit0
|
||||
clb_bit_mov Rhi ; 绕回位搬进 Rhi(先搬走,顺带清掉 Rlo 的 bit0)
|
||||
.tp N
|
||||
bit_copy Rlo buf ; Rlo 的 bit0 = N 的 LSB(N 保留)
|
||||
|
||||
output Rlo
|
||||
output Rhi
|
||||
output N
|
||||
+7
-5
@@ -3,15 +3,17 @@
|
||||
; clb_divmod 的驱动:0 号 cell 放被除数、1 号放除数,输出商和余数。
|
||||
;
|
||||
; r8forge_derive drv/divmod.r8asm -2 0=2047 1=10 # 204 7
|
||||
; r8forge_derive drv/divmod.r8asm -2 0=7 1=10 # 0 7(零轮)
|
||||
; r8forge_derive drv/divmod.r8asm -2 0=7 1=10 # 0 7(十一轮,跟值无关)
|
||||
; r8forge_derive drv/divmod.r8asm -2 0=2047 1=1 # 2047 0(旧版这里会 HANG)
|
||||
;
|
||||
; out 依次是商、余数。
|
||||
; out 依次是商、余数。N、D 现在都保持原样(加 -2 能看到)。
|
||||
.var N 0
|
||||
.var D 1
|
||||
.var Q 2
|
||||
.var S 3
|
||||
.var R 3
|
||||
.var S 4
|
||||
|
||||
clb_divmod N D Q S
|
||||
clb_divmod N D Q R S
|
||||
|
||||
output Q
|
||||
output N
|
||||
output R
|
||||
+29
-16
@@ -79,6 +79,24 @@ struct machine {
|
||||
}
|
||||
};
|
||||
|
||||
// import_file() only reports what the parser found; an unknown macro or a bad
|
||||
// '.tp' target is found later, while the tree is expanded. Both leave the tape
|
||||
// truncated, and running a truncated tape produces a plausible looking wrong
|
||||
// answer, so the error flag has to be checked after the expansion too (this is
|
||||
// the same order r8forge's own main uses).
|
||||
bool assemble(r8asm &a, const char *file, std::string &tape) {
|
||||
if (!a.import_file(file, kDefaultCellSize)) {
|
||||
std::cerr << "could not assemble " << file << "\n";
|
||||
return false;
|
||||
}
|
||||
tape = a.export_rot8();
|
||||
if (a.failed()) {
|
||||
std::cerr << "could not assemble " << file << "\n";
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
int main(int argc, char **argv) {
|
||||
@@ -90,12 +108,11 @@ int main(int argc, char **argv) {
|
||||
const int params = std::atoi(argv[2]);
|
||||
if (params == 0) { // just run the program and dump what it printed
|
||||
r8asm a;
|
||||
if (!a.import_file(file, kDefaultCellSize)) {
|
||||
std::cerr << "could not assemble " << file << "\n";
|
||||
std::string tape;
|
||||
if (!assemble(a, file, tape))
|
||||
return 1;
|
||||
}
|
||||
machine m;
|
||||
m.run(a.export_rot8());
|
||||
m.run(tape);
|
||||
std::cout << "out";
|
||||
for (uint16_t v : m.out)
|
||||
std::cout << " " << int(v);
|
||||
@@ -105,10 +122,9 @@ int main(int argc, char **argv) {
|
||||
// params == -2: same as -1 but dumps every non zero cell afterwards
|
||||
if (params == -2) {
|
||||
r8asm a;
|
||||
if (!a.import_file(file, kDefaultCellSize)) {
|
||||
std::cerr << "could not assemble " << file << "\n";
|
||||
std::string tape;
|
||||
if (!assemble(a, file, tape))
|
||||
return 1;
|
||||
}
|
||||
machine m;
|
||||
for (int i = 3; i < argc; i++) {
|
||||
const char *eq = std::strchr(argv[i], '=');
|
||||
@@ -118,7 +134,7 @@ int main(int argc, char **argv) {
|
||||
const int at = std::atoi(std::string(argv[i], size_t(eq - argv[i])).c_str());
|
||||
m.cells[size_t(at)] = uint16_t(std::atoi(eq + 1) & kDefaultCellMask);
|
||||
}
|
||||
m.run(a.export_rot8());
|
||||
m.run(tape);
|
||||
std::cout << "out";
|
||||
for (uint16_t v : m.out) {
|
||||
std::cout << " " << int(v);
|
||||
@@ -135,10 +151,9 @@ int main(int argc, char **argv) {
|
||||
// params == -1: the rest of argv is addr=value; set those cells, run, dump OUT
|
||||
if (params == -1) {
|
||||
r8asm a;
|
||||
if (!a.import_file(file, kDefaultCellSize)) {
|
||||
std::cerr << "could not assemble " << file << "\n";
|
||||
std::string tape;
|
||||
if (!assemble(a, file, tape))
|
||||
return 1;
|
||||
}
|
||||
machine m;
|
||||
for (int i = 3; i < argc; i++) {
|
||||
const char *eq = std::strchr(argv[i], '=');
|
||||
@@ -148,7 +163,7 @@ int main(int argc, char **argv) {
|
||||
const int at = std::atoi(std::string(argv[i], size_t(eq - argv[i])).c_str());
|
||||
m.cells[size_t(at)] = uint16_t(std::atoi(eq + 1) & kDefaultCellMask);
|
||||
}
|
||||
m.run(a.export_rot8());
|
||||
m.run(tape);
|
||||
std::cout << "out";
|
||||
for (uint16_t v : m.out) {
|
||||
std::cout << " " << int(v);
|
||||
@@ -165,11 +180,9 @@ int main(int argc, char **argv) {
|
||||
addr[static_cast<size_t>(i)] = argc > 3 + i ? std::atoi(argv[3 + i]) : i;
|
||||
|
||||
r8asm assembler;
|
||||
if (!assembler.import_file(file, kDefaultCellSize)) {
|
||||
std::cerr << "could not assemble " << file << "\n";
|
||||
std::string tape;
|
||||
if (!assemble(assembler, file, tape))
|
||||
return 1;
|
||||
}
|
||||
const std::string tape = assembler.export_rot8();
|
||||
std::cerr << "tape: " << tape.size() << " characters\n";
|
||||
|
||||
std::cout << "stat";
|
||||
|
||||
+33
-16
@@ -89,13 +89,21 @@ struct machine {
|
||||
}
|
||||
};
|
||||
|
||||
// The expansion (export_rot8) is where an unknown macro or a bad '.tp' target
|
||||
// is found, so the error flag has to be checked after it: a truncated tape
|
||||
// still runs, and produces a plausible looking wrong answer.
|
||||
std::string assemble(const std::string &file) {
|
||||
r8asm assembler;
|
||||
if (!assembler.import_file(file, kDefaultCellSize) || assembler.failed()) {
|
||||
if (!assembler.import_file(file, kDefaultCellSize)) {
|
||||
std::cerr << "could not assemble " << file << "\n";
|
||||
std::exit(1);
|
||||
}
|
||||
return assembler.export_rot8();
|
||||
std::string tape = assembler.export_rot8();
|
||||
if (assembler.failed()) {
|
||||
std::cerr << "could not assemble " << file << "\n";
|
||||
std::exit(1);
|
||||
}
|
||||
return tape;
|
||||
}
|
||||
|
||||
int failures = 0;
|
||||
@@ -464,24 +472,28 @@ int test_ones(const std::string &file) {
|
||||
return bad;
|
||||
}
|
||||
|
||||
// clb_divmod: Q = N div D, R = N mod D. Repeated subtraction, so the runtime is
|
||||
// O(N/D) and the worst case (D = 1) would cross the step budget: sampled only.
|
||||
// clb_divmod: Q = N div D, R = N mod D, and N and D come back unchanged. Shift
|
||||
// and restore, so the loop runs _CELL_SIZE times whatever N and D are -- the
|
||||
// repeated subtraction this replaced ran N/D times and crossed the 5M step
|
||||
// budget outright for D = 1, so it could only be sampled. Now every dividend
|
||||
// can be swept for a spread of divisors, and the divisor set is a superset of
|
||||
// the old sampled table's.
|
||||
int test_divmod(const std::string &file) {
|
||||
const std::string tape = assemble(file);
|
||||
std::cout << "clb_divmod: " << tape.size() << " characters (sampled)\n";
|
||||
const int nums[] = {0, 1, 2, 9, 10, 11, 100, 511, 1024, 2047};
|
||||
std::cout << "clb_divmod: " << tape.size() << " characters\n";
|
||||
const int divs[] = {1, 2, 3, 7, 10, 100, 1000, 2047};
|
||||
int bad = 0, n = 0;
|
||||
for (int a : nums)
|
||||
for (int d : divs) {
|
||||
if (a / d > 600) continue; // keep well inside the 5M step budget
|
||||
size_t worst = 0;
|
||||
for (int d : divs)
|
||||
for (int a = 0; a < kCellMod; a++) {
|
||||
machine m;
|
||||
m.cells[0] = uint16_t(a); // N
|
||||
m.cells[1] = uint16_t(d); // D
|
||||
m.run(tape, 5'000'000);
|
||||
n++;
|
||||
if (m.steps > worst) worst = m.steps;
|
||||
const bool ok = m.finished && m.out.size() == 2 && m.out[0] == a / d &&
|
||||
m.out[1] == a % d;
|
||||
m.out[1] == a % d && m.cells[0] == a && m.cells[1] == d;
|
||||
if (!ok) {
|
||||
bad++;
|
||||
if (bad <= 3)
|
||||
@@ -489,22 +501,26 @@ int test_divmod(const std::string &file) {
|
||||
std::to_string(a / d) + " " + std::to_string(a % d));
|
||||
}
|
||||
}
|
||||
std::cout << " " << (bad ? "FAILED" : "all " + std::to_string(n) + " sampled pairs ok")
|
||||
<< (bad ? " (" + std::to_string(bad) + " wrong)" : "") << "\n";
|
||||
std::cout << " " << (bad ? "FAILED" : "all " + std::to_string(n) + " pairs ok")
|
||||
<< (bad ? " (" + std::to_string(bad) + " wrong)" : "")
|
||||
<< " (worst " << worst << " steps)\n";
|
||||
return bad;
|
||||
}
|
||||
|
||||
// clb_digits: the value becomes four ASCII digits, most significant first.
|
||||
// clb_digits: the value becomes four ASCII digits, most significant first. The
|
||||
// divmod underneath is now O(_CELL_SIZE) instead of O(N/10), so the whole cell
|
||||
// range fits in the budget: every value is swept.
|
||||
int test_digits(const std::string &file) {
|
||||
const std::string tape = assemble(file);
|
||||
std::cout << "clb_digits: " << tape.size() << " characters\n";
|
||||
const int nums[] = {0, 1, 7, 10, 42, 99, 100, 512, 1000, 1234, 2047};
|
||||
int bad = 0, n = 0;
|
||||
for (int v : nums) {
|
||||
size_t worst = 0;
|
||||
for (int v = 0; v < kCellMod; v++) {
|
||||
machine m;
|
||||
m.cells[0] = uint16_t(v);
|
||||
m.run(tape, 5'000'000);
|
||||
n++;
|
||||
if (m.steps > worst) worst = m.steps;
|
||||
std::string want = std::to_string(v);
|
||||
while (want.size() < 4) want.insert(want.begin(), '0');
|
||||
bool ok = m.finished && m.out.size() == 4;
|
||||
@@ -517,7 +533,8 @@ int test_digits(const std::string &file) {
|
||||
}
|
||||
}
|
||||
std::cout << " " << (bad ? "FAILED" : "all " + std::to_string(n) + " values ok")
|
||||
<< (bad ? " (" + std::to_string(bad) + " wrong)" : "") << "\n";
|
||||
<< (bad ? " (" + std::to_string(bad) + " wrong)" : "")
|
||||
<< " (worst " << worst << " steps)\n";
|
||||
return bad;
|
||||
}
|
||||
|
||||
|
||||
@@ -87,6 +87,10 @@ int main(int argc, char **argv) {
|
||||
return 1;
|
||||
}
|
||||
const std::string tape = assembler.export_rot8();
|
||||
if (assembler.failed()) { // unknown macro / bad '.tp', found while expanding
|
||||
std::cerr << "could not assemble " << file << "\n";
|
||||
return 1;
|
||||
}
|
||||
std::cout << "tape: " << tape.size() << " characters\n";
|
||||
|
||||
int failures = 0;
|
||||
|
||||
Reference in new issue
Block a user