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).
This commit is contained in:
dsh committed 2026-11-18 17:27:05 +08:00
1 parent 01aa13d0f0
commit 3543003a78
11 files changed
+116 -55

No files matched your search

+5 -5
View File
@@ -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 <src> 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 和文件注释**。
## 语义上会咬人的几条
+1 -1
View File
@@ -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、退出码不变。
+29 -11
View File
@@ -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 只留两轮、每个宏只调一次。
-2
View File
@@ -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`**:还是全展开的,可以想压缩的办法。
## 顺手清掉的小尾巴
+39 -14
View File
@@ -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
+1 -1
View File
@@ -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:那个文件是**程序**不是宏库,
+2 -2
View File
@@ -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. 已知的坑(都在库里踩过)
+3 -2
View File
@@ -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`),
+11 -10
View File
@@ -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"
+8 -7
View File
@@ -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
+17
View File
@@ -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