实验三 存储管理1
实验三存储管理实验
实验三存储管理实验 Pleasure Group Office【T985AB-B866SYT-B182C-BS682T-STT18】实验三存储管理实验一. 目的要求：1、通过编写和调试存储管理的模拟程序以加深对存储管理方案的理解。
熟悉虚存管理的各种页面淘汰算法。
2、通过编写和调试地址转换过程的模拟程序以加强对地址转换过程的了解。
二．实验内容：1、设计一个固定式分区分配的存储管理方案，并模拟实现分区的分配和回收过程。
可以假定每个作业都是批处理作业，并且不允许动态申请内存。
为实现分区的分配和回收，可以设定一个分区说明表，按照表中的有关信息进行分配，并根据分区的分配和回收情况修改该表。
算法描述：本算法将内存的用户区分成大小相等的四个的分区，设一张分区说明表用来记录分区，其中分区的表项有分区的大小、起始地址和分区的状态，当系统为某个作业分配主存空间时，根据所需要的内存容量，在分区表中找到一个足够大的空闲分区分配给它，然后将此作业装入内存。
如果找不到足够大的空闲分区，则这个作业暂时无法分配内存空间，系统将调度另一个作业。
当一个作业运行结束时，系统将回收改作业所占据的分区并将该分区改为空闲。
算法原程序#include ""#include ""#include <>#include <>#define PCB_NUM 5 行程序.");printf("\n\t\t\t0.退出程序.");scanf("%d",&m);switch(m){case1:break;case0:system("cls");menu();break;default:system("cls");break;}}void paixu(struct MemInf* ComMem,int n){int i,j,t;for(j=0; j<n-1; j++)for(i=0; i<n-j-1; i++)if(ComMem[i].size>ComMem[i+1].size){t=ComMem[i].size;ComMem[i].size=ComMem[i+1].size;ComMem[i+1].size=t;}}void paixu2(){int i,j,t;for(j=0; j<4; j++)for(i=0; i<4-j; i++)if(pcbList[i].size>pcbList[i+1].size){t=pcbList[i].size;pcbList[i].size=pcbList[i+1].size; pcbList[i+1].size=t;}}void main(){DD:menu();char ch;int i,j,n,a=0;struct MemInf* ComMem;system("cls");printf("你要分多少个分区呢，请输入数值吧:");scanf("%d",&n);ComMem=(struct MemInf*)malloc(n*sizeof(struct MemInf));printf("请划分内存固定大小分区:\n");ize);if(i==0) ComMem[i].addr=40;ddr=ComMem[i-1].addr+ComMem[i-1].size;tate=0;ize+a;if(a>=INT){printf("超出规定内存范围");ch=getchar();ch=getchar();goto DD;}}paixu(ComMem,n);cbID =1;pcbList[0].RunState =0; ize=30;pcbList[0].RunTime =0;pcbList[0].TolTime =5;pcbList[1].pcbID =2;pcbList[1].RunState =0;pcbList[1].size=15;pcbList[1].RunTime =0;pcbList[1].TolTime =6;pcbList[2].pcbID =3;pcbList[2].RunState =0;pcbList[2].size=50;pcbList[2].RunTime =0;pcbList[2].TolTime =3;pcbList[3].pcbID =4;pcbList[3].RunState =0;pcbList[3].size=120;pcbList[3].RunTime =0;pcbList[3].TolTime =4;pcbList[4].pcbID =5;pcbList[4].RunState =0;pcbList[4].size=125;pcbList[4].RunTime =0;pcbList[4].TolTime =9;ch=getchar();ch=getchar();while(pcbList[PCB_NUM-1].RunTime < pcbList[PCB_NUM-1].TolTime){{for(j=0; j<PCB_NUM; j++){tate ==0&& pcbList[j].RunState==0) ize >= pcbList[j].size) tate =pcbList[j].pcbID ;pcbList[j].RunState=1;}}unTime >=pcbList[j].TolTime) tate == pcbList[j].pcbID){ComMem[i].state =0; unState=2; unState==1&& pcbList[i].RunTime < pcbList[i].TolTime) unTime++;cbID,pcbList[i].size, pcbList[i].RunState,pcbList[i].TolTime ,pcbList[i].RunTime);printf("分区ID\t 分区大小\t 状态\n");for(i=0; i<n; i++)printf("%d\t %d\t\t %d\n",i,ComMem[i].size ,ComMem[i].state );printf("按回车键继续...\n");getchar(); tart=-1;frees[i].length=0;strcpy(frees[i].tag,"free");occupys[i].start=-1;occupys[i].length=0;strcpy(occupys[i].tag,"");}free_quantity=0;occupy_quantity=0;}void writedata() tart);printf("输入第%d个分区的长度：\n",j);scanf("%d",&frees[i].length);}if((fp=fopen(fname,"wb"))==NULL)printf("错误,文件打不开,请检查文件名\n");for(i=0;i<SIZE;i++)if(fwrite(&frees[i],sizeof(struct node),1,fp)!=1)printf("文件写入错误!\n");fclose(fp);}void readdata() tart<=frees[t].start)t=j;}frees[free_quantity].start=frees[i].start;frees[free_quantity].length=frees[i].length;frees[i].start=frees[t].start;frees[i].length=frees[t].length;frees[t].start=frees[free_quantity].start;frees[t].length=frees[free_quantity].length;}}void view() tart,frees[i].length,frees[i].tag);printf("\n\n已分配分区表显示如下：\n");printf("起始地址\t长度\t占用作业名\n");for(j=0;j<occupy_quantity;j++)printf("%6dk\t%10dk\t%s\t\n",occupys[j].start,occupys[j].length,occupys[j].t ag);getchar();getchar();}void earliest() ength>=joblength)f=1;}if(f==0){printf("\n当前没有能满足你申请长度的空闲内存,请稍候再试\n");getchar();}else{ ength>=joblength){t=1;}j++;}j--;occupys[occupy_quantity].start=frees[j].start; ag,jobname); occupys[occupy_quantity].length=joblength;occupy_quantity++;if(frees[j].length>joblength){frees[j].start+=joblength;frees[j].length-=joblength;}else{for(i=j;i<free_quantity-1;i++){frees[i].start=frees[i+1].start;frees[i].length=frees[i+1].length;}free_quantity--;}printf("作业申请内存空间成功!\n");getchar();getchar();}}void excellent() ength>=joblength)f=1;}if(f==0){printf("\n当前没有能满足你申请长度的空闲内存,请稍候再试\n");getchar();}else ength>=joblength){t=1;}j++;}j--;for(i=0;i<free_quantity;i++){if(frees[i].length>=joblength&&frees[i].length<frees[j].length) j=i;}occupys[occupy_quantity].start=frees[j].start; ag,jobname);occupys[occupy_quantity].length=joblength;occupy_quantity++;if(frees[j].length>joblength){frees[j].start+=joblength;frees[j].length-=joblength;}else{for(i=j;i<free_quantity-1;i++){frees[i].start=frees[i+1].start;frees[i].length=frees[i+1].length;}free_quantity--;}printf("作业申请内存空间成功!\n");getchar();getchar();}}void worst(){char jobname[20];int joblength,f=0;int i,j;printf("请输入作业名：\n");scanf("%s",&jobname);printf("输入作业的长度：\n");scanf("%d",&joblength);for(i=0;i<free_quantity;i++){if(frees[i].length>=joblength)f=1;}if(f==0){printf("\n当前没有能满足你申请长度的空闲内存,请稍候再试\n");getchar();getchar();}else ength>=joblength){t=1;}j++;}j--;for(i=0;i<free_quantity;i++){if(frees[i].length>=joblength&&frees[i].length>frees[j].length) j=i;}occupys[occupy_quantity].start=frees[j].start; ag,jobname);occupys[occupy_quantity].length=joblength;occupy_quantity++;if(frees[j].length>joblength){frees[j].start+=joblength;frees[j].length-=joblength;}else{for(i=j;i<free_quantity-1;i++){frees[i].start=frees[i+1].start;frees[i].length=frees[i+1].length;}free_quantity--;}printf("作业申请内存空间成功!\n");getchar();getchar();}}void main(){initial();int n;writedata();system("cls");readdata();for(;;){sort();printf("************************************\n"); printf("************************************\n"); printf("** 欢迎使用可变分区存储管理系统 **\n");printf("************************************\n"); printf("** 1.显示空闲表和分配表 **\n");printf("** 2.首次适应算法 **\n");printf("** 3.最佳适应算法 **\n");printf("** 4.最坏适应算法 **\n");printf("** 0.退出系统 **\n"); printf("************************************\n"); printf("************************************\n"); printf("请输入您要选择的项目：\n");scanf("%d",&n);for(;;){if(n<0||n>4){printf("没有这个选项，请重新输入!");scanf("%d",&n);}elsebreak;}switch(n){case0:printf("感谢您的使用!再见!\n");exit(0);case1:view();break;case2:earliest();break;case3:excellent();break;case4:worst();break;}system("cls");}}测试结果：使用首次适应算法的结果：使用最佳适应算法：使用最坏适应算法：内存过满：3、编写并调试一个段页式存储管理的地址转换的模拟程序。
存储管理实验报告总结(3篇)
第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. 文件系统的合理管理能够提高文件的存取效率，减少文件的碎片化，提高系统的整体性能。
(完整word版)Linux操作系统实验报告 存储管理试验
(3)实现FIFO页面淘汰算法。
(4)实现页故障率反馈模型。
2、实验目的与要求
①(1)用C语言是实现模拟Linux系统中连续内存分配用到的伙伴对算法。
(2)通过链表的形式输出在内存申请和释放过程中内存状态的对比图。
②(1)了解工作集模型的原理及其特点。
printmem();
}
int power(int x,int y){
int k=0,tmp=1;
for(;k<y;k++){
tmp=tmp*x;
}
return tmp;
}
int root(int x,int y){
int result=y,count=0;
while(result!=1){
result=result/x;
merge(tempId,merger);
}else {
return 0;
}
return 1;
}else {
second=second->next;
isFirst++;
}
}
return 1;
}
int freeb(int size){
block * first=(struct block *)malloc(sizeof(struct block));
if((second->start==nextStart || second->start==preStart) && second->loc==0){
merger->size=(first->size)+(second->size);
实验三 动态分区存储管理
实验三存储管理动态分区存储管理
实验目的
•熟悉并掌握动态分区分配的各种算法。
•熟悉并掌握动态分区中分区回收的各种情
况，并能够实现分区合并。
实验内容及要求
•用高级语言模拟实现动态分区存储管理，要求：
–分区分配算法至少实现首次适应算法、最佳适应算法和最坏适应算法中的至少一种。
熟悉并掌握各种算法的空闲区组织方式。
–分区的初始化——可以由用户输入初始分区的大小。
（初始化后只有一个空闲分区，起始地址为0，大小是用户输入的大小）–分区的动态分配过程：由用户输入作业号和作业的大小，实现分区过程。
–分区的回收：用户输入作业号，实现分区回收，同时，分区的合并要体现出来。
（注意：不存在的作业号要给出错误提示！）–分区的显示：任何时刻，可以查看当前内存的情况（起始地址是什么，大小多大的分区时空闲的，或者占用的，能够显示出来）
实验报告要求
•实验报告应包含但不限于以下内容：–设计图（结构图/流程图）和源代码;
–使用的编程语言和系统环境;
–结果截图;
–对结果截图的解释性说明。
注意事项
•三个动态分区分配算法可以使用一套程序，差别只在空闲分区链(表)的排序策略。
•至少完成一个分配算法。
•需完成回收算法。
计算机操作系统实验三 存储管理
南京信息工程大学实验（实习）报告实验（实习）名称存储管理实验（实习）日期 20131130 得分指导教师系计算机系专业计科年级 2011 班次 1 姓名汤建洋学号 201123080181. 实验目的本实验的目的是通过请求页式存储管理中页面置换算法模拟设计，了解虚拟存储技术的特点，掌握请求页式存储管理的页面置换算法，此外通过实验了解HASH表数据结构的使用。
2. 实验准备⑴数据结构HASH表查找方式。
⑵操作系统相关内存交换知识。
⑶阅读Linux系统的msg.c、sem.c和shm.c等源码文件，掌握几个LINUX函数getpid ( )、srand (int a)和int rand ( )的使用方法。
3. 实验内容设计一个虚拟存储区和内存工作区，并分别编程实现使用先进先出置换算法（FIFO）和最近最少使用页面置换算法（LRU）计算访问命中率。
4. 实验指导拥有页面交换机制的操作系统总是把当前进程中急需处理的部分页面换入到内存当中，而把更多暂时不需处理的页面放置在外存当中，由于进程需要处理页面的顺序不同，而需要在内存与外存之间进行页面交换，交换算法也就应运而生。
本实验并没有进入系统空间对实际进程页面进行控制，而是在用户空间用线性表的连续存储方式对进程页面交换进行的模拟。
⑴ FIFO算法实现<原理描述>在分配内存页面数（AP）小于进程页面数（PP）时，当然是最先的AP个页面放入内存；这时有需要处理新的页面，则将原理在内存中的AP个页面中最先进入的调出，然后放入新页面；以后如果有新页面需要调入，按（2）之规则进行。
算法特点：所使用的内存页面构成一个队列。
<算法实现提示>要得到“命中率”，必然应该有一个常量total_instruction记录页面总共使用次数；此外需要一个变量记录总共换入页面的次数（需要换出页面，总是因为没有命中而产生的）diseffect。
利用公式(1-diseffect/total_instructiong)×100%可以得到命中率。
计算机操作系统实验三存储器管理
计算机操作系统实验三存储器管理引言存储器管理是计算机操作系统中非常重要的一部分。
它负责管理计算机中的存储器资源，以便有效地分配和管理内存。
在操作系统的设计和实现中，存储器管理的性能和效率对整个系统的稳定性和性能有着重要的影响。
本文档将介绍计算机操作系统实验三中的存储器管理的实验内容及相关的知识点。
我们将从内存分区管理、页式存储管理和段式存储管理三个方面进行讨论。
内存分区管理内存分区管理是一种常见的存储器管理方法，旨在将物理内存分成若干个不同大小的区域，以便为不同的进程分配内存。
在实验三中，我们将学习和实现两种内存分区管理算法：首次适应算法和最佳适应算法。
首次适应算法是一种简单直观的算法，它从内存的起始位置开始查找第一个满足要求的空闲分区。
而最佳适应算法则是通过遍历整个内存空间，选择最合适的空闲分区来满足进程的内存需求。
通过实验，我们将学习如何实现这两种算法，并通过比较它们的性能和效果来深入理解内存分区管理的原理和实现。
页式存储管理页式存储管理是一种将物理内存分成固定大小的页框（page frame）和逻辑地址分成固定大小的页面（page）的管理方法。
在操作系统中，虚拟内存通过将进程的地址空间划分成大小相等的页面，并与物理内存中的页框相对应，实现了大容量的存储管理和地址空间共享。
在实验三中，我们将学习和实现页式存储管理的基本原理和算法。
我们将了解页表的结构和作用，以及如何通过页表将逻辑地址转换为物理地址。
此外，我们还将学习页面置换算法，用于处理内存不足时的页面置换问题。
段式存储管理段式存储管理是一种将逻辑地址分成不同大小的段并与物理内存中的段相对应的管理方法。
在操作系统的设计中，段式存储管理可以提供更灵活的地址空间管理和内存分配。
实验三将介绍段式存储管理的基本原理和实现方法。
我们将学习段表的结构和作用，以及如何通过段表将逻辑地址转换为物理地址。
同时，我们还将探讨段的分配和释放过程，并学习如何处理外部碎片的问题。
操作系统实验3虚拟存储器管理[1]
![操作系统实验3虚拟存储器管理[1]](https://img.taocdn.com/s3/m/77f86034e2bd960590c67728.png)
实验报告班级：系统本111 学号：2011415108 姓名：张国锋日期：2013.6.27⒈实验题目模拟分页式虚拟存储管理实验。
2．实验要求编写一段程序来模拟页面置换算法。
要求能分别显示最佳(Optimal)置换算法、先进先出(FIFO)页面置换算法和最近最久未使用(LRU)置换算法的置换过程。
3. 实验目的通过本实验帮助学生理解虚拟存储器的工作方法。
了解分页式存储管理里中各页面置换算法是怎样实现的，各算法有怎样的优缺点。
⒋实验原理分析⑴页面置换算法是在分页存储管理方式中为了合理的将进程运行所需的页面调入内存而产生的算法。
一个好的页面转换算法，应具有较低的页面更换频率。
最常见的页面置换算法有最佳(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 页面号串5.实验代码清单#include <stdio.h>#include <stdlib.h>#include <conio.h>#define Bsize 3#define Psize 20struct pageInfor{int content; /*页面号*/int timer; /*被访问标记*/};void PRA(); /*初始化*/int findSpace(); /*查找是否有空闲内存*/int findExist(int curpage);/*查找内存中是否有该页面*/int findReplace(); /*查找应予置换的页面*/void display(); /*显示*/void FIFO(); /*FIFO算法*/void LRU(); /*LRU算法*/void Optimal(); /*OPTIMAL算法*/void BlockClear(); /*BLOCK恢复*/struct pageInfor * block; /*物理块*/struct pageInfor * page; /*页面号串*/int QString[20];void PRA(){int i,n;printf("请输入页面号引用串:\n");for(i=0;i<20;i++){scanf("%d",&QString[i]);}printf("您输入页面号引用串为:\n");printf("==================\n");for(i=0;i<20;i++){printf("%d\t",QString[i]);}printf("==================\n");block=(struct pageInfor *)malloc(sizeof(struct pageInfor));for(i=0; i<Bsize; i++) {block[i].content = -1;block[i].timer = 0;}page = (struct pageInfor *)malloc(sizeof(struct pageInfor)*Psize); for(i=0; i<Psize; i++) {page[i].content = QString[i];page[i].timer = 0;}}int findSpace(){int i=0;for(i=0; i<Bsize; i++)if(block[i].content == -1)return i; /*找到空闲内存，返回BLOCK中位置*/ return -1;}int findExist(int curpage){int i=0;for(i=0; i<Bsize; i++)if(block[i].content == page[curpage].content)return i; /*找到内存中有该页面，返回BLOCK中位置*/ return -1;}int findReplace(){int pos = 0,i;for(i=0; i<Bsize; i++)if(block[i].timer >= block[pos].timer)pos = i; /*找到应予置换页面，返回BLOCK中位置*/ return pos;}void display(){int i=0;for(i=0; i<Bsize; i++)if(block[i].content != -1)printf("%d\t",block[i].content);printf("\n");}void Optimal(){int exist,space,position,i,k,j ;for(i=0; i<Psize; i++) {exist = findExist(i);if(exist != -1) {printf("不缺页\n");}else {space = findSpace();if(space != -1) {block[space] = page[i];display();}else {for(k=0; k<Bsize; k++)for(j=i; j<Psize; j++) {if(block[k].content != page[j].content) { block[k].timer = 1000;}else {block[k].timer = j;break;}}position = findReplace();block[position] = page[i];display();}}}getch();system("cls");}void LRU(){int exist,space,position,i,k,j ; for(i=0; i<Psize; i++) { exist = findExist(i);if(exist != -1) {printf("不缺页\n");block[exist].timer = -1; } else {space = findSpace();if(space != -1) {block[space] = page[i]; display();}else {position = findReplace(); block[position] = page[i]; display();}}for(j=0; j<Bsize; j++)block[j].timer++;}getch();system("cls");}void FIFO(){int exist,space,position,i,k,j ;for(i=0; i<Psize; i++) {exist = findExist(i);if(exist != -1) {printf("不缺页\n");}else {space = findSpace();if(space != -1) {block[space] = page[i];display();}else {position = findReplace();block[position] = page[i];display();}}for(j=0; j<Bsize; j++)block[j].timer++; /*BLOCK中所有页面TIMER++*/ }getch();system("cls");}void BlockClear() //清空页面信息{int i;for(i=0; i<Bsize; i++) {block[i].content = -1;block[i].timer = 0;}}void main(){PRA();system("color 2");int select=1;while(select) {printf("系统本111项静怡小组页面置换算法程序\n"); printf("请按以下菜单选择：\n");printf("[1]\tOptimal\t算法\n");printf("[2]\tFIFO\t算法\n");printf("[3]\tLRU\t算法\n");printf("[0]\t退出\n");scanf("%d",&select);switch(select) {case 0:break;case 1:printf("Optimal算法结果如下:\n");Optimal();break;case 2:printf("FIFO算法结果如下:\n");FIFO();break;case 3:printf("LRU算法结果如下:\n");LRU();break;default:printf("菜选项输入错误，请输入(1,2,3,0)\n");break;}BlockClear();}}6.实现①输入课本中例题数据，创建3个物理模块，页面引用串为7 0 1 2 0 3 0 4 2 3 0 3 2 12 0 1 7 0 1运行界面如图1所示图1 输入②用最佳置换算法，运行后如图2所示图2 Optinal算法③用FIFO先进先出算法运行后如图3所示图3 FIFO算法④用LRU最久未使用算法，运行后如图4所示图4 LRU算法。
实验3：存储管理
操作系统实验报告实验题目：存储管理专业计算机科学与技术学生姓名班级学号指导教师肖莹指导单位计算机学院日期一、实验目的1、理解操作系统存储管理原理操作系统的发展使得系统完成了大部分的内存管理工作。
对于程序员而言，这些内存管理的过程完全透明不可见。
因此，程序员开发时从不关心系统如何为自己分配内存，而且永远认为系统可以分配给程序所需要的内存。
在程序开发时，程序员真正需要做的就是：申请内存、使用内存、释放内存，其他一概无需过问。
2、在Linux下，用malloc（）函数实现cat或copy命令。
二、实验指导1、内存分配与管理的相关函数1）内存动态分配函数#include <malloc.h>void *malloc(size_t size)该函数分配指定大小size个字节的内存空间，成功时返回分配内存的指针（即所分配内存的地址）。
2） void free(void * addr);该函数释放由malloc()分配的内存，addr是要释放内存空间的起始地址，并且addr必须是被以前malloc( )调用返回的。
2、内存分配与回收参考程序——申请内存、使用内存以及释放一块内存#include <stdio.h>#include <string.h>#include<stdlib.h>#include <malloc.h>int main(void){char * str;if ((str=(char*)malloc(10))==NULL){printf("not enough memory to allocate buffer\\n");exit(1);}strcpy(str,"hello");printf("string is %s\\n",str);free(str);return 0;}（要求：1、以自己的学号命名C程序；2、能够输出内存空间无法分配的信息）三、实验步骤（附操作截图）四、运行结果及其结果分析（附结果截图）五、思考题1、为什么需要动态存储分配？。
操作系统实验-存储管理
操作系统实验-存储管理操作系统实验-存储管理1、引言1.1 概述在操作系统中，存储管理是一个关键的任务。
它负责将程序和数据加载到内存中，管理内存的分配和回收，并确保不同进程之间的内存互不干扰。
本实验旨在深入了解并实践存储管理的相关概念和算法。
1.2 目的本实验的目的是让学生通过实际操作，了解存储管理的基本原理和常用算法，包括分页、分段和虚拟内存等。
通过实验，学生将学会如何实现内存分配和回收，以及处理内存碎片等问题。
1.3 实验环境- 操作系统：Windows、Linux、MacOS等- 编程语言：C、C++等2、实验步骤2.1 实验准备- 安装相应的开发环境和工具- 创建一个空白的项目文件夹，用于存放实验代码和相关文件2.2 实验一、分页存储管理- 理解分页存储管理的概念和原理- 实现一个简单的分页存储管理系统- 设计测试用例，验证分页存储管理的正确性和有效性2.3 实验二、分段存储管理- 理解分段存储管理的概念和原理- 实现一个简单的分段存储管理系统- 设计测试用例，验证分段存储管理的正确性和有效性2.4 实验三、虚拟存储管理- 理解虚拟存储管理的概念和原理- 实现一个简单的虚拟存储管理系统- 设计测试用例，验证虚拟存储管理的正确性和有效性3、实验结果分析3.1 分页存储管理结果分析- 分析分页存储管理系统的性能优缺点- 比较不同页面大小对系统性能的影响3.2 分段存储管理结果分析- 分析分段存储管理系统的性能优缺点- 比较不同段大小对系统性能的影响3.3 虚拟存储管理结果分析- 分析虚拟存储管理系统的性能优缺点- 比较不同页面置换算法对系统性能的影响4、总结与展望4.1 实验总结- 总结本次实验的收获和体会- 分析实验中遇到的问题和解决方法4.2 实验展望- 探讨存储管理领域的未来发展方向- 提出对本实验的改进意见和建议附件：无法律名词及注释：- 存储管理：操作系统中负责管理内存的任务，包括内存分配、回收和管理等功能。
实验三 存储器管理实验
实验三存储器管理实验◆实验名称：存储器管理实验◆仪器、设备：计算机◆参考资料：操作系统实验指导书◆实验目的：设计一个请求页式存储管理方案，并编写模拟程序实现。
◆实验内容：编写程序用来模拟虚拟页式存储管理中的页面置换要求：1.快表页面固定为4块2.从键盘输入N个页面号3.输出每次物理块中的页面号和缺页次数，缺页率◆实验原理、数据（程序）记录：#define PAGES 4 /* 物理块数*/#define N 16 /*最多输入的页面号*/int pages[PAGES][2]; /*page[i][0]保存页面号，page[i][1]保存页面存留时间*/int queue[N]; /*页面号数组*/void initialise(void) /*------------初始化：快表和页面号数组++++++++++++++*/ {int i;for(i=0;i<N;i++)queue[i]=-1;for(i=0;i<PAGES;i++){pages[i][0]=-1;pages[i][1]=0;}}int is_page_exist(int page) /*若还有空页，返回空页序号的相反数-1若存在，返回该页的序号若不存在，返回需要替换页面序号的相反数-1*/{int max;int replace;int i=0;max=pages[0][1];replace=0;for(;i<PAGES;i++)pages[i][1]++;i=0;while(i<PAGES&&pages[i][0]!=-1&&pages[i][0]!=page){if(max<pages[i][1]){max=pages[i][1];replace=i;}i++;}if(i==PAGES)return (0-replace-1);else if(pages[i][0]==page)return i;elsereturn (0-i-1);}int input_pages(void) /**************输入页面号*****************/ {int i=0;int num;printf("请输入1～16个页面：【输入0 结束】\n");scanf("%d",&num);while(num&&i<N){if(num>0&&num<=N){queue[i]=num;i++;scanf("%d",&num);}elseprintf("输入错误数据～！\n");}return i;}void display_pages(void) /* 输出物理块中的页面号*/{int i=0;for(;i<PAGES;i++)if (pages[i][0]!= -1) printf("%5d ",pages[i][0]);printf("\n");}void LRU(int * lack_page) /* 核心算法，LRU算法*/{int i=0;int temp;* lack_page=0;while(queue[i]!=-1){temp=is_page_exist(queue[i]);if(temp>-1) /*若已经存在，修改相应序号的属性值*/pages[temp][1]=1;else /*若不存在，修改返回序号的内容，并修改属性值*/ {(* lack_page)++;pages[0-temp-1][0]=queue[i];pages[0-temp-1][1]=1;}printf("第%2d个页面访问时物理块中的页面号：",i+1);display_pages();i++;}}int main(void){int lack=0;float totle_page=0;initialise();totle_page=(float)input_pages();LRU(&lack);printf("缺页数为：%d\n",lack);printf("缺页率为：%0.3f\n",lack/totle_page);}◆实验结果及分析输入数据：1 2 4 3 1 4 5 6输出结果：第1个页面访问时物理块中的页面号：1第2个页面访问时物理块中的页面号：1 2第3个页面访问时物理块中的页面号：1 2 4第4个页面访问时物理块中的页面号：1 2 4 3第5个页面访问时物理块中的页面号：1 2 4 3第6个页面访问时物理块中的页面号：1 2 4 3第7个页面访问时物理块中的页面号：1 5 4 3第8个页面访问时物理块中的页面号：1 5 4 6缺页次数：6缺页率：0.750通过实验，实现了利用LRU算法进行虚拟存储管理的模拟。
实验三 存储管理实验
实验三存储管理实验一. 目的要求：1、通过编写和调试存储管理的模拟程序以加深对存储管理方案的理解。
熟悉虚存管理的各种页面淘汰算法。
2、通过编写和调试地址转换过程的模拟程序以加强对地址转换过程的了解。
二 . 例题设计一个请求页式存储管理方案。
并编写模拟程序实现之。
产生一个需要访问的指令地址流。
它是一系列需要访问的指令的地址。
为不失一般性，你可以适当地（用人工指定地方法或用随机数产生器）生成这个序列，使得 50％的指令是顺序执行的。
25％的指令均匀地散布在前地址部分，25％的地址是均匀地散布在后地址部分。
为简单起见。
页面淘汰算法采用 FIFO页面淘汰算法，并且在淘汰一页时，只将该页在页表中抹去。
而不再判断它是否被改写过，也不将它写回到辅存。
具体的做法可以是：产生一个需要访问的指令地址流；指令合适的页面尺寸（例如以 1K或2K为1页）；指定内存页表的最大长度，并对页表进行初始化；每访问一个地址时，首先要计算该地址所在的页的页号，然后查页表，判断该页是否在主存——如果该页已在主存，则打印页表情况；如果该页不在主存且页表未满，则调入一页并打印页表情况；如果该页不足主存且页表已满，则按FIFO页面淘汰算法淘汰一页后调入所需的页，打印页表情况；逐个地址访问，直到所有地址访问完毕。
存储管理算法的流程图如下：三 . 实验题：1、设计一个固定式分区分配的存储管理方案，并模拟实现分区的分配和回收过程。
可以假定每个作业都是批处理作业，并且不允许动态申请内存。
为实现分区的分配和回收，可以设定一个分区说明表，按照表中的有关信息进行分配，并根据分区的分配和回收情况修改该表。
#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{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;int n=0;for(i=0; i<NUM; i++){PARTITAB p=parTab[i];if(p.state=='N' && p.size>size) {parTab[i].state='Y';n=1;break;}}if (n==0){printf("内存大小是%d\t",size); printf("无法分配内存！\n");}else{printf("内存大小是%d\t",size); printf("装入内存成功！\n");}}void createTab(){parTab[0].no=0;parTab[0].size=12;parTab[0].firstAddr=20;parTab[0].state='N';parTab[1].no=1;parTab[1].size=32;parTab[1].firstAddr=32;parTab[1].state='N';parTab[2].no=2;parTab[2].size=64;parTab[2].firstAddr=64;parTab[2].state='N';parTab[3].no=3;parTab[3].size=128;parTab[3].firstAddr=128;parTab[3].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;int k=1+rand()%100;printf("****固定式分区分配存储管理******\n"); createTab();checkTab();printf("请按任意键继续：\n");getchar();printf("一次装入多个作业：\n");for(i=0; i<NUM; i++){AllocateMemory(k);k=1+rand()%100;}checkTab();printf("请按任意键继续：\n");getchar();printf("若继续装入作业\n");k=1+rand()%100;AllocateMemory(k);checkTab();printf("请按任意键继续：\n"); getchar();printf("若有一个作业完成\n"); k=rand()%4;recycleMemory(2);checkTab();printf("继续装入作业\n");k=1+rand()%100;AllocateMemory(k);checkTab();return 0;}截图显示为：2、设计一个可变式分区分配的存储管理方案。
《操作系统》实验三 存储管理
①先进先出算法（FIFO）；
②最近最少使用算法（LRU）；
③最佳淘汰算法（OPT）；先淘汰最不常用的页地址； ④最少访问页面算法（LFU）。
命中率的算、数据结构
int vmsize /*虚存容量，为32k*/
三、实验内容
1、问题描述
⑴通过随机数产生一个指令序列，共320条指令。指令的地址按下述原则生成：
①一半的指令是顺序执行的；
②四分之一的指令是均匀分布在前地址部分；
③四分之一的指令是均匀分布在后地址部分。
具体的实施办法是：
①在[0，319]之间选一起点m；
②顺序执行一条指令，即m+1条；
③向前地址[0，m—1]中执行一条指令m′；
（3）算法总体框图（见后图3.1）
（4）FIFO算法与LRU算法框图
④顺序执行一条指令，即m′+1条；
⑤向后地址（m′+2，319）执行一条指令m’’
⑵将指令序列变换成为页地址流。
假设：
①页面大小为1KB；
②用户实存容量为4页到32页；
③用户虚存容量为32KB。
用户虚存容量32KB，每1KB中放10条指令，共320条指令（0∽319）。其中0∽9为0页，10∽19为1页…310∽319为31页。
实验三存贮器管理
一、实验目的
本课题实习的目的用高级语言编写一个程序，模拟实现分页式虚拟存储管理，并对几种常用的页面调度算法（、LRU、FIFO OPT等）进行分析比较，评测其性能优劣，从而加深对虚拟存储管理以及各种调度算法的了解。
二、实验要求
采用一些常用的存贮器分配算法,设计一个存贮器管理模拟系统并调试运行。模拟环境应尽量接近真实。
操作系统实验三存储管理
实验三存储管理一、实验目的通过实验了解Windows 2000内存的使用，学习如何在应用程序中管理内存，体会Windows应用程序内存的简单性和自我防护能力。
学习检查虚拟内存空间或对其进行操作；了解Windows 2000的内存结构和虚拟内存的管理，进而了解进程堆和Windows为使用内存而提供的一些扩展功能。
二、实验环境硬件环境：计算机一台，局域网环境；软件环境：Windows 2000 Professional，Visual C++ 6.0专业版或企业版。
三、实验内容和步骤在Windows 2000环境下，4GB的虚拟地址空间被划分成两个部分：低端2GB提供给进程使用，高端2GB提供给系统使用。
这意味着用户的应用程序代码，包括DLL以及进程使用的各种数据等，都装在用户进程地址空间内(低端2GB) 。
1.虚拟内存的检测程序参见实验指导书程序中显示一个WalkVM() 函数开始于某个进程可访问的最低端虚拟地址处，并在其中显示各块虚拟内存的特性。
虚拟内存中的块由VirtualQueryEx() API定义成连续快或具有相同状态(自由区、已调配区等等) 的内存，并分配以一组统一的保护标志(只读、可执行等等) 。
分析运行结果按committed、reserved、free等三种虚拟地址空间分别记录实验数据。
其中“描述”是指对该组数据的简单描述，例如，对下列一组数据：00010000 – 00012000 <8.00KB> Committed, READWRITE, Private可描述为：具有READWRITE权限的已调配私有内存区。
将系统当前的自由区(free) 虚拟地址空间填入表中。
将系统当前的保留区(reserved) 虚拟地址空间填入表5-8中。
2) 从上述输出结果，对照分析程序，请简单描述程序运行的流程：__运行已调配区，运行自由区，运行保留区_______2. 虚拟内存操作示例程序显示了如何分配一个大容量空间，将物理存储委托给其中的很小一部分(千分之一) 并加以使用。
操作系统实验报告三存储器管理实验
操作系统实验报告三存储器管理实验操作系统实验报告三：存储器管理实验一、实验目的本次存储器管理实验的主要目的是深入理解操作系统中存储器管理的基本原理和方法，通过实际操作和观察，掌握内存分配与回收的算法，以及页面置换算法的工作过程和性能特点，从而提高对操作系统资源管理的认识和实践能力。
二、实验环境本次实验使用的操作系统为 Windows 10，编程语言为 C+＋，开发工具为 Visual Studio 2019。
三、实验内容1、内存分配与回收算法实现首次适应算法（First Fit）最佳适应算法（Best Fit）最坏适应算法（Worst Fit）2、页面置换算法模拟先进先出页面置换算法（FIFO）最近最久未使用页面置换算法（LRU）时钟页面置换算法（Clock）四、实验原理1、内存分配与回收算法首次适应算法：从内存的起始位置开始，依次查找空闲分区，将第一个能够满足需求的空闲分区分配给进程。
最佳适应算法：在所有空闲分区中，选择能够满足需求且大小最小的空闲分区进行分配。
最坏适应算法：选择空闲分区中最大的分区进行分配。
2、页面置换算法先进先出页面置换算法：选择最早进入内存的页面进行置换。
最近最久未使用页面置换算法：选择最近最长时间未被访问的页面进行置换。
时钟页面置换算法：给每个页面设置一个访问位，在页面置换时，从指针指向的页面开始扫描，选择第一个访问位为0 的页面进行置换。
五、实验步骤1、内存分配与回收算法实现定义内存分区结构体，包括分区起始地址、大小、是否已分配等信息。
实现首次适应算法、最佳适应算法和最坏适应算法的函数。
编写测试程序，创建多个进程，并使用不同的算法为其分配内存，观察内存分配情况和空闲分区的变化。
2、页面置换算法模拟定义页面结构体，包括页面号、访问位等信息。
实现先进先出页面置换算法、最近最久未使用页面置换算法和时钟页面置换算法的函数。
编写测试程序，模拟页面的调入和调出过程，计算不同算法下的缺页率，比较算法的性能。
实验3(存储管理)
实验3〔存储管理〕《操作系统》实验实验3 存储管理实验3 存储管理一、目的与要求1. 目的提高内存管理的效率始终是操作系统研究的重要课题之一，虚拟存储技术是用来提高存储容量的一种重要方法，所以，本项实验的目的是让学生独立地设计几个常用的存储分配算法，并用高级语言编写程序对各种算法进行分析比拟，评测其性能的优劣，从而加深对这些算法的了解。
2. 要求本实验要求学生用C语言独立编写分区分配算法、回收算法、请求式分页分配算法。
在请求式分页分配算法中，通过程序的执行结果来分析计算不同页面淘汰算法情况下的访问命中率，并以此来比拟各种算法的优劣，同时，还要求分析改变页面大小和实际存储容量对计算结果的影响，为选择好的算法，适宜的页面尺寸和实存容量提供依据。
本次实验的上机时间为2～4学时。
二、实验内容1. 分区分配算法本实验要求采用首次适应算法和最正确适应算法两种分区分配的内存管理算法。
(1) 建立分区描述器：分区描述器可根据自己编写程序的需要来建立，描述器本身所包含的内容以描述清楚内存分区情况为准。
(2) 建立自由主存队列：针对两种不同的放置策略〔首次适应和最正确适应〕来建立相应的队列结构。
(3) 用C语言编写实现首次适应算法和最正确适应算法的程序。
(4) 用C语言编写回收算法。
2. 请求式分页存储管理算法本实验要求采用请求式分页存储算法，淘汰算法采用先进先出算法FIFO和最近最少使用页面淘汰算法〔LRU〕。
设逻辑空间大小为128K，页面尺寸分别为2、4、6、8、10、12、14、16K，内存容量为8至64页。
(1) 先进先出算法FIFO：该算法的实质是选择作业中在主存驻留时间最长的一页淘汰，这种算法容易实现，例如分配一个作业的存储块数为m，那么只需建立一张m个元素的队列表Q(0)、Q(1)、…、Q(m-1)和一个替换指针。
这个队列是按页调入主存的一页。
如图4-1所示，某时刻调入主存四个块，〔即m=4〕，它们按页进入主存的先后顺序为4、5、1、2，当需要置换时，总是淘汰替换指针所指向的那一页。
实验三 存储管理指导
实验三存储管理实验目的1) 加深对存储管理的理解；2) 掌握几种页面置换算法；3) 通过实验比较各种置换算法的优劣。
实验要求1) 编写程序完成实验内容；2) 对测试数据进行分析；3) 撰写实验报告。
实验内容1) 定义为进程分配的物理块数；2）定义进程运行所需访问的页面号；3）定义页的结构；4）模拟两种页面置换算法；5）计算页面置换算法的命中率；6）比较两种算法的优劣。
实验原理1.虚拟存储基于局部性原理，应用程序在运行之前，没有必要全部装入内存，仅须将那些当前要运行的少数页面或段先装入内存便可运行，其余部分暂留在盘上。
程序在运行时，如果它所要访问的页(段)已调入内存，便可继续执行下去；但如果程序所要访问的页(段)尚未调入内存(称为缺页或缺段)，此时程序应利用OS所提供的请求调页(段)功能，将它们调入内存，以使进程能继续执行下去。
如果此时内存已满，无法再装入新的页(段)，则还须再利用页(段)的置换功能，将内存中暂时不用的页(段)调至盘上，腾出足够的内存空间后，再将要访问的页(段)调入内存，使程序继续执行下去。
2.页面置换算法1）最佳(Optimal)置换算法最佳置换算法是由Belady于1966年提出的一种理论上的算法。
其所选择的被淘汰页面，将是以后永不使用的，或许是在最长(未来)时间内不再被访问的页面。
采用最佳置换算法，通常可保证获得最低的缺页率。
但由于人们目前还无法预知一个进程在内存的若干个页面中，哪一个页面是未来最长时间内不再被访问的，因而该算法是无法实现的，但可以利用该算法去评价其它算法。
2）先进先出(FIFO)页面置换算法这是最早出现的置换算法。
该算法总是淘汰最先进入内存的页面，即选择在内存中驻留时间最久的页面予以淘汰。
该算法实现简单，只需把一个进程已调入内存的页面，按先后次序链接成一个队列，并设置一个指针，称为替换指针，使它总是指向最老的页面。
但该算法与进程实际运行的规律不相适应，因为在进程中，有些页面经常被访问，比如，含有全局变量、常用函数、例程等的页面，FIFO算法并不能保证这些页面不被淘汰。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验三存储管理
1．实验目的
存储管理的主要功能之一是合理地分配空间。
请求页式管理是一种常用的虚拟存储管理技术。
本实验的目的是通过请求页式存储管理中页面置换算法模拟设计，了解虚拟存储技术的特点，掌握请求页式存储管理的页面置换算法。
2．实验内容
(1) 通过随机数产生一个指令序列，共320条指令。
指令的地址按下述原则生成：
a) 50% 的指令是顺序执行的；
b) 25% 的指令是均匀分布在前地址部分；
c) 25% 的指令是均匀分布在后地址部分；
具体的实施方法是：
a) 在[0，319]的指令地址之间随机选取一起点m；
b) 顺序执行一条指令，即执行地址为m+1的指令；
c) 在前地址[0，m+1]中随机选取一条指令并执行，该指令的地址为m';
d) 顺序执行一条指令，其地址为m'+1;
e) 在后地址[m'+2，319]中随机选取一条指令并执行;
f) 重复上述步骤a)~f)，直到执行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) 先进先出的算法（FIFO）；
b) 最近最少使用算法（LRU）；
c) 最佳淘汰算法（OPT）；
命中率=1-页面失效次数/页地址流长度
在本实验中，页地址流长度为320，页面失效次数为每次访问相应指令时，该指令所对应的页不在内存的次数。
3．随机数产生办法
关于随机数产生办法，可以采用操作系统提供的函数，如Linux或UNIX系统提供函数srand()和rand()，分别进行初始化和产生随机数。
例如：
srand();
语句可以初始化一个随机数；
a[0]=10*rand()/32767*319+1;
a[1]=10*rand()/32767*a[0];
…
语句可以用来产生a[0]与a[1]中的随机数。