(完整版)页面置换算法C语言

合集下载

操作系统课程设计-页面置换算法C语言

操作系统课程设计-页面置换算法C语言5、根据方案使算法得以模拟实现。

6、锻炼知识的运用能力和实践能力。

三、设计要求1、编写算法，实现页面置换算法FIFO、LRU；2、针对内存地址引用串，运行页面置换算法进行页面置换；3、算法所需的各种参数由输入产生（手工输入或者随机数产生）；4、输出内存驻留的页面集合，页错误次数以及页错误率；四．相关知识：1．虚拟存储器的引入：局部性原理：程序在执行时在一较短时间内仅限于某个部分；相应的，它所访问的存储空间也局限于某个区域，它主要表现在以下两个方面：时间局限性和空间局限性。

2．虚拟存储器的定义：虚拟存储器是只具有请求调入功能和置换功能，能从逻辑上对内存容量进行扩充的一种存储器系统。

3．虚拟存储器的实现方式：分页请求系统，它是在分页系统的基础上，增加了请求调页功能、页面置换功能所形成的页面形式虚拟存储系统。

请求分段系统，它是在分段系统的基础上，增加了请求调段及分段置换功能后，所形成的段式虚拟存储系统。

4．页面分配：平均分配算法，是将系统中所有可供分配的物理块，平均分配给各个进程。

按比例分配算法，根据进程的大小按比例分配物理块。

考虑优先的分配算法，把内存中可供分配的所有物理块分成两部分：一部分按比例地分配给各进程；另一部分则根据个进程的优先权，适当的增加其相应份额后，分配给各进程。

5．页面置换算法：常用的页面置换算法有OPT、FIFO、LRU、Clock、LFU、PBA等。

五、设计说明1、采用数组页面的页号2、FIFO算法，选择在内存中驻留时间最久的页面予以淘汰；分配n个物理块给进程，运行时先把前n个不同页面一起装入内存，然后再从后面逐一比较，输出页面及页错误数和页错误率。

3、LRU算法，根据页面调入内存后的使用情况进行决策；同样分配n个物理块给进程，前n个不同页面一起装入内存，后面步骤与前一算法类似。

选择置换算法，先输入所有页面号，为系统分配物理块，依次进行置换：六．设计思想：OPT基本思想：是用一维数组page[pSIZE]存储页面号序列，memery[mSIZE]是存储装入物理块中的页面。

(完整word版)页面置换算法OPT+FIFO+LRU+clock

#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;}。

页面置换算法(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++实现）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 算法原理是最简单的页⾯置换算法。

页面置换算法实验(内含完整代码)

实验二存储管理一、实验目的通过模拟实现请求页式存储管理的几种基本页面置换算法，了解虚拟存储技术的特点，掌握虚拟存储请求页式存储管理中几种基本页面置换算法的基本思想和实现过程，并比较它们的效率。

二、实验内容基于一个虚拟存储区和内存工作区，设计下述算法并计算访问命中率。

1、最佳淘汰算法（OPT）2、先进先出的算法（FIFO）3、最近最久未使用算法（LRU）4、简单时钟(钟表)算法（CLOCK）命中率＝１－页面失效次数／页地址流(序列)长度三、实验原理简述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。

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）算法。

c语言实现页面置换

#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;}}}}。

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);}运⾏结果截图：以上就是本⽂的全部内容，希望对⼤家的学习有所帮助，也希望⼤家多多⽀持。

(完整word版)实验八页面置换模拟程序设计C语言实验

实验八页面置换模拟程序设计一、【实验目的】加深对请求页式存储管理实现原理的理解，掌握页面置换算法。

二、【实验内容】1．假设分给一作业的内存块数为4，每个页面中可存放10条指令。

2．用C语言设计一个程序,模拟一作业的执行过程。

设该作业共有320条指令,即它的地址空间为32页，目前它的所有页面都还未调入内存。

在模拟过程中，如果所访问的指令已经在内存，则显示其物理地址，并转下一条指令。

