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值,表示该虚页的最后一次被访问时间。
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;
C语言实现页面置换算法
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);}运⾏结果截图:以上就是本⽂的全部内容,希望对⼤家的学习有所帮助,也希望⼤家多多⽀持。
lru页面调度算法c语言实现
lru页面调度算法c语言实现LRU页面调度算法是一种常用的页面置换算法,它根据页面的历史使用情况来决定淘汰哪一页。
LRU全称是Least Recently Used,即最近最少使用。
该算法的核心思想是,当需要淘汰一页时,选择最近最久未被使用的页面进行淘汰,以便为新的页面让出空间。
在实际的计算机系统中,内存空间是有限的,而程序需要的内存空间往往远远超过可用的内存空间。
为了解决这个问题,操作系统采用了虚拟内存的技术,将程序所需的内存空间分为若干个页面,每个页面的大小固定,通常为4KB或者8KB。
当程序运行时,操作系统将程序所需的页面加载到内存中,如果内存空间不足,则需要进行页面置换。
LRU页面调度算法是一种比较简单有效的页面置换算法。
它的基本原理是,当需要淘汰一页时,选择最久未使用的页面进行淘汰。
为了实现这个目标,操作系统通常使用一个数据结构来记录页面的使用情况,比如一个链表或者一个队列。
每当程序访问一个页面时,操作系统就将该页面移到链表或者队列的头部,这样就保证了链表或者队列的尾部是最久未使用的页面。
当需要淘汰一页时,操作系统就选择链表或者队列的尾部页面进行淘汰。
这是因为,尾部页面是最久未使用的页面,它的使用频率最低,淘汰它对程序的影响最小。
淘汰完页面后,操作系统将新的页面加载到内存中,并将新的页面插入到链表或者队列的头部。
LRU页面调度算法的优点是,它能够比较准确地预测页面的使用情况。
当程序的访问模式具有局部性时,即程序往往会连续访问相邻的页面,LRU算法能够将这些页面保留在内存中,从而提高程序的执行效率。
另外,LRU算法的实现比较简单,只需要维护一个链表或者队列即可。
然而,LRU页面调度算法也存在一些问题。
首先,LRU算法需要维护一个链表或者队列,这会占用一定的内存空间。
其次,LRU算法需要频繁地更新链表或者队列,这会增加操作系统的开销。
最后,当程序的访问模式不具有局部性时,LRU算法的效果会大打折扣,因为它无法准确地预测页面的使用情况。
先进先出(FIFO)页面置换算法C语言实现、最近最久未使用(LRU)页面置换算法C语言实现
先进先出(FIFO)页⾯置换算法C语⾔实现、最近最久未使⽤(LRU)页⾯置换算法C语⾔实现1.实现效果2.实现源代码1 #include<iostream>2 #include<process.h>3 #include<stdlib.h>4 #include<ctime>5 #include<conio.h>6 #include<stdio.h>7 #include<string.h>8using namespace std;910#define Myprintf printf("|---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---|\n")/*表格控制*/11#define bsize 4 //物理块⼤⼩12#define psize 16 //进程⼤⼩13void chushihua();//初始化函数14void ymzh();16void changeaddr(struct Page p[], int logaddr);17void dizhizhuanhuan();18void menu();19int wang();2021int yemianliu[32]={0};//全局变量数组,地址流22int p;23struct Page {24int pno;//页号25int flag;//标志位26int cno;//主存号27int modf;//修改位28int addr;//外存地址29 }Page; //全局变量p是⼀共有多少地址流3031 typedef struct pagel32 {33int num; /*记录页⾯号*/34int time; /*记录调⼊内存时间*/35 }Pagel; /*页⾯逻辑结构,⽅便算法实现*/3637 Pagel b[bsize]; /*内存单元数*/38int c[bsize][psize];/*保存内存当前的状态:缓冲区*/39int queue[100];/*记录调⼊队列*/40int k;/*调⼊队列计数变量*/41int phb[bsize]={0};//物理块标号42int pro[psize]={0};//进程序列号43int flag[bsize]={0};//进程等待次数(存放最久未被使⽤的进程标志)*/ 44int i=0,j=0;//i表⽰进程序列号,j表⽰物理块号*/45int m =-1,n =-1;//物理块空闲和进程是否相同判断标志*/46int mmax=-1, maxflag=0;//标记替换物理块进程下标*/47int count =0; //统计页⾯缺页次数4849void chushihua() //初始化函数50 {51int t;52 srand(time(0));//随机产⽣指令序列53 p=12+rand()%32;54 cout<<"地址流序列:";55 cout<<endl;56for(i=0; i<p; i++)57 {58 t=1+rand()%9;59 yemianliu[i]=t;//将随机产⽣的指令数存⼊页⾯流60 }61for (i=p-1;i>=0;i--)62 {63 cout<<yemianliu[i]<<"";64 }65 cout<<endl;66 }67void ymzh()68 {69 chushihua();70 yemianzhihuan();71 }7273void yemianzhihuan()74 {75int a;76 printf("----------------------------------\n");77 printf("☆☆欢迎使⽤分页模拟实验系统☆☆\n");78 printf("----------------------------------");79 printf("☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆\n");80 printf("☆☆1.进⼊硬件地址变换算法☆☆\n");81 printf("☆☆------------------------☆☆\n");82 printf("☆☆2.进⼊页⾯置换算法☆☆\n");83 printf("☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆\n");84 printf("请输⼊您的选择:");85switch(a)86 {87case1:88 ymzh();89break;90case2:91 wang();92break;93default:94 cout<<"输⼊有误,请重新输⼊!"<<endl;95break;96 }97 }98100int j=logaddr/64;//对应的块号101int k=logaddr%64; //对应的偏移量102int flag=0;103int addr;104for(int i=0;i<8;i++)105 {106if(p[i].pno==j)//找到对应的页号107 {108if(p[i].flag==1)//页⾯标志为1109 {110 addr=p[i].cno*64+k;111 cout<<"物理地址为:"<<addr<<endl;112 cout<<"详细信息:"<<"\t页⾯号:"<<p[i].pno<<"\t 主存号:"<<p[i].cno<<"\t偏移量:"<<k<<endl; 113 flag=1;114break;115 }116 }117 }118119if(flag==0)120 cout<<"该页不在主存,产⽣缺页中断"<<endl;121 }122123void dizhizhuanhuan()124 {125int a;126int ins;//指令逻辑地址127struct Page p[8];128 p[0].pno=0;p[0].flag=1;p[0].cno=5;p[0].modf=1;p[0].addr=011;129 p[1].pno=1;p[1].flag=1;p[1].cno=8;p[1].modf=1;p[1].addr=012;130 p[2].pno=2;p[2].flag=1;p[2].cno=9;p[2].modf=0;p[2].addr=013;131 p[3].pno=3;p[3].flag=1;p[3].cno=10;p[3].modf=0;p[3].addr=015;132 p[4].pno=4;p[4].flag=0;p[4].addr=017;133 p[5].pno=5;p[5].flag=0;p[5].addr=025;134 p[6].pno=6;p[6].flag=0;p[6].addr=212;135 p[7].pno=7;p[7].flag=0;p[7].addr=213;136 printf("\t\t\t--------------------------------\n");137 printf("\t\t\t☆☆欢迎使⽤分页模拟实验系统☆☆\n");138 printf("\t\t\t---------------------------------\n");139 printf("\t\t\t☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆\n");140 printf("\t\t\t☆☆1.输⼊指令☆☆\n");141 printf("\t\t\t☆☆------------------------☆☆\n");142 printf("\t\t\t☆☆2.进⼊页⾯置换算法☆☆\n");143 printf("\t\t\t☆☆------------------------☆☆\n");144 printf("\t\t\t☆☆0.EXIT ☆☆\n");145 printf("\t\t\t☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆\n");146while(a!=0)147 {148 cout<<endl<<"请输⼊您的选择:";149 cin>>a;150151 cout<<"页号"<<"标记位"<<"外存地址"<<"主存号"<<endl;152for(int i=0;i<8;i++)153 {154 cout<<p[i].pno<<"\t"<<p[i].flag<<"\t"<<p[i].addr<<"\t";155if(p[i].flag)156 cout<<p[i].cno;157 cout<<endl;158 }159160switch(a)161 {162case0:printf("\t\t\t再见!\t\t\t\n"); break;163case1:164 cout<<"请输⼊指令的逻辑地址:";165 cin>>ins;166 changeaddr(p, ins);break;167case2: system("CLS"); a=wang();break;168default:cout<<"输⼊有误,请重新输⼊!"<<endl;break;169 }170 }171 }172173void menu()174 {175int a;176 printf("\t\t\t--------------------------------\n");177 printf("\t\t\t☆☆欢迎使⽤分页模拟实验系统☆☆\n");178 printf("\t\t\t---------------------------------\n");179 printf("\t\t\t☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆\n");180 printf("\t\t\t☆☆1.输⼊指令☆☆\n");181 printf("\t\t\t☆☆------------------------☆☆\n");182 printf("\t\t\t☆☆2.进⼊页⾯置换算法☆☆\n");184 printf("\t\t\t☆☆0.EXIT ☆☆\n");185 printf("\t\t\t☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆\n"); 186 printf("请选择所要执⾏的操作:");187 scanf("%d",&a);188switch(a)189 {190case0: printf("\t\t\t-再见!-\t\t\t\n");break;191case1: dizhizhuanhuan (); break;192case2: wang (); break;193default:cout<<"输⼊有误,请重新输⼊!"<<endl;break; 194 }195 }196int main()197 {198 menu();199 }200201//****************随机产⽣序列号函数202int* build()203 {204 printf("随机产⽣⼀个进程序列号为:\n");205int i=0;206for(i=0; i<psize; i++)207 {208 pro[i]=10*rand()/(RAND_MAX+1)+1;209 printf("%d ", pro[i]);210 }211 printf("\n");212return(pro);213 }214215//***************************************查找空闲物理块216int searchpb()217 {218for (j=0;j<bsize; j++)219 {220if(phb[j] == 0)221 {222 m=j;223return m;224break;225 }226 }227return -1;228 }229//************************************查找相同进程230int searchpro()231 {232for(j=0;j< bsize;j++)233 {234if(phb[j] =pro[i])235 {236 n=j;237return j;238 }239 }240return -1;241 }242243//*************************初始化内存244void empty()245 {246for(i=0;i<bsize;i++)247 phb[i]=0;248 count=0; //计数器置零249 } //******先进先出页⾯置换算法250void FIFO()251 {252for( i=0; i<psize; i++)253 {254// m=searchpb();255// n=searchpro();256//找到第⼀个空闲的物理快257for(j=0;j<bsize;j++) {258if(phb[j] == 0){259 m=j;260break;261 }262 }263//找与进程相同的标号264for(j=0;j<bsize;j++) {265if(phb[j] == pro[i]){266 n=j;268 }269270//找flag值最⼤的271for(j=0;j<bsize;j++)272 {273if(flag[j]>maxflag)274 {275 maxflag = flag[j];276 mmax = j;277 }278 }279280if(n == -1)//不存在相同进程281 {282if(m != -1)//存在空闲物理块283 {284 phb[m]=pro[i];//进程号填⼊该空闲物理块285// count++;286 flag[m]=0;287for (j=0;j<=m; j++)288 {289 flag[j]++;290 }291 m=-1;292 }293else//不存在空闲物理块294 {295 phb[mmax] =pro[i];296 flag[mmax] =0;297for (j=0;j<bsize;j++)298 {299 flag[j]++;300 }301 mmax = -1;302 maxflag = 0;303 count++;304 }305 }306else//存在相同的进程307 {308 phb[n] = pro[i];309for(j=0;j<bsize;j++)310 {311 flag[j]++;312 }313 n=-1;314 }315for(j=0;j < bsize;j++)316 {317 printf("%d ", phb[j]);318 }319 printf("\n");320 }321 printf("缺页次数为:%d\n",count);322 printf("缺页率 :%16. 6f",(float)count/psize);323 printf("\n");324 }325/*初始化内存单元、缓冲区*/326void Init(Pagel *b,int c[bsize][psize])327 {328int i,j;329for (i=0;i<psize;i++)330 {331 b[i].num=-1;332 b[i].time=psize-i-1;333 }334for(i=0;i<bsize;i++)335for(j=0;j<psize;j++)336 c[i][j]=-1;337 }338/*取得在内存中停留最久的页⾯,默认状态下为最早调⼊的页⾯*/ 339int GetMax(Pagel *b)340 {341int i;342int max=-1;343int tag=0;344for(i=0;i<bsize;i++)345 {346if(b[i].time>max)347 {348 max=b[i].time;349 tag= i;350 }353 }354355/*判断页⾯是否已在内存中*/356int Equation(int fold, Pagel *b)357 {358int i;359for(i=0;i<bsize;i++)360 {361if(fold==b[i]. num)362return i;363 }364return -1;365 }366/*LRU核⼼部分*/367void Lruu(int fold, Pagel *b)368 {369int i;370int val;371 val=Equation(fold, b);372if (val>=0)373 {374 b[val].time=0;375for(i=0;i<bsize;i++)376if (i!=val)377 b[i].time++;378 }379else380 {381 queue[++k]=fold;/*记录调⼊页⾯*/382 val=GetMax(b);383 b[val].num=fold;384 b[val].time=0;385for (i=0;i<bsize;i++){386387// URLcount++;388if (i!=val)389 b[i].time++;390 }391 }392 }393394void LRU()395 {396int i,j;397 k=0;398 Init(b, c);399for(i=0; i<psize; i++)400 {401 Lruu(pro[i],b);402 c[0][i]=pro[i];403/*记录当前的内存单元中的页⾯*/404for(j=0;j<bsize;j++)405 c[j][i]=b[j].num;406 }407408/*结果输出*/409 printf("内存状态为:\n");410 Myprintf;411for(j=0;j<psize;j++)412 printf("|%2d", pro[j]);413 printf("|\n");414 Myprintf;415416for(i=0;i<bsize;i++)417 {418for(j=0; j<psize; j++)419 {420if(c[i][j]==-1)421 printf("|%2c",32);422else423 printf("|%2d",c[i][j]);424 }425 printf("|\n");426 }427428 Myprintf;429// printf("\n调⼊队列为:");430// for(i=0;i<k;i++)431// printf("%3d", queue[i]);432433 printf("\n缺页次数为:%6d\n 缺页率 :%16. 6f", k+1,(float)(k+1)/psize); 434 }437int wang()438 {439int sel;440do{441 printf("\t\t\t--------------------------------\n");442 printf("\t\t\t☆☆欢迎使⽤分页模拟实验系统☆☆\n");443 printf("\t\t\t---------------------------------\n");444 printf("\t\t\t☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆\n");445 printf("\t\t\t☆☆虚拟内存☆☆\n");446 printf("\t\t\t☆☆------------------------☆☆\n");447 printf("\t\t\t☆☆1.产⽣随机序列☆☆\n");448 printf("\t\t\t☆☆------------------------☆☆\n");449 printf("\t\t\t☆☆2.最近最久未使⽤☆☆\n");450 printf("\t\t\t☆☆------------------------☆☆\n");451 printf("\t\t\t☆☆3.先进先出☆☆\n");452 printf("\t\t\t☆☆------------------------☆☆\n");453 printf("\t\t\t☆☆0.退出☆☆\n");454 printf("\t\t\t☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆\n");455 printf("请选择所要执⾏的操作:");456 scanf("%d",&sel);457switch(sel)458 {459case0: printf("\t\t\t再见!t\t\t\n"); break;460case1: build(); break;461case2: printf("最近最久未使⽤\n"); LRU();empty(); printf("\n");break; 462case3: printf("先进先出算法\n"); FIFO();empty();printf("\n");break; 463default:printf("请输⼊正确的选项号!");printf("\n\n");break;464 }465 }while(sel !=0 );466return sel;467 }。
lru页面置换算法实验c语言总结
LRU页面置换算法实验C语言总结1.引言在计算机科学中,页面置换算法是解决主存容量有限的情况下,如何有效地管理页面(或称为内存块)的一种重要方法。
L RU(L ea st Re ce nt ly Us e d)页面置换算法是其中一种经典的策略,通过淘汰最久未使用的页面来提高内存的利用率。
本文将总结使用C语言实现L RU页面置换算法的相关实验。
2.算法原理L R U页面置换算法的核心思想是:最近被访问的页面可能在未来继续被访问,而最久未被使用的页面可能在未来也不再被访问。
基于这一思想,L R U算法维护一个页面访问的时间顺序链表,每次发生页面置换时,选择链表头部(即最久未使用)的页面进行淘汰。
3.实验设计本次实验旨在使用C语言实现LR U页面置换算法,并通过模拟页面访问的过程来验证算法的正确性。
具体设计如下:3.1数据结构为了实现LR U算法,我们需要定义几个关键的数据结构:3.1.1页面节点结构t y pe de fs tr uc tP age{i n tp ag eI D;//页面I Ds t ru ct Pa ge*n ex t;//下一个节点指针s t ru ct Pa ge*p re v;//上一个节点指针}P ag e;3.1.2内存块结构t y pe de fs tr uc tM emo r y{i n tc ap ac it y;//内存块容量i n ts iz e;//当前存储的页面数量P a ge*h ea d;//内存块链表头指针P a ge*t ai l;//内存块链表尾指针}M em or y;3.2实验步骤本次实验主要包括以下几个步骤:3.2.1初始化内存块根据实际需求,设置内存块的容量,并初始化链表头指针和尾指针。
3.2.2页面置换每次发生页面访问时,检查访问的页面是否已经在内存块中。
如果在,将该页面移动到链表尾部;如果不在,执行页面置换。
3.2.3页面淘汰当内存块已满时,选择链表头部的页面进行淘汰,将新访问的页面加入链表尾部。
操作系统课程设计:lru页面置换算法
操作系统功能模拟设计实验题目: lru置换算法(C编写)学生姓名:计号学号: 1104032022专业:网络工程班级:11网络工程二班实验题目LRU页面调度算法处理缺页中断一、实验目的:了解和掌握寄存器分配和内存分配的有关技术二、实验内容(1)首先对LRU页面调度算法原理进行深刻的理解和掌握;(2)选择一种熟悉的编程语言来实现对一组访问序列进行内部的cache更新;(3)根据LRU页面调度算法算法的要求设计相应的数据结构,如:记录访问序列的数组、模拟内存cache的数组等等;(4)显示每个访问数进入cache的操作并显示出每次访问后内存中序列的状态。
三、实验环境Windows系统,c语言四、实验主要步骤(包括使用的数据结构的说明)1、初始化及使用数据结构开始的阶段,产生随机的访问序列,并用了结构体:struct page{int pageframe[10]; // 表示页表int flag; //标记是否有页面置换int length; //用来访问序列的长度int page_count; //页框的数目int page_serial[20]; //存取随机产生的访问序列组int count; //用来标识页框是否被装满int k; //用于记录访问页表的指针int pagetime[10]; //用来记录页框里面的数被访问的过后到再一次被访问所经历的的时间}p;并初始化这些量;void init(){ //初始化所有页表int i;p.flag=0;for(i=0;i<10;i++){p.pageframe[i]=-1;p.pagetime[i]=0;}for(i=0;i<20;i++){p.page_serial[i]=-1;}}2、LRU页面调度算法原理LRU页面调度算法是对要访问cache的访问序列进行更新的,当页表还是空的时候,进来要访问的页如果页表里面有的话,就对它的访问记录加一,如果也表里面没有切页表么有填满,就像页表里面添加。
页面置换算法(FIFO算法,LRU算法)
实验四页面置换算法一、实验流程图二、实验程序#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语⾔实现)【操作系统】页⾯置换算法(最佳置换算法)(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个物理块最前⾯的那个就会是要换出的,因为该页⾯最长时间未被使⽤过。
lru算法实验报告
实验二模拟LRU页面置换算法一、实验目的1)用C或C++模拟LRU页面置换算法2)掌握LRU页面置换算法的调度过程二、实验内容设计一个虚拟存储系统,编写程序模拟LUR页面置换算法,通过程序输出淘汰的页面并计算出命中率:示列:随机输入页面访问串:7 0 1 2 0 3 0 4 2 3 0 3 2 1 2 0 1随机输入内存驻留集大小:3 (驻留集初始状态为空)三、实验要求要求访问页面号、驻留集都是随机输入,驻留集初始状态下为空。
实验代码:#include<iostream>using namespace std;int judge(int q[],int rear,int front,int num){for(int i = rear; i < front; i++){if(q[i] == num){return i;}}return -1;}void f(int q[],int rear,int t){for(int i = t; i > rear; i--){q[i] = q[i-1];}}void show(int q[],int rear,int front){for(int i = rear; i <= front; i++)cout << q[i] << " ";cout << endl;}void deal(int a[],int n,int m){int rear = 0;int front = -1;int q[m];int temp = 0;int count = 0;for(int i = 0; i < n; i++){int t = judge(q,rear,front,a[i]);q[++front]=a[i];if(temp < m){if(t != -1){f(q,rear,t);cout << a[i] << "命中" << endl; rear++;count++;}else{temp++;}}else{if(t != -1){f(q,rear,t);cout << a[i] << "命中" << endl; rear++;count++;}else{cout << q[rear] << "淘汰" << endl;rear++;}}}cout << "命中率为:" << count << "/" << n;}int main(){int n;int m;cout << "请输入要访问的页面序列个数:";cin >> n ;cout << "请输入驻留值的大小:";cin >> m;int a[n];cout << "请输入要访问的" << n << "个页面序列" << endl; for(int i = 0; i < n;i++){cin >> a[i];}deal(a,n,m);}运行结果:。
- 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++)