From c2cd0e827fe89d3c41a3029872b7877c3a98f271 Mon Sep 17 00:00:00 2001 From: dsh Date: Sat, 7 Nov 2026 22:22:03 +0800 Subject: [PATCH] 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. --- AGENTS.md | 63 +++++++----- SPEC.md | 225 +++++++++++++++++++++++++++++++----------- asm/digits.r8asm | 39 +++++--- asm/divmod.r8asm | 133 +++++++++++++++---------- asm/raw_sub.r8asm | 5 +- drv/div_shift.r8asm | 36 +++++++ drv/divmod.r8asm | 12 ++- src/derive.cc | 45 ++++++--- tests/byte_op_test.cc | 49 ++++++--- tests/synth_test.cc | 4 + 10 files changed, 420 insertions(+), 191 deletions(-) create mode 100644 drv/div_shift.r8asm diff --git a/AGENTS.md b/AGENTS.md index c0a209d..b39dbe8 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -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= 2= 4= +**下一步可以做的(这轮没做)**: -顺序(`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` | 位级搬运,并且把源吃掉 | diff --git a/SPEC.md b/SPEC.md index f771036..1424bb4 100644 --- a/SPEC.md +++ b/SPEC.md @@ -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 ` | 第二个解释器,直接跑纸带 | 与 `r8forge_derive` 对答案 | | `r8forge_derive -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 - ; 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 降到几万。 diff --git a/asm/digits.r8asm b/asm/digits.r8asm index 97d4b18..ffa05d0 100644 --- a/asm/digits.r8asm +++ b/asm/digits.r8asm @@ -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 diff --git a/asm/divmod.r8asm b/asm/divmod.r8asm index bc8b1e1..4d732e4 100644 --- a/asm/divmod.r8asm +++ b/asm/divmod.r8asm @@ -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 diff --git a/asm/raw_sub.r8asm b/asm/raw_sub.r8asm index a77299f..5f9f131 100644 --- a/asm/raw_sub.r8asm +++ b/asm/raw_sub.r8asm @@ -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 diff --git a/drv/div_shift.r8asm b/drv/div_shift.r8asm new file mode 100644 index 0000000..6faebde --- /dev/null +++ b/drv/div_shift.r8asm @@ -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 diff --git a/drv/divmod.r8asm b/drv/divmod.r8asm index 8a1efda..9f1ba6c 100644 --- a/drv/divmod.r8asm +++ b/drv/divmod.r8asm @@ -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 diff --git a/src/derive.cc b/src/derive.cc index a014e1a..22d2962 100644 --- a/src/derive.cc +++ b/src/derive.cc @@ -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(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"; diff --git a/tests/byte_op_test.cc b/tests/byte_op_test.cc index 0abfcd0..d39f5b8 100644 --- a/tests/byte_op_test.cc +++ b/tests/byte_op_test.cc @@ -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; } diff --git a/tests/synth_test.cc b/tests/synth_test.cc index af697a3..104c7bf 100644 --- a/tests/synth_test.cc +++ b/tests/synth_test.cc @@ -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;