存储器管理实验报告.docx
存储器管理实验实验报告
存储器管理实验实验报告一、实验目的存储器管理是操作系统的重要组成部分，本次实验的目的在于深入理解存储器管理的基本原理和方法，通过实际操作和观察，掌握存储器分配与回收的算法，以及页面置换算法的实现和性能评估。
二、实验环境本次实验使用的操作系统为 Windows 10，编程语言为 C+＋，开发工具为 Visual Studio 2019。
三、实验内容与步骤（一）存储器分配与回收算法实现1、首次适应算法（1）原理：从空闲分区链的首地址开始查找，找到第一个满足需求的空闲分区进行分配。
（2）实现步骤：建立空闲分区链表，每个节点包含分区的起始地址、大小和状态（已分配或空闲）。
当有分配请求时，从链表头部开始遍历，找到第一个大小满足需求的空闲分区。
将该分区进行分割，一部分分配给请求，剩余部分仍作为空闲分区留在链表中。
若找不到满足需求的空闲分区，则返回分配失败。
2、最佳适应算法（1）原理：从空闲分区链中选择与需求大小最接近的空闲分区进行分配。
（2）实现步骤：建立空闲分区链表，每个节点包含分区的起始地址、大小和状态。
当有分配请求时，遍历整个链表，计算每个空闲分区与需求大小的差值。
选择差值最小的空闲分区进行分配，若有多个差值相同且最小的分区，选择其中起始地址最小的分区。
对选中的分区进行分割和处理，与首次适应算法类似。
3、最坏适应算法（1）原理：选择空闲分区链中最大的空闲分区进行分配。
（2）实现步骤：建立空闲分区链表，每个节点包含分区的起始地址、大小和状态。
当有分配请求时，遍历链表，找到最大的空闲分区。
对该分区进行分配和处理。
（二）页面置换算法实现1、先进先出（FIFO）页面置换算法（1）原理：选择在内存中驻留时间最久的页面进行置换。
（2）实现步骤：建立页面访问序列。
为每个页面设置一个进入内存的时间戳。
当发生缺页中断时，选择时间戳最早的页面进行置换。
2、最近最久未使用（LRU）页面置换算法（1）原理：选择最近一段时间内最长时间未被访问的页面进行置换。
操作系统存储器管理实验报告.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;});四测试数据与实验结果五结果分析与实验体会通过上机，我了解了许多关于操作系统的专业知识。
存储器管理实验报告
操作系统实验报告存储器管理学院电信学院专业计算机科学与技术班级14级计科一班实验题目动态分区分配实验组别第三组指导老师曹华了解动态分区分配方式中使用的数据结构和分配算法，并进一步加深对动态分区存储管理方式及其实现过程的理解。
二、实验内容用Ｃ语言分别实现采用首次适应算法和最佳适应算法的动态分区分配过程 alloc() 和回收过程 free()。
其中，空闲分区通过分区链来管理，在进行内存分配时，系统优先使用空闲区低端的空间。
请分别用首次适应算法和最佳适应算法进行内存块的分配和回收，要求每次分配和回收后显示出空闲内存分区链的情况。
三、实验主要仪器设备软件环境：ＶＣ＋＋６编程环境四、实验原理及设计方案1.实验原理：可变分区调度算法有：最先适应分配算法，循环首次适应算法，最佳适应算法，最坏适应算法。
首次适应算法（First-fit）：当要分配内存空间时，就查表，在各空闲区中查找满足大小要求的可用块。
只要找到第一个足以满足要求的空闲块就停止查找，并把它分配出去；如果该空闲空间与所需空间大小一样，则从空闲表中取消该项；如果还有剩余，则余下的部分仍留在空闲表中，但应修改区分大小和分区始址。
用户提出内存空间的申请：系统根据申请者的要求，按照一定的分配策略分析内存空间的使用情况，找出能满足请求的空闲区，分给申请者；当程序执行完毕或主动归还内存资源时，系统要收回它所占用的内存空间或它归还的部分内存空间。
最佳适应算法（Best-fit）：当要分配内存空间时，就查找空闲表中满足要求的空闲块，并使得剩余块是最小的。
然后把它分配出去，若大小恰好合适，则直按分配；若有剩余块，则仍保留该余下的空闲分区，并修改分区大小的起始地址。
内存回收：将释放作业所在内存块的状态改为空闲状态，删除其作业名，设置为空，并判断该空闲块是否与其他空闲块相连，若释放的内存空间与空闲块相连时，则合并为同一个空闲块，同时修改分区大小及起始地址。
每当一个进程被创建时，内存分配程序首先要查找空闲内存分区链，从中寻找一个合适的空闲块进行划分，并修改空闲内存分区链，系统根据回收区的首址，从空闲区链中找到相应的插入点，此时出现如下四种情况：(１) 回收区与插入点的前一个空闲区Ｆ１相邻接，此时可将回收区直接与Ｆ１合并，并修改Ｆ１的大小；(２) 回收区与插入点的后一个空闲分区Ｆ２相邻接，此时可将回收区直接与Ｆ２合并，并用回收区的首址作为新空闲区的首址，大小为二者之和；(３) 回收区同时与插入点的前后两个空闲分区邻接，此时需将三者合并；(４) 回收区不与任何一个空闲区邻接，此时应建一新的表项2.主要数据结构的说明定义一个空闲区说明表结构struct freearea {int ID; //分区号long size;//分区大小long address;//分区地址int state; //状态}ElemType;线性表的双向链表存储结构Struct DuLNode//double linked list{ElemType data;struct DuLNode *prior; //前趋指针struct DuLNode *next; //后继指针｝DuLNode,*DuLinkList;算法；首次适应算法：是在分配内存时，从链首开始顺序查找，直到找到一个大小能够满足要求的分区，即进行分配。
存储器管理实验报告
存储器管理实验报告#include //首次适应算法#include#includeusing namespace std;typedef struct JOB{char JobName[10];int needTime;int needMemorrizes;int status;JOB *next;} JobProgram;JobProgram *head,*Program,*p;typedef struct memorrizesElement1{int memorrizes;}memorrizesElement;memorrizesElement element[3];void initMemorry(){for (int i = 0; i<3; i++)element[i].memorrizes = 5;}int searchAndJudge(JobProgram *JP){for (int i = 0; i<3; i++){if (element[i].memorrizes >= JP->needMemorrizes)return i;}return -1;}void intput(){Program = new JobProgram; cout<<"请输入作业名称: "; cin>>Program->JobName;cout<<"请输入作业需要时间: "; cin>>Program->needTime;cout<<"请输入作业需要内存数: "; cin>>Program->needMemorrizes; Program->status = -1;if (head == NULL){p = head;head = Program;p = Program;head->next = NULL;}else{p->next = Program;p = Program;p->next = NULL;}}void MoveMemorryManaging() {// JobProgram *q;JobProgram *ppp = head;JobProgram *pre;while (ppp!=NULL){int k = searchAndJudge(ppp);if (ppp->status ==-1){if (k!=-1){if (ppp->needMemorrizes <= 5){//element[k].flag = 1;element[k].memorrizes -= ppp->needMemorrizes;ppp->status = k;cout<<"作业正在运行: "<<endl;< p="">cout<<"作业名字: "<JobName<<endl<<"作业需要时间: "<needTime<<endl<<"作业状态: "<status<<endl;< p=""> ppp->needTime--;if (ppp->needTime==0){if (ppp == head){JobProgram *s = head;head = head->next;element[s->status].memorrizes += s->needMemorrizes;delete s;}else{JobProgram *s = ppp;pre->next = ppp->next;element[s->status].memorrizes += s->needMemorrizes;delete s;ppp = pre;}}}else{cout<<"你输入的内存需要大小超过了固定分区每个块的大小，无法装入运行"<<="">exit(1);}}else{cout<<"作业就绪: "<<endl;< p="">cout<<"作业名字: "<JobName<<endl<<"作业需要时间: "<needTime<<endl<<"作业状态: "<status<<endl;< p=""> }}else{cout<<"作业正在运行: "<<endl;< p="">cout<<"作业名字: "<JobName<<endl<<"作业需要时间: "<needTime<<endl<<"作业状态: "<status<<endl;< p=""> ppp->needTime--;if (ppp->needTime==0){if (ppp == head){JobProgram *s = head;head = head->next;element[s->status].memorrizes += s->needMemorrizes; delete s;}else{JobProgram *s = ppp;pre->next = ppp->next;element[s->status].memorrizes += s->needMemorrizes; delete s;ppp = pre;}}}pre = ppp;ppp = ppp->next;}}int main(){int n;cout<<"请输入要执行的作业的个数: ";cin >> n;initMemorry();for (int i = 0; i<="" p="">intput();while(head)MoveMemorryManaging();return 0;}</endl;<></endl<<"作业状态:></endl<<"作业需要时间:> </endl;<></endl;<></endl<<"作业状态:></endl<<"作业需要时间:> </endl;<></endl;<></endl<<"作业状态:></endl<<"作业需要时间:> </endl;<>。
存储器管理实验报告
存储器管理实验报告1. 实验目的本实验旨在通过实际操作，学习和理解存储器管理的基本概念和原理，并通过编写代码来实现常见的存储器管理算法。
2. 实验背景存储器管理是计算机系统中的重要组成部分，它负责管理和分配计算机的内存资源。
在计算机系统中，内存分为多个不同的区域，每个区域用于存储不同类型的数据。
存储器管理的主要任务是有效地管理和分配这些内存资源，以满足程序的需求，并保证系统的稳定性和高效性。
3. 实验步骤本实验共分为以下几个步骤：步骤一：了解存储器管理的基本概念在开始实验之前，我们首先需要了解存储器管理的基本概念。
包括内存分区、内存分配算法、内存回收算法等。
步骤二：设计实验代码根据实验要求，我们需要编写代码来实现常见的存储器管理算法。
可以选择使用C、C++等编程语言来实现。
步骤三：实验代码测试完成代码编写后，我们需要对代码进行测试，以验证其正确性和可行性。
可以编写一些测试样例来测试不同的存储器管理算法。
步骤四：实验结果分析根据实验的结果，我们可以对不同的存储器管理算法进行比较和分析，评估其优劣和适用性。
步骤五：实验总结在实验结束后，我们可以对实验过程和结果进行总结，总结实验中所学到的知识和经验，并提出改进的建议。
4. 实验总结通过本次实验，我深入了解了存储器管理的基本概念和原理，并通过编写代码实现了常见的存储器管理算法。
实验过程中，我遇到了一些问题，但通过查阅相关文献和资料，最终解决了这些问题。
通过实验，我不仅加深了对存储器管理的理解，还提高了编程能力和问题解决能力。
5. 改进建议在实验过程中，我发现代码实现的效率还有待提高，可以进一步优化算法的设计和实现。
此外，可以扩展实验内容，研究更多的存储器管理算法，并进行比较和分析。
参考文献•[1] 《操作系统教程》•[2] 《计算机体系结构》•[3] 《操作系统原理》。
实验五 存储管理(实验报告格式)
实验五：存储管理一、实验目的（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.了解存储管理的概念及作用；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.使用性能监控工具实时监测系统的性能指标，发现内存和磁盘的利用率较高，需要优化存储管理。
存储管理实验报告_6
昆明理工大学信息工程与自动化学院学生实验报告（2012 —2013 学年第二学期）一、实验目的存储管理的主要功能之一是合理地分配空间。
请求页式管理是一种常用的虚拟存储管理技术。
通过本次实验, 要求学生通过编写和调试地址转换过程的模拟程序以加强对地址转换过程的了解, 通过请求页式存储管理中页面置换算法模拟设计, 了解虚拟存储技术的特点, 掌握请求页式存储管理的页面置换算法。
二、实验原理及基本技术路线图（方框原理图）用C或C++语言模拟实现请求式分页管理。
要求实现: 页表的数据结构、分页式内存空间的分配及回收（建议采用位图法）、地址重定位、页面置换算法（从FIFO,LRU,NRU中任选一种）。
int subareaSize[num]={8,12,16,32,24,16,64,128,40,64};//分区大小Process *pro=NULL;//保持进程信息int ProcessNum=0;//进程数目int applyProcessNum=0;//每次申请进程数目int maxApplyNum=0;//最大可申请数目int *applyIndex=NULL;//申请进程队列int totalApplyNum=0;//申请总数int *assignPointer=NULL;//已分配内存的进程队列int assignFlag=0;//分配索引, 表示已申请队列已分配的进程数int exeIndex;//执行的进程号Node *subareaNode=new Node[3];//分区回收时, 进程所在分区及其前, 后分区信息LinkList createLinkList(int n );//建立空闲分区链Node firstFit(LinkList &head,Process pro);//首次适应算法Node nestFit(LinkList &head,Process pro,Node flag);//循环适应算法Node bestFit(LinkList &head,Process pro);//最佳适应算法Node worstFit(LinkList &head,Process pro);//最坏适应算法Node assign(LinkList &head,int orderIndex,int index,Node flagNode);//一次分区分配int assignMemory(LinkList &head);//内存分配void insertNode(LinkList &head,Node q,int index);//插入节点Node deleteNode(LinkList &head,int index);//删除节点int display(LinkList &head);//打印分区分配情况int lowAttemper(int *excursionPointer);//低级调度int findSubarea(LinkList &head,int index);//回收内存int creatProcess();//创建进程Process* randomCreatPro(int n);//随机产生进程下面是各种方法简述:(1) 最优替换算法, 即OPT算法。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
用Ｃ语言分别实现采用首次适应算法和最佳适应算法的动态分区分配过程alloc()和回收过程free()。其中，空闲分区通过分区链来管理，在进行内存分配时，系统优先使用空闲区低端的空间。
请分别用首次适应算法和最佳适应算法进行内存块的分配和回收，要求每次分配和回收后显示出空闲内存分区链的情况。
{
ElemType data;
struct DuLNode *prior; //前趋指针
struct DuLNode *next; //后继指针
｝DuLNode,*DuLinkList;
算法；
首次适应算法：是在分配内存时，从链首开始顺序查找，直到找到一个大小能够满足要求的分区，即进行分配。
最佳适应算法：是在分配内存时，从链首开始顺序查表，查找到链尾，并记录一个大小不小于要求的分区的最小分区，在查找完毕后进行分配。
{
return (*(struct kongxian *)a).start-(*(struct kongxian *)b).start;
}
int cmp2(const void *a,const void *b)
{
return (*(struct zuoye *)a).start-(*(struct zuoye *)b).start;
操作系统实验报告
存储器管理
学院电信学院
专业计算机科学与技术
班级14级计科一班
实验题目动态分区分配
实验组别第三组
指导老师曹华
学号
20141030111
20141030112
20141030113
20141030114
姓名
张 丹
陈云云
张伟军
李瑞玲
实验项目
二
题 目
动态分区分配
一、实验目的
了解动态分区分配方式中使用的数据结构和分配算法，并进一步加深对动态分区存储管理方式及其实现过程的理解。
(1)回收区与插入点的前一个空闲区Ｆ１相邻接，此时可将回收区直接与Ｆ１合并，并修改Ｆ１的大小；
(2)回收区与插入点的后一个空闲分区Ｆ２相邻接，此时可将回收区直接与Ｆ２合并，并用回收区的首址作为新空闲区的首址，大小为二者之和；
(3)回收区同时与插入点的前后两个空闲分区邻接，此时需将三者合并；
(4)回收区不与任何一个空闲区邻接，此时应建一新的表项
printf("空闲分区ID:%d起止:%d结束:%d长度:%d\n",i,kongxian[i].start,kongxian[i].end,kongxian[i].length);
}
void print2() //打印作业分区
{
int i;
for(i=0;i<n2;i++)
printf("作业分区ID：%d起止:%d结束:%d长度:%d\n",i,zuoye[i].start,zuoye[i].end,zuoye[i].length);
内存回收：将释放作业所在内存块的状态改为空闲状态，删除其作业名，设置为空，并判断该空闲块是否与其他空闲块相连，若释放的内存空间与空闲块相连时，则合并为同一个空闲块，同时修改分区大小及起始地址。
每当一个进程被创建时，内存分配程序首先要查找空闲内存分区链，从中寻找一个合适的空闲块进行划分，并修改空闲内存分区链，系统根据回收区的首址，从空闲区链中找到相应的插入点，此时出现如下四种情况：
三、实验要仪器设备
软件环境：ＶＣ＋＋６编程环境
四、实验原理及设计方案
1.实验原理：
可变分区调度算法有：最先适应分配算法，循环首次适应算法，最佳适应算法，最坏适应算法。
首次适应算法（First-fit）：当要分配内存空间时，就查表，在各空闲区中查找满足大小要求的可用块。只要找到第一个足以满足要求的空闲块就停止查找，并把它分配出去；如果该空闲空间与所需空间大小一样，则从空闲表中取消该项；如果还有剩余，则余下的部分仍留在空闲表中，但应修改区分大小和分区始址。
struct kongxian
{
int start; //起址
int end; //结束
int length; //长度
}kongxian[N];
struct zuoye
{
int start; //起址
int end; //结束
int length; //长度
}zuoye[N];
int cmp1(const void *a,const void *b)
2.主要数据结构的说明
定义一个空闲区说明表结构
struct freearea {
int ID; //分区号
long size; //分区大小
long address; //分区地址
int state; //状态
}ElemType;
线性表的双向链表存储结构
Struct DuLNode//double linked list
}
void init()
{
n1=1; //初始时只有一个空闲区
n2=0; //初始没有作业
kongxian[0].start=0;
kongxian[0].end=1023;
kongxian[0].length=1024;
}
void print1() //打印空闲分区
{
int i;
for(i=0;i<n1;i++)
3.程序流程图
首次适应算法
最佳适应算法
F
T
TF
4.实验程序
首次适应算法
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<math.h>
#define N 10000
int n1;//空闲分区的个数
int n2;//作业区的个数
}
int main()
{
int i,j,t,len,flag,id;
int front,middle, behind;
int t1,t2;
init();
print1();
printf("输入1装入新作业，输入0回收作业，输入-1结束\n");
用户提出内存空间的申请：系统根据申请者的要求，按照一定的分配策略分析内存空间的使用情况，找出能满足请求的空闲区，分给申请者；当程序执行完毕或主动归还内存资源时，系统要收回它所占用的内存空间或它归还的部分内存空间。
最佳适应算法（Best-fit）：当要分配内存空间时，就查找空闲表中满足要求的空闲块，并使得剩余块是最小的。然后把它分配出去，若大小恰好合适，则直按分配；若有剩余块，则仍保留该余下的空闲分区，并修改分区大小的起始地址。