devbox
人工智能uu
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

存储管理算法设计之【内存空间的分配和回收】_模拟设计文件存储空间的分配与回收(空闲文件目录法)

作者：人工智能uu | 2024-07-04 00:31:11

赞

踩

模拟设计文件存储空间的分配与回收(空闲文件目录法)
博客总领目录请看这篇，不看后悔

软件工程专业大学四年学什么_大学近代史学分是多少-CSDN博客icon-default.png?t=N7T8https://blog.csdn.net/qq_41587612/article/details/104362661B站同名up猪，欢迎关注我的账号鸽子不二的个人空间-鸽子不二个人主页-哔哩哔哩视频哔哩哔哩鸽子不二的个人空间，提供鸽子不二分享的视频、音频、文章、动态、收藏等内容，关注鸽子不二账号，第一时间了解UP主动态。icon-default.png?t=N7T8https://space.bilibili.com/204913846

设计一  内存空间的分配和回收

【实验目的】

通过本实验，帮助学生理解存储管理的功能，掌握动态异长分区的存储分配与回收算法。

【实验内容】

模拟动态异长分区的分配算法、回收算法。

【实验要求】

常用的动态异长分区的分配算法有：最先适应算法、最佳适应算法和最坏适应算法。要求选择任意一种算法，设计相应的数据结构，模拟内存空间的分配和回收。实验报告中给出程序中使用的数据结构及流程图。

【实验原理】

  • 首次适应算法（First Fit）

       该算法从空闲分区链首开始查找，直至找到一个能满足其大小要求的空闲分区为止。然后再按照作业的大小，从该分区中划出一块内存分配给请求者，余下的空闲分区仍留在空闲分区链中。空闲分区以地址递增次序排列。    

缺点：低地址部分不断被划分，留下许多难以利用、很小的空闲区，而每次查找又都从低地址部分开始，会增加查找的开销。

优点：开销较小，回收分区一般无需对空闲分区队列重新排序。该算法倾向于使用内存中低地址部分的空闲区，在高地址部分的空闲区很少被利用，从而保留了高地址部分的大空闲区。显然为以后到达的大作业分配大的内存空间创造了条件。

  • 最佳适应算法（Best Fit）

        该算法总是把既能满足要求，又是最小的空闲分区分配给作业。为了加速查找，该算法要求将所有的空闲区按容量递增顺序排成一个空白链。这样每次找到的第一个满足要求的空闲区，必然是最优的。

缺点：因为每次分配后剩余的空间一定是最小的，所以内存中留下许多难以利用的小的空闲区（外部碎片）；开销大，回收后可能要重新排序。

优点：每次分配给文件的都是最合适该文件大小的分区。有更多大分区被保留。     

  • 最坏适应算法（Worst Fit）

       空闲区按容量递减次序排列，每次优先分配最大连续空闲区。     

缺点：较大空闲分区被迅速用完，绝大多数时候都会造成资源的严重浪费甚至是完全无法实现分配；开销大，回收后可能要重新排序。

优点：尽可能地利用存储器中大的空闲区，减少了难以利用的小碎片。

【数据结构设计】

（1）数据结构设计

       为了实现存储资源的分配和回收，操作系统需要记录内存资源使用情况，即哪些区域尚未分配，哪些区域已经分配以及分配给哪些进程等。为此一般需要两个表，一个为分配表, 另外一个为空闲区域表。前者记录已经分配的区域, 后者记录着所有当前未被进程占用的空闲区域，如图1所示。

空闲区域首址

空闲区域长度

…

…

addr

size

…

…

              图1 空闲区域表

       显然, 没有记录于表中的区域即为已被进程所占用的非空闲区域，在实际的操作系统中，这些区域登记在进程的PCB中。而PCB中除了关于内存资源的信息外，还有其它大量信息。

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

线程名称

驻留区始址

驻留区大小

a

0

10

b

20

20

……

……

……

            图2 线程驻留区表

        同时，需要一张表来记录各个线程对内存的请求信息，如图3所示。

线程名称

请求大小(KB)

预计驻留时间( 秒)

thread_1

20

4

thread_2

10

5

……

……

……

                       图3 内存申请表

（2）设计并分析测试数据

        假设初始内存布局如图4，图中的起始地址以及大小都以KB来衡量。

        由图4可见，初始时共有五个线程驻留在内存，它们是a,b,c,d,e，线程驻留区表如图5；还有五个空闲区，空闲区域表如图6。

        假设现在有三个线程提出内存申请，申请情况见图7。经过分析我们得到在每种分配算法下这三个线程所申请到的内存情况。图8是最先适应算法分配情况，图9是最佳适应算法分配情况，图10是最坏适应算法分配情况。

【算法设计】

宏定义：

#define Free 0 //空闲状态

#define Busy 1 //已用状态

#define OK 1    //完成

#define ERROR 0 //出错

#define MAX_length 640  //定义最大主存信息640KB      

六大函数:

①status Alloc(int)：内存分配函数。对于选择的首次适应算法或者是最佳适应算法判断分配完成状态，说明是否实现分配或者是分配错误。

②status free(int)：内存回收函数。主要涉及合并内存的三种情况：

该空闲块与前面的空闲块相连的主存回收，表示为：

if (p->prior != block_first && p->prior->data.state == Free)

{

             p->prior->data.size += p->data.size;//空间扩充,合并为一个

             p->prior->next = p->next;//去掉原来被合并的p

             p->next->prior = p->prior;

             p = p->prior;

}

该空闲块与后面的空闲块相连，表示为：

if (p->next != block_last && p->next->data.state == Free) {

         p->data.size += p->next->data.size;//空间扩充,合并为一个 p->next->next->prior = p;

         p->next = p->next->next;

}

该空闲块与最后的空闲块相连，表示为：

if (p->next == block_last && p->next->data.state == Free) {

       p->data.size += p->next->data.size;

       p->next = NULL;

}

③status First_fit(int)：首次适应算法，只需要将地址由小到大排列好，从头指针开始遍历，逐个检验，找到第一个空间＞=所申请的空间时，给予分配。 temp->prior = p->prior;

temp->next = p;

temp->data.address = p->data.address;

p->prior->next = temp;

p->prior = temp;

p->data.address = temp->data.address + temp->data.size; p->data.size -= request;

④status Best_fit(int)：对由小到大的空闲区排列的空闲区，与所申请的内存大小相比，取两者差最小的给予分配，插入。初始化最小空间和最佳位置，用ch来记录最小位置。

⑤void show()：查看分配。

⑥status Initblock()：开创带头结点的内存空间链表。

