动态分区存储管理的模拟实现

合集下载

动态分区分配方式的模拟

动态分区分配方式的模拟

动态分区分配方式的模拟动态分区分配方式是计算机中内存管理的一种重要方式。

在动态分区分配方式中,内存空间被分割为多个不同大小的分区,每个分区可以被进程占用。

当一个进程需要内存时,系统会为其分配一个适当大小的分区,进程结束后,该分区将会被释放出来供其他进程使用。

为了更好地理解动态分区分配方式的原理和实际运作,可以通过模拟的方法来观察和分析。

下面是一个简单的动态分区分配方式的模拟过程:假设我们有一块容量为6400KB的内存,要模拟分配4个进程的情况。

这4个进程的内存需求分别是1000KB,2000KB,500KB和300KB。

首先,我们可以将内存划分为几个分区,每个分区的大小根据需要进行调整。

可以设置整块内存为一块分区(大小为6400KB),或者划分成多个较小的分区。

由于这里有4个进程需要分配内存,我们可以为它们设置4个分区,分别为P1,P2,P3和P41.初始状态:内存:[6400KB](未分配)进程:P1,P2,P3,P4(空)2.分配P1:内存:[1000KB](P1)、[5400KB](未分配)进程:P1,P2,P3,P4P1占用了1000KB的内存,剩余空间为5400KB。

3.分配P2:内存:[1000KB](P1)、[2000KB](P2)、[3400KB](未分配)进程:P1,P2,P3,P4P2占用了2000KB的内存,剩余空间为3400KB。

4.分配P3:内存:[1000KB](P1)、[2000KB](P2)、[500KB](P3)、[2900KB](未分配)进程:P1,P2,P3,P4P3占用了500KB的内存,剩余空间为2900KB。

5.分配P4:内存:[1000KB](P1)、[2000KB](P2)、[500KB](P3)、[300KB](P4)、[2600KB](未分配)进程:P1,P2,P3,P4P4占用了300KB的内存,剩余空间为2600KB。

在模拟的过程中,我们可以看到进程在内存中的分配情况和未分配内存的变化。

动态分区分配方式的模拟实验原理说明

动态分区分配方式的模拟实验原理说明

动态分区分配方式的模拟实验原理说明一、引言动态分区分配方式是操作系统中的一种内存管理方式,它将内存分为若干个不同大小的分区,根据进程的需求动态地分配内存。

在实际应用中,动态分区分配方式广泛应用于多任务操作系统中,如Windows、Linux等。

本文将介绍动态分区分配方式的模拟实验原理。

二、动态分区分配方式的基本原理动态分区分配方式是指在内存空间中按照进程需要划分出若干个不同大小的空间块,每个空间块可以被一个进程占用。

当有新进程需要内存时,操作系统会在空闲的空间块中选择一个大小合适的空间块给该进程使用。

当进程结束时,该进程所占用的空间块就会被释放出来,成为空闲块。

三、模拟实验环境搭建为了模拟动态分区分配方式,我们需要搭建一个虚拟机环境。

首先需要安装一款虚拟机软件(如VMware Workstation),然后安装一个操作系统(如Windows)。

接下来,在虚拟机中安装Visual Studio等开发工具。

四、模拟实验步骤1.设计数据结构为了方便管理内存空间,我们需要设计一种数据结构来存储内存块的信息。

我们可以使用链表来实现这一功能,每个节点表示一个内存块,包括该内存块的起始地址、大小以及状态(已分配或未分配)等信息。

2.初始化内存空间在模拟实验中,我们需要初始化一段虚拟内存空间。

我们可以使用一个数组来表示整个内存空间,并将其划分为若干个大小不同的空间块。

同时,我们需要将这些空间块的信息存储到链表中。

3.模拟进程请求内存在模拟实验中,我们需要模拟多个进程同时请求内存的情况。

当一个进程请求内存时,操作系统会根据其所需的内存大小,在空闲的空间块中选择一个合适的块分配给该进程,并将该块标记为已分配状态。

4.模拟进程释放内存当一个进程结束时,它所占用的内存块就会被释放出来,成为空闲块。

此时操作系统会更新链表信息,并将该块标记为未分配状态。

5.显示当前内存使用情况在模拟实验过程中,我们需要不断地显示当前的内存使用情况。

c++动态分区分配算法模拟(操作系统课程设计)

c++动态分区分配算法模拟(操作系统课程设计)

