页面置换算法

在地址映射过程中，若在页面中发现所要访问的页面不在内存中，则产生缺页中断。当发生缺页中断时，如果操作系统内存中没有空闲页面，则操作系统必须在内存选择一个页面将其移出内存，以便为即将调入的页面让出空间。而用来选择淘汰哪一页的规则叫做页面置换算法。

常见的置换算法

最佳置换算法（OPT）

这是一种理想情况下的页面置换算法，但实际上是不可能实现的。该算法的基本思想是：发生缺页时，有些页面在内存中，其中有一页将很快被访问（也包含紧接着的下一条指令的那页），而其他页面则可能要到10、100或者1000条指令后才会被访问，每个页面都可以用在该页面首次被访问前所要执行的指令数进行标记。最佳页面置换算法只是简单地规定：标记最大的页应该被置换。这个算法唯一的一个问题就是它无法实现。当缺页发生时，操作系统无法知道各个页面下一次是在什么时候被访问。虽然这个算法不可能实现，但是最佳页面置换算法可以用于对可实现算法的性能进行衡量比较。

先进先出置换算法（FIFO）

最简单的页面置换算法是先入先出（FIFO）法。这种算法的实质是，总是选择在主存中停留时间最长（即最老）的一页置换，即先进入内存的页，先退出内存。理由是：最早调入内存的页，其不再被使用的可能性比刚调入内存的可能性大。建立一个FIFO队列，收容所有在内存中的页。被置换页面总是在队列头上进行。当一个页面被放入内存时，就把它插在队尾上。

这种算法只是在按线性顺序访问地址空间时才是理想的，否则效率不高。因为那些常被访问的页，往往在主存中也停留得最久，结果它们因变“老”而不得不被置换出去。

FIFO的另一个缺点是，它有一种异常现象，即在增加存储块的情况下，反而使缺页中断率增加了。当然，导致这种异常现象的页面走向实际上是很少见的。

最近最久未使用（LRU）算法

FIFO算法和OPT算法之间的主要差别是，FIFO算法利用页面进入内存后的时间长短作为置换依据，而OPT算法的依据是将来使用页面的时间。如果以最近的过去作为不久将来的近似，那么就可以把过去最长一段时间里不曾被使用的页面置换掉。它的实质是，当需要置换一页时，选择在之前一段时间里最久没有使用过的页面予以置换。这种算法就称为最久未使用算法（Least Recently Used，LRU）。

LRU算法是与每个页面最后使用的时间有关的。当必须置换一个页面时，LRU算法选择过去一段时间里最久未被使用的页面。

LRU算法是经常采用的页面置换算法，并被认为是相当好的，但是存在如何实现它的问题。LRU算法需要实际硬件的支持。其问题是怎么确定最后使用时间的顺序，对此有两种可行的办法：

1.计数器。最简单的情况是使每个页表项对应一个使用时间字段，并给CPU增加一个逻辑时钟或计数器。每次存储访问，该时钟都加1。每当访问一个页面时，时钟寄存器的内容就被复制到相应页表项的使用时间字段中。这样我们就可以始终保留着每个页面最后访问的“时间”。在置换页面时，选择该时间值最小的页面。这样做，不仅要查页表，而且当页表改变时（因CPU调度）要维护这个页表中的时间，还要考虑到时钟值溢出的问题。

2.栈。用一个栈保留页号。每当访问一个页面时，就把它从栈中取出放在栈顶上。这样一来，栈顶总是放有目前使用最多的页，而栈底放着目前最少使用的页。由于要从栈的中间移走一项，所以要用具有头尾指针的双向链连起来。在最坏的情况下，移走一页并把它放在栈顶上需要改动6个指针。每次修改都要有开销，但需要置换哪个页面却可直接得到，用不着查找，因为尾指针指向栈底，其中有被置换页。

因实现LRU算法必须有大量硬件支持，还需要一定的软件开销。所以实际实现的都是一种简单有效的LRU近似算法。

一种LRU近似算法是最近未使用算法（Not Recently Used，NRU）。它在存储分块表的每一表项中增加一个引用位，操作系统定期地将它们置为0。当某一页被访问时，由硬件将该位置1。过一段时间后，通过检查这些位可以确定哪些页使用过，哪些页自上次置0后还未使用过。就可把该位是0的页淘汰出去，因为在之前最近一段时间里它未被访问过。

