(完整word版)实验五、存储管理实验报告
- 格式:doc
- 大小:60.50 KB
- 文档页数:8
操作系统存储管理实验报告实验5存储管理第一,实验的目的1,加深对操作系统存储管理的理解2,可以过度模拟页面调试算法,加深对操作系统内存管理的理解二、一般设计思想、环境语言、工具等一般设计思想:1.编写一个函数来计算和输出以下算法的命中率:(1) OPT页面替换算法OPT选定的过时页面是已经转移到内存中并且将来不会被使用或者在最长时间内不会被访问的页面。
因此,如何找到这样的页面是算法的关键。
每页可以设置一个步长变量。
它的初始值是一个足够大的数字。
对于不在内存中的页面,其值将重置为零。
对于内存中的页面,其值被重置为当前访问的页面与页面首次出现时的距离。
因此,该值越大,在最长时间内不会被访问的页面就越多,并且可以选择它作为交换页面。
(2)先进先出页面替换算法先进先出总是选择首先进入内存的页面进行清除,因此可以设置先进先出的繁忙页面帧队列,新转移到内存的页面挂在队列的尾部,当没有空闲页面帧时,可以从队列的头部取出下一个页面帧作为空闲页面帧,然后再转移到需要的页面。
(3) LRU页面替换算法LRU 根据转移到存储器中的页面的使用做出决定。
它使用“最近的过去”作为“最近的未来”的近似,并选择最长时间没有使用的页面进行删除。
该算法主要通过页面结构中的访问时间来实现。
时间记录页面的最后访问时间。
因此,当需要删除一个页面时,选择时间值最小的页面,即最近最长时间没有使用的页面进行删除。
(4) LFU页面替换算法LFU要求每个页面配置一个计数器(即页面结构中的计数器)。
一旦页面被访问,计数器的值将增加1。
当需要替换一个页面时,将选择计数器值最小的页面,即存储器中访问次数最少的页面进行清除。
⑤NUR页面替换算法NUR要求为每个页面设置一个访问位(访问位仍然可以由页面结构中的计数器表示)。
当页面被访问时,其访问位计数器被设置为1。
当需要页面替换时,替换算法从替换指针(最初指向第一页)开始顺序检查内存中的每一页。
如果其访问位为0,则选择页面进行替换,否则,替换指针向下移动以继续向下搜索。
实验三、存储管理一、实验目的:? 一个好的计算机系统不仅要有一个足够容量的、存取速度高的、稳定可靠的主存储器,而且要能合理地分配和使用这些存储空间。
当用户提出申请存储器空间时,存储管理必须根据申请者的要求,按一定的策略分析主存空间的使用情况,找出足够的空闲区域分配给申请者。
当作业撤离或主动归还主存资源时,则存储管理要收回作业占用的主存空间或归还部分主存空间。
主存的分配和回收的实现虽与主存储器的管理方式有关的,通过本实验理解在不同的存储管理方式下应怎样实现主存空间的分配和回收。
在计算机系统中,为了提高主存利用率,往往把辅助存储器(如磁盘)作为主存储器的扩充,使多道运行的作业的全部逻辑地址空间总和可以超出主存的绝对地址空间。
用这种办法扩充的主存储器称为虚拟存储器。
通过本实验理解在分页式存储管理中怎样实现虚拟存储器。
在本实验中,通过编写和调试存储管理的模拟程序以加深对存储管理方案的理解。
熟悉虚存管理的各种页面淘汰算法通过编写和调试地址转换过程的模拟程序以加强对地址转换过程的了解。
二、实验题目:设计一个可变式分区分配的存储管理方案。
并模拟实现分区的分配和回收过程。
对分区的管理法可以是下面三种算法之一:(任选一种算法实现)首次适应算法循环首次适应算法最佳适应算法三.实验源程序文件名:cunchuguanli.c执行文件名:cunchuguanli.exe四、实验分析:1)本实验采用可变分区管理,使用首次适应算法实现主存的分配和回收1、可变分区管理是指在处理作业过程中建立分区,使分区大小正好适合作业的需求,并且分区个数是可以调整的。
当要装入一个作业时,根据作业需要的主存量查看是否有足够的空闲空间,若有,则按需要量分割一个分区分配给该作业;若无,则作业不能装入,作业等待。
随着作业的装入、完成,主存空间被分成许多大大小小的分区,有的分区被作业占用,而有的分区是空闲的。
为了说明那些分区是空闲的,可以用来装入新作业,必须有一张空闲说明表? 空闲区说明表格式如下:?第一栏第二栏其中,起址——指出一个空闲区的主存起始地址,长度指出空闲区的大小。
存储器管理实验实验报告一、实验目的存储器管理是操作系统的重要组成部分,本次实验的目的在于深入理解存储器管理的基本原理和方法,通过实际操作和观察,掌握存储器分配与回收的算法,以及页面置换算法的实现和性能评估。
二、实验环境本次实验使用的操作系统为 Windows 10,编程语言为 C++,开发工具为 Visual Studio 2019。
三、实验内容与步骤(一)存储器分配与回收算法实现1、首次适应算法(1)原理:从空闲分区链的首地址开始查找,找到第一个满足需求的空闲分区进行分配。
(2)实现步骤:建立空闲分区链表,每个节点包含分区的起始地址、大小和状态(已分配或空闲)。
当有分配请求时,从链表头部开始遍历,找到第一个大小满足需求的空闲分区。
将该分区进行分割,一部分分配给请求,剩余部分仍作为空闲分区留在链表中。
若找不到满足需求的空闲分区,则返回分配失败。
2、最佳适应算法(1)原理:从空闲分区链中选择与需求大小最接近的空闲分区进行分配。
(2)实现步骤:建立空闲分区链表,每个节点包含分区的起始地址、大小和状态。
当有分配请求时,遍历整个链表,计算每个空闲分区与需求大小的差值。
选择差值最小的空闲分区进行分配,若有多个差值相同且最小的分区,选择其中起始地址最小的分区。
对选中的分区进行分割和处理,与首次适应算法类似。
3、最坏适应算法(1)原理:选择空闲分区链中最大的空闲分区进行分配。
(2)实现步骤:建立空闲分区链表,每个节点包含分区的起始地址、大小和状态。
当有分配请求时,遍历链表,找到最大的空闲分区。
对该分区进行分配和处理。
(二)页面置换算法实现1、先进先出(FIFO)页面置换算法(1)原理:选择在内存中驻留时间最久的页面进行置换。
(2)实现步骤:建立页面访问序列。
为每个页面设置一个进入内存的时间戳。
当发生缺页中断时,选择时间戳最早的页面进行置换。
2、最近最久未使用(LRU)页面置换算法(1)原理:选择最近一段时间内最长时间未被访问的页面进行置换。
第1篇一、实验背景存储管理是操作系统的重要组成部分,负责对计算机的存储资源进行合理分配、有效利用和保护。
为了加深对存储管理原理和方法的理解,我们进行了存储管理实验,通过编写和调试模拟程序,对存储管理技术进行了深入学习和实践。
二、实验目的1. 理解存储管理的概念、原理和方法。
2. 掌握不同存储管理技术的实现过程。
3. 分析存储管理技术的优缺点,为实际应用提供参考。
三、实验内容1. 可变分区存储管理实验实验目的:了解可变分区存储管理的原理和实现方法。
实验内容:(1)编写程序实现内存空间的分配和回收。
(2)采用最优适应算法、首次适应算法、下次适应算法等,模拟内存分配过程。
(3)分析不同分配算法的性能。
实验结果:通过实验,我们了解了可变分区存储管理的原理和实现方法,并分析了不同分配算法的性能。
2. 分页存储管理实验实验目的:掌握分页存储管理的基本概念和实现方法。
实验内容:(1)编写程序实现内存空间的分配和回收。
(2)采用页式存储管理技术,模拟内存分配过程。
(3)分析页面置换算法的性能,如LRU、FIFO等。
实验结果:通过实验,我们掌握了分页存储管理的基本概念和实现方法,并分析了页面置换算法的性能。
3. 虚拟页式存储管理实验实验目的:了解虚拟页式存储管理的原理和实现方法。
实验内容:(1)编写程序实现虚拟内存的分配和回收。
(2)采用工作集算法、抖动预防等技术,模拟虚拟内存的访问和页面置换过程。
(3)分析虚拟页式存储管理技术的优缺点。
实验结果:通过实验,我们了解了虚拟页式存储管理的原理和实现方法,并分析了其优缺点。
四、实验总结1. 通过本次实验,我们对存储管理技术有了更深入的理解,掌握了不同存储管理技术的实现方法。
2. 实验过程中,我们学会了编写模拟程序,通过程序模拟存储管理过程,验证了存储管理技术的性能。
3. 实验结果分析表明,不同存储管理技术具有不同的优缺点,在实际应用中应根据具体需求选择合适的存储管理技术。
存储管理实验报告存储管理实验报告引言:存储管理是计算机系统中非常重要的一部分,它负责管理计算机系统中的存储资源,包括内存和外存。
合理的存储管理能够提高计算机系统的性能和效率,保证系统的稳定运行。
本次实验旨在通过实践操作,深入了解存储管理的原理和方法,并通过实验结果分析,探讨存储管理的优化策略。
一、实验目的本次实验的主要目的是通过实践操作,深入了解存储管理的原理和方法,并通过实验结果分析,探讨存储管理的优化策略。
具体目标如下:1. 了解存储管理的基本概念和原理;2. 掌握存储管理的常用方法和技术;3. 分析实验结果,探讨存储管理的优化策略。
二、实验环境本次实验使用了一台配置较高的计算机,具备较大的内存和高速的硬盘。
实验环境如下:1. 操作系统:Windows 10;2. 内存:16GB;3. 硬盘:1TB。
三、实验过程1. 内存管理实验在内存管理实验中,我们使用了一段较大的程序代码进行测试。
首先,我们通过编程语言将程序代码写入内存中,然后通过内存管理技术将程序代码加载到内存的合适位置。
在加载过程中,我们使用了分页和分段两种常用的内存管理技术,并比较了它们的性能差异。
实验结果显示,分页技术相对来说更加高效,能够更好地利用内存资源,提高系统的运行速度。
2. 外存管理实验在外存管理实验中,我们模拟了大文件的读写操作。
首先,我们将一个较大的文件写入硬盘中,然后通过外存管理技术将文件加载到内存中进行读取。
在加载过程中,我们使用了磁盘调度算法和文件系统管理技术,并比较了它们的性能差异。
实验结果显示,磁盘调度算法的选择对系统的读写速度有较大的影响,而文件系统的合理管理能够提高文件的存取效率。
四、实验结果分析通过对实验结果的分析,我们可以得出以下结论:1. 内存管理中,分页技术相对于分段技术更加高效,能够更好地利用内存资源,提高系统的运行速度;2. 外存管理中,磁盘调度算法的选择对系统的读写速度有较大的影响,合理选择磁盘调度算法能够提高系统的性能;3. 文件系统的合理管理能够提高文件的存取效率,减少文件的碎片化,提高系统的整体性能。
存储管理实验报告存储管理实验报告一、引言存储管理是计算机系统中一个非常重要的组成部分,它负责管理计算机内存的分配、回收和保护。
本次实验旨在通过实际操作,深入理解存储管理的原理和技术,并探索不同的存储管理策略对系统性能的影响。
二、实验目的1. 理解存储管理的基本概念和原理;2. 掌握常见的存储管理算法和策略;3. 分析不同存储管理策略对系统性能的影响。
三、实验环境本次实验使用了一台配置较低的个人电脑,操作系统为Windows 10,内存容量为4GB。
四、实验内容1. 静态分区分配算法静态分区分配算法是最简单的存储管理算法之一。
在实验中,我们使用了最先适应算法(First Fit)和最佳适应算法(Best Fit)进行静态分区分配。
通过对比两种算法的分配效果,我们发现最佳适应算法在减少内存碎片方面表现更好。
2. 动态分区分配算法动态分区分配算法是一种更加灵活的存储管理策略。
在实验中,我们实现了首次适应算法(First Fit)和最佳适应算法(Best Fit)两种动态分区分配算法。
通过观察不同算法的分配效果,我们发现首次适应算法在处理大量小内存块时效率较高,而最佳适应算法在处理大内存块时表现更好。
3. 页面置换算法页面置换算法是虚拟内存管理中的重要组成部分。
在实验中,我们实现了最近最少使用(LRU)算法和先进先出(FIFO)算法两种页面置换算法。
通过模拟内存不足的情况,我们观察了不同算法对系统性能的影响。
结果显示,LRU算法在减少页面置换次数方面比FIFO算法更为优秀。
五、实验结果与分析通过本次实验,我们对不同的存储管理算法和策略进行了实际操作,并观察了它们对系统性能的影响。
实验结果显示,最佳适应算法在静态分区分配中表现更好,而首次适应算法在动态分区分配中效率更高。
在页面置换算法中,LRU 算法在减少页面置换次数方面更为出色。
六、实验总结本次实验通过实际操作,深入理解了存储管理的原理和技术,并探索了不同的存储管理策略对系统性能的影响。
一、实训目的1. 通过本次实训,加深对存储管理方案的理解,掌握虚拟存储器的管理方式,熟悉虚存管理的各种页面淘汰算法。
2. 通过编写和调试地址转换过程的模拟程序,加强对地址转换过程的理解。
3. 培养编程能力和问题解决能力,提高实际操作水平。
二、实训环境1. 操作系统:Windows 102. 编程语言:C++3. 开发环境:Visual Studio 20194. 硬件配置:CPU:Intel Core i5,内存:8GB,硬盘:256GB SSD三、实训原理1. 虚拟存储器:虚拟存储器是一种将内存与外存相结合的存储管理技术,可以扩大程序可访问的存储空间。
2. 页面置换算法:页面置换算法是虚拟存储器中的一种内存管理技术,用于确定在内存中保留哪些页面,淘汰哪些页面。
3. 地址转换过程:地址转换过程是将逻辑地址转换为物理地址的过程。
四、实训内容1. 设计一个请求页式存储管理方案,并编写模拟程序实现。
2. 产生一个需要访问的指令地址流,其中50%的指令是顺序执行的,25%的指令均匀地散布在前地址部分,25%的地址是均匀地散布在后地址部分。
3. 指定内存页表的最大长度,并对页表进行初始化。
4. 每访问一个地址时,计算该地址所在的页的页号,然后查页表,判断该页是否在主存。
5. 如果该页已在主存,则打印页表情况;如果该页不在主存,则采用FIFO页面淘汰算法淘汰一页,并将该页在页表中抹去。
6. 编写代码实现上述功能,并进行测试。
五、实训过程1. 确定虚拟存储器的大小、内存大小、页面大小和页面置换算法。
2. 设计数据结构存储页面信息,包括页号、是否在内存中、是否被修改等。
3. 编写函数实现地址转换过程,包括计算页号、判断页是否在内存中等。
4. 编写FIFO页面淘汰算法,淘汰不在内存中的页面。
5. 编写测试程序,生成指令地址流,并调用相关函数进行测试。
六、实训结果1. 成功实现了请求页式存储管理方案,并编写了相应的模拟程序。
实验五:存储管理一、实验目的(1)熟悉内存空闲分区的分配方式;(2)理解动态分区存储管理方式;(3)掌握动态分区的分配与回收的过程。
二、实验环境微型计算机,Ubuntu Linux10.04 ,gedit,gcc三、实验内容根据流程图和参考程序,完成模拟内存分配和回收过程。
内存空间大小为100,进程数为5,每个进程所需空间为随机产生,大小为1~20,编制程序,首先对5个进程进行内存分配,然后回收指定的进程空间,并进行适当的空闲分区合并操作,要求每次操作结束后都能显示当前的内存分配情况。
四、实验结果截图一截图二截图三五、源代码#include<stdio.h>#include<malloc.h>typedef struct MEMORY_BLOCK{int name; //进程名int address; //起始地址int length; //长度int flag; //标志,表示该块是否被分配。
struct MEMORY_BLOCK *next; //指向下一个进程}MEMORY_BLOCK;#define NUM 5#define LEN sizeof(MEMORY_BLOCK)void allocation(MEMORY_BLOCK *Header,int name,int length_p){ MEMORY_BLOCK *temp,*t,*tt;int minsize=2; //不可切割的分区阈值while(t!=0){if(t->length>length_p&&t->flag==0) break;t=t->next;}if(t->length-length_p>minsize){ //分割temp=(MEMORY_BLOCK*)malloc(LEN);temp->name=-1;temp->flag=0;temp->length=t->length-length_p;temp->address=t->address+length_p;t->name=name;t->flag=1;t->length=length_p;temp->next=t->next;t->next=temp;}else{ //直接分配t->name=name;t->flag=1;}}void reclaim(int processname, MEMORY_BLOCK *Header){ MEMORY_BLOCK *temp,*t,*tt;temp=t;while(t->name!=processname){temp=t;t=t->next;}if(t->next!=NULL){ //t非尾结点if(temp->flag==0&&t->next->flag==0){ //左右为空temp->name=-1;temp->length=temp->length+t->length+t->next->length;tt=t->next;temp->next=tt->next;}else if(temp->flag==0){ //左为空temp->name=-1;temp->length=temp->length+t->length;temp->next=t->next;}else if(t->next->flag==0){ //右为空t->name=-1;t->length=t->length+t->next->length;t->flag=0;tt=t->next;t->next=tt->next;}else{ //左右不为空t->name=-1;t->flag=0;}else{ //t是尾结点if(temp->flag==0){ //左为空temp->name=-1;temp->length=temp->length+t->length;temp=t->next;}else{ //左不为空t->name=-1;t->flag=0;}}}void main(){ //主函数int length_p,i,processname;MEMORY_BLOCK *Header,*t;Header=(MEMORY_BLOCK*)malloc(LEN); //初始化存储空间Header->name=-1;Header->address=0;Header->length=100;Header->flag=0;Header->next=NULL;srand((int)time(0));for(i=1;i<=NUM+1;i++){length_p=rand()%20+1; //随机产生进程所需存储空间,至少为1allocation(Header,i,length_p);}printf("当前内存分配情况:\n");t=Header;while(t!=0){printf("process_name:%d,address:%d,length:%d,flag:%d\n",t->name,t->address,t->length,t->flag);t=t->next;}printf("请输入回收的进程号(输入0结束):\n");scanf("%d",&processname);while(processname!=0){printf("回收process name %d\n",processname);reclaim(processname,Header);printf("当前内存分配情况:\n");t=Header;while(t!=0){printf("process_name:%d,address:%d,length=%d,flag=%d\n", t->name, t->address, t->length,t->flag);t=t->next;}。
操作系统存储管理实验报告一、实验目的本次实验的目的是通过编写一段程序,实现对内存的分配和回收操作,并验证算法的正确性和性能。
二、实验内容1.实现首次适应算法首次适应算法是一种动态分配的内存管理算法,通过从低地址往高地址内存块,找到第一个满足需求的空闲块进行分配。
具体实现过程如下:(1)初始化内存空间,设置内存块的大小和地址范围;(2)编写一个函数,实现内存的分配操作,根据需求大小找到第一个合适的空闲块,并在其前后设置相应的标志位;(3)编写一个函数,实现内存的回收操作,根据释放块的地址,将其前后的标志位进行合并;(4)模拟应用程序的运行,测试内存的分配和回收操作。
2.实现最佳适应算法最佳适应算法是一种动态分配的内存管理算法,通过整个内存空间,找到最小的满足需求的空闲块进行分配。
具体实现过程如下:(1)初始化内存空间,设置内存块的大小和地址范围;(2)编写一个函数,实现内存的分配操作,遍历整个内存空间,找到满足需求且大小最小的空闲块进行分配;(3)编写一个函数,实现内存的回收操作,根据释放块的地址,将其前后的标志位进行合并;(4)模拟应用程序的运行,测试内存的分配和回收操作。
三、实验结果1.首次适应算法经过测试,首次适应算法能够正确地进行内存的分配和回收操作,并且算法的性能良好。
尽管首次适应算法在分配过程中可能会产生碎片,但是由于它从低地址开始,可以在较短的时间内找到满足需求的空闲块。
在实际应用中,首次适应算法被广泛采用。
2.最佳适应算法经过测试,最佳适应算法能够正确地进行内存的分配和回收操作,并且算法的性能较好。
最佳适应算法会整个内存空间,找到大小最小的满足需求的空闲块。
因此,在分配过程中不会产生很多的碎片,但是算法的执行时间较长。
四、实验总结通过本次实验,我们成功地实现了首次适应算法和最佳适应算法,并对算法的正确性和性能进行了验证。
两种算法在内存的分配和回收过程中都表现出良好的性能,可广泛应用于实际场景中。
存储管理实验报告一、实验目的1.了解存储管理的概念及作用;2.掌握存储管理的基本操作和技术;3.熟悉常见的存储管理工具和方法;4.分析存储管理对系统性能的影响。
二、实验内容1.了解存储管理的基本概念:存储管理是指对计算机中的存储器进行有效管理和利用的一种技术手段。
主要包括内存管理和外存管理两个方面。
2.学习常见的存储管理工具和方法:(1)内存管理方案:连续内存管理、非连续内存管理和虚存管理;(2)外存管理方案:磁盘存储管理、文件系统管理和缓存管理等。
3.实际操作存储管理工具:(1)使用操作系统的内存管理工具,如Windows的任务管理器和Linux的top命令等,查看内存使用情况和进程占用的内存大小;(2)使用磁盘管理工具,如Windows的磁盘管理器和Linux的fdisk命令等,查看磁盘的分区情况和使用状况;(3)使用文件系统管理工具,如Windows的资源管理器和Linux的ls命令等,查看文件和目录的存储和管理状态。
4.分析存储管理对系统性能的影响:(1)使用性能监控工具,如Windows的性能监视器和Linux的sar 命令等,实时监测系统的内存、磁盘和文件系统等性能指标;(2)对比不同存储管理方案的优缺点,分析其对系统性能的影响;(3)根据实验结果提出优化存储管理的建议。
三、实验步骤1.阅读相关文献和资料,了解存储管理的基本概念和原理;2.使用操作系统的内存管理工具,查看当前系统内存的使用情况;3.使用操作系统的磁盘管理工具,查看当前系统磁盘的分区情况;4.使用操作系统的文件系统管理工具,查看当前系统文件和目录的存储和管理状态;5.使用性能监控工具,实时监测系统的内存、磁盘和文件系统等性能指标;6.根据实验结果,分析存储管理对系统性能的影响;7.结合实验结果,提出优化存储管理的建议。
四、实验结果1.使用内存管理工具查看系统内存使用情况,发现部分进程占用内存过高,导致系统运行缓慢;2.使用磁盘管理工具查看系统磁盘分区情况,发现磁盘分区不合理,造成磁盘空间利用率较低;3.使用文件系统管理工具查看文件和目录的存储和管理状态,发现有大量重复和冗余的文件,需要进行清理和整理;4.使用性能监控工具实时监测系统的性能指标,发现内存和磁盘的利用率较高,需要优化存储管理。
计算机与信息技术学院综合性实验报告一、实验目的通过请求页式存储管理中页面置换算法模拟设计,了解虚拟存储技术的特点,掌握请求页式管理的页面置换算法。
二、实验仪器或设备微型计算机、Linux操作系统、dev C++三、总体设计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]);按以上方式,用户指令可组成32页。
3、计算并输出下述算法在不同内存容量下的命中率。
A. FIFO先进先出置换算法;B. LRU最近最久未使用置换算法;C. NUR最近未使用置换算法。
命中率=1-页面失效次数/页地址流长度在本实验中,页地址流长度为320,页面失效次数为每次访问相应指令时,该指令所对应的页不在内存的次数。
4、相关定义(1)数据结构○1页面类型typedef struct /*页面结构*/{int pn,pfn,time;}pl_type;其中pn为页面号,pfn为页帧号,time为访问时间○2页帧控制结构struct pfc_struct{ /*页帧控制结构*/int pn,pfn;struct pfc_struct *next;};typedef struct pfc_struct pfc_type;pfc_type pfc[total_vp],*freepf_head,*busypf_head,*busypf_tail;其中pfc_type pfc[total_vp]定义用户进程虚页控制结构*freepf_head为空闲页帧头的指针*busypf_head为忙页帧头的指针*busypf_tail忙页帧尾的指针(2)函数定义void initialize(int):初始化函数void FIFO(int):计算使用FIFO算法时的命中率void LRU(int):计算使用LRU算法时的命中率void NRU(int):计算使用NRU算法时的命中率(3)变量定义int a[total_instruction]:指令流数组int diseffect:页面失效次数int page[total_instruction]:每条指令所属页面号int offset[total_instruction]:每页装入10条指令后取模运算得出的页内偏移地址int total_pf:用户进程的内存页面数四、实验步骤按照流程图编写代码、并上机调试运行程序代码:#include <stdlib.h>#include <stio.h>#define TRUE 1#define FALSE 0#define INVALID -1#define total_instruction 320 /*指令流长*/#define total_vp 32 /*虚页长*/typedef struct /*页面结构*/{int pn,pfn,time;}pl_type;pl_type pl[total_vp]; /*页帧结构数组*/struct pfc_struct{ /*页帧控制结构*/int pn,pfn;struct pfc_struct *next;};typedef struct pfc_struct pfc_type;pfc_type pfc[total_vp],*freepf_head,*busypf_head,*busypf_tail;int diseffect,a[total_instruction];int page[total_instruction],offset[total_instruction];void initialize(int);void FIFO(int);void LRU(int);void NRU(int);int main( ){int s,i;/*由于每次运行时进程号不同,故可用来作为初始化随机数队列的“种子”*/ srand(10*getpid());s=(float)319*rand( )/RAND_MAX+1;for(i=0;i<total_instruction;i+=4) /*产生指令队列*/{a[i]=s; /*任选一指令访问点m*/a[i+1]=a[i]+1; /*顺序执行一条指令*/a[i+2]=(float)a[i]*rand( )/RAND_MAX; /*执行前地址指令m' */a[i+3]=a[i+2]+1; /*顺序执行一条指令*/s=(float)(318-a[i+2])*rand( )/RAND_MAX+a[i+2]+2;}for (i=0;i<total_instruction;i++) /*将指令序列变换成页地址流*/{page[i]=a[i]/10;offset[i]=a[i]%10;}for(i=4;i<=32;i++) /*用户内存工作区从4个页帧到32个页帧*/{printf("%2d page frames ",i);void FIFO(int);void LRU(int);void NRU(int);printf("\n");}}void initialize(int total_pf) /*初始化相关数据结构*/ {int i;diseffect=0;for(i=0;i<total_vp;i++){ pl[i].pn=i;pl[i].pfn=INVALID;pl[i].time=-1;}for(i=0;i<total_pf-1;i++){ pfc[i].next=&pfc[i+1];pfc[i].pfn=i;} /*建立pfc[i-1]和pfc[i]之间的链接*/pfc[total_pf-1].next=NULL;pfc[total_pf-1].pfn=total_pf-1;freepf_head=&pfc[0]; /*空页面队列的头指针为pfc[0]*/ }void FIFO(int total_pf) /*先进先出算法*/int total_pf; /* 用户进程的内存页面数 */ { int i,j;pfc_type *p, *t;initialize(total_pf); /* 初始化相关页面控制用数据结构*/ busypf_head=busypf_tail=NULL: /* 忙页面队列头,队列尾链接 */for(i=0;i=total_instruction;i++){ if(p1[page[i]].pfn= =INVALID) /* 页面失效 */{ disaffect+=1; /* 失效次数 */if(freep_headf= =NULL) /* 无空闲页面 */{ p=busypf_head->next;p1[busypf_head->pn].pfn=INVALID;freepf_head=busypf_head; /*释放忙页面队列中的第一个页面*/ freepf_head->next=NULL:busypf_head=p;}p=freepf_head->next; /* 按FIFO方式调新页面入内存页面 */ freepf_head->next=NULL:freepf_head->pn=page[i];p1[page[i]].pfn=freepf_head->pfn;if(busypf_tail= =NULL)busypf_head=busypf_tail=freepf_head;else{ busypf_tail->next=freepf_head;busypf_tail=freepf_head;}freepf_head=p;}}printf(“FIFO:%6.4f”,1-(float)disaffect/320);}void LRU (int total_pf) /*最近最久未使用算法*/int total_pf;{ int min,minj,i,j,present_time;initialize(total_pf);present_time=0;for(i=0;i<total_instruction;i++){ if(p1[page[i]].pfn= =INVALID) /* 页面失效 */ { disaffect++;if(freepf_head= =NULL) /* 无空闲页面 */ { min=32767;for(j=0;j<total_vp;j++)if(min>p1[j].time&&p1[j].pfn !=INVALID){ min=p1[j].time;minj=j;}freepf_head=&pfc[p1[minj].pfn];p1[minj].pfn=INVALID;p1[min].time=-1;freepf_head->next=NULL;}p1[page[i]].pfn=freepf_head->pfn;p1[page[i]].time=present_time;freepf_head=freepf_head->next;}elsep1[page[i]].time=present_time;present_time++;}printf(“LRU:%6.4f”,1-(flaot)disaffect/320);}void NRU(int total_pf) /*最近未使用置换算法*/ int total_pf;{ int i,j,dp,cont_flag,old_dp;pfc_type *t;initialize(total_pf);dp=0;for(i=0;i<total_instruction;i++){ if(p1[page[i]].pfn= =INVALID) /* 页面失效 */ { diseffect++;if(freepf_head= =NULL) /* 无空闲页面 */ { cont_flag=TRUE;old_dp=dp;while(cont_flag)if(p1[dp].counter= =0 && p1[dp].pfn!=INVALID)cont_flag=FLASE;else{ dp++;if(dp= =total_vp)dp=0;if(dp= =old_dp)for(j=0;j<total_vp;j++)p1[j].counter=0;}freepf_head=&pfc[p1[dp].pfn];p1[dp].pfn=INVALID;freepf_head->next=NULL:}p1[page[i]].pfn=freepf_head->pfn;freepf_head=freepf_head->next;}elsep1[page[i]].counter=1;if(i%clear_period= =0)for(j=0;j<total_vp;j++)p1[j].counter=0;}printf(“NUR:%6.4f”,1-(float)disaffect/320);}void OPT(total_pf)int total_pf;{ int i,j,max,maxpage,d,dist[total_vp];pfc_type *t;initialize(total_pf);for(i=0;i<total_instruction;i++){ if(p1[page[i]].pfn= =INVALID){ diseffect++;if(freepf_head= =NULL){ for(j=0;j<total_vp;j++)if(p1[j].pfn !=INVALID)dist[j]=32767;elsedist[j]=0;d=1;for(j=i+1;j<total_instruction;j++){ if(p1[page[j]].pfn!=INVALID)dist[page[j]]=d;d++;}max=-1;for(j=0;j<total_vp;j++)if(max<dist[j]){ max=dist[j];maxpage=j;}freepf_head=&pfc[p1[maxpage].pfn];freepf_head->next=NULL;p1[maxpage].pfn=INVALID;}p1[page[i]].pfn=freepf_head->pfn;freepf_head=freepf_head->next;}}printf(“OPT:%6.4f”,1-(float)disaffect/320);}显示结果:4 page frames FIFO:0.4969 LRU:0.5000 NUR:0.50005 page frames FIFO:0.5188 LRU:0.5125 NUR:0.50626 page frames FIFO:0.5281 LRU:0.5188 NUR:0.53447 page frames FIFO:0.5406 LRU:0.5500 NUR:0.55628 page frames FIFO:0.5500 LRU:0.5719 NUR:0.55319 page frames FIFO:0.5625 LRU:0.5812 NUR:0.578110 page frames FIFO:0.5844 LRU:0.5969 NUR:0.596911 page frames FIFO:0.5938 LRU:0.6094 NUR:0.625012 page frames FIFO:0.6156 LRU:0.6281 NUR:0.659413 page frames FIFO:0.6375 LRU:0.6344 NUR:0.650014 page frames FIFO:0.6844 LRU:0.6625 NUR:0.650015 page frames FIFO:0.6844 LRU:0.6812 NUR:0.687516 page frames FIFO:0.7062 LRU:0.7062 NUR:0.709417 page frames FIFO:0.7094 LRU:0.7125 NUR:0.725018 page frames FIFO:0.7188 LRU:0.7281 NUR:0.734419 page frames FIFO:0.7281 LRU:0.7531 NUR:0.753120 page frames FIFO:0.7281 LRU:0.7656 NUR:0.759421 page frames FIFO:0.7812 LRU:0.7781 NUR:0.790622 page frames FIFO:0.7875 LRU:0.7937 NUR:0.812523 page frames FIFO:0.7960 LRU:0.8094 NUR:0.818724 page frames FIFO:0.8000 LRU:0.8219 NUR:0.821925 page frames FIFO:0.8344 LRU:0.8312 NUR:0.834426 page frames FIFO:0.8625 LRU:0.8438 NUR:0.859427 page frames FIFO:0.8625 LRU:0.8652 NUR:0.878128 page frames FIFO:0.8750 LRU:0.8656 NUR:0.881229 page frames FIFO:0.8844 LRU:0.8781 NUR:0.881230 page frames FIFO:0.8875 LRU:0.8875 NUR:0.890631 page frames FIFO:0.8875 LRU:0.8906 NUR:0.900032 page frames FIFO:0.9000 LRU:0.9000 NUR:0.9000五、结果分析与总结从上述结果可知,当内存页面数较少(4~5页面)时,5种算法的命中率差别不大,都是50%左右。