虚拟存储器管理实验报告
实习五 虚拟存储器实验报告
实习五虚拟存储器实验报告一、实验目的本次虚拟存储器实验旨在深入理解计算机系统中虚拟存储器的工作原理和机制，通过实际操作和观察，掌握虚拟存储器的相关概念和技术，包括页式存储管理、地址转换、页面置换算法等。
同时，培养我们的实践能力和问题解决能力，为今后学习和工作中涉及到的计算机系统相关知识打下坚实的基础。
二、实验环境本次实验使用的操作系统为 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. 学习并分析几种常见的页面置换算法，如FIFO、LRU、OPT等。
4. 比较不同页面置换算法的性能，提高对虚拟存储管理的认识。
二、实验环境1. 操作系统：Windows 102. 编程语言：Python3. 虚拟存储器模拟工具：虚拟机（VirtualBox）三、实验内容1. 模拟分页式虚拟存储器（1）定义分页式虚拟存储器的参数，如页大小、内存大小、虚拟地址空间大小等。
（2）创建页表，记录每个页在内存中的位置和是否已加载。
（3）模拟进程的指令序列，生成虚拟地址。
（4）根据虚拟地址进行地址转换，得到物理地址。
（5）处理缺页中断，选择合适的页面置换算法。
2. 页面置换算法模拟（1）实现FIFO（先进先出）页面置换算法。
（2）实现LRU（最近最少使用）页面置换算法。
（3）实现OPT（最优页面置换）算法。
3. 比较不同页面置换算法的性能（1）设置不同的页面置换算法，模拟进程运行。
（2）记录每次缺页中断时的页面命中率。
（3）比较不同页面置换算法的页面命中率，分析其性能。
四、实验结果与分析1. 分页式虚拟存储器模拟（1）通过模拟，成功实现了分页式虚拟存储器的地址转换和缺页中断处理过程。
（2）实验结果表明，分页式虚拟存储器能够有效地提高内存利用率，减少内存碎片。
2. 页面置换算法模拟（1）实现了FIFO、LRU和OPT三种页面置换算法。
（2）通过模拟，比较了三种算法在不同进程下的页面命中率。
3. 页面置换算法性能比较（1）FIFO算法的页面命中率较低，适用于进程较稳定的情况。
（2）LRU算法的页面命中率较高，适用于进程频繁访问同一页面的情况。
（3）OPT算法的页面命中率最高，但实现复杂度较高，适用于进程访问序列可预测的情况。
五、实验结论1. 通过本次实验，加深了对虚拟存储管理的基本概念和原理的理解。
操作系统管理_-_虚拟存储器_实验报告_代码
淮海工学院计算机工程学院实验报告书课程名：《操作系统原理》题目：虚拟存储器班级：学号：姓名：评语：成绩：指导教师：批阅时间：年月日一、目的与要求（一）目的由于超大规模集成电器电路（ＶＬＳＩ）技术的发展，使存贮器的容量不断扩大，价格大幅度下降。
但从应用角度看，存贮器的容量和成本总会受到一定的限制。
所以，提高存贮器的使用效率始终是操作系统研究的重要课题之一，虚拟存贮器技术是用来扩大主存容量的一种重要的方法。
本实习要求学生独立地用高级语言编写几个常用的存贮器分配算法，并能设计一个存贮管理的模拟程序，能对各种算法进行分析比较，评测其性能优劣，从而加深对这些算法的了解。
（二）要求为了比较真实地模拟存贮器管理，可预先生成一个大致符合实际情况的指令地址流。
然后，通过模拟这样一种指令序列的执行来计算和分析比较各种算法的访问命中率。
二、示例１．题目本示例给出采用页式分配存贮器管理方案，并通过分析、计算不同页面淘汰算法情况下的访问命中率来比较各种算法的优劣，另外也考虑改变页面尺寸大小和实际存贮器容量对计算结果的影响，从而可为选择好的算法、合适的页面尺寸和存贮器实际容量提供依据。
本程序是按下述原则生成指令序列的：（１）５０％的指令是顺序执行的。
（２）２５％的指令是均匀分布在前地址部分。
（３）２５％的指令是均匀分布在后地址部分。
示例中选用最佳淘汰算法（OPT）和最近最少使用页面淘汰算法（ＬＲＵ）计算页面命中率。
公式为：页面失败次数命中率＝１－───────页地址流长度假定虚拟存贮容量为３２Ｋ，页面尺寸从１Ｋ到８Ｋ，实存容量从４页到３２页。
２.算法与框图（１）最佳淘汰算法（ＯＰＴ）。
这是一种理想的算法，可用来作为衡量其他算法优劣的依据，在实际系统中是难以实现的，因为它必须先知道指令的全部地址流。
由于本示例中已生成了全部地址流，故可计算最佳命中率。
该算法的准则是淘汰已满页表中以后不再访问或是最迟访问的页。
这就要求将页表中的页逐个与后继指令访问的所有页比较，如后继指令不再访问此页，则把此页淘汰，不然得找出后继指令中最迟访问的页面予以淘汰。
虚存管理实验报告
一、实验目的1. 理解虚存管理的概念、原理及其在操作系统中的作用；2. 掌握虚存管理的几种常用页面置换算法；3. 熟悉虚拟存储器的工作过程，包括地址转换、页面调入/调出等；4. 通过实验加深对虚存管理技术的理解和应用。
二、实验环境1. 操作系统：Windows 102. 编程语言：Python3.83. 虚拟存储器管理模拟程序：自行编写三、实验内容1. 虚存管理概述1.1 虚存管理的概念：虚存管理是操作系统内存管理的一个重要组成部分，通过虚拟存储技术，使得应用程序可以使用比实际物理内存更大的存储空间。
1.2 虚存管理的原理：虚存管理通过将程序的逻辑地址空间划分为若干个页面，并将这些页面映射到物理内存的页面中，实现逻辑地址空间与物理内存的映射。
2. 页面置换算法2.1 先进先出（FIFO）算法：FIFO算法是最简单的页面置换算法，按照页面进入内存的顺序进行置换。
2.2 最近最久未使用（LRU）算法：LRU算法将最近最久未使用的页面置换出内存。
2.3 Clock算法：Clock算法是对LRU算法的改进，通过使用一个指针来指示下一个要被置换的页面。
3. 虚拟存储器工作过程3.1 地址转换：当应用程序访问逻辑地址时，CPU将产生一个虚拟地址，操作系统通过地址转换将虚拟地址转换为物理地址。
3.2 页面调入/调出：当访问的页面不在内存中时，操作系统需要将一个页面从内存中调出，并将需要访问的页面调入内存。
4. 实验步骤4.1 编写模拟程序：编写一个模拟虚拟存储器管理的程序，实现页面置换算法、地址转换等功能。
4.2 生成指令地址流：产生一个需要访问的指令地址流，包括顺序执行的指令、均匀分布在前地址部分的指令、均匀分布在后地址部分的指令。
4.3 运行模拟程序：运行模拟程序，观察页面置换过程、地址转换过程以及内存使用情况。
4.4 分析实验结果：分析实验结果，比较不同页面置换算法的性能，分析虚拟存储器在内存使用上的优势。
操作系统管理-虚拟存储器-实验报告-代码7页
操作系统管理-虚拟存储器-实验报告-代码7页一、实验目的学习操作系统中虚拟存储器的概念，掌握虚拟存储器的实现思路和方式。
二、实验要求在C语言环境下，实现基于分页机制的虚拟存储和页表管理。
三、实验内容1.实现一个虚拟存储器，其中分页大小为4KB，虚拟地址空间大小为4GB（每个进程可以使用的虚拟地址空间）。
物理内存大小为512MB，即实际内存中有128个物理页面。
2.实现页表管理，将虚拟地址映射到物理地址。
3.实现页面替换算法，当物理内存不足时，需要将某些页面从内存中置换出来。
4.实现程序的运行，能够根据页面缺失率输出性能参数。
四、实验步骤1.确定程序设计思路和数据结构。
2.实现虚拟存储器和页表管理。
3.实现页面替换算法。
五、实验代码及解析对于程序设计思路，首先需要确定虚拟存储器和物理内存的大小，以及页面大小。
虚拟存储器大小默认为4GB，物理内存大小为512MB，页面大小为4KB。
其次，需要设计页表数据结构。
页表可以使用一个二维数组表示，其中第一维表示页表项，第二维表示页内地址。
页表项有四个字段，分别为标志位（是否在内存中）、页框号（页面所在的物理页框号）、保护（页面的读写权限）、计数（页面使用情况的计数器）。
第三，需要设计页面替换算法。
本程序采用最近最少使用算法（LRU）作为页面替换算法，当物理内存不足时，选择使用最近最少使用的页面进行替换。
#define PAGE_SIZE 4096 // 页面大小#define VIRTUAL_MEM_SIZE 4 * 1024 * 1024 * 1024 // 虚拟存储器大小#define PHYSICAL_MEM_SIZE 512 * 1024 * 1024 // 物理内存大小#define PAGE_NUM (VIRTUAL_MEM_SIZE / PAGE_SIZE) // 页面总数#define PHYSICAL_PAGE_NUM (PHYSICAL_MEM_SIZE / PAGE_SIZE) // 物理页面数struct page_table_entry {int present; // 是否在内存中（1为在，0为不在）int page_frame; // 页面所在的物理页框号int protect; // 页面的读写权限int count; // 页面使用情况的计数器}struct page_table_entry page_table[PAGE_NUM][PAGE_SIZE]; // 页表虚拟存储器和页表管理需要掌握的是页表的相关数据结构，还有一个重要的点，就是如何将虚拟地址映射到物理地址。
虚拟存储管理实验总结
虚拟存储管理实验总结虚拟存储是一种计算机操作系统的存储管理技术。
通过虚拟存储技术，操作系统能够把正在运行的程序看成是存储在主存储器中的一部分。
当程序需要的数据暂时不存在于主存储器时，操作系统会自动把暂时不用的程序或数据存放在磁盘上，并在需要时再自动调入主存储器中，从而以较小的主存储器容量来运行大程序。
在本次虚拟存储管理实验中，我们学习了虚拟存储管理技术的实现原理以及相关算法。
通过该实验，我们深入理解了进程运行时的存储管理过程，并通过实际操作和调试，进一步巩固了对操作系统的理论知识和实践应用的掌握。
一、实验环境本次实验主要在Linux操作系统上进行。
Linux内核由于其源代码公开、开放平台、代码规范等优点，成为了广大计算机科学爱好者学习操作系统的首选。
我们还需要安装实验所需的MAM分配器和SSTF调度器等辅助工具。
二、实验过程实验的主要步骤包括：1.分配器的实现。
我们需要实现MAM分配器，该分配器要求能够自动将进程使用的内存块分配出去，且在进程退出时自动释放所使用的内存块。
2.虚拟地址转换实现。
实验中，我们需要使用页表来管理虚拟地址。
通过页表，可以将虚拟地址转换为物理地址，从而操作系统可以向硬盘中读写数据。
3.页面置换算法实现。
当内存不足时，虚拟存储会通过一些页面置换算法将部分进程在内存中的页面清除，以留下新的内存页面。
我们需要实现SSTF算法，即使用磁盘上最近访问时间最短的页面作为置换页面。
4.进程初始化和各种信号灯的设置。
进程初始化时，需要使用fork函数创建子进程并将进程挂入等待队列中，以等待分配内存同步完成。
信号灯的设置则是为了保证操作的原子性和同步性。
实验中，我们首先实现了MAM分配器，通过实现内存块分配和释放函数，它可以很好地帮助我们管理分配出去的内存块。
接着，我们着手实现虚拟地址转换功能，需要对物理内存和虚拟内存进行管理。
由于高速缓存可以从磁盘中不用重复读取数据，所以我们还需要实现页面管理算法，以保证内存的有效利用。
虚拟存储器实验报告
虚拟存储器实验报告一、实验目的本次虚拟存储器实验的目的在于深入理解虚拟存储器的工作原理，掌握其基本概念和关键技术，通过实际操作和观察，分析虚拟存储器对系统性能的影响，并能够运用所学知识解决在实验过程中遇到的问题。
二、实验环境本次实验使用的操作系统为 Windows 10，开发工具为 Visual Studio 2019，编程语言为 C+＋。
实验所使用的计算机配置为：Intel Core i7 处理器，16GB 内存，512GB 固态硬盘。
三、实验原理虚拟存储器是一种利用硬盘等辅助存储器来扩充主存容量的技术。
它将程序的逻辑地址空间与物理地址空间分开，使得程序可以使用比实际物理内存更大的地址空间。
当程序访问的地址不在物理内存中时，系统会通过页面置换算法将暂时不用的页面换出到硬盘，将需要的页面换入到物理内存中。
虚拟存储器的实现主要依赖于页式存储管理和地址转换机制。
页式存储管理将逻辑地址空间划分为固定大小的页面，物理地址空间也划分为相同大小的页框。
地址转换通过页表来完成，页表记录了逻辑页面与物理页框的对应关系。
四、实验内容1、页面置换算法的实现首先实现了先进先出（FIFO）页面置换算法。
创建一个固定大小的物理内存页框数组，模拟物理内存。
当需要装入新页面时，如果物理内存已满，按照先进入的页面先被置换的原则选择置换页面。
接着实现了最近最少使用（LRU）页面置换算法。
为每个页面设置一个访问时间戳，当需要置换页面时，选择访问时间最久远的页面进行置换。
2、虚拟地址到物理地址的转换设计了一个简单的页表结构，包括逻辑页号、物理页框号和有效位等字段。
输入一个虚拟地址，通过查找页表将其转换为物理地址。
如果页面不在物理内存中，触发页面置换算法进行页面调入。
3、性能分析对不同大小的程序和不同的页面置换算法，测量其页面缺失率和执行时间。
分析页面大小、物理内存大小等因素对虚拟存储器性能的影响。
五、实验步骤1、初始化实验环境设定物理内存大小、页面大小等参数。
虚拟存储器管理实验报告
淮海工学院计算机科学系实验报告书课程名：《操作系统》题目：虚拟存储器管理页面置换算法模拟实验班级：学号：姓名：一、实验目的与要求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%。
操作系统实验实验报告虚拟内存
操作系统实验实验报告虚拟内存实验报告：虚拟内存一、引言虚拟内存是现代操作系统中一种重要的内存管理技术。
它允许将物理内存与硬盘上的存储空间结合起来，扩大了计算机系统的内存容量。
本实验旨在深入学习和实践虚拟内存的相关知识，包括虚拟地址到物理地址的转换及页面置换算法的实现。
二、实验原理2.1虚拟地址与物理地址转换虚拟内存通过将程序的虚拟地址空间划分为大小相等的页面，每个页面对应物理内存或硬盘上的一个页面帧。
通过页表来建立虚拟地址到物理地址的映射关系。
当程序访问一个虚拟地址时，系统会通过查找页表得到该虚拟地址对应的物理地址。
2.2页面置换算法当物理内存不足以存放所有需要运行的程序时，需要使用页面置换算法将一部分页面调出到硬盘上，以便为新的页面腾出空间。
常见的页面置换算法有FIFO（先进先出）、LRU（最近最久未使用）和LFU（最少使用）等。
三、实验过程3.1虚拟地址到物理地址的转换首先，在操作系统中，我们设计了一个简单的页表结构，用来存储虚拟地址到物理地址的映射关系。
我们将虚拟地址空间划分为大小为4KB的页面，页表中的每一项对应一个页面，包含了页面的有效位、物理页帧号等信息。
当程序访问一个虚拟地址时，首先通过虚拟地址的高位几位确定页表的索引，然后根据索引找到对应的页表项。
如果该页面已经在物理内存中，可以直接从页表项中获取物理页帧号，然后加上页内偏移量，得到物理地址。
如果该页面不在内存中，则需要将其从硬盘上调入内存，更新页表项中的信息，并得到物理地址。
3.2页面置换算法的实现在本实验中，我们选择了FIFO页面置换算法。
该算法简单、实现容易。
我们使用一个先进先出的队列来存储页面的序号。
当需要置换页面时，我们选择队列中的第一个页面进行替换，并将新的页面插入队列的末尾。
四、实验结果我们通过编写一个简单的程序来模拟实验过程，包括对虚拟地址到物理地址的转换以及页面置换算法的实现。
通过对程序的运行和输出结果的观察，我们验证了虚拟内存和页面置换算法的正确性。
存储器管理实验报告
一、实验目的1. 理解存储器管理的概念和作用。
2. 掌握虚拟存储器的实现原理。
3. 熟悉存储器分配策略和页面置换算法。
4. 提高动手实践能力，加深对存储器管理知识的理解。
二、实验环境1. 操作系统：Linux2. 编程语言：C/C++3. 开发环境：GCC编译器三、实验内容1. 虚拟存储器实现原理（1）分页式存储管理：将内存划分为固定大小的页，进程的逻辑地址空间也划分为相应的页。
内存与外存之间通过页表进行映射，实现虚拟存储器。
（2）页表管理：包括页表建立、修改和删除等操作。
（3）页面置换算法：包括FIFO、LRU、LRU时钟等算法。
2. 存储器分配策略（1）固定分区分配：将内存划分为若干个固定大小的分区，每个分区只能分配给一个进程。
（2）可变分区分配：根据进程需求动态分配内存，分为首次适应、最佳适应和最坏适应等策略。
（3）分页存储管理：将内存划分为固定大小的页，进程的逻辑地址空间也划分为相应的页，通过页表进行映射。
3. 页面置换算法（1）FIFO算法：根据进程进入内存的顺序进行页面置换，最早进入内存的页面将被淘汰。
（2）LRU算法：淘汰最近最少使用的页面。
（3）LRU时钟算法：结合LRU算法和FIFO算法的优点，通过一个时钟指针实现页面置换。
四、实验步骤1. 编写程序实现虚拟存储器的基本功能，包括分页式存储管理、页表管理、页面置换算法等。
2. 编写测试程序，模拟进程在虚拟存储器中的运行过程，观察不同页面置换算法的效果。
3. 分析实验结果，比较不同页面置换算法的性能差异。
五、实验结果与分析1. 实验结果通过模拟实验，验证了虚拟存储器的基本功能，包括分页式存储管理、页表管理、页面置换算法等。
实验结果显示，不同页面置换算法对系统性能的影响较大。
2. 实验分析（1）FIFO算法：实现简单，但可能导致频繁的页面置换，影响系统性能。
（2）LRU算法：性能较好，但实现复杂，需要额外的硬件支持。
（3）LRU时钟算法：结合LRU算法和FIFO算法的优点，在性能和实现复杂度之间取得平衡。
操作系统实验六_虚拟存储器实验报告
操作系统实验六_虚拟存储器实验报告
实验目的：
通过本次实验，了解虚拟存储器的实现原理，以及如何分配虚拟地址和物理地址，实现虚拟存储器管理。
实验内容：
1.按照顺序完成程序代码，以实现对虚拟地址的映射，再间接实现对物理地址的访问。
2.完成不同的页面置换算法，并分析各自的特点。
实验步骤：
1.在实验中实现了给定的伪指令程序，其中包括了虚拟存储器的实现代码。
在页面大小为1K的情况下，每个进程的虚拟地址空间为64K，物理地址空间为16K。
2.在虚拟存储器的实现中，采用了分段式存储器管理模式，其中包括了段描述符表和页表。
其中段描述符表包括了段基址、段长、段类型等信息，而页表则记录了虚拟地址和物理地址的映射关系。
3.实现了三种页面置换算法：LRU、FIFO和随机算法。
其中，LRU算法会选择最近没有使用过的页面进行置换；FIFO算法会按照先进先出原则进行页面置换；随机算法则随机选取一个页面进行置换。
4.通过本次实验，学习了如何通过虚拟地址访问物理地址，并实现了对虚拟存储器的管理。
同时，在实现页面置换算法时，也对不同算法的特点进行了分析。
实验结果：。
操作系统实验(四)实验报告--虚拟内存
操作系统实验(四)实验报告--虚拟内存操作系统实验（四）虚拟内存1、实验题目页面置换算法模拟——OPT、FIFO和LRU算法2、实验目的了解虚拟存储技术的特点，掌握请求页式存储管理的页面置换算法，如最佳（Optimal）置换算法、先进先出（Fisrt In First Out）置换算法和最近最久未使用（Least Recently Used）置换算法3、实验内容1）OPT算法：需要发生页面置换时，算法总是选择在将来最不可能访问的页面进行置换。
2）FIFO算法：算法总是选择在队列中等待时间最长的页面进行置换。
3）LRU算法：如果某一个页面被访问了，它很可能还要被访问；相反，如果它长时间不被访问，那么，在最近未来是不大可能被访问的。
4、程序代码#include<iostream>#include <cstdlib>#include <time.h>#include <cstdio>#define L 30///页面走向长度最大为30using namespace std;int M=4; ///内存块struct P///定义一个结构体{int num,time;}p[30];int Input(int m,P p[L])///打印页面走向状态{m=30;int i,j;j=time(NULL);///取时钟时间srand(j);///以时钟时间x为种子，初始化随机数发生器cout<<"页面走向: ";for(i=0; i<m; i++){p[i].num=rand( )%10;///产生1到10之间的随即数放到数组p中p[i].time=0;cout<<p[i].num<<" ";}cout<<endl;return m;}void print(P *page1)///打印当前的页面{P *page=new P[M];page=page1;for(int i=0; i<M; i++)cout<<page[i].num<<" ";cout<<endl;}int Search(int e,P *page1 )///寻找内存块中与e相同的块号{P *page=new P[M];page=page1;for(int i=0; i<M; i++)if(e==page[i].num)return i; ///返回i值return -1;}int Max(P *page1)///寻找最近最长未使用的页面用于OPT算法{P *page=new P[M];page=page1;int e=page[0].time,i=0;while(i<M) ///找出离现在时间最长的页面{if(e<page[i].time) e=page[i].time;i++;}for( i=0; i<M; i++)if(e==page[i].time)return i; ///找到离现在时间最长的页面返回其块号return -1;}int Count(P *page1,int i,int t,P p[L])///记录当前内存块中页面离下次使用间隔长度用于OPT算法{P *page=new P[M];page=page1;int count=0;for(int j=i; j<L; j++){if(page[t].num==p[j].num )break;///当前页面再次被访问时循环结束else count++;///否则count+1}return count;///返回count的值}int main(){int c=1;int m=0,t=0;float n=0;///缺页次数m=Input(m,p);///调用input函数，返回m值M=4;P *page=new P[M];///dowhile(c==1||c==2||c==3){int i=0;for(i=0; i<M; i++) ///初试化页面基本情况{page[i].num=0;page[i].time=m-1-i;}cout<<"1:FIFO页面置换"<<endl;cout<<"2:LRU页面置换"<<endl;cout<<"3:OPT页面置换"<<endl;cout<<"按其它键结束程序；"<<endl;cin>>c;if(c==1)///FIFO页面置换///FIFO();{n=0;cout<<" FIFO算法页面置换情况如下: "<<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<<" ="<<n/m<<endl;}if(c==2)///LRU页面置换,最近最久未使用{n=0;cout<<" LRU算法页面置换情况如下: "<<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<<" = "<<n/m<<endl;}if(c==3)///OPT页面置换{n=0;cout<<" OPT算法置换情况如下:"<<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<<" = "<<n/m<<endl;}}///while(c==1||c==2||c==3);return 0;}5、心得体会通过该实验，是我对虚拟内存更加了解，对最佳置换算法、先进先出算法、最近最久算法更加了解。
- 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;}五、程序运行结果六、实验体会这次的实验，我们了解到了请求页式虚存管理是常用的虚拟存储管理方案之一。