深入浅出计算机原理
CHAPTER 01 · 信息如何变成电路

计算机全景:一条指令的旅行

一句话总览:计算机把程序和数据编码成比特,由 CPU 取指并执行,通过存储与外设完成任务。
🏭
生活化类比 · 对应与边界
把电脑想成厨房:程序是菜谱、CPU 是厨师、内存是操作台、SSD 是储物间、外设是点餐与上菜窗口。菜谱也要放上操作台才能方便读取;边界是 CPU 没有理解力,只能执行约定的指令,真实机器还会并行、缓存与预测。

1.1 先认清五个角色

运算器负责算术与逻辑;控制器决定下一步动作,两者与寄存器等共同构成 CPU。输入、输出和存储连接成整机。内存容量决定能同时铺开多少工作,CPU 决定怎样处理这些工作。

程序运行:先装入,再取指,最后产生输出
程序运行:先装入,再取指,最后产生输出SSD / 持久保存程序文件断电通常仍保留主存 RAM运行中的代码和数据常见 DRAM 断电丢失CPU控制器 + 运算器寄存器:眼前工作台输出设备显示 / 声音或写回文件读写输入设备 → 提供数据;互连 → 在这些部件间运送请求和数据
图中箭头表示数据与请求的路径;程序文件存在 SSD 上,不等于 CPU 正在执行它。
角色做什么看得见的例子
CPU执行指令、操纵数据计算两个数、判断条件
内存暂放正在使用的代码和数据打开的程序、活动数组
SSD / 磁盘长期保存文件照片、可执行文件
输入 / 输出连接外部世界键盘、屏幕、网卡

1.2 存储程序:指令也是数据的一种解释

同样一串 0 和 1,被取指单元按指令格式解释,可能表示“相加”;被图像程序解释,可能表示像素颜色。比特本身没有“这是照片”的标签,意义来自格式与上下文。现代机器通常有分别存放指令与数据的一级 Cache,但仍属于存储程序思想。

同一串比特,解释方式决定意义
同一串比特,解释方式决定意义位模式01000001按 ASCII 编码解读字符 A按无符号整数解读十进制 65放入约定的图像格式中解读可能表示某个颜色通道的强度
这是三种可选解释,分支表达“按哪种规则读”;比特本身不标注用途。

1.3 用一次加法串起后面的课程

JavaScript · 可在浏览器控制台运行
const a = 3;
const b = 4;
const sum = a + b;
console.log(sum); // 7;这是源代码,CPU 实际执行机器指令
怎么学这份宝典
适合零基础到计算机专业入门。按目录依次学:信息与电路 → CPU → 存储 → 外设与系统 → 整机分析。每章约 15–25 分钟;先看图、手算例题,再做自测,最后打卡。代码标有语言;伪汇编只用于理解机制。窄屏下,图解、表格和实验画布可左右滑动查看。进度保存在当前浏览器,自测和实验状态刷新后重置。
易错:把内存与硬盘混为一谈
错误:认为“SSD 还有空间,内存就不可能满” → 后果:同时开很多程序仍可能卡顿或分配失败 → 正确:分别观察 RAM 工作集与持久存储占用,二者承担不同角色。
记忆锚点
文件先装入,CPU 再取指;内存管眼前,存储管长久。

1.4 随堂自测 · 先想再点

QUIZ 1
关闭电源后,普通 DRAM 中的运行数据通常怎样?
DRAM 需要持续供电和刷新。保存文件是把需要的数据写到持久存储,CPU 主频不能替代这一步。
QUIZ 2
字节 01000001 为什么既能表示 65,又能表示 A?
这串比特按无符号整数是 65,按 ASCII 是 A。存储器只保存位模式,程序与格式决定语义。
CHAPTER 02 · 信息如何变成电路

二进制与单位:数格子的方法

一句话总览:二进制用位权表示数值;bit 是一位,byte 通常是八位,容量与速率必须先统一单位。
💡
生活化类比 · 对应与边界
想象一排八盏灯:亮是 1,灭是 0,每盏灯的“分值”从右向左翻倍。位模式对应灯的状态,位权对应分值;边界是电路中的 0/1 实际对应电压范围,并非必须真的发光。

2.1 位置比符号更重要

十进制 305 = 3×100 + 0×10 + 5;二进制同理,只把底数换成 2。8 位无符号整数共有 2⁸ = 256 种组合,范围为 0–255。

00101101₂ = 32 + 8 + 4 + 1 = 45₁₀
00101101₂ = 32 + 8 + 4 + 1 = 45₁₀02^7 = 12802^6 = 6412^5 = 3202^4 = 1612^3 = 812^2 = 402^1 = 212^0 = 1
从最右一位的 2⁰ 开始,只有为 1 的位参与求和;前导 0 不改变数值。

2.2 十六进制是二进制的速记法

四个二进制位恰好对应一个十六进制数字:0–9、A–F。分组从右往左,每四位一组;0x 是常用十六进制前缀,0b 是常用二进制前缀。

四位一组:同一个数的三种写法
四位一组:同一个数的三种写法二进制0010 | 1101十六进制2 | D → 0x2D十进制2×16 + 13 = 45
进制改变写法,不改变数值;0x10 是十进制 16,不是十进制 10。
JavaScript · 观察不同进制
const n = 0b00101101;
console.log(n);              // 45
console.log(n.toString(16)); // "2d"
console.log(0x2D === 45);     // true

2.3 容量、带宽和地址数量

写法含义换算或例题
1 B / 1 byte1 字节,现代通用计算机中是 8 bit1 B = 8 b
kB / MB / GB十进制容量单位1 MB = 1,000,000 B
KiB / MiB / GiB二进制容量单位1 MiB = 1,048,576 B
100 Mb/s每秒 100,000,000 bit理想上限 12.5 MB/s,实际还有协议等开销
n 位字节地址能区分 2ⁿ 个字节位置32 位字节地址的理论空间为 4 GiB;不等于已安装内存
易错:看到 100 Mbps 就当作每秒 100 MB
错误:把小写 b 当大写 B → 后果:估计的下载时间可能差 8 倍 → 正确:先除以 8,再考虑协议、设备与链路开销;KB 的使用可能含糊,需确认厂商约定。
记忆锚点
二进制看位权,十六进制四位团;小 b 是位,大 B 是字节。

2.4 随堂自测 · 先想再点

QUIZ 1
一个 8 位无符号整数的最大值是多少?
8 位共有 256 种位模式,从 0 开始计数,因此最大值为 2⁸−1 = 255。256 需要第九位。
QUIZ 2
理想情况下,80 Mb/s 的链路最多相当于多少 MB/s?
每字节 8 位,因此 80÷8 = 10 MB/s。这是忽略协议和其他瓶颈的理论换算。
CHAPTER 03 · 信息如何变成电路

整数与补码:绕一圈的算术

一句话总览:同一位模式可按有符号或无符号解释;补码让固定宽度的加减共享加法器,结果必须检查范围。
🕘
生活化类比 · 对应与边界
把 4 位无符号加法看作只有 16 个刻度的钟:15 再加 1 回到 0。补码把刻度 8–15 解释为 −8 到 −1。固定宽度对应钟面大小,截断对应绕圈;边界是语言不一定允许你依赖有符号溢出,例如 C/C++ 的有符号溢出不能当成可靠回绕。

3.1 同样的 1111,为什么可能是 −1?

n 位补码的最高位权重是 −2ⁿ⁻¹,其余位仍取正位权。4 位 1101 = −8 + 4 + 0 + 1 = −3。无符号范围 0…2ⁿ−1;补码范围 −2ⁿ⁻¹…2ⁿ⁻¹−1。

固定 4 位:编码不变,解释不同
固定 4 位:编码不变,解释不同同一位模式1 1 0 1按无符号解释8 + 4 + 1 = 13按补码解释−8 + 4 + 1 = −3最高位的权重变了不是“单独一个负号”
补码的符号位参与整体编码;不能把其余位直接读成绝对值。

3.2 求负数、做加法、扩展位宽

