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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

由于本实验是对存储管理算法的模拟，所以用一个线程来代表一个进程，用线程驻留区图5-2 线程驻留区表图5-3 存申请表5.3.2 算法分析常用的动态异长分区的分配算法有：最先适应算法、最佳适应算法和最坏适应算法。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

起始地址0 10 20 40 70 80 85 145 160 180占用者大小10 10 20 30 10 5 60 15 20 20图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_table 对应于图5-5，数组init_thread_residence_memory_table 对应于图5-7，为了实现动态分配与释放，用链表重新组织空闲区域表、线程驻留区表和存申请表，全局变量p_free_area _list 是空闲区链首，p_thread_require_memory_queue 是存申请队列的队首，p_thread_r esidence_memory_list 是线程驻留区链首，tail_thread_residence_memory_list 是线程驻留区链尾，由于线程驻留区链表被存分配函数和存释放函数共享，故用临界区变量CS_THREAD_MEMORY_LIST来保护，同理，屏幕是所有线程共享的，所以用临界区变量CS_SCREEN来保护,空闲区链表被存分配函数和存释放函数共享，故用临界区变量CS_FREEAREA_LIST来保护。

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

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

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

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

图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;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_memo ry_table,3);p_thread_residence_memory_list=FF_initialize_thread_residence_memory_list(init_thread_re sidence_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_memo ry_table,3);p_thread_residence_memory_list=BF_initialize_thread_residence_memory_list(init_thread_re sidence_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_memo ry_table,3);p_thread_residence_memory_list=WF_initialize_thread_residence_memory_list(init_thread_re sidence_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_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();break;case '2':BF();break;case '3':WF();break;case '4':end=true;。