操作系统实验内存分配(共21页).doc

《操作系统实验内存分配(共21页).doc》由会员分享，可在线阅读，更多相关《操作系统实验内存分配(共21页).doc（21页珍藏版）》请在淘文阁 - 分享文档赚钱的网站上搜索。

1、精选优质文档-倾情为你奉上 西 安 邮 电 大 学 （计算机学院）课内实验报告实验名称： 内存管理 专业名称： 软件工程班 级： 学生姓名： 学号（8位）：指导教师： 实验日期： 实验五：进程1.实验目的 通过深入理解区管理的三种算法，定义相应的数据结构，编写具体代码。 充分模拟三种算法的实现过程，并通过对比，分析三种算法的优劣。（1）掌握内存分配FF，BF，WF策略及实现的思路；（2）掌握内存回收过程及实现思路；（3）参考给出的代码思路，实现内存的申请、释放的管理程序，调试运行，总结程序设计中出现的问题并找出原因，写出实验报告。2.实验要求：1） 掌握内存分配FF，BF，WF策略及实现的思路

2、；2） 掌握内存回收过程及实现思路；3） 参考本程序思路，实现内存的申请、释放的管理程序，调试运行，总结程序设计中出现的问题并找出原因，写出实验报告。3. 实验过程：创建进程：删除其中几个进程：(默认以ff首次适应算法方式排列)Bf 最佳适应算法排列方式：wf最差匹配算法排列方式：4. 实验心得： 这次实验实验时间比较长，而且实验指导书中对内存的管理讲的很详细，老师上课的时候也有讲的很详细，但是代码比较长，刚开始的时候也是不太懂，但是后面经过和同学一起商讨，明白几种算法的含义： 首次适应算法。在采用空闲分区链作为数据结构时，该算法要求空闲分区链表以地址递增的次序链接。在进行内存分配时，从链首开

3、始顺序查找，直至找到一个能满足进程大小要求的空闲分区为止。然后，再按照进程请求内存的大小，从该分区中划出一块内存空间分配给请求进程，余下的空闲分区仍留在空闲链中。 循环首次适应算法。该算法是由首次适应算法演变而形成的，在为进程分配内存空间时，从上次找到的空闲分区的下一个空闲分区开始查找，直至找到第一个能满足要求的空闲分区，并从中划出一块与请求的大小相等的内存空间分配给进程。 最佳适应算法将空闲分区链表按分区大小由小到大排序，在链表中查找第一个满足要求的分区。 最差匹配算法将空闲分区链表按分区大小由大到小排序，在链表中找到第一个满足要求的空闲分区。实验中没有用到循环首次适应算法，但是对其他三种的

4、描述还是很详细，总的来说，从实验中还是学到了很多。5.程序源代码：#include#include#include#include#define PROCESS_NAME_LEN 32 /进程名长度#define MIN_SLICE 10 /最小碎片的大小#define DEFAULT_MEM_SIZE 1024/内存大小#define DEFAULT_MEM_START 0 /起始位置/*内存分配算法*/#define MA_FF 1#define MA_BF 2#define MA_WF 3/*描述每一个空闲块的数据结构*/struct free_block_typeint size;/空

5、闲块大小int start_addr;/空闲块起始地址struct free_block_type *next;/指向下一个空闲块;/*指向内存中空闲块链表的首指针*/struct free_block_type *free_block = NULL;/*每个进程分配到的内存块的描述*/struct allocated_blockint pid;/进程标识符int size;/进程大小int start_addr;/进程分配到的内存块的起始地址char process_namePROCESS_NAME_LEN;/进程名struct allocated_block *next;/指向下一个进程控

6、制块;/*进程分配内存块链表的首指针*/struct allocated_block *allocated_block_head = NULL;int free_block_count = 0;/空闲块个数int mem_size = DEFAULT_MEM_SIZE; /内存大小int current_free_mem_size = 0;/当前空闲内存大小int ma_algorithm = MA_FF; /当前分配算法static int pid = 0; /初始PIDint flag = 0;/设置内存大小标志,表示内存大小是否设置/*函数声明*/struct free_block_ty