【程序代码】

  1. #include<iostream>
  2. #include<stdlib.h>
  3. using namespace std;
  4. #define Free 0 //空闲状态
  5. #define Busy 1 //已用状态
  6. #define OK 1    //完成
  7. #define ERROR 0 //出错
  8. #define MAX_length 640  //定义最大主存信息640KB
  9. typedef int Status;
  10. int flag;//标志位  0为空闲区     1为已分配的工作区
  11.  
  12. typedef struct FreAarea//定义一个空闲区说明表结构
  13. {
  14. 	long size;   //分区大小
  15. 	long address; //分区地址
  16. 	int state;   //状态
  17. }ElemType;
  18.  
  19. typedef struct DuLNode// 线性表的双向链表存储结构
  20. {
  21. 	ElemType data;
  22. 	struct DuLNode *prior; //前趋指针
  23. 	struct DuLNode *next;  //后继指针
  24. }
  25.  
  26. DuLNode, *DuLinkList;
  27. DuLinkList block_first; //头结点
  28. DuLinkList block_last;  //尾结点
  29. Status Alloc(int);//内存分配
  30. Status free(int); //内存回收
  31. Status First_fit(int);//首次适应算法
  32. Status Best_fit(int); //最佳适应算法
  33. Status Worst_fit(int); //最差适应算法
  34. void show();//查看分配
  35. Status Initblock();//开创空间表 
  36.  
  37. Status Initblock()//开创带头结点的内存空间链表
  38. {
  39. 	block_first = (DuLinkList)malloc(sizeof(DuLNode));
  40. 	block_last = (DuLinkList)malloc(sizeof(DuLNode));
  41. 	block_first->prior = NULL;
  42. 	block_first->next = block_last;
  43. 	block_last->prior = block_first;
  44. 	block_last->next = NULL;
  45. 	block_last->data.address = 0;
  46. 	block_last->data.size = MAX_length;
  47. 	block_last->data.state = Free;
  48. 	return OK;
  49. }
  50. Status Alloc(int ch)//分配主存
  51. {
  52. 	int request = 0;
  53. 	cout << "请输入需要分配的主存大小(单位:KB)："<<endl;
  54. 	cin >> request;
  55. 	if (request<0 || request == 0)
  56. 	{
  57. 		cout << "分配大小不合适，请重试！" << endl;
  58. 		return ERROR;
  59. 	}
  60.  
  61. 	if (ch == 2) //选择最佳适应算法
  62. 	{
  63. 		if (Best_fit(request) == OK) cout << "分配成功！" << endl;
  64. 		else cout << "内存不足，分配失败！" << endl;
  65. 		return OK;
  66. 	}
  67. 	if (ch == 3) //选择最差适应算法
  68. 	{
  69. 		if (Worst_fit(request) == OK) cout << "分配成功！" << endl;
  70. 		else cout << "内存不足，分配失败！" << endl;
  71. 		return OK;
  72. 	}
  73. 	else //默认首次适应算法
  74. 	{
  75. 		if (First_fit(request) == OK) cout << "分配成功！" << endl;
  76. 		else cout << "内存不足，分配失败！" << endl;
  77. 		return OK;
  78. 	}
  79. }
  80. Status First_fit(int request)//首次适应算法
  81. {
  82. 	//为申请作业开辟新空间且初始化
  83. 	DuLinkList temp = (DuLinkList)malloc(sizeof(DuLNode));
  84. 	temp->data.size = request;
  85. 	temp->data.state = Busy;
  86.  
  87. 	DuLNode *p = block_first->next;
  88. 	while (p)
  89. 	{
  90. 		if (p->data.state == Free && p->data.size == request)
  91. 		{//有大小恰好合适的空闲块
  92. 			p->data.state = Busy;
  93. 			return OK;
  94. 			break;
  95. 		}
  96. 		if (p->data.state == Free && p->data.size>request)
  97. 		{//有空闲块能满足需求且有剩余
  98. 			temp->prior = p->prior;
  99. 			temp->next = p;
  100. 			temp->data.address = p->data.address;
  101. 			p->prior->next = temp;
  102. 			p->prior = temp;
  103. 			p->data.address = temp->data.address + temp->data.size;
  104. 			p->data.size -= request;
  105. 			return OK;
  106. 			break;
  107. 		}
  108. 		p = p->next;
  109. 	}
  110. 	return ERROR;
  111. }
  112. Status Best_fit(int request)//最佳适应算法
  113. {
  114. 	int ch; //记录最小剩余空间
  115. 	DuLinkList temp = (DuLinkList)malloc(sizeof(DuLNode));
  116. 	temp->data.size = request;
  117. 	temp->data.state = Busy;
  118. 	DuLNode *p = block_first->next;
  119. 	DuLNode *q = NULL; //记录最佳插入位置
  120.  
  121. 	while (p) //初始化最小空间和最佳位置
  122. 	{
  123. 		if (p->data.state == Free && (p->data.size >= request))
  124. 		{
  125. 			if (q == NULL)
  126. 			{
  127. 				q = p;
  128. 				ch = p->data.size - request;
  129. 			}
  130. 			else if (q->data.size > p->data.size)
  131. 			{
  132. 				q = p;
  133. 				ch = p->data.size - request;
  134. 			}
  135. 		}
  136. 		p = p->next;
  137. 	}
  138. 	if (q == NULL) return ERROR;//没有找到空闲块
  139. 	else if (q->data.size == request)
  140. 	{
  141. 		q->data.state = Busy;
  142. 		return OK;
  143. 	}
  144. 	else
  145. 	{
  146. 		temp->prior = q->prior;
  147. 		temp->next = q;
  148. 		temp->data.address = q->data.address;
  149. 		q->prior->next = temp;
  150. 		q->prior = temp;
  151. 		q->data.address += request;
  152. 		q->data.size = ch;
  153. 		return OK;
  154. 	}
  155. 	return OK;
  156. }
  157. Status Worst_fit(int request)//最差适应算法
  158. {
  159. 	int ch; //记录最大剩余空间
  160. 	DuLinkList temp = (DuLinkList)malloc(sizeof(DuLNode));
  161. 	temp->data.size = request;
  162. 	temp->data.state = Busy;
  163. 	DuLNode *p = block_first->next;
  164. 	DuLNode *q = NULL; //记录最佳插入位置
  165.  
  166. 	while (p) //初始化最大空间和最佳位置
  167. 	{
  168. 		if (p->data.state == Free && (p->data.size >= request))
  169. 		{
  170. 			if (q == NULL)
  171. 			{
  172. 				q = p;
  173. 				ch = p->data.size - request;
  174. 			}
  175. 			else if (q->data.size < p->data.size)
  176. 			{
  177. 				q = p;
  178. 				ch = p->data.size - request;
  179. 			}
  180. 		}
  181. 		p = p->next;
  182. 	}
  183. 	if (q == NULL) return ERROR;//没有找到空闲块
  184. 	else if (q->data.size == request)
  185. 	{
  186. 		q->data.state = Busy;
  187. 		return OK;
  188. 	}
  189. 	else
  190. 	{
  191. 		temp->prior = q->prior;
  192. 		temp->next = q;
  193. 		temp->data.address = q->data.address;
  194. 		q->prior->next = temp;
  195. 		q->prior = temp;
  196. 		q->data.address += request;
  197. 		q->data.size = ch;
  198. 		return OK;
  199. 	}
  200. 	return OK;
  201. }
  202. Status free(int flag)//主存回收
  203. {
  204. 	DuLNode *p = block_first;
  205. 	for (int i = 0; i <= flag; i++)
  206. 		if (p != NULL)
  207. 			p = p->next;
  208. 		else
  209. 			return ERROR;
  210.  
  211. 	p->data.state = Free;
  212. 	if (p->prior != block_first && p->prior->data.state == Free)//与前面的空闲块相连
  213. 	{
  214. 		p->prior->data.size += p->data.size;//空间扩充,合并为一个
  215. 		p->prior->next = p->next;//去掉原来被合并的p
  216. 		p->next->prior = p->prior;
  217. 		p = p->prior;
  218. 	}
  219. 	if (p->next != block_last && p->next->data.state == Free)//与后面的空闲块相连
  220. 	{
  221. 		p->data.size += p->next->data.size;//空间扩充,合并为一个
  222. 		p->next->next->prior = p;
  223. 		p->next = p->next->next;
  224. 	}
  225. 	if (p->next == block_last && p->next->data.state == Free)//与最后的空闲块相连
  226. 	{
  227. 		p->data.size += p->next->data.size;
  228. 		p->next = NULL;
  229. 	}
  230.  
  231. 	return OK;
  232. }
  233. void show()//显示主存分配情况
  234. {
  235. 	int flag = 0;
  236. 	cout << "\n主存分配情况:\n";
  237. 	cout << "++++++++++++++++++++++++++++++++++++++++++++++\n\n";
  238. 	DuLNode *p = block_first->next;
  239. 	cout << "分区号\t起始地址\t分区大小\t状态\n\n";
  240. 	while (p)
  241. 	{
  242. 		cout << "  " << flag++ << "\t";
  243. 		cout << "  " << p->data.address << "\t\t";
  244. 		cout << " " << p->data.size << "KB\t\t";
  245. 		if (p->data.state == Free) cout << "空闲\n\n";
  246. 		else cout << "已分配\n\n";
  247. 		p = p->next;
  248. 	}
  249. 	cout << "++++++++++++++++++++++++++++++++++++++++++++++\n\n";
  250. }
  251. int main() //主函数
  252. {
  253. 	int ch;//算法选择标记
  254. 	cout << "请输入所使用的内存分配算法：\n";
  255. 	cout << "(1)首次适应算法\n(2)最佳适应算法\n(3)最坏适应算法\n";
  256.  
  257. 	cin >> ch;
  258. 	while (ch<1 || ch>3)
  259. 	{
  260. 		cout << "输入错误，请重新输入所使用的内存分配算法：\n";
  261. 		cin >> ch;
  262. 	}
  263.  
  264. 	Initblock(); //开创空间表
  265. 	int choice;  //操作选择标记
  266. 	while (1)
  267. 	{
  268. 		show();
  269. 		cout << "请输入您的操作：";
  270. 		cout << "\n1: 分配内存\n2: 回收内存\n0: 退出\n";
  271.  
  272. 		cin >> choice;
  273. 		if (choice == 1) Alloc(ch); // 分配内存
  274. 		else if (choice == 2)  // 内存回收
  275. 		{
  276. 			int flag;
  277. 			cout << "请输入您要释放的分区号："<<endl;
  278. 			cin >> flag;
  279. 			free(flag);
  280. 		}
  281. 		else if (choice == 0) break; //退出
  282. 		else //输入操作有误
  283. 		{
  284. 			cout << "输入有误，请重试！" << endl;
  285. 			continue;
  286. 		}
  287. 	}
  288. }

 【实验结果】

假设初始状态下，可用的内存空间为640KB，并有下列的请求序列：

•作业1申请130KB •作业2申请60KB •作业3申请100KB •作业2释放60KB •作业4申请200KB •作业3释放100KB•作业1释放130KB •作业5申请140KB •作业6申请60KB •作业7申请50KB •作业6释放60KB。

首次适应：

最佳适应：

最坏适应：

【实验心得】

       我在编写主存空间的分配和回收的过程中总结，从解决实际问题的角度，我们可以这样来看：首先要了解这个问题的基本要求，即输入、输出、完成从输入到输出的要求是什么；其次，从问题的要害入手，从前到后解决问题的每个方面，即从输入开始入手，着重考虑如何从输入导出输出。在这个过程中，可确定所需的变量、数组、函数，然后确定处理的过程，即算法。可得出最后的结论，进而完成程序的编写。经过这次实验，我对主存空间的分配和回收有了深一步的了解，同时也初步了解了内存空间的工作原理。总的来说这个实验既具有挑战性又极具趣味性。

以下是老师给的代码：

【程序结构】

       程序包含两个文件，一个是头文件variable_partition.h，另一个是源程序文件variable_partition.cpp。在头文件中定义了宏、数据结构、全局变量、函数声明，源程序中含有各个函数的实现。

       在头文件中，结构体FREEAREA、REQUIRE_MEMORY、THREAD_RESIDENCE_MEMORY分别对应于图1、图2、图3中的一行，不同之处是为了构成链表在三个结构体中都有前向指针。数组init_free_area_table对应于图6，数组init_thread_require_memory_table对应于图5，数组init_thread_residence_memory_table对应于图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_thread是线程句柄数组，用来存放各个线程的句柄。

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

         第一组是主函数main()，其作用是显示主菜单并根据用户的选择执行相应功能；

         第二组包括函数print_space()和函数display_thread_residence_memory()，前者用来显示若干个空格，后者用来显示线程驻留区表；

         第三组共十个函数，用来实现最先适应分配法，它们的名称及功能如图11。

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

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

【在Windows下运行的程序代码】

