操作系统第 3 章：内存管理

408 操作系统「内存管理」复习：核心知识点、真题题型、通用解法与易错点。

本章以本站 408 真题 → 操作系统 → 第 3 章内存管理 为主，并用 408 模拟选择题 → 操作系统 → 第 3 章 补充题型。本站也明确建议按“真题确定命题方式，再用模拟题补充”的顺序复习。第 3 章真题主要分为“基本内存管理”和“虚拟内存管理”两大部分。(Any Docs)

这一章是操作系统里计算味最重、综合性最强的章节之一。

如果第 2 章进程管理的核心是“状态 + 调度 + PV”，那么第 3 章可以压缩成一句话：

CPU 给出虚拟地址以后，到底怎样找到真正的物理内存？如果页面不在内存，又怎么办？

408 会围绕这条主线不断变形。

一、先建立整章知识地图

模块	典型考法	重要度
地址装入、链接、重定位	概念选择题	★★
连续分配	首次/最佳/最坏适应、碎片、回收合并	★★★
伙伴系统	分裂、合并	★★～★★★
基本分页	页号、页内偏移、页框、物理地址	★★★★★
多级页表	页表大小、地址拆分、页表级数	★★★★★
分段	段号、段长、越界、共享	★★★
请求分页	缺页异常处理	★★★★★
页面置换	FIFO、LRU、CLOCK、改进 CLOCK	★★★★★
TLB	命中率、平均访存时间	★★★★★
工作集与抖动	工作集计算、抖动原因	★★★
页面缓冲	与置换、缺页率区别	★★
局部性	数组访问与缺页、Cache 联合	★★★★
综合大题	页表 + TLB + 缺页 + 置换 + 地址计算	★★★★★

真正应该投入最多时间的是：

分页地址转换 → 多级页表 → TLB → 缺页 → 页面置换 → 物理地址。

这几个知识点可以单独考，也非常喜欢串成一道大题。

三、题型一：链接、装入、重定位与地址保护

1. 逻辑地址什么时候形成？

【2011 408 真题】

题意是：

虚拟内存系统中最终还要把逻辑地址转换为物理地址，那么程序的逻辑地址主要在哪个阶段形成：编辑、编译、链接还是装载？

答案：链接阶段。(Any Docs)

这一题容易把“编译”和“链接”混淆。

基本流程：

源程序

→ 编译

→ 若干目标模块

→ 链接

→ 完整逻辑地址空间

→ 装入

→ 运行期间地址转换。

可以理解成：

编译解决“每个模块自己是什么”，链接解决“大家拼在一起以后在哪里”。

类型	转换时间	特点
静态重定位	装入时	一旦装入，通常不能随便移动
动态重定位	运行时	借助硬件地址转换，可以移动

3. 地址保护

【2009 408 真题】

题目问：

分区分配方式下，主要采用什么措施保护各进程的内存空间？

答案：界地址保护。(Any Docs)

常见实现：

基址寄存器 + 限长寄存器。

逻辑地址 $x$ 首先判断：

0 \leq x < L

合法后：

P A = B + x

其中：

$B$ ：基址；

$L$ ：进程地址空间长度。

一定是：

先检查，再相加。

这个思想到了分段系统完全一样。

四、题型二：内部碎片与外部碎片

这是选择题高频陷阱。

1. 内部碎片

已经分给出了，但尚未使用完。

例如一个页框 4KB，进程最后一页只有 1KB：

[1KB有效数据 | 3KB浪费]

这 3KB 已经属于该进程，因此别人无法使用。

所以是内部碎片。

必须记住的表

管理方式	内部碎片	外部碎片
固定分区	有	通常不作为主要问题
动态分区	基本无	有
分页	有	无
分段	基本无	有
段页式	有	无页框层面的外部碎片

模拟题专门把固定分区、动态分区、分页、分段、段页式混起来问，正确判断内部碎片的关键就是：

