可变分区分配与回收——采用最坏算法操作系统课程设计.doc
在可变分区管理方式下采用最先适应算法实现主存储器的分配和回收。

..实验三、四存储管理一、实验目的帮助学生理解在不同的存储管理方式下应如何实现主存空间的分配和回收。
理解好的计算机系统不仅要有一个足够容量的、存取速度高的、稳定可靠的主存储器,而且要能够合理地分配和使用这些存储空间。
二、实验环境1、Java环境三、实验时数:4学时四、实验容与步骤1.在可变分区管理方式下采用最先适应算法实现主存储器的分配和回收。
2.在可变分区管理方式下采用最正确适应算法实现主存储器的分配和回收。
3.在可变分区管理方式下采用最坏适应算法实现主存储器的分配和回收。
要求:1。
分配时输入作业号以及申请量。
2.回收时输入作业号。
3.每次分配或回收之后按如下格式按照起始地址从小到大输出存分配情况。
五、实验报告实验题目。
1.在可变分区管理方式下采用最先适应算法实现主存储器的分配和回收。
1、2、程序中使用的数据构造及符合说明。
用Node 类模拟表示存的当前状态。
通过Node数组来开辟一组存,然后用Link类来进展存的连接3、程序流程图。
// Node.javaclass Node{//用Node来模拟存的当前状态int start;int size;boolean state;int jobNo;public Node(){}public Node(int start,int size,boolean state,int jobNo){this.start = start;this.size = size;this.state = state;this.jobNo = jobNo;}public void print(){//打印Node类if (this!=null){System.out.println("起始位置"+this.start+"大小"+this.size+"状态"+this.state+"工作号"+this.jobNo);}}};//Link.javaclass Link{ //用Link类来模拟连接各个存,并添加作业public void addJob(int size,int jobNo,Node a[]){for(int i=0;i<a.length;i++){if(a[i]!=null){ //当前存有容时if(size<a[i].size&&a[i].state==false){ //判断是否符合条件a[i].size=a[i].size-size; //当前存分配大小给作业if(a[i+1]==null){ //当下一块存还没有使用时a[i+1]=new Node(size+a[i].start,size,true,jobNo);//使用该存}else{ //当下一块存已被使用,那么继续寻找一块还没被使用的存for(int j=i+1;j<a.length-1;j++){if(a[j]==null){a[j]=new Node(size+a[j-1].start,size,true,jobNo);break; //当找到未被使用的存及填入容后跳出循环}}}}a[i].print();//打印输出当前Link中各个存块的使用情况}}}public void delete(Node a[],int jobNo){//删除某一个进程,当该进程被删除后,进程所在存的状态变为falsefor(int i=0;i<a.length;i++){if(a[i]!=null){if(a[i].jobNo==jobNo){//a[i].size=0;a[i].state=false;a[i].jobNo=0;}if(a[i]!=null){a[i].print();}}}}public void back(Node a[]){ //进展状态为false的存的回收删除存状态为false 的存节点。
计算机操作系统内存管理系统可变分区存储管理方式的内存分配回收

课程设计2 可变分区存储管理方式的内存分配回收一、课程设计目的深入了解采用可变分区存储管理方式的内存分配回收的实现。
二、预备知识存储管理中可变分区的管理方式。
三、小组成员四、课程设计内容编写程序完成可变分区存储管理方式的内存分配回收。
具体包括:确定内存空间分配表;采用最优适应算法完成内存空间的分配和回收;编写主函数对所做工作进行测试。
五、设计思路:整体思路:可变分区管理方式将内存除操作系统占用区域外的空间看做一个大的空闲区。
当作业要求装入内存时,根据作业需要内存空间的大小查询内存中的各个空闲区,当从内存空间中找到一个大于或等于该作业大小的内存空闲区时,选择其中一个空闲区,按作业需求量划出一个分区装人该作业,作业执行完后,其所占的内存分区被收回,成为一个空闲区。
如果该空闲区的相邻分区也是空闲区,则需要将相邻空闲区合并成一个空闲区。
设计所才用的算法:采用最优适应算法,每次为作业分配内存时,总是把既能满足要求、又是最小的空闲分区分配给作业。
但最优适应算法容易出现找到的一个分区可能只比作业所需求的长度略大一点的情行,这时,空闲区分割后剩下的空闲区就很小以致很难再使用,降低了内存的使用率。
为解决此问题,设定一个限值minsize,如果空闲区的大小减去作业需求长度得到的值小于等于minsize,不再将空闲区分成己分分区和空闲区两部分,而是将整个空闲区都分配给作业。
内存分配与回收所使用的结构体:为便于对内存的分配和回收,建立两张表记录内存的使用情况。
一张为记录作业占用分区的“内存分配表”,内容包括分区起始地址、长度、作业名/标志(为0时作为标志位表示空栏目);一张为记录空闲区的“空闲分区表”,内容包括分区起始地址、长度、标志(0表空栏目,1表未分配)。
两张表都采用顺序表形式。
关于分配留下的内存小碎片问题:当要装入一个作业时,从“空闲分区表”中查找标志为“1”(未分配)且满足作业所需内存大小的最小空闲区,若空闲区的大小与作业所需大小的差值小于或等于minsize,把该分区全部分配给作业,并把该空闲区的标志改为“0”(空栏目)。
操作系统课程设计

