可变分区存储管理方式的内存分配和回收实验报告(最优算法)

合集下载

可变分区存储管理的内存分配算法模拟实现----最佳适应算法

可变分区存储管理的内存分配算法模拟实现----最佳适应算法

可变分区存储管理的内存分配算法模拟实现----最佳适应算法可变分区存储管理是一种内存管理技术,其通过将内存分割成不同大小的区域来存储进程。

每个进程被分配到与其大小最匹配的区域中。

内存分配算法的选择影响了系统的性能和资源利用率。

本文将介绍最佳适应算法,并模拟实现该算法。

一、什么是最佳适应算法?最佳适应算法是一种可变分区存储管理中的内存分配策略。

它的基本思想是在每次内存分配时选择最合适的空闲区域。

具体来说,它从可用的空闲区域中选择大小与需要分配给进程的内存最接近的区域。

二、算法实现思路最佳适应算法实现的关键是如何快速找到最合适的空闲区域。

下面给出一个模拟实现的思路:1. 初始化内存分区列表,首先将整个内存定义为一个大的空闲区域。

2. 当一个进程请求分配内存时,从列表中找到与所需内存最接近的空闲区域。

3. 将该空闲区域分割成两部分,一部分分配给进程,并将该部分标记为已分配,另一部分留作新的空闲区域。

4. 更新内存分区列表。

5. 当一个进程释放内存时,将其所占用的内存区域标记为空闲,然后尝试合并相邻的空闲区域。

三、算法模拟实现下面是一个简单的Python代码实现最佳适应算法:pythonclass MemoryPartition:def __init__(self, start_addr, end_addr, is_allocated=False): self.start_addr = start_addrself.end_addr = end_addrself.is_allocated = is_allocatedclass MemoryManager:def __init__(self, total_memory):self.total_memory = total_memoryself.partition_list = [MemoryPartition(0, total_memory)]def allocate_memory(self, process_size):best_fit_partition = Nonesmallest_size = float('inf')# 找到最佳适应的空闲区域for partition in self.partition_list:if not partition.is_allocated and partition.end_addr - partition.start_addr >= process_size:if partition.end_addr - partition.start_addr < smallest_size:best_fit_partition = partitionsmallest_size = partition.end_addr - partition.start_addrif best_fit_partition:# 将空闲区域分割,并标记为已分配new_partition =MemoryPartition(best_fit_partition.start_addr,best_fit_partition.start_addr + process_size, True)best_fit_partition.start_addr += process_sizeself.partition_list.append(new_partition)return new_partition.start_addr,new_partition.end_addrelse:return -1, -1def deallocate_memory(self, start_addr, end_addr):for partition in self.partition_list:if partition.start_addr == end_addr and not partition.is_allocated:# 标记空闲区域partition.is_allocated = False# 尝试合并相邻空闲区域for next_partition in self.partition_list:if not next_partition.is_allocated andnext_partition.start_addr == end_addr:end_addr = next_partition.end_addrself.partition_list.remove(next_partition)breakelse:breakdef print_partitions(self):for partition in self.partition_list:if partition.is_allocated:print(f"Allocated Partition: {partition.start_addr} - {partition.end_addr}")else:print(f"Free Partition: {partition.start_addr} - {partition.end_addr}")# 测试最佳适应算法if __name__ == "__main__":mm = MemoryManager(1024)start, end = mm.allocate_memory(256)print(f"Allocated memory: {start} - {end}")mm.print_partitions()mm.deallocate_memory(start, end)print("Memory deallocated:")mm.print_partitions()以上代码实现了一个简单的内存管理器类`MemoryManager`,它具有`allocate_memory`和`deallocate_memory`等方法。

在可变分区存储管理中,最优适应分配算法

在可变分区存储管理中,最优适应分配算法

在可变分区存储管理中,最优适应分配算法
最优适应分配算法(optimal fit algorithm)是可变分区存储管理中常用的算法,它是以一种有效而实用方式来利用磁盘存储空间的技术,目的是使用最小的空间来存放最多的文件。

