操作系统实验内存分配.docx
- 文档编号:7496176
- 上传时间:2023-01-24
- 格式:DOCX
- 页数:27
- 大小:412.22KB
操作系统实验内存分配.docx
《操作系统实验内存分配.docx》由会员分享,可在线阅读,更多相关《操作系统实验内存分配.docx(27页珍藏版)》请在冰豆网上搜索。
操作系统实验内存分配
西安邮电大学
(计算机学院)
课内实验报告
实验名称:
内存管理
专业名称:
软件工程
班级:
学生姓名:
学号(8位):
指导教师:
实验日期:
实验五:
进程
1.实验目的
通过深入理解区管理的三种算法,定义相应的数据结构,编写具体代码。
充分模拟三种算法的实现过程,并通过对比,分析三种算法的优劣。
(1)掌握内存分配FF,BF,WF策略及实现的思路;
(2)掌握内存回收过程及实现思路;
(3)参考给出的代码思路,实现内存的申请、释放的管理程序,调试运行,总结程序设计中出现的问题并找出原因,写出实验报告。
2.实验要求:
1)掌握内存分配FF,BF,WF策略及实现的思路;
2)掌握内存回收过程及实现思路;
3)参考本程序思路,实现内存的申请、释放的管理程序,调试运行,总结程序设计中出现的问题并找出原因,写出实验报告。
3.实验过程:
创建进程:
删除其中几个进程:
(默认以ff首次适应算法方式排列)
Bf最佳适应算法排列方式:
wf最差匹配算法排列方式:
4.实验心得:
这次实验实验时间比较长,而且实验指导书中对内存的管理讲的很详细,老师上课的时候也有讲的很详细,但是代码比较长,刚开始的时候也是不太懂,但是后面经过和同学一起商讨,明白几种算法的含义:
首次适应算法。
在采用空闲分区链作为数据结构时,该算法要求空闲分区链表以地址递增的次序链接。
在进行内存分配时,从链首开始顺序查找,直至找到一个能满足进程大小要求的空闲分区为止。
然后,再按照进程请求内存的大小,从该分区中划出一块内存空间分配给请求进程,余下的空闲分区仍留在空闲链中。
循环首次适应算法。
该算法是由首次适应算法演变而形成的,在为进程分配内存空间时,从上次找到的空闲分区的下一个空闲分区开始查找,直至找到第一个能满足要求的空闲分区,并从中划出一块与请求的大小相等的内存空间分配给进程。
最佳适应算法将空闲分区链表按分区大小由小到大排序,在链表中查找第一个满足要求的分区。
最差匹配算法将空闲分区链表按分区大小由大到小排序,在链表中找到第一个满足要求的空闲分区。
实验中没有用到循环首次适应算法,但是对其他三种的描述还是很详细,总的来说,从实验中还是学到了很多。
5.程序源代码:
#include
#include
#include
#include
#definePROCESS_NAME_LEN32//进程名长度
#defineMIN_SLICE10//最小碎片的大小
#defineDEFAULT_MEM_SIZE1024//内存大小
#defineDEFAULT_MEM_START0//起始位置
/*内存分配算法*/
#defineMA_FF1
#defineMA_BF2
#defineMA_WF3
/*描述每一个空闲块的数据结构*/
structfree_block_type
{
intsize;//空闲块大小
intstart_addr;//空闲块起始地址
structfree_block_type*next;//指向下一个空闲块
};
/*指向内存中空闲块链表的首指针*/
structfree_block_type*free_block=NULL;
/*每个进程分配到的内存块的描述*/
structallocated_block
{
intpid;//进程标识符
intsize;//进程大小
intstart_addr;//进程分配到的内存块的起始地址
charprocess_name[PROCESS_NAME_LEN];//进程名
structallocated_block*next;//指向下一个进程控制块
};
/*进程分配内存块链表的首指针*/
structallocated_block*allocated_block_head=NULL;
intfree_block_count=0;//空闲块个数
intmem_size=DEFAULT_MEM_SIZE;//内存大小
intcurrent_free_mem_size=0;//当前空闲内存大小
intma_algorithm=MA_FF;//当前分配算法
staticintpid=0;//初始PID
intflag=0;//设置内存大小标志,表示内存大小是否设置
/*函数声明*/
structfree_block_type*init_free_block(intmem_size);
voiddisplay_menu();
intset_mem_size();
voidset_algorithm();
voidrearrange(intalgorithm);
intrearrange_WF();
intrearrange_BF();
intrearrange_FF();
intnew_process();
intallocate_mem(structallocated_block*ab);
voidkill_process();
intfree_mem(structallocated_block*ab);
intdispose(structallocated_block*free_ab);
intdisplay_mem_usage();
structallocated_block*find_process(intpid);
intdo_exit();
intallocate_FF(structallocated_block*ab);
intallocate_BF(structallocated_block*ab);
intallocate_WF(structallocated_block*ab);
intallocate(structfree_block_type*pre,structfree_block_type*allocate_free_nlock,structallocated_block*ab);
intmem_retrench(structallocated_block*ab);
//通过内存紧缩技术给新进程分配内存空间
intmem_retrench(structallocated_block*ab)
{
structallocated_block*allocated_work,*allocated_pre=allocated_block_head;
structfree_block_type*free_work,*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;
}
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);
return1;
}
//给新进程分配内存空间
intallocate(structfree_block_type*pre,structfree_block_type*allocate_free_block,structallocated_block*ab)
{
structallocated_block*p=allocated_block_head;
ab->start_addr=allocate_free_block->start_addr;
if(allocate_free_block->size-ab->size { ab->size=allocate_free_block->size; if(pre! =NULL) { pre->next=allocate_free_block; } else { free_block=allocate_free_block->next; } free(allocate_free_block); } else { allocate_free_block->start_addr+=ab->size; allocate_free_block->size-=ab->size; } if(p==NULL) { allocated_block_head=ab; } else { while(p->next! =NULL) p=p->next; p->next=ab; } current_free_mem_size-=ab->size; if(current_free_mem_size==0) free_block=NULL; return0; } //按照最坏适应算法给新进程分配内存空间 intallocate_WF(structallocated_block*ab) { intret; structfree_block_type*wf=free_block; if(wf==NULL) return-1; if(wf->size>=ab->size) allocate(NULL,wf,ab); elseif(current_free_mem_size>=ab->size) ret=mem_retrench(ab); else ret=-2; rearrange_WF(); returnret; } //按照最佳适应算法给新进程分配内存空间 intallocate_BF(structallocated_block*ab) { intret; structfree_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&¤t_free_mem_size>ab->size) ret=mem_retrench(ab); else ret=-2; rearrange_BF(); returnret; } //按照首次适应算法给新进程分配内存空间 intallocate_FF(structallocated_block*ab) { intret; structfree_block_type*pre=NULL,*ff=free_block; if(ff==NULL) return-1; while(ff! =NULL) { if(ff->size>=ab->size) { ret=allocate(pre,ff,ab); break; } pre=ff; pre=pre->next; } if(ff==NULL&¤t_free_mem_size>ab->size) ret=mem_retrench(ab); else ret=-2; rearrange_FF(); returnret; } //分配内存模块 intallocate_mem(structallocated_block*ab) { intret; structfree_block_type*fbt,*pre; intrequest_size=ab->size; fbt=pre=free_block; switch(ma_algorithm) { caseMA_FF: ret=allocate_FF(ab); break; caseMA_BF: ret=allocate_BF(ab); break; caseMA_WF: ret=allocate_WF(ab); break; default: break; } returnret; } //创建一个新的进程。 intnew_process() { structallocated_block*ab; intsize; intret; ab=(structallocated_block*)malloc(sizeof(structallocated_block)); if(! ab) exit(-5); ab->next=NULL; pid++; sprintf(ab->process_name,"PROCESS-%02d",pid);//sprintf()函数将格式化的数据写入某字符串中 ab->pid=pid; printf("Memoryfor%s: ",ab->process_name); for(;;) { scanf("%d",&size); getchar(); if(size>0) { ab->size=size; break; } else printf("Thesizehavetogreaterthanzero! Pleaseinputagain! "); } ret=allocate_mem(ab);//从空闲区分配内存,ret==1表示分配ok if((ret==1)&&(allocated_block_head==NULL))//如果此时allocated_block_head尚未赋值,则赋值 {//进程分配链表为空 allocated_block_head=ab; return1; } elseif(ret==1)//分配成功,将该已分配块的描述插入已分配链表 { ab->next=allocated_block_head;//头插法 allocated_block_head=ab; return2; } elseif(ret==-1)//分配不成功 { printf("Allocationfail\n"); free(ab); return-1; } return3; } //退出程序并释放内存空间。 intdo_exit() { structallocated_block*allocated_ab,*allocated_pre; structfree_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_pre); 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; return0; } //在进程分配链表中寻找指定进程。 structallocated_block*find_process(intpid) { structallocated_block*ab=allocated_block_head; if(ab==NULL) { printf("Here? ? ? ? ? ? 111111111\n"); returnNULL; } while(ab->pid! =pid&&ab->next! =NULL) ab=ab->next; if(ab->next==NULL&&ab->pid! =pid) { printf("Here? ? ? ? ? ? 2222222\n"); returnNULL; } returnab; } //显示当前内存的使用情况,包括空闲区的情况和已经分配的情况。 intdisplay_mem_usage() { structfree_block_type*fbt=free_block; structallocated_block*ab=allocated_block_head; printf("----------------------------------------------------------\n"); //显示空闲区 printf("FreeMemory: \n"); printf("%20s%20s\n","start_addr","size"); while(fbt! =NULL) { printf("%20d%20d\n",fbt->start_addr,fbt->size); fbt=fbt->next; } //显示已分配区 printf("\nUsedMemory: \n"); printf("%10s%20s%10s%10s\n","PID","ProcessName","start_addr","size"); while(ab! =NULL) { printf("%10d%20s%10d%10d\n",ab->pid,ab->process_name,ab->start_addr,ab->size); ab=ab->next; } printf("----------------------------------------------------------\n"); return1; } //释放ab数据结构节点。 intdispose(structallocated_block*free_ab) { structallocated_block*pre,*ab; if(free_block==NULL) return-1; if(free_ab==allocated_block_head)//如果要释放第一个节点 { allocated_block_head=allocated_block_head->next; free(free_ab); } else { pre=allocated_block_head; ab=allocated_block_head->next; //找到free_ab while(ab! =free_ab) { pre=ab; ab=ab->next; } pre->next=ab->next; free(ab); } return1; } /*将ab所表示的已分配区归还,并进行可能的合并*/ intfree_mem(structallocated_block*ab) { intalgorithm=ma_algorithm; structfree_block_type*fbt,*pre,*work; fbt=(structfree_block_type*)malloc(sizeof(structfree_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-
- 配套讲稿:
如PPT文件的首页显示word图标,表示该PPT已包含配套word讲稿。双击word图标可打开word文档。
- 特殊限制:
部分文档作品中含有的国旗、国徽等图片,仅作为作品整体效果示例展示,禁止商用。设计者仅对作品中独创性部分享有著作权。
- 关 键 词:
- 操作系统 实验 内存 分配