7、pe* init_free_block(int mem_size);void display_menu();int set_mem_size();void set_algorithm();void rearrange(int algorithm);int rearrange_WF();int rearrange_BF();int rearrange_FF();int new_process();int allocate_mem(struct allocated_block *ab);void kill_process();int free_mem(struct allocated_block

8、*ab);int dispose(struct allocated_block *free_ab);int display_mem_usage();struct allocated_block *find_process(int pid);int do_exit();int allocate_FF(struct allocated_block *ab);int allocate_BF(struct allocated_block *ab);int allocate_WF(struct allocated_block *ab);int allocate(struct free_block_typ

9、e *pre, struct free_block_type *allocate_free_nlock, struct allocated_block *ab);int mem_retrench(struct allocated_block *ab);/ 通过内存紧缩技术给新进程分配内存空间int mem_retrench(struct allocated_block *ab)struct allocated_block *allocated_work, *allocated_pre = allocated_block_head;struct free_block_type *free_wor

10、k, *free_pre = free_block-next;if(allocated_pre = NULL)return -1;allocated_pre-start_addr = 0;allocated_work = allocated_pre-next;while(allocated_work != NULL)allocated_work-start_addr = allocated_pre-start_addr + allocated_pre-size;allocated_pre = allocated_work;allocated_work = allocated_work-next

11、;free_block-start_addr = allocated_pre-start_addr + allocated_pre-size;free_block-size = current_free_mem_size;free_block-next = NULL;free_work = free_pre;while(free_pre != NULL)free(free_pre);free_pre = free_work;if(free_pre != NULL)free_work = free_work-next;allocate(NULL, free_block, ab);return 1