头文件 variable_partition.h 的清单

  1. #include <windows.h>
  2. #include <conio.h>
  3. #include <stdlib.h>
  4. #include <stdio.h>
  5. #include <io.h>
  6. #include <string.h>
  7.  
  8. #define MAX_THREAD 3
  9. #define BF_initialize_require_memory_list FF_initialize_require_memory_list
  10. #define WF_initialize_require_memory_list FF_initialize_require_memory_list
  11. #define BF_initialize_thread_residence_memory_list FF_initialize_thread_residence_memory_list
  12. #define WF_initialize_thread_residence_memory_list FF_initialize_thread_residence_memory_list
  13. #define WF_delete_freearea_list FF_delete_freearea_list
  14. #define BF_delete_freearea_list FF_delete_freearea_list
  15. #define WF_delete_require_memory_list FF_delete_require_memory_list
  16. #define BF_delete_require_memory_list FF_delete_require_memory_list
  17. #define WF_delete_thread_residence_memory_list FF_delete_thread_residence_memory_list
  18. #define BF_delete_thread_residence_memory_list FF_delete_thread_residence_memory_list
  19.  
  20. typedef struct freearea{                    //表示空闲区域的数据结构
  21. 	struct freearea *next;                  //指向下一个结点的指针
  22. 	int start_address;                     //空闲区起始地址
  23. 	int size;                              //空闲区大小
  24. }FREEAREA;
  25.  
  26. typedef struct require_memory{             //记录线程申请内存的数据结构
  27.     struct require_memory *next;           //指向下一个结点的指针
  28. 	char thread_name[10];                //线程名
  29. 	int size;                             //申请内存大小（以KB为单位）
  30. 	int duration;                         //在内存的驻留时间（以秒为单位）
  31. }REQUIRE_MEMORY;
  32.  
  33. typedef struct thread_residence_memory{         //描述线程驻留区的数据结构
  34.     struct thread_residence_memory *next;       //指向下一个结点的指针
  35. 	char thread_name[10];                     //线程名
  36. 	int start_address;                          //驻留区起始地址
  37. 	int size;                                   //驻留区大小
  38. }THREAD_RESIDENCE_MEMORY;
  39.  
  40. FREEAREA init_free_area_table[5]={             //测试数据：初始空闲区表
  41. 	{NULL,10,10},
  42. 	{NULL,40,30},
  43. 	{NULL,80,5},
  44. 	{NULL,145,15},
  45. 	{NULL,180,20}
  46. };
  47.  
  48. REQUIRE_MEMORY init_thread_require_memory_table[3]={       //测试数据：初始内存申请表
  49. 	{NULL,"thread_1",20,4},
  50. 	{NULL,"thread_2",10,5},
  51. 	{NULL,"thread_3",5,6}
  52. };
  53. //测试数据：初始线程驻留区表
  54. THREAD_RESIDENCE_MEMORY init_thread_residence_memory_table[5]={
  55. 	{NULL,"a",0,10},
  56. 	{NULL,"b",20,20},
  57. 	{NULL,"c",70,10},
  58. 	{NULL,"d",85,60},
  59. 	{NULL,"e",160,20}
  60. };
  61.  
  62. FREEAREA *p_free_area_list=NULL;                                              //空闲区链首
  63. REQUIRE_MEMORY *p_thread_require_memory_queue=NULL;                //内存申请队列队首
  64. THREAD_RESIDENCE_MEMORY *p_thread_residence_memory_list=NULL;      //线程驻留区链首
  65. THREAD_RESIDENCE_MEMORY *tail_thread_residence_memory_list=NULL;     //线程驻留区链尾
  66. CRITICAL_SECTION CS_THREAD_MEMORY_LIST;                //保护线程驻留区链表的临界区
  67. CRITICAL_SECTION CS_SCREEN;                                         //保护屏幕的临界区
  68. CRITICAL_SECTION CS_FREEAREA_LIST;                           //保护空闲区链表的临界区
  69. HANDLE h_thread[MAX_THREAD];                                              //线程句柄数组
  70.  
  71. void print_space(int num);                                                     //输出若干个空格
  72. void display_thread_residence_memory_list();                                 //显示线程驻留区表
  73. //最先适应分配法的函数
  74. FREEAREA *FF_initialize_freearea_list(FREEAREA *init_table,int num);          //初始化空闲区链表
  75. void FF_delete_freearea_list();                                                //删除空闲区链表
  76. REQUIRE_MEMORY *FF_initialize_require_memory_list(REQUIRE_MEMORY *init_table,int num);
  77. //初始化内存申请链表
  78. void FF_delete_require_memory_list();                                       //删除内存申请链表
  79. THREAD_RESIDENCE_MEMORY  *FF_initialize_thread_residence_memory_list
  80. (THREAD_RESIDENCE_MEMORY *init_table,int num);                   //初始化线程驻留区链表
  81. void FF_delete_thread_residence_memory_list();                            //删除线程驻留区链表
  82. void FF_thread(void *data);                                                          //线程函数
  83. int FF_require_memory(int size);                                                  //内存申请函数
  84. void FF_release_memory(int start_address,int size);                                 //内存释放函数
  85. void FF();                                                      //最先适应分配算法的初始化函数
  86.  
  87. //最佳适应分配算法的函数
  88. void BF_thread(void *data);                                                         //线程函数
  89. int BF_require_memory(int size);                                                 //内存申请函数
  90. void BF_release_memory(int start_address,int size);                                //内存释放函数
  91. void BF_insert_freearea(FREEAREA *free_node);                            //空闲区结点插入函数
  92. void BF();                                                                       //初始化程序
  93. void BF_initialize_freearea_list(FREEAREA *init_table,int num);                  //初始化空闲区链表
  94.  
  95. //最坏适应分配算法的函数
  96. void WF_thread(void *data);                                                        //线程函数
  97. void WF_insert_freearea(FREEAREA *free_node);                          //空闲区结点插入函数
  98. void WF_initialize_freearea_list(FREEAREA *init_table,int num);                //初始化空闲区链表
  99. int WF_require_memory(int size);                                               //内存申请函数
  100. void WF_release_memory(int start_address,int size);                              //内存释放函数
  101. void WF();                                                                      //初始化程序

