页面淘汰算法

㈠ 页面淘汰算法

LRU（2个块）：
1 2 3 4 2 1 5 6 2 1 2 3 7 6 3 2 1 2 3 6
————————————————————
1 1 3 3 2 2 5 5 2 2 2 2 7 7 3 3 1 1 3 3
2 2 4 4 1 1 6 6 1 1 3 3 6 6 2 2 2 2 6
缺页中断18次

LRU（4个块）：
1 2 3 4 2 1 5 6 2 1 2 3 7 6 3 2 1 2 3 6
————————————————————
1 1 1 1 1 1 1 1 1 1 1 1 1 6 6 6 6 6 6 6
2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2
3 3 3 3 5 5 5 5 5 3 3 3 3 3 3 3 3 3
4 4 4 4 6 6 6 6 6 7 7 7 7 1 1 1 1
缺页中断次数10次

FIFO（2个块）
1 2 3 4 2 1 5 6 2 1 2 3 7 6 3 2 1 2 3 6
————————————————————
1 1 1 1 1 1 1 1 1 1 1 3 3 6 6 2 2 2 3 3
2 2 4 4 1 1 6 6 1 1 2 7 7 3 3 1 1 1 6
缺页中断次数18次

FIFO（4个块）
1 2 3 4 2 1 5 6 2 1 2 3 7 6 3 2 1 2 3 6
————————————————————
1 1 1 1 1 1 5 5 5 5 5 3 3 3 3 3 1 1 1 1
2 2 2 2 2 2 6 6 6 6 6 7 7 7 7 7 7 3 7
3 3 3 3 3 3 2 2 2 2 2 6 6 6 6 6 6 6
4 4 4 4 4 4 1 1 1 1 1 1 2 2 2 2 2
缺页中断次数：14次

㈡ 最佳页面淘汰算法是怎样计算的

<1> 先进先出调度算法
先进先出调度算法根据页面进入内存的时间先后选择淘汰页面，先进入内存的页面先淘汰，后进入内存的后淘汰。本算法实现时需要将页面按进入内存的时间先后组成一个队列，每次调度队首页面予以淘汰。
<2>最近最少调度算法
先进先出调度算法没有考虑页面的使用情况，大多数情况下性能不佳。根据程序执行的局部性特点，程序一旦访问了某些代码和数据，则在一段时间内会经旅旅常访问他们，因此最近最少用调度在选择淘汰页面时会考虑页面最近的使用，总是选择在最近一段时间以来最少使用的页面予以淘汰。算法实现时需要为每个页面设置数据结构记录页面自上次访问以来所经历的时间。
<3>最近最不常用调度算法
由于程序设计中经常使用循环结构，根据程序执行的局部性特点，可以设想在一段时间内经常被访问的代码和数据在将来也会经常被访问，显然这样的页面不应该被淘汰。最近最不常用调度算法启扰总是根据一段时间内页面的访问次数来选择淘汰页面，每次淘汰访问次数最少的页面。算法实现时需要为每个页面设置计数器，记录访问次数。计数器由硬件或操作系统自动定时清零。
（2）拆旁凳缺页调度次数和缺页中断率、缺页置换率计算
缺页中断次数是缺页时发出缺页中断的次数。
缺页中断率=缺页中断次数/总的页面引用次数*100%
缺页调度次数是调入新页时需要进行页面调度的次数
缺页置换率=缺页调度次数/总的页面引用次数*100%

㈢ 先进先出页面淘汰算法

