缺页中断——FIFO、LRU、OPT这三种置换算法

1. 缺页中断

　　在请求分页系统中，可以通过查询页表中的状态位来确定所要访问的页面是否存在于内存中。每当所要访问的页面不在内存时，会产生一次缺页中断，此时操作系统会根据页表中的外存地址在外存中找到所缺的一页，将其调入内存。 

　　缺页本身是一种中断，与一般的中断一样，需要经过4个处理步骤： 

　　1. 保护CPU现场 

　　2. 分析中断原因 

　　3. 转入缺页中断处理程序进行处理 

　　4. 恢复CPU现场，继续执行 

　　但是缺页中断时由于所要访问的页面不存在与内存时，有硬件所产生的一种特殊的中断，因此，与一般的中断存在区别： 

　　 1. 在指令执行期间产生和处理缺页中断信号 

　　 2. 一条指令在执行期间，可能产生多次缺页中断 

　　 3. 缺页中断返回时，执行产生中断的那一条指令，而一般的中断返回时，执行下一条指令

2. 页面置换算法

　　进程运行过程中，如果发生缺页中断，而此时内存中有没有空闲的物理块是，为了能够把所缺的页面装入内存，系统必须从内存中选择一页调出到磁盘的对换区。但此时应该把那个页面换出，则需要根据一定的页面置换算法（Page
Replacement Algorithm)来确定。

2.1 最佳置换（Optimal， OPT)

2.1.1 基本思想

　　置换以后不再被访问，或者在将来最迟才回被访问的页面，缺页中断率最低。但是该算法需要依据以后各业的使用情况，而当一个进程还未运行完成是，很难估计哪一个页面是以后不再使用或在最长时间以后才会用到的页面。所以该算法是不能实现的。但该算法仍然有意义，作为很亮其他算法优劣的一个标准。

2.1.2 算例

　　采用固定分配局部置换的策略，嘉定系统为某进程在内存中分配了3个物理块，页面访问顺序为2、3、2、1、5、2、4、5、3、2、5、2。假定系统未采用预调页策略，即未事先调入任何页面。进程运行时，一次将2、3、1三个页面调入内存，发生3次缺页中断。当第一次访问页面5时，产生第4次缺页中断，根据OPT算法，淘汰页面1，因为它在以后不会在使用了；第5次缺页中断时，淘汰页面2，因为它在5、3、2三个页面中，是在将来最迟才会被页面访问的页面。以此类推： 

　　注意：第4次中断时将最后不会访问的1剔除，将最后才访问的3放入最下面的内存块中，以后的调度过程中，最后不会访问或最后才被访问的页面总是放在最下面的内存块中。内存块从上到下依次存放最先访问的页面。 

　　中断次数为6，缺页中断率为6/12*100% = 50%。

P:	2	3	2	1	5	2	4	5	3	2	5	2
M=3	2	2	2	2	2	5	5	3	5	5	2	2
		3	3	3	5	3	3	5	4	2	5	5
				1	3	2	4	4	3	4	4	4
F=5	Y	Y		Y	Y		Y			Y

2.2 先进先出置换算法（First In First Out, FIFO)

2.2.1 基本思想

　　置换最先调入内存的页面，即置换在内存中驻留时间最久的页面。按照进入内存的先后次序排列成队列，从队尾进入，从队首删除。但是该算法会淘汰经常访问的页面，不适应进程实际运行的规律，目前已经很少使用。

2.2.2 算例

　　仍然以OPT算例为例子。 

　　中断次数为6，缺页中断率为9/12*100% = 75%。

P:	2	3	2	1	5	2	4	5	3	2	5	2
M=3	2	3	3	1	5	2	4	4	3	3	5	2
		2	2	3	1	5	2	2	4	4	3	5
				2	3	1	5	5	2	2	4	3
F=9	Y	Y		Y	Y	Y	Y		Y			Y

2.2.3 Belady异常

　　一般来说，分配给进程的物理块越多，运行时的缺页次数应该越少，使用FIFO时，可能存在相反情况，分配4个物理块的缺页竟然比3个物理块的缺页次数还多！ 

　　例如：进程访问顺序为0、2、1、3、0、2、4、0、2、1、3、4。 

　　M=3时，缺页中断9次。缺页中断率9/12*100% = 75%。

P:	0	2	1	3	0	2	4	0	2	1	3	4
M=3	0	2	1	3	0	2	4	4	4	1	3	3
		0	2	1	3	0	2	2	2	4	1	1
			0	2	1	3	0	0	0	2	4	4
F=9	Y	Y	Y	Y	Y	Y	Y			Y	Y