源程序文件 variable_partition.cpp 的清单

  1. #include "variable_partition.h"
  2. int main(int argc,char *argv[]){
  3. 	char select;
  4. 	while(1){
  5. 		printf("|-----------------------------------|\n");
  6. 		printf("|  1:first fit allocation     |\n");
  7. 		printf("|  2:best fit allocation     |\n");
  8. 		printf("|  3:worst fit allocation    |\n");
  9. 		printf("|  4:exit                 |\n");
  10. 		printf("|-----------------------------------|\n");
  11. 		printf("select a function(1~4):");
  12. 		do{
  13. 			select=(char)getch();
  14. 		}while(select!='1'&&select!='2'&&select!='3'&&select!='4');
  15. 		system("cls");
  16. 		switch(select){
  17. 		case '1':
  18. 			FF();
  19. 			break;
  20. 		case '2':
  21. 			BF();
  22. 			break;
  23. 		case '3':
  24. 			WF();
  25. 			break;
  26. 		case '4':
  27. 			return 0;
  28. 		}
  29. 		printf("\nPress any key to return to main menu.");
  30. 		getch();
  31. 		system("cls");
  32. 	}
  33. 	return 0;
  34. }
  35.  
  36.  
  37. void print_space(int num){                           //显示若干个空格
  38. 	int i;
  39. 	for(i=0;i<num;i++){
  40. 		printf(" ");
  41. 	}
  42. }
  43.  
  44. void display_thread_residence_memory_list(){          //显示驻留线程链表
  45. 	THREAD_RESIDENCE_MEMORY *p;
  46. 	char buffer[20];
  47.    	p=p_thread_residence_memory_list;
  48. 	printf("|-------------------|--------------------|------------------|\n");
  49. 	printf("| thread_name | start_address(kB) | size(KB) |\n");
  50. 	printf("|-------------------|--------------------|------------------|\n");
  51. 	while(p!=NULL){
  52.        printf("| %s",p->thread_name);
  53. 	   print_space(18-strlen(p->thread_name));
  54. 	   printf("| %d",p->start_address);
  55. 	   itoa( p->start_address, buffer, 10 );
  56.    	   print_space(19-strlen(buffer));
  57. 	   printf("| %d",p->size);
  58.        itoa(p->size, buffer, 10 );
  59.    	   print_space(17-strlen(buffer));
  60.        printf("|\n");
  61. 	   p=p->next;
  62. 	};
  63.     printf("|-------------------|--------------------|------------------|\n\n");
  64. }
  65.  
  66. //最先适应分配法：初始化空闲区链表
  67. FREEAREA *FF_initialize_freearea_list(FREEAREA *init_table,int num){
  68.   FREEAREA *temp;
  69.   FREEAREA *head=NULL;
  70.   FREEAREA *tail=NULL;
  71.   int i;
  72.   for(i=0;i<num;i++){
  73.      temp=(FREEAREA *)malloc(sizeof(FREEAREA));
  74.      temp->start_address=init_table[i].start_address;
  75. 	 temp->size=init_table[i].size;
  76. 	 temp->next=NULL;
  77. 	 if(head==NULL)
  78. 		 head=tail=temp;
  79. 	 else{
  80. 		 tail->next=temp;
  81. 		 tail=tail->next;
  82. 	 }
  83.   };
  84.   return head;
  85. }
  86.  
  87. //最先适应分配法：删除空闲区链表
  88. void FF_delete_freearea_list(){
  89. 	FREEAREA *temp;
  90. 	temp=p_free_area_list;
  91. 	while(temp!=NULL){
  92. 		temp=p_free_area_list->next;
  93. 		free(p_free_area_list);
  94. 		p_free_area_list=temp;
  95. 	}
  96. 	p_free_area_list=NULL;
  97. }
  98.  
  99.  
  100. //最先适应分配法：初始化内存申请链表
  101. REQUIRE_MEMORY *FF_initialize_require_memory_list(REQUIRE_MEMORY *init_table,int num){
  102.   REQUIRE_MEMORY *temp;
  103.   REQUIRE_MEMORY *head=NULL;
  104.   REQUIRE_MEMORY *tail=NULL;
  105.   int i;
  106.   for(i=0;i<num;i++){
  107.      temp=(REQUIRE_MEMORY *)malloc(sizeof(REQUIRE_MEMORY));
  108.      strcpy(temp->thread_name,init_table[i].thread_name);
  109. 	 temp->size=init_table[i].size;
  110. 	 temp->duration=init_table[i].duration;
  111. 	 temp->next=NULL;
  112. 	 if(head==NULL)
  113. 		 head=tail=temp;
  114. 	 else{
  115. 		 tail->next=temp;
  116. 		 tail=tail->next;
  117. 	 }
  118.   };
  119.   return head;
  120. }
  121.  
  122. //最先适应分配法：删除内存申请链表
  123. void FF_delete_require_memory_list(){
  124. 	REQUIRE_MEMORY *temp;
  125. 	temp=p_thread_require_memory_queue;
  126. 	while(temp!=NULL){
  127. 		temp=p_thread_require_memory_queue->next;
  128. 		free(p_thread_require_memory_queue);
  129. 		p_thread_require_memory_queue=temp;
  130. 	}
  131. 	p_thread_require_memory_queue=NULL;
  132. }
  133.  
  134. //最先适应分配法：初始化线程驻留区链表
  135. THREAD_RESIDENCE_MEMORY *FF_initialize_thread_residence_memory_list(THREAD_RESIDENCE_MEMORY *init_table,int num){
  136.   THREAD_RESIDENCE_MEMORY *temp;
  137.   THREAD_RESIDENCE_MEMORY *head=NULL;
  138.   THREAD_RESIDENCE_MEMORY *tail=NULL;
  139.   int i;
  140.   for(i=0;i<num;i++){
  141.      temp=(THREAD_RESIDENCE_MEMORY *)malloc(sizeof(THREAD_RESIDENCE_MEMORY));
  142.      strcpy(temp->thread_name,init_table[i].thread_name);
  143. 	 temp->start_address=init_table[i].start_address;
  144. 	 temp->size=init_table[i].size;
  145. 	 temp->next=NULL;
  146. 	 if(head==NULL)
  147. 		 head=tail=temp;
  148. 	 else{
  149. 		 tail->next=temp;
  150. 		 tail=tail->next;
  151. 	 }
  152.   };
  153.   tail_thread_residence_memory_list=tail;
  154.   return head;
  155. }
  156.  
  157. //最先适应分配法：删除线程驻留区链表
  158. void FF_delete_thread_residence_memory_list(){
  159. 	THREAD_RESIDENCE_MEMORY *temp=p_thread_residence_memory_list;
  160. 	
  161. 	temp=p_thread_residence_memory_list;
  162. 	while(temp!=NULL){
  163. 		temp=p_thread_residence_memory_list->next;
  164. 		free(p_thread_residence_memory_list);
  165. 		p_thread_residence_memory_list=temp;
  166. 	}
  167. 	p_thread_residence_memory_list=NULL;
  168. }
  169.  
  170. //线程：申请内存，驻留一段时间，释放内存
  171. void FF_thread(void *data){
  172.     int start_address=-1;
  173. 	THREAD_RESIDENCE_MEMORY *temp;
  174. 	EnterCriticalSection(&CS_SCREEN);
  175. 	printf("create thread:%s\n",((REQUIRE_MEMORY *)(data))->thread_name);
  176. 	LeaveCriticalSection(&CS_SCREEN);
  177.     
  178. 	
  179.     while(1){                                                        //申请内存
  180. 		start_address=FF_require_memory(((REQUIRE_MEMORY *)(data))->size);
  181. 		if(start_address>=0)
  182. 			break;
  183. 		else
  184. 			Sleep(1000);
  185. 	}
  186. 	temp=(THREAD_RESIDENCE_MEMORY *)malloc(sizeof(THREAD_RESIDENCE_MEMORY));
  187.     strcpy(temp->thread_name,((REQUIRE_MEMORY *)(data))->thread_name);
  188. 	temp->start_address=start_address;
  189. 	temp->size=((REQUIRE_MEMORY *)(data))->size;
  190. 	temp->next=NULL;
  191. 	EnterCriticalSection(&CS_THREAD_MEMORY_LIST);
  192. 	                                                       //加入线程驻留区链表
  193. 	tail_thread_residence_memory_list->next=temp;
  194. 	tail_thread_residence_memory_list=tail_thread_residence_memory_list->next;
  195.     LeaveCriticalSection(&CS_THREAD_MEMORY_LIST);
  196. 	                                                       //显示线程驻留区链表
  197. 	EnterCriticalSection(&CS_SCREEN);
  198. 	printf("after %s %s\n",((REQUIRE_MEMORY *)(data))->thread_name,"get memory:");
  199. 	display_thread_residence_memory_list();
  200. 	LeaveCriticalSection(&CS_SCREEN);
  201. 	
  202. 	Sleep(((REQUIRE_MEMORY *)(data))->duration);
  203. 	                                                       //释放内存
  204. 	FF_release_memory(start_address,((REQUIRE_MEMORY *)(data))->size);
  205. }
  206.  
  207.  
  208. //最先适应分配法：内存申请函数
  209. int FF_require_memory(int size){
  210. 	int start_address=-1;
  211. 	FREEAREA *p;
  212. 	FREEAREA *p_next;
  213. 	EnterCriticalSection(&CS_FREEAREA_LIST);
  214. 	p=p_next=p_free_area_list;
  215. 	while(p_next!=NULL){
  216. 		if(size==p_next->size){                     //刚好满足要求，删除空闲区结点
  217. 			start_address=p_next->start_address;
  218. 			if(p_next==p_free_area_list)
  219. 				p_free_area_list=p_next->next;
  220. 			else
  221. 			    p->next=p_next->next;
  222. 			free(p_next);
  223. 			break;
  224. 		}
  225. 		else
  226. 			if(size<p_next->size){                      //分割空闲区结点
  227. 				start_address=p_next->start_address;
  228. 				p_next->start_address+=size;
  229. 				p_next->size-=size;
  230. 				break;
  231. 			}
  232. 			else
  233. 			{
  234. 				p=p_next;
  235. 				p_next=p_next->next;
  236. 			}
  237. 	}
  238.    	LeaveCriticalSection(&CS_FREEAREA_LIST);
  239. 	return start_address;
  240. }
  241.  
  242. //最先适应分配法：内存释放函数
  243. void FF_release_memory(int start_address,int size){
  244. 	EnterCriticalSection(&CS_FREEAREA_LIST);
  245. 	//请读者自己实现这段代码
  246. 	LeaveCriticalSection(&CS_FREEAREA_LIST);
  247. }
  248.  
  249. //最先适应分配算法的初始化程序
  250. void FF(){
  251. 	int i=0;
  252.     REQUIRE_MEMORY *p;
  253.    	HANDLE h_thread[MAX_THREAD];
  254. 	InitializeCriticalSection(&CS_THREAD_MEMORY_LIST);
  255.      InitializeCriticalSection(&CS_FREEAREA_LIST);
  256. 	InitializeCriticalSection(&CS_SCREEN);
  257. 	printf("最先适应分配算法\n");
  258.     p_free_area_list=FF_initialize_freearea_list(init_free_area_table,5);
  259. p_thread_require_memory_queue=FF_initialize_require_memory_list(init_thread_require_memory_table,3);
  260. p_thread_residence_memory_list=FF_initialize_thread_residence_memory_list(init_thread_residence_memory_table,5);
  261.     p=p_thread_require_memory_queue;
  262.     while(p!=NULL){
  263.       h_thread[i]=CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)(FF_thread),p,0,NULL);
  264.       i++;
  265. 	 p=p->next;
  266.     };
  267.    WaitForMultipleObjects(MAX_THREAD,h_thread,TRUE,-1);              //等待所有线程结束
  268.  
  269. 	EnterCriticalSection(&CS_SCREEN);
  270. 	printf("after all threads have finished:\n");
  271. 	display_thread_residence_memory_list();                    //显示驻留线程链表
  272. 	LeaveCriticalSection(&CS_SCREEN);
  273. 	                                                         //删除各种链表
  274. 	FF_delete_freearea_list();
  275. 	FF_delete_require_memory_list();
  276. 	FF_delete_thread_residence_memory_list();
  277. 	getch();
  278.     printf("\n");
  279. }
  280.  
  281. //最佳适应分配算法的线程：申请内存，驻留一段时间，释放内存
  282. void BF_thread(void *data){
  283.     int start_address=-1;
  284. 	THREAD_RESIDENCE_MEMORY *temp;
  285. 	EnterCriticalSection(&CS_SCREEN);
  286. 	printf("create thread:%s\n",((REQUIRE_MEMORY *)(data))->thread_name);
  287. 	LeaveCriticalSection(&CS_SCREEN);
  288.     
  289. 	//申请内存
  290.     while(1){
  291. 		start_address=BF_require_memory(((REQUIRE_MEMORY *)(data))->size);
  292. 		if(start_address>=0)
  293. 			break;
  294. 		else
  295. 			Sleep(1000);
  296. 	}
  297. 	temp=(THREAD_RESIDENCE_MEMORY *)malloc(sizeof(THREAD_RESIDENCE_MEMORY));
  298.     strcpy(temp->thread_name,((REQUIRE_MEMORY *)(data))->thread_name);
  299. 	temp->start_address=start_address;
  300. 	temp->size=((REQUIRE_MEMORY *)(data))->size;
  301. 	temp->next=NULL;
  302. 	EnterCriticalSection(&CS_THREAD_MEMORY_LIST);
  303. 	//加入线程内存驻留区链表
  304. 	tail_thread_residence_memory_list->next=temp;
  305. 	tail_thread_residence_memory_list=tail_thread_residence_memory_list->next;
  306.     LeaveCriticalSection(&CS_THREAD_MEMORY_LIST);
  307. 	//显示线程内存驻留区链表
  308. 	EnterCriticalSection(&CS_SCREEN);
  309. 	printf("after %s %s\n",((REQUIRE_MEMORY *)(data))->thread_name,"get memory:");
  310. 	display_thread_residence_memory_list();
  311. 	LeaveCriticalSection(&CS_SCREEN);
  312. 	
  313. 	Sleep(((REQUIRE_MEMORY *)(data))->duration);
  314. 	//释放内存
  315. 	BF_release_memory(start_address,((REQUIRE_MEMORY *)(data))->size);
  316. }
  317.  
  318. //最佳适应分配算法的内存申请函数
  319. int BF_require_memory(int size){
  320.   	int start_address=-1;
  321. 	FREEAREA *p;
  322. 	FREEAREA *p_next;
  323. 	EnterCriticalSection(&CS_FREEAREA_LIST);
  324. 	p=p_next=p_free_area_list;
  325. 	while(p_next!=NULL){
  326. 		if(size==p_next->size){//刚好满足要求，删除空闲区结点
  327. 			start_address=p_next->start_address;
  328. 			if(p_next==p_free_area_list)
  329. 				p_free_area_list=p_next->next;
  330. 			else
  331. 			    p->next=p_next->next;
  332. 			free(p_next);
  333. 			break;
  334. 		}
  335. 		else
  336. 			if(size<p_next->size){//分割空闲区结点
  337. 				start_address=p_next->start_address;
  338. 				p_next->start_address+=size;
  339. 				p_next->size-=size;
  340. 				p->next=p_next->next;
  341. 				BF_insert_freearea(p_next);
  342. 				break;
  343. 			}
  344. 			else
  345. 			{
  346. 				p=p_next;
  347. 				p_next=p_next->next;
  348. 			}
  349. 	}
  350.    	LeaveCriticalSection(&CS_FREEAREA_LIST);
  351. 	return start_address;
  352.  
  353. }
  354.  
  355. //最佳适应分配算法的内存释放函数
  356. void BF_release_memory(int start_address,int size){
  357.   //请读者自己实现这段代码
  358. }
  359.  
  360. //最佳分配算法的空闲区结点插入函数
  361. void BF_insert_freearea(FREEAREA *free_node){
  362.      FREEAREA *p;
  363.      FREEAREA *p_next;
  364. 	 
  365. 	 if(p_free_area_list==NULL)
  366. 		 p_free_area_list=free_node;
  367. 	 else{
  368. 	   p_next=p=p_free_area_list;
  369. 	   while(p_next!=NULL&&p_next->size<free_node->size){
  370. 		 p=p_next;
  371. 		 p_next=p_next->next;
  372. 	   }
  373. 	   if(p_next==NULL)               //应插入到尾部
  374. 		 p->next=free_node;
  375. 	   else
  376. 		 if(p==p_next){                //应插入到头部
  377. 		    free_node->next=p;
  378. 		    p_free_area_list=free_node;
  379. 		 }
  380. 		 else{                        //应插入到p与p_next之间
  381. 			 free_node->next=p_next;
  382. 			 p->next=free_node;
  383. 		 }
  384. 	 }
  385. }
  386.  
  387. //最佳适应分配法：初始化空闲区链表
  388. void BF_initialize_freearea_list(FREEAREA *init_table,int num){
  389.   FREEAREA *temp;
  390.   int i;
  391.   for(i=0;i<num;i++){
  392.      temp=(FREEAREA *)malloc(sizeof(FREEAREA));
  393.      temp->start_address=init_table[i].start_address;
  394. 	 temp->size=init_table[i].size;
  395. 	 temp->next=NULL;
  396. 	 BF_insert_freearea(temp);
  397.   }
  398. }
  399.  
  400. //最佳分配算法的初始化程序
  401. void BF(){
  402.   	int i=0;
  403.     REQUIRE_MEMORY *p;
  404.    	HANDLE h_thread[MAX_THREAD];
  405. 	InitializeCriticalSection(&CS_THREAD_MEMORY_LIST);
  406.     InitializeCriticalSection(&CS_FREEAREA_LIST);
  407. 	InitializeCriticalSection(&CS_SCREEN);
  408. 	printf("最佳适应分配算法\n");
  409.     BF_initialize_freearea_list(init_free_area_table,5);
  410. p_thread_require_memory_queue=BF_initialize_require_memory_list(init_thread_require_memory_table,3);
  411. p_thread_residence_memory_list=BF_initialize_thread_residence_memory_list(init_thread_residence_memory_table,5);
  412.     p=p_thread_require_memory_queue;
  413.     while(p!=NULL){
  414.       h_thread[i]=CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)(BF_thread),p,0,NULL);
  415.       i++;
  416. 	  p=p->next;
  417.     };
  418.     //等待所有线程结束
  419.     WaitForMultipleObjects(MAX_THREAD,h_thread,TRUE,-1);
  420.  
  421. 	//显示驻留线程链表
  422. 	EnterCriticalSection(&CS_SCREEN);
  423. 	printf("after all threads have finished:\n");
  424. 	display_thread_residence_memory_list();
  425. 	LeaveCriticalSection(&CS_SCREEN);
  426.  
  427. 	//删除各种链表
  428. 	FF_delete_freearea_list();
  429. 	FF_delete_require_memory_list();
  430. 	FF_delete_thread_residence_memory_list();
  431.  
  432. 	getch();
  433.     printf("\n");
  434. }
  435.  
  436.  
  437. //最坏适应分配算法的线程：申请内存，驻留一段时间，释放内存
  438. void WF_thread(void *data){
  439.     int start_address=-1;
  440. 	THREAD_RESIDENCE_MEMORY *temp;
  441. 	EnterCriticalSection(&CS_SCREEN);
  442. 	printf("create thread:%s\n",((REQUIRE_MEMORY *)(data))->thread_name);
  443. 	LeaveCriticalSection(&CS_SCREEN);
  444.     
  445. 	//申请内存
  446.     while(1){
  447. 		start_address=WF_require_memory(((REQUIRE_MEMORY *)(data))->size);
  448. 		if(start_address>=0)
  449. 			break;
  450. 		else
  451. 			Sleep(1000);
  452. 	}
  453. 	temp=(THREAD_RESIDENCE_MEMORY *)malloc(sizeof(THREAD_RESIDENCE_MEMORY));
  454.     strcpy(temp->thread_name,((REQUIRE_MEMORY *)(data))->thread_name);
  455. 	temp->start_address=start_address;
  456. 	temp->size=((REQUIRE_MEMORY *)(data))->size;
  457. 	temp->next=NULL;
  458. 	EnterCriticalSection(&CS_THREAD_MEMORY_LIST);
  459. 	//加入线程内存驻留区链表
  460. 	tail_thread_residence_memory_list->next=temp;
  461. 	tail_thread_residence_memory_list=tail_thread_residence_memory_list->next;
  462.     LeaveCriticalSection(&CS_THREAD_MEMORY_LIST);
  463. 	//显示线程内存驻留区链表
  464. 	EnterCriticalSection(&CS_SCREEN);
  465. 	printf("after %s %s\n",((REQUIRE_MEMORY *)(data))->thread_name,"get memory:");
  466. 	display_thread_residence_memory_list();
  467. 	LeaveCriticalSection(&CS_SCREEN);
  468. 	
  469. 	Sleep(((REQUIRE_MEMORY *)(data))->duration);
  470. 	//释放内存
  471. 	WF_release_memory(start_address,((REQUIRE_MEMORY *)(data))->size);
  472. }
  473.  
  474. //最坏分配算法的空闲区结点插入函数
  475. void WF_insert_freearea(FREEAREA *free_node){
  476.     FREEAREA *p;
  477.     FREEAREA *p_next;
  478. 	 
  479. 	 if(p_free_area_list==NULL)
  480. 		 p_free_area_list=free_node;
  481. 	 else{
  482.        p=p_next=p_free_area_list;
  483. 	   while(p_next!=NULL&&free_node->size<p_next->size){
  484. 		 p=p_next;
  485. 		 p_next=p_next->next;
  486. 	   }
  487. 	   if(p_next==NULL)      //应插入到尾部
  488. 		 p->next=free_node;
  489. 	   else
  490. 		 if(p==p_next){  //应插入到头部
  491. 		    free_node->next=p;
  492. 		    p_free_area_list=free_node;
  493. 		 }
  494. 		 else{           //应插入到p与p_next之间
  495. 			 free_node->next=p_next;
  496. 			 p->next=free_node;
  497. 		 }
  498. 	 }
  499. }
  500.  
  501. //最坏适应分配法：初始化空闲区链表
  502. void WF_initialize_freearea_list(FREEAREA *init_table,int num){
  503.   FREEAREA *temp;
  504.   int i;
  505.   for(i=0;i<num;i++){
  506.      temp=(FREEAREA *)malloc(sizeof(FREEAREA));
  507.      temp->start_address=init_table[i].start_address;
  508. 	 temp->size=init_table[i].size;
  509. 	 temp->next=NULL;
  510. 	 WF_insert_freearea(temp);
  511.   }
  512. }
  513.  
  514. //最坏适应分配算法的内存申请函数
  515. int WF_require_memory(int size){
  516. 	int start_address=-1;
  517. 	FREEAREA *p_next;
  518. 	EnterCriticalSection(&CS_FREEAREA_LIST);
  519. 	p_next=p_free_area_list;
  520. 	if(size==p_free_area_list->size){//刚好满足要求，删除空闲区结点
  521. 		start_address=p_next->start_address;
  522. 		p_free_area_list=p_free_area_list->next;
  523. 		free(p_next);
  524. 	}
  525. 	else
  526. 		if(size<p_next->size){//分割空闲区结点
  527. 			start_address=p_next->start_address;
  528. 			p_next->start_address+=size;
  529. 			p_next->size-=size;
  530. 		    p_free_area_list=p_free_area_list->next;
  531. 			WF_insert_freearea(p_next);
  532. 		}
  533. 	LeaveCriticalSection(&CS_FREEAREA_LIST);
  534. 	return start_address;
  535.  
  536. }
  537.  
  538. //最坏适应分配算法：内存释放函数
  539. void WF_release_memory(int start_address,int size){
  540.   //请读者自己实现这段代码
  541. }
  542.  
  543.  
  544. //最坏适应分配算法的初始化程序
  545. void WF(){
  546.   int i=0;
  547.     REQUIRE_MEMORY *p;
  548.    	HANDLE h_thread[MAX_THREAD];
  549. 	InitializeCriticalSection(&CS_THREAD_MEMORY_LIST);
  550.     InitializeCriticalSection(&CS_FREEAREA_LIST);
  551. 	InitializeCriticalSection(&CS_SCREEN);
  552. 	printf("最坏适应分配算法\n");
  553.     WF_initialize_freearea_list(init_free_area_table,5);
  554. p_thread_require_memory_queue=WF_initialize_require_memory_list(init_thread_require_memory_table,3);
  555. p_thread_residence_memory_list=WF_initialize_thread_residence_memory_list(init_thread_residence_memory_table,5);
  556.     p=p_thread_require_memory_queue;
  557.     while(p!=NULL){
  558.       h_thread[i]=CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)(WF_thread),p,0,NULL);
  559.       i++;
  560. 	  p=p->next;
  561.     };
  562.     //等待所有线程结束
  563.     WaitForMultipleObjects(MAX_THREAD,h_thread,TRUE,-1);
  564.  
  565. 	//显示驻留线程链表
  566. 	EnterCriticalSection(&CS_SCREEN);
  567. 	printf("after all threads have finished:\n");
  568. 	display_thread_residence_memory_list();
  569. 	LeaveCriticalSection(&CS_SCREEN);
  570.  
  571. 	//删除各种链表
  572. 	FF_delete_freearea_list();
  573. 	FF_delete_require_memory_list();
  574. 	FF_delete_thread_residence_memory_list();
  575.  
  576. 	getch();
  577.     printf("\n");	
  578. }

