lru页面置换算法例题详解
详解页式管理置换算法FIFO_LRU_OPT
页式管理OPT、LRU、FIFO置换算法详解指令：1,2,3,4,2,1,5,6,2,1,2,3,7,6,3,2,1,2,3,6若内存最多容纳4个页面，则……一、OPT（理想型淘汰）算法该算法无法实现。
置换规则：（1）淘汰内存中以后不再访问的页面；（2）如果没有（1），则淘汰将要访问指令之后的将来最迟被访问的指令的页面。
分析：（1）当访问5时，内存1,2,3,4,发生第5次中断，淘汰不再访问的4，换入5，内存1,2,3,5；（2）当访问6时，内存1,2,3,5,发生第6次中断，淘汰不再访问的5，换入6，内存1,2,3,6；（3）当访问7时，内存1,2,3,6,发生第7次中断，由于之后的指令（1、2、3、6）都是现在内存页面都存在的指令，无法淘汰，但可以根据指令访问顺序，先淘汰将来最迟被访问的1，换入7，置换后的内存7,2,3,6；（4）当访问1时，内存7,2,3,6,发生第8次中断，淘汰不再访问的7，换入1，内存1,2,3,6；即OPT算法一共会出现8次缺页中断。
二、LRU（最近最久未使用）算法该算法利用堆栈实现，每次访问都调整堆栈中页面顺序。
把被访问页面从栈移出再压入栈顶。
置换规则：（1）栈顶始终为最新访问过的页面；（2）栈底始终为最近最久未被访问的页面；（3）访问存在的页面要调到栈顶。
分析：（1）访问第5个指令2时，由于内存页面中已经存在2，所以不置换，但调整2在栈中顺序，即将2调到栈顶，其它页面依次后置。
调整前内存4,3,2,1,调整后内存2,4,3,1；（2）访问第7个指令5时，发生第5次中断，原内存1,2,4,3,淘汰栈底3，栈顶调入5，调整后内存5,1,2,4；（3）访问第8个指令6时，发生第6次中断，原内存5,1,2,4,，淘汰栈底4，栈顶调入6，调整后内存6,5,1,2；……即LRU算法一共会出现10次缺页中断。
三、FIFO（先进先出）算法该算法利用队列实现。
FIFO与LRU的区别是FIFO遇到内存中存在的页面不需要调换页面顺序。
操作系统页面置换算法（opt,lru,fifo,clock）实现
操作系统页⾯置换算法（opt,lru,fifo,clock ）实现选择调出页⾯的算法就称为页⾯置换算法。
好的页⾯置换算法应有较低的页⾯更换频率，也就是说，应将以后不会再访问或者以后较长时间内不会再访问的页⾯先调出。
常见的置换算法有以下四种（以下来⾃操作系统课本）。
1. 最佳置换算法(OPT)最佳(Optimal, OPT)置换算法所选择的被淘汰页⾯将是以后永不使⽤的，或者是在最长时间内不再被访问的页⾯,这样可以保证获得最低的缺页率。
但由于⼈们⽬前⽆法预知进程在内存下的若千页⾯中哪个是未来最长时间内不再被访问的，因⽽该算法⽆法实现。
最佳置换算法可以⽤来评价其他算法。
假定系统为某进程分配了三个物理块，并考虑有以下页⾯号引⽤串： 7, 0, 1, 2, 0, 3, 0, 4, 2, 3, 0, 3, 2, 1, 2, 0, 1, 7, 0, 1进程运⾏时，先将7, 0, 1三个页⾯依次装⼊内存。
进程要访问页⾯2时，产⽣缺页中断，根据最佳置换算法，选择第18次访问才需调⼊的页⾯7予以淘汰。
然后，访问页⾯0时，因为已在内存中所以不必产⽣缺页中断。
访问页⾯3时⼜会根据最佳置换算法将页⾯1淘汰……依此类推，如图3-26所⽰。
从图中可以看出⾤⽤最佳置换算法时的情况。
可以看到，发⽣缺页中断的次数为9，页⾯置换的次数为6。
图3-26 利⽤最佳置换算法时的置换图2. 先进先出(FIFO)页⾯置换算法优先淘汰最早进⼊内存的页⾯，亦即在内存中驻留时间最久的页⾯。
该算法实现简单，只需把调⼊内存的页⾯根据先后次序链接成队列，设置⼀个指针总指向最早的页⾯。
但该算法与进程实际运⾏时的规律不适应，因为在进程中，有的页⾯经常被访问。
图3-27 利⽤FIFO 置换算法时的置换图这⾥仍⽤上⾯的实例，⾤⽤FIFO 算法进⾏页⾯置换。
进程访问页⾯2时，把最早进⼊内存的页⾯7换出。
然后访问页⾯3时，再把2, 0, 1中最先进⼊内存的页换出。
07实验7：LRU页面置换算法
实验6：LRU页面置换算法例如：进程P有5个页，进程访问页的顺序为：4，3，2，1，4，3，5，4，3，2，1，5；如果在内存中分配给该进程3个页面，则缺页情况如下：页面淘汰顺序：4，3，2，1，5，4，3运行环境：VC++ 6.0#include "stdafx.h"void max_value(int x, int cc[][2]); //函数声明, 页表处理int r_algorithm(int cc[][2]); //函数声明, 选择页面淘汰算法void page_table(int page1, int c[5][2]); //打印页表void main(){ int i,j,page,row=0,col=1; //b[row]][col],行/列指针int k=0; //记录缺页中断次数int a[12]={4,3,2,1,4,3,5,4,3,2,1,5}; //存放页的调度顺序int b[3][13]; //模拟内存（三个页面）int c[5][2]={{1,0},{2,0},{3,0},{4,0},{5,0}}; //定义页表并赋初值int d[13],p=0; // 存放页面淘汰顺序, p页面淘汰数组d的指针b[0][0]=0; //数组的初值不确定，0表示页面为空b[1][0]=0;b[2][0]=0;//****************************页面调度处理****************************for(i=0;i<12;i++){if(a[i]==b[0][i]||a[i]==b[1][i]||a[i]==b[2][i]){ b[0][i+1]=b[0][i]; //将前一列数据复制到下一列b[1][i+1]=b[1][i];b[2][i+1]=b[2][i];max_value(a[i],c); //处理页表, a[i]页面是刚被访问的页面page_table(a[i],c); //打印页表col++; //col指向下一列}else //页面不在内存{ if(row>2) //row>2表示内存已没有空闲页面{ page = r_algorithm(c); //返回淘汰的页面paged[p] = page; //d[]存放被淘汰的页面p++;k++; //缺页中断次数b[0][i+1]=b[0][i]; //将前一列数据复制到下一列b[1][i+1]=b[1][i];b[2][i+1]=b[2][i];if(b[0][i+1]==page) b[0][i+1]=a[i];if(b[1][i+1]==page) b[1][i+1]=a[i];if(b[2][i+1]==page) b[2][i+1]=a[i];max_value(a[i],c); //访问a[i]页面, i页面是刚被访问的页面page_table(a[i],c); //打印页表}else{ b[0][i+1]=b[0][i]; //将前一列数据复制到下一列b[1][i+1]=b[1][i];b[2][i+1]=b[2][i];b[row][col]=a[i]; //a[i]页面进入内存max_value(a[i],c); //访问a[i]页面, i页面是刚被访问的页面col++;k++; //缺页中断次数row++;page_table(a[i],c); //打印页表}}}//=========================显示处理结果=========================printf("\n ");for(i=0;i<12;i++)printf("%6d",a[i]); //显示页面调度顺序printf("\n=========================================================================\n");for(j=0;j<13;j++)printf("%6d",b[0][j]);printf("\n -------------------------------------------------------------------------\n");for(j=0;j<13;j++)printf("%6d",b[1][j]);printf("\n -------------------------------------------------------------------------\n");for(j=0;j<13;j++)printf("%6d",b[2][j]);printf("\n -------------------------------------------------------------------------\n");printf("\n缺页中断次数：%6d\n",k);printf("\n页面淘汰顺序：");for(j=0;j<p;j++)printf("%6d",d[j]); //显示页面淘汰顺序printf("\n\n");}//================访问的页面在内存的处理(页表处理)=================== void max_value(int x, int cc[][2]) //x-页号：求页表中计数的最大值，//并将该页面置为最新访问的页面{ int i, max;max=cc[0][1];for(i=0; i<5; i++)if(max < cc[i][1]) max=cc[i][1];for(i=0; i<5; i++)if(cc[i][0]==x) cc[i][1]=max+1;}//=================选择被淘汰的页面(页表处理)====================== int r_algorithm(int cc[5][2]){ int i,min,row,p;for(i=0;i<5;i++) //查询第一个计数为非0的页面的计数值if(cc[i][1]!=0 ) {min=cc[i][1]; p=cc[i][0]; row=i; break;}for(i=0; i<5; i++) //寻找计数值最小的数页面{ if(min>cc[i][1] && cc[i][1]!=0){min=cc[i][1];p=cc[i][0]; //最小数所对应的页号被淘汰row=i; //记录最小数所在的行}}cc[row][1]=0; //在页表中被淘汰的页面计数清零return(p); //返回被淘汰的页面--P}//================================================================== void page_table(int page1, int c[5][2]) //打印页表{ int i;printf("页面调度顺序page= %d\n",page1);for(i=0;i<5;i++)printf("%5d%5d\n",c[i][0],c[i][1]);}。
FIFOLRU例题
例 1设页面走向为P=4, 3, 2, 1, 4, 3, 5, 4, 3, 2, 1, 5，主存容量M=3，置换算法采用FIFO，则缺页中断次数及缺页率按表 4 - 4 给出。
表4-4 FIFO性能分析例(M=3)
例 2设M=4，其余同例 1。
缺页中断次数和缺页率如表 4-5 所示。
表4-5 FIFO性能分析例(M=4)
F=10
f=10/12=83%
例 3设页面走向如上，M=3，置换算法为LRU，则系统模型如表 4-6 所示。
在表 4-6 中，由于采用LRU算法，M中各列按访问的时间顺序排列，最近被访问的页面在最前。
由表 4-6 算出缺页中断次数F=10，缺页率f=10/12=83%。
表4-6 LRU性能分析例(M=3)
例 4 设M =4，其余同例 3，则系统性能模型如表 4-7 所示。
表4-7 LRU 性能分析例(M
=4)
由表 4-6， 表 4-7 可得如下事实：
设G(P, M, t )表示当页面走向为P ，主存容量为M ，在时刻t 的页面集合，对于LRU 算法，存在如下关系，即 成立。
即对于任何时刻t (t =1, 2, …, 12),G (P , M , t )所选中的页号必定包含在G (P , M +1, t)之中。
这种关系说明了增加主存容量不会增加缺页中断次数，然而对FIFO 算法， 此关系并不成立。
)
,1,(),,(t M P G t M P G +⊆。
页面置换算法(FIFO、LRU)
#include<iostream.h>#include <stdlib.h>#include <time.h>#include <stdio.h>#define L 20//页面走向长度最大为20int M; //内存块struct Pro//定义一个结构体{ int num,time;};Input(int m,Pro p[L])//打印页面走向状态{ cout<<"请输入实际页走向长度L(15<=L<=20)：";do{ cin>>m;if(m>20||m<15)cout<<"实际页长度须在15～20之间;请重新输入L： ";else break;}while(1);int i,j;j=time(NULL);//取时钟时间srand(j);//以时钟时间x为种子，初始化随机数发生器cout<<"输出随机数: ";for(i=0;i<m;i++){ p[i].num=rand( )%10+1;// 1到10之间的随即数放到数组p中p[i].time=0;cout<<p[i].num<<" ";}cout<<endl;return m;}void print(Pro *page1)//打印当前的页面{ Pro *page=new Pro[M];page=page1;for(int i=0;i<M;i++)cout<<page[i].num<<" ";cout<<endl;}int Search(int e,Pro *page1 )//寻找内存块中与e相同的块号{ Pro *page=new Pro[M];page=page1;for(int i=0;i<M;i++)if(e==page[i].num)return i;//返回i值return -1;}int Max(Pro *page1)//寻找最近最长未使用的页面{ Pro *page=new Pro[M];page=page1;int e=page[0].time,i=0;while(i<M) //找出离现在时间最长的页面{ if(e<page[i].time) e=page[i].time;i++;}for( i=0;i<M;i++)if(e==page[i].time)return i;//找到离现在时间最长的页面返回其块号return -1;}int Count(Pro *page1,int i,int t,Pro p[L])//记录当前内存块中页面离下次使用间隔长度{ Pro *page=new Pro[M];page=page1;int count=0;for(int j=i;j<L;j++){ if(page[t].num==p[j].num )break;//当前页面再次被访问时循环结束else count++;//否则count+1}return count;//返回count的值}int main(){ int c;int m=0,t=0;float n=0;Pro p[L];m=Input(m,p);//调用input函数，返回m值cout<<"请输入可用内存页面数m(3～5): ";do{ cin>>M;if(M>5||M<3)cout<<"内存块m须在3～5之间，请重新输入m： ";else break;}while(1);Pro *page=new Pro[M];do{ for(int i=0;i<M;i++)//初始化页面基本情况{ page[i].num=0;page[i].time=m-1-i;}i=0;cout<<"1:FIFO页面置换"<<endl;cout<<"2:LRU页面置换"<<endl;cout<<"按其它键结束程序；"<<endl;cin>>c;system("cls");if(c==1)//FIFO页面置换{ n=0;cout<<" ****************************************** "<<endl;cout<<" FIFO算法页面置换情况如下: "<<endl;cout<<"****************************************** "<<endl;while(i<m){ if(Search(p[i].num,page)>=0) //当前页面在内存中{ cout<<p[i].num<<" "; //输出当前页p[i].numcout<<"不缺页"<<endl;i++; //i加1}else //当前页不在内存中{ if(t==M)t=0;else{ n++; //缺页次数加1page[t].num=p[i].num;//把当前页面放入内存中cout<<p[i].num<<" ";print(page); //打印当前页面t++; //下一个内存块i++; //指向下一个页面}}}cout<<"缺页次数："<<n<<" 缺页率："<<n/m<<endl;}if(c==2)//LRU页面置换{ n=0;cout<<" ******************************************"<<endl;cout<<" LRU算法页面置换情况如下: "<<endl;cout<<" ******************************************"<<endl;while(i<m){int a;t=Search(p[i].num,page);if(t>=0)//如果已在内存块中{ page[t].time=0;//把与它相同的内存块的时间置0for(a=0;a<M;a++)if(a!=t)page[a].time++;//其它的时间加1cout<<p[i].num<<" ";cout<<"不缺页"<<endl;}else //如果不在内存块中{ n++; //缺页次数加1t=Max(page); //返回最近最久未使用的块号赋值给tpage[t].num=p[i].num; //进行替换page[t].time=0; //替换后时间置为0cout<<p[i].num<<" ";print(page);for(a=0;a<M;a++)if(a!=t)page[a].time++; //其它的时间加1}i++;}cout<<"缺页次数："<<n<<" 缺页率："<<n/m<<endl;}}while(c==1||c==2||c==3);return 0;}。
操作系统 LRU页面置换算法
#include <stdio.h> //头文件#include <time.h> //#include <stdlib.h> //产生随机数所需要的头文件main(){int pagen;int memoryn; //可用内存块数为memoryn，页面长度为pagen，int choose; //3<=memoryn<=5.15<=pagen<=20printf("*****************************页*面*置*换*算*法**********************************\n");printf("\n\n请输入您要求的内存块数量（范围为3至5）：");scanf("%d",&memoryn);if(memoryn<3||memoryn>5){printf("\n\n对不起，您的输入有误，请重新输入：");scanf("%d",&memoryn);}printf("\n\n请输入您要求的页面长度（范围为8至10）：");scanf("%d",&pagen);if(pagen<8||pagen>10){printf("\n\n对不起，您的输入有误，请重新输入：");scanf("%d",&pagen);}//从用户处获取内存块与页面长度//***************************************************************************** ***********//short times[5]={0,0,0,0,0}; //时间轴数组short pagenumber[20]; //控制页面走向数组short pagememory[5]={88,88,88,88,88}; //物理块数组int i,n; //控制变量为iprintf("\n\n\n由您所确定的页面走向为：");for(i=0;i<pagen;i++){scanf("%d",&pagenumber[i]);}int want=0; //want为缺页数int now; //中断数//控制变量为ipagememory[0]=pagenumber[0];//对第一个物理块进行赋值printf("第%2d 步：",i=1);for(i=0;i<memoryn;i++){printf(" %2d",pagememory[i]);}printf("\n");for(i=1;i<pagen;i++){if(pagememory[0]!=pagenumber[i]){pagememory[1]=pagenumber[i];now=i+1;break;}} //对第二个物理块进行赋值printf("第%2d 步：",now);for(i=0;i<memoryn;i++){printf(" %2d",pagememory[i]);}printf("\n");for(i=2;i<pagen;i++){if((pagememory[0]!=pagenumber[i])&&(pagememory[1]!=pagenumber[i])) {pagememory[2]=pagenumber[i];now=i+1;break;}} //对第三个物理块进行赋值want=3; //此时可以将缺页值暂定为3printf("第%2d 步：",now);for(i=0;i<memoryn;i++){printf(" %2d",pagememory[i]);}if(memoryn==4){for(i=3;i<pagen;i++){if((pagememory[0]!=pagenumber[i])&&(pagememory[1]!=pagenumber[i]) &&(pagememory[2]!=pagenumber[i])){pagememory[3]=pagenumber[i];now=i+1;want=4;break;}}printf("第%2d 步：",now);for(i=0;i<memoryn;i++){printf(" %2d",pagememory[i]);}printf("\n");} //如果为四个物理块，则为第四个物理块赋值if(memoryn==5){for(i=3;i<pagen;i++){if((pagememory[0]!=pagenumber[i])&&(pagememory[1]!=pagenumber[i]) &&(pagememory[2]!=pagenumber[i])){pagememory[3]=pagenumber[i];now=i+1;want=4;break;}}printf("第%2d 步：",now);for(i=0;i<memoryn;i++){printf(" %2d",pagememory[i]);}printf("\n");for(i=4;i<pagen;i++){if((pagememory[0]!=pagenumber[i])&&(pagememory[1]!=pagenumber[i]) &&(pagememory[2]!=pagenumber[i])&&(pagememory[3]!=pagenumber[i])){pagememory[4]=pagenumber[i];now=i+1;want=5;break;}}} //如果为五个物理块，则为第四个物理块赋值printf("第%2d 步：",now);for(i=0;i<memoryn;i++){printf(" %2d",pagememory[i]);}printf("\n");{int needchange; //页面置换发生时要进行置换的物理块块号int mn=memoryn; //为时间轴赋初值所用到的物理块数int max; //最大的时间值int j; //控制变量i.jfor(i=0;i<memoryn;i++){mn--;times[i]=mn;} //给时间轴数组设定初值for(j=now;j<pagen;j++){if((pagenumber[j]!=pagememory[0])&&(pagenumber[j]!=pagememory[1]) &&(pagenumber[j]!=pagememory[2])&&(pagenumber[j]!=pagememory[3]) &&(pagenumber[j]!=pagememory[4])){if(times[0]<=times[1]){max=times[1];}{max=times[0];}if(max<=times[2]){max=times[2];}if(max<=times[3]){max=times[3];}if(max<=times[4]){max=times[4];} //确定时间轴数组里储存的最大时间for(i=0;i<memoryn;i++){if(max==times[i]){needchange=i;break;}} //提取出最大时间也就是先进入的页面所对应的物理块号pagememory[needchange]=pagenumber[j];for(i=0;i<memoryn;i++){if(i==needchange){times[i]=0;}else{times[i]++;}} //更新时间轴want++; //缺页数进行自增运算printf("第%2d 步：",j+1);for(i=0;i<memoryn;i++)printf(" %2d",pagememory[i]);}printf("\n");}else{for(i=0;i<memoryn;i++){if(pagenumber[j]==pagememory[i]){times[i]=0;}else{times[i]++;}}} //出线相同页面只把时间轴自增一，不做其他操作}printf("\n\n LRU页面置换次数为: %d\n",want);system("pause");}}。
操作系统页面置换算法例题
（1）最佳置换算法（OPT) ：选择以后永不使用或在最长时间内不再被访问的
内存页面予以淘汰。
（2）先进先出置换算法（FIFO）：选择最先进入内存的页面
予以淘汰。
（3）最近最久未使用算法（LRU）：选择在最近一段时间内最久没
有使用过的页，把它淘汰。
（4）最少使用算法（LFU）：选择到当前时间为止
被访问次数最少的页转换。
【例4-8】在一个请求分页存储管理的系统中，一个程序的页面走向为
6,0,1,2,0,3,0,4,2,3,分别采用最佳置换算法、先进先出置换算法、最近最久未使用
算法，完成下列要求。
设分配给该程序的存储块数M=3,每调进一个新页就发生
一次缺页中断。
时刻12345678910
访问顺序6012030423
M=3
f
OPT
时刻12345678910访问顺序6012030423
M=36662222222
000000444
11133333 f123456
FIFO
时刻12345678910访问顺序6012030423 M=36662222444
000033322
11110003 f123456789 LRU
时刻12345678910访问顺序6012030423 M=312030423
001203042 6660122304 f12345678。
C++模拟LRU页面置换算法(可打印修改)
void addtime(struct node zhuliuji[],int m) {
for(int i=0;i<m;i++) {
zhuliuji[i].time++; } }
char addzhuliuji(struct node zhuliuji[],int m,char c) {
} cin>>jtemp; //显示结果，以便观察 }
int main() {
struct node zhuliuji[20]; char str[20]; int n,m; cout<<"请输入访问串的大小："<<endl; cin>>n; cout<<"请输入驻留级大小："<<endl; cin>>m; cout<<"请输入访问串的内容："<<endl; init(str,n,zhuliuji,m); LRU(str,n,zhuliuji,m); return 0; }
void LRU(char str[],int n,struct node zhuliuji[],int m) {
int jtemp=0; for(int i =0;i<n;i++) {
if(i<m) {
zhuliuji[jtemp].data = str[i]; addtime(zhuliuji,m); zhuliuji[jtemp].time = 0; jtemp ++; }else { addtime(zhuliuji,m); char ch = addzhuliuji(zhuliuji,m,str[i]); // if(ch!='\0') //cout<<"淘汰的页数为："<<ch<<endl; } cout<<"驻留级为："; for(int j=0;j<m;j++) { cout<<zhuliuji[j].data<<'\t'; } cout<<endl;
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
lru页面置换算法例题详解
LRU（Least Recently Used）页面置换算法是一种常用的内存管理算法，
其基本思想是：当内存空间不足时，优先淘汰最近最少使用的页面。
下面是一个LRU页面置换算法的详细例子：
假设我们有3个物理块，当前内存中已经装入了页面1、页面2和页面3。
现在，我们按照顺序依次访问页面4、页面3、页面2、页面1、页面4、页面3、页面5和页面4，我们需要使用LRU算法来决定哪些页面应该被淘汰。
步骤1：装入页面4。
此时内存中有页面1、页面2、页面3和页面4，下
一次访问时，将页面4标记为最近使用。
步骤2：访问页面3。
由于页面3在内存中，将其标记为最近使用。
步骤3：访问页面2。
同样，页面2也在内存中，将其标记为最近使用。
步骤4：访问页面1，内存已满，需要淘汰一个页面。
根据LRU算法，应该淘汰最久未使用的页面，即页面3。
因此，将页面1装入内存中，并标记为最近使用，同时将页面3淘汰。
步骤5：访问页面4，内存已满，需要淘汰一个页面。
根据LRU算法，应该淘汰最久未使用的页面，即页面2。
因此，将页面4装入内存中，并标记为最近使用，同时将页面2淘汰。
步骤6：访问页面3，内存已满，需要淘汰一个页面。
根据LRU算法，应该淘汰最久未使用的页面，即页面1。
因此，将页面3装入内存中，并标记为最近使用，同时将页面1淘汰。
步骤7：访问页面5，内存已满，需要淘汰一个页面。
根据LRU算法，应该淘汰最久未使用的页面，即页面1。
因此，将页面5装入内存中，并标记为最近使用，同时将页面1淘汰。
在上述过程中，我们按照LRU算法依次淘汰了页面3、页面2、页面1和页面1，最终实现了页面的置换。