固定大小单位分配 → 容易产生内部碎片；可变连续区域 → 容易产生外部碎片。 (Any Docs)

分页绝对不要说“页面小可以减少外部碎片”。

因为：

分页本身就没有外部碎片

页面变小减少的是平均内部碎片。

但代价是：

页数增加 → 页表项增加 → 页表更大。

五、题型三：动态分区分配算法

这是典型的“画内存图”问题。

需要掌握：

算法	选择
First Fit 首次适应	第一个够大的
Next Fit 邻近/循环首次适应	从上次搜索位置继续
Best Fit 最佳适应	最小但够用的
Worst Fit 最坏适应	最大的

六、经典真题：Best Fit

【2010 408 真题】

题目给出：

主存 55MB，开始全部空闲，采用最佳适应算法：

分配 15MB

→ 分配 30MB

→ 释放 15MB

→ 分配 8MB

→ 分配 6MB

问最后最大的空闲分区是多少。(Any Docs)

开始：

55

分 15：

40

再分 30：

10

释放 15：

空洞为：

15, 10

申请 8MB。

Best Fit 找最小但够用的。

所以使用 10MB：

10 - 8 = 2

现在：

15, 2

再申请 6MB。

使用 15MB：

15 - 6 = 9

最终：

9, 2

所以最大空闲区：

9 MB

七、为什么 Best Fit 反而容易产生碎片？

【2019 408 真题】

问：

First Fit、Worst Fit、Best Fit、Next Fit 中，谁最容易产生小碎片？

答案是：

Best Fit

因为它总挑“刚刚够大”的。

例如申请 99KB。

存在：

100KB、300KB、1000KB。

Best Fit 会拿 100KB：

100 - 99 = 1 KB

于是不断制造：

1KB、2KB、3KB……

这种很难再使用的小洞。(Any Docs)

八、动态分区真正难的是“释放后合并”

【2017 408 真题】

题目给出的空闲区包括：

20K 起始、40KB；

500K 起始、80KB；

1000K 起始、100KB；

200K 起始、200KB。

现在回收：

起始 60K、大小 140KB。

最好的方法不是靠想象，而是全部写成左闭右开区间。

原第一个：

[20, 60)

回收：

[60, 200)

后面的空闲分区：

[200, 400)

三段刚好连续。

合并：

[20, 400)

大小：

40 + 140 + 200 = 380 KB

于是原来的四个空洞中，两个与新释放区域合并，最终只有三个空洞。

而题目还说明使用 Best Fit 且每次重新排序，所以空闲链表按大小从小到大：

80KB

→ 100KB

→ 380KB。

因此链首是：

起始 500K、80KB。(Any Docs)

这类题的统一方法

永远写：

[start, start + size)

然后检查：

前一个结束地址 = 新区起始？

新区结束地址 = 后一个起始？

是就合并。

比画随意的方块可靠得多。

九、模拟题的重要变式：从高地址端分配

本站里有一道王道模拟题：

初始用户区 [126K,512K)，所有申请都从所选空闲分区的高地址端切出。

依次申请、释放后再采用 First Fit，最终最小空闲块得到 13KB。(Any Docs)

这道题最有价值的地方不是答案，而是在提醒：

“First Fit”只决定选哪个空洞，并不一定决定从空洞哪一端切。

如果题目明确：

“从高地址部分分配”

就不能习惯性从低地址端画。

十、伙伴算法：2024 已经正式考过

【2024 408 真题】

题目问：

每次释放分区时，只与“大小相同的对应空闲分区”进行合并的是哪种算法？

答案：

Buddy System 伙伴算法

伙伴系统的块大小都是：

2^{k}

例如申请 20KB。

可能从 64KB 开始：

64 \to 32 + 32

给用户一个 32KB。

内部浪费：

32 - 20 = 12 KB

释放以后，只有它对应的那个 32KB 伙伴也空闲，才能合并：

32 + 32 = 64

不能随便找另一个 32KB 合并。(Any Docs)

这可能继续变式

408 很可能继续考：

