动态异长分区的存储分配与回收程序补充
动态分区存储管理方式的主存分配回收总结
动态分区存储管理方式的主存分配回收总结动态分区存储管理是一种常见的主存分配回收技术，它通过动态创建并分配大小不等的存储块来管理主存空间，以满足不同进程的需求。
这种管理方式在操作系统中起着至关重要的作用，因此本文将对动态分区存储管理的主存分配回收进行总结，从原理、特点、优缺点及其在实际应用中的情况进行阐述。
一、原理动态分区存储管理是基于分区的主存管理机制，它将主存空间划分为多个不等大小的分区，每个分区可以被分配给一个进程使用。
当系统收到一个新进程的请求时，它会根据需要的主存大小为进程分配一个合适大小的分区。
当进程执行完毕，系统会回收该进程所占用的分区，使得该空间可以再次被分配给其他进程使用。
在动态分区存储管理中，主要有两种分配方式：首次适应算法和最佳适应算法。
首次适应算法是从第一个满足大小要求的分区开始进行分配；而最佳适应算法是从所有满足大小要求的分区中选择最小的分区进行分配。
这两种分配方式都有自己的优点和局限性，但它们都是基于动态分区存储管理的基本原理。
二、特点1.灵活性动态分区存储管理可以根据进程的需求动态地分配和回收主存空间，提高了主存的利用率和效率。
进程可以根据需要申请和释放主存空间，而无需预先分配固定大小的空间。
2.节省空间动态分区存储管理可以尽可能地利用主存中的碎片空间，减少了外部碎片的浪费。
这种管理方式能够充分利用主存空间，提高了主存的利用率。
3.多样性动态分区存储管理可以适应不同大小的进程需求，能够根据进程的大小灵活地进行分区分配，满足了不同进程的需求。
三、优缺点1.优点（1）提高了主存的利用率和效率。
（2）灵活地分配和回收主存空间，满足不同进程的需求。
（3）节省了主存空间，减少了碎片的浪费。
2.缺点（1）会产生外部碎片，影响了分区空间的利用率。
（2）分配和回收过程中可能产生较大的开销，影响了系统的性能。
四、在实际应用中的情况动态分区存储管理在操作系统中得到了广泛的应用，特别是在多道程序设计和实时系统中。
动态异长分区的存储分配与回收算法
实验5 动态异长分区的存储分配与回收算法5.1 实验目的理解存储管理的功能，掌握动态异长分区的存储分配与回收算法。
存储器是计算机系统中的关键资源，存储管理一直是操作系统的最主要功能之一。
存储管理既包括内存资源管理，也包括用于实现分级存储体系的外存资源的管理。
通常，内存与外存可采用相同或相似的管理技术，如内存采用段式存储管理，则外存也采用段式存储管理。
存储管理需要完成如下功能：存储分配、存储共享、存储保护、存储扩充、地址映射。
当一个作业进入内存时，由操作系统将其变为进程,并为进程分配存储空间。
进程运行结束时, 由操作系统将其所占用的存储空间收回。
不同的操作系统对内存空间的划分与分配方法是不同的，通常分为两类：静态等长分区的分配和动态异长分区的分配。
静态等长分区常用于页式存储管理方式与段页式存储管理方式，存储空间被静态地划分为若干个长度相等的区域，每个区域被称作一个页面。
动态异长分区常用于界地址存储管理方式与段式存储管理方式，存储空间被动态地划分为若干个长度不等的区域。
5.2 实验要求本实验要求模拟动态异长分区的分配算法、回收算法和碎片整理算法。
5.3 实验步骤5.3.1 数据结构分析为了实现存储资源的分配和回收，操作系统需Array要记录内存资源使用情况，即哪些区域尚未分配，哪些区域已经分配以及分配给哪些进程等。
为此一般需要两个表，一个为分配表, 另外一个为空闲区域表。
前者记录已经分配的区域, 后者记录着所有当前未被进程占用的空闲区域, 如图5-1所示。
图5-1 空闲区域表显然, 没有记录于表中的区域即为已被进程所占用的非空闲区域，在实际的操作系统中，这些区域登记在进程的PCB中。
而PCB中除了关于内存资源的信息外，还有其它大量信息。
由于本实验是对存储管理算法的模拟，所以用一个线程来代表一个进程，用线程驻留区域表来描述线程占用的内存空间，如图5-2所示。
5.3.2 算法分析常用的动态异长分区的分配算法有：最先适应算法、最佳适应算法和最坏适应算法。
存储管理动态分区分配及回收算法
存储管理动态分区分配及回收算法存储管理是计算机系统中的重要组成部分，它负责管理和分配计算机中的物理内存资源。
在计算机系统中，通过动态分区分配和回收算法来实现对这些资源的有效利用。
本文将介绍动态分区分配和回收算法的原理、主要算法以及优缺点。
动态分区分配是一种灵活、动态的内存分配方式，它根据进程的需求动态地分配内存空间。
动态分区分配算法有多种，其中最常用的有首次适应算法、最佳适应算法和最坏适应算法。
首次适应算法（First Fit）是最常用的分配算法之一、它从低地址开始寻找第一个满足要求的空闲分区来分配进程。
这种算法的优点是简单、高效，但是可能会产生大量的碎片空间，降低内存的利用率。
最佳适应算法（Best Fit）是在所有空闲分区中找到一个大小最适合进程的分区来分配。
它的主要思想是选择一个更接近进程大小的空闲分区，以减少碎片空间的产生。
然而，这种算法的缺点是需要遍历整个空闲分区链表，因此效率相对较低。
最坏适应算法（Worst Fit）与最佳适应算法相反，它选择一个大小最大的空闲分区来分配进程。
这种算法的好处是可以尽可能地保留大块的碎片空间，以便后续分配使用。
但是，它也会导致更多的碎片空间浪费。
动态分区的回收算法是用于回收被释放的内存空间并合并相邻的空闲分区，以尽量减少碎片空间的产生。
常见的回收算法有合并相邻空闲分区算法和快速回收算法。
合并相邻空闲分区算法会在每次有分区被回收时，检查是否有相邻的空闲分区可以合并。
如果有，就将它们合并为一个大的空闲分区。
这样可以最大程度地减少碎片空间，提高内存的利用效率。
快速回收算法是一种将被释放的分区插入到一个空闲分区链表的头部，而不是按照地址顺序进行插入的算法。
这样可以减少对整个空闲分区链表的遍历时间，提高回收的效率。
总结起来，动态分区分配和回收算法在存储管理中起着重要的作用。
首次适应算法、最佳适应算法和最坏适应算法是常用的动态分区分配算法，它们各自有着不同的优缺点。
简述采用动态分区分配的内存管理方式时内存回收的流程
简述采用动态分区分配的内存管理方式时内存回收的流程在采用动态分区分配的内存管理方式下，内存回收是指在程序运行过程中，回收已经使用但不再需要的内存空间，以便能够重新分配给其他需要使用的程序或进程。
下面将详细介绍动态分区分配的内存回收流程。
1.标记已被释放的内存块：在动态分区分配方式中，每个已被分配的内存块都需要维护一个标记位，用于标记其是否已经被释放。
当程序运行到内存回收的时候，首先需要根据一定的算法遍历整个内存空间，查找标记位为已释放的内存块。
2.合并相邻的空闲内存块：找到标记位为已释放的内存块后，需要将其与相邻的其他被释放的内存块合并，以构成更大的空闲内存块。
这样做可以减少内存碎片化，提高内存利用率。
3.更新内存管理信息：合并空闲内存块后，需要更新内存管理信息。
这包括更新已分配和空闲内存块的起始地址和大小等信息，以便后续程序再次申请内存时能够查找合适的空闲内存块。
4.触发垃圾回收机制：在一些情况下，程序回收的内存可能存在垃圾数据，例如被遗忘的对象或者无法访问的内存块。
这时候，系统通常触发垃圾回收机制，通过垃圾回收算法来识别并回收这些垃圾数据。
5.回收被释放的内存：经过前面的步骤，现在得到了一系列被合并和标记为已释放的内存块。
接下来，系统将这些内存块回收，使其重新变为可用的空闲内存。
6.维护内存分区：在进行内存回收后，还需要维护内存分区，以便后续的内存分配能够顺利进行。
这包括更新内存分区表，记录每个分区的起始地址和大小等信息。
7.返回内存空间：经过上述步骤，内存回收过程完成，系统可以将释放的内存空间重新变为可用的，以供其他程序或进程申请使用。
需要注意的是，在动态分区分配方式下，内存回收是一个相对复杂的过程。
因为内存回收涉及到合并内存块、更新内存管理信息等操作，同时还需要考虑内存碎片化和效率问题。
因此，在实际应用中，需要根据具体的场景和需求选择合适的内存回收策略和算法，以达到最优的内存管理效果。
操作系统-存储管理动态分区分配及回收算法(附源码)
存储管理动态分区分配及回收算法课程名称:计算机操作系统班级:信1501-2实验者姓名：李琛实验日期：2018年5月20日评分：教师签名：一、实验目的分区管理是应用较广泛的一种存储管理技术。
本实验要求用一种结构化高级语言构造分区描述器，编制动态分区分配算法和回收算法模拟程序，并讨论不同分配算法的特点.二、实验要求1、编写:First Fit Algorithm2、编写：Best Fit Algorithm3、编写：空闲区回收算法三、实验过程（一）主程序1、定义分区描述器node，包括3 个元素:（1)adr-—分区首地址(2）size——分区大小(3)next——指向下一个分区的指针2、定义3 个指向node 结构的指针变量：(1）head1——空闲区队列首指针（2）back1-—指向释放区node 结构的指针（3）assign——指向申请的内存分区node 结构的指针3、定义1 个整形变量：free——用户申请存储区的大小（由用户键入）（二)过程1、定义check 过程，用于检查指定的释放块（由用户键入）的合法性2、定义assignment1 过程，实现First Fit Algorithm3、定义assignment2 过程，实现Best Fit Algorithm4、定义acceptment1 过程，实现First Fit Algorithm 的回收算法5、定义acceptment2 过程，实现Best Fit Algorithm 的回收算法6、定义print 过程，打印空闲区队列（三）执行程序首先申请一整块空闲区，其首址为0，大小为32767；然后，提示用户使用哪种分配算法，再提示是分配还是回收；分配时要求输入申请区的大小，回收时要求输入释放区的首址和大小。
实验代码Main。
cpp#include〈stdio。
h〉#include<stdlib.h>#include〈string。
存储管理动态分区分配及回收算法
before=head2; after=head2->next; while(after) { if(after->adr==back2->adr+back2->size) {//和后边空闲区合并
void print(char choice)//输出空闲区队列信息
-9-
{ Node *p;
if(choice=='f'||choice=='F') p=head1->next;
else p=head2->next;
if(p) { printf("\n空闲区队列的情况为：\n");
-4-
if(back1->adr==before->adr+before->size) {//和前边分区合并 before->size+=back1->size; before->next=back1->next; free(back1); } else if(after&&back1->adr+back1->size==after->adr) {//和后边分区合并 back1->size+=after->size; back1->next=after->next; back1->id=after->id; free(after); after=back1; } printf("\t首先分配算法回收内存成功！！！\n"); } else printf("\t首先分配算法回收内存失败！！！\n");
存储管理动态分区分配及回收算法
存储管理动态分区分配及回收算法存储管理是操作系统中非常重要的一部分，它负责对计算机系统的内存进行有效的分配和回收。
动态分区分配及回收算法是其中的一种方法，本文将详细介绍该算法的原理和实现。
动态分区分配及回收算法是一种将内存空间划分为若干个动态分区的算法。
当新的作业请求空间时，系统会根据作业的大小来分配一个合适大小的分区，使得作业可以存储在其中。
当作业执行完毕后，该分区又可以被回收，用于存储新的作业。
动态分区分配及回收算法包括以下几个步骤：1.初始分配:当系统启动时，将整个内存空间划分为一个初始分区，该分区可以容纳整个作业。
这个分区是一个连续的内存块，其大小与初始内存大小相同。
2.漏洞表管理:系统会维护一个漏洞表，用于记录所有的可用分区的大小和位置。
当一个分区被占用时，会从漏洞表中删除该分区，并将剩余的空间标记为可用。
3.分区分配:当一个作业请求空间时，系统会根据作业的大小，在漏洞表中查找一个合适大小的分区。
通常有以下几种分配策略：- 首次适应(First Fit): 从漏洞表中找到第一个满足作业大小的分区。
这种策略简单快速，但可能会导致内存碎片的产生。
- 最佳适应(Best Fit): 从漏洞表中找到最小的满足作业大小的分区。
这种策略可以尽量减少内存碎片，但是分配速度相对较慢。
- 最差适应(Worst Fit): 从漏洞表中找到最大的满足作业大小的分区。
这种策略可以尽量减少内存碎片，但是分配速度相对较慢。
4.分区回收:当一个作业执行完毕后，系统会将该分区标记为可用，并更新漏洞表。
如果相邻的可用分区也是可合并的，系统会将它们合并成一个更大的分区。
总结来说，动态分区分配及回收算法是一种对计算机系统内存进行有效分配和回收的方法。
通过合理的分配策略和回收机制，可以充分利用内存资源，提高系统性能。
然而，如何处理内存碎片问题以及选择合适的分配策略是需要仔细考虑的问题。
动态异长分区的存储分配与回收算法
试验5 动态异长分区的存储分派与收受接管算法5.1 试验目标懂得存储治理的功效,控制动态异长分区的存储分派与收受接管算法.存储器是盘算机体系中的症结资本,存储治理一向是操纵体系的最重要功效之一.存储治理既包含内存资本治理,也包含用于实现分级存储体系的外存资本的治理.平日, 内存与外存可采取雷同或类似的治理技巧,如内存采取段式存储治理,则外存也采取段式存储治理.存储治理须要完成如下功效： 存储分派.存储共享.存储呵护.存储扩充.地址映射.当一个功课进入内存时,由操纵体系将其变成过程,并为过程分派存储空间.过程运行停止时, 由操纵体系将其所占用的存储空间收回.不合的操纵体系对内存空间的划分与分派办法是不合的,平日分为两类：静态等长分区的分派和动态异长分区的分派.静态等长分区经常应用于页式存储治理方法与段页式存储治理方法,存储空间被静态地划分为若干个长度相等的区域,每个区域被称作一个页面. 动态异长分区经常应用于界地址存储治理方法与段式存储治理方法,存储空间自动态地划分为若干个长度不等的区域.5.2 试验请求本试验请求模仿动态异长分区的分派算法.收受接管算法和碎片整顿算法.5.3 试验步调数据构造剖析为了实现存储资本的分派和收受接管,操纵体系须要记载内存资本应用情形,即哪些区域尚未分派,哪些区域已经分派以及分派给哪些过程等.为此一般须要两个表,一个为分派表, 别的一个为余暇区域表.前者记载已经分派的区域, 后者记载着所有当前未被过程占用的余暇区域, 如图5-1所示.显然, 没有记载于表中的区域即为已被过程所占用的非余暇区域,在现实的操纵体系中,图5-1 余暇区域表这些区域登记在过程的PCB中.而PCB中除了关于内存资本的信息外,还有其它大量信息.因为本试验是对存储治理算法的模仿,所以用一个线程来代表一个过程,用线程驻留区域表来描写线程占用的内存空间,如图5-2所示.同时,须要一张表来记载各个线程对内存的请求信息,如图5-3所示.算法剖析经常应用的动态异长分区的分派算法有：最先顺应算法.最佳顺应算法和最坏顺应算法.1. 最先顺应算法(First Fit,FF)对于存储申请敕令, 拔取知足申请长度请求且肇端地址最小的余暇区域.在实现时, 可将体系中所有的余暇区域按照肇端地址由小到大的次序依次记载于余暇区域表中.当过程申请存储空间时, 体系由表的头部开端查找, 取第一个知足请求的表目.假如该表目所对应的区域长度正好与所申请的区域长度雷同, 则将该区域全体分派给申请者.不然将该区域朋分为两部分, 一部分的长度与所申请的长度雷同, 将其分派给申请者;另一部分的长度为原长度与分派长度之差, 将其仍记载于余暇区域表中.收受接管时,按收受接管区的首地址查询余暇区表,如有与收受接管区相临的余暇区,则将其归并到相临区中,不然,把收受接管区按照地址从低到高的次序拔出到余暇区域表的恰当地位.2. 最佳顺应算法(Best Fit,BF)分派时取知足申请请求且长度最小的余暇区域.在实现时, 可将体系中所有的余暇区域按照长度由小到大的次序依次记载于余暇区域表中.与最先顺应算法相类似, 当过程申请存储空间时, 体系由表的头部开端查找, 取第一个知足请求的表目.假如该表目所对应的区域长度正好与所申请的区域长度雷同, 则将该区域全体分派给申请者.不然将该区域朋分为两部分, 一部分的长度与所申请的长度雷同, 将其分派给申请者;另一部分即残剩部分的长度为原长度与分派长度之差, 因为残剩部分的长度已经转变,所以应从新将其按长度从小到大的次序拔出到余暇区域表中.收受接管时,不但要按收受接管区的首地址查询余暇区表,找到与收受接管区相临的余暇区,将其归并到相临区中,并且要把归并后的收受接管区按照长度递增的次序拔出到余暇区域表的恰当地位.3. 最坏顺应算法(Worst Fit,WF)分派时取知足申请请求且长度最大的余暇区域.在实现时, 可将体系中所有的余暇区域按照长度由大到小的次序依次记载于余暇区域表中.当过程申请存储空间时, 取第一个表目.假如该表目所对应的区域长度正好与所申请的区域长度雷同, 则将该区域全体分派给申请者.不然将该区域朋分为两部分, 一部分的长度与所申请的长度雷同, 将其分派给申请者;另一部分即残剩部分的长度为原长度与分派长度之差, 因为残剩部分的长度已经转变,所以应从新将其按长度递减的次序拔出到余暇区域表中.收受接管时,不但要按收受接管区的首地址查询余暇区表,找到与收受接管区相临的余暇区,将其归并到相临区中,并且要把归并后的收受接管区按照长度递减的次序拔出到余暇区域表的恰当地位.设计并剖析测试数据假设初始内存计划如图5-4,图中的肇端地址以及大小都以KB来权衡.肇端地址占用者大小图5-4初始内存计划由图5-4可见,初始时共有五个线程驻留在内存,它们是a,b,c,d,e,线程驻留区表如图5-5;还有五个余暇区,余暇区域表如图5-6.假设如今有三个线程提出内存申请,申请情形见图5-7.经由剖析我们得到在每种分派算法下这三个线程所申请到的内存情形.图5-8是最先顺应算法分派情形,图5-9是最佳顺应算法分派情形,图5-10是最坏顺应算法分派情形.程序设计程序包含两个文件,一个是头文件variable_partition.h,另一个是源程序文件variable_partition.cpp.在头文件中界说了宏.数据构造.全局变量.函数声明,源程序中含有各个函数的实现.在头文件中,构造体FREEAREA.REQUIRE_MEMORY.THREAD_RESIDENCE_MEMORY分离对应于图5-1.图5-2.图5-3中的一行,不合之处是为了组成链表在三个构造体中都有前向指针.数组init_free_area_table对应于图5-6,数组init_thread_require_memory_table对应于图5-5,数组init_thread_residence_memory_table对应于图5-7,为了实现动态分派与释放,用链表从新组织余暇区域表.线程驻留区表和内存申请表,全局变量p_free_area_list 是余暇区链首,p_thread_require_memory_queue是内存申请队列的队首,p_thread_reside nce_memory_list是线程驻留区链首,tail_thread_residence_memory_list是线程驻留区链尾,因为线程驻留区链表被内存分派函数和内存释放函数共享,故用临界区变量CS_THREA D_MEMORY_LIST来呵护,同理,屏幕是所有线程共享的,所以用临界区变量CS_SCREEN来呵护,余暇区链表被内存分派函数和内存释放函数共享,故用临界区变量CS_FREEAREA_LIST来呵护.h_thread是线程句柄数组,用来存放各个线程的句柄.程序共包含25个函数,按照感化可以将它们分成五组.第一组是主函数main(),其感化是显示主菜单并依据用户的选择履行响应功效;第二组包含函数print_space()和函数display_thread_residence_memory(),前者用来显示若干个空格,后者用来显示线程驻留区表;第三组共十个函数,用来实现最先顺应分派法,它们的名称及功效如图5-11.第四组共六个函数,用来实现最佳顺应分派法,它们的名称及功效如图5-12.第五组共六个函数,用来实现最坏顺应分派法,它们的名称及功效如图5-13.参考源代码.1 windows下的参考源程序下面是完全的程序清单.头文件的清单#include <windows.h>#include <conio.h>#include <stdlib.h>#include <stdio.h>#include <io.h>#include <string.h>#define MAX_THREAD 3#define BF_initialize_require_memory_list FF_initialize_require_memory_list#define WF_initialize_require_memory_list FF_initialize_require_memory_list#define BF_initialize_thread_residence_memory_list FF_initialize_thread_residence_memory_list #define WF_initialize_thread_residence_memory_list FF_initialize_thread_residence_memory_list #define WF_delete_freearea_list FF_delete_freearea_list#define BF_delete_freearea_list FF_delete_freearea_list#define WF_delete_require_memory_list FF_delete_require_memory_list#define BF_delete_require_memory_list FF_delete_require_memory_list#define WF_delete_thread_residence_memory_list FF_delete_thread_residence_memory_list#define BF_delete_thread_residence_memory_list FF_delete_thread_residence_memory_listtypedef struct freearea{ //暗示余暇区域的数据构造struct freearea *next; //指向下一个结点的指针int start_address; //余暇区肇端地址int size; //余暇区大小}FREEAREA;typedef struct require_memory{ //记载线程申请内存的数据构造struct require_memory *next; //指向下一个结点的指针char thread_name[10]; //线程名int size; //申请内存大小（以KB为单位）int duration; //在内存的驻留时光（以秒为单位）}REQUIRE_MEMORY;typedef struct thread_residence_memory{ //描写线程驻留区的数据构造struct thread_residence_memory *next; //指向下一个结点的指针char thread_name[10]; //线程名int start_address; //驻留区肇端地址int size; //驻留区大小}THREAD_RESIDENCE_MEMORY;FREEAREA init_free_area_table[5]={ //测试数据：初始余暇区表{NULL,10,10},{NULL,40,30},{NULL,80,5},{NULL,145,15},{NULL,180,20}};REQUIRE_MEMORY init_thread_require_memory_table[3]={ //测试数据：初始内存申请表{NULL,"thread_1",20,4},{NULL,"thread_2",10,5},{NULL,"thread_3",5,6}};//测试数据：初始线程驻留区表THREAD_RESIDENCE_MEMORY init_thread_residence_memory_table[5]={ {NULL,"a",0,10},{NULL,"b",20,20},{NULL,"c",70,10},{NULL,"d",85,60},{NULL,"e",160,20}};FREEAREA *p_free_area_list=NULL; //余暇区链首REQUIRE_MEMORY *p_thread_require_memory_queue=NULL; //内存申请队排队首THREAD_RESIDENCE_MEMORY *p_thread_residence_memory_list=NULL; //线程驻留区链首THREAD_RESIDENCE_MEMORY *tail_thread_residence_memory_list=NULL; //线程驻留区链尾CRITICAL_SECTION CS_THREAD_MEMORY_LIST; //呵护线程驻留区链表的临界区CRITICAL_SECTION CS_SCREEN; //呵护屏幕的临界区CRITICAL_SECTION CS_FREEAREA_LIST; //呵护余暇区链表的临界区HANDLE h_thread[MAX_THREAD]; //线程句柄数组void print_space(int num); //输出若干个空格void display_thread_residence_memory_list(); //显示线程驻留区表//最先顺应分派法的函数FREEAREA *FF_initialize_freearea_list(FREEAREA *init_table,int num); //初始化余暇区链表void FF_delete_freearea_list(); //删除余暇区链表REQUIRE_MEMORY *FF_initialize_require_memory_list(REQUIRE_MEMORY *init_table,int num);//初始化内存申请链表void FF_delete_require_memory_list(); //删除内存申请链表THREAD_RESIDENCE_MEMORY *FF_initialize_thread_residence_memory_list(THREAD_RESIDENCE_MEMORY *init_table,int num); //初始化线程驻留区链表void FF_delete_thread_residence_memory_list(); //删除线程驻留区链表void FF_thread(void *data); //线程函数int FF_require_memory(int size); //内存申请函数void FF_release_memory(int start_address,int size); //内存释放函数void FF(); //最先顺应分派算法的初始化函数//最佳顺应分派算法的函数void BF_thread(void *data); //线程函数int BF_require_memory(int size); //内存申请函数void BF_release_memory(int start_address,int size); //内存释放函数void BF_insert_freearea(FREEAREA *free_node); //余暇区结点拔出函数void BF(); //初始化程序void BF_initialize_freearea_list(FREEAREA *init_table,int num); //初始化余暇区链表//最坏顺应分派算法的函数void WF_thread(void *data); //线程函数void WF_insert_freearea(FREEAREA *free_node); //余暇区结点拔出函数void WF_initialize_freearea_list(FREEAREA *init_table,int num); //初始化余暇区链表int WF_require_memory(int size); //内存申请函数void WF_release_memory(int start_address,int size); //内存释放函数void WF(); //初始化程序源程序文件 variable_partition.cpp 的清单#include "variable_partition.h"int main(int argc,char *argv[]){char select;while(1){printf("|-----------------------------------|\n");printf("| 1:first fit allocation |\n");printf("| 2:best fit allocation |\n");printf("| 3:worst fit allocation |\n");printf("| 4:exit |\n");printf("|-----------------------------------|\n");printf("select a function(1~4):");do{select=(char)getch();}while(select!='1'&&select!='2'&&select!='3'&&select!='4');system("cls");switch(select){case '1':FF();break;case '2':BF();break;case '3':WF();break;case '4':return 0;}printf("\nPress any key to return to main menu.");getch();system("cls");}return 0;}void print_space(int num){ //显示若干个空格int i;for(i=0;i<num;i++){printf(" ");}}void display_thread_residence_memory_list(){ //显示驻留线程链表THREAD_RESIDENCE_MEMORY *p;char buffer[20];p=p_thread_residence_memory_list;printf("|-------------------|--------------------|------------------|\n");printf("| thread_name | start_address(kB) | size(KB) |\n");printf("|-------------------|--------------------|------------------|\n");while(p!=NULL){printf("| %s",p->thread_name);print_space(18-strlen(p->thread_name));printf("| %d",p->start_address);itoa( p->start_address, buffer, 10 );print_space(19-strlen(buffer));printf("| %d",p->size);itoa(p->size, buffer, 10 );print_space(17-strlen(buffer));printf("|\n");p=p->next;};printf("|-------------------|--------------------|------------------|\n\n");}//最先顺应分派法：初始化余暇区链表FREEAREA *FF_initialize_freearea_list(FREEAREA *init_table,int num){ FREEAREA *temp;FREEAREA *head=NULL;FREEAREA *tail=NULL;int i;for(i=0;i<num;i++){temp=(FREEAREA *)malloc(sizeof(FREEAREA));temp->start_address=init_table[i].start_address;temp->size=init_table[i].size;temp->next=NULL;if(head==NULL)head=tail=temp;else{tail->next=temp;tail=tail->next;}};return head;}//最先顺应分派法：删除余暇区链表void FF_delete_freearea_list(){FREEAREA *temp;temp=p_free_area_list;while(temp!=NULL){temp=p_free_area_list->next;free(p_free_area_list);p_free_area_list=temp;}p_free_area_list=NULL;}//最先顺应分派法：初始化内存申请链表REQUIRE_MEMORY *FF_initialize_require_memory_list(REQUIRE_MEMORY *init_table,int num){ REQUIRE_MEMORY *temp;REQUIRE_MEMORY *head=NULL;REQUIRE_MEMORY *tail=NULL;int i;for(i=0;i<num;i++){temp=(REQUIRE_MEMORY *)malloc(sizeof(REQUIRE_MEMORY));strcpy(temp->thread_name,init_table[i].thread_name);temp->size=init_table[i].size;temp->duration=init_table[i].duration;temp->next=NULL;if(head==NULL)head=tail=temp;else{tail->next=temp;tail=tail->next;}};return head;}//最先顺应分派法：删除内存申请链表void FF_delete_require_memory_list(){REQUIRE_MEMORY *temp;temp=p_thread_require_memory_queue;while(temp!=NULL){temp=p_thread_require_memory_queue->next;free(p_thread_require_memory_queue);p_thread_require_memory_queue=temp;}p_thread_require_memory_queue=NULL;}//最先顺应分派法：初始化线程驻留区链表THREAD_RESIDENCE_MEMORY*FF_initialize_thread_residence_memory_list(THREAD_RESIDENCE_MEMORY *init_table,int num){ THREAD_RESIDENCE_MEMORY *temp;THREAD_RESIDENCE_MEMORY *head=NULL;THREAD_RESIDENCE_MEMORY *tail=NULL;int i;for(i=0;i<num;i++){temp=(THREAD_RESIDENCE_MEMORY *)malloc(sizeof(THREAD_RESIDENCE_MEMORY)); strcpy(temp->thread_name,init_table[i].thread_name);temp->start_address=init_table[i].start_address;temp->size=init_table[i].size;temp->next=NULL;if(head==NULL)head=tail=temp;else{tail->next=temp;tail=tail->next;}};tail_thread_residence_memory_list=tail;return head;}//最先顺应分派法：删除线程驻留区链表void FF_delete_thread_residence_memory_list(){THREAD_RESIDENCE_MEMORY *temp=p_thread_residence_memory_list;temp=p_thread_residence_memory_list;while(temp!=NULL){temp=p_thread_residence_memory_list->next;free(p_thread_residence_memory_list);p_thread_residence_memory_list=temp;}p_thread_residence_memory_list=NULL;}//线程：申请内存,驻留一段时光,释放内存void FF_thread(void *data){int start_address=-1;THREAD_RESIDENCE_MEMORY *temp;EnterCriticalSection(&CS_SCREEN);printf("create thread:%s\n",((REQUIRE_MEMORY *)(data))->thread_name);LeaveCriticalSection(&CS_SCREEN);while(1){ //申请内存start_address=FF_require_memory(((REQUIRE_MEMORY *)(data))->size);if(start_address>=0)break;elseSleep(1000);}temp=(THREAD_RESIDENCE_MEMORY *)malloc(sizeof(THREAD_RESIDENCE_MEMORY)); strcpy(temp->thread_name,((REQUIRE_MEMORY *)(data))->thread_name);temp->start_address=start_address;temp->size=((REQUIRE_MEMORY *)(data))->size;temp->next=NULL;EnterCriticalSection(&CS_THREAD_MEMORY_LIST);//参加线程驻留区链表tail_thread_residence_memory_list->next=temp;tail_thread_residence_memory_list=tail_thread_residence_memory_list->next;LeaveCriticalSection(&CS_THREAD_MEMORY_LIST);//显示线程驻留区链表EnterCriticalSection(&CS_SCREEN);printf("after %s %s\n",((REQUIRE_MEMORY *)(data))->thread_name,"get memory:");display_thread_residence_memory_list();LeaveCriticalSection(&CS_SCREEN);Sleep(((REQUIRE_MEMORY *)(data))->duration);//释放内存FF_release_memory(start_address,((REQUIRE_MEMORY *)(data))->size);}//最先顺应分派法：内存申请函数int FF_require_memory(int size){int start_address=-1;FREEAREA *p;FREEAREA *p_next;EnterCriticalSection(&CS_FREEAREA_LIST);p=p_next=p_free_area_list;while(p_next!=NULL){if(size==p_next->size){ //刚好知足请求,删除余暇区结点start_address=p_next->start_address;if(p_next==p_free_area_list)p_free_area_list=p_next->next;elsep->next=p_next->next;free(p_next);break;}elseif(size<p_next->size){ //朋分余暇区结点start_address=p_next->start_address;p_next->start_address+=size;p_next->size-=size;break;}else{p=p_next;p_next=p_next->next;}}LeaveCriticalSection(&CS_FREEAREA_LIST);return start_address;}//最先顺应分派法：内存释放函数void FF_release_memory(int start_address,int size){EnterCriticalSection(&CS_FREEAREA_LIST);//请读者本身实现这段代码LeaveCriticalSection(&CS_FREEAREA_LIST);}//最先顺应分派算法的初始化程序void FF(){int i=0;REQUIRE_MEMORY *p;HANDLE h_thread[MAX_THREAD];InitializeCriticalSection(&CS_THREAD_MEMORY_LIST);InitializeCriticalSection(&CS_FREEAREA_LIST);InitializeCriticalSection(&CS_SCREEN);printf("最先顺应分派算法\n");p_free_area_list=FF_initialize_freearea_list(init_free_area_table,5);p_thread_require_memory_queue=FF_initialize_require_memory_list(init_thread_require_memory _table,3);p_thread_residence_memory_list=FF_initialize_thread_residence_memory_list(init_thread_residen ce_memory_table,5);p=p_thread_require_memory_queue;while(p!=NULL){h_thread[i]=CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)(FF_thread),p,0,NULL);i++;p=p->next;};WaitForMultipleObjects(MAX_THREAD,h_thread,TRUE,-1); //等待所有线程停止EnterCriticalSection(&CS_SCREEN);printf("after all threads have finished:\n");display_thread_residence_memory_list(); //显示驻留线程链表LeaveCriticalSection(&CS_SCREEN);//删除各类链表FF_delete_freearea_list();FF_delete_require_memory_list();FF_delete_thread_residence_memory_list();getch();printf("\n");}//最佳顺应分派算法的线程：申请内存,驻留一段时光,释放内存void BF_thread(void *data){int start_address=-1;THREAD_RESIDENCE_MEMORY *temp;EnterCriticalSection(&CS_SCREEN);printf("create thread:%s\n",((REQUIRE_MEMORY *)(data))->thread_name);LeaveCriticalSection(&CS_SCREEN);//申请内存while(1){start_address=BF_require_memory(((REQUIRE_MEMORY *)(data))->size);if(start_address>=0)break;elseSleep(1000);}temp=(THREAD_RESIDENCE_MEMORY *)malloc(sizeof(THREAD_RESIDENCE_MEMORY)); strcpy(temp->thread_name,((REQUIRE_MEMORY *)(data))->thread_name);temp->start_address=start_address;temp->size=((REQUIRE_MEMORY *)(data))->size;temp->next=NULL;EnterCriticalSection(&CS_THREAD_MEMORY_LIST);//参加线程内存驻留区链表tail_thread_residence_memory_list->next=temp;tail_thread_residence_memory_list=tail_thread_residence_memory_list->next;LeaveCriticalSection(&CS_THREAD_MEMORY_LIST);//显示线程内存驻留区链表EnterCriticalSection(&CS_SCREEN);printf("after %s %s\n",((REQUIRE_MEMORY *)(data))->thread_name,"get memory:");display_thread_residence_memory_list();LeaveCriticalSection(&CS_SCREEN);Sleep(((REQUIRE_MEMORY *)(data))->duration);//释放内存BF_release_memory(start_address,((REQUIRE_MEMORY *)(data))->size);}//最佳顺应分派算法的内存申请函数int BF_require_memory(int size){int start_address=-1;FREEAREA *p;FREEAREA *p_next;EnterCriticalSection(&CS_FREEAREA_LIST);p=p_next=p_free_area_list;while(p_next!=NULL){if(size==p_next->size){//刚好知足请求,删除余暇区结点start_address=p_next->start_address;if(p_next==p_free_area_list)p_free_area_list=p_next->next;elsep->next=p_next->next;free(p_next);break;}elseif(size<p_next->size){//朋分余暇区结点start_address=p_next->start_address;p_next->start_address+=size;p_next->size-=size;p->next=p_next->next;BF_insert_freearea(p_next);break;}else{p=p_next;p_next=p_next->next;}}LeaveCriticalSection(&CS_FREEAREA_LIST);return start_address;}//最佳顺应分派算法的内存释放函数void BF_release_memory(int start_address,int size){//请读者本身实现这段代码}//最佳分派算法的余暇区结点拔出函数void BF_insert_freearea(FREEAREA *free_node){FREEAREA *p;FREEAREA *p_next;if(p_free_area_list==NULL)p_free_area_list=free_node;else{p_next=p=p_free_area_list;while(p_next!=NULL&&p_next->size<free_node->size){p=p_next;p_next=p_next->next;}if(p_next==NULL) //应拔出到尾部p->next=free_node;elseif(p==p_next){ //应拔出到头部free_node->next=p;p_free_area_list=free_node;}else{ //应拔出到p与p_next之间free_node->next=p_next;p->next=free_node;}}}//最佳顺应分派法：初始化余暇区链表void BF_initialize_freearea_list(FREEAREA *init_table,int num){FREEAREA *temp;int i;for(i=0;i<num;i++){temp=(FREEAREA *)malloc(sizeof(FREEAREA));temp->start_address=init_table[i].start_address;temp->size=init_table[i].size;temp->next=NULL;BF_insert_freearea(temp);}}//最佳分派算法的初始化程序void BF(){int i=0;REQUIRE_MEMORY *p;HANDLE h_thread[MAX_THREAD];InitializeCriticalSection(&CS_THREAD_MEMORY_LIST);InitializeCriticalSection(&CS_FREEAREA_LIST);InitializeCriticalSection(&CS_SCREEN);printf("最佳顺应分派算法\n");BF_initialize_freearea_list(init_free_area_table,5);p_thread_require_memory_queue=BF_initialize_require_memory_list(init_thread_require_memory_ table,3);p_thread_residence_memory_list=BF_initialize_thread_residence_memory_list(init_thread_residen ce_memory_table,5);p=p_thread_require_memory_queue;while(p!=NULL){h_thread[i]=CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)(BF_thread),p,0,NULL);i++;p=p->next;};//等待所有线程停止WaitForMultipleObjects(MAX_THREAD,h_thread,TRUE,-1);//显示驻留线程链表EnterCriticalSection(&CS_SCREEN);printf("after all threads have finished:\n");display_thread_residence_memory_list();LeaveCriticalSection(&CS_SCREEN);//删除各类链表FF_delete_freearea_list();FF_delete_require_memory_list();FF_delete_thread_residence_memory_list();getch();printf("\n");}//最坏顺应分派算法的线程：申请内存,驻留一段时光,释放内存void WF_thread(void *data){int start_address=-1;THREAD_RESIDENCE_MEMORY *temp;EnterCriticalSection(&CS_SCREEN);printf("create thread:%s\n",((REQUIRE_MEMORY *)(data))->thread_name);LeaveCriticalSection(&CS_SCREEN);//申请内存while(1){start_address=WF_require_memory(((REQUIRE_MEMORY *)(data))->size);if(start_address>=0)break;elseSleep(1000);}temp=(THREAD_RESIDENCE_MEMORY *)malloc(sizeof(THREAD_RESIDENCE_MEMORY)); strcpy(temp->thread_name,((REQUIRE_MEMORY *)(data))->thread_name);temp->start_address=start_address;temp->size=((REQUIRE_MEMORY *)(data))->size;temp->next=NULL;EnterCriticalSection(&CS_THREAD_MEMORY_LIST);//参加线程内存驻留区链表tail_thread_residence_memory_list->next=temp;tail_thread_residence_memory_list=tail_thread_residence_memory_list->next;LeaveCriticalSection(&CS_THREAD_MEMORY_LIST);//显示线程内存驻留区链表EnterCriticalSection(&CS_SCREEN);printf("after %s %s\n",((REQUIRE_MEMORY *)(data))->thread_name,"get memory:");display_thread_residence_memory_list();LeaveCriticalSection(&CS_SCREEN);Sleep(((REQUIRE_MEMORY *)(data))->duration);//释放内存WF_release_memory(start_address,((REQUIRE_MEMORY *)(data))->size);}//最坏分派算法的余暇区结点拔出函数void WF_insert_freearea(FREEAREA *free_node){FREEAREA *p;FREEAREA *p_next;if(p_free_area_list==NULL)p_free_area_list=free_node;else{p=p_next=p_free_area_list;while(p_next!=NULL&&free_node->size<p_next->size){p=p_next;p_next=p_next->next;}if(p_next==NULL) //应拔出到尾部p->next=free_node;elseif(p==p_next){ //应拔出到头部free_node->next=p;p_free_area_list=free_node;}else{ //应拔出到p与p_next之间free_node->next=p_next;p->next=free_node;}}}//最坏顺应分派法：初始化余暇区链表void WF_initialize_freearea_list(FREEAREA *init_table,int num){FREEAREA *temp;int i;for(i=0;i<num;i++){temp=(FREEAREA *)malloc(sizeof(FREEAREA));temp->start_address=init_table[i].start_address;temp->size=init_table[i].size;temp->next=NULL;WF_insert_freearea(temp);}}//最坏顺应分派算法的内存申请函数int WF_require_memory(int size){int start_address=-1;FREEAREA *p_next;EnterCriticalSection(&CS_FREEAREA_LIST);p_next=p_free_area_list;if(size==p_free_area_list->size){//刚好知足请求,删除余暇区结点start_address=p_next->start_address;p_free_area_list=p_free_area_list->next;free(p_next);}elseif(size<p_next->size){//朋分余暇区结点start_address=p_next->start_address;p_next->start_address+=size;p_next->size-=size;p_free_area_list=p_free_area_list->next;WF_insert_freearea(p_next);}LeaveCriticalSection(&CS_FREEAREA_LIST);return start_address;}//最坏顺应分派算法：内存释放函数void WF_release_memory(int start_address,int size){//请读者本身实现这段代码}//最坏顺应分派算法的初始化程序void WF(){int i=0;REQUIRE_MEMORY *p;HANDLE h_thread[MAX_THREAD];InitializeCriticalSection(&CS_THREAD_MEMORY_LIST);InitializeCriticalSection(&CS_FREEAREA_LIST);InitializeCriticalSection(&CS_SCREEN);printf("最坏顺应分派算法\n");WF_initialize_freearea_list(init_free_area_table,5);p_thread_require_memory_queue=WF_initialize_require_memory_list(init_thread_require_memory _table,3);p_thread_residence_memory_list=WF_initialize_thread_residence_memory_list(init_thread_residen ce_memory_table,5);p=p_thread_require_memory_queue;while(p!=NULL){h_thread[i]=CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)(WF_thread),p,0,NULL);i++;p=p->next;};//等待所有线程停止WaitForMultipleObjects(MAX_THREAD,h_thread,TRUE,-1);//显示驻留线程链表EnterCriticalSection(&CS_SCREEN);printf("after all threads have finished:\n");display_thread_residence_memory_list();LeaveCriticalSection(&CS_SCREEN);//删除各类链表FF_delete_freearea_list();FF_delete_require_memory_list();FF_delete_thread_residence_memory_list();getch();printf("\n");}.2 linux下的参考源程序○1编译敕令gcc variable_partition .cpp –o variable_partition.o –lcurses –lpthread○2程序清单#include <unistd.h>#include <curses.h>#include <stdlib.h>#include <pthread.h>#include <time.h>#include <string.h>#include <semaphore.h>#define MAX_THREAD 3#define BF_initialize_require_memory_list FF_initialize_require_memory_list #define WF_initialize_require_memory_list FF_initialize_require_memory_list #define BF_initialize_thread_residence_memory_listFF_initialize_thread_residence_memory_list#define WF_initialize_thread_residence_memory_listFF_initialize_thread_residence_memory_list#define WF_delete_freearea_list FF_delete_freearea_list#define BF_delete_freearea_list FF_delete_freearea_list#define WF_delete_require_memory_list FF_delete_require_memory_list#define BF_delete_require_memory_list FF_delete_require_memory_list#define WF_delete_thread_residence_memory_listFF_delete_thread_residence_memory_list#define BF_delete_thread_residence_memory_listFF_delete_thread_residence_memory_listtypedef struct freearea{struct freearea *next;int start_address;int size;}FREEAREA;typedef struct require_memory{struct require_memory *next;char thread_name[10];int size;int duration;}REQUIRE_MEMORY;typedef struct thread_residence_memory{struct thread_residence_memory *next;char thread_name[10];int start_address;int size;}THREAD_RESIDENCE_MEMORY;FREEAREA init_free_area_table[5]={{NULL,10,10},{NULL,40,30},{NULL,80,5},{NULL,145,15},{NULL,180,20}};REQUIRE_MEMORY init_thread_require_memory_table[3]={{NULL,"thread_1",20,4},{NULL,"thread_2",10,5},{NULL,"thread_3",5,6}};THREAD_RESIDENCE_MEMORY init_thread_residence_memory_table[5]={ {NULL,"a",0,10},{NULL,"b",20,20},{NULL,"c",70,10},{NULL,"d",85,60},{NULL,"e",160,20}};FREEAREA *p_free_area_list=NULL;REQUIRE_MEMORY *p_thread_require_memory_queue=NULL;THREAD_RESIDENCE_MEMORY *p_thread_residence_memory_list=NULL;THREAD_RESIDENCE_MEMORY *tail_thread_residence_memory_list=NULL;pthread_mutex_t CS_THREAD_MEMORY_LIST;pthread_mutex_t CS_SCREEN;pthread_mutex_t CS_FREEAREA_LIST;pthread_t h_thread[MAX_THREAD];sem_t thread_end[MAX_THREAD];void display_thread_residence_memory_list();FREEAREA *FF_initialize_freearea_list(FREEAREA *init_table,int num);void FF_delete_freearea_list();REQUIRE_MEMORY *FF_initialize_require_memory_list(REQUIRE_MEMORY *init_table,int num);void FF_delete_require_memory_list();THREAD_RESIDENCE_MEMORY *FF_initialize_thread_residence_memory_list(THREAD_RESIDENCE_MEMORY *init_table,int num);void FF_delete_thread_residence_memory_list();void* FF_thread(void *data);int FF_require_memory(int size);void FF_release_memory(int start_address,int size);void FF();void* BF_thread(void *data);int BF_require_memory(int size);void BF_release_memory(int start_address,int size);void BF_insert_freearea(FREEAREA *free_node);void BF();void BF_initialize_freearea_list(FREEAREA *init_table,int num);void* WF_thread(void *data);void WF_insert_freearea(FREEAREA *free_node);void WF_initialize_freearea_list(FREEAREA *init_table,int num);int WF_require_memory(int size);void WF_release_memory(int start_address,int size);void WF();源文件variable_partition.cpp#include "variable_partition.h"int main(int argc,char *argv[]){char select;bool end=false;initscr();while(!end){clear();refresh();printw("|-----------------------------------|\n");printw("| 1:first fit allocation |\n");printw("| 2:best fit allocation |\n");printw("| 3:worst fit allocation |\n");printw("| 4:exit |\n");printw("|-----------------------------------|\n");printw("select a function(1~4):");do{select=(char)getch();}while(select!='1'&&select!='2'&&select!='3'&&select!='4');clear();refresh();switch(select){case '1':FF();。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
1实验5 动态异长分区的存储分配与回收算法实验目的理解存储管理的功能，掌握动态异长分区的存储分配与回收算法。
存储器是计算机系统中的关键资源，存储管理一直是操作系统的最主要功能之一。
存储管理既包括内存资源管理，也包括用于实现分级存储体系的外存资源的管理。
通常，内存与外存可采用相同或相似的管理技术，如内存采用段式存储管理，则外存也采用段式存储管理。
存储管理需要完成如下功能：存储分配、存储共享、存储保护、存储扩充、地址映射。
当一个作业进入内存时，由操作系统将其变为进程,并为进程分配存储空间。
进程运行结束时, 由操作系统将其所占用的存储空间收回。
不同的操作系统对内存空间的划分与分配方法是不同的，通常分为两类：静态等长分区的分配和动态异长分区的分配。
静态等长分区常用于页式存储管理方式与段页式存储管理方式，存储空间被静态地划分为若干个长度相等的区域，每个区域被称作一个页面。
动态异长分区常用于界地址存储管理方式与段式存储管理方式，存储空间被动态地划分为若干个长度不等的区域。
5.2 实验要求本实验要求模拟动态异长分区的分配算法、回收算法和碎片整理算法。
最先适应分配法：内存释放函数void FF_release_memory(int start_address,int size){EnterCriticalSection(&CS_FREEAREA_LIST);__int64 t1, t2; //记录该算法起止时间t1 = GetCycleCount(); //记录起始时间FREEAREA *temp,*p,*pp;//将空闲区按start_address由小到大排序，以便整合相邻空闲区while(1){int change = 0;p = p_free_area_list;if(p->next != NULL){if(p->start_address > p->next->start_address){pp = p->next;p->next = pp->next;pp->next = p;p_free_area_list = pp;change = 1;}}if(p->next != NULL){while(p->next->next != NULL){if(p->next->start_address > p->next->next->start_address ){pp = p->next->next;p->next->next = pp->next;pp->next = p->next;p->next = pp;change = 1;}p = p->next ;}}if(change == 0){break;}}//插入空闲区temp = new FREEAREA;p = new FREEAREA;temp->start_address = start_address;temp->size = size;temp->next = NULL;p->next = p_free_area_list;while(p->next != NULL){if(p->next->start_address > temp->start_address){temp->next = p->next ;p->next = temp;break;}else{p = p->next ;}}if(p->next == NULL){p->next = temp;}else if(temp->next == p_free_area_list){p_free_area_list = temp;}//整合碎片while(1){int change = 0;p = p_free_area_list;if(p == NULL){break;}while(p->next != NULL){if((p->start_address + p->size) == (p->next->start_address)){p->size = p->next->size + p->size;change = 1;if(p->next->next == NULL){free(p->next);p->next = NULL;}else{p->next = p->next->next;}}if(p->next == NULL){break;}else{p = p->next ;}}if(change == 0){break;}}//整理线程结束后的驻留链表THREAD_RESIDENCE_MEMORY *q;q = p_thread_residence_memory_list;if(q->start_address == start_address){p_thread_residence_memory_list = p_thread_residence_memory_list->next ;}else{while(q->next != NULL){if(q->next->start_address == start_address){if(q->next == tail_thread_residence_memory_list){tail_thread_residence_memory_list = q;}q->next = q->next->next ;break;}q = q->next;}}//记录结束时间，并将运行时间存入对应数组t2 = GetCycleCount();if(time[0][0] > t2 - t1){time[0][0] = t2 - t1;}if(time[0][1] < t2 - t1){time[0][1] = t2 - t1;}LeaveCriticalSection(&CS_FREEAREA_LIST);}最佳适应分配算法的内存释放函数void BF_release_memory(int start_address,int size){EnterCriticalSection(&CS_FREEAREA_LIST);__int64 t1, t2; //记录该算法起止时间t1 = GetCycleCount(); //记录起始时间FREEAREA *temp,*p,*pp;//将空闲区按start_address由小到大排序，以便整合相邻空闲区while(1){int change = 0;p = p_free_area_list;if(p->next != NULL){if(p->start_address > p->next->start_address){pp = p->next;p->next = pp->next;pp->next = p;p_free_area_list = pp;change = 1;}}if(p->next != NULL){while(p->next->next != NULL){if(p->next->start_address > p->next->next->start_address ){pp = p->next->next;p->next->next = pp->next;pp->next = p->next;p->next = pp;change = 1;}p = p->next ;}}if(change == 0){break;}}//插入空闲区temp = new FREEAREA;p = new FREEAREA;temp->start_address = start_address;temp->size = size;temp->next = NULL;p->next = p_free_area_list;while(p->next != NULL){if(p->next->start_address > temp->start_address){temp->next = p->next ;p->next = temp;break;}else{p = p->next ;}}if(p->next == NULL){p->next = temp;}else if(temp->next == p_free_area_list){p_free_area_list = temp;}//整合碎片while(1){int change = 0;p = p_free_area_list;if(p == NULL){break;}while(p->next != NULL){if((p->start_address + p->size) == (p->next->start_address)){ p->size = p->next->size + p->size;change = 1;if(p->next->next == NULL){free(p->next);p->next = NULL;}else{p->next = p->next->next;}}if(p->next == NULL){break;}else{p = p->next ;}}if(change == 0){break;}}//将空闲区按SIZE由小到大排序，以便符合BF算法while(1){int change = 0;p = p_free_area_list;if(p->size > p->next->size){pp = p->next;p->next = pp->next;pp->next = p;p_free_area_list = pp;change = 1;}while(p->next->next != NULL){if(p->next->size > p->next->next->size ){pp = p->next->next;p->next->next = pp->next;pp->next = p->next;p->next = pp;change = 1;}p = p->next ;}if(change == 0){break;}}//整理线程结束后的驻留链表THREAD_RESIDENCE_MEMORY *q;q = p_thread_residence_memory_list;if(q->start_address == start_address){p_thread_residence_memory_list = p_thread_residence_memory_list->next ;}else{while(q->next != NULL){if(q->next->start_address == start_address){if(q->next == tail_thread_residence_memory_list){tail_thread_residence_memory_list = q;}q->next = q->next->next ;break;}q = q->next;}}//记录结束时间，并将运行时间存入对应数组t2 = GetCycleCount();if(time[1][0] > t2 - t1){time[1][0] = t2 - t1;}if(time[1][1] < t2 - t1){time[1][1] = t2 - t1;}LeaveCriticalSection(&CS_FREEAREA_LIST);}最坏适应分配算法：内存释放函数void WF_release_memory(int start_address,int size){EnterCriticalSection(&CS_FREEAREA_LIST);__int64 t1, t2; //记录该算法起止时间t1 = GetCycleCount(); //记录起始时间FREEAREA *temp,*p,*pp;//将空闲区按start_address由小到大排序，以便整合相邻空闲区while(1){int change = 0;p = p_free_area_list;if(p->next != NULL){if(p->start_address > p->next->start_address){pp = p->next;p->next = pp->next;pp->next = p;p_free_area_list = pp;change = 1;}}if(p->next != NULL){while(p->next->next != NULL){if(p->next->start_address > p->next->next->start_address ){pp = p->next->next;p->next->next = pp->next;pp->next = p->next;p->next = pp;change = 1;}p = p->next ;}}if(change == 0){break;}}//插入空闲区temp = new FREEAREA;temp->start_address = start_address;temp->size = size;temp->next = NULL;p = new FREEAREA;p->next = p_free_area_list;while(p->next != NULL){if(p->next->start_address > temp->start_address){temp->next = p->next ;p->next = temp;break;}else{p = p->next ;}}if(p->next == NULL){p->next = temp;}else if(temp->next == p_free_area_list){p_free_area_list = temp;}//整合碎片while(1){int change = 0;p = p_free_area_list;if(p == NULL){break;}while(p->next != NULL){if((p->start_address + p->size) == (p->next->start_address)){ p->size = p->next->size + p->size;change = 1;if(p->next->next == NULL){free(p->next);p->next = NULL;}else{p->next = p->next->next;}}if(p->next == NULL){break;}else{p = p->next ;}}if(change == 0){break;}}//将空闲区按SIZE由大到小排序，以便符合WF算法while(1){int change = 0;p = p_free_area_list;if(p->size < p->next->size){pp = p->next;p->next = pp->next;pp->next = p;p_free_area_list = pp;change = 1;}while(p->next->next != NULL){if(p->next->size < p->next->next->size ){pp = p->next->next;p->next->next = pp->next;pp->next = p->next;p->next = pp;change = 1;}p = p->next ;}if(change == 0){break;}}//整理线程结束后的驻留链表THREAD_RESIDENCE_MEMORY *q;q = p_thread_residence_memory_list;if(q->start_address == start_address){p_thread_residence_memory_list = p_thread_residence_memory_list->next ;}else{while(q->next != NULL){if(q->next->start_address == start_address){if(q->next == tail_thread_residence_memory_list){tail_thread_residence_memory_list = q;}q->next = q->next->next ;break;}q = q->next;}}//记录结束时间，并将运行时间存入对应数组t2 = GetCycleCount();if(time[2][0] > t2 - t1){time[2][0] = t2 - t1;}if(time[2][1] < t2 - t1){time[2][1] = t2 - t1;}LeaveCriticalSection(&CS_FREEAREA_LIST);}。