实验三 存储管理实验2014012622沈桂江
实验三存储管理实验
实验三存储管理实验 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、编写并调试一个段页式存储管理的地址转换的模拟程序。
存储管理实验报告
存储管理实验报告存储管理实验报告引言：存储管理是计算机系统中非常重要的一部分，它负责管理计算机系统中的存储资源，包括内存和外存。
合理的存储管理能够提高计算机系统的性能和效率，保证系统的稳定运行。
本次实验旨在通过实践操作，深入了解存储管理的原理和方法，并通过实验结果分析，探讨存储管理的优化策略。
一、实验目的本次实验的主要目的是通过实践操作，深入了解存储管理的原理和方法，并通过实验结果分析，探讨存储管理的优化策略。
具体目标如下：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 算法在减少页面置换次数方面更为出色。
六、实验总结本次实验通过实际操作，深入理解了存储管理的原理和技术，并探索了不同的存储管理策略对系统性能的影响。
实验三 动态分区存储管理
实验三存储管理动态分区存储管理
实验目的
•熟悉并掌握动态分区分配的各种算法。
•熟悉并掌握动态分区中分区回收的各种情
况，并能够实现分区合并。
实验内容及要求
•用高级语言模拟实现动态分区存储管理，要求：
–分区分配算法至少实现首次适应算法、最佳适应算法和最坏适应算法中的至少一种。
熟悉并掌握各种算法的空闲区组织方式。
–分区的初始化——可以由用户输入初始分区的大小。
（初始化后只有一个空闲分区，起始地址为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%可以得到命中率。
实验三 存储器管理
实验三 可变分区管理一、实验内容模拟主存储器空间的分配和回收。
二、实验目的一个好的计算机系统不仅要有一个足够容量的、存取速度高的、稳定可靠的主存储器，而且要能合理地分配和使用这些存储空间。
当用户提出申请存储器空间时，存储管理必须根据申请者的要求，按一定的策略分析主存空间的使用情况，找出足够的空闲区域分配给申请者。
当作业撤离或主动归还主存资源时，则存储管理要收回作业占用的主存空间或归还部分主存空间。
主存的分配和回收的实现虽与主存储器的管理方式有关的，通过本实验帮助学生理解在采用循环首次适应算法管理方式下应怎样实现主存空间的分配和回收。
三、实验题目在可变分区管理方式下采用循环首次适应算法实现主存分配和实现主存回收。
[提示]：（1）可变分区方式是按作业需要的主存空间大小来分割分区的。
当要装入一个作业时，根据作业需要的主存量查看是否有足够的空闲空间，若有，则按需要量分割一个分区分配给该作业；若无，则作业不能装入。
随着作业的装入、撤离，主存空间被分成许多个分区，有的分区被作业占用，而有的分区是空闲的。
例如：图1为了说明哪些区是空闲的，可以用来装入新作业，必须要有一张空闲区说明表，格式如下：第一栏 第二栏表1 其中，起址——指出一个空闲区的主存起始地址。
长度——指出从起始地址开始的一个连续空闲的长度。
状态——有两种状态，一种是“未分配”状态，指出对应的由起址指出的某个长度的区域是空闲区；另一种是“空表目”状态，表示表中对应的登记项目是空白（无效），可用来登记新的空闲区（例如，作业撤离后，它所占的区域就成了空闲区，应找一个“空表目”栏登记归还区的起址和长度且修改状态）。
由于分区的个数不定，所以空闲区说明表中应有适量的状态为“空表目”的登记栏目，否则造成表格“溢出”无法登记。
（2）上述的这张说明表的登记情况是按提示：a)表1是所装入的三个作业占用的主存区域后填写的。
b)当有一个新作业要求装入主存时，必须查空闲区说明表，从中找出一个足够大的空闲区。
计算机操作系统实验三存储器管理
计算机操作系统实验三存储器管理引言存储器管理是计算机操作系统中非常重要的一部分。
它负责管理计算机中的存储器资源，以便有效地分配和管理内存。
在操作系统的设计和实现中，存储器管理的性能和效率对整个系统的稳定性和性能有着重要的影响。
本文档将介绍计算机操作系统实验三中的存储器管理的实验内容及相关的知识点。
我们将从内存分区管理、页式存储管理和段式存储管理三个方面进行讨论。
内存分区管理内存分区管理是一种常见的存储器管理方法，旨在将物理内存分成若干个不同大小的区域，以便为不同的进程分配内存。
在实验三中，我们将学习和实现两种内存分区管理算法：首次适应算法和最佳适应算法。
首次适应算法是一种简单直观的算法，它从内存的起始位置开始查找第一个满足要求的空闲分区。
而最佳适应算法则是通过遍历整个内存空间，选择最合适的空闲分区来满足进程的内存需求。
通过实验，我们将学习如何实现这两种算法，并通过比较它们的性能和效果来深入理解内存分区管理的原理和实现。
页式存储管理页式存储管理是一种将物理内存分成固定大小的页框（page frame）和逻辑地址分成固定大小的页面（page）的管理方法。
在操作系统中，虚拟内存通过将进程的地址空间划分成大小相等的页面，并与物理内存中的页框相对应，实现了大容量的存储管理和地址空间共享。
在实验三中，我们将学习和实现页式存储管理的基本原理和算法。
我们将了解页表的结构和作用，以及如何通过页表将逻辑地址转换为物理地址。
此外，我们还将学习页面置换算法，用于处理内存不足时的页面置换问题。
段式存储管理段式存储管理是一种将逻辑地址分成不同大小的段并与物理内存中的段相对应的管理方法。
在操作系统的设计中，段式存储管理可以提供更灵活的地址空间管理和内存分配。
实验三将介绍段式存储管理的基本原理和实现方法。
我们将学习段表的结构和作用，以及如何通过段表将逻辑地址转换为物理地址。
同时，我们还将探讨段的分配和释放过程，并学习如何处理外部碎片的问题。
实验三 存储器管理实验
实验三存储器管理实验◆实验名称：存储器管理实验◆仪器、设备：计算机◆参考资料：操作系统实验指导书◆实验目的：设计一个请求页式存储管理方案，并编写模拟程序实现。
◆实验内容：编写程序用来模拟虚拟页式存储管理中的页面置换要求：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、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验三存储管理实验2014012622沈桂江西北农林科技大学信息工程学院实习报告课程计算机操作系统学院信息工程专业年级软件141 学号 2014012622 姓名沈桂江周次 10 交报告时间成绩实验三存储管理实验一. 目的要求:1、通过编写和调试存储管理的模拟程序以加深对存储管理方案的理解。
熟悉虚存管理的各种页面淘汰算法。
2、通过编写和调试地址转换过程的模拟程序以加强对地址转换过程的了解。
二( 实习内容:1、设计一个固定式分区分配的存储管理方案，并模拟实现分区的分配和回收过程。
可以假定每个作业都是批处理作业，并且不允许动态申请内存。
为实现分区的分配和回收，可以设定一个分区说明表，按照表中的有关信息进行分配，并根据分区的分配和回收情况修改该表。
2、设计一个可变式分区分配的存储管理方案。
并模拟实现分区的分配和回收过程。
对分区的管理法可以是下面三种算法之一:首次适应算法循环首次适应算法最佳适应算法3、编写并调试一个段页式存储管理的地址转换的模拟程序。
首先设计好段表、页表，然后给出若干个有一定代表性的地址，通过查找段表页表后得到转换的地址。
要求打印转换前的地址，相应的段表，页表条款及转换后的地址，以便检查。
三(实习任务及完成情况:1.设计存储算法流程图:图1-1图1-2 段表、页表和内存的关系 2.第一道题:设计一个固定式分区分配的存储管理方案，并模拟实现分区的分配和回收过程。
(1)编写程序源代码:#include <stdio.h>#define N 5struct freearea /*定义一个空闲区说明表结构,并初始化变量*/ {int startaddress;/*空闲区地址*/int size;/*空闲区大小*/int state;/*空闲区状态:0为空表目,1为可用空闲块*/ } freeblock[N]= {{20,20,1},{80,50,1},{150,100,1},{300,30,0},{600,100,1}};/*定义为作业分配主存空间的函数alloc()*/ int alloc(int applyarea)/*applyarea为作业申请量*/ {int i,tag=0;/*tag为检查是否有满足作业若需要的空闲区的标志*/for(i=0; i<N; i++) /*检查空闲区说明表是否有满足作业要求的空闲区*/ if(freeblock[i].state==1&&freeblock[i].size>applyarea){startaddress=freeblock[i].startaddress+applyarea; freeblock[i].freeblock[i].size=freeblock[i].size-applyarea;tag=1;/*有满足条件的空闲区时,tag置1*/return freeblock[i].startaddress-applyarea;}else if(freeblock[i].state==1&&freeblock[i].size==applyarea){freeblock[i].state=0;tag=1;/*有满足条件的空闲区时,tag置1*/return freeblock[i].startaddress;/*返回为作业分配的主存地址*/}if(tag==0)return -1;/*没有满足条件的空闲区,分配不成功,返回-1*/}/*定义主存回收函数:setfree()*//*tag1代表释放区的高地址是否邻接一个空闲区,tag2代表释放区的高低地址是否都邻接一个空闲区,tag3代表释放区的低地址是否邻接一个空闲区*/ void setfree(){int start,length,tag1=0,tag2=0,tag3=0,i,j;printf("输入空闲区的起始地址:\n");scanf("%d",&start);/*输入释放区的开始地址*/printf("输入空闲区的大小:\n");scanf("%d",&length);/*输入释放区的大小*/for(i=0; i<N; i++){if(freeblock[i].startaddress==start+1&&freeblock[i].state==1){length=1+freeblock[i].size;tag1=1;/*有与释放区的高地址邻接的空闲区,tag1置1*/for(j=0; j<N; j++)if(freeblock[j].startaddress+freeblock[j].size==start&&freeblock[j]. state==1){freeblock[i].state=0;freeblock[j].size=freeblock[j].size+1;tag2=1;/*有与释放区上下都邻接的空闲区,tag2置1*/break;}if(tag2==0)/*无与释放区高地址邻接的空闲区*/{freeblock[i].startaddress=start;freeblock[i].size=1;break;}}}if(tag1=0)/*无与释放区高地址邻接的空闲区,检查是否低地址有邻接空闲区*/{for(i=0; i<N; i++)if(freeblock[i].startaddress+freeblock[i].size==start&&freeblock[i]. state==1){freeblock[i].size=freeblock[i].size+1;tag3=1;/*有与释放区低地址邻接的空闲区,tag3置1*/break;}if(tag3==0)/*无与释放区高低地址邻接的空闲区*/for(j=0; j<N; j++)if(freeblock[j].state==0)/*找一个空白表,将释放区放入表中*/{freeblock[j].startaddress=start;freeblock[j].size=1;freeblock[j].state=1;break;}}}/*定义对空闲区表中的空闲区调整的函数adjust(),使空闲区按始地址从小到大排列,空表目放在后面*/void adjust(){int i,j;struct freearea middata;for(i=0; i<N; i++) /*将空闲区按始地址顺序在表中排列*/for(j=0; j<N; j++)if(freeblock[j].startaddress>freeblock[j+1].startaddress) {middata.startaddress=freeblock[j].startaddress; middata.size=freeblock[j].size;middata.state=freeblock[j].state;freeblock[j].startaddress=freeblock[j+1].startaddress; freeblock[j].size=freeblock[j+1].size;freeblock[j].state=freeblock[j+1].state;freeblock[j+1].startaddress=middata.startaddress; freeblock[j+1].size=middata.size;freeblock[j+1].state=middata.state;}for(i=0; i<N; i++) /*将空表目放在表后面*/for(j=0; j<N; j++)if(freeblock[j].state==0&&freeblock[j+1].state==1){middata.startaddress=freeblock[j].startaddress;middata.size=freeblock[j].size;middata.state=freeblock[j].state;freeblock[j].startaddress=freeblock[j+1].startaddress;freeblock[j].size=freeblock[j+1].size;freeblock[j].state=freeblock[j+1].state;freeblock[j+1].startaddress=middata.startaddress;freeblock[j+1].size=middata.size;freeblock[j+1].state=middata.state;}}/*定义打印空闲区说明表函数:print()*/void print(){int i;printf(" |................................................|\n");printf(" | start size state |\n");printf(" |................................................|\n");for(i=0; i<N; i++){printf(" | %3d %3d %5d|\n",freeblock[i].startaddress,freeblock[i].size,freeblock[i].state); printf("|................................................|\n"); }}void main()/*主函数*/{int applyarea,start,j;char end;printf("\n 有任何工作请求内存?y or n:");while((end=getchar())=='y'){printf("在这第一空闲内存:\n");adjust();/*对空闲区表中的空闲区调整的函数*/print();/*打印空闲区表的初始状态*/printf("输入请求内存的大小:");scanf("%d",&applyarea);/*输入作业的申请量*/start=alloc(applyarea);/*调用alloc()函数,为作业分配空间,start为返回的始地址*/adjust();printf("分配后，可用内存是:\n");print();/*打印空闲区表*/if(start==-1)/*alloc()分配不成功时,返回-1*/printf("没有合适的内存，请稍等\n");elseprintf("工作的内存起始地址: %d\n",start);printf("工作尺寸: %d\n",applyarea);printf("工作运行. \n");printf("任务终止.. \n");for(j=1; j<100000; j++); /*延迟时间*/setfree();/*主存回收函数*/adjust();/*调整空闲区说明表*/print();/*打印空闲区表函数*/printf("有任何工作在等待? y/n:");end=getchar();/*是否有作业等待? 有(Y)无(N)*/ }}(2)程序运行结果:图2-1 内存初始化操作图2-2 请求输入大小为90的内存图2-3 从空闲区为0的地址开始搜索符合的内存图2-4 请求输入大小为99的内存图2-5 从起始地址为20开始请求分配大小为8的内存图2-6 请求分配大小为100的内存，空间不足分配失败 2.第二道题:设计一个可变式分区分配的存储管理方案。