Clock置换算法

采用Clock算法时,只需为每个页面设置一位访问位，再将内存中的所有页面都通过链接指针链接成一个循环队列。当某页被访问时,就将其访问位被置为1。置换算法在选择一页淘汰时，只检查页的访问位。如果改位是0,就选择该页换出;如果是1,则重新将它置0,暂不换出，而给该页第二次驻留内存的机会,再按照FIFO算法检查下一个页面。当检查到队列中的最后一个页面时，若其访问位仍为1,则再返回到队首去检查第一个页面。由于该算法是循环地检查各页面的使用情况,故称为Clock算法。

最少使用（LFU）置换算法

在采用最少使用置换算法时，应为在内存中的每个页面设置一个移位寄存器，用来记录该页面被访问的频率。该置换算法选择在之前时期使用最少的页面作为淘汰页。由于存储器具有较高的访问速度，例如100 ns，在1 ms时间内可能对某页面连续访问成千上万次，因此，通常不能直接利用计数器来记录某页被访问的次数，而是采用移位寄存器方式。每次访问某页时，便将该移位寄存器的最高位置1，再每隔一定时间(例如100 ns)右移一次。这样，在最近一段时间使用最少的页面将是∑Ri最小的页。

LFU置换算法的页面访问图与LRU置换算法的访问图完全相同；或者说，利用这样一套硬件既可实现LRU算法，又可实现LFU算法。应该指出，LFU算法并不能真正反映出页面的使用情况，因为在每一时间间隔内，只是用寄存器的一位来记录页的使用情况，因此，访问一次和访问10 000次是等效的。

6）工作集算法

7）工作集时钟算法

8）老化算法（非常类似LRU的有效算法）