学习操作系统和计算机网 络,了解计算机系统的工 作原理
参加编程比赛和项目实践, 提高解决问题的能力
关注行业动态和技术发展, 不断学习新知识和技能
感谢您的观看
汇报人:
算法性能评估
时间复杂度:O(n)
空间复杂度:O(1)
稳定性:稳定
适用场景:适用于动态分 区分配问题
模拟结果总结与反思
模拟结果:动态分区分配算法的性能表现 优点:提高了内存利用率,减少了内存碎片 缺点:增加了内存管理开销,可能导致内存碎片 改进方向:优化内存管理算法,提高内存利用率和性能
05 课程设计总结与展望优化目标Leabharlann 提高 算法的执行效率 和内存利用率
优化策略:采用 动态调整分区大 小、优化内存分 配策略等方法
优化效果:通过 优化,可以提高 算法的执行效率 和内存利用率, 降低内存碎片率, 提高系统的稳定 性和可靠性。
04 模拟结果分析
内存分配情况统计
内存分配次数:统 计模拟过程中内存 分配的次数
确定分区大小和数量
确定分区大小:根据需求确定分区大小,如1KB、2KB等 确定分区数量:根据需求确定分区数量,如10个、20个等 分区分配策略:采用最佳适应算法、最坏适应算法、首次适应算法等 分区合并策略:采用分区合并算法,如合并空闲分区、合并相邻空闲分区等
实现分区分配算法
初始化:设置分区表,记录每个分区的状态和位置 分配:根据请求大小,查找合适的分区 合并:将相邻的空闲分区合并为一个大分区 分割:将大分区分割为多个小分区 回收:释放不再使用的分区,将其加入空闲分区列表 维护:定期整理分区表,保持分区信息的准确性
实现内存回收函数
内存回收函数的作用:释放不再使用的内存空间,提高内存利用率 内存回收函数的实现:通过遍历内存块链表,找到空闲内存块,将其添加到空闲链表中 内存回收函数的调用:在程序运行过程中,当需要释放内存时,调用内存回收函数 内存回收函数的优化:通过改进算法,提高内存回收的效率和准确性

使用最佳适应算法对内存实现模拟动态分区管理

使用最佳适应算法对内存实现模拟动态分区管理

使用最佳适应算法对内存实现模拟动态分区管理摘要:内存动态分区管理的算法是操作系统课程中一个重要内容,理解和学习不同的分区算法能够为深入学习操作系统等知识提供一定的理论知识和实践依据。

本文采用c语言程序设计出最佳适应算法来模拟计算机内存分区管理,减少内存分配时产生的碎片,以此提高操作系统的稳定性。

关键词: c语言;模拟;内存分区;分配管理;最佳适应算法中图分类号:tp301 文献标识码:a 文章编号:1006-4311(2013)16-0214-021 模拟算法的设计思想计算机操作系统的最佳适应算法(best fit)是动态内存分区分配算法的一种[1]。

它能够从全部空闲区找出满足作业要求并且最小的空闲分区,这种算法能够让产生的碎片尽量缩小。

为了提高寻找速度,这种算法要求将所有的空闲区按其内容以从小到大的顺序形成一个空闲分区链。

这样,第一次找到的能满足要求的空闲区,必然是最佳的[2]。

最佳适应算法利用的思想就是将地址相邻近的自由区与回收区进行有效地合并,通过初始化空闲区、分配空闲区、回收空闲区实现模拟的内存管理,从而尽量减少碎片的产生,并尽可能的利用内存空间。

2 模拟算法的设计2.1 定义空闲分区链结构初始化时内存分配最大值定义为35670。

全局变量申明:设置分区描述器:2.2 主函数主函数main()包括:建立头结点head;定义内存分配申请1和回收内存2的选择,如果输入1则输入申请的内存大小并调用分配函数assign1=assignment(head,application1),若assign1->address==-1则分配不成功,则调用printf()函数输出“申请失败”,否则分配成功,用assign1->address进行分配;输入2将调用printf()函数提示“输入回收区的首地址和回收区的大小”,然后用语句check=backcheck(head,back)函数判断申请是否合法,若输入合法,则调用do-while循环语句多次查找适应的节点,并再次调用printf()函数输出回收结果。

实验五动态分区分配算法的模拟

实验五动态分区分配算法的模拟

实验五动态分区分配算法的模拟为了更好地理解动态分区分配算法的工作原理,我们可以进行一次模拟实验。

在实验中,我们将模拟一个内存分区,并使用动态分区分配算法来管理这些分区。

首先,让我们定义一个内存大小为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();}。

实验五-动态分区存储管理

实验五-动态分区存储管理

实验五动态分区存储管理一、实验目的深入了解采用动态分区存储管理方式的内存分配回收的实现。

通过编写和调试存储管理的模拟程序以加深对存储管理方案的理解,熟悉动态分区存储管理的内存分配和回收。

二、实验内容编写程序完成动态分区存储管理方式的内存分配回收。

具体包括:确定内存空间分配表;采用最优适应算法完成内存空间的分配和回收;编写主函数对所做工作进行测试。

三、设计思路整体思路:动态分区管理方式将内存除操作系统占用区域外的空间看成一个大的空闲区。