【在Linux下运行的代码】

编译命令：gcc variable_partition .cpp –o variable_partition.o –lcurses –lpthread

头文件variable_partition.h

  1. #include <unistd.h>
  2. #include <curses.h>
  3. #include <stdlib.h>
  4. #include <pthread.h>
  5. #include <time.h>
  6. #include <string.h>
  7. #include <semaphore.h>
  8.  
  9. #define MAX_THREAD 3
  10. #define BF_initialize_require_memory_list FF_initialize_require_memory_list
  11. #define WF_initialize_require_memory_list FF_initialize_require_memory_list
  12. #define BF_initialize_thread_residence_memory_list 
  13. FF_initialize_thread_residence_memory_list
  14. #define WF_initialize_thread_residence_memory_list 
  15. FF_initialize_thread_residence_memory_list
  16. #define WF_delete_freearea_list FF_delete_freearea_list
  17. #define BF_delete_freearea_list FF_delete_freearea_list
  18. #define WF_delete_require_memory_list FF_delete_require_memory_list
  19. #define BF_delete_require_memory_list FF_delete_require_memory_list
  20. #define WF_delete_thread_residence_memory_list 
  21. FF_delete_thread_residence_memory_list
  22. #define BF_delete_thread_residence_memory_list 
  23. FF_delete_thread_residence_memory_list
  24.  
  25. typedef struct freearea{
  26. 	struct freearea *next;
  27. 	int start_address;
  28. 	int size;
  29. }FREEAREA;
  30.  
  31. typedef struct require_memory{
  32.     struct require_memory *next;
  33. 	char thread_name[10];
  34. 	int size;
  35. 	int duration;
  36. }REQUIRE_MEMORY;
  37.  
  38. typedef struct thread_residence_memory{
  39.     struct thread_residence_memory *next;
  40. 	char thread_name[10];
  41. 	int start_address;
  42. 	int size;
  43. }THREAD_RESIDENCE_MEMORY;
  44.  
  45. FREEAREA init_free_area_table[5]={
  46. 	{NULL,10,10},
  47. 	{NULL,40,30},
  48. 	{NULL,80,5},
  49. 	{NULL,145,15},
  50. 	{NULL,180,20}
  51. };
  52.  
  53. REQUIRE_MEMORY init_thread_require_memory_table[3]={
  54. 	{NULL,"thread_1",20,4},
  55. 	{NULL,"thread_2",10,5},
  56. 	{NULL,"thread_3",5,6}
  57. };
  58.  
  59. THREAD_RESIDENCE_MEMORY init_thread_residence_memory_table[5]={
  60. 	{NULL,"a",0,10},
  61. 	{NULL,"b",20,20},
  62. 	{NULL,"c",70,10},
  63. 	{NULL,"d",85,60},
  64. 	{NULL,"e",160,20}
  65. };
  66.  
  67. FREEAREA *p_free_area_list=NULL;
  68. REQUIRE_MEMORY *p_thread_require_memory_queue=NULL;
  69. THREAD_RESIDENCE_MEMORY *p_thread_residence_memory_list=NULL;
  70. THREAD_RESIDENCE_MEMORY *tail_thread_residence_memory_list=NULL;
  71. pthread_mutex_t CS_THREAD_MEMORY_LIST;
  72. pthread_mutex_t CS_SCREEN;
  73. pthread_mutex_t CS_FREEAREA_LIST;
  74. pthread_t h_thread[MAX_THREAD];
  75. sem_t thread_end[MAX_THREAD];
  76.  
  77. void display_thread_residence_memory_list();
  78. FREEAREA *FF_initialize_freearea_list(FREEAREA *init_table,int num);
  79.  
  80. void FF_delete_freearea_list();
  81. REQUIRE_MEMORY *FF_initialize_require_memory_list(REQUIRE_MEMORY *init_table,
  82. int num);
  83.  
  84. void FF_delete_require_memory_list();
  85. THREAD_RESIDENCE_MEMORY *FF_initialize_thread_residence_memory_list
  86. (
  87. THREAD_RESIDENCE_MEMORY *init_table,
  88. int num
  89. );
  90. void  FF_delete_thread_residence_memory_list();
  91. void* FF_thread(void *data);
  92. int   FF_require_memory(int size);
  93. void  FF_release_memory(int start_address,int size);
  94. void  FF();
  95.  
  96. void* BF_thread(void *data);
  97. int   BF_require_memory(int size);
  98. void  BF_release_memory(int start_address,int size);
  99. void  BF_insert_freearea(FREEAREA *free_node);
  100. void  BF();
  101. void  BF_initialize_freearea_list(FREEAREA *init_table,int num);
  102.  
  103. void* WF_thread(void *data);
  104. void  WF_insert_freearea(FREEAREA *free_node);
  105. void  WF_initialize_freearea_list(FREEAREA *init_table,int num);
  106. int   WF_require_memory(int size);
  107. void  WF_release_memory(int start_address,int size);
  108. void  WF();

