From 3543003a789dd37f0c9aeec6c1644ddf2abec292 Mon Sep 17 00:00:00 2001 From: dsh Date: Wed, 18 Nov 2026 17:27:05 +0800 Subject: [PATCH] digits: reorder the scratch block -- 22% fewer steps, 15% less tape The profile said 77% of clb_digits' steps are pointer moves, so the layout of its 13 cell scratch block (S..S+12) is the cost. The block is one rigid 7 cell unit (clb_divmod owns its internal order: Rhi,Sd,Bo,Cm=Bc,Ci,buf,NR) plus six free units, so the legal space is 5040 permutations. All 5040 were assembled and run (minimal driver, value 2047): old: TEN Q R [block] counter T F new: T1 R [block] TEN Q F counter tape 13,717 -> 11,717 chars (-14.6%) steps 145,114 -> 113,264 (-21.9%) pointer moves 111,958 -> 80,108 (-28.4%) non-move steps identical (33,156) Full 2048 value sweep: worst 164,843 -> 123,731 (-24.9%), mean 144,904 -> 112,552 (-22.3%), better on all 2048 values. The old layout ranked 3459/5040. Two things worth remembering. First, ordering the units by the wrapper's first visit order is *worse* than the old layout (150,748 steps): first visit ignores revisit frequency -- the counter is touched once per round, TEN is copied into Bc every round, T1 is hammered by clb_add_ip's carry chain. Second, the n-1 lower bound is not reachable here: 74% of the steps still execute inside clb_divmod's block, whose order is not clb_digits' to choose, so this lever is now exhausted (that is what the exhaustive search proves). Min tape is not min steps either: block-first BQTRT1F1C gives the shortest tape (10,713) but 123,890 steps. Tape counts a .tp once, steps count its execution. Ripple: asm/test.r8asm 64,513 -> 62,513 chars, 236,439 -> 206,491 steps, INS_SIZE headroom ~1k -> ~3k; --opt 58,060 -> 56,350; calc --opt 52,857; calc_op 77,356 -> 69,324 chars / 599,090 -> 476,170 steps. Verified: ctest 8/8, byte_op_test 21 items (digits 2048/2048), examples_test 18, --opt assembles, SPEC 7.7/10.2 + AGENTS + README + docs/calc.md + docs/divmod.md numbers updated. New driver drv/digits_layout.r8asm keeps the measurement honest (one clb_digits call, no output, value fed as 0=2047). --- AGENTS.md | 10 ++++---- README.md | 2 +- SPEC.md | 40 ++++++++++++++++++++++--------- TODO.md | 2 -- asm/digits.r8asm | 53 ++++++++++++++++++++++++++++++----------- asm/test.r8asm | 2 +- docs/calc.md | 4 ++-- docs/divmod.md | 5 ++-- drv/calc_disp.r8asm | 21 ++++++++-------- drv/calc_op.r8asm | 15 ++++++------ drv/digits_layout.r8asm | 17 +++++++++++++ 11 files changed, 116 insertions(+), 55 deletions(-) create mode 100644 drv/digits_layout.r8asm diff --git a/AGENTS.md b/AGENTS.md index 549cda8..57c0857 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -30,20 +30,20 @@ cmake --build build --config Release # "No preprocessor test for PellesC")。本机路径见 AGENTS.local.md。 # 当前基线:都通过,别弄坏(`ctest --test-dir build -j 4` 一次跑完 8 条,约 9 秒) -r8forge asm/test.r8asm # 64513 字符(除 raw_puts_dyn 外每个宏一次 + 每个语言特性) +r8forge asm/test.r8asm # 62513 字符(除 raw_puts_dyn 外每个宏一次 + 每个语言特性) r8forge_byte_op_test # 21 项(divmod 16384 组、digits 2048、undigits 4096) r8forge_examples_test # 18 个 example + asm/test.r8asm,核对头部 `; out`/`; in` r8forge_macro_docs_test # 53 macros in 23 files -r8forge --opt asm/test.r8asm # 纸带窥孔优化 64513 -> 58060(>< 净位移、+ mod W、- mod 2) +r8forge --opt asm/test.r8asm # 纸带窥孔优化 62513 -> 56350(>< 净位移、+ mod W、- mod 2) r8forge_tape_opt in.rot8 out.rot8 # 同一优化,但作用在已有纸带上 -r8forge_tape_run t.rot8 --profile # 剖面:指针移动占 76~80% 步数(实测,见下) +r8forge_tape_run t.rot8 --profile # 剖面:指针移动占 66~73% 步数(实测,见下) r8forge_synth_test examples/full_add.r8asm # all eight combinations ok r8forge_derive verify_loop.r8asm -1 0=5 # out 5 0 powershell -File tests\widths.ps1 # 位宽矩阵:每个位宽一套工具链 + 断言(约 20 分钟) ``` `asm/test.r8asm` 的纸带**必须留在 65536 条指令以下**(ROT-8-viz 的 `INS_SIZE`),所以里面 -只有"每个宏一次 + 两轮 hash",现在离上限只剩 ~1k。加东西前先算长度。 +只有"每个宏一次 + 两轮 hash",现在离上限只剩 ~3k。加东西前先算长度。 `r8forge_byte_op_test` 是**唯一按返回值判断字节级对错的**;其它自检只证明"汇编得出来"或 "位级正确"。`r8forge_derive` 会检查汇编错误(漏 `%include` 时纸带是截断的,以前不看 error @@ -67,7 +67,7 @@ powershell -File tests\widths.ps1 # 位宽矩阵:每个位宽一 * **交互程序这样测**:`r8forge_tape_run t.rot8 -i "12+34="`(字符喂给 `inp`,低 7 位,读空后为 0), `r8forge_derive 0 -i "..."` 是同一份输入的第二个实现;例程把输入写在头部 `; in ...`,`r8forge_examples_test` 会自动喂。实时终端那一侧在 ROT-8-viz(默认串行)。 -* **代价的大头是"走"不是"算"**:`tape_run --profile` 实测,计算器 79.5%、全家桶 76.4% 的步数是 `>`/`<`,旋转只占 7%、翻转 4~6%。这台机器没有随机寻址,每次访问的代价就是 `|Δ地址|`,所以**布局才是性能旋钮**;`--opt` 省 17% 步数正是因为它砍的是往返移动。 +* **代价的大头是"走"不是"算"**:`tape_run --profile` 实测,计算器 71.1%、全家桶 73.0% 的步数是 `>`/`<`,旋转只占 7%、翻转 4~6%。这台机器没有随机寻址,每次访问的代价就是 `|Δ地址|`,所以**布局才是性能旋钮**:`clb_digits` 的 13 格草稿重排一轮,全家桶 64513 -> 62513 字符、236439 -> 206491 步(SPEC §7.7);`--opt` 再省 14~15% 步数,正是因为它砍的是往返移动。 * 一次会话很难把结论留在对话里 —— **落进 commit message 和文件注释**。 ## 语义上会咬人的几条 diff --git a/README.md b/README.md index 543347d..0b43ca6 100644 --- a/README.md +++ b/README.md @@ -70,7 +70,7 @@ r8forge asm/test.r8asm # 汇编,stdout 是纸带 r8forge --synth-chars examples/full_add.r8asm # 按真实布局重新搜 r8forge -j 4 examples/full_add.r8asm # 纸带搜索最多 4 个 worker(默认每硬件线程一个) r8forge -q examples/full_add.r8asm > full_add.rot8 # stdout 只剩纸带 -r8forge --opt asm/test.r8asm > t.rot8 # 纸带窥孔优化:64513 -> 58060 字符 +r8forge --opt asm/test.r8asm > t.rot8 # 纸带窥孔优化:62513 -> 56350 字符 ``` `-j` 只影响纸带搜索(层数搜索是串行的);`-q` 只压 stdout,错误照旧进 stderr、退出码不变。 diff --git a/SPEC.md b/SPEC.md index 42cd6b5..c0dde1e 100644 --- a/SPEC.md +++ b/SPEC.md @@ -553,9 +553,10 @@ A 的 12 个取值全对(`r8forge_byte_op_test` 的 `test_ones`)。 ### 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` 起 **13 格**必须连续且干净。纸带 **13717 字符** -(最小驱动,旧版 10829 —— divmod 的草稿块从 4 格变成 7 格,而且多了一格余数), -`r8forge_byte_op_test` 的 `test_digits` 现在**穷举全部 2048 个值**(最坏 164,867 步)。 +N 被吃干净;`REG` 起 4 格、`S` 起 **13 格**必须连续且干净。纸带 **11717 字符** +(最小驱动;13 格草稿重排之前是 13717,再往前 10829 —— divmod 的草稿块从 4 格变成 +7 格,而且多了一格余数),`r8forge_byte_op_test` 的 `test_digits` 现在**穷举全部 +2048 个值**(最坏 **123,755** 步;重排之前 164,867)。 2047 -> REG = '2' '0' '4' '7' 7 -> REG = '0' '0' '0' '7' @@ -570,15 +571,32 @@ N 被吃干净;`REG` 起 4 格、`S` 起 **13 格**必须连续且干净。纸 挪的顺序必须**从高到低**(`REG+2 -> REG+3` 先做),否则会把还没搬的高位盖掉。 4 轮之后 `REG+0..3` 正好是千、百、十、个。 -`S` 起的 13 格是这么排的(`clb_divmod` 要一块 7 格的连续草稿,所以它从 `S+3` 开始): +`S` 起的 13 格是这么排的(`clb_divmod` 要一块 7 格的连续草稿,所以它从 `S+2` 开始)。 +**这个排法是量出来的,不是拍的**:把 13 格拆成 7 个单元(TEN、商、余数、7 格草稿块、 +轮数计数器、add_ip 的 T 和 F),5040 种排列全部汇编一遍、用 `r8forge_tape_run` 跑 +`0=2047` 数步数,取最小的那个: - 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 + S+0 clb_add_ip 的 T S+1 余数(这一位的数字,divmod 的 R) + S+2..S+8 clb_divmod 的草稿块(Rhi、Sd、Bo、Cm=Bc、Ci、buf、NR) + S+9 TEN(除数) S+10 商(divmod 的 Q) + S+11 clb_add_ip 的 F S+12 轮数计数器(loop) -挪位链和"商 -> N"的拷贝都借 `S+8`(divmod 的 buf)当缓冲 —— 那个格子在 divmod 结束时 -是干净的。余数现在单独占一格(旧版是"余数就在 N 里"),所以 `REG+0 = '0' + 余数` 读的是 -`S+2`;下一轮的 N 还是靠 `copy` 从商搬回去。 +依据是三条距离(这台机器没有随机寻址,访问一格就是走 |Δ地址|): + +* **余数紧贴草稿块前面、TEN 紧贴草稿块后面**。余数是 `raw_add` 的 A(每次 11 位 + 一位一位过),TEN 是 `raw_sub` 的被减数(每轮 `copy TEN -> Bc`,缓冲就是块里的 + buf)—— 这两个距离直接乘进 divmod 内层 11×11 的位循环。旧排法把 TEN 放在最前面, + 离 buf 8 格、离 Bc 6 格;只把它挪到块后面(其它单元的先后不变)就省 **22,226** 步。 +* **add_ip 的 T 紧挨着余数**:`clb_inc_ip`/`clb_dec_ip` 的进位链每轮在这两格之间来回, + 光把 T 和余数换个位置就差 4,450 步。 +* **轮数计数器只被 loop 每轮碰一次**,踢到最远的一头(`S+12`)。 + +改完 `0=2047` 是 **113,264** 步(145,114 -> 113,264),2048 个值全扫最坏 123,731 +(值 1999)、平均 112,552(旧 144,904)。契约一个字没改,改的只是 13 格内部的排法。 + +挪位链和"商 -> N"的拷贝都借 `S+7`(divmod 的 buf)当缓冲 —— 那个格子在 divmod 结束时 +是干净的。余数单独占一格(旧版是"余数就在 N 里"),所以 `REG+0 = '0' + 余数` 读的是 +`S+1`;下一轮的 N 还是靠 `copy` 从商搬回去。 第一版是"4 个分支 + one-hot flag 分派",**只写对了第一支**(其余三支没触发),换成 整体挪位后不仅正确,还少了两层嵌套、4 个 cell 和一堆 flag 交接。教训: @@ -731,7 +749,7 @@ clb_add_ip PH Ci S F ; 把进位加进高字节(Ci 被吃) E 大宏(`clb_ones` / `loop` / `clb_digits` + `clb_undigits`)→ F 语言特性(自定义 `%macro` + `%rep` + `%for` + 两份 `%synth`)→ G 两轮 hash(`clb_add_nc` + `clb_mul`)。 -11 位下纸带 **64513 字符**、**236439 步**、93 个 `out`。两个约束值得记住: +11 位下纸带 **62513 字符**、**206491 步**、93 个 `out`。两个约束值得记住: * **必须留在 65536 条指令以下**:ROT-8-viz 的 `INS_SIZE`(`include/rot8/rot8.h`)是 65536, 超了 `read_tape` 会截断,交叉验证就废了。所以 hash 只留两轮、每个宏只调一次。 diff --git a/TODO.md b/TODO.md index cc8a6e0..5a26394 100644 --- a/TODO.md +++ b/TODO.md @@ -50,8 +50,6 @@ * **`clb_divmod` 预计算 `~D`**:单轮 2019 → 973 步,估计 28.6k → 17.6k 步,纸带净 −76; 没换是因为当时指名用 `raw_sub`。细节和注意事项见 [`docs/divmod.md`](docs/divmod.md) 第 6 节。 -* **`clb_digits` 的布局**:13 格草稿跨得很开,`.tp` 行走占了纸带的大头;重排草稿格应该能 - 明显缩短(未实测)。 * **`clb_divmod` 里那个 495 字符的提交 `copy`**:还是全展开的,可以想压缩的办法。 ## 顺手清掉的小尾巴 diff --git a/asm/digits.r8asm b/asm/digits.r8asm index 1a117da..7013eb5 100644 --- a/asm/digits.r8asm +++ b/asm/digits.r8asm @@ -10,8 +10,32 @@ ; %3: Cell S ; ; 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 的草稿),进来要求干净。 +; cell 是草稿,进来要求干净。 +; +; ---- 13 格草稿的排法(按"少走路"重排过,见下面"布局"一段) ---------------- +; +; S+0 clb_add_ip 的 T S+1 余数 R(这一位的数字) +; S+2..S+8 clb_divmod 的草稿块(Rhi、Sd、Bo、Cm=Bc、Ci、buf、NR) +; S+9 TEN(除数) S+10 商 Q +; S+11 clb_add_ip 的 F S+12 轮数计数器(loop) +; +; ---- 布局:这台机器没有随机寻址,每次访问的代价就是 |Δ地址| -------------- +; +; 旧排法是 TEN、商、余数、草稿块、轮数、add_ip 的 T、F 依次排下来,结果每轮都要 +; 在块前面和块里面来回走:divmod 每轮拿 TEN 当 raw_sub 的被减数(copy TEN -> Bc, +; 缓冲就是块里的 buf),TEN 却离 buf 有 8 格。现在的三条依据: +; +; * 余数 R 紧贴在草稿块**前面**、TEN 紧贴在**后面**。R 是 raw_add 的 A,TEN 是 +; raw_sub 的 B,这两个距离都乘进内层 11×11 的位循环里。实测:只把 TEN 从最前 +; 面挪到块后面(其它单元的先后不变)就省 22,226 步,是这次改动的大头。 +; * add_ip 的 T 紧挨着 R(clb_inc_ip / clb_dec_ip 的进位链每轮在这两格之间来回); +; 光把 T 和 R 换个位置就差 4,450 步。 +; * 轮数计数器只被 loop 每轮碰一次,踢到最远的一头(S+12)。 +; +; 效果(最小驱动,见 SPEC §7.7):纸带 13,717 -> 11,717 字符;2047 这个值 +; 145,114 -> 113,264 步。2048 个值全扫:最坏 164,843 -> 123,731(值 1999)、 +; 平均 144,904 -> 112,552。**契约一个字没改**:还是"REG 起 4 格、S 起 13 格 +; 连续且干净",只有格子内部的排法变了。 %macro clb_digits 3 .anchor before_clb_digits @@ -20,7 +44,7 @@ ; L = 十进制位数 = floor(_CELL_SIZE * log10(2)) + 1,用 30103/100000 做整数近似: ; 11 位 -> 4、16 位 -> 5、8 位 -> 3、32 位 -> 10,和 2^W-1 的真实位数一致。 ; **轮数因此自动跟着位宽走**,不用手改。 -.tp %3+10 +.tp %3+12 ; 轮数计数器 set_1 %rep _CELL_SIZE * 30103 / 100000 rol @@ -28,10 +52,10 @@ set_1 %endrep ; ---- 四位,一轮一位 -loop %3+10 +loop %3+12 ; 重建 TEN = 10(位 1、3):绕整圈,在 1 和 3 各置一个 1 - erase %3+0 - .tp %3+0 + erase %3+9 ; TEN + .tp %3+9 ror set_1 %rep 2 @@ -43,14 +67,15 @@ loop %3+10 %endrep ; N = 这位数字(R,余数),Q = 商 - clb_divmod %1 %3+0 %3+1 %3+2 %3+3 + clb_divmod %1 %3+9 %3+10 %3+1 %3+2 ; TEN、Q、R、草稿块 ; ---- 已有数字整体上移一格:从高到低搬。 ; 轮数 = L-1,用 %for 跟着位宽自动来(11 位 3 轮、16 位 4 轮)。 + ; 缓冲借 divmod 的 buf(S+7),它在 divmod 结束时是干净的。 %for k _CELL_SIZE * 30103 / 100000 - erase %3+8 + erase %3+7 ; buf .tp %2 + _CELL_SIZE * 30103 / 100000 - 1 - k - copy %2 + _CELL_SIZE * 30103 / 100000 - k %3+8 + copy %2 + _CELL_SIZE * 30103 / 100000 - k %3+7 %endfor ; ---- REG+0 = '0' + 数字(位 4、5)。 @@ -68,13 +93,13 @@ loop %3+10 %rep _CELL_SIZE - 5 ror %endrep - clb_add_ip %2+0 %3+2 %3+11 %3+12 + clb_add_ip %2+0 %3+1 %3+0 %3+11 ; A=REG+0、B=R、T=T1、F ; ---- 下一位的被除数(缓冲要干净) - erase %3+8 - .tp %3+1 - copy %1 %3+8 -endloop %3+10 + erase %3+7 ; buf + .tp %3+10 ; Q + copy %1 %3+7 ; N = Q +endloop %3+12 .tp before_clb_digits %endmacro diff --git a/asm/test.r8asm b/asm/test.r8asm index 96d077e..fd53bfc 100644 --- a/asm/test.r8asm +++ b/asm/test.r8asm @@ -26,7 +26,7 @@ ; ; 纸带必须留在 65536 条指令以下(ROT-8-viz 的 INS_SIZE),所以这里只放 ; "每个宏一次" + 两轮 hash;想加更多调用前先看长度,超了那边就跑不完整。 -; 现在 64513 字符、236439 步、93 个 out —— 离上限只剩 1k,加东西前先算账。 +; 现在 62513 字符、206491 步、93 个 out —— 离上限只剩 3k,加东西前先算账。 ; (clb_divmod 没有单独的显式段落:clb_digits 每一轮都在调它。) ; ; 没有 %include 的只有 asm/fibonacci.r8asm:那个文件是**程序**不是宏库, diff --git a/docs/calc.md b/docs/calc.md index 3636725..e7e7766 100644 --- a/docs/calc.md +++ b/docs/calc.md @@ -75,9 +75,9 @@ t = C - 0x2A ; 命令: 0..5 数字: 6..15 | `+`/`-`(`clb_add_nc`/`clb_sub_nc`) | ~2.5k | | `*`(`clb_mul`) | ≤ 20,300 | | `/`(`clb_divmod`) | ~28,600 | -| 打印(`clb_digits`) | ≤ 164,867 | +| 打印(`clb_digits`) | ≤ 123,755 | -一行 `12 34 + .` ≈ 36k×2 + 2.5k + 165k ≈ **240k 步**。`examples_test` 的上限是 2000 万步, +一行 `12 34 + .` ≈ 36k×2 + 2.5k + 124k ≈ **200k 步**。`examples_test` 的上限是 2000 万步, 所以会话控制在 10 行左右(或把打印换成"里程表"版本,见下)。 ## 6. 已知的坑(都在库里踩过) diff --git a/docs/divmod.md b/docs/divmod.md index 4a9ef69..f0c9c14 100644 --- a/docs/divmod.md +++ b/docs/divmod.md @@ -84,8 +84,9 @@ buf、NR。固定代价里最大的是 `raw_sub` 的 2793 字符和提交时那 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)。 + 740,695 步降到 **113,288** 步(最坏 123,755 —— 小值反而慢,同上)。纸带 + `clb_digits` **11717**(13 格草稿重排之前 13717,再往前 10829 —— 重排见 SPEC §7.7), + `clb_divmod` **4499**(旧 4189)。 **纠正一个流传的数字**:这里原来写"`2047/10` 要 148 万步"、"`clb_digits` 的 1.48M 步"。 按 SPEC §1.3 的口径实测旧实现是 **495,986**(`2047/10`)和 **740,695**(digits `0=2047`), diff --git a/drv/calc_disp.r8asm b/drv/calc_disp.r8asm index cec2652..218ab2b 100644 --- a/drv/calc_disp.r8asm +++ b/drv/calc_disp.r8asm @@ -6,8 +6,9 @@ ; 内存地图(clb_digits 要 REG 起 4 格、S 起 13 格,SPEC §7.7): ; cell 0 N 要打印的整数(load 装进来,被 clb_digits 吃干净) ; cell 1..4 REG clb_digits 写出的 4 个 ASCII 数字,高位在前、左边补 '0' -; cell 5..17 S clb_digits 的 13 格草稿(S+0=TEN、S+1=商、S+2=余数、 -; S+3..S+9=divmod 草稿、S+10=轮数、S+11/S+12=add_ip 草稿) +; cell 5..17 S clb_digits 的 13 格草稿(S+0=add_ip 的 T、S+1=余数、 +; S+2..S+8=divmod 草稿、S+9=TEN、S+10=商、S+11=add_ip 的 F、 +; S+12=轮数;排法见 SPEC §7.7) ; cell 18 '>' 62 ; cell 19 ' ' 32 ; cell 20 '\n' 10 @@ -15,8 +16,8 @@ ; 三个常量格只造一次(load 是"先整格 erase、再 xor 常数",所以装第二遍数字不用管它们)。 ; ; 两遍之间要擦 REG 和 S:clb_digits 进来要求这两块干净(SPEC §7.7)。第一遍跑完 -; REG 里是 "0046"、S 里还剩 TEN/商/余数/轮数计数器(S+0 甚至被挪位链写进了第一位数字), -; 不擦的话第二遍会拿脏草稿开跑。开机时内存全 0,所以第一遍不用擦。 +; REG 里是 "0046"、S 里还剩 TEN/商/余数/轮数计数器(还有挪位链和 add_ip 留下的 +; 草稿),不擦的话第二遍会拿脏草稿开跑。开机时内存全 0,所以第一遍不用擦。 ; ; clb_digits 吃 N(跑完 N 是 0),所以每遍都靠 load N 重新装值,别指望上一遍剩的。 ; @@ -24,18 +25,18 @@ ; build/Release/r8forge_derive.exe drv/calc_disp.r8asm 0 ; out 62 32 48 48 52 54 10 62 32 50 48 52 55 10 ; -; 这条纸带 29188 字符;两遍共 282288 步(r8forge_tape_run 和 derive 结果一致)。 +; 这条纸带 25188 字符;两遍共 220496 步(r8forge_tape_run 和 derive 结果一致)。 ; ; 预置 cell 的 `-1` 跑法(实测,不是推的): ; * `-1 0=7`、`-1 0=2047`:输出逐项不变 —— 程序第一件事就是 load N(整格 erase ; 再 xor 装值,第一遍是 46),预置的 cell 0 被覆盖。cell 18/19/20 同理(三个常量 ; 都由 load 覆盖)。 ; * `-1 1=7 2=7 3=7 4=7`(REG 全脏):也不变 —— 四轮挪位链把开机垃圾全冲出去了。 -; * S 里大部分格子也不怕:S+0(cell 5,TEN 每轮重建)、S+1/S+2(商/余数由 divmod -; 整格写)、S+12(cell 17)都自清理。 -; * 但 S 不是全部自清理,契约里的"干净"是真的:cell 15 = S+10 是轮数计数器, -; 只 `set_1` 不清格,预置 `15=7` 会让它多出几个 1、第一遍多跑几轮,打出 -; `48 48 48 48`("0000");cell 16 = S+11 是 add_ip 的草稿,预置 `16=7` 会把 +; * S 里大部分格子也不怕:S+9(cell 14,TEN 每轮重建)、S+1/S+10(余数/商由 +; divmod 整格写)、S+11(cell 16,add_ip 的 F 由 clb_nonzero 先 set_0)都自清理。 +; * 但 S 不是全部自清理,契约里的"干净"是真的:cell 17 = S+12 是轮数计数器, +; 只 `set_1` 不清格,预置 `17=7` 会让它多出几个 1、第一遍多跑几轮,打出 +; `48 48 48 48`("0000");cell 5 = S+0 是 add_ip 的 T,预置 `5=7` 会把 ; 第一遍最后一位从 '6' 变成 '7',打出 `48 48 52 55`("0047")。 ; 第二遍不受影响 —— 两遍之间擦了 REG 和 S。 %include "asm/lib.r8asm" diff --git a/drv/calc_op.r8asm b/drv/calc_op.r8asm index 134ed77..b15f6fc 100644 --- a/drv/calc_op.r8asm +++ b/drv/calc_op.r8asm @@ -17,8 +17,9 @@ ; clb_add_nc 的 S 每 bit 先 set_0 再写,clb_mul 开头 erase PL, ; clb_divmod 开头 erase Q)。 ; cell 1..4 REG clb_digits 写出的 4 个 ASCII 数字,高位在前、左边补 '0' -; cell 5..17 S clb_digits 的 13 格草稿(S+0=TEN、S+1=商、S+2=余数、 -; S+3..S+9=divmod 草稿、S+10=轮数、S+11/S+12=add_ip 草稿) +; cell 5..17 S clb_digits 的 13 格草稿(S+0=add_ip 的 T、S+1=余数、 +; S+2..S+8=divmod 草稿、S+9=TEN、S+10=商、S+11=add_ip 的 F、 +; S+12=轮数;排法见 SPEC §7.7) ; cell 18 '>' 62 ; cell 19 ' ' 32 ; cell 20 '\n' 10 @@ -60,13 +61,13 @@ ; / :Q=682、R=1,N=2047、D=3 都保留 ; 探针 out:46 0 0 0 70 1 0 0 408 0 12 0 682 1 2047 3 ; -; 这条纸带 77356 字符、599090 步(r8forge_tape_run 和 derive 的 out 逐项一致)。 +; 这条纸带 69324 字符、476170 步(r8forge_tape_run 和 derive 的 out 逐项一致)。 ; -; 注意:77356 > ROT-8-viz 的 INS_SIZE(65536),它的 read_tape 会截断,所以这份驱动 +; 注意:69324 > ROT-8-viz 的 INS_SIZE(65536),它的 read_tape 会截断,所以这份驱动 ; 只在 r8forge_tape_run / r8forge_derive 上验。这不是可以顺手改掉的小事:单个 -; clb_digits 展开是 13741 字符(drv/digits.r8asm 口径),四个显示块写死就 54964, -; 剩下 1 万多要装四个运算和 51 次 erase —— 除非把显示改成运行期循环(stage 5 的 -; 主循环里 clb_digits 只展开一次,所以那边不会超),否则下不来。 +; clb_digits 展开是 11741 字符(drv/digits.r8asm 口径),四个显示块写死就 46964, +; 剩下 2 万多(22360)要装四个运算和 51 次 erase —— 除非把显示改成运行期循环 +; (stage 5 的主循环里 clb_digits 只展开一次,所以那边不会超),否则下不来。 %include "asm/lib.r8asm" %include "asm/digits.r8asm" ; clb_digits(顺带带进 divmod / add_ip / raw_sub / raw_or) %include "asm/raw_add_nc.r8asm" ; clb_add_nc diff --git a/drv/digits_layout.r8asm b/drv/digits_layout.r8asm new file mode 100644 index 0000000..3c20d3e --- /dev/null +++ b/drv/digits_layout.r8asm @@ -0,0 +1,17 @@ +; clb_digits 的**最小驱动**:只调一次、不带 output(SPEC §1.3 的口径)。 +; 专门用来量布局:纸带长度 11717 = SPEC §7.7 给的最小驱动长度(重排草稿格之前 13717)。 +; +; N=0 放被转换的值(运行期喂,不进纸带),REG=1..4 是四位 ASCII 窗口, +; S=5 起 13 格是草稿区。看结果用 drv/digits.r8asm(那份带 output)。 +; +; build/Release/r8forge drv/digits_layout.r8asm | Set-Content -NoNewline t.rot8 +; build/Release/r8forge_tape_run t.rot8 0=2047 --profile +; +; 换布局时**只许动 asm/digits.r8asm 里的内部偏移**,这个驱动一个字都不用改。 +%include "asm/digits.r8asm" + +.var N 0 +.var REG 1 +.var S 5 + +clb_digits N REG S