实验四 操作系统存储管理实验报告

合集下载

操作系统存储管理实验报告.doc

操作系统存储管理实验报告.doc

操作系统存储管理实验报告实验5存储管理第一,实验的目的1,加深对操作系统存储管理的理解2,可以过度模拟页面调试算法,加深对操作系统内存管理的理解二、一般设计思想、环境语言、工具等一般设计思想:1.编写一个函数来计算和输出以下算法的命中率:(1) OPT页面替换算法OPT选定的过时页面是已经转移到内存中并且将来不会被使用或者在最长时间内不会被访问的页面。

因此,如何找到这样的页面是算法的关键。

每页可以设置一个步长变量。

它的初始值是一个足够大的数字。

对于不在内存中的页面,其值将重置为零。

对于内存中的页面,其值被重置为当前访问的页面与页面首次出现时的距离。

因此,该值越大,在最长时间内不会被访问的页面就越多,并且可以选择它作为交换页面。

(2)先进先出页面替换算法先进先出总是选择首先进入内存的页面进行清除,因此可以设置先进先出的繁忙页面帧队列,新转移到内存的页面挂在队列的尾部,当没有空闲页面帧时,可以从队列的头部取出下一个页面帧作为空闲页面帧,然后再转移到需要的页面。

(3) LRU页面替换算法LRU 根据转移到存储器中的页面的使用做出决定。

它使用“最近的过去”作为“最近的未来”的近似,并选择最长时间没有使用的页面进行删除。

该算法主要通过页面结构中的访问时间来实现。

时间记录页面的最后访问时间。

因此,当需要删除一个页面时,选择时间值最小的页面,即最近最长时间没有使用的页面进行删除。

(4) LFU页面替换算法LFU要求每个页面配置一个计数器(即页面结构中的计数器)。

一旦页面被访问,计数器的值将增加1。

当需要替换一个页面时,将选择计数器值最小的页面,即存储器中访问次数最少的页面进行清除。

⑤NUR页面替换算法NUR要求为每个页面设置一个访问位(访问位仍然可以由页面结构中的计数器表示)。

当页面被访问时,其访问位计数器被设置为1。

当需要页面替换时,替换算法从替换指针(最初指向第一页)开始顺序检查内存中的每一页。

如果其访问位为0,则选择页面进行替换,否则,替换指针向下移动以继续向下搜索。

操作系统存储器管理实验报告.doc

操作系统存储器管理实验报告.doc

一目的与要求(1) 请求页式虚存管理是常用的虚拟存储管理方案之一。

(2) 通过请求页式虚存管理中对页面置换算法的模拟,加深理解虚拟存储技术的特点。

(3) 模拟页式虚拟存储管理中硬件的地址转换和缺页中断,并用先进先出调度算法(FIFO)处理缺页中断.二实验内容或题目(1)本实验要求使用C语言编程模拟一个拥有若干个虚页的进程在给定的若干个实页中运行、并在缺页中断发生时分别使用FIFO和LRU算法进行页面置换的情形。

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

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

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

三实验步骤与源程序(1)实验步骤1、理解好相关实验说明。

2、根据实验说明,画出相应的程序流程图。

3、按照程序流程图,用C语言编程并实现。

(2)流程图如下:①虚页和实页结构在虚页结构中,pn代表虚页号,因为共10个虚页,所以pn的取值范围是0—9。

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

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

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

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

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

