实验五 虚拟内存页面置换算法
实验5页面置换算法模拟实验ok
实验5 页面置换算法模拟实验一．实验目的1.进一步掌握虚拟存储器的实现方法。
2.掌握各种页面置换算法。
3.比较各种页面置换算法的优缺点。
二．实验内容模拟实现页面置换算法，步骤为：①使用产生随机数函数得到一个随机的数列，作为将要载入的页面序列。
②使用先进先出（FIFO）算法、最近最久未使用（LRU）置换算法和最佳（OPT）置换算法，列出所需淘汰的页面号序列。
③列出缺页中断次数。
三．参考源程序如下：#include <stdio.h>#include <stdlib.h>#include <time.h>#define N 10#define B 4/*------------------------------------------------------------------------函数名：IsInBuf()，返回某个数X在不在缓冲Buf[],如在，返回位置，否则返回－1--------------------------------------------------------------------------*/int IsInBuf(int buf[],int x){int i,j=-1;for(i=0;i<B;i++){if(buf[i]==x){ j=i;break; }else if(buf[i]==-1){ buf[i]=x;j=i;break; } }return j;}/*------------------------------------------------------------------------函数名：oldest()，返回最近最久未使用的页面位置--------------------------------------------------------------------------*/int oldest(int f[]){int i,j=0,max=-1;for(i=0;i<B;i++){if(f[i]>max){ max=f[i]; j=i; }f[i]++; }return j;}/*------------------------------------------------------------------------函数名：oldest2()，返回未来最久未使用的页面位置--------------------------------------------------------------------------*/int oldest2(int list[],int buf[],int f[],int start){int i,j;for(i=0;i<B;i++){for(j=start;j<N;j++){ if(buf[i]==list[j]) break; }f[i]=j; }return oldest(f);}int main(void){int list[N];int buf[B],f[B],i,j ;int old=0;int change=0;srand((int)time(NULL)); /*生成一系列随机数并初始化环境*/for(i=0;i<B;i++) {buf[i]=f[i]=-1;}printf("\nThe Random List:\n");for(i=0;i<N;i++){ list[i]=(int)rand()%10; printf("%2d",list[i]); } printf("\nFIFO\n");/*显示FIFO淘汰的页面序列*/change=0;for(i=0;i<N;i++){j=IsInBuf(buf,list[i]);if(j==-1){printf("%2d",buf[old]);buf[old]=list[i];old=(old+1)%(int)B;change++;}else printf(" "); }printf("\n changes %2d\n",change); /*显示有多少个缺页中断*/printf("\nLRU\n");/*显示LRU淘汰的页面序列*/change=0;for(i=0;i<B;i++) {buf[i]=f[i]=-1;}for(i=0;i<N;i++){j=IsInBuf(buf,list[i]);old=oldest(f);if(j==-1){printf("%2d",buf[old]);buf[old]=list[i];f[old]=0;change++;}else{ f[j]=0; printf(" "); } }printf("\n changes %2d\n",change); /*显示有多少个缺页中断*/printf("\nOPT\n");/*显示OPT淘汰的页面序列*/change=0;for(i=0;i<B;i++) {buf[i]=f[i]=-1;}for(i=0;i<N;i++){j=IsInBuf(buf,list[i]);if(j==-1){old=oldest2(list,buf,f,i);printf("%2d",buf[old]);buf[old]=list[i];f[old]=0;change++; }else{ f[j]=0; printf(" "); } }printf("\n changes %2d\n",change); /*显示有多少个缺页中断*/ getch();return 0; }（假设当前随机产生的页面序列为：7 1 0 4 2 5 8 6 9 1)四.填表题(1).在一个请求分页存储管理系统中，一个作业的页面走向为4、3、2、1、4、3、5、4、3、2、1、5，当分配给该作业的物理块数分别为4时，试计算采用先进先出淘汰算法时的缺页率(假设开始执行时主存中没有页面)，并将所得结果填表。
操作系统实验实验报告 虚拟内存
操作系统实验实验报告虚拟内存一、实验目的本次操作系统实验的目的是深入理解虚拟内存的概念、原理和实现机制，通过实际操作和观察，掌握虚拟内存的相关技术，包括页面置换算法、内存分配策略等，并分析其对系统性能的影响。
二、实验环境操作系统：Windows 10 专业版开发工具：Visual Studio 2019编程语言：C+＋三、实验原理1、虚拟内存的概念虚拟内存是一种计算机系统内存管理技术，它使得应用程序认为自己拥有连续的可用内存（一个连续完整的地址空间），而实际上，这些内存可能是被分散存储在物理内存和外部存储设备（如硬盘）中的。
虚拟内存通过将程序使用的内存地址映射到物理内存地址，实现了内存的按需分配和管理。
2、页面置换算法当物理内存不足时，操作系统需要选择一些页面（内存中的固定大小的块）换出到外部存储设备，以腾出空间给新的页面。
常见的页面置换算法有先进先出（FIFO）算法、最近最少使用（LRU）算法、时钟（Clock）算法等。
3、内存分配策略操作系统在分配内存时，需要考虑如何有效地利用有限的物理内存资源。
常见的内存分配策略有连续分配、分页分配和分段分配等。
四、实验内容与步骤1、实现简单的虚拟内存系统使用 C+＋编写一个简单的虚拟内存模拟程序，包括内存页面的管理、地址映射、页面置换等功能。
2、测试不同的页面置换算法在虚拟内存系统中，分别实现 FIFO、LRU 和 Clock 算法，并对相同的访问序列进行测试，比较它们的页面置换次数和缺页率。
3、分析内存分配策略的影响分别采用连续分配、分页分配和分段分配策略，对不同大小和类型的程序进行内存分配，观察系统的性能（如内存利用率、执行时间等）。
具体步骤如下：（1）定义内存页面的结构，包括页面号、标志位（是否在内存中、是否被修改等）等。
（2）实现地址映射函数，将虚拟地址转换为物理地址。
（3）编写页面置换算法的函数，根据不同的算法选择要置换的页面。
（4）创建测试用例，生成随机的访问序列，对不同的算法和分配策略进行测试。
页面置换算法实验报告_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. 最佳(OPT)页面置换算法最佳算法是一种理想化的算法，它总是选择未来最长时间内不会被访问的页面进行置换。
然而，由于无法预测未来的访问模式，最佳算法无法在实际系统中使用。
2. 先进先出(FIFO)页面置换算法FIFO算法是一种简单的页面置换算法，它总是选择最早进入内存的页面进行置换。
这种算法容易实现，但是它没有考虑到页面的访问模式，可能会导致较高的缺页率。
3. 最近最久未使用(LRU)页面置换算法LRU算法是一种基于页面访问历史的页面置换算法，它总是选择最近最久未使用的页面进行置换。
这种算法通常能够较好地预测未来的访问模式，但是实现起来较为复杂，需要维护一个访问历史记录。
4. 时钟(Clock)页面置换算法时钟算法是一种基于页面访问位的页面置换算法，它使用一个指针来指向内存中的页面，当需要置换页面时，检查指针指向的页面的访问位。
如果访问位为0，则选择该页面进行置换；如果访问位为1，则将访问位置为0，并将指针移动到下一个页面。
这种算法相对简单，并且能够较好地预测未来的访问模式。
5. 最不经常使用(LFU)页面置换算法LFU算法是一种基于页面访问频率的页面置换算法，它总是选择访问频率最低的页面进行置换。
这种算法能够较好地预测未来的访问模式，并且对于访问频率较低的页面有较好的效果。
四、页面置换算法的评价指标评价一个页面置换算法的好坏通常使用缺页率来衡量。
《操作系统》实验五页面置换算法模拟
实验五. 请求页式存储管理的模拟[实验内容]:熟悉虚拟存储管理的各种页面置换算法，并编写模拟程序实现请求页式存储管理的页面置换算法----最近最久未使用算法（LRU），要求在每次产生置换时显示页面分配状态和缺页率。
[实验要求]：1、运行给出的实验程序，查看执行情况，进而分析算法的执行过程，在理解FIFO页面置换算法和最近最久未使用算法（LRU）置换算法后，给出最佳置换算法的模拟程序实现，并集成到参考程序中。
2、执行2个页面置换模拟程序，分析缺页率的情况。
最好页框数和访问序列长度可调节，在使用同一组访问序列数据的情况下，改变页框数并执行2个页面置换模拟程序，查看缺页率的变化。
3、在每次产生置换时要求显示分配状态和缺页率。
程序的地址访问序列通过随机数产生，要求具有足够的长度。
最好页框数和访问序列长度可调节。
实验的执行结果如下图所示（左下图为FIFO执行结果，右下图为LRU执行结果）：程序源代码：#include <libio.h>#include "windows.h"#include <conio.h>#include <stdlib.h>#include <fstream.h>#include <io.h>#include <string.h>#include <stdio.h>void initialize(); //初始化相关数据结构void createps(); //随机生成访问序列void displayinfo(); //显示当前状态及缺页情况void fifo(); //先进先出算法int findpage(); //查找页面是否在内存void lru(); //最近最久未使用算法int invalidcount = 0; // 缺页次数int vpoint; //页面访问指针int pageframe[10]; // 分配的页框int pagehistory[10]; //记录页框中数据的访问历史int rpoint; //页面替换指针int inpflag; //缺页标志，0为不缺页，1为缺页struct PageInfo //页面信息结构{int serial[100]; // 模拟的最大访问页面数，实际控制在20以上int flag; // 标志位，0表示无页面访问数据int diseffect; // 缺页次数int total_pf; // 分配的页框数int total_pn; // 访问页面序列长度} pf_info;//////////////////////////////////////////////////////////////////////// //初始化相关数据结构void initialize(){int i,pf;inpflag=0; //缺页标志，0为不缺页，1为缺页pf_info.diseffect =0; // 缺页次数pf_info.flag =0; // 标志位，0表示无页面访问数据printf("\n请输入要分配的页框数："); // 自定义分配的页框数scanf("%d",&pf);pf_info.total_pf =pf;for(i=0;i<100;i++) // 清空页面序列{pf_info.serial[i]=-1;}///////////////////////////////////////////////////////////////////// 随机生成访问序列void createps(void ){int s,i,pn;initialize(); //初始化相关数据结构printf("\n请输入要随机生成访问序列的长度："); //自定义随机生成访问序列的长度scanf("%d",&pn);srand(rand()); //初始化随机数队列的"种子"s=((float) rand() / 32767) * 50 + pn; // 随机产生页面序列长度pf_info.total_pn = s;for(i=0;i<s;i++) //产生随机访问序列{pf_info.serial[i]=((float) rand() / 32767) * 16 ; //随机数的大小在0-15之间 }}////////////////////////////////////////////////////////////////////////// 显示当前状态及缺页情况void displayinfo(void){int i,n;if(vpoint==0){printf("\n=============页面访问序列=============\n");for(i=0; i<pf_info.total_pn; i++){printf("%4d",pf_info.serial[i]);if ((i+1) % 10 ==0) printf("\n"); //每行显示10个}printf("\n======================================\n");}printf("访问%3d : 内存<",pf_info.serial[vpoint]);for(n=0;n<pf_info.total_pf;n++) // 页框信息{if (pageframe[n] >=0)printf("%3d",pageframe[n]);elseprintf(" ");}printf(" >");if(inpflag==1) //缺页标志，0为不缺页，1为缺页{printf(" ==>缺页 ");printf("缺页率%3.1f",(float)(pf_info.diseffect)*100.00/vpoint);}printf("\n");}//////////////////////////////////////////////////////////////////////// // 查找页面是否在内存，1为在内存，0为不在即缺页int findpage(int page){int n;for(n=0;n<pf_info.total_pf;n++){pagehistory[n] ++; // 访问历史加1}for(n=0;n<pf_info.total_pf;n++){if (pageframe[n]==page ){inpflag=0 ; //inpflag缺页标志，0为不缺页，1为缺页pagehistory[n]=0; //置访问历史为0return 1;}}inpflag=1; //页面不存在，缺页return 0;}//////////////////////////////////////////////////////////////////////// // FIFO页面置换算法void fifo(void){int n,count,pstate;rpoint=0; // 页面替换指针初始化为0invalidcount = 0; // 缺页数初始化为0createps(); // 随机生成访问序列count=0; // 是否装满是所有的页框for(n=0;n<pf_info.total_pf;n++) // 清除页框信息{pageframe[n]=-1;}inpflag=0; //缺页标志，0为不缺页，1为缺页for(vpoint=0;vpoint<pf_info.total_pn;vpoint++) // 执行算法{pstate=findpage(pf_info.serial[vpoint]); //查找页面是否在内存if(count<pf_info.total_pf) // 开始时不计算缺页{if(pstate==0) // 页不存在则装入页面{pageframe[rpoint]=pf_info.serial[vpoint];rpoint=(rpoint+1) % pf_info.total_pf;count++;}}else // 正常缺页置换{if(pstate==0) // 页不存在则置换页面{pageframe[rpoint]=pf_info.serial[vpoint];rpoint=(rpoint+1) % pf_info.total_pf;pf_info.diseffect++; // 缺页次数加1}}Sleep(10);displayinfo(); // 显示当前状态} // 置换算法循环结束getch();return;}///////////////////////////////////////////////////////////////////// LRU页面置换算法void lru(void){int n,count,pstate,max;rpoint=0; // 页面替换指针invalidcount = 0; // 缺页次数初始化为0createps(); // 随机生成访问序列count=0; // 是否装满所有的页框for(n=0;n<pf_info.total_pf;n++){pageframe[n]=-1; // 清除页框信息pagehistory[n]=0; // 清除页框历史}inpflag=0; //缺页标志，0为不缺页，1为缺页for(vpoint=0;vpoint<pf_info.total_pn;vpoint++) // 执行算法{pstate=findpage(pf_info.serial[vpoint]); //查找页面是否在内存if(count<pf_info.total_pf) // 开始时不计算缺页{if(pstate==0) // 页不存在则装入页面{pageframe[rpoint]=pf_info.serial[vpoint]; //把要调入的页面放入一个空的页框里rpoint=(rpoint+1) % pf_info.total_pf;count++;}}else // 正常缺页置换{if(pstate==0)// 页不存在则置换页面{max=0;for(n=1;n<pf_info.total_pf;n++){if(pagehistory[n]>pagehistory[max]){max=n;}}rpoint=max;pageframe[rpoint]=pf_info.serial[vpoint];pagehistory[rpoint]=0;pf_info.diseffect++; // 缺页次数加1}}Sleep(10);displayinfo(); // 显示当前状态} // 置换算法循环结束_getch();return;}/////////////////////最佳置换算法自己完成///////////////////////////////////////////////////////////////////// 主函数int main(){char ch;system("cls") ;while ( true ){printf("*******************************************\n");printf(" 若要执行FIFO页面置算法请按1\n");printf(" 若要执行LRU 页面置算法请按2\n");printf(" 若要退出请按3\n") ;printf("*******************************************\n");printf( "Enter your choice (1 or 2 or 3): ");do{ //如果输入信息不正确，继续输入ch = (char)getch() ;}while(ch != '1' && ch != '2'&& ch != '3');printf("\n\n你按的是：%c ,现在为你执行对应操作。
实验五 请求页式存储管理中常用页面置换算法模拟
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");
void BlockClear(int Nsize) {//块清除 for(int i=0; i<Nsize; i++) { block[i].yemian = -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;
操作系统虚拟内存与页面置换算法
操作系统虚拟内存与页面置换算法操作系统的虚拟内存是一种将运行程序所需的内存空间扩展到硬盘上的技术。
通过虚拟内存，操作系统可以更好地管理内存资源，使得多个程序能够同时运行，并且在内存不足时能够有效地置换页面。
一、虚拟内存的概念和作用虚拟内存是操作系统为每个进程提供的一种看似连续、但实则可以存储在物理内存和硬盘上的地址空间。
它的主要作用有以下几点：1. 扩充内存容量：虚拟内存可以将硬盘上的一部分空间作为内存扩充，有效地提高内存的容量。
2. 隔离进程地址空间：每个进程有独立的虚拟内存空间，通过虚拟内存的隔离，进程与进程之间不会相互干扰。
3. 简化物理内存管理：操作系统只需将常用的部分加载到物理内存中，而不必一次性将整个进程加载到内存中，减少物理内存的压力。
二、页面置换算法虚拟内存的管理会面临一个问题——当物理内存不足时，如何选择将哪些页面换出到硬盘中以便腾出空间给其他页面使用。
下面介绍几种常见的页面置换算法：1. 先进先出（FIFO）算法FIFO算法是最简单的页面置换算法。
它根据页面进入物理内存的先后顺序进行置换，即最早进入内存的页面最先被置换。
但是，FIFO算法的缺点是它无法根据页面的访问频率进行调度，可能导致缺页率较高。
2. 最近最久未使用（LRU）算法LRU算法是一种比较常用的页面置换算法。
它通过记录页面最近一次被访问的时间戳，优先置换最长时间未被访问的页面。
LRU算法可以有效地利用页面的访问模式，但是实现起来比较复杂。
3. 时钟（Clock）算法时钟算法是一种简单而高效的页面置换算法。
它通过维护一个指针，在页面发生缺页时从指针所指页面开始扫描。
如果页面被访问过，则将其访问位置为1；如果没有被访问过，则将其换出并将指针指向下一个页面。
时钟算法的优点是实现简单，并且能够适应访问模式的变化。
综上所述，虚拟内存是操作系统管理内存资源的一种技术。
通过虚拟内存，操作系统可以更好地管理内存，提高内存的利用率，使得多个程序能够同时运行。
页面置换算法实验报告
页面置换算法实验报告页面置换算法实验报告一、引言在计算机操作系统中，页面置换算法是一种重要的内存管理策略。
当物理内存不足以容纳所有需要运行的进程时，操作系统需要根据一定的算法将部分页面从内存中换出，以便为新的页面腾出空间。
本实验旨在通过实际操作，对比不同的页面置换算法在不同场景下的性能表现。
二、实验背景在计算机系统中，每个进程都有自己的虚拟内存空间，而物理内存空间是有限的。
当进程需要访问某个页面时，如果该页面不在物理内存中，就会发生缺页中断，操作系统需要根据页面置换算法选择一个页面将其换出，然后将需要访问的页面换入。
常见的页面置换算法有先进先出（FIFO）、最近最久未使用（LRU）、时钟（Clock）等。
三、实验目的本实验旨在通过模拟不同的页面置换算法，比较它们在不同情况下的缺页率和效率。
通过实验结果，评估各个算法在不同场景下的优劣，为实际系统的内存管理提供参考。
四、实验设计与方法本实验选择了三种常见的页面置换算法进行比较：FIFO、LRU和Clock。
我们使用C++编程语言模拟了一个简单的内存管理系统，并通过产生不同的访存序列来模拟不同的场景。
实验中，我们设置了不同的物理内存大小，访存序列长度和页面大小，以模拟不同的系统环境。
五、实验结果与分析在实验中，我们分别测试了FIFO、LRU和Clock算法在不同的系统环境下的表现。
通过统计不同算法的缺页率和运行时间，得出以下结论：1. FIFO算法FIFO算法是最简单的页面置换算法，它按照页面进入内存的顺序进行置换。
实验结果表明，FIFO算法在缺页率方面表现一般，特别是在访存序列具有局部性的情况下，其性能明显下降。
这是因为FIFO算法无法区分不同页面的重要性，可能会将经常使用的页面换出，导致缺页率升高。
2. LRU算法LRU算法是一种基于页面访问时间的置换算法，它认为最近被访问的页面很可能在未来会被再次访问。
实验结果表明，LRU算法在缺页率方面表现较好，特别是在访存序列具有较强的局部性时，其性能明显优于FIFO算法。
请求页式存储管理的页面置换算法.
《操作系统》实验报告班级：计科0801班姓名：边佳学号：08407102 日期：2011年5月19日实验五请求页式存储管理的页面置换算法实验目的：通过请求页式存储管理中页面置换算法模拟程序，了解虚拟存储技术的特点，掌握请求页式存储管理的页面置换算法。
实验属性：设计实验内容：1.通过随机数产生一个指令序列，共320条指令，指令的地址按下述原则生产：50％的指令是顺序执行的；25％的指令是均匀分布在前地址部分；25％的指令是均匀分布在后地址部分。
2.将指令序列变换成为页地址流：设页面大小为1K；用户内存容量为4页到32页；用户虚存容量为32K。
在用户虚存中，按每K存放10条指令排列虚存地址，即320条指令在虚存中的存放方式为：第0条至第9条指令为第0页；第10条至19条指令为第1页；…第310条至319条指令为第31页。
3.计算并输出下述各种算法在不同内存容量下的命中率。
(1 先进先出算法（FIFO）(2 最近最少使用算法（LRU）(3 最佳使用算（OPT）命中率＝１－页面失效次数／页地址流长度本实验中，页地址流长度为320，页面失效次数为每次访问相应指令时，该指令所对应的页不在内存的次数。
实验思路：关于随机数的产生办法，首先要初始化设置随机数，产生序列的开始点，可通过下列语句实现： srand ( 400 ；(1 计算随机数，产生320条指令序列m＝160；for (i＝0；i＜80；i++＝{j＝i﹡4；a[j]＝m；a[j+1]＝m+1；a[j+2]＝a[j] ﹡1.0﹡ rand( /32767；a[j+3]＝a[j+2]+1m＝a[j+3]+(319-a[j+3] ﹡1.0﹡rand( /32767；}(2 将指令序列变换成为页地址流for ( k＝0；k＜320；k++{ pt＝a[k]/10；pd= a[k]%10；…}(3 计算不同算法的命中率rate＝1-1.0﹡U/320 ；其中U为缺页中断次数，320是页地址流长度。
虚拟内存页面置换算法实训报告
虚拟内存页面置换算法实训报告1. 介绍虚拟内存页面置换算法的概念和作用- 虚拟内存是计算机操作系统中的一种技术，它允许程序访问比物理内存更大的地址空间。
- 页面置换算法是虚拟内存管理的一种重要策略，它用于在物理内存不足时将一部分页面移出物理内存，以便为新的页面腾出空间。
2. 算法分类- 最优页面置换算法(OPT)：根据未来的访问情况，选择最长时间内不再被访问的页面进行置换。
- 先进先出页面置换算法(FIFO)：选择最早进入物理内存的页面进行置换。
- 最近最少使用页面置换算法(LRU)：选择最长时间内未被访问的页面进行置换。
- 时钟页面置换算法(CLOCK)：使用一个指针指向当前页面，选择指针指向的页面进行置换。
3. 算法比较- OPT算法是最理想的页面置换算法，但实际上很难实现，因为需要预测未来的页面访问情况。
- FIFO算法简单易实现，但可能会出现“抖动”现象，即频繁地将同一页面置换出去再置换回来。
- LRU算法性能较好，但实现较为复杂，需要维护一个访问时间戳。
- CLOCK算法是对LRU算法的一种改进，实现较为简单，但在某些情况下可能会出现性能问题。
4. 实验设计- 使用C++语言实现了FIFO、LRU和CLOCK三种页面置换算法。
- 使用随机生成的页面序列进行测试，记录每种算法的缺页率和执行时间。
- 分析实验结果，比较各种算法的优缺点。
5. 实验结果- 在测试中，FIFO算法的缺页率最高，CLOCK算法的缺页率最低，LRU 算法的缺页率居中。
- 在执行时间方面，CLOCK算法最快，FIFO算法最慢，LRU算法居中。
- 综合考虑，可以根据具体的应用场景选择适合的页面置换算法。
6. 结论- 虚拟内存页面置换算法是操作系统中的重要技术，对系统性能有着重要影响。
- 不同的页面置换算法有着各自的优缺点，需要根据具体情况进行选择。
- 实验结果表明，CLOCK算法在缺页率和执行时间方面都表现较好，可以作为一种较为通用的页面置换算法。
页面置换算法实验报告
页面置换算法实验报告一、实验目得:设计与实现最佳置换算法、随机置换算法、先进先出置换算法、最近最久未使用置换算法、简单Clock置换算法及改进型Cｌock置换算法;通过支持页面访问序列随机发生实现有关算法得测试及性能比较、二、实验内容:●虚拟内存页面总数为N,页号从0到N—1●物理内存由M个物理块组成●页面访问序列串就是一个整数序列,整数得取值范围为0到N - １、页面访问序列串中得每个元素p表示对页面p得一次访问●页表用整数数组或结构数组来表示❑符合局部访问特性得随机生成算法1.确定虚拟内存得尺寸Ｎ,工作集得起始位置p,工作集中包含得页数e,工作集移动率ｍ(每处理m个页面访问则将起始位置p ＋1),以及一个范围在0与１之间得值t;2.生成ｍ个取值范围在p与ｐ+ e间得随机数,并记录到页面访问序列串中;3.生成一个随机数r,0 ≤r ≤1;4.如果r〈t,则为p生成一个新值,否则p = (p＋１) mod N;5.如果想继续加大页面访问序列串得长度,请返回第2步,否则结束。
三、实验环境:操作系统:Wiｎｄows7软件: ＶＣ++6.0四、实验设计:本实验包含六种算法,基本内容相差不太,在实现方面并没有用统一得数据结构实现,而就是根据不同算法得特点用不同得数据结构来实现:1、最佳置换与随机置换所需操作不多,用整数数组模拟内存实现;2、先进先出置换与最近最久未使用置换具有队列得特性,故用队列模拟内存来实现;3、CLOCK置换与改进得CＬOＣＫ置换具有循环队列得特性,故用循环队列模拟内存实现;4、所有算法都就是采用整数数组来模拟页面访问序列。
五、数据结构设计:／/页面访问序列数组:ｉnｔｒeｆ［ref_sｉze];//内存数组:iｎt pｈy［phy_size］;//队列数据结构定义:tｙpeｄef sｔrｕｃt QＮoｄeﻩ//定义队列数据结构｛ﻩint daｔa;struct QNｏde *ｎext;}QNodｅ,*ＱueuePtr;ｔypedｅｆstrｕct{QuｅuｅPtr ｆrｏnt;ﻩ／/头指针ﻩQuｅuｅPtr reaｒ;ﻩ//尾指针｝LinkQuｅuｅ;/／定义链表数据结构typedeｆstruct LNoｄｅ//定义循环链表数据结构｛iｎt data;iｎt flag;ﻩ//访问位int modｉfy;ﻩﻩ//修改位ﻩstｒuct LNodｅ＊ｎext;}LNｏde,＊LinｋLｉst;六、主要函数说明:1、voｉd seｔ_rａｎｄ_num()ﻩ//产生具有局部特性得随机数列;2、int Exchange_ＬNoｄｅ(LｉnkLisｔ&L,inｔe,iｎt i)//将链表Ｌ中序号为i得结点替换为内容为e得结点;3、ｂool Sｅａrch_ＬiｎkLisｔ(LinｋＬｉst＆L,ｉnt e,ｉnｔ&i)／／找到链表Ｌ中内容为ｅ得结点,并用i返回其位置,i=1表示第一个非头结点,依次类推;4、void Ｓeａrch_ＬＬ_Flａg(LiｎkLisｔ＆Ｌ,iｎt ＆i)//用i返回第一个flag为0得结点得位置,i＝1表示第一个非头结点,以此类推;5、voｉd Ｓeｔ_LL＿Ｆlag(LinkLｉsｔ&L,int i) //设置链表Ｌ中得序号为ｉ得结点得ｆlaｇ标志为1;6、iｎtＳｅarch_ＬL＿ModifyClock(LinkLｉst ＆L,ｉnt&moｄｉｆy_ｎｕm)／/找到改进得CLOＣＫ算法所需要淘汰得页,用ｍodｉfｙ_nｕm返回其位置;此函数根据书上给得思路,第一遍扫描Ａ=０且M=０得页面予以淘汰,若失败,则进行第二轮扫描A=０且M=１得页面,第二轮扫描时将所有访问过得页面得访问位Ａ置0;若失败则重复上述两部;7、voｉd Sｅｔ＿LL_moｄｉfy(ＬｉｎｋLｉst＆L,int i) //设置链表L中得序号为i得结点得ｍodiｆy标志为1;8、booｌSearｃhQuｅｕe(LｉnｋQuｅｕe ＆Q,iｎｔe,int ＆ｉ)ﻩ//寻找队列Ｑ中结点data域等于ｅ得结点,并用i返回其在Q中得位置;9、ｉnt getnum(iｎt a,intｂ)ﻩﻩ//用ｂ返回元素ａ在被引用数列中得下一个位置10、voｉd ORA() ／/实现最佳置换算法,包括判断页面就是否在内存中、页面进内存、输出内存状态等内容;11、ｖoid RＡＮD() ﻩ／/随机置换算法12、void FＩＦO() ﻩﻩﻩ//先进先出算法1３、voiｄLRＵ() ﻩﻩ//最近最久未使用算法实现最近最久未使用算法得思想就是:判断待进入内存得页面,如果与内存中得第一个页面相同,则将它移到最后一个,即标志为最近使用得页;如果与内存中得第二个页面相同,则将它删除,并在队列尾部添加相同元素,即标志为最近使用得页;ﻩ１４、vｏid CＬOＣK()ﻩﻩ／／实现CLOＣK算法1５、ｖoid Ｍｏdifiｅｄ_Ｃlock() ／/实现改进得CLOCK算法16、inｔｍain() ／/主函数,调用实现各算法得６个主要函数,并输出各算法得缺页率。
页面置换算法实践报告
页面置换算法实践报告页面置换算法（Page Replacement Algorithm）是操作系统中用于管理虚拟内存的重要算法之一。
其目的是在有限的物理内存空间中，将进程所需的页面加载到内存中，并根据一定的策略替换掉不再被使用的页面，以提高内存利用率和系统性能。
在本次实践报告中，我将重点介绍三种常见的页面置换算法：先进先出（FIFO）、最近最久未使用（LRU）和最不经常使用（LFU）。
先进先出（FIFO）算法是最简单的页面置换算法之一。
它根据页面进入内存的先后顺序进行页面置换。
当一个页面需要被替换时，选择最早进入内存的页面进行替换。
虽然FIFO算法的实现简单，但它无法很好地反映页面的使用频率和重要性，容易发生“缺页率抖动”的问题。
缺页率抖动指的是在某些场景下，缺页率会频繁地快速上升，然后又快速下降。
最近最久未使用（LRU）算法是一种基于页面历史访问记录的页面置换算法。
它认为最近被访问过的页面是最有可能在未来被访问的，因此选择最近最久未使用的页面进行替换。
LRU算法可以较为准确地反映页面的使用频率，避免了FIFO算法的缺点。
但由于需要记录页面的访问历史，因此实现相对复杂，需要额外的开销。
最不经常使用（LFU）算法是一种基于页面使用频率的页面置换算法。
它认为使用频率最低的页面是最不重要的，因此选择最不经常使用的页面进行替换。
LFU算法可以较好地反映页面的使用频率，对于一些热点页面和冷门页面的处理较为准确。
但由于需要记录页面的使用次数，因此实现相对复杂，需要额外的开销。
根据实际情况选择合适的页面置换算法对于系统的性能影响非常重要。
一般来说，FIFO算法比较适用于缺页率较低的情况，而LRU算法则适用于需要较高精确度的场景，而LFU算法则适用于需要特别关注页面使用频率的场景。
在实践中，我们可以使用模拟算法来进行页面置换算法的实验。
通过构造不同的页面访问序列，我们可以测试不同算法的效果并进行比较。
在实验过程中，我们可以观察不同算法的缺页率、替换次数、访问延迟等指标，以评估算法的性能。
虚拟内存的页面置换算法
虚拟内存的页面置换算法一、概述虚拟内存是计算机操作系统中的一种技术，它允许程序使用比实际物理内存更大的内存空间。
但是，由于实际物理内存是有限的，虚拟内存的实现需要使用到一种称为页面置换算法的策略。
页面置换算法的作用是根据一定的规则将内存中的页面从物理内存中换出，以便为新的页面腾出空间。
二、FIFO算法FIFO（First In First Out）算法是最简单的页面置换算法之一。
它的原理是将最早进入内存的页面置换出去。
这种算法的实现非常简单，只需要维护一个页面队列，按照页面进入内存的先后顺序进行置换。
然而，FIFO算法存在一个明显的问题，即它无法区分页面的重要性。
如果最早进入内存的页面是一个常用的页面，那么它被置换出去后可能会频繁地被再次访问，从而导致性能下降。
三、LRU算法LRU（Least Recently Used）算法是一种比较常用的页面置换算法。
它的原理是将最近最少使用的页面置换出去。
为了实现LRU算法，需要维护一个页面访问时间的记录。
具体来说，每当一个页面被访问时，就将它的访问时间更新为当前时间。
当需要置换页面时，选择访问时间最早的页面进行置换。
这样做的好处是，能够较好地区分页面的重要性，常用的页面能够保留在内存中，提高系统的性能。
四、LFU算法LFU（Least Frequently Used）算法是根据页面的访问频率进行置换的算法。
它的原理是将访问频率最低的页面置换出去。
为了实现LFU算法，需要维护每个页面的访问次数。
具体来说，每当一个页面被访问时，就将它的访问次数加一。
当需要置换页面时，选择访问次数最低的页面进行置换。
LFU算法的优点是能够适应不同页面访问频率的变化，但是实现起来比较复杂。
五、OPT算法OPT（Optimal）算法是一种理论上的最佳页面置换算法。
它的原理是根据未来的访问情况进行页面置换。
具体来说，OPT算法会根据未来的页面访问情况预测哪个页面在未来最长时间内不会被访问到，然后将其置换出去。
操作系统 操作系统页面置换算法
实验五操作系统页面调度算法专业班级：学号：姓名：教师评分：实验项目名称：操作系统页面置换算法一、实验目的和要求：目的：对操作系统中使用的页面调度算法进行设计。
要求：对教材中所讲述的几种页面调度算法进行深入的分析，通过请求页式存储管理中页面置换算法模拟设计,了解虚拟存储技术的特点,掌握请求页式存储管理的页面置换算法。
二、实验内容1、设计两个程序模拟实现一个作业在内存中执行的页面置换，并计算缺页中断次数。
3、编制两种页面置换算法：1）FIFO页面置换算法；2）LRU页面置换算法三、实验原理：1、FIFO页面置换算法：总是选择在内存中驻留时间最长的一页将其淘汰。
2、LRU页面置换算法：选择最近一段时间内最长时间没有被访问过的页面予以淘汰。
四、参考程序：1、FIFO页面置换算法：#define M 4 /*m为系统分配给作业的主存中的页面数*/#define N 15#include <stdio.h>void main(){int a[M];/*定义内存页面数*/int b[N];/*定义总页面数*/int c[N];/*定义被淘汰的页面号*/int i,k,flag,count,m=0;printf("请输入作业序号:\n");for(i=0;i<N;i++) /*输入作业依次要访问的页号*/scanf("%d",&b[i]);printf("发生缺页的面号分别为：");for(i=0;i<M;i++)/*输出发生缺页中断的初始页号共m块*/ { a[i]=b[i];printf("%3d,",a[i]);}count=M;for(i=M;i<N;i++){ flag=0;for(k=0;k<M;k++)if(a[k]==b[i])flag=1;if(flag==0){ c[m]=a[0];m++;for(k=0;k<M-1;k++)a[k]=a[k+1];a[M-1]=b[i];count++;printf("%3d,",b[i]);}}printf("\n发生缺页的次数=%d\n",count);printf("\n缺页中断率=%.2f%%%\n",(float)count/N*100); printf("\n驻留内存的页号分别为：");for(i=0;i<M;i++)printf("%3d,",a[i]);printf("\n被淘汰的页号分别为：");for(i=0;i<m;i++)printf("%3d,",c[i]);}2、LRU页面置换算法：#define M 4 /*m为在主存中的页面数*/#define N 15#include <stdio.h>void main(){int a[M];/*定义内存页面数*/int b[N];int c[N];/*定义被淘汰的页面号*/int i,j,k,count,flag,m=0;printf("请输入作业序号:\n");for(i=0;i<N;i++)/*输入作业依次访问的页号*/ scanf("%d",&b[i]);printf("发生缺页的面号分别为：\n");for(i=0;i<M;i++){ a[i]=b[i];printf("%3d",a[i]);}count=M;在此处将程序补充完整/*代码补全*/for(i=M;i<N;i++){ flag=0;for(k=0;k<M;k++)if(a[k]==b[i]){ flag=1;for(j=k;j<M-1;j++)a[j]=a[j+1];a[M-1]=b[i];}if(flag==0){ c[m]=a[0];m++;for(k=0;k<M-1;k++)a[k]=a[k+1];a[M-1]=b[i];count++;printf("%3d,",b[i]);}}printf("\n发生缺页的次数=%d\n",count);printf("\n缺页中断率=%.2f%%%\n",(float)count/N*100);printf("\n驻留内存的页号分别为：");for(i=0;i<M;i++)printf("%d,",a[i]);printf("\n被淘汰的页号分别为：");for(i=0;i<m;i++)printf("%3d,",c[i]);}五、参考文献：1、《操作系统教程》，第3版，孙钟秀主编，高等教育出版社。
实验5 页式存储管理的页面置换算法模拟
实验4 页式存储管理的页面置换算法模拟1.实验目的通过请求页式存储管理中页面置换算法模拟设计，了解虚拟存储技术的特点，掌握请求页式存储管理的页面置换算法。
2.实验环境装有操作系统Windows XP和开发工具VC++6.0，内存在256M以上的微机；或者：装有Linux(Fedora 7)操作系统和gcc编译器，内存在256M以上的微机。
3.实验内容（1）通过随机数产生一个指令序列，共320条指令。
指令的地址按下述原则生成：①50%的指令是顺序执行的；②25%的指令是均匀分布在前地址部分；③25%的指令是均匀分布在后地址部分；具体的实施方法是：①在[0，319]的指令地址之间随机选取一起点m；②顺序执行一条指令，即执行地址为m+1的指令；③在前地址[0，m+1]中随机选取一条指令并执行，该指令的地址为m’；④顺序执行一条指令，其地址为m’+1的指令；⑤在后地址[m’+2，319]中随机选取一条指令并执行；⑥重复上述步骤①～⑤，直到执行320次指令。
（2）将指令序列变换为页地址流①设页面大小为1K；②分配内存容量为4K到32K；③用户虚存容量为32K。
在用户虚存中，按每K存放10条指令排列虚存地址，即320条指令在虚存中的存放方式为：第0条～第9条指令为第0页（对应虚存地址为[0，9]）；第10条～第19条指令为第1页（对应虚存地址为[10，19]）；…………第310条～第319条指令为第31页（对应虚存地址为[310，319]）。
按以上方式，用户指令可组成32页。
（3）计算先进先出（FIFO）算法或最近最少使用（LRU）算法在不同内存容量下的命中率。
其中，命中率=1-页面失效次数/页地址流长度4.实验要求(1)将FIFO或者LRU算法的源程序及程序执行结果写入实验报告；(2)将FIFO和LRU算法的工作机理写入实验报告。
代码：#include <stdio.h>#include <stdlib.h>#include <string.h>#ifndef _UNISTD_H#define _UNISTD_H#include <IO.H>#include <PROCESS.H>#endif#define TRUE 1#define FALSE 0#define INVALID -1#define total_instruction 320 //指令流长#define total_vp 32 //虚页长#define clear_period 50 //清周期typedef struct //页面结构{int pn, //页面序号pfn, //页面所在内存区的帧号counter, //单位时间内访问次数time; //上次访问的时间}pl_type;pl_type pl[total_vp]; //页面结构数组struct pfc_struct{ //页面控制结构int pn, //页面号pfn; //内存区页面的帧号struct pfc_struct *next; //页面指针，用于维护内存缓冲区的链式结构};typedef struct pfc_struct pfc_type; //主存区页面控制结构别名pfc_type pfc[total_vp], //主存区页面控制结构数组*freepf_head, //主存区页面控制结构的空闲页面头指针*busypf_head, //主存区页面控制结构的忙页面头指针*busypf_tail; //主存区页面控制结构的忙页面尾指针int diseffect; //页错误计数器，初次把页面载入主存时也当做页错误int a[total_instruction]; //随即指令流数组int page[total_instruction]; //指令对应的页面号int offset[total_instruction]; //指令所在页面中的偏移量int initialize(int); //初始化页面结构数组和页面控制结构数组int FIFO(int); //先进先出算法int LRU(int); //最近最久未使用算法int OPT(int); //最佳置换算法int CLOCK(int); //简单时钟(钟表)算法int main( ){int s; //随机数int i;srand(10*getpid()); /*每次运行时进程号不同，用来作为初始化随机数队列的"种子"*/ s = (int)((float)(total_instruction-1)*(rand()/(RAND_MAX+1.0)));printf("\n------------随机产生指令流------------\n");for (i=0; i<total_instruction; i+=4) //产生指令队列{a[i]=s; //任选一指令访问点ma[i+1]=a[i]+1; //顺序执行一条指令a[i+2]=(int)((float)a[i]*(rand()/(RAND_MAX+1.0))); //执行前地址指令m'a[i+3]=a[i+2]+1; //顺序执行一条指令printf("%6d%6d%6d%6d\n", a[i],a[i+1],a[i+2],a[i+3]);s = (int)((float)((total_instruction-1)-a[i+2])*(rand()/(RAND_MAX+1.0))) + a[i+2];}printf("--------------------------------------\n");for (i=0;i<total_instruction;i++) //将指令序列变换成页地址流{page[i]=a[i]/10;offset[i]=a[i]%10;}printf("\n--不同页面工作区各种替换策略的命中率表--\n");printf("Page\t FIFO\t LRU\t OPT\t CLOCK\n");for(i=4;i<=32;i++) //用户内存工作区从个页面到个页面{printf(" %2d \t",i);FIFO(i);LRU(i);OPT(i);CLOCK(i);printf("\n");}return 0;}//初始化页面结构数组和页面控制结构数组//total_pf; 用户进程的内存页面数int initialize(int total_pf){int i;diseffect=0;for(i=0;i<total_vp;i++){pl[i].pn=i;pl[i].pfn=INVALID; //置页面所在主存区的帧号为-1.表示该页不在主存中pl[i].counter=0; //置页面结构中的访问次数为pl[i].time=-1; //置页面结构中的上次访问的时间为-1 }for(i=0;i<total_pf-1;i++){pfc[i].next=&pfc[i+1]; //建立pfc[i-1]和pfc[i]之间的链接pfc[i].pfn=i; //初始化主存区页面的帧号}pfc[total_pf-1].next=NULL;pfc[total_pf-1].pfn=total_pf-1;freepf_head=&pfc[0]; //主存区页面控制结构的空闲页面头指针指向pfc[0] return 0;}//最近最久未使用算法//int total_pf; 用户进程的内存页面数int LRU (int total_pf){int MinT; //最小的访问时间，即很久没被访问过int MinPn; //拥有最小的访问时间的页的页号int i,j;int CurrentTime; //系统当前时间initialize(total_pf); //初始化页面结构数组和页面控制结构数组CurrentTime=0;diseffect=0;for(i=0;i<total_instruction;i++){if(pl[page[i]].pfn==INVALID) //页面失效{diseffect++; //页错误次数加if(freepf_head==NULL) //无空闲页面{MinT=100000;for(j=0;j<total_vp;j++){ //找出time的最小值，表明该页很久没被访问过if(MinT>pl[j].time&&pl[j].pfn!=INVALID){MinT=pl[j].time;MinPn=j;}}freepf_head=&pfc[pl[MinPn].pfn]; //最久没被访问过的页被释放pl[MinPn].pfn=INVALID; //最久没被访问过的页被换出主存pl[MinPn].time=-1; //最久没被访问过的页的访问时间置为无效freepf_head->next=NULL;}pl[page[i]].pfn=freepf_head->pfn; //有空闲页面,把相应的页面换入主存，并把pfn改为相应的帧号pl[page[i]].time=CurrentTime; //令访问时间为当前系统时间freepf_head=freepf_head->next; //减少一个空闲页面}elsepl[page[i]].time=CurrentTime; //命中则刷新该单元的访问时间CurrentTime++; //系统当前时间加}printf("%6.3f\t",1-(float)diseffect/320);return 0;}//最佳置换算法//int total_pf; 用户进程的内存页面数int OPT(int total_pf){int i,j;int MaxD; //将来最近一次访问的距离的最大值（以时间单元度量）int MaxPn; //将来最近一次访问的距离的最大值的页号int dis; //距离计数器int dist[total_vp]; //距离数组，保存距离上一次访问的时间差距个数initialize(total_pf); //初始化页面结构数组和页面控制结构数组diseffect=0;for(i=0;i<total_instruction;i++){if(pl[page[i]].pfn==INVALID) //页面失效{diseffect++; //页错误次数加if(freepf_head==NULL) //无空闲页面{for(j=0;j<total_vp;j++){if(pl[j].pfn!=INVALID) //如果该页在主存中dist[j]=100000; // 该页关联的距离值改为最大值elsedist[j]=0; //如果不在该页主存中，该页关联的距离值改为}dis=1; //初始距离值为for(j=i+1;j<total_instruction;j++) //从要替换的指令的下一条算起，{if(pl[page[j]].pfn!=INVALID &&pl[page[j]].counter==0) //如果该页在主存中,并且是将要最近访问的页//if(pl[page[j]].pfn!=INVALID && dist[page[j]]==100000) //此条语句原理与上相同{ dist[page[j]]=dis; //距离值改为displ[page[j]].counter=1; //使访问次数标志加，区别第一次访问和第二次访问}dis++;}MaxD=-1;for(j=0;j<total_vp;j++){pl[j].counter=0; //重置访问次数为if(MaxD<dist[j]) //查找将来最近一次访问的距离的最大值及其序号{MaxD=dist[j];MaxPn=j;}}freepf_head=&pfc[pl[MaxPn].pfn]; //替换将来一段时间最久访问的页freepf_head->next=NULL;pl[MaxPn].pfn=INVALID;}pl[page[i]].pfn=freepf_head->pfn; //把当前页换入主存中，并且把当前页的pfn改为换入页的帧号，freepf_head=freepf_head->next; //减少一个空闲页面}//if}//forprintf("%6.3f\t",1-(float)diseffect/320);return 0;}//简单时钟算法//int total_pf; 用户进程的内存页面数int CLOCK(int total_pf){int i;int use[total_vp]; //使用位int swap;swap=0; //发生替换initialize(total_pf);pfc_type *pnext; //时钟指针pfc_type *head; //队列头指针pnext=freepf_head;head=freepf_head;for(i=0;i<total_vp;i++){use[i]=0;} //初始化使用位为diseffect=0;for(i=0;i<total_instruction;i++){if (pl[page[i]].pfn==INVALID) //页面失效,不在主存中{diseffect++; //页错误次数加if(freepf_head==NULL) //无空闲页面{while(use[pnext->pfn]==1) //若时钟指针指向的页的使用位为，则改为并跳过{use[pnext->pfn]=0;pnext=pnext->next;if(pnext==NULL) pnext=head; //如果时钟指针到达队列尾部，重新返回头部}//换出被替换的页pl[pnext->pn].pfn=INVALID;swap=1;}if(use[pnext->pfn]==0){ //如果使用位为，则换入相应的页pl[page[i]].pfn=pnext->pfn; //页面结构中要标记帧号pnext->pn=page[i]; //页面控制结构中要标记页号use[pnext->pfn]=1; //重置使用位为pnext=pnext->next; //时钟指针下移if(pnext==NULL) pnext=head; //如果时钟指针到达队列尾部，重新返回头部if(swap==0){ freepf_head=freepf_head->next; } }}else{//页面在主存中use[pl[page[i]].pfn]=1; //刷新使用位为}}printf("%6.3f\t",1-(float)diseffect/320);return 0;}//先进先出算法版本//int total_pf; 用户进程的内存页面数//实现细节由CLOCK算法退化而来，与FIFO同效果int FIFO(int total_pf){int i;int use[total_vp];int swap=0;initialize(total_pf);pfc_type *pnext,*head;pnext=freepf_head;head=freepf_head;for(i=0;i<total_vp;i++){use[i]=0;}diseffect=0;for(i=0;i<total_instruction;i++){if (pl[page[i]].pfn==INVALID) //页面失效,不在主存中{diseffect++;if(freepf_head==NULL) //无空闲页面{while(use[pnext->pfn]==1){use[pnext->pfn]=0;pnext=pnext->next;if(pnext==NULL) pnext=head;}//换出被替换的页pl[pnext->pn].pfn=INVALID;swap=1;}if(use[pnext->pfn]==0){ //如果使用位为，则换入相应的页pl[page[i]].pfn=pnext->pfn; //页面结构中要标记帧号pnext->pn=page[i]; //页面控制结构中要标记页号use[pnext->pfn]=1; //重置使用位为pnext=pnext->next;if(pnext==NULL) pnext=head;if(swap==0){ freepf_head=freepf_head->next; }}}}printf("%6.3f\t",1-(float)diseffect/320);return 0;}结果：LRU：如果一个数据在最近一段时间没有被访问到，那么在将来它被访问的可能性也很小。
实验五页面置换算法
实验五：页面置换算法1.实验目的1)进一步加深理解父子进程之间的关系及其并发执行。
2)理解内存页面调度的机理。
3)掌握页面置换算法及其实现方法。
4)培养综合运用所学知识的能力。
5)页面置换算法是虚拟存储管理实现的关键，通过本次试验理解内存页面调度的机制，在模拟实现FIFO、LRU等经典页面置换算法的基础上，理解虚拟存储实现的过程。
6)将不同的置换算法放在不同的子进程中加以模拟，培养综合运用所学知识的能力。
2.实验内容程序涉及一个父进程和两个子进程。
父进程使用rand()函数随机产生若干随机数，经过处理后，存于一数组Acess_Series[]中，作为内存页面访问的序列。
两个子进程根据这个访问序列，分别采用FIFO和LRU两种不同的页面置换算法对内存页面进行调度。
3.实验要求这是一个综合性实验，要求在掌握父子进程并发执行机制和内存页面置换算法的基础上，能综合运用这两方面的知识，自行、独立编制程序。
每个子进程应能反映出页面置换的过程，并统计页面置换算法的命中或缺页情况。
设缺页的次数为diseffect。
总的页面访问次数为total_instruction。
则：缺页率 = disaffect/total_instruction命中率 = 1- disaffect/total_instruction将为进程分配的内存页面数mframe作为程序的参数，通过多次运行程序，说明FIFO算法存在的Belady现象。
4.程序流程图FIFO算法演示流程图：LRU5.数据结构及说明struct one_frame{//内存中的页int page_no;char flag;};struct one_frame M_Frame[frame_num];int pid1,pid2;//子进程int Acess_Series[total_instruction]={4,3,2,1,4,3,5,4,3,2,1,5};//待输入的页信息int diseffect;//未命中个数6.源程序。
虚拟存储器管理 页面置换算法模拟实验
淮海工学院计算机工程学院实验报告书课程名：《操作系统原理A 》题目：虚拟存储器管理页面置换算法模拟实验班级：软件***学号：20**1228**姓名：****一、实验目的与要求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。
实验五 虚拟内存页面置换算法
实验五虚拟内存页面置换算法一、需求分析 (1)1.输入的形式和输入值的范围 (2)2.输出的形式 (2)3.程序所能达到的功能 (3)4.测试数据 (4)二、概要设计 (5)1.抽象数据类型的定义 (5)2.主程序的流程 (6)3.程序各模块之间的层次(调用)关系 (7)三、详细设计 (7)1.void FIFO() (7)2.void OPI() (8)3.void LRU() (10)四、调试分析 (11)1.发现的问题 (11)2.算法的性能分析(包括基本操作和其它算法的时间复杂度和空间复杂度的分析)及其改进设想； (11)3.解决方法 (11)4.经验和体会 (12)五、用户使用说明 (12)六、测试结果 (12)七．附录 (14)一、需求分析●需求在进程运行过程中，若其所访问的页面不在内存而需把它们调入内存，但内存已无空闲空间时，为了保证该进程能正常运行，系统必须从内存调出一页程序或数据送磁盘的对换区中。
但应将哪个页面调出，需根据一定的算法来确定。
通常，把选择换出页面的算法称为页面置换算法。
置换算法的好坏，将直接影响到系统的性能。
一个好的页面置换算法，应具有较低的更好频率。
从理论上讲，应将那些以后不再访问的页面换出，或把那些在较长时间内不再访问的页面调出。
●实验目的通过这次实验，加深对虚拟内存页面置换概念的理解，进一步掌握先进先出FIFO、最佳置换OPI和最近最久未使用LRU页面置换算法的实现方法。
●实验内容设计程序模拟先进先出FIFO、最佳置换OPI和最近最久未使用LRU页面置换算法的工作过程。
假设内存中分配给每个进程的最小物理块数为m，在进程运行过程中要访问的页面个数为n，页面访问序列为P1, … ,Pn，分别利用不同的页面置换算法调度进程的页面访问序列，给出页面访问序列的置换过程，计算每种算法缺页次数和缺页率。
程序要求1）利用先进先出FIFO、最佳置换OPI和最近最久未使用LRU三种页面置换算法模拟页面访问过程。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验五虚拟内存页面置换算法一、需求分析 (1)1.输入的形式和输入值的范围 (2)2.输出的形式 (2)3.程序所能达到的功能 (3)4.测试数据 (4)二、概要设计 (5)1.抽象数据类型的定义 (5)2.主程序的流程 (6)3.程序各模块之间的层次(调用)关系 (7)三、详细设计 (7)1.void FIFO() (7)2.void OPI() (8)3.void LRU() (10)四、调试分析 (11)1.发现的问题 (11)2.算法的性能分析(包括基本操作和其它算法的时间复杂度和空间复杂度的分析)及其改进设想； (11)3.解决方法 (11)4.经验和体会 (12)五、用户使用说明 (12)六、测试结果 (12)七．附录 (14)一、需求分析●需求在进程运行过程中，若其所访问的页面不在内存而需把它们调入内存，但内存已无空闲空间时，为了保证该进程能正常运行，系统必须从内存调出一页程序或数据送磁盘的对换区中。
但应将哪个页面调出，需根据一定的算法来确定。
通常，把选择换出页面的算法称为页面置换算法。
置换算法的好坏，将直接影响到系统的性能。
一个好的页面置换算法，应具有较低的更好频率。
从理论上讲，应将那些以后不再访问的页面换出，或把那些在较长时间内不再访问的页面调出。
●实验目的通过这次实验，加深对虚拟内存页面置换概念的理解，进一步掌握先进先出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.输入的形式和输入值的范围从dos控制台界面按照输入提示输入数据（红色的数字即为输入的内容）：物理块(LackNum)：3页号数（PageNum）：20页面序列(PageOrder)：7 0 1 2 0 3 0 4 2 3 0 3 2 1 2 0 1 7 0 1进程的最大页号数为100，物理块、页面序列的值为int类型的范围。
2.输出的形式输入数据后，按ENTER键就可在dos控制台界面得到结果。
按照实验要求分别输出程序模拟先进先出FIFO、最佳置换OPI和最近最久未使用LRU页面置换算法的工作过程。
结果如下：首行是算法的名称，第二行是页号序列，接下来的3行数字是模仿物理块的情况，竖着看才是正确的结果，此图显示的是3块物理块时内存占用情况。
之后显示缺页次数和缺页率。
3.程序所能达到的功能程序模拟先进先出FIFO、最佳置换OPI和最近最久未使用LRU页面置换算法的工作过程。
假设内存中分配给每个进程的最小物理块数为m，在进程运行过程中要访问的页面个数为n，页面访问序列为P1, … ,Pn，分别利用不同的页面置换算法调度进程的页面访问序列，给出页面访问序列的置换过程，计算每种算法缺页次数和缺页率。
4.测试数据二、概要设计1.抽象数据类型的定义程序中进程调度时间变量描述如下：const int MaxNumber=100;int PageOrder[MaxNumber];int Simulate[MaxNumber][MaxNumber];int PageCount[MaxNumber];int PageNum,LackNum;double LackPageRate;bool found;主要函数：void print();void init();void original();void FIFO();void OPI();void LRU();2.主程序的流程 Init()输入a a=1a=2a=3a=4结束初始化全局变量：最小物理块数，页面个数，页面访问序列输出缺页次数和缺页率及模拟过程FIFO()OPI()LRU()否是否否是是是否3.程序各模块之间的层次(调用)关系main()Init()FIFO()OPI()LRU()Print()Print()Print()调用1 2 3三、详细设计1.void FIFO()original();Simulate[0][0]=PageOrder[0];int temp=0,flag=0;for(i=1;i<PageNum;i++){//判断该页面是否存在内存中for(j=0;j<BlockNum;j++){if(PageOrder[i]==Simulate[flag][j])break;}if(j==BlockNum){//该页面不在内存中for(k=0;k<BlockNum;k++){//模拟置换过程if(Simulate[flag][k]==NULL)break;elseSimulate[i][k]=Simulate[flag][k];}//淘汰最先进入内存的页面temp++;temp=temp%BlockNum;Simulate[i][temp]=PageOrder[i];LackNum++;flag=i;}//该页面在内存中elsecontinue;}2.void OPI()original();Simulate[0][0]=PageOrder[0];int temp,flag=0;//flag表示上一个模拟内存的下标for(i=1;i<PageNum;i++){//判断该页面是否存在内存中for(j=0;j<BlockNum;j++){if(PageOrder[i]==Simulate[flag][j])break;}//j!=BlockNum表示该页面已经在内存中if(j!=BlockNum)continue;//模拟置换过程for(k=0;k<BlockNum;k++){if(Simulate[flag][k]==NULL)break;elseSimulate[i][k]=Simulate[flag][k];}//内存中页面进行选择//两种情况：内存已满和内存未满for(j=0;j<BlockNum;j++){if(Simulate[i][j]==NULL){Simulate[i][j]=PageOrder[i];LackNum++;flag=i;break;}}if(j!=BlockNum)//内存未满continue;//内存已满temp=0;//temp表示要置换的页面内存下标for(j=0;j<BlockNum;j++){//选取要置换的页面内存下标for(k=i+1;k<PageNum;k++){//最长时间内不被访问的页面if(Simulate[i][j]==PageOrder[k]){PageCount[j]=k;break;}}if(k==PageNum)//之后没有进行对该页面的访问PageCount[j]=PageNum;if(PageCount[temp]<PageCount[j]){temp=j;}}Simulate[i][temp]=PageOrder[i];LackNum++;flag=i;}3.void LRU()original();Simulate[0][0]=PageOrder[0];int temp,flag=0;//flag表示上一个模拟内存的下标PageCount[0]=0;//最近的页面下标for(i=1;i<PageNum;i++){//判断该页面是否存在内存中for(j=0;j<BlockNum;j++){if(PageOrder[i]==Simulate[flag][j]){PageCount[j]=i;break;}}//j!=BlockNum表示该页面已经在内存中if(j!=BlockNum)continue;//模拟置换过程for(k=0;k<BlockNum;k++){if(Simulate[flag][k]==NULL)break;elseSimulate[i][k]=Simulate[flag][k];}//内存中页面进行选择//两种情况：内存已满和内存未满for(j=0;j<BlockNum;j++){if(Simulate[i][j]==NULL){//内存未满Simulate[i][j]=PageOrder[i];PageCount[j]=i;LackNum++;flag=i;break;}}if(j!=BlockNum)continue;//内存已满temp=0;//temp表示要置换的页面内存下标for(j=0;j<BlockNum;j++){//最近最久时间内不被访问的页面if(PageCount[temp]>PageCount[j])temp=j;}Simulate[i][temp]=PageOrder[i];PageCount[temp]=i;LackNum++;flag=i;}}四、调试分析1.发现的问题在编写程序的最初，界面不是很好，看着很乱。
最后求的缺页率也不是用百分数表示。
2.算法的性能分析(包括基本操作和其它算法的时间复杂度和空间复杂度的分析)及其改进设想；该程序的的时间复杂度还算理想，是O(m*n),空间复杂度也是一样，复杂度为O(m*n),均不需要再改进了。
3.解决方法界面使用空格填充，使各行各列对齐。
对于输出百分数，将缺页率乘以100，后加%输出。
4.经验和体会通过二次编程，又一次加深了对先进先出（FIFO）页面置换算法，最佳（OPI）置换算法，最近最久未使用（LRU）置换算法的理解。
同时，也掌握了一些使界面输出看起来更工整的办法。
还有，在平时做作业的时候，总是默认为物理块数是3，其实只是比较常用而已，并不是每次都是3.这个在编程中有体现，在今后做题中会更注意。
五、用户使用说明(1)用户根据提示输入物理块数(2)输入页面个数(3)依次输入页面访问个数(4)根据提示选择算法，输入对应的数字。
六、测试结果列出测试结果，包括输入和输出。
七．附录#include<iostream>#include<iomanip>using namespace std;const int MaxNumber=100;int PageOrder[MaxNumber];//页面序列P1, … ,Pn，int Simulate[MaxNumber][MaxNumber];//模拟页面置换过程int PageCount[MaxNumber];//int PageNum,LackNum;//页面数，缺页数double LackPageRate;//缺页率bool found;int BlockNum;int i,j,k;void print();void init();void original();void FIFO();void OPI();void LRU();void main(){//cout<<setw(2)<<" ";init();bool d=true;while(d){cout<<"算法选择\n FIFO: 输入'1'\n OPI: 输入'2'\n LRU: 输入'3'\n exit: 输入'4'\n";int c;cin>>c;switch(c){case 1:cout<<endl<<"先进先出FIFO页面置换算法：\n";FIFO();print();break;case 2:cout<<endl<<"最佳页面OPI置换算法：\n";OPI();print();break;case 3:cout<<endl<<"最近最久未使用LRU置换算法：\n";LRU();print();break;case 4:d=false;break;default:cout<<"你的输入有问题请重新输入！\n";break;}}}void init(){cout<<"物理块数m: ";cin>>BlockNum;cout<<"页面个数n: ";cin>>PageNum;cout<<"页面访问序列P1, … ,Pn\n";for(i=0;i<PageNum;i++)cin>>PageOrder[i];}void original(){for(i=0;i<PageNum;i++)for(j=0;j<BlockNum;j++)Simulate[i][j]=NULL;LackNum=1;}void print(){//模拟三种算法的页面置换过程，//给出每个页面访问时的内存分配情况//每种算法的缺页次数和缺页率。