C++模拟LRU页面置换算法
LRU页面置换算法模拟程序

#include<stdio.h>#include<conio.h>#define M 4#define N 17#define Myprintfprintf("|---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---|\n") /*表格控制*/typedef struct page{int num; /*记录页面号*/int time; /*记录调入内存时间*/}Page; /* 页面逻辑结构,结构为方便算法实现设计*/Page b[M]; /*内存单元数*/int c[M][N]; /*暂保存内存当前的状态:缓冲区*/int queue[100]; /*记录调入队列*/int K; /*调入队列计数变量*//*初始化内存单元、缓冲区*/void Init(Page *b,int c[M][N]){int i,j;for(i=0;i<N;i++){b[i].num=-1;+b[i].time=N-i-1;}for(i=0;i<M;i++)for(j=0;j<N;j++)c[i][j]=-1;}/*取得在内存中停留最久的页面,默认状态下为最早调入的页面*/ int GetMax(Page *b){int i;int max=-1;int tag=0;for(i=0;i<M;i++){if(b[i].time>max){max=b[i].time;tag=i;}}return tag;}/*判断页面是否已在内存中*/int Equation(int fold,Page *b){int i;for(i=0;i<M;i++){if (fold==b[i].num)return i;}return -1;}/*LRU核心部分*/void Lru(int fold,Page *b){ int i;int val;val=Equation(fold,b);if (val>=0){b[val].time=0;for(i=0;i<M;i++)if (i!=val)b[i].time++;}else{queue[++K]=fold;/*记录调入页面*/val=GetMax(b);b[val].num=fold;b[val].time=0;for(i=0;i<M;i++)if (i!=val)b[i].time++;}}/*主程序*/void main(){int a[N]={1,0,1,0,2,4,1,0,0,8,7,5,4,3,2,3,4};int i,j;start: K=-1;Init(b, c);for(i=0;i<N;i++){Lru(a[i],b);c[0][i]=a[i];/*记录当前的内存单元中的页面*/ for(j=0;j<M;j++)c[j][i]=b[j].num;}/*结果输出*/printf("内存状态为:\n");Myprintf;for(j=0;j<N;j++)printf("|%2d ",a[j]);printf("|\n");Myprintf;for(i=0;i<M;i++){ for(j=0;j<N;j++){if(c[i][j]==-1)printf("|%2c ",32);elseprintf("|%2d ",c[i][j]); }printf("|\n");}Myprintf;printf("\n调入队列为:");for(i=0;i<K+1;i++)printf("%3d",queue[i]);printf("\n缺页次数为:%6d\n缺页率:%16.6f",K+1,(float)(K+1)/N); printf("\nAre you continuing!\ty?");if(getche()=='y')goto start;}。
页面置换算法(FIFO,LRU,最佳,Clock)