②程序流程图如下:(3)源程序如下:#include<iostream.h>#define M 40int N;struct Pro{int num,time;};int Input(int m,Pro p[M]){cout<<"请输入实际页数:";do{cin>>m;if(m>M)cout<<"数目太多,请重试"<<endl;else break;}while(1);//cout<<"请输入各页面号:";for(int i=0;i<m;i++){cout<<"第"<<i<<"个页面号为:";cin>>p[i].num;p[i].time=0;}return m;}void print(Pro *page1)//打印当前的页面{Pro *page=new Pro[N];page=page1;for(int i=0;i<N;i++)cout<<page[i].num<<" ";cout<<endl;}int Search(int e,Pro *page1 ){Pro *page=new Pro[N];page=page1;for(int i=0;i<N;i++)if(e==page[i].num)return i; return -1;}int Max(Pro *page1){Pro *page=new Pro[N];page=page1;int e=page[0].time,i=0;while(i<N)//找出离现在时间最长的页面{if(e<page[i].time)e=page[i].time;i++;}for( i=0;i<N;i++)if(e==page[i].time)return i;return -1;}int Compfu(Pro *page1,int i,int t,Pro p[M]){Pro *page=new Pro[N];page=page1;int count=0;for(int j=i;j<M;j++){if(page[t].num==p[j].num )break;else count++;}return count;}int main(){cout<<"可用内存页面数:";cin>>N;Pro p[M];Pro *page=new Pro[N];char c;int m=0,t=0;float n=0;m=Input(m,p);do{for(int i=0;i<N;i++)//初试化页面基本情况{page[i].num=0;page[i].time=2-i;}i=0;cout<<"************************"<<endl;cout<<"*****f:FIFO页面置换*****"<<endl;cout<<"*****l:LRU页面置换******"<<endl;cout<<"*****o:OPT页面置换******"<<endl;cout<<"*****按其它键结束*******"<<endl;cout<<"************************"<<endl;cout<<"请选择操作类型(f,l,o):";cin>>c;if(c=='f')//FIFO页面置换{n=0;cout<<"页面置换情况: "<<endl;while(i<m){if(Search(p[i].num,page)>=0)i++;//找到相同的页面else{if(t==N)t=0;else{n++;//page[t].num=p[i].num;print(page);t++;}}}cout<<"缺页次数:"<<n<<" 缺页率:"<<n/m<<endl; }if(c=='l')//LRU页面置换{ n=0;cout<<"页面置换情况: "<<endl;while(i<m){int k;k=t=Search(p[i].num,page);if(t>=0)page[t].time=0;else{n++;t=Max(page);page[t].num=p[i].num;page[t].time=0;}if(t==0){page[t+1].time++;page[t+2].time++;}if(t==1){page[2].time++;page[0].time++;}if(t==2){page[1].time++;page[0].time++;}if(k==-1) print(page); i++;}cout<<"缺页次数:"<<n<<" 缺页率:"<<n/m<<endl;}if(c=='o')//OPT页面置换{n=0;while(i<m){if(Search(p[i].num,page)>=0)i++;else{int temp=0,cn;for(t=0;t<N;t++){if(temp<Compfu(page,i,t,p)){temp=Compfu(page,i,t,p); cn=t;}}page[cn]=p[i];n++;print(page);i++;}}cout<<"缺页次数:"<<n<<" 缺页率:"<<n/m<<endl; }}while(c=='f'||c=='l'||c=='o');return 0;});四测试数据与实验结果五结果分析与实验体会通过上机,我了解了许多关于操作系统的专业知识。

操作系统实验四存储管理

操作系统实验四存储管理

师学院计算机系实验报告(2014—2015学年第二学期)课程名称操作系统实验名称实验四存储管理专业计算机科学与技术(非师)年级2012级学号B2012102147 姓名秋指导教师远帆实验日期2015-05-20图1 word运行情况“存使用”列显示了该应用程序的一个实例正在使用的存数量。

5) 启动应用程序的另一个实例并观察它的存需求。

请描述使用第二个实例占用的存与使用第一个实例时的存对比情况:第二个实例占用存22772K,比第一个实例占用的存大很多4:未分页合并存。

估算未分页合并存大小的最简单法是使用“任务管理器”。

未分页合并存的估计值显示在“任务管理器”的“性能”选项卡的“核心存”部分。

总数(K) :________220___________分页数:_____________________未分页(K) :_________34__________图2核心存C 简单基本NTFS 30G 良好(系统)D 简单基本NTFS 90G 良好E 简单基本NTFS 90G 良好F 简单基本NTFS 88G 良好图3磁盘情况6:计算分页文件的大小。

要想更改分页文件的位置或大小配置参数,可按以下步骤进行:1) 右键单击桌面上的“我的电脑”图标并选定“属性”。

2) 在“高级”选项卡上单击“性能选项”按钮。

3) 单击对话框中的“虚拟存”区域中的“更改”按钮。

请记录:所选驱动器的页面文件大小:驱动器:______________F_____________________可用空间:___________9825_____________________ MB初始大小(MB) :_____ 2048______________________最大值(MB) :________4092_____________________所有驱动器页面文件大小的总数:允的最小值:________16____________________ MB注:1、报告的项目或设置,可根据实际情况加以补充和调整2、教师批改学生实验报告应在学生提交实验报告10日。

操作系统:实验4 存储管理(实验报告)

操作系统:实验4 存储管理(实验报告)

欢迎共阅班级: 姓名: 学号:5) 当前计算机的实际内存大小为:______________________________________ 分析程序4-1,请回答问题:1) 理论上每个Windows 应用程序可以独占的最大存储空间是:_____________2) 程序中,用于检查系统中虚拟内存特性的API 函数是:__________________ 4.2 Windows 虚拟内存本节实验的目的是:实验4存储管理1) 通过实验了解Windows内存的使用,学习如何在应用程序中管理内存,体会Windows应用程序内存的简单性和自我防护能力。

2) 学习检查虚拟内存空间或对其进行操作;3) 了解Windows的内存结构和虚拟内存的管理,进而了解进程堆和Windows为使用内存而提供的一些扩展功能。

1. 工具/准备工作在开始本节实验之前,请回顾教材的相关内容。

需要准备一台运行Windows系统的计算机,且安装了C/C++编译器。

2. 实验内容与步骤将系统当前的保留区(reserved)虚拟地址空间填入表4.3中。

表4.3 实验记录2) 根据运行结果,请简单描述程序运行的流程:_________________________________________________________________________________________________________________________________________的程序段,该段程序试图通过VirtualAlloc()函数,然后利用物理备用内存将整个块分配到虚拟内存空间的任何位置。

