存储管理动态异长存储资源分配算法
动态异长分区的存储分配与回收算法

实验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.实验过程:#include "stdafx.h"#ifdef HAVE_CONGIG_H#include <config.g>#endif#include <stdio.h>#include <stdlib.h>#include MAPSIZE 100struct map{int m_addr;int m_size;};struct map map[MAPSIZE];int BF_malloc(struct map *mp,int size){register int a,s;register struct map *bp,*bpp;for(bp=mp;bp->size;bp++){if(bp->m_size>=size){a=bp->m_addr;s=bp->m_size;for(bpp=bp;bpp->m_size;bpp++){if(bpp->m_size>=size && bpp->m_size<s){a=bpp->m_addr;s=bpp->m_size;bp=bpp;}}bp->m_addr+=size;if((bp->m_size-=size)==0)do{bp++;(bp-1)->m_addr=bp->m_size);}while((bp-1)->m_size=bp->m_size);return(a);}}return(-1);}int WF_malloc(struct map *map,int size){register int a,s;register struct map *bp,*bpp;for(bp=mp;bp->m_size;bp++){if(bp->m_size>=size){a=bp->m_addr;s=bp->m_size;for(bpp=bp;bpp->m_size;bpp++){if(bpp->m_size>s){a=bpp->m_addr;s=bpp->m_size;bp=bpp;}}bp->m_addr+=size;if((bp->m_size-=size)==0)do{bp++;(bp-1)->m_size=bp->m_size);}while((bp-1)->m_size=bp->m_size);return(a);}}return(-1);}void mfree(struct map *map,int aa,int size){register struct map *bp;register int t;register int a;a=aa;for(bp=mp;bp->m_addr <=a && bp->m_addr !=0;bp++) ;if(bp>mp && (bp-1)->m_addr+(bp-1)->m_addr==a){(bp-1)->m_addr +=size;if(a+size==bp->m_addr ){(bp-1)->m_size +=bp->m_size;while(bp->m_size ){bp++;(bp-1)->m_addr =bp->m_addr;(bp-1)->m_size =bp->m_size ;}}}else{if(a+size==bp->m_addr && bp->m_size){bp->m_addr -=size;bp->m_size +=size;}else if(size)do{t=bp->m_addr;bp->m_addr=a;a=t;t=bp->m_size;bp->m_size=size;bp++;}while(size=t);}}void init(){struct map *bp;int addr,size;int i=0;bp=map;printf("Please input starting addr and total size:");scanf("%d,%d",&addr,&size);bp->m_addr=addr;bp->m_size=size;(++bp)->m_size=0;}void show_map(){int i=0;struct map *bp;bp=map;printf("\nCurrent memory map...\n");printf("Address\t\tSize\n");while(bp->m_size!=0){printf("<%d\t\t%d>\n",bp->m_addr,bp->m_size);bp++;}printf("\n");}main(){int a,s;int c;int i;init();printf("Please input,b for BF,w for WF:");scanf("%c",&c);do{show_map();printf("Please input,1 for request,2 for relese,0 for exit:");scanf("%d",&i);switch (i){case 1;printf("Please input size:");scanf("%d",&s);if(c=='b')a=BF_malloc(map,s);elsea=WF_malloc(map,s);if(a==-1)printf("request can't be satisfied \n");elseprintf("alloc memory at address:%d,size:%d \n",a,s);break;case 2;printf("Please input addr and siae:");scantf("%d,%d",&a,&s);mfree(map,a,s);break;case 0:exit(0);}}while(1);}。
动态异长分区内存分配与去配算法的设计-最佳适应算法

动态异长分区内存分配与去配算法的设计-最佳适应算法动态异长分区内存分配与去配算法的设计-最佳适应算法
动态异长分区内存分配是一种内存管理方式,它将物理内存划分为若干个不同大小的分区。
在应用程序运行时,系统会根据需要为程序分配相应大小的内存分区,使得程序能够正常运行。
在程序运行结束后,系统需要将分配的内存空间释放,以供其他程序使用。
最佳适应算法是一种常用的动态异长分区内存分配算法。
该算法在为程序分配内存分区时,会选择最小的能够容纳该程序的空闲分区。
如果不存在这样的分区,则会将内存空间进行分裂,以满足程序的需要。
在释放内存空间时,该算法会将相邻的空闲分区进行合并,以增加可用内存空间的大小。
最佳适应算法的优点在于,它能够更好地利用内存空间,减少内存浪费。
但是,该算法需要对空闲分区进行排序,以便快速找到最合适的空闲分区。
这会增加算法的时间复杂度和内存消耗。
总的来说,最佳适应算法是一种高效的动态异长分区内存分配算法,它能够更好地利用内存空间,减少内存浪费。
但是,该算法需要对空闲分区进行排序,可能会增加算法的时间复杂度和内存消耗。
存储管理