4 位示例:3 的相反数如何编码
4 位示例:3 的相反数如何编码正数 30011逐位取反1100再加 11101 = −3验算0011 + 1101截为 0000
取反加一适用于固定宽度;最高位外的进位丢弃后,3 + (−3) 得 0。
机制4 位例子为什么
符号扩展到 8 位1101 → 11111101,仍是 −3扩展有符号数时复制最高位
无符号零扩展1101 → 00001101,仍是 13扩展无符号数时在高位补 0
有符号溢出0111 + 0001 → 1000,即 7+1 变成 −8真值 8 超过 4 位补码最大值 7
进位不等于有符号溢出1111 + 0001 → 0000,外溢进位为 1按补码是 −1+1=0,没有有符号溢出

3.3 亲手拨动补码位模式

操作目标:先看 127,再点“加 1”。比较无符号的 128与补码的 −128,解释为什么同一结果具有两种读法。再看 255 加 1:这次无符号发生回绕。

HANDS-ON DEMO 01
8 位补码实验台
切换任意位,或让有限宽度的结果绕圈。演示的是位模式,不代表所有语言的溢出规则。窄屏可左右滑动图示。
JavaScript · 显式模拟 8 位,而非依赖语言溢出
const raw = (127 + 1) & 255; // 只保留低 8 位:128
const signed = raw < 128 ? raw : raw - 256;
console.log(raw, signed);   // 128, -128
易错:只要出现最高位外进位,就说“有符号溢出”
错误:混淆无符号进位与有符号溢出 → 后果:把 −1+1 这样的正常补码运算判错 → 正确:分别按两种范围检查;补码加法中,同号相加却得到异号结果才是有符号溢出。
记忆锚点
先定位宽,再问符号;取反加一求相反,扩位保值看符号。

3.4 随堂自测 · 先想再点

QUIZ 1
4 位补码 1110 表示什么?
最高位的权重是 −8,所以 −8+4+2 = −2。14 是按无符号整数解释的值。
QUIZ 2
4 位补码加法中,哪一项发生有符号溢出?
7+1 的真值是 8,超出 −8…7;截为 1000 后被读成 −8。其他三项的真值都在范围内。
CHAPTER 04 · 信息如何变成电路

小数、文字与像素:编码的约定

一句话总览:数字、文字和图像都存成比特;编码决定怎么解释,精度与长度决定能表达多少。
🧪
生活化类比 · 对应与边界
把浮点数想成科学计数法的标签:符号决定方向,指数决定量级,有效数字决定细节;把字符编码想成字典编号再装进信封。码点是编号,UTF-8 是装箱规则;边界是一个视觉字符可能由多个码点组合,字典编号并不等于屏幕字形。

4.1 浮点数:范围大,不代表处处精确

二进制小数的位权是 1/2、1/4、1/8……0.5 = 0.1₂ 可以精确表示;0.1₁₀ 的二进制展开会无限循环,因此必须舍入。IEEE 754 的 binary32 常见布局为 1 位符号、8 位指数、23 位小数部分。

binary32 的三段:不是“前半整数,后半小数”
binary32 的三段:不是“前半整数,后半小数”符号 s1 bit指数 E8 bits,偏置 127小数部分 F23 bits,正规数的前导 1 不存储正规数值 = (−1)^s × (1.F)₂ × 2^(E−127)例:1.5 = 1.1₂ × 2⁰ → s=0,E=127,F=1000…E=0 或 255 有特殊规则,涉及零、非正规数、无穷和 NaN。
23 位存储小数加上隐含前导 1,正规数具有 24 位二进制有效精度;大数附近的可表示间距更大。
JavaScript · Number 通常用 binary64
console.log(0.1 + 0.2 === 0.3); // false:舍入误差
const a = 0.1 + 0.2, b = 0.3;
const close = Math.abs(a - b) <= 1e-12 * Math.max(1, Math.abs(a), Math.abs(b));
console.log(close); // true;容差应随业务与误差尺度选择

4.2 文字:码点、字节、字形是三个层次

“中”从抽象字符走到存储字节
“中”从抽象字符走到存储字节字符中Unicode 码点U+4E2DUTF-8 编码E4 B8 AD3 个字节解码与字体恢复字符并画出字形
UTF-8 对单个 Unicode 标量值使用 1–4 字节;“一个汉字永远两个字节”不是通用规则。
观察对象例子别混淆
ASCIIA → 0x41ASCII 范围的字符在 UTF-8 中也是一个字节
Unicode 码点中 → U+4E2D码点不是字节序列
UTF-8 字节中 → E4 B8 AD解码用错编码可能产生乱码
像素 RGB红色 → (255,0,0)这里只讨论 8 位/通道的未压缩 RGB;编码图片还含结构与元数据

4.3 图像:容量先数样本,再数每样本的位数

一张 100×100 像素、每像素 24 位的未压缩 RGB 图,其像素数据为 100×100×3 = 30,000 B。透明度通道、行填充、文件头或压缩都会改变实际文件大小。

一个像素的 24 位 RGB 表示
一个像素的 24 位 RGB 表示R 通道8 bit:0–255G 通道8 bit:0–255B 通道8 bit:0–255合在一起24 bit = 3 B
通道数量和位深决定原始数据规模;不能仅凭分辨率推断 JPEG/PNG 文件大小。
易错:字节数等于字符数,浮点数等于精确实数
错误:按“一字符一字节”截取 UTF-8,或用浮点直接表示所有金额 → 后果:截断多字节字符形成非法序列,或累积舍入误差 → 正确:按字符边界处理文本;精确金额可用最小货币单位整数或适合业务的十进制定点方案。
记忆锚点
浮点保量级,精度有边界;字符先编号,编码才落字节。

4.4 随堂自测 · 先想再点

QUIZ 1
为什么 0.1 常不能被二进制浮点精确存储?
有限位数只能保留有限的二进制有效数字。0.5、0.25 等可以精确表示,不能把所有小数一概而论。
QUIZ 2
“中”的 UTF-8 编码为 E4 B8 AD,这说明什么?
E4、B8、AD 各是一个字节。其他字符的 UTF-8 长度可能不同,视觉上的一个字符也可能含多个码点。
CHAPTER 05 · 电路如何执行指令

逻辑门与加法器:计算从开关长出

一句话总览:逻辑门把输入位映射为输出位;组合电路连接这些规则,就能实现加法、比较和选择。
🔌
生活化类比 · 对应与边界
把逻辑门想成通行规则:AND 像“两张证都要有”,OR 像“任一证即可”,XOR 像“恰好一张”。证件是否存在对应输入 0/1,是否放行对应输出;边界是实际电路有传播延迟、功耗与电压容限,并非瞬间判定的抽象开关。

5.1 四条规则就能读懂很多电路

ABA AND BA OR BA XOR B
00000
01011
10011
11110

NOT 只有一个输入:NOT 0 = 1,NOT 1 = 0。位运算操作每一位;逻辑运算先把整个值当作真假。二者用途不同。

全加器:一位运算也要接住低位的进位
全加器:一位运算也要接住低位的进位三个输入A = 1B = 1,Cin = 1全加器S = A XOR B XOR CinCout = AB + A·Cin + B·Cin本位和 S = 1进位 Cout = 11 + 1 + 1 = 3 = 11₂ → 低位输出 1,高位进位 1
公式中的乘法表示 AND、加法表示 OR;输出两位共同表达三个输入的和。

5.2 多位加法器:进位会走路

4 位行波进位:低位先产生信息,高位才能定结果
4 位行波进位:低位先产生信息,高位才能定结果bit 0 加法器接收 Cin产出 C1bit 1 加法器接收 C1产出 C2bit 2 加法器接收 C2产出 C3bit 3 加法器接收 C3产出 Cout
这是教学用行波进位结构;进位逐级传播会影响关键路径,实际可用更快的进位结构。

5.3 选择器与 ALU:先算规则,再选结果

多路选择器 MUX 用控制信号从多个输入中挑一个。ALU 可并行产生或组织不同运算,再按控制码选择加、与、或等结果。CPU 的“决定做哪种运算”最终也要落到控制信号上。