12、;/ 给新进程分配内存空间 int allocate(struct free_block_type *pre, struct free_block_type *allocate_free_block, struct allocated_block *ab)struct allocated_block *p = allocated_block_head;ab-start_addr = allocate_free_block-start_addr;if(allocate_free_block-size - ab-size size = allocate_free_block-size;if(pre

13、 != NULL)pre-next = allocate_free_block;elsefree_block = allocate_free_block-next;free(allocate_free_block);elseallocate_free_block-start_addr += ab-size;allocate_free_block-size -= ab-size;if(p = NULL)allocated_block_head = ab;elsewhile(p-next != NULL)p = p-next;p-next = ab;current_free_mem_size -=

14、 ab-size;if(current_free_mem_size = 0)free_block = NULL;return 0;/按照最坏适应算法给新进程分配内存空间int allocate_WF(struct allocated_block *ab)int ret;struct free_block_type *wf = free_block;if(wf = NULL)return -1;if(wf-size = ab-size)allocate(NULL, wf, ab);else if(current_free_mem_size = ab-size)ret = mem_retrench

15、(ab);elseret = -2;rearrange_WF();return ret;/ 按照最佳适应算法给新进程分配内存空间int allocate_BF(struct allocated_block *ab)int ret;struct free_block_type *pre = NULL, *bf = free_block;if(bf = NULL)return -1;while(bf != NULL)if(bf-size = ab-size)ret = allocate(pre, bf,ab);break;pre = bf;pre = pre-next;if(bf = NULL &

16、 current_free_mem_size ab-size)ret = mem_retrench(ab);elseret = -2;rearrange_BF();return ret;/ 按照首次适应算法给新进程分配内存空间int allocate_FF(struct allocated_block *ab)int ret;struct free_block_type *pre = NULL, *ff = free_block;if(ff = NULL)return -1;while(ff != NULL)if(ff-size = ab-size)ret = allocate(pre, ff

17、,ab);break;pre = ff;pre = pre-next;if(ff = NULL & current_free_mem_size ab-size)ret = mem_retrench(ab);elseret = -2;rearrange_FF();return ret;/分配内存模块int allocate_mem(struct allocated_block *ab)int ret ;struct free_block_type *fbt, *pre;int request_size = ab-size;fbt = pre = free_block;switch(ma_algo

18、rithm)case MA_FF :ret = allocate_FF(ab);break;case MA_BF :ret = allocate_BF(ab);break;case MA_WF :ret = allocate_WF(ab);break;default :break;return ret;/ 创建一个新的进程。int new_process()struct allocated_block *ab;int size;int ret;ab = (struct allocated_block *)malloc(sizeof(struct allocated_block);if(!ab)

19、exit(-5);ab-next = NULL;pid+;sprintf(ab-process_name, PROCESS-%02d, pid);/sprintf()函数将格式化的数据写入某字符串中ab-pid = pid; printf(Memory for %s:, ab-process_name);for(; ; )scanf(%d, &size);getchar();if(size 0)ab-size = size;break;elseprintf(The size have to greater than zero! Please input again!);ret = alloca

20、te_mem(ab); /从空闲区分配内存，ret=1表示分配okif(ret = 1) & (allocated_block_head = NULL)/如果此时allocated_block_head尚未赋值，则赋值 /进程分配链表为空allocated_block_head = ab;return 1;else if(ret = 1) /分配成功，将该已分配块的描述插入已分配链表ab-next = allocated_block_head;/头插法allocated_block_head = ab;return 2;else if(ret = -1) /分配不成功printf(Alloca

21、tion failn);free(ab);return -1; return 3;/退出程序并释放内存空间。int do_exit()struct allocated_block *allocated_ab, *allocated_pre;struct free_block_type *free_ab, *free_pre;free_pre = free_block;allocated_pre = allocated_block_head;if(free_pre != NULL)free_ab = free_pre-next;while(free_ab != NULL)free(free_pr

22、e);free_pre = free_ab;free_ab = free_ab-next;if(allocated_pre != NULL)allocated_ab = allocated_pre-next;while(allocated_ab != NULL)free(allocated_pre);allocated_pre = allocated_ab;allocated_ab = allocated_ab-next;allocated_ab = allocated_ab-next;return 0;/在进程分配链表中寻找指定进程。struct allocated_block *find_

23、process(int pid)struct allocated_block *ab = allocated_block_head;if(ab = NULL)printf(Here?n);return NULL;while(ab-pid != pid & ab-next != NULL)ab = ab-next;if(ab-next = NULL & ab-pid != pid)printf(Here?n);return NULL;return ab;/显示当前内存的使用情况，包括空闲区的情况和已经分配的情况。int display_mem_usage()struct free_block_t

24、ype *fbt = free_block;struct allocated_block *ab = allocated_block_head;printf(-n);/显示空闲区printf(Free Memory:n);printf(%20s %20sn, start_addr, size);while(fbt != NULL)printf(%20d %20dn, fbt-start_addr, fbt-size);fbt = fbt-next;/显示已分配区printf(nUsed Memory:n);printf(%10s %20s %10s %10sn, PID, ProcessNam

25、e, start_addr, size);while(ab != NULL)printf(%10d %20s %10d %10dn, ab-pid, ab-process_name, ab-start_addr, ab-size);ab = ab-next;printf(-n);return 1;/ 释放ab数据结构节点。int dispose(struct allocated_block *free_ab)struct allocated_block *pre, *ab;if(free_block = NULL)return -1;if(free_ab = allocated_block_h

26、ead)/如果要释放第一个节点allocated_block_head = allocated_block_head-next;free(free_ab); elsepre = allocated_block_head; ab = allocated_block_head-next;/找到free_abwhile(ab != free_ab)pre = ab;ab = ab-next;pre-next = ab-next;free(ab);return 1;/*将ab所表示的已分配区归还，并进行可能的合并*/int free_mem(struct allocated_block *ab)int

27、 algorithm = ma_algorithm;struct free_block_type *fbt, *pre, *work;fbt = (struct free_block_type*)malloc(sizeof(struct free_block_type);if(!fbt)return -1;pre = free_block;fbt-start_addr = ab-start_addr;fbt-size = ab-size;fbt-next = NULL;if(pre != NULL)while(pre-next != NULL)pre = pre-next;pre-next =

28、 fbt;elsefree_block = fbt;rearrange_FF();pre = free_block;work = pre-next;while(work != NULL)if(pre-start_addr + pre-size = work-start_addr)pre-size += work-size;free(work);work = pre-next;elsepre = work;work = work-next;current_free_mem_size += ab-size;return 1;/ 删除进程，归还分配的存储空间，并删除描述该进程内存分配的节点。void

29、 kill_process()struct allocated_block *ab;int pid;printf(Kill Process, pid=);scanf(%d, &pid);getchar();ab = find_process(pid);if(ab != NULL)free_mem(ab); /*释放ab所表示的分配区*/dispose(ab); /*释放ab数据结构节点*/按FF算法重新整理内存空闲块链表,按空闲块首地址排序。int rearrange_FF()struct free_block_type *head = free_block;struct free_block

30、_type *forehand, *pre, *rear;int i;if(head = NULL)return -1;/冒泡排序for(i = 0; i next;rear = pre-next;while(pre-next != NULL)if(forehand = head & forehand-start_addr = pre-start_addr)/比较空闲链表中第一个空闲块与第二个空闲块的开始地址的大小head-next = pre-next;pre-next = head;head = pre;forehand = head-next;pre = forehand-next;re

31、ar = pre-next;else if(pre-start_addr = rear-start_addr)/比较链表中其他相邻两节点的开始地址的大小pre-next = rear-next;forehand-next = rear;rear-next = pre;forehand = rear;rear = pre-next;elseforehand = pre;pre = rear;rear = rear-next;return 0;/ 按BF算法重新整理内存空闲块链表,按空闲块大小从小到大排序。int rearrange_BF()struct free_block_type *head

32、 = free_block;struct free_block_type *forehand, *pre, *rear;int i;if(head = NULL)return -1;/冒泡排序for(i = 0; i next;rear = pre-next;while(pre-next != NULL)if(forehand = head & forehand-size size)/比较空闲链表中第一个空闲块与第二个空闲块的空间的大小head-next = pre-next;pre-next = head;head = pre;forehand = head-next;pre = foreh

33、and-next;rear = pre-next;else if(pre-size size)/比较链表中其他相邻两节点的空间的大小pre-next = rear-next;forehand-next = rear;rear-next = pre;forehand = rear;rear = pre-next;elseforehand = pre;pre = rear;rear = rear-next;return 0;/按WF算法重新整理内存空闲块链表,按空闲块大小从大到小排序。int rearrange_WF()struct free_block_type *head = free_blo

34、ck;struct free_block_type *forehand, *pre, *rear;int i;if(head = NULL)return -1;/冒泡排序for(i = 0; i next;rear = pre-next;while(pre-next != NULL)if(forehand = head & forehand-size = pre-size)/比较空闲链表中第一个空闲块与第二个空闲块空间的大小head-next = pre-next;pre-next = head;head = pre;forehand = head-next;pre = forehand-ne

35、xt;rear = pre-next;else if(pre-size = rear-size)/比较链表中其他相邻两节点的空间的大小pre-next = rear-next;forehand-next = rear;rear-next = pre;forehand = rear;rear = pre-next;elseforehand = pre;pre = rear;rear = rear-next;return 0;/按指定的算法整理内存空闲块链表。void rearrange(int algorithm)switch(algorithm)case MA_FF:rearrange_FF(

36、);break;case MA_BF:rearrange_BF();break;case MA_WF:rearrange_WF();break;/设置当前的分配算法void set_algorithm()int algorithm;/system(clear);printf(t1 - First Fitn);/首次适应算法printf(t2 - Best Fit n);/最佳适应算法printf(t3 - Worst Fit n);/最坏适应算法printf(nPlease choose(13):);for(; ; )scanf(%d, &algorithm);getchar();if(alg

37、orithm = 1 & algorithm 0)current_free_mem_size = size;mem_size = size;/设置内存大小为sizefree_block-size = mem_size;/设置空闲块大小为sizebreak;elseprintf(The size must greater than zero! Please input again:);flag = 1;/内存大小已经设置return 1;/显示主菜单void display_menu()printf(n);/system(clear);printf(1 - Set memory size (de