存储管理主要是指对内存空间的管理(外存管理见文件 系统)。内存空间一般分为两部分:系统区和用户区。 系统区存放系统程序和系统数据等;用户区存放用户 的程序和数据等。存储管理主要是对内存中用户区进 行管理。
存储管理功能 内存资源管理 存储管理方式
1 存储管理功能
存储空间的分配和回收
静态地址映射:程序装入内存时进行地址转换; 动态地址映射:程序执行过程中进行地址转换, 需要硬件的支持。
2 内存资源管理
2.1 内存分区
分区时刻
静态分区:系统初始化时分; 动态分区:申请时分。 等长分区:2i 异长分区:依程序、程序单位、对象大小。 静态+等长(页式、段页式) 动态+异长(段式、可变分区方式)
X(段号1) e: 调用y段f
80k-1 D(段号3)
0 a: … 20k-1 段内地址 (二维地址)
逻辑地址=
段号
3. 对应关系
main
... 100k: 40k
...
200k:
x
60k
... 300k: 320k:
y
20k 80k ... 内存空间
d
进程空间
4. 所需表目
(1) 段表:每进程一个
b: l b 段号 ... 段首址 段长 … b’ … … l’ …
物理地址
b’+d
s
... ... b l ... PCB s d 逻辑地址 若查不到
+
段号 .. . s .. .
段长 段首址 … ... l’ b’ … ...
cp
b: l cp b + 段号 ... 段首址 段长 … b’ … ... l’ ...
存储管理动态分区分配及回收算法

存储管理动态分区分配及回收算法存储管理是操作系统中非常重要的一部分,它负责对计算机系统的内存进行有效的分配和回收。
动态分区分配及回收算法是其中的一种方法,本文将详细介绍该算法的原理和实现。
动态分区分配及回收算法是一种将内存空间划分为若干个动态分区的算法。
当新的作业请求空间时,系统会根据作业的大小来分配一个合适大小的分区,使得作业可以存储在其中。
当作业执行完毕后,该分区又可以被回收,用于存储新的作业。
动态分区分配及回收算法包括以下几个步骤: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();。
动态异长分区的存储分配与回收算法