这种技术只对拥有1GB以上的RAM且都有换页文件的计算机可行。

从运行结果看,这种技术成功了吗?_________________。

3) 程序中说明为___________________________________________________的程序段,该段程序利用VirtualAlloc()函数,如果函数成功,则获得大块内存,但不将任何物理内存调配到此块中。

操作系统存储管理实验报告

操作系统存储管理实验报告

操作系统存储管理实验报告一、实验目的本次实验的目的是通过编写一段程序,实现对内存的分配和回收操作,并验证算法的正确性和性能。

二、实验内容1.实现首次适应算法首次适应算法是一种动态分配的内存管理算法,通过从低地址往高地址内存块,找到第一个满足需求的空闲块进行分配。

具体实现过程如下:(1)初始化内存空间,设置内存块的大小和地址范围;(2)编写一个函数,实现内存的分配操作,根据需求大小找到第一个合适的空闲块,并在其前后设置相应的标志位;(3)编写一个函数,实现内存的回收操作,根据释放块的地址,将其前后的标志位进行合并;(4)模拟应用程序的运行,测试内存的分配和回收操作。

2.实现最佳适应算法最佳适应算法是一种动态分配的内存管理算法,通过整个内存空间,找到最小的满足需求的空闲块进行分配。

具体实现过程如下:(1)初始化内存空间,设置内存块的大小和地址范围;(2)编写一个函数,实现内存的分配操作,遍历整个内存空间,找到满足需求且大小最小的空闲块进行分配;(3)编写一个函数,实现内存的回收操作,根据释放块的地址,将其前后的标志位进行合并;(4)模拟应用程序的运行,测试内存的分配和回收操作。

三、实验结果1.首次适应算法经过测试,首次适应算法能够正确地进行内存的分配和回收操作,并且算法的性能良好。

尽管首次适应算法在分配过程中可能会产生碎片,但是由于它从低地址开始,可以在较短的时间内找到满足需求的空闲块。

在实际应用中,首次适应算法被广泛采用。

2.最佳适应算法经过测试,最佳适应算法能够正确地进行内存的分配和回收操作,并且算法的性能较好。

最佳适应算法会整个内存空间,找到大小最小的满足需求的空闲块。

因此,在分配过程中不会产生很多的碎片,但是算法的执行时间较长。

四、实验总结通过本次实验,我们成功地实现了首次适应算法和最佳适应算法,并对算法的正确性和性能进行了验证。

两种算法在内存的分配和回收过程中都表现出良好的性能,可广泛应用于实际场景中。

操作系统存储管理实验报告总结

操作系统存储管理实验报告总结

操作系统存储管理实验报告总结篇一:东华大学操作系统存储管理实验报告东华大学计算机学院操作系统实验报告实验名称:存储管理问题姓名:姜元杰学号:111310228班级:计算机1102 指导老师:李继云报告日期: XX/11/2一、实验概述1. 实验目标存储管理的主要功能之一是合理地分配空间。

请求页式管理是一种常用的虚拟存储管理技术。

本实验的目的是通过请求页式存储管理中页面置换算法模拟设计,了解虚拟存储技术的特点,掌握请求页式管理的页面置换算法。

2. 实验要求1) 通过随机数产生一个指令序列,共320条指令,指令的地址按下述原则生成:? 50%的指令是顺序执行的;? 25%的指令是均匀分布在前地址部分。

? 25%的指令是均匀分布在后地址部分。

2) 将指令序列变换成页地址流? 页面大小 = 10条指令? 4页? 用户虚存容量 = 32页;? 在用户虚存中,按每K存放10条指令排列虚存地址3) 计算并输出下述各种算法在不同内存容量下的命中率。

? 先进先出的算法(FIFO);? 最近最少使用算法(LRU);? 最佳淘汰算法(OPT);? 命中率=1-页面失效次数/页地址流长度;输出以表结构输出,行头是页码,列头是对应替换算法。

在本实验中,页地址流长度为320,页面失效次数为每次访问相应指令时,该指令所对应的页不在内存的次数。

二、实验内容1. 设计思路总体思路:设计存储管理类(class StorageManagemen),封装FIFO,LRU,OPT算法实现函数与各自所需公共或个体数据机构和公共代码部分,实现“TOP-DOWN”的程序设计思想,增强代码结构性和可读性。

1) 先进先出的算法(FIFO):FIFO是最简单的页置换算法,FIFO的页置换的算法为每个页记录着该页调入内存的时间。

当必须置换一页时,将选择最旧的页。

注意并不需要记录调入一页的确切时间,可以创建一个FIFO队列来管理内存中的所有页。

队列中的首页将被置换。

实验四 操作系统存储管理实验报告

实验四  操作系统存储管理实验报告

实验四操作系统存储管理实验报告一、实验目的本次操作系统存储管理实验的主要目的是深入理解操作系统中存储管理的基本原理和方法,通过实际操作和观察,掌握内存分配、回收、地址转换等关键技术,提高对操作系统存储管理机制的认识和应用能力。

