虚拟内存页面置换算法实验报告

实验编号４名称页面置换算法模拟实验目的通过请求页式存储管理中页面置换算法模拟设计，以便：1、了解虚拟存储技术的特点2、掌握请求页式存储管理中页面置换算法实验内容与步骤设计一个虚拟存储区和内存工作区，并使用FIFO和LRU算法计算访问命中率。

<程序设计>先用srand()函数和rand()函数定义和产生指令序列，然后将指令序列变换成相应的页地址流，并针对不同的算法计算相应的命中率。

<程序1>#include <windows.h> //Windows版，随机函数需要，GetCurrentProcessId()需要//#include <stdlib.h>//Linux版，随机函数srand和rand需要#include <stdio.h> //printf()需要#define TRUE 1#define FALSE 0#define INV ALID -1#define NULL 0#define total_instruction 320 //共320条指令#define total_vp 32 //虚存页共32页#define clear_period 50 //访问次数清零周期typedef struct{//定义页表结构类型〔页面映射表PMT〕int pn, pfn, counter, time;//页号、页框号(块号)、一个周期内访问该页面的次数、访问时间}PMT;PMT pmt[32];typedef struct pfc_struct{//页面控制结构int pn, pfn;struct pfc_struct *next;}pfc_type;pfc_type pfc[32];pfc_type *freepf_head,*busypf_head,*busypf_tail;//空闲页头指针，忙页头指针，忙页尾指针int NoPageCount; //缺页次数int a[total_instruction];//指令流数组int page[total_instruction], offset[total_instruction];//每条指令的页和页内偏移void initialize( int );void FIFO( int );//先进先出void LRU( int );//最近最久未使用void NRU( int );//最近最不经常使用/****************************************************************************main()*****************************************************************************/ void main(){int i,s;//srand(10*getpid());//用进程号作为初始化随机数队列的种子//Linux版srand(10*GetCurrentProcessId());//用进程号作为初始化随机数的种子//Windows版s=rand()%320;//在[0，319]的指令地址之间随机选取一起点mfor(i=0;i<total_instruction;i+=4){//产生指令队列if(s<0||s>319){printf("when i==%d,error,s==%d\n",i,s);exit(0);}a[i]=s;//任意选一指令访问点m。

操作系统实验实验报告虚拟内存一、实验目的本次操作系统实验的目的是深入理解虚拟内存的概念、原理和实现机制，通过实际操作和观察，掌握虚拟内存的相关技术，包括页面置换算法、内存分配策略等，并分析其对系统性能的影响。

二、实验环境操作系统：Windows 10 专业版开发工具：Visual Studio 2019编程语言：C+＋三、实验原理1、虚拟内存的概念虚拟内存是一种计算机系统内存管理技术，它使得应用程序认为自己拥有连续的可用内存（一个连续完整的地址空间），而实际上，这些内存可能是被分散存储在物理内存和外部存储设备（如硬盘）中的。

虚拟内存通过将程序使用的内存地址映射到物理内存地址，实现了内存的按需分配和管理。

2、页面置换算法当物理内存不足时，操作系统需要选择一些页面（内存中的固定大小的块）换出到外部存储设备，以腾出空间给新的页面。

常见的页面置换算法有先进先出（FIFO）算法、最近最少使用（LRU）算法、时钟（Clock）算法等。

3、内存分配策略操作系统在分配内存时，需要考虑如何有效地利用有限的物理内存资源。

常见的内存分配策略有连续分配、分页分配和分段分配等。

四、实验内容与步骤1、实现简单的虚拟内存系统使用 C+＋编写一个简单的虚拟内存模拟程序，包括内存页面的管理、地址映射、页面置换等功能。

2、测试不同的页面置换算法在虚拟内存系统中，分别实现 FIFO、LRU 和 Clock 算法，并对相同的访问序列进行测试，比较它们的页面置换次数和缺页率。

