操作系统—页面置换算法实验报告
页面置换算法实验报告
页面置换算法实验报告
一、实验内容
本次实验主要围绕页面置换算法进行，以实验课本的实例介绍，采用FIFO页面置换算法对后面提到的参数进行置换，最终得出页面置换的结果和比较所得结果。
二、实验步骤
(一) 熟悉FIFO算法
首先是要了解FIFO页面置换算法，FIFO全称（First In First Out），按页面进入内存的顺序来替换相应内存页面，先进先出，将先进入内存的页面先替换出去。
(二) 阅读实验课本
在阅读实验课本之前要先熟悉实验书上所介绍的FIFO算法，然后在实验书上找出需要做的实验，并对实验环境和表格进行观察，掌握实验的基本内容。
(三) 开始页面置换
在开始实验之前，熟悉实验环境，根据实验书上的参数，首先模拟进程分配内存，根据FIFO算法去进行计算，根据上表中的参数去比较，最后得出最终结果。
(四) 在本次实验的补充
这次实验中，可以把FIFO的概念应用到实际应用中，也可以模拟不同情况，例如改变页面的大小，观察不同页面置换算法的结果，实验出最合适的结果。
三、实验结论
本次实验是为了了解FIFO页面置换算法，实验出最终的结果，最后得出页面置换的结果及比较结果。
操作系统实验报告页面置换参考模板
实验三内存页面置换算法的设计实习内容设计一个虚拟存储区和内存工作区，并使用下述算法来模拟实现页面的置换： 1. 先进先出的算法（FIFO）2. 最近最久未使用算法（LRU）3. 最佳置换算法（OPT）实习目的本实习要求学生通过请求页式存储管理中页面置换算法模拟设计，了解虚拟存储技术的技术特点，掌握请求页式存储管理的页面置换算法。
LINUX中，为了提高内存利用率，提供了内外存进程对换机制，内存空间的分配和回收均以页为单位进行，一个进程只需将其一部分（段或页）调入内存便可运行，还支持请求调页的存储管理方式。
当进程在运行中需要访问某部分程序和数据时，发现其所在页面不在内存，就立即提出请求（向CPU发出缺中断），由系统将其所需页面调入内存。
这种页面调入方式叫请求调页。
当CPU接收到缺页中断信号，中断处理程序先保存现场，分析中断原因，转入缺页中断处理程序。
该程序通过查找页表，得到该页所在外存的物理块号。
如果此时内存未满，能容纳新页，则启动磁盘I/O将所缺之页调入内存，然后修改页表。
如果内存已满，则须按某种置换算法从内存中选出一页准备换出，是否重新写盘由页表的修改位决定，然后将缺页调入，修改页表。
利用修改后的页表，去形成所要访问数据的物理地址，再去访问内存数据。
整个页面的调入过程对用户是透明的。
实习原理——算法思想：1．先进先出(FIFO)置换算法的思路该算法总是淘汰最先进入内存的页面，即选择在内存中驻留时间最久的页面予以淘汰。
该算法实现简单，只需把一个进程已调入内存的页面，按照先后次序连接成一个队列，并设置一个替换指针，使它总指向最老的页面。
2．最近久未使用(LRU)置换算法的思路最近久未使用置换算法的替换规则，是根据页面调入内存后的使用情况来进行决策的。
该算法赋予每个页面一个访问字段，用来记录一个页面自上次被访问以来所经历的时间，当需淘汰一个页面的时候选择现有页面中其时间值最大的进行淘汰。
3.最佳（OPT）置换算法的思路其所选择的被淘汰的页面，奖是以后不使用的，或者是在未来时间内不再被访问的页面，采用最佳算法，通常可保证获得最低的缺页率。
页面置换算法模拟实验报告
if(block[i].timer >= block[pos].timer)
pos = i;//找到应予置换页面，返回BLOCK中位置
return pos;
}
void PRA::display(void)
{
for(int i=0; i<Bsize; i++)
}
}
int PRA::findSpace(void)
{
for(int i=0; i<Bsize; i++)
if(block[i].content == -1)
return i;//找到空闲内存，返回BLOCK中位置
return -1;
}
int PRA::findExist(int curpage)
{
if(exist != -1)
{
cout<<"不缺页"<<endl;
}
else
{
space = findSpace();
if(space != -1)
{
block[space] = page[i];
display();
}
else
{
for(int k=0; k<Bsize; k++)
for(int j=i; j<Psize; j++)
int findReplace(void); //查找应予置换的页面
void display(void); //显示
void FIFO(void);//FIFO算法
操作系统实验三(页面置换算法)实验报告剖析
实验三实验报告实验源码：#include "stdio.h"#include <iostream.h>#include <stdlib.h>#define DataMax 100 // 常量DataMax#define BlockNum 10 // 常量BlockNumint DataShow[BlockNum][DataMax]; // 用于存储要显示的数组bool DataShowEnable[BlockNum][DataMax]; // 用于存储数组中的数据是否需要显示int Data[DataMax]; // 保存数据int Block[BlockNum]; // 物理块int count[BlockNum]; // 计数器int N; // 页面个数int M; // 最小物理块数int ChangeTimes; // 缺页次数void DataInput(); // 输入数据的函数void DataOutput(); // 输出数据的函数void FIFO(); // FIFO 函数void Optimal(); // Optimal函数void LRU(); // LRU函数int main(int argc, char* argv[]){DataInput();int menu;while(true){printf("\n* 菜单选择*\n");printf("*******************************************************\n");printf("* 1-Optimal *\n");printf("* 2-FIFO *\n");printf("* 3-LRU *\n");printf("* 4-返回上一级*\n");printf("* 0-EXIT *\n");printf("*******************************************************\n");scanf("%d",&menu);switch(menu){case 1:Optimal();break;case 2:FIFO();break;case 3:LRU();break;case 0:exit(0);break;case 4:system("cls");DataInput();break;}if(menu != 1 && menu != 2 && menu != 3 && menu != 0 && menu !=4) { system("cls");printf("\n请输入0 - 4之间的整数！\n");continue;}}return 0;}void DataInput(){int i,choice;printf("请输入最小物理块数：");scanf("%d",&M);// 输入最小物理块数大于数据个数while(M > BlockNum){printf("物理块数超过预定值，请重新输入：");scanf("%d",&M);}printf("请输入页面的个数：");scanf("%d",&N);// 输入页面的个数大于数据个数while(N > DataMax){printf("页面个数超过预定值，请重新输入：");scanf("%d",&N);}printf("请选择产生页面访问序列的方式(1.随机2.输入)：");scanf("%d",&choice);switch(choice){case 1:// 产生随机访问序列for(i = 0;i < N;i++){Data[i] = (int)(((float) rand() / 32767) * 10); // 随机数大小在0 - 9之间}system("cls");// 显示随机产生的访问序列printf("\n随机产生的访问序列为：");for(i = 0;i < N;i++){printf("%d ",Data[i]);}printf("\n");break;case 2:// 输入访问序列printf("请输入页面访问序列：\n");for(i = 0;i < N;i++)scanf("%d",&Data[i]);system("cls");// 显示输入的访问序列printf("\n输入的访问序列为：");for(i = 0;i < N;i++){printf("%d ",Data[i]);}printf("\n");break;default:while(choice != 1 && choice != 2){printf("请输入1或2选择相应方式:");scanf("%d",&choice);}break;}}void DataOutput(){int i,j;// 对所有数据操作for(i = 0;i < N;i++){printf("%d ",Data[i]);}printf("\n");for(j = 0;j < M;j++){// 对所有数据操作for(i = 0;i < N;i++){if( DataShowEnable[j][i] )printf("%d ",DataShow[j][i]);elseprintf(" ");}printf("\n");}printf("缺页次数: %d\n",ChangeTimes);printf("缺页率: %d %%\n",ChangeTimes * 100 / N); }// 最佳置换算法void Optimal(){int i,j,k;bool find;int point;int temp; // 临时变量，比较离的最远的时候用int m = 1,n;ChangeTimes = 0;for(j = 0;j < M;j++){for(i=0;i < N;i++){DataShowEnable[j][i] = false; // 初始化为false，表示没有要显示的数据}}for(i = 0;i < M;i++){count[i] = 0 ; // 初始化计数器}// 确定当前页面是否在物理块中，在继续，不在置换/////////////////////////////////////////////////////////////////////////////////// Block[0] = Data[0];for(i = 1;m < M;i++){int flag = 1;for(n = 0; n < m;n++){if(Data[i] == Block[n]) flag = 0;}if(flag == 0) continue;Block[m] = Data[i];m++;}//////////////////////////////////////////////////////////////////////////////////// 对所有数据进行操作for(i=0;i < N;i++){// 表示块中有没有该数据find = false;for(j = 0;j < M;j++){if( Block[j] == Data[i] ){find = true;}}if( find ) continue; // 块中有该数据，判断下一个数据// 块中没有该数据，最优算法ChangeTimes++; // 缺页次数++for(j = 0;j < M;j++){// 找到下一个值的位置find = false;for( k = i;k < N;k++){if( Block[j] == Data[k] ){find = true;count[j] = k;break;}}if( !find ) count[j] = N;}// 因为i是从0开始记，而BlockNum指的是个数，从1开始，所以i+1if( (i + 1) > M ){//获得要替换的块指针temp = 0;for(j = 0;j < M;j++){if( temp < count[j] ){temp = count[j];point = j; // 获得离的最远的指针}}}else point = i;// 替换Block[point] = Data[i];// 保存要显示的数据for(j = 0;j < M;j++){DataShow[j][i] = Block[j];DataShowEnable[i < M ? (j <= i ? j : i) : j][i] = true; // 设置显示数据}}// 输出信息printf("\nOptimal => \n");DataOutput();}// 先进先出置换算法void FIFO(){bool find;int point;int temp; // 临时变量int m = 1,n;ChangeTimes = 0;for(j = 0;j < M;j++){for(i = 0;i < N;i++){DataShowEnable[j][i] = false; // 初始化为false，表示没有要显示的数据}}for(i = 0;i < M;i++){count[i] = 0; // 大于等于BlockNum，表示块中没有数据，或需被替换掉// 所以经这样初始化（3 2 1），每次替换>=3的块，替换后计数值置1，// 同时其它的块计数值加1 ，成了（1 3 2 ），见下面先进先出程序段}// 确定当前页面是否在物理块中，在继续，不在置换/////////////////////////////////////////////////////////////////////////////////// Block[0] = Data[0];for(i = 1;m < M;i++){int flag = 1;for(n = 0; n < m;n++){if(Data[i] == Block[n]) flag = 0;}if(flag == 0) continue;Block[m] = Data[i];m++;}//////////////////////////////////////////////////////////////////////////////////// 对有所数据操作for(i = 0;i < N;i++){// 增加countfor(j = 0;j < M;j++){count[j]++;find = false; // 表示块中有没有该数据for(j = 0;j < M;j++){if( Block[j] == Data[i] ){find = true;}}// 块中有该数据，判断下一个数据if( find ) continue;// 块中没有该数据ChangeTimes++; // 缺页次数++// 因为i是从0开始记，而M指的是个数，从1开始，所以i+1if( (i + 1) > M ){//获得要替换的块指针temp = 0;for(j = 0;j < M;j++){if( temp < count[j] ){temp = count[j];point = j; // 获得离的最远的指针}}}else point = i;// 替换Block[point] = Data[i];count[point] = 0; // 更新计数值// 保存要显示的数据for(j = 0;j < M;j++){DataShow[j][i] = Block[j];DataShowEnable[i < M ? (j <= i ? j : i) : j][i] = true; // 设置显示数据}}// 输出信息printf("\nFIFO => \n");DataOutput();}// 最近最久未使用置换算法void LRU(){int i,j;bool find;int point;int temp; // 临时变量int m = 1,n;ChangeTimes = 0;for(j = 0;j < M;j++){for(i = 0;i < N;i++){DataShowEnable[j][i] = false; // 初始化为false，表示没有要显示的数据}}for(i = 0;i < M;i++){count[i] = 0 ; // 初始化计数器}// 确定当前页面是否在物理块中，在继续，不在置换///////////////////////////////////////////////////////////////////////////////////Block[0] = Data[0];for(i = 1;m < M;i++){int flag = 1;for(n = 0; n < m;n++){if(Data[i] == Block[n]) flag = 0;}if(flag == 0) continue;Block[m] = Data[i];m++;}//////////////////////////////////////////////////////////////////////////////////// 对有所数据操作for(i = 0;i < N;i++){// 增加countfor(j = 0;j < M;j++){count[j]++;}find = false; // 表示块中有没有该数据for(j = 0;j < M;j++){if( Block[j] == Data[i] ){count[j] = 0;find = true;}}// 块中有该数据，判断下一个数据if( find ) continue;// 块中没有该数据ChangeTimes++;// 因为i是从0开始记，而BlockNum指的是个数，从1开始，所以i+1 if( (i + 1) > M ){//获得要替换的块指针temp = 0;for(j = 0;j < M;j++){if( temp < count[j] ){temp = count[j];point = j; // 获得离的最远的指针}}}else point = i;// 替换Block[point] = Data[i];count[point] = 0;// 保存要显示的数据for(j=0;j<M;j++){DataShow[j][i] = Block[j];DataShowEnable[i < M ?(j <= i ? j : i) : j][i] = true; // 设置显示数据}}// 输出信息printf("\nLRU => \n");DataOutput();}实验结果截图：程序运行：输入相应数据：选择相应算法：最佳置换算法：先进先出算法：最近最久未使用算法：。
操作系统页置换实验报告
实验四页置换一、实验目的：通过请求页式存储管理中页面置换算法模拟程序，了解虚拟存储技术的特点，掌握请求页式存储管理的页面置换算法。
二、实验环境说明：此实验在MacOS 10.9 的Xcode软件下编译运行。
三、实验内容：写一个程序来实现本章中介绍的FIFO和LRU页置换算法。
首先，产生一个随机的页面引用序列，页面数从0～9。
将这个序列应用到每个算法并记录发生的页错误的次数。
实现这个算法时，要将页帧的数量设置为可变（从1～7）。
假设使用请求调页。
四、程序设计说明：1.全局变量：定义bsize为页帧的数量，可以手动修改，初始值为4。
定义psize为进程请求次数，可以手动修改，初始值为16。
定义Page结构体，内含页面编号和调入时间。
2.初始化缓冲区和物理内存：3.获得随机序列（0～9），共psize个数：4.搜索空内存，便于页的调入：5.搜索是否有相同的进程已在内存中，有则不缺页，不需要置换：6.每次应用完一个算法后清空内存和缓冲区，便于其他算法的页置换：7.FIFO算法：FIFO页置换算法为每个页记录着该页调入内存的时间。
当必须置换一页时，将选择最旧的页。
FIFO算法性能并不总是很好，可能会有Belady 异常的出现。
8.获得置入时间最早的页面，用于FIFO算法：9.判断页面是否相同：10.LRU算法：LRU页置换算法为每个页关联该页上次使用的时间。
当必须置换一页时，LRU选择最长时间没有使用的页。
这种策略为向后看最优页置换算法。
11.主目录：12.主函数：五、运行结果：1.运行程序显示主目录界面：2.选择操作1，生成psize（此处为16）个随机数（0～9）序列：3.选择操作2，执行FIFO算法，并输出运行结果：4.选择操作3，执行LRU算法，并输出运行结果：5.选择操作4，输出end，结束程序：六、不同页帧数比较：1. 3 frames：2. 4 frames：3. 5 frames：七、 源代码：见pageReplacement.c 附件。
页面置换实验报告
计算机科学系实验报告书课程名：《操作系统》题目：虚拟存储器管理页面置换算法模拟实验班级：学号：姓名：一、实验目的与要求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值，表示该虚页的最后一次被访问时间。
操作系统实验报告6-页面置换算法模拟综述
struct{
intlength;//当獭?前°物?理え?块é长¤度è
intmiss_flag;//缺ā?页?标括?志?，?若?为a1，?则ò缺ā?页?
intmiss_count;//缺ā?页?次?数簓
BlockNode*front;
BlockNode*rear;
}Block;
if(!Block.front){
printf("内ú存?分?配?失骸?败悒?\n");
exit(0);
}
Block.length=0;
Block.miss_count=0;
Block.rear->next=NULL;
}
voidenqueue(intpage_index)//入?队ó
{
BlockNode*node=(BlockNode*)malloc(sizeof(BlockNode));
if((i+1)%5== 0){
printf("\n");
}//if
}
printf("\n");
}
voidFIFO_Replace(intpage_index)//FIFO置?换?
{
BlockNode*node;
if(!Block.length){
enqueue(page_index);
Block.miss_flag=0;
if(num>=down&& num<=up)
break;
printf("输?入?范?围§有瓺误ó,请?重?新?输?入?:");
}//while
returnnum;
操作系统实验报告_页面置换算法模拟
操作系统实验报告_页面置换算法模拟学生实验报告姓名: 年级专业班级学号成绩验证设计实验3 请求分页系统的页面实验类型课程名称实验名称操作系统综合创新置换算法【实验目的、要求】1.通过编程实现请求分页存储管理系统的Optimal、FIFO、LRU调度算法，使学生掌握计算机虚拟存储管理中有关缺页处理方法等内容，巩固有关虚拟存储管理的知识。
2.了解Windows2000/XP中内存管理机制，掌握页式虚拟存储技术。
3.理解内存分配原理，特别是以页面为单位的虚拟内存分配方法。
【实验内容】在Windows XP或Windows 2000等操作系统环境下，使用VC、VB、Delphi、java或C等编程语言，实现请求分页存储管理系统的Optimal、FIFO、LRU调度算法。
【实验环境】(含主要设计设备、器材、软件等)计算机 C语言编程软件【实验步骤、过程】(含原理图、流程图、关键代码，或实验过程中的记录、数据等)1.启动计算机，运行C语言编程软件。
2.分析理解页面的几种基本算法的特点和原理，在纸上画出原理图。
3.编辑源程序，关键代码如下。
(1)先进先出页面置换算法。
#include<stdio.h>void main(){int i,n,t,k=3,a[100];scanf("%d",&n);for(i=0;i<n;i++)scanf("%d",&a[i]);for(i=3;i<n;i++)if(a[i]!=a[0]&&a[i]!=a[1]&&a[i]!=a[2]) //该页面在内存中，不需要置换。
{t=a[i];a[i]=a[k%3]; //通过对k值对3取余的值来确定需要置换的当前页面。
a[k%3]=t;k++; //仅当发生了页面置换时，k的值才发生改变。
printf("%d %d %d\n",a[0],a[1],a[2]);}else{printf("%d %d %d\n",a[0],a[1],a[2]);}}(2)最佳置换算法#include<stdio.h>void main(){int i,j,,n,a[100];int c1,c2,c3; // 标志该页面再次被访问时在引用串中的位置int p,k,r;printf("请输入页面数:\n");scanf("%d",&n);printf("请输入页面号引用串:\n");for(i=0;i<n;i++)scanf("%d",&a[i]);for(j=3;j<n;j++){if((a[j]!=a[0])&&(a[j]!=a[1])&&(a[j]!=a[2])) //页面在内存不发生置换～{for(p=j;p<n;p++)if(a[0]==a[p]){ c1=p;break; //跳出循环，直接置c1=n!} else c1=n; //标志该页面再次被访问时在引用串中的位置～若该页面不会再次被访问，则将c1置为最大n!for(k=j;k<n;k++)if(a[1]==a[k]){ c2=k;break; }elsec2=n;for(r=j;r<n;r++)if(a[2]==a[r]){ c3=r;break;}else c3=n; //通过比较c1,c2,c3的大小确定最长时间内不再访问的页面～if((c1>c2)&&(c1>c3)||(c1==c3)||(c1==c2)) //当前a[0]页面未来最长时间不再访问!{t=a[j];a[j]=a[0];a[0]=t; //把当前访问页面和最佳页面交换～printf("%d %d %d\n",a[0],a[1],a[2]);}if((c2>c1)&&(c2>c3)||(c2==c3)) //当前a[1]页面未来最长时间不再访问!{t=a[j];a[j]=a[1];a[1]=t;printf("%d %d %d\n",a[0],a[1],a[2]);}if((c3>c1)&&(c3>c2)) //当前a[2]页面未来最长时间不再访问!{t=a[j];a[j]=a[2];a[2]=t;printf("%d %d %d\n",a[0],a[1],a[2]); //输出置换后页框中的物理块组成～}}elseprintf("%d %d %d\n",a[0],a[1],a[2]);}}(3)LRU算法。
操作系统实验三(页面置换算法)实验报告
操作系统实验三(页面置换算法)实验报告int N; // 页面个数int M; // 最小物理块数int ChangeTimes; // 缺页次数void DataInput(); // 输入数据的函数void DataOutput(); // 输出数据的函数void FIFO(); // FIFO 函数void Optimal(); // Optimal函数void LRU(); // LRU函数int main(int argc, char* argv[]){DataInput();int menu;while(true){printf("\n* 菜单选择 *\n");printf("*******************************************************\n");printf("*1-Optimal *\n");printf("* 2-FIFO *\n");printf("* 3-LRU *\n");printf("* 4-返回上一级 *\n");printf("* 0-EXIT *\n");printf("*******************************************************\n");scanf("%d",&menu);switch(menu){case 1:Optimal();break;case 2:FIFO();break;case 3:LRU();break;case 0:exit(0);break;case 4:system("cls");DataInput();break;}if(menu != 1 && menu != 2 && menu != 3 && menu != 0 && menu !=4) {system("cls");printf("\n请输入0 - 4之间的整数！\n");continue;}}return 0;}void DataInput(){int i,choice;printf("请输入最小物理块数：");scanf("%d",&M);// 输入最小物理块数大于数据个数while(M > BlockNum){printf("物理块数超过预定值，请重新输入：");scanf("%d",&M);}printf("请输入页面的个数：");scanf("%d",&N);// 输入页面的个数大于数据个数while(N > DataMax){printf("页面个数超过预定值，请重新输入：");scanf("%d",&N);}printf("请选择产生页面访问序列的方式(1.随机 2.输入)：");scanf("%d",&choice);switch(choice){case 1:// 产生随机访问序列for(i = 0;i < N;i++){Data[i] = (int)(((float) rand() / 32767) * 10); // 随机数大小在0 - 9之间}system("cls");// 显示随机产生的访问序列printf("\n随机产生的访问序列为：");for(i = 0;i < N;i++){printf("%d ",Data[i]);}printf("\n");break;case 2:// 输入访问序列printf("请输入页面访问序列：\n");for(i = 0;i < N;i++)scanf("%d",&Data[i]);system("cls");// 显示输入的访问序列printf("\n输入的访问序列为：");for(i = 0;i < N;i++){printf("%d ",Data[i]);}printf("\n");break;default:while(choice != 1 && choice != 2){printf("请输入1或2选择相应方式:");scanf("%d",&choice);}break;}}void DataOutput(){int i,j;// 对所有数据操作for(i = 0;i < N;i++){printf("%d ",Data[i]);}printf("\n");for(j = 0;j < M;j++){// 对所有数据操作for(i = 0;i < N;i++){if( DataShowEnable[j][i] )printf("%d ",DataShow[j][i]);elseprintf(" ");}printf("\n");}printf("缺页次数: %d\n",ChangeTimes);printf("缺页率: %d %%\n",ChangeTimes * 100 / N);}// 最佳置换算法void Optimal(){int i,j,k;bool find;int point;int temp; // 临时变量，比较离的最远的时候用int m = 1,n;ChangeTimes = 0;for(j = 0;j < M;j++){for(i=0;i < N;i++){DataShowEnable[j][i] = false; // 初始化为false，表示没有要显示的数据}}for(i = 0;i < M;i++){count[i] = 0 ; // 初始化计数器}// 确定当前页面是否在物理块中，在继续，不在置换/////////////////////////////////////// ///////////////////////////////////////// ///Block[0] = Data[0];for(i = 1;m < M;i++){int flag = 1;for(n = 0; n < m;n++){if(Data[i] == Block[n]) flag = 0;}if(flag == 0) continue;Block[m] = Data[i];m++;}/////////////////////////////////////// ///////////////////////////////////////// //// 对所有数据进行操作for(i=0;i < N;i++){// 表示块中有没有该数据find = false;for(j = 0;j < M;j++){if( Block[j] == Data[i] ){find = true;}}if( find ) continue; // 块中有该数据，判断下一个数据// 块中没有该数据，最优算法ChangeTimes++; // 缺页次数++for(j = 0;j < M;j++){// 找到下一个值的位置find = false;for( k = i;k < N;k++){if( Block[j] == Data[k] ){find = true;count[j] = k;break;}}if( !find ) count[j] = N;}// 因为i是从0开始记，而BlockNum指的是个数，从1开始，所以i+1if( (i + 1) > M ){//获得要替换的块指针temp = 0;for(j = 0;j < M;j++){if( temp < count[j] ){temp = count[j];point = j; // 获得离的最远的指针}}}else point = i;// 替换Block[point] = Data[i];// 保存要显示的数据for(j = 0;j < M;j++){DataShow[j][i] = Block[j];DataShowEnable[i < M ? (j <= i ? j : i) : j][i] = true; // 设置显示数据}}// 输出信息printf("\nOptimal => \n");DataOutput();}// 先进先出置换算法void FIFO(){int i,j;bool find;int point;int temp; // 临时变量int m = 1,n;ChangeTimes = 0;for(j = 0;j < M;j++){for(i = 0;i < N;i++){DataShowEnable[j][i] = false; // 初始化为false，表示没有要显示的数据}}for(i = 0;i < M;i++){count[i] = 0; // 大于等于BlockNum，表示块中没有数据，或需被替换掉// 所以经这样初始化（3 2 1），每次替换>=3的块，替换后计数值置1，// 同时其它的块计数值加 1 ，成了（1 3 2 ），见下面先进先出程序段}// 确定当前页面是否在物理块中，在继续，不在置换/////////////////////////////////////// ///////////////////////////////////////// ///Block[0] = Data[0];for(i = 1;m < M;i++){int flag = 1;for(n = 0; n < m;n++){if(Data[i] == Block[n]) flag = 0;}if(flag == 0) continue;Block[m] = Data[i];m++;}/////////////////////////////////////// ///////////////////////////////////////// //// 对有所数据操作for(i = 0;i < N;i++){// 增加countfor(j = 0;j < M;j++){count[j]++;}find = false; // 表示块中有没有该数据for(j = 0;j < M;j++){if( Block[j] == Data[i] ){find = true;}}// 块中有该数据，判断下一个数据if( find ) continue;// 块中没有该数据ChangeTimes++; // 缺页次数++ // 因为i是从0开始记，而M指的是个数，从1开始，所以i+1if( (i + 1) > M ){//获得要替换的块指针temp = 0;for(j = 0;j < M;j++){if( temp < count[j] ){temp = count[j];point = j; // 获得离的最远的指针}}}else point = i;// 替换Block[point] = Data[i];count[point] = 0; // 更新计数值// 保存要显示的数据for(j = 0;j < M;j++){DataShow[j][i] = Block[j];DataShowEnable[i < M ? (j <= i ? j : i) : j][i] = true; // 设置显示数据}}// 输出信息printf("\nFIFO => \n");DataOutput();}// 最近最久未使用置换算法void LRU(){int i,j;bool find;int point;int temp; // 临时变量int m = 1,n;ChangeTimes = 0;for(j = 0;j < M;j++){for(i = 0;i < N;i++)DataShowEnable[j][i] = false; // 初始化为false，表示没有要显示的数据}}for(i = 0;i < M;i++){count[i] = 0 ; // 初始化计数器}// 确定当前页面是否在物理块中，在继续，不在置换/////////////////////////////////////// ///////////////////////////////////////// ///Block[0] = Data[0];for(i = 1;m < M;i++){int flag = 1;for(n = 0; n < m;n++){if(Data[i] == Block[n]) flag = 0;if(flag == 0) continue;Block[m] = Data[i];m++;}/////////////////////////////////////// ///////////////////////////////////////// //// 对有所数据操作for(i = 0;i < N;i++){// 增加countfor(j = 0;j < M;j++){count[j]++;}find = false; // 表示块中有没有该数据for(j = 0;j < M;j++){if( Block[j] == Data[i] ){count[j] = 0;find = true;}}// 块中有该数据，判断下一个数据if( find ) continue;// 块中没有该数据ChangeTimes++;// 因为i是从0开始记，而BlockNum指的是个数，从1开始，所以i+1if( (i + 1) > M ){//获得要替换的块指针temp = 0;for(j = 0;j < M;j++){if( temp < count[j] ){temp = count[j];point = j; // 获得离的最远的指针}}}else point = i;// 替换Block[point] = Data[i];count[point] = 0;// 保存要显示的数据for(j=0;j<M;j++){DataShow[j][i] = Block[j];DataShowEnable[i < M ?(j <= i ? j : i) : j][i] = true; // 设置显示数据}}// 输出信息printf("\nLRU => \n");DataOutput();}实验结果截图：程序运行：输入相应数据：选择相应算法：最佳置换算法：先进先出算法：最近最久未使用算法：。
计算机操作系统实验4页面置换算法
实验4 页面置换算法（2学时）一、实验目的通过实验加强对虚拟存储管理中页面置换算法的理解和掌握。
二、实验内容编写程序实现虚拟存储管理中OPT,FIFO,LRU页面置换算法。
三、实验要求1、任意给出一组页面访问顺序（如页面走向是1、2、5、7、5、7、1、4、3、5、6、4、3、2、1、5、2）。
2、分配给该作业一定的物理块（如3块、4块等）。
3、利用OPT,FIFO,LRU页面置换算法模拟页面置换过程并计算其缺页率。
4、每访问一个页面均需给出内存中的内容（内存中的页面号），若有淘汰还需给出淘汰的页面号。
5、通过给出特殊的页面访问顺序，分配不同的物理块，利用FIFO 算法计算其缺页率，进一步理解Belady现象。
6、（附加）实现CLOCK置换算法，修改位可在确定页面号时直接任意给出。
程序代码（java）package wcm4;import java.util.LinkedList;import java.util.Scanner;public class Test {/*** @param args*/LinkedList ll=new LinkedList();int a;int leng;int[] all={1,2,5,7,5,7,1,4,3,5,6,4,3,2,1,5,2};//int[] free=new int[all.length];Object o=new Integer(a);public static void main(String[] args) {// TODO Auto-generated method stubTest t=new Test();t.begin();}public void begin(){System.out.println("请选择测试类型：");System.out.println("1 OPT; 2 FiFO; 3 LRU; 4 CLOCK; 5退出");Scanner sc=new Scanner(System.in);int choose=sc.nextInt();while(choose!=5){switch(choose){case 1:this.opt();break;case 2:this.fifo();break;case 3:this.lru();break;case 4:this.clock();break;}System.out.println("请选择测试类型：");System.out.println("1 OPT; 2 FiFO; 3 LRU; 4 CLOCK; 5退出");sc=new Scanner(System.in);choose=sc.nextInt();}}public void need(){System.out.println("请输入分配给该作业的物理块数：");Scanner sc=new Scanner(System.in);leng=sc.nextInt();}public void fifo(){ll=new LinkedList();this.need();int a=0;for(int i=0;i<all.length;i++){o=all[i];if(!ll.contains(o)){if(ll.size()<leng){ll.add(o);o=null;}else{ll.add(o);o=ll.poll();a++;}}else{o=null;}this.print();}System.out.println("FIFO的缺页率为：");System.out.println(a);System.out.println("——");System.out.println(all.length);}public void opt(){//最佳置换算法//leng=0;ll=new LinkedList();this.need();int a=0;//int temp=0;//int[] b=new int[leng];for(int i=0;i<all.length;i++){int[] b=new int[leng];o=all[i];if(!ll.contains(o)){if(ll.size()<leng){ll.add(o);o=null;}else{for(int j=i;j<all.length;j++){Object o1=new Integer(all[j]);for(int k=0;k<leng;k++){if(ll.get(k).equals(o1)){if(b[k]==0){b[k]=j;//待替换的页在以后第一次出现的位置}}}}if(b[leng-1]==0){o=ll.set(leng-1, o);a++;}else{int temp=0;for(int m=0;m<leng;m++){if(b[m]==0){temp=m;break;}else if(b[m]>b[temp]){temp=m;}}o=ll.set(temp, o);//替换以后离得最远的a++;}}}else{o=null;}this.print();}System.out.println("OPT的缺页率为：");System.out.println(a);System.out.println("——");System.out.println(all.length);}public void lru(){//最近最久未使用ll=new LinkedList();this.need();int a=0;for(int i=0;i<all.length;i++){o=all[i];if(!ll.contains(o)){if(ll.size()<leng){ll.add(o);o=null;}else{ll.add(o);o=ll.poll();a++;}}else{ll.add(o);ll.remove(o);o=null;}this.print();}System.out.println("OPT的缺页率为：");System.out.println(a);System.out.println("——");System.out.println(all.length);}public void clock(){//简单clockll=new LinkedList();this.need();int a=0;int[] b=new int[leng];for(int i=0;i<all.length;i++){o=all[i];if(!ll.contains(o)){if(ll.size()<leng){ll.add(o);o=null;}else{for(int j=0;j<=ll.size();j++){if(b[j%ll.size()]==0){b[j%ll.size()]=1;}else{int temp1=j%ll.size();o=ll.set(temp1, o);b[temp1]=0;//改变该位的标记位break;}}a++;}}else{int temp=ll.indexOf(o);//找到该位b[temp]=0;o=null;}this.print();System.out.println("标记位为：");for(int k=0;k<ll.size();k++){System.out.print(b[k]);}System.out.println();}System.out.println("CLOCK的缺页率为：");System.out.println(a);System.out.println("——");System.out.println(all.length);}public void print(){Object[] op=ll.toArray();for(int i=0;i<ll.size();i++){System.out.print(op[i]);}System.out.print(" ");System.out.println(o);//System.out.println();} }。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
操作系统—页面置换算法实验报告
本报告旨在介绍操作系统中的页面置换算法，包括实验的目的和背景以及页面置换算法的概念
和作用。
本实验旨在描述实验环境以及所使用的页面
置换算法，包括FIFO、LRU、OPT等。
同时，
还会详细介绍实验步骤和设置的参数。
实验环境
操作系统：Windows 10
编程语言：C++
开发环境：Visual。
2019
页面置换算法
FIFO（First-In-First-Out）算法：按照先进先出的原则置换页面，最早进入内存的页面会被置换出去。
LRU（Least Recently Used）算法：根据页面的使用情况，置
换最长时间没有被访问过的页面。
OPT（Optimal）算法：理论上最优的页面置换算法，根据未来一段时间内页面的访问情况，选择最少使用的页面进行置换。
实验步骤
创建一个模拟操作系统的C++程序。
设定内存大小、页面大小和页面数等参数。
实现FIFO算法，将其应用于模拟操作系统中的页面置换过程。
实现LRU算法，将其应用于页面置换过程。
实现OPT算法，将其应用于页面置换过程。
运行模拟程序，观察不同页面置换算法的效果。
分析比较不同算法的页面置换结果，评估其优缺点。
参数设置
内存大小：512MB
页面大小：4KB
页面数：128
以上是本次实验的实验设计，将通过创建模拟操作系统程序，
实现FIFO、LRU和OPT等页面置换算法，并对其结果进行比较和
评估。
本实验展示了页面置换算法的不同性能，并
分析了各种算法的优缺点。
实验结果表明，不同的页面置换算法对系统性能有显著影响。
以下是对各种算法的性能分析：
先进先出(FIFO)算法：该算法将最早进入内存的页面置换出去。
优点是简单易实现，缺点是无法适应程序的访问模式变化，容易产生"Belady异常"。
先进先出(FIFO)算法：该算法将最早进入内存的
页面置换出去。
优点是简单易实现，缺点是无法适应程序的访问模
式变化，容易产生"Belady异常"。
最优(OPT)算法：该算法置换出接下来最长时间内不会被访问
的页面。
优点是可以确保最低的缺页率，缺点是需要未来页面访问
序列的信息，实际中难以实现。
最优(OPT)算法：该算法置换出接
下来最长时间内不会被访问的页面。
优点是可以确保最低的缺页率，缺点是需要未来页面访问序列的信息，实际中难以实现。
最优(OPT)算法：该算法置换出接下来最长时间内不会被访问的页面。
优点是可以确保最低的缺页率，缺点是需要未来页面访问序列的信息，实际中难以实现。
最优(OPT)算法：该算法置换出接下来最长
时间内不会被访问的页面。
优点是可以确保最低的缺页率，缺点是
需要未来页面访问序列的信息，实际中难以实现。
最近最久未使用(LRU)算法：该算法置换出最近最久未使用的
页面。
优点是相对于FIFO算法，能够更好地适应程序的访问模式
变化，缺点是需要维护一个访问历史记录，开销相对较大。
最近最
久未使用(LRU)算法：该算法置换出最近最久未使用的页面。
优点
是相对于FIFO算法，能够更好地适应程序的访问模式变化，缺点
是需要维护一个访问历史记录，开销相对较大。
最近最久未使用(LRU)算法：该算法置换出最近最久未使用的页面。
优点是相对于FIFO算法，能够更好地适应程序的访问模式变化，缺点是需要维
护一个访问历史记录，开销相对较大。
最近最久未使用(LRU)算法：该算法置换出最近最久未使用的页面。
优点是相对于FIFO算法，
能够更好地适应程序的访问模式变化，缺点是需要维护一个访问历
史记录，开销相对较大。
时钟(Clock)算法：该算法基于一个时钟指针，按照页面的访
问情况进行循环置换。
优点是相较于LRU算法，减少了访问历史
记录的开销，缺点是在某些情况下可能产生"频繁置换"问题。
时钟(Clock)算法：该算法基于一个时钟指针，按照页面的访问情况进
行循环置换。
优点是相较于LRU算法，减少了访问历史记录的开销，缺点是在某些情况下可能产生"频繁置换"问题。
时钟(Clock)
算法：该算法基于一个时钟指针，按照页面的访问情况进行循环置换。
优点是相较于LRU算法，减少了访问历史记录的开销，缺点
是在某些情况下可能产生"频繁置换"问题。
时钟(Clock)算法：该算
法基于一个时钟指针，按照页面的访问情况进行循环置换。
优点是
相较于LRU算法，减少了访问历史记录的开销，缺点是在某些情
况下可能产生"频繁置换"问题。
根据实验结果及性能分析，不同的页面置换算法在不同场景下
有各自的优缺点。
选择合适的页面置换算法应基于系统的特性和应
用的需求。
根据实验结果及性能分析，不同的页面置换算法在不同
场景下有各自的优缺点。
选择合适的页面置换算法应基于系统的特
性和应用的需求。
以上是对实验运行结果及各种页面置换算法性能的分析。
在本次实验中，我们对页面置换算法进行了
研究和分析，得出以下结论：
页面置换算法在操作系统中具有重要的应用价值。
页面置换算
法是操作系统中处理内存分配和管理的关键机制之一，它能够合理
地管理有限的物理内存资源，确保系统能够高效地运行。
不同的页面置换算法适用于不同的场景和需求。
在实验过程中，我们研究了多种常见的页面置换算法，如FIFO、LRU、OPT等。
这些算法各自具有优点和缺点，选择合适的页面置换算法取决于系统的特性和运行负载。
页面置换算法仍然存在改进的空间。
虽然现有的页面置换算法在一定程度上能够满足操作系统的需求，但在面对某些特定场景和负载时，其性能可能还有待提高。
因此，未来可以进一步研究和改进页面置换算法，以提升操作系统的性能和效率。
综上所述，页面置换算法在操作系统中具有重要的应用价值，并且仍然有改进的空间。
通过对不同算法的研究和比较，我们可以选择合适的页面置换算法来满足操作系统的需求，并且进一步优化算法以提高系统性能。
参考文献1名称]
参考文献2名称]
参考文献3名称]
参考文献4名称]
参考文献5名称]
参考文献5名称]。