共计 18864 个字符，预计需要花费 48 分钟才能阅读完成。

内存的基础知识

一、什么是内存？有何作用

内存是用于存放数据的硬件。程序执行前 需要先放到内存中才能被 CPU 处理。

思考：在多道程序环境下，系统中会有多个程序并发执行，也就是会有多个程度的数据需要同时放入内存中，那么如何区分各个程序的数据是放在什么地方呢？

方案：给内存的存储单元编地址

补充：

二、进程的运行原理–指令

我们写的代码要翻译成 CPU 能识别的命令。这些指令会告诉 CPU 应该区内存的哪个地址存 / 取数据，这个数据应该做什么样的处理。在这个例子中，指令中直接给出了变量 x 的实际存放地址（物理地址）。但实际在生成机器指令的时候并不知道该进程的数据会被放到什么位置。所以编译生成的指令中一般是使用 逻辑地址（相对地址）。

三、逻辑地址与物理地址

例：

宿舍四个人一起出去旅行，四个人的学号尾号分别是 0、1、2、3。

住酒店时酒店给他们安排了 4 个房号相连的房间。四个人按学号递增次序入住房间。比如 0、1、2、3 号分别入住了 5、 6、 7、 8 号房间。

四个人编号0、 1、 2、 3 是一个 “相对位置”，各自入住的房间号是一个 “绝对位置”。即只要知道 0 号同学住的是房号为 N 的房间，那么 M 号同学的房号一定是 N+M。

eg：编译时只需要确定变量 x 存放的相对地址是 100（也就是相对于进程在内存中的起始地址而言的地址）。CPU 想要找到 x 在内存中的实际存放位置，只需要用进程的起始地址 +100 即可。

相对地址 又称 逻辑地址，绝对地址 又称 物理地址。

四、从写程序到程序运行

编译：由编译程序将用户源代码编译成若干个目标模块（即把高级语言 翻译为机器语言）

链接：由链接程序将编译后形成的一组目标模块，以及所需库函数链接在一起，形成一个完整的装入模块

装入（装载）：由装入程序将装入模块装入内存运行

五、装入模块装入内存

int a = 1;

int x = a + 1;

第一种可能：

第二种可能：

装入的三种方式（用三种不同的方法完成 逻辑地址到物理地址的转换）：

1. 绝对装入
2. 静态重定位
3. 动态重定位

1.装入的三种方式–绝对装入

绝对装入：在编译时，如果知道程序将放到内存中的哪个位置，编译程序将产生绝对地址的目标代码。装入程序按照装入模块中的地址，将程序和数据装入内存。

eg: 若知道装入模块要从地址为 100 的地方开始存放。

绝对装入 只适用于单道程序环境。

程序中使用的绝对地址，可在编译或汇编时给出，也可由程序员直接赋予。通常情况下都是编译或汇编时再转换为绝对地址。

2.装入的三种方式–静态重定位

静态重定位：又称 可重定位装入。编译、链接后的装入模块的地址都是从 0 开始的，指令中使用的地址、数据存放的地址都是相对于起始地址而言的逻辑地址。可根据内存的当前情况，将装入模块装入到内存的适当位置。装入时对地址进行 “重定位” ，将逻辑地址变换为物理地址（地址变换是在装入时一次完成的）。

静态重定位的特点是在一个作业装入内存时，必须分配其要求的全部内存空间，如果没有足够的内存，就不能装入该作业。作业一旦进入内存后，在运行期间就不能再移动，也不能再申请内存空间。

3.装入的三种方式–动态重定位

动态重定位：又称 动态运行时装入。编译、链接后的装入模块的地址都是从 0 开始。装入程序把装入模块装入内存后，并不会立即把逻辑地址转换为物理地址，而是 把地址转换推迟到程序要执行时才进行。因此装入内存后所有的地址依然是逻辑地址。这种方式需要一个 重定位寄存器 的支持。

采用动态定位时 允许程序在内存中发生移动。并且可将程序分配到不连续的存储区中；在程序运行前只需装入它的部分代码即可投入运行，然后再程序运行期间，根据需要动态申请分配内存；便于程序段的共享，可以向用户提供一个比存储空间大得多的地址空间。

六、链接的三种方式

1. 静态链接

静态链接：在程序运行之前，先将各目标模块及他们所需的库函数连接成一个完整的可执行文件（装入模块），之后不再拆开。

2.装入时动态链接

装入时动态链接：将各目标模块装入内存时，边装入边链接的链接方式。

3. 运行时动态链接

运行时动态链接：在程序执行中需要该目标模块时，才对它进行链接。其优点是便于修改和更新，便于实现对目标模块的共享。

总结

内存管理的概念

一、内存空间的分配与回收

三个问题：

1. 操作系统要怎么记录哪些内存区域已经被分配出去了，哪些又还空闲？
2. 当进程运行结束之后，如何将进程占用的内存空间回收？
3. 很多位置都可以放入，应该放哪里？

二、内存空间的扩充

游戏的大小超过 60GB ，实际上电脑内存才 4GB，为什么还可以顺利运行。

–虚拟技术（操作系统的虚拟性）

三、地址转换

为了使编程方便，程序员写程序时应该只需要关注指令、数据的逻辑地址。而 逻辑地址到物理地址的转换（这个过程称为地址重定位） 应该由操作系统负责，这样就保证了程序员写程序时不需要关注物理内存的实际情况。

四、内存保护

内存保护可采取两种方法：

1. 在 CPU 设置一对上、下限寄存器，存放进程的上、下限地址。进程的指令要访问某个地址时，CPU 检查其是否越界。
2. 采用 重定位寄存器（又称 基址寄存器）和 界地址寄存器（又称 限长寄存器） 进行越界检查。重定位寄存器中存放的是进程的 起始物理地址。界地址寄存器中存放的是进程的 最大逻辑地址。

总结

覆盖与交换

一、覆盖技术

早期的计算机内存很小，经常会出现内存大小不够用的情况。后来引入了 覆盖技术，用来解决 程序大小超过物理内存总和 的问题。

覆盖技术的思想：将 程序分为多个段（多个模块）。常用的段常驻内存，不常用的段在需要时调入内存。

内存中分为 一个 “固定区” 和 若干个 “覆盖区”。

需要常驻内存的段放在 “固定区” 中，调入后就不再调出（除非运行结束）

不常用的段放在 “覆盖区”，需要用到时调入内存，用不到时调出内存

必须由程序员声明覆盖结构，操作系统完成自动覆盖。缺点：对用户不透明，增加了用户编程负担。覆盖技术只用于早期的操作系统中。

