内存扩充技术全解析：覆盖、交换、虚拟内存对比与缺页中断完整流程

内存扩充技术全解析：覆盖、交换、虚拟内存对比与缺页中断完整流程

本文从一道让我当年栽了跟头的 408 真题讲起，把覆盖、交换、虚拟内存三种技术的底层逻辑、地址变换流程、缺页中断处理全部拆开讲透。不是背定义，而是把"为什么这样设计"的因果链讲清楚。文末附四套考场答题模板和完整计算例题。

目录

一、从一道真题说起

2019 年 408 统考有一道选择题，大意是问"以下关于缺页中断的叙述哪个正确"。四个选项分别涉及中断类型、产生次数、恢复方式。我的朋友当年做这道题的时候，在 A 和 D 之间犹豫了将近两分钟——因为脑子里一直有个模糊的印象：“缺页中断涉及磁盘 I/O，那它算不算外中断？”

最后蒙对了。但那种"似懂非懂"的感觉让我的朋友很不舒服。

后来我的朋友把整个请求分页的地址变换流程从头到尾推了三遍，又翻了 Linux 内核do_page_fault的源码，才真正把这块吃透。这篇文章就是那次"推三遍"的产物。

二、根本矛盾：程序比内存大

所有内存扩充技术的出发点都是同一个矛盾：程序需要的地址空间 > 物理内存容量。

解决思路也很朴素：装不下全部，就只装一部分，剩下的放磁盘，用的时候再拿。

三种技术的区别在于三个问题：切多细？谁来管？什么时候拿？

三代演进，一代比一代自动化，一代比一代粒度细。

三、覆盖：程序员的手动挡

3.1 怎么工作的

把程序按功能拆成模块，常用的常驻内存，不常用的需要时调入，用完覆盖掉。

拿一个编译器举例：

// 伪代码：覆盖结构的编译器// 主程序常驻内存（50KB）intmain(){// 覆盖区（70KB），依次装入不同模块overlay_load("lexer");// 词法分析 40KBdo_lexical_analysis();overlay_load("parser");// 语法分析 60KB，覆盖掉 lexerdo_syntax_analysis();overlay_load("semantic");// 语义分析 50KB，覆盖掉 parserdo_semantic_analysis();overlay_load("codegen");// 代码生成 70KB，覆盖掉 semanticdo_code_generation();}

全部装入需要 270KB，覆盖后只需 50 + max(40,60,50,70) = 120KB。

3.2 覆盖树

调用关系复杂时用覆盖树描述。核心规则：兄弟节点互斥（共享覆盖区），父子节点可共存。

A（常驻，20KB） / \ B D (30KB) (40KB) | | C E (50KB) (25KB)

所需内存 = 20 + max(30,50) + max(40,25) = 110KB。

3.3 为什么被淘汰

三个字：太累了。程序员得手动分析调用图、手动写 overlay 调用、程序一改就得重新设计。1960 年代 IBM OS/360 和 PDP-11 的 RT-11 广泛使用这套机制，链接器甚至有专门的覆盖段语法。到了 1980 年代虚拟内存普及，覆盖就退出了主流——因为同样的事情 OS 和硬件能自动做，而且做得更好。

四、交换：OS 的半自动挡

4.1 怎么工作的

内存紧张时，把暂时不跑的进程整体换出到磁盘交换区，腾出空间给别的进程。

时刻 T1：内存满 ┌────────┬────────┬────────┐ │ 进程 A │ 进程 B │ 进程 C │ └────────┴────────┴────────┘ 时刻 T2：B 阻塞，换出；D 换入 ┌────────┬────────┬────────┐ │ 进程 A │ 进程 D │ 进程 C │ └────────┴────────┴────────┘ ↕ 磁盘交换区：进程 B

4.2 几个容易忽略的点