3、分析内存分配策略的影响分别采用连续分配、分页分配和分段分配策略，对不同大小和类型的程序进行内存分配，观察系统的性能（如内存利用率、执行时间等）。

具体步骤如下：（1）定义内存页面的结构，包括页面号、标志位（是否在内存中、是否被修改等）等。

（2）实现地址映射函数，将虚拟地址转换为物理地址。

（3）编写页面置换算法的函数，根据不同的算法选择要置换的页面。

（4）创建测试用例，生成随机的访问序列，对不同的算法和分配策略进行测试。

页面置换算法实验报告院系:****************学院班级:***********姓名:***学号:************一、实验题目: 页面置换算法二. 实验目的：1.用C语言编写OPT、FIFO、LRU三种置换算法。

2.熟悉内存分页管理策略。

3.了解页面置换的算法。

4.掌握一般常用的调度算法。

5.根据方案使算法得以模拟实现。

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

三. 实验内容及要求:设计一个虚拟存储区和内存工作区, 编程序演示下述算法的具体实现过程, 并计算访问命中率:要求设计主界面以灵活选择某算法, 且以下算法都要实现1) 最佳置换算法(OPT): 将以后永不使用的或许是在最长(未来)时间内不再被访问的页面换出。

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

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

四、实验结果初始化结果1, 先进先出（FIFO）算法实验结果:2, 最近最久未使用（LRU）算法实验结果: 3, 最佳使用法（OPT）实验结果:五、实验总结选择置换算法, 先输入所有页面号, 为系统分配物理块, 依次进行置换:OPT基本思想:是用一维数组page[]存储页面号序列, memery[]是存储装入物理块中的页面。

数组next[]记录物理块中对应页面的最后访问时间。

每当发生缺页时, 就从物理块中找出最后访问时间最大的页面, 调出该页, 换入所缺的页面。

若物理块中的页面都不再使用, 则每次都置换物理块中第一个位置的页面。

FIFO基本思想:是用队列存储内存中的页面, 队列的特点是先进先出, 与该算法是一致的, 所以每当发生缺页时, 就从队头删除一页, 而从队尾加入缺页。

或者借助辅助数组time[]记录物理块中对应页面的进入时间, 每次需要置换时换出进入时间最小的页面。

LRU基本思想:是用一维数组page[]存储页面号序列, memery[]是存储装入物理块中的页面。

第1篇一、实验目的1. 理解虚拟存储器的概念和作用。

2. 掌握分页式存储管理的基本原理和地址转换过程。

3. 熟悉几种常见的页面置换算法，并比较其优缺点。

4. 通过实验，加深对虚拟存储器管理机制的理解。

二、实验内容1. 模拟分页式存储管理中的地址转换过程。

2. 比较几种常见的页面置换算法：FIFO、LRU、LFU和OPT。

三、实验原理虚拟存储器是一种将内存和磁盘结合使用的存储管理技术，它允许程序使用比实际物理内存更大的地址空间。

虚拟存储器通过将内存划分为固定大小的页（Page）和相应的页表（Page Table）来实现。

1. 分页式存储管理分页式存储管理将内存划分为固定大小的页，每个页的大小相同。

程序在运行时，按照页为单位进行内存访问。

分页式存储管理的主要优点是内存碎片化程度低，便于实现虚拟存储器。

2. 页面置换算法当内存中没有足够的空间来存放新请求的页面时，需要将某个页面从内存中移除，这个过程称为页面置换。

以下介绍几种常见的页面置换算法：（1）FIFO（先进先出）：优先淘汰最早进入内存的页面。

（2）LRU（最近最少使用）：优先淘汰最近最少被访问的页面。

（3）LFU（最不频繁使用）：优先淘汰最不频繁被访问的页面。

（4）OPT（最佳置换）：优先淘汰未来最长时间内不再被访问的页面。

四、实验步骤1. 模拟分页式存储管理中的地址转换过程（1）创建一个模拟内存的数组，表示物理内存。