二、交换技术

交换（对换）技术的设计思想：内存空间紧张时，系统将内存中某些进程暂时 换出 外存，把外存中某些已具备运行条件的进程 换入 内存（进程在内存与磁盘间动态调度）

中级调度（内存调度），就是要决定要将哪个处于挂起状态的进程重新调入内存。

复习：暂时换出外存等待的进程状态为 挂起状态，挂起态又可以进一步细分为 就绪挂起、阻塞挂起 两种状态。

思考：

1. 应该在外存（磁盘）的什么位置保存被换出的进程？
2. 什么时候应该交换？
3. 应该换出哪些进程？
4. 具有对换功能的操作系统中，通常把磁盘空间分为 文件区 和 对换区 两部分。文件区 主要用于存放文件，主要追求存储空间的利用率，因此对文件区空间的管理 采用离散分配方式；对换区 空间只占磁盘空间的小部分，被换出的进程数据就存放在对换区。由于对换的速度直接影响到系统的整体速度，因此对换区空间的管理 主要追求换入换出速度，因此通常对换区 采用连续分配方式。总之，对换区的 I / O 速度比文件区的更快。
5. 交换通常在许多进程运行且内存吃紧时进行，而系统负荷降低就暂停。例如：在发现许多进程运行时经常发生缺页，就说明内存紧张，此时可以换出一些进程：如果缺页率明显下降，就可以暂停换出。
6. 可优先换出阻塞进程；可换出优先级低的进程；为了防止优先级低的进程在被调用内存后很快又被换出，有的系统还会考虑进程在内存的驻留时间。

（注：PCB 会常驻内存，不会被换出）

总结

连续分配管理方式

连续分配：指为用户进程分配的必须是一个 连续的内存空间

一、单一连续分配

在单一连续分配方式中，内存被分为 系统区 和 用户区。系统区通常位于内存的低地址部分，用于存放操作系统相关数据；用户区用于存放用户进程相关数据。

内存中 只能有一道用户程序，用户程序独占整个用户区空间。

优点： 实现简单；无外部碎片；可以采用覆盖技术扩充内存；不一定需要采取内存保护

缺点： 只用用户单用户、单任务的操作系统中；有内部碎片；存储器利用率极低。（分配给某进程的内存区域中，如果有些部分没有用上，就是 “内部碎片”）

二、固定分区分配

为了能在内存中装入多道程序，且这些程序间又不会互相影响，于是将整个 用户空间 划分为 若干个固定大小的分区，在 每个分区中只装入一道作业，这样就形成了最早最简单的一种可运行多道程序的内存管理方式。

分区大小相等：缺乏灵活性，但是很 适合用于用一台计算机控制多个相同对象的场合。

分区大小不等：增加了灵活性，可以满足不同大小的进程需求。根据常在系统中运行的作业大小情况进行划分。

操作系统需要建立一个数据结构–分区说明表，来实现各个分区的分配与回收。每个表对应一个分区，通常按分区大小排列。每个表项对应分区的 大小、起始地址、状态（是否已分配）

当某用户程序要装入内存时，由操作系统内核程序根据用户程序大小检索该表，从中找到一个能满足大小的、未分配的分区，将之分配给该程序，然后修改状态为 “已分配”。

优点：实现简单，无外部碎片。

缺点： 1. 当用户程序太大时，可能所有的分区都不能满足需求，此时不得不采用覆盖技术。 2. 会产生内部碎片，内存利用率低。

三、动态分区分配

动态分区分配 又称为 可变分区分配。这种分配方式 不会预先划分内存分区，而是在进程装入内存时，根据进程的大小动态的建立分区，并使分区大小正好适合进程的需要。

基本问题：

1. 系统要用什么样的数据结构记录内存的使用情况？
2. 当很多个空闲分区都能满足需求时，应该选择哪个分区进行分配？
3. 如何进行分区的分配与回收操作？

1.系统要用什么样的数据结构记录内存的使用情况？

2.当很多个空闲分区都能满足需求时，应该选择哪个分区进行分配？

3.如何进行分区的分配与回收操作？

假设系统采用的数据结构是 “空闲分区表”

如何分配？

情况一：

情况二：

如何回收？

情况一：

情况二：

情况三：

情况四：

动态分区分配 没有内部碎片，，但是 有外部碎片。

内部碎片，分配给某进程的内存区域中，如果有些部分没有用上。

外部碎片，是指内存中的某些空闲分区由于太小而难以利用。

如果内存中空闲空间的总和本来可以满足某进程的要求，但由于进程需要的是一整块连续的内存空间，因此这些 “碎片” 不能满足进程的需求。

可以通过 紧凑（拼凑） 技术来解决外部碎片。

总结

动态分区分配算法*

一、首次适应算法

算法思想： 每次都从低地址开始查找，找到第一个能满足大小的空闲分区。

如何实现：空闲分区以地址递增的次序排列。 每次分配内存时顺序查找 空闲分区链（或 空闲分区表），找到大小能满足要求的第一个空闲分区。

二、最佳适应算法

算法思想： 由于动态分区分配是一种连续分配方式，为各进程分配的空间必须是连续的一整片区域。因此为了保证当 “大进程” 到来时能有连续的大片空间，可以尽可能多的留下大片的空闲区，即，优先使用更小的空闲区。

如何实现： 空闲分区 按容量递增次序链接。每次分配内存时顺序查找 空闲分区链（或 空闲分区表），找到大小能满足要求的第一个空闲分区。

缺点：每次都选最小的分区进行分配，会留下越来越多的、很小的、难以利用的内存块。因此这种方法会产生很多的外部碎片。

三、最坏适应算法

又称 最大适应算法。

算法思想： 为了解决最佳适应算法的问题–即留下太多难以利用的小碎片，可以在每次分配时优先使用最大的连续空闲区，这样分配后剩余的空闲区就不会太小，更方便使用。

如何实现： 空闲分区 按容量递减次序链接。 每次分配内存时顺序查找 空闲分区链（或 空闲分区表），找到大小能满足要求的第一个空闲分区。

缺点：每次都选最大的分区进行分配，虽然可以让分配后留下的空闲区更大，更可用，但是这种分配方式会导致较大的连续空闲区被迅速用完。如果之后有 “大进程” 到达，就没有内存分区可用了。

四、邻近适应算法

算法思想： 首次适应算法每次都从链头开始查找。这可能会导致低地址部分出现很多小的空闲分区，而每次分配查找时，都要经过这些分区，因此也增加了查找的开销。如果每次都从上次查找结束的位置开始检索，就能解决上述问题。