#include<iostream>using namespace std;void Print(int bc[],int blockCount){for(int i=0;i<blockCount;i++){cout<<bc[i]<<" ";}cout<<endl;}bool Travel(int bc[],int blockCount,int x){bool is_found=false;int i;for(i=0;i<blockCount;i++){if(bc[i]==x){is_found=true;break;}}return is_found;}void FIFO(int pc[],int bc[],int pageCount,int blockCount) {cout<<"0:FIFO置换算法"<<endl;int i;if(pageCount<=blockCount){cout<<"缺页次数为"<<0<<endl;cout<<"缺页率为"<<0<<endl;}else{int noPage=0;int p=0;for(i=0;i<pageCount;i++){cout<<"引用页:"<<pc[i]<<endl;if(!Travel(bc,blockCount,pc[i])){if(i<blockCount){bc[i]=pc[i];}else{if(p==blockCount){p=0;}bc[p]=pc[i];p++;}noPage++;cout<<"物理快情况:";Print(bc,blockCount);}cout<<endl;}cout<<"缺页次数为:"<<noPage<<endl;cout<<"缺页率为:"<<(float)noPage/pageCount<<endl;}}int FoundMaxNum(int a[],int n){int k,j;k=a[0];j=0;for (int i=0;i<n;i++){if(a[i]>=k){k=a[i];j=i;}}return j;}void LRU(int pc[],int bc[],int pageCount,int blockCount){cout<<"1:LRU置换算法"<<endl;if(pageCount<=blockCount){cout<<"缺页次数为"<<0<<endl;cout<<"缺页率为"<<0<<endl;}else{int noPage=0;int i,j,m;int *bc1=new int[blockCount];for(i=0;i<blockCount;i++){bc1[i]=0;}for(i=0;i<pageCount;i++){cout<<"引用页:"<<pc[i]<<endl;if(!Travel(bc,blockCount,pc[i])){if(i<blockCount){bc[i]=pc[i];for(int p=0;p<=i;p++){bc1[p]++;}}else{for(j=0;j<blockCount;j++){bc1[j]++;}int k=FoundMaxNum(bc1,blockCount);bc[k]=pc[i];bc1[k]=1;}noPage++;cout<<"物理快情况:";Print(bc,blockCount);}else if(Travel(bc,blockCount,pc[i])){if(i<blockCount){for(j=0;j<=i;j++){bc1[j]++;}for(m=0;m<=i;m++){if(bc[m]==pc[i]){break;}}bc1[m]=1;bc[m]=pc[i];}else{for(j=0;j<blockCount;j++){bc1[j]++;}for(m=0;m<blockCount;m++){if(bc[m]==pc[i]){break;}}bc1[m]=1;bc[m]=pc[i];}}cout<<endl;}cout<<"缺页次数为:"<<noPage<<endl;cout<<"缺页率为:"<<(float)noPage/pageCount<<endl;delete bc1;}}void Optiomal(int pc[],int bc[],int pageCount,int blockCount){cout<<"2:最佳置换算法"<<endl;if(pageCount<=blockCount){cout<<"缺页次数为"<<0<<endl;cout<<"缺页率为"<<0<<endl;}else{int noPage=0;int i,j,k;for(i=0;i<pageCount;i++){cout<<"引用页:"<<pc[i]<<endl;if(!Travel(bc,blockCount,pc[i])){if(i<blockCount){bc[i]=pc[i];}else{int max=0;int blockIndex;;for(j=0;j<blockCount;j++){for(k=i;k<pageCount;k++){if(bc[j]==pc[k]){break;}}if(k>=max){max=k;blockIndex=j;}}bc[blockIndex]=pc[i];}noPage++;cout<<"物理快情况:";Print(bc,blockCount);}cout<<endl;}cout<<"缺页次数为:"<<noPage<<endl;cout<<"缺页率为:"<<(float)noPage/pageCount<<endl;}}void NRU(int pc[],int bc[],int pageCount,int blockCount){cout<<"3:Clock置换算法"<<endl;if(pageCount<=blockCount){cout<<"缺页次数为"<<0<<endl;cout<<"缺页率为"<<0<<endl;}else{int noPage=0;int i,j;int *bc1=new int[blockCount];for(i=0;i<blockCount;i++){bc1[i]=0;}for(i=0;i<pageCount;i++){cout<<"引用页:"<<pc[i]<<endl;if(!Travel(bc,blockCount,pc[i])){for(j=0;j<blockCount;j++){if(bc1[j]==1){bc1[j]=0;}else if(bc1[j]==0){break;}if(j==blockCount-1){j=-1;}}bc[j]=pc[i];bc1[j]=1;noPage++;cout<<"物理快情况:";Print(bc,blockCount);}cout<<endl;}cout<<"缺页次数为:"<<noPage<<endl;cout<<"缺页率为:"<<(float)noPage/pageCount<<endl;delete bc1;}}int main(){int pageCount,blockCount,i;cout<<"输入页面数"<<endl;cin>>pageCount;int *pc=new int[pageCount];cout<<"输入页面走向"<<endl;for(i=0;i<pageCount;i++){cin>>pc[i];}cout<<"输入物理块数"<<endl;cin>>blockCount;cout<<"0:FIFO置换算法"<<endl;cout<<"1:LRU置换算法"<<endl;cout<<"2:最佳置换算法"<<endl;cout<<"3:Clock置换算法"<<endl;cout<<"按数字选择算法类别:"<<endl;int n;while(cin>>n){if(n==0){int *bc=new int[blockCount];FIFO(pc,bc,pageCount,blockCount);delete bc;}else if(n==1){int *bc=new int[blockCount];LRU(pc,bc,pageCount,blockCount);delete bc;}else if(n==2){int *bc=new int[blockCount];Optiomal(pc,bc,pageCount,blockCount);delete bc;}else if(n==3){int *bc=new int[blockCount];for(i=0;i<blockCount;i++){bc[i]=-1;}NRU(pc,bc,pageCount,blockCount);delete bc;}else break;}delete pc;return 0;}。
操作系统课程设计页面置换算法C语言