一、课程设计题目可变分区分配与回收--最佳适应算法1、课程设计题目分析1)动态分区分配它是连续分配方式之一,动态分区分配是根据进程的实际需要,动态地为之分配内存空间。
2)分区分配算法为把一个新作业装入内存,须按照一定的分配算法,从空闲分区表或空闲分区链中选出一分区分配给该作业。
目前常用的有以下五种分配算法。
①首次适应算法(first fit)②循环首次适应算法(next fit)③最佳适应算法(best fit)④最坏适应算法(worst fit)⑤快速适应算法(quick fit)3)最佳适应算法所谓“最佳”是指每次为作业分配内存是,宗总是把能满足要求、又是最小的空间分区分配给作业,避免“大材小用”。
为了加速寻找,该算法要求将所有的空闲分区按其容量以从小到大的顺序形成一空闲分区链。
但是,每次分配后所切割下来的剩余部分总是最小的,这样,在存储器中会留下许多难以利用的小空闲区。
4)可变分区的回收当进程运行完毕释放内存时,系统根据回收区的首址,从空闲区链(表)中找到相应的插入点,此时可能出现以下三种情况之一:①回收区与插入点的前一个空闲分区F1相邻接,见图(a)。
此时应将回收区与插入点的前一分区合并,不必为回收分区分配新表项,而只需修改其前一分区F1的大小②回收分区与插入点的后一空闲分区F2相邻接,见图(b)。
此时也可将两分区合并,形成新的空闲分区,但用回收区的首址作为新空闲区的首址,大小为两者之和。
③回收区同时与插入点的前、后两个分区邻接,见图(C)。
此时将三个分区合并,使用F1表项和F1的首址,取消F2的表项,大小为三者之和。
④回收区既不与F1邻接,又不与F2邻接。
这时应为回收区单独建立一新2、数据结构1) 空间抽象类:Area.javaclass Area {private int id; //空闲区域号private int value; //空闲区域大小public int getId() { //空闲区域号的获得方法return id;}public void setId(int id) { //空闲区域大小的设置this.id = id;}public int getValue() { //空闲区域大小的获得方法return value;}public void setValue(int value) { //空闲区域大小的设置this.value = value;}Area(int id) { //空闲区域类构造方法1 this.id = id;}Area(int id, int value) { //空闲区域类的构造方法2 this.id = id;this.value = value;}}2) 作业抽象类:Memory.javaclass Memory {private int id; //作业号private int value; //作业大小public int getId() { //作业号的获得方法return id;}public void setId(int id) { //作业号的设置this.id = id;}public int getValue() { //作业大小的获得方法return value;}public void setValue(int value) { //作业大小的设置this.value = value;}Memory(int id) { //作业类的构造方法1this.id = id;}Memory(int id, int value) { //作业类的构造方法2this.id = id;this.value = value;}}3、流程图最佳适应算法流程示意图见图3.14、开发环境1)开发环境安装Java开发工具--JDK安装包,设置环境变量2)开发工具下载Eclipse软件并安装,它是一个开源的基于Java的免费开发平台,是一个可视化的开发环境。
可变分区存储管理方式的内存分配和回收

free_quantity++; fscanf(文件指针,格式字符串,输入表列);}return 1;}return 0;}void sort(){int i,j,p;for(i=0;i<free_quantity-1;i++){p=i;for(j=i+1;j<free_quantity;j++){if(frees[j].address<frees[p].address){p=j;}}if(p!=i){frees[free_quantity]=frees[i];frees[i]=frees[p];frees[p]=frees[free_quantity];}}}void view(){int i;cout<<endl<<"mmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmm"<< endl;cout<<"输出空闲区表:\n起始地址分区长度状态\n"<<endl;for(i=0;i<free_quantity;i++){(2);(12);cout<<frees[i].address;(10);cout<<frees[i].length;(8);cout<<frees[i].tag<<endl;}cout<<endl<<"wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww"< <endl;cout<<"输出已分分区表:\n起始地址分区长度占用作业名\n"<<endl;for(i=0;i<occupy_quantity;i++){(2);(12);cout<<occupys[i].address;(10);cout<<occupys[i].length;(8);cout<<occupys[i].tag<<endl;}}void ear(){char job_name[10];int job_length;int i,j,flag,t;cout<<"请输入分配内存的作业名和空间大小:";cin>>job_name;cin>>job_length;flag=0;for(i=0;i<free_quantity;i++){ ength>=job_length){flag=1;}}if(flag==0){ ength>=job_length){ddress=frees[i].address; ag,job_name);occupys[occupy_quantity].length=job_length;occupy_quantity++;if(frees[i].length>job_length){frees[i].address+=job_length;frees[i].length-=job_length;}else{for(j=i;j<free_quantity-1;j++){frees[j]=frees[j+1];}free_quantity--;cout<<"内存空间成功:)"<<endl;}}}void reclaim()ag,job_name)){flag=i;address=occupys[i].address;length=occupys[i].length;}}if(flag==-1){ ddress+frees[i].length)==address){if(((i+1)<free_quantity)&&(frees[i+1].address==address+length)){frees[i].length=frees[i].length+frees[i+1].length+length;for(j=i+1;j<free_quantity;j++){frees[j]=frees[j+1];}free_quantity--;p=1;}else{frees[i].length+=length;p=1;}}if(frees[i].address==(address+length)){frees[i].address=address;frees[i].length+=length;p=1;}}if(p==0){frees[free_quantity].address=address;frees[free_quantity].length=length;free_quantity++;}ddress=-1;ength=0;strcpy(frees[i].tag,"free");occupys[i].address=-1;ength=0;strcpy(occupys[i].tag,"");}free_quantity=0;occupy_quantity=0;flag=read();while(flag==1){sort();cout<<"选择功能项: (0-退出,1-分配内存,2-回收内存,3-显示内存)\n"<<endl;cout<<"选择功项(0-3):";cin>>chioce;switch(chioce){case 0:flag=0;break;case 1:ear();break;case 2:reclaim();break;case 3:view();break;default:cout<<"没有该选项\n"<<endl;}}}。
操作系统-存储管理动态分区分配及回收算法(附源码)