交换区不是普通文件。它是磁盘上专门划分的连续区域，以原始块设备方式读写，绕过了文件系统的元数据开销。Linux 里可以是独立的 swap 分区，也可以是文件系统上的 swap 文件（swapon命令挂载）。前者 I/O 效率略高，后者灵活（可以动态fallocate扩容）。

触发者是中级调度。不是高级调度（作业调度），也不是低级调度（CPU 调度），是介于两者之间的中级调度（Medium-Term Scheduling）。进程被换出后状态变为挂起态（Suspend），PCB 仍留在内存。

换出时要保存完整上下文。寄存器、PC、栈指针，全部存到 PCB。换入时原样恢复，进程从断点继续跑。

4.3 根本局限

交换没有扩充内存。它只是在进程之间倒腾空间，每个进程仍然必须完整装入内存才能运行。一个 200MB 的进程，如果物理内存只有 128MB，交换也救不了你。

而且粒度太粗——换出一个进程要搬运整个地址空间，几十 MB 的磁盘 I/O，毫秒到秒级开销。CPU 一次访存才 100ns，差了好几个数量级。

五、虚拟内存：全自动挡

5.1 理论根基：局部性原理

程序在任意时刻真正活跃的数据只是很小一部分。这个观察被 Denning（1968）形式化为工作集模型：进程在时间窗口 Δ 内访问的页面集合 W(t, Δ)。只要工作集装得下，进程就能高效运行；装不下就频繁缺页，系统陷入抖动（Thrashing）。

我在实验室里亲眼见过抖动：一台 4GB 内存的机器跑了太多虚拟机，vmstat 1看到 si/so（swap in/out）持续几百 KB/s，CPU 的wa（iowait）飙到 90% 以上，整个系统基本卡死。杀掉几个进程后立刻恢复。这就是工作集装不下的典型表现。

5.2 三大特征

• 多次性：作业分多次调入，不必一次性全装
• 对换性：运行中页面可以换入换出
• 虚拟性：逻辑地址空间远大于物理内存（32 位系统：4GB 虚拟空间 vs 可能只有 512MB 物理内存）

5.3 请求分页的页表

比基本分页多了几个关键字段：

这里有个容易混的点：保护位违反和缺页是两回事。页面在内存（P=1）但你写了一个只读页，触发的是保护异常（Linux 里表现为 SIGSEGV），不是缺页中断。只有 P=0 才是缺页。

另外一个细节：P=0 不一定意味着页面在磁盘上。可能是malloc后还没首次访问（demand zeroing，页面根本还没分配），可能是文件映射页还没读入，也可能是正在被别的进程调入（共享页场景）。OS 的缺页处理程序会区分这些情况。

5.4 外存怎么组织的

Linux 里进程的页面分两种来源：

• 文件映射页（File-backed）：代码段.text、只读数据.rodata，直接映射到可执行文件。淘汰时直接丢弃，需要时从文件重读，不用写回。
• 匿名页（Anonymous）：堆、栈、mmap(MAP_ANONYMOUS)分配的内存。没有对应文件，脏页淘汰时必须写回 swap 分区。

这就是为什么 Linux 即使内存够用也建议配 swap——不是为了"扩充内存"，而是为了有地方放匿名脏页。你可以用cat /proc/meminfo | grep Swap看当前 swap 使用情况。

六、三者对比（一张表搞定）

考场速记：覆盖管"段"（程序员手动），交换管"进程"（OS 自动），虚拟内存管"页"（OS+硬件自动）。

七、地址变换：带快表的请求分页

7.1 硬件基础

三个关键角色：

• PTBR（页表基址寄存器）：存当前进程页表的物理起始地址。进程切换时由 OS 设置。
• PTLR（页表长度寄存器）：存页表项个数，用于越界检查。
• TLB（快表）：CPU 内部的高速缓存，存最近用过的页表项。命中率通常 95%~99%。