给起始地址、块大小，判断两个块是不是 buddy；

或者连续申请、释放后求最终空闲块。

这属于值得准备的新考法。

十一、题型四：基本分页——本章真正的核心

分页系统有三个词必须彻底区分：

概念	属于哪里
page 页	虚拟地址空间
frame 页框 / 页帧 / 物理块	物理内存
page table 页表	page → frame 映射

例如：

虚拟页 5 → 页框 17。

如果页面大小为 4KB：

P A = 17 \times 4096 + offset

十二、地址位数怎么拆？

如果页大小为：

2^{12} B

那么页内偏移 12 位。

32 位地址：

VPN 20 位 ∣ offset 12 位

因此：

虚拟页数：

2^{20}

页面：

2^{12} = 4 KB

十三、页表大小怎么算？

假设：

32 位虚拟地址；

页大小 4KB；

PTE 4B。

页号 20 位，所以页表有：

2^{20}

项。

每项 4B：

2^{20} \times 4 = 2^{22} B = 4 MB

所以一个进程如果建立完整一级页表，就可能需要 4MB。

这正是多级页表出现的原因之一。

十五、为什么要多级页表？

【2014 408 真题】

题目问多级页表的优点。

正确方向不是“转换更快”，而是：

减少页表对大块连续内存的要求，并且没用到的虚拟地址范围可以不建立下级页表。(Any Docs)

这一点非常容易错。

多级页表：

节省页表空间 / 降低连续空间要求

但代价是：

地址转换可能访问更多次内存。

例如没有 TLB：

一级页表：

查页表 + 访问数据：

2

次内存。

二级页表：

页目录

→ 二级页表

→ 数据。

一共：

3

次。

三级：

4

次。

因此：

n 级页表，没有 TLB 时通常需要 n + 1 次访存

十六、二级页表的经典计算

【2010 408 真题】

条件：

页面：

2^{10} B

PTE：

2B。

整个逻辑空间：

2^{16}

页。

一个二级页表通常占一个页面，所以每张二级页表能放：

\frac{2 ^{10}}{2} = 2^{9} = 512

个 PTE。

总共需要管理：

2^{16}

页。

因此需要二级页表数量：

\frac{2 ^{16}}{2 ^{9}} = 2^{7} = 128

于是页目录至少有：

128

项。(Any Docs)

通用公式

页面大小 $P$ ，PTE 大小 $e$ ：

每张页表项数 = \frac{P}{e}

如果要覆盖 $N$ 个页面：

下级页表数量 = ⌈ \frac{N}{P / e} ⌉

十八、PDBR / 页表基址寄存器到底存什么？

【2021 408 真题】

二级分页系统问：

CPU 页表基址寄存器保存什么？

答案：

当前进程最高级页表的物理起始地址

不是虚拟地址。(Any Docs)

为什么？

假如 PDBR 存虚拟地址：

CPU 想查页表

→ 得先把 PDBR 的虚拟地址转物理地址

→ 转它又需要查页表

→ 但页表地址还不知道……

循环依赖。

所以必须从一个真实物理地址起步。

十九、进程切换与线程切换对 PDBR 的影响

【2018 408 大题】

题目还问：

进程切换时 PDBR 变不变？

同一进程线程切换时呢？

结论：

不同进程有不同虚拟地址空间：

进程切换一般改变 PDBR

同一进程中的线程共享虚拟地址空间：

同一进程线程切换一般不改变 PDBR

这道题同时还要求由页目录号、页号和偏移重新拼出虚拟地址，以及说明改进 CLOCK 需要访问位和修改位。(Any Docs)

二十、题型五：分段

分页：

站在操作系统/物理内存角度，把东西等大小切。

分段：

站在程序员逻辑角度，把程序分成代码段、数据段、栈段……

所以分段地址：

段号 + 段内偏移

二十二、分段地址转换：先越界检查！

【2016 408 真题】

段 2：

段长 300；

基址 4000；