操作系统课程设计页⾯置换算法C语⾔操作系统课程设计页⾯置换算法C语⾔页⾯置换算法⼀.题⽬要求:经过实现页⾯置换算法的FIFO和LRU两种算法,理解进程运⾏时系统是怎样选择换出页⾯的,对于两种不同的算法各⾃的优缺点是哪些。
要求设计主界⾯以灵活选择某算法,且以下算法都要实现1) 最佳置换算法(OPT):将以后永不使⽤的或许是在最长(未来)时间内不再被访问的页⾯换出。
2) 先进先出算法(FIFO):淘汰最先进⼊内存的页⾯,即选择在内存中驻留时间最久的页⾯予以淘汰。
3) 最近最久未使⽤算法(LRU):淘汰最近最久未被使⽤的页⾯。
4) 最不经常使⽤算法(LFU)⼆.实验⽬的:1、⽤C语⾔编写OPT、FIFO、LRU,LFU四种置换算法。
2、熟悉内存分页管理策略。
3、了解页⾯置换的算法。
4、掌握⼀般常见的调度算法。
5、根据⽅案使算法得以模拟实现。
6、锻炼知识的运⽤能⼒和实践能⼒。
三、设计要求1、编写算法,实现页⾯置换算法FIFO、LRU;2、针对内存地址引⽤串,运⾏页⾯置换算法进⾏页⾯置换;3、算法所需的各种参数由输⼊产⽣(⼿⼯输⼊或者随机数产⽣);4、输出内存驻留的页⾯集合,页错误次数以及页错误率;四.相关知识:1.虚拟存储器的引⼊:局部性原理:程序在执⾏时在⼀较短时间内仅限于某个部分;相应的,它所访问的存储空间也局限于某个区域,它主要表现在以下两个⽅⾯:时间局限性和空间局限性。
2.虚拟存储器的定义:虚拟存储器是只具有请求调⼊功能和置换功能,能从逻辑上对内存容量进⾏扩充的⼀种存储器系统。
3.虚拟存储器的实现⽅式:分页请求系统,它是在分页系统的基础上,增加了请求调页功能、页⾯置换功能所形成的页⾯形式虚拟存储系统。
请求分段系统,它是在分段系统的基础上,增加了请求调段及分段置换功能后,所形成的段式虚拟存储系统。
4.页⾯分配:平均分配算法,是将系统中所有可供分配的物理块,平均分配给各个进程。
按⽐例分配算法,根据进程的⼤⼩按⽐例分配物理块。
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]);}。
NUR页面置换算法

