页式存储管理： 最佳置换(OPT)--先进先出页面置换(FIFO)--最久未使用置换(LRU)

页式存储管理： 最佳置换--先进先出页面置换--最久未使用置换

1.背景

进程运行时，若其访问的页面不在内存而需将其调入，但内存已无空闲空间时，就需要从内存中调出一页程序或数据，送入磁盘的对换区。

选择调出页面的算法就称为页面置换算法。好的页面置换算法应有较低的页面更换频率，也就是说，应将以后不会再访问或者以后较长时间内不会再访问的页面先调出。

2.置换策略理论

1. 最佳置换算法(OPT)
最佳(Optimal, OPT)置换算法所选择的被淘汰页面将是以后永不使用的，或者是在最长时间内不再被访问的页面,这样可以保证获得最低的缺页率。但由于人们目前无法预知进程在内存下的若千页面中哪个是未来最长时间内不再被访问的，因而该算法无法实现。

2. 先进先出(FIFO)页面置换算法

优先淘汰最早进入内存的页面，亦即在内存中驻留时间最久的页面。该算法实现简单，只需把调入内存的页面根据先后次序链接成队列，设置一个指针总指向最早的页面。但该算法与进程实际运行时的规律不适应，因为在进程中，有的页面经常被访问。

3. 最近最久未使用(LRU)置换算法
选择最近最长时间未访问过的页面予以淘汰，它认为过去一段时间内未访问过的页面，在最近的将来可能也不会被访问。该算法为每个页面设置一个访问字段，来记录页面自上次被访问以来所经历的时间，淘汰页面时选择现有页面中值最大的予以淘汰。

3.策论比较

1. FIFO，Optimal，LRU这三种置换算法的优劣？
•优点：

    ① FIFO页面置换算法实现简单，要求的硬件支持较少。

    ② Optimal页面置换算法可保证获得最低的缺页率，并且可以用来评价其他算法。

    ③ LRU页面置换算法利用“最近的过去”代替“最近的将来”，以此模拟Optimal算法，是实际应用中缺页率最低的算法。

•缺点：

    ① FIFO算法所依据的条件是各个页面调入内存的时间，而页面调入内存的先后并不能反映页面的使用情况。

    ② Optimal算法是理论上的算法，目前该算法是无法实现的。

    ③LRU算法是根据各页以前的使用情况，来代替各页面将来的使用情况，进而判断要替换出去的页面，而页面过去和将来的         走向之间并无必然的联系；其实际应用时要求较多的硬件支持，因而多采用近似算法。

2. 在什么情况下采用哪种置换算法更有利？
    •FIFO算法在按线性顺序访问地址空间时使用；当硬件水平不足时，FIFO算法也可作为首选。
    •OPT算法可以进行模拟实验分析或理论分析。
    •当系统有寄存器或栈的硬件支持时，利用LRU算法可以获得最低缺页率。

----------------------------------------------------------------------------------------------------------------------------------

例：假定系统为某进程分配了三个物理块，并考虑有以下页面号引用串：  7, 0, 1, 2, 0, 3, 0, 4, 2, 3, 0, 3, 2, 1, 2, 0, 1, 7, 0, 1

1. 最佳置换算法(OPT)

进程运行时，先将7, 0, 1三个页面依次装入内存。进程要访问页面2时，产生缺页中断，根据最佳置换算法，选择第18次访问才需调入的页面7予以淘汰。然后，访问页面0时，因为已在内存中所以不必产生缺页中断。访问页面3时又会根据最佳置换算法将页面1淘汰……依此类推，如图3-26所示。从图中可以看出釆用最佳置换算法时的情况。

可以看到，发生缺页中断的次数为9，页面置换的次数为6。

访问页面	7	0	1	2	0	3	0	4	2	3	0	3	2	1	2	0	1	7	0	1
物理块1	7	7	7	2		2		2			2			2				7
物理块2		0	0	0		0		4			0			0				0
物理块3			1	1		3		3			3			1				1
缺页否	√		√	√		√		√			√			√				√

图3-26  利用最佳置换算法时的置换图

2. 先进先出(FIFO)页面置换算法

优先淘汰最早进入内存的页面，亦即在内存中驻留时间最久的页面。该算法实现简单，只需把调入内存的页面根据先后次序链接成队列，设置一个指针总指向最早的页面。但该算法与进程实际运行时的规律不适应，因为在进程中，有的页面经常被访问。

访问页面	7	0	1	2	0	3	0	4	2	3	0	3	2	1	2	0	1	7	0	1
物理块1	7	7	7	2		2	2	4	4	4	0			0	0			7	7	7
物理块2		0	0	0		3	3	3	2	2	2			1	1			1	0	0
物理块3			1	1		1	0	0	0	3	3			3	2			2	2	1
缺页否	√	√	√	√		√	√	√	√	√	√			√	√			√	√	√

图3-27  利用FIFO置换算法时的置换图

这里仍用上面的实例，釆用FIFO算法进行页面置换。进程访问页面2时，把最早进入内存的页面7换出。然后访问页面3时，再把2, 0, 1中最先进入内存的页换出。由图 3-27可以看出，利用FIFO算法时进行了 12次页面置换，比最佳置换算法正好多一倍。