（2）创建一个模拟页表的数组，用于存放虚拟页号和物理页号之间的映射关系。

（3）模拟进程对内存的访问，将访问的虚拟页号转换为物理页号。

2. 比较几种常见的页面置换算法（1）创建一个模拟进程的数组，包含访问的虚拟页号序列。

（2）对每个页面置换算法，模拟进程的运行过程，记录缺页中断次数。

（3）计算不同页面置换算法的缺页率，并比较其性能。

五、实验结果与分析1. 分页式存储管理中的地址转换过程实验结果表明，分页式存储管理能够有效地将虚拟地址转换为物理地址，实现虚拟存储器。

操作系统实验二：虚拟存储器管理时间：2013-12-06地点：计算机实验机房2实验人：朱蓉蓉学号：E01114336题目一：采用先进先出算法实现分页管理的缺页调度。

实验代码：#include "stdio.h"#define N 20#define m 4void main(){int n;printf("请输入引用串页面个数:\n");scanf("%d",&n);int ym[N],i,j,q,mem[m]={0},table[m][N];char flag,f[N];printf("请输入页面访问序列:\n");for(i=0;i<n;i++){printf("输入页面号:");scanf("%d",&ym[i]);}for(i=0;i<n;i++) //查页表，看是否缺页{q=0;while((ym[i]!=mem[q])&&(q!=m)) q++;if(q==m) flag='*'; //缺页，则置标志flag为'*'else flag=' ';if(flag=='*'){for(j=m-1;j>0;j--) //淘汰最先调入的页面调入当前访问的mem[j]=mem[j-1];mem[0]=ym[i];}for(j=0;j<m;j++)table[j][i]=mem[j];f[i]=flag;}printf("输出结果为下表(0代表为空，*代表有缺页)\n");for(i=0;i<m;i++){for(j=0;j<n;j++)printf("%3d",table[i][j]);printf("\n");}for(i=0;i<n;i++)printf("%3c",f[i]);printf("\n");}实验二：采用LRU算法实现分页管理的缺页调度.实验代码：#include <stdio.h>#define P 20#define m 5void main(){int n;printf("--------------LRU算法缺页调度---------------\n");printf("请输入引用串页面个数:\n");scanf("%d",&n);int ym[P],i,j,q,mem[m]={0},table[m][P];char flag,f[P];printf("请输入页面访问序列:\n");for(i=0;i<n;i++){printf("输入页面号:");scanf("%d",&ym[i]);}for(i=0;i<n;i++) //查页表，看是否缺页{q=0;while((ym[i]!=mem[q])&&(q!=m)) q++;if(q==m) flag='*'; //缺页，则置标志flag为'*'else flag=' ';for(j=q;j>0;j--)mem[j]=mem[j-1];mem[0]=ym[i];for(j=0;j<m;j++)table[j][i]=mem[j];f[i]=flag;}printf("输出结果为下表（0代表为空，*代表有缺页）\n");for(i=0;i<m;i++){for(j=0;j<n;j++)printf("%3d",table[i][j]);printf("\n");}for(i=0;i<n;i++)printf("%3c",f[i]);printf("\n");}。

计算机科学系实验报告书课程名：《操作系统》题目：虚拟存储器管理页面置换算法模拟实验班级：学号：姓名：一、实验目的与要求1.目的：请求页式虚存管理是常用的虚拟存储管理方案之一。

通过请求页式虚存管理中对页面置换算法的模拟，有助于理解虚拟存储技术的特点，并加深对请求页式虚存管理的页面调度算法的理解。

2.要求：本实验要求使用C语言编程模拟一个拥有若干个虚页的进程在给定的若干个实页中运行、并在缺页中断发生时分别使用FIFO和LRU算法进行页面置换的情形。

其中虚页的个数可以事先给定（例如10个），对这些虚页访问的页地址流（其长度可以事先给定，例如20次虚页访问）可以由程序随机产生，也可以事先保存在文件中。

