页面置换算法代码实现(完整版)
页面置换算法实验(内含完整代码)
![页面置换算法实验(内含完整代码)](https://img.taocdn.com/s3/m/390765bbf121dd36a32d822d.png)
实验二存储管理一、实验目的通过模拟实现请求页式存储管理的几种基本页面置换算法,了解虚拟存储技术的特点,掌握虚拟存储请求页式存储管理中几种基本页面置换算法的基本思想和实现过程,并比较它们的效率。
二、实验内容基于一个虚拟存储区和内存工作区,设计下述算法并计算访问命中率。
1、最佳淘汰算法(OPT)2、先进先出的算法(FIFO)3、最近最久未使用算法(LRU)4、简单时钟(钟表)算法(CLOCK)命中率=1-页面失效次数/页地址流(序列)长度三、实验原理简述UNIX中,为了提高内存利用率,提供了内外存进程对换机制;内存空间的分配和回收均以页为单位进行;一个进程只需将其一部分(段或页)调入内存便可运行;还支持请求调页的存储管理方式。
当进程在运行中需要访问某部分程序和数据时,发现其所在页面不在内存,就立即提出请求(向CPU发出缺中断),由系统将其所需页面调入内存。
这种页面调入方式叫请求调页。
为实现请求调页,核心配置了四种数据结构:页表、页帧(框)号、访问位、修改位、有效位、保护位等。
当CPU接收到缺页中断信号,中断处理程序先保存现场,分析中断原因,转入缺页中断处理程序。
该程序通过查找页表,得到该页所在外存的物理块号。
如果此时内存未满,能容纳新页,则启动磁盘I/O将所缺之页调入内存,然后修改页表。
如果内存已满,则须按某种置换算法从内存中选出一页准备换出,是否重新写盘由页表的修改位决定,然后将缺页调入,修改页表。
利用修改后的页表,去形成所要访问数据的物理地址,再去访问内存数据。
整个页面的调入过程对用户是透明的。
四、算法描述本实验的程序设计基本上按照实验内容进行。
即使用srand( )和rand( )函数定义和产生指令序列,然后将指令序列变换成相应的页地址流,并针对不同的算法计算出相应的命中率。
(1)通过随机数产生一个指令序列,共320条指令。
指令的地址按下述原则生成:A:50%的指令是顺序执行的B:25%的指令是均匀分布在前地址部分C:25%的指令是均匀分布在后地址部分具体的实施方法是:A:在[0,319]的指令地址之间随机选取一起点mB:顺序执行一条指令,即执行地址为m+1的指令C:在前地址[0,m+1]中随机选取一条指令并执行,该指令的地址为m’D:顺序执行一条指令,其地址为m’+1E:在后地址[m’+2,319]中随机选取一条指令并执行F:重复步骤A-E,直到320次指令(2)将指令序列变换为页地址流设:页面大小为1K;用户内存(页帧)容量为4页~32页;用户虚存容量为32K。
操作系统页面置换算法(C++实现)
![操作系统页面置换算法(C++实现)](https://img.taocdn.com/s3/m/8d8bcfd79fc3d5bbfd0a79563c1ec5da50e2d6ce.png)
操作系统页⾯置换算法(C++实现)1. 最佳(Optimal)置换算法1.1 算法原理 其选择淘汰的页⾯将是以后永不使⽤的,或许是在最长时间内不再被访问的页⾯。
采⽤最佳置换算法通常可以保证获得最低的缺页率。
但由于⼈们⽬前还⽆法预知,⼀个进程在内存的若⼲个界⾯中,哪⼀个页⾯是未来最长时间内不再被访问的,因⽽该算法是⽆法实现的,但可以利⽤它来评价其他算法。
现举例如下: 最佳置换算法可以⽤来评价其他算法。
假定系统为某进程分配了三个物理块,并考虑有以下页⾯号引⽤串: 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。
访问页⾯70120304230321201701177722222720000400031133311缺页否√ √√√√√√√√1.2 实现代码函数1void Optimal(vector<int> PageOrder, vector<vector<int> > &Simulate, int &PageNum,int &LackNum, int m, int n){2 vector<bool> found(n,false); // 记录页⾯中是否存在3 vector<int> lump; // 物理块45for(int i = 0; i < n; found[PageOrder[i]] = true, i ++){6//物理块中不存在7if( !found[PageOrder[i]] ){8// 物理块未满时9if(lump.size() < m){10 lump.push_back(PageOrder[i]);11 }12// 物理块满需要置换13else{14int temp, max = 0;15for(int j = 0; j < lump.size(); j ++){16int count = i;17for(; count < n + 1; count ++)18if(PageOrder[count] == lump[j]) break;19if(count > max){20 max = count;temp = j; // 记录当前最远页⾯序号21 }22 }23 found[lump[temp]] = false;24 lump[temp] = PageOrder[i];25 }26for(int j = 0; j < lump.size(); j ++)27 Simulate[i].push_back(lump[j]);28 LackNum ++; //访问页⾯失败29 }30//物理块中存在31else32 PageNum ++; //访问页⾯成功33 }34 }2. 先进先出(FIFO)置换算法2.1 算法原理 是最简单的页⾯置换算法。
实验四页面置换算法代码
![实验四页面置换算法代码](https://img.taocdn.com/s3/m/df915376f56527d3240c844769eae009581ba2d0.png)
实验四页面置换算法模拟(2)一.题目要求:设计一个虚拟存储区和内存工作区,编程序演示下述算法的具体实现过程,并计算访问命中率:要求设计主界面以灵活选择某算法,且以下算法都要实现1)最佳置换算法(OPT):将以后永不使用的或许是在最长(未来)时间内不再被访问的页面换出。
2)先进先出算法(FIFO):淘汰最先进入内存的页面,即选择在内存中驻留时间最久的页面予以淘汰。
3)最近最久未使用算法(LRU):淘汰最近最久未被使用的页面。
4)最不经常使用算法(LFU).实验目的:1、用C语言编写OPT、FIFO、LRU,LFU四种置换算法2、熟悉内存分页管理策略。
3、了解页面置换的算法。
4、掌握一般常用的调度算法。
5、根据方案使算法得以模拟实现。
6、锻炼知识的运用能力和实践能力。
三.相关知识:1 .虚拟存储器的引入:局部性原理:程序在执行时在一较短时间内仅限于某个部分;相应的,它所访问的存储空间也局限于某个区域,它主要表现在以下两个方面:时间局限性和空间局限性。
2 .虚拟存储器的定义:虚拟存储器是只具有请求调入功能和置换功能,能从逻辑上对内存容量进行扩充的一种存储器系统。
3 .虚拟存储器的实现方式:分页请求系统,它是在分页系统的基础上,增加了请求调页功能、页面置换功能所形成的页面形式虚拟存储系统。
请求分段系统,它是在分段系统的基础上,增加了请求调段及分段置换功能后,所形成的段式虚拟存储系统。
4 .页面分配:平均分配算法,是将系统中所有可供分配的物理块,平均分配给各个进程。
按比例分配算法,根据进程的大小按比例分配物理块。
考虑优先的分配算法,把内存中可供分配的所有物理块分成两部分:一部分按比例地分配给各进程;另一部分则根据个进程的优先权,适当的增加其相应份额后,分配给各进程。
5 .页面置换算法:常用的页面置换算法有OPT、FIFO、LRU、Clock、LFU、PBA等。
四.设计思想:选择置换算法,先输入所有页面号,为系统分配物理块,依次进行置换:OPT基本思想:是用一维数组page[pSIZE]存储页面号序列,memery[mSIZE]是存储装入物理块中的页面。
C语言实现页面置换算法
![C语言实现页面置换算法](https://img.taocdn.com/s3/m/88f8272030126edb6f1aff00bed5b9f3f80f7253.png)
C语⾔实现页⾯置换算法本⽂实例为⼤家分享了C语⾔实现页⾯置换算法的具体代码,供⼤家参考,具体内容如下操作系统实验页⾯置换算法(FIFO、LRU、OPT)概念:1.最佳置换算法(OPT)(理想置换算法):从主存中移出永远不再需要的页⾯;如⽆这样的页⾯存在,则选择最长时间不需要访问的页⾯。
于所选择的被淘汰页⾯将是以后永不使⽤的,或者是在最长时间内不再被访问的页⾯,这样可以保证获得最低的缺页率。
2.先进先出置换算法(FIFO):是最简单的页⾯置换算法。
这种算法的基本思想是:当需要淘汰⼀个页⾯时,总是选择驻留主存时间最长的页⾯进⾏淘汰,即先进⼊主存的页⾯先淘汰。
其理由是:最早调⼊主存的页⾯不再被使⽤的可能性最⼤。
3.最近最久未使⽤(LRU)算法:这种算法的基本思想是:利⽤局部性原理,根据⼀个作业在执⾏过程中过去的页⾯访问历史来推测未来的⾏为。
它认为过去⼀段时间⾥不曾被访问过的页⾯,在最近的将来可能也不会再被访问。
所以,这种算法的实质是:当需要淘汰⼀个页⾯时,总是选择在最近⼀段时间内最久不⽤的页⾯予以淘汰。
题⽬:编写⼀个程序,实现本章所述的FIFO、LRU和最优页⾯置换算法。
⾸先,⽣成⼀个随机的页⾯引⽤串,其中页码范围为0-9.将这个随机页⾯引⽤串应⽤到每个算法,并记录每个算法引起的缺页错误的数量。
实现置换算法,⼀遍页⾯帧的数量可以从1~7。
#include <stdio.h>#include <stdlib.h>#include <time.h>int numbers[20]={7,0,1,2,0,3,0,4,2,3,0,3,2,1,2,0,1,7,0,1};//本地数据,与课本⼀致,⽅便测试int nums=0;//输⼊栈的个数,为了⽅便使⽤,int stack[20][7]={10};void begin();void randomnum();//⽤于产⽣随机数void init();//初始化void FIFO();//FIFO算法void LRU();//LRU算法void OPT();//最优页⾯置换算法(OPT)void print();//输出int main() {begin();FIFO();LRU();OPT();return 0;}void begin()//开始菜单界⾯{int i,j,k;printf("请输⼊页⾯帧的数量(1-7):");scanf("%d",&nums);for(k=0;;k++){printf("是否使⽤随机数产⽣输⼊串(0:是,1:否)");scanf("%d",&j);if(j==0){randomnum();break;}else if(j==1){break;}else{printf("请输⼊正确的选择!\n");}}printf("页⾯引⽤串为:\n");for(i=0;i<20;i++){printf("%d ",numbers[i]);}printf("\n");init();}void randomnum()//如果需要使⽤随机数⽣成输⼊串,调⽤该函数{srand(time(0));//设置时间种⼦for(int i = 0; i < 20; i++) {numbers[i] = rand() % 10;//⽣成区间0`9的随机页⾯引⽤串}}void init()//⽤于每次初始化页⾯栈中内容,同时⽅便下⾯输出的处理{int i,j;for(i=0;i<20;i++)for(j=0;j<nums;j++)stack[i][j]=10;}void print()//输出各个算法的栈的内容{int i,j;for(i=0;i<nums;i++){for(j=0;j<20;j++){if(stack[j][i]==10)printf("* ");elseprintf("%d ",stack[j][i]);}printf("\n");}}void FIFO()//FIFO算法{init();int i,j=1,n=20,k,f,m;stack[0][0]=numbers[0];for(i=1;i<20;i++){f=0;for(m=0;m<nums;m++){stack[i][m]=stack[i-1][m];}for(k=0;k<nums;k++){if(stack[i][k]==numbers[i]){n--;f=1;break;}}if(f==0){stack[i][j]=numbers[i];j++;}if(j==nums)j=0;}printf("\n");printf("FIFO算法:\n");print();printf("缺页错误数⽬为:%d\n",n);}void LRU()//LRU算法{int i,j,m,k,sum=1;int sequence[7]={0};//记录序列init();stack[0][0]=numbers[0];sequence[0]=nums-1;for(i=1;i<nums;i++)//前半部分,页⾯空置的情况{for(j=0;j<nums;j++){stack[i][j]=stack[i-1][j];}for(j=0;j<nums;j++){if(sequence[j]==0){stack[i][j]=numbers[i];break;}}for(j=0;j<i;j++)//将之前的优先级序列都减1{sequence[j]--;}sequence[i]=nums-1;//最近使⽤的优先级列为最⾼sum++;}for(i=nums;i<20;i++)//页⾯不空,需要替换的情况{int f;f=0;for(j=0;j<nums;j++){stack[i][j]=stack[i-1][j];}for(j=0;j<nums;j++)//判断输⼊串中的数字,是否已经在栈中 {if(stack[i][j]==numbers[i]){f=1;k=j;break;}}if(f==0)//如果页⾯栈中没有,不相同{for(j=0;j<nums;j++)//找优先序列中为0的{if(sequence[j]==0){m=j;break;}}for(j=0;j<nums;j++){sequence[j]--;}sequence[m]=nums-1;stack[i][m]=numbers[i];sum++;}else//如果页⾯栈中有,替换优先级{if(sequence[k]==0)//优先级为最⼩优先序列的{for(j=0;j<nums;j++){sequence[j]--;}sequence[k]=nums-1;}else if(sequence[k]==nums-1)//优先级为最⼤优先序列的{//⽆需操作}else//优先级为中间优先序列的{for(j=0;j<nums;j++){if(sequence[k]<sequence[j]){sequence[j]--;}}sequence[k]=nums-1;}}}printf("\n");printf("LRU算法:\n");print();printf("缺页错误数⽬为:%d\n",sum);}void OPT()//OPT算法{int i,j,k,sum=1,f,q,max;int seq[7]={0};//记录序列init();stack[0][0]=numbers[0];seq[0]=nums-1;for(i=1;i<nums;i++)//前半部分,页⾯空置的情况{for(j=0;j<nums;j++){stack[i][j]=stack[i-1][j];}for(j=0;j<nums;j++){if(seq[j]==0){stack[i][j]=numbers[i];break;}}for(j=0;j<i;j++)//将之前的优先级序列都减1{seq[j]--;}seq[i]=nums-1;//最近使⽤的优先级列为最⾼sum++;}for(i=nums;i<20;i++)//后半部分,页⾯栈中没有空的时候情况{//k=nums-1;//最近的数字的优先级for(j=0;j<nums;j++)//前⾯的页⾯中内容赋值到新的新的页⾯中{stack[i][j]=stack[i-1][j];}for(j=0;j<nums;j++){f=0;if(stack[i][j]==numbers[i]){f=1;break;}}if(f==0)//页⾯中没有,需要替换的情况{for(q=0;q<nums;q++)//优先级序列中最⼤的就是最久未⽤的,有可能出现后⾯没有在⽤过的情况 {seq[q]=20;}for(j=0;j<nums;j++)//寻找新的优先级{for(q=i+1;q<20;q++){if(stack[i][j]==numbers[q]){seq[j]=q-i;break;}}}max=seq[0];k=0;for(q=0;q<nums;q++){if(seq[q]>max){max=seq[q];k=q;}}stack[i][k]=numbers[i];sum++;}else{//页⾯栈中有需要插⼊的数字,⽆需变化,替换的优先级也不需要变化 }}printf("\n");printf("OPT算法:\n");print();printf("缺页错误数⽬为:%d\n",sum);}运⾏结果截图:以上就是本⽂的全部内容,希望对⼤家的学习有所帮助,也希望⼤家多多⽀持。
实验报告页面置换算法(c语言实现)
![实验报告页面置换算法(c语言实现)](https://img.taocdn.com/s3/m/ef50c1b058fb770bf78a55b7.png)
实验三页面置换算法#include<iostream.h>#include <stdlib.h>#include <time.h>#include <stdio.h>#define L 20int M; struct Proi nt num,time;};I nput(int m,Pro p[L]){i nt i,j,c;c out<<"请输入实际页面走向长度L(15<=L<=20):";d o{c in>>m;i f(m>20||m<15)cout<<"实际页面长度须在15~20之间;请重新输入L:";e lse break;}while(1);j=time(NULL);s rand(j);c out<<"输出随机数: ";f or(i=0;i<m;i++){p[i].num=rand( )%10+1;p[i].time=0;c out<<p[i].num<<" ";}c out<<endl;r eturn m;}v oid print(Pro *page1){P ro *page=new Pro[M];p age=page1;f or(int i=0;i<M;i++)i f(page[i].num==-1)c out<<" ";e lsec out<<page[i].num<<" ";c out<<"√"<<endl;}i nt Search(int e,Pro *page1 ){P ro *page=new Pro[M];p age=page1;f or(int i=0;i<M;i++) if(e==page[i].num) return i; r eturn -1;}i nt Max(Pro *page1){}i nt Count(Pro *page1,int i,int t,Pro p[L]){}i nt main(){i nt c;i nt m=0,t=0;f loat n=0;P ro p[L];c out<<"********************************************* "<<endl;c out<<" * 页式存储管理*"<<endl;c out<<"********************************************* "<<endl;c out<<"请输入可用内存页面数m(3~5): ";d o{c in>>M;i f(M>5||M<3)c out<<"内存块M须在3~5之间,请重新输入M:";e lse break;}while(1);m=Input(m,p);P ro *page=new Pro[M];c out<<"^-^欢迎进入操作系统界面^-^"<<endl;c out<<"1:FIFO页面置换"<<endl;c out<<"2:LRU页面置换"<<endl;c out<<"3:OPT页面置换"<<endl;c out<<"4:退出"<<endl;d o{c out<<"按1~4键操作:"<<endl;c in>>c;s ystem("cls");f or(int i=0;i<M;i++){p age[i].num=-1;p age[i].time=m-1-i;}i=0;i f(c==1){n=0;c out<<"******************************************"<<endl;c out<<endl;c out<<" FIFO算法页面置换情况如下: "<<endl;cout<<endl;c out<<"******************************************"<<endl;w hile(i<m){i f(Search(p[i].num,page)>=0) {cout<<p[i].num<<" "; p[i].numc out<<"不缺页"<<endl;i++;}e lse {i f(t==M)t=0;e lse{n++;p age[t].num=p[i].num;c out<<p[i].num<<" ";p rint(page);t++;i++;}}}c out<<"缺页次数:"<<n<<" }i f(c==2){n=0;c out<<"******************************************"<<endl;c out<<endl;c out<<" LRU算法页面置换情况如下: "<<endl;c out<<endl;c out<<"******************************************"<<endl;w hile(i<m){i nt a;t=Search(p[i].num,page);i f(t>=0){p age[t].time=0;for(a=0;a<M;a++)i f(a!=t)page[a].time++;cout<<p[i].num<<" ";c out<<"不缺页"<<endl;}e lse{n++; t=Max(page);page[t].num=p[i].num; page[t].time=0;cout<<p[i].num<<" ";p rint(page);f or(a=0;a<M;a++)i f(a!=t)page[a].time++;}i++;}c out<<"缺页次数:"<<n<<" 缺页率:"<<n/m<<endl;}i f(c==3){n=0;c out<<"******************************************"<<endl;c out<<endl;c out<<" OPT算法置换情况如下:"<<endl;c out<<endl;c out<<"******************************************"<<endl;w hile(i<m){i f(Search(p[i].num,page)>=0){c out<<p[i].num<<" ";c out<<"不缺页"<<endl;i++;}e lse{i nt a=0;f or(t=0;t<M;t++)i f(page[t].num==0)a++;if(a!=0) {i nt q=M;f or(t=0;t<M;t++)i f(page[t].num==0&&q>t)q=t;p age[q].num=p[i].num;n++;c out<<p[i].num<<" ";p rint(page);i++;}e lse{i nt temp=0,s;f or(t=0;t<M;t++)i f(temp<Count(page,i,t,p)){t emp=Count(page,i,t,p);s=t;}page[s].num=p[i].num;n++;c out<<p[i].num<<" ";p rint(page);i++;}}}c out<<"缺页次数:"<<n<<" 缺页率:"<<n/m<<endl;}i f(c==4){c out<<" ^-^再见!^-^ "<<endl;}}while(c==1||c==2||c==3||c==4);r eturn 0;}结果:完成相关实验并且获得预期结果.。
页面置换算法(FIFO算法,LRU算法)
![页面置换算法(FIFO算法,LRU算法)](https://img.taocdn.com/s3/m/c073ee2fed630b1c59eeb59e.png)
实验四页面置换算法一、实验流程图二、实验程序#include <stdio.h>#include <stdlib.h>#include <malloc.h>#define null 0#define len sizeof(struct page)struct page{ int num;int tag;struct page *next;};struct page *create(int n) /*建立分配的内存空间,并初始化,返回头结点*/{int count=1;struct page *p1,*p2,*head;head=p2=p1=(struct page *)malloc(len); //开辟一个新的单元,并将malloc返回的指针转换为结构体类型的指针p1->tag=-1;p1->num=-1;while(count<n){count++;p1=(struct page *)malloc(len);p1->tag=-1;p1->num=-1;p2->next=p1;p2=p1;}p2->next=null;return(head);}void FIFO(int array[],int n){int *p;struct page *cp,*dp,*head,*new1;int count=0;head=create(n);p=array;while(*p!=-1){ cp=dp=head;for(;cp->num!=*p&&cp->next!=null;) cp=cp->next;if (cp->num==*p) printf(" ! " );else{ count++;cp=head;for(;cp->tag!=-1&&cp->next!=null;) cp=cp->next;if(cp->tag==-1){cp->num=*p;printf(" * ");}else{new1=(struct page*)malloc(len);new1->num=*p;new1->tag=0;new1->next=null;cp->next=new1;head=head->next;printf(" %d ",dp->num);free(dp);}}p++;}printf("\nQueye Zongshu : %d \n",count);}void LRU(int array[],int n){int count=0,*p=array;struct page *head,*cp,*dp,*rp,*new1,*endp;head=create(n);while(*p!=-1){cp=dp=rp=endp=head;for(;endp->next!=null;) endp=endp->next;for(;cp->num!=*p&&cp->next!=null;){rp=cp;cp=cp->next;}if(cp->num==*p){printf(" ! ");if(cp->next!=null){if(cp!=head)rp->next=cp->next;else head=head->next;}endp->next=cp;cp->next=null;}else{count++;cp=rp=head;for(;cp->tag!=-1&&cp->next!=null;) cp=cp->next;{printf(" * ");cp->num=*p;cp->tag=0;}else{new1=(struct page *)malloc(len);new1->num=*p;new1->tag=0;new1->next=null;cp->next=new1;dp=head;head=head->next;printf(" %d ",dp->num);free(dp);}}p++;}printf("\nQueye Zongshu : %d \n",count);}OPT(int array[],int n){int *p,*q,count=0,i;struct page *head,*cp,*dp,*new1;p=array;head=create(n);while(*p!=-1){ cp=head;for(;cp->num!=*p&&cp->next!=null;) cp=cp->next;if(cp->num!=*p){ count++;cp=head;for(;cp->tag!=-1&&cp->next!=null;) cp=cp->next;if(cp->tag==-1){printf(" * ");cp->num=*p;cp->tag=0;}else{ i=1;q=p;q++;cp=head;while(*q!=-1&&i<n){ for(;*q!=cp->num&&cp->next!=null;) cp=cp->next;if(*q==cp->num){cp->tag=1;i++;}q++;cp=head;}if(i==n){for(;cp->tag!=0;) cp=cp->next;printf(" %d ",cp->num);cp->num=*p;}else{ cp=head;for(;cp->tag!=0;) cp=cp->next;if(cp==head){ for(;cp->next!=null;) cp=cp->next;new1=(struct page *)malloc(len);new1->num=*p;new1->tag=0;new1->next=null;cp->next=new1;dp=head;head=head->next;printf(" %d ",dp->num);free(dp);}else{ printf(" %d ",cp->num);cp->num=*p;}}cp=head;for(;cp->next!=null;) {cp->tag=0;cp=cp->next;}cp->tag=0;}}else printf(" ! ");p++;}printf("\nQueye Zongshu : %d \n",count);}main(){FILE *fp;char pt;char str[10];int i,j=0;int page[50],space=0;for(i=0;i<50;i++)page[i]=-1;fp=fopen("page.txt","r+");if(fp==NULL){printf("Cann't open the file\n");exit(0);}i=0;while((pt=fgetc(fp))!=EOF)/*将数字字符串转化成整型-开始*/ {if(pt>='0'&&pt<='9'){str[i]=pt;i++;space=0;}else{if(pt==' '||pt=='\n'){if(space==1) break;else{str[i]='\0';page[j]=atoi(str);if(pt=='\n') break;else{space=1;j++;i=0;}}}}}/*结束*/if(pt==EOF) {str[i]='\0';page[j]=atoi(str);}i=0;while(page[i]!=-1) {printf(" %d ",page[i]);i++;}fclose(fp);printf("\n");printf(" ! : mean no moved \n * : mean have free space \n\n"); printf("FIFO ");FIFO(page,3);printf("\nLRU ");LRU(page,3);printf("\nOPT ");OPT(page,3);}。
【操作系统】页面置换算法(最佳置换算法)(C语言实现)
![【操作系统】页面置换算法(最佳置换算法)(C语言实现)](https://img.taocdn.com/s3/m/2a5deb1c4b7302768e9951e79b89680203d86bea.png)
【操作系统】页⾯置换算法(最佳置换算法)(C语⾔实现)【操作系统】页⾯置换算法(最佳置换算法)(C语⾔实现)(编码⽔平较菜,写博客也只是为了个⼈知识的总结和督促⾃⼰学习,如果有错误,希望可以指出)1.页⾯置换算法:在地址映射过程中,若在页⾯中发现所要访问的页⾯不在内存中,则产⽣缺页中断。
当发⽣缺页中断时,如果操作系统内存中没有空闲页⾯,则操作系统必须在内存选择⼀个页⾯将其移出内存,以便为即将调⼊的页⾯让出空间。
⽽⽤来选择淘汰哪⼀页的规则叫做页⾯置换算法。
⼀个好的页⾯置换算法,应具有较低的页⾯更换频率。
从理论上讲,应该保留最近重复访问的页⾯,将以后都不再访问或者很长时间内不再访问的页⾯调出。
----百度百科2.具体的页⾯置换算法:2.1 最佳置换算法:⼀个进程在内存的若⼲个页⾯中,哪⼀个页⾯是未来最长时间内不再被访问的,那么如果发⽣缺页中断时,就将该页⾯换出,以便存放后⾯调⼊内存中的页⾯。
1.这是计算机操作系统(第四版)中的⼀个例⼦。
系统⾸先为进程分配了三个物理块。
上⾯⼀排数字是作业号。
在转满三个物理块后,要访问2号作业,2号作业不在内存,所以会发⽣缺页中断,然后系统需要将2号作业调⼊内存,但是此时物理块已经装满。
2.依据最佳置换算法,会将7号页换出(0号页在2号页后第1个就会被访问,1号页在2号页后第10个会被访问,7号页在2号页后第14个会被访问,7号页在已经装⼊内存的作业中是未来最长时间不会被访问的,所以换出7号页)。
3.后⾯依次类推。
2.2 先进先出算法:如果发⽣缺页中断,需要换出⼀个页⾯的时候,总是选择最早进⼊内存的页⾯,即选择在内存中驻留时间最久的页⾯进⾏换出。
有点不清楚。
就是每次发⽣缺页就将最早进⼊内存的页⾯换出,然后将刚调⼊的页⾯换⼊该物理块。
2.3 最近最久未使⽤(LRU)置换算法:LRU算法是缺页中断发⽣时选择最久未使⽤的页⾯进⾏换出。
这个算法其实也很好判断。
分享⼀个⼩技巧。
内存分配了k个物理块,发⽣缺页中断将要往内存调⼊某个页⾯的时候,在该页⾯往前⾯数K个物理块最前⾯的那个就会是要换出的,因为该页⾯最长时间未被使⽤过。
页面置换算法模拟程序-附代码
![页面置换算法模拟程序-附代码](https://img.taocdn.com/s3/m/7dcfddb284254b35effd3421.png)
目录1.问题的提出 (2)1.1关于页面置换算法模拟程序问题的产生 (2)1.2任务分析 (2)2.需求分析 (2)3.方案设计 (3)4.总体设计 (4)4.1程序N-S图 (4)4.2主要的函数 (4)4.3主要流程图及代码 (5)4.3.1 FIFO(先进先出) (5)4.3.2 LRU(最近最久未使用) (6)4.3.3 OPT(最佳置换算法) (8)4.4实现结果 (11)5.程序测试 (14)5.1设计测试数据 (14)5.2测试结果及分析 (15)摘要随着计算机的普及人们的物质生活得到了极大的满足,人们在精神生活方面同样也需要提高,所以越来越多的人进行着各种各样的学习。
操作系统是计算机教学中最重要的环节之一,也是计算机专业学生的一门重要的专业课程。
操作系统质量的好坏,直接影响整个计算机系统的性能和用户对计算机的使用。
一个精心设计的操作系统能极扩充计算机系统的功能,充分发挥系统中各种设备的使用效率,提高系统工作的可靠性。
由于操作系统涉及计算机系统中各种软硬件资源的管理,容比较繁琐,具有很强的实践性。
要学好这门课程,必须把理论与实践紧密结合,才能取得较好的学习效果.本课程设计是学生学习完《操作系统教程》课程后,进行的一次全面的综合训练,通过课程设计,让学生更好地掌握操作系统的原理及实现方法,加深对操作系统基础理论和重要算法的理解,加强学生的动手能力。
熟悉页面置换算法及其实现,引入计算机系统性能评价方法的概念。
关键词:编制页面置换算法模拟程序、打印页面、FIFO页面算法、LRU页面置换算法、OPT页面置换算法。
引言1.问题的提出1.1关于页面置换算法模拟程序问题的产生在各种存储器管理方式中,有一个共同的特点,即它们都要求将一个作业全部装入存方能运行,但是有两种情况:(1)有的作业很大,不能全部装入存,致使作业无法运行;(2)有大量作业要求运行,但存容量不足以容纳所有这些作业。
而虚拟存技术正式从逻辑上扩充存容量,将会解决以上两个问题。
页面置换算法模拟(原创)
![页面置换算法模拟(原创)](https://img.taocdn.com/s3/m/dfff4d4a767f5acfa1c7cdeb.png)
}
void destroy_blockBlock.front){
Block.front=Block.front->next;
free(Block.rear);
}
free(page);
}
void init_page()//初始化页面系列
printf("页面号*");
for(i=0;i < BlockSize;i++)
printf(" ");
printf(" * 是否缺页 *\n");
printf("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n");
for(i=0;i<PageCount;i++){
}
node=Block.front;
max_node_last=node;
while(node=node->next){//寻找Block中next_order值最大的节点的上一个节点
if(node == max_node)
break;
max_node_last=node;
}
return;
}
dequeue();
enqueue(page_index);
Block.miss_flag=1;
Block.miss_count++;
}
void OPT_Replace(int page_index)//OPT置换
{
BlockNode *node;
BlockNode *max_node,*max_node_last;
实验六 页面置换算法实现
![实验六 页面置换算法实现](https://img.taocdn.com/s3/m/9c807d90d0d233d4b14e6928.png)
计算机操作系统综合设计实验六实验名称:页面置换算法实现学号:学生姓名:班级:指导教师:实验地点:实验日期:评分:一、实验目的1)理解页面置换相关理论;2)掌握Clock置换算法和改进型Clock置换算法。
二、实验平台windows 10Visual C++ 6.0三、实验步骤1、实验内容1)设计页面置换相关数据结构;2)给一个进程设计多个(≥10)页面;3)设定为每个进程提供的页面数(≤5);4)可动态修改页面信息(包括调用标志和修改标志);5)实现改进型Clock页面置换算法;6)动态给出页面调用序列并进行调度;7)输出置换结果。
2、实验步骤1)输入代码A、打开Visual C++ 6.0;B、新建c++文件,创建basic.h头文件,并且创建clock.cpp;2)进行功能测试并得出正确结果A、编译、运行clock.cpp。
B、输入引用次数,以及页面号。
C、得到页面执行结果,以及缺页率。
3)clock置换函数程序流程图四、实验总结通过这次课程设计,加深了对操作系统的认识,了解了操作系统中各种资源分配算法的实现,特别是对虚拟存储,页面置换有了深入的了解,并能够用高级语言进行模拟演示。
对于clock函数的实现,起初根本不知道怎么下笔,但是认真分析了它的运作机制,就逐步清晰了。
通过浏览、阅读有关的资料,学到了很多东西。
一分耕耘,一分收获,这次的课程设计让我受益匪浅。
虽然自己所做的很少也不够完善,但毕竟也是努力的结果。
另外,使我体会最深的是:任何一门知识的掌握,仅靠学习理论知识是远远不够的,要与实际动手操作相结合才能达到功效。
操作系统之页面置换算法(最佳置换OPT,先进先出FIFO,最近最久未使用LRU)
![操作系统之页面置换算法(最佳置换OPT,先进先出FIFO,最近最久未使用LRU)](https://img.taocdn.com/s3/m/7bde8665ae1ffc4ffe4733687e21af45b307fea4.png)
操作系统之页⾯置换算法(最佳置换OPT,先进先出FIFO,最近最久未使⽤LRU)最近学习操作系统时,实验要求实现常见的三种页⾯置换算法,博主按照书上要求试着编写,实现了案例,并记录在博客随记中,以便后续⾃⼰复习并也给需要的同学分享参考⼀下!⽔平有限,若有错,请悄悄告诉博主!博主好⽴即改正。
最佳置换算法(optimal replacement,OPT)是从内存中选择今后不再访问的页⾯或者在最长⼀段时间后才需要访问的页⾯进⾏淘汰。
如下例⼦:根据页⾯⾛向依次处理,得到最终的置换结果如下图表,整个页⾯缺页次数为7,缺页率为7/12=58%。
1 #include <iostream>2 #include <stdio.h>3 #include <stdlib.h>4#define N 125#define B 36using namespace std;78int pageArr[N]={1,2,3,4,1,2,5,1,2,3,4,5};//页⾯⾛向9int block[B]={0};//物理块3个,其数值是页号10 typedef struct FLAG {11int flags[B];12int counts;13 } FLAG;1415void opt(int pageArr[],int block[]);16int inBlock(int which);17int findFar(int next);18void Replace(int index,int value);19void disPlay();2021int main(void){22 cout << "begin:" <<endl;23 opt(pageArr,block);24 cout << "end!" <<endl;25return0;26 }2728void opt(int pageArr[],int block[]){29int getIndex;30for(int i=0;i<N;i++){31if(i<3){//前3页号#短缺#进队列32 block[i]=pageArr[i];33 printf("缺页:(null)-->%d\n",pageArr[i]);34 }35else {36if(i==3){37 disPlay();3839 }40if(inBlock(pageArr[i])!=-1){//下⼀个页⾯if在物理块中返回index并跳过,反-141 disPlay();4243continue;44 }45 getIndex=findFar(i+1);//从下⼀个页号,找到最远出现的页⾯,替换的下标46if(getIndex==-1){47 cout<<"error,not replace obj!"<<'\t';48 }49else{50 Replace(getIndex,pageArr[i]);//由下标找到上⼀组替换⽬标,⽤第⼆参数替换51 disPlay();5253 }54 }55 }56return;57 }5859//替换block中的物理块60void Replace(int index,int value){61 printf("缺页:%d--被替换为-->%d\n",block[index],value);62 block[index]=value;63return;64 }656667//找到最远出现的页⾯68int findFar(int next){69int index=-1;//error,默认返回不存在的索引70 FLAG myflag;71 myflag.flags[0]=0;72 myflag.flags[1]=0;73 myflag.flags[2]=0;74 myflag.counts=0;75int stop = N-next;76while(stop--){77 index=inBlock(pageArr[next++]);78if(index!=-1){79 myflag.flags[index]=1;80 myflag.counts++;83break;84 }85 }86for(index=0;index<B;index++){87if(myflag.flags[index]==0)88break;89 }90return index;91 }929394//下⼀个页⾯if在物理块中返回index,反-195int inBlock(int which){96//int i=0;97//while(i<B)98// if(block[i++]==which)99// return i-1;100for(int i=0;i<B;i++){101if(block[i]==which)102return i;103 }104return -1;105 }106107//打印⼀元组108void disPlay(){109int i=0;110while(i<B){111 printf("%d\t",block[i++]);112 }113 printf("\n");114return;115 }上⾯是博主使⽤C++(基本是C语法)编写的代码,运⾏结果如下://////////////////////////////////////////////////////////////////////////begin:缺页:(null)-->1缺页:(null)-->2缺页:(null)-->31 2 3缺页:3--被替换为-->41 2 41 2 41 2 4缺页:4--被替换为-->51 2 51 2 51 2 5缺页:1--被替换为-->33 2 5缺页:3--被替换为-->44 2 54 2 5end!//////////////////////////////////////////////////////////////////////////先进先出算法:先进先出置换算法(first in first out,FIFO)是淘汰最先进⼊内存的页⾯,即选择在内存中驻留时间最长的页⾯进⾏淘汰的算法。
实验四 页面置换算法代码(一)
![实验四 页面置换算法代码(一)](https://img.taocdn.com/s3/m/cdf3f25202020740bf1e9b20.png)
实验四页面置换算法模拟(2)一.题目要求:设计一个虚拟存储区和存工作区,编程序演示下述算法的具体实现过程,并计算访问命中率:要求设计主界面以灵活选择某算法,且以下算法都要实现1) 最佳置换算法(OPT):将以后永不使用的或许是在最长(未来)时间不再被访问的页面换出。
2) 先进先出算法(FIFO):淘汰最先进入存的页面,即选择在存中驻留时间最久的页面予以淘汰。
3) 最近最久未使用算法(LRU):淘汰最近最久未被使用的页面。
4) 最不经常使用算法(LFU)二.实验目的:1、用C语言编写OPT、FIFO、LRU,LFU四种置换算法。
2、熟悉存分页管理策略。
3、了解页面置换的算法。
4、掌握一般常用的调度算法。
5、根据方案使算法得以模拟实现。
6、锻炼知识的运用能力和实践能力。
三.相关知识:1.虚拟存储器的引入:局部性原理:程序在执行时在一较短时间仅限于某个部分;相应的,它所访问的存储空间也局限于某个区域,它主要表现在以下两个方面:时间局限性和空间局限性。
2.虚拟存储器的定义:虚拟存储器是只具有请求调入功能和置换功能,能从逻辑上对存容量进行扩充的一种存储器系统。
3.虚拟存储器的实现方式:分页请求系统,它是在分页系统的基础上,增加了请求调页功能、页面置换功能所形成的页面形式虚拟存储系统。
请求分段系统,它是在分段系统的基础上,增加了请求调段及分段置换功能后,所形成的段式虚拟存储系统。
4.页面分配:平均分配算法,是将系统中所有可供分配的物理块,平均分配给各个进程。
按比例分配算法,根据进程的大小按比例分配物理块。
考虑优先的分配算法,把存中可供分配的所有物理块分成两部分:一部分按比例地分配给各进程;另一部分则根据个进程的优先权,适当的增加其相应份额后,分配给各进程。
5.页面置换算法:常用的页面置换算法有OPT、FIFO、LRU、Clock、LFU、PBA等。
四.设计思想:选择置换算法,先输入所有页面号,为系统分配物理块,依次进行置换:OPT基本思想:是用一维数组page[pSIZE]存储页面号序列,memery[mSIZE]是存储装入物理块中的页面。
页面置换算法
![页面置换算法](https://img.taocdn.com/s3/m/2febcb3031126edb6f1a10e0.png)
#include "windows.h"#include <conio.h>#include <stdlib.h>#include <fstream.h>#include <io.h>#include <string.h>#include <stdio.h>void initialize(); //初始化相关数据结构void createps(); //随机生成访问序列void displayinfo(); //显示当前状态及缺页情况void fifo(); //先进先出算法int findpage(); //查找页面是否在内存void lru(); //最近最久未使用算法int invalidcount = 0; // 缺页次数int vpoint; //页面访问指针int pageframe[10]; // 分配的页框int pagehistory[10]; //记录页框中数据的访问历史int rpoint; //页面替换指针int inpflag; //缺页标志,0为不缺页,1为缺页struct PageInfo //页面信息结构{int serial[100]; // 模拟的最大访问页面数,实际控制在20以上int flag; // 标志位,0表示无页面访问数据int diseffect; // 缺页次数int total_pf; // 分配的页框数int total_pn; // 访问页面序列长度} pf_info;//////////////////////////////////////////////////////////////////////////初始化相关数据结构void initialize(){int i,pf;inpflag=0; //缺页标志,0为不缺页,1为缺页pf_info.diseffect =0; // 缺页次数pf_info.flag =0; // 标志位,0表示无页面访问数据printf("\n请输入要分配的页框数:"); // 自定义分配的页框数scanf("%d",&pf);pf_info.total_pf =pf;for(i=0;i<100;i++) // 清空页面序列{pf_info.serial[i]=-1;}}///////////////////////////////////////////////////////////////////// 随机生成访问序列void createps(void ){int s,i,pn;initialize(); //初始化相关数据结构printf("\n请输入要随机生成访问序列的长度:"); //自定义随机生成访问序列的长度scanf("%d",&pn);srand(rand()); //初始化随机数队列的"种子"s=((float) rand() / 32767) * 50 + pn; // 随机产生页面序列长度pf_info.total_pn = s;for(i=0;i<s;i++) //产生随机访问序列{pf_info.serial[i]=((float) rand() / 32767) * 16 ; //随机数的大小在0-15之间}}////////////////////////////////////////////////////////////////////////// 显示当前状态及缺页情况void displayinfo(void){int i,n;if(vpoint==0){printf("\n=============页面访问序列=============\n");for(i=0; i<pf_info.total_pn; i++){printf("%4d",pf_info.serial[i]);if ((i+1) % 10 ==0) printf("\n"); //每行显示10个}printf("\n======================================\n");}printf("访问%3d : 内存<",pf_info.serial[vpoint]);for(n=0;n<pf_info.total_pf;n++) // 页框信息{if (pageframe[n] >=0)printf("%3d",pageframe[n]);elseprintf(" ");}printf(" >");if(inpflag==1) //缺页标志,0为不缺页,1为缺页{printf(" ==>缺页");printf("缺页率%3.1f",(float)(pf_info.diseffect)*100.00/vpoint);}printf("\n");}////////////////////////////////////////////////////////////////////////// 查找页面是否在内存,1为在内存,0为不在即缺页int findpage(int page){int n;for(n=0;n<pf_info.total_pf;n++){pagehistory[n] ++; // 访问历史加1}for(n=0;n<pf_info.total_pf;n++){if (pageframe[n]==page ){inpflag=0 ; //inpflag缺页标志,0为不缺页,1为缺页pagehistory[n]=0; //置访问历史为0return 1;}}inpflag=1; //页面不存在,缺页return 0;}////////////////////////////////////////////////////////////////////////// FIFO页面置换算法void fifo(void){int n,count,pstate;rpoint=0; // 页面替换指针初始化为0invalidcount = 0; // 缺页数初始化为0createps(); // 随机生成访问序列count=0; // 是否装满是所有的页框for(n=0;n<pf_info.total_pf;n++) // 清除页框信息{pageframe[n]=-1;}inpflag=0; //缺页标志,0为不缺页,1为缺页for(vpoint=0;vpoint<pf_info.total_pn;vpoint++) // 执行算法{pstate=findpage(pf_info.serial[vpoint]); //查找页面是否在内存if(count<pf_info.total_pf) // 开始时不计算缺页{if(pstate==0) // 页不存在则装入页面{pageframe[rpoint]=pf_info.serial[vpoint];rpoint=(rpoint+1) % pf_info.total_pf;count++;}}else // 正常缺页置换{if(pstate==0) // 页不存在则置换页面{pageframe[rpoint]=pf_info.serial[vpoint];rpoint=(rpoint+1) % pf_info.total_pf;pf_info.diseffect++; // 缺页次数加1}}Sleep(10);displayinfo(); // 显示当前状态} // 置换算法循环结束_getch();return;}///////////////////////////////////////////////////////////////////// LRU页面置换算法void lru(void){int n,count,pstate,max;rpoint=0; // 页面替换指针invalidcount = 0; // 缺页次数初始化为0createps(); // 随机生成访问序列count=0; // 是否装满所有的页框for(n=0;n<pf_info.total_pf;n++){pageframe[n]=-1; // 清除页框信息pagehistory[n]=0; // 清除页框历史}inpflag=0; //缺页标志,0为不缺页,1为缺页for(vpoint=0;vpoint<pf_info.total_pn;vpoint++) // 执行算法{pstate=findpage(pf_info.serial[vpoint]); //查找页面是否在内存if(count<pf_info.total_pf) // 开始时不计算缺页{if(pstate==0) // 页不存在则装入页面{pageframe[rpoint]=pf_info.serial[vpoint]; //把要调入的页面放入一个空的页框里rpoint=(rpoint+1) % pf_info.total_pf;count++;}}else // 正常缺页置换{if(pstate==0)// 页不存在则置换页面{max=0;for(n=1;n<pf_info.total_pf;n++){if(pagehistory[n]>pagehistory[max]){max=n;}}rpoint=max;pageframe[rpoint]=pf_info.serial[vpoint];pagehistory[rpoint]=0;pf_info.diseffect++; // 缺页次数加1}}Sleep(10);displayinfo(); // 显示当前状态} // 置换算法循环结束_getch();return;}///////////////////////////////////////////////////////////////////// 主函数int main(){char ch;system("cls") ;while ( true ){//printf("若要执行FIFO页面置算法请按"1"\n");//printf("若要执行LRU 页面置算法请按"2" \n");//printf("若要退出请按"3"\n");printf("*******************************************\n");printf( "Enter your choice (1 or 2 or 3): ");do{ //如果输入信息不正确,继续输入ch = (char)_getch() ;}while(ch != '1' && ch != '2'&& ch != '3');printf("\n\n你按的是:%c ,现在为你执行对应操作。
c语言实现页面置换
![c语言实现页面置换](https://img.taocdn.com/s3/m/5db87ba5f524ccbff12184a6.png)
#include "stdio.h"#include "stdlib.h"#define true 1#define false 0int wang;/*是否有元素*/int have(int a[],int t){int i=0,j=0;for(j=0;j<4;j++){if(a[j]==t){i=1; /*有元素*/break;}}return i;}/*先进先出页面置换算法*/void FIFO(int num[]){int i,j,k;int a[4]={-1,-1,-1,-1} ;for(i=0,j=0;i<20;i++){if(j<4){if(have(a,num[i])==0) a[j++]=num[i];}else{if(have(a,num[i])==0) {for(j=1;j<4;j++) a[j-1]=a[j]; a[3]=num[i];}}for(k=0;k<4;k++)printf(" %2d",a[k]); printf(" \n");}}/*最近最久未使用*/void LRU(int num[]){int i,j,k,temp;int a[4]={-1,-1,-1,-1} ;for(i=0;i<20;i++){if(i==0)a[0]=num[0];else{for(j=0;j<4;j++){if(a[j]==num[i]) break;}for(k=j;k>0;k--){a[k]=a[k-1];}a[0]=num[i];}for(k=0;k<4;k++)printf(" %2d",a[k]); printf(" \n");}}/*选择排序*/void SelectSort(int r[],int n){int i,j,temp;for(i=0;i<n;i++){for(j=i+1;j<n;j++) /*不考虑后面元素,可视从j往前的数据都是排好的*/ {if(r[i]>r[j])/*如果当前元素r[j]比索引指向的元素r[i]小,换位*/ {temp=r[i];r[i]=r[j];r[j]=temp;}}}}/*返回要置换的位置*/int del(int a[],int num[],int n){int i,j;int s[4]={0,0,0,0};int t[4]={0,0,0,0};for(i=0;i<4;i++){for(j=n;j<20;j++){if(a[i]==num[j]){s[i]=j;t[i]=j;break;}}if(j==20){ s[i]=20;t[i]=20;}}SelectSort(s,4);for(i=0;i<4;i++){if(t[i]==s[3])break;}return i;}/*最佳置换算法*/void Optimal(int num[]){int i,j,k,temp;int a[4]={-1,-1,-1,-1} ;for(i=0,j=0;i<20;i++){if(j<4){if(have(a,num[i])==0) a[j++]=num[i];}else{if(have(a,num[i])==0) {temp=del(a,num,i); a[temp]=num[i];}}for(k=0;k<4;k++)printf(" %2d",a[k]); printf(" \n");}}void main(){loop: /* 循环 */{char ch;int i;int num[20];/*初始化页面调用数组*/for(i=0;i<20;i++){num[i]=rand()%10;printf(" %d",num[i]);}printf("\n");printf("----------------------------------\n");printf(" 1---FIFO;2---LRU;3---Optimal\n");printf("----------------------------------\n\n");printf("intput the NO. :");i=0;scanf("%d",&i);printf("\n [1] [2] [3] [4]\n");switch (i){case 1:FIFO(num);break;case 2:LRU(num); break;case 3:Optimal(num);break;default:printf("input wrong No.!!!");}printf("again?(y or n)\ninput:");loop_1:{ch=getch();if(ch=='y') /* y 再次输入 */goto loop;else if(ch=='n') /* n 退出 */exit(0);else /* 都不是提示输入错误 */{printf("\ninput wrong!again please!!!\ninput:"); goto loop_1;}}}}。
页面置换
![页面置换](https://img.taocdn.com/s3/m/0ab43906b52acfc789ebc97f.png)
#include"stdio.h"#include"stdlib.h"#include"malloc.h"#include"iostream.h"#define null 0#define len sizeof(struct page)struct page{int num;int tag;struct page *next;};struct page *create(int n){int count=1;struct page *p1,*p2,*head;head=p2=p1=(struct page *)malloc(len);p1->tag=-1;p1->num=-1;while(count<n){count++;p1=(struct page *)malloc(len);p1->tag=-1;p1->num=-1;p2->next=p1;p2=p1;}p2->next=null;return(head);}void FIFO(int array[],int n){int *p;struct page *cp,*dp,*head,*new1;int count=0;head=create(n);p=array;while(*p!=-1){cp=dp=head;for(;cp->num!=*p&&cp->next!=null;)cp=cp->next;if(cp->num==*p)printf("!");else{count++;cp=head;for(;cp->tag!=-1&&cp->next!=null;)cp=cp->next;if(cp->tag==-1){cp->num=*p;cp->tag=0;printf("*");}else{new1=(struct page*)malloc(len);new1->num=*p;new1->tag=0;new1->tag=null;cp->next=new1;head=head->next;printf("%d",dp->num);free(dp);}}p++;}printf("\nQueye Zongshu:%d\n",count);}void LRU(int array[],int n){int count=0,*p=array;struct page *head,*cp,*dp,*rp,*new1,*endp;head=create(n);while(*p!=-1){cp=dp=rp=endp=head;for(;endp->next!=null;)endp=endp->next;for(;cp->num!=*p&&cp->next!=null;){rp=cp;cp=cp->next;}if(cp->num==*p){printf("!");if(cp->next!=null){if(cp!=head)rp->next=cp->next;else head=head->next;}endp->next=cp;cp->next=null;}else{count++;cp=rp=head;for(;cp->tag!=-1&&cp->next!=null;)cp=cp->next;if(cp->tag==-1){printf("*");cp->num=*p;cp->tag=0;}else{new1=(struct page*)malloc(len);new1->num=*p;new1->tag=0;new1->next=null;cp->next=new1;dp=head;head=head->next;printf("%d",dp->num);free(dp);}}p++;}printf("\nQueye Zongshu:%d\n",count);}void OPT(int array[],int n){int *p,*q,count=0,i;struct page *head,*cp,*dp,*new1;p=array;head=create(n);while(*p!=-1){cp=head;for(;cp->num!=*p&&cp->next!=null;)cp=cp->next;if(cp->num!=*p){cp=head;for(;cp->tag!=-1&&cp->next!=null;)cp=cp->next;if(cp->tag==-1){printf("*");cp->num=*p;cp->tag=0;}else{i=1;q=p;q++;cp=head;while(*q!=-1&&i<n){for(;*q!=cp->num&&cp->next!=null;)cp=cp->next;if(*q==cp->num){cp->tag=1;i++;}q++;cp=head;}if(i==n){for(;cp->tag!=0;)cp=cp->next;printf("%d",cp->num);cp->num=*p;}else{cp=head;for(;cp->tag!=0;)cp=cp->next;if(cp==head){for(;cp->next!=null;)cp=cp->next;new1=(struct page *)malloc(len);new1->num=*p;new1->tag=0;new1->next=null;cp->next=new1;dp=head;head=head->next;printf("%d",dp->num);free(dp);else{printf("%d",cp->num);cp->num=*p;}}cp=head;for(;cp->next!=null;){cp->tag=0;cp=cp->next;}cp->tag=0;}}else printf("!");p++;}printf("\nQueye Zongshu:%d\n",count);}void main(){FILE *fp;char pt;char str[10];int i,j=0;int page[50],space=0;for(i=0;i<50;i++)page[i]=-1;fp=fopen("page.txt","r+");if(fp==NULL){printf("Cann't open the file\n");exit(0);}i=0;while((pt=fgetc(fp))!=EOF){if(pt>='0'&&pt<='9'){str[i]=pt;i++;space=0;}else{if(pt==' '||pt=='\n'){if(space==1)break;else{str[i]='\0';page[j]=atoi(str);if(pt=='\n')break;else{space=1;j++;i=0;}}}}}if(pt==EOF){str[i]='\0';page[j]=atoi(str);}i=0;while(page[i]!=-1){printf("%d",page[i]);i++;}fclose(fp);printf("\n");printf("!:mean no moved\n*:mean have free space\n\n"); printf("FIFO");FIFO(page,3);printf("\nLRU");LRU(page,3);printf("\nOPT");OPT(page,3);}。
(完整word版)页面置换算法OPT+FIFO+LRU+clock
![(完整word版)页面置换算法OPT+FIFO+LRU+clock](https://img.taocdn.com/s3/m/f73b597676c66137ef061944.png)
#include<iostream>#include<fstream>using namespace std;#define BlockSize 10#define PageSize 100int page[PageSize]; //页面数组存放页面int block[BlockSize]; //物理块数组int result[PageSize][BlockSize]; //存放页面和物理块二维数组int pSize = 0; //用户使用页面数int bSize = 0; //用户使用物理块数int blockFlag[BlockSize]; //用于LRU与最佳置换算法中,辅助判断该换出的页面int noPageCount = 0; //缺页次数//输入数据void inputData(){cout<<endl<<"请输入物理块数(1<=bSize<="<<BlockSize<<')'<<endl;cin>>bSize;cout<<"请输入页面数(1<=pSize<="<<PageSize<<')'<<endl;cin>>pSize;while(bSize<=0||bSize>BlockSize||pSize<=0||pSize>PageSize){//判断用户输入是否在范围内cout<<"输入范围错误,请重新输入:"<<endl;cout<<"请输入物理块数(1<=F<="<<BlockSize<<')';cin>>bSize;cout<<endl<<"请输入页面数(1<=p<="<<PageSize<<')';cin>>pSize;}cout<<"请输入页面走向"<<endl;for(int i = 0;i <pSize;i++)cin>>page[i];}//初始化page数组void initPage(){for(int i = 0;i<PageSize;i++)page[i] = -1;}//初始化block与result数组void initBlockResult(){int i = 0;for(i = 0;i<BlockSize;i++)block[i] = -1;for(i = 0;i < PageSize;i++)for(int j = 0; j < BlockSize;j++)result[i][j] = -1;}//查找物理块中是否存在要调用的页面int Exist(int i){for(int j = 0;j < bSize;j++)if(block[j] == i)return j;return -1;}//显示结果void display(int noPageCount){for(int i =0 ;i < pSize;i++){cout<<" "<<page[i]<<" ";for(int j = 0;j < bSize;j++){if(result[i][j] == -1) break;else cout<<'['<<result[i][j]<<']'<<' ';}cout<<endl;}cout<<"____________________________________"<<endl;cout<<endl<<"缺页次数:"<<noPageCount<<endl;cout<<"缺页率:"<<((double)noPageCount/pSize)*100<<'%'<<endl;cout<<"===================================="<<endl;}//最佳置换算法OPTvoid OPT(){int i = 0,j = 0;int position = 0,noPageCount = 0;int pageFlag = 0,resultFlag = 0; //页面标记(下标)指向下一个页面,结果标记表示结果的行,即result数组的行标for(i = 0;i < BlockSize;i++)blockFlag[i] = 0;while(pageFlag < pSize){if(Exist(page[pageFlag]) != -1) //判断页面是否已经存在resultFlag++;else{if(position < bSize) //判断有无空闲物理块{ //若有则将页面放入空闲块block[position] = page[pageFlag];position++;noPageCount++;for(i = 0;i < position;i++)result[resultFlag][i] = block[i];resultFlag++;}else{for(i = 0;i < bSize;i++){for(j = pageFlag+1;j < pSize;j++){if(block[i] == page[j]){blockFlag[i] = j;break;}}if(j == pSize) blockFlag[i] = 999;}int optPos = 0,max = blockFlag[0];for(int i = 0;i < bSize;i++)if(max < blockFlag[i]){max = blockFlag[i];optPos = i;}block[optPos] = page[pageFlag];noPageCount++;for(i = 0;i < bSize;i++)result[resultFlag][i] = block[i];resultFlag++;}}pageFlag++;}cout<<endl<<"最佳置换算法:"<<endl;display(noPageCount);return;}//先进先出页面置换算法FIFOvoid FIFO(){int blockFlag = 0,pageFlag = 0,resultFlag = 0; //物理块标记,确定该换出的物理块下标int i = 0,j = 0,noPageCount = 0;int position = 0; //指示物理块,查找有无空闲while (pageFlag < pSize){if(Exist(page[pageFlag]) != -1)resultFlag++;else{if(position < bSize){block[position] = page[pageFlag];position++;noPageCount++;for(i = 0;i <= position;i++)result[resultFlag][i] = block[i];resultFlag++;}else{block[blockFlag] = page[pageFlag]; //blockFlag指示要换出的页面noPageCount++;for(i = 0;i < bSize;i++)result[resultFlag][i] = block[i];resultFlag++;blockFlag++;blockFlag = blockFlag % bSize;}}pageFlag++;}cout<<endl<<"先进先出页面置换算法FIFO:"<<endl;display(noPageCount);return;}//最近最久未用算法LRUvoid LRU(){int i = 0,noPageCount = 0;int pageFlag = 0,resultFlag = 0,position = 0;for(i = 0;i < BlockSize;i++) //初始化时间记录数组blockFlag[i] = 0;while(pageFlag < pSize){if(Exist(page[pageFlag]) != -1){ //判断页面是否已经在主存中resultFlag++;blockFlag[Exist(page[pageFlag])] = 0; //若在则将时间记录数组对应位置为0 }else{if(position < bSize){block[position] = page[pageFlag];blockFlag[position] = 0;position++;noPageCount++;for(i = 0;i <= position;i++)result[resultFlag][i] = block[i];resultFlag++;}else{int last = 0,min = blockFlag[0];for(int i = 0;i < bSize;i++)if(min < blockFlag[i]){min = blockFlag[i];last = i;}block[last] = page[pageFlag]; //置换最久未用页面blockFlag[last] = 0;noPageCount++;for(i = 0;i < bSize;i++)result[resultFlag][i] = block[i];resultFlag++;}}for(i = 0;i < bSize;i++)blockFlag[i]++;pageFlag++;}cout<<endl<<"最近最久未用算法LRU:"<<endl;display(noPageCount);return;}//时钟(clock)置换算法void clock(){int i = 0,position = 0,noPageCount = 0;bool boolBlockFlag[BlockSize];int flag = 0; //访问位循环标记int pageFlag = 0,resultFlag = 0;while(pageFlag < pSize){if(Exist(page[pageFlag]) != -1){resultFlag++;boolBlockFlag[Exist(page[pageFlag])] = true;}else{if(position < bSize){block[position] = page[pageFlag];noPageCount++;boolBlockFlag[position] = true;position++;for(i = 0;i < position;i++)result[resultFlag][i] = block[i];resultFlag++;}else{while(true){ //无限循环,找出访问位为false 的页面if(boolBlockFlag[flag] == false) break;boolBlockFlag[flag] = false; //若为true,置为falseflag++;flag = flag%bSize;}block[flag] = page[pageFlag];boolBlockFlag[flag] = true;flag++;flag = flag%bSize;noPageCount++;for(i = 0;i < position;i++)result[resultFlag][i] = block[i];resultFlag++;}}pageFlag++;}cout<<endl<<"时钟(clock)置换算法:"<<endl;display(noPageCount);return;}int main(){initPage();int func;while(func!=5){cout<<"请选择所需要的功能:"<<endl;cout<<"0.输入数据"<<endl;cout<<"1.最佳(optimal)置换算法"<<endl;cout<<"2.先进先出(FIFO)置换算法"<<endl;cout<<"3.最近最久未用(LRU)置换算法"<<endl;cout<<"4.时钟(clock)置换算法"<<endl;cout<<"5.退出"<<endl;switch(func){case 0:inputData();break;case 1:initBlockResult();OPT();break;case 2:initBlockResult();FIFO();break;case 3:initBlockResult();LRU();break;case 4:initBlockResult();clock();break;case 5:break;}cout<<"请选择功能:";cin>>func;system("cls");}return 0;}。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
实验原理:
在内存运行过程中,若其所要访问的页面不在内存而需要把他们调入内存,但内存已经没有空闲空间时,为了保证该进程能正常运行,系统必须从内存中调出一页程序或数据送磁盘的对换区中。
但应将那个页面调出,需根据一定的算法来确定。
通常,把选择换出页面的算法成为页面置换算法。
置换算法的好坏,将直接影响到系统的性能。
一个好的页面置换算法,应具有较低的页面更换频率。
从理论上讲,应将那些以后不再会访问的页面置换出,或者把那些在较长时间内不会在访问的页面调出。
目前存在着许多种置换算法(如FIFO,OPT,LRU),他们都试图更接近理论上的目标。
实验目的:
1.熟悉FIFO,OPT和LRU算法
2.比较三种算法的性能优劣
实验内容:
写出FIFO,OPT和LRU算法的程序代码,并比较它们的算法性能。
实验步骤:
代码如下:
#include <stdio.h>
#define M 4 //物理页数
#define N 20 //需要调入的页数
typedef struct page
{
int num;
int time;
}Page; //物理页项,包括调入的页号和时间
Page mm[M]; //4个物理页
int queue1[20],queue2[20],queue3[20]; //记录置换的页int K=0,S=0,T=0; //置换页数组的标识
int pos=0;//记录存在最长时间项
//初始化内存页表项及存储内存情况的空间
void INIT(){
int i;
for(i=0;i<M;i++){
mm[i].num =-1;
mm[i].time =0;
}
}
//取得内存中存在时间最久的位置
int GetMax(){
int max=-1;
int i;
for(i=0;i<M;i++){
if(mm[i].time > max){
max=mm[i].time ;
pos=i;
}
}
return pos;
}
//检查最长时间不使用页面
int longesttime(int fold)
.
{
int i;
int max=-1;
for(i=fold;i<N;i++){
if(mm[0].num!=i){
mm[0].time++;
}
if(mm[1].num!=i){
mm[1].time++;
}
if(mm[2].num!=i){
mm[2].time++;
}
if(mm[3].num!=i){
mm[3].time++;
}
}
for(i=0;i<M;i++){
if(mm[i].time>max){
max=mm[i].time;
pos=i;
}
}
return pos;
}
//检查某页是否在内存
int Equation(int fold){
int i;
.
for(i=0;i<M;i++){
if(mm[i].num == fold)
return i;
}
return -1;
}
//检查物理内存是否已满,-1表满,其他不满int Check(){
int i;
for(i=0;i<M;i++){
if(mm[i].num == -1)
return i;
}
return -1;
}
//先进先出
void FIFO(int fold){
int i;
int a,b,c;
a=Equation(fold);
//页已存在
if(a != -1){}
//页不存在
else{
b=Check();
//内存还有空闲
.
if(b != -1){
mm[b].num = fold;
}
//内存已满,需要置换
else {
c=GetMax();
mm[c].num = fold;
mm[c].time = 0;
}
queue1[K++]=fold;
}
for(i=0;i<M;i++){
if(mm[i].num != -1){
mm[i].time ++;
}
}
}
void OPT(int fold)
{
int a,b,c;
a=Equation(fold);
if(a == -1){//页不在内存
b=Check();
//内存还有空闲
if(b != -1){
mm[b].num = fold;
}
//内存已满,需要置换
else{
c=longesttime(fold);
mm[c].num = fold;
mm[c].time = 0;
}
queue3[T++]=fold;
}
}
void LRU(int fold)
{
int i;
int a,b;
int p;
a=Equation(fold);
if(a != -1)//页已在内存
{
//把此项移动到链表最后一项
if(a==3)//此项已经在最后,不需要做任何改动return;
else
{
p=Equation(-1);
if(p==-1)//链表是满的
{
for(;a<3;a++)
mm[a].num=mm[a+1].num;
mm[3].num=fold;
}
else if(p<=3)//链表不满
{
for(;a<p-1;a++)
mm[a].num=mm[a+1].num;
mm[a].num=fold;
}
}
}
else
{
b=Check();
if(b!=-1)//不满
mm[b].num=fold;
else
{
for(i=0;i<3;i++)
mm[i].num=mm[i+1].num;
mm[3].num=fold;
}
queue2[S++]=fold;
}
}
void main()
{
int A[N],B[N];
int i;
INIT();
printf("请依次输入%d个页面号:\n",N);
for(i=0;i<N;i++){
scanf("%d",&A[i]);
}
//FIFO
for(i=0;i<N;i++){
B[i]=A[i];
}
for(i=0;i<N;i++){
FIFO( B[i] );
}
printf("FIFO的");
printf("调入队列为:");
for(i=0;i<K;i++)
printf("%3d",queue1[i]);
printf("\n缺页次数为:%6d\n缺页率:%16.6f\n\n",K,(float)K/N);
//LRU
INIT();
for(i=0;i<N;i++){
B[i]=A[i];
}
for(i=0;i<N;i++){
LRU( B[i] );
}
printf("LRU的");
printf("调入队列为:");
for(i=0;i<S;i++)
printf("%3d",queue2[i]);
printf("\n缺页次数为:%6d\n缺页率:%16.6f\n\n",S,(float)S/N);
//OPT
INIT();
for(i=0;i<N;i++){
B[i]=A[i];
}
for(i=0;i<N;i++){
OPT( B[i] );
}
printf("OPT的");
printf("调入队列为:");
for(i=0;i<T;i++)
printf("%3d",queue3[i]);
printf("\n缺页次数为:%6d\n缺页率:%16.6f\n\n",T,(float)T/N);
}
如有侵权请联系告知删除,感谢你们的配合!。