一、算法简介
最优适应分配算法是在可变分区存储管理系统中应用最多的一种有效算法。

它通过寻找和利用未被利用的空间,有效地管理存储空间,减少内存的浪费。

此算法的基本原理是比较进程的内存空间需求和当前空闲分区的剩余空间,选择一个空闲分区分配给进程,使得分配的这块空间刚好能够满足进程的内存空间需求。

二、算法的优势
1、空间利用率高:最优适应分配算法做了色样的优化,通过对比空闲区和进程大小,可以在多个空闲区中选择一个最合适的空间来分配,这就有效地将空闲分区完全利用起来。

2、降低内存碎片:最优适应分配算法在进行存储空间的分配时,给每一个进程的存储空间要求满足有效利用完可用的空闲分区,这样就可以有效地降低内存碎片的影响。

3、处理时间短暂:最优适应分配算法虽然空间利用率高,但是相对地,其耗费的时间是少的,因此,这种算法可以满足时间要求,确保效率。

三、应用情况
最优适应分配算法主要用于可变分区存储管理技术,这种技术可以有效地管理大量文件,而不会浪费空间。

而且现在,这种算法已经被广泛应用于嵌入式系统中,专家们尤其是在嵌入式系统设计中广泛地使用最优适应分配算法,以在CPU装入的程序数量、运行程序数量不变的情况下,达到最大的利用空间效果。

内存的分配和回收分区链实验报告按照这个内容来完成

内存的分配和回收分区链实验报告按照这个内容来完成

一、实验目的理解分区式存储管理的基本原理,熟悉分区分配和回收算法。

即理解在不同的存储管理方式下,如何实现主存空间的分配与回收;并掌握动态分区分配方式中的数据结构和分配算法及动态分区存储管理方式及其实现过程。

二、设备与环境1. 硬件设备:PC机一台2. 软件环境:安装Windows操作系统或者Linux操作系统,并安装相关的程序开发环境,如VC \VC++\Java 等编程语言环境。

三、实验原理实验要求使用可变分区存储管理方式,分区分配中所用的数据结构采用空闲分区表和空闲分区链来进行,分区分配中所用的算法采用首次适应算法、最佳适应算法、最差适应算法三种算法来实现主存的分配与回收。

同时,要求设计一个实用友好的用户界面,并显示分配与回收的过程。

同时要求设计一个实用友好的用户界面,并显示分配与回收的过程。

A、主存空间分配(1)首次适应算法在该算法中,把主存中所有空闲区按其起始地址递增的次序排列。

在为作业分配存储空间时,从上次找到的空闲分区的下一个空闲分区开始查找,直到找到第一个能满足要求的空闲区,从中划出与请求的大小相等的存储空间分配给作业,余下的空闲区仍留在空闲区链中。

(2)最佳适应算法在该算法中,把主存中所有空闲区按其起始地址递增的次序排列。

在为作业分配存储空间时,从上次找到的空闲分区的下一个空闲分区开始查找,直到找到一个能满足要求的空闲区且该空闲区的大小比其他满足要求的空闲区都小,从中划出与请求的大小相等的存储空间分配给作业,余下的空闲区仍留在空闲区链中(3)最坏适应算法在该算法中,把主存中所有空闲区按其起始地址递增的次序排列。

在为作业分配存储空间时,从上次找到的空闲分区的下一个空闲分区开始查找,直到找到一个能满足要求的空闲区且该空闲区的大小比其他满足要求的空闲区都大,从中划出与请求的大小相等的存储空间分配给作业,余下的空闲区仍留在空闲区链中。

B、主存空间回收当一个作业执行完成撤离时,作业所占的分区应该归还给系统。

可变分区存储管理实验报告

可变分区存储管理实验报告

实验三可变分区存储管理
一、实验目的
通过编写可变分区存储模拟系统,掌握可变分区存储管理的基本原理,分区的分配与回收过程。