要求程序运行时屏幕能显示出置换过程中的状态信息并输出访问结束时的页面命中率。

程序应允许通过为该进程分配不同的实页数，来比较两种置换算法的稳定性。

二、实验说明1．设计中虚页和实页的表示本设计利用C语言的结构体来描述虚页和实页的结构。

在虚页结构中，pn代表虚页号，因为共10个虚页，所以pn的取值范围是0—9。

pfn 代表实页号，当一虚页未装入实页时，此项值为-1；当该虚页已装入某一实页时，此项值为所装入的实页的实页号pfn。

time项在FIFO算法中不使用，在LRU中用来存放对该虚页的最近访问时间。

在实页结构中中，pn代表虚页号，表示pn所代表的虚页目前正放在此实页中。

pfn代表实页号，取值范围（0—n-1）由动态指派的实页数n所决定。

next是一个指向实页结构体的指针，用于多个实页以链表形式组织起来，关于实页链表的组织详见下面第4点。

2．关于缺页次数的统计为计算命中率，需要统计在20次的虚页访问中命中的次数。

为此，程序应设置一个计数器count，来统计虚页命中发生的次数。

每当所访问的虚页的pfn项值不为-1，表示此虚页已被装入某实页内，此虚页被命中，count加1。

最终命中率=count/20*100%。

3．LRU算法中“最近最久未用”页面的确定为了能找到“最近最久未用”的虚页面，程序中可引入一个时间计数器countime，每当要访问一个虚页面时，countime的值加1，然后将所要访问的虚页的time项值设置为增值后的当前countime值，表示该虚页的最后一次被访问时间。

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

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

1、最佳淘汰算法（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。

操作系统实验报告四【实验题目】虚拟内存页面置换算法【实验目的】通过这次实验，加深对虚拟内存页面置换概念的理解，进一步掌握先进先出FIFO，最佳置换OPI和最近最久未使用LRU页面置换算法的实现方法。

【实验内容】问题描述：设计程序模拟先进先出FIFO，最佳置换OPI和最近最久未使用LRU页面置换算法的工作过程。

假设内存中分配给每个进程的最小物理块数为m，在进程运行过程中要访问的页面个数为n，页面访问序列为P1, …,Pn，分别利用不同的页面置换算法调度进程的页面访问序列，给出页面访问序列的置换过程，计算每种算法缺页次数和缺页率。

程序要求如下：1）利用先进先出FIFO，最佳置换OPI和最近最久未使用LRU三种页面置换算法模拟页面访问过程。

2）模拟三种算法的页面置换过程，给出每个页面访问时的内存分配情况。

3）输入：最小物理块数m，页面个数n，页面访问序列P1, … ,Pn，算法选择1-FIFO，2-OPI，3-LRU。

4）输出：每种算法的缺页次数和缺页率。

【实验要求】1) 上机前认真复习页面置换算法，熟悉FIFO，OPI，LRU三种页面分配和置换算法的过程；2) 上机时独立编程、调试程序；3) 根据具体实验要求，完成好实验报告（包括实验的目的、内容、要求、源程序、实例运行结果截图）。