控制信号让同一组硬件完成不同任务
控制信号让同一组硬件完成不同任务操作数A,B候选运算加法 / 与 / 或MUX 选择由 ALU 控制码决定结果写入目标寄存器
图示强调功能关系;具体 ALU 的共享与并行方式依实现而异。
JavaScript · 一位全加器
const A = 1, B = 1, cin = 1;
const sum = A ^ B ^ cin;
const cout = (A & B) | (A & cin) | (B & cin);
console.log(sum, cout); // 1, 1
易错:用 OR 代替 XOR 求本位和
错误:把 1+1 的本位结果写成 1 OR 1 = 1 → 后果:连 1+1=10₂ 都算错 → 正确:本位和用 XOR,进位单独计算;逻辑真假与逐位计算也要分开。
记忆锚点
异或管本位,相与生进位;选择器听控制,ALU 出结果。

5.4 随堂自测 · 先想再点

QUIZ 1
全加器输入 A=1、B=0、Cin=1,输出是什么?
1+0+1=2=10₂,因此本位为 0、进位为 1。不能只看 A 与 B 而忽略 Cin。
QUIZ 2
为什么行波进位加法器增大位宽后可能更慢?
组合电路存在传播延迟,级联路径越长,最坏路径可能越慢。更快的进位结构就是在缩短这种依赖。
CHAPTER 06 · 电路如何执行指令

时钟与寄存器:电路怎样记住昨天

一句话总览:组合逻辑计算“下一步”,寄存器在约定时刻保存状态;时序电路 = 记忆 + 状态转移。
📸
生活化类比 · 对应与边界
把时钟沿想成统一拍照口令:寄存器在约定沿给输入“拍快照”,两个沿之间组合逻辑准备下一张。快照对应保存的状态,口令间隔对应周期;边界是输入必须在拍照前后保持稳定,物理电路不是随意按下就永远拍清楚。

6.1 没有记忆的规则,怎么执行一连串步骤?

组合电路输出依赖当前输入;时序电路还依赖已有状态。寄存器可由一组触发器组成,保存若干位。以下教学模型采用上升沿触发:在两个有效沿之间,Q 保持旧值,D 可以经过运算逐渐稳定。

状态反馈:旧状态参与计算,时钟沿保存新状态
状态反馈:旧状态参与计算,时钟沿保存新状态寄存器 Q当前计数 = 3组合逻辑下一值 D = Q + 1下一个有效时钟沿采样 D → Q = 4进入下一周期,新的 Q 再次参与计算数据流:Q → 计算 D → 沿到来才更新 Q
不能把 D 变化误认为 Q 立刻变化;寄存器在约定沿更新,形成离散状态。

6.2 频率不是越高越稳

时间概念含义直观结果
时钟周期 T相邻有效沿之间的间隔f = 1/T;1 GHz 对应 1 ns 周期
建立时间 setup采样前,输入需要稳定一段时间组合路径不能晚于这条截止线
保持时间 hold采样后,输入仍需稳定一段时间过早变化也可能导致采样问题
关键路径决定最慢完成时间的路径简化约束:T ≥ clk-to-Q + 组合延迟 + setup;还需考虑时钟偏差等
两个时钟沿之间:要给计算留足时间
两个时钟沿之间:要给计算留足时间时间 →沿 1:发出旧状态沿 2:采样新状态组合逻辑传播并稳定稳在下一沿到来前,数据要完成传播并满足 setup
图中脉宽仅为示意;判断可用频率看最坏延迟与时序约束,不能只看逻辑公式是否正确。

6.3 状态机:红绿灯也是“下一状态函数”

简化三态控制器:每次 tick 前进一步
简化三态控制器:每次 tick 前进一步RED停车tick → GREENGREEN通行tick → YELLOWYELLOW准备停车tick → RED
最后一个状态回到 RED,构成循环;真实交通控制还包含计时、行人请求和安全约束。
JavaScript · 用变量模拟状态寄存器
let state = "RED";
function tick() {
  const next = { RED: "GREEN", GREEN: "YELLOW", YELLOW: "RED" };
  state = next[state]; // 模拟一个有效时钟沿更新状态
  return state;
}
console.log(tick()); // GREEN
易错:组合逻辑画对了,就认为任意频率都能运行
错误:忽略传播与采样时序,直接缩短周期 → 后果:寄存器可能采到未稳定数据,结果间歇出错 → 正确:计算关键路径并满足建立、保持时间;跨时钟域信号还需专门同步处理。
记忆锚点
组合算未来,寄存存现在;时钟负责交接,时序决定能否交好。

6.4 随堂自测 · 先想再点

QUIZ 1
上升沿触发寄存器的 D 在两个有效沿之间变化,Q 通常怎样?
沿触发寄存器只在约定沿更新;这里假定正常工作且没有异步控制。透明锁存器的行为则不同。
QUIZ 2
若最坏组合路径还没稳定,下一个采样沿已到,最直接的风险是?
逻辑正确不保证时序正确。必须给最坏路径和寄存器的采样约束留足时间。
CHAPTER 07 · 电路如何执行指令

指令集:软件与硬件的接口

一句话总览:指令集 ISA 约定机器能做什么、指令怎样编码、程序能看到哪些状态;微架构决定具体怎样实现。
📝
生活化类比 · 对应与边界
把 ISA 想成餐厅的菜单与点单格式,微架构是后厨的分工与设备。同一道菜可以由不同厨房完成。指令语义对应菜品承诺,实现对应工作流程;边界是现实菜品很难严格一致,而兼容 CPU 必须满足 ISA 规定的可观察行为。

7.1 源代码、汇编、机器码分别给谁看?

从人的意图到硬件认可的位模式
从人的意图到硬件认可的位模式源代码sum = a + b汇编记号ADD R0, R1, R2机器码按 ISA 格式编码硬件执行更新规定的状态
这里只展示概念层次;解释器与 JIT 也可能在运行时产生机器码。汇编记号不是 CPU 读取的字符串。
教学 ISA:假设一条指令固定 16 位
教学 ISA:假设一条指令固定 16 位操作码bits 15…124 位:做什么目标寄存器bits 11…84 位:写到哪源寄存器bits 7…44 位:从哪读源寄存器 / 小立即数bits 3…0由操作码决定怎样解释字段宽度总和:4 + 4 + 4 + 4 = 16 位
这是自定义教学编码,不是 x86 或 RISC-V 的真实指令格式;真实 ISA 的字段分配各不相同。

7.2 三类操作数:立即数、寄存器、内存

写法(伪汇编)意思发生什么
ADD R0, R1, R2R0 ← R1 + R2读两个寄存器,写一个寄存器
ADD R0, #4R0 ← R0 + 44 是指令里的立即数
LOAD R0, [R1+8]R0 ← 内存[R1+8]用基址与偏移算有效地址,再访问内存
STORE [R1+8], R0内存[R1+8] ← R0地址与要写的数据是不同东西
BEQ R0, R1, target相等则跳到 target可能改写下一条指令的位置 PC

7.3 ISA 与微架构:兼容不等于一样快

ISA 像接口合同,包含寄存器、指令行为、可见异常等;流水线深度、Cache 大小、乱序调度等通常属于实现。RISC/CISC 是描述指令设计取向的历史术语,不能直接推出“谁一定更快”或“每条都用一个周期”。

伪汇编 · 只展示语义,不绑定真实处理器
LOAD  R0, [100] // 把地址 100 中的值读入 R0
ADD   R0, #4    // R0 中的数值加 4
STORE [104], R0 // 把结果写到地址 104
易错:把地址当成地址里的值
错误:把 LOAD R0,[100] 理解为 R0=100 → 后果:后续计算拿到位置编号而非数据 → 正确:区分立即数 #100 与内存访问 [100];具体汇编语法还应遵循目标 ISA。
记忆锚点
ISA 说承诺,微架构说做法;方括号找内容,立即数直接拿。

7.4 随堂自测 · 先想再点