TLB 的存在是为了解决一个性能问题：没有 TLB 时每次访存都要先查内存中的页表（1 次访存），再取数据（又 1 次），两次访存太慢。有了 TLB，大部分情况直接命中，省掉查页表那次。

进程切换时 TLB 怎么处理？早期是全刷新（代价大），现代 CPU 给每个 TLB 条目加一个进程标识符（x86 叫 PCID，ARM 叫 ASID），切换时不用刷，匹配标识符就行。

7.2 地址结构

逻辑地址：[ 页号 P（高位） | 页内偏移 W（低位）] 物理地址：[ 块号 f（高位） | 页内偏移 W（低位，不变）] 物理地址 = f × 页面大小 + W

页面大小 4KB = 2¹²，所以偏移占低 12 位。32 位地址空间里页号占高 20 位（最多 1M 页）。

7.3 完整流程

我画了一张流程图，建议对着这个图把流程走三遍，走到能默写出来为止：

CPU 发出逻辑地址 │ ▼ 提取页号 P、偏移 W（MMU 硬件） │ ▼ P ≥ PTLR ？──── 是 ──→ 越界中断，终止 │ 否 ▼ 查 TLB ──── 命中 ──→ 获得块号 f ──────────────────┐ │ │ 未命中 │ ▼ │ 查内存页表（PTBR + P×项大小） │ │ │ ▼ │ 有效位 = 1 ？ │ │ │ │ 是 否 │ ▼ ▼ │ 获得 f 缺页中断 │ 更新TLB （见第八节） │ │ 处理完重新执行 ──→ 回到"查 TLB" │ │ │ └────────────────────────────────────────────────┘ │ ▼ 硬件更新：访问位=1 若写操作：修改位=1 │ ▼ 物理地址 = f × 页大小 + W CPU 访问物理内存

7.4 内存访问次数（高频考点）

这里有个坑：很多人以为 TLB 命中就是 0 次访存。不是。TLB 只是省了"查页表"那次，取数据仍然要访问内存。除非数据恰好在 L1/L2 Cache 里，但那是 Cache 的事，跟 TLB 无关。

补充一点：现代系统用多级页表（x86-64 是 4 级：PGD→PUD→PMD→PTE）。没有 TLB 的话理论上要 4 次访存查页表 + 1 次取数据 = 5 次。所以 TLB 在多级页表系统里更加不可或缺——命中时仍然只要 1 次，跟页表几级没关系。

7.5 EAT 公式（408 必考计算）

设ma= 访存时间（如 100ns），ε= TLB 命中率，p= 缺页率，t_PF= 缺页处理时间（含磁盘 I/O，约 8ms）。

E A T = ε ⋅ m a + ( 1 − ε ) ⋅ [ ( 1 − p ) ⋅ 2 m a + p ⋅ t P F ] EAT = \varepsilon \cdot ma + (1-\varepsilon) \cdot [(1-p) \cdot 2ma + p \cdot t_{PF}]EAT=ε⋅ma+(1−ε)⋅[(1−p)⋅2ma+p⋅tPF​]

这个公式的前提：TLB 命中就一定不缺页。为什么？因为页面被换出时 OS 会 invalidate 对应 TLB 条目，所以 TLB 里存在的条目一定对应 P=1 的页表项。

分支逻辑：

• 概率 ε：TLB 命中，1 次访存，耗时 ma
• 概率 (1-ε)：TLB 未命中，先查页表（1 次 ma），然后：
  • 概率 (1-p)：页在内存，再取数据（1 次 ma），共 2ma
  • 概率 p：缺页，耗时 t_PF

缺页率对性能的影响有多夸张？看这个表（ε=0.98, ma=100ns, t_PF=8ms）：

每增加一个数量级，性能恶化约一个数量级。这就是为什么工作集必须装得下——装不下就抖动，CPU 利用率趋近于零。

八、缺页中断：完整处理流程

8.1 性质（选择题最爱考）

先说结论，再解释为什么：