如何实现： 空闲分区以地址递增的顺序排列（可排成一个循环链表）。每次分配内存时 从上次查找结束的位置开始 查找 空闲分区链（或 空闲分区表），找到大小能满足要求的第一个空闲分区。

总结

基本分页存储管理的基本概念

一、思考：连续分配方式的缺点

考虑支持多道程序的两种连续分配方式：

1. 固定分区分配：缺乏灵活性，会产生大量的内部碎片，内存的利用率很低。
2. 动态分区分配：会产生很多外部碎片，虽然可以用 “紧凑” 技术来处理，但是 “紧凑” 的时间代价很高。

基于这一思想，产生了 “非连续分配方式，或者称为 ”离散分配方式“。

连续分配：为用户进程分配的必须是一个 连续的内存空间。

非连续分配：为用户进程分配的可以是一些 分散的内存空间。

二、把 “固定分区分配” 改为 “非连续分配版本”

假设进程 A 大小为 23MB，但是每个分区大小只有 10MB，如果进程只能占用一个分区，那显然放不下。

解决思路：如果只允许进程占用多个分区，那么可以 把进程拆分成 10MB + 10MB +3MB 三个部分，再把这三个部分分别放到三个分区中（这些 分区不要求连续）

进程 A 的最后一个部分是 3MB，放入分区后会产生 7MB 的内部碎片。

如果每个分区大小为 2MB，那么进程 A 可以拆分为 11 * 2MB + 1MB 共 12 个部分。只有最后一部分 1MB 占不满分区，会产生 1MB 的内部碎片。

显然，如果把分区大小设置的更小一些，内部碎片会更小，内存利用率会更高。

基本分页存储管理的思想–把内存分为一个个相等的小分区，在按照分区大小把进程拆分成一个个小部分。

三、分页存储管理的基本概念

将内存空间分为一个个 大小相等的分区，每个分区就是一个 “页框”，或称 “页帧”、“内存块”、“物理块”。每个页框有一个编号，即 “页框号”，页框号 从 0 开始。

将用户进程的地址空间也分为 与页框大小相等 的一个个区域，称为 “页” 或 “页面”。每个页面也有一个编号，即 “页号”，页号也是 从 0 开始。（注：进程的最后一个页面可能没有一个页框那么大。因此 页框不能太大，否则可能产生过大的内部碎片）

操作系统 以页框为单位为各个进程分配 内存空间。进程的每个页面分别放入一个页框中。也就是说，进程的 页面 与内存的 页框 有 一一对应 的关系。

各个页面不必连续存放，也不必按先后顺序来，可以放到不相邻的各个页框中。

四、思考：如何实现地址的转换*

进程在内存中 连续存放时，操作系统是如何实现逻辑地址到物理地址的转换的：

如果采用 分页技术，应该如何实现地址转换？

逻辑地址为 80 的内存单元：

应该在 1 号页，该页在内存中的 起始位置为 450，逻辑地址为 80 的内存单元相对于该页的起始地址而言，“偏移量” 应该是 30。实际物理地址 = 450 + 30 = 480

1. 要算出逻辑地址对应的 页号
2. 要知道该页号对应 页面在内存中的起始地址
3. 要算出逻辑地址 在页面中的 “偏移量”
4. 物理地址 = 页面地址 + 页内偏移量

如何计算：

页号 = 逻辑地址 / 页面长度（取除法的 整数部分）

页内偏移量 = 逻辑地址 % 页面长度（取除法的 余数部分）

页面 在内存中的起始位置：操作系统需要用某种数据结构记录进程各个页面的起始位置

页号 = 80 / 50 = 1

页内偏移量 = 80 % 50 = 30

1 号页 在内存中 存放的 起始位置 450

为了方便计算页号、页内偏移量，页面大小 一般为 2 的整数幂

结论：如果每个页面大小为 2^k B，用二进制数表示逻辑地址，则末尾 K 即为 页内偏移量，其余部分就是 页号。

因此，如果 让每个页面的大小为 2 的整数幂，计算机就可以很方便的得出一个逻辑地址对应的页号和页内偏移量。

五、逻辑地址结构

分页存储管理的 逻辑地址结构 如下所示：

地址结构包含两个部分：前一部分为页号，后一部分为页内偏移量 W。在上图所示例子中，地址长度为 32 位，其中 0~11 位为 “页内偏移量”，或称 “页内地址”：12~31 位为 “页号”。

如果有 K 位表示 “页内偏移量”，则说明该系统中一个页面的大小是 2^K 个内存单元

如果有 M 位表示 “页号”，则说明在该系统中，一个进程最多允许有 2^M 个页面

分页存储管理中，如何实现地址转换？

1. 要算出逻辑地址对应的 页号
2. 要知道该页号对应 页面在内存中的起始地址
3. 要算出逻辑地址 在页面内的 “偏移量”
4. 物理地址 = 页面始址 + 页内偏移量

六、页表*

为了能知道进程的每个页面在内存中存放的位置，操作系统要 为每个进程建立一张页表

1. 一个进程对应一张页表
2. 进程的每一页对应一个页表项
3. 每个 页表项 由 “页号” 和 “块号” 组成
4. 页表记录 进程页面和实际存放的内存块之间的对应关系
5. 每个页表项的长度是相同的，页号是 “隐含” 的

为什么每个页表项的长度是相同的，页号是 “隐含” 的？

Eg：假设某系统物理内存大小为 4GB，页面大小为 4KB，则每个页表项至少应该为多少字节？

4GB = 2^32 B，4KB = 2^12 B

因此 4GB 的内存总共会被分为 2^32 / 2^12 = 2^20 个内存块，因此内存块号的范围为 0~2^20 -1，因此至少要 20 个二进制位才能表示那么多的内存块号，因此至少要 3 个字节。（每个字节 8 个二进制位，3 个字节共 24 个二进制位）

各页表项会 按顺序连续 存放在内存中，如果该页表在内存中存放的起始地址为 X，则 M 号对应的页表项一定是存放在内存地址为 X + 3*M。

因此，页表中的 “页号” 可以是 “隐含” 的。只需要知道 页表存放的起始地址 和 页表项长度，即可找到各个页号对应的页表项存放的位置。

在本例中，一个页表占 3B，如果进程由 n 个页面，则该进程的页表总共会占 3*n 个字节。

总结

基本地址变换机构

重点理解、记忆基本地址变换机构（用于实现逻辑地址到物理地址转换的一组硬件机构）的原理和流程