二、实验环境操作系统:Windows 10开发工具:Visual Studio 2019三、实验原理1、内存分配方式连续分配:分为单一连续分配和分区式分配(固定分区和动态分区)。

离散分配:分页存储管理、分段存储管理、段页式存储管理。

2、内存回收算法首次适应算法:从内存低地址开始查找,找到第一个满足要求的空闲分区进行分配。

最佳适应算法:选择大小最接近作业需求的空闲分区进行分配。

最坏适应算法:选择最大的空闲分区进行分配。

3、地址转换逻辑地址到物理地址的转换:在分页存储管理中,通过页表实现;在分段存储管理中,通过段表实现。

四、实验内容及步骤1、连续内存分配实验设计一个简单的内存分配程序,模拟固定分区和动态分区两种分配方式。

输入作业的大小和请求分配的分区类型,程序输出分配的结果(成功或失败)以及分配后的内存状态。

2、内存回收实验在上述连续内存分配实验的基础上,添加内存回收功能。

输入要回收的作业号,程序执行回收操作,并输出回收后的内存状态。

3、离散内存分配实验实现分页存储管理的地址转换功能。

输入逻辑地址,程序计算并输出对应的物理地址。

4、存储管理算法比较实验分别使用首次适应算法、最佳适应算法和最坏适应算法进行内存分配和回收操作。

记录不同算法在不同作业序列下的内存利用率和分配时间,比较它们的性能。

五、实验结果与分析1、连续内存分配实验结果固定分区分配方式:在固定分区大小的情况下,对于作业大小小于或等于分区大小的请求能够成功分配,否则分配失败。

内存状态显示清晰,分区的使用和空闲情况一目了然。

动态分区分配方式:能够根据作业的大小动态地分配内存,但容易产生内存碎片。

2、内存回收实验结果成功回收指定作业占用的内存空间,内存状态得到及时更新,空闲分区得到合并,提高了内存的利用率。

操作系统-----存储管理实验报告

操作系统-----存储管理实验报告

操作系统实验报告一、实验题目:存储管理(该实验为综合性实验,共用8个学时)二、实验要求:1、通过随机数产生一个指令序列,共320条指令。

其地址按下述原则生成:①50%的指令是顺序执行的;②25%的指令是均匀分布在前地址部分;③25%的指令是均匀分布在后地址部分;具体的实施方法是:A.在[0,319]的指令地址之间随机选取一起点M;B.顺序执行一条指令,即执行地址为M+1的指令;C.在前地址[0,M+1]中随机选取一条指令并执行,该指令的地址为M’;D.顺序执行一条指令,其地址为M’+1;E.在后地址[M’+2,319]中随机选取一条指令并执行;F.重复A—E,直到执行320次指令。

2、指令序列变换成页地址流,设:①页面大小为1K;②用户内存容量为4页到32页;③用户虚存容量为32K。

在用户虚存中,按每页存放10条指令排列虚存地址,即320条指令在虚存中的存放方式为:第0条~第9条指令为第0页(对应虚存地址为[0,9]);第10条~第19条指令为第1页(对应虚存地址为[10,19]);…………第310条~第319条指令为第31页(对应虚存地址为[310,319]);3、计算并输出下述各种算法(可任选三个)在不同内存容量下的命中率。

A. FIFO先进先出置换算法;B. LRU最近最久未使用置换算法;C. OPT最佳置换算法。

D. NUR最近未使用置换算法。

E. LFU最少使用置换算法。

三、总的设计思想、环境语言、工具等总的设计思想:1、编写函数计算并输出下述各种算法的命中率①OPT页面置换算法OPT所选择被淘汰的页面是已调入内存,且在以后永不使用的,或是在最长时间内不再被访问的页面。

因此如何找出这样的页面是该算法的关键。

可为每个页面设置一个步长变量,其初值为一足够大的数,对于不在内存的页面,将其值重置为零,对于位于内存的页面,其值重置为当前访问页面与之后首次出现该页面时两者之间的距离,因此该值越大表示该页是在最长时间内不再被访问的页面,可以选择其作为换出页面。

操作系统存储管理实验报告

操作系统存储管理实验报告

操作系统存储管理实验报告一、实验目的操作系统的存储管理是计算机系统中非常重要的组成部分,它直接影响着系统的性能和资源利用率。

本次实验的目的在于深入理解操作系统中存储管理的基本原理和方法,通过实际操作和观察,掌握存储分配、回收、地址转换等关键技术,并对不同存储管理策略的性能进行分析和比较。

二、实验环境本次实验在 Windows 10 操作系统下进行,使用 Visual Studio 2019 作为编程环境,编程语言为 C++。

三、实验内容(一)固定分区存储管理1、原理固定分区存储管理将内存空间划分为若干个固定大小的分区,每个分区只能装入一道作业。

分区的大小可以相等,也可以不等。

2、实现创建一个固定大小的内存空间数组,模拟内存分区。

为每个分区设置状态标志(已分配或空闲),并实现作业的分配和回收算法。