已经在内存；

可读写。

现在访问：

段号 2，段内地址 400。

有人会直接算：

4000 + 400 = 4400

错。

必须先检查：

400 < 300 ?

不成立。

因此直接：

越界异常

不会得到 4400。(Any Docs)

统一流程：

段号合法？ \to 段内偏移 < 段长？ \to 权限？ \to 是否在内存？ \to 基址 + 偏移

二十四、题型六：请求分页与缺页异常

这是第二大核心。

基本分页：

所有需要页面先装进来，再运行。

请求分页：

暂时不用的页面先不装，访问到了再装。

所以页表项必须额外记录：

存在位 / 有效位。

例如：

页号	页框号	存在位
2	17	1
3	—	0

访问页 3：

缺页异常

二十五、缺页异常到底干什么？

完整逻辑是：

虚拟地址合法

→ 查页表发现页面不在内存

→ 产生缺页异常

→ OS 接管

→ 找页框

→ 必要时选择牺牲页

→ 若牺牲页已修改则写回

→ 从磁盘调入目标页

→ 修改页表

→ 必要时更新/失效 TLB

→ 重新执行发生缺页的指令

这里一个非常关键的判断：

缺页 ≠ 越界

缺页表示：

这个地址合法，只是页面暂时不在内存

越界表示：

这个地址本身非法

二十六、缺页时一定置换页面吗？

不是。

【2022 408 真题】

页面 b 不在内存，发生缺页。

问缺页处理“不一定”包含什么操作。

答案：

页面淘汰

因为如果还有空闲页框：

直接把 b 放进去即可。

无须淘汰。(Any Docs)

所以：

缺页：

\neq =

页面置换。

正确关系是：

缺页且没有空闲页框 \Rightarrow 需要页面置换

二十七、固定分配、可变分配、局部/全局置换

【2015 408 真题】

问哪种组合不可能：

固定分配 + 全局置换。

答案：

固定分配 + 全局置换不合理

原因：

固定分配规定：

进程页框数固定。

全局置换：

可以从系统其他进程占用的页框里选牺牲页。

那某进程拿走别人的页框之后，各进程页框数就改变了。

于是与固定分配矛盾。(Any Docs)

应该记：

组合	可否
固定 + 局部	✓
固定 + 全局	✗
可变 + 局部	✓
可变 + 全局	✓

二十八、题型七：页面置换算法

四个必须精通：

算法	淘汰谁	需要什么信息
OPT	未来最久不用	未来访问序列
FIFO	最早进入内存	装入时间
LRU	最久没有被访问	最近访问历史
CLOCK	近似 LRU	访问位
改进 CLOCK	综合访问/修改	A 位 + M 位

二十九、OPT：理论最优

OPT：

未来最长时间不用的页面淘汰。

它能取得理论上的最少缺页次数。

但真实系统不知道未来。

所以：

OPT 主要作为理论比较基准

三十二、2015 408：LRU 标准选择题

分配 4 个页框。

访问序列已经走到：

2，0，2，9，3，4，2，8，2，4，8，4，5。

下一页是 7。

题目问 LRU 淘汰谁。(Any Docs)

处理完成后驻留：

{2, 4, 8, 5}

看它们最后一次出现的位置。

2：更早

8：之后

4：之后

5：刚刚出现。

所以：

2

LRU 最快方法

如果题目只问“当前淘汰谁”，不一定需要从头完整画表。

只要确定当前驻留页面，然后从访问序列末尾倒着找。

最后最晚找到的那个驻留页，就是 LRU。

三十三、FIFO 与 LRU 最容易混淆的地方

假设：

A 最早装入；

但 A 刚刚被访问。

那么：

FIFO：

仍然淘汰 A。

LRU：

不会淘汰 A。

一句口诀：

FIFO 看出生日期，LRU 看最后活动时间。

三十六、2010 408 大题：FIFO 与 CLOCK

这道题非常值得完整掌握。