一、基本地址变换机构

基本地址变换机构可以借助进程的页表将逻辑地址转换为物理地址。

通常会在系统中设置一个 页表寄存器（PTR），存放 页表在内存中的起始地址 F 和 页表长度 M。进程未执行时，页表的始址和页表长度 放在进程控制块（PCB）中，当进程被调度时，操作系统内核会把它们放到页表寄存器中。

注意：页面大小是 2 的整数幂

设 页面大小为 L，逻辑地址 A 到 物理地址 E 的变换过程如下：

1. 计算页号 P 和 页内偏移量 W（如果用十进制数手算，则 页号 P = 逻辑地址 A / 页面大小 L，页内偏移量 W = 逻辑地址 A % 页面大小 L；但是在计算机实际运行时，逻辑地址结构是固定不变的，因此计算机硬件可以更快的得到二进制表示的页号、页内偏移量）
2. 比较 页号 P 和 页表长度 M，若 P ≥ M，则产生越界中断，否则继续执行。（注意：页号是从 0 开始的，而页表长度至少是 1，因此 P = M 时也会越界）
3. 页表中页号 P 对应的 页表项地址 = 页表起始地址 F + 页号 P * 页表项长度，取出该页表项内容 b，即为内存块号。（注意区分 页表项长度、页表长度、页面大小的区别。页表长度 指的是这个页表中总共有几个页表项，即总共有几个页；页表项长度 指的是每个页表项占多大的存储空间；页面大小 指的是一个页面占多大的存储空间）
4. 计算 物理地址 E = 内存块号 b * 页面大小 L + 页内偏移量 W，用得到的物理地址 E 去访存。（如果内存块号、页面偏移量是用二进制表示的，那么把二者拼接起来就是最终的物理地址了。

例：若页面大小 L 为 1K 字节，页号 2 对应的内存块号 b = 8，将逻辑地址 A = 2500 转换为物理地址 E。

等价描述：某系统 按字节寻址，逻辑地址结构中，页内偏移量占 10 位（说明一个页面的大小为 2^10 B = 1KB），页号 2 对应的内存块号 b = 8，将逻辑地址 A = 2500 转换为物理地址 E。

1. 计算页号、页内偏移量

   页号 P = 逻辑地址 A / 页面大小 L = 2500 / 1024 = 2；页内偏移量 W = 逻辑地址 A % 页面大小 L = 2500 % 1024 = 452

2. 根据题中条件可知，页号 2 没有越界，其存放的内存块号 b = 8
3. 物理地址 E = 内存块号 b * 页面大小 L + 页内偏移量 W = 8 * 1024 + 452 = 8644

在分页存储管理（页式管理）的系统中，只要确定了每个页面的大小，逻辑地址结构就确定了。因此，页式管理中地址是一维的。即，只要给出一个逻辑地址，系统就可以自动的算出页号、页内偏移量两个部分，并不需要显式的告诉系统这个逻辑地址中，页内偏移量占多少位。

二、对页表项大小的进一步探讨

每个页表项的长度是相同的，页号是 “隐含” 的？

Eg：假设某系统物理内存大小为 4GB，页面大小为 4KB，内存总共会被分为 2^32 / 2^12 = 2^20 个内存块，因此内存块号的范围应该是 0 ~ 2^20 -1

因此至少要 20 个二进制位才能表示这么多的内存块号，因此至少要 3 个字节才够（每个字节 8 个二进制位，3 个字节共 24 个二进制位）

各页表项会 按顺序连续的 存放在内存中，如果该页表在内存中存放的起始地址为 X，则 M 号页对应的页表项是存放在内存地址为 X + 3 * M。

一个页面为 4KB，则每个页框可以存放 4096 % 3 = 1365 个页表项，但是这个页框会剩余 4096 % 3 = 1B 页内碎片，因此，1365 号页表项存放的地址为 X + 3 * 1365 + 1，如果 每个页表项占 4 字节，则每个页框刚好可存放 1024 个页表项。

1024 号页表虽然是存放在下一个页框中的，但是它的地址依然可以用 X + 4 * 1024 得出。

结论： 理论上，页表项长度为 3B 即可表示内存块号的范围，但是，为了方便页表的查询，常常会让一个页表项占更多的字节，使得 每个页面恰好可以装的下整数个页表项

总结

具有快表的地址变换机构

是基本地址变换机构的改进版本

一、、局部性原理

int i =  0;

int a[100];

while (i < 100) {

  a[i] = i;

  i++;

}// 这个程序执行时，会很频繁的访问 10号、23号内存块

时间局部性： 如果执行了程序中的某条指令，那么不久后这条指令很有可能再次执行；如果某个数据被访问过，不久之后该数据很可能再次被访问。（因为程序中存在大量循环）

空间局部性： 一旦程序访问了某个存储单元，在不久之后，其附近的存储单元也很有可能被访问。（因为很多数据在内存中都是连续存放的）

在 基本地址变换机构 中，每次要访问一个逻辑地址，都需要 查询内存中的页表。由于局部性原理，可能连续很多次查到的都是同一个页表项。既然如此，能否利用这个特性减少访问页表的次数呢？

二、快表

快表，又称 联想寄存器（TLB），是一种 访问速度比内存块很多 的高速缓冲存储器，用来存放当前访问的若干页表项，以加速地址变换的过程。与此对应，内存中的页表常称为 慢表。

快表中存放的是页面的一部分副本。

三、引入快表后，地址的变换过程

1. CPU 给出逻辑地址，由某个硬件算得页号、页内偏移量，将页号与快表中的所有页号进行比较。
2. 如果找到匹配的页号，说明要访问的页表项在快表中有副本，则直接从中取出该页对应的内存块号，再将内存块号与页内偏移量拼接形成物理地址，最后，访问 该物理地址对应的 内存单元。因此，若 快表命中，则访问某个逻辑地址仅需 一次访存 即可。
3. 如果没有找到匹配的页号，则需要 访问内存中的页表，找到对应页表项，得到页面存放的内存块号，再将内存块号与页内偏移量拼接形成物理地址，最后，访问 该物理地址对应的 内存单元。因此，若 快表未命中，则访问某个逻辑地址需要 两次访存（注意：在找到页表项后，应同时将其存入快表，以便后面可能的再次访问。但若快表已满，则必须按照一定的算法对旧的页表项进行替换）

由于查询快表的速度比查询页表的速度快很多，因此只要快表命中，就可以节省很多时间。因为局部性原理，一般来说快表的命中率可以达到 90% 以上。