缺页中断是内中断（同步异常，Fault 类），不是外中断。

为什么？因为它是 MMU 在指令执行期间检测到有效位=0 时触发的，是 CPU 内部事件。虽然后续处理会涉及磁盘 I/O（那是外中断），但缺页中断本身的触发机制是内部的。

打个比方：你打开冰箱发现没菜了（内中断：你自己发现的），然后打电话叫外卖（后续处理），外卖路上堵车（外部事件）。但"发现没菜"这个触发点是你内部的，不是外面有人敲门告诉你没菜了。

其他性质：

• 一条指令可产生多次缺页（x86 的REP MOVSB每次迭代都可能缺页；跨页指令的源和目的在不同缺页页面）
• 处理完后重新执行原指令，不是执行下一条（因为指令还没完成，架构状态没更新）
• 进程从运行态→阻塞态（等磁盘 I/O），CPU 去跑别的进程

8.2 处理流程

以 Linux x86-64 为例，从硬件触发到恢复执行的完整路径：

硬件触发： MMU 检测 P=0 → 缺页地址写入 CR2 寄存器 → PC 压入内核栈 → CPU 切换到 Ring 0，跳转到 IDT 中 page fault 入口 OS 处理（do_page_fault → handle_mm_fault）： ① 保存 CPU 现场（通用寄存器） ② 从 CR2 读取缺页地址，确定页号 合法性检查： 地址不在进程 VMA 范围内 → 发 SIGSEGV，进程可能被杀 权限不符（写只读页）→ 保护异常处理（COW 等） 合法缺页 → 继续 ③ 有空闲页框？ 有 → 直接用 无 → 置换算法选淘汰页 修改位=1（脏页）→ 写回磁盘（一次写 I/O） 修改位=0（干净）→ 直接丢弃（省一次 I/O） ④ 进程 → 阻塞态，发起 DMA 读盘 CPU 转去调度其他进程 ⑤ 磁盘 I/O 完成 → 硬件中断 → 进程 → 就绪态 ⑥ 更新页表：P=1，填入块号，D=0 ⑦ 恢复现场，重新执行原指令 → 查 TLB（未命中）→ 查页表（P=1）→ 硬件填充 TLB → 访问内存

8.3 几个值得深挖的点

为什么脏页要写回，干净页不用？

干净页的磁盘副本还是最新的（没被改过），直接丢弃就行，需要时从原处重读。脏页的磁盘副本已经过时了，不写回数据就永久丢失。一次磁盘写 I/O 大约 8~10ms，能省就省。这也是为什么 CLOCK 改进算法（二次机会）同时看访问位和修改位——优先淘汰"最近没访问且没修改"的页面。

为什么是"重新执行"？

引起缺页的那条指令还没完成。它想读一个内存数据，数据所在页不在内存，指令在取数阶段被打断。此时目标寄存器没写入、标志位没修改，架构状态跟这条指令执行前一模一样。数据调进来后，从头再执行这条指令就行了。

现代 CPU 通过精确异常机制保证这一点：异常发生时流水线中该指令之后的所有指令全部冲刷，架构状态回退。所以重新执行是安全的。

TLB 什么时候更新？

缺页处理程序（OS 代码）更新的是内存中的页表，不是 TLB。TLB 由硬件在下次地址变换时自动填充。所以重新执行指令时还会经历一次 TLB Miss → 查页表 → 填充 TLB 的过程。此后再访问同一页，TLB 就命中了。

多进程缺同一页怎么办？

比如共享库的代码页，多个进程同时缺同一页。OS 通常只发起一次磁盘 I/O，其他进程也阻塞等同一个 I/O 完成。避免重复读盘。Linux 里这叫 page cache 共享。

8.4 用 GDB 观察缺页中断

如果你想在真实系统上观察缺页行为，可以写一个简单的程序：