3、实验结果与分析通过输入不同大小的作业请求,观察内存的分配和回收情况。

分析固定分区存储管理的优缺点,如内存利用率低、存在内部碎片等。

(二)可变分区存储管理1、原理可变分区存储管理根据作业的实际需求动态地划分内存空间,分区的大小和数量是可变的。

2、实现使用链表或数组来管理内存空间,记录每个分区的起始地址、大小和状态。

实现首次适应、最佳适应和最坏适应等分配算法,以及分区的合并和回收算法。

3、实验结果与分析比较不同分配算法的性能,如分配时间、内存利用率等。

观察内存碎片的产生和处理情况,分析可变分区存储管理的优缺点。

(三)页式存储管理1、原理页式存储管理将内存空间和作业都划分为固定大小的页,通过页表将逻辑地址转换为物理地址。

2、实现设计页表结构,实现逻辑地址到物理地址的转换算法。

模拟页面的调入和调出过程,处理缺页中断。

3、实验结果与分析测量页式存储管理的页面置换算法(如先进先出、最近最少使用等)的命中率,分析其对系统性能的影响。

探讨页大小的选择对存储管理的影响。

(四)段式存储管理1、原理段式存储管理将作业按照逻辑结构划分为若干个段,每个段有自己的名字和长度。

实验四操作系统存储管理实验报告

实验四操作系统存储管理实验报告

实验四操作系统存储管理实验报告一、实验目的本次实验的主要目的是深入理解操作系统中存储管理的基本原理和方法,通过实际操作和观察,掌握内存分配与回收、页面置换算法等关键概念,并能够分析和解决存储管理中可能出现的问题。

二、实验环境本次实验在装有 Windows 操作系统的计算机上进行,使用了 Visual Studio 等编程工具和相关的调试环境。

三、实验内容(一)内存分配与回收算法实现1、首次适应算法首次适应算法从内存的起始位置开始查找,找到第一个能够满足需求的空闲分区进行分配。

在实现过程中,我们通过建立一个空闲分区链表来管理内存空间,每次分配时从表头开始查找。

2、最佳适应算法最佳适应算法会选择能够满足需求且大小最小的空闲分区进行分配。

为了实现该算法,在空闲分区链表中,分区按照大小从小到大的顺序排列,这样在查找时能够快速找到最合适的分区。

3、最坏适应算法最坏适应算法则选择最大的空闲分区进行分配。

同样通过对空闲分区链表的排序和查找来实现。

(二)页面置换算法模拟1、先进先出(FIFO)页面置换算法FIFO 算法按照页面进入内存的先后顺序进行置换,即先进入内存的页面先被置换出去。

在模拟过程中,使用一个队列来记录页面的进入顺序。

2、最近最久未使用(LRU)页面置换算法LRU 算法根据页面最近被使用的时间来决定置换顺序,最近最久未使用的页面将被置换。

通过为每个页面设置一个时间戳来记录其最近使用的时间,从而实现置换策略。

3、时钟(Clock)页面置换算法Clock 算法使用一个环形链表来模拟内存中的页面,通过指针的移动和页面的访问标志来决定置换页面。

四、实验步骤(一)内存分配与回收算法的实现步骤1、初始化内存空间,创建空闲分区链表,并为每个分区设置起始地址、大小和状态等信息。

2、对于首次适应算法,从链表表头开始遍历,找到第一个大小满足需求的空闲分区,进行分配,并修改分区的状态和大小。

3、对于最佳适应算法,在遍历链表时,选择大小最接近需求的空闲分区进行分配,并对链表进行相应的调整。

计算机操作系统储存管理实验报告

计算机操作系统储存管理实验报告

计算机操作系统储存管理实验报告软件学院综合性、设计性实验报告⼀、实验⽬的通过请求页式存储管理中页⾯置换算法模拟程序,了解虚拟存储技术的特点,掌握请求页式存储管理的页⾯置换算法。

⼆、实验仪器或设备实验机房pc电脑三、总体设计(设计原理、设计⽅案及流程等)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)命中率=1-页⾯失效次数/页地址流长度本实验中,页地址流长度为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] ﹡﹡ rand( )/32767;a[j+3]=a[j+2]+1m=a[j+3]+(319-a[j+3]) ﹡﹡rand( )/32767;}(2) 将指令序列变换成为页地址流for ( k=0;k<320;k++){ pt=a[k]/10;pd= a[k]%10;…}(3) 计算不同算法的命中率rate=﹡U/320 ;其中U为缺页中断次数,320是页地址流长度。

《操作系统》存储管理实验报告

《操作系统》存储管理实验报告

《操作系统》存储管理实验报告操作系统是计算机系统中最基础、最核心的软件之一,负责管理计算机硬件资源和提供资源的分配与调度。

而存储管理是操作系统中的重要组成部分,它负责管理计算机的内存,包括内存的分配、回收、保护等操作。

本文将针对存储管理进行实验,并撰写实验报告。

本次实验主要涉及以下内容:内存的分配与回收、内存的保护。