例：某系统使用基本分页存储管理，并采用了具有快表的变换机构。访问一次快表耗时 1us，访问一次内存耗时 100us。若快表的命中率为 90%，那么访问一个逻辑地址的平均耗时是多少？

(1+100) * 0.9 + (1+100+100) * 0.1 = 111 us

有的系统支持快表和慢表同时查找，如果是这样，平均耗时应该是(1+100) * 0.9 + (100+100) * 0.1 = 110.9 us

若未采用快表机制，则访问一个逻辑地址需要 100 + 100 = 200 us，显然，引入快表机制后，访问一个逻辑地址的速度变快了。

总结

两级页表

一、单级页表存在的问题

某计算机系统按字节寻址，支持 32 位的逻辑地址，采用分页存储管理，页面大小为 4KB，页表项长度为 4B。

4KB = 2^12 B，因此页内地址要用 12 位表示，剩余 20 位表示页号。

因此该系统中用户进程最多有 2^20 页。相应的，一个进程的页表中，最多会有 2^20 * 4B = 2^22 B，共需要 2^22 / 2^12 = 2^10 个页框存储该页表。（需要专门给进程配 2^10 = 1024 个连续的页框来存放它的页表）

根据页号查询页表的方法：K 号页对应的页表项存放位置 = 页表始址 + K * 4 要在 所有的页表项都连续存放 的基础上才能用这种方法找到页表项。

根据局部性原理可知，很多时候，进程在一段时间内只需要访问某几个页面就可以正常运行，因此 没有必要让整个页表都常驻内存。

二、如何解决单级页表的问题

问题一：页表必须连续存放，因此当页表很大时，需要占用很多个连续的页框。

问题二：没有必要让整个页表常驻内存，因为进程在一段时间内可能只需要访问某几个特定的页面。

思考：我们是如何解决进程在内存中必须连读存储的问题的？

将进程地址空间分页，并为其建立一张页表，记录各页面的存放位置。

同样的思路也可用于解决 “页表必须连续存放” 的问题，把必须连续存放的页表再分页。

可将长页表进行分组，使每个内存块刚好可以放入一个分组（比如页面大小 4KB，每个页表项 4B，每个页面可存放 1K 个页表项，因此每 1K 个连续的页表项为一组，每组刚好占一个内存块，再将各组离散的放到各个内存块中）

另外，要为离散分配的页表再建立一张页表，称为 页目录表，或称 外层页表，或称 顶层页表。

三、两级页表的原理、地址结构

32 位逻辑地址空间，页表项大小为 4B，页面大小为 4KB，则页内地址占 12 位。

四、如何实现地址变换

例：将逻辑地址（0000000000,0000000001，111111111111）转换为物理地址（用十进制表示）。

1. 按照地址结构将逻辑地址拆分为三部分
2. 从 PCB 中读出页目录表始址，再根据一级页号查页目录表，找到下一级页表在内存中的存放位置
3. 根据二级页号查表，找到最终想访问的内存块号
4. 结合页内偏移量得到物理地址

最终要访问的内存块号为 4，该内存块的起始地址为 4 * 4096 = 16384，页内偏移量为 1023

最终的物理地址为 16384 + 1023 = 17407

五、需要注意的几个细节

1. 若采用多级页表机制，则 各级页表的大小不能超过一个页面

   例：某系统按字节编址，采用 40 位逻辑地址，页面大小为 4KB，页表项大小为 4B，假设采用纯页式存储，则要采用（）级页表，页内偏移量为（）位？

   页面大小 = 4KB = 2^12 B，按字节编址，因此页内偏移量为 12 位

   页号 = 40 – 12 = 28 位

   页面大小 = 2^12 B，页表项大小 = 4B，则每个页面可存放 2^12 / 4 = 2^10 个页表项

   因此各级页表最多包含 2^10 个页表项，需要 10 个 二进制位才能映射到 2^10 个页表项，因此每一级的页表对应页号应为 10 位。总共 28 位的页号至少要分为三级

   

总结

基本分段存储管理方式

一、分段

进程的地址空间：按照程序 自身的逻辑 关系 划分为若干个段，每一个段都有一个段名（在低级语言中，程序员用段名来编程），每段从 0 开始编址。

内存分配规则：以段为单位进行分配，每个段在内存中占据连续空间，但 各段之间可以不相邻。

由于是按逻辑功能模块划分，用户 编程更方便，程序的可读性更高

分段系统的逻辑地址结构由段号（段名）和段内地址（段内偏移量）所组成。如：

段号的位数决定了每个进程最多可以分几个段

段内地址位数决定了每个段的最大长度是多少

在上述例子中，若系统是按字节寻址的，则

段号占 16 位，因此在该系统中，每个进程最多有 2^16 = 64K 个段

段内地址占 16 位，因此每个段的最大长度是 2^16 = 64 KB。

二、段表

问题：程序分多个段，各段离散的装入内存，为了保证程序能正常运行，就必须能从物理内存中找到各个逻辑段的存放位置。为此，需为每个进程建立一张段映射表，简称 “段表”。

1. 每个段对应一个段表项，其中记录了该段在内存中的 起始位置（又称 “基址”）和 段的长度。
2. 各个段表项的长度是相同的。例如：某系统按字节寻址，采用分段存储管理，逻辑地址结构为（段号 16 位，段内地址 16 位），因此用 16 位即可表示最大段长。物理内存大小为 4GB（可用 32 位表示整个物理内存地址空间）。因此，可以让每个段表项占 16 + 32 = 48 位，即 68.由于段表项长度相同，因此 段号可以是隐含的，不占存储空间。若段表存放的起始地址为 M，则 K 号段对应的段表项存放的地址为 M + K*6。

三、地址变换

LOAD 1, [D] | <A> ； // 将分段 D 中 A 单元内的值读入寄存器 1。

经过编译程序编译后，形成等价的机器指令；

“取出 段号为 2，段内地址为 1024 的内存单元中的内容，放到寄存器 1 中。”

CPU 执行指令时，需要将逻辑地址变换为物理地址：

（红色表示段号，黑色表示段内地址）

四、分段、分页管理对比

页 是 信息的物理单位。分页的主要目的是为了实现离散分配，提高内存利用率。分页仅仅是系统管理上的需要，完全是系统行为，对用户是不可见的。

段 是 信息的逻辑单位。分段的主要目的是更好的满足用户需求。一个段通常包含着一组属于一个逻辑模块的信息。分段对用户是可见的，用户编程时需要显示的给出段名。

页的大小固定且由系统决定。段的长度不固定，决定于用户编写的程序。

