Files
R8Forge/drv/calc_op.r8asm
dsh 3543003a78 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).
2026-11-18 17:27:05 +08:00

210 lines
8.2 KiB
Plaintext
Raw Permalink Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
; calc_op —— 桌上计算器 stage 4:四个运算各跑一次,结果按 stage 3 的格式显示
; (docs/calc.md §3 第 4 步)。没有 inp、没有栈、没有主循环 —— 那是 stage 5。
;
; 四组,顺序固定:
; 12 + 34 = 46 -> "> 0046\n"
; 100 - 30 = 70 -> "> 0070\n"
; 12 * 34 = 408 -> "> 0408\n"
; 2047 / 3 = 682 -> "> 0682\n"
;
; 显示那一半照抄 drv/calc_disp.r8asm:'>'、' '、clb_digits 的 4 位 ASCII 数字、'\n';
; 三个常量格(GT/SP/NL)开机造一次,四个运算都不碰它们。
;
; 内存地图:
; cell 0 N 要显示的数字,**同时也是四个运算的落点**:
; add/sub 的 S、mul 的 PL、divmod 的 Q 都直接写这里,
; 于是"把结果搬进 N"这一步不用做(三个宏都不要求结果格干净:
; 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=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
; cell 21 A 操作数 A:add/sub 的 A、mul 的 MC、divmod 的 N
; cell 22 B 操作数 B:add/sub 的 B、mul 的 MUL、divmod 的 D
; cell 23..29 SC **共用草稿块,7 格**:
; add/sub 只借 SC+0 当进位格(CellBit);
; mul 的 7 个草稿格正好是它(PH/MCA/S/Ci/T/F/NR);
; divmod 的 7 格连续草稿 S 也正好是它。
; mul 和 divmod 不同时跑,所以能共用;每次调用前整块 erase。
; cell 30 R divmod 的余数(宏自己 erase,跑完是 1,之后没人用)
;
; 进位格就是 SC+0,三处都把它当真输入用:
; * 加法:进来 erase 成 0,出去再查一遍(下面那个运行期断言)—— 46 < 2048,
; 最高位不进位,所以出来必须是 0;
; * 减法:进来 set_1(S = A + ~B + 1 才是 A - B),出去是"没借位",
; 100 >= 30 所以出 1(SPEC §7.2);
; * 乘法:复用同一格当 clb_mul 的 Ci,要求进来是 0(擦整块时一起擦掉)。
;
; 运行期断言:加法之后进位出万一不是 0,那个条件体会多 output 一个数(进位格的值),
; out 就从 28 个数变成 29 个,一眼看出来。
;
; 擦草稿分两种,别混:
; * clb_digits 进来要求 REG(4 格)和 S(13 格)干净。第一遍开机本来就是 0,
; 后面三遍之前照 stage 3 的惯用法把这两块擦回 0(stage 3 两遍之间干的就是这件事);
; * mul / divmod 的共用草稿块每次调用前整块擦(mul 要求 7 格全干净;divmod 按
; SPEC §7.6 只要求 S+5 干净,这里整块擦,省得记哪格脏过)。
;
; 验证:
; build/Release/r8forge.exe drv/calc_op.r8asm
; build/Release/r8forge_tape_run.exe <tape.rot8>
; build/Release/r8forge_derive.exe drv/calc_op.r8asm 0
; out 62 32 48 48 52 54 10 62 32 48 48 55 48 10 62 32 48 52 48 56 10 62 32 48 54 56 50 10
;
; 四个运算的契约,用同布局的临时探针**实测**过(跑完就删,没进仓库):
; + :N=46,进位出 0,A、B 被吃成 0
; - :N=70,没借位 1(100 >= 30),A、B 被吃成 0
; * :PL=408、PH=0,MC=12 保留,MUL 被吃成 0,7 格草稿全用上
; / :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
;
; 这条纸带 69324 字符、476170 步(r8forge_tape_run 和 derive 的 out 逐项一致)。
;
; 注意:69324 > ROT-8-viz 的 INS_SIZE(65536),它的 read_tape 会截断,所以这份驱动
; 只在 r8forge_tape_run / r8forge_derive 上验。这不是可以顺手改掉的小事:单个
; 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
%include "asm/raw_sub_nc.r8asm" ; clb_sub_nc(顺带带进 clb_not_ip)
%include "asm/mul.r8asm" ; clb_mul
; Macro load
; %1: Cell operand
; %2: Count value
;
; 先整格清干净,再 `.xor` 上常数(`.xor` 是异或,不清格就变成和旧值异或)。
%macro load 2
erase %1
.tp %1
.xor %2
%endmacro
.var N 0 ; 要显示的数字,四个运算的结果都写这里(clb_digits 吃干净)
.var REG 1 ; REG..REG+3:clb_digits 的输出,4 个 ASCII 数字
.var S 5 ; S..S+12:clb_digits 的草稿区(13 格)
.var GT 18 ; '>' = 62
.var SP 19 ; ' ' = 32
.var NL 20 ; '\n' = 10
.var A 21 ; 操作数 A:add/sub 的 A、mul 的 MC、divmod 的 N
.var B 22 ; 操作数 B:add/sub 的 B、mul 的 MUL、divmod 的 D
.var SC 23 ; 共用草稿块 SC..SC+6(7 格)
.var MCi SC ; 进位格:add/sub 的 Ci = mul 的 Ci = divmod 的 S+0
.var PH SC+1 ; mul 的 PH(积的高半)
.var MCA SC+2 ; mul 的 MCA
.var MS SC+3 ; mul 的 S
.var MT SC+4 ; mul 的 T
.var MF SC+5 ; mul 的 F(移位寄存器的最高位)
.var MNR SC+6 ; mul 的轮数计数器
.var R 30 ; divmod 的余数
; ---- 常量区:三格只造一次 ----
load GT 62
load SP 32
load NL 10
; ================= 1) 12 + 34 = 46 =================
load A 12
load B 34
erase MCi ; 进位输入 = 0(真输入,不靠上一轮剩的)
clb_add_nc A B N MCi ; A、B 被吃干净,N = 46,MCi = 进位出
; 查进位出:46 < 2048 不进位,所以这里 MCi 必须是 0。
.tp MCi
biz
output MCi ; 只有进位出 = 1 才会多打一个数
.tp MCi
flb ; 把条件吃掉(biz/rnz 是循环对)
rnz
output GT
output SP
clb_digits N REG S
output REG + 0
output REG + 1
output REG + 2
output REG + 3
output NL
; ================= 2) 100 - 30 = 70 =================
load A 100
load B 30
erase MCi
.tp MCi
set_1 ; 进位输入 = 1 -> S = A + ~B + 1 = A - B
clb_sub_nc A B N MCi ; A、B 被吃干净;MCi 出"没借位"(100 >= 30 -> 1)
; 第二遍之前:把 clb_digits 要的两块擦回开机状态(stage 3 的惯用法)。
%for k 4
erase REG + k
%endfor
%for k 13
erase S + k
%endfor
output GT
output SP
clb_digits N REG S
output REG + 0
output REG + 1
output REG + 2
output REG + 3
output NL
; ================= 3) 12 * 34 = 408 =================
%for k 7
erase SC + k ; mul 的 7 格草稿(含 Ci)进来必须干净
%endfor
load A 12 ; MC(乘完保留)
load B 34 ; MUL(结束为 0)
; 签名:clb_mul MC MUL PL PH MCA S Ci T F NR
clb_mul A B N PH MCA MS MCi MT MF MNR
; 积是 (PH:PL) = (0:408),低半就是 N;PH 那半不用(408 < 2048)。
; 第三遍之前:再擦一次 clb_digits 的两块。
%for k 4
erase REG + k
%endfor
%for k 13
erase S + k
%endfor
output GT
output SP
clb_digits N REG S
output REG + 0
output REG + 1
output REG + 2
output REG + 3
output NL
; ================= 4) 2047 / 3 = 682 =================
%for k 7
erase SC + k ; divmod 的 7 格草稿(SC+5 是拷贝缓冲,必须干净)
%endfor
load A 2047 ; N(除完保留)
load B 3 ; D(除完保留)
clb_divmod A B N R SC ; Q = 682 直接写进 N;R = 1(余数,不显示)
; 第四遍之前:再擦一次 clb_digits 的两块。
%for k 4
erase REG + k
%endfor
%for k 13
erase S + k
%endfor
output GT
output SP
clb_digits N REG S
output REG + 0
output REG + 1
output REG + 2
output REG + 3
output NL