当作业要求装入内存时,根据作业需要内存空间的大小查询内存中的各个空闲区,当从内存空间中找到一个大于或等于该作业大小的内存空闲区时,选择其中一个空闲区,按作业需求量划出一个分区装人该作业,作业执行完后,其所占的内存分区被收回,成为一个空闲区。

如果该空闲区的相邻分区也是空闲区,则需要将相邻空闲区合并成一个空闲区。

设计所采用的算法:采用最优适应算法,每次为作业分配内存时,总是把既能满足要求、又是最小的空闲分区分配给作业。

但最优适应算法容易出现找到的一个分区可能只比作业所需求的长度略大一点的情行,这时,空闲区分割后剩下的空闲区就很小以致很难再使用,降低了内存的使用率。

为解决此问题,设定一个限值minsize,如果空闲区的大小减去作业需求长度得到的值小于等于minsize,不再将空闲区分成己分分区和空闲区两部分,而是将整个空闲区都分配给作业。

内存分配与回收所使用的结构体:为便于对内存的分配和回收,建立两张表记录内存的使用情况。

一张为记录作业占用分区的“内存分配表”,内容包括分区起始地址、长度、作业名/标志〔为0时作为标志位表示空栏目〕;一张为记录空闲区的“空闲分区表”,内容包括分区起始地址、长度、标志〔0表空栏目,1表未分配〕。

两张表都采用顺序表形式。

关于分配留下的内存小碎片问题:当要装入一个作业时,从“空闲分区表”中查找标志为“1”〔未分配〕且满足作业所需内存大小的最小空闲区,假设空闲区的大小与作业所需大小的差值小于或等于minsize,把该分区全部分配给作业,并把该空闲区的标志改为“0”〔空栏目〕。

动态分区分配方式模拟

动态分区分配方式模拟

动态分区分配方式模拟动态分区分配方式的核心思想是将内存划分为若干个不同大小的分区,每个分区可以用来存放一个进程或作为一部分进程的存储区域。

当一个进程需要分配内存时,系统会根据进程的需要选择一个合适大小的空闲分区分配给该进程。

当进程执行完毕后,系统会回收其占用的内存分区,再次将其标记为空闲分区。

首次适应算法(First Fit)是最简单的动态分区分配算法之一、它从内存的起始位置开始,寻找第一个满足进程需要的空闲分区,然后将该分区分配给进程。

首次适应算法的优点是实现简单,且内存利用率较高。

然而,它也有一些缺点,比如容易产生碎片,导致内存的利用率下降。

最佳适应算法(Best Fit)是根据进程需要的内存大小,选择最小的满足条件的空闲分区进行分配。

最佳适应算法可以最大限度地减少碎片的产生,提高内存的利用率。

但是,最佳适应算法的缺点是实现较为复杂,同时由于选择最小的分区进行分配,会导致大量的碎片出现。

最坏适应算法(Worst Fit)与最佳适应算法相反,它选择最大的满足进程需要的空闲分区进行分配。

最坏适应算法的优点是可以减少大型进程的外部碎片,但由于选择最大的分区进行分配,会导致更多的碎片产生。

为了更好地理解动态分区分配方式,我们可以通过一个简单的模拟实例来进行说明。

假设有一块内存大小为1MB,现有以下三个请求需要进行内存分配:1.进程A需要200KB的内存;2.进程B需要400KB的内存;3.进程C需要600KB的内存。

首次适应算法:首先,进程A需要200KB的内存,首次适应算法从内存起始位置开始寻找空闲分区,找到一个大小符合要求的空闲分区,将其分配给进程A。

然后,进程B需要400KB的内存,首次适应算法会从上次分配的位置开始,找到一个大小满足要求的空闲分区,并将其分配给进程B。

最后,进程C需要600KB的内存,首次适应算法会继续从上次分配的位置开始,但发现没有足够的空闲分区,分配失败。