如果所访问的指令尚未装入内存，则发生缺页，此时需记录缺页的次数，并将相应页调入内存.如果4个内存块中均已装入该作业的虚页面，则需进行页面置换。

最后显示其物理地址，并转下一条指令。

在所有320条指令执行完毕后,请计算并显示作业运行过程中发生的缺页率。

3．置换算法：请分别考虑OPT、FIFO和LRU算法.4．作业中指令的访问次序要求按下述原则生成：50%的指令是顺序执行的.25％的指令是均匀分布在前地址(即低地址）部分。

25％的指令是均匀分布在后地址（即高地址）部分。

具体的实施办法是：①在［0，319］之间随机选取一条起始执行指令，其序号为m;②顺序执行下一条指令，即序号为m+1的指令；③通过随机数,跳转到前地址部分［0,m-1］中的某条指令处，其序号为m1；④顺序执行下一条指令，即序号为m1+1的指令；⑤通过随机数,跳转到后地址部分［m1+2，319]中的某条指令处,其序号为m2；⑥顺序执行下一条指令,即序号为m2+1的指令；⑦重复“跳转到前地址部分、顺序执行、跳转到后地址部分、顺序执行”的过程，直至执行完全部320条指令。

5。

随机数产生办法，Linux或UNIX系统提供函数strand(）和rand(）,分别进行初始化和产生随机数。

例如：strand (）; 语句可初始化一个随机数；a[0］=10＊rand（)/65535＊319+1; a［1］=10*rand()/65535*a[0]; 语句可用来产生a［0］与a［1］中的随机数。

实验报告页面置换算法(c语言实现)

实验三页面置换算法#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;}结果：完成相关实验并且获得预期结果.。

(完整word版)操作系统课程设计-页面置换算法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．页面分配：平均分配算法，是将系统中所有可供分配的物理块，平均分配给各个进程。

按比例分配算法，根据进程的大小按比例分配物理块。

页面置换算法(C语言)

《操作系统》实验报告题目:页面置换算法班级：网络工程姓名：朱锦涛学号：E31314037一、实验目的用代码实现页面置换算法，通过代码的具体实现，加深对两个页面置换算法：先进先出页面置换算法和最近最久未使用算法的核心的理解。

二、实验原理1.先进先出页面置换算法：地址映射过程中，若在页面中发现所要访问的页面不再内存中，则产生缺页中断。

当发生缺页中断时操作系统必须在内存选择一个页面将其移出内存，以便为即将调入的页面让出空间。

而用来选择淘汰哪一页的规则叫做页面置换算法。

最简单的页面置换算法是先入先出(FIFO)法。

2.最近最久未使用算法：LRU算法的提出，是基于这样一个事实：在前面几条指令中使用频繁的页面很可能在后面的几条指令中频繁使用。

反过来说，已经很久没有使用的页面很可能在未来较长的一段时间内不会被用到。

这个，就是著名的局部性原理——比内存速度还要快的cache，也是基于同样的原理运行的。

因此，我们只需要在每次调换时，找到最少使用的那个页面调出内存。

这就是LRU算法的全部内容。

三、实验内容源程序：#include<iostream.h>#include <stdlib.h>#include <time.h>#include <stdio.h>#define L 20//页面走向长度最大为20 int M; //内存块struct Pro//定义一个结构体{int num,time;};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值}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;//找到离现在时间最长的页面返回其块号}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,i;int t=0;f loat n=0;P ro p[L]; //20个结构体srand(time(NULL));//随机数发生器c out<<"输出随机数: ";f or(i=0;i<20;i++) //20 个随机数{p[i].num=rand( )%10+1;//产生1到10之间的随即数放到数组p中p[i].time=0;cout<<p[i].num<<" ";}cout<<endl;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=20-1-i;}cout<<"1:FIFO页面置换"<<endl;cout<<"2:LRU页面置换"<<endl;cout<<"按其它键结束程序；"<<endl;cin>>c;system("cls"); //清屏if(c==1)//FIFO页面置换{n=0;cout<<"******************************************"<<endl;cout<<endl;cout<<" FIFO算法页面置换情况如下: "<<endl;cout<<endl;cout<<"******************************************"<<endl;while(i<20){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/20<<endl;}if(c==2)//LRU页面置换{n=0;cout<<"******************************************"<<endl;cout<<endl;cout<<" LRU算法页面置换情况如下: "<<endl;cout<<endl;cout<<"******************************************"<<endl;while(i < 20){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/20<<endl;}}while(c==1||c==2);return 0;}实验结果：FIFO置换算法：LRU置换算法：四.实验小结本次试验，使用顺序表来存储包括内存页面和页面号引用串，struct Pro{int num,time;};其中num表示页面号，页面号引用串用随机数循环20次来初始化20个页面号，同时物理块号可由用户自己在3~5之间选择，初始化页面号全为0。

页面置换算法c语言

页面置换算法（Page Replacement Algorithm）是操作系统中用于管理计算机内存的一种算法。

当系统中的物理内存不足时，操作系统会选择内存中的一些页面，将它们从内存中移动到磁盘上，以便为新的页面提供空间。

以下是使用C语言实现FIFO（First-In, First-Out）页面置换算法的示例代码：c复制代码#include<stdio.h>#include<stdlib.h>#define MAX_FRAMES 100#define MAX_PAGES 1000int frames[MAX_FRAMES];int page_faults = 0;void insert(int page, int frames[], int* page_faults) {int i;for (i = 0; i < *page_faults; i++) {if (frames[i] == page) {// Page already exists in memoryreturn;}}for (i = *page_faults; i < MAX_FRAMES; i++) {if (frames[i] == -1) {// Frame is empty, insert page at the end of the arrayframes[i] = page;(*page_faults)++;return;}}// All frames are full, page must be replaced to make room for the new page frames[*page_faults] = page;(*page_faults)++;}int main() {int pages[MAX_PAGES];int num_pages, num_frames, i, j;int page_faults_array[MAX_PAGES];int page_faults = 0;int current_frames[MAX_FRAMES];for (i = 0; i < MAX_FRAMES; i++) {current_frames[i] = -1; // Initialize all frames as empty}printf("Enter the number of pages: ");scanf("%d", &num_pages);printf("Enter the number of frames: ");scanf("%d", &num_frames);for (i = 0; i < num_pages; i++) {printf("Enter page %d: ", i + 1);scanf("%d", &pages[i]);insert(pages[i], current_frames, &page_faults); // Insert page into memorypage_faults_array[i] = page_faults; // Store page fault count for each page in an array}printf("Page Faults: %d\n", page_faults); // Print total number of page faults for the entire sequence of pagesprintf("Page Faults for each page in the sequence:\n"); // Print page fault count for each page in the sequence of pagesfor (i = 0; i < num_pages; i++) {printf("Page %d: %d\n", pages[i], page_faults_array[i]); // Print the page fault count for each page in the array of page fault counts for each page in the sequence of pages (nested array) (Duh) (Sorry for the confusion) (It's actually not that confusing once you see it written out like this) (If you're still con。

先进先出（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 }。

FIFO页面置换算法

FIFO页面置换算法1）假设每个页面中可存放10条指令，分配给作业的内存块数为4。

2）用C语言模拟一个作业的执行过程，该作业共有320条指令，即它的地址空间为32页，目前它的所有页都还未调入内存。

在模拟过程中，如果所访问的指令已在内存，则显示其物理地址，并转下一条指令。

如果所访问的指令还未装入内存，则发生缺页，此时需记录缺页的次数，并将相应页调入内存。

如果4个内存块均已装入该作业，则需进行页面置换，最后显示其物理地址，并转下一条指令。

在所有320指令执行完毕后，请计算并显示作业运行过程中发生的缺页率。

3）置换算法：先进先出FIFO算法。

#include<stdio.h>#include<stdlib.h>#include<malloc.h>#define N 4#define size 320typedef struct Block{int block_num; //块号int page_num; //页号struct Block *next;}BLOCK,*BLOCKLIST;typedef struct instruct{ //指令数据结构int address; //指令地址int page_num; //指令所存的页号}INSTRUCTION,*INSTRUCTIONLIST;INSTRUCTION instructions[size]; //定义320条指令BLOCKLIST block_head,front_in; //block_head指向块链表的头，front_in指向最老的页面，即被淘汰的页面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_num=(int)instructions[k].address/10;}//初始化块（循环链表）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_num=-1;}p->next=head;return head;}//显示块内的数据void display(INSTRUCTION instructions){BLOCKLIST p=block_head;printf("The new page: (page_num==%d),(address==%d)\n",instructions.page_num,instructions.address);printf("block_num,page_num\n");do{printf(" %2d %10d\n",p->block_num,p->page_num);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;printf("%d\n\n",address);}//查找该页是否存在，存在不要置换，否则置换int Find_page_in_block(INSTRUCTION instructions,BLOCKLIST &p) {p=block_head;do{if(p->page_num==instructions.page_num)return 1;p=p->next;}while(p!=block_head);return 0;}//用于将四个块填满void loadpage(INSTRUCTION instructions){BLOCKLIST p;p=block_head;while(p->page_num!=-1)p=p->next;p->page_num=instructions.page_num;blockSize++;}//按FIFO置换页面void replace_page(INSTRUCTION instructions,BLOCKLIST &p) {front_in->page_num=instructions.page_num;p=front_in;front_in=front_in->next;}void main(){BLOCKLIST p;Init_Instructions();block_head=Init_block();front_in=block_head;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]);display(instructions[i]);}else {diseffect++;replace_page(instructions[i],p);display(instructions[i]);show_physical_address(p,instructions[i]);}getchar();}printf("NRU %f\n",(float)diseffect/size);getchar();getchar();getchar();}。

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页面淘汰当内存块已满时，选择链表头部的页面进行淘汰，将新访问的页面加入链表尾部。

操作系统课程设计页面置换算法C语言word文档良心出品

页面置换算法一•题目要求：通过实现页面置换算法的FIFO 和LRU 两种算法，理解进程运行时系统是怎样选择换出页面的，对于两种不同的算法各自的优缺点是哪些。

要求设计主界面以灵活选择某算法，且以下算法都要实现最佳置换算法(OPT):将以后永不使用的或许是在最长(未来)时间内不再被访问的页面换出。

先进先出算法(FIFO):淘汰最先进入内存的页面，即选择在内存中驻留时间最久的页面予以淘汰。

最近最久未使用算法(LRU):淘汰最近最久未被使用的页面。

最不经常使用算法(LFU)1、编写算法，实现页面置换算法 FIFO 、LRU2、针对内存地址引用串，运行页面置换算法进行页面置换;3、算法所需的各种参数由输入产生(手工输入或者随机数产生)；4、输出内存驻留的页面集合，页错误次数以及页错误率; 四. 相关知识：1虚拟存储器的引入：局部性原理：程序在执行时在一较短时间内仅限于某个部分；相应的，它所访问的存储空间也局限于某个区域，它主要表现在以下两个方面：时间局限性和空间局限性。

2. 虚拟存储器的定义：虚拟存储器是只具有请求调入功能和置换功能，能从逻辑上对内存容量进行扩充的一种存储器系统。

3. 虚拟存储器的实现方式：分页请求系统，它是在分页系统的基础上，增加了请求调页功能、页面置换功能所形成的页面形式虚拟存储系统。

请求分段系统，它是在分段系统的基础上，增加了请求调段及分段置换功能后，所形成的段式虚拟存储系统。

4. 页面分配：平均分配算法，是将系统中所有可供分配的物理块，平均分配给各个进程。

按比例分配算法，根据进程的大小按比例分配物理块。

1) 2) 3) 4)二•实验目的：1、用C 语言编写OPT 、FIFO 、LRU , LFU 四种置换算法。