FIFO算法还会产生当所分配的物理块数增大而页故障数不减反增的异常现象，这是由 Belady于1969年发现，故称为Belady异常，如图3-28所示。只有FIFO算法可能出现Belady 异常，而LRU和OPT算法永远不会出现Belady异常。

访问页面	1	2	3	4	1	2	5	1	2	3	4	5
物理块1	1	1	1	4	4	4	5			,5'	5
物理块2		2	2	2	1	1	1			3	3
物理块3			3	3	3	2	2			2	4
缺页否	√	√	√	√	√	√	√			√	√
		1	1	1			5	5	5	5	4	4
物理块2*		2	2	2			2	1	1	1	1	5
物理块3*			3	3			3	3	2	2	2	2
物理块4*				4			4	4	4	3	3	3
缺页否	√	√	√				√	√	√	√	√	√

图 3-28   Belady 异常

3. 最近最久未使用(LRU)置换算法

对上面的实例釆用LRU算法进行页面置换，如图3-29所示。进程第一次对页面2访问时，将最近最久未被访问的页面7置换出去。然后访问页面3时，将最近最久未使用的页面1换出。

访问页面	7	0	1	2	0	3	0	4	2	3	0	3	2	1	2	0	1	7	0	1
物理块1	7	7	7	2		2		4	4	4	0			1		1		1
物理块2		0	0	0		0		0	0	3	3			3		0		0
物理块3			1	1		3		3	2	2	2			2		2		7
缺页否	√	√	√	√		√		√	√	√	√			√		√		√

图3-29  LRU页面置换算法时的置换图

在图3-29中，前5次置换的情况与最佳置换算法相同，但两种算法并无必然联系。实际上，LRU算法根据各页以前的情况，是“向前看”的，而最佳置换算法则根据各页以后的使用情况，是“向后看”的。

LRU性能较好，但需要寄存器和栈的硬件支持。LRU是堆栈类的算法。理论上可以证明，堆栈类算法不可能出现Belady异常。FIFO算法基于队列实现，不是堆栈类算法。

-----------------------------------------------------------------------------------------------------------------

4.实例

1. 通过随机数产生一个指令序列，共 320 条指令。其地址按下述原则生成：
 （1）50%的指令是顺序执行的；
 （2）50%的指令是均匀分布在前地址部分；
 （3）50%的指令是均匀分布在后地址部分；
具体的实施方法是：
  A. 在[0，319]的指令地址之间随机选取一起点 M；
  B. 顺序执行一条指令，即执行地址为 M+1 的指令；
  C. 在前地址[0，M+1]中随机选取一条指令并执行，该指令的地址为 M’；
  D. 顺序执行一条指令，其地址为 M’+1；
  E. 在后地址[M’+2，319]中随机选取一条指令并执行；
  F. 重复A—E，直到执行 320 次指令。

2. 指令序列变换成页地址流 设 ：
 （1）页面大小为1K；
 （2） 用户内存容量为 4 页到 32 页；
 （3）用户虚存容量为 32K。
  在用户虚存中，按每页存放10 条指令排列虚存地址，即 320 条指令在虚存中的存放方式为：
  第0条—第9条指令为第0页（对应虚存地址为[0，9]） ；
  第10条—第19条指令为第1页（对应虚存地址为[10,19]） ；
  ……………………
  第310条—第319条指令为第31页（对应虚存地址为[310，319]） ；按以上方式，用户指令可组成 32 页。

3. 计算并输出下述各种算法在不同内存容量下的命中率。
  A. 先进先出（FIFO）页面置换算法
  B. 最近最久未使用（LRU）页面置换算法--最近最少使用算法
  C. 最佳（Optimal）页面置换算法

5.代码

#include
#include
#include
#include
#include
#include
using namespace std;
#define max 0x3f3f3f3f

int size;
double ratio;

struct Order
{
    int id;       //序列号
    int numpage;  //属于页面号
};
Order order[320]; 

struct Page
{
    int num;
    bool in;      //是否在内存中
    int time;     //时间
};
Page page[32];

void init0()
{
    int first;
    srand((unsigned)time(NULL));  //随机种子
    for(int i=0;i<320;i+=6)
    {
        first=(int)(319.0*rand()/RAND_MAX)+1;
        order[i].id=first;              //任选一指令节点
        order[i+1].id=order[i].id+1;    //顺序访问下一条指令
        order[i+2].id=(int)(1.0*order[i].id*rand()/RAND_MAX); //前地址指令
        order[i+3].id=order[i+2].id+1;    //顺序访问下一条指令
        order[i+4].id=(int)(1.0*rand()*(318-order[i+2].id)/RAND_MAX)+order[i+2].id+2;   //后地址指令
        order[i+5].id=order[i+4].id+1;  //顺序访问下一条指令 
    }
}

void init()
{
    for(int i=0;i<320;i++)
    {
        order[i].numpage=order[i].id/10;
      //  cout< "<min)
                    {
                        kk=k;
                        min=page[k].time;
                    }
                }
                page[kk].in=0; 
           //   cout<<"退出 "<>size;
            if(size>=4&&size<=32) break;
            else cout<<"请正确输入内存容量！"<

6.运行结果

End