存储管理动态分区分配及回收算法课程名称:计算机操作系统班级:信1501-2实验者姓名:李琛实验日期:2018年5月20日评分:教师签名:一、实验目的分区管理是应用较广泛的一种存储管理技术。
本实验要求用一种结构化高级语言构造分区描述器,编制动态分区分配算法和回收算法模拟程序,并讨论不同分配算法的特点.二、实验要求1、编写:First Fit Algorithm2、编写:Best Fit Algorithm3、编写:空闲区回收算法三、实验过程(一)主程序1、定义分区描述器node,包括3 个元素:(1)adr——分区首地址(2)size-—分区大小(3)next——指向下一个分区的指针2、定义3 个指向node 结构的指针变量:(1)head1—-空闲区队列首指针(2)back1-—指向释放区node 结构的指针(3)assign——指向申请的内存分区node 结构的指针3、定义1 个整形变量:free——用户申请存储区的大小(由用户键入)(二)过程1、定义check 过程,用于检查指定的释放块(由用户键入)的合法性2、定义assignment1 过程,实现First Fit Algorithm3、定义assignment2 过程,实现Best Fit Algorithm4、定义acceptment1 过程,实现First Fit Algorithm 的回收算法5、定义acceptment2 过程,实现Best Fit Algorithm 的回收算法6、定义print 过程,打印空闲区队列(三)执行程序首先申请一整块空闲区,其首址为0,大小为32767;然后,提示用户使用哪种分配算法,再提示是分配还是回收;分配时要求输入申请区的大小,回收时要求输入释放区的首址和大小。
实验代码Main。
cpp#include〈stdio。
h〉#include<stdlib。
h〉#include<string。
实验四可变分区存储管理方式的内存分配和回收