QUIZ 1
两款 CPU 使用相同 ISA,为什么运行同一程序仍可能耗时不同?
兼容 ISA 保证规定的行为,并不保证相同延迟。不同微架构可以采用不同缓存、并行和预测设计。
QUIZ 2
伪指令 LOAD R0,[R1+8] 中,R1+8 一般表示什么?
先用基址 R1 加偏移 8 形成地址,再把该位置的数据读入 R0。地址计算不等于业务数据加法。
CHAPTER 08 · 电路如何执行指令

CPU 执行:取指、译码与状态更新

一句话总览:执行指令就是取出编码、生成控制、完成运算或访存,再更新寄存器、内存与 PC。
🚚
生活化类比 · 对应与边界
把 CPU 想成按工单操作的工位:PC 是下一张工单的位置,IR 是当前拿在手中的工单,译码是查操作规则,执行是动手。工单位置不等于工单内容;边界是现代 CPU 会让多张工单重叠甚至乱序处理,这里先用顺序模型看清因果。

8.1 先把数据通路里的角色放对

简化数据通路:数据走线路,控制信号决定线路做什么
简化数据通路:数据走线路,控制信号决定线路做什么PC指令地址指令存储 / IR取出指令编码控制单元译码 → 控制信号寄存器组读源值 / 写结果ALU算术 / 计算地址数据存储读 / 写写回路径:ALU 结果或读取的数据 → 目标寄存器
图中省略选择器与部分控制连线;PC 也会按顺序、分支、异常等规则更新。

8.2 用一条 LOAD 看清四个教学阶段

阶段读什么 / 做什么本例重点
取指 FETCH用 PC 找到指令,放入 IR拿到 LOAD R0,[10]
译码 DECODE识别操作与操作数,准备控制知道这是读内存,不是做立即数赋值
执行 EXECUTE计算地址并读取数据,或完成 ALU 运算读到 M[10]=3,暂存结果
更新 COMMIT按指令语义写寄存器或内存,推进 PCR0=3,PC 指向下一条

这四阶段是为了教学分解,不是实际处理器的固定流水级数,也不表示每阶段必为一个真实时钟周期。PC 在真实 ISA 中常以字节地址表示;下面实验为便于观察,PC 使用指令序号。

8.3 亲自执行:把 3 加 4 再存回

HANDS-ON DEMO 02
微型 CPU:看见每一步状态变化
初始 M[10]=3、M[11]=0、R0=0。请观察:译码不会让数据突然改变,结果在更新阶段才落到教学机状态。窄屏可左右滑动图示。
实验程序 · PC 按指令序号计数
LOAD  R0, [10] // PC=0:读出 3
ADD   R0, #4   // PC=1:算得 7
STORE [11], R0 // PC=2:将 7 写回 M[11]
HALT           // PC=3:教学机停止
易错:把所有“执行”都理解为 ALU 加法
错误:认为每条指令都会计算一个数并写同一寄存器 → 后果:看不懂 STORE、分支和异常的状态变化 → 正确:先问它读什么,再问它修改哪些可见状态;STORE 写内存,分支修改控制流。
记忆锚点
PC 指路,IR 拿单;译码发令,执行更新。

8.4 随堂自测 · 先想再点

QUIZ 1
实验中,STORE [11],R0 的主要可见效果是什么?
STORE 把数据从寄存器送到指定内存位置,之后按教学模型进入下一条。它通常不以写目标通用寄存器为主要结果。
QUIZ 2
取指时,PC 和 IR 的关系是什么?
PC 回答“下一条去哪里找”,IR 回答“当前取到了什么”。它们承担不同角色,不能互换。
CHAPTER 09 · 电路如何执行指令

流水线与并行:提高产量的代价

一句话总览:流水线让不同指令重叠占用不同阶段以提高吞吐,但数据依赖、资源冲突与分支会带来等待。
🧺
生活化类比 · 对应与边界
把流水线想成洗衣、烘干、折叠三个工位:第一篮在烘干时,第二篮可以洗。工位对应流水级,篮子对应指令;边界是指令之间会依赖结果,洗衣篮之间通常没有“后一篮必须吃前一篮产物”的约束。

9.1 先分清“多久完成一条”和“多久产出一条”

4 条指令:理想流水从 20 拍缩为 8 拍
4 条指令:理想流水从 20 拍缩为 8 拍理想五级流水:每阶段 1 拍,无冲突、无停顿1拍2拍3拍4拍5拍6拍7拍8拍指令 1IFIDEXMEMWB指令 2IFIDEXMEMWB指令 3IFIDEXMEMWB指令 4IFIDEXMEMWB
5 级 × 4 条若完全串行需 20 拍;理想流水需 5+4−1=8 拍。单条指令仍经历 5 级,并未变成 1 拍。
指标关注的问题在理想五级示例中
延迟 latency一条指令从进入到完成多久5 拍,未计流水寄存器额外开销
吞吐 throughput单位时间能完成多少条填满后最多每拍完成一条
填充 / 排空开头和结尾有哪些空档短程序难以达到长期峰值
实际性能还受什么影响阶段不均衡、额外寄存器开销、各种停顿

9.2 三类冒险:不是所有气泡都同一个原因

数据依赖:后面的指令要等到可用结果
数据依赖:后面的指令要等到可用结果指令 1LOAD R1,[R2]数据返回前R1 新值尚不可用指令 2ADD R3,R1,R4处理方式转发;必要时停顿
转发能缩短等待,但不能把尚未产生的数据变出来;典型 load-use 依赖仍可能需要停顿。
冒险触发条件常见处理
结构冒险同一时刻争同一资源分离资源、增加端口或停顿
数据冒险后续指令依赖未可用的结果转发、调度、停顿;具体依流水线设计
控制冒险还不知道分支之后执行哪条预测与推测执行,预测错后清除相关工作

9.3 乱序、多发射、多核各解决什么?

机制增加哪种重叠边界
多发射一拍发出多条合适的指令需要足够执行资源与独立工作
乱序执行暂时绕过等待,先做独立指令仍须维护 ISA 规定的可观察行为
多核多个核心处理多个执行流共享数据、同步和串行部分限制加速
伪汇编 · 依赖与独立工作
LOAD R1, [R2]   // 可能等待内存
ADD  R3, R1, R4 // 依赖 R1,不能直接使用旧值
ADD  R5, R6, R7 // 若无其他约束,可作为独立工作调度
易错:五级流水线一定快五倍
错误:用级数直接当加速比 → 后果:忽略短任务填充、依赖与分支,性能预估失真 → 正确:先算完成时间,再计停顿;理想 n 条、k 级等长阶段需 n+k−1 拍,而非总是 n 拍。
记忆锚点
流水提产量,不保证缩单程;依赖没消失,预测会付错路钱。

9.4 随堂自测 · 先想再点

QUIZ 1
理想 5 级流水,每级 1 拍,4 条指令无停顿共需几拍?
总时间为级数 + 指令数 −1,即 5+4−1=8 拍。需要先填充流水,不能一开始就每拍完成。
QUIZ 2
后续 ADD 需要 LOAD 尚未返回的数据,哪种说法合理?
转发传递已经可用的结果,不能改变数据尚未返回的事实。寄存器重命名也不能消除真实的读后写数据依赖。
CHAPTER 10 · 数据如何靠近 CPU

存储层次与局部性:快的为什么小

一句话总览:存储层次用少量快存储缓存大量慢存储中的热点,利用时间与空间局部性缩短平均等待。
📚
生活化类比 · 对应与边界
把存储层次想成读书:手边摊开的几页是寄存器,桌面常用书是 Cache,书架是内存,仓库是 SSD。越常用越靠近手;边界是机器按固定大小的块和替换规则搬运,程序不能像人一样随意凭印象拿书。

10.1 又快、又大、又便宜:通常难同时满足

分层的目的:让大多数访问停在上层
分层的目的:让大多数访问停在上层寄存器少量、紧贴执行L1 / L2 / L3 Cache缓存近期访问块主存 DRAM运行中的工作集SSD / 磁盘大容量持久存储上:通常更快更小 / 每位成本高下:容量更大延迟通常更高
层次是功能关系示意,不是面积、容量或延迟的比例图;具体延迟随平台和负载而变化。
介质保存方式(概念)使用场景
SRAM通过稳定电路状态保存,供电时无需 DRAM 式周期刷新常用于 Cache,较快但每位成本与面积高
DRAM用电容等结构保存信息,需要刷新常用于主存,密度较高
闪存 SSD非易失存储,按设备规则读写与擦除保存文件;写入、擦除粒度和寿命管理由设备处理