【源代码】//--------------- YeMianZhiHuan.cpp -----------------#include "iostream.h"const int DataMax=100;const int BlockNum = 10;int DataShow[BlockNum][DataMax]; // 用于存储要显示的数组bool DataShowEnable[BlockNum][DataMax]; // 用于存储数组中的数据是否需要显示//int Data[DataMax]={4,3,2,1,4,3,5,4,3,2,1,5,6,2,3,7,1,2,6,1}; // 测试数据//int N = 20; // 输入页面个数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();// DataInput();// FIFO();// Optimal();// LRU();// return 0;int menu;while(true){cout<<endl;cout<<"* 菜单选择*"<<endl;cout<<"*******************************************************"<<endl;cout<<"* 1-FIFO *"<<endl;cout<<"* 2-Optimal *"<<endl;cout<<"* 3-LRU *"<<endl;cout<<"* 0-EXIT *"<<endl;cout<<"*******************************************************"<<endl;cin>>menu;switch(menu){case 1: FIFO();break;case 2: Optimal();break;case 3: LRU();break;default: break;}if(menu!=1&&menu!=2&&menu!=3) break;}}//*/void DataInput(){cout<<"请输入最小物理块数：";cin>>M;while(M > BlockNum) // 大于数据个数{cout<<"物理块数超过预定值，请重新输入："; cin>>M;}cout<<"请输入页面的个数：";cin>>N;while(N > DataMax) // 大于数据个数{cout<<"页面个数超过预定值，请重新输入："; cin>>N;}cout<<"请输入页面访问序列："<<endl;for(int i=0;i<N;i++)cin>>Data[i];}void DataOutput(){int i,j;for(i=0;i<N;i++) // 对所有数据操作{cout<<Data[i]<<" ";}cout<<endl;for(j=0;j<M;j++){cout<<" ";for(i=0;i<N;i++) // 对所有数据操作{if( DataShowEnable[j][i] )cout<<DataShow[j][i]<<" ";elsecout<<" ";}cout<<endl;}cout<<"缺页次数: "<<ChangeTimes<<endl;cout<<"缺页率: "<<ChangeTimes*100/N<<"%"<<endl; }void FIFO(){int i,j;bool find;int point;int temp; // 临时变量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 ），见下面先进先出程序段}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++; // 缺页次数++if( (i+1) > M ) // 因为i是从0开始记，而M指的是个数，从1开始，所以i+1 {//获得要替换的块指针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; // 设置显示数据}}// 输出信息cout<< endl;cout<<"FIFO => "<< endl;DataOutput();}void Optimal(){int i,j,k;bool find;int point;int temp; // 临时变量，比较离的最远的时候用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 ; //// }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;}if( (i+1) > M ) // 因为i是从0开始记，而BlockNum指的是个数，从1开始，所以i+1 {//获得要替换的块指针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; // 设置显示数据}}// 输出信息cout<< endl;cout<<"Optimal => "<< endl;DataOutput();}void LRU(){int i,j;bool find;int point;int temp; // 临时变量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 ;}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++; // 缺页次数++if( (i+1) > M ) // 因为i是从0开始记，而BlockNum指的是个数，从1开始，所以i+1 {//获得要替换的块指针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; // 设置显示数据}}// 输出信息cout<< endl;cout<<"LRU => "<< endl;DataOutput();}【效果截图】以作业为测试数据：。

操作系统实验报告——页面置换问题的实现系别：信息工程系班级：计科姓名：学号：页面置换问题的模拟实现一．实验目的1．通过模拟实现几种基本页面置换的算法，了解虚拟存储技术的特点。

2．掌握虚拟存储请求页式存储管理中几种基本页面置换算法的基本思想，并至少用三种算法来模拟实现。

3．通过对几种置换算法页面的比较，来对比他们的优缺点，并通过比较更换频率来对比它们的效率。

二．实验内容：设计一个虚拟存储区和内存工作区，并使用下述算法来模拟实现页面的置换：1. 先进先出的算法（FIFO）2. 最近最久未使用算法（LRU）3. 最佳置换算法（OPT）三．实验分析在进程运行过程中，若其所访问的页面不存在内存而需要把它们调入内存，但内存已无空闲时，为了保证该进程能够正常运行，系统必须从内存中调出一页程序或数据送磁盘的对换区中。

但应调出哪个页面，需根据一定的算法来确定，算法的好坏，直接影响到系统的性能。

一个好的页面置换算法，应该有较低的页面更换频率。

假设分给一作业的物理块数为3 ，页面数为20个。

页面号为(20个)：7，0，1，2，0，3，0，4，2，3，0，3，2，1，2，0，1，7，0，11．先进先出(FIFO)置换算法的思路该算法总是淘汰最先进入内存的页面，即选择在内存中驻留时间最久的页面予以淘汰。