二、实验内容与步骤
1.打开程序,所得程序界面窗口如图3-1:
图3-1
2.首先选择算法:是否使用搬家算法,可以通过界面上的按钮或算法菜单栏进行
选择;如果不先选择算法,其他功能将被隐藏;注意:在程序执行过程中,不可以重新选择算法。

3.进行初始化:设置内存大小,可以选择默认值400KB;确定内存大小前,其他
操作将被屏蔽。

4.初始化内存大小以后,就可以进行添加进程操作。

5.添加一个进程后,撤消进程功能被激活,可以撤消一个选定的进程或所有的进
程(图3-2)
图3-2
6.查询功能:可以通过按钮或菜单栏显示内存状态图形、空闲区图表,还可以在内存状态条里闪烁显示某一在空闲区图表选中的空闲区。

7.内存不足但经过搬家算法可以分配内存空间给进程,将有如下(图3-3)提示:
图3-3
8.内存空间不足也有相应提示。

9.重置或退出。

三、实验结果
第一至四组数据测试采用搬家算法,第二至八组数据测试不采用搬家算法。

第一组测试数据:(测试内存错误输入) 选择搬家算法,内存大小:0KB/-50KB/空
第二组测试数据:(测试内存空间不够)选择搬家算法,内存大小:400KB
第三组测试数据:(测试是否采用最佳适应法)选择搬家算法,内存大小:200KB 第四组数据:(测试搬家算法)选择搬家算法,内存大小:400KB
第五组数据至第八组数据:不采用搬家算法,内存大小:分别与第一至第四组数据相同,操作过程:分别与第一至第四组数据相同。

计算机操作系统内存管理系统可变分区存储管理方式的内存分配回收

计算机操作系统内存管理系统可变分区存储管理方式的内存分配回收

计算机操作系统内存管理系统可变分区存储管理方式的内存分配回收内存管理是操作系统中非常重要的一个功能,它负责管理计算机内存资源的分配和回收。

内存分配是指在程序运行时,为进程分配适当大小的内存空间;内存回收是指当进程终止或不再需要分配的内存时,将它们释放回系统。

可变分区存储管理方式是一种常用的内存管理方式,它的特点是将内存分为若干个可变大小的分区。

下面将详细介绍可变分区存储管理方式的内存分配和回收。

一、内存分配:1. 首次适应算法(First Fit):从起始地址开始查找第一个满足分配要求的可用分区,分配其中一部分给进程,并将剩余部分作为新的可用分区。

2. 循环首次适应算法(Next Fit):与首次适应算法类似,但是从上一次分配的位置开始查找。

3. 最佳适应算法(Best Fit):在所有可用分区中找到最小且能满足分配要求的分区进行分配。

4. 最坏适应算法(Worst Fit):在所有可用分区中找到最大的空闲分区进行分配。

这种方法可能会造成大量外部碎片,但可以更好地支持大型进程。

二、内存回收:1.碎片整理:在每次回收内存时,可以通过将相邻的空闲分区合并为一个更大的分区来减少外部碎片。

这种方法需要考虑如何高效地查找相邻分区和合并它们。

2.分区分割:当一个进程释放内存时,生成的空闲分区可以进一步划分为更小的分区,并将其中一部分分配给新进程。

这样可以更好地利用内存空间,但会增加内存分配时的开销。

3.最佳合并:在每次回收内存时,可以选择将相邻的空闲分区按照最佳方式合并,以减少外部碎片。

4.分区回收:当一个进程终止时,可以将其所占用的分区标记为可用,以便其他进程使用。

三、优化技术:1.预分配内存池:为了避免频繁的内存分配和回收,可以预分配一定数量的内存作为内存池,由进程从内存池中直接分配和回收内存。

2.内存压缩:当内存不足时,可以通过将一部分进程的内存内容移动到磁盘等外部存储器中,释放出一定的内存空间。

