用软件自底向上模拟 8 位 CPU:感知机逻辑门 → 加法器 → ALU → 时序部件 → 存储部件 → 指令集与整机(已跑通),附迷你汇编器。
ALU/— 组合算术部件gate.py基本逻辑门(纯 Python 算术,~0.2µs/门;原 numpy 感知机版见 git 历史,26× 提速,197 万项穷举验证数学等价)full_adder.py半加器 → 全加器 → 8 位行波进位加减法器(补码减法,带 cin 端口)alu.py11 种运算 + Z/N/C/V 标志位(ADC/SBB 复用加减法器,只换进位来源)test_alu.py穷举测试(197 万项断言)
COMB/— 通用组合部件mux.py门级 2 选 1 / one-hot AND-OR 阵列 / 字级多路选择器decoder.pyn → 2^n one-hot 译码器(带使能端)test_comb.py
SEQ/— 时序部件dff.pyD 触发器 + 时钟(行为级:显式状态 + 边沿统一提交)register.py8 位寄存器(8 个 DFF 共享时钟组成)register_file.py8×8 位寄存器堆(双读端口 MUX + 单写端口译码器)pc.py程序计数器(incr 经加法器自增 / load 跳转装载)test_seq.py/test_register_file.py/test_pc.py
MEM/— 存储部件ram.py256 字节同步 RAM(读组合、写打拍、load_program 烧写)test_ram.py
CPU/— 指令集与整机(阶段三)isa.py统一双字节指令编码、43 种助记符、汇编辅助与反汇编control.py控制器("微程序 ROM"查找表 + 跳转条件判断;CMP/INC/DEC 派生; c_from 字段选择加法器进位来源 0/1/C——ADC/SBB 与 ADD/SUB 只差这一格)cpu.py整机接线 + step()/run()(一拍一条指令,统一提交)test_cpu.py单指令 → 条件分支 → 循环程序差分(449 项断言)
ASM/— 迷你汇编器(工具层,只依赖 isa,零机器改动)asm.py两遍扫描:标号自动解析、.org/.db伪指令、CLI(--run上机执行)test_asm.py281 项断言(编码差分/标号/错误/端到端);example.asm、sub_demo.asm(递归求和)、pushpop_demo.asm(PUSH/POP 阶乘)示例dec_io.asm十进制 I/O 程序库(div10 / print_dec / parse_dec / lfsr—— 项目第一个库文件,驱动在前、库在后拼接)
first_program.py— 入门示例:带指令跟踪的阶乘循环程序(见「第一个程序」)second_hello.py— 第二个示例:内存映射 I/O + 自修改代码打印字符串(见「第二个程序」)third_screen.py— 第三个示例:帧缓冲"屏幕" + 字符流/回车端口(见「第三个程序」)fourth_multibyte.py— 第四个示例:16 位多字节加减法,手工传递进位(见「第四个程序」)fourth_multibyte_v2.py— 第四示例的 ADC/SBB 版:16 位 76→25 条、32 位展开链、 指针循环翻车现场(INC/DEC 重写 C,该缺陷已修复——程序原地算对)三幕 (见「第四个程序」v2 小节)fourth_multibyte_v3.py— 第四示例的指针循环版:翻车程序复活差分验收、 立此存照、任意位宽(实测 256 位)与空间/时间账本(见「第四个程序」v3 小节)fifth_division.py— 第五个示例:软件除法(移位相减恢复余数法,121 组矩阵差分)(见「第五个程序」)sixth_munch.py— 第六个示例:XOR 花纹(Munching Squares,1962 PDP-1 demo 祖师爷)(见「第六个程序」)sixth_munch_v2.py— 第六示例的寄存器间接版:同一张表新旧两机制逐字节差分(547→483 条)seventh_corewar.py— 第七个示例:Core War 核心大战——蠕虫 vs 轰炸机共享内存决斗(见「第七个程序」)eighth_echo.py— 第八个示例:输入端口 0xFC 开通——回声机与按键分支(见「第八个程序」)ninth_snake.py— 第九个示例:贪吃蛇(复古模式 ~1 FPS)——键盘 + 帧缓冲首次合体,差分自校验(见「第九个程序」)ninth_snake_v1_1.py— 第九示例修复版:防掉头双变量防线 + 死亡拍单帧渲染 + 方向仪表盘,三幕验收(回归/立此存照/修复证明)(见「第九个程序」v1.1 小节)ninth_snake_v1_2.py— 第九示例 v1.2:★ 修复——循环重排为 tick→sample→render,转向等待窗口可视化ninth_snake_v1_3.py— 第九示例 v1.3:固定步长累加器(方案③)——游戏速度与机器速度解耦,默认 3 拍/秒tenth_acceptance.py— 第十个示例:验收程序——冒泡排序 + 十进制打印,源码主体为 .asm 文本、微型调用约定、栈的两种真实用法(见「第十个程序」)eleventh_guess.py— 第十一个示例:猜数字——人猜机 / 机猜人两幕对话机, parse_dec 对偶 print_dec、二分 7 问 + 说谎检测(见「第十一个程序」)twelfth_jr.py— 第十二个示例:相对跳转 JR——位置无关的两个实验、块状 imp 零补丁迁徙、取 PC 魔术半成功(见「第十二个程序」)
分层依赖(自底向上搭建,箭头方向即 import 方向,永不反向):
第 5 层 集成 CPU/cpu.py ← 唯一 import 四个部件包的文件(塔尖)
第 4 层 规格与语义 CPU/isa.py · CPU/control.py ← 零依赖的纯定义(指令编码 / 微程序表)
第 3 层 系统部件 SEQ/register_file.py · SEQ/pc.py · MEM/ram.py
第 2 层 功能部件 SEQ/register.py · COMB/mux.py+decoder.py · ALU/full_adder.py · ALU/alu.py
第 1 层 原语 SEQ/dff.py(记忆之根)· ALU/gate.py(组合之根)
三条架构铁律:依赖严格单向(部件包不知道 CPU 的存在);isa/control 不依赖任何部件(纯规格,换实现不动规格);跨包 import 仅 7 条 (COMB→ALU、SEQ→ALU/COMB、CPU→ALU/SEQ/MEM、ASM→CPU——耦合面刻意 收窄,边集由 test_cpu 断言冻结,新增耦合必须显式改表)。
一条指令的旅程(CPU.step() 五步,声明与提交分离):
PC ─地址→ RAM.read×2 ─op,arg→ isa.decode → control.signals(微码七信号)
│
RF.read(门级 MUX 译码选择)─A,B→ ALU ─结果+标志┤
│ ├→ RF.write / RAM.write(声明)
│ └→ 4×DFF 标志位(声明)
└→ PC 下一拍:add8(pc,2) 顺序 / load(目标) 跳转(声明)
↓
clk.tick() ← 全机唯一提交点:PC、寄存器、RAM、标志同时翻转
第七个控制信号 c_from 选择加法器/旋转器进位来源(0 / 1 / C 标志):
ADC/SBB 不是新电路,是同一加减法器换一个进位来源——C 标志的旧值经
反馈线回到 ALU 进位口,进位得以跨指令接力(本拍算出的新标志要等 tick
才提交);ROL/ROR 也走这根线穿 C 旋转,完成多字节移位链。
内存地图(端口/栈分家后正式分区——tenth 的相撞花絮推动此图诞生: 此前各约定逐站累积,从未对过总账):
0xFF │ 预留(未来状态口)
0xFE │ 控制台端口 ─┐
0xFD │ 回车端口 ├ I/O 阁楼(栈不路过)
0xFC │ 键盘端口 ──┘ 兼空栈哨兵 SP=0xFC
0xFB ▼ 栈顶:PUSH 向下生长,与数据区相向而行(相遇即溢出,无保护)
│ 数据 / 帧缓冲(0xC0~ 一带,按程序各自约定)
│ 程序 0x00~(PC 启动位)
测试金字塔:ALU 197 万项穷举打底,向上 COMB 109、SEQ 18+23+9、MEM 11、 CPU 449——底层全绿,上层失败只需查上层。
python -m CPU.cpu # 整机演示:带指令跟踪的累加循环
python -m CPU.test_cpu # CPU 测试(含斐波那契等循环程序差分,约 3 秒)
python -m ASM.test_asm # 汇编器测试(281 项断言,瞬时)
python -m ASM.asm ASM/example.asm # 汇编:打印机器码 + 反汇编
python -m ASM.asm ASM/example.asm --run # 汇编 + 上机执行(带跟踪)
python -m ASM.asm ASM/sub_demo.asm --run # 递归求和演示(CALL/RET 硬件栈)
python -m ASM.asm ASM/pushpop_demo.asm --run # 定义直译版阶乘(PUSH/POP 保存现场)
python -m ALU.test_alu # ALU 穷举测试(约 12 秒,197 万项断言)
python -m COMB.test_comb # 组合部件测试(瞬时)
python -m SEQ.test_seq # 时序行为测试(瞬时)
python -m SEQ.test_register_file
python -m SEQ.test_pc
python -m MEM.test_ramfirst_program.py 是上手示例:用助记符辅助函数拼出"5! = 120"的阶乘循环,
带指令跟踪运行,结果写入内存 0x80。在项目根目录执行 python first_program.py 即可。
核心骨架(每条指令恰好 2 字节,第 k 条位于地址 2k——注释标地址、跳转目标按此手算,
这是手工汇编的基本功):
from CPU import isa
from CPU.cpu import CPU
prog = (isa.I_LDI(0, 5) + # 0x00: R0 = n = 5
isa.I_LDI(1, 1) + # 0x02: R1 = acc = 1
isa.I_ALU("MUL", 1, 0) + # 0x04: acc *= n
isa.I_UN("DEC", 0) + # 0x06: n -= 1(更新标志)
isa.I_JMP("JNZ", 0x04) + # 0x08: n≠0 则回 0x04
isa.I_ST(1, 0x80) + # 0x0A: 结果写入内存 0x80
isa.I_HALT()) # 0x0C
cpu = CPU(prog)
n, halted = cpu.run(trace=True) # 逐条打印指令、寄存器与标志
print(cpu.rf.read(1), cpu.ram.read(0x80), cpu.flags())写自己的程序就是这三步:isa.I_* 拼字节 → CPU(prog) 装载 → run(trace=True) 执行。
随时用 cpu.rf.read(i) / cpu.ram.read(addr) / cpu.flags() 观察状态;
单步调试可循环调用 cpu.step()。约定:程序放低地址、数据从 0x80 起,
256 字节共用一块内存。
second_hello.py(python second_hello.py,输出 HELLO, MOCK_CPU!,98 条指令)
不给 CPU 增加任何东西就实现了输出,靠两个经典概念:
- 内存映射 I/O:约定地址 0xFE 是"控制台端口",往它写字节就显示一个字符。
程序继承 RAM 造了一颗带屏幕的内存(
ConsoleRAM),CPU 以为自己只是在 做普通的 ST——设备挂在总线上"冒充"内存,这正是真实计算机的 I/O 方式 (C64 的屏幕、串口芯片的寄存器都是这么接的) - 自修改代码:本机 LD/ST 只有直接地址、没有指针寻址,无法遍历字符串。 解法是循环里把新地址写回那条 LD 指令的地址字节(指令与数据同片内存, 冯·诺依曼结构的本义)——程序运行中改写自己。这是早期程序员的日常, 也是现代 CPU 的禁忌(指令缓存与流水线不一致,x86 遇到必须冲刷流水线)
third_screen.py(python third_screen.py)造出了一块"真·屏幕"——同一个
程序里对照演示两种输出模型。设备约定(CPU 依然不知情):0x90~0x9F 共
16 字节是帧缓冲(这片内存"就是"屏幕),0xFE 字符流端口打一个字符,
0xFD 回车端口换行。
- teletype vs framebuffer:标题
DEMO:走流式端口——"写一个打一个", 输出是流水;进度条走帧缓冲——渲染器读内存的当前状态作画,屏幕显示 "存着什么"而非"来过什么",所以格子可以被反复改写、就地更新。这是显存 相对打印机的本质能力(C64 屏幕内存、显卡显存同理) - 刷新与写入异步解耦:渲染不在写钩子里,而由驱动端的刷新循环按圈触发 ——对应真实显卡"CPU 随便写、显示器按场频自己扫"的工作方式
- 填格子复用自修改代码技巧(指针写回 ST 指令的地址字节)
fourth_multibyte.py(python fourth_multibyte.py)在没有 ADC/SBB 指令的机器上
做 16 位加减法,6 组差分用例全过(含进位链、16 位溢出、借位链)。核心问题:
进位必须跨字节传递,但每条 ADD 都会覆盖 C 标志。解法:
- 进位不放标志里,放寄存器里(R2 传递):每字节"带进位加"分两步——
先
ADD并趁 C 还在立即分支落进 R2;再补 cin:R0==255时回绕并再置进位, 否则安全 +1。进位输出 = 两股进位在寄存器里汇合 - 减法对偶:借位判定用
JNC(SUB 的 C 是借位取反),回绕检测R0==0再减 - 每字节 ~14 条指令——写完就懂了真实 CPU 为什么都有
ADC/SBB(1 条顶 14 条); 这条预言由下方 v2 兑现
补上带进位指令后重写同一件事(v1 原样保留),三幕验收全过:
-
第一幕:16 位加减 76 → 25 条——
ADD低字节 /ADC高字节,C 标志在 字节间自动接力;进位落盘用0+0+C = C(ALU 兼职"标志搬运工"); 借位(= NOT C)没有单指令技巧——ADC/SBB 都随 C 单调增,凑不出 1−C, 只能 JC 分支(x86 正相反:CF 本身就是借位,一步搬出——惯例决定哪头便宜) -
第二幕:翻车现场→疗效证明——指针循环版(LDX/STX + ADC,看似最优雅) 曾必然翻车:循环体里的 INC/DEC 当时重写全部四个标志,进位链断在指针 步进上。同一程序的前后对照(v2 原样冻结,机器修复后原地"复活"):
INC/DEC 的标志语义 0x000000FF + 1 的机器结果 判定 修复前(写 Z/N/C/V) 0x01010000(最高进位 1)字节 1 丢真进位,字节 2、3 吃 DEC 假进位 ✗ 修复后(只写 Z/N,C/V 保持) 0x00000100(最高进位 0)与期望一致 ✓ x86 的 INC/DEC 保全 CF、6502 的 INX/INY 不碰 C、Z80 的 INC r 不碰 Cy—— 真 ISA 专门给多精度循环留活路,本机已照此修复(INC/DEC 只写 Z/N)
把 v2 第二幕的翻车程序一字不改地请回来,给它正式的差分验收(三幕全过):
- 第一幕:32 位差分——那 25 条程序跑 6 组用例与 Python 对账全过:变的 不是程序,是机器(INC/DEC 只写 Z/N 后,进位链能安全穿过指针步进)
- 第二幕:立此存照——同一程序同一输入:修复前
0x01010000(v2 冻结 记录)vs 修复后0x00000100(实跑),病灶与疗效一屏对照 - 第三幕:任意位宽与空间/时间账本——位宽不进代码结构、只进数据:
LDI R5, N−1一个常量管所有宽度(64 位差分全过;256 位全链进位 294 条 指令,程序仍是那 25 条)。账本首次出现可测量的取舍:循环版代码恒 25 条 但执行 9N+6;展开版执行 4N+4 但体积线性涨——N=5 时代码体积打平,展开版 极限约 240 位(代码占满 256 字节内存),时间与空间第一次分家
三部曲弧线:v1 手工传进位(每字节 14 条)→ v2 带进位展开链(每字节 4 条) → v3 循环完全体(位宽只是数据)——没有进位指令 → 有了但链条脆 → 链条稳 且可循环,多精度算术(也就是大数库的形状)走完全程。
- 第三幕:32 位展开链 21 条——每字节 LD/ADC/ST 共 4 条,全链进位 (0xFFFFFFFF+1 回绕成 0)等 6 组差分全过;64 位、256 位照葫芦画瓢—— 这正是大数库的形状(OpenSSL/GMP 的核心循环就是 64 位 ADC 链)
fifth_division.py(python fifth_division.py)用**移位相减(恢复余数法)**实现
8 位 ÷ 8 位 = 商 + 余数,8 组精选 + 11×11 全矩阵共 121 组差分全过。算法与
8086 DIV 指令的微码同构,21 条指令:
- 每轮处理被除数一位:
SHL R0把被除数最高位顶进 C 标志(移位窗口),SHL R1再把它从 bit0 注入余数(两次移位间 C 会被覆盖,需分支先落地); 然后 CMP 试减——够减则 SUB、商本位置 1,不够则跳过("恢复") - 为什么 8 位机除法靠软件:加减是并行链、乘法是单向阵列(部分积可一次 展开,一拍完成),而除法每一位依赖上一位试减的结果——带反馈的迭代, 硬件要么做多拍状态机、要么单拍级联 8 级比较减法拖慢全机时钟;加上晶体管 预算紧(6502 约 3500 管)和除法需求稀少,历史选择就是软件子程序。 6502/Z80/8051 均无 DIV,ARM 与 RISC-V 基础指令集也长期不含除法
- 开发花絮:手算跳转地址偏了 2 导致死循环——"该做汇编器"的活案例
sixth_munch.py(python sixth_munch.py,全程约 5 秒)复刻 1962 年 PDP-1 上的
祖师爷级 demo:把 x XOR y 铺满屏幕,阈值流动时花纹层层生长又坍缩——"啃食"
由此得名,后收录于 MIT 的 HAKMEM 备忘录,是 demoscene 的起点。8 位机的 3 位
XOR 恰好铺满 8×8 网格——这台机器和这个图案天生一对。
- 机器侧(547 条指令):双重循环算 64 格的 x^y 值进帧缓冲 0xC0~0xFF;
遍历用自修改指针——
ST R6,[0x0D]每格改写 ST 指令自己的地址字节, 这就是指针的本相:地址存在寄存器里、每步 +1、间接决定落点 (无间接寻址指令的机器用自修改模拟它) - 显示侧(Python 驱动):帧缓冲存的不是 0/1 而是"本格的 XOR 值", 渲染以阈值 t 扫描——值 < t 点亮;t 逐帧上升,对角线 → 方阵 → 四象限 → 全亮 → 坍缩。程序与显示异步解耦 = PDP-1 的 CRT 持续刷新、程序只写内存
second_hello / third_screen / sixth_munch 是同一主题的三次变奏,共享三件套:
- 设备冒充内存:屏幕/控制台不是机器的一部分,是 Python 侧的地址约定—— ② write 钩子(端口 0xFE)→ ③ 读写混合(端口 + 帧缓冲)→ ⑥ 纯读侧观察 (零钩子),设备越来越被动,CPU 与 ISA 全程零知情
- 自修改代码当指针:三者都在遍历内存(字符串/格子/表格),无间接寻址的 机器把指针刻进指令的操作数字节、每步改写(②改 LD,③⑥改 ST)
- 写入与显示异步解耦:程序只管把数据摆进内存,显示按自己的节奏扫描 ——PDP-1 的 CRT 模型,⑥ 推到极致(机器算完即 HALT,动画全在显示侧)
谱系即历史:② teletype 流式(写一个打一个)→ ③ 帧缓冲(显示"存着什么") → ⑥ 纯数据 + 显示端动画——从打字机到显卡的输出进化路线,1962 年至今。
seventh_corewar.py(python seventh_corewar.py,约 10 秒)复刻 1984 年的
程序角斗:蠕虫 vs 轰炸机,两颗 CPU 共享同一片 RAM 轮流各走一步(MARS
进程模型),轰炸机向中场投非法操作码炸弹,谁先让对方执行到非法指令谁胜。
- 蠕虫 = "常驻引擎 + 蛙跳入口"(自复制程序的落地形态):引擎 18 字节 永不搬家(绝对地址永远有效——这正是绝对跳转 ISA 上纯 imp 不可能、而 此变体可行的原因),每代 LDX/STX 把身体拷到前方,再用一条 STX 把自己 JMP 的地址字节改成新副本首址(间接寻址与自修改联手),跳进去再蛙跳
- 纯 imp 为何不可能:Redcode 的
MOV 0,1一条指令爬行靠的是"PC 随 复制前进"的游戏专属设计;我们的绝对跳转 ISA 里副本的跳转目标全失效—— 这也是真实病毒需要相对跳转/重定位的原因 - 确定性对战:固定布局下结果可复现(本局第 1239 拍蠕虫铺到轰炸机获胜)
- 花絮:首跑"裁判误判"——蠕虫每代合法自改 JMP 字节,被朴素逐字节完整性 检查当成"被炸";修复 = 完整性比对豁免自改字节
eighth_echo.py(python eighth_echo.py)开通 0xFC 输入端口——第一块
"全双工"外设 ConsoleKeyboardRAM 同时钩住 read()(读 0xFC = 取键)与
write()(写 0xFE = 打字符),与输出三件套的 write 钩子互为镜像,
I/O 全家福凑齐。
- 约定:读 0xFC 为破坏性读取(如真实键盘数据寄存器),队列空返回 0 = "无键"哨兵;键码存 ASCII——字符 '0' 是 48,与哨兵 0 互不相扰 (若需输入 NUL 字节,升级方案是 0xFB 状态端口,信令移到带外)
- 轮询:机器无中断,等键靠
CMP/JZ忙等——1970-80 年代键盘的真实 工作方式;驱动端预投喂按键(剧本式输入),确定性保留 - 两幕自校验通过:回声机(投喂 HELLO → 回声 HELLO → 停机)、按键分支 ('1'→A / '2'→B / 'Q'→退出,输入驱动控制流)——解锁贪吃蛇、 Breakout、猜数字、迷你 Eliza 等交互程序
ninth_snake.py(python ninth_snake.py 剧本回放 + 差分自校验;
python ninth_snake.py --play 真人 WASD/方向键操控)。机器侧 92 条指令
(184 字节)+ 驱动端渲染/时钟,复古节奏约 1 FPS(未做 gate.py 提速的
方案 B)。
- 键盘即时钟:机器阻塞等键,驱动端每拍投喂两个"增量键码" (dx+2、dy+2 ∈ {1,2,3},避开 0=无键哨兵)——机器侧省掉整个方向分派
- 帧缓冲即蛇身:8×8 场地 0xC0~0xFF,蛇身格存"年龄"(头=1,每拍 +1, 超过蛇长即清零=尾巴缩回),食物=255;单一数据结构零重复记账
- 食物:机内 Galois LFSR(种子 1,抽头 0xB8),落在非空格则重抽
- 开局烧写:初始局面全部由
.db摆好,机器只初始化 3 个寄存器 - 验收:剧本回放与 Python 参考实现逐格差分(两套独立实现,最终 棋盘/分数/结局必须一致)——分数 2:2、64 格一致、第 25 拍撞墙
- 花絮:食物标记初版设 250,被
INC检测法当场戳穿——250+1=251 不回绕, 255+1 才归零(哨兵值与检测算法必须配套)
两个版本的默认模式不同(v1.1 的身份是"修复验证文件"):
| 命令 | v1(ninth_snake.py) | v1.1(ninth_snake_v1_1.py) |
|---|---|---|
python xxx.py |
剧本回放 + 差分自校验(棋盘动画) | 三幕验收(回归/立此存照/修复证明) |
python xxx.py --play |
真人操控 | 真人操控 + 方向仪表盘 |
v1 的防掉头参照物是"最新意向 cur"而非"实际投喂方向"——同一采样窗口内 快速按两个键(如上行时 A+S)可让第二个键对照第一个"幽灵转向"通过检查, 机器实际收到 180° 反向 → 一拍撞死自己(用户实测发现)。
- 修复:拆 cur 为
last_fed(上一拍实际投喂——防掉头的唯一参照, 仅在投喂后更新)+pending(下一拍意向);防线只认"已执行"—— 意向转两次骗不过执行才走一步。附带修复死亡拍双重渲染 - 方向仪表盘:每帧显示
当前:↑ 下一:← ★——当前=last_fed(实际 走的方向)、下一=pending(便签上的意向)、★=两者不同(转向待执行)。 按键后"下一"立即变、"当前"下一拍才跟上——"慢一拍"的因果链可视化 - 三幕验收:① 回归——v1.1 跑 v1 同一剧本的差分依旧逐格一致(机器侧 零改动);② 立此存照——内联复刻 v1 旧防线喂 A+S,bug 必然发生 (文档化);③ 修复证明——新防线拦截 's',游戏级注入 A+S 蛇存活
v1.1 的 ★ 永远不亮:循环里 last_fed = pending 在 render 之前执行,
渲染时两者恒等。v1.2 把循环重排为 tick → sample → render——先执行
这一拍、再采样下一拍按键、最后渲染;渲染时 last_fed(刚走完)和
pending(刚采样的下一拍意向)自然可能不同,★ 在"转向已排队但尚未
执行"的窗口里亮起。机器侧零改动,三幕验收依旧全过。
gate.py 提速后机器每拍仅 ~14ms,v1.2 的 sleep(0.12) 节奏过快(~7 FPS), 玩家反应不过来——与红警等老游戏在高速 CPU 上"AI 太快"同病根: 帧率绑定了游戏逻辑。
- 修法:固定步长 + 累加器——逻辑更新频率恒定(
TICK_RATE = 4拍/秒),机器全速干完一拍后休眠等待。累加器本质是"时间银行": 真实时间存进去,攒够一步的份额就取出来执行一步 - 游戏速度与机器速度完全解耦(改
TICK_RATE一个常量调速度, 换机器零调参);确定性保留(每秒恰好 TICK_RATE 步,差分测试可靠) - 实测:累加器精确维持恒定节拍(误差 <1ms)
- 真玩模式:
python ninth_snake_v1_3.py --play(默认 3 拍/秒,改TICK_RATE调速)
tenth_acceptance.py(python tenth_acceptance.py,23 项断言三幕全过)是
"工具链阅兵式":不演示任何新机制,以真实程序员的身份解两个最经典的日常
任务——冒泡排序与十进制打印,把汇编器、子程序、栈、指针、标志分支、
I/O 端口全部当理所当然的建材用上,哪个环节掉链子哪个环节就露馅。
- 源码主体是 .asm 文本(全项目第一次):常驻库(sort8 / print_dec /
内部 div10)+ 三个驱动,经
assemble()生成——手拼isa.I_*正式退役; 驱动在前、库在后(机器从地址 0 启动,库只当零件仓) - 微型调用约定:R0 参数/返回(消耗);R1-R4 草稿、被调方自保存
(序言 PUSH / 尾声 POP);R5/R6/R7 = 全局常数 0/10/48 只读。第三幕
print_dec被循环安全调用 8 次——约定接受复用检验(常数幸存断言) - print_dec:反复除 10,余数 PUSH 进栈、POP 出来恰好逆序——栈的 算法性用法(现场保存之外的第二种真实用法);do-while 结构保证 0 打 "0"、天然无前导零
- sort8:旗帜 do-while 外层(一趟零交换即毕业)+ 指针内层;相等必须 跳过交换——否则旗帜永不归零(死循环),设计期推演发现、"全相同" 等价类专设岗哨;bound 常驻栈顶——寄存器不够,栈来凑
- 差分:print_dec 对
str(n)13 例、sort8 对sorted()7 等价类 (已序/逆序/重复/全同/边界/乱序/N=2)、合体对" ".join;三重断言 (结果 + 停机 + SP 归零);账本实测:提前退出收益 595 条(681→86) - 花絮:0xFE 端口与栈相撞——栈从 0xFF 向下第二格恰是惯例端口 0xFE: PUSH 存现场被端口钩子当成打字(多出 \x00),ST 打字又覆盖栈中保存的 R2,尾声"还原"出 ASCII 数字泄漏进下轮输出。本程序是第一个"子程序栈 × 控制台端口"合体用户,第一个撞上。当年端口暂搬 0x9E 绕行(见 git 历史); 机器已修复——SP 初始 0→0xFC(I/O 阁楼避栈,6502 专页做栈的同款思路), 本程序回归惯例端口 0xFE,它用 0xFE 跑全绿正是修复的验收现场
eleventh_guess.py(python eleventh_guess.py 两幕剧本差分;--play 1/2
真玩)把 tenth 教会的"说数字"配上新学的"听数字"(parse_dec:读键、回显、
按十进制累加),I/O 从回声机升级成对话机。机器侧源码全部从 ASM/dec_io.asm
拼接——项目第一个真正的程序库文件(微 ABI 与 tenth 同款;Breakout 的
记分打印今后直接领用)。
- 第一幕:人猜机——LFSR 藏 0~99 秘密数,你猜它答
</>/=,命中报 回合数;5 种子 × 4 策略(二分/线性/首猜命中/边界游)对独立参考实现 逐字符差分(连回显都算进转录) - 第二幕:机猜人——二分搜索,7 问定乾坤(每答 1 bit,2⁷=128>100,
信息论现场);应答 h/l/y;说谎检测打印
!终止——lo>hi 不变量当裁判, 外加 mid=0 还喊"大了"的回绕岗哨(减到 255 会骗过不变量) - 防溢出中点:mid = lo + (hi−lo)/2——JDK 二分的 (lo+hi)/2 溢出 bug 带了 九年(int 在 2³¹ 撞墙),我们在 8 位撞 255 的墙:同一道名题的微缩版
- 回显是设备行为:parse_dec 每键写回 0xFE——屏幕上的输入是程序"还给 你的"(电传机血统:telnet 时代还有专门的回显协商)
- --play 模式:键盘钩子在队列空时阻塞读 stdin——回合制游戏里 input() 的阻塞就是天然节拍
- 花絮:mid 暂存格原放 0xE0,被自检断言抓到程序越界压格(功能测试 侥幸全绿——被压的是第二幕永不执行的 lfsr 死代码)——内存地图纪律比 功能测试先看见碰撞,上移 0xE8 修复
twelfth_jr.py(python twelfth_jr.py,三幕全过)是编年史第五幕的第一块砖:
新增 JR 族八条(0xC8 段,目标 = 下一条地址 + 带符号偏移 ±127,条件同绝对族;
6502 的分支族同款——短距相对与长距绝对 JMP 并存)。微码 jump 字段用 R 前缀
哨兵(RJMP/RJZ…),条件表零改动复用;cpu 按 pc+2+偏移算目标——补码偏移让
加法器不必知道正负。
- 第一幕:位置无关的两个实验——①同一源码在 0x00/0x80 各汇编一次:JRNZ
版逐字节相同(
CA FA走到哪都是"往回 6"),JNZ 版跳转字节随基址变 (7A 04/7A 84);②不重新汇编、原样搬家到炸弹场:JR 版照跑,JNZ 版 跳回旧址猝死 - 第二幕:块状 imp——无引擎、无补丁的移动蠕虫:复制自己到紧邻前方后 落空走进副本(PC 随复制前进——Redcode imp 的原理在块级复活),全块唯一 的分支是一条 JRNZ;爬 10 代、11 份副本逐字节相同。对照第七站的常驻引擎 + 每代 STX 补丁(手工自重定位)——双双退役;锚定对照(换绝对 JNZ)大脑困在 出生地(执行点最远 0x1E),出生地一炸即死,相对版早已远走
- 第三幕:取 PC 魔术半成功——x86 的 call/pop 取 EIP 在本机取到的值是对的 (返回地址由硬件按 PC+2 现算,天然相对),但控制流被绝对 CALL 拐回原址, 原址一炸副本即死。PIC 完全体还差两块砖:相对 CALL 与相对数据寻址—— 真·纯 imp(单条指令)同样卡在后者,这正是块状 imp 需要发射器填地址、 需要 7 条而不是 1 条的原因
- 汇编器随之升级:JR 写目标标号、偏移由汇编器算(第二遍
len(out)即当前 地址),越界带行号报错;立即数接受#标号(蠕虫发射器取块首地址用)
LDI/MOV/LD/ST 数据传送(立即数/寄存器/内存)
LDX/STX 寄存器间接读写(地址 = 指针寄存器内容,Rd←mem[Rn] / mem[Rn]←Rs)
ADD SUB AND OR XOR MUL CMP R0~R7 寄存器运算,CMP 只更新标志不写回
ADC SBB 带进位加减(进位输入 = C 标志):多字节运算的进位链
INC DEC SHL SHR 单目运算(INC/DEC 即 B=1 的 ADD/SUB,但只写 Z/N——C/V 保持)
NOT ROL ROR 位操作单目:NOT 取反(只写 Z/N,NEG 惯用法 NOT+INC);
ROL/ROR 穿 C 旋转(cin=C)——多字节移位链原语 SHL lo/ROL hi
JMP JZ JNZ JC JNC JN JNN JV 条件跳转(消费 Z/N/C/V)
JR JRZ … JRV 相对跳转族(目标 = 下一条 + 带符号偏移,±127):控制流位置无关
CALL/RET 子程序调用与返回(硬件栈:SP 空栈=0,返回地址压栈,栈从 0xFF 向下生长)
PUSH/POP 压栈/弹栈(保存与恢复现场——递归中"活过下一次调用"的保障,序言/尾声雏形)
HALT 停机;0xF8 预留 DIV
ASM/asm.py 用两遍扫描把汇编文本翻译成机器码:第一遍用位置计数器(LC)
建符号表(标号 → 地址,标号本身占 0 字节);第二遍查表生成字节,前向/后向
引用统一解决。编码的单一事实源在 CPU/isa.py——全部经 isa.I_* 编码,
汇编器零重复实现;十类错误(未定义/重复标号、非法寄存器、缺 #/[]、JR 偏移越界等)
带行号在翻译期拦截。
语法刻意最小化:标号 name:(可与指令同行)、注释 ;、立即数 #5/#0x1F、
地址 [0x80](也接受 [标号])、跳转目标直接写标号名;伪指令 .org(定位,
只许前进、中间补零)与 .db(数据/ASCII 字符串)。立即数也接受 #标号(取标号
地址);JR 族同样写目标标号,偏移由汇编器算。指令与 isa 的 43 条一致,
助记符大小写不敏感(ldi = LDI,解析时统一转大写);标号名则大小写敏感
(loop ≠ Loop,符号表按原样存取)。标号名只需是合法标识符(字母/下划线开头)——名字是翻译期的
脚手架,查表换成地址后即抹除,机器码里只有数字(有蜕变测试守护此性质)。
从此告别手算跳转地址——三个示例程序曾栽过的坑(地址 +2 事故)由机器数数 根除。
python -m ASM.test_asm # 281 项断言(瞬时)
python -m ASM.asm ASM/example.asm # 翻译:机器码 + 反汇编对照
python -m ASM.asm ASM/example.asm --run # 翻译 + 上机执行(带跟踪)测试四层:与 isa.I_* 的编码差分(43 助记符 × 8 寄存器)、标号与伪指令、
错误用例(含行号专项)、端到端(汇编 → 上机 → 与 Python 对账:阶乘 120、
累加 15)。示例源码见 ASM/example.asm。
- 8 位字宽、LSB-first 位列表、超出位宽自动截断
- 新机状态确定性全零(8 寄存器/内存/标志/SP 从 0 出发)——测试中寄存器作
计数器用(断言读增量)可依赖零起点免初始化;作数据载体用
(值本身是断言内容)则必须显式
LDI装值 - 时序纪律:组合阶段"读旧值 + d()/write() 声明",时钟沿 tick() 统一提交; 同拍读到的永远是旧值
- 标志位 Z/N/C/V(减法 C 为借位取反,6502/ARM 同派);ADC/SBB 的进位输入 = C 标志本身(借位取反惯例下无需取反);INC/DEC 只写 Z/N、C/V 保持 (指针步进不踩进位链,x86/6502 同款);乘法 8x8 → 16 位(存低字节,C=高字节非 0)
- 硬件栈:SP 空栈 = 0xFC(I/O 阁楼 0xFC~0xFF 之下),PUSH 即 SP−1 再写, 栈从 0xFB 向下生长、与数据区相向而行,无溢出保护
- I/O 端口约定(设备冒充内存,CPU 零知情,示例脚本内定义):读 0xFC 取键 (空 = 0 哨兵);写 0xFE 打字符 / 0xFD 回车;0xFC~0xFF 是"I/O 阁楼"、 在栈路径之外(端口/栈已分家,见架构节内存地图);帧缓冲区按程序各自约定
- 依赖方向自底向上:gate → full_adder → alu;dff → register → register_file/pc; 部件包不知道 CPU 的存在
一条指令里的地址什么时候被定死(学名 binding time / 绑定时机)——这个 变量同时讲得清 a.out→COFF/ELF 的格式演化史与本机的开发顺序:
| 幕 | 绑定时机 | 真实史 | 本机证据 |
|---|---|---|---|
| ① 手编绝对地址 | 编写时 | 1948-55 手编汇编;a.out 的精神 | first~sixth 注释手标地址、手算跳转;fifth 的 +2 事故 |
| ② 符号表与标号 | 翻译时(仍绝对) | 1970s a.out:符号有、重定位无 | ASM/(蜕变测试:名字不进机器码) |
| ③ 绝望的运行时绑定 | 运行时(地址嵌在指令里) | 前变址寄存器时代的自修改代码 | second/third/sixth 的地址字节补丁 |
| ④ 正规运行时绑定 | 运行时(地址是数据) | 1954-58 变址寄存器发明 | LDX/STX(sixth_v2 547→483 差分送别);栈 = 半版(返回地址运行时产生,但专营不可通用) |
| ⑤ 未至之境(开工中) | 装载时 / 运行时按需 | COFF/ELF:段+重定位+符号表;GOT/PLT 懒绑定 | JR 相对跳转 = PIC 雏形(已建,第十二站:块状 imp 零补丁迁徙——第七站那条 STX 补丁就此退役);待建:link.py 多模块、相对 CALL 与相对数据寻址(取 PC 魔术半成功为证) |
路线图因此有了历史因果线:JR 已补上 PIC 的控制流半边;多模块 = 跨 1960s 链接器线;相对 CALL + base+offset 寻址 = PIC 完全体的最后两块砖——待办清单 不再只是功能列表,是计算史的重演进度表。
- 逻辑门
- 8 位加减法器
- ALU(算术/逻辑/移位/乘法/标志位)
- 时序骨架:DFlipFlop → Register → Clock
- 存储部件:寄存器堆 / PC / RAM(MUX 与译码器首次登场)
- 指令集与控制器:ISA / 微程序表 / 整机跑通循环程序
- 迷你汇编器 ASM/:两遍扫描、标号自动解析、
.org/.db、CLI--run - CALL/RET 与硬件栈:子程序、嵌套调用、递归(236+161 项断言护体)
- PUSH/POP:栈上保存/恢复现场;定义直译版阶乘与两次递归的 fib 验收(272+180 项断言)
- 寄存器间接寻址 LDX/STX:指针成为寄存器里的普通数据,自修改代码正式退役 (新旧机制 64 格逐字节差分一致,测试增至 312+214 项)
- ADC/SBB 带进位加减:微码 c_from 字段三选一(0/1/C),C 标志反馈线接入 ALU;16 位加减 76→25 条、32 位链 21 条(测试增至 366+236 项)
- INC/DEC 的"C 保持":微码 flags 字段升级为 True/False/"ZN",INC/DEC 只写 Z/N、C/V 保持——指针步进不再踩进位链(v2 第二幕翻车程序原地算对,活证据; 测试 376 项全绿,14 程序回归结果零变化;v3 复活差分验收 + 任意位宽推广 (实测 256 位)与空间/时间账本)
- 端口/栈分家:SP 初始 0→0xFC,0xFC~0xFF 成 I/O 阁楼、栈从 0xFB 向下与 数据区相向而行(tenth 相撞花絮推动的内存地图正式化);端口/帧缓冲/全部 冻结程序零改动;tenth 回归惯例端口 0xFE 全绿 = 修复验收现场(测试 377 项)
- NOT/ROL/ROR 指令化(0xB0/0xB8/0xC0 段,32→35 条):ROL/ROR 为穿 C 的 链式旋转(cin 接 C——c_from 的第三、四位 FLAG 客户),多字节数从此能 移位(SHL lo/ROL hi);NOT 只写 Z/N 保链(NEG 惯用法 NOT+INC);ALU 的 旧自转版旋转同步升级为链式并双 cin 穷举(197.3 万项);测试 430+266 项
- JR 相对跳转族(0xC8 段,35→43 条):PIC 雏形——同一段字节两基址逐字节 相同、原样搬家照跑;块状 imp 零补丁迁徙(第七站 STX 补丁退役),取 PC 魔术 揭示剩余两块砖(相对 CALL / 相对数据寻址);汇编器 rtarget + #标号(测试 449+281 项)
- 阶段四余项:变长指令、多周期状态机、link.py 多模块链接、相对 CALL + 相对数据寻址(PIC 完全体)、Breakout/迷你 Eliza 等交互程序