#include<stdio.h>#include<stdlib.h>#include<string.h>intmain(){// malloc 返回时，页面并未真正分配（demand zeroing）// 首次访问时才触发缺页中断，OS 分配物理页框并清零char*p=malloc(4096*10);// 申请 10 页，但此时 0 次缺页printf("malloc done, now touching pages...\n");// 每次访问新的一页，触发一次缺页中断for(inti=0;i<10;i++){p[i*4096]='x';// 触发第 i 页的缺页中断}printf("done. Check /proc/self/statm for RSS change.\n");// 查看当前进程的内存使用FILE*f=fopen("/proc/self/statm","r");intsize,resident;fscanf(f,"%d %d",&size,&resident);printf("Virtual pages: %d, Resident pages: %d\n",size,resident);fclose(f);free(p);return0;}

编译运行后，用strace -e trace=mmap,brk ./a.out可以看到系统调用，用perf stat -e page-faults ./a.out可以直接统计缺页次数。在我的机器上，这个程序大约产生 12~15 次 minor page fault（包括 libc 初始化带来的）。

九、易错点汇总

把当年坑过我的、也坑过不少考生的点列在这里。不是简单的对错判断，而是把"为什么会搞混"讲清楚。

TLB 命中 = 0 次访存？

不是。TLB 命中 = 1 次访存（取数据）。TLB 省的是"查页表"那次，不是所有访存。这个错误在选择题里出现频率极高，因为直觉上"命中"听起来像是"什么都不用做了"。

缺页中断是外中断？

不是。触发点是 MMU 检测有效位（CPU 内部），不是磁盘控制器发信号（外部）。磁盘 I/O 是处理步骤，不改变中断类型。

先查缺页还是先查越界？

先越界。P ≥ PTLR 说明地址本身非法，此时去查页表可能访问非法物理地址（总线错误）。必须先排除非法情况。

交换也能扩充内存？

不能。交换只是进程间调度空间，单个进程仍须完整装入。它是"调度"不是"扩充"。

淘汰页面都要写回？

不是。只有 D=1（脏页）才写回。D=0 直接丢弃。

进程缺页时 CPU 空转？

不是。进程阻塞，CPU 去跑别的进程。I/O 完成后中断唤醒。这是多道程序设计的基本操作。

十、例题实战

例题 1：EAT 计算

ma=100ns，t_PF=8ms，ε=0.98。

（1）p=0.0001 时 EAT = ？

EAT = 0.98×100 + 0.02×[(1-0.0001)×200 + 0.0001×8000000] = 98 + 0.02×[199.98 + 800] = 98 + 0.02×999.98 ≈ 98 + 20 = 118 ns

（2）EAT ≤ 120ns 时 p 最大多少？

98 + 0.02×[200 + 8000000p] ≤ 120 （p极小时忽略 p×200） 4 + 160000p ≤ 22 160000p ≤ 18 p ≤ 1.125×10⁻⁴

严格解（保留所有项）：159996p ≤ 18，p ≤ 1.12503×10⁻⁴。结果一样，考场用近似就行。

直觉验证：万分之一意味着每 10000 次访存缺页一次，一次缺页等 8ms = 80000 次访存的时间，所以平均多花 80000/10000 = 8% 的时间。102×1.08 ≈ 110，跟 118 量级吻合（差异来自 TLB 未命中分支的加权）。

例题 2：地址变换

页面 4KB，地址空间 64KB，8 个页框（已满）。

访问逻辑地址0x1A3F，TLB 未命中。

拆地址：4KB=2¹²，低 12 位是偏移。0x1A3F→ 页号 P=1，偏移 W=0xA3F=2623。

越界检查：PTLR=64K/4K=16，P=1<16，通过。

查 TLB：未命中。

查页表：页号 1，P=0，缺页。

缺页处理：

• 无空闲页框，CLOCK 算法选中页号 2（R=0, D=1）
• D=1，脏页，写回磁盘
• 页号 1 从磁盘读入块号 5
• 更新页表：页号 1，P=1，块号=5，D=0