实验四实验四可变分区存储管理方式的内存分配和回收一.实验目的通过编写和调试存储管理的模拟程序以加深对存储管理方案的理解,熟悉可变分区存储管理的内存分配和回收。
二.实验属性设计三.实验内容1.确定内存空间分配表;2.采用最优适应算法完成内存空间的分配和回收;3.编写主函数对所做工作进行测试。
四.实验背景材料实现可变分区的分配和回收,主要考虑的问题有三个:第一,设计记录内存使用情况的数据表格,用来记录空闲区和作业占用的区域;第二,在设计的数据表格基础上设计内存分配算法;第三,在设计的数据表格基础上设计内存回收算法。
首先,考虑第一个问题,设计记录内存使用情况的数据表格,用来记录空间区和作业占用的区域。
由于可变分区的大小是由作业需求量决定的,故分区的长度是预先不固定的,且分区的个数也随内存分配和回收变动。
总之,所有分区情况随时可能发生变化,数据表格的设计必须和这个特点相适应。
由于分区长度不同,因此设计的表格应该包括分区在内存中的起始地址和长度。
由于分配时空闲区有时会变成两个分区:空闲区和已分分区,回收内存分区时,可能会合并空闲分区,这样如果整个内存采用一张表格记录己分分区和空闲区,就会使表格操作繁琐。
分配内存时查找空闲区进行分配,然后填写己分配区表,主要操作在空闲区;某个作业执行完后,将该分区变成空闲区,并将其与相邻的空闲区合并,主要操作也在空闲区。
由此可见,内存的分配和回收主要是对空闲区的操作。
这样为了便于对内存空间的分配和回收,就建立两张分区表记录内存使用情况,一张表格记录作业占用分区的“己分分区表”;一张是记录空闲区的“空闲区表”。
这两张表的实现方法一般有两种:一种是链表形式,一种是顺序表形式。
在实验中,采用顺序表形式,用数组模拟。
由于顺序表的长度必须提前固定,所以无论是“已分分区表”还是“空闲区表”都必须事先确定长度。
它们的长度必须是系统可能的最大项数。
“已分分区表”的结构定义#define n 10 //假定系统允许的最大作业数量为nstruct{ float address; //已分分区起始地址float length; //已分分区长度、单位为字节int flag; //已分分区表登记栏标志,“0”表示空栏目,实验中只支持一个字符的作业名}used_table[n]; //已分分区表“空闲区表”的结构定义#define m 10 //假定系统允许的空闲区最大为mstruct{ float address; //空闲区起始地址float length; //空闲区长度、单位为字节int flag; //空闲区表登记栏标志,“0”表示空栏目,“1”表示未分配}used_table[n]; //空闲区表第二,在设计的数据表格基础上设计内存分配。
可变分区分配与回收——采用最坏算法-操作系统课程设计

哈尔滨理工大学课程设计(操作系统)题目:可变分区分配与回收—采用最坏算法班级:计算机科学与技术学院计算机系10-8班姓名:张兢 1004010813指导教师:高雪瑶系主任:林克正2013年03月01日一、课程设计目的1、背景主存是CPU可直接访问的信息空间,合理而有效的使用贮存将在很大程度上影响整个计算机系统的性能。
本课题要求模拟实现分区式主存管理机制。
模拟实现各种分区管理方法以及相应的主存分配以及回收算法。
2、目的通过该课题进一步加深对可变分区存储机制的理解。
加深对存储器动态分区分配算法的认识。
掌握“首次适应算法”、“下次适应算法”、“最佳适应算法发”、“最坏适应算法”的内存分配过程。
掌握内存的回收策略。
二、课题任务描述1、设计可用的内存空闲空间,并能动态输入用户作业所需的内存大小。
2、编程模拟各种分配算法的实施过程,允许自行选择如“首次适应算法”、“下次适应算法”、“最佳适应算法发”、“最坏适应算法”等常用算法,要求实现不少于三种算法。
3、实现内存的回收。
要求考虑回收时的内存合并问题。
三、课题研发相关知识(包含所用库函数的介绍)1、首次适应算法(first fit)FF算法要求空闲分区链以地址递增的次序链接。
在分配内存时,从链首开始顺序查找,直至找到一个大小能男足要求的空闲分区位置;然后再按照作业的大小,从该分区中划出一块内存空间分配给请求者,余下的空闲分区仍留在空闲链中。
若从链首直至链尾都不能找到一个能满足要求的分区,则此次内存分配失败,返回。
但是,低址部分不断被划分,会留下许多难以利用的很小的空闲分区。
2、最佳适应算法(best fit)所谓“最佳”是指每次为作业分配内存时,总是把能满足要求、又是最小的空闲分区分配给作业,避免“大材小用”。
为了加速寻找,该算法要求将所有的空闲分区按其容量以从小到大的顺序形成一空闲分区链。
这样,第一次找到的能满足要求的空闲区,必然是最佳的。
这样,在存储器中会留下许多难以利用的小空闲区。
操作系统 可变分区分配与回收

