实验四 虚拟存储器管理
操作系统 课程实验-实验四页式虚拟存储管理中地址转换和缺页中断
实验四页式虚拟存储管理中地址转换和缺页中断一、实验目的深入了解页式存储管理如何实现地址转换；进一步认识页式虚拟存储管理中如何处理缺页中断。
二、实验预备知识页式存储管理中地址转换的方法；页式虚拟存储的缺页中断处理方法。
三、实验内容编写程序完成页式虚拟存储管理中地址转换过程和模拟缺页中断的处理。
实验具体包括：首先对给定的地址进行地址转换工作，若发生缺页则先进行缺页中断处理，然后再进行地址转换；最后编写主函数对所做工作进行测试。
假定主存64KB，每个主存块1024字节，作业最大支持到64KB，系统中每个作业分得主存块4块。
四、提示与讲解页式存储管理中地址转换过程很简单，假定主存块的大小为2n字节，主存大小为2m'字节和逻辑地址m位，则进行地址转换时，首先从逻辑地址中的高m-n位中取得页号，然后根据页号查页表，得到块号，并将块号放入物理地址的高m'-n位，最后从逻辑地址中取得低n位放入物理地址的低n位就得到了物理地址，过程如图6所示。
逻辑地址图6 页式存储管理系统地址转换示意图地址转换是由硬件完成的，实验中使用软件程序模拟地址转换过程，模拟地址转换的流程如图7所示（实验中假定主存64KB，每个主存块1024字节，即n=10,m'=16，物理地址中块号6位、块内地址10位；作业最大64KB，即m=16，逻辑地址中页号6位、页内地址10位）。
在页式虚拟存储管理方式中，作业信息作为副本放在磁盘上，作业执行时仅把作业信息的部分页面装入主存储器，作业执行时若访问的页面在主存中，则按上述方式进行地址转换，若访问的页面不在主存中，则产生一个“缺页中断”，由操作系统把当前所需的页面装入主存储器后，再次执行时才可以按上述方法进行地址转换。
页式虚拟存储管理方式中页表除页号和该页对应的主存块号外，至少还要包括存在标志（该页是否在主存），磁盘位置（该页的副本在磁盘上的位置）和修改标志（该页是否修改过）。
操作系统实验指导-虚拟存储器管理
操作系统实验指导
实验四虚拟存储器管理
实验目的：
1 理解虚拟存储器的概念
2 掌握分页式存储管理地址转换和缺页中断
实验方法：上机操作
实验环境：编程语言不限
实验内容：
1 模拟分页式存储管理中硬件的地址转换和产生缺页中断
2 用先进先出页面调度算法处理缺页中断
实验要求：
实验报告只要求提交电子文档，不需要提交纸质打印文档。
电子文档按“学号-姓名-实验编号”统一命名，例如: 095043125-黄昌军-03.doc。
其中名字后的03为实验一的编号，依次类推。
提交时间：2011年11月21日24:00之前。
防灾科技学院实验报告。
存储器管理实验实验报告
存储器管理实验实验报告一、实验目的存储器管理是操作系统的重要组成部分，本次实验的目的在于深入理解存储器管理的基本原理和方法，通过实际操作和观察，掌握存储器分配与回收的算法，以及页面置换算法的实现和性能评估。
二、实验环境本次实验使用的操作系统为 Windows 10，编程语言为 C+＋，开发工具为 Visual Studio 2019。
三、实验内容与步骤（一）存储器分配与回收算法实现1、首次适应算法（1）原理：从空闲分区链的首地址开始查找，找到第一个满足需求的空闲分区进行分配。
（2）实现步骤：建立空闲分区链表，每个节点包含分区的起始地址、大小和状态（已分配或空闲）。
当有分配请求时，从链表头部开始遍历，找到第一个大小满足需求的空闲分区。
将该分区进行分割，一部分分配给请求，剩余部分仍作为空闲分区留在链表中。
若找不到满足需求的空闲分区，则返回分配失败。
2、最佳适应算法（1）原理：从空闲分区链中选择与需求大小最接近的空闲分区进行分配。
（2）实现步骤：建立空闲分区链表，每个节点包含分区的起始地址、大小和状态。
当有分配请求时，遍历整个链表，计算每个空闲分区与需求大小的差值。
选择差值最小的空闲分区进行分配，若有多个差值相同且最小的分区，选择其中起始地址最小的分区。
对选中的分区进行分割和处理，与首次适应算法类似。
3、最坏适应算法（1）原理：选择空闲分区链中最大的空闲分区进行分配。
（2）实现步骤：建立空闲分区链表，每个节点包含分区的起始地址、大小和状态。
当有分配请求时，遍历链表，找到最大的空闲分区。
对该分区进行分配和处理。
（二）页面置换算法实现1、先进先出（FIFO）页面置换算法（1）原理：选择在内存中驻留时间最久的页面进行置换。
（2）实现步骤：建立页面访问序列。
为每个页面设置一个进入内存的时间戳。
当发生缺页中断时，选择时间戳最早的页面进行置换。
2、最近最久未使用（LRU）页面置换算法（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%。
OS实验指导四——虚拟存储器管理
OS实验指导四——虚拟存储器管理
《操作系统》实验指导四
开课实验室：A207、A209 2015/11/23 、2015/11/24
一、实验目的
设计一个请求页式存储管理方案，并编写模拟程序实现。
二、设备与环境
1. 硬件设备：PC机一台
2. 软件环境：安装Windows操作系统或者
Linux操作系统，并安装相关的程序开发
环境，如C \C++\Java 等编程语言环境。
三、实验要求
1) 上机前认真复习页面置换算法，熟悉FIFO算法和LRU页面分配和置换算法的过程；
2) 上机时独立编程、调试程序；
3) 根据具体实验要求，完成好实验报告（包括实验的目的、内容、要求、源程序、实例运行结果截图）。
四、实验内容
1、问题描述：
设计程序模拟FIFO和LRU页面置换算法的工作过程。
假设内存中分配给每个进程的最小物理块数为m，在进程运行过程中要访问的页面个数为n，页面访问序列为P1, … ,Pn，分别利用不同的页面置换算法调度进程的页面访问序列，。
虚拟存储器管理
沈阳工程学院学生实验报告（课程名称：操作系统）实验题目：虚拟存储器管理班级计算机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五、成绩评定优良中及格不及格出勤内容格式分析总评指导教师：年月日。
操作系统原理虚拟存储器管理资料
光存储技术
通过垂直堆叠存储单元，提供更 高的存储密度和更低的延迟，有 望改变虚拟存储器的架构和设计。
利用激光在介质上刻写数据，具 有极高的存储密度和长达数百年 的数据保存期限，为虚拟存储器 提供了前所未有的容量和可靠性。
云计算与虚拟存储器的关系
云计算资源池化
分布式存储系统
云原生技术
云计算通过虚拟化技术将物理资源抽 象成逻辑资源，实现资源的动态分配 和共享，虚拟存储器是云计算资源池 化的重要组成部分。
物理地址空间
实际内存中的地址空间，与逻辑地址空间不一定连续。物理地址是内存单元的 实际地址，由硬件直接访问。
地址映射机制
1 2
动态重定位
程序执行时，将逻辑地址转换为物理地址的过程。 通过查页表或段表实现地址映射。
请求调页/请求分段
当所需页面/段不在内存中时，发出缺页/缺段中 断，将所需页面/段调入内存。
05
虚拟存储器与操作系统的关系
虚拟存储器对操作系统的影响
扩大内存容量
虚拟存储器通过内外存交换技术， 使得程序可以使用比实际内存更 大的容量。
内存保护
每个程序都在自己的虚拟地址空 间中运行，互不干扰，提高了系 统的安全性。
内存管理灵活
虚拟存储器实现了内存的逻辑扩 充，使得内存管理更加灵活，方 便用户和程序员使用。
03
内存回收策略
当进程不再需要某些内存空间时，操 作系统需要将这些空间回收并重新利 用。常见的内存回收策略包括引用计 数法、标记清除法和复制法等。
缓存技术
要点一
缓存命中与缺失
当CPU访问数据时，如果数据已经在 缓存中，则称为缓存命中；否则需要 从主存中读取数据到缓存中，称为缓 存缺失。
操作系统原理虚拟存储器管理
总结词
将内存划分为大小不等的段，每段存放 一个程序的段，以段为单位进行交换。
VS
详细描述
段式存储管理将内存空间划分为大小不等 的段框，每个段框可以存放一个程序的段 。程序被划分为多个段，每个段可以有不 同的长度。在进行段交换时，以段为单位 进行数据的存取和替换。
段页式存储管理
总结词
结合段式和页式存储管理的特点，将内存划分为固定大小的页框，程序分割为多个段，每段再分割为 固定大小的页。
虚拟存储器提供了一个统一的地址空间，使得应用程序可以 像访问内存一样访问硬盘上的数据，从而提高了程序的运行 效率。
虚拟存储器的实现方式
内存管理单元（MMU）
负责将虚拟地址转换为物理地址，实现虚拟存储器到物理存储器的 映射。
交换区
当物理内存不足时，操作系统会将部分内存数据交换到硬盘的交换 区中，以释放物理内存空间。
实现进程隔离
通过虚拟内存技术，每个进程都有独 立的内存空间，实现进程间的隔离， 防止数据冲突和相互干扰。
支持大内存程序
通过将内存分为物理内存和虚拟内存， 支持大内存程序的运行，满足不断增 长的程序需求。
02
虚拟存储器的基本概念
虚拟存储器的定义
虚拟存储器是一种将物理内存与硬盘存储相结合的技术，通 过将部分硬盘空间映射到物理内存中，实现内存的扩展。
操作系统原理虚拟存储器管 理
• 引言 • 虚拟存储器的基本概念 • 虚拟存储器的原理 • 虚拟存储器的管理策略 • 虚拟存储器的实现技术 • 虚拟存储器的性能优化
01
引言
主题简介
虚拟存储器是操作系统中用于管理物 理内存和磁盘存储的技术，通过将内 存分为物理内存和虚拟内存，实现进 程间的隔离和内存的动态分配。
实验四 存储器管理 结果
实验四存储器管理1、目的与要求本实验的目的是让学生熟悉存储器管理的方法，加深对所学各种存储器管理方案的了解；要求采用一些常用的存储器分配算法，设计一个存储器管理模拟系统，模拟内存空间的分配和释放。
2、实验内容①设计一个存放空闲块的自由链和一个内存作业分配表，存放内存中已经存在的作业。
②编制一个按照首次适应法分配内存的算法，进行内存分配。
③同时设计内存的回收以及内存清理（如果要分配的作业块大于任何一个空闲块，但小于总的空闲分区，则需要进行内存的清理，空出大块的空闲分区）的算法。
3．实验环境①PC兼容机②Windows、DOS系统、Turbo c 2.0③C语言4．实验提示一、数据结构1、自由链内存空区采用自由链结构，链首由指针freep指向，链中各空区按地址递增次序排列。
初启动时整个用户内存区为一个大空区，每个空区首部设置一个区头（freearea）结构，区头信息包括：Size 空区大小Next 前向指针，指向下一个空区Back 反向指针，指向上一个空区Adderss 本空区首地址2、内存分配表JOBMA T系统设置一个MA T，每个运行的作业都在MAT中占有一个表目，回收分区时清除相应表目，表目信息包括：Name 用户作业名Length 作业区大小Addr 作业区首地址二、算法存储分配算法采用首次适应法，根据指针freep查找自由链，当找到第一块可满足分配请求的空区便分配，当某空区被分配后的剩余空闲空间大于所规定的碎片最小量mini时，则形成一个较小的空区留在自由链中。
回收时，根据MA T将制定分区链入自由链，若该分区有前邻或后邻分区，则将他们拼成一个较大的空区。
当某个分配请求不能被满足，但此时系统中所有碎片总容量满足分配请求的容量时，系统立即进行内存搬家，消除碎片。
即将各作业占用区集中下移到用户内存区的下部（高地址部分），形成一片连续的作业区，而在用户内存区的上部形成一块较大的空闲，然后再进行分配。
操作系统管理_-_虚拟存储器_实验报告_代码
淮海工学院计算机工程学院实验报告书课程名：《操作系统原理》题目：虚拟存储器班级：学号：姓名：评语：成绩：指导教师：批阅时间：年月日一、目的与要求（一）目的由于超大规模集成电器电路（ＶＬＳＩ）技术的发展，使存贮器的容量不断扩大，价格大幅度下降。
但从应用角度看，存贮器的容量和成本总会受到一定的限制。
所以，提高存贮器的使用效率始终是操作系统研究的重要课题之一，虚拟存贮器技术是用来扩大主存容量的一种重要的方法。
本实习要求学生独立地用高级语言编写几个常用的存贮器分配算法，并能设计一个存贮管理的模拟程序，能对各种算法进行分析比较，评测其性能优劣，从而加深对这些算法的了解。
（二）要求为了比较真实地模拟存贮器管理，可预先生成一个大致符合实际情况的指令地址流。
然后，通过模拟这样一种指令序列的执行来计算和分析比较各种算法的访问命中率。
二、示例１．题目本示例给出采用页式分配存贮器管理方案，并通过分析、计算不同页面淘汰算法情况下的访问命中率来比较各种算法的优劣，另外也考虑改变页面尺寸大小和实际存贮器容量对计算结果的影响，从而可为选择好的算法、合适的页面尺寸和存贮器实际容量提供依据。
本程序是按下述原则生成指令序列的：（１）５０％的指令是顺序执行的。
（２）２５％的指令是均匀分布在前地址部分。
（３）２５％的指令是均匀分布在后地址部分。
示例中选用最佳淘汰算法（OPT）和最近最少使用页面淘汰算法（ＬＲＵ）计算页面命中率。
公式为：页面失败次数命中率＝１－───────页地址流长度假定虚拟存贮容量为３２Ｋ，页面尺寸从１Ｋ到８Ｋ，实存容量从４页到３２页。
２.算法与框图（１）最佳淘汰算法（ＯＰＴ）。
这是一种理想的算法，可用来作为衡量其他算法优劣的依据，在实际系统中是难以实现的，因为它必须先知道指令的全部地址流。
由于本示例中已生成了全部地址流，故可计算最佳命中率。
该算法的准则是淘汰已满页表中以后不再访问或是最迟访问的页。
这就要求将页表中的页逐个与后继指令访问的所有页比较，如后继指令不再访问此页，则把此页淘汰，不然得找出后继指令中最迟访问的页面予以淘汰。
虚拟机磁盘管理实训报告
一、实训背景随着虚拟化技术的不断发展，虚拟机已成为企业信息化建设的重要工具。
磁盘管理作为虚拟机的重要组成部分，对保障虚拟机稳定运行和提升系统性能具有重要意义。
为了提高我们对虚拟机磁盘管理的实践能力，本次实训选取了VMwareWorkstation虚拟机平台，通过实际操作，掌握磁盘管理的相关知识。
二、实训目的1. 熟悉虚拟机磁盘的基本概念和分类；2. 掌握虚拟机磁盘的创建、扩展和删除方法；3. 学会调整虚拟机磁盘性能；4. 熟悉虚拟机磁盘故障排查和恢复方法。
三、实训内容1. 虚拟机磁盘基本概念虚拟机磁盘分为三种类型：固定大小磁盘、动态扩展磁盘和差异磁盘。
（1）固定大小磁盘：在创建虚拟机时指定磁盘大小，虚拟机启动后，磁盘大小不会改变。
（2）动态扩展磁盘：在创建虚拟机时指定初始磁盘大小，虚拟机启动后，可以根据需要动态扩展磁盘大小。
（3）差异磁盘：基于基础磁盘创建，仅存储与基础磁盘不同的数据，可以节省磁盘空间。
2. 虚拟机磁盘创建以VMware Workstation为例，创建虚拟机磁盘的步骤如下：（1）在虚拟机管理器中，选择“文件”→“新建”→“虚拟机”选项。
（2）根据向导提示，填写虚拟机名称、操作系统等信息。
（3）选择虚拟机硬件配置，包括CPU、内存、网络等。
（4）选择磁盘类型，如固定大小磁盘、动态扩展磁盘或差异磁盘。
（5）设置磁盘大小，根据需要选择合适的磁盘类型。
（6）完成虚拟机创建，磁盘将自动创建。
3. 虚拟机磁盘扩展以VMware Workstation为例，扩展虚拟机磁盘的步骤如下：（1）在虚拟机管理器中，右键点击要扩展的虚拟机，选择“设置”。
（2）在“硬件”选项卡中，选择“磁盘”。
（3）右键点击要扩展的磁盘，选择“扩展”。
（4）根据向导提示，设置扩展后的磁盘大小。
（5）完成扩展后，虚拟机磁盘空间将增加。
4. 虚拟机磁盘删除以VMware Workstation为例，删除虚拟机磁盘的步骤如下：（1）在虚拟机管理器中，右键点击要删除的虚拟机，选择“设置”。
操作系统管理-虚拟存储器-实验报告-代码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、初始化实验环境设定物理内存大小、页面大小等参数。
虚拟存储管理实验报告
计算机科学与技术学院操作系统实验报告实验名称：虚拟存储管理度指导老师：刘国清姓名：曾莲花学号： 0143专业班级：网工10101班实验时间： 2012-12-04实验六虚拟存储管理一．实验目的存储管理的主要功能之一是合理地分配空间。
请求页式管理是一种常用的虚拟存储管理技术。
本实验的目的是通过请求页式管理中页面置换算法模拟设计，了解虚拟存储技术的特点，掌握请求页式存储管理的页面置换算法。
二． 实验内容通过计算不同算法的命中率比较算法的优劣。
同时也考虑了用户内存容量对命中率的影响。
页面失效次数为每次访问相应指令时，该指令所对应的页不在内存中的次数。
计算并输出下属算法在不同内存容量下的命中率。
先进先出的算法（FIFO ）；最近最少使用算法（LRU ）；三． 系统框图四 操作说明运行程序前先新建一个页面流文件文件（例如），在文件中存储的是一系列页号（页号用整数表示，用空格作为分隔符），用来模拟程序执行时的页访问次序。
试验中新建文件 文件五 结果分析 页地址流长度页面失效次数命中率-=1记录并分析实验结果(分析内存页面的具体调度情况并计算命中率)。
1. 对于如下的页面访问序列； 1，2，3，4，1，2，5，1，2，3，4，5命中率 = 1 – 9/19 = 10/19当内存页面数分别为2、3、4、5时，使用FIFO和LRU置换算法模拟页面调度，命中率 = 12.思考以下问题，并使用实验数据来回答：什么是Belay现象本次实验中是否出现了Belay现象LRU算法会存在Belay 现象吗FIFO算法必然会出现Belay现象吗解 :采用FIFO算法时,如果对一个进程未分配它所要求的全部页面,有时就会出现分配的页面数增多,缺页率反而提高的异常现象.是的出现了Bealy现象，LRU算法会存在不一定存在Belay现象LRU算法的性能在哪些情况下优于FIFO哪些情况下次于FIFO各自的原因何在LRU算法的缺点在于实现方法的不足，效率高的硬件算法通常在大多数机器上无法运行，而软件算法明显有太多的开销3.选择一个页面调度算法，详细地描述其程序的实现过程。
操作系统原理实验-虚拟存储器.
佛山科学技术学院实验报告课程名称操作系统原理实验实验项目虚拟存储器专业班级姓名学号指导教师成绩日期一、实验目的1、了解虚拟存储器的基本原理和实现方法。
2、掌握几种页面置换算法。
二、实验内容设计模拟实现采用不同内外存调度算法进行页面置换，并计算缺页率。
三、实验原理内存在计算机中的作用很大，电脑中所有运行的程序都需要经过内存来执行，如果执行的程序很大或很多，就会导致内存消耗殆尽。
为了解决这个问题，Window中运用了虚拟内存技术，即拿出一部分硬盘空间来充当内存使用，当内存占用完时，电脑就会自动调用硬盘来充当内存，以缓解内存的紧张。
虚拟存储器是指具有请求调入功能和置换功能，能从逻辑上对内存容量加以扩充的一种存储器系统。
它是采用一定的方法将一定的外存容量模拟成内存，同时对程序进出内存的方式进行管理，从而得到一个比实际内存容量大得多的内存空间，使得程序的运行不受内存大小的限制。
虚拟存储区的容量与物理主存大小无关，而受限于计算机的地址结构和可用磁盘容量。
虚拟内存的设置主要有两点，即内存大小和分页位置，内存大小就是设置虚拟内存最小为多少和最大为多少；而分页位置则是设置虚拟内存应使用那个分区中的硬盘空间。
（一）页式虚拟存储器在页式虚拟存储系统中，将程序按统一的大小划分成多个页，同时也将虚拟存储器划分为同样大小的页，其中虚拟空间的页称为虚页（逻辑页），而主存空间的页称为实页（物理页），并对这些页按地址从低到高的顺序编号。
在编程时，程序的虚地址由高位字段的虚页号和低位字段的页内地址两部分组成，虚页号标识页。
虚地址到实地址之间的变换是由页表来实现的。
页表是一张存放在主存中的虚页号和实页号的对照表，记录着程序的虚页调入主存时被安排在主存中的位置。
若计算机采用多道程序工作方式，则可为每个用户作业建立一个页表，硬件中设置一个页表基址寄存器，存放当前所运行程序的页表的起始地址。
页表中的每一行记录了与某个虚页对应的若干信息，包括虚页号、装入位和实页号等。
实验四--操作系统存储管理实验报告
实验四 操作系统存储管理实验报告一、实验目的存储管理的主要功能之一是合理地分配空间。
请求页式管理是一种常用的虚拟存储管理技术。
本实验的目的是通过请求页式管理中页面置换算法模拟设计，了解虚拟存储技术的特点，掌握请求页式存储管理的页面置换算法。
二、实验内容（1） 通过计算不同算法的命中率比较算法的优劣。
同时也考虑了用户内存容量对命中率的影响。
页面失效次数为每次访问相应指令时，该指令所对应的页不在内存中的次数。
在本实验中，假定页面大小为1k ，用户虚存容量为32k ，用户内存容量为4页到32页。
（2） produce_addstream 通过随机数产生一个指令序列，共320条指令。
A 、 指令的地址按下述原则生成：1） 50%的指令是顺序执行的2）25%的指令是均匀分布在前地址部分3） 25%的指令是均匀分布在后地址部分B 、 具体的实施方法是：1）在[0，319]的指令地址之间随机选取一起点m ； 2） 顺序执行一条指令，即执行地址为m+1的指令；3） 在前地址[0，m+1]中随机选取一条指令并执行，该指令的地址为m ’； 4）顺序执行一条指令，地址为m ’+1的指令 5）在后地址[m ’+2，319]中随机选取一条指令并执行； 6） 重复上述步骤1）~5），直到执行320次指令C 、 将指令序列变换称为页地址流在用户虚存中，按每k 存放10条指令排列虚存地址，即320条指令在虚存中页地址流长度页面失效次数命中率-=1的存放方式为：第0条~第9条指令为第0页（对应虚存地址为[0，9]）；第10条~第19条指令为第1页（对应虚存地址为[10，19]）；。
第310条~第319条指令为第31页（对应虚存地址为[310，319]）；按以上方式，用户指令可组成32页。
（3）计算并输出下属算法在不同内存容量下的命中率。
1）先进先出的算法（FIFO）；2）最近最少使用算法（LRU）；3）最佳淘汰算法（OPT）；4）最少访问页面算法（LFR）；其中3）和4）为选择内容三、系统框图五运行结果首先打印出产生的指令信息，第一列为指令序列号，第二列为指令地址，第三列为指令所在的虚页号选择FIFO调度算法，并且内存从3也开始逐渐增加到32页，打印出缺页次数缺页率，命中率选择LRU调度算法，并且内存从3也开始逐渐增加到32页，打印出缺页次数缺页率，命中率选择OPT调度算法，并且内存从3也开始逐渐增加到32页，打印出缺页次数缺页率，命中率六实验程序产生指令流文件produce_addstream.h #ifndef PRODUCE_ADDSTREAM_H #define PRODUCE_ADDSTREAM_H #include<stdio.h>#include<stdlib.h>#include<time.h>#include<iomanip.h>#include<vector>using namespace std;#define random(x) (rand()%x)#define MAX_LENGTH 320struct produce{int num; //指令序号int zhiling; //指令地址int virtualpage; //指令虚页号produce *next;};struct produce*creatlist();void insert(struct produce *first,struct produce *s); //插入一个节点（尾插法）void print(struct produce *first); //打印函数int max(vector<vector<int> >,int );struct produce*creatlist(){srand((int)time(0));struct produce*first=new produce;first->next=NULL;int m=0,m1=0;/*int yanzheng[20]={7,0,1,2,0,3,0,4,2,3,0,3,2,1,2,0,1,7,0,1};for (int i=0;i<(MAX_LENGTH/4);i++){struct produce *s0;s0=new produce;s0->num=i*4+0;s0->zhiling=yanzheng[i*4+0];s0->virtualpage=s0->zhiling;insert(first,s0);struct produce *s1;s1=new produce;s1->num=i*4+1;s1->zhiling=yanzheng[i*4+1];s1->virtualpage=s1->zhiling;insert(first,s1);struct produce *s2;s2=new produce;s2->num=i*4+2;s2->zhiling=yanzheng[i*4+2];s2->virtualpage=s2->zhiling;insert(first,s2);struct produce *s3;s3=new produce;s3->num=i*4+3;s3->zhiling=yanzheng[i*4+3];s3->virtualpage=s3->zhiling;insert(first,s3);}//*///*for (int i=0;i<(MAX_LENGTH/4);i++){struct produce *s0;s0=new produce;m=random(MAX_LENGTH);s0->num=i*4+0;s0->zhiling=m+1;s0->virtualpage=s0->zhiling/10;insert(first,s0);m1=random(m+1);struct produce *s1;s1=new produce;s1->num=i*4+1;s1->zhiling=m1;s1->virtualpage=s1->zhiling/10;insert(first,s1);struct produce *s2;s2=new produce;s2->num=i*4+2;s2->zhiling=m1+1;s2->virtualpage=s2->zhiling/10;insert(first,s2);struct produce *s3;s3=new produce;s3->num=i*4+3;s3->zhiling=random(MAX_LENGTH-m1-2)+m1+2;s3->virtualpage=s3->zhiling/10;insert(first,s3);}//*/return first;}void insert(struct produce *first,struct produce *s){struct produce *r=first;struct produce *p;while(r){p=r;r=r->next;}p->next=s;p=s;p->next=NULL;}void print(struct produce *first) //打印函数{struct produce *p;p =first->next;cout<<"随机产生的指令的信息如下"<<endl;cout<<"指令序号"<<"指令地址"<<"指令虚页号"<<endl;while (p){cout<<p->num<<'\t'<<p->zhiling<<setw(14)<<p->virtualpage<<endl;p=p->next;}}int max(vector<vector<int> > page,int Maxpage){int a=0,position=0;for (int i=0;i<Maxpage;i++){if (page[i][1]>a){a=page[i][1];position=i;}}return position;}#endif先来先出调度算法：fifo.h#ifndef FIFO_H#define FIFO_Hvoid fifo(struct produce *first,int Maxpage){vector<int> page(Maxpage);//for (int i=0;i<Maxpage;i++)page[i]=-1;int rear=0;//定义一个变量，指向要被替换的位置int pages;//定义变量保存当前指令的所在的地址int count1=0;//int count2=0;//缺页次数int find=1;struct produce *p=first->next;while (p){pages=p->virtualpage;for(int i=0;i<Maxpage;i++){if (page[i]==-1||count1<Maxpage){page[i]=pages;count1 ++;count2 ++;find =1;break;}else if (page[i]==pages){find =1;break;}find=0;}if (find==0){page[rear]=pages;rear ++;rear=rear%Maxpage;count2 ++;}p=p->next;}cout<<"FIFO调度算法缺页次数缺页率命中率"<<endl;cout<<count2<<setw(25)<<double(count2)/MAX_LENGTH<<setw(10)<<1-dou ble(count2)/MAX_LENGTH<<endl;}#endif FIFO_HLRU调度算法lru.h#ifndef LRU_H#define LRU_H#include<vector>using namespace std;//int max(vector<vector<int> >,int );void lru(struct produce*first,int Maxpage){struct produce*p=first->next;vector<vector<int> > page2(Maxpage, vector<int>(2));int count1=0; //定义内存已经被占用的页数int count2=0; //定义记录缺页次数int equal=0; //定义判断如果当前页数与比较的页数，如果相等则为1，否则为0int place=0; //定义要替换的位置for (int i=0;i<Maxpage;i++){page2[i][0]=-1;page2[i][1]=0;}while (p){if (count1<Maxpage){for (int i=0;i<Maxpage;i++){page2[i][1]=page2[i][1]+1;if (page2[i][0]==-1){page2[i][0]=p->virtualpage;count2++;break;}else if (page2[i][0]==p->virtualpage){page2[i][1] =1;}}count1++;}else{for (int i=0;i<Maxpage;i++){page2[i][1] +=1;if (page2[i][0]==p->virtualpage){equal=1;place=i;break;}}if (equal==1){page2[place][1] =1;equal=0;}else{place = max(page2,Maxpage);page2[place][1]=1;page2[place][0]=p->virtualpage;count2++;}}p=p->next;}cout<<"LRU调度算法缺页次数缺页率命中率"<<endl;cout<<count2<<setw(24)<<double(count2)/MAX_LENGTH<<setw(10)<<1-dou ble(count2)/MAX_LENGTH<<endl;}#endif LRU_HOPT调度算法opt.h#ifndef OPT_H#define OPT_H#include<vector>using namespace std;int search(struct produce*place,int position);void opt(struct produce*first,int Maxpage){struct produce*p =first->next;vector<vector<int> > page3(Maxpage, vector<int>(2));int count1=0; //定义内存已被使用的页数int count2=0; //定义缺页次数int current=0; //定义当前工作位置int equal=0; //定义判断如果当前页数与比较的页数，如果相等则为1，否则为0int place=0; //定义要替换的位置for (int i=0;i<Maxpage;i++){page3[i][0]=-1;page3[i][1]=0;}while (p){//cout<<1111<<endl;if (count1<Maxpage){for (int i=0;i<Maxpage;i++){if (page3[i][0]==-1){page3[i][0]=p->virtualpage;page3[i][1]=search(p,current);count2++;break;}else if (page3[i][0]==p->virtualpage){page3[i][1]=search(p,current);}}count1++;}else{for (int i=0;i<Maxpage;i++){if (page3[i][0]==p->virtualpage){equal=1;place=i;break;}}if (equal==1){page3[place][1] =search(p,current);equal=0;}else{place = max(page3,Maxpage);page3[place][1]=search(p,current);page3[place][0]=p->virtualpage;count2 +=1;}}p=p->next;current +=1;}cout<<"OPT调度算法缺页次数缺页率命中率"<<endl;cout<<count2<<setw(25)<<double(count2)/MAX_LENGTH<<setw(10)<<1-dou ble(count2)/MAX_LENGTH<<endl;}int search(struct produce*place,int position){struct produce*p=place->next;int current=place->virtualpage;int position1=position+1;while(p){if (current==p->virtualpage){return position1;}position1++;p=p->next;}return position1;}#endif主函数控制台ccglmain.cpp#include<iostream.h>#include "produce_addstream.h"#include "fifo.h"#include "lru.h"#include "opt.h"void main(){int S; //定义变量记录用户选择char again; //定义变量用户选择继续还是退出cout<<"开始产生内存指令"<<endl;struct produce *first=creatlist();//产生随机指令cout<<"打印产生的指令信息"<<endl;print(first);//打印产生的指令信息while (1){int Maxpage=3;//定义内存最大页面数cout<<"输入你的选择"<<endl;cout<<"1:FIFO(先进先出)调度算法\n"<<"2:LRU(最近最少使用算法)\n"<<"3:OPT(最佳淘汰算法)\n"<<"4:清屏"<<endl;cin>>S;while(S>4||S<1){cout<<"输入错误重新输入"<<endl;cin>>S;}if (S!=4){while(Maxpage<=32){switch(S){case 1:fifo(first,Maxpage);break;case 2:lru(first,Maxpage);break;case 3:opt(first,Maxpage);break;default:break;}Maxpage++;}cout<<"是否继续调用其他算法？是请按y/Y,否请按其它键"<<endl;cin>>again;if(again=='y'||again=='Y'){continue;}else break;}else system("cls");}}。
虚拟存储管理实验报告
虚拟存储管理实验报告一、单项选择题（共5题，每题10分，共50分）1、虚拟存储器的最大容量____。
A.为内外存容量之和B.由计算机的地址结构决定C.是任意的D.由作业的地址空间决定2、某虚拟存储器系统采用页式内存管理，使用LRU页面替换算法，考虑下面的页面访问地址流：1、8、1、7、8、2、7、2、1、8、3、8、2、1、3、1、7、1、3、7假定内存容量为4个页面，开始时是空的，则页面失效次数是____。
A. 4B.5C.6D.73、实现虚拟存储器的目的是____。
A. 实现存储保护B.实现程序浮动C. 扩充辅存容量D.扩充内存容量4、分页式虚拟存储系统中，页面的大小与可能产生的缺页中断次数____。
A.成正比B.成反比C.无关D.成固定比例5、页式虚拟存储管理的主要特点是____。
A.不要求将作业装入到内存的连续区域B.不要求将作业同时全部装入到内存的连续区域C.不要求进行缺页中断处理D.不要求进行页面置换二、填空题（共4题，每题5分，共20分）1、在页式存储管理系统中，常用的页面淘汰算法有：____，选择淘汰不再使用或最远的将来才使用的页；____，选择淘汰在内存驻留时间最长的页；____选择淘汰离当前时刻最近的一段时间内使用的最少的页。
2、设有8页的逻辑空间，没页有1024字节，它们被映射到32快的物理存储区中。
那么，逻辑地址的有效位是____位，物理地址至少是____位。
3、某作业在执行过程中，按下列顺序访问页号：1、2、3、4、5、6、7、4、2、1、3、6、7、4。
作业分得内存4块，若采用先进先出调度算法时，淘汰顺序为____；采用最近最久未使用算法时，淘汰页号顺序为____。
4、段页式存储管理中，是将作业分____，____内分____。
分配以____为单位。
在不考虑使用联想存储快表情况下，每条访问内存的指令需要____次访问内存。
其中第____次是查作业的页表。
三、简答题（共2题，每题15分，共30分）1、在分页系统中地址结构长度为16位，页面大小为2K，作业地址空间为6K，该作业的各页依次存放在2、3、6号物理块中，相对地址2500处有一条指令store 1,4500，请给出该作业的页表，该指令的物理单元和数据存放的物理单元。
虚拟存储器管理
虚拟存储器管理------模拟内存分配与回收代码加注释#include "stdio.h"#include "iostream.h"#include "stdlib.h"#define n 10 //假定系统允许的最大作业为，假定模拟实验中n值为10 #define m 10 //假定系统允许的空闲区表最大为m，假定模拟实验中m 值为10#define minisize 100typedef struct{float address; //已分分区起始地址float length; //已分分区长度，单位为字节int flag; //已分配区表登记栏标志，用"0"表示空栏目,实验中只支持一个字符的作业名} used_table[n];//已分配区表typedef struct{float address; //空闲区起始地址float length; //空闲区长度，单位为字节int flag; //空闲区表登记栏标志，用"0"表示空栏目，用"1"表示未分配}free_table[m]; //空闲区表//采用最优分配算法分配xk大小的空间allocate(char J,float xk){int i,k;float ad;k=-1;for(i=0;i<m;i++) //寻找空间大于xk的最小空闲区登记项kif(free_table[i].length>=xk&&free_table[i].flag==1)if(k==-1||free_table[i].length<free_table[k].length)k=i;if(k==-1)//未找到可用空闲区，返回{printf(" 无可用空闲区\n");return;}//找到可用空闲区，开始分配：若空闲区大小与要求分配的空间差小于msize大小，则空闲区全部分配；若空闲区大小与要求分配的空间差大于minisize大小，则从空闲区划出一部分分配if(free_table[k].length-xk<=minisize){free_table[k].flag=0; //该空闲区被分配ad=free_table[k].address;xk=free_table[k].length;}else{free_table[k].length=free_table[k].length-xk;ad=free_table[k].address+free_table[k].length;}//修改已分配区表i=0;//寻找空表目while(used_table[i].flag!=0&&i<n) i++;//无表目填写已分分区if(i>=n){printf(" 无表目填写已分区，错误\n"); //修正空闲区表if(free_table[k].flag==0)free_table[k].flag=1;//前面找到的是某个空闲分区的一部分else{free_table[k].length=free_table[k].length+xk; return;}}//修改已分配表else{used_table[i].address=ad;used_table[i].length=xk;used_table[i].flag=J;}return;}//回收作业名为J的作业所占主存空间reclaim(char J){int i,k,j,s,t;float S,L;//寻找已分配表中对应登记项s=0;while((used_table[s].flag!=J||used_table[s].flag==0)&&s<n) s++;//在已分配表中找不到名字为J的作业if(s>=n){{printf("找不到作业\n");}//修改已分配表used_table[s].flag=0;//取得归还分区的起始地址S和长度LS=used_table[s].address;L=used_table[s].length;j=-1;k=-1;//寻找回收分区的空闲上下邻，上邻表目k，下邻表目ji=0;while(i<m&&(j==-1||k==-1)){if(free_table[i].flag==1){if(free_table[i].address+free_table[i].length==S) k=i;//找到上邻if(free_table[i].address==S+L) j=i;//找到下邻}i++;}if(k!=-1)if(j!=-1) //上邻空闲区，下邻空闲区，三项合并free_table[k].length=free_table[j].length+free_table[k].length+L;free_table[j].flag=0;}else //上邻空闲区，下邻非空闲区，与上邻合并free_table[k].length=free_table[k].length+L;elseif(j!=-1) //上邻非空闲区，下邻为空闲区，与下邻合并{free_table[j].address=S;free_table[j].length=free_table[j].length+L;}else //上下邻均为非空闲区，回收区域直接填入{ //在空闲区表中寻找空栏目t=0;while(free_table[t].flag==1&&t<m)t++;if(t>=m)//空闲区表满,回收空间失败,将已分配表复原{out<<"主存空闲表没有空间,回收空间失败"<<endl;used_table[s].flag=J;return;free_table[t].address=S;free_table[t].length=L;free_table[t].flag=1;}return;}//主函数void main( ){int i,a;float xk;char s;ifstream in("input.txt");//空闲分区表初始化free_table[0].address=10240; free_table[0].length=102400; free_table[0].flag=1;for(i=1;i<m;i++)free_table[i].flag=0;//已分配表初始化for(i=0;i<n;i++)used_table[i].flag=0;while(1){printf(" 选择功能象（0-退出，1-分配主存，2-回收主存，3-显示主存）\n");printf(" 选择功能象（0~3）：\n");scanf("%d",&a);switch(a){case 0:exit(0);case 1:printf(" 输入作业名J和作业名所需长度xk \n");scanf("%c%c%f",&J,&xk);allocate(J,xk);break;case 2:printf(" 输入要回收分区的作业名");scanf("%c%c",&J);reclaim(J);break;case 3:printf(" 输出空闲区表：\n起使地址分区长度标志");for(i=0;i<m;i++)printf("%6.0f%9.0f%6d\n",free_table[i].address,free_table[i].length,free_ table[i].flag);printf(" 按任意键，输出已分配区表\n");getchar();printf(" 输出已分配表：\n起使地址分区长度标志\n");for(i=0;i<n;i++)if(used_table[i].flag!=0)printf("%6.0f%9.0f%6c\n",used_table[i].address,used_table[i].length,use d_table[i].flag);elseprintf("%6.0f%9.0f%6d\n",used_table[i].address,used_table[i].length,use d_table[i].flag);break;default:defult:printf("没有该选项\n"); }。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验四虚拟存储器管理一、实验目的1、为了更好的配合《操作系统》有关虚拟存储器管理章节的教学。
2、加深和巩固学生对于请求页式存储管理的了解和掌握。
3、提高学生的上机和编程过程中处理具体问题的能力。
二、实验内容请求页式存储管理是一种常用的虚拟存储管理技术。
本实验的目的是通过请求页式存储管理中页面置换算法模拟设计，了解虚拟存储技术的特点，掌握请求页式存储管理的页面置换算法。
1．通过随机数产生一个指令序列，共320条指令。
指令的地址按下述原则生成：a.50%的指令是顺序执行的。
b.25%的指令是均匀分布在前地址部分。
c.25%的指令是均匀分布在后地址部分。
具体的实施方法是：a.在[0,319]指令地址之间随机选取一起点；b.顺序执行一条指令，即执行地址为m+1的指令；c.在前地址[0，m+1]中随机选取一条指令并执行，该指令的地址为m’；d.顺序执行一条指令，其地址为m’；e.在后地址[m’+2，319]中随机选取一条指令并执行；f.重复上述步骤a~e，直到执行320次指令。
2．将指令序列变换成为页地址流设：a.页面大小为1K；b.用户内存容量为4到32页；c.用户虚存容量为32K。
在用户虚存中，按每K存放10条指令排列虚存地址，即320条指令在虚存中的存放方式为：第0条~第9条指令为第0页，对应虚存地址为[0，9]；第10条~第19条指令为第1页，对应虚存地址为[10，19]..第310条~第319条指令为第31页，对应虚存地址为[310，319]。
按以上方式，用户指令可组成32页。
3、输出下述各种算法在不同内存容量下的命中率。
a.先进先出的算法；b.最近最少访问算法；c.最近最不经常使用算法。
其中：命中率=1-页面失效次数/页地址流长度页地址流长度为320，页面失效次数为每次访问相同指令时，该指令所对应的页不在内存的次数。
三、实验要求实验课时4学时。
要求画出利用各种算法置换时的置换图，并可以分析说明。
编程可分为几个部分完成：指令的分页，算法的选择，算法的实现，命中率的输出。
编写程序前可先阅读Linux源代码页面换入：static int do_swap_page(struct mm_struct * mm,struct vm_area_struct * vma,unsigned long address,pte_t * page_table,swp_entry_t entry,int write_access){struct page *page = lookup_swap_cache(entry);pte-t pte;if (!pgae){lock_kernel( );swapin_readahead(entry);page = read_swap_cache(entry);unlock_kernel( );if (!page)return -1;flush_page_to_ram(page);flush_icache_page(vma,page);}mm->rss++;pte = mk_pte(page,vma->vm_page_prot);/**Freeze the "shared" ness of the page,ie page_count + swap_count.*Must lock page before transferring our swap count to already*obtained apge count.*/lock_page(page);swap_free(entry);if (write_access && !is_page_shared(page))pte = pte_mkwrite(pte_mkdirty(pte));UnlockPage(page);set_pte(page_table,pte);/*No need to invalidate - it was non-present before */update_mmu_cache(vma,address,pte);return 1; /*Minor fault */}四、源程序指导#include <stdlib.h>#include <stdio.h>#include <math.h>int i,M,j,k,s,h,t;char r;float int_count,page_count,v;float vc[29];int l,m,n,o,p;int address[320];int page[32][10],pageNo[32],page_Index[200],page_IndexNo[200],page_change[200];pagechange(){for(i=0;i<32;i++){for(j=0;j<10;j++)page[i][j]=10*i+j;pageNo[i]=i;}}Ram_Make(){int x,y;Loop1:l=random(319);if(l>1)m=l+1;elsegoto Loop1;Loop2:x=random(319);if(x<l-1){n=x;o=n+1;}elsegoto Loop2;Loop3:y=random(319);if(y>o)p=y;elsegoto Loop3;}fifo(){for(s=4;s<=32;s++){page_change[0]=page_IndexNo[0];int_count=1;page_count=1;for(h=1;h<5*M;h++){if(page_IndexNo[h]!=page_IndexNo[h-1])page_count+=1;for(t=0;t<s;t++){if(page_IndexNo[h]==page_change[t])goto Loop8;else if(page_IndexNo[h]!=page_change[t] && page_change[t]==999){page_change[t]=page_IndexNo[h];int_count++;goto Loop8;}}for(k=0;k<s;k++)page_change[k]=page_change[k+1];page_change[s-1]=page_IndexNo[h];int_count+=1;Loop8:;}v=int_count/page_count;vc[s-4]=1-v;printf("Vc for page %d: vc[%d]=%.3f $$$ ",s,s-4,vc[s-4]); for(i=0;i<200;i++)page_change[i]=999;}}lru(){int q,temp;for(s=4;s<=32;s++){page_change[0]=page_IndexNo[0];page_count=1;int_count=1;for(h=1;h<5*M;h++){if(page_IndexNo[h]!=page_IndexNo[h-1])page_count+=1;for(t=0;t<s;t++){if(page_IndexNo[h]!=page_change[t] && page_change[t]==999) {page_change[t]=page_IndexNo[h];int_count++;goto Loop9;}else if(page_IndexNo[h]==page_change[t]){for(q=t;q<s;q++){if(page_change[q+1]!=999){temp=page_change[q];page_change[q]=page_change[q+1];page_change[q+1]=temp;}}goto Loop9;}}for(k=0;k<s;k++)page_change[k]=page_change[k+1];page_change[s-1]=page_IndexNo[h];int_count+=1;Loop9:;}v=int_count/page_count;vc[s-4]=1-v;printf("The vc for the page %d: vc[%d]=%.3f $$$ ",s,s-4,vc[s-4]); for(i=0;i<200;i++)page_change[i]=999;}}opt(){int i,count[32],max,j;for(j=0;j<32;j++)count[j]=0;for(s=4;s<=32;s++){page_change[0]=page_IndexNo[0];page_count=1;int_count=1;for(h=1;h<5*M;h++){if(page_IndexNo[h]!=page_IndexNo[h-1])page_count+=1;for(t=0;t<s;t++){if(page_IndexNo[h]==page_change[t])goto Loop10;else if(page_IndexNo[h]!=page_change[t] && page_change[t]==999) {page_change[t]=page_IndexNo[h];int_count++;goto Loop10;}}for(t=0;t<s;t++){for(i=h;i<5*M;i++){if(page_change[t]==page_IndexNo[i]){count[t]=i;goto Loop11;}}page_change[t]=page_IndexNo[h];int_count+=1;goto Loop10;Loop11:;}max=0;for(t=0;t<s;t++){if(count[t]>max)max=count[t];}for(t=0;t<s;t++){if(count[t]==max){page_change[t]=page_IndexNo[h];int_count+=1;}}Loop10:;}v=int_count/page_count;vc[s-4]=1-v;printf("The vc for page %d: vc[%d]=%.3f $$$ ",s,s-4,vc[s-4]); for(i=0;i<200;i++)page_change[i]=999;}}main(){char c;Loop4:clrscr();for(i=0;i<320;i++)address[i]=rand();for(i=0;i<200;i++)page_change[i]=999;printf("Put The Value Of The M: ");scanf("%d",&M);pagechange();for(j=0;j<M;j++){Ram_Make();page_Index[5*j+0]=l;page_IndexNo[5*j+0]=l/10;page_Index[5*j+1]=m;page_IndexNo[5*j+1]=m/10;page_Index[5*j+2]=n;page_IndexNo[5*j+2]=n/10;page_Index[5*j+3]=o;page_IndexNo[5*j+3]=o/10;page_Index[5*j+4]=p;page_IndexNo[5*j+4]=p/10;}for(k=0;k<5*M;k++)printf("page_Index[%d]=%d,page_IndexNo[%d]=%d\n",k,page_Index[k],k,page_IndexNo [k]);printf("\n");Loop5:printf("select the method for page_exchange:\n");printf("1.)FIFO\n2.)LRU\n3.)OPT\n");printf("Put The select of The method: ");scanf("%s",&r);switch(r){ case '1':fifo();break;case '2':lru();break;case '3':opt();break;default:printf("\n");printf("Put the value between 1 to 3 !!!!!!\n");goto Loop5;}Loop6:printf("\n");printf("Do You Want to do again[y/n]:");scanf("%s",&c);if(c=='y')goto Loop4;else if(c=='n')exit;else{printf("Select for 'y' and 'n'!!!!\n");goto Loop6;}}。