真验5 动背同少分区的保存调配与回支算法之阳早格格创做5.1 真验手段明白保存管制的功能,掌握动背同少分区的保存调配与回支算法.保存器是估计机系统中的闭键资材,保存管制背去是支配系统的最主要功能之一.保存管制既包罗内存资材管制,也包罗用于真止分级保存体系的中存资材的管制.常常,内存与中存可采与相共或者相似的管制技能,如内存采与段式保存管制,则中存也采与段式保存管制.保存管制需要完毕如下功能:保存调配、保存共享、保存呵护、保存扩充、天面映射.当一个做业加进内存时,由支配系统将其形成进程,并为进程调配保存空间.进程运止中断时, 由支配系统将其所占用的保存空间支回.分歧的支配系统对付内存空间的区分与调配要领是分歧的,常常分为二类:固态等少分区的调配战动背同少分区的调配.固态等少分区时常使用于页式保存管制办法与段页式保存管制办法,保存空间被固态天区分为若搞个少度相等的天区,每个天区被称做一个页里. 动背同少分区时常使用于界天面保存管制办法与段式保存管制办法,保存空间主动背天区分为若搞个少度不等的天区.5.2 真验央供本真验央供模拟动背同少分区的调配算法、回支算法战碎片整治算法.5.3 真验步调数据结构分解为了真止保存资材的调配战回支,支配系统需要记录内存资材使用情况,即哪些天区尚已调配,哪些天区已经调配以及调配给哪些进程等.为此普遍需要二个表,一个为调配表, 其余一个为空忙天区表.前者记录已经调配的天区, 后者记录着所有目前已被进程占用的空忙天区, 如图51所示.隐然, 不记录于表中的天区即为已被进程所占用的非空忙天区,正在本质的支配系统中,那些天区备案正在进程的PCB 中.而PCB 中除了闭于内存资材的疑息中,另有其余洪量疑息.由于本真验是对付保存管制算法的模拟,所以用一个线程去代表一个进程,用线程驻留天区表去形貌线程占用的内存空间,如图52所示.图51 空忙天区表共时,需要一弛表去记录各个线程对付内存的哀供疑息,如图53所示.算法分解时常使用的动背同少分区的调配算法有:最先符合算法、最好符合算法战最坏符合算法.1. 最先符合算法(First Fit,FF)对付于保存申请下令, 采用谦脚申请少度央供且起初天面最小的空忙天区.正在真止时, 可将系统中所有的空忙天区依照起初天面由小到大的序次依次记录于空忙天区表中.当进程申请保存空间时, 系统由表的头部启初查找, 与第一个谦脚央供的表目.如果该表目所对付应的天区少度恰好与所申请的天区少度相共, 则将该天区局部调配给申请者.可则将该天区分隔为二部分, 一部分的少度与所申请的少度相共, 将其调配给申请者;另一部分的少度为本少度与调配少度之好, 将其仍记录于空忙天区表中.回支时,按回支区的尾天面查询空忙区表,若有与回支区相临的空忙区,则将其合并到相临区中,可则,把回支区依照天面从矮到下的程序拔出到空忙天区表的适合位子.2. 最好符合算法(Best Fit,BF)调配时与谦脚申请央供且少度最小的空忙天区.正在真止时, 可将系统中所有的空忙天区依照少度由小到大的序次依次记录于空忙天区表中.与最先符合算法相类似, 当进程申请保存空间时, 系统由表的头部启初查找, 与第一个谦脚央供的表目.如果该表目所对付应的天区少度恰好与所申请的天区少度相共, 则将该天区局部调配给申请者.可则将该天区分隔为二部分, 一部分的少度与所申请的少度相共, 将其调配给申请者;另一部分即结余部分的少度为本少度与调配少度之好, 由于结余部分的少度已经改变,所以应沉新将其按少度从小到大的程序拔出到空忙天区表中.回支时,不但是要按回支区的尾天面查询空忙区表,找到与回支区相临的空忙区,将其合并到相临区中,而且要把合并后的回支区依照少度递加的程序拔出到空忙天区表的适合位子.3. 最坏符合算法(Worst Fit,WF)调配时与谦脚申请央供且少度最大的空忙天区.正在真止时, 可将系统中所有的空忙天区依照少度由大到小的序次依次记录于空忙天区表中.当进程申请保存空间时, 与第一个表目.如果该表目所对付应的天区少度恰好与所申请的天区少度相共, 则将该天区局部调配给申请者.可则将该天区分隔为二部分, 一部分的少度与所申请的少度相共, 将其调配给申请者;另一部分即结余部分的少度为本少度与调配少度之好, 由于结余部分的少度已经改变,所以应沉新将其按少度递减的程序拔出到空忙天区表中.回支时,不但是要按回支区的尾天面查询空忙区表,找到与回支区相临的空忙区,将其合并到相临区中,而且要把合并后的回支区依照少度递减的程序拔出到空忙天区表的适合位子.安排并分解尝试数据假设初初内存筹备如图54,图中的起初天面以及大小皆以KB去衡量.占用者大小图54初初内存筹备由图54可睹,初初时公有五个线程驻留正在内存,它们是a,b,c,d,e,线程驻留区表如图55;另有五个空忙区,空忙天区表如图56.假设目前有三个线程提出内存申请,申请情况睹图57.通太过解咱们得到正在每种调配算法下那三个线程所申请到的内存情况.图58是最先符合算法调配情况,图59是最好符合算法调配情况,图510是最坏符合算法调配情况.另一个是源步调文献variable_partition.cpp.正在头文献中定义了宏、数据结构、局部变量、函数声明,源步调中含有各个函数的真止.正在头文献中,结构体FREEAREA、REQUIRE_MEMO RY、THREAD_RESIDENCE_MEMORY分别对付应于图5 1、图52、图53中的一止,分歧之处是为了形成链表正在三个结构体中皆有前背指针.数组init_free_area_table对付应于图56,数组init_thread_require_memory_table对付应于图55,数组init_thread_residence_memory_table对付应于图5 7,为了真止动背调配与释搁,用链表沉新构造空忙天区表、线程驻留区表战内存申请表,局部变量p_free_area_list 是空忙区链尾,p_thread_require_memory_queue是内存申请行列的队尾,p_thread_residence_memory_list是线程驻留区链尾,tail_thread_residence_memory_list是线程驻留区链尾,由于线程驻留区链表被内存调配函数战内存释搁函数共享,故用临界区变量CS_THREAD_MEMORY_LIST去呵护,共理,屏幕是所有线程共享的,所以用临界区变量CS _SCREEN去呵护,空忙区链表被内存调配函数战内存释搁函数共享,故用临界区变量CS_FREEAREA_LIST去呵护.h_t hread是线程句柄数组,用去存搁各个线程的句柄.步调共包罗25个函数,依照效率不妨将它们分成五组.第一组是主函数main(),其效率是隐现主菜单并根据用户的采用真止相映功能;第二组包罗函数print_space()战函数display_thread_residence_memory(),前者用去隐现若搞个空格,后者用去隐现线程驻留区表;第三组共十个函数,用去真止最先符合调配法,它们的称呼及功能如图511.第四组共六个函数,用去真止最好符合调配法,它们的称呼及功能如图512.第五组共六个函数,用去真止最坏符合调配法,它们的称呼及功能如图513.参照源代码.1 windows下的参照源步调底下是完备的步调浑单.头文献 variable_partition.h 的浑单#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_MEMORYinit_thread_require_memory_table[3]={//尝试数据:初初内存申请表{NULL,"thread_1",20,4},{NULL,"thread_2",10,5},{NULL,"thread_3",5,6}};/ /尝试数据:初初线程驻留区表THREAD_RESIDENCE_MEMORYinit_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,intnum);//初初化空忙区链表//最坏符合调配算法的函数void WF_thread(void *data);//线程函数void WF_insert_freearea(FREEAREA *free_node);//空忙区结面拔出函数void WF_initialize_freearea_list(FREEAREA *init_table,intnum);//初初化空忙区链表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(18strlen(p>thread_name));printf("| %d",p>start_address);itoa( p>start_address, buffer, 10 );print_space(19strlen(buffer));printf("| %d",p>size);itoa(p>size, buffer, 10 );print_space(17strlen(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_RESI DENCE_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_MEMOR Y *)(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_MEMOR Y *)(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_LIS T);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_me mory_list(init_thread_require_memory_table,3);p_thread_residence_memory_list=FF_initialize_thread_resid ence_memory_list(init_thread_residence_memory_table,5); p=p_thread_require_memory_queue;while(p!=NULL){h_thread[i]=CreateThread(NULL,0,(LPTHREAD_START_RO UTINE)(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_MEMO RY *)(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_MEMOR Y *)(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_LIS T);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_m emory_list(init_thread_require_memory_table,3);p_thread_residence_memory_list=BF_initialize_thread_res idence_memory_list(init_thread_residence_memory_table,5);p=p_thread_require_memory_queue;while(p!=NULL){h_thread[i]=CreateThread(NULL,0,(LPTHREAD_START_RO UTINE)(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_MEMO RY *)(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_MEMOR Y *)(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_LIS T);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_re sidence_memory_list(init_thread_residence_memory_table,5); p=p_thread_require_memory_queue;while(p!=NULL){h_thread[i]=CreateThread(NULL,0,(LPTHREAD_START_RO UTINE)(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");}.2linux下的参照源步调○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_listFF_initialize_require_memory_list#define WF_initialize_require_memory_listFF_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_listFF_delete_require_memory_list#define BF_delete_require_memory_listFF_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_MEMORYinit_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,in t 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();#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();break;case '2':BF();break;case '3':WF();break;case '4':end=true;}printw("\nPress any key to return to main menu.");refresh();getch();}endwin();return 0;}void display_thread_residence_memory_list(){THREAD_RESIDENCE_MEMORY *p;p=p_thread_residence_memory_list;int i=13;move(10,0);printw("||||\n");printw("| thread_name | start_address(kB) | size(KB) |\n");printw("||||\n");while(p!=NULL){move(i,0);printw("| %s",p>thread_name);move(i,20);printw("| %d",p>start_address);move(i,41);printw("| %d",p>size);move(i,60);printw("|\n");。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
.存储管理—动态异长存储资源分配算法一、设计目的理解动态异长存储分区资源管理,掌握所需数据结构和管理程序,了解各种存储分配算法的优点和缺点。
二、设计内容(1)分析UNIX最先适应(First Fit,FF)存储分配算法,即map数据结构、存储分配函数malloc()和存储释放函数mfree(),找出与算法有关的成分。
(2) 修改上述与算法有关的成分,使其分别体现BF(Best Fit,最佳适应)分配原则和WF(Worst Fit,最环适应)分配原则。
三、设计准备(理论、技术)1.最先适应(First Fit,FF)算法指对于存储申请命令,选取满足申请长度要求且起始地址最小的空闲区域。
在实现时,可以将系统中所有的空闲区域按照起始地址由小到大的次序依次记录于空闲区域表中。
当进程申请存储空间时,系统由表的头部开始查找,取满足要求的第一个表目。
如果表目所对应的区域长度恰好与申请的区域长度相同,则将该区域全部分配给申请者,否则将该区域分割为两部分,一部分的长度与申请长度相同,将其分配给申请者;另一部分的长度为原长度与分配长度之差,将其记录在空闲区域表中2.最佳适应(Best Fit,BF)算法是为了克服最先适应算法缺点提出的。
它在分配时取满足申请要求且长度最小的空间区域。
在实现时,可以将系统中所有的空闲区域按照长度由小到大的次序依次记录于空闲区域表中。
当进程申请存储空间时,系统由表的头部开始查找,取满足要求的第一个表目。
3.最坏适应(Worst Fit,WF)算法是为了克服最佳适应算法的缺点而提出的。
它在分配时取满足申请要求且长度最大的空闲区域。
在实现时,可以将系统中所有的空闲区域按照长度由小到大的次序依次记录于空闲区域表中。
当进程申请存储空间时,取第一个表目。
4.程序设计技术分析按题目题目首先对存储分配表进行初始化;然后对用户输入的请求和释放,按照动态更新存储分配表,并将每次更新之后的存储分配表在屏幕上显示出来动态分区分配需要解决三个问题:A.对于请求表中的要求内存长度,从可用表或自由链寻找出合适的空闲区域分配程序。
B.分配空闲区后更新自由链或可用表。
C.进程或作业释放内存资源时,合并相邻空闲区并刷新可用表。
四、设计过程(设计思想、代码实现)1.设计思想(1)分析最先适应算法,定义map数据结构;设置整形变量存储存储资源表信息 struct map{int m_addr;int m_size;};..(2) 分析UNIX最先适应存储分配算法编写最佳适应算法BF_malloc();遍历链表,取满足申请要求且长度最小的空间区域for(bpp=bp;bpp->m_size;bpp++){//最佳适应if(bpp->m_size>=size&&bpp->m_size<s){a=bpp->m_addr;s=bpp->m_size;bp=bpp;}}(3)根据最好适应算法编写最坏适应算法WF_malloc(),主要代码如下:for(bpp=bp;bpp->m_size;bpp++){//最坏适应if(bpp->m_size>s){a=bpp->m_addr;s=bpp->size;bp=bpp;}}(4)存储释放函数mfree();被释放的存储区域与前合并条件:if(bp>mp&&(bp-1)->m_addr+(bp-1)->m_size==a)与后合并条件:if(a+size==bp->m_addr&&bp->m_size)无合并条件:if(size)(5)showMap()方法显示存储资源表;(6)存储分配表进行初始化方法init()2.代码实现#ifdef HAVE_CONFIG_H#include<config.h>//分配布局函数#endif#include<stdio.h>#include<stdlib.h>#include<iostream.h>#define MAPSIZE 100struct map//存储资源表结构{int m_addr;int m_size;};struct map map[MAPSIZE];//存储资源表//BF存储分配函数int BF_malloc(struct map *mp,int size){ register int a,s;register struct map *bp,*bpp;for(bp=mp;bp->m_size;bp++){if(bp->m_size>=size){a=bp->m_addr;..s=bp->m_size;for(bpp=bp;bpp->m_size;bpp++){//最佳适应 if(bpp->m_size>=size&&bpp->m_size<s){ a=bpp->m_addr;s=bpp->m_size;bp=bpp;}}bp->m_addr+=size;if((bp->m_size-==size)==0)do{bp++;(bp-1)->m_addr=bp->m_addr;}while((bp-1)->m_size=bp->m_size)return(a);}}return(1);}//WF存储分配函数int WF_malloc(struct map *mp,int size){ register int a,s;register struct map *bp,*bpp;for(bp=mp;bp->m_size;bp++){if(bp->m_size>=size){a=bp->m_addr;s=bp->m_size;for(bpp=bp;bpp->m_size;bpp++){//最坏适应 if(bpp->m_size>s){a=bpp->m_addr;bp=bpp;}}bp->m_addr+=size;if((bp->size-==size)==0)do{bp++;(bp-1)->m_addr=bp->m_addr;}while((bp-1)->m_size=bp->m_size);return(a);}..}return(-1);}//存储释放函数void mfree(struct map *mp,int aa,int size){register struct map *bp;register int t;register int a;a=aa;for(bp=mp;bp->m_addr<=a&&bp->m_size!0;bp++)if(bp>mp&&(bp-1)->m_addr+(bp-1)->m_size==a){//与前合并 (bp-1)->m_size+=size;(bp-1)->m_size+=bp->m_size;while(bp->m-size){bp++;(bp-1)->m_addr=bp->m_addr;(bp-1)->m_size=bp->size;}}else{if(a+size==bp->m_addr&&bp->m_size){//与后合并bp->m_addr-=size;bp->m_size+=size;}else if(size)do{//无合并t=bp->m_addr;a=t;t=bp->m_size;bp->m_size=size;bp++;}while(size=t);}}void init(){//初始化该链表的指针struct map *bp;int addr,size;int i=0;bp=map;cout<<please input starting addr and total size<<endl; cin>>addr>>size;bp->m_addr=addr;..bp->m_size=size;(++bp)->m_size=0;//表尾}void showMap(){//显示存储资源表int i=0;struct map *bp;bp=map;cout<<\Current memory map...<<endl;while(bp->m_size!=0){cout<<<<<bp->m_addr<<\ \t<<bp->m_size<<><<endl;bp++;}printf(\);}void main(){int a,s;//地址,表长int c;//选择算法int i;//选择需求init();cout<<Please input,b for BF,w for WF:<<endl;cin>>c;do{showMap();cout<<Please input,1 for request,2 for release,0 forexit:<<endl;cin>>i;switch(i){case 1:cout<<Please input size<<endl;cin>>s;if(c=='b')a=BF_malloc(map,s);elsea=WF_malloc(map,s);if(a==-1)cout<<equest can't be satisfied<<endl;elsecout<<alloc memory at address:<<a<<size:<<s<<endl;break;case 2:cout<<Please input addr and size<<endl;cin>>a>>s;mfree(map,a,s);break;..case 0:exit(0);}}while(1);}五、设计结果并分析根据提示输入存储资源表地址和表长;测试数据:0,100;选择适应算法:最好适应算法输入b,最坏适应算法输入w;测试数据:b 初始化存储资源表;显示地址和表长<0 100>选择要求1.请求,2.释放,0.退出;测试数据:1;输入表长;测试数据:20;分配存储器地址,长度;测试数据:0,20;显示更新之后的存储分配表继续选择要求;测试数据:1;输入表长;测试数据:15;分配存储器地址,长度;测试数据:20,15;显示更新之后的存储分配表如图所示:继续选择要求;测试数据:2;输入地址和表长;测试数据16,10;显示更新之后的存储分配表继续选择要求;测试数据:2;输入地址和表长;测试数据27,5;显示更新之后的存储分配表如图所示:..六、系统的结构、原理框图和模块等的详细说明1.主流程图2.适应算法流程图..七、用户使用说明书和参考资料1.使用说明书根据提示信息输入需求,系统调用函数,显示存储资源表分配情况。