clb_divmod: nine parameters down to four

Complaint received and agreed with: nine cells to pass for a division is not an
interface anybody wants to type.  Two things made it possible to shrink:

  * .tp and macro arguments accept address expressions (measured: .tp A+1
    assembles, and set_0 A+1 expands to .tp A+1 inside the callee).  So the
    four scratch cells can be passed as one block: clb_divmod N D Q S uses S,
    S+1, S+2 and S+3.
  * BUF and X were unnecessary: copy already has sources and destinations to
    spare that are dead at the moment they are needed, and clb_inc_ip can take
    a cell that the probe is about to overwrite.

So the signature is now clb_divmod N D Q S -- three data cells and one scratch
base -- and the tape dropped from 5839 to 4189 characters on the way, because
the scratch cells now sit next to each other and every .tp walk got shorter.

Still correct: all 76 sampled pairs (2047/10 = 204 7, 7/10 = 0 7, 10/10 = 1 0,
1234/100 = 12 34, 999/7 = 142 5, 2047/2047 = 1 0), and the O(N/D) limit is
unchanged.
This commit is contained in:
dsh committed 2026-11-07 16:53:27 +08:00
1 parent 0b96b76104
commit 4a5bd836a8
4 files changed
+47 -45

No files matched your search

+1 -1
View File
@@ -212,7 +212,7 @@ 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,9 cell)** | `drv/divmod.r8asm` | **5839 字符**(最小驱动)/ 5845(带 output) | **76 组抽样全对**(O(N/D) 运行,`2047/1` 会撞步数上限) |
| **`clb_divmod`(N div D / N mod D,7 cell)** | `drv/divmod.r8asm` | **4189 字符**(最小驱动)/ 4195(带 output) | **76 组抽样全对**(O(N/D) 运行,`2047/1` 会撞步数上限) |
| `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 吃干净 —— 所以后者能省掉
+10 -7
View File
@@ -396,23 +396,26 @@ A 的 12 个取值全对(`r8forge_byte_op_test` 的 `test_ones`)。
### 7.6 `clb_divmod`:除法与取模
`clb_divmod N D Q W V T Ci X BUF`:`Q = N div D`、**`N` 结束时就是余数 R**,D 被吃干净。
9 个 cell(3 个数据 + 6 个草稿),纸带 **5839 字符**(`drv/divmod.r8asm` 是 5845),
76 组抽样全对(`r8forge_byte_op_test` 的 `test_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`)。
算法是最钝的那招:
Q = 0
while N >= D: N -= D ; Q += 1
两处踩出来的设计:
三处踩出来的设计:
1. **`clb_sub_nc` 会把 N 和 D 都吃掉**,而减法**不能用 `S == A` 的别名** —— 实测
`clb_sub_nc A B A Ci`(A=15 B=10 Ci=1)直接给出 `0`。所以每轮都得 copy 出 `W = N`、
`V = D` 再减,三个 copy 里有两个是"过路费"。
2. **首轮要能什么都不做**:`T` 预置成 `N`、`Q` 预置成 `-1`。于是第一轮"提交 `T -> N`"是
`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**。
`O(N/D)` 的代价要记住:`2047 / 1` 会撞 500 万步上限(实测 HANG),每轮约 2.4k 步,
所以 **N/D 最多到 1500 左右**;`2047 / 2` 是 1023 轮,正常返回 `1023 1`。
+33 -29
View File
@@ -1,7 +1,7 @@
%include "asm/raw_sub_nc.r8asm"
%include "asm/add_ip.r8asm"
; 除法/取模:Q = N div D,R = N mod D。
; 除法/取模:Q = N div D,R 就是 N 自己。
;
; 用它自己那句老话:**只有纸带长度是目标**。所以这里不写长除法的移位/恢复,
; 就是最钝的那招:
@@ -10,67 +10,71 @@
; while N >= D: N -= D ; Q += 1
;
; 循环体在纸带里只出现一次,长度和 N、D 的大小无关;代价是运行 O(N/D)
; (N=2047、D=1 时约 2047 轮,是这台机器上最慢的宏,但还在 500 万步以内)。
; (N=2047、D=1 时约 2047 轮,会撞 500 万步上限,所以 N/D 别超过 1500 左右)。
;
; 两个关键点,都是踩出来的:
; 三个关键点,都是踩出来的:
;
; 1. **`clb_sub_nc` 会把 N 和 D 都吃掉**,而减法不能用 `S == A` 的别名
; (实测 `clb_sub_nc A B A Ci` 直接给出 0)。所以每轮都要 copy 出 W = N、
; V = D 再减 —— 三个 copy 里有两个是给它交的"过路费"。
; (实测 `clb_sub_nc A B A Ci` 直接给出 0)。所以每轮都要 copy 出 v = N、
; d = D 再减 —— 三个 copy 里有两个是给它交的"过路费"。
;
; 2. **首轮要能"什么都不做"**:把 T 预置成 N,Q 预置成 -1。于是第一轮的
; "提交 T -> N" 是空操作,"Q += 1" 正好把 -1 补回 0;探测放在循环体末尾,
; 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 会一直循环)。
; Macro clb_divmod
; %1: Cell N
; %2: Cell D
; %3: Cell Q
; %4: Cell W
; %5: Cell V
; %6: Cell T
; %7: Cell Ci
; %8: Cell X
; %9: Cell BUF
; %4: Cell S
;
; N 是被除数,结束时就是余数 R;D 是除数,会被吃干净;Q 是商(宏自己清零后累加)。
; W、V、T、Ci、X、BUF 都是草稿 cell,进来时要求是干净的。
; S 起的 4 个**连续** cell 是草稿(S、S+1、S+2、S+3),进来时要求是干净的。
; 前提 D >= 1(除零没有定义,这里不检查)。
%macro clb_divmod 9
%macro clb_divmod 4
.anchor before_clb_divmod
; T = N:第一轮"提交"是空操作
.tp %1
copy %6 %9
; s = %4,s+1 = %4+1 ... 四个草稿格
; s : N 的副本
; s+1 : D 的副本
; s+2 : 减法结果 / 拷贝缓冲
; s+3 : 进位(= N >= D)
; Q = -1:第一轮的 +1 把它补回 0
erase %3
clb_dec_ip %3 %8
clb_dec_ip %3 %4
; t = N:第一轮"提交"是空操作
.tp %1
copy %4+2 %4
; Ci = 1 只为让底下那个 biz 直接进循环体;
; 真正的判断在体尾的 clb_sub_nc 里
.tp %7
.tp %4+3
set_1
biz
; ---- 体:提交上一轮减出来的 T,记一个商,再探一次
.tp %6
copy %1 %9 ; N = T
; ---- 体:提交上一轮减出来的 t,记一个商,再探一次
.tp %4+2
copy %1 %4 ; N = t
clb_inc_ip %3 %8 ; Q += 1
clb_inc_ip %3 %4+1 ; Q += 1
.tp %1
copy %4 %9 ; W = N
copy %4 %4+2 ; s = N
.tp %2
copy %5 %9 ; V = D
.tp %7
copy %4+1 %4+2 ; s+1 = D
.tp %4+3
set_1 ; 进位入 = 1,做的是普通减法
clb_sub_nc %4 %5 %6 %7 ; T = N - D,Ci = (N >= D)
clb_sub_nc %4 %4+1 %4+2 %4+3 ; t = N - D,Ci = (N >= D)
.tp %7
.tp %4+3
rnz
.tp before_clb_divmod
+3 -8
View File
@@ -1,6 +1,6 @@
%include "asm/divmod.r8asm"
; clb_divmod 的驱动:0 号 cell 放 X、1 号放 D,输出商和余数。
; 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(零轮)
@@ -9,14 +9,9 @@
.var N 0
.var D 1
.var Q 2
.var W 3
.var V 4
.var T 5
.var Ci 6
.var X 7
.var BUF 8
.var S 3
clb_divmod N D Q W V T Ci X BUF
clb_divmod N D Q S
output Q
output N