该算法实现简单，只需把一个进程已调入内存的页面，按照先后次序连接成一个队列，并设置一个替换指针，使它总指向最老的页面。

2．最近久未使用(LRU)置换算法的思路最近久未使用置换算法的替换规则，是根据页面调入内存后的使用情况来进行决策的。

该算法赋予每个页面一个访问字段，用来记录一个页面自上次被访问以来所经历的时间，当需淘汰一个页面的时候选择现有页面中其时间值最大的进行淘汰。

3.最佳（OPT）置换算法的思路其所选择的被淘汰的页面，奖是以后不使用的，或者是在未来时间内不再被访问的页面，采用最佳算法，通常可保证获得最低的缺页率。

4．数据结构struct pageInfor{int content;//页面号int timer;//被访问标记};class PRA{public:PRA(void);int findSpace(void); //查找是否有空闲内存int findExist(int curpage); //查找内存中是否有该页面int findReplace(void); //查找应予置换的页面void display(void); //显示void FIFO(void); //FIFO算法void LRU(void); //LRU算法void BlockClear(void);//BLOCK清空，以便用另一种方法重新演示pageInfor * block; //物理块pageInfor * page; //页面号串private:};5．FIFO页面置换算法当需要访问一个新的页面时，首先调用findExist(i)函数来查看物理块中是否就有这个页面，若要查看的页面物理块中就有，则调用display函数直接显示，不需要替换页面；如果要查看的页面物理块中没有，就需要寻找空闲物理块放入，若存在有空闲物理块，则将页面放入；若没有空闲物理块，则调用findReplace 函数替换页面。

页面置换算法实验报告页面置换算法实验报告一、引言在计算机操作系统中，页面置换算法是一种重要的内存管理策略。

当物理内存不足以容纳所有需要运行的进程时，操作系统需要根据一定的算法将部分页面从内存中换出，以便为新的页面腾出空间。

本实验旨在通过实际操作，对比不同的页面置换算法在不同场景下的性能表现。

二、实验背景在计算机系统中，每个进程都有自己的虚拟内存空间，而物理内存空间是有限的。

当进程需要访问某个页面时，如果该页面不在物理内存中，就会发生缺页中断，操作系统需要根据页面置换算法选择一个页面将其换出，然后将需要访问的页面换入。

常见的页面置换算法有先进先出（FIFO）、最近最久未使用（LRU）、时钟（Clock）等。

三、实验目的本实验旨在通过模拟不同的页面置换算法，比较它们在不同情况下的缺页率和效率。

通过实验结果，评估各个算法在不同场景下的优劣，为实际系统的内存管理提供参考。

四、实验设计与方法本实验选择了三种常见的页面置换算法进行比较：FIFO、LRU和Clock。

我们使用C++编程语言模拟了一个简单的内存管理系统，并通过产生不同的访存序列来模拟不同的场景。

实验中，我们设置了不同的物理内存大小，访存序列长度和页面大小，以模拟不同的系统环境。

五、实验结果与分析在实验中，我们分别测试了FIFO、LRU和Clock算法在不同的系统环境下的表现。

通过统计不同算法的缺页率和运行时间，得出以下结论：1. FIFO算法FIFO算法是最简单的页面置换算法，它按照页面进入内存的顺序进行置换。

实验结果表明，FIFO算法在缺页率方面表现一般，特别是在访存序列具有局部性的情况下，其性能明显下降。

这是因为FIFO算法无法区分不同页面的重要性，可能会将经常使用的页面换出，导致缺页率升高。

2. LRU算法LRU算法是一种基于页面访问时间的置换算法，它认为最近被访问的页面很可能在未来会被再次访问。

实验结果表明，LRU算法在缺页率方面表现较好，特别是在访存序列具有较强的局部性时，其性能明显优于FIFO算法。