分页 的用户进程 地址空间是一维的，程序员只需给出一个记忆符即可表示一个地址。

分段 的用户进程 地址空间是二维的，程序员在标识一个地址时，即要给出段名，也要给出段内地址。

分段 比分页 更容易实现信息的共享和保护。

不能被修改的代码称为 纯代码 或 可重入代码（不属于临界资源），这样的代码是可以共享的。可修改的代码是不能共享的（比如，有一个代码段中有很多变量，各进程并发的同时访问可能造成数据不一致）

访问一个逻辑地址需要几次访存？

分页（单级页表）：第一次访存–查内存中的页表，第二次访存–访问目标内存单元。总共 两次访存

分段：第一次访存–查内存中的段表，第二次访存–访问目标内存单元。总共 两次访存

与分页系统类似，分段系统中也 可以引入 快表 机构，将近期访问过的段表项放到快表中，这样 可以少一次访问，加快地址变换速度。

总结

段页式管理方式

一、分页、分段的优缺点分析

二、分段 + 分页 = 段页式管理

将进程按逻辑模块分段，再将各段分页（如每个页面 4KB），再将内存空间分为大小相同的内存块 / 页框 / 页帧 / 物理块，进程前将各页面分别装入各内存块中。

三、段页式管理的逻辑地址结构

分段系统的逻辑地址结构 由段号和段内地址（段内偏移量）组成。如：

段页式系统的逻辑地址结构 由段号、页号、页内地址（页内偏移量）组成。如：

“分段” 对用户是可见的，程序员编程时需要显示的给出段号、段内地址。而将各段 “分页” 对用户是不可见的。系统会根据段内地址自动划分页号和页内偏移量。因此 段页式 管理的 地址结构是二维的。

段号的位数决定了每个进程最多可以分几个段

页号位数决定了每个段最大有多少页

页内偏移量决定了页面大小、内存块大小是多少

在上述例子中，若系统是按字节寻址的，则：

段号占 16 位，因此在该系统中，每个进程最多有 2^16 = 64K 个段

页号占 4 位，因此每个段中最多有 2^4 = 16 页

页内偏移量占 12 位，因此每个页面 / 每个内存块大小为 2^12 = 4096 = 4KB

四、段表、页表

每个段对应一个段表项、每个段表项由段号、页表长度、页表存放块号（页表起始地址） 组成。每个 段表项长度相等，段号是隐含的。

每个页面对应一个页表项，每个页表项由页号、页面存放的内存块号组成。每个页表项长度相等，页号是隐含的。

总结

虚拟内存的基本概念

一、传统存储管理方式的特征、缺点

一次性：作业必须一次性全部装入内存后才能开始运行。这会造成两个问题：

1. 作业很大时，不能全部装入内存，导致 大作业无法运行。
2. 当大量作业要求运行时，由于内存无法容纳所有作业，因此只有少量作业能运行，导致 多道程序并发度下降。

驻留性：一旦作业被装入内存，就 会一直驻留在内存中，直至作业运行结束。事实上，在一个时间段内，只需要访问作业的一小部分数据即可正常运行，这就导致了内存中会驻留大量的、暂时用不到的数据，浪费了宝贵的内存资源。

二、局部性原理

时间局部性： 如果执行了程序中的某条指令，那么不久后这条指令很有可能再次执行；如果某个数据被访问过，不久之后该数据很可能再次被访问。（因为程序中存在大量循环）

空间局部性： 一旦程序访问了某个存储单元，在不久之后，其附近的存储单元也很有可能被访问。（因为很多数据在内存中都是连续存放的）

如何应用局部性原理？

高速缓冲技术 的思想：将近期会频繁访问到的数据放到更高速的存储器中，暂时用不到的数据放在更低速存储器中。

快表机构就是将近期常访问的页表项副本放到更高速的联想寄存器中。

三、虚拟内存的定义和特征

基于局部性原理，在程序装入时，可以将程序中 很快会用到的部分装入内存，暂时用不到的部分留在外存，就可以让程序开始执行。

在程序执行过程中，当所访问的 信息不在内存时，由 操作系统负责将所需信息从外存调入内存，然后继续执行程序。

若内存空间不够，由 操作系统负责 将内存中 暂时用不到的信息换出到外存。

在操作系统的管理下，在用户看来似乎有一个比实际大得多的内存，这就是 虚拟内存。（操作系统虚拟性的一个体现）

易混知识点：

虚拟内存的 最大容量 是由计算机的地址结构（CPU 寻址范围）确定的

虚拟内存的 实际容量 = min（内存和外存之和，CPU寻址范围）

如：某计算机地址结构为 32 位，按字节编址，内存大小为 512MB，外存大小为 2GB。则虚拟内存的 最大容量 为 2^32 B = 4GB，虚拟内存的 实际容量 = min （2^32 B，512MB + 2GB） = 2GB + 512MB。

虚拟内存有以下三个主要特征：

多次性：无需在作业运行时一次性全部装入内存，而是允许被分成多次调入内存。

对换性：在作业运行时无需一直常驻内存，而是允许在作业运行过程中，将作业换入、换出。

虚拟性：从逻辑上扩充了内存的容量，是用户看到的内存容量，远大于实际的容量。

四、如何实现虚拟内存技术

虚拟内存技术，允许一个作业多次调入内存。如果采用连续分配方式，会不方便实现。因此，虚拟内存的实现需要建立在 离散分配 的内存管理方式基础上。

主要区别：

在程序执行过程中，当所 访问的信息不再内存时，由操作系统负责将所需信息从外存调入内存，然后继续执行程序。操作系统要体用请求调页（或请求调段）功能

若内存空间不够，由操作系统负责 将内存中暂时用不到的信息换出外存。（操作系统要提供页面置换（或段置换）的功能

总结

请求分页管理方式

一、页表机制

与基本分页管理相比，请求分页管理中，为了实现 “请求调页”，操作系统需要知道每个页面是否已经调入内存，如果还没调入，那么也需要知道该页面在外存中存放的位置。

当内存空间不够时，要实现 “页面置换”，操作系统需要通过某些指标来决定到底换出哪个页面；有的页面没有被修改过，就不用再浪费时间写会外存。有的页面修改过，就需要将外存中的旧数据覆盖，因此，操作系统也需要记录各个页面是否被修改的信息。

二、缺页中断机构

假设此时要访问逻辑地址 = （页号，页内偏移量） = （0，1024）

在请求分页系统中，每当要访问的 页面不在内存 时，便产生一个 缺页中断，然后由操作系统的缺页 中断处理程序处理中断。