页	页框	装入时刻	A
0	7	130	1
1	4	230	1
2	2	200	1
3	9	160	1

第二问：FIFO

装入时间：

页 0：130

页 1：230

页 2：200

页 3：160。

最早：

130

所以淘汰页 0。

页 0 原页框：

7

页 5 装入页框 7。

物理地址：

7 \times 400 H + 3 C A H

= 1 C 00 H + 3 C A H

1 F C A H

第三问：CLOCK

指针当前指向页框 2。

所有页面 A 都是 1。

第一次扫描：

全部从 1 清成 0。

转一圈重新回到页框 2。

现在该页：

A = 0

于是淘汰页框 2 中的页 2。

页 5 装入页框 2。

物理地址：

2 \times 400 H + 3 C A H

= 800 H + 3 C A H

B C A H

这道题体现了本章的核心综合形式：

地址拆分 + 缺页 + 置换 + 物理地址

A	M	含义
0	0	最近没访问、没修改
0	1	最近没访问、修改过
1	0	最近访问、没修改
1	1	最近访问、修改过

三十八、2021 408：缺页 + 改进 CLOCK + 地址转换

题目给：

页大小 4KB；

2 个固定页框；

页 3：

存在， $A = 1, M = 0$

页 4：

存在， $A = 1, M = 1$

页 2：

不存在。

现在访问：

02A01H。(Any Docs)

拆地址：

02 A 01 H = 2 \times 1000 H + A 01 H

所以访问页 2。

页 2 不在内存：

缺页。

改进 CLOCK 经过扫描后优先让页 3 成为：

(0, 0)

因此淘汰页 3。

页 3 原页框：

60 H

所以页 2 装入 60H。

物理地址：

60 H \times 1000 H + A 01 H

60 A 01 H

最重要的坑是：

页 2 页表项里即使残留了一个旧页框号，只要存在位为 0，这个页框号就不能直接用于地址转换。

算法	看哪个字段
FIFO	装入时间最小
LRU	最近访问时间最小
改进 CLOCK	A、M，并结合指针扫描顺序

四十一、抖动 Thrashing

这是概念题非常爱考的。

抖动：

CPU 大量时间都在处理缺页和换页，真正执行程序的时间很少。

常见原因：

多道程序度过高

进程太多：

每个进程得到的页框太少。

工作集装不下。

于是：

A 缺页

→ 换 B

→ 马上访问 B

→ 又换 A

→ 又要 A……

磁盘疯狂 I/O。

【2011 408 真题】

题目给三个方案：

撤销部分进程；

增加交换区；

提高进程优先级。

有效措施是：

撤销 / 挂起一部分进程

因为可以减少多道程序度，让剩余进程得到更多页框。

单纯扩大 swap：

并不能让进程的工作集装进物理内存。

提高优先级也不能增加它的驻留集。(Any Docs)

四十五、模拟题：反推 TLB 命中率

本站有一道很好的模拟题：

TLB 查询 1ns；

内存访问 100ns；

TLB 与页表查询并行；

要求开启分页以后平均访存时间不超过 110ns。

求最低 TLB 命中率。(Any Docs)

命中：

TLB 1ns 得到结果，然后访问数据：

T_{h} = 101 ns

未命中。

因为 TLB 与内存中的页表同时开始查：

100ns 时页表完成，

然后再访问一次目标数据：

T_{m} = 200 ns

设命中率 $h$ ：

101 h + 200 (1 - h) \leq 110

整理：

200 - 99 h \leq 110

99 h \geq 90

h \geq \frac{90}{99}

h \approx 90.9%

这种题最关键的不是公式背诵，而是先判断：

TLB 和页表是串行查，还是并行查？

题目条件不同，公式就不同。

四十六、超级经典：2009 TLB + 缺页 + LRU 综合大题

这是第 3 章非常值得反复做的一道题。

【2009 408 真题】

页大小：

4KB。

页表部分情况：

页 0 → 101H，有效；

页 1 → 不在内存；

