实验三 存储管理实验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]Windows Server 2003内存结构[2] Windows Server 2003虚拟内存二、 [1]实验目的1）通过实验了解windows Server 2003内存的使用，学习如何在应用程序中管理内存、体会Windows应用程序内存的简单性和自我防护能力。
2）了解windows Server 2003的内存结构和虚拟内存的管理，进而了解进程堆和windows为使用内存而提供的一些扩展功能。
三、 [1]实验内容四、 [1]实验步骤Windows提供了一个API即GetSystemInfo() ，以便用户能检查系统中虚拟内存的一些特性。
程序5-1显示了如何调用该函数以及显示系统中当前内存的参数。
步骤1：登录进入Windows Server 2003 。
步骤2：在“开始”菜单中单击“程序”-“Microsoft Visual Studio 6.0”–“Microsoft Visual C++ 6.0”命令，进入Visual C++窗口。
步骤3：在工具栏单击“打开”按钮，在“打开”对话框中找到并打开实验源程序。
程序5-1：获取有关系统的内存设置的信息步骤4：单击“Build”菜单中的“Compile ”命令，并单击“是”按钮确认。
系统对进行编译。
步骤5：编译完成后，单击“Build”菜单中的“Build ”命令，建立可执行文件。
操作能否正常进行如果不行，则可能的原因是什么答：操作能正常进行。
_____________________________________________________步骤6：在工具栏单击“Execute Program” (执行程序) 按钮，执行程序。
运行结果 (分行书写。
如果运行不成功，则可能的原因是什么) ：1) 虚拟内存每页容量为：2) 最小应用地址： 0x000100003) 最大应用地址为： 0x7ffeffff4) 当前可供应用程序使用的内存空间为：5) 当前计算机的实际内存大小为：阅读和分析程序5-1，请回答问题：1)理论上每个windows应用程序可以独占的最大存储空间是：____4GB____2)在程序5-1中，用于检索系统中虚拟内存特性的API函数是： DWORD 提示：可供应用程序使用的内存空间实际上已经减去了开头与结尾两个64KB的保护区。
《操作系统》实验三 存储管理
①先进先出算法（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. 虚拟内存操作示例程序显示了如何分配一个大容量空间，将物理存储委托给其中的很小一部分(千分之一) 并加以使用。
实验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，当需要置换时，总是淘汰替换指针所指向的那一页。
实验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、为什么需要动态存储分配？。
分区式存储管理实验报告
操作系统实验报告(四)分区式存储器管理专业：XXX姓名：XXX班级：XXX学号：XXX指导老师：XXX2013/12/3实验三：分区式存储器管理实验一．实验目的模拟实现一个简单的固定（或可变）分区存储管理系统，进一步加深对分区分配方案设计思想的理解。
二．实验内容（1）建立相关的数据结构，作业控制块、已分配分区及未分配分区；（2）实现一个分区分配算法，如最先适应分配算法、最优或最坏适应分配算法；（3）实现一个分区回收算法；（4）给定一批作业/进程，选择一个分配或回收算法，实现分区存储的模拟管理；（5）将整个过程可视化显示出来。
三．实验步骤(1)任务分析：1、本实验虽然不以前面实验为基础，但建议在其界面中继续增加分区存储管理功能。
2、数据结构：分区说明表，用数组实现。
3、存储管理：建议采取固定分区法管理内存。
编写内存分配、内存回收算法。
(2)程序设计：数据结构设计程序中自由链队列的结点类型可描述如下：structemptylist{intlen, address;//len为分区长度；address为分区起始地址structemptylist *next;//下一个节点};内存占用区用链表描述，其结点类型描述如下：structbusylink{char name;//进程名称intlen , address;//len为分区长度；address为分区起始地址structbusylink *next;//下一个节点};设全程量，设置一个自由链队列和一个占用区队列。
structemptylist *empty_head=NULL; //自由链队列(带头结点)队首指针structbusylink *busy_head=NULL//占用区队列队（带头结点）首指针structbusylink*busy_tail=NULL;// 占用区队列队尾指针(3)程序结果：分配几个内存后，显示其内部的分配进程如下：其中进程S是系统默认分配的进程，内存长度为5.回收过2,4以后显示如下：(4)调试与测试四．实验总结本次实验采用最佳适应算法来分配内存，然后分别输出未进行内存回收时和进行回收时，内存分配情况，进行对比。
实验三 存储管理指导
实验三存储管理实验目的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．掌握可变分区算法中空闲分区的合并方法二、实验内容与要求设计一个存储器管理模拟系统并调试运行。
要求采用一种常用的存储器分配算法(如：最佳适应算法、最坏适应算法）,设计一个存储器管理模拟系统。
允许进行多次的分配和释放，并可向用户反馈分配和释放情况及当前内存的情况；采用“命令菜单”选择和键盘命令输入的会话方式，根据输入请求调用分配模块，或回收模块，或内存查询模块，或最终退出系统。
三、实验参考下面是采用的是首次适应分配算法的一个示例。
根据指针freep查找自由链，当找到第一块可满足分配请求的空闲区时便分配之。
当某空闲区被分配后的剩余空闲区空间大于规定的碎片最小容量min时，则形成一个较小的空闲区留在自由链中。
回收时，根据MAT将指定分区链入自由链。
若该分区有前邻或后邻空闲分区，则将他们拼接成一块加大的空闲区。
当某个分配请求不能被满足，但此时系统中所有碎片总量满足分配请求的容量时，系统立即进入内存“紧凑”以消除碎片。
即将各作业占用区集中下移到用户内存区的下部（高地址部分），形成一片连接的作业区，而在用户内存区的上部形成一块较大的空闲区。
然后再进行分配。
本系统的主要程序模块包括：分配模块ffallocation，回收模块ffcolection，紧凑模块coalesce及命令处理模块menu。
Menu用以模拟系统的输入，采用“命令菜单”选择和键盘命令输入的会话方式，根据输入请求调用分配模块，或回收模块，或内存查询模块，或最终退出系统。
用到的数据结构如下：（1）自由链与区头。
内存空闲区采用自由链结构。
链首由freep指向，链中各个空闲区按地址递增次序排列。
初启时整个用户内存区为一个空闲区。
在每个空闲区首部设置一个区头（freearca）结构。
区头信息包括：size 空闲区大小（以字节计），包括区头所占空间；next 前向链指针，指向下一个空闲区；back 反向链指针，指向上一个空闲区；address 本空闲区首地址。
实验三 存储管理实验
实验三存储管理实验一. 目的要求：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、设计一个可变式分区分配的存储管理方案。
计算机操作系统储存管理实验报告
软件学院综合性、设计性实验报告专业：java 年级/班级：2012级2013—2014学年第一学期一、实验目的通过请求页式存储管理中页面置换算法模拟程序，了解虚拟存储技术的特点，掌握请求页式存储管理的页面置换算法。
二、实验仪器或设备实验机房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）命中率＝１－页面失效次数／页地址流长度本实验中，页地址流长度为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] ﹡1.0﹡rand( )/32767；a[j+3]＝a[j+2]+1m＝a[j+3]+(319-a[j+3]) ﹡1.0﹡rand( )/32767；}(2) 将指令序列变换成为页地址流for ( k＝0；k＜320；k++){ pt＝a[k]/10；pd= a[k]%10；…}(3) 计算不同算法的命中率rate＝1-1.0﹡U/320 ；其中U为缺页中断次数，320是页地址流长度。
- 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.第二道题:设计一个可变式分区分配的存储管理方案。