实验过程中,我首先根据操作系统的要求,设计了相应的算法用于内存的分配与回收。

并通过编写程序,验证了算法的正确性。

随后,我进一步研究了内存的保护机制,通过设置访问权限位和访问控制表,实现了对内存的合理保护。

在内存的分配与回收方面,我设计了一种简单的算法,首次适应算法。

具体实现如下:首先,将内存分为若干个块,每个块的大小为固定值。

当需要分配内存时,首先遍历内存块列表,找到第一个大小合适的块,将其分配给进程。

当进程终止时,将其占用的内存块回收,以便后续进程使用。

通过编写程序进行测试,结果表明该算法能够正确地进行内存的分配与回收。

在内存的保护方面,我采用了访问权限位和访问控制表的方式进行。

具体实现如下:首先,为每个进程分配一组访问权限位,记录了该进程能够访问的内存区域。

同时,设置一个访问控制表,记录了每个内存块的权限。

当进程访问一些内存块时,首先检查该进程的访问权限位,再与访问控制表中的权限进行比较,以确定该进程是否有权限访问该内存块。

通过编写程序进行测试,证明了该机制能够有效地保护内存。

总结来说,本次实验主要涉及了操作系统中的存储管理部分,包括内存的分配与回收、内存的保护。

通过设计算法和编写程序,我成功地实现了这些功能,并验证了其正确性。

通过本次实验,我进一步加深了对操作系统存储管理的理解,提高了编程和设计的能力。

操作系统实验四存储管理

操作系统实验四存储管理

宁德师范学院计算机系
实验报告
(2014—2015学年第二学期)
课程名称操作系统
实验名称实验四存储管理
专业计算机科学与技术(非师)年级2012级
学号B2012102147 姓名王秋指导教师王远帆
实验日期2015-05-20
图1 word运行情况
“内存使用”列显示了该应用程序的一个实例正在使用的内存数量。

启动应用程序的另一个实例并观察它的内存需求。

请描述使用第二个实例占用的内存与使用第一个实例时的内存对比情况:第二个实例占用内存22772K,比第一个实例占用的内存大很多
2、教师批改学生实验报告应在学生提交实验报告10日内。

操作系统存储管理实验报告

操作系统存储管理实验报告

程使用内存的信息:(2) 利用cat /proc/meminfo命令可以查看RAM使用情况,而且这是最简单的方法:$ cat /proc/meminfo参数/proc/meminfo是个动态更新的虚拟文件,实际上它的内容是许多其他内存相关工具(如: free、 ps、 top) 等显示信息的组合。

/proc/meminfo列出了所有你想了解的内存的使用情况。

进程的内存使用信息也可以通过cat 命令显示/proc/<pid>/statm和/proc/<pid>/status文件的信息来查看。

根据_上述命令的输出,用户可以发现一些使用内存较大的进程。

为了缓解系统内存的紧张情况,可以使用kill命令终止一些进程,使系统释放一部分内存空间。

(二)、监视对换区使用情况在Linux系统上运行的程序只看到大量的可用内存,而不关心哪部分在磁盘上,哪部分是物理内存。

当然,硬盘的读写速度比物理内存要慢得多,大约慢千倍,所以如果程序运行中多次在物理内存和硬盘之间交换内存块,则导致程序运行较慢。

.vmstat命令是一个通用监控程序,是Virtual Meomory Statistics (虛拟内存统计)的缩写。

vmstat命令显示实时数据与平均值的统计,包括CPU、内存、I/O等内容。

例如内存情况,不仅显示物理内存,也统计虚拟内存。

--般vmstat工具的使用是通过两个数字参数来完成的,第一个参数是采样的时间间隔数,单位是秒,第二个参数是采样的次数。

下面是一个使用vmstat命令监视虚拟内存使用的例子。

vmstat命令报告主要的活动类型有进程(procs)、内存、交换分区、块设备I/O量、系统中断,以及CPU使用情况(包括分配给用户的时间、系统占用时间和空闲时间分别占用的比例)。

用户在编程时,如果需要为产生的数据申请内存空间,可以在程序中使用系统提供的相应函数,如: malloc (分配没有被初始化的内存块)、calloc (分配内存块并且初始化)、realloc(调整先前分配的内存块的大小)、free(释放先前由malloc等分配的内存)。

操作系统存储管理实验报告

操作系统存储管理实验报告

操作系统存储管理实验报告操作系统存储管理实验报告引言:操作系统是计算机系统中的核心软件之一,它负责管理计算机硬件资源和提供用户与计算机之间的接口。

在操作系统中,存储管理是一个重要的子系统,它负责管理计算机的内存资源。

本实验旨在通过实际操作,深入了解操作系统的存储管理机制,并通过实验结果分析其性能和效果。

实验目的:1. 了解操作系统的存储管理机制;2. 掌握存储管理相关的概念和技术;3. 分析不同存储管理策略的优缺点;4. 通过实验验证不同策略的性能和效果。