10.2 局部性:为什么相邻、重复访问更友好?

两种局部性让一次搬运服务多次计算
两种局部性让一次搬运服务多次计算时间局部性刚用过的变量很快又会用空间局部性用了 a[i]随后用 a[i+1]整块搬入 Cache一次带来相邻字节后续命中减少等待主存
不是“地址近就永远快”;工作集大小、映射冲突、预取和访问顺序会共同影响命中。
JavaScript · 对比访问意图,不作为严格基准
const a = new Uint32Array(1024);
let sum = 0;
for (let i = 0; i < a.length; i++) {
  sum += a[i]; // 连续元素通常能利用空间局部性
}
console.log(sum);

10.3 平均等待时间:一次“偶尔慢”也会拉高均值

简化单级模型:AMAT = 命中时间 + 未命中率 × 额外未命中代价。若查 Cache 用 1 ns,未命中率 5%,未命中后额外等 80 ns,则平均为 1+0.05×80=5 ns。这里“额外”表示不重复包含前面的查找时间。

情况代入结果
5% 未命中1 + 0.05 × 805 ns
1% 未命中1 + 0.01 × 801.8 ns
代价定义不同若给的是未命中总耗时,要用加权平均不要把命中查找时间重复相加
易错:只看 CPU 频率,忽略等待数据
错误:认为处理器更快,所有程序就按比例加速 → 后果:内存密集任务仍被数据供应拖慢 → 正确:观察工作集与访问模式,先改善局部性,再判断是否受带宽或延迟限制。
记忆锚点
常用放近,邻居带来;小快顶上,大慢兜底。

10.4 随堂自测 · 先想再点

QUIZ 1
循环反复使用同一个已读变量,体现哪种局部性?
刚访问过的数据很快再次访问,这是时间局部性。空间局部性关注邻近位置,二者可以同时出现。
QUIZ 2
命中 2 ns,未命中率 10%,额外代价 50 ns,简化 AMAT 为多少?
按定义计算 2+0.1×50=7 ns。50 ns 是额外代价,不是每次访问都要付的代价。
CHAPTER 11 · 数据如何靠近 CPU

Cache:标签、映射与替换

一句话总览:Cache 把地址拆成标记、索引、块内偏移,索引找候选,标签确认身份,偏移选块内字节。
🗄️
生活化类比 · 对应与边界
把直接映射 Cache 想成按尾号分格的临时柜:编号决定只能去哪个格,格上标签记录目前放的是谁。索引对应格号、tag 对应身份、offset 对应包裹内部位置;边界是 Cache 按字节地址与固定块长计算,不是随意按十进制尾号分柜。

11.1 一条地址怎样被拆开?

假设字节编址、地址宽 8 位、4 行直接映射 Cache、每行 4 B 数据。offset 占 log₂4=2 位,index 占 log₂4=2 位,剩下 4 位是 tag。这里只计算数据容量 4×4=16 B,不含标签与有效位开销。

地址 0x14 = 0001 01 00₂ 的去向
地址 0x14 = 0001 01 00₂ 的去向tag = 0001高 4 位:确认是哪一个块index = 01中 2 位:第 1 行offset = 00低 2 位:块内第 0 字节先看第 1 行是否有效、tag 是否为 1匹配 → 命中;不匹配 → 搬入块 0x14…0x17
行号从 0 开始。只要 index 一样,不同主存块就会争同一行;不能仅凭索引判断命中。

11.2 用冲突实验看清“刚读过也会丢”

依次访问 0、1、16、0。0 和 1 属于同一个 4 B 块,第二次会命中;16 与 0 映射到同一行,随后把 0 对应的块换掉。实验只模拟读访问、冷启动、直接映射、4 行×4 B。

HANDS-ON DEMO 03
Cache 逐次访问观察台
选地址,看块号、行号、tag 与命中率。每次未命中装入整个 4 B 块。窄屏可左右滑动图示。
JavaScript · 计算直接映射位置
const address = 20; // 十进制 20 = 0x14
const block = Math.floor(address / 4); // 5
const index = block % 4;               // 1
const tag = Math.floor(block / 4);     // 1
const offset = address % 4;            // 0

11.3 映射、替换、写策略分三件事记

问题常见规则关键区别
能放哪?直接映射 / 组相联 / 全相联直接映射只有一行候选,组相联在一组内有多个候选
满了换谁?LRU 及近似策略、随机等替换策略在多个候选之间选择;不改变映射规则
写到哪里?写直达 / 写回写直达也更新下一层;写回先修改 Cache 并标脏,替换等时机再写回
写未命中怎么办?写分配 / 不写分配决定是否把块装进来,与写直达/写回是不同维度
易错:地址对应某行,就认为一定命中
错误:只算 index 不比较 tag 和有效位 → 后果:把另一个主存块的数据错认成目标数据 → 正确:候选行有效且 tag 匹配才命中;块内偏移最后才选具体字节。
记忆锚点
索引找座位,标签核身份,偏移挑字节;映射定位置,替换定去留。

11.4 随堂自测 · 先想再点

QUIZ 1
在本章模型中,先读地址 0,再读地址 1,第二次通常怎样?
冷启动时读 0 搬入整个块 0…3。读 1 只是选择同一块内偏移 1,不需要重新装块。
QUIZ 2
为何读 0、16、0 会让最后一次访问 0 未命中?
块号分别为 0 和 4,index 都是 0,但 tag 不同。直接映射没有另一候选行可留住前一个块。
CHAPTER 12 · 数据如何靠近 CPU

内存布局与字节序:地址里的风景

一句话总览:内存按地址定位字节;类型解释字节、布局安排位置、字节序决定多字节值的排列。
🏢
生活化类比 · 对应与边界
把内存看成有连续门牌号的公寓:地址是门牌,变量值是住户物品,数组是连续租下的一排房间。地址与内容不同,类型说明怎样读连排房间;边界是进程看到的通常是虚拟地址,而且对象布局受 ABI、语言与对齐规则影响。

12.1 数组位置:基址 + 下标 × 元素大小

若基址为 100、每个元素 4 B,则 a[3] 的起始地址是 100+3×4=112。指针的位宽描述地址表示能力,不等于所指对象的大小;32 位数据也可以由 64 位地址来定位。

数组寻址:从元素编号转成字节位置
数组寻址:从元素编号转成字节位置数组基址100下标 3每元素 4 B字节偏移3 × 4 = 12元素起点100 + 12 = 112
数组下标通常从 0 开始;元素不一定只占一个字节。越界不会自动指向“下一合法变量”。

12.2 小端、大端:拆开后,哪一头先放?

32 位整数 0x12345678 的小端存放
32 位整数 0x12345678 的小端存放0x78地址 1000x56地址 1010x34地址 1020x12地址 103低地址 →按小端序组合:0x12345678;最低有效字节放在最低地址
小端:低有效字节在低地址;大端则按地址 100…103 放 12、34、56、78。这里讨论字节顺序,不讨论字节内部的比特传输顺序。
JavaScript · DataView 明确选择字节序
const buf = new ArrayBuffer(4);
const view = new DataView(buf);
view.setUint32(0, 0x12345678, true); // true 表示小端
console.log([...new Uint8Array(buf)]); // [120, 86, 52, 18]

12.3 栈、堆与对齐:布局不是随手排列