NRU页面置换算法1)假设每个页面中可存放10条指令,分配给作业的内存块数为4。
2)用C语言模拟一个作业的执行过程,该作业共有320条指令,即它的地址空间为32页,目前它的所有页都还未调入内存。
在模拟过程中,如果所访问的指令已在内存,则显示其物理地址,并转下一条指令。
如果所访问的指令还未装入内存,则发生缺页,此时需记录缺页的次数,并将相应页调入内存。
如果4个内存块均已装入该作业,则需进行页面置换,最后显示其物理地址,并转下一条指令。
在所有320指令执行完毕后,请计算并显示作业运行过程中发生的缺页率。
3)置换算法:最近最不经常使用(NRU)算法。
#include<stdio.h>#include<stdlib.h>#include<malloc.h>#define N 4#define size 320typedef struct Page{int page_num;int flag_A; //访问位int flag_M; //修改位int read_or_write; //0表示不被修改,1表示被修改}PAGE;typedef struct Block{int block_num; //块号PAGE page; //所装页的信息struct Block *next;}BLOCK,*BLOCKLIST;typedef struct instruct{ //指令数据结构int address; //指令地址PAGE page; //对应页的信息}INSTRUCTION,*INSTRUCTIONLIST;INSTRUCTION instructions[size];//定义320个指令BLOCKLIST block_head; //块的头指针int diseffect=0; //缺页次数int blockSize=0;void Init_Instructions(){for(int i=0;i<320;i++)instructions[i].address=rand()%320;for(int k=0;k<320;k++){instructions[k].page.page_num=(int)instructions[k].address/10;instructions[k].page.flag_A=0;instructions[k].page.read_or_write=rand()%2;if(instructions[k].page.read_or_write==0)instructions[k].page.flag_M=0;else instructions[k].page.flag_M=1;}}BLOCKLIST Init_block(){BLOCKLIST head=(BLOCKLIST)malloc(sizeof(BLOCK)) ;BLOCKLIST p;for(int i=1;i<=N;i++) {if(i==1) p=head;else {p->next=(BLOCKLIST)malloc(sizeof(BLOCK));p=p->next;}p->block_num=i;p->page.page_num=-1;p->page.flag_A=0;p->page.flag_M=0;}p->next=head;return head;}void display(INSTRUCTION instructions){BLOCKLIST p=block_head;printf("The new page: (page_num==%d), (flag_M==%d), (address==%d)\n", instructions.page.page_num,instructions.page.flag_M,instructions.address);printf("block_num,page_num,flag_A,flag_M\n");do{printf(" %2d %10d%9d%8d\n",p->block_num,p->page.page_num,p->page.flag_A,p->page.flag_M);p=p->next;}while(p!=block_head);}void show_physical_address(BLOCKLIST &p,INSTRUCTION instructions){int address;printf("physical address:");address=p->block_num*1024+instructions.address%10;//页面大小为1kprintf("%d\n\n",address);}//查找四个块中是否有此页面int Find_page_in_block(INSTRUCTION instructions,BLOCKLIST &p){p=block_head;do{if(p->page.page_num==instructions.page.page_num){p->page.flag_A=1;if(p->page.flag_M==0)p->page.flag_M=instructions.page.flag_M;return 1;}p=p->next;}while(p!=block_head);return 0;}//先将四个块中装满void loadpage(PAGE page){BLOCKLIST p;p=block_head;while(p->page.page_num!=-1)p=p->next;p->page.page_num=page.page_num;p->page.flag_A=1;p->page.flag_M=page.flag_M;blockSize++;}//第一次循环扫描A=0 M=0int cscanf1(BLOCKLIST &p){p=block_head;do{if(p->page.flag_A==0 && p->page.flag_M==0)return 1;p=p->next;}while(p!=block_head);return 0;}//第二次循环扫描A=0 M=1int cscanf2(BLOCKLIST &p){p=block_head;do{ //把扫面过后的A=1,M=0 或A=1,M=1中的A置0if(p->page.flag_A==1 && (p->page.flag_M==0 || p->page.flag_M==1)){p->page.flag_A=0;p=p->next;continue;}if(p->page.flag_A==0 && p->page.flag_M==1)return 1;p=p->next;}while(p!=block_head);return 0;}//第三次扫描将所有的A置为0int cscanf3(BLOCKLIST &p){p=block_head;do{p->page.flag_A=0;p=p->next;}while(p!=block_head);return 1;}//用于换进页面void assignment(BLOCKLIST &p,INSTRUCTION instructions) {p->page.page_num=instructions.page.page_num;p->page.flag_A=1;p->page.flag_M=instructions.page.flag_M;}//NRU页面替换算法void replace_page(INSTRUCTION instructions,BLOCKLIST &p) {if(cscanf1(p)){assignment(p,instructions);}else if(cscanf2(p)){assignment(p,instructions);}else if(cscanf3(p)){if(cscanf1(p))assignment(p,instructions);else {cscanf2(p);assignment(p,instructions);}}}void main(){BLOCKLIST p;Init_Instructions();block_head=Init_block();for(int i=0;i<size;i++) {if(Find_page_in_block(instructions[i],p)){display(instructions[i]);show_physical_address(p,instructions[i]);getchar();continue;}else if(blockSize<N) {diseffect++;loadpage(instructions[i].page);}else {diseffect++;replace_page(instructions[i],p);}display(instructions[i]);if(diseffect>4)show_physical_address(p,instructions[i]);getchar();}printf("NRU %f\n",(float)diseffect/size);getchar();getchar();getchar();}。
CACHE页面置换算法LRU的C语言实现