3.页面替换算法:在虚拟内存系统中,当物理内存不足时使用页面替换算法,将不常用的页面淘汰出物理内存,以便为新页面分配内存。

内存分配回收实验报告

内存分配回收实验报告

一、实验目的通过本次实验,加深对内存分配与回收机制的理解,掌握内存分配算法和回收策略,并能够运用所学知识解决实际内存管理问题。

二、实验内容1. 确定内存空间分配表;2. 采用首次适应算法实现内存分配;3. 采用最佳适应算法实现内存分配;4. 采用最坏适应算法实现内存分配;5. 实现内存回收功能;6. 对比分析不同内存分配算法的优缺点。

三、实验步骤1. 创建一个内存空间模拟程序,用于演示内存分配与回收过程;2. 定义内存空间分配表,记录内存块的起始地址、大小和状态(空闲或占用);3. 实现首次适应算法,在内存空间分配表中查找第一个满足条件的空闲内存块,分配给请求者;4. 实现最佳适应算法,在内存空间分配表中查找最接近请求大小的空闲内存块,分配给请求者;5. 实现最坏适应算法,在内存空间分配表中查找最大的空闲内存块,分配给请求者;6. 实现内存回收功能,当内存块释放时,将其状态更新为空闲,并合并相邻的空闲内存块;7. 对比分析不同内存分配算法的优缺点,包括分配时间、内存碎片和内存利用率等方面。

四、实验结果与分析1. 首次适应算法:该算法按照内存空间分配表的顺序查找空闲内存块,优点是分配速度快,缺点是容易产生内存碎片,且内存利用率较低;2. 最佳适应算法:该算法查找最接近请求大小的空闲内存块,优点是内存利用率较高,缺点是分配速度较慢,且内存碎片较多;3. 最坏适应算法:该算法查找最大的空闲内存块,优点是内存利用率较高,缺点是分配速度较慢,且内存碎片较多。

五、实验结论通过本次实验,我们掌握了内存分配与回收的基本原理和算法,了解了不同内存分配算法的优缺点。

在实际应用中,我们需要根据具体需求选择合适的内存分配算法,以优化内存管理,提高系统性能。

六、实验心得1. 内存分配与回收是计算机系统中重要的组成部分,对系统性能有着重要影响;2. 熟练掌握内存分配算法和回收策略,有助于解决实际内存管理问题;3. 在实际应用中,应根据具体需求选择合适的内存分配算法,以优化内存管理,提高系统性能。

操作系统-内存分配与回收实验报告

操作系统-内存分配与回收实验报告

操作系统-内存分配与回收实验报告本次实验是关于内存管理的实验,主要涉及内存分配和回收的操作。

本文将对实验过程和结果进行详细介绍。

1. 实验目的本次实验的主要目的是熟悉内存管理的基本原理和机制,掌握内存分配和回收的方法,并且实现一个简单的内存管理器。

2. 实验原理内存管理是操作系统的重要组成部分,主要负责管理计算机的内存资源,并且协调进程对内存的访问。

在计算机工作过程中,内存扮演着重要的角色,因此内存管理的效率和稳定性对计算机的性能和稳定性有着重要影响。

内存管理包括内存分配和回收两个方面。

内存分配是指为进程分配空闲的内存空间,以便程序可以执行;内存回收是指将已经使用完成的内存空间还回给系统,以便其他进程使用。

3. 实验步骤为了实现一个简单的内存管理器,我们需要进行以下步骤:(1)定义内存块结构体首先,我们需要定义一个内存块结构体,用于描述内存块的基本信息。