页面置换算法(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个物理块最前⾯的那个就会是要换出的，因为该页⾯最长时间未被使⽤过。

C语言实现页面置换先进先出算法（FIFO）

C语⾔实现页⾯置换先进先出算法（FIFO）本⽂实例为⼤家分享了C语⾔实现页⾯置换算法的具体代码，供⼤家参考，具体内容如下⼀、设计⽬的加深对请求页式存储管理实现原理的理解，掌握页⾯置换算法中的先进先出算法。

⼆、设计内容设计⼀个程序，有⼀个虚拟存储区和内存⼯作区，实现下述三种算法中的任意两种，计算访问命中率（命中率=1-页⾯失效次数/页地址流长度）。

附加要求：能够显⽰页⾯置换过程。

该系统页地址流长度为320，页⾯失效次数为每次访问相应指令时，该指令对应的页不在内存的次数。

程序⾸先⽤srand()和rand()函数分别进⾏初始化、随机数定义和产⽣指令序列，然后将指令序列变换成相应的页地址流，并针对不同的算法计算出相应的命中率。

通过随机数产⽣⼀个指令序列。

共320条指令，指令的地址按下述原则⽣成：（1）50%的指令是顺序执⾏的。

（2）25%的指令是均匀分布在前地址部分。

（3）25%的指令是均匀分布在后地址部分。

具体的实施⽅法如下：在【0，319】的指令地址之间随机选取⼀起点m。

顺序执⾏⼀条指令，即执⾏地址为m+1的指令。

在前地址【0,m+1】中随机选取⼀条指令并执⾏，该指令的地址为m'。

顺序执⾏⼀条指令，其地址为m'+1。

在后地址【m'+2,319】中随机选取⼀条指令并执⾏。

重复步骤（1）-（5），直到320次指令。

将指令序列变换为页地址流。

设：页⾯⼤⼩为1KB。

⽤户内存容量4页到32页。

⽤户虚存容量为32KB。

在⽤户虚存中，按每K存放10条指令虚存地址，即320条指令在虚存中的存放⽅式为：第0条～9条指令为第0页（对应虚存地址为【0，9】）。

第10条～19条指令为第1页（对应虚存地址为【10，19】）。

……第310条～319条指令为第31页（对应虚拟地址为【310，319】）。

按以上⽅式，⽤户指令可组成32页。

计算每种算法在不同内存容量下的命中率。

三、程序结构⾸先，⽤srand()和rand()函数分别进⾏初始化、随机数定义和产⽣指令序列；接着，将指令序列变换成相应的页地址流；然后，并针先进先出算法计算出相应的命中率和输出页⾯置换过程。

(完整版)页面置换算法C语言

操作系统课程设计-页面置换算法C语言

(完整word版)页面置换算法OPT+FIFO+LRU+clock

页面置换算法(FIFO,LRU,最佳,Clock)

操作系统页面置换算法（C++实现）

页面置换算法实验(内含完整代码)

CACHE页面置换算法LRU的C语言实现

c语言实现页面置换

C语言实现页面置换算法

(完整word版)实验八页面置换模拟程序设计C语言实验

实验报告页面置换算法(c语言实现)

(完整word版)操作系统课程设计-页面置换算法C语言

页面置换算法(C语言)

页面置换算法c语言

先进先出（FIFO）页面置换算法C语言实现、最近最久未使用（LRU）页面置换算法C语言实现

FIFO页面置换算法

lru页面置换算法实验c语言总结

操作系统课程设计 页面置换算法C语言word文档良心出品

页面置换算法(FIFO算法,LRU算法)

【操作系统】页面置换算法（最佳置换算法）（C语言实现）

C语言实现页面置换先进先出算法（FIFO）

操作系统课程设计页面置换算法C语言word文档良心出品