计算机全景:一条指令的旅行
把电脑想成厨房:程序是菜谱、CPU 是厨师、内存是操作台、SSD 是储物间、外设是点餐与上菜窗口。菜谱也要放上操作台才能方便读取;边界是 CPU 没有理解力,只能执行约定的指令,真实机器还会并行、缓存与预测。
1.1 先认清五个角色
运算器负责算术与逻辑;控制器决定下一步动作,两者与寄存器等共同构成 CPU。输入、输出和存储连接成整机。内存容量决定能同时铺开多少工作,CPU 决定怎样处理这些工作。
| 角色 | 做什么 | 看得见的例子 |
|---|---|---|
| CPU | 执行指令、操纵数据 | 计算两个数、判断条件 |
| 内存 | 暂放正在使用的代码和数据 | 打开的程序、活动数组 |
| SSD / 磁盘 | 长期保存文件 | 照片、可执行文件 |
| 输入 / 输出 | 连接外部世界 | 键盘、屏幕、网卡 |
1.2 存储程序:指令也是数据的一种解释
同样一串 0 和 1,被取指单元按指令格式解释,可能表示“相加”;被图像程序解释,可能表示像素颜色。比特本身没有“这是照片”的标签,意义来自格式与上下文。现代机器通常有分别存放指令与数据的一级 Cache,但仍属于存储程序思想。
1.3 用一次加法串起后面的课程
const a = 3;
const b = 4;
const sum = a + b;
console.log(sum); // 7;这是源代码,CPU 实际执行机器指令1.4 随堂自测 · 先想再点
二进制与单位:数格子的方法
想象一排八盏灯:亮是 1,灭是 0,每盏灯的“分值”从右向左翻倍。位模式对应灯的状态,位权对应分值;边界是电路中的 0/1 实际对应电压范围,并非必须真的发光。
2.1 位置比符号更重要
十进制 305 = 3×100 + 0×10 + 5;二进制同理,只把底数换成 2。8 位无符号整数共有 2⁸ = 256 种组合,范围为 0–255。
2.2 十六进制是二进制的速记法
四个二进制位恰好对应一个十六进制数字:0–9、A–F。分组从右往左,每四位一组;0x 是常用十六进制前缀,0b 是常用二进制前缀。
const n = 0b00101101;
console.log(n); // 45
console.log(n.toString(16)); // "2d"
console.log(0x2D === 45); // true2.3 容量、带宽和地址数量
| 写法 | 含义 | 换算或例题 |
|---|---|---|
| 1 B / 1 byte | 1 字节,现代通用计算机中是 8 bit | 1 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;不等于已安装内存 |
2.4 随堂自测 · 先想再点
整数与补码:绕一圈的算术
把 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。
3.2 求负数、做加法、扩展位宽
| 机制 | 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:这次无符号发生回绕。
const raw = (127 + 1) & 255; // 只保留低 8 位:128
const signed = raw < 128 ? raw : raw - 256;
console.log(raw, signed); // 128, -1283.4 随堂自测 · 先想再点
小数、文字与像素:编码的约定
把浮点数想成科学计数法的标签:符号决定方向,指数决定量级,有效数字决定细节;把字符编码想成字典编号再装进信封。码点是编号,UTF-8 是装箱规则;边界是一个视觉字符可能由多个码点组合,字典编号并不等于屏幕字形。
4.1 浮点数:范围大,不代表处处精确
二进制小数的位权是 1/2、1/4、1/8……0.5 = 0.1₂ 可以精确表示;0.1₁₀ 的二进制展开会无限循环,因此必须舍入。IEEE 754 的 binary32 常见布局为 1 位符号、8 位指数、23 位小数部分。
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 文字:码点、字节、字形是三个层次
| 观察对象 | 例子 | 别混淆 |
|---|---|---|
| ASCII | A → 0x41 | ASCII 范围的字符在 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。透明度通道、行填充、文件头或压缩都会改变实际文件大小。
4.4 随堂自测 · 先想再点
逻辑门与加法器:计算从开关长出
把逻辑门想成通行规则:AND 像“两张证都要有”,OR 像“任一证即可”,XOR 像“恰好一张”。证件是否存在对应输入 0/1,是否放行对应输出;边界是实际电路有传播延迟、功耗与电压容限,并非瞬间判定的抽象开关。
5.1 四条规则就能读懂很多电路
| A | B | A AND B | A OR B | A XOR B |
|---|---|---|---|---|
| 0 | 0 | 0 | 0 | 0 |
| 0 | 1 | 0 | 1 | 1 |
| 1 | 0 | 0 | 1 | 1 |
| 1 | 1 | 1 | 1 | 0 |
NOT 只有一个输入:NOT 0 = 1,NOT 1 = 0。位运算操作每一位;逻辑运算先把整个值当作真假。二者用途不同。
5.2 多位加法器:进位会走路
5.3 选择器与 ALU:先算规则,再选结果
多路选择器 MUX 用控制信号从多个输入中挑一个。ALU 可并行产生或组织不同运算,再按控制码选择加、与、或等结果。CPU 的“决定做哪种运算”最终也要落到控制信号上。
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, 15.4 随堂自测 · 先想再点
时钟与寄存器:电路怎样记住昨天
把时钟沿想成统一拍照口令:寄存器在约定沿给输入“拍快照”,两个沿之间组合逻辑准备下一张。快照对应保存的状态,口令间隔对应周期;边界是输入必须在拍照前后保持稳定,物理电路不是随意按下就永远拍清楚。
6.1 没有记忆的规则,怎么执行一连串步骤?
组合电路输出依赖当前输入;时序电路还依赖已有状态。寄存器可由一组触发器组成,保存若干位。以下教学模型采用上升沿触发:在两个有效沿之间,Q 保持旧值,D 可以经过运算逐渐稳定。
6.2 频率不是越高越稳
| 时间概念 | 含义 | 直观结果 |
|---|---|---|
| 时钟周期 T | 相邻有效沿之间的间隔 | f = 1/T;1 GHz 对应 1 ns 周期 |
| 建立时间 setup | 采样前,输入需要稳定一段时间 | 组合路径不能晚于这条截止线 |
| 保持时间 hold | 采样后,输入仍需稳定一段时间 | 过早变化也可能导致采样问题 |
| 关键路径 | 决定最慢完成时间的路径 | 简化约束:T ≥ clk-to-Q + 组合延迟 + setup;还需考虑时钟偏差等 |
6.3 状态机:红绿灯也是“下一状态函数”
let state = "RED";
function tick() {
const next = { RED: "GREEN", GREEN: "YELLOW", YELLOW: "RED" };
state = next[state]; // 模拟一个有效时钟沿更新状态
return state;
}
console.log(tick()); // GREEN6.4 随堂自测 · 先想再点
指令集:软件与硬件的接口
把 ISA 想成餐厅的菜单与点单格式,微架构是后厨的分工与设备。同一道菜可以由不同厨房完成。指令语义对应菜品承诺,实现对应工作流程;边界是现实菜品很难严格一致,而兼容 CPU 必须满足 ISA 规定的可观察行为。
7.1 源代码、汇编、机器码分别给谁看?
7.2 三类操作数:立即数、寄存器、内存
| 写法(伪汇编) | 意思 | 发生什么 |
|---|---|---|
| ADD R0, R1, R2 | R0 ← R1 + R2 | 读两个寄存器,写一个寄存器 |
| ADD R0, #4 | R0 ← R0 + 4 | 4 是指令里的立即数 |
| 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 // 把结果写到地址 1047.4 随堂自测 · 先想再点
CPU 执行:取指、译码与状态更新
把 CPU 想成按工单操作的工位:PC 是下一张工单的位置,IR 是当前拿在手中的工单,译码是查操作规则,执行是动手。工单位置不等于工单内容;边界是现代 CPU 会让多张工单重叠甚至乱序处理,这里先用顺序模型看清因果。
8.1 先把数据通路里的角色放对
8.2 用一条 LOAD 看清四个教学阶段
| 阶段 | 读什么 / 做什么 | 本例重点 |
|---|---|---|
| 取指 FETCH | 用 PC 找到指令,放入 IR | 拿到 LOAD R0,[10] |
| 译码 DECODE | 识别操作与操作数,准备控制 | 知道这是读内存,不是做立即数赋值 |
| 执行 EXECUTE | 计算地址并读取数据,或完成 ALU 运算 | 读到 M[10]=3,暂存结果 |
| 更新 COMMIT | 按指令语义写寄存器或内存,推进 PC | R0=3,PC 指向下一条 |
这四阶段是为了教学分解,不是实际处理器的固定流水级数,也不表示每阶段必为一个真实时钟周期。PC 在真实 ISA 中常以字节地址表示;下面实验为便于观察,PC 使用指令序号。
8.3 亲自执行:把 3 加 4 再存回
LOAD R0, [10] // PC=0:读出 3
ADD R0, #4 // PC=1:算得 7
STORE [11], R0 // PC=2:将 7 写回 M[11]
HALT // PC=3:教学机停止8.4 随堂自测 · 先想再点
流水线与并行:提高产量的代价
把流水线想成洗衣、烘干、折叠三个工位:第一篮在烘干时,第二篮可以洗。工位对应流水级,篮子对应指令;边界是指令之间会依赖结果,洗衣篮之间通常没有“后一篮必须吃前一篮产物”的约束。
9.1 先分清“多久完成一条”和“多久产出一条”
| 指标 | 关注的问题 | 在理想五级示例中 |
|---|---|---|
| 延迟 latency | 一条指令从进入到完成多久 | 5 拍,未计流水寄存器额外开销 |
| 吞吐 throughput | 单位时间能完成多少条 | 填满后最多每拍完成一条 |
| 填充 / 排空 | 开头和结尾有哪些空档 | 短程序难以达到长期峰值 |
| 实际性能 | 还受什么影响 | 阶段不均衡、额外寄存器开销、各种停顿 |
9.2 三类冒险:不是所有气泡都同一个原因
| 冒险 | 触发条件 | 常见处理 |
|---|---|---|
| 结构冒险 | 同一时刻争同一资源 | 分离资源、增加端口或停顿 |
| 数据冒险 | 后续指令依赖未可用的结果 | 转发、调度、停顿;具体依流水线设计 |
| 控制冒险 | 还不知道分支之后执行哪条 | 预测与推测执行,预测错后清除相关工作 |
9.3 乱序、多发射、多核各解决什么?
| 机制 | 增加哪种重叠 | 边界 |
|---|---|---|
| 多发射 | 一拍发出多条合适的指令 | 需要足够执行资源与独立工作 |
| 乱序执行 | 暂时绕过等待,先做独立指令 | 仍须维护 ISA 规定的可观察行为 |
| 多核 | 多个核心处理多个执行流 | 共享数据、同步和串行部分限制加速 |
LOAD R1, [R2] // 可能等待内存
ADD R3, R1, R4 // 依赖 R1,不能直接使用旧值
ADD R5, R6, R7 // 若无其他约束,可作为独立工作调度9.4 随堂自测 · 先想再点
存储层次与局部性:快的为什么小
把存储层次想成读书:手边摊开的几页是寄存器,桌面常用书是 Cache,书架是内存,仓库是 SSD。越常用越靠近手;边界是机器按固定大小的块和替换规则搬运,程序不能像人一样随意凭印象拿书。
10.1 又快、又大、又便宜:通常难同时满足
| 介质 | 保存方式(概念) | 使用场景 |
|---|---|---|
| SRAM | 通过稳定电路状态保存,供电时无需 DRAM 式周期刷新 | 常用于 Cache,较快但每位成本与面积高 |
| DRAM | 用电容等结构保存信息,需要刷新 | 常用于主存,密度较高 |
| 闪存 SSD | 非易失存储,按设备规则读写与擦除 | 保存文件;写入、擦除粒度和寿命管理由设备处理 |
10.2 局部性:为什么相邻、重复访问更友好?
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 × 80 | 5 ns |
| 1% 未命中 | 1 + 0.01 × 80 | 1.8 ns |
| 代价定义不同 | 若给的是未命中总耗时,要用加权平均 | 不要把命中查找时间重复相加 |
10.4 随堂自测 · 先想再点
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,不含标签与有效位开销。
11.2 用冲突实验看清“刚读过也会丢”
依次访问 0、1、16、0。0 和 1 属于同一个 4 B 块,第二次会命中;16 与 0 映射到同一行,随后把 0 对应的块换掉。实验只模拟读访问、冷启动、直接映射、4 行×4 B。
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; // 011.3 映射、替换、写策略分三件事记
| 问题 | 常见规则 | 关键区别 |
|---|---|---|
| 能放哪? | 直接映射 / 组相联 / 全相联 | 直接映射只有一行候选,组相联在一组内有多个候选 |
| 满了换谁? | LRU 及近似策略、随机等 | 替换策略在多个候选之间选择;不改变映射规则 |
| 写到哪里? | 写直达 / 写回 | 写直达也更新下一层;写回先修改 Cache 并标脏,替换等时机再写回 |
| 写未命中怎么办? | 写分配 / 不写分配 | 决定是否把块装进来,与写直达/写回是不同维度 |
11.4 随堂自测 · 先想再点
内存布局与字节序:地址里的风景
把内存看成有连续门牌号的公寓:地址是门牌,变量值是住户物品,数组是连续租下的一排房间。地址与内容不同,类型说明怎样读连排房间;边界是进程看到的通常是虚拟地址,而且对象布局受 ABI、语言与对齐规则影响。
12.1 数组位置:基址 + 下标 × 元素大小
若基址为 100、每个元素 4 B,则 a[3] 的起始地址是 100+3×4=112。指针的位宽描述地址表示能力,不等于所指对象的大小;32 位数据也可以由 64 位地址来定位。
12.2 小端、大端:拆开后,哪一头先放?
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 随堂自测 · 先想再点
虚拟内存:地址翻译与保护
把虚拟地址想成酒店客人的房号,物理地址是后台真实房间编号;前台映射表决定“客人眼中的 101”实际在哪。页表对应映射,权限对应房卡能否开门,TLB 对应前台常查记录;边界是映射以页为单位,且硬件参与翻译,操作系统处理建立与异常。
13.1 地址拆成页号和页内偏移
若页面为 4 KiB,则页内偏移占 12 位。虚拟页号用于查页表;页内偏移不变,与查到的物理页框号重新组合。进程的虚拟连续区域可以映射到不连续的物理页框。
13.2 TLB 未命中和缺页不是一件事
| 事件 | 是什么没找到 / 不满足 | 可能如何处理 |
|---|---|---|
| TLB miss | TLB 里没有目标翻译 | 查询页表并填回 TLB,页面可能已在 RAM |
| 页不在内存 | 页表条目表明当前不能直接访问 | 触发缺页异常,由系统装入、分配或采取其他处理 |
| 权限违规 | 访问方式不被该映射允许 | 系统可能终止进程,或按写时复制等机制合法修复 |
| 非法地址 | 无合法映射或不满足访问条件 | 异常不一定能恢复;不能承诺“都会从 SSD 找到” |
13.3 它还解决隔离,不只是“借硬盘当内存”
页表权限可以让代码页只读、限制用户态访问内核区域,并使不同进程保持独立视图。按需分配、共享映射、写时复制也建立在这个抽象上。换出到持久存储是某些系统的策略,不能用它定义全部虚拟内存。
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"13.4 随堂自测 · 先想再点
总线与输入输出:让设备说同一种话
把互连想成道路,设备控制器是收发站,协议是交通规则。数据路径对应道路,仲裁对应通行权,握手对应确认;边界是现代互连可能是交换式、串行、点到点的,并非所有设备挤在一条共享平行公路上。
14.1 CPU 不直接理解键盘或 SSD 的物理细节
| 接口角色 | 典型含义 | 为什么需要 |
|---|---|---|
| 控制寄存器 | 启动、停止、设置模式 | 告诉设备要做什么 |
| 状态寄存器 | 就绪、忙、完成、错误 | 让软件知道是否能继续 |
| 数据寄存器 / 队列 | 提交或获取数据与描述符 | 承载实际工作内容 |
| MMIO | 把设备寄存器映射到地址空间 | 通过受约束的访存访问设备;并非普通 RAM |
14.2 请求、等待、响应:设备有自己的节奏
14.3 轮询与带宽:计算时先写假设
轮询就是反复读状态,直到就绪。对极短等待或专用场景可能合适,长时间忙等则占用 CPU。若教学总线每次传 32 bit、每秒传 100,000,000 次,理想带宽为 32÷8×100,000,000 = 400 MB/s;仲裁、握手等开销会降低有效载荷速率。
while ((readStatus() & 1) === 0) {
// 忙等:CPU 不断检查;真实系统需要超时与错误处理
}
const data = readData(); // 看到就绪后,才按协议读取| 概念 | 问题 | 例子 |
|---|---|---|
| 延迟 | 发出一个请求后等多久? | 小文件首个数据何时到 |
| 带宽 | 稳定传输每秒多少数据? | 大文件连续搬运速率 |
| 有效载荷速率 | 真正业务数据有多少? | 扣除协议、空闲、重复传输等开销 |
| MMIO 访问规则 | 能否缓存、重排、合并? | 应使用系统 / 驱动提供的接口与必要屏障 |
14.4 随堂自测 · 先想再点
中断与 DMA:谁搬数据,谁喊完成
把中断想成取餐铃,DMA 想成搬运车:铃提醒你,车运货,工作人员先填搬运单。铃对应通知,车对应 DMA,单据对应描述符;边界是 CPU 还要设置缓冲区、处理权限与同步,DMA 不是不受监管的自动小车。
15.1 中断:先保存现场,再去处理事件
| 机制 | 触发来源 | 典型例子 |
|---|---|---|
| 外部中断 | 相对当前程序异步的外部事件 | 设备完成、定时器到期 |
| 同步异常 | 与正在执行的指令相关 | 缺页、非法操作;分类和恢复规则依架构 |
| 处理程序 | 按向量 / 入口进入的受控代码 | 快速处理必要工作,较长任务可延后执行 |
15.2 DMA:CPU 配置,硬件搬运
const buffer = allocateDmaBuffer(4096); // 按系统规则分配 / 映射
submitDma(buffer, 4096); // CPU 配置并启动
doOtherWork(); // 可与搬运重叠
waitForCompletion(); // 完成通知与必要同步
consume(buffer); // 确认完成后再使用数据15.3 DMA 还需要缓冲区生命期与一致性
| 方式 | CPU 主要做什么 | 适用取舍 |
|---|---|---|
| 程序查询 / 轮询 | 反复检查状态,可能自己搬数据 | 简单;等待过长会占用处理能力 |
| 中断驱动 I/O | 收到事件后处理必要工作 | 减少长期忙等;高频中断也有开销 |
| DMA + 完成机制 | 准备队列、映射、处理同步与完成 | 适合批量数据;仍争用内存与互连带宽 |
| 缓冲区同步 | 确保双方看见正确版本,完成前不释放 | 是否需显式缓存维护依平台一致性与 API 约定 |
15.4 随堂自测 · 先想再点
从源码到进程:编译器与操作系统
把程序文件想成剧本,进程是一场正在演的戏,线程是推进表演的演员;操作系统安排舞台与资源。文件对应静态描述,进程对应运行实例,线程对应执行流;边界是同一进程的线程共享很多资源,不能像完全独立的剧组那样随意忽视同步。
16.1 编译、汇编、链接、装载分别解决什么?
| 环节 | 典型错误 | 定位思路 |
|---|---|---|
| 编译 | 语法、类型等检查未通过 | 看源代码与编译诊断 |
| 链接 | 找不到函数实现、符号重复 | 检查目标文件、库与声明定义 |
| 装载 / 运行 | 依赖不可用、权限或执行期故障 | 检查运行环境、映射与具体异常 |
int add(int a, int b) {
return a + b; // 编译器按目标 ISA 与优化选项生成代码
}
// 若调用处传入常量,优化器可能直接折叠结果或内联16.2 一个进程,多个线程
上下文切换要保存、恢复执行状态。单核可以在多个线程间轮流运行形成并发;多核才可能在同一时刻并行执行多个线程。共享数据若缺少同步,可能出现数据竞争或可见性问题。
16.3 用户态到内核态:请求特权服务
16.4 随堂自测 · 先想再点
性能分析:用公式拆掉“越大越快”
把性能看成送货:每件要几步对应 CPI,总件数对应指令数,步频对应时钟频率;等电梯与装货则像 I/O 与同步等待。路线、步数、步频一起决定时间;边界是 CPU 可流水并行,CPI 是平均量,现代处理器甚至可小于 1。
17.1 CPU 时间:别只盯着主频
| 教学示例 | 代入 | 结果 |
|---|---|---|
| 机器 A | 10⁹ 条 × 1.5 CPI ÷ 3×10⁹ Hz | 0.5 s CPU 时间 |
| 机器 B | 10⁹ 条 × 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 倍。
const p = 0.8, n = 4;
const speedup = 1 / ((1 - p) + p / n);
console.log(speedup); // 约 2.5
console.log(1 / (1 - p)); // 极限约 517.3 做公平比较:先问要优化哪种慢
| 观察 | 可能受限于 | 下一步应验证 |
|---|---|---|
| CPU 持续忙,I/O 少 | 计算、指令、分支或缓存行为 | 热点与硬件计数器,不能仅凭 CPU 占用定因 |
| 长时间等读盘 / 网络 | I/O 延迟、吞吐或排队 | 请求大小、并发、缓存、设备与链路 |
| 增加线程反而更慢 | 同步竞争、内存带宽、调度等 | 共享热点、锁等待、带宽与任务粒度 |
| 长时间运行后变慢 | 温度 / 功耗预算等也可能影响 | 持续负载、频率、温度及测试条件 |
17.4 随堂自测 · 先想再点
综合实战:按下一个键,直到保存成功
把整机协作看成乐团:输入是提示,CPU、内存、设备各有声部,操作系统协调时机。协议相当于乐谱,缓冲区相当于待演奏片段;边界是计算机各部件并不总在同一节拍上,需要队列、握手、同步与错误处理。
18.1 输入到显示:别让每个键都绕一趟硬盘
场景:在一个桌面文本编辑器里输入 A。下面是一种简化路径,不绑定特定操作系统;键盘传输的是按键等事件信息,输入法和键盘布局也可能参与,不能把按键扫描信息直接等同于最终字符编码。
18.2 点击保存:完成在哪一层才算“完成”?
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 倍,忽略新增开销 |