重新执行：查 TLB 未命中 → 查页表 P=1，f=5 → 硬件填充 TLB

物理地址：5×4096+2623 = 23103 =0x5A3F

例题 3：选择题

关于缺页中断，正确的是：

A. 属于外中断
B. 一条指令最多产生一次
C. 处理后执行下一条指令
D. 属于内中断，一条指令可产生多次

答案 D。A 错（内中断）；B 错（REP MOVSB、跨页指令）；C 错（重新执行原指令）。

十一、答题模板（考场直接抄）

模板 A：三者区别

（1）作用范围：覆盖——同一程序内部；交换——不同进程之间；虚拟内存——单个进程内部。
（2）实现主体：覆盖——程序员手动；交换——OS 中级调度；虚拟内存——OS+MMU 协同。
（3）粒度：覆盖——程序段；交换——整个进程；虚拟内存——页（4KB）。
（4）是否扩充：覆盖和虚拟内存逻辑扩充；交换仅调度，不扩充。
（5）理论基础：覆盖——调用图；交换——多道程序设计；虚拟内存——局部性原理。
（6）透明度：覆盖不透明；交换和虚拟内存透明。

模板 B：地址变换流程

（1）提取页号 P 和偏移 W。
（2）P 与 PTLR 比较，P≥PTLR 则越界中断。
（3）查 TLB：命中→获得 f，转（6）；未命中→查内存页表（PTBR+P），转（4）。
（4）检查有效位：P=1→获得 f，写入 TLB，转（6）；P=0→缺页中断，处理后重新执行。
（5）（缺页处理）
（6）更新访问位（=1），写操作则修改位=1。
（7）物理地址 = f×页大小+W。
（8）访问内存。

模板 C：缺页中断处理

（1）保存现场（PC、PSW、寄存器）。
（2）从 CR2 确定缺页地址和页号，合法性检查。
（3）有空闲页框→直接用；无→置换（D=1 写回，D=0 丢弃）。
（4）进程→阻塞态，DMA 读盘，CPU 调度其他进程。
（5）I/O 完成→进程→就绪态。
（6）更新页表（P=1，填块号，D=0）。
（7）恢复现场，重新执行原指令。

模板 D：缺页中断定义与特点

缺页中断是 CPU 访问的页面不在内存（P=0）时由 MMU 触发的内部异常。特点：（1）内中断，非外中断；（2）一条指令可产生多次；（3）处理后重新执行原指令（精确异常）；（4）硬件检测触发，OS 负责调页。

十二、延伸阅读

• 汤小丹《计算机操作系统》第四版，第 4 章
• 王道《操作系统考研复习指导》内存管理章节
• Tanenbaum《现代操作系统》第 4 章
• CSAPP 第 9 章（虚拟内存讲得最透的一本）
• Linux 源码：arch/x86/mm/fault.c（do_page_fault入口）
• Linux 源码：mm/memory.c（handle_mm_fault核心逻辑）
• 用perf stat -e page-faults,minor-faults,major-faults观察真实系统的缺页行为

写在最后

这块内容我前后看了大概有四五遍才真正吃透。第一遍看教材，觉得"好像懂了"；第二遍做 408 真题，发现"其实没懂"；第三遍推地址变换流程，把每个分支都走了一遍；第四遍翻 Linux 源码，把 OS 侧的处理逻辑对上号；第五遍给同学讲了一遍，讲的过程中发现自己还有几个点含糊。

如果你现在处于"好像懂了"的阶段，我的建议是：拿一张白纸，把地址变换流程从头画到尾，每个判断节点都标清楚。画不出来的地方就是你没懂的地方。画三遍，基本就稳了。

觉得有用的话点个赞收藏，有问题评论区聊。

标签：操作系统内存管理虚拟内存缺页中断请求分页TLB页面置换408考研EATLinux