动态分区分配方式的模拟实验报告模板
实验四动态分区分配算法实验报告及程序
实验报告四动态分区分配算法班级学号姓名一、实验目的动态分区分配是根据进程的实际需要，动态地为之分配内存空间，而在分配时，须按照一定的分配算法，从空闲分区表或空闲分区链中选出一分区分配给该作业。
在本实验中运用了四种分配算法，分别是1.首次适应算法，2.循环首次适应算法，3.最坏适应算法4.最佳适应算法。
二、实验环境普通的计算机一台，编译环境Microsoft Visual C++ 6.0三、算法思想1．数据结构（1）分区开始地址startaddress（2）分区大小size（3）分区状态state2．功能介绍（1）首次适应算法在首次适应算法中，是从已建立好的数组中顺序查找，直至找到第一个大小能满足要求的空闲分区为止，然后再按照作业大小，从该分区中划出一块内存空间分配给请求者，余下的空间令开辟一块新的地址，大小为原来的大小减去作业大小，若查找结束都不能找到一个满足要求的分区，则此次内存分配失败。
（2）循环首次适应算法该算法是由首次适应算法演变而成，在为进程分配内存空间时，不再是每次都从第一个空间开始查找，而是从上次找到的空闲分区的下一个空闲分区开始查找，直至找到第一个能满足要求的空闲分区，从中划出一块与请求大小相等的内存空间分配给作业，为实现本算法，设置一个全局变量f，来控制循环查找，当f%N==0时，f=0；若查找结束都不能找到一个满足要求的分区，则此次内存分配失败。
（3）最坏适应算法最坏适应分配算法是每次为作业分配内存时，扫描整个数组，总是把能满足条件的，又是最大的空闲分区分配给作业。
（4）最佳适应算法最坏适应分配算法是每次为作业分配内存时，扫描整个数组，总是把能满足条件的，又是最小的空闲分区分配给作业。
四、源程序#include <stdio.h>#define L 10typedef struct LNode{int startaddress;int size;int state;}LNode;LNodeP[L]={{0,128,0},{200,256,0},{500,512,0},{1 500,1600,0},{5000,150,0}};int N=5; int f=0;void print(){ int i;printf("起始地址分区状态\n");for(i=0;i<N;i++)printf("%3d %8d %4d\n",P[i].startaddress, P[i].size,P[i].state);}void First(){ int i,l=0,m;printf("\n输入请求分配分区的大小：");scanf("%d",&m);for(i=0;i<N;i++){ if(P[i].size<m)continue;else if(P[i].size==m){ P[i].state=1;l=1;break; }else{P[N].startaddress=P[i].startaddress+m;P[N].size=P[i].size-m;P[i].size=m;P[i].state=1;l=1; N++;break; } }if(l==1||i<N){ printf("地址成功分配\n\n");printf("地址分配成功后的状态：\n");print(); }elseprintf("没有可以分配的地址空间\n"); } void CirFirst(){ int l=0,m,t=0;printf("\n输入请求分配分区的大小：");scanf("%d",&m);while(f<N){ if(P[f].size<m){ f=f+1;if(f%N==0){ f=0;t=1;}continue; }if(P[f].size==m && P[f].state!=1){ P[f].state=1;l=1; f++;break; }if(P[f].size>m && P[f].state!=1){ P[N].startaddress=P[f].startaddress+m;P[N].size=P[f].size-m;P[f].size=m;P[f].state=1;l=1; N++;f++; break; } }if(l==1){ printf("地址成功分配\n\n");printf("地址分配成功后的状态：\n");print(); }elseprintf("没有可以分配的地址空间\n"); } void Worst(){int i,t=0,l=0,m;int a[L];printf("\n输入请求分配分区的大小：");scanf("%d",&m);for(i=0;i<N;i++){ a[i]=0;if(P[i].size<m)continue;else if(P[i].size==m){ P[i].state=1;l=1; break; }elsea[i]=P[i].size-m; }if(l==0){ for(i=0;i<N;i++){ if(a[i]!=0)t=i; }for(i=0;i<N;i++){ if(a[i]!=0 && a[i]>a[t])t=i; }P[N].startaddress=P[t].startaddress+m;P[N].size=P[t].size-m;P[t].size=m;P[t].state=1;l=1; N++; }if(l==1||i<N){ printf("地址成功分配\n\n");printf("地址分配成功后的状态：\n");print(); }elseprintf("没有可以分配的地址空间\n"); } void Best(){ int i,t=0,l=0,m;int a[L];printf("\n输入请求分配分区的大小：");scanf("%d",&m);for(i=0;i<N;i++){ a[i]=0;if(P[i].size<m)continue;else if(P[i].size==m){ P[i].state=1;l=1;break;}elsea[i]=P[i].size-m; }if(l==0){ for(i=0;i<N;i++){ if(a[i]!=0)t=i; }for(i=0;i<N;i++){ if(a[i]!=0 && a[i]<a[t])t=i; }P[N].startaddress=P[t].startaddress+m;P[N].size=P[t].size-m;P[t].size=m;P[t].state=1;l=1; N++; }if(l==1||i<N){ printf("地址成功分配\n\n");printf("地址分配成功后的状态：\n");print(); }elseprintf("没有可以分配的地址空间\n"); } void main(){ int k=0;printf("动态分区分配算法：");while(k!=5){printf("\n~~~~~~~~主菜单~~~~~~~~~");printf("\n1、首次适应算法\n2、循环首次适应算法");printf("\n3、最坏适应算法\n4、最佳适应算法");printf("\n5、退出\n");printf("请选择算法：");scanf("%d",&k);switch(k){ case 1:printf("\n初始状态为：\n");print();First();continue;case 2:printf("\n初始状态为：\n");print();CirFirst();continue;case 3:printf("\n初始状态为：\n"); print();Worst();continue;case 4:printf("\n初始状态为：\n");print();Best();continue;case 5:break;default:printf("选择错误，请重新选择。
采用首次适应算法的动态分区分配模拟课程设计实验报告
1 需求分析1）本程序要求实现对内存的动态分配与回收的模拟，同时，在内存的分配时还必须使用首次适应算法，最后，还要显示内存块分配和回收后空闲内存分区链的情况。
2）要实现对作业的内存分配，首先要有一个对作业进行创建和分配内存的模块，其中，该模块在分配内存时要使用首次适应算法；要实现对内存的回收，要有一个内存回收的模块，其中，该模块在回收内存时要考虑内存回收的四种情况；最后，还要有一个能显示内存空闲分区链的情况的模块。
2 概要设计1）首次适应算法的结构如图1：图1 首次适应算法的结构图2）数据结构：struct Fq{int size,o,no;Fq *before,*next;};其中，Fq表示结构体的名字（类型），size表示分区的可用空间大小，o表示该分区的状态（是否已分配），no表示该分区中的作业标志，*before表示该结点的向前指针，*next表示该结点的向后指针。
3）各种函数说明：void alloc(int b,int no,Fq *p)；对作业no进行内存分配的功能函数；其中，参数b表示需求的内存大小，参数no表示作业的编号，参数*p表示空闲分区链的第一个非空结点的指针；void free(Fq *c)；将地址为c的分区的内存回收；其中，参数*c表示要回收内存的结点；void create(Fq *head)；创建新作业的子函数；其中，参数*head表示空闲分区链的链首指针；要配合函数alloc（）使用；void cha(Fq *head)；查看内存中的空闲分区链的子函数；其中，参数*head表示空闲分区链的链首指针；void hui(Fq *head)；回收内存的子函数；其中，参数*head表示空闲分区链的链首指针；要配合函数free（）使用；3 运行环境1）操作系统: Windows XP ( 32位 / DirectX 11 )2）电脑: X86 兼容台式电脑处理器: 英特尔 Pentium(奔腾) 双核 E5300 @ 2.60GHz内存: 2 GB4 开发工具和编程语言1）开发工具：Visual C++ 6.0；2）编程语言：C++语言；5 详细设计1）程序结构如图2：图2 程序结构图2）●主菜单模块：void main()//主函数{Fq *head=new Fq;head->next=new Fq;head->next->size=MAXSIZE;head->next->o=0;head->next->next=NULL;int choice=0;do{cout<<"请选择你要进行的操作："<<endl;cout<<"1、创建新作业 2、查看空闲分区链 3、回收内存空间 0、退出"<<endl;cin>>choice;switch(choice){case 1: create(head);break;case 2: cha(head);break;case 3: hui(head);break;case 0: break;default: cout<<"输入错误！"<<endl;}}while(choice!=0);}●创建新作业模块：void create(Fq *head)//创建作业子函数{Fq *p=head->next;p->before=head;int no=0,b=0;cout<<"请输入要创建的作业的编号：";cin>>no;cout<<"请输入作业的需求空间大小：";cin>>b;alloc(b,no,p);//此处调用功能函数alloc()}●查看空闲分区链模块：void cha(Fq *head)//查看内存中的空闲分区链的子函数{Fq *p=head->next;p->before=head;int i=0;cout<<"空闲分区链的情况为："<<endl;while(p!=NULL){if(p->o==0){cout<<"空闲分区"<<++i<<" "<<p->size<<"K"<<endl;}p=p->next;}}●回收内存空间模块：void hui(Fq *head)//回收内存的子函数{Fq *p=head->next;p->before=head;int no=0;cout<<"请输入要回收内存的作业号：";cin>>no;while(p!=NULL){if(p->no==no){free(p);//此处调用功能函数free()cout<<"作业"<<no<<"的内存已回收！"<<endl;return ;}else p=p->next;}}●内存分配功能函数模块：void alloc(int b,int no,Fq *p)//对作业no进行内存分配的子函数{while(p!=NULL){if(p->o==1) {p=p->next;}else{if(p->size>b){if(p->size-b<=min_size){p->o=1;p->no=no;}else{Fq *q=new Fq;Fq *r;r=p->before;r->next=q;q->before=r;q->next=p;p->before=q;q->size=b;p->size=p->size-b;q->no=no;q->o=1;}cout<<"内存分配成功！"<<endl;return ;}else p=p->next;}}cout<<"内存分配失败！"<<endl;}●内存回收功能函数模块：void free(Fq *c)//将地址为c的分区内存回收{if(c->before->o==0&&c->next->o==0){Fq *r=c->before,*s=c->next->next;r->size=(r->size+c->size+c->next->size);r->next=s;if(s!=NULL) s->before=r;}if(c->before->o==0&&c->next->o!=0){c->before->size=c->before->size+c->size;c->before->next=c->next;c->next->before=c->before;}if(c->next->o==0&&c->before->o!=0){Fq *r=c->next->next;c->size=c->size+c->next->size;c->next=c->next->next;if(r!=NULL) r->before=c;c->o=0;}else c->o=0;}6 调试分析1）内存分配功能函数模块：刚开始对作业分配内存时，只是将空闲分区的大小以及前后向指针进行修改，而没有对分配给作业的内存进行设置；这样，尽管内存的空闲分区大小已经变小，但是，以后却无法对已分配的内存空间以及作业进行修改；于是，我经过思考后，决定将分配给作业的内存空间也设置为一个分区，只不过不是空闲的分区，通过状态标识符o来与空闲分区进行区别。
动态分区管理实验报告
实验五动态分区管理模拟实验报告关键问题：写一动态分区管理程序，使其内存分配采用最优适应分配算法。
设计思路：在空闲分区链中找最适合的空闲块，使内存碎片尽量的减少！根据最佳适应算法原理，在内存分配函数ffallocation()中，增加记录适合空白块的标记sp，然后拿当前空白块fp减去后jl的后的大小和它后面的另一空白块sp减去jl的大小相比较。
如果前者大于后者，且后者的空白区大于jl的大小，则当前空白块为sp,否则继续往后比较，直到空闲分区链末尾！则当前空白块为最适合的空白块！然后就把当前空白块分配给作业。
其他部分的代码与实例相同！实现的关键代码：//------------------------------------------------------------------- //有两个链:空白块链及作业链.空白块链描述空白块,链首指针freep,初始为一大块空白块.//作业链按从高址到低址的顺序链接,链首指针jobp//为作业jn分配jl大小内存，起始地址为javoid ffallocation(int jl,char jn[10],int* ja){mat* jp=NULL;//作业链当前节点mat* jp2=NULL;//新的作业节点mat* jp1=NULL;//freearea* fp=NULL;//当前空白块//修改部分 freearea* sp;//记录适合的空白块int i;*ja=-1;if (totalfree<jl) //剩余空间大小不能满足作业要求return;*ja=0;fp=freep;//取空白块链首块，将顺着链寻找第一块满足作业要求的块。
sp=freep;while (fp!=NULL){if (fp->freesize<jl){fp=fp->next;//当前空白块大小不满足要求sp=sp->next;}else //将当前空白块分配给作业{/*当当前空白块fp与它的下一块空白块sp相比较，如果它减去jl后大于下一空白块sp减去jl,且下一空白块sp大于等于jl,则当前空白块为sp;否则sp继续往后查找，直到空闲块查找完毕，然后当前空闲块为所要查找的适合空闲块！*/while(sp!=NULL){if((fp->freesize-jl>sp->freesize-jl)&(sp->freesize>=jl)){fp=sp;}else{sp=sp->next;}}// jobnumber++;totalfree=totalfree-jl;jp2=new mat;//申请一块作业节点空间//在节点上登记为该作业分配的内存空间// for (i=0;i<10;i++) (jp2->jobname)[i]=' ';i=-1;while(jn[++i])(jp2->jobname)[i]=jn[i];(jp2->jobname)[i]='\0';jp2->joblength=jl;jp2->jobaddress=fp->freeaddress;//登记该作业的起始地址*ja=jp2->jobaddress;//将节点jp2插入作业链jobp,按高址到低址的顺序。
动态内存分区分配方式模拟
“计算机操作系统”课程设计实验报告动态内存分区分配方式模拟学生姓名专业名称学号目录1 题目要求 (1)2 设计思想 (1)3 数据定义 (2)4 处理流程 (3)5 源程序 (6)6 运行结果 (15)7 设计体会 (22)动态内存分区分配方式模拟1题目要求假设初始态下，可用内存空间为640K，并有下列请求序列，请分别用首次适应算法和最佳适应算法为作业分配和回收内存块，并显示出每次分配和回收后的空闲分区链的情况来以及内存占用情况图。
作业1申请130K作业2申请60K作业3申请100k作业2释放60K作业4申请200K作业3释放100K作业1释放130K作业5申请140K作业6申请60K作业7申请50K作业6释放60K2设计思想根据题目要求，要用首次适应算法和最佳适应算法分别实现内存的动态分区，因此先介绍一下这两种算法的基本思想：首次适应算法中，空闲分区链是按地址递增的次序链接的，当要分配内存空间时，就查表，在各空闲分区中查找满足大小要求的可用块，只要找到第一个足以满足要求的空间就停止查找，并把它分配出去，如果该空闲空间与所需空间大小一样，则将该分区的状态改为1，即已被分配，若还有剩余，则将剩余空间重新划为一个空闲分区，有新的起始地址，状态为0。
最佳适应算法的空闲链是按照空闲块的大小为序、按增量方式排列的，即小块在前，大块在后，它在满足需要的前提下，尽量分配最小的空闲块，这样每次查找分配时第一次找到的能满足要求的必然的最佳的，若空闲空间大小与要分配的大小相差不多时，可直接将其状态改为1即可，若有剩余，则将剩余空闲空间重新划分为一个空闲区，并根据空闲区的大小对链表进行重新排序。
首次适应算法的回收过程相对简单，因为分区链是按照地址顺序链接的，因此释放内存时只需要判断要释放的分区前后是否也为空闲区，然后根据情况看是要跟前边或后边或前后都合并为一个大的空闲区，如果前后分区都已分配，则直接将该分区状态改为0即可。
实现内存分配实验报告(3篇)
第1篇一、实验目的1. 理解操作系统内存分配的基本原理和常用算法。
2. 掌握动态分区分配方式中的数据结构和分配算法。
3. 通过编写程序，实现内存分配和回收功能。
二、实验环境1. 操作系统：Linux2. 编程语言：C语言3. 开发工具：GCC编译器三、实验原理1. 内存分配的基本原理操作系统内存分配是指操作系统根据程序运行需要，将物理内存分配给程序使用的过程。
内存分配算法主要包括以下几种：（1）首次适应算法（First Fit）：从内存空间首部开始查找，找到第一个满足条件的空闲区域进行分配。
（2）最佳适应算法（Best Fit）：在所有满足条件的空闲区域中，选择最小的空闲区域进行分配。
（3）最坏适应算法（Worst Fit）：在所有满足条件的空闲区域中，选择最大的空闲区域进行分配。
2. 动态分区分配方式动态分区分配方式是指操作系统在程序运行过程中，根据需要动态地分配和回收内存空间。
动态分区分配方式包括以下几种：（1）固定分区分配：将内存划分为若干个固定大小的分区，程序运行时按需分配分区。
（2）可变分区分配：根据程序大小动态分配分区，分区大小可变。
（3）分页分配：将内存划分为若干个固定大小的页，程序运行时按需分配页。
四、实验内容1. 实现首次适应算法（1）创建空闲分区链表，记录空闲分区信息，包括分区起始地址、分区大小等。
（2）编写分配函数，实现首次适应算法，根据程序大小查找空闲分区，分配内存。
（3）编写回收函数，回收程序所占用的内存空间，更新空闲分区链表。
2. 实现最佳适应算法（1）创建空闲分区链表，记录空闲分区信息。
（2）编写分配函数，实现最佳适应算法，根据程序大小查找最佳空闲分区，分配内存。
（3）编写回收函数，回收程序所占用的内存空间，更新空闲分区链表。
3. 实验结果分析（1）通过实验，验证首次适应算法和最佳适应算法的正确性。
（2）对比两种算法在内存分配效率、外部碎片等方面的差异。
五、实验步骤1. 创建一个动态内存分配模拟程序，包括空闲分区链表、分配函数和回收函数。
动态内存分配实验报告
Free[free_p].len=length;
free_p++;
//
sort(Free,Free+free_p,cmp);
for(j=0;j<free_p;j++)
{
1].address)
if(j + 1 < free_p&&Free[j].address+Free[j].len==Free[j +
if(used[i].run_id==id) {
int add=used[i].address; int length=used[i].len; used_p--; for(j=i;j<used_p;j++) {
used[j]=used[j+1]; }
Free[free_p].address=add;
Free[i].address+=len; Free[i].len-=len; } else { free_p--;
for(j=i;j<free_p;j++) {
Free[j]=Free[j+1]; } } break; } }
} void reclaim(int id) {
int i,j,k; for(i=0;i<used_p;i++) {
{ Free[j].len+=Free[j + 1].len; free_p--; for(k =j + 1; k < free_p;k++) { Free[k]=Free[k+1]; }
}
}
} }
} void show() {
动态分区算法实验报告
动态分区算法实验报告动态分区算法实验报告一、引言计算机操作系统是现代计算机系统中的核心组成部分，它负责管理计算机硬件资源，并提供各种服务。
内存管理是操作系统的重要功能之一，它负责管理计算机的内存资源，为进程提供运行环境。
在内存管理中，动态分区算法是一种常用的内存分配策略。
本实验旨在通过实践，深入了解动态分区算法的原理和实现。
二、实验目的1. 了解动态分区算法的基本原理和实现方式；2. 掌握动态分区算法的实验环境搭建和使用方法；3. 分析动态分区算法的优缺点，并比较不同算法的性能差异。
三、实验环境本实验使用C语言编程实现，实验环境如下：1. 操作系统：Windows 10；2. 开发工具：Visual Studio 2019；3. 编程语言：C语言。
四、实验过程1. 实验准备在开始实验之前，我们首先需要了解动态分区算法的基本原理。
动态分区算法根据进程的内存需求，将内存划分为若干个不同大小的分区，并按照进程的请求进行分配和释放。
常用的动态分区算法有首次适应算法、最佳适应算法和最坏适应算法等。
2. 实验设计本实验选择实现首次适应算法，并设计以下几个函数：- 初始化内存空间：初始化一块指定大小的内存空间，将其划分为一个个的分区，并设置分区的状态；- 分配内存：根据进程的内存需求，在内存空间中找到合适的分区进行分配，并更新分区的状态；- 释放内存：将已分配的内存空间进行释放，并更新分区的状态；- 显示内存状态：打印当前内存空间的分区状态。
3. 实验实现根据上述设计，我们使用C语言实现了动态分区算法的相关函数。
通过调用这些函数，我们可以模拟动态分区算法的运行过程，并观察分区的分配和释放情况。
4. 实验结果经过实验，我们得到了以下结果：- 动态分区算法可以有效地管理内存资源，根据进程的需求进行灵活的内存分配；- 首次适应算法在内存分配效率和速度方面表现良好，但可能会导致内存碎片的产生；- 释放内存时，及时合并相邻的空闲分区可以减少内存碎片的数量。
操作系统-动态分区分配算法实验报告
实验题目：存储器内存分配设计思路：1.既然是要对内存进行操作，首先对和内存相关的内容进行设置我使用的是用自定义的数据结构struct来存放内存中一个内存块的内容包括：始地址、大小、状态（f:空闲u:使用e:结束）之后采用数组来存放自定义的数据类型，这样前期的准备工作就完成了2.有了要加工的数据，接下来定义并实现了存放自定义数据类型的数组的初始化函数和显示函数，需要显示的是每个内存块的块号、始地址、大小、状态3.接着依此定义三种动态分区分配算法首次适应算法、最佳适应算法和最差适应算法4.对定义的三种算法逐一进行实现①首次适应算法：通过遍历存放自定义数据类型的数组，找到遍历过程中第一个满足分配大小的内存块块号i，找到之后停止对数组的遍历，将i之后的块号逐个向后移动一个，然后将满足分配大小的内存块i分为两块，分别是第i块和第i+1块，将两块的始地址、大小、状态分别更新，这样便实现了首次适应算法②最佳适应算法：和首次适应算法一样，首先遍历存放自定义数据类型的数组，找到满足分配大小的内存块后，对内存块的大小进行缓存，因为最佳适应是要找到最接近要分配内存块大小的块，所以需要遍历整个数组，进而找到满足分配大小要求的而且碎片最小的块i，之后的操作和首次遍历算法相同③最差适应算法：和最佳适应算法一样，区别在于，最佳适应是找到最接近要分配内存块大小的块，而最差适应是要找到在数组中，内存最大的块i，找到之后的操作和最佳适应算法相同，因此不在这里赘述。
5.定义并实现释放内存的函数通过块号找到要释放的内存块，把要释放的内存块状态设置成为空闲，查看要释放的块的左右两侧块的状态是否为空闲，如果有空闲，则将空闲的块和要释放的块进行合并（通过改变块的始地址、大小、状态的方式）6.定义主函数，用switch来区分用户需要的操作，分别是：①首次适应②最佳适应③最差适应④释放内存⑤显示内存⑥退出系统实验源程序加注释：#include<bits/stdc++.h>#define MI_SIZE 100 //内存大小100typedef struct MemoryInfomation//一个内存块{int start; //始地址int Size; //大小char status; //状态 f:空闲 u:使用 e：结束} MI;MI MList[MI_SIZE];void InitMList() //初始化{int i;MI temp = { 0,0,'e' };for (i = 0; i < MI_SIZE; i++){MList[i] = temp;}MList[0].start = 0; //起始为0MList[0].Size = MI_SIZE;//大小起始最大MList[0].status = 'f'; //状态起始空闲}void Display() //显示{int i, used = 0;printf("\n---------------------------------------------------\n");printf("%5s%15s%15s%15s", "块号", "始地址", "大小", "状态");printf("\n---------------------------------------------------\n");for (i = 0; i < MI_SIZE && MList[i].status != 'e'; i++){if (MList[i].status == 'u'){used += MList[i].Size;}printf("%5d%15d%15d%15s\n", i, MList[i].start, MList[i].Size, MList[i].status == 'u' ? "使用" : "空闲");}printf("\n----------------------------------------------\n");}void FirstFit(){int i, j, flag = 0;int request;printf("最先适应算法：请问你要分配多大的内存\n");scanf("%d", &request);for (i = 0; i < MI_SIZE && MList[i].status != 'e'; i++){if (MList[i].Size >= request && MList[i].status == 'f') {if (MList[i].Size - request <= 0){MList[i].status = 'u';}else{for (j = MI_SIZE - 2; j > i; j--){MList[j + 1] = MList[j];}MList[i + 1].start = MList[i].start + request; MList[i + 1].Size = MList[i].Size - request;MList[i + 1].status = 'f';MList[i].Size = request;MList[i].status = 'u';flag = 1;}break;}}if (flag != 1 || i == MI_SIZE || MList[i].status == 'e'){printf("没有足够大小的空间分配\n");}Display();}void BadFit(){int i, j = 0, k = 0, flag = 0, request;printf("最坏适应算法：请问你要分配多大的内存\n");scanf("%d", &request);for (i = 0;i < MI_SIZE - 1 && MList[i].status != 'e';i++){if (MList[i].Size >= request && MList[i].status == 'f') {flag = 1;if (MList[i].Size > k){k = MList[i].Size;j = i;}}}i = j;if (flag == 0){printf("没有足够大小的空间分配\n");j = i;}else if (MList[i].Size - request <= 0){MList[i].status = 'u';}else{for (j = MI_SIZE - 2;j > i;j--){MList[j + 1] = MList[j];}MList[i + 1].start = MList[i].start + request;MList[i + 1].Size = MList[i].Size - request;MList[i + 1].status = 'f';MList[i].Size = request;MList[i].status = 'u';}Display();}void M_Release() //释放内存{int i, number;printf("\n请问你要释放哪一块内存:\n");scanf("%d", &number);if (MList[number].status == 'u'){MList[number].status = 'f';if (MList[number + 1].status == 'f')//右边空则合并{MList[number].Size += MList[number].Size;for (i = number + 1; i < MI_SIZE - 1 && MList[i].status != 'e'; i++) { //i后面的每一个结点整体后移if (i > 0){MList[i] = MList[i + 1];}}}if (number > 0 && MList[number - 1].status == 'f')//左边空则合并{MList[number - 1].Size += MList[number].Size;for (i = number; i < MI_SIZE - 1 && MList[i].status != 'e'; i++){MList[i] = MList[i + 1];}}}else{printf("该块内存无法正常释放\n");}Display();}void BestFit(){int i, j = 0, t, flag = 0, request;printf("最佳适应算法：请问你要分配多大的内存\n");scanf("%d", &request);t = MI_SIZE;for (i = 0; i < MI_SIZE && MList[i].status != 'e'; i++){if (MList[i].Size >= request && MList[i].status == 'f'){flag = 1;if (MList[i].Size < t){t = MList[i].Size;j = i;}}}i = j;if (flag == 0){printf("没有足够大小的空间分配\n");j = i;}else if (MList[i].Size - request <= 0){MList[i].status = 'u';}else {for (j = MI_SIZE - 2; j > i; j--){MList[j + 1] = MList[j];}MList[i + 1].start = MList[i].start + request;MList[i + 1].Size = MList[i].Size - request;MList[i + 1].status = 'f';MList[i].Size = request;MList[i].status = 'u';}Display();}int main(){int x;InitMList();while (1){printf(" \n"); printf(" 1.首次适应\n");printf(" 2.最佳适应\n");printf(" 3.最差适应\n"); printf(" 4.释放内存\n"); printf(" 5.显示内存\n"); printf(" 6.退出系统\n"); printf("请输入1-6：");scanf("%d", &x);switch (x){case 1:FirstFit();break;case 2:BestFit();break;case 3:BadFit();break;case 4:M_Release();break;case 5:Display();break;case 6:exit(0);}}return 0;}实验测试结果记录：1.首次适应2.最佳适应3.最差适应4.释放内存5.显示内存6.退出系统请输入1-6：1最先适应算法：请问你要分配多大的内存10---------------------------------------------------块号始地址大小状态---------------------------------------------------0 0 10 使用1 10 90 空闲----------------------------------------------1.首次适应2.最佳适应3.最差适应4.释放内存5.显示内存6.退出系统请输入1-6：1最先适应算法：请问你要分配多大的内存25---------------------------------------------------块号始地址大小状态---------------------------------------------------0 0 10 使用1 10 25 使用2 35 65 空闲----------------------------------------------1.首次适应2.最佳适应3.最差适应4.释放内存5.显示内存6.退出系统请输入1-6：1最先适应算法：请问你要分配多大的内存15---------------------------------------------------块号始地址大小状态---------------------------------------------------0 0 10 使用1 10 25 使用2 35 15 使用3 50 50 空闲----------------------------------------------1.首次适应2.最佳适应3.最差适应4.释放内存5.显示内存6.退出系统请输入1-6：1最先适应算法：请问你要分配多大的内存20---------------------------------------------------块号始地址大小状态---------------------------------------------------0 0 10 使用1 10 25 使用2 35 15 使用3 50 20 使用4 70 30 空闲----------------------------------------------1.首次适应2.最佳适应3.最差适应4.释放内存5.显示内存6.退出系统请输入1-6：4请问你要释放哪一块内存:---------------------------------------------------块号始地址大小状态---------------------------------------------------0 0 10 空闲1 10 25 使用2 35 15 使用3 50 20 使用4 70 30 空闲----------------------------------------------1.首次适应2.最佳适应3.最差适应4.释放内存5.显示内存6.退出系统请输入1-6：4请问你要释放哪一块内存:2---------------------------------------------------块号始地址大小状态---------------------------------------------------0 0 10 空闲1 10 25 使用2 35 15 空闲3 50 20 使用4 70 30 空闲----------------------------------------------1.首次适应2.最佳适应3.最差适应4.释放内存5.显示内存6.退出系统请输入1-6：2最佳适应算法：请问你要分配多大的内存5---------------------------------------------------块号始地址大小状态---------------------------------------------------0 0 5 使用1 5 5 空闲2 10 25 使用3 35 15 空闲4 50 20 使用5 70 30 空闲----------------------------------------------1.首次适应2.最佳适应3.最差适应4.释放内存5.显示内存6.退出系统请输入1-6：3最坏适应算法：请问你要分配多大的内存25---------------------------------------------------块号始地址大小状态---------------------------------------------------0 0 5 使用1 5 5 空闲2 10 25 使用3 35 15 空闲4 50 20 使用5 70 25 使用6 95 5 空闲----------------------------------------------1.首次适应2.最佳适应3.最差适应4.释放内存5.显示内存6.退出系统请输入1-6：总结与自评：总结：分区存储管理是操作系统进行内存管理的一种方式。
实验五动态分区分配算法的模拟
实验五动态分区分配算法的模拟为了更好地理解动态分区分配算法的工作原理，我们可以进行一次模拟实验。
在实验中，我们将模拟一个内存分区，并使用动态分区分配算法来管理这些分区。
首先，让我们定义一个内存大小为1000字节的分区。
我们假设这个内存中包含几个已分配的分区和几个空闲的分区。
我们使用首次适应算法来进行分区的首次适应分配。
首先，我们将整个内存空间标记为空闲状态，并创建一个初始的空闲链表。
我们假设初始时只有一个空闲分区，大小为1000字节，起始地址为0。
现在，假设有一个进程请求分配一个250字节大小的内存空间。
我们首先检查空闲链表，找到一个大小大于等于250字节的空闲分区。
在这种情况下，我们发现第一个空闲分区的大小是1000字节，所以我们将它拆分成250字节的已分配分区和750字节的空闲分区。
我们在已分配分区上标记一个进程编号，并将空闲分区加入空闲链表。
接下来，假设我们的进程需要申请500字节的内存空间。
在这种情况下，我们需要查找一个大小大于等于500字节的空闲分区。
我们发现第一个可用的空闲分区大小是750字节，我们将它拆分为已分配的500字节和剩余的250字节的空闲分区。
然后，我们假设有进程释放了先前分配的250字节的内存空间。
当一个进程释放分配的内存空间时，我们需要合并相邻的空闲分区。
在这种情况下，释放的分区位于地址0，大小为250字节，并且其下一个分区是地址500，大小为500字节的空闲分区。
因此，我们将这两个分区合并为一个大小为750字节的空闲分区。
接下来，我们假设另一个进程将请求600字节的内存空间。
根据首次适应算法，我们将在第一个满足条件的空闲分区进行分配。
在这种情况下，我们将分配200字节的空闲分区和分配400字节的空闲分区拆分为600字节的已分配分区和空闲分区。
最后，假设一个进程请求200字节的内存空间。
根据首次适应算法，我们在第一个满足条件的空闲分区进行分配。
在这种情况下，我们将250字节的空闲分区拆分为200字节的已分配分区和50字节的空闲分区。
实验五 动态分区分配算法的模拟
实验五动态分区分配算法的模拟一、实验目的1、加深操作系统内存管理过程的理解2、掌握内存分配算法的基本应用二、实验任务请同学们用C/C++实现一个完整的（可变）动态分区管理器，包括分配，回收，分区碎片整理等。
希望同学们实现如下功能：n 初始化功能：内存状态设置为初始状态。
n 分配功能：要求至少使用两种算法，用户可以选择使用。
n 回收功能：n 空闲块的合并：即紧凑功能，用以消除碎片。
当做碎片整理时，需要跟踪分配的空间，修改其引用以保证引用的正确性。
n 显示当前内存的使用状态，可以使用表格或图形。
三、实验指导1．基本思想动态分区是指系统不预先划分固定分区，而是在装入程序的时候划分内存区域，使得为程序分配的分区大小恰好等于该程序的需求量，且分区的个数是动态的。
显然动态分区有较大的灵活性，较之固定分区能获得好的内存利用率。
2．数据结构动态分区管理可以用两种数据结构实现，一种是已分配区表和空闲区表，也就是用预先定义好的系统空间来存放空间分配信息。
另一种也是最常用的就是空闲链表，由于对分区的操作是动态的，所以很难估计数据结构所占用的空间，而且空闲区表会占用宝贵的系统空间，所以提出了空闲链表的概念。
其特点是用于管理分区的信息动态生成并和该分区在物理地址上相邻。
这样由于可以简单用两个空闲块之间的距离定位已分配空间，不仅节约了系统空间，而且不必维持已分配空间的信息。
本实验是要做一个模拟程序，来模拟动态分区算法的分配和回收过程，并不是真正的去分配和回收内存。
基本的模拟方法有两种：1、先从内存中申请一块存储区，对这块存储区进行模拟的分配和回收活动。
2、不申请存储区，自己定义一块虚拟的存储区，对这块存储区进行模拟的分配和回收活动，分配和回收仅仅是对数据结构的修改而已。
程序代码：#include<iostream>using namespace std;int FreePartition[100];//空闲分区块数组int FirstPartition[100];//首次适应算法数组int CycleFirstPartition[100];//循环首次适应算法数组int BestPartition[100];//最佳适应算法数组int WorstPartition[100];//最坏适应算法数组int ProcessNeed[100];//每个作业的大小int PartitionNum,ProcessNum;//分区块数，作业数//首次适应算法void First(){int i,j;char str;for(i=0;i<PartitionNum;i++){FirstPartition[i]=FreePartition[i];}for(i=0;i<ProcessNum;i++)//找出第一块满足作业的分区for(j=0;j<PartitionNum;j++){if(ProcessNeed[i]>FirstPartition[j])continue;else{FirstPartition[j]-=ProcessNeed[i];//找到后把分区大小减去作业的大小 ? ? ? ? ? ? ?str='A'+i;cout<<"作业"<<str<<"在第"<<j+1<<"块分区中"<<endl;break;}}cout<<endl;cout<<"分配之后剩余情况："<<endl;?for(i=0;i<PartitionNum;i++)cout<<FirstPartition[i]<<" ";cout<<endl<<endl;}//循环首次适应算法void CycleFirst(){int i,j=1;char str;for(i=0;i<PartitionNum;i++){CycleFirstPartition[i]=FreePartition[i];}for(i=0;i<ProcessNum;i++)//for(j=0;j<PartitionNum;j++){j=j-1;while(j<PartitionNum)if(ProcessNeed[i]>CycleFirstPartition[j])//continue;j++;else{CycleFirstPartition[j]-=ProcessNeed[i];str='A'+i;cout<<"作业"<<str<<"在第"<<j+1<<"块分区中"<<endl; break;}//j++;//cout<<j<<" ";if(j==PartitionNum && i!=ProcessNum){i=-1;}}}cout<<endl;cout<<"分配之后剩余情况："<<endl;for(i=0;i<PartitionNum;i++)cout<<CycleFirstPartition[i]<<" ";cout<<endl<<endl;}//最佳适应算法void Best(){int i,j,k;char str;?for(i=0;i<PartitionNum;i++){BestPartition[i]=FreePartition[i];}for(i=0;i<ProcessNum;i++){k=0;for(j=0;j<PartitionNum;j++){//cout<<BestPartition[j]<<" ? "<<ProcessNeed[i]<<endl; if(BestPartition[j]>=ProcessNeed[i]){break;}}for(int n=0;n<PartitionNum;n++){if(BestPartition[n]<BestPartition[k] && BestPartition[n]>=ProcessNeed[i])//找最佳的 k=n;}BestPartition[k]-=ProcessNeed[i];str='A'+i;cout<<"作业"<<str<<"在第"<<j+1<<"块分区中"<<endl;}cout<<endl;cout<<"分配之后剩余情况："<<endl;for(i=0;i<PartitionNum;i++)cout<<BestPartition[i]<<" ";cout<<endl<<endl;}//最坏适应算法void Worst(){int i,j,k;char str;for(i=0;i<PartitionNum;i++){WorstPartition[i]=FreePartition[i];}for(i=0;i<ProcessNum;i++){k=0;for(j=0;j<PartitionNum;j++){if(WorstPartition[j]>WorstPartition[k])//找到最大的分区k=j;}WorstPartition[k]-=ProcessNeed[i];str='A'+i;cout<<"作业"<<str<<"在第"<<j+1<<"块分区中"<<endl;}cout<<endl;cout<<"分配之后剩余情况："<<endl;for(i=0;i<PartitionNum;i++)cout<<WorstPartition[i]<<" ";cout<<endl<<endl;}void main(){int i;cout<<"输入分区块数："<<endl;cin>>PartitionNum;cout<<"输入每个分区的大小："<<endl;for(i=0;i<PartitionNum;i++)cin>>FreePartition[i];cout<<"输入作业数："<<endl;cin>>ProcessNum;cout<<"输入每个作业的大小："<<endl;for(i=0;i<ProcessNum;i++)cin>>ProcessNeed[i];cout<<"------------首次适应算法-----------------"<<endl; First();cout<<"------------循环首次适应算法-------------"<<endl; ?CycleFirst();cout<<"------------最佳适应算法-----------------"<<endl; Best();cout<<"------------最坏适应算法-----------------"<<endl; Worst();}。
计算机操作系统实验报告动态分区分配方式的模拟
计算机操作系统实验报告姓名：班级：学号：题目：动态分区分配方式的模拟实习内容简要描述本次实验要完成两部分内容：一是用C语言实现对采用首次适应算法和最佳适应算法的动态分区分配过程ALLOCo和回收过程FREE（）,其中空闲分区由空闲分区链来管理，进行分配时，系统优先使用空闲区底端空间。
二是假设初始状态下，可用内存空间为640KBO按照题目要求的作业顺序，以及各个作业分配和回收的内存空间。
分别采用首次适应法和最佳适应法，对内存进行分配和回收，要求每次分配和回收后显示空闲内存分区链的情况。
实验分析算法介绍本次实验通过用C语言进行编程并调试、运行，形象地表现出动态分区的分配方式，直观地展现了首次适应算法和最佳适应算法对内存的释放和回收方式之间的区别。
加深了我们对两种算法优缺点的理解，帮助我们了解一些数据结构和分配算法，进一步加深我们对动态分区存储器管理方式及其实现过程的理解。
主要的问题在于，如何解决两种算法对内存的释放和回收空间的表示。
动态分区分配：又称为可变分区分配，这种分配方式并不事先先将主存划分成一块块的分区，而是在作业进入主存时，根据作业的大小动态地建立分区。
并使分区的大小正好适应作业的需要。
因此系统中分区的大小是可变的，分区的数目也是可变的。
分区分配算法：（两者的空闲块链接方式不冋）①首次适应法：为作业选择分区时总是按地址从高到低搜索，只要找到可以容纳该作业的空白块，就把该空白块分配给该作业。
特点：优先利用内存中底地址部分的空闲分区（将所有空闲区，按其地址递增的顺序链接）②最佳适应算法：接到内存申请时，在空闲块表中找到一个不小于请求的最小空块进行分配；为作业选择分区时总是寻找其大小最接近于作业所要求的存储区域。
特点：用最小空间满足要求（将所有空闲区，按其大小递增的顺序联接成空闲区链）结果分析(思考题解答；错误原因分析)间的分配和回收。
思考题解答：1、首次适应算法分配时从表头指针开始查找可利用空间表，将找到的第一个大小不小于“请求”的空闲块的一部分分配给用户。
(完整word版)动态分区分配方式的模拟实验报告
L［i].sad=L[i］。sad+T[k］。rom;
L［i］。rom=L[i］.rom—T［k］.rom；
L[i］。state=1；
T[k].sad=L[i］.sad—T［k].rom；
printf（"内存分配成功！\n作业申请空间为％d\n起始地址为%d\n”,T[k］.rom，T[k］。sad);
L[i]。rom=L[i］.rom-T［k］.rom;
L［i].state=1;
T［k］。sad=L[i]。sad-T［k］。rom；
printf（"内存分配成功！\n作业申请空间为%d\n起始地址为%d\n"，T[k］。rom,T［k］.sad);
break;
｝
else
｛
L［i］。sad=L[i]。sad+Size；
4。实验原理或流程图
首次适应算法（First-fit)：当要分配内存空间时,就查表，在各空闲区中查找满足大小要求的可用块。只要找到第一个足以满足要球的空闲块就停止查找，并把它分配出去；如果该空闲空间与所需空间大小一样,则从空闲表中取消该项；如果还有剩余，则余下的部分仍留在空闲表中，但应修改分区大小和分区始址。
L[i].rom=L[i］。rom-Size；
L［i]。state=2;
T[k]。sad=L[i].sad—Size；
printf(”内存分配成功！\n作业申请空间为％d\n起始地址为%d\n",L［i］。rom，T[k].sad）;
break；
}
}
else if（L[i］.state=0&＆L［i］。rom—T［k］。rom==Size）
T[k］.id=k;
int i;
动态分区分配方式的模拟 (2)
实
验
步
骤
首次适应算法； 从空闲分区表的第一个表目起查找该表，把最先能够满足要求的空闲区分配给作业，这种方法目的在于减少查找时间。为适应这种算法，空闲分区表（空闲区链）中的空闲分区要按地址由低到高进行排序。该算法优先使用低址部分空闲区，在低址空间造成许多小的空闲区，在高地址空间保留大的空闲区。
{
//分配初始分区内存
subAreaNode *fir = (subAreaNode *)malloc(sizeof(subAreaNode));
//给首个分区赋值
fir->n= 0;
fir->addr = 0;
fir->size = SIZE;
fir->state = Free;
fir->taskId = -1;
&& (p->nxt != NULL && p->nxt->state == Free)) {
//情况1：合并上下两个分区
//先合并上区间
pp = p;
//分配大小为size的区间
subAreaNode *node = (subAreaNode *)malloc(sizeof(subAreaNode));
node->addr = p->addr + size;
node->size = p->size - size;
node->state = Free;
//分配大小为size的区间
subAreaNode *node = (subAreaNode *)malloc(sizeof(subAreaNode));
动态分区分配算法实验报告
操作系统实验报告实验二:动态分区分配算法学生：学号：学院：系别：专业：实验时间：报告时间：一、实验内容编写一个内存动态分区分配模拟程序，模拟内存的分配和回收的完整过程。
一个好的计算机系统不仅要有一个足够容量的、存取速度高的、稳定可靠的主存储器，而且要能合理地分配和使用这些存储空间。
当用户提出申请存储器空间时，存储管理必须根据申请者的要求，按一定的策略分析主存空间的使用情况，找出足够的空闲区域分配给申请者。
当作业撤离或主动归还主存资源时，则存储管理要收回作业占用的主存空间或归还部分主存空间。
主存的分配和回收的实现与主存储器的管理方式有关的，通过本实验帮助学生理解在可变分区管理方式下应怎样实现主存空间的分配和回收。
三、实验原理模拟在可变分区管理方式下采用最先适应算法实现主存分配和回收。
(1)可变分区方式是按作业需要的主存空间大小来分割分区的。
当要装入一个作业时，根据作业需要的主存量查看是否有足够的空闲空间，若有，则按需要量分割一个分区分配给该作业；若无，则作业不能装入。
随着作业的装入、撤离，主存空间被分成许多个分区，有的分区被作业占用，而有的分区是空闲的。
例如：为了说明哪些区是空闲的，可以用来装入新作业，必须要有一X 空闲区说明表，格式如下：第一栏第二栏其中，起址——指出一个空闲区的主存起始地址。
长度——指出从起始地址开始的一个连续空闲的长度。
状态——有两种状态，一种是“未分配”状态，指出对应的由起址指出的某个长度的区域是空闲区。
(2) 当有一个新作业要求装入主存时，必须查空闲区说明表，从中找出一个足够大的空闲区。
有时找到的空闲区可能大于作业需要量，这时应把原来的空闲区变成两部分：一部分分给作业占用；另一部分又成为一个较小的空闲区。
为了尽量减少由于分割造成的空闲区，而尽量保存高地址部分有较大的连续空闲区域，以利于大型作业的装入。
为此，在空闲区说明表中，把每个空闲区按其地址顺序登记，即每个后继的空闲区其起始地址总是比前者大。
希冀动态分区实验报告
希冀动态分区实验报告1、实验名称：动态分区内存分配算法的实现2、实验要求：（1）理解动态分区管理方式的基本原理，（2）掌握首次适应法、最佳适应法、最坏适应法三种分配算法，（3）用c或c++语言编程实现三种算法。
3、实验方式：通过实验室的微机上机，实际调试程序。
4、实验环境：硬件环境：pc机一台；软件环境：windows10操作系统、ｃ或ｃ＋＋程序设计语言。
5、实验过程：（1）算法描述：1）根据当前算法在空闲分区链表中搜索合适空闲分区进行分配，分配时注意以下情况：①找到可满足空闲分区且分配后剩余空间足够大，则分割；②找到可满足空闲分区且但分配后剩余空间比较小，则一起分配；③找不可满足需要的空闲分区但空闲分区之和能满足需要，则采用内存紧缩技术，进行空闲分区的合并，然后再分配；④在成功分配内存后，应保持空闲分区按照相应算法有序；⑤分配成功则返回1，否则返回-1。
2）回收内存四种情况①回收区与前一个空闲分区相邻接，与前一分区合并，修改前一分区的大小；②回收区与插入点的后一空闲分区相邻接，将两个分区合并，形成新的分区。
（用回收区的首地址作为新分区的首地址，大小为其之和）③回收区同时与前后两个空闲分区相邻接，合并三个分区，首地址为第一个分区的首址，大小为三个之和；④回收区与之均不邻接，建立新表项。
（2）实现代码：/*常量定义*//* 内存分配算法 *//*描述每一个空闲块的数据结构*/struct free_block_type{int size;int start_addr;struct free_block_type *next;};/*每个进程分配到的内存块的描述*/struct allocated_block{int pid;int size;int start_addr;char process_name[process_name_len];struct allocated_block *next;};/*指向内存中空闲块链表的首指针*/struct free_block_type *free_block;/*进程分配内存块链表的首指针*/struct allocated_block *allocated_block_head = null; int mem_size=default_mem_size; /*内存大小*/int ma_algorithm = ma_ff; /*当前分配算法*/static int pid = 0; /*初始pid*/int flag = 0; /*设置内存大小标志,防止重复设置*/void display_menu();void do_exit();struct free_block_type *init_free_block(int mem_size); void set_mem_size();void set_algorithm();void new_process();void kill_process();void display_mem_usage();void rearrange(int choice);void rearrage_ff();void rearrage_bf();void rearrage_wf();main(){char choice;pid=0;free_block = init_free_block(mem_size); //初始化空闲区display_menu();while(1){printf("请选择（0-5）: ");fflush(stdin);choice=getchar(); //获取用户输入switch(choice){case'1':set_mem_size(); //设置内存大小system("cls");break;case'2':set_algorithm();//设置算法flag=1;system("cls");break;case'3':new_process();//创建新进程flag=1;system("cls");break;case'4':kill_process();//删除进程flag=1;system("cls");break;case'5':display_mem_usage();//显示内存使用 flag=1;break;case'0':do_exit();//释放链表并退出exit(0);default: break;}choice=getchar();}}//紧缩处理void free_memory_rearrage(int memory_reduce_size,int allocated_size){struct free_block_type *p1,*p2;struct allocated_block *a1,*a2;if(memory_reduce_size!=0) //分配完还有小块空间{p1=free_block;p2=p1->next;p1->start_addr=0;p1->size=memory_reduce_size;p1->next=null;mem_size=memory_reduce_size; //}else{p2=free_block;free_block=null;mem_size=0;}while(p2!=null)//释放节点{p1=p2;p2=p2->next;free(p1);}//allocated_block 重新修改链接a1=(struct allocated_block*)malloc(sizeof(struct allocated_block));a1->pid=pid;a1->size=allocated_size;a1->start_addr=memory_reduce_size; //已申请的开始地址，从memory_reduce_size开始sprintf(a1->process_name, "process-%02d", pid);a1->next=allocated_block_head;a2=allocated_block_head;allocated_block_head=a1;while(a2!=null){a2->start_addr=a1->start_addr+a1->size;a1=a2;a2=a2->next;}}int allocate_mem(struct allocated_block *ab){//根据当前算法在空闲分区链表中搜索合适空闲分区进行分配，分配时注意以下情况：// 1. 找到可满足空闲分区且分配后剩余空间足够大，则分割// 2. 找到可满足空闲分区且但分配后剩余空间比较小，则一起分配// 3. 找不可满足需要的空闲分区但空闲分区之和能满足需要，则采用内存紧缩技术，进行空闲分区的合并，然后再分配// 4. 在成功分配内存后，应保持空闲分区按照相应算法有序// 5. 分配成功则返回1，否则返回-1struct free_block_type *fbt, *pre;int request_size=ab->size;//int memory_count;//计算剩余分区总内存大小fbt = pre =free_block;while((pre!=null)&&(request_size>pre->size))//遍历查找匹配空白区{//memory_count+=pre->size;fbt=pre;pre=pre->next;}if(!pre) //pre=pre->next结尾{if(mem_size>=request_size)/*memory_count*/{if(mem_size>=request_size+min_slice)free_memory_rearrage(mem_size-request_size,request_size); //采用紧缩技术elsefree_memory_rearrage(0,mem_size); //采用紧缩技术,空间全部分配return 0;//全部重定位,不返回上级}elsereturn -1;//分配失败!}else //内存能满足request_size<=pre->size{if((pre->size-request_size)>min_slice)//找到可满足空闲分区且分配后剩余空间足够大，则分割{pre->size=pre->size-request_size;ab->start_addr=pre->start_addr+pre->size;}else//找到可满足空闲分区且但分配后剩余空间比较小，则一起分配，删除该节点{if(pre==fbt){fbt=pre->next;free_block=fbt;}elsefbt->next=pre->next;ab->start_addr=pre->start_addr;ab->size=pre->size;free(pre);//释放节点}}mem_size-=ab->size;//...rearrange(ma_algorithm);//分配成功，按照相应算法排序return 1;}void new_process(){struct allocated_block *ab;int size;int ret;/*ret==1表示从空闲分区分配空间成功*/if(mem_size==0){printf("内存全部分配！无法创建新进程，请先释放其他进程！\n");return;}ab=(struct allocated_block *)malloc(sizeof(struct allocated_block));if(ab==null){printf("no mem!\n");exit(1);}ab->next=null;pid++;sprintf(ab->process_name,"process-%02d",pid);//字符串格式化ab->pid=pid;while(1){printf("请输入内存 %s(0-%d):",ab->process_name,mem_size);scanf("%d",&size);if(size<=mem_size&&size>0){ab->size=size;break;}printf("请重新输入！\n");}ret=allocate_mem(ab);//从空闲内存分配空间/*如果此时allocated_block_head尚未赋值，则赋值*/if((ret==1)&&(allocated_block_head == null)) allocated_block_head=ab;else if(ret==1) /*分配成功，将该已分配块的描述插入已分配链表(头插<无头节点>)*/ {ab->next=allocated_block_head;allocated_block_head=ab;}else if(ret==-1)/*分配不成功*/{printf("分配失败！\n");free(ab);return;}printf("分配成功！\n");}struct allocated_block *find_process(int pid){struct allocated_block *p;p=allocated_block_head;while(p){if(p->pid==pid)return p;p=p->next;}return p;}/*释放ab所表示的分配区*/int free_mem(struct allocated_block *ab){int algorithm = ma_algorithm;struct free_block_type *fbt,*pre,*work;mem_size+=ab->size;fbt=(struct free_block_type*)malloc(sizeof(struct free_block_type));if(!fbt)return -1;fbt->size = ab->size;fbt->start_addr=ab->start_addr;fbt->next=null;rearrange(ma_ff);//按地址有序排列// 进行可能的合并，基本策略如下// 1. 将新释放的结点插入到空闲分区队列末尾// 2. 对空闲链表按照地址有序排列// 3. 检查并合并相邻的空闲分区// 4. 将空闲链表重新按照当前算法排序pre=null;work=free_block;//查找插入位置while((work!=null)&&(fbt->start_addr>work->start_addr)){pre=work;work=work->next;}//插入当前节点//回收内存四种情况//1）回收区与前一个空闲分区相邻接，与前一分区合并，修改前一分区的大小//2）回收区与插入点的后一空闲分区相邻接，将两个分区合并，形成新的分区。
(完整word版)动态分区分配方式模拟
使用动态分区分配方式的模拟1内容（1）用C语言分别实现采用首次适应算法和最佳适应算法的动态分区分配过程alloc( )和回收过程free( )。
其中，空闲分区通过空闲分区链来管理：在进行内存分配时，系统优先使用空闲区低端的空间。
（2）假设初始状态下，可用的内存空间为640KB，并有下列的请求序列：•作业1申请130KB。
•作业2申请60KB。
•作业3申请100KB。
•作业2释放60KB。
•作业4申请200KB。
•作业3释放100KB。
•作业1释放130KB。
•作业5申请140KB。
•作业6申请60KB。
•作业7申请50KB。
•作业6释放60KB。
请分别采用首次适应算法和最佳适应算法，对内存块进行分配和回收，要求每次分配和回收后显示出空闲分区链的情况。
2、示例程序：//Tittle: 使用动态分区算法的模拟//author: XuYongzhen#include <stdio.h>#include <stdlib.h>#include <malloc.h>#include <iostream>using namespace std;typedef struct DuLNode{struct DuLNode *prior;struct DuLNode *next;int address;int jsize;int jnumber;//显示分区被那个作业占用，显示零则为空闲分区；}DuLNode,*DuLinkList ;void CreatList(DuLinkList &L){DuLinkList p=(DuLinkList)malloc(sizeof(DuLNode));L->next=p;L->jnumber=100;//为释放头结点后面的结点空间做统一化处理p->prior=L;p->next=NULL;p->jsize=600;p->address=0;p->jnumber=0;}void RequestList(DuLinkList &L,int job,int size){cout<<"作业"<<job<<"申请"<<size<<"KB的空间"<<endl;DuLinkList p=L->next;while((p->jnumber>0||p->jsize<size)&&p)p=p->next;if(p==NULL)cout<<"没有适合的空间分配"<<endl;else{DuLinkList s=(DuLinkList)malloc(sizeof(DuLNode));s->prior=p->prior;p->prior->next=s;s->next=p;p->prior=s;s->jnumber=job;s->jsize=size;s->address=p->address;p->address=p->address+s->jsize;p->jsize=p->jsize-s->jsize;DuLinkList t=L->next;while(t){if(t->jnumber==0)cout<<"空闲分区：始址="<<t->address<<"大小="<<t->jsize<<endl;elsecout<<"已分配的分区：作业号="<<t->jnumber<<"始址="<<t->address<<"大小="<<t->jsize<<endl;t=t->next;}//whilecout<<endl;}//else}//RequestListvoid FreeList(DuLinkList &L,int job){cout<<"作业"<<job<<"释放"<<endl;DuLinkList p=L->next;while(p->next&&p->jnumber!=job)p=p->next;if(p->prior->jnumber==0 && p->next->jnumber==0){//p的前后都是空闲分区,则合并三者DuLinkList s=p->next;DuLinkList q=p->prior;p->prior->next=p->next;p->next->prior=p->prior;s->prior->next=s->next;s->next->prior=p->prior;q->jsize=p->jsize+s->jsize+q->jsize;}if(p->prior->jnumber==0 && p->next->jnumber!=0){//回收区与插入点的前一个分区相临接DuLinkList q=p->prior;p->prior->next=p->next;p->next->prior=p->prior;q->jsize=p->jsize+q->jsize;}if(p->prior->jnumber!=0 && p->next->jnumber==0){//回收区与插入点的后一个分区相临接DuLinkList q=p->next;p->prior->next=p->next;p->next->prior=p->prior;q->address=p->address;q->jsize=p->jsize+q->jsize;}if(p->prior->jnumber!=0 && p->next->jnumber!=0)//回收区去插入点前后的两个空闲分区都不相临接p->jnumber=0;DuLinkList t=L->next;while(t){if(t->jnumber==0)cout<<"空闲分区：始址="<<t->address<<"大小="<<t->jsize<<endl;elsecout<<"已分配的分区：作业号="<<t->jnumber<<"始址="<<t->address<<"大小="<<t->jsize<<endl;t=t->next;}cout<<endl;}void main(){DuLinkList L=(DuLinkList)malloc(sizeof(DuLNode));CreatList(L);RequestList(L,1,130);RequestList(L,2,60);RequestList(L,3,100);FreeList(L,2);RequestList(L,4,200);FreeList(L,3);FreeList(L,1);RequestList(L,5,140);RequestList(L,6,60);RequestList(L,7,50);FreeList(L,6);}。
动态分区分配方式的模拟 (2)
p->n=p->n+1;
}
printf("内存分配成功！\n");
return 1;
}
p = p->nxt;
}
printf("找不到合适的内存分区，分配失败...\n");
return 0;
}
//最佳适应算法
int bestFit(int task = Busy;
tar->taskId = taskId;
p->n=p->n+1;
}
printf("内存分配成功！\n");
return 1;
} else {
//找不到合适的空闲分区
printf("找不到合适的内存分区，分配失败...\n");
return 0;
}
}
//回收内存
int freeSubArea(int taskId)
p = p->pre;
p->size += pp->size;
p->nxt = pp->nxt;
if(pp->nxt != NULL) {
pp->nxt->pre = p;
}
free(pp);
} else {
//情况4：上下分区均不用合并
p->state = Free;
p->taskId = -1;
pp->nxt->pre = p;
}
free(pp);
} else if((p->pre != &subHead && p->pre->state == Free)
实验五 动态分区分配方式内存管理模拟
实验五动态分区分配方式内存管理模拟一、实验目的1)掌握连续分配方式内存管理理论2)掌握动态分区分配方式内存管理理论二、实验原理动态分区分配：根据进程的实际需要，动态地创建分区为之分配内存空间，在实现动态分区分配时，将涉及分区分配中所使用的数据结构，分区分配算法和分区的分配与回收操作等问题。
1）分区分配中的数据结构空闲分区表：一个数据表，用于记录每个空闲块的情况，如起始地址、大小、使用情况等；空闲分区链表：把所有的空闲分区链接成一个链表，便于内存空间查看与分配回收。
2）分配算法首次适应法：空闲分区按首地址递增次序组织，每次查找时从链首出发，寻找满足要求的内存块。
循环首次适应算法：空闲分区按首地址递增次序组织，每次从上次查找的下一个空闲块开始查找，直到找到满足要求的内存块。
最佳适应法：空闲分区按空闲分区大小址递增次序组织，每次查找时从链首出发，寻找满足要求的最小内存块进行分配。
最坏适应法：空闲分区按空闲分区大小递减次序组织，每次查找时直接判断最大空闲分区是否满足要求。
3）内存分配过程利用分配算法找到满足要求的内存块，设请求的内存大小为size：若找到的空闲分区的大小等于size，完全分配；若找到的空闲分区大小大于size，且一分为二后，剩余大小小于1K，则不再分割，作为整体进行分配；否则一分为二，剩余部分仍然作为空闲分区存在；若无满足要求空闲分区，则分配失败4）内存回收根据释放区首址和大小，查找空闲分区表/链表，判断是否有相邻的空闲分区存在：释放区与前空闲区相邻：将释放区与前空闲区合并为一个空闲区。
其首址仍为前空闲区首址，大小为释放区大小与空闲区大小之和。
释放区与前后两个空闲区相邻：将这三个区合为一个空闲区，其首址为前空闲区首址，大小为这三个区大小之和，并取消原后空闲区表目。
释放区与后空闲区相邻：则把释放区合并到后空闲，首地址为释放区首地址，大小为二者大小之和。
释放区不与任何空闲区相邻：将释放区作为一个空闲区，将其大小和首址插入到空闲区表的适当位置。
计算机操作系统课程设计报告《存储管理——动态分区分配算法的模拟》
《计算机操作系统》课程设计题目：存储管理——动态分区分配算法的模拟专业：软件工程年级：2012级小组成员：指导教师：时间：地点：2012年5 月目录目录 (1)概述 (3)2. 课程设计任务及要求 (3)2.1 设计任务 (3)2.2 设计要求 (3)2.3 课程设计任务安排 (3)3. 算法及数据结构 (4)3.1算法的总体思想（流程） (4)3.2首次适应算法 (4)3.2.1 功能 (4)3.2.2 数据结构（包括变量的定义，要注释！） (4)3.2.3 算法（流程图表示，或伪C表示） (5)3.3循环首次适应算法 (6)3.3.1功能 (6)3.3.2 数据结构 (6)3.3.3算法 (7)3.4最佳适应算法 (8)3.4.1功能 (8)3.4.2 数据结构 (8)3.4.3算法 (8)3.5最坏适应算法 (10)3.5.1功能 (10)3.5.2 数据结构 (10)3.5.3算法 (11)4. 程序设计与实现 (12)4.1 程序流程图 (12)4.2 程序代码（要注释） (12)4.3 实验结果 (21)5. 结论 (23)6. 收获、体会和建议。
(23)A的总结： (23)B的总结： (23)7. 参考文献。
(24)概述动态分区分配是根据进程的实际需要，动态地为之分配内存空间，而在分配时，须按照一定的分配算法，从空闲分区表或空闲分区链中选出一分区分配给该作业。
在本实验中运用了五种分配算法，分别是：1.首次适应算法2.循环首次适应算法3.最坏适应算法4.最佳适应算法5. 快速适应算法2. 课程设计任务及要求2.1设计任务要求设计主界面以灵活选择其中算法，5种算法都要求实现。
2.2设计要求1）首先由系统生成当前的内存状态，要求未分配的分区数量不少于3个，且空间大小随机，然后随机生成一个数，表示等待分配进程的大小。
2）然后显示上述算法由用户选择，结果显示分配后的状态。
3. 算法及数据结构3.1算法的总体思想（流程）设计程序模拟四种动态分区分配算法：首次适应算法、循环首次适应算法、最佳适应算法和最坏适应算法的工作过程。