典型进程地址空间:看用途,不死记方向
典型进程地址空间:看用途,不死记方向代码 / 只读区域机器指令常量等静态数据全局 / 静态对象生命周期通常较长堆 / 动态区域动态分配对象分配器组织空间线程栈调用帧、返回信息每线程通常有自己的栈实际还包括共享库、映射文件和空洞;地址、顺序、增长方向依平台而异。
图是功能分区示意,不对应固定地址。编译器可能将局部值保留在寄存器,未必真的在栈里。
布局规则为什么存在不要据此推断
对齐让对象起址满足类型 / ABI 约束,便于访问结构体大小不一定等于成员大小之和,可能有填充
栈帧记录一次调用需要的局部状态与返回信息返回后局部对象通常失效,保留地址不延长生命周期
动态分配让对象生命周期不绑定当前调用分配失败、泄漏或悬垂引用仍需管理
保护边界合法地址范围与权限受进程和系统约束有个数字地址不等于有权读写它
易错:原样写入本机整数,就能在所有机器还原
错误:直接用本机字节布局做跨机器文件协议 → 后果:遇到不同字节序、对齐或类型宽度时读错 → 正确:约定字段宽度、字节序与编码,逐字段序列化。
记忆锚点
地址找位置,类型讲读法;小端低位先,跨机先约定。

12.4 随堂自测 · 先想再点

QUIZ 1
基址为 200、每元素 8 B 的连续数组,a[3] 起始地址是?
从 0 开始的下标 3 对应偏移 3×8=24 B,所以地址为 224。不能直接把元素编号当字节偏移。
QUIZ 2
小端存放 0x01020304,最低地址的字节是?
小端把最低有效字节 0x04 放到最低地址。数值本身没有变,只是多字节值在内存中的排列不同。
CHAPTER 13 · 数据如何靠近 CPU

虚拟内存:地址翻译与保护

一句话总览:虚拟内存把进程使用的虚拟地址映射到物理内存并检查权限;它首先是地址抽象与隔离机制。
🏨
生活化类比 · 对应与边界
把虚拟地址想成酒店客人的房号,物理地址是后台真实房间编号;前台映射表决定“客人眼中的 101”实际在哪。页表对应映射,权限对应房卡能否开门,TLB 对应前台常查记录;边界是映射以页为单位,且硬件参与翻译,操作系统处理建立与异常。

13.1 地址拆成页号和页内偏移

若页面为 4 KiB,则页内偏移占 12 位。虚拟页号用于查页表;页内偏移不变,与查到的物理页框号重新组合。进程的虚拟连续区域可以映射到不连续的物理页框。

例:4 KiB 页面,虚拟 0x1234 → 物理 0x9234
例:4 KiB 页面,虚拟 0x1234 → 物理 0x9234虚拟地址 0x1234虚拟页号 1偏移 0x234页表条目虚拟页 1 → 页框 9检查存在位与权限物理地址 0x92349 × 0x1000 + 0x234偏移保持不变另一个进程的同一虚拟页号可以对应不同页框;共享映射也可以指向同一页框。
页大小为本例假设;实际系统可支持多种页大小与多级页表。地址翻译不等于从磁盘读取。

13.2 TLB 未命中和缺页不是一件事

正常翻译快路:先查最近用过的映射
正常翻译快路:先查最近用过的映射虚拟地址CPU 发起访问TLB缓存页表翻译命中可快速得到页框物理地址按权限继续访问Cache / 主存提供目标数据
此图分离概念步骤;实际 Cache 与翻译的先后或并行方式依设计而异,不能把 TLB 当成缓存数据的普通 Cache。
事件是什么没找到 / 不满足可能如何处理
TLB missTLB 里没有目标翻译查询页表并填回 TLB,页面可能已在 RAM
页不在内存页表条目表明当前不能直接访问触发缺页异常,由系统装入、分配或采取其他处理
权限违规访问方式不被该映射允许系统可能终止进程,或按写时复制等机制合法修复
非法地址无合法映射或不满足访问条件异常不一定能恢复;不能承诺“都会从 SSD 找到”

13.3 它还解决隔离,不只是“借硬盘当内存”

页表权限可以让代码页只读、限制用户态访问内核区域,并使不同进程保持独立视图。按需分配、共享映射、写时复制也建立在这个抽象上。换出到持久存储是某些系统的策略,不能用它定义全部虚拟内存。

JavaScript · 只模拟翻译算式
const virtual = 0x1234, pageSize = 4096;
const vpn = Math.floor(virtual / pageSize); // 1
const offset = virtual % pageSize;         // 0x234
const pageTable = { 1: 9 };
const physical = pageTable[vpn] * pageSize + offset;
console.log(physical.toString(16)); // "9234"
易错:把每次 TLB miss 都当成磁盘 I/O
错误:TLB 没记录就认为页面必定不在 RAM → 后果:错误估计开销与故障原因 → 正确:先查页表;缺页也可能只是分配零页或写时复制,不必然读取磁盘。
记忆锚点
页号换身份,偏移不挪位;TLB 缓翻译,页表管映射与权限。

13.4 随堂自测 · 先想再点

QUIZ 1
4 KiB 页中,虚拟地址 0x1234 的页内偏移是什么?
4 KiB=0x1000,所以商为页号 1,余数为偏移 0x234。地址翻译替换页号部分,不改变页内偏移。
QUIZ 2
TLB miss 能否直接推出“需要从 SSD 读页”?
TLB 缓存翻译,miss 后可能通过页表获得映射。是否要读持久存储,取决于页面状态与系统处理策略。
CHAPTER 14 · 整机如何协同工作

总线与输入输出:让设备说同一种话

一句话总览:输入输出经控制器和互连协议交换命令与数据;带宽决定搬运速度,延迟决定开始或完成要等多久。
🛣️
生活化类比 · 对应与边界
把互连想成道路,设备控制器是收发站,协议是交通规则。数据路径对应道路,仲裁对应通行权,握手对应确认;边界是现代互连可能是交换式、串行、点到点的,并非所有设备挤在一条共享平行公路上。

14.1 CPU 不直接理解键盘或 SSD 的物理细节

设备控制器把“外界动作”变成机器可操作的状态
设备控制器把“外界动作”变成机器可操作的状态CPU / 驱动发命令,查状态互连与地址规则请求 / 响应 / 顺序设备控制器控制寄存器状态与缓冲区物理设备键盘、网卡、SSD
驱动是理解设备接口的软件;控制器是执行设备操作的硬件,二者分工不同。
接口角色典型含义为什么需要
控制寄存器启动、停止、设置模式告诉设备要做什么
状态寄存器就绪、忙、完成、错误让软件知道是否能继续
数据寄存器 / 队列提交或获取数据与描述符承载实际工作内容
MMIO把设备寄存器映射到地址空间通过受约束的访存访问设备;并非普通 RAM

14.2 请求、等待、响应:设备有自己的节奏

抽象握手:发出请求不等于设备已经完成
抽象握手:发出请求不等于设备已经完成① 发请求地址 / 命令 / 数据② 等待或排队设备尚在处理③ 响应有效 / 完成 / 错误④ 软件推进读取结果共享资源可能需要仲裁;具体协议可能有多笔未完成请求,图只展示一笔。
“写了启动位”只表示请求已提交;是否完成,要按设备接口检查状态或等待通知。

14.3 轮询与带宽:计算时先写假设

轮询就是反复读状态,直到就绪。对极短等待或专用场景可能合适,长时间忙等则占用 CPU。若教学总线每次传 32 bit、每秒传 100,000,000 次,理想带宽为 32÷8×100,000,000 = 400 MB/s;仲裁、握手等开销会降低有效载荷速率。

伪代码 · readStatus / readData 是抽象设备接口
while ((readStatus() & 1) === 0) {
  // 忙等:CPU 不断检查;真实系统需要超时与错误处理
}
const data = readData(); // 看到就绪后,才按协议读取
概念问题例子
延迟发出一个请求后等多久?小文件首个数据何时到
带宽稳定传输每秒多少数据?大文件连续搬运速率
有效载荷速率真正业务数据有多少?扣除协议、空闲、重复传输等开销
MMIO 访问规则能否缓存、重排、合并?应使用系统 / 驱动提供的接口与必要屏障
易错:把 MMIO 当普通数组随意缓存与重排
错误:用普通内存直觉读写设备状态 → 后果:可能读到过期状态、漏发命令或破坏顺序 → 正确:遵守设备协议,使用操作系统提供的 I/O 访问方式;不能只靠普通变量赋值猜硬件顺序。
记忆锚点
控制发命令,状态问进度;高带宽管大搬运,低延迟管快回应。