#include<stdio.h>
#include<stdlib.h>
#define max 30
typedef struct{
int visit_number;//要访问的页面号
}nu,number[max];
int *memoryblock;//主存中有三个主存块，可装三个页面
void init_memoryblock(int n)//初始化主存块
{
int i=1;
memoryblock=(int*)malloc(sizeof(int));//分配空间
for(i=1;i<=n;i++)
{
memoryblock[i]=-1;//开始时候没有页面进入，初始为-1
}
}
void init_visitpage(number num,int n)//n表示要访问的页面的个数
{
int i=0;
int j=3;
printf("输入要访问的页面号: ");
for(i=1;i<=n;i++)
{
scanf("%d",&num[i].visit_number);
}
printf("\n");
}
void FIFO_page_dispatch(number num,int n)//FIFO页面调度算法
{
int i,j=3,temp,counter=0;
for(i=1;i<=n;i++)
{
//----------------------------页面在主存中-------------------------------
for(j=3;j>=1;j--)
{
if(num[i].visit_number==memoryblock[j])//////要访问的页面在主存中
{
printf("(%d)页面在主存块中，换出和换进都是%d号页面:\n",i,memoryblock[j]);
}
break;
}
//-----------------------------------------------------------------------
//----------------------------页面不在主存中-----------------------------
if(num[i].visit_number!=memoryblock[1]&&num[i].visit_number!=memoryblock[2]&&
num[i].visit_number!=memoryblock[3])/////////////[ 1 ]
/*内存中没有要访问的页面，中断*/
{
if(memoryblock[1]!=-1&&memoryblock[2]!=-1&&memoryblock[3]!=-1)
{
temp=memoryblock[3];
memoryblock[3]=memoryblock[2];
memoryblock[2]=memoryblock[1];
memoryblock[1]=num[i].visit_number;
//---------------------------------
printf("(%d)——页面发生置换:",i);
printf("换出(%d号)页面—",temp);
printf("换进(%d)号页面\n",num[i].visit_number);
counter++;
}
for(j=3;j>=1;j--)//////////////[ 2 ]
{
if(memoryblock[j]==-1)//还有空闲主存块
{
printf("(%d)有空闲主存块，%d号页面直接调入:\n",i,i);
memoryblock[j]=num[i].visit_number;
break;
}

}
//-----------------------------移动主存块-------------------
}
//------------------------------------------------------------------------
}
printf("\n共产生 %d 次页面置换:",counter);
}
void main()
{
number num;
int m,n;
printf("输入要访问页面串的个数(<30)和内存块个数：");
{
scanf("%d%d",&n,&m);
getchar();
}
init_memoryblock(m);//初始化主存块
init_visitpage(num,n);//输入要访问的页面号顺序
FIFO_page_dispatch(num,n);//FIFO调度
printf("\n");
}

㈣ 最佳页面淘汰算法是怎样计算的

1;
50%指令顺序执行
2;25%指令均匀散步在前地址部分
3;25%指令均匀散步在后地址部分
题目中选用:命中率=1-页面失败次数(只选用2的兄弊幂次)/叶地址流长度
算法:opt
fifo
rlu(定义)(至少用两个算法)程序流程图开始:产生给定长度符合假定的指令地址流->为散纳每一个指令地址羡掘族的成对应的访问页号->置初算size=1~8(1,2,4,8)(页面大上)实存
=4~32(4,8,16,32)->输入淘汰算法->A->ALG=FIFO(OR)(LRU)->FIFO->用FIFO计算命中率->用LRU计算命中率->输出结果->结束算法定义:理想淘汰算法--最佳页面算法(OPT)
淘汰以后不再需要的或最远的将来才会用到的页面
先进先出页面淘汰算法(FIFO)
选择在内存中驻留时间最长的页并淘汰之
最近最少使用页面淘汰算法(LRU)
选择最后一次访问时间距离当前时间最长的一页并淘汰之即淘汰没有使用的时间最长的页.

㈤ 储存管理中,分页式虚拟储存管理的页面淘汰算法有

储存管理中，分页式虚拟储存管理的页面淘汰链森算法有先进先出法，最近最少使用页面陆樱先淘汰，最优淘汰算法。最优淘汰算法(OPT)：系统预测作业今后要访问的页面，淘汰页是将来不被访问的页面或者在最长时间早唤丛后才被访问的页面。它保证有最少的缺页率，但它实现困难，只能通过理论分析用来衡量其它算法的优劣。