源文件variable_partition.cpp

  1. #include "variable_partition.h"
  2. int main(int argc,char *argv[]){
  3. 	char select;
  4. 	bool end=false;
  5. 	initscr();
  6. 	while(!end){
  7. 		clear();
  8. 		refresh();
  9. 		printw("|-----------------------------------|\n");
  10. 		printw("|  1:first fit allocation           |\n");
  11. 		printw("|  2:best  fit allocation           |\n");
  12. 		printw("|  3:worst fit allocation           |\n");
  13. 		printw("|  4:exit                           |\n");
  14. 		printw("|-----------------------------------|\n");
  15. 		printw("select a function(1~4):");
  16. 		do{
  17. 			select=(char)getch();
  18. 		}while(select!='1'&&select!='2'&&select!='3'&&select!='4');
  19. 		clear();
  20. 		refresh();
  21. 		switch(select){
  22. 		case '1':
  23. 			FF();
  24. 			break;
  25. 		case '2':
  26. 			BF();
  27. 			break;
  28. 		case '3':
  29. 			WF();
  30. 			break;
  31. 		case '4':
  32. 			end=true;
  33. 		}
  34. 		printw("\nPress any key to return to main menu.");
  35. 		refresh();
  36. 		getch();
  37. 		
  38. 	}
  39. 	endwin();
  40. 	return 0;
  41. }
  42.  
  43. void display_thread_residence_memory_list(){
  44. 	THREAD_RESIDENCE_MEMORY *p;
  45.    	p=p_thread_residence_memory_list;
  46. 	int i=13;
  47. 	move(10,0);
  48. 	printw("|-------------------|--------------------|------------------|\n");
  49. 	printw("| thread_name       | start_address(kB)  | size(KB)         |\n");
  50. 	printw("|-------------------|--------------------|------------------|\n");
  51. 	while(p!=NULL){
  52. 	   move(i,0);
  53.        printw("| %s",p->thread_name);
  54. 	   move(i,20);
  55. 	   printw("| %d",p->start_address);
  56. 	   move(i,41);
  57. 	   printw("| %d",p->size);
  58.        move(i,60);
  59.        printw("|\n");
  60. 	   p=p->next;
  61. 	   i++;
  62. 	};
  63. 	move(i,0);
  64.         printw("|-------------------|--------------------|------------------|\n\n");
  65. 	refresh();
  66. }
  67.  
  68. FREEAREA *FF_initialize_freearea_list(FREEAREA *init_table,int num){
  69.   FREEAREA *temp;
  70.   FREEAREA *head=NULL;
  71.   FREEAREA *tail=NULL;
  72.   int i;
  73.   for(i=0;i<num;i++){
  74.      temp=(FREEAREA *)malloc(sizeof(FREEAREA));
  75.      temp->start_address=init_table[i].start_address;
  76. 	 temp->size=init_table[i].size;
  77. 	 temp->next=NULL;
  78. 	 if(head==NULL)
  79. 		 head=tail=temp;
  80. 	 else{
  81. 		 tail->next=temp;
  82. 		 tail=tail->next;
  83. 	 }
  84.   };
  85.   return head;
  86. }
  87.  
  88. void FF_delete_freearea_list(){
  89. 	FREEAREA *temp;
  90. 	temp=p_free_area_list;
  91. 	while(temp!=NULL){
  92. 		temp=p_free_area_list->next;
  93. 		free(p_free_area_list);
  94. 		p_free_area_list=temp;
  95. 	}
  96. 	p_free_area_list=NULL;
  97. }
  98.  
  99. REQUIRE_MEMORY *
  100. FF_initialize_require_memory_list(REQUIRE_MEMORY *init_table,int num)
  101. {
  102.   REQUIRE_MEMORY *temp;
  103.   REQUIRE_MEMORY *head=NULL;
  104.   REQUIRE_MEMORY *tail=NULL;
  105.   int i;
  106.   for(i=0;i<num;i++){
  107.      temp=(REQUIRE_MEMORY *)malloc(sizeof(REQUIRE_MEMORY));
  108.      strcpy(temp->thread_name,init_table[i].thread_name);
  109. 	 temp->size=init_table[i].size;
  110. 	 temp->duration=init_table[i].duration;
  111. 	 temp->next=NULL;
  112. 	 if(head==NULL)
  113. 		 head=tail=temp;
  114. 	 else{
  115. 		 tail->next=temp;
  116. 		 tail=tail->next;
  117. 	 }
  118.   };
  119.   return head;
  120. }
  121.  
  122. void FF_delete_require_memory_list(){
  123. 	REQUIRE_MEMORY *temp;
  124. 	temp=p_thread_require_memory_queue;
  125. 	while(temp!=NULL){
  126. 		temp=p_thread_require_memory_queue->next;
  127. 		free(p_thread_require_memory_queue);
  128. 		p_thread_require_memory_queue=temp;
  129. 	}
  130. 	p_thread_require_memory_queue=NULL;
  131. }
  132.  
  133. THREAD_RESIDENCE_MEMORY 
  134. *FF_initialize_thread_residence_memory_list
  135. (THREAD_RESIDENCE_MEMORY *init_table,int num)
  136. {
  137.   THREAD_RESIDENCE_MEMORY *temp;
  138.   THREAD_RESIDENCE_MEMORY *head=NULL;
  139.   THREAD_RESIDENCE_MEMORY *tail=NULL;
  140.   int i;
  141.   for(i=0;i<num;i++){
  142.      temp=(THREAD_RESIDENCE_MEMORY *)malloc(sizeof(THREAD_RESIDENCE_MEMORY));
  143.      strcpy(temp->thread_name,init_table[i].thread_name);
  144. 	 temp->start_address=init_table[i].start_address;
  145. 	 temp->size=init_table[i].size;
  146. 	 temp->next=NULL;
  147. 	 if(head==NULL)
  148. 		 head=tail=temp;
  149. 	 else{
  150. 		 tail->next=temp;
  151. 		 tail=tail->next;
  152. 	 }
  153.   };
  154.   tail_thread_residence_memory_list=tail;
  155.   return head;
  156. }
  157.  
  158. void FF_delete_thread_residence_memory_list(){
  159. 	THREAD_RESIDENCE_MEMORY *temp=p_thread_residence_memory_list;
  160. 	
  161. 	temp=p_thread_residence_memory_list;
  162. 	while(temp!=NULL){
  163. 		temp=p_thread_residence_memory_list->next;
  164. 		free(p_thread_residence_memory_list);
  165. 		p_thread_residence_memory_list=temp;
  166. 	}
  167. 	p_thread_residence_memory_list=NULL;
  168. }
  169.  
  170. void* FF_thread(void *data){
  171.         int start_address=-1;
  172. 	int i=(((REQUIRE_MEMORY *)(data))->thread_name)[7]-49;
  173. 	THREAD_RESIDENCE_MEMORY *temp;
  174. 	pthread_mutex_lock(&CS_SCREEN);
  175. 	printw("create thread:%s\n",((REQUIRE_MEMORY *)(data))->thread_name);
  176. 	refresh();
  177. 	pthread_mutex_unlock(&CS_SCREEN);
  178.     
  179.     while(1){
  180. 		start_address=FF_require_memory(((REQUIRE_MEMORY *)(data))->size);
  181. 		if(start_address>=0)
  182. 			break;
  183. 		else
  184. 			sleep(1);
  185. 	}
  186. 	temp=(THREAD_RESIDENCE_MEMORY *)malloc(sizeof(THREAD_RESIDENCE_MEMORY));
  187.     strcpy(temp->thread_name,((REQUIRE_MEMORY *)(data))->thread_name);
  188. 	temp->start_address=start_address;
  189. 	temp->size=((REQUIRE_MEMORY *)(data))->size;
  190. 	temp->next=NULL;
  191. 	pthread_mutex_lock(&CS_THREAD_MEMORY_LIST);	
  192. 	tail_thread_residence_memory_list->next=temp;
  193. 	tail_thread_residence_memory_list=tail_thread_residence_memory_list->next;
  194.     pthread_mutex_unlock(&CS_THREAD_MEMORY_LIST);	
  195. 	sleep(((REQUIRE_MEMORY *)(data))->duration);	
  196. 	FF_release_memory(start_address,((REQUIRE_MEMORY *)(data))->size);
  197. 	sem_post(&thread_end[i]);
  198. 	return 0;
  199. }
  200.  
  201. int FF_require_memory(int size){
  202. 	int start_address=-1;
  203. 	FREEAREA *p;
  204. 	FREEAREA *p_next;
  205. 	pthread_mutex_lock(&CS_FREEAREA_LIST);
  206. 	p=p_next=p_free_area_list;
  207. 	while(p_next!=NULL){
  208. 		if(size==p_next->size){
  209. 			start_address=p_next->start_address;
  210. 			if(p_next==p_free_area_list)
  211. 				p_free_area_list=p_next->next;
  212. 			else
  213. 			    p->next=p_next->next;
  214. 			free(p_next);
  215. 			break;
  216. 		}
  217. 		else
  218. 			if(size<p_next->size){
  219. 				start_address=p_next->start_address;
  220. 				p_next->start_address+=size;
  221. 				p_next->size-=size;
  222. 				break;
  223. 			}
  224. 			else
  225. 			{
  226. 				p=p_next;
  227. 				p_next=p_next->next;
  228. 			}
  229. 	}
  230.    	pthread_mutex_unlock(&CS_FREEAREA_LIST);
  231. 	return start_address;
  232.  
  233. }
  234.  
  235. void FF_release_memory(int start_address,int size){
  236. 	pthread_mutex_lock(&CS_FREEAREA_LIST);
  237. 	
  238. 	pthread_mutex_unlock(&CS_FREEAREA_LIST);
  239. }
  240.  
  241. void FF(){
  242. 	int i=0;
  243. 	int j=0;
  244.         REQUIRE_MEMORY *p;
  245.  
  246. 	for(j=0;j<MAX_THREAD;j++){
  247. 	   sem_init(&thread_end[j],0,0);
  248.     }
  249.    	
  250. 	pthread_mutex_init(&CS_THREAD_MEMORY_LIST,NULL);
  251.     pthread_mutex_init(&CS_FREEAREA_LIST,NULL);
  252. 	pthread_mutex_init(&CS_SCREEN,NULL);
  253. 	printw("First Fit\n");
  254. 	refresh();
  255.     p_free_area_list=FF_initialize_freearea_list(init_free_area_table,5);
  256.     p_thread_require_memory_queue=FF_initialize_require_memory_list(init_thread_require_memory_table,3);
  257.     p_thread_residence_memory_list=FF_initialize_thread_residence_memory_list
  258. (init_thread_residence_memory_table,5);
  259.     p=p_thread_require_memory_queue;
  260.     while(p!=NULL){
  261.           pthread_create(&h_thread[i],NULL,FF_thread,p);
  262.           i++;
  263.   p=p->next;
  264.     };
  265.    
  266.    for(j=0;j<MAX_THREAD;j++){
  267. 		sem_wait(&thread_end[j]);
  268.    }
  269. 	
  270. 	pthread_mutex_lock(&CS_SCREEN);
  271. 	printw("after all threads have finished:\n");
  272. 	refresh();
  273. 	display_thread_residence_memory_list();
  274. 	pthread_mutex_unlock(&CS_SCREEN);
  275.  
  276. 	
  277. 	FF_delete_freearea_list();
  278. 	FF_delete_require_memory_list();
  279. 	FF_delete_thread_residence_memory_list();
  280.  
  281. 	for(j=0;j<MAX_THREAD;j++){
  282. 	   sem_destroy(&thread_end[j]);
  283.         }
  284.  
  285. 	getch();
  286.         printw("\n");
  287. 	refresh();
  288. }
  289. 	
  290. void* BF_thread(void *data){
  291.         int start_address=-1;
  292. 	int i=(((REQUIRE_MEMORY *)(data))->thread_name)[7]-49;
  293. 	THREAD_RESIDENCE_MEMORY *temp;
  294. 	pthread_mutex_lock(&CS_SCREEN);
  295. 	printw("create thread:%s\n",((REQUIRE_MEMORY *)(data))->thread_name);
  296. 	refresh();
  297. 	pthread_mutex_unlock(&CS_SCREEN);
  298.     
  299.     while(1){
  300. 		start_address=BF_require_memory(((REQUIRE_MEMORY *)(data))->size);
  301. 		if(start_address>=0)
  302. 			break;
  303. 		else
  304. 			sleep(1);
  305. 	}
  306. 	temp=(THREAD_RESIDENCE_MEMORY *)malloc(sizeof(THREAD_RESIDENCE_MEMORY));
  307.     strcpy(temp->thread_name,((REQUIRE_MEMORY *)(data))->thread_name);
  308. 	temp->start_address=start_address;
  309. 	temp->size=((REQUIRE_MEMORY *)(data))->size;
  310. 	temp->next=NULL;
  311. 	pthread_mutex_lock(&CS_THREAD_MEMORY_LIST);
  312. 	
  313. 	tail_thread_residence_memory_list->next=temp;
  314. 	tail_thread_residence_memory_list=tail_thread_residence_memory_list->next;
  315.     pthread_mutex_unlock(&CS_THREAD_MEMORY_LIST);
  316. 	
  317. 	sleep(((REQUIRE_MEMORY *)(data))->duration);
  318. 	
  319. 	BF_release_memory(start_address,((REQUIRE_MEMORY *)(data))->size);
  320. 	sem_post(&thread_end[i]);
  321. 	return 0;
  322. }
  323.  
  324. int BF_require_memory(int size){
  325.   	int start_address=-1;
  326. 	FREEAREA *p;
  327. 	FREEAREA *p_next;
  328. 	pthread_mutex_lock(&CS_FREEAREA_LIST);
  329. 	p=p_next=p_free_area_list;
  330. 	while(p_next!=NULL){
  331. 		if(size==p_next->size){
  332. 			start_address=p_next->start_address;
  333. 			if(p_next==p_free_area_list)
  334. 				p_free_area_list=p_next->next;
  335. 			else
  336. 			    p->next=p_next->next;
  337. 			free(p_next);
  338. 			break;
  339. 		}
  340. 		else
  341. 			if(size<p_next->size){
  342. 				start_address=p_next->start_address;
  343. 				p_next->start_address+=size;
  344. 				p_next->size-=size;
  345. 				p->next=p_next->next;
  346. 				BF_insert_freearea(p_next);
  347. 				break;
  348. 			}
  349. 			else
  350. 			{
  351. 				p=p_next;
  352. 				p_next=p_next->next;
  353. 			}
  354. 	}
  355.    	pthread_mutex_unlock(&CS_FREEAREA_LIST);
  356. 	return start_address;
  357.  
  358. }
  359.  
  360. void BF_release_memory(int start_address,int size){
  361. }
  362.  
  363. void BF_insert_freearea(FREEAREA *free_node){
  364.      FREEAREA *p;
  365.      FREEAREA *p_next;
  366. 	 
  367. 	 if(p_free_area_list==NULL)
  368. 		 p_free_area_list=free_node;
  369. 	 else{
  370. 	   p_next=p=p_free_area_list;
  371. 	   while(p_next!=NULL&&p_next->size<free_node->size){
  372. 		 p=p_next;
  373. 		 p_next=p_next->next;
  374. 	   }
  375. 	   if(p_next==NULL)      
  376. 		 p->next=free_node;
  377. 	   else
  378. 		 if(p==p_next){  
  379. 		    free_node->next=p;
  380. 		    p_free_area_list=free_node;
  381. 		 }
  382. 		 else{          
  383. 			 free_node->next=p_next;
  384. 			 p->next=free_node;
  385. 		 }
  386. 	 }
  387. }
  388.  
  389. void BF_initialize_freearea_list(FREEAREA *init_table,int num){
  390.   FREEAREA *temp;
  391.   int i;
  392.   for(i=0;i<num;i++){
  393.      temp=(FREEAREA *)malloc(sizeof(FREEAREA));
  394.      temp->start_address=init_table[i].start_address;
  395. 	 temp->size=init_table[i].size;
  396. 	 temp->next=NULL;
  397. 	 BF_insert_freearea(temp);
  398.   }
  399. }
  400.  
  401. void BF(){
  402.   	int i=0;
  403. 	int j=0;
  404.     REQUIRE_MEMORY *p;
  405. 	for(j=0;j<MAX_THREAD;j++){
  406. 	   sem_init(&thread_end[j],0,0);
  407.     }
  408.  
  409. 	pthread_mutex_init(&CS_THREAD_MEMORY_LIST,NULL);
  410.     pthread_mutex_init(&CS_FREEAREA_LIST,NULL);
  411. 	pthread_mutex_init(&CS_SCREEN,NULL);
  412. 	printw("Best Fit\n");
  413. 	refresh();
  414.     BF_initialize_freearea_list(init_free_area_table,5);
  415.     p_thread_require_memory_queue=BF_initialize_require_memory_list(init_thread_require_memory_table,3);
  416.     p_thread_residence_memory_list=BF_initialize_thread_residence_memory_list
  417. (init_thread_residence_memory_table,5);
  418.     p=p_thread_require_memory_queue;
  419.     while(p!=NULL){
  420.         pthread_create(&h_thread[i],NULL,BF_thread,p);
  421.         i++;
  422. 	    p=p->next;
  423.     };
  424.    
  425.    for(j=0;j<MAX_THREAD;j++)
  426. 	{sem_wait(&thread_end[j]);}
  427. 	
  428. 	pthread_mutex_lock(&CS_SCREEN);
  429. 	printw("after all threads have finished:\n");
  430. 	refresh();
  431. 	display_thread_residence_memory_list();
  432. 	pthread_mutex_unlock(&CS_SCREEN);
  433.  
  434. 	FF_delete_freearea_list();
  435. 	FF_delete_require_memory_list();
  436. 	FF_delete_thread_residence_memory_list();
  437. 	
  438. 	for(j=0;j<MAX_THREAD;j++){
  439. 	   sem_destroy(&thread_end[j]);
  440.     }
  441.  
  442. 	getch();
  443.     printw("\n");
  444. 	refresh();
  445. }
  446.  
  447. void* WF_thread(void *data){
  448.     int start_address=-1;
  449. 	int i=(((REQUIRE_MEMORY *)(data))->thread_name)[7]-49;
  450. 	THREAD_RESIDENCE_MEMORY *temp;
  451. 	pthread_mutex_lock(&CS_SCREEN);
  452. 	printw("create thread:%s\n",((REQUIRE_MEMORY *)(data))->thread_name);
  453. 	refresh();
  454. 	pthread_mutex_unlock(&CS_SCREEN);
  455.     	
  456.     while(1){
  457. 		start_address=WF_require_memory(((REQUIRE_MEMORY *)(data))->size);
  458. 		if(start_address>=0)
  459. 			break;
  460. 		else
  461. 			sleep(1);
  462. 	}
  463. 	temp=(THREAD_RESIDENCE_MEMORY *)malloc(sizeof(THREAD_RESIDENCE_MEMORY));
  464.         strcpy(temp->thread_name,((REQUIRE_MEMORY *)(data))->thread_name);
  465. 	temp->start_address=start_address;
  466. 	temp->size=((REQUIRE_MEMORY *)(data))->size;
  467. 	temp->next=NULL;
  468. 	pthread_mutex_lock(&CS_THREAD_MEMORY_LIST);
  469. 	tail_thread_residence_memory_list->next=temp;
  470. 	tail_thread_residence_memory_list=tail_thread_residence_memory_list->next;
  471.     pthread_mutex_unlock(&CS_THREAD_MEMORY_LIST);
  472. 	
  473. 	sleep(((REQUIRE_MEMORY *)(data))->duration);
  474. 	
  475. 	WF_release_memory(start_address,((REQUIRE_MEMORY *)(data))->size);
  476. 	sem_post(&thread_end[i]);
  477. 	return 0;
  478. }
  479.  
  480. void WF_insert_freearea(FREEAREA *free_node){
  481.     FREEAREA *p;
  482.     FREEAREA *p_next;
  483. 	 
  484. 	 if(p_free_area_list==NULL)
  485. 		 p_free_area_list=free_node;
  486. 	 else{
  487.            p=p_next=p_free_area_list;
  488. 	   while(p_next!=NULL&&free_node->size<p_next->size){
  489. 		 p=p_next;
  490. 		 p_next=p_next->next;
  491. 	   }
  492. 	   if(p_next==NULL)      
  493. 		 p->next=free_node;
  494. 	   else
  495. 		 if(p==p_next){  
  496. 		    free_node->next=p;
  497. 		    p_free_area_list=free_node;
  498. 		 }
  499. 		 else{           
  500. 			 free_node->next=p_next;
  501. 			 p->next=free_node;
  502. 		 }
  503. 	 }
  504. }
  505.  
  506. void WF_initialize_freearea_list(FREEAREA *init_table,int num){
  507.   FREEAREA *temp;
  508.   int i;
  509.   for(i=0;i<num;i++){
  510.      temp=(FREEAREA *)malloc(sizeof(FREEAREA));
  511.      temp->start_address=init_table[i].start_address;
  512. 	 temp->size=init_table[i].size;
  513. 	 temp->next=NULL;
  514. 	 WF_insert_freearea(temp);
  515.   }
  516. }
  517.  
  518. int WF_require_memory(int size){
  519. 	int start_address=-1;
  520. 	FREEAREA *p_next;
  521. 	pthread_mutex_lock(&CS_FREEAREA_LIST);
  522. 	p_next=p_free_area_list;
  523. 	if(size==p_free_area_list->size){
  524. 		start_address=p_next->start_address;
  525. 		p_free_area_list=p_free_area_list->next;
  526. 		free(p_next);
  527. 	}
  528. 	else{
  529. 		if(size<p_next->size){
  530. 			start_address=p_next->start_address;
  531. 			p_next->start_address+=size;
  532. 			p_next->size-=size;
  533. 		        p_free_area_list=p_free_area_list->next;
  534. 			WF_insert_freearea(p_next);
  535. 		}
  536. 	}
  537. 	pthread_mutex_unlock(&CS_FREEAREA_LIST);
  538. 	return (start_address);
  539.  
  540. }
  541. void WF_release_memory(int start_address,int size){
  542. }
  543.  
  544. void WF(){
  545.     int i=0;
  546. 	int j=0;
  547.    REQUIRE_MEMORY *p;
  548.  
  549. 	for(j=0;j<MAX_THREAD;j++){
  550. 	   sem_init(&thread_end[j],0,0);
  551.     }
  552.    	
  553. 	pthread_mutex_init(&CS_THREAD_MEMORY_LIST,NULL);
  554.     pthread_mutex_init(&CS_FREEAREA_LIST,NULL);
  555. 	pthread_mutex_init(&CS_SCREEN,NULL);
  556. 	printw("Wirst Fit\n");
  557.   	refresh();
  558.     WF_initialize_freearea_list(init_free_area_table,5);
  559.     p_thread_require_memory_queue=WF_initialize_require_memory_list(init_thread_require_memory_table,3);
  560.     p_thread_residence_memory_list=WF_initialize_thread_residence_memory_list
  561. (init_thread_residence_memory_table,5);
  562.     p=p_thread_require_memory_queue;
  563.     while(p!=NULL){
  564.         pthread_create(&h_thread[i],NULL,WF_thread,p);
  565.         i++;
  566. 	    p=p->next;
  567.    };
  568.     
  569.    for(j=0;j<MAX_THREAD;j++){
  570. 	   sem_wait(&thread_end[j]);
  571.    }
  572.  
  573. 	
  574. 	pthread_mutex_lock(&CS_SCREEN);
  575. 	printw("after all threads have finished:\n");
  576. 	refresh();
  577. 	display_thread_residence_memory_list();
  578. 	pthread_mutex_unlock(&CS_SCREEN);
  579.  
  580. 	
  581. 	FF_delete_freearea_list();
  582. 	FF_delete_require_memory_list();
  583. 	FF_delete_thread_residence_memory_list();
  584. 	
  585. 	for(j=0;j<MAX_THREAD;j++){
  586. 	   sem_destroy(&thread_end[j]);
  587.    }
  588.  
  589. 	getch();
  590.     printw("\n");	
  591. 	refresh();
  592. }

【测试结果】

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/人工智能uu/article/detail/785007
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号