页式虚拟存储管理FIFO、LRU和OPT页面置换算法
(完整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(最近未使用)算法、OPT(最佳置换)算法等。
FIFO算法的思想非常简单，就是按照页面调入到内存的先后顺序，将最先调入的页面置换出去。
这种算法的优点是简单易实现，但是由于没有考虑页面使用的频率，因此可能会出现置换出来的页面又马上要被调入内存的情况，造成系统不断的置换，效率较低。
LRU算法则是根据页面最近一次被访问的时间来置换页面，即选择最久未被使用的页面进行置换。
由于考虑了页面的使用情况，LRU算法比FIFO算法更为优秀，但是实现上比FIFO要复杂一些。
OPT算法是一种理论上最优的页面置换算法，它可以在所有置换算法中取得最佳的性能，但是由于它需要提前知道程序页面访问顺序，因此在实际应用中难以实现。
除了上述几种页面置换算法外，还有一些改进算法如LFU(最近最少使用)算法和Clock算法等。
这些算法从不同角度出发，考虑不同的因素进行页面置换，因此在具体应用场景中，根据不同的需求和系统特性，可以选择最合适的置换算法。
总之，页面置换算法是操作系统中非常重要的一部分，它决定了计算机内存的使用效率和系统的性能表现。
因此，在选择页面置换算法时不仅要考虑算法的实现难度和性能，还需要结合具体系统特性和应用场景来综合考虑，以达到最优的效果。
【算法】页面置换算法FIFO、LRU和LFU的概述以及实现方式
【算法】页⾯置换算法FIFO、LRU和LFU的概述以及实现⽅式【算法】页⾯置换算法FIFO、LRU和LFU的概述以及实现⽅式页⾯置换算法，我们最常⽤的页⾯置换算法包括FIFO先来先服务，LRU最近最久未被使⽤，LFU最近最少被使⽤以及我们的时钟置换算法。
⼀、FIFO算法——先来先服务1、简述FIFO算法FIFO算法是我们⽐较简单的置换算法，就是先来先服务或者说是先进先出。
也就是说在进⾏页⾯置换的时候，最先来的那个会被最先置换出去。
先进⼊的指令先完成并引退，跟着才执⾏第⼆条指令。
2、FIFO算法的简单实现FIFO算法的简单实现：可以通过维护⼀个链表结构去存储当前调⼊的页⾯；将最先进⼊的页⾯维护在链表的最前，最后进⼊的页⾯维护在链表的最后；这样，当发⽣缺页中断时，需要进⾏置换的时候，淘汰表头的页⾯并将新调⼊的页⾯加到链表的尾部；当然除了链表以外我们还可以采⽤数组或者队列等来进⾏实现。
3、FIFO算法的特点（1）FIFO算法实现简单，易于理解易于编程。
FIFO算法实现简单，⽆须硬件⽀持，只需要⽤循环数组管理物理块即可。
（2）FIFO算法可能会出现Belady现象。
也就是在FIFO算法中，如果未分配够⼀个进程所要求的页⾯，有时就会出现分配的页⾯数增多，却也率反⽽增加Belady现象。
（3）FIFO算法可能会置换调重要的页⾯，其效率不⾼。
（4）在FIFO算法可能中会导致多次的页⾯置换。
当页⾯置换的时间⼤于所要操作的时间的时候，这时候其效率就会很低。
当其不停的进⾏页⾯置换的时候会出现⼤量的系统抖动现象。
⼆、LRU算法——最近最久未被使⽤1、简述LRU算法LRU算法是最近最久未被使⽤的⼀种置换算法。
也就是说LRU是向前查看。
在进⾏页⾯置换的时候，查找到当前最近最久未被使⽤的那个页⾯，将其剔除在内存中，并将新来的页⾯加载进来。
2、LRU算法的实现LRU的实现就相对于FIFO的实现复杂⼀点。
我们可以采⽤哈希映射和链表相结合。
实验十二 内存管理和页面置换算法的模拟概要
实验十二内存管理和页面置换算法的模拟实验目的：1.了解Linux如何实现虚拟存储；2.分析并实现一个与缺页相关的程序。
3.通过用C语言实现OPT、FIFO和LRU三种页面调度算法，掌握虚拟存储器的实现方法，了解内存分页管理的相关细节，包括分页策略、页表结构和页面置换算法，并比较各种页面置换算法的优缺点。
实验内容：1.Linux内核中存在一个变量记录缺页中断次数，可以利用这个变量来统计一段时间内产生缺页中断的次数。
用户可以指定统计的时间长度，也可以用默认的时间段长度。
2.用C语言模拟OPT、FIFO和LRU三种页面置换算法。
实验步骤：（一）查看stat文件在Linux系统的/proc文件系统中有一个记录系统当前基本状况的文件stat。
该文件中有一节是关于中断次数的。
这一节中记录了从系统启动后到当前时刻发生的系统中断的总次数，之后依次是0号中断发生的次数，1号中断发生的次数，依次类推。
其中缺页中断是第14号中断，也就是在关键字intr之后的第16项。
请进入/proc目录，运行less stat命令，记录下系统当前发生缺页次数。
（二）编写一个记录一段时间内系统缺页次数的统计程序可以利用stat文件提供的数据在一段时间的开始时刻和结束时刻分别读取缺页中断发生的次数，然后做一个简单的减法，就可以得出这段时间内发生的缺页中断次数。
由于系统动态更新的，过去时刻的数据无法采集到，所以这里的开始时刻最早也只能是当前时刻，实验采用的统计时间段就是从当前时刻开始的一段时间。
参考代码如下图1所示。
#include <signal.h>#include <sys/time.h>#include <unistd.h>#include <stdio.h>#include <sys/types.h>#include <sys/stat.h>#include <fcntl.h>#define FILENAME "/proc/stat" /*指定文件操作的对象*/#define DEFAULTTIME 5 /*设定缺省的统计时间段长度为5秒*/static void sig_handler(int signo);int get_page_fault(void);int readfile(char *data);int exit_flag=0;int page_fault;int main(int argc, char **argv){struct itimerval v;int cacl_time;if (signal(SIGALRM, sig_handler) == SIG_ERR){printf("Unable to create handler for SIGALRM\n");return -1;}if (argc <=2 )page_fault = get_page_fault();/*初始化time_real*/if (argc < 2){printf("Use default time!\n");cacl_time = DEFAULTTIME;}else if (argc == 2){printf("Use user's time\n");cacl_time = atoi(argv[1]);}else if (argc >2){printf("Useage:mypage [time]\n");return 0;}v.it__sec = cacl_time;v.it__usec = 0;v.it__sec = cacl_time;v.it__usec = 0;setitimer(ITIMER_REAL, &v, NULL);while (!exit_flag);printf("In %d secends,system calls %d page fault!\n", cacl_time, page_fault);return 0;}static void sig_handler(int signo){if(signo == SIGALRM) /*当ITIMER_REAL为0时，这个信号被发出*/ {page_fault = page_fault - get_page_fault();exit_flag = 1;}}/*该函数调用文件操作函数readfile，得到当前系统的缺页中断次数*/int get_page_fault(void){char d[50];int retval;/*读取缺页中断次数*/retval = readfile(d);if (retval<0){printf("read data from file failed!\n");exit(0);}printf("Now the number of page fault is %s\n", d);return atoi(d);}/*该函数对/proc/stat文件内容进行读操作，读取指定项的值*/int readfile(char *data){int fd;int seekcount = 0;int retval = 0;int i=0;int count = 0;char c, string[50];fd = open(FILENAME,O_RDONLY);if (fd < 0){printf("Open file /proc/stat failed!\n");return -1;}/*查找stat文件中的关键字intr*/do {i = 0;do {lseek(fd, seekcount, SEEK_SET);retval = read(fd, &c, sizeof(char));if (retval < 0){printf("read file error!\n");return retval;}seekcount += sizeof(char);if (c == ' ' || c == '\n'){string[i] = 0;break;}if((c >= '0' && c<= '9') || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')) string[i++] = c;}while(1);}while(strcmp("intr", string));printf("find intr!\n");/*读取缺页次数*/do {lseek(fd, seekcount, SEEK_SET);retval = read(fd, &c, sizeof(char));if(retval < 0){printf("read file error!\n");return retval;}seekcount += sizeof(char);if (c == ' ' || c == '\n'){string[i] = 0;i = 0;count++;}if((c >= '0' && c<= '9') || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'))string[i++] = c;}while(count != 16);close(fd);strcpy(data, string);return 0;}图 1 统计缺页次数（三）模拟简单的置换算法简单的页面置换算法有OPT、FIFO和LRU三种。
实验--编程实现请求分页存储管理页面Optimal、FIFO、LRU置换算法
for(int i=0;i<fS;i++){
if(((Couple)(i)).time<temp){
temp=((Couple)(i)).time;
index=i;
}
}
for(int i=0;i<fS;i++){
if(i!=index){
((Couple)(i)).time--;
for(int i=0;i<;i++){
"Frame size: "+frameSize[i]+"\n");
(frameSize[i]);
(frameSize[i]);
"Total errors found: "+errorCount);
"\n************************************\n");
(frameSize[i]);
(frameSize[i]);
"Total errors found: "+errorCount);
"\n************************************\n");
errorCount=0;
}
"----------------Using LRU----------------");
(new Couple(0));
}
}
public void LRUReplace(int fS){
boolean findThesame=false;
int pre=-1;alue==digitalArray[j]){
操作系统课设报告页面置换算法
武汉轻工大学数学与计算机学院《操作系统》课程设计说明书题目：页式虚拟存储管理页面置换算法专业：班级：学号：姓名：指导老师：2015年5月26日目录一、设计目的二、设计内容三、基本原理和解决方案四、实验内容五、流程图六、源代码七、运行结果八、实验总结（心得体会）一、设计目的通过请求页式存储管理中页面置换算法模拟程序，了解虚拟存储技术的特点，掌握请求页式存储管理的页面置换算法。
二、设计内容阅读教材《计算机操作系统》第四章，掌握存储器管理相关概念和原理。
模拟实现页式虚拟存储管理的三种页面置换算法（OPT、FIFO和LRU），并通过比较性能得出结论。
前提：（1）页面分配采用固定分配局部置换。
（2）作业的页面走向和分得的物理块数预先指定。
可以从键盘输入也可以从文件读入。
（3）置换算法的置换过程输出可以在显示器上也可以存放在文件中，但必须清晰可读，便于检验。
三、基本原理和解决方案存储管理是操作系统进行资源管理的一个重要功能。
现代操作系统广泛采用虚拟存储的技术对内存进行扩充。
实现虚拟存储的一个主要技术手段就是将辅存和主存统一管理，在二者之间进行对换，从而形成物理上两级而逻辑上一级的存储管理系统。
一个置换算法的好坏对这个逻辑上的单级虚存的性能起着极其重要的作用，而且会影响处理机的调度性能。
对于本任务规定的前提：页面分配采用固定分配局部置换，则置换发生的时机是作业已经将操作系统分配的固定数目的物理块全部用完且发生缺页的时候。
此时必须要将已经装入内存的部分逻辑页面换出以便将所缺的页面调入内存。
置换算法就是一个决定将内存中“哪一个”页面换出的算法。
四、实验内容1.通过随机数产生一个指令序列，共320条指令，指令的地址按下述原则生产：50％的指令是顺序执行的；25％的指令是均匀分布在前地址部分；25％的指令是均匀分布在后地址部分。
2.将指令序列变换成为页地址流设页面大小为1K；用户内存容量为4页到32页；用户虚存容量为32K。
页面置换算法讲义
页面置换算法首先了解页面置换算法：在地址映射过程中，若在页面中发现所要访问的页面不在内存中，则产生缺页中断。
当发生缺页中断时，操作系统必须在内存中选择一个页面将其移除内存，以便为即将调入的页面让出空间。
而用来选择淘汰哪一页的规则叫做页面置换算法。
1、分类：最佳置换算法（OPT）：所选择的被淘汰页面将是以后永不使用的，或者是最长时间内不被访问的页面，这样可以保证获得最低的缺页率。
先进先出算法（FIFO）：优先淘汰最早进入的页面，也就是在内存中停留时间最长的页面。
最近最久未使用算法（LRU）：选择最近最长时间未被访问过的页面进行淘汰。
最少使用（LFU）置换算法、工作集算法、NRU算法等2、真题解析：①某虚拟存储系统采用最近最少使用（LRU）页面淘汰算法。
假定系统为每个作业分配三个页面的主存空间，其中一个页面用来存放程序。
现在某作业的部分语句如下。
Var A:Array[1..128,1..128] OF integer;i,j:integer;FOR i:=1 to 128 DOFOR j:=1 to 128 DOA[i,j]:=0;设每个页面可存放128个整数变量，变量i、j放在程序页中，矩阵A按行序存放。
初始时，程序及变量i、j已在内存，其余两页为空。
在上面程序片段执行过程中，共产生____次缺页中断。
最后留在内存中的是矩阵A的最后_______。
解析：系统为每个作业分配三个页面的主存控件，其中一个存放程序，另外两个存放的是：二位数组A[128，,128]共128行，128列，所以每行都有128个整型变量。
因为矩阵A按行序排列，又因为一个页面可以存放128个整数变量，所以一个页面存放矩阵A中的一行，两个页面存放矩阵A中的两行。
其用最近最少使用页面淘汰算法（淘汰最久未被访问的页面，如1、2行先进入页面，当第三行进入页面的时候，第一行相对于第二行就是最久未被访问的页面，所以淘汰第一行，第三行进入主存）如下分析行数 1 2 3 4 5 ... (128)页面一 1 1 3 3 5 ... ...页面二 2 2 4 4 ... ...缺页（*）* * * * * * * * ————————————128次缺页由以上分析可知，最后留在内存中的是矩阵A的最后两行，因为是一行一行的进入的，而且内存中允许两个页面存在，再有前5行进入主存的规律分析，所以是最后两行127行和128行。
O p t i m a l 最 佳 页 面 置 换 算 法
java实现FIFO和LRU页面置换算法FIFO是内存管理的一种页面置换算法，FIFO（FirstInput First Output），即先进先出队列。
例：在超市购物之后会提着我们满满的购物车来到收银台排在结账队伍的最后，眼睁睁地看着前面的客户一个个离开。
这就是一种先进先出机制，先排队的客户先行结账离开。
LRU是内存管理的另一种页面置换算法，对于在内存中但又不用的数据块（内存块）叫做LRU，操作系统会根据哪些数据属于LRU而将其移出内存而腾出空间来加载另外的数据。
?LRU是Least Recently Used的缩写，即最近最久未使用，常用于页面置换算法，是为虚拟页式存储管理服务的。
JAVA实现如下（可以直接执行）：import java.util.Scanner;class wuli{int vlu;int falt;wuli(int vlu ){this.falt=-1;this.vlu=vlu;public class fifolru {int mun; --物理块数int yemianmun; --页面个数fifolru(int mun,int yemianmun) {this.mun=mun;this.yemianmun=yemianmun;public static void fifo(wuli a[],int b[] ) { --------------------------------------------fifo------------System.out.println("+++++++++++++FIFO算法++++++++++++++++");int mun=0;int count=0;for(int q=0;qa.length;q++)a[q]=new wuli (-2); --初始化对象for(int q=0;qb.length;q++) {if(count==a.length) {int f=0; --处理满的情况for(int qq=0;qqa.length;qq++) {if(a[qq].falt==b[q]) {System.out.println("*发现相同，不存入 ");if(f==0) {System.out.println("到达一个元素"+b[q]+"已经满，弹出第一个元素"+a[0].falt+" 末尾加入元素"+b[q]);for(int z=0;za.length-1;z++) { --前移a[z].falt=a[z+1].falt;a[a.length-1].falt=b[q]; --最后一个赋值continue;int k=0;for(int qq=0;qqa.length;qq++) { --处理未满情况if(a[qq].falt==b[q]) {System.out.println("发现相同，不存入 ");if(k==0)for(int z=0;za.length;z++)if(a[z].vlu==-2) --找到没用到的物理块{ a[z].falt=b[q]; a[z].vlu=0;mun++;count++;System.out.println("没有发现相同，存入 ");break;}continue;System.out.print("++++++++++结果物理块的值:"); --fifo 结果for(int a1=0;a1a.length;a1++) {System.out.print(a[a1].falt+" ");System.out.println("++++++++++");System.out.println("++++++++++FIFO缺页次数："+mun+"次+++++++++++");public static void lru(wuli a[],int b[] ) { --------------------------------------------------lru System.out.println("++++++++++LRU算法++++++++++++");int mun=0;int count=0;for(int q=0;qa.length;q++)a[q]=new wuli (-2); --初始化对象for(int q=0;qb.length;q++) {if(count==a.length) { --处理满的情况int f=0;for(int qq=0;qqa.length;qq++) {if(a[qq].falt==b[q]) {System.out.println("*发现相同，不存入,更新位置 ");int ji=qq;for(int s=qq;s0;s--)a[s].falt=a[s-1].falt;a[0].falt=b[q];if(f==0) {System.out.println("到达一个元素"+b[q]+"已经满，弹出最后一个元素"+a[a.length-1].falt+" 首部加入元素"+b[q]);for(int s=a.length-1;s0;s--)a[s].falt=a[s-1].falt;a[0].falt=b[q];continue;int k=0;for(int qq=a.length-1;qq= 0;qq--) { --处理未满情况if(a[qq].falt==b[q]) {System.out.println("发现相同，不存入，更新位置 ");int ji=qq;while(a[ji-1].falt!=-1){ a[ji].falt=a[ji-1].falt ;for(int z=a.length-1;z=0;z--)if(a[z].vlu==-2)a[z+1].falt=b[q];if(k==0)for(int z=a.length-1;z=0;z--)if(a[z].vlu==-2) --找到没用到的物理块{ a[z].falt=b[q]; a[z].vlu=0; mun++;count++;System.out.println("没有发现相同，存入 ");break;}continue;System.out.print("++++++++++结果物理块的值:"); --lru 结果for(int a1=0;a1a.length;a1++) {System.out.print(a[a1].falt+" ");System.out.println("++++++++++");System.out.println("++++++++++FIFO缺页次数："+mun+"次+++++++++++");public static void main(String arg[]) {Scanner input=new Scanner(System.in);System.out.println("请输入分配给程序的物理块数");int mun0=input.nextInt();wuli wulikuai[]=new wuli[mun0]; --物理块数组System.out.println("请输入页面流的个数");int mun1=input.nextInt();int yemianmun[]=new int[mun1]; --页面个数数组fifolru text=new fifolru(mun0, mun1);System.out.print("请顺序输入页面流");for(int a=0;ayemianmun.length;a++) {int shuju = input.nextInt();yemianmun[a]=shuju;System.out.print("选择fifo算法，还是LRU算法。
操作系统中的虚拟内存管理与页面置换算法
操作系统中的虚拟内存管理与页面置换算法虚拟内存管理和页面置换算法是操作系统中重要的概念和技术。
在计算机系统中，虚拟内存可以为程序提供比实际内存空间更大的地址空间，从而使得程序能够运行更大的数据量，而页面置换算法则是在需要将内存中的页面换出至磁盘时选择哪些页面进行置换的策略。
本文将分别从虚拟内存管理和页面置换算法两个方面进行详细的介绍。
虚拟内存管理虚拟内存是一种使用硬盘空间模拟扩展内存的技术。
它允许系统将一个程序的一部分或全部数据和程序代码加载到物理内存中，而不是将所有程序都加载到内存中。
这样可以使得系统能够运行更多的程序，节省物理内存空间。
虚拟内存管理的主要功能包括地址映射、页面调度、页面置换等，其中最重要的是地址映射。
地址映射是虚拟内存管理的主要功能之一。
虚拟内存管理使用了分页和分段技术。
分页是将物理内存和虚拟内存划分成固定大小的页，在页面地址映射过程中，每个页面都有对应的页面表，记录了虚拟页面和物理页面之间的对应关系。
分段是将程序划分成不同的段，每个段的大小不固定，段表记录了虚拟段和物理段之间的对应关系。
地址映射的过程就是将程序的虚拟地址转换成对应的物理地址的过程，这个过程需要通过页面表和段表来实现。
除了地址映射，虚拟内存管理中的页面调度也是非常重要的。
页面调度是将需要的页面加载到内存中的过程。
当程序需要访问一个虚拟地址对应的数据时，系统会通过页面表来找到对应的物理页面，并将这个页面加载到内存中。
如果这个页面已经存在于内存中，则直接访问对应的物理页面。
如果页面不在内存中，就会触发缺页中断，系统会根据页面置换算法来选择哪些页面进行置换。
页面置换算法页面置换算法是虚拟内存管理中的一个关键技术。
它是在内存中的页面不够用时，选择哪些页面进行置换的策略。
页面置换算法的目标是尽量减少页面置换的开销，使得系统能够更有效地利用有限的内存资源。
常见的页面置换算法包括FIFO算法、最近最久未使用算法（LRU算法）、时钟算法、最不常用算法（LFU算法）、最佳算法（OPT算法）等。
页面置换算法实验报告实验心得
页面置换算法实验报告实验心得
本次实验是关于页面置换算法的实验，页面置换算法是操作系统中一个非常重要的算法，用于管理内存中的页面。
在本次实验中，我们学习了三种页面置换算法：FIFO、LRU和OPT。
FIFO算法是最简单的页面置换算法，它按照页面进入内存的顺序来选择要被替换的页面。
但是FIFO算法存在一个问题，就是它无法考虑页面是否频繁使用，因此可能会大量使用不常用的页面，而且在内存不足时，会频繁地将常用的页面替换出去。
LRU算法是一种比较高效的页面置换算法，它按照页面最近的使用时间来选择要被替换的页面。
LRU算法考虑了页面的使用频率，能够保证常用的页面不会被替换出去，因此在内存不足时，LRU算法的性能比FIFO算法要好。
OPT算法是一种理论上最优的页面置换算法，它根据未来最长时间内不再使用的页面来选择要被替换的页面。
但是实际上，由于难以预测未来的页面使用情况，因此实际上很难实现OPT算法。
在实验中，我们使用了Python编程语言来模拟这三种页面置换算法，并对算法的性能进行了测试。
通过实验，我对页面置换算法有了更深入的了解，也提升了自己的编程能力。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
目录1 需求分析 (2)目的和要求 (2)研究内容 (2)2 概要设计 (2)2．1 FIFO算法 (3)2．2 LRU算法 (3)2．3 OPT算法 (3)2．4 输入新的页面引用串 (3)3 详细设计 (4)3．1 FIFO（先进先出）页面置换算法： (4)3．2 LRU（最近最久未使用）置换算法： (4)3．3 OPT（最优页）置换算法 (4)4 测试 (5)5 运行结果 (5)6 课程设计总结 (10)7 参考文献 (10)8 附录：源程序清单 (10)1 需求分析目的和要求在熟练掌握计算机虚拟存储技术的原理的基础上，利用一种程序设计语言模拟实现几种置换算法，一方面加深对原理的理解，另一方面提高学生通过编程根据已有原理解决实际问题的能力，为学生将来进行系统软件开发和针对实际问题提出高效的软件解决方案打下基础。
研究内容模拟实现页式虚拟存储管理的三种页面置换算法（FIFO(先进先出)、LRU（最近最久未使用）和OPT（最长时间不使用）），并通过比较性能得出结论。
前提：（1）页面分配采用固定分配局部置换。
（2）作业的页面走向和分得的物理块数预先指定。
可以从键盘输入也可以从文件读入。
（3）置换算法的置换过程输出可以在显示器上也可以存放在文件中，但必须清晰可读，便于检验。
2 概要设计本程序主要划分为4个功能模块，分别是应用FIFO算法、应用LRU算法、应用OPT算法和页面引用串的插入。
各模块之间的结构图2．1 FIFO 算法该模块的主要功能是对相应页面引用串进行处理，输出经过FIFO 算法处理之后的结果。
2．2 LRU 算法该模块的主要功功能是对相应的页面引用串进行处理，输出经过LRU 算法处理之后的结果。
2．3 OPT 算法该模块的主要功功能是对相应的页面引用串进行处理，输出经过OPT 算法处理之后的结果。
2．4 输入新的页面引用串该模块的主要功能是用户自己输入新的页面引用串，系统默认的字符串是0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0，用户可以自定义全新的20个数字页面引用串。
3 详细设计在进程运行过程中，若其所要访问的页面不在内存而需把它们调入内存，但内存已无空闲空间时，为了保证该进程能正常运行，系统必须从内存中调出一页程序或数据，送磁盘的对换区中。
但应将哪个页面调出，须根据一定的算法来确定。
一个好的页面置换算法，应具有较低的页面更换频率。
从理论上讲，应将那些以后不再会访问的页面换出，或将那些在较长时间内不会再访问的页面调出。
3．1 FIFO（先进先出）页面置换算法：这是最早出现的置换算法。
该算法总是淘汰最先进入内存的页面，即选择在内存中驻留时间最久的页面予以淘汰。
该算法实现简单只需把一个进程已调入内存的页面，按先后次序链接成一个队列，并设置一个指针，称为替换指针，使它总是指向最老的页面。
但该算法与进程实际运行的规律不相适应，因为在进程中，有些页面经常被访问，比如，含有全局变量、常用函数、例程等的页面，FIFO 算法并不能保证这些页面不被淘汰。
3．2 LRU（最近最久未使用）置换算法：FIFO置换算法性能之所以较差，是因为它所依据的条件是各个页面调入内存的时间，而页面调入的先后并不能反映页面的使用情况。
最近最久未使用（LRU）置换算法，是根据页面调入内存后的使用情况进行决策的。
由于无法预测各页面将来的使用情况，只能利用“最近的过去”作为“最近的将来”的近似，因此，LRU置换算法是选择最近最久未使用的页面予以淘汰。
该算法赋予每个页面一个访问字段，用来记录一个页面自上次被访问以来所经历的时间t,，当须淘汰一个页面时，选择现有页面中其t值最大的，即最近最久未使用的页面予以淘汰。
3．3OPT（最优页）置换算法最优页置换算法是所有算法中产生页错误率最低的，而且绝对没有Belady 异常的问题。
它会置换最长时间不会使用的页。
最优页（OPT）置换算法，是根据最长时间不会使用的页来决策的。
这就意味着，需要注意内存中的页面和页面的距离了。
因此OPT算法是选择最久未使用的页面进行淘汰的。
该算法赋予内存中每个页面一个访问字段，用来记录距离此处的最近页面的距离，这样通过比较，就能把最久未使用的页面淘汰掉。
4测试程序在设计过程中，曾经出过这样或者那样的问题，最让我纠结的问题是在设计OPT算法时出现的，当我认为没有问题的时候程序一运行就没有想要的结果，很明显不是语法上的错误，由于在程序编写过程中没有截图，此处没有图片说明了。
都是逻辑上的错误，最让人难以接受的是，不是程序的逻辑，还是思维的逻辑，也就是从一开始编写程序时，自己的想法的错误了，我说怎么老是显示不出正确的结果，后来改正后结果就显示正常了。
5运行结果主界面输入错误的选择选择4的时候自己输入新的页面号引用串，此处输入书上的例子确认后首部分的页面号引用串改变选择FIFO算法，相关设置之后选择LRU算法之后选择OPT算法之后如果你选择的物理模块是其他的数量，此处用4个模块，OPT算法为例6 课程设计总结1、通过完成该课程设计，使我了解了什么是缺页中断，以及处理缺页中断的调度算法。
通过自己编程，加深了对理论学习的理解。
自己动手的编写对缺页终端的调度算法了解加深了不少了解，使我也明白了，真理是在实践中证明的。
程序中也出现过这样或者那样的问题，我也曾经颓废过，为了一个简单的逻辑问题纠结了好久，真正弄明白之后才发现自己是那么的蠢，一种豁然开朗的感觉涌上心头。
2、程序执行是稳定的，高效的。
在LRU算法中，要找出最近最久未使用的页面的话，就必须设置有关的访问记录项，且每一次访问这些记录项，页面都必须更新这些记录项。
这个记录项在此程序中为typedef struct page{int yemian;emian = -1;iaoji = 0;}for(i=0; i<Psize; i++){page[i].yemian = QString[i];page[i].biaoji = 0;}}int findSpace(int Nsize){emian == -1){return i;emian == page[curpage].yemian){return i;iaoji >= block[a].biaoji){a = i;emian != -1)emian<<" ";}}cout<<endl;}/*FIFO核心部分*/void FIFO(int Nsize){iaoji++;iaoji=0;cout<<"不缺页"<<endl;score+=1;}else{space = findSpace(Nsize);if(space != -1){block[space] = page[i];display(Nsize);}else{aition = findReplace(Nsize);block[aition] = page[i];display(Nsize);}}for(int j=0; j<Nsize; j++){block[j].biaoji++;emian==page[l].yemian)iaoji=l-i;break;}else{block[j].biaoji=Psize-i;}}}aition = findReplace(Nsize);emian = -1; block[i].biaoji = 0;}}/*主程序*/void main(void){int i,select,Nsize,QString[Psize]={0};while(select){cout<<"页面号引用串: ";for(i=0;i<20;i++){cout<<QString[i]<<" ";}cout<<endl;cout<<"+******************************+"<<endl; cout<<"+------------欢迎--------------+"<<endl; cout<<"+--------页面置换算法----------+"<<endl; cout<<"+-----选择<1>应用FIFO算法------+"<<endl; cout<<"+-----选择<2>应用LRU算法-------+"<<endl; cout<<"+-----选择<3>应用OPT算法-------+"<<endl; cout<<"+---选择<4>插入新的页面号引用串+"<<endl; cout<<"+-------选择<0>退出------------+"<<endl; cout<<"+******************************+"<<endl; cout<<"请选择：";cin>>select;switch(select){case 0:break;case 1:cout<<"请输入分配的物理块数的大小: ";cin>>Nsize;while(1){if(Nsize>0&&Nsize<=10){Init(QString,Nsize);cout<<"页面号引用串: ";for(i=0;i<Psize;i++){cout<<QString[i]<<" ";}cout<<endl;cout<<"FIFO算法结果如下:"<<endl;FIFO(Nsize);BlockClear(Nsize);cout<<"----------------------"<<endl;system("pause");system("cls");break;}else{cout<<"---输入有误，物理块数请选择1-10的数---"<<endl<<"请输入分配的物理块数的大小:";cin>>Nsize;}}break;case 2:cout<<"请输入分配的物理块数的大小: ";cin>>Nsize;while(1){if(Nsize>0&&Nsize<=10){Init(QString,Nsize);cout<<"页面号引用串: ";for(i=0;i<Psize;i++){cout<<QString[i]<<" ";}cout<<endl;cout<<"LRU算法结果如下:"<<endl;LRU(Nsize);BlockClear(Nsize);cout<<"----------------------"<<endl;system("pause");system("cls");break;}else{cout<<"---输入有误，物理块数请选择1-10的数---"<<endl<<"请输入分配的物理块数的大小:";cin>>Nsize;}}break;case 3:cout<<"请输入分配的物理块数的大小: ";cin>>Nsize;while(1){if(Nsize>0&&Nsize<=10){Init(QString,Nsize);cout<<"页面号引用串: ";for(i=0;i<Psize;i++){cout<<QString[i]<<" ";}cout<<endl;cout<<"OPT算法结果如下:"<<endl;OPT(Nsize);BlockClear(Nsize);cout<<"----------------------"<<endl;system("pause");system("cls");break;}else{cout<<"---输入有误，物理块数请选择1-10的数---"<<endl<<"请输入分配的物理块数的大小:";cin>>Nsize;}}break;case 4:cout<<"请输入20个数：\n";for(i=0;i<20;i++){cin>>QString[i];}system ("cls");break;default:cout<<"提示:功能号错误!"<<endl;cout<<"----------------------"<<endl;system("pause");system("cls");break;}}}。