#include<iostream>#include<stdlib.h>#define MAX_SIZE 10000#define BUSY 1#define FREE 0#define LIMIT_SIZE 100using namespace std;struct MemoryBlock{MemoryBlock *front,*next;long size;long addr;int PID;int state;}*head,*cur,*tmp;int PIDcnt;void init(){PIDcnt=0;head=new MemoryBlock;head->next=NULL;head->size=MAX_SIZE;head->addr=0;head->state=0;}void Redis(){cur=head;while(cur){if(cur->state==1){cur=cur->next;continue;}if(cur->next==NULL) break;MemoryBlock *n=cur;cur=cur->next;while(cur->state==1){cur=cur->next;} MemoryBlock *f=n;while(n!=cur){n=n->next;n->addr-=f->size;}cur->size+=f->size;if(f==head){head=f->next;}else{f->front->next=f->next;f->next->front=f->front;}delete f;}// Show();}void Show(){cur=head;int num=0;puts("---------------------------------------------------\n");cout<<"num "<<"addr "<<"size "<<"state "<<"PID "<<endl;while(cur!=NULL){printf("%-6d%-8d%-8d%-8d",++num,cur->addr,cur->size,cur->state);if(cur->state)cout<<cur->PID;cout<<endl;cur=cur->next;}puts("\n---------------------------------------------------\n");}void Alloc(){int flag=1;int u_size;cur=head;cout<<"please input the size:"<<endl;cin>>u_size;while((cur!=NULL)&&flag==1){if(cur->size<u_size||cur->state==1)cur=cur->next;else {if((cur->size-u_size)<LIMIT_SIZE){cur->state=1;cur->PID=++PIDcnt;flag=cur->addr;}else {MemoryBlock *tMB=new MemoryBlock;if(cur==head){head=tMB;}else{cur->front->next=tMB;tMB->front=cur->front;}cur->front=tMB;tMB->next=cur;tMB->addr=cur->addr;tMB->size=u_size;tMB->state=1;tMB->PID=++PIDcnt;cur->addr+=u_size;cur->size-=u_size;flag=tMB->addr;}}}if(flag==1){Redis();cur=head;while((cur!=NULL)&&flag==1){if(cur->size<u_size||cur->state==1)cur=cur->next;else {if((cur->size-u_size)<LIMIT_SIZE){cur->state=1;cur->PID=++PIDcnt;flag=cur->addr;}else {MemoryBlock *tMB=new MemoryBlock;if(cur==head){head=tMB;}else{cur->front->next=tMB;tMB->front=cur->front;}cur->front=tMB;tMB->next=cur;tMB->addr=cur->addr;tMB->size=u_size;tMB->state=1;tMB->PID=++PIDcnt;cur->addr+=u_size;cur->size-=u_size;flag=tMB->addr;}}}if(flag==1){puts("---------------------------------------\n");cout<<"failed,without enough memory!\n"<<endl;puts("---------------------------------------\n");}else {puts("---------------------------------------\n");cout<<"succeed,the memory block begin from "<<flag<<endl<<endl;puts("---------------------------------------\n");}}else {puts("---------------------------------------\n");cout<<"succeed,the memory block begin from "<<flag<<endl<<endl;puts("---------------------------------------\n");}}void Recycle(){int ID;int flag=1;cur=head;cout<<"please input the PID of the process you want to delete:";cin>>ID;while(flag&&cur){if(cur->state==1&&cur->PID==ID){if(cur!=head){if(cur->front->state==0){cur->front->size+=cur->size;cur->front->next=cur->next;cur->next->front=cur->front;tmp=cur;cur=cur->front;delete tmp;}}if(cur->next!=NULL){if(cur->next->state==0){cur->size+=cur->next->size;if(cur->next->next!=NULL)cur->next->next->front=cur;tmp=cur->next;cur->next=cur->next->next;delete tmp;}}cur->state=0;flag=0; }cur=cur->next;}if(flag==1){puts("---------------------------------------\n");cout<<"failed,without such process!\n"<<endl;puts("---------------------------------------\n");}else {puts("---------------------------------------\n");cout<<"succeed,process "<<ID<<" has been deleted"<<endl<<endl;puts("---------------------------------------\n");}}int main(){int i;char c;init();puts("___________welcome to Operating systen curriculum project___________\n");while(1){puts("1.Allocate memory\n");puts("2.Recycle memory\n");puts("3.Redistribut memory\n");puts("4.show the memory state\n");puts("0.exit\n");c=getchar();switch(c){case '1': Alloc();getchar();break;case '2':Recycle();getchar();break;case '3': Redis();getchar();break;case '4':Show();getchar();break;case '0':return 0;default:getchar();}}}。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
node->addr = tar->addr + size;
node->size = tar->size - size;
node->state = Free;
node->taskId = -1;
3、最坏适应算法(worst fit)
要扫描整个空闲分区表或链表,总是挑选一个最大的空闲区分割给作业使用,其优点是可使剩下的空闲区不至于太小,产生碎片的几率最小,对中小作业有力,查找效率很高。但是它会使存储器中缺乏大的空闲分区。
4、回收内存
当进程运行完毕释放内存时,系统根据会收取的首址,从空闲区链中找到相应的插入点,并考虑回收区前后是否有空闲分区,如果有,则把两个分区合并成一个大的空闲分区。
fir->pre = &subHead;
fir->nxt = NULL;
//初始化分区头部信息
subHead.pre = NULL;
subHead.nxt = fir;
}
//首次适应算法
int firstFit(int taskId, int size)
{ subAreaNode *p = subHead.nxt;
void intSubArea()
{//分配初始分区内存
subAreaNode *fir = (subAreaNode *)malloc(sizeof(subAreaNode));
//给首个分区赋值
fir->addr = 0;
fir->size = SIZE;
fir->state = Free;
fir->taskId = -1;
1、首次适应算法(first fit)
FF算法要求空闲分区链以地址递增的次序链接。在分配内存时,从链首开始顺序查找,直至找到一个大小能男足要求的空闲分区位置;然后再按照作业的大小,从该分区中划出一块内存空间分配给请求者,余下的空闲分区仍留在空闲链中。若从链首直至链尾都不能找到一个能满足要求的分区,则此次内存分配失败,返回。但是,低址部分不断被划分,会留下许多难以利用的很小的空闲分区。
(3)函数
1)void intSubArea():分配初始分区内存。
2)int firstFit(int taskId, int size):首次适应算法实现函数,taskId为作业名,size为作业申请的内存大小。
3)int bestFit(int taskId, int size):最佳适应算法实现函数,taskId为作业名,size为作业申请的内存大小。
5、库函数的介绍
1)stdio就是指“standard buffered input&output"意思就是说带缓冲的标准输入输出!所以了,用到标准输入输出函数时,就要调用这个头文件!
2)Stdlib.h即standard library 标准库文件。Stdlib头文件里包含了C,C++语言的最常用的系统函数。Stdlib.h里面定义了五中类型,一些宏和通用工具函数。 类型例如:size_t ,wchar_t, div_t, ldiv_t,lldiv_t; 宏例如:EXIT_FALIRE,EXIT_SUCCESS,RAND_MAX和MB_CUR_MAX。
1、设计可用的内存空闲空间,并能动态输入用户作业所需的内存大小。
2、编程模拟各种分配算法的实施过程,允许自行选择如“首次适应算法”、“下次适应算法”、“最佳适应算法发”、“最坏适应算法”等常用算法,要求实现不少于三种算法。
3、实现内存的回收。要求考虑回收时的内存合并问题。
三、课题研发相关知识 (包含所用库函数的介绍)
int tarSize = SIZE + 1;
subAreaNode *p = subHead.nxt;
while(p != NULL)
{ //寻找最佳空闲区间
if(p->state == Free && p->size >= size && p->size < tarSize) {
tar = p;
struct subAreaNode {
int addr; //起始地址
int size; //分区大小
int taskId; //作业号
STATE state; //分区状态
subAreaNode *pre; //分区前向指针
subAreaNode *nxt; //分区后向指针
}subHead;
//初始化空闲分区链
(3)最坏适应算法Worst_fit(int,int);流程图(图5)
4.程序的技术路线
本程序采用C语言编写,在windows下的Visual C++中编译,模拟可变分区存储管理方式的内存分配与回收。假定系统的最大内存空间为1000kb,判断是否划分空闲区的最小限值为MINSIZE=5。初始化用户可占用内存区的首地址为0,大小为0B。定义一个结构体及其对象subHead实现内存的分配回收及分配表和空闲表的登记。用最佳分配算法实现动态分配时,调用int bestFit(int taskId, int size)内存分配函数,设定循环条件查找最佳空闲分区,根据找到的空闲区大小和作业大小判断是整个分配给作业还是切割空闲区后再分配给作业,并在“内存分配表”和“空闲分区表”中作登记。调用int freeSubArea(int taskId)函数实现内存的回收。顺序循环“内存分配表”找到要回收的作业,设置标志位flag,当flag=1时表示回收成功。回收内存时需考虑内存的4种合并方式,即合并上下分区、合并上分区、合并下分区、上下分区都不合并。
本课题要求模拟实现分区式主存管理机制。模拟实现各种分区管理方法以及相应的主存分配以及回收算法。
2、目的
通过该课题进一步加深对可变分区存储机制的理解。加深对存储器动态分区分配算法的认识。掌握“首次适应算法”、“下次适应算法”、“最佳适应算法发”、“最坏适应算法”的内存分配过程。掌握内存的回收策略。
二、课题任务描述
6)void showSubArea():显示空闲分区链情况。包括起始地址 ,空间大小 。工作状态 。作业号。
7)int main():主函数,主要用于显示操作界面,调用各个子函数等功能。
3、主要功能的流程图
(1)首次适应算法First_fit(int,int);流程图(图3)
(2)最佳适应算法Best_fit(int,int);流程图(图4)
tar->taskId = taskId;
}
printf("内存分配成功!\n");
return 1;
} else {
//找不到合适的空闲分区
printf("找不到合适的内存分区,分配失败...\n");
return 0;
}
}
int worstFit(int taskId, int size)
{
subAreaNode *tar = NULL;
五、带有详细注解的源程序
#include<stdio.h>
#include<time.h>
#include<stdlib.h>
#define SIZE 1000 //内存初始大小
#define MINSIZE 5 //碎片最小值
enum STATE { Free, Busy };
static int ss=0,ee=0;
2、最佳适应算法(best fit)
所谓“最佳”是指每次为作业分配内存时,总是把能满足要求、又是最小的空闲分区分配给作业,避免“大材小用”。为了加速寻找,该算法要求将所有的空闲分区按其容量以从小到大的顺序形成一空闲分区链。这样,第一次找到的能满足要求的空闲区,必然是最佳的。这样,在存储器中会留下许多难以利用的小空闲区。
tarSize = p->size;
}
p = p->nxt;
}
if(tar != NULL) {
//找到要分配的空闲分区
if(tar->size - size <= MINSIZE) {
//整块分配
tar->state = Busy;
tar->task的区间
//修改分区链节点指针
node->pre = tar;
node->nxt = tar->nxt;
if(tar->nxt != NULL) {
tar->nxt->pre = node;
}
tar->nxt = node;
//分配空闲区间
tar->size = size;
tar->state = Busy;
以下是一些常用的函数:dec 置基数为10 相当于"%d";hex 置基数为16 相当于"%X";oct 置基数为8 相当于"%o";setw(n) 设域宽为n个字符
四、课题设计:总体结构、所使用的数据结构、主要功能的流程图、程序的技术路线
1、总体结构
本系统采用了首次适应算法、最佳适应算法和最坏适应算法模拟存储器动态分区。系统利用其中某种分配算法,从空闲分区链中找到满足请求内存大小的分区并分配内存给作业。假设总的内存大小为size,作业请求的内存大小为request,内存碎片最小为f。当request>size时,内存溢出,出现系统错误;当request<=size时,在内存中根据上述算法寻找最佳的内存分区分配给作业。寻找到合适的内存分区之后,如果size-request<=f,将此分区上的内存全部分配给作业;如果size-request>f,就在此分区上分割request大小的内存给作业,剩余内存继续留在当前的分区中。当进程运行完毕,系统找到该进程并释放其内存,根据所释放内存的位置对内存进行合并。