通过一道题目学习下cache的LRU算法。
c语言实现。
LRU算法是最久未使用替换算法,就是假设刚刚用到的数据,将来用到几率也非常大。
每次淘汰cache中最久没有使用的元素。
题目:Design and implement a data structure for Least Recently Used (LRU) cache. It should support the following operations: get and set.get(key) - Get the value (will always be positive) of the key if the key exists in the cache, otherwise return -1.set(key, value) - Set or insert the value if the key is not already present. When the cache reached its capacity, it should invalidate the least recently used item before inserting a new item.所以,目标就是要设计一个cache系统(数据结构+接口函数),要求保证最近使用的数据不能被移除出cache,也就是每次添加一个cache项的时候,把最旧的cache项移除出去。
假设cache只有4这么大,现在有很多元素1,2,2,4,2,5,3cache income:11cache income:22 1cache income:11 2cache income:44 1 2cache income:22 4 1cache income:55 2 4 1cache income:33 5 2 4实现:哈希表+双向链表+LRU(Least Recent Used)算法。
页面置换算法(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;}。
实验三页面置换算法模拟实验

计算机科学系实验报告书课程名:《操作系统》题目:虚拟存储器管理页面置换算法模拟实验班级:学号:姓名:一、实验目的与要求1.目的:请求页式虚存管理是常用的虚拟存储管理方案之一。
通过请求页式虚存管理中对页面置换算法的模拟,有助于理解虚拟存储技术的特点,并加深对请求页式虚存管理的页面调度算法的理解。
2.要求:本实验要求使用C语言编程模拟一个拥有若干个虚页的进程在给定的若干个实页中运行、并在缺页中断发生时分别使用FIFO和LRU算法进行页面置换的情形。
其中虚页的个数可以事先给定(例如10个),对这些虚页访问的页地址流(其长度可以事先给定,例如20次虚页访问)可以由程序随机产生,也可以事先保存在文件中。
要求程序运行时屏幕能显示出置换过程中的状态信息并输出访问结束时的页面命中率。
程序应允许通过为该进程分配不同的实页数,来比较两种置换算法的稳定性。
二、实验说明1.设计中虚页和实页的表示本设计利用C语言的结构体来描述虚页和实页的结构。
在虚页结构中,pn代表虚页号,因为共10个虚页,所以pn的取值范围是0—9。
pfn代表实页号,当一虚页未装入实页时,此项值为-1;当该虚页已装入某一实页时,此项值为所装入的实页的实页号pfn。
time项在FIFO算法中不使用,在LRU中用来存放对该虚页的最近访问时间。
在实页结构中中,pn代表虚页号,表示pn所代表的虚页目前正放在此实页中。
pfn代表实页号,取值范围(0—n-1)由动态指派的实页数n所决定。
next是一个指向实页结构体的指针,用于多个实页以链表形式组织起来,关于实页链表的组织详见下面第4点。
2.关于缺页次数的统计为计算命中率,需要统计在20次的虚页访问中命中的次数。
为此,程序应设置一个计数器count,来统计虚页命中发生的次数。
每当所访问的虚页的pfn项值不为-1,表示此虚页已被装入某实页内,此虚页被命中,count加1。
最终命中率=count/20*100%。
3.LRU算法中“最近最久未用”页面的确定为了能找到“最近最久未用”的虚页面,程序中可引入一个时间计数器countime,每当要访问一个虚页面时,countime的值加1,然后将所要访问的虚页的time项值设置为增值后的当前countime值,表示该虚页的最后一次被访问时间。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
一、实验目的:用c++模拟LRU页面置换算法
二、实验内容:随机一访问串和驻留集的大小,通过模拟程序显示淘汰的页号并统计命中率。示例:
输入访问串:7 0 1 2 0 3 0 4 2 3 0 3 2 1 2 0 1
驻留集大小:3
算法的实现:由于LRU算法淘汰的是上次使用距离t时刻最远的页,故需记录这个距离。
cin>>n;
cout<<"请输入驻留级大小:"<<endl;
cin>>m;
cout<<"请输入访问串的内容:"<<endl;
init(str,n,zhuliuji,m);
LRU(str,n,zhuliuji,m);
return 0;
}
五.运行结果
{
cin>>str[i];
}
}
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)
zhuliuji[jtemp].time = 0;
jtemp ++;
}else
{
addtime(zhuliuji,m);
char ch = addzhuliuji(zhuliuji,m,str[i]);
// if(ch!='\0')
//cout<<"淘汰的页数为:"<<ch<<endl;
}
cout<<"驻留级为:";
temp = i;
}
if(zhuliuji[i].data==c)
{
zhuliuji[i].time =0;
// cout<<"zhuliuji存在"<<c<<endl;
return ch;
}
}
ch = zhuliuji[temp].data;
zhuliuji[temp].data = c;
zhuliuji[temp].time = 0;
return ch;
}
void LRU(char ቤተ መጻሕፍቲ ባይዱtr[],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);
0/11/12/10/31/32/30/21/22/23/20/2
缺 缺缺缺命 缺命缺缺缺缺命命
红色表示:每个页帧对应的计数器值
通过模拟程序输出淘汰的页号分别为:7 1 2 3 0 4
命中率为:4/13
四、代码:
#include <iostream>
using namespace std;
struct node
计数器:可使用计数器,给每一个页帧增设一个计数器。每访问一页,就把对应页帧的计数器清零,其余页帧的计数器加1.因此,计数器值为最大的页即上次访问距当前最远的页。
7 0 12030 4 2 3 0 320/71/72/70/21/22/23/20/41/42/40/01/02/0
0/01/02/00/01/00/01/02/00/31/30/31/3
for(int j=0;j<m;j++)
{
cout<<zhuliuji[j].data<<'\t';
}
cout<<endl;
}
cin>>jtemp;//显示结果,以便观察
}
int main()
{
struct node zhuliuji[20];
char str[20];
int n,m;
cout<<"请输入访问串的大小:"<<endl;
{
char ch = '\0';
int max = zhuliuji[0].time;
int temp = 0; //标记时间最长的驻留级
for(int i=0;i<m;i++)
{
if(max<zhuliuji[i].time&&zhuliuji[i].data!=c)
{
max = zhuliuji[i].time;
{
char data;
int time;
};
void init(char str[],int n,struct node zhuliuji[],int m)
{
for(int i = 0;i<m;i++)
{
zhuliuji[i].data = '\0';
zhuliuji[i].time = 0;
}
for(int i =0;i<n;i++)