页 2 → 254H，有效。

TLB 初始为空。

TLB：

10ns。

内存：

100ns。

一次缺页：

1 0^{8} ns

驻留集固定为 2；

使用 LRU。

访问：

2362H

→ 1565H

→ 25A5H。(Any Docs)

第三次：25A5H

25 A 5 H = 2 \times 1000 H + 5 A 5 H

页 2。

页 2 仍在内存，并且 TLB 已经缓存映射。

所以：

10 + 100 = 110 ns

页 1 的最终物理地址

页 1 被装入：

101 H

页框。

所以：

P A = 101 H \times 1000 H + 565 H

101565 H

这道题一定要掌握什么？

它实际上把五个点串在了一起：

TLB

→ 页表

→ 缺页

→ LRU

→ 物理地址。

以后看到复杂大题就按这个顺序拆开，而不是试图一口气想完。

四十七、有效访存时间 + 缺页率

设正常访存时间：

T_{m}

缺页率：

p

一次缺页处理的额外代价：

T_{f}

则近似：

E A T = (1 - p) T_{m} + p (T_{f} + 重新访问时间)

因为：

T_{f} ≫ T_{m}

很多题近似写成：

E A T \approx T_{m} + p T_{f}

四十八、模拟题：反推最大缺页率

本站有一道很有价值的模拟题：

正常内存访问 1μs；

未修改页缺页处理 1ms；

修改页缺页处理 10ms；

60% 被换出的页面修改过；

要求 EAT 不超过 3μs。(Any Docs)

平均缺页处理时间：

T_{f} = 0.4 \times 1 + 0.6 \times 10

= 6.4 ms

转成 μs：

6400 μ s

正常分页访问约为：

2 μ s

于是：

2 + 6400 p \leq 3

p \leq \frac{1}{6400}

因此：

p_{m a x} = \frac{1}{6400}

这类题透露出一个非常重要的考试直觉：

允许的缺页率往往必须极低。

因为磁盘 I/O 太慢。

四十九、为什么修改位这么重要？

假设替换一个干净页面。

磁盘里已经有正确副本。

可以直接：

丢掉。

但修改页：

内存是最新版本。

所以必须：

写回磁盘 \to 读入新页

于是一次置换可能发生：

两次磁盘 I/O。

所以所有置换算法都倾向于：

在条件相近时优先淘汰干净页。

五十二、2012 408 大题：页面缓冲 + 时间局部性

这道真题给出：

每隔 5 个时间单位扫描驻留集；

本轮没访问的页面回收到空闲页框链尾；

但页框内容暂时不清空；

如果以后又访问且原内容还在，就重新拿回来。(Any Docs)

例如页 1 原来占页框 32。

后来因为一个扫描窗口内没访问，被回收到空闲链。

但内容仍然是页 1。

随后很快再次访问页 1。

那么系统发现：

32 号页框里的旧内容还没有被覆盖。

可以直接恢复：

32

号页框。

不需要磁盘重新读。

所以这种策略特别适合：

时间局部性好的程序

五十三、题型十二：程序局部性

这是这几年特别值得重视的交叉知识点。

局部性分：

时间局部性：

刚访问过的东西很可能很快再次访问。

空间局部性：

访问某地址以后，很可能继续访问附近地址。

分页、TLB、Cache 都大量依赖局部性。

五十四、数组按行还是按列？

【2020 408 大题】

数组：

a[1024][1024]

每个元素 4B。

起始虚拟地址：

10800000H。

题目问：

a[1][2] 的虚拟地址；

页目录号、页号；

页目录项和页表项地址；

虚拟空间/物理空间是否连续；

最后还问按行遍历和按列遍历哪个局部性好。(Any Docs)

`a[1][2]` 地址

C 语言二维数组行优先。

前面经过：

1 \times 1024 + 2 = 1026

个元素。

每个 4B：

1026 \times 4 = 4104 = 1008 H

所以虚拟地址：

10800000 H + 1008 H