14.4 随堂自测 · 先想再点

QUIZ 1
CPU 写入设备“开始”命令后,能否立即认定数据已准备好?
提交命令和完成操作是两件事。设备可能排队或等待外部动作,软件需要遵守完成通知和状态规则。
QUIZ 2
每秒传 2 亿次、每次 16 bit 的教学链路,理想带宽是?
16 bit=2 B,2×200,000,000=400,000,000 B/s,即 400 MB/s。这里忽略全部协议开销。
CHAPTER 15 · 整机如何协同工作

中断与 DMA:谁搬数据,谁喊完成

一句话总览:中断负责通知 CPU 发生了事件,DMA 负责按配置在设备与内存间搬数据;二者可配合但不是同一机制。
🔔
生活化类比 · 对应与边界
把中断想成取餐铃,DMA 想成搬运车:铃提醒你,车运货,工作人员先填搬运单。铃对应通知,车对应 DMA,单据对应描述符;边界是 CPU 还要设置缓冲区、处理权限与同步,DMA 不是不受监管的自动小车。

15.1 中断:先保存现场,再去处理事件

简化中断路径:被打断不等于丢失进度
简化中断路径:被打断不等于丢失进度运行原程序当前指令流响应中断保存必要上下文进入处理程序识别 / 确认事件返回或调度恢复执行状态
何时受理、保存哪些状态、是否切换线程由硬件与系统共同决定;不是每个中断都导致进程切换。
机制触发来源典型例子
外部中断相对当前程序异步的外部事件设备完成、定时器到期
同步异常与正在执行的指令相关缺页、非法操作;分类和恢复规则依架构
处理程序按向量 / 入口进入的受控代码快速处理必要工作,较长任务可延后执行

15.2 DMA:CPU 配置,硬件搬运

DMA 数据路径与通知路径必须分开看
DMA 数据路径与通知路径必须分开看CPU / 驱动① 准备缓冲区② 提交地址、长度、方向设备 / DMA 引擎③ 按描述符搬运访问受系统约束主存缓冲区批量数据在这里不是 CPU 逐字节复制④ 完成后可发中断通知;也可能轮询完成队列
蓝绿路径传输数据,琥珀路径表示完成通知。实际 DMA 地址可能经过 IOMMU 翻译,不能直接假设等于进程虚拟地址。
伪代码 · 驱动流程,省略平台接口细节
const buffer = allocateDmaBuffer(4096); // 按系统规则分配 / 映射
submitDma(buffer, 4096);                // CPU 配置并启动
doOtherWork();                         // 可与搬运重叠
waitForCompletion();                   // 完成通知与必要同步
consume(buffer);                       // 确认完成后再使用数据

15.3 DMA 还需要缓冲区生命期与一致性

方式CPU 主要做什么适用取舍
程序查询 / 轮询反复检查状态,可能自己搬数据简单;等待过长会占用处理能力
中断驱动 I/O收到事件后处理必要工作减少长期忙等;高频中断也有开销
DMA + 完成机制准备队列、映射、处理同步与完成适合批量数据;仍争用内存与互连带宽
缓冲区同步确保双方看见正确版本,完成前不释放是否需显式缓存维护依平台一致性与 API 约定
易错:提交 DMA 后立刻释放或复用缓冲区
错误:认为“函数返回就已经搬完” → 后果:设备继续写已复用的内存,造成数据损坏甚至安全问题 → 正确:按接口等待完成并做必要同步,之后才能读结果、复用或释放缓冲区。
记忆锚点
中断来报信,DMA 来搬运;CPU 填单据,完成再碰缓冲区。

15.4 随堂自测 · 先想再点

QUIZ 1
关于中断与 DMA,哪种表述正确?
通知与数据搬运是两个职责,常常组合使用。DMA 仍需配置、缓冲区管理和完成同步。
QUIZ 2
DMA 写入缓冲区尚未完成,软件就释放了它,风险是什么?
异步传输的硬件活动可能仍在继续。必须遵守系统 DMA API 的完成和生命周期规则。
CHAPTER 16 · 整机如何协同工作

从源码到进程:编译器与操作系统

一句话总览:编译工具把源码变成可执行代码,操作系统建立进程地址空间与执行上下文,让程序受控运行。
🎭
生活化类比 · 对应与边界
把程序文件想成剧本,进程是一场正在演的戏,线程是推进表演的演员;操作系统安排舞台与资源。文件对应静态描述,进程对应运行实例,线程对应执行流;边界是同一进程的线程共享很多资源,不能像完全独立的剧组那样随意忽视同步。

16.1 编译、汇编、链接、装载分别解决什么?

典型原生编译路径:每一步有不同输入输出
典型原生编译路径:每一步有不同输入输出编译源代码 → 汇编或目标表示汇编汇编 → 目标文件链接解析符号 / 重定位组合目标与库装载运行建立映射、入口与上下文
工具链可能合并步骤,也可能直接产生目标代码;动态链接的部分工作发生在装载或运行时。
环节典型错误定位思路
编译语法、类型等检查未通过看源代码与编译诊断
链接找不到函数实现、符号重复检查目标文件、库与声明定义
装载 / 运行依赖不可用、权限或执行期故障检查运行环境、映射与具体异常
C 片段 · 语义不等于固定的机器指令序列
int add(int a, int b) {
  return a + b; // 编译器按目标 ISA 与优化选项生成代码
}
// 若调用处传入常量,优化器可能直接折叠结果或内联

16.2 一个进程,多个线程

进程提供资源视图,线程提供各自的执行上下文
进程提供资源视图,线程提供各自的执行上下文同一进程:共享地址空间与许多资源共享:代码、全局数据、动态分配对象、打开的资源线程 A自己的寄存器上下文与栈线程 B自己的寄存器上下文与栈
“栈各自使用”不等于互相绝对不可访问;同一地址空间里的错误指针仍可能破坏其他线程数据。

上下文切换要保存、恢复执行状态。单核可以在多个线程间轮流运行形成并发;多核才可能在同一时刻并行执行多个线程。共享数据若缺少同步,可能出现数据竞争或可见性问题。

16.3 用户态到内核态:请求特权服务

系统调用:程序请求读取文件
系统调用:程序请求读取文件用户代码调用库的读取接口系统调用入口受控切换到内核内核检查与处理权限 / 文件 / I/O返回或阻塞结果可用后继续
库函数不一定每次都进入内核,缓冲可能先满足请求;进入内核态也不等于必定切换到另一个进程。
易错:线程共享内存,所以不需要同步
错误:多个线程无保护地读改写同一计数器 → 后果:更新可能丢失,某些语言下还会形成未定义行为 → 正确:识别共享状态,用适当的锁、原子操作或消息传递;并发不保证程序自动更快。
记忆锚点
编译讲翻译,链接找实现;文件是剧本,进程才开演。

16.4 随堂自测 · 先想再点

QUIZ 1
源码可以编译,但链接时报告某函数“未定义引用”,优先检查什么?
声明让编译器知道怎样调用,定义提供实现。链接器需要找到相应符号,编译通过不能保证链接成功。
QUIZ 2
同一进程的两个线程通常具有哪种关系?
线程通常共享进程资源,同时保留各自执行位置和必要状态。并发与并行取决于调度和可用核心。
CHAPTER 17 · 把原理用到整机

性能分析:用公式拆掉“越大越快”

一句话总览:性能必须围绕任务和指标衡量;指令数、平均 CPI、频率与系统等待共同决定完成时间。
⏱️
生活化类比 · 对应与边界
把性能看成送货:每件要几步对应 CPI,总件数对应指令数,步频对应时钟频率;等电梯与装货则像 I/O 与同步等待。路线、步数、步频一起决定时间;边界是 CPU 可流水并行,CPI 是平均量,现代处理器甚至可小于 1。

17.1 CPU 时间:别只盯着主频