最佳适应算法:最佳适应算法需要对所有空闲分区进行排序,按照分区大小的升序排列。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
node->size = tar->size - size;
node->state = Free;
node->taskId = -1;
//修改分区链节点指针
node->pre = tar;
node->nxt = tar->nxt;
if (tar->nxt != NULL)
{
tar->nxt->pre = node;
scanf("%d", &taskId);
printf("请输入需要分配的内存大小(KB):");
scanf("%d", &size);
if (size <= 0)
{
printf("错误:分配内存大小必须为正值\n");
continue;
}
//调用分配算法
bestFit(taskId, size);
//显示空闲分区链情况
showSubArea();
}
else if (ope == 2)
{
//模拟回收内存
printf("请输入要回收的作业号:");
scanf("%d", &taskId);
freeSubArea(taskId);
//显示空闲分区链情况
showSubArea();
}
else
{
printf("错误:请输入0/1/2\n");
int bestFit(int taskId, int size)
{
subAreaNode *tar = NULL;
int tarSize = 240 + 1;
subAreaNode *p = subHead.nxt;
while (p != NULL)
{
//寻找最佳空闲区间
if (p->state == Free && p->size >= size && p->size < tarSize)
p->nxt = pp->nxt;
pp->nxt->pre = p;
free(pp);
//后合并下区间
pp = p->nxt;
p->size += pp->size;
p->nxt = pp->nxt;
if (pp->nxt != NULL)
{
pp->nxt->pre = p;
}
free(pp);
}
else if ((p->pre == &subHead || p->pre->state == Busy)
p = p->nxt;
}
if (flag == 1)
{
//回收成功
printf("内存分区回收成功...\n");
return 1;
}
else
{
//找不到目标作业,回收失败
printf("找不到目标作业,内存分区回收失败...\n");
return 0;
}
}
//显示空闲分区链情况
void showSubArea()
(1).输出此时的已分配区表和未分配区表;
(2).装入Job3(15K),输出主存分配后的已分配区表和未分配区表;
(3).回收Job2所占用的主存空间,输出主存回收后的已分配区表和未分配区表;
(4).装入Job4(130K),输出主存分配后的已分配区表和未分配区表。
实验要求
1.数据结构参考定义如下,也可根据需要进行改进:
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;
}
}
#include<stdlib.h>
enum STATE
{
Free,
Busy
};
struct subAreaNode
{
int addr; //起始地址
int size; //分区大小
int taskId; //作业号
STATE state; //分区状态
subAreaNode *pre; //分区前向指针
{
pp->nxt->pre = p;
}
free(pp);
}
else if ((p->pre != &subHead && p->pre->state == Free)
&& (p->nxt == NULL || p->nxt->state == Busy))
{
//情况3:只合并上面的分区
pp = p;
}used_table[n];/*已分配区表*/
(2)未分配区表:
#define m 10/*假定系统允许的空闲区表最大为m,m值为10*/
struct
{int number;/*序号*/
int address;/*空闲区起始地址,单位为KB */
int length;/*空闲区长度,单位为KB*/
计算机科学与工程学院学生实验报告
专业
计算机科学与技术
班级
学号
姓名
课程名称
操作系统
课程类型
专业必修课
实验名称
动态分区存储管理的模拟实现
实验目的:
1.熟悉动态分区存储管理方式下,主存空间的分配和回收算法。
2.提高C语言编程能力。
实验内容:
假设主存当前状态如右表所示:
系统采用最佳适应分配算法为作业分配主存空间,而且具有紧凑技术。请编程完成以下操作:
fir->size = 240; //内存初始大小
fir->state = Free;
fir->taskId = -1;
fir->pre = &subHead;
fir->nxt = NULL;
//初始化分区头部信息
subHead.pre = NULL;
subHead.nxt = fir;
}
//最佳适应算法
5.程序调试、运行成功后,请老师检查。
实验步骤:
1.分配内存,结果如下图:
2.回收内存,结果如下图:
3.合并内存,结果如下图:
4.N-S流程图:
Байду номын сангаас4.1内存分配流程图:
4.2内存回收流程图:
附录程序代码:
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
}
}
//回收内存
int freeSubArea(int taskId)
{
int flag = 0;
subAreaNode *p = subHead.nxt, *pp;
while (p != NULL)
{
if (p->state == Busy && p->taskId == taskId)
{
flag = 1;
}
}
printf("分配算法模拟结束\n");
system("pause");
return 0;
}
实验总结:通过本次实验,基本实现了内存分配和内存回收,内存分配中所运用的算法是最佳适应分配算法,但是该程序没有实现紧凑性,程序其他方面没有问题。
实验评语:
实验成绩
教师签名
int flag;/*空闲区表登记栏标志,0:空表项;1:空闲区*/
}free_table[m];/*空闲区表*/
2.以allocate命名主存分配所用的过程或函数(算法参考课件),要将各种情况考虑周全。
3.以reclaim命名主存回收所用的过程或函数(算法参考课件),要将各种情况考虑周全。
4.画出算法实现的N-S流程图。
if ((p->pre != &subHead && p->pre->state == Free)
&& (p->nxt != NULL && p->nxt->state == Free))
{
//情况1:合并上下两个分区
//先合并上区间
pp = p;
p = p->pre;
p->size += pp->size;
subAreaNode *nxt; //分区后向指针
}subHead;
//初始化空闲分区链
void intSubArea()
{
//分配初始分区内存
subAreaNode *fir = (subAreaNode *)malloc(sizeof(subAreaNode));
//给首个分区赋值
fir->addr = 0;
&& (p->nxt != NULL && p->nxt->state == Free))
相关文档
最新文档