10801008 H

五十六、为什么按行遍历好？

数组按行存储。

同一行：

A[i][0], A[i][1], A[i][2]...

地址连续。

所以按行访问：

空间局部性强

而按列：

A[0][j]

→ A[1][j]

→ A[2][j]

每次跨越一整行。

这道 2020 真题中：

一行大小：

1024 \times 4 = 4096 B = 4 KB

恰好一页。

所以按列每访问下一元素：

几乎就跳到下一页。

极易：

TLB miss

Cache miss
甚至缺页。

而按行可以连续吃完整个页面。(Any Docs)

六十、一道非常容易忽略的题：最少要几个页框？

模拟题：

指令系统允许一级间接寻址；

请求分页；

问一个进程至少需要多少页框才能保证指令完成。(Any Docs)

最坏情况：

一条指令本身跨两个页面：

2

页。

一级间接寻址的间接地址：

可能另占：

1

页。

最终操作数：

又在另一个页面：

1

页。

所以至少：

2 + 1 + 1 = 4

个页框。

这种题不是普通地址计算，而是在问：

一条指令执行过程中最多需要同时存在多少个页面？

属于很好的拓展题型。

六十一、多级页表综合题怎么拆？

以后遇到：

32 位地址：

10 + 10 + 12

只要看到虚拟地址：

0xXXXXXXXX

立刻拆：

页目录：

V A ≫ 22

二级页表索引：

(V A ≫ 12) & 3 F F H

offset：

V A & F F F H

六十二、页目录项地址怎么算？

页目录基址：

P D B R

页目录号：

p_{1}

每项 4B。

那么：

P D E 地址 = P D B R + 4 p_{1}

查 PDE 得到二级页表页框：

f_{2}

于是二级页表基址：

P T B a se = f_{2} \times 4096

页表索引：

p_{2}

所以：

P T E 地址 = P T B a se + 4 p_{2}

再查 PTE：

得到数据页框 $f$ 。

最终：

P A = f \times 4096 + o f f se t

这套链条一定要非常熟：

V A \to P D E \to P T E \to F r am e \to P A

步骤	做什么
1	先确定页面大小，得到 offset 位数
2	把虚拟地址拆成页号/各级索引/offset
3	先查 TLB，判断 hit / miss
4	TLB miss 再按层级查页表
5	检查存在位、权限、越界等控制位
6	缺页则判断有没有空页框
7	没空页框时应用 FIFO/LRU/CLOCK 等
8	脏页需要写回，随后调入新页
9	更新页表、TLB、相关状态位
10	重新执行发生缺页的指令
11	得到页框号后拼接 offset
12	如果问时间，再把各次 TLB/内存/磁盘访问逐项相加

概念 A	概念 B	区别
页 page	页框 frame	虚拟 vs 物理
缺页	页面置换	有空页框时缺页但不置换
TLB miss	缺页	TLB 没有不代表内存没有
缺页	越界	合法但不驻留 vs 地址非法
页号	页框号	虚拟编号 vs 物理编号
虚拟地址连续	物理地址连续	前者完全可以对应离散页框
FIFO	LRU	装入时间 vs 最近访问时间
缺页率	缺页处理时间	发生概率 vs 一次处理代价
页表	TLB	完整映射结构 vs 高速缓存
虚拟地址空间	swap	地址范围 vs 外存后备空间
内部碎片	外部碎片	已分配内部浪费 vs 空闲空间零散

六十六、页面大小变大，到底有什么影响？

这是很适合出综合选择题的知识点。

页面变大：

页数减少。

因此：

页表项减少

页表更小。

TLB 每个表项覆盖范围扩大。

磁盘顺序传输效率可能提高。

但是：

内部碎片一般增大。

一次调入的数据更多。

如果空间局部性差，会装进很多无用数据。

所以没有：

“页面越大一定越好”

或：

“页面越小一定越好”。

408 最喜欢这种绝对化选项。

六十七、一个很实用的平均内部碎片结论