同一任务:把三个因素写在一起
同一任务:把三个因素写在一起指令数 IC完成任务用了多少条平均 CPI平均每指令几个周期总周期数IC × CPICPU 时间IC × CPI ÷ 频率
公式中的 CPU 执行时间与包含 I/O、排队、休眠的墙钟时间不同;比较时要先统一统计口径。
教学示例代入结果
机器 A10⁹ 条 × 1.5 CPI ÷ 3×10⁹ Hz0.5 s CPU 时间
机器 B10⁹ 条 × 2 CPI ÷ 4×10⁹ Hz同样是 0.5 s,频率更高也未更快
IPC 与 CPI在同一统计区间、同一指令口径下互为倒数多发射处理器的 IPC 可大于 1
墙钟时间用户真正等待的开始到结束时间还包括 I/O、调度、同步等待等影响

17.2 阿姆达尔定律:快的部分救不了全部

假设原总时间里比例 p 的部分可以提升 N 倍,其余不变,忽略额外开销:总体加速比 S = 1 / [(1−p)+p/N]。若 80% 可提速到 4 倍,新时间比例为 20%+80%/4=40%,总体仅快 2.5 倍。

80% 部分加速四倍后,串行的 20% 仍完整存在
80% 部分加速四倍后,串行的 20% 仍完整存在原任务 100%20% 不变80% 可加速部分加速后 40%仍为 20%缩为 20%若 N 趋向无穷,总体加速仍不超过 1 / 20% = 5 倍。
此图以原总时间为共同尺度;真实并行还会增加同步、通信与资源竞争开销。
JavaScript · 估算提升上限
const p = 0.8, n = 4;
const speedup = 1 / ((1 - p) + p / n);
console.log(speedup); // 约 2.5
console.log(1 / (1 - p)); // 极限约 5

17.3 做公平比较:先问要优化哪种慢

观察可能受限于下一步应验证
CPU 持续忙,I/O 少计算、指令、分支或缓存行为热点与硬件计数器,不能仅凭 CPU 占用定因
长时间等读盘 / 网络I/O 延迟、吞吐或排队请求大小、并发、缓存、设备与链路
增加线程反而更慢同步竞争、内存带宽、调度等共享热点、锁等待、带宽与任务粒度
长时间运行后变慢温度 / 功耗预算等也可能影响持续负载、频率、温度及测试条件
易错:拿不同程序、输入或时间口径比主频
错误:仅看 GHz 或一次偶然用时宣布胜负 → 后果:被不同指令数、缓存冷热和后台任务误导 → 正确:固定任务、输入、环境与测量口径,进行合理重复,并说明波动和预热条件。
记忆锚点
时间看乘除,瓶颈看占比;先测最慢处,再谈加速器。

17.4 随堂自测 · 先想再点

QUIZ 1
10⁹ 条指令、平均 CPI=2、频率 2 GHz,CPU 时间约多少?
总周期为 2×10⁹,除以每秒 2×10⁹ 周期,得到 1 s。GHz 不是完成业务指令的直接速率。
QUIZ 2
某任务只有 50% 的时间能被无限加速,总体速度上限是多少倍?
另一半仍需原来 50% 的时间,因此极限加速为 1/0.5=2。局部优化必须按原耗时占比看整体收益。
CHAPTER 18 · 把原理用到整机

综合实战:按下一个键,直到保存成功

一句话总览:一次输入到保存横跨设备通知、系统调度、CPU 与存储层次、显示和持久化,每一步都受接口与时序约束。
🎼
生活化类比 · 对应与边界
把整机协作看成乐团:输入是提示,CPU、内存、设备各有声部,操作系统协调时机。协议相当于乐谱,缓冲区相当于待演奏片段;边界是计算机各部件并不总在同一节拍上,需要队列、握手、同步与错误处理。

18.1 输入到显示:别让每个键都绕一趟硬盘

场景:在一个桌面文本编辑器里输入 A。下面是一种简化路径,不绑定特定操作系统;键盘传输的是按键等事件信息,输入法和键盘布局也可能参与,不能把按键扫描信息直接等同于最终字符编码。

前半程:输入事件成为应用可处理的消息
前半程:输入事件成为应用可处理的消息键盘与控制器检测按键事件系统输入路径驱动 / 通知 / 队列应用线程获得事件并处理文本数据更新字符 / 编码 / 缓冲区
具体输入链路可能涉及设备轮询与控制器中断等多种机制;这里画逻辑关系,不声称每键必有一次专属中断。
后半程:算出要显示什么,再交给显示路径
后半程:算出要显示什么,再交给显示路径CPU 执行代码指令、寄存器、ALUCache / 内存读取文本与布局数据图形与合成路径CPU / GPU 协同渲染显示设备按刷新时序呈现
文本编辑通常先在内存中更新;刷新屏幕不等于保存文件,显示也不必每次都访问 SSD。

18.2 点击保存:完成在哪一层才算“完成”?

保存路径:多层缓冲让“写成功”有不同承诺
保存路径:多层缓冲让“写成功”有不同承诺应用缓冲区① 编码成约定字节可能先存在用户内存系统 / 文件缓存② 系统接收数据未必已掉电安全设备队列 / 缓存③ 提交存储请求处理完成与错误持久介质④ 按约定确认达到持久化语义应用应区分:接口接受、内核接收、设备完成、掉电后仍可恢复。
实际持久化保证取决于系统接口、文件系统、设备和调用顺序;“刷新界面”或普通 write 返回不自动等于掉电安全。
伪代码 · 把完成承诺写清楚
const bytes = encodeUtf8(text); // 文本 → 字节
writeFile(bytes);               // 返回含义取决于具体 API
syncAccordingToPlatform();      // 按平台与业务要求请求持久化
showSavedOnlyAfterSuccess();    // 检查失败,不假装已经完成
易错:界面出现“已保存”,就认为一定不会丢数据
错误:把进入应用缓冲区当成持久化完成 → 后果:崩溃或掉电后可能丢失尚未提交的数据 → 正确:定义保存承诺,按平台接口落实写入、同步与错误处理;文件替换等场景还需考虑元数据与原子性。

18.3 结课任务:用一张链路图讲明白整台机器

建议两人一组,用纸画出“输入一个字符并保存”的链路。每个框标出负责的部件,每条箭头标明传的是地址、数据、指令还是通知;再互相指出一个可能慢、一个可能出错的地方。

回忆关卡不用看答案,先讲给同学听回看章节
信息关0x41 为何可以是 65 或 A?0.1 为何会舍入?01–04
电路关加法进位怎么传?寄存器何时更新?05–06
执行关LOAD 和 STORE 修改什么?流水线为何会停?07–09
存储关Cache 查标签还是查页表?TLB miss 是缺页吗?10–13
系统关中断与 DMA 谁搬数据?程序与进程有何区别?14–16
性能关为何四倍加速一个模块,整机未必快四倍?17
拓展练习动手方式参考检查点
完整跑通 CPU 实验记录 4 条指令的阶段与状态HALT 后 R0=7、M[11]=7、PC=3;本模型停在 HALT
预测 Cache 访问重置后按顺序访问 0、1、16、0未命中、命中、未命中、未命中
解释编码与排列把 0x12345678 写成小端字节序78 56 34 12;不要把十六进制字面量当成 ASCII 文本
估算真实收益60% 耗时部分快 3 倍,余下不变总体 1/(0.4+0.6/3)≈1.67 倍,忽略新增开销
课程约定与适用边界
本课程沿着“信息 → 电路 → CPU → 存储 → 整机”的主线组织。教学 ISA、阶段数、Cache 容量和页大小均已标明;不代表所有处理器或操作系统。拓展学习可依次深入数字逻辑、计算机组成与体系结构、操作系统,并以目标平台的体系结构手册核对细节。
带走一条主线
比特定表示,电路做运算;指令串状态,层次藏等待;协议连整机,测量找瓶颈。

18.4 随堂自测 · 先想再点

QUIZ 1
编辑器把 A 显示出来,能否推出文件已持久化?
显示可能只使用进程内存和图形路径;保存还需要编码、文件接口和存储完成。两种结果应分别确认。
QUIZ 2
完整链路中,哪组对应最合理?
CPU、MMU、DMA 的职责各自明确。TLB 缓翻译、Cache 缓数据或指令,普通寄存器也不是持久存储。
渝ICP备2026024724号-1