此时 缺页的进程阻塞，放入阻塞队列，调页 完成后再将其唤醒，放回就绪队列。

如果内存中 有空闲块，则为进程 分配一个空闲块，将所却页面装入该块，并修改页表中相应的页表项。

如果内存中 没有空闲块，则 由页面置换算法选择一个页面淘汰，若该页面在内存期间 被修改过，则要将其 写回外存。未修改过的页面不用写回外存。

缺页中断 是因为当前执行的指令想要访问的目标页面未调入内存而产生的，因此 属于内中断。

一条指令 在执行期间，可能产生多次缺页中断。（如： copy A to B，即将逻辑地址 A 中的数据复制到逻辑地址 B，而 A、B 属于不同页面，则有可能产生两次中断）

三、地址变换机构

请求分页 存储管理与 基本分页 存储管理的主要区别：

在程序执行过程中，当所 访问的信息不在内存时，由操作系统负责将所需信息从外存调入内存，然后继续执行程序。

若内存空间不够，由操作系统负责 将内存中暂时用不到的信息换出到外存。

新增步骤：

1. 请求调页（查到页表项时进行判断）
2. 页面置换（需要调入页面，但没有空闲内存块时进行）
3. 需要修改请求页表中新增的表项

快表中有的页面一定是在内存中的，若某个页面被换出外存，则快表中的相应表项也要删除，否则可能会访问到错误的页面。

补充：

1. 只有 “写指令” 才需要修改 “修改位”。并且，一般来说只需要修改快表中的数据，只有要将快表项删除时才需要写回内存中的慢表。这样可以减少访存次数。
2. 和普通的中断处理一样，缺页中断处理依然需要保留 CPU 现场。
3. 需要用某种 “页面置换算法” 来决定一个换出页面
4. 换入 / 换出页面都需要启动慢速的 I / O 操作，可见，如果换入 / 换出太频繁，会有很大的开销。
5. 页面调入内存后，需要修改慢表，同时也需要将表项复制到快表中。在具有快表机构的请求分页系统中，访问一个逻辑地址时，若发生缺页，则地址变换步骤是：

   查快表（未命中） — 查慢表（发现未调入内存） — 调页（调入的页面对应的表项会直接加入快表） — 查快表（命中） — 访问目标内存单元

总结

页面置换算法

一、最佳置换算法（OPT）

最佳置换算法（OPT，Optimal）：每次选择 淘汰的页面 将是 以后永不使用，或者 在最长时间内不再被访问的页面，这样可以保证最低的缺页率。

例：假设系统为某进程分配了三个内存块，并考虑到有下一页面号引用串（会依次访问这些页面）：7,0,1,2,0,3,0,4,2,3,0,3,2,1,2,0,1,7,0,1

整个过程 缺页中断 发生了 9 次，页面置换 发生了 6 次。

注意，缺页时未必发生页面置换。若还有可用的空闲内存块，就不用进行页面置换。

缺页率 = 9 / 20 = 45%

最佳置换算法可以保证最低的缺页率，但实际上，只有在进程执行的过程中才能知道接下来会访问到的是哪个页面。操作系统无法提前预判页面访问序列。因此，最佳置换算法是无法实现的。

二、先进先出置换算法（FIFO）

先进先出置换算法（FIFO）：每次选择 淘汰的页面 是 最早进入内存的页面。

实现方法：把调入内存的页面根据调入的先后顺序排成一个队列，需要换出页面时选择队头页面即可。队列的最大长度取决于系统为进程分配了多少个内存块。

例：假设系统为某进程分配了 三个 内存块，考虑到有以下页面号引用串：3,2,1,0,3,2,4,3,2,1,0,4

假设系统为某进程分配了 四个 内存块

Belady 异常 — 当为进程分配的物理量块数增大时，缺页次数不减反增的异常现象。

只有 FIFO 算法会产生 Belady 异常。另外，FIFO 算法虽然 实现简单，但是该算法与进程实际运行时的规律不适应，因为先进入页面也有可能最经常被访问。因此，算法性能差。

三、最近最久未使用置换算法（LRU）

最近最久未使用置换算法（LRU，least recently used）：每次 淘汰的页面 是 最近最久未使用的页面，实现方法：赋予每个页面对应的页表项中，用 访问字段记录该页面自上次被访问以来所经历的时间 t。当需要淘汰一个页面时，选择现有页面中 t 值最大的，即最近最久未使用的页面。

例：假设系统为某系统分配了 四个 内存块，并考虑到有以下页面号引用串：1,8,1,7,8,2,7,2,1,8,3,8,2,1,3,7,1,3,7

在手动做题时，若需要淘汰页面，可以逆向检查此时在内存中的几个页面号，再 逆向扫描过程中最后一个出现的页号就是要淘汰的页面。

该算法的实现需要专门的硬件支持，虽然算法 性能好，但是 实现困难，开销大。

四、时钟置换算法（CLOCK）

时钟置换算法 是一种性能和开销较均衡的算法，又称 CLOCK 算法，或 最近未用算法（NRU，Not Recently Used）

简单的 CLOCK 算法 实现方法：为每个页面设置一个 访问位，再将内存中的页面都通过链接指针 链接成一个循环队列。当某页被访问时，其访问位置为 1。当需要淘汰一个页面时，只需检查页的访问位。如果是 0，就选择该页换出；如果是 1，则将它置为 0，暂不换出，继续检查下一页面，若第一轮扫描中所有页面都是 1，则将这些页面的访问位依次置为 0 后，再进行第二轮扫描（第二轮扫描中一定会有访问位为 0 的页面，因此 简单的 CLOCK 算法 选择一个淘汰页面 最多会经过两轮扫描）

例：假设系统为某进程分配了 五个 内存块，并考虑到有以下页面号引用串：1,3,4,2,5,6,3,4,7

五、改进型的时钟置换算法

简单的时钟置换算法 仅考虑到一个页面最近是否被访问过。事实上，如果被淘汰的页面没有被修改过，就不需要执行 I / O 操作写回外存。只有被淘汰的页面被修改过时，才需要写回外存。

因此，除了考虑一个页面最近有没有被访问过之外，操作系统还应考虑页面有没有被修改过。在其他条件都相同时，应优先考虑没有修改过的页面，避免 I / O 操作。这就是改进型的时钟置换算法的思想。

修改位 = 0，表示页面没有被修改过；修改位 = 1，表示页面被修改过。为方便讨论，用 （访问位，修改位） 的形式表示各页面状态。如（1,1）表示一个页面近期被访问过，且被修改过。