如果进程大小相对页面边界可以近似认为随机。

最后一页平均浪费：

\frac{P}{2}

其中 $P$ 为页大小。

所以页面越大：

平均内部碎片一般越大。

这个虽然不一定每次直接考公式，但非常适合用来判断选项。

六十九、为什么缺页后要重新执行指令？

假设执行：

x = A[i];

CPU 执行到访问 A[i]：

发现页面不存在。

此时这条指令还没真正完成。

OS 调入页面以后不能直接执行下一条。

必须：

重新执行原指令

这也是计算一次缺页总时间时经常忘掉的一部分。

2009 那道综合真题就明确利用了这一点。

七十、数组题还可能和 Cache 联合

这是非常值得预测的一种 408 综合考法。

已经有真题把：

二维数组

分页
二级页表
局部性

放在一起。

后续完全可以继续加入：

Cache。

例如：

页面 4KB；

Cache block 64B；

数组元素 4B。

一个页面有：

\frac{4096}{4} = 1024

个 int。

一个 Cache block 有：

\frac{64}{4} = 16

个 int。

如果顺序遍历：

每 16 个 int 一次 Cache 块缺失；

每 1024 个 int 一次新页。

因此一个循环可以同时问：

Cache miss

TLB miss
page fault。

这种组合非常符合 408 “计组 + 操作系统交叉”的风格。

七十二、还有一种值得防：Copy-on-Write

虽然传统基础教材不会把它当本章最核心内容，但它和近年的“共享物理页”题非常自然。

例如 fork 后：

父进程页 $p_{1}$

子进程页 $p_{2}$

一开始都映射：

f

于是：

p_{1} \neq = p_{2}

完全可以，而：

f_{1} = f_{2}

当某个进程写页面时发生保护异常，OS：

复制物理页

→ 修改该进程页表

→ 以后两个进程页框不同。

这本质上就是 2023“共享数据页”考法的自然延伸。

七十四、最后给出压缩成考场判断口诀

分区：

固定有内碎，动态有外碎；

Best Fit 小洞多；

回收先看前邻后邻；

紧凑需要动态重定位。

分页：

页号在高位，偏移在低位；

offset 位数决定页大小；

页表基址 + 页号 × PTE 大小；

物理地址 = 页框 × 页大小 + offset。

多级页表：

上一级 PTE 指向下一级页表的物理页框；

多级页表省页表空间，不是为了加快访问；

没有 TLB，级数越多访存次数通常越多；

PDBR 指向最高级页表的物理地址。

分段：

先查段号；

再查 offset 是否越过段长；

再看权限；

最后才是 base + offset。

虚拟内存：

缺页是“合法但不在内存”；

有空页框不一定置换；

脏页换出要写回；

缺页后重新执行原指令。

置换算法：

FIFO 看谁最早进；

LRU 看谁最久没用；

CLOCK 看 A；

改进 CLOCK 看 A、M；

FIFO 可能 Belady。

共享：

虚页号可以不同；

共享物理页框必须相同。

局部性：

C 二维数组按行存；

按行遍历通常远好于按列。

如果时间有限，第 3 章建议至少把这些题真正拿纸完整算一遍：**2013 分页/二级页表大题、2009 TLB+缺页+LRU 大题、2010 FIFO/CLOCK 大题、2012 页面缓冲大题、2015 多级页表大题、2018 PDBR/地址组成大题、2020 二维数组+二级页表大题，再配 2021 改进 CLOCK 和 2023 共享页选择题。**它们基本覆盖了内存管理最重要的命题骨架。本站中的真题也确实持续围绕这些主题反复变化。(Any Docs)

如果只记这一章最重要的一句话，就是：

先拆地址，后查映射；先判合法 / 驻留，再做置换；最后拼物理地址并计算代价。

这条思路真正熟练以后，第 3 章那些看起来很长的综合大题，实际上都只是把几个固定步骤串起来。

操作系统第 3 章：内存管理

On this page