虚拟存储器管理实验报告
实习五 虚拟存储器实验报告
实习五虚拟存储器实验报告一、实验目的本次虚拟存储器实验旨在深入理解计算机系统中虚拟存储器的工作原理和机制，通过实际操作和观察，掌握虚拟存储器的相关概念和技术，包括页式存储管理、地址转换、页面置换算法等。
同时，培养我们的实践能力和问题解决能力，为今后学习和工作中涉及到的计算机系统相关知识打下坚实的基础。
二、实验环境本次实验使用的操作系统为 Windows 10，开发工具为 Visual Studio 2019，编程语言为 C+＋。
三、实验原理1、虚拟存储器的概念虚拟存储器是一种利用硬盘等辅助存储器来扩充主存容量的技术。
它将程序和数据按照一定的页面大小划分，并在需要时将页面从硬盘调入主存，从而实现了使用有限的主存空间运行较大规模的程序。
2、页式存储管理页式存储管理将主存和辅存空间都划分为固定大小的页面。
程序的地址空间被分成若干页，主存也被分成相同大小的页框。
通过页表来记录页面和页框的对应关系，实现地址转换。
3、地址转换当 CPU 执行指令时，给出的是逻辑地址。
通过页表将逻辑地址转换为物理地址，才能在主存中访问相应的数据。
4、页面置换算法当主存空间不足时，需要选择一个页面换出到硬盘，以腾出空间调入新的页面。
常见的页面置换算法有先进先出（FIFO）算法、最近最少使用（LRU）算法等。
四、实验内容与步骤1、设计并实现一个简单的页式存储管理系统定义页面大小和主存、辅存的容量。
实现页表的数据结构，用于记录页面和页框的对应关系。
编写地址转换函数，将逻辑地址转换为物理地址。
2、实现页面置换算法分别实现 FIFO 和 LRU 页面置换算法。
在页面调入和调出时，根据相应的算法选择置换的页面。
3、测试和分析实验结果生成一系列的访问序列，模拟程序的运行。
统计不同页面置换算法下的缺页次数和命中率。
分析实验结果，比较不同算法的性能。
五、实验过程与结果1、页式存储管理系统的实现我们将页面大小设置为 4KB，主存容量为 16MB，辅存容量为 1GB。
实习五虚拟存储器实验报告
实习五虚拟存储器实验报告一、实验目的本次虚拟存储器实验旨在深入理解虚拟存储器的工作原理，掌握页面置换算法的实现和性能评估，以及观察虚拟存储器对系统性能的影响。
二、实验环境本次实验在装有 Windows 操作系统的计算机上进行，使用了专门的虚拟存储器实验软件，包括模拟系统内存和磁盘存储的工具。
三、实验原理1、虚拟存储器的概念虚拟存储器是一种通过硬件和软件的结合，为用户提供一个比实际物理内存大得多的逻辑地址空间的技术。
它允许程序在运行时，仅将部分数据和代码装入内存，而其余部分则存储在磁盘上，当需要时再进行调入和调出。
2、页面置换算法常见的页面置换算法有先进先出（FIFO）算法、最近最少使用（LRU）算法和最佳置换（OPT）算法等。
这些算法用于决定当内存空间不足时，哪些页面应该被替换出去，以腾出空间给新的页面。
四、实验内容与步骤（一）实验内容1、实现 FIFO 页面置换算法，并对其性能进行测试。
2、实现 LRU 页面置换算法，并对其性能进行比较。
3、观察不同页面访问序列和内存大小对页面置换算法性能的影响。
（二）实验步骤1、启动虚拟存储器实验软件，设置系统内存大小和页面大小。
2、输入页面访问序列，分别运行 FIFO 和 LRU 页面置换算法。
3、记录每次页面置换的情况，包括被置换的页面、缺页次数等。
4、改变页面访问序列和内存大小，重复上述实验过程。
五、实验结果与分析（一）FIFO 页面置换算法结果当使用 FIFO 算法时，对于给定的页面访问序列，随着内存大小的增加，缺页次数逐渐减少。
但在某些情况下，由于先进先出的特性，可能会出现将即将使用的页面置换出去的情况，导致缺页率较高。
（二）LRU 页面置换算法结果LRU 算法在大多数情况下表现优于 FIFO 算法。
因为它基于页面的最近使用情况进行置换，更能保留近期可能会再次使用的页面，从而减少缺页次数。
（三）不同页面访问序列的影响不同的页面访问序列对页面置换算法的性能有显著影响。
实验3虚拟存储器管理
淮海工学院计算机科学系实验报告书课程名：《操作系统原理》题目：实验三虚拟存储器管理班级：Z软件52学号：2017140595姓名：郭文静1、实验目的与要求本实验模拟请求页式虚存管理系统的页面置换情况。
实验程序能模拟一个拥有若干个虚页的进程在给定的若干个实页中运行、并在缺页中断发生时分别使用FIFO和LRU算法进行页面置换的情形。
要求程序运行时屏幕能显示出置换过程中的状态信息并输出访问结束时的页面命中率。
并通过为该进程分配不同的实页数，来比较几种算法的稳定性。
2、实验内容或题目本实验要求使用C/C++语言编程模拟一个拥有若干个虚页的进程在给定的若干个实页中运行、并在缺页中断发生时分别使用FIFO和LRU算法进行页面置换的情形。
其中虚页的个数可以事先给定（例如10个），对这些虚页访问的页地址流（其长度可以事先给定，例如20次虚页访问）可以由程序随机产生，也可以事先保存在文件中。
要求程序运行时屏幕能显示出置换过程中的状态信息并输出访问结束时的页面命中率。
程序应允许通过为该进程分配不同的实页数，来比较两种置换算法的稳定性。
实验说明：（1）设计中虚页和实页的表示本设计利用C/C++/Java语言的结构体来描述虚页和实页的结构。
在虚页结构中，pn代表虚页号，因为共10个虚页，所以pn的取值范围是0—9。
pfn代表实页号，当一虚页未装入实页时，此项值为-1；当该虚页已装入某一实页时，此项值为所装入的实页的实页号pfn。
time项在FIFO算法中不使用，在LRU中用来存放对该虚页的最近访问时间。
在实页结构中中，pn代表虚页号，表示pn所代表的虚页目前正放在此实页中。
pfn代表实页号，取值范围（0—n-1）由动态指派的实页数n所决定。
next 是一个指向实页结构体的指针，用于多个实页以链表形式组织起来，关于实页链表的组织详见下面第4点。
（2）关于缺页次数的统计为计算命中率，需要统计在20次的虚页访问中命中的次数。
虚拟存储管理实验报告
虚拟存储管理实验报告实验概述虚拟存储管理实验是操作系统课程中的一项重要实验，旨在通过模拟内存管理中的分页机制和页面置换算法，深入理解操作系统中的虚拟内存管理技术。
本实验主要包括以下几个关键点：- 模拟内存的分页机制- 实现页面置换算法- 分析不同页面置换算法的性能指标实验环境本次实验基于C语言和Linux操作系统进行实现，使用gcc编译器进行编译和调试。
实验过程及实现细节在本次实验中，我们实现了一个简单的虚拟内存系统，主要包括以下几个模块：页面管理、页面分配、页面置换和性能分析。
下面对每个模块的实现细节进行详细描述。
页面管理页面管理模块主要负责管理虚拟内存和物理内存之间的映射关系。
我们采用了分页机制进行管理，将虚拟内存和物理内存划分为固定大小的页面。
页面的大小由实验设置为4KB。
页面分配页面分配模块负责分配物理内存空间给进程使用。
我们使用一个位图作为物理内存管理的数据结构，记录每个页面的使用情况。
在每次页面分配时，我们会查找位图中第一个空闲的页面，并将其分配给进程。
页面置换页面置换模块是虚拟存储管理中的核心算法，主要用于解决内存中页面不足时的页面置换问题。
本次实验中我们实现了两种常用的页面置换算法：FIFO（先进先出）和LRU（最近最少使用）算法。
FIFO算法是一种简单的页面置换算法，它总是选择最早被加载到物理内存的页面进行置换。
LRU算法是一种基于页面访问历史的算法，它总是选择最长时间未被访问的页面进行置换。
性能分析性能分析模块主要用于评估不同的页面置换算法的性能指标。
我们使用了缺页率（Page Fault Rate）和命中率（Hit Rate）作为评价指标。
缺页率表示物理内存中的页面不能满足进程请求的比例，命中率表示进程请求的页面已经在物理内存中的比例。
实验结果为了评估不同的页面置换算法的性能，在实验过程中，我们通过模拟进程的页面访问序列，统计页面置换次数、缺页率和命中率等指标。
以一个包含100个页面访问请求的序列为例，我们分别使用FIFO算法和LRU 算法进行页面置换。
虚拟存储器管理
沈阳工程学院学生实验报告（课程名称：操作系统）实验题目：虚拟存储器管理班级计算机131 学号2013414126 姓名杨光成地点实训F608 指导教师吕海华王黎明实验日期: 2015 年 5 月26 日一、实验题目模拟分页式虚拟存储管理实验。
二、实验要求编写一段程序来模拟页面置换算法。
要求能分别显示最佳(Optimal)置换算法、先进先出(FIFO)页面置换算法和最近最久未使用(LRU)置换算法的置换过程。
三、实验目的通过本实验帮助学生理解虚拟存储器的工作方法。
了解分页式存储管理里中各页面置换算法是怎样实现的，各算法有怎样的优缺点。
四、实验原理分析⑴页面置换算法是在分页存储管理方式中为了合理的将进程运行所需的页面调入内存而产生的算法。
一个好的页面转换算法，应具有较低的页面更换频率。
最常见的页面置换算法有最佳(Optimal)置换算法、先进先出(FIFO)页面置换算法和最近最久未使用(LRU)置换算法。
⑵算法的说明最佳置换算法：选择以后永不使用或是在最长时间内不再被访问的页面作为被淘汰的页面。
这种算法通常可保证获得最低的缺页率，但因为内存中哪个页面是以后永不使用的是无法预知的，所以该算法是无法实现的。
先进先出页面置换算法：选择内存中驻留时间最长的页面作为被淘汰的页面。
该算法实现简单，只需将调入内存中的页面链成一个队列，并设置一个指针指向最老的页面即可。
最近最久未使用置换算法：选择最近最久未使用的页面作为被淘汰的页面。
该算法需要为每个页面设置一个访问字段用来记录页面上次被访问的时间，通过这个时间来决定淘汰哪一个页面。
⑶主要变量及函数说明如表1所示表1 主要变量及函数说明表PRA(void) 初始化int findSpace(void) 查找是否有空闲内存int findExist(int curpage) 查找内存中是否有该页面int findReplace(void) 查找应予置换的页面void display(void) 显示void FIFO(void) FIFO算法void LRU(void) LRU算法void Optimal(void) OPTIMAL算法void BlockClear(void) BLOCK恢复struct pageInfor * block 物理块struct pageInfor * page 页面号串五、实验代码清单1、主函数（如图1）int main(){int c;int m=0,t=0;float n=0;Pro p[L];m=Input(m,p);//调用input函数，返回m值cout<<"请输入可用内存页面数m(3～5): ";do{cin>>M;if(M>5||M<3)cout<<"内存块m须在3～5之间，请重新输入m： ";else break;}while(1);Pro *page=new Pro[M];do{for(int i=0;i<M;i++)//初试化页面基本情况{page[i].num=0;page[i].time=m-1-i;}i=0;cout<<"1:FIFO"<<endl;cout<<"2:LRU"<<endl;cout<<"3:OPT"<<endl;cout<<"按其它键结束程序；"<<endl; cin>>c;return 0;}图1 2、FIFO页面置换（如图2）if(c==1)//FIFO页面置换{n=0;cout<<" ****************************************** "<<endl;cout<<endl;cout<<" FIFO算法情况如下: "<<endl;cout<<endl;cout<<" ****************************************** "<<endl;while(i<m){if(Search(p[i].num,page)>=0)//当前页面在内存中{ cout<<p[i].num<<" ";//输出当前页p[i].numcout<<"不缺页"<<endl;i++;//i加1}else //当前页不在内存中{if(t==M)t=0;else{n++;//缺页次数加1page[t].num=p[i].num;//把当前页面放入内存中cout<<p[i].num<<" ";print(page);//打印当前页面t++;//下一个内存块i++;//指向下一个页面}}}cout<<"缺页次数："<<n<<" 缺页率："<<n/m<<endl;}图23、LRU页面置换（如图3）if(c==2)//LRU页面置换{n=0;cout<<" ****************************************** "<<endl;cout<<endl;cout<<" LRU算法情况如下: "<<endl;cout<<endl;cout<<" ****************************************** "<<endl; while(i<m){int a;t=Search(p[i].num,page);if(t>=0)//如果已在内存块中{page[t].time=0;//把与它相同的内存块的时间置0for(a=0;a<M;a++)if(a!=t)page[a].time++;//其它的时间加1cout<<p[i].num<<" ";cout<<"不缺页"<<endl;}else//如果不在内存块中{n++; //缺页次数加1t=Max(page);//返回最近最久未使用的块号赋值给tpage[t].num=p[i].num;//进行替换page[t].time=0;//替换后时间置为0cout<<p[i].num<<" ";print(page);for(a=0;a<M;a++)if(a!=t)page[a].time++;//其它的时间加1}i++;}cout<<"缺页次数："<<n<<" 缺页率："<<n/m<<endl;}图34、OPT页面置换（如图4）if(c==3)//OPT页面置换{n=0;cout<<" ****************************************** "<<endl;cout<<endl;cout<<" OPT算法情况如下:"<<endl;cout<<endl;cout<<" ****************************************** "<<endl;while(i<m){if(Search(p[i].num,page)>=0)//如果已在内存块中{cout<<p[i].num<<" ";cout<<"不缺页"<<endl;i++;}else//如果不在内存块中{int a=0;for(t=0;t<M;t++)if(page[t].num==0)a++;//记录空的内存块数if(a!=0)//有空内存块{int q=M;for(t=0;t<M;t++)if(page[t].num==0&&q>t)q=t;//把空内存块中块号最小的找出来page[q].num=p[i].num;n++;cout<<p[i].num<<" ";print(page);i++;}else{int temp=0,s;for(t=0;t<M;t++)//寻找内存块中下次使用离现在最久的页面if(temp<Count(page,i,t,p)){temp=Count(page,i,t,p);s=t;}//把找到的块号赋给spage[s].num=p[i].num;n++;cout<<p[i].num<<" ";print(page);i++;}}}cout<<"缺页次数："<<n<<" 缺页率："<<n/m<<endl;}图4五、成绩评定优良中及格不及格出勤内容格式分析总评指导教师：年月日。
虚拟页面管理实验报告(3篇)
第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. 分页式存储管理中的地址转换过程实验结果表明，分页式存储管理能够有效地将虚拟地址转换为物理地址，实现虚拟存储器。
虚拟器存储实验报告
一、实验目的1. 了解虚拟器存储的基本概念和原理；2. 掌握虚拟器存储的安装和配置方法；3. 通过虚拟器存储实验，验证虚拟器存储在计算机系统中的作用和优势。
二、实验环境1. 操作系统：Windows 102. 虚拟器软件：VMware Workstation 153. 实验内容：创建虚拟机、配置虚拟机、安装操作系统、配置网络、使用虚拟机存储三、实验步骤1. 创建虚拟机（1）打开VMware Workstation，点击“创建新的虚拟机”；（2）选择“自定义（高级）”，点击“下一步”；（3）选择虚拟机兼容性，点击“下一步”；（4）选择操作系统类型和版本，点击“下一步”；（5）输入虚拟机名称和安装路径，点击“下一步”；（6）分配内存大小，点击“下一步”；（7）创建虚拟硬盘，选择硬盘文件类型和容量，点击“下一步”；（8）选择虚拟机网络类型，点击“下一步”；（9）选择I/O设备设置，点击“下一步”；（10）完成创建虚拟机。
2. 配置虚拟机（1）双击打开虚拟机；（2）选择“自定义设置”；（3）在“硬件”选项卡中，调整虚拟机CPU核心数、内存大小等；（4）在“选项”选项卡中，配置网络连接、USB控制器等；（5）在“虚拟硬盘”选项卡中，调整硬盘容量、存储模式等；（6）在“CD/DVD选项”选项卡中，添加安装操作系统所需的镜像文件；（7）在“其他设置”选项卡中，配置USB控制器、打印机等。
3. 安装操作系统（1）启动虚拟机，进入操作系统安装界面；（2）按照安装向导完成操作系统安装。
4. 配置网络（1）在虚拟机中打开网络管理工具；（2）选择合适的网络连接方式，如桥接模式；（3）配置IP地址、子网掩码、网关等信息。
5. 使用虚拟机存储（1）在虚拟机中安装文件管理器；（2）将需要存储的文件复制到虚拟机中；（3）在虚拟机中打开文件管理器，查看存储的文件。
四、实验结果与分析1. 实验结果通过本次实验，成功创建了一个虚拟机，并安装了操作系统。
虚拟内存管理实习报告
虚拟内存管理实习报告姓名李炜学号**********日期4月10日目录内容一：总体概述 (3)内容二：任务完成情况 (3)任务完成列表（Y/N） (3)具体Exercise的完成情况 (3)内容三：遇到的困难以及解决方法 (9)内容四：收获及感想 (9)内容五：对课程的意见和建议 (9)内容六：参考文献 (10)内容一：总体概述这次实习主要是加入对tlb和虚拟内存的进一步支持，并且实验一下在原理课上学到过的各种替换策略，tlb是为了加速从虚拟地址到物理地址的翻译过程，而虚拟内存更是肩负着提供比实际物理内存更大的虚拟内存的重任，有了虚拟内存，才可以运行比实际内存更大的程序。
内容二：任务完成情况任务完成列表（Y/N）具体Exercise的完成情况TLB异常处理部分：Exercise 1:这个文件中和本次实习相关的主要是StartProcess这个函数，在这个函数中，首先打开一个文件，判断这个文件是否是可执行文件，如果是的话，为这个文件开辟一块地址空间来运行一个新线程，之后初始化和这个线程相关的寄存器，初始化完成之后运行这个程序。
其中在开辟新的地址空间的时候，为这个地址空间中的page table的每一项进行了初始化。
所以在后面对translationEntry增加内容的时候，最好还是在这个初始化过程中加入相应的初始化操作。
在构造可执行文件的空间时，首先读入这个文件的开始部分，即noffH，这个部分包含了文件的magic number（表示是否是可执行文件），文件中代码，数据，栈等各部分的位置、大小等。
之后根据这个大小，按照页大小分配内存页数量，初始化page table，将可执行文件的代码段和数据段按照虚存与内存一一对应的方式读入内存中。
(h)在这个文件中，主要是针对虚拟机整体的操作，其中在构造函数中，首先初始化了寄存器和内存，这个部分和本次实习没有关系，下面初始化了tlb中的项。
开始的时候，我认为对于每个地址空间都应该有自己的tlb，每次切换线（进）程的时候都要同时切换tlb内容，这个方案在nachos这样的虚拟机上实际上时可以实现的，而且tlb的miss可能会比只有一个tlb 要少很多，但是这种情况不符合计算机系统的实际情况，因为对于实际的计算机体系结构来说，tlb是一个硬件不见，每个cpu的核心应该具备一个tlb，因为多超标量等优化机制的存在，线程切换十分频繁，如果每次都要同时按照线程切换tlb，那样代价太大了，tlb本身是用来利用局部性来减少对page table的访问的，如果频繁改变tlb内容开销上太大，得不偿失。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
淮海工学院计算机科学系实验报告书课程名：《操作系统》题目：虚拟存储器管理页面置换算法模拟实验班级：学号：姓名：一、实验目的与要求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值，表示该虚页的最后一次被访问时间。
当LRU算法需要置换时，从所有已分配实页的虚页中找出time值为最小的虚页就是“最近最久未用”的虚页面，应该将它置换出去。
4．算法中实页的组织因为能分配的实页数n是在程序运行时由用户动态指派的，所以应使用链表组织动态产生的多个实页。
为了调度算法实现的方便，可以考虑引入free和busy两个链表：free链表用于组织未分配出去的实页，首指针为free_head，初始时n个实页都处于free链表中；busy链表用于组织已分配出去的实页，首指针为busy_head，尾指针为busy_tail，初始值都为null。
当所要访问的一个虚页不在实页中时，将产生缺页中断。
此时若free链表不为空，就取下链表首指针所指的实页，并分配给该虚页。
若free链表为空，则说明n个实页已全部分配出去，此时应进行页面置换：对于FIFO 算法要将busy_head 所指的实页从busy链表中取下，分配给该虚页，然后再将该实页插入到busy 链表尾部；对于LRU算法则要从所有已分配实页的虚页中找出time值为最小的虚页，将该虚页从装载它的那个实页中置换出去，并在该实页中装入当前正要访问的虚页。
三、程序流程图三个模块的流程图〈1〉登录模块〈2〉参数输入模块〈3〉算法实现模块四、主要程序清单模块之间的调用关系#include<stdio.h>#include<stdlib.h>#include<time.h>int producerand(int remainder);void initprocess();void chosedisplace();struct linknode * fifo(struct linknode *head,int randcount);void Optimal(struct linknode*head,int randprocess);struct linknode* LRU(struct linknode *head,int randprocess);struct linknode* initlink();void choicestey();int allotment(struct linknode *head);bool checkfifooptimal(struct linknode* head,int checkpage);void recover(struct linknode *head,int randprocess);void recovermemory();int process[10][20];//数组的横坐标为进程序列，纵坐标为每个进程的页号int processallotment[6];//存储每个进程已经分配的块数int finishp[6];//标志进程是否完成（1完成0不完成）int finishprocess=0;//进程完成的个数int findpage[6];//每个进程命中的个数struct linknode *plinkhead[6];struct linknode *plink[6];int memoryallotment[6];int stey=0;struct linknode{struct linknode *linkper;//空链表的前驱指针int page;int processpage;int used;int memorypage;struct linknode *linknext;//空链表的后继指针struct linknode *processper;//进程的前去指针struct linknode *processnext;//进程的后继指针};int main(){struct linknode *head=initlink();initprocess();choicestey();int re=allotment(head);if(re==0){printf("内存分配出现问题。
");system("pause");} chosedisplace();recovermemory();system("pause");}void recovermemory(){int n=0;printf("是否回收全部已分配的内存空间?\n回收输入1，不回收输入2\n");scanf("%d",&n);if(n==1){for(int i=1;i<=5;i++)recover(plinkhead[i],i);}if(n==2)printf("您这么做会浪费内存空间");}void recover(struct linknode *head,int randprocess){while(head!=0){head->used=0;head=head->processnext;}}void choicestey(){printf("请选择置换算法\n");printf("1 表示FIFO\n2 表示Optimal\n3 表示LRU\n");bool flag=true;while(flag){scanf("%d",&stey);switch(stey){case 1:{printf("您选择的是FIFO替换算法\n");flag=false; break;}case 2:{printf("您选择的是Optimal替换算法\n");flag=false;break;}case 3:{printf("您选择的是LRU替换算法\n");flag=false;break;}default :printf("输入错误，请重新输入\n");}}}void chosedisplace()//选择置换算法{struct linknode *head;int randcount;//进程序号bool find;while(finishprocess<5){randcount=producerand(5);while(processallotment[randcount]<process[randcount][0]){find=false;head=plinkhead[randcount];if(stey==1||stey==2)find=checkfifooptimal(head,process[randcount][processallotment[randcount]+1]);if(find==true){findpage[randcount]++;}if(find==false)//如果在链表中没找到当前的页数{switch(stey){case 1:{plinkhead[randcount]=fifo(plinkhead[randcount],randcount);break;}case 2:{Optimal(plinkhead[randcount],randcount);break;}case 3:{plinkhead[randcount]=LRU(plinkhead[randcount],randcount);break;}}}processallotment[randcount]++;}if(finishp[randcount]==0){finishprocess++;finishp[randcount]=1;}}struct linknode *p;printf("进程执行完后内存分配情况：\n");for(int i=1;i<=5;i++){p=plinkhead[i];while(p!=0){printf("内存块号：%d\t进程号：%d\t号：%d\n",p->memorypage,p->processpage,p->page);p=p->processnext;}}for(int i=1;i<=5;i++){printf("进程序列%d",i);printf("\t进程总页数为%d\t命中页为%d\t",process[i][0],findpage[i]);printf("进程的命中率为%.0f%%\n",((float)findpage[i])*100/process[i][0]);}}bool checkfifooptimal(struct linknode* head,int checkpage){while(head!=0)//遍历链表查单当前页是否在链表中{if(head->page==checkpage){return true;}else{head=head->processnext;}}return false;}struct linknode* LRU(struct linknode *head,int randprocess){struct linknode *bhead;bhead=head;while(head->processnext!=0){if(head->page==process[randprocess][processallotment[randprocess]+1])break;else head=head->processnext;}if(head->page!=process[randprocess][processallotment[randprocess]+1])//没找到{bhead->page=process[randprocess][processallotment[randprocess]+1];head->processnext=bhead;bhead->processper=head;bhead=bhead->processnext;bhead->processper=0;head=head->processnext;head->processnext=0;plink[randprocess]=plink[randprocess]->processnext;return bhead;}else//找到了{if(head==bhead)//头{head->processper=plink[randprocess];plink[randprocess]->processnext=head;plink[randprocess]=plink[randprocess]->processnext;head=head->processnext;head->processper=0;plink[randprocess]->processnext=0;findpage[randprocess]++;return head;}else{if(head->processnext==0)//尾{findpage[randprocess]++;return bhead;}else//中间{head->processnext->processper=head->processper;head->processper->processnext=head->processnext;head->processnext=0;head->processper=plink[randprocess];plink[randprocess]->processnext=head;plink[randprocess]=plink[randprocess]->processnext;findpage[randprocess]++;return bhead;}}}}void Optimal(struct linknode*head,int randprocess){struct linknode *maxp;maxp=head;int max=1,i;while(head!=0){for(i=processallotment[randprocess]+1;i<=process[randprocess][0];i++){if(process[randprocess][i]==head->page){break;}}if(i>max){max=i;maxp=head;}head=head->processnext;}maxp->page=process[randprocess][processallotment[randprocess]+1]; }struct linknode* fifo(struct linknode*head,int randprocess){struct linknode*phead;//改变后的头指针phead=head;head->page=process[randprocess][processallotment[randprocess]+1];while(head->processnext!=0){head=head->processnext;}head->processnext=phead;phead->processper=head;phead=phead->processnext;head=head->processnext;head->processnext=0;phead->processper=0;return phead;}int allotment(struct linknode *head)//为进程分配内存{int allotsum=0;//已经分配完进程的个数int randprocess;//当前要分配内存的进程标号bool boolallot[6];for(int i=1;i<6;i++){processallotment[i]=0;boolallot[i]=false;memoryallotment[i]=0;}while(allotsum<=4)//判断是否全部进程都分配完{randprocess=producerand(5);//随即生成进程标号if(boolallot[randprocess]==false)//判断进程是否分配完{if(head->used==0){if(processallotment[randprocess]==0){plinkhead[randprocess]=head;plink[randprocess]=head;plink[randprocess]->processper=0;plink[randprocess]->processnext=0;head->processpage=randprocess;plink[randprocess]->page=process[randprocess][1];head->used=1;printf("内存块号：%d\t进程号：%d\t页号：%d\n",head->memorypage,head->processpage,head->page);head=head-> linknext;memoryallotment[randprocess]++;findpage[randprocess]++;}else{boolchecksame=checkfifooptimal(plinkhead[randprocess],process[randprocess][processallotment[randprocess]+1]);if(checksame==false){head->used=1;head->processnext=0;head->processper=plink[randprocess];plink[randprocess]-> processnext=head;head->processpage=randprocess;head->page=process[randprocess][processallotment[randprocess]+1];plink[randprocess]=plink[randprocess]->processnext;printf("内存块号：%d\t进程号：%d\t页号：%d\n",head->memorypage,head->processpage,head->page);head=head->linknext;memoryallotment[randprocess]++;findpage[randprocess]++;}else{if(stey==3)plinkhead[randprocess]=LRU(plinkhead[randprocess],randprocess);else findpage[randprocess]++;}}processallotment[randprocess]++;}else{printf("进程%d分配失败\n",randprocess);return 0;}if(head==0){printf("进程%d分配失败\n",randprocess);return 0;}if(processallotment[randprocess]==process[randprocess][0]) {printf("进程%d分配成功\n",randprocess);allotsum++;boolallot[randprocess]=true;finishprocess++;finishp[randprocess]=1;}elseif(memoryallotment[randprocess]==4){allotsum++;boolallot[randprocess]=true;printf("进程%d分配成功\n",randprocess);}}}struct linknode *p;printf("初始内存分配情况：\n");for(int i=1;i<=5;i++){p=plinkhead[i];while(p!=0){printf("内存块号：%d\t进程号：%d\t号：%d\n",p->memorypage,p->processpage,p->page);p=p->processnext;}}return 1;}void initprocess(){int perrandcount;for(int i=1;i<=5;i++)//假设有5个进程{perrandcount=producerand(10);//每个进程产生的页面个数process[i][0]=perrandcount;for(int j=1;j<=perrandcount;j++)process[i][j]=producerand(20);//为第i个进程产生0到19之间的页面顺序}for(int i=1;i<=5;i++){printf("进程序列%d",i);printf("该进程的调用页号顺序");for(int j=1;j<=process[i][0];j++)printf("%d ",process[i][j]);printf("\n");}for(int i=1;i<=5;i++){findpage[i]=0;//为进程是否完成做初始化finishp[i]=0; //为每一个进程的命中数初始化}}struct linknode* initlink()//初始化内存链表{struct linknode *p,*q,*head;p=new linknode;head=q=p;p->used=0;p->processnext=NULL;p->processper=NULL;p->linkper=q;p->linknext=NULL;p->memorypage=1;p->page=-1;for(int i=1;i<=20;i++) //假设内存有20个大小相等的空闲块{p=new linknode;p->used=0;p->processnext=NULL;p->processper=NULL;p->linkper=q;q->linknext=p;p->linknext=NULL;p->page=-1;p->memorypage=i+1;q=q->linknext;}return head;}int producerand(int remainder)//产生随机数{int randcount;randcount=(rand()+(unsigned)time(NULL))%remainder+1;return randcount;}五、程序运行结果六、实验体会这次的实验，我们了解到了请求页式虚存管理是常用的虚拟存储管理方案之一。