内存块结构体可以包含以下信息:· 内存块的起始地址· 内存块是否被分配下面是一个内存块结构体定义的示例代码:typedef struct mem_block{void *start_address; // 内存块的起始地址size_t size; // 内存块的大小bool is_allocated; // 内存块是否已经分配}MemBlock;(3)实现内存分配函数现在,我们可以开始实现内存分配函数了。

内存分配函数需要完成以下工作:· 在内存管理器中寻找一个合适的内存块void *mem_alloc(MemManager *manager, size_t size){MemBlock *p = manager->block_list;while(p){if(p->size >= size && !p->is_allocated){p->is_allocated = true;return p->start_address;}p = p->next;}return NULL;}· 找到该内存块所在的位置· 将该内存块标记为未分配状态4. 实验结果本次实验实现了一个简单的内存管理器,通过该内存管理器可以实现内存分配和回收的操作。

可变分区存储管理方式的内存分配和回收

可变分区存储管理方式的内存分配和回收

可变分区存储管理方式的内存分配和回收第一篇:可变分区存储管理方式的内存分配和回收#include//定义输入/输出函数#include//数据流输入/输出#include//字符串处理#include//参数化输入/输出const int MJ=10;//假定系统允许的最大作业数量为10typedef struct node{int address;int length;char tag[10];}job;job frees[MJ];int free_quantity;job occupys[MJ];int occupy_quantity;int read(){FILE *fp;char fn[10];cout<cin>>fn;if((fp=fopen(fn,“r”))==NULL){ 其意义是在当前目录下打开文件file a,只允许进行“读”操作,并使fp指向该文件cout<}else{while(!feof(fp)){fscanf(fp,“%d,%d”,&frees[free_quantity].address,&frees[free_quantity].length);free_quantity++;fscanf(文件指针,格式字符串,输入表列);}return 1;}return 0;}void sort(){int i,j,p;for(i=0;ip=i;for(j=i+1;jif(frees[j].addressp=j;}}if(p!=i){frees[free_quantity]=frees[i];frees[i]=frees[p];frees[p]=frees[free_quantity];}}}void view(){int i;cout<cout<for(i=0;icout.setf(2); cout.width(12); cout<cout.width(10); cout<cout.width(8); cout<}cout<cout<for(i=0;icout.setf(2); cout.width(12); cout<cout.width(10); cout<cout.width(8); cout<}}void ear(){char job_name[10]; int job_length;int i,j,flag,t;cout<cin>>job_name; cin>>job_length; flag=0;for(i=0;iif(frees[i].length>=job_length){flag=1;}}if(flag==0){//未找到空闲区,返回cout<}else{t=0;i=0;while(t==0){if(frees[i].length>=job_length){//找到可用空闲区,开始分配t=1;}i++;}i--;occupys[occupy_quantity].address=frees[i].address;//修改已分配区表strcpy(occupys[occupy_quantity].tag,job_name);occupys[occupy_quantity].length=job_length;occupy_quantity++;if(frees[i].length>job_length){frees[i].address+=job_length;frees[i].length-=job_length;}else{for(j=i;jfrees[j]=frees[j+1];}free_quantity--;cout<}}}void reclaim()//回收作业所占的内存空间{char job_name[20];int i,j,flag,p=0;int address;int length;//寻找已分分区表中对应的登记项cout<cin>>job_name;flag=-1;for(i=0;iif(!strcmp(occupys[i].tag,job_name)){flag=i;address=occupys[i].address;length=occupys[i].length;}}if(flag==-1){ //在已分分区表中找不到作业cout<}else{//修改空闲区表,加入空闲表for(i=0;iif((frees[i].address+frees[i].length)==address){ if(((i+1)for(j=i+1;jfrees[j]=frees[j+1];}free_quantity--;p=1;}else{frees[i].length+=length;p=1;}}if(frees[i].address==(address+length)){ frees[i].address=address;frees[i].length+=length;p=1;}}if(p==0){frees[free_quantity].address=address; frees[free_quantity].length=length; free_quantity++;}//删除分配表中的该作业for(i=flag;ioccupys[i]=occupys[i+1];}occupy_quantity--;}}void main(){int flag=0;int t=1;int chioce=0;int i;for(i=0;ifrees[i].address=-1;//空闲区表初始化frees[i].length=0;strcpy(frees[i].tag,“free”);occupys[i].address=-1;//已分分区表初始化occupys[i].length=0;strcpy(occupys[i].tag,“");}free_quantity=0;occupy_quantity=0;flag=read();while(flag==1){sort();cout<cin>>chioce;switch(chioce){case 0:flag=0;break;case 1:ear();break;case 2:reclaim();break;case 3:view();break;default:cout<}}}第二篇:可变分区存储管理方式的内存分配和回收实验报告一.实验目的通过编写和调试存储管理的模拟程序以加深对存储管理方案的理解,熟悉可变分区存储管理的内存分配和回收。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

一.实验目的通过编写和调试存储管理的模拟程序以加深对存储管理方案的理解,熟悉可变分区存储管理的内存分配和回收。

二.实验内容1.确定内存空间分配表;2.采用最优适应算法完成内存空间的分配和回收;3.编写主函数对所做工作进行测试。

三.实验背景材料由于可变分区的大小是由作业需求量决定的,故分区的长度是预先不固定的,且分区的个数也随内存分配和回收变动。

总之,所有分区情况随时可能发生变化,数据表格的设计必须和这个特点相适应。

由于分区长度不同,因此设计的表格应该包括分区在内存中的起始地址和长度。

由于分配时空闲区有时会变成两个分区:空闲区和已分分区,回收内存分区时,可能会合并空闲分区,这样如果整个内存采用一张表格记录己分分区和空闲区,就会使表格操作繁琐。

分配内存时查找空闲区进行分配,然后填写己分配区表,主要操作在空闲区;某个作业执行完后,将该分区变成空闲区,并将其与相邻的空闲区合并,主要操作也在空闲区。

由此可见,内存的分配和回收主要是对空闲区的操作。

这样为了便于对内存空间的分配和回收,就建立两张分区表记录内存使用情况,一张表格记录作业占用分区的“己分分区表”;一张是记录空闲区的“空闲区表”。

这两张表的实现方法一般有两种:一种是链表形式,一种是顺序表形式。

在实验中,采用顺序表形式,用数组模拟。

由于顺序表的长度必须提前固定,所以无论是“已分分区表”还是“空闲区表”都必须事先确定长度。

它们的长度必须是系统可能的最大项数。

“已分分区表”的结构定义#define n 10 //假定系统允许的最大作业数量为nstruct{ float address; //已分分区起始地址float length; //已分分区长度、单位为字节int flag; //已分分区表登记栏标志,“0”表示空栏目,实验中只支持一个字符的作业名}used_table[n]; //已分分区表“空闲区表”的结构定义#define m 10 //假定系统允许的空闲区最大为mstruct{ float address; //空闲区起始地址float length; //空闲区长度、单位为字节int flag; //空闲区表登记栏标志,“0”表示空栏目,“1”表示未分配}used_table[n]; //空闲区表第二,在设计的数据表格基础上设计内存分配。

装入一个作业时,从空闲区表中查找满足作业长度的未分配区,如大于作业,空闲区划分成两个分区,一个给作业,一个成为小空闲分区。

实验中内存分配的算法采用“最优适应”算法,即选择一个能满足要求的最小空闲分区。

第三,在设计的数据表格基础上设计内存回收问题。

内存回收时若相邻有空闲分区则合并空闲区,修改空闲区表。

四、参考程序#define n 10 //假定系统允许的最大作业数量为n#define m 10 //假定系统允许的空闲区最大为m#define minisize 100struct{ float address; //已分分区起始地址float length; //已分分区长度、单位为字节int flag; //已分分区表登记栏标志,“0”表示空栏目,实验中只支持一个字符的作业名}used_table[n]; //已分分区表struct{ float address; //空闲区起始地址float length; //空闲区长度、单位为字节int flag; //空闲区表登记栏标志,“0”表示空栏目,“1”表示未分配}used_table[n]; //空闲区表allocate(J,xk) //采用最优分配算法分配xk大小的空间char J;float xk;{int i,k;float ad;k=-1;for(i=0;i<m;i++) //寻找空间大于xk的最小空闲区登记项if(free_table[i].length>=xk&&free_table[i].flag==1)if(k==-1||free_table[i].length<free_table[k].length)k=i;if(k==-1) //未找到空闲区,返回{printf("无可用的空闲区\n");return;}//找到可用空闲区,开始分配;若空闲区大小与要求分配的空间差小于minisize大小,则空闲区全部分配;//若空闲区大小与要求分配的空间差大于minisize大小,则从空闲区划分一部分分配if(free_table[k].length-xk<=minisize){free_table[k].flag=0;ad=free_table[k].address;xk=free_table[k].length;}else{free_table[k].length=free_table[k].length-xk;ad=free_table[k].address+free_table[k].length;}//修改已分配区表i=0;while(used_table[i].flag!=0&&i<n) //寻找空表目i++;if(i>=n) //无表目填写已分分区{printf("无表目填写以分分区,错误\n");if(free_table[k].flag==0) //前面找到的是整个空闲区free_table[k].flag=1;else //前面找到的是某个空闲区的一部分 free_table[k].length=free_table[k].length+xk;return;}else //修改已分配区表{used_table[i].address=ad;used_table[i].length=xk;used_table[i].flag=J;}return;}//内存分配函数结束reclaim(J) //回收作业名为J的作业所占的内存空间char J:{int i,k,j,s,t;float S,L;//寻找已分分区表中对应的登记项S=0;while((used_table[S].flag!=J||used_table[S].flag==0)&&S<n)S++;if(S>=n) //在已分分区表中找不到名字为J的作业{printf("找不到该作业\n");return;}//修改已分分区表used_table[S].flag=0;//取得归还分区的起始地址S和长度LS=used_table[S].address;L=used_table[S].length;j=-1;k=-1;i=0;//寻找回收分区的上下邻空闲区,上邻表目K,下邻表目Jwhile(i<m&&(j==-1||k==-1)){if(free_table[i].flag==0){if(free_table[i].address+free_table[i].length==0) k=i; //找到上邻 {if(free_table[i].address==S+L) j=1; //找到下邻 }i++;}if(k!=-1)if(j!=-1) //上邻空闲区,下邻空闲区,三项合并{free_table[k].length=free_table[j].length+free_table[k].length+L;free_table[j].flag+0;}else //上邻空闲区,下邻非空闲区,与上邻合并free_table[k].length=free_table[k].length+L;elseif(j!=-1) //上邻非空闲区,下邻空闲区,与下邻合并{free_table[j].address=S;free_table[j].length=free_table[j].length+L;}else{ //上下邻均为非空闲区,回收区域直接填入 t=0; //在空闲区表中寻找空栏目while(free_table[t].flag==1&&t<m)t++;if(t>=m) //空闲区表满,回收空间失败,将已分配分区表复原{printf("内存空闲表没有空间,回收空间失败\n");used_table[S].flag=J;return;}free_table[t].address=s;free_table[t].length=l;free_table[t].flag=1;}return(true);} //内存回收函数结束main(){ int i,a;float xk;char J;//空闲区表初始化free_table[0].address=10240;free_table[0].length=102400;free_table[0].flag=1;for(i=1;i<m;i++)free_table[i].flag=0;//已分分区表初始化for(i=1;i<n;i++)used_table[i].flag=0;while(1){printf("选择功能项(0—退出,1—分配内存,2-回收内存,3-显示内存)\n");printf("选择功项(0-3):");scanf("%d",&a);switch(a){case 0;exit(0); //a=0程序结束case 1; //a=1 分配内存空间printf("输入作业名J和作业所需长度XK:"); scanf("%c%c%f",&j,&xk);allocate(j,xk); //分配内存空间break;case 2; //a=2 回收内存空间printf("输入要回放分区的作业名");scanf("%c%c",&j);reclaim(j); //回收内存空间。

相关文档
最新文档