9）NRU(最近未使用）算法

10）第二次机会算法

第二次机会算法的基本思想是与FIFO相同的，但是有所改进，避免把经常使用的页面置换出去。当选择置换页面时，检查它的访问位。如果是0，就淘汰这页；如果访问位是1，就给它第二次机会，并选择下一个FIFO页面。当一个页面得到第二次机会时，它的访问位就清为0，它的到达时间就置为当前时间。如果该页在此期间被访问过，则访问位置1。这样给了第二次机会的页面将不被淘汰，直至所有其他页面被淘汰过（或者也给了第二次机会）。因此，如果一个页面经常使用，它的访问位总保持为1，它就从来不会被淘汰出去。

第二次机会算法可视为一个环形队列。用一个指针指示哪一页是下面要淘汰的。当需要一个存储块时，指针就前进，直至找到访问位是0的页。随着指针的前进，把访问位就清为0。在最坏的情况下，所有的访问位都是1，指针要通过整个队列一周，每个页都给第二次机会。这时就退化成FIFO算法了。

操作系统页面置换算法代码

#include

#include #define TRUE 1

#define FALSE 0

#define INVALID -1

#define NUL 0

#define total_instruction 320 /*指令流长*/

#define total_vp 32 /*虚页长*/

#define clear_period 50 /*清零周期*/

typedef struct{ /*页面结构*/

int pn,pfn,counter,time;

}pl_type;

pl_type pl[total_vp]; /*页面结构数组*/

struct pfc_struct{ /*页面控制结构*/

int pn,pfn;

struct pfc_struct *next;

};

typedef struct pfc_struct pfc_type;

pfc_type pfc[total_vp],*freepf_head,*busypf_head,*busypf_tail;

int diseffect,a[total_instruction];

int page[total_instruction], offset[total_instruction];

void initialize(int);

void FIFO(int);

void LRU(int);

void NUR(int);

int main()

{

int S,i;

srand((int)getpid());

S=(int)rand()%390;

for(i=0;i

{

a[i]=S; /*任选一指令访问点*/

a[i+1]=a[i]+1; /*顺序执行一条指令*/

a[i+2]=(int)rand()%390; /*执行前地址指令m’*/

a[i+3]=a[i+2]+1; /*执行后地址指令*/

S=(int)rand()%390;

}

for(i=0;i

{

page[i]=a[i]/10;

offset[i]=a[i]%10;

}

for(i=4;i<=32;i++) /*用户内存工作区从4个页面到32个页面*/

{

FIFO(i);

LRU(i);

NUR(i);

}

return 0;

}

void FIFO(int total_pf) /*FIFO(First in First out)ALGORITHM*/

/*用户进程的内存页面数*/

{

int i;

pfc_type *p, *t;

initialize(total_pf); /*初始化相关页面控制用数据结构*/

busypf_head=busypf_tail=NUL; /*忙页面队列头，对列尾链接*/

for(i=0;i

{

if(pl[page[i]].pfn==INVALID) /*页面失效*/

{

diseffect+=1; /*失效次数*/

if(freepf_head==NUL) /*无空33闲页面*/

{

p=busypf_head->next;

pl[busypf_head->pn].pfn=INVALID; /*释放忙页面队列中的第一个页面*/

freepf_head=busypf_head;

freepf_head->next=NUL;

busypf_head=p;

}

p=freepf_head->next; /*按方式调新页面入内存页面*/

freepf_head->next=NUL;

freepf_head->pn=page[i];

pl[page[i]].pfn=freepf_head->pfn;

if(busypf_tail==NUL)

busypf_head=busypf_tail=freepf_head;

else

{

busypf_tail->next=freepf_head;

busypf_tail=freepf_head;

}

freepf_head=p;

}

void LRU(int total_pf)

{

int min,minj,i,j,present_time;

initialize(total_pf);present_time=0;

for(i=0;i

{

if(pl[page[i]].pfn==INVALID) /*页面失效*/

{

diseffect++;

if(freepf_head==NUL) /*无空闲2页面*/

{

min=32767;

for(j=0;j

if(min>pl[j].time&&pl[j].pfn!=INVALID)

{

min=pl[j].time;

minj=j;

}

freepf_head=&pfc[pl[minj].pfn];

pl[minj].pfn=INVALID;

pl[minj].time=-1;

freepf_head->next=NUL;

}

pl[page[i]].pfn=freepf_head->pfn;

pl[page[i]].time=present_time;

freepf_head=freepf_head->next;

}

else

pl[page[i]].time=present_time;

present_time++;

}

void NUR(int total_pf)

{

int i,j,dp,cont_flag,old_dp;

pfc_type *t;

initialize(total_pf);

dp=0;

for(i=0;i

{

if(pl[page[i]].pfn==INVALID) /*页面失效*/

{

diseffect++;

if(freepf_head==NUL) /*无空闲1页面*/

{

cont_flag=TRUE;old_dp=dp;

while(cont_flag)

if(pl[dp].counter==0&&pl[dp].pfn!=INVALID)

cont_flag=FALSE;

else

{

dp++;

if(dp==total_vp)

dp=0;

if(dp==old_dp)

for(j=0;j

pl[j].counter=0;

}

freepf_head=&pfc[pl[dp].pfn];

pl[dp].pfn=INVALID;

freepf_head->next=NUL;

}

pl[page[i]].pfn=freepf_head->pfn;

freepf_head=freepf_head->next;

}

else

pl[page[i]].counter=1;

if(i%clear_period==0)

for(j=0;j

pl[j].counter=0;

}

void initialize(int total_pf) /*初始化相关数据结构*/

/*用户进程的内存页面数*/

{

int i;

diseffect=0;

for(i=0;i

{

pl[i].pn=i;pl[i].pfn=INVALID; /*置页面控制结构中的页号，页面为空*/

pl[i].counter=0;pl[i].time=-1; /*页面控制结构中的访问次数为0，时间为-1*/

}

for(i=1;i

{

pfc[i-1].next=&pfc[i];pfc[i-1].pfn=i-1;/*建立pfc[i-1]和pfc[i]之间的连接*/

}

pfc[total_pf-1].next=NUL;pfc[total_pf-1].pfn=total_pf-1;

freepf_head=&pfc[0]; /*页面队列的头指针为pfc[0]*/

}

/*说明：本程序在Linux的gcc下和c-free下编译运行通过*/

全国各地天气预报查询

上海市

云南省

云南省

云南省

云南省

云南省

云南省

云南省

云南省

云南省

云南省

云南省

云南省

云南省

云南省

云南省

云南省

内蒙古自治区

内蒙古自治区

内蒙古自治区

内蒙古自治区

内蒙古自治区

内蒙古自治区

内蒙古自治区

内蒙古自治区

内蒙古自治区

内蒙古自治区

内蒙古自治区

内蒙古自治区

北京市

吉林省

吉林省

吉林省

吉林省

吉林省

吉林省

吉林省

吉林省

吉林省

四川省

四川省

四川省

四川省

四川省

四川省

四川省

四川省

四川省

四川省

四川省

四川省

四川省

四川省

四川省

四川省

四川省

四川省

四川省

四川省

四川省

天津市

宁夏回族自治区

宁夏回族自治区

宁夏回族自治区

宁夏回族自治区

宁夏回族自治区

安徽省

安徽省

安徽省

安徽省

安徽省

安徽省

安徽省

安徽省

安徽省

安徽省

安徽省

安徽省

安徽省

安徽省

安徽省

安徽省

山东省

山东省

山东省

山东省

山东省

山东省

山东省

山东省

山东省

山东省

山东省

山东省

山东省

山东省

山东省

山东省

山西省

山西省

山西省

山西省

山西省

山西省

山西省

山西省

山西省

山西省

山西省

广东省

广东省

广东省

广东省

广东省

广东省

广东省

广东省

广东省

广东省

广东省

广东省

广东省

广东省

广东省

广东省

广东省

广东省

广东省

广东省

广东省

广西壮族自治区

广西壮族自治区

广西壮族自治区

广西壮族自治区

广西壮族自治区

广西壮族自治区

广西壮族自治区

广西壮族自治区

广西壮族自治区

广西壮族自治区

广西壮族自治区

广西壮族自治区

广西壮族自治区

广西壮族自治区

新疆维吾尔自治区

新疆维吾尔自治区

新疆维吾尔自治区

新疆维吾尔自治区

新疆维吾尔自治区

新疆维吾尔自治区

新疆维吾尔自治区

新疆维吾尔自治区

新疆维吾尔自治区

新疆维吾尔自治区

新疆维吾尔自治区

新疆维吾尔自治区

新疆维吾尔自治区

新疆维吾尔自治区

新疆维吾尔自治区

江苏省

江苏省

江苏省

江苏省

江苏省

江苏省

江苏省

江苏省

江苏省

江苏省

江苏省

江苏省

江苏省

江西省

江西省

江西省

江西省

江西省

江西省

江西省

江西省

江西省

江西省

江西省

河北省

河北省

河北省

河北省

河北省

河北省

河北省

河北省

河北省

河北省

河北省

河南省

河南省

河南省

河南省

河南省

河南省

河南省

河南省

河南省

河南省

河南省

河南省

河南省

河南省

河南省

河南省

河南省

河南省

浙江省

浙江省

浙江省

浙江省

浙江省

浙江省

浙江省

浙江省

浙江省

浙江省

浙江省

海南省

海南省

海南省

海南省

海南省

湖北省

湖北省

湖北省

湖北省

湖北省

湖北省

湖北省

湖北省

湖北省

湖北省

湖北省

湖北省

湖北省

湖北省

湖南省

湖南省

湖南省

湖南省

湖南省

湖南省

湖南省

湖南省

湖南省

湖南省

湖南省

湖南省

湖南省

湖南省

甘肃省

甘肃省

甘肃省

甘肃省

甘肃省

甘肃省

甘肃省

甘肃省

甘肃省

甘肃省

甘肃省

甘肃省

甘肃省

甘肃省

福建省

福建省

福建省

福建省

福建省

福建省

福建省

福建省

福建省

西藏自治区

西藏自治区

西藏自治区

西藏自治区

西藏自治区

西藏自治区

西藏自治区

贵州省

贵州省

贵州省

贵州省

贵州省

贵州省

贵州省

贵州省

贵州省

辽宁省

辽宁省

辽宁省

辽宁省

辽宁省

辽宁省

辽宁省

辽宁省

辽宁省

辽宁省

辽宁省

辽宁省

辽宁省

辽宁省

重庆市

重庆市

陕西省

陕西省

陕西省

陕西省

陕西省

陕西省

陕西省

陕西省

陕西省

陕西省

青海省

青海省

青海省

青海省

青海省

青海省

青海省

青海省

黑龙江省

黑龙江省

黑龙江省

黑龙江省

黑龙江省

黑龙江省

黑龙江省

黑龙江省

黑龙江省

黑龙江省

黑龙江省

黑龙江省

黑龙江省