　　Ｍ=4时，缺页中断10次。缺页中断率10/12*100% = 83.3%。

P:	0	2	1	3	0	2	4	0	2	1	3	4
M=4	0	2	1	3	3	3	4	0	2	1	3	4
		0	2	1	1	1	3	4	0	2	1	3
			0	2	2	2	1	3	4	0	2	1
				0	0	0	2	1	3	4	0	2
F=10	Y	Y	Y	Y			Y	Y	Y	Y	Y	Y

2.3 最近最久未使用置换算法（Least Recently Used， LRU）

2.3.1 基本思想

　　置换最近一段时间以来最长时间未访问过的页面。根据程序局部性原理，刚被访问的页面，可能马上又要被访问；而较长时间内没有被访问的页面，可能最近不会被访问。 

　　LRU算法普偏地适用于各种类型的程序，但是系统要时时刻刻对各页的访问历史情况加以记录和更新，开销太大，因此LRU算法必须要有硬件的支持。

2.3.2 算例

　　仍然以OPT算例为例子。 

　　中断次数为6，缺页中断率为7/12*100% = 58.3%。

P:	2	3	2	1	5	2	4	5	3	2	5	2
M=3	2	3	2	1	5	2	4	5	3	2	5	2
		2	3	2	1	5	2	4	5	3	2	5
				3	2	1	5	2	4	5	3	3
F=7	Y	Y		Y	Y		Y		Y	Y

　　堆栈实现LRU： 

　　系统使用特殊的堆栈来存放内存中每一个页面的页号。每当访问一页时就调整一次，即把被访问页面的页号从栈中移出再压入栈顶。因此，栈顶始终是最新被访问页面的页号，栈底始终是最近最久未被访问的页号。当发生缺页中断时，总是淘汰栈底页号所对应的页面。 

　　

考虑下述页面走向：

          1，2，3，4，2，1，5，6，2，1，2，3，7，6，3，2，1，2，3，6

     当内存块数量分别为3时，试问FIFO、LRU、OPT这三种置换算法的缺页次数各是多少?

   答：缺页定义为所有内存块最初都是空的，所以第一次用到的页面都产生一次缺页。

       当内存块数量为3时：



发生缺页中断的次数为16。

　　在FIFO算法中，先进入内存的页面被先换出。当页6要调入时，内存的状态为4、1、5，考查页6之前调入的页面，分别为5、1、2、4，可见4为最先进入内存的，本次应换出，然后把页6调入内存。



发生缺页中断的次数为15。

LRU是Least Recently Used的缩写，即最近最少使用页面置换算法，是为虚拟页式存储管理服务的。该算法的初衷是有内存管理而被提出来的，其目的是为解决“如何节省利用容量不大的内存为最多的进程提供资源”时如何减少过多的让进程去读取外存。 
   这里以链表法来实现LRU: 
   一点介绍 
   操作系统为每个进程维护一条链表，链表的每个结点记录一张页面的地址。调用一次页面，则把该页面的结点从链中取出，放到链尾；要装入新页，则把链头的页面调出，同时生成调入页面的结点，放到链尾。 

　　在LRU算法中，最近最少使用的页面被先换出。当页6要调入时，内存的状态为5、2、1，考查页6之前调入的页面，分别为5、1、2，可见2为最近一段时间内使用最少的，本次应换出，然后把页6调入内存。



发生缺页中断的次数为11。

　　　　在OPT算法中，在最远的将来才被访问的页面被先换出。当页6要调入时，内存的状态为1、2、5，考查页6后面要调入的页面，分别为2、1、2、…，可见5为最近一段时间内使用最少的，本次应换出，然后把页6调入内存。

最不经常使用(Least Frequently Used --LFU) 页置换算法，要求在页置换时置换引用计数最小的页，因为经常使用的页应该有一个较大的引用次数。但是有些页在开始时使用次数很多，但以后就不再使用，这类页将会长时间留在内存中，因此可以将引用计数寄存器定时右移一位，形成指数衰减的平均使用次数。

注意LFU与LRU的区别，LFU一定是使用次数最少并且最近的被淘汰，而LRU被淘汰的是离上一次使用时间最长的。。

OPT算法因为要知道后面请求的页框，因此我觉得这个算法有个小小的bug,如果在某个请求中，若在该请求的页框之后的页框序列中至少存在一个和当前内存块中不匹配的页框，则按照内存块的顺序（从上往下）替换没有出现的页框。比如上面那个OPT例子。对于最后一个页框请求，因为6未命中，且6之后没有请求的序列，因此应该替换3，所以替换后的序列为6
， 2 ，1   当然，这只是针对做题而言。