动态异长分区的存储分配与回收算法

实验5 动态异长分区的存储分配与回收算法
5.1 实验目的
理解存储管理的功能，掌握动态异长分区的存储分配与回收算法。

存储器是计算机系统中的关键资源，存储管理一直是操作系统的最主要功能之一。

存储管理既包括内存资源管理，也包括用于实现分级存储体系的外存资源的管理。

通常，内存与外存可采用相同或相似的管理技术，如内存采用段式存储管理，则外存也采用段式存储管理。

存储管理需要完成如下功能：存储分配、存储共享、存储保护、存储扩充、地址映射。

当一个作业进入内存时，由操作系统将其变为进程,并为进程分配存储空间。

进程运行结束时, 由操作系统将其所占用的存储空间收回。

不同的操作系统对内存空间的划分与分配方法是不同的，通常分为两类：静态等长分区的分配和动态异长分区的分配。

静态等长分区常用于页式存储管理方式与段页式存储管理方式，存储空间被静态地划分为若干个长度相等的区域，每个区域被称作一个页面。

动态异长分区常用于界地址存储管理方式与段式存储管理方式，存储空间被动态地划分为若干个长度不等的区域。

5.2 实验要求
本实验要求模拟动态异长分区的分配算法、回收算法和碎片整理算法。

5.3 实验步骤
5.3.1 数据结构分析
为了实现存储资源的分配和回收，操作系统需Array要记录内存资源使用情况，即哪些区域尚未分配，
哪些区域已经分配以及分配给哪些进程等。

为此一
般需要两个表，一个为分配表, 另外一个为空闲区
域表。

前者记录已经分配的区域, 后者记录着所有
当前未被进程占用的空闲区域, 如图5-1所示。

图5-1 空闲区域表
显然, 没有记录于表中的区域即为已被进程所占用的非空闲区域，在实际的操作系统中，这些区域登记在进程的PCB中。

而PCB中除了关于内存资源的信息外，还有其它大量信息。

由于本实验是对存储管理算法的模拟，所以用一个线程来代表一个进程，用线程驻留
区域表来描述线程占用的内存空间，如图5-2所示。

5.3.2 算法分析
常用的动态异长分区的分配算法有：最先适应算法、最佳适应算法和最坏适应算法。

1. 最先适应算法(First Fit，FF)
对于存储申请命令, 选取满足申请长度要求且起始地址最小的空闲区域。

在实现时, 可将系统中所有的空闲区域按照起始地址由小到大的次序依次记录于空闲区域表中。

当进程申请存储空间时, 系统由表的头部开始查找, 取第一个满足要求的表目。

如果该表目所对应的区域长度恰好与所申请的区域长度相同, 则将该区域全部分配给申请者。

否则将该区域分割为两部分, 一部分的长度与所申请的长度相同, 将其分配给申请者；另一部分的长度为原长度与分配长度之差, 将其仍记录于空闲区域表中。

回收时，按回收区的首地址查询空闲区表，若有与回收区相临的空闲区，则将其合并到相临区中，否则，把回收区按照地址从低到高的顺序插入到空闲区域表的适当位置。

2. 最佳适应算法(Best Fit ，BF )
分配时取满足申请要求且长度最小的空闲区域。

在实现时, 可将系统中所有的空闲区域按照长度由小到大的次序依次记录于空闲区域表中。

与最先适应算法相类似, 当进程申请存储空间时, 系统由表的头部开始查找, 取第一个满足要求的表目。

如果该表目所对应的区域长度恰好与所申请的区域长度相同, 则将该区域全部分配给申请者。

否则将该区域分割为两部分, 一部分的长度与所申请的长度相同, 将其分配给申请者；另一部分即剩余部分的长度为原长度与分配长度之差, 由于剩余部分的长度已经改变，所以应重新将其按长度从小到大的顺序插入到空闲区域表中。

回收时，不仅要按回收区的首地址查询空闲区表，找到与回收区相临的空闲区，将其合并到相临区中，而且要把合并后的回收区按照长度递增的顺序插入到空闲区域表的适当位置。

3. 最坏适应算法(Worst Fit ，WF )
分配时取满足申请要求且长度最大的空闲区域。

在实现时, 可将系统中所有的空闲区域按照长度由大到小的次序依次记录于空闲区域表中。

当进程申请存储空间时, 取第一个表目。

如果该表目所对应的区域长度恰好与所申请的区域长度相同, 则将该区域全部分配给申请者。

否则将该区域分割为两部分, 一部分的长度与所申请的长度相同, 将其分配给申请者；另一部分即剩余部分的长度为原长度与分配长度之差, 由于剩余部分的长度已经改变，所以应重新将其按长度递减的顺序插入到空闲区域表中。

回收时，不仅要按回收区的首地址查询空闲区表，找到与回收区相临的空闲区，将其合并到相临区中，而且要把合并后的回收区按照长度递减的顺序插入到空闲区域表的适当位置。

5.3.3 设计并分析测试数据
假设初始内存布局如图5-4，图中的起始地址以及大小都以KB 来衡量。

起始地址占用者 大 小 图5-4初始内存布局
由图5-4可见，初始时共有五个线程驻留在内存，它们是a,b,c,d,e ，线程驻留区表如图5-5；还有五个空闲区，空闲区域表如图5-6。

假设现在有三个线程提出内存申请，申请情况见图5-7。

经过分析我们得到在每种分配算法下这三个线程所申请到的内存情况。

图5-8是最先适应算法分配情况，图5-9是最佳适应算法分配情况，图5-10是最坏适应算法分配情况。

5.3.4 程序设计
程序包含两个文件，一个是头文件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_tab le 对应于图5-5，数组init_thread_residence_memory_table 对应于图5-7，为了实现动态分配与释放，用链表重新组织空闲区域表、线程驻留区表和内存申请表，全局变量p_fr ee_area_list 是空闲区链首，p_thread_require_memory_queue 是内存申请队列的队首，p _thread_residence_memory_list 是线程驻留区链首，tail_thread_residence_memory_li st 是线程驻留区链尾，由于线程驻留区链表被内存分配函数和内存释放函数共享，故用临界区变量CS_THREAD_MEMORY_LIST 来保护，同理，屏幕是所有线程共享的，所以用临界区变量CS_SCREEN 来保护,空闲区链表被内存分配函数和内存释放函数共享，故用临界区变量
CS_FREEAREA_LIST来保护。

h_thread是线程句柄数组，用来存放各个线程的句柄。

程序共包含25个函数，按照作用可以将它们分成五组。

第一组是主函数main()，其作用是显示主菜单并根据用户的选择执行相应功能；
第二组包括函数print_space()和函数display_thread_residence_memory()，前者用来显示若干个空格，后者用来显示线程驻留区表；
第三组共十个函数，用来实现最先适应分配法，它们的名称及功能如图5-11。

第四组共六个函数，用来实现最佳适应分配法，它们的名称及功能如图5-12。

第五组共六个函数，用来实现最坏适应分配法，它们的名称及功能如图5-13。

5.3.5 参考源代码
5.3.5.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_list typedef 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;
else
Sleep(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;
else
p->next=p_next->next;
free(p_next);
break;
}
else
if(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;
else
Sleep(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;
else
p->next=p_next->next;
free(p_next);
break;
}
else
if(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;
else
if(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;
else
Sleep(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;
else
if(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);
}
else
if(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");
}
5.3.5.2 linux下的参考源程序
○1编译命令
gcc variable_partition .cpp –o variable_partition.o –lcurses –lpthread
○2程序清单
头文件variable_partition.h
#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_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_list
typedef 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();
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");
p=p->next;
i++;
};。