动态分区分配方式的模拟实验报告模板
采用首次适应算法的动态分区分配模拟课程设计实验报告
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. 创建一个动态内存分配模拟程序，包括空闲分区链表、分配函数和回收函数。
动态分区算法实验报告
动态分区算法实验报告动态分区算法实验报告一、引言计算机操作系统是现代计算机系统中的核心组成部分，它负责管理计算机硬件资源，并提供各种服务。
内存管理是操作系统的重要功能之一，它负责管理计算机的内存资源，为进程提供运行环境。
在内存管理中，动态分区算法是一种常用的内存分配策略。
本实验旨在通过实践，深入了解动态分区算法的原理和实现。
二、实验目的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();}。
动态分区分配方式的模拟
this.work=work;
}
publicString getNumber() {
returnnumber;
}
publicvoidsetNumber(Stringnumber) {
this.number=number;
}
publicString getSize() {
pstmt = conn.prepareStatement(sql);
pstmt.setString(1, number);
int num = pstmt.executeUpdate();
System.out.println("删除"+num+"条数据");
}finally {
/*ConnectionFactory.close(null, pstmt, conn);*/
Connection conn = null;
PreparedStatement pstmt = null;
try {
conn = ConnectionFactory.getConnection();
String sql = " delete from zone where number = ?";
太原工业学院计算机工程系
操作系统实验报告（）
实验名称
动态分区分配方式的模拟
实验日期
2016/12/3
成绩
姓名
班级学号
实
验
目
的
了解动态分区分配方式中使用的数据结构和分配算法，进一步加深对动态分区存储管理方式及其实现过程的理解
实
验
环
计算机操作系统实验报告动态分区分配方式的模拟
计算机操作系统实验报告姓名：班级：学号：题目：动态分区分配方式的模拟实习内容简要描述本次实验要完成两部分内容：一是用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;
动态分区分配算法实验报告
操作系统实验报告实验二:动态分区分配算法学生：学号：学院：系别：专业：实验时间：报告时间：一、实验内容编写一个内存动态分区分配模拟程序，模拟内存的分配和回收的完整过程。
一个好的计算机系统不仅要有一个足够容量的、存取速度高的、稳定可靠的主存储器，而且要能合理地分配和使用这些存储空间。
当用户提出申请存储器空间时，存储管理必须根据申请者的要求，按一定的策略分析主存空间的使用情况，找出足够的空闲区域分配给申请者。
当作业撤离或主动归还主存资源时，则存储管理要收回作业占用的主存空间或归还部分主存空间。
主存的分配和回收的实现与主存储器的管理方式有关的，通过本实验帮助学生理解在可变分区管理方式下应怎样实现主存空间的分配和回收。
三、实验原理模拟在可变分区管理方式下采用最先适应算法实现主存分配和回收。
(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）回收区与插入点的后一空闲分区相邻接，将两个分区合并，形成新的分区。
操作系统实验四实验报告动态分区分配算法
操作系统实验四【实验题目】：动态分区分配算法【实验学时】：4学时【实验目的】通过这次实验，加深对动态分区分配算法的理解，进一步掌握首次适应算法、循环首次适应算法、最佳适应算法和最坏适应算法的实现方法。
【实验内容及要求】问题描述：设计程序模拟四种动态分区分配算法：首次适应算法、循环首次适应算法、最佳适应算法和最坏适应算法的工作过程。
假设内存中空闲分区个数为n，空闲分区大小分别为P1, … ,P n，在动态分区分配过程中需要分配的进程个数为m（m≤n），它们需要的分区大小分别为S1, … ,S m，分别利用四种动态分区分配算法将m个进程放入n个空闲分区，给出进程在空闲分区中的分配情况。
程序要求：1）利用首次适应算法、循环首次适应算法、最佳适应算法和最坏适应算法四种动态分区分配算法模拟分区分配过程。
2）模拟四种算法的分区分配过程，给出每种算法进程在空闲分区中的分配情况。
3）输入：空闲分区个数n，空闲分区大小P1, … ,P n，进程个数m，进程需要的分区大小S1, … ,S m。
4）输出：首次适应算法，循环首次适应算法，最佳适应算法，最坏适应算法，最终内存空闲分区的分配情况。
实现源代码：#include<iostream>#include<fstream>#include<iomanip>#include<string>#define max 100using namespace std;int work_num;int zone_num;struct Data{int data;char name;};Data *d=new Data[max];struct Table{int data;char array[max];int length;};Table *T=new Table[max];Table *temp=new Table[max];void Init(){ifstream inf("DTFQ.txt");int i,j;char ch;inf>>work_num;cout<<"作业数："<<work_num<<endl;inf>>zone_num;cout<<"空闲分区数："<<zone_num<<endl;cout<<" 作业为：";for(j=0;j<work_num;j++){inf.get(ch);d[j].name=ch;cout<<setw(4)<<d[j].name;}cout<<endl;cout<<"作业大小：";for(i=0;i<work_num;i++){.inf>>d[i].data;cout<<setw(4)<<d[i].data;}cout<<endl;cout<<"空闲分区：";for(j=0;j<zone_num;j++){inf>>T[j].data;temp[j].data=T[j].data;T[j].length=0;temp[j].length=0;cout<<setw(4)<<T[j].data;}cout<<endl;}void renew(){int j;for(j=0;j<zone_num;j++){T[j].data=temp[j].data;T[j].length=temp[j].length;}}void re(){int i;for(i=0;i<zone_num;i++){T[i].array[T[i].length]='#';}}void show(){int i,j;re();for(i=0;i<zone_num;i++){if(T[i].data==temp[i].data)cout<<setw(4)<<T[i].data;else{cout<<setiosflags(ios::right)<<setw(4)<<T[i].data<<setw(1);for(j=0;j<T[i].length;j++){if(T[i].array[j]=='#')break;elsecout<<setiosflags(ios::right)<<T[i].array[j];}}}cout<<endl;}void first_fit(){renew();cout<<"fist fit：";int i,j;int tag=0;for(i=0;i<work_num;i++){for(j=0;j<zone_num;j++){if(d[i].data<=T[j].data){T[j].data=T[j].data - d[i].data;T[j].array[T[j].length]=d[i].name;T[j].length++;tag=0;break;}elsetag=1;}if(tag==1){cout<<"作业太大，无满足条件分区！"<<endl;break;}}//re();}void next_fit(){renew();cout<<"next fit：";int i,j;int m=0,tag=0,count=0;for(i=0;i<work_num;i++){for(j=m;j<zone_num;j++){if(d[i].data<=T[j].data){T[j].data=T[j].data - d[i].data;T[j].array[T[j].length]=d[i].name;T[j].length++;tag=0;m=j;break;}else{tag=1;count++;}}while(tag==1 && count<zone_num){for(j=0;j<m;j++){if(d[i].data<=T[j].data){T[j].data=T[j].data - d[i].data;T[j].array[T[j].length]=d[i].name;T[j].length++;tag=0;break;}else{tag=1;count++;}}}if(tag==1 && count==zone_num){cout<<"作业太大，无满足条件分区！"<<endl;break;}}//re();}void best_fit(){renew();cout<<"best fit：";int i,j,k,temp,m;int tag=0,n=0;for(i=0;i<work_num;i++){for(j=0;j<zone_num;j++){if(d[i].data<=T[j].data){temp=T[j].data;m=j;int tag1=0;for(k=m+1;k<=zone_num;k++){if(T[k].data<temp){if(T[k].data>=d[i].data){temp=T[k].data;n=k;tag1=1;}}else if(tag1==0)n=j;}T[n].data=temp - d[i].data;T[n].array[T[n].length]=d[i].name;T[n].length++;tag=0;break;}elsetag=1;}if(tag==1){cout<<"作业太大，无满足条件分区！"<<endl;break;}}//re();}void worst_fit(){renew();cout<<"worst fit：";int i,j,k,temp,m;int tag=0,n=0;for(i=0;i<work_num;i++){for(j=0;j<zone_num;j++){if(d[i].data<=T[j].data){int tag1=0;temp=T[j].data;m=j;for(k=m+1;k<=zone_num;k++){if(T[k].data>temp){if(T[k].data>=d[i].data){temp=T[k].data;n=k;tag1=1;}}else if(tag1==0)n=j;}T[n].data=temp - d[i].data;T[n].array[T[n].length]=d[i].name;T[n].length++;tag=0;break;}elsetag=1;}if(tag==1){cout<<"作业太大，无满足条件分区！"<<endl;break;}}//re();}void main(){Init();first_fit();show();next_fit();show();best_fit();show();worst_fit();show();system("pause");}实验截图：如有侵权请联系告知删除，感谢你们的配合！。
计算机操作系统动态分区存储管理方式下的内存空间的分配与回收实验报告
计算机操作系统动态分区存储管理方式下的内存空间的分配与回收实验报告第一篇：计算机操作系统动态分区存储管理方式下的内存空间的分配与回收实验报告计算机操作系统实验报告实验二实验题目：存储器管理系别：计算机科学与技术系班级：姓名：学号：2一、实验目的深入理解动态分区存储管理方式下的内存空间的分配与回收。
二、实验内容编写程序完成动态分区存储管理方式下的内存分配和回收的实现。
具体内容包括：确定用来管理内存当前使用情况的数据结构；采用首次适应算法完成内存空间的分配；分情况对作业进行回收；编写主函数对所做工作进行测试。
三、实验原理分配：动态分区存储管理方式把内存除OS占用区域外的空间看作一个大的空闲区。
当作业要求装入内存时，根据作业需要内存空间的大小查询内存中各个空闲区，当从内存中找到一个大于或等于该作业大小的内存空闲区时，选择其中一个空闲区，按作业要求划出一个分区装入该作业。
回收：作业执行完后，它所占用的内存空间被收回，成为一个空闲区。
如果该空闲区的相邻分区也是空闲区，则需要将相邻空闲区合并成一个空闲区。
四、实验方法实现动态分区的分配与回收，主要考虑三个问题：第一、设计记录内存使用情况的数据表格，用来记录空闲区和作业占用的区域(利用结构体类型数组来保存数据)；第二、在设计的数据表格基础上设计内存分配算法（采用首次适应算法找合适的分区（对空闲分区表进行排序），分配时要考虑碎片问题）；第三、在设计的数据表格基础上设计内存回收算法（分四种情况进行回收（上邻、下邻、上下邻和无相邻分区）。
五、实验步骤第一，设计记录内存使用情况的数据表格λ已分配分区表：起始地址、长度、标志（0表示“空表项”，1表示“已分配”）λ空闲分区表：起始地址、长度、标志（0表示“空表项”，1表示“未分配”）struct used_table { float address;//已分分区起始地址float length;//已分分区长度，单位为字节int flag;//已分配表区登记栏标志，用0表示空栏目，char zuoyename;};//已分配区表Struct free_table[ { float address;//空闲分区起始地址float length;//空闲分区长度，单位为字节int flag;//空闲分区表登记栏目用0表示空栏目，1表示未配};//空闲分区表第二，在设计的表格上进行内存分配λ首次适应算法：为作业分配内存，要求每次找到一个起始地址最小的适合作业的分区（按起始地址递增排序）。
操作系统试验动态分区分配 某系统采用动态分区分配方式
操作系统试验动态分区分配某系统采用动态分区分配方式实验报告课程名称________操作系统试验____________实验名称________动态分区分配___________实验类型_________验证型_________________实验地点___机房___实验日期__2011_指导教师__________________________专业_计算机科学与技术_班级__________学号______________姓名____________成绩________________XX大学计算机与通信工程学院实验3动态分区分配一．实验目的用高级语言编写和调试一个内存分配模拟程序，以加深对动态分区的概念及内存分配原理的理解。
二．实验原理可变分区调度算法有:最先适应分配算法,最优适应分配算法,最坏适应算法。
用户提出内存空间的申请；系统根据申请者的要求，按照一定的分配策略分析内存空间的使用情况，找出能满足请求的空闲区，分给申请者；当程序执行完毕或主动归还内存资源时，系统要收回它所占用的内存空间或它归还的部分内存空间。
每当一个进程被创建时，内存分配程序首先要查找空闲内存分区表（链），从中寻找一个合适的空闲块进行划分，并修改空闲内存分区表（链）。
当进程运行完毕释放内存时，系统根据回收区的首址，从空闲区表（链）中找到相应的插入点，此时出现如下四种情况：1)回收区与插入点的前一个空闲分区F1相邻接，此时可将回收区直接与F1合并，并修改F1的大小；2)回收区与插入点的后一个空闲分区F2相邻接，此时可将回收区直接与F2合并，并用回收区的首址最为新空闲区的首址，大小为二者之和；3)回收区同时与插入点的前、后两个空闲分区邻接，此时需将三者合并；4)回收区不与任何一个空闲区邻接，此时应建一新的表项。
三．实验内容编写并调试一个模拟的内存分配程序。
具体做法为：使用一个循环，根据提示，由用户选择随时创建一个新的进程，并为其分配存储空间，也随时可以撤销一个进程，可以根据需要随时打印空闲分区表（链）以及打印系统中内存使用情况。
实验五 动态分区分配方式内存管理模拟
实验五动态分区分配方式内存管理模拟一、实验目的1)掌握连续分配方式内存管理理论2)掌握动态分区分配方式内存管理理论二、实验原理动态分区分配：根据进程的实际需要，动态地创建分区为之分配内存空间，在实现动态分区分配时，将涉及分区分配中所使用的数据结构，分区分配算法和分区的分配与回收操作等问题。
1）分区分配中的数据结构空闲分区表：一个数据表，用于记录每个空闲块的情况，如起始地址、大小、使用情况等；空闲分区链表：把所有的空闲分区链接成一个链表，便于内存空间查看与分配回收。
2）分配算法首次适应法：空闲分区按首地址递增次序组织，每次查找时从链首出发，寻找满足要求的内存块。
循环首次适应算法：空闲分区按首地址递增次序组织，每次从上次查找的下一个空闲块开始查找，直到找到满足要求的内存块。
最佳适应法：空闲分区按空闲分区大小址递增次序组织，每次查找时从链首出发，寻找满足要求的最小内存块进行分配。
最坏适应法：空闲分区按空闲分区大小递减次序组织，每次查找时直接判断最大空闲分区是否满足要求。
3）内存分配过程利用分配算法找到满足要求的内存块，设请求的内存大小为size：若找到的空闲分区的大小等于size，完全分配；若找到的空闲分区大小大于size，且一分为二后，剩余大小小于1K，则不再分割，作为整体进行分配；否则一分为二，剩余部分仍然作为空闲分区存在；若无满足要求空闲分区，则分配失败4）内存回收根据释放区首址和大小，查找空闲分区表/链表，判断是否有相邻的空闲分区存在：释放区与前空闲区相邻：将释放区与前空闲区合并为一个空闲区。
其首址仍为前空闲区首址，大小为释放区大小与空闲区大小之和。
释放区与前后两个空闲区相邻：将这三个区合为一个空闲区，其首址为前空闲区首址，大小为这三个区大小之和，并取消原后空闲区表目。
释放区与后空闲区相邻：则把释放区合并到后空闲，首地址为释放区首地址，大小为二者大小之和。
释放区不与任何空闲区相邻：将释放区作为一个空闲区，将其大小和首址插入到空闲区表的适当位置。
用于动态分区分配的仿真实验报告模板.doc
用于动态分区分配的仿真实验报告模板华北电力大学已核实并上报了实验名称、仿真课程名称、动态分区分配方法、计算机操作系统专业课:学生姓名:号码:成就:讲师:实验日期:I .实验目的:了解动态分区分配方法中使用的数据结构和分配算法，进一步加深对动态分区存储管理方法及其实施过程的理解。
二、实验内容:(1)使用第一自适应算法和最佳自适应算法的动态分区分配过程alloc()和恢复过程free()分别用C语言实现。
其中，空闲分区由分区链管理；在内存分配中，系统优先考虑空闲区下端的空间。
(2)假设初始状态下的可用内存空间为640K，有以下请求序列:工作1需要130千字节。
对于任务2，申请60KB。
对于任务3，申请100KB。
◎作业2释放60KB。
对于任务4，申请200千字节。
◎作业3释放100KB。
作业1释放130KB。
作业5需要140千字节。
◎任务6适用于60KB。
◎作业7适用于50KB。
◎作业6释放60KB。
请分别使用首次自适应算法和最佳自适应算法来分配和回收内存块。
要求在每次分配和回收后显示空闲内存分区链的情况。
四、设计思路和方法:第一个自适应算法(学名:号码:成就:讲师:实验日期:I .实验目的:了解动态分区分配方法中使用的数据结构和分配算法，进一步加深对动态分区存储管理方法及其实施过程的理解。
二、实验内容:(1)使用第一自适应算法和最佳自适应算法的动态分区分配过程alloc()和恢复过程free()分别用C语言实现。
其中，空闲分区由分区链管理；在内存分配中，系统优先考虑空闲区下端的空间。
(2)假设初始状态下的可用内存空间为640K，有以下请求序列:工作1需要130千字节。
对于任务2，申请60KB。
对于任务3，申请100KB。
◎作业2释放60KB。
对于任务4，申请200千字节。
◎作业3释放100KB。
作业1释放130KB。
作业5需要140千字节。
◎任务6适用于60KB。
◎作业7适用于50KB。
◎作业6释放60KB。