算法规则：将所有可能被置换的页面排成一个循环队列。

第一轮：从当前位置开始扫描到第一个（0,0）的帧用于替换。本轮扫描不修改任何标志位。（第一优先级：最近没访问且没修改的页面）

第二轮：若第一轮扫描失败，则重新扫描，查找第一个（0,1）的帧用于替换。本轮将所有扫描过的帧访问位设为 0。（第二优先级：最近没访问，但修改过的页面）

第三轮：若第二轮扫描失败，则重新扫描，查找第一个（0,0）的帧用于替换。本轮扫描不修改任何标志位。（第三优先级：最近访问过，但没修改的页面）

第四轮：若第三轮扫描失败，则重新扫描，查找第一个（0,1）的帧用于替换。（第四优先级：最近访问过，且修改过的页面）

由于第二轮已将所有帧的访问位设为 0，因此经过第三轮、第四轮扫描一定会有一个帧被选中，因此 改进型 CLOCK 置换算法 选择一个淘汰页面 最多会进行四轮扫描。

总结

页面分配策略

一、页面分配、置换策略

驻留集：指请求分页存储管理中给进程分配的物理块的集合。在采用了虚拟存储技术的系统中，驻留集大小一般小于进程的总大小。

• 考虑一个极端情况，若某进程共有 100 个页面，则该进程的驻留集大小为 100 时进程可以全部放入内存，运行期间不可能再发生缺页。若驻留集大小为 1，则进程运行期间必定会极频繁的缺页。

若驻留集太小，会导致缺页频繁，系统要花大量时间来处理缺页，实际用于进程推进的时间很少；驻留集太大，又会导致多道程序并发度下降，资源利用率降低。

固定分配：操作系统为每个进程分配一组固定书目的物理块，在进程运行期间不再改变。即，驻留集大小不变。

可变分配：先为每个进程分配一定数目的物理块，在进程运行期间，可根据情况做适当的增加或减少。即，驻留集大小可变。

局部置换：发生缺页时只能选进程自己的物理块进行置换。

全局置换：可以将操作系统保留的空闲物理块分配给缺页进程，也可以将别的进程持有的物理块置换到外存，再分配给缺页进程。

固定分配局部置换：系统为每个进程分配一定数量的物理块，在整个运行期间都不改变。若进程在运行中发生缺页，则只能从该进程在内存中的页面中选出一页换出，然后再调入需要的页面。这种策略的缺点是：很难在刚开始就确定应为每个进程分配多少个物理块才算合理。（采用这种策略的系统可以根据进程大小、优先级、或是根据程序员给出的参数来确定为一个进程分配的内存块数）

可变分配全局置换：刚开始会为每个进程分配一定数量的物理块。操作系统会保持一个空闲物理块队列。当某进程发生缺页时，从空闲物理块中取出一块分配给该进程；若已无空闲物理块，则可选择一个 未锁定 （系统会锁定一些页面，这些页面中的内存不能置换出外存，如重要的内核数据可以设为 “锁定”）的页面换出外存，再将该物理块分配给缺页的进程。采用这种策略时，只要某进程发生缺页，都将获得新的物理块，仅当空闲物理块用完时，系统才选择一个未锁定的页面调出。被选择调出的页可能是系统中任何一个进程中的页，因此这个 被选中的进程拥有的物理块会减少，缺页率会增加。

可变分配局部置换：刚开始会为每个进程分配一定数量的物理块。当某进程发生缺页时，只允许从该进程自己的物理块中选出一个进程换出外存。如果进程在运行中频繁的缺页，系统会为该进程多分配几个物理块，直至该进程缺页率趋势适当程度；反之，如果进程在运行中缺页率特别低，则可适当减少分配给该进程的物理块。

可变分配 全局 置换：只要缺页就分配新物理块。

可变分配 局部 置换：要根据发生 缺页的频率 来动态的增加或减少进程的物理块

二、何时调入页面

1. 预调页策略：根据局部性原理（主要指空间局部性，即，如果当前访问了某个内存单元，在之后很有可能会接着访问与其相邻的那些内存单元），一次调入若干个相邻的页面可能比一次调入一个页面更高效。但如果提前调入的页面中大多数都没被访问过，则又是低效的。因此可以预测不久之后可能访问到的页面，将他们预先调入内存，但目前预测成功率只有 50% 左右。故这种策略 主要用于进程的首次调入（运行前调入），由程序员指出应该先调入哪些部分。
2. 请求调页策略：进程在 运行期间发现缺页时才将所缺页面调入内存。由这种策略调入的页面一定会被访问到，但由于每次只能调入一页，而每次调页都要磁盘 I / O，操作，因此 I / O 开销较大。

三、从何处调页面

1. 系统拥有足够的对换区空间：页面的调入、调出都是在内存与对换区之间进行，这样可以保证页面的调入、调出速度很快。在进程运行前，需将进程相关的数据从文件区复制到对换区。

   

    

2. 系统缺少足够的对换区空间：凡是不会被修改的数据都直接从文件区调入，由于这些页面不会被修改，因此换出时不必写回磁盘，下次需要时再从文件区调入即可。对于这些可能被修改的部分，换出时需写回磁盘对换区，下次需要时再从对换区调入。

   

    

3. UNIX 方式：运行之前进程有关的数据全部放在文件区，故未使用过的页面，都可从文件区调入。若被使用过的页面需要换出，则写回对换区，下次需要时从对换区调入。

四、抖动（颠簸）现象

刚刚换出的页面马上又要换入内存，刚刚换入的页面马上又要换出外存，这种频繁的页面调度行为称为 抖动 或 颠簸。产生抖动的 主要原因 是进程频繁访问的页面数目高于可用的物理块数（分配给进程的物理块不够）

五、工作集

驻留集：指请求分页存储管理中给进程分配的内存块的集合。

工作集：指在某段时间间隔里，进程实际访问页面的集合。

操作系统会根据 “窗口尺寸” 来算出工作集。

例：某进程的页面访问序列如下，窗口尺寸为 4，各时刻工作集为？

工作集大小 可能小于窗口尺寸，实际应用中，操作系统可以统计进程的工作集大小，根据工作集大小给进程分配若干内存块。如：窗口尺寸为 5，经过一段时间的监测发现某进程的工作集最大为 3，那么说明该进程有很好的局部性，可以给这个进程分配 3 个以上的内存块即可满足进程的运行需要。一般来说，驻留集大小不能小于工作集大小，否则进程运行过程中将频繁缺页。

总结