实验内容:本次实验主要涉及以下几个方面的内容:1. 内存分配:在操作系统中,内存是计算机中的重要资源,它被划分为多个固定大小的块,每个块称为一页。

实验中,我们将学习不同的内存分配算法,如连续分配、离散分配和分页分配,并通过实验验证它们的性能和效果。

2. 内存回收:当某个进程不再需要使用内存时,操作系统需要回收该内存空间,以便其他进程使用。

实验中,我们将学习不同的内存回收算法,如最佳适应算法、最坏适应算法和首次适应算法,并通过实验比较它们的效果。

3. 虚拟内存管理:虚拟内存是一种扩展内存的技术,它将磁盘空间作为辅助存储器,将部分数据存储在磁盘上,以释放内存空间。

实验中,我们将学习虚拟内存的概念和原理,并通过实验验证其性能和效果。

实验结果与分析:通过实验,我们得到了不同存储管理策略的性能数据,并进行了分析。

在内存分配方面,连续分配在内存利用率方面表现较好,但容易产生外部碎片;离散分配能够充分利用内存空间,但需要额外的管理开销;分页分配能够灵活地分配内存,但会带来内部碎片。

在内存回收方面,最佳适应算法能够更好地利用内存空间,但需要较长的搜索时间;最坏适应算法能够减少外部碎片,但可能导致内存利用率较低;首次适应算法在搜索时间和内存利用率方面都有较好的平衡。

在虚拟内存管理方面,虚拟内存能够有效扩展内存空间,提高系统的性能和效率。

通过实验,我们发现虚拟内存的使用可以显著减少交换空间的开销,并提高系统的响应速度。

操作系统实验报告4

操作系统实验报告4

操作系统实验报告4一、实验目的本次操作系统实验的目的在于深入了解和掌握操作系统中进程管理、内存管理、文件系统等核心概念和相关操作,通过实际的实验操作,增强对操作系统原理的理解和应用能力,提高解决实际问题的能力。

二、实验环境本次实验使用的操作系统为 Windows 10,编程语言为 C++,开发工具为 Visual Studio 2019。

三、实验内容与步骤(一)进程管理实验1、进程创建与终止使用 C++语言编写程序,创建多个进程,并在进程中执行不同的任务。

通过进程的标识符(PID)来监控进程的创建和终止过程。

2、进程同步与互斥设计一个生产者消费者问题的程序,使用信号量来实现进程之间的同步与互斥。

观察生产者和消费者进程在不同情况下的执行顺序和结果。

(二)内存管理实验1、内存分配与释放编写程序,使用动态内存分配函数(如`malloc` 和`free`)来分配和释放内存。

观察内存的使用情况和内存泄漏的检测。

2、内存页面置换算法实现几种常见的内存页面置换算法,如先进先出(FIFO)算法、最近最少使用(LRU)算法和最佳置换(OPT)算法。

通过模拟不同的页面访问序列,比较不同算法的性能。

(三)文件系统实验1、文件创建与读写使用 C++语言的文件操作函数,创建一个新文件,并向文件中写入数据。

从文件中读取数据,并进行数据的处理和显示。

2、文件目录操作实现对文件目录的创建、删除、遍历等操作。

观察文件目录结构的变化和文件的组织方式。

四、实验结果与分析(一)进程管理实验结果与分析1、进程创建与终止在实验中,成功创建了多个进程,并通过控制台输出观察到了每个进程的 PID 和执行状态。

可以看到,进程的创建和终止是按照程序的逻辑顺序进行的,操作系统能够有效地管理进程的生命周期。

2、进程同步与互斥在生产者消费者问题的实验中,通过信号量的控制,生产者和消费者进程能够正确地实现同步与互斥。

当缓冲区为空时,消费者进程等待;当缓冲区已满时,生产者进程等待。

《操作系统》存储管理实验报告要点

《操作系统》存储管理实验报告要点

____大学____学院实验报告课程名称:计算机操作系统实验名称:存储管理实验实验日期:班级:姓名:学号:仪器编号:XX实验报告要求:1.实验目的 2.实验要求 3.实验步骤 4.程序清单5.运行情况 6.流程图7.实验体会1、实验目的①通过编写和调试存储管理的模拟程序以加深对存储管理方案的理解,熟悉虚存管理的各种页面淘汰法。

②通过编写和调试地址转换过程的模拟程序以加强对地址转换过程的了解。

2、实验要求①设计一个固定式分区分配的存储管理方案,并模拟实现分区的分配和回收过程。

可以假定每个作业都是批处理作业,并且不允许动态申请内存。

为实现分区的分配和回收,可以设定一个分区说明表,按照表中的有关信息进行分配,并根据分区的分配和回收情况修改该表。

②设计一个可变式分区分配的存储管理方案,并模拟实现分区的分配和回收过程。

对分区的管理法可以是下面三种算法之一:首次适应算法;最坏适应算法;最佳适应算法。

③编写并调试一个段页式存储管理的地址转换的模拟程序。

首先设计好段表、页表,然后给出若干个有一定代表性的地址,通过查找段表页表后得到转换的地址。

要求打印转换前的地址,相应的段表,页表条款及转换后的地址,以便检查。

3、实验步骤(1)理解实验要求,联系所学知识;(2)根据要求编写调度算法;(3)编写完整的实验代码并在VC++ 6.0环境下编译运行;(4)调试程序直至得出结果。

4、程序清单①#include <stdio.h>#include <stdio.h>#include<math.h>#include<stdlib.h>#define NUM 4#define alloMemory(type) (type*)malloc(sizeof(type))struct partiTab{int no;int size;int firstAddr;char state;}parTab[NUM];typedef struct partiTab PARTITAB;typedef struct jcb { /*定义作业控制块JCB ,部分信息省略*/ char name[10]; //作业名int size; //作业大小struct jcb* link; //链指针}JCB;typedef struct{JCB *front,*rear;}jcbQue;jcbQue *jcbReadyQue;void AllocateMemory(int size);void createTab();void checkTab();void recycleMemory(int i);void AllocateMemory(int size){int i;for(i=0;i<NUM;i++){PARTITAB p=parTab[i];if(p.state='N' && p.size>size)parTab[i].state='Y';elseprintf("没有空闲分区,无法分配内存!\n");}}void createTab(){int i;for( i=1;i<=NUM;i++){//getPartiTab(PARTITAB);parTab[i-1].no=i;parTab[i-1].size=20;parTab[i-1].firstAddr=21;parTab[i-1].state='N';}}void checkTab(){int i;printf("分区号\t大小\t起址\t状态\n");for(i=0;i<NUM;i++){printf("%d\t",parTab[i].no);printf("%d\t",parTab[i].size);printf("%d\t",parTab[i].firstAddr);printf("%c\t",parTab[i].state);printf("\n");}}void recycleMemory(int i){parTab[i-1].state='N';}int main(int argc, char* argv[]){int i;printf("\n\n\t\t*********************************************\t\t\n");printf("\t\t\t\t实验一存储管理实验\n");printf("\t\t\t\t固定式分区分配存储管理\n");printf("\t\t*********************************************\t\t\n");createTab();checkTab();printf("请按任意键继续:\n");getchar();printf("每个分区装入一道作业:\n");for(i=0;i<NUM;i++){AllocateMemory((i+1)*3);}checkTab();printf("请按任意键继续:\n");getchar();printf("假如一段时间后,其中一个作业结束,回收给它分配的分区(假如该作业在第2分区)\n"); recycleMemory(2);checkTab();printf("请按任意键继续:\n");getchar();printf("接着,从外存后备作业队列中选择一个作业装入该分区(假如该作业大小为10)\n"); AllocateMemory(10);checkTab();return 0;}#include<stdio.h>#include <dos.h>#include<stdlib.h>#include<conio.h>#define n 10#define m 10#define minisize 100struct{float address;float length;int flag;}used_table[n];struct{float address;float length;int flag;}free_table[m];void allocate(char J,float xk){int i,k;float ad;k=-1;for(i=0; i<m; i++)if(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;}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;}void 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++;if(s>=n){printf("找不到该作业\n");return;}used_table[s].flag=0;S=used_table[s].address;L=used_table[s].length;j=-1;k=-1;i=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;else if(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) /*空闲区表满,回收空间失败,将已分配表复原*/{printf("主存空闲表没有空间,回收空间失败\n");used_table[s].flag=J;return;}free_table[t].address=S;free_table[t].length=L;free_table[t].flag=1;}return;}/*主存回收函数结束*/int main( ){printf("\n\n\t\t*********************************************\t\t\n"); printf("\t\t\t\t实验三存储管理实验\n");printf("\n\t\t\t可变式分区分配(最佳适应算法)\n");printf("\t\t*********************************************\n");int i,a;char J;/*空闲分区表初始化:*/free_table[0].address=10240; /*起始地址假定为10240*/free_table[0].length=10240; /*长度假定为10240,即10k*/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("功能选择项:\n1。

实验四--操作系统存储管理实验报告

实验四--操作系统存储管理实验报告

实验四 操作系统存储管理实验报告一、实验目的存储管理的主要功能之一是合理地分配空间。

请求页式管理是一种常用的虚拟存储管理技术。

本实验的目的是通过请求页式管理中页面置换算法模拟设计,了解虚拟存储技术的特点,掌握请求页式存储管理的页面置换算法。

二、实验内容(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");}}。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

实验四 操作系统存储管理实验报告一、实验目的存储管理的主要功能之一是合理地分配空间。

请求页式管理是一种常用的虚拟存储管理技术。

本实验的目的是通过请求页式管理中页面置换算法模拟设计,了解虚拟存储技术的特点,掌握请求页式存储管理的页面置换算法。

二、实验内容(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次指令页地址流长度页面失效次数命中率-=1C、将指令序列变换称为页地址流在用户虚存中,按每k存放10条指令排列虚存地址,即320条指令在虚存中的存放方式为:第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");}}。

相关文档
最新文档