操作系统课程设计--连续动态分区内存管理模拟实现

合集下载

操作系统内存管理模拟系统的实现

操作系统内存管理模拟系统的实现

摘要操作系统的内存管理是指系统软件对其他应用程序使用内存时所作的管理,是一种统筹关系。

本设计采用活动分区方案,但不采用紧凑算法。

假设系统内存容量为100KB。

能处理内存回收的时候上下邻合并的问题;对随机出现的进程i申请jKB内存,程序能判断是否能分配;释放随机的首地址为Handle 的内存块;同时输出内存使用情况和空闲情况。

关键字:内存资源;分配;存储管理;回收目录1 概述 (5)1.1设计任务 (5)1.2 设计思想 (5)1.3 基础知识 (5)2 各模块伪码算法 (6)2.1主程序 (7)2.2 创建进程模块 (8)2.3 进程信息模块 (9)2.4 进程申请模块 (10)2.5 分区创建模块 (11)2.6 内存分配模块 (12)2.7 低级调度模块 (14)3函数关系调用图 (15)4测试结果 (16)4.1 主界面调试结果 (16)4.2 创建进程调试结果 (17)4.3 进程信息调试结果 (17)4.4 进程申请调试结果 (18)4.5 分区创建调试结果 (19)4.6 内存分配调试结果 (20)4.7 内存回收调试结果 (21)4.8 打印分区调试结果 (22)4.9 低级调度调试结果 (23)5源程序 (24)6总结 (45)参考文献 (46)致谢 (47)摘要操作系统的内存管理是指系统软件对其他应用程序使用内存时所作的管理,是一种统筹关系。

本设计采用活动分区方案,但不采用紧凑算法。

假设系统内存容量为100KB。

能处理内存回收的时候上下邻合并的问题;对随机出现的进程i申请jKB内存,程序能判断是否能分配;释放随机的首地址为Handle 的内存块;同时输出内存使用情况和空闲情况。

关键字:内存资源;分配;存储管理;回收1 概述1.1设计任务应用内存管理实现内存管理的分配和回收。

能处理内存回收的时候上下邻合并的问题以及输出内存使用情况和空闲情况。

采用活动分区方案,但不采用紧凑算法。

假设系统内存容量为100KB。

动态内存分区分配方式模拟

动态内存分区分配方式模拟

“计算机操作系统”课程设计实验报告动态内存分区分配方式模拟学生姓名专业名称学号目录1 题目要求 (1)2 设计思想 (1)3 数据定义 (2)4 处理流程 (3)5 源程序 (6)6 运行结果 (15)7 设计体会 (22)动态内存分区分配方式模拟1题目要求假设初始态下,可用内存空间为640K,并有下列请求序列,请分别用首次适应算法和最佳适应算法为作业分配和回收内存块,并显示出每次分配和回收后的空闲分区链的情况来以及内存占用情况图。

作业1申请130K作业2申请60K作业3申请100k作业2释放60K作业4申请200K作业3释放100K作业1释放130K作业5申请140K作业6申请60K作业7申请50K作业6释放60K2设计思想根据题目要求,要用首次适应算法和最佳适应算法分别实现内存的动态分区,因此先介绍一下这两种算法的基本思想:首次适应算法中,空闲分区链是按地址递增的次序链接的,当要分配内存空间时,就查表,在各空闲分区中查找满足大小要求的可用块,只要找到第一个足以满足要求的空间就停止查找,并把它分配出去,如果该空闲空间与所需空间大小一样,则将该分区的状态改为1,即已被分配,若还有剩余,则将剩余空间重新划为一个空闲分区,有新的起始地址,状态为0。

最佳适应算法的空闲链是按照空闲块的大小为序、按增量方式排列的,即小块在前,大块在后,它在满足需要的前提下,尽量分配最小的空闲块,这样每次查找分配时第一次找到的能满足要求的必然的最佳的,若空闲空间大小与要分配的大小相差不多时,可直接将其状态改为1即可,若有剩余,则将剩余空闲空间重新划分为一个空闲区,并根据空闲区的大小对链表进行重新排序。

首次适应算法的回收过程相对简单,因为分区链是按照地址顺序链接的,因此释放内存时只需要判断要释放的分区前后是否也为空闲区,然后根据情况看是要跟前边或后边或前后都合并为一个大的空闲区,如果前后分区都已分配,则直接将该分区状态改为0即可。

操作系统课程设计动态分区分配存储管理

操作系统课程设计动态分区分配存储管理

操作系统课程设计动态分区分配存储管理操作系统课程设计动态分区分配存储管理吕霆计算机10-01班设计题⽬学号专业班级学⽣姓名指导教师第⼀章课程设计概述1.1 设计任务:动态分区分配存储管理1.2 设计要求建⽴描述内存分配状况的数据结构;建⽴描述进程的数据结构;使⽤两种⽅式产⽣进程:(a)⾃动产⽣,(b)⼿⼯输⼊;在屏幕上显⽰内存的分配状况、每个进程的执⾏情况;建⽴分区的分配与回收算法,⽀持紧凑算法;时间的流逝可⽤下⾯⼏种⽅法模拟:(a)按键盘,每按⼀次可认为过⼀个时间单位;(b) 响应WM_TIMER;将⼀批进程的执⾏情况存⼊磁盘⽂件,以后可以读出并重放;⽀持算法:⾸次适应算法、循环⾸次适应算法、最佳适应算法:最坏适应算法。

1.3 设计⽬的旨在让我们更好的了解动态分区管理⽅⾯的知识.第⼆章原理及算法描述2.1动态分区分配算法原理⾸次适应算法* 算法概述:分配内存时,从链⾸开始顺序查找,找到满⾜的空闲分区则划出空间分配,余下的空闲空间仍保留在空闲链表中* 实现⽅法:分配时从数组第⼀个元素开始⽐较,若符合条件则将该元素减去对应作业的值循环⾸次适应算法* 算法概述:由⾸次适应算法演变,只是每次分配改为由上⼀次找到的空闲分区开始查找* 实现⽅法:在⾸次适应算法的基础上增加⼀个值⽤于记录找到的空闲分区的位置最佳适应算法* 算法概述:每次为作业分配内存时,总是把能满⾜要求、⼜是最⼩的空闲分区最坏适应算法* 算法概述:每次为作业分配内存时,总是挑选⼀个最⼤的空闲分区分割给作业使⽤* 实现⽅法:算法与最佳适应算法⼏乎相同,仅在排序时把空闲分区表按从⼤到⼩的顺序排列,所以未作详细注释回收分区当进程运⾏完毕释放内存时,系统根据回收区的⾸址,从空闲区链(表)中找到相应的插⼊点,此时可能出现以下四种情况之⼀;1)回收区与插⼊点的前⼀个空闲分区F1相邻接,此时应将回收区与插⼊点的前⼀分区合并,不必为回收区分配新表项,⽽只需修改其前⼀分区F1的⼤⼩.2)回收分区与插⼊点的后⼀空闲分区F2相邻接,此时也可将两分区合并,形成新的空闲分区,但⽤回收区的⾸址作为新空闲区的⾸址,⼤⼩为两者之和.3)回收区同时与插⼊点的前,后两个分区邻接,此时将三个分区合并,使⽤F1的表项和F1的⾸址,取消F2的表项,⼤⼩为三者之和.4)回收区既不与F1相邻接,⼜不与F2邻接.这时应为回收区单独建⽴⼀新表项,填写回收区的⾸址和⼤⼩,并根据其⾸址插⼊到空闲链中的适当位置.紧凑算法通过移动内存中的作业的位置,以把原来多个分散的⼩分区拼接成⼀个⼤分区的⽅法.第三章开发环境此程序是本⼈利⽤c++语⾔在vs2012的开发环境中实现的第四章程序实现--数据结构#include#include#includeusing namespace std;ofstream stream;//输出流对象int ary1[20][4];//内存分配状态int ary2[20][3];//空闲分区状态int ary3[10];//进程分配状态int id1;//算法选择号int m;//内存区数int n;//空闲区数int q;//进程数int r=0;//循环⾸次适应算法:对应的这次查找到的空闲分区序号//打印输出函数void vision()if(id1==1)stream.open("first_fit.txt", ios::app);if(id1==2)stream.open("nextfirst_fit.txt", ios::app); if(id1==3)stream.open("best_fit.txt",ios::app);if(id1==4)stream.open("worst_fit.txt", ios::app); if(id1==5)stream.open("compact.txt",ios::app);if(id1==6)stream.open("huishou.txt",ios::app); cout<<"-------------内存分配状态-------------"<cout<<"分区号⼤⼩/KB 始址/KB 状态"< stream<<"-------------内存分配状态-------------"< stream<<"分区号⼤⼩/KB 始址/KB 状态"<for(j=0;j{cout <stream<cout <stream<cout <stream<if(ary1[j][3]==2){cout<<"已分配";stream<<"已分配";}else{cout<<"未分配";stream<<"未分配";}cout <stream<}cout <cout<<"--------空闲分区链--------"<cout<<"分区号⼤⼩/KB 起址/KB"<stream<<"--------空闲分区链--------"<cout<stream<cout<stream<cout<stream<}cout<<"--------------------------"< stream<<"--------------------------"< cout<stream.close();}//作业信息的⾃动产⽣void create_pro(){int i;for(i=0;i{ary3[i]=rand()%100;if(ary3[i]==0){i--;}}ary3[0]=42;ary3[1]=86;cout<<"产⽣"<cout<<"⼤⼩分别是:";for(i=0;icout<<"["<}cout <}int id3=rand()%10;m=id3;//内存区数量cin>>choice2;q=choice2;cout<<"输⼊想创建的作业请求⼤⼩"< for(int i=0;i{cin>>j;ary3[i]=j;}cout<<"你创建了"<for(int i=0;icout<}cout<}//内存信息的⾃动产⽣void create_apply(){int i;for (i=0;i{ary1[i][0]=i+1;ary1[i][1]=rand()%100;if(i==0)ary1[i][2]=0;else{ary1[i][2]=ary1[i-1][2]+ary1[i-1][1];}ary1[i][3]=rand()%3;}int k=0;//空闲区数量for (i=0;i{if(ary1[i][3]!=2){ary2[k][0]=ary1[i][0];ary2[k][1]=ary1[i][1];ary2[k][2]=ary1[i][2];k++;}n=k;//空闲块数量}//内存信息的⼿动⽣成int create_fenqu(){int k,x,y,o=0;int a=0;cout<<"输⼊想创建的内存分区块数 : " ; cin>>k;cout<<"输⼊"<for(int i=0;iary1[i][0]=i; //序号cin>>x;ary1[i][1]=x;//⼤⼩}cout<<"输⼊内存块的分配状态"<for(int i=0;icin>>y;if(y==2){n++;}ary1[i][3]=y;//状态}for(int i=2;iary1[i][2]=ary1[i-1][2]+ary1[i-1][1];//起始地址}m=k;for (int i=0;i{if(ary1[i][3]!=2){ary2[a][0]=ary1[i][0];ary2[a][1]=ary1[i][1];ary2[a][2]=ary1[i][2];a++;}}n=a;return m,n;}//⾸次适应算法void first_fit()vision();int i;int j;int k;int l;int d;//⽤来保存第k个的值int id2=0;for(i=0;i{for(j=0;j{if(ary2[j][1]>=ary3[i])//进程占⽤空间⼩于等于其中⼀个空闲区的⼤⼩{cout<<"["<stream.open("first_fit.txt", ios::app);stream<<"["<{ary1[ary2[j][0]-1][3]=2;for(k=j+1;k{ary2[k-1][0]=ary2[k][0];ary2[k-1][1]=ary2[k][1];ary2[k-1][2]=ary2[k][2];}n--;}else//否则的话,空闲链对应的地⽅盘块⼤⼩⼩了进程占⽤的⼤⼩,并且内存分配从对应的那⼀项开始增加⼀项{l=ary2[j][0];d=ary1[l-1][1];//⼤⼩ary1[l-1][1]=ary3[i];ary1[l-1][3]=2;m++;for(k=m;k>ary2[j][0]+1;k--){ary1[k-1][0]=ary1[k-2][0]+1;ary1[k-1][1]=ary1[k-2][1];ary1[k-1][2]=ary1[k-2][2];ary1[k-1][3]=ary1[k-2][3];}l=ary2[j][0];ary1[l][1]=d-ary3[i];ary1[l][2]=ary1[l-1][1]+ary1[l-1][2];ary1[l][3]=0;k=0;for(id2=0;id2{if(ary1[id2][3]!=2){ary2[k][0]=ary1[id2][0];k++;}}n=k;}break;}else{cout<<"["<stream.open("first_fit.txt", ios::app); stream<<"["<stream.close();}}vision();}}//⾸次循环适应算法void next_fit(){vision();int i;int j;int k;int s;int d;int id2;for(i=0;ifor(j=r;j{if(ary3[i]<=ary2[j][1]){stream<<"["<stream.close();if(ary3[i]==ary2[j][1]){//---改变内存分配---k=ary2[j][0];//得到对应空闲块对应内存块的序号k--;ary1[k][3]=2;//把对应内存块标志位上改成已分配//------------------//--改变空闲块表:把从这块空闲块以下的所有空闲块向上移⼀格--n--;for(k=j;k{ary2[k][0]=ary2[k+1][0];ary2[k][1]=ary2[k+1][1];ary2[k][2]=ary2[k+1][2];}vision();//------------------break;}else//对应的空闲块⼤⼩⼤于进程需要⼤⼩{//-----改变内存分配情况-----r=(r+1)%n;//改变第k块的内容k=ary2[j][0];d=ary1[k-1][1];ary1[k-1][1]=ary3[i];ary1[k-1][3]=2;//从k+1之后所有向后移⼀格m++;//内存块数增加1for(s=m-1;s>k;s--)ary1[s][1]=ary1[s-1][1];ary1[s][2]=ary1[s-1][2];}//改变第k+1块内容:对应的数组是ary1[k] ary1[k][0]=ary1[k-1][0]+1;ary1[k][1]=d-ary1[k-1][1];ary1[k][2]=ary1[k-1][1]+ary1[k-1][2];//--------------------------//----改变空闲表分配情况----k=0;for(id2=0;id2{if(ary1[id2][3]!=2){ary2[k][0]=ary1[id2][0];ary2[k][1]=ary1[id2][1];ary2[k][2]=ary1[id2][2];k++;}}n=k;//--------------------------vision();break;}}else{cout<<"["<stream.open("nextfirst_fit.txt", ios::app); stream<<"["<stream.close();}}}//思路:先把空闲列表检索⼀遍,选出最佳答案,进⾏分配void best_fit()//最佳算法--按顺序检索,把与进程要求内存⼤⼩最接近的快分配给进程{ int i;int s;int j=-9999;//⽤来保存最接近的答案int e;//⽤来存放进⾏⽐较时的中间结果int l;int d;int id2;vision();for(i=0;i{ e=9999;j=-9999;for(s=0;s{if((ary2[s][1]>=ary3[i])&&(e>ary2[s][1]))//满⾜分配要求{e=ary2[s][1];j=s;}}if(j<0){cout<<"["<stream.open("best_fit.txt", ios::app);stream<<"["<stream.close();}else{cout<<"["<stream.open("best_fit.txt", ios::app);stream<<"["<stream.close();if(ary2[j][1]==ary3[i])k=ary2[j][0];ary1[k-1][3]=2;for(l=k;l{ary2[l-1][0]=ary2[l][0]; ary2[l-1][1]=ary2[l][1]; ary2[l-1][2]=ary2[l][2]; }n--;}else。

操作系统课程设计实验报告内存的持续分派算法

操作系统课程设计实验报告内存的持续分派算法

组号成绩运算机操作系统课程设计报告题目内存的持续分派算法专业:运算机科学与技术班级:学号姓名:指导教师:2016年12月26 日一、设计目的把握内存的里联系分派方式的各类算法。

二、设计内容本系统模拟操作系统内存分派算法的实现,实现可重定位分区分派算法,采纳PCB概念结构体来表示一个进程,概念了进程的名称和大小,进程内存起始地址和进程状态。

内存分区表用空闲分区表的形式来模拟实现。

三、设计原理动态分区的实现是依照进程所申请的内存大小来决定动态的由系统进行分派内存空间大小,因此分区内外的空闲分区个数是不定的,依照进程数和进程大小决定的。

可重定位分区算法比动态分区算法增加了紧凑的功能。

四、详细设计及编码1、模块分析该实验可分为三大部份,每一部份又由个数不同的几个函数实现。

第一部份是装入作业,第二部份是内存回收,第三部份是进行紧凑。

装入作业的时候第一初始化一个链表,依照用户输入的操作代号进行相应的操作。

假设用户选择装入作业第一判定空闲分区内外有无比作业需要的内存大的分区,假设有直接分派,假设没有进行紧凑操作,再将紧凑后的空闲分区与作业大小比较,假设能装的下那么分派给作业,假设是进行紧凑后的空闲分区仍不能装入整个作业那么通知用户内存不够。

2、流程图2、 代码实现 检索空闲分区链进行紧凑形成连空闲分区总N Y N找到>的分无法分请求分配修改有关的数据进行紧凑形成连按动态分区方式Y 返回分区号及首址#include<>#include<>#include<>#include<>#define TURE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1#define OVERFLOW -2#define SIZE 3StartAddr>pList[j+1].pStartAddr){temp=pList[j];pList[j]=pList[j+1];pList[j+1]=temp;}}}}void compact(LinkList &L,struct PCB *pList){StartAddr=0; StartAddr=pList[i].pStartAddr+pList[i].pOccupy;}StartAddr+pList[pLength-1].pOccupy;s->areaSize=sumEmpty;ListInsert(L,s);No;delPSize=pList[index-1].pSize;delPOccupy=pList[index-1].pOccupy;delPStartAddr=pList[index-1].pStartAddr;StartAddr,pList[i].pOccupy,pList[i].pNo);}}void distribute(LinkList &L,struct PCB *process){LinkList p=L->next;while(p!=NULL){if(p->areaSize>=process->pSize)break;p=p->next;}//printf("%d KB < %dKB",process->pSize,p->areaSize);////////////////////if(p->areaSize-process->pSize<=SIZE){//不用分割全数分派(直接删除此空闲分区结点)process->pStartAddr=p->aStartAddr; //进程始址转变process->pState=1; //进程状态process->pOccupy=p->areaSize; //进程实际占用内存为改空闲分区的大小pList[pLength++]= *process; //把进程加入进程列表pSort(pList);pListPrint(pList);//输出内存中空间占用情形DeleteElem(L,p->aStartAddr);}else{//分割分派process->pStartAddr=p->aStartAddr; //进程始址转变process->pState=1; //进程状态process->pOccupy=process->pSize; //进程实际占用内存为该进程的大小pList[pLength++]= *process; //把进程加入进程列表pSort(pList); //进程排序pListPrint(pList);//输出内存中空间占用情形p->aStartAddr+=process->pSize; //空闲分区始址转变p->areaSize-=process->pOccupy; //空闲分区大小转变}}///////////////////////////////////////////////////////int main(){struct PCB p;int i,num,dele,k,stAddr,flag;LinkList s,L;if(!InitList(L)) //初始化空闲分区表printf("创建表失败\n");while(1){printf("请选择要进行的操作(1:装入;2:回收)");int flag;scanf("%d",&flag);if(flag==1){creatP(&p);//初始化进程//printf("______________________________________________________________________ __________");printf("待装入作业:%d Size = %d KB\n",,;//1、请求分派size//2、检索空闲分区表(第一次适应FF)//PrintList(L);stAddr=search(L,;//取得足够大的分区的始址,没有那么返回-1 if(stAddr==-1){//没有足够大的分区if(add(L)>={//空闲区总和足够大// printf("没有足够大的空闲分区但空闲总和足够大\n");//紧凑compact(L,pList);//按动态分区方式分派distribute(L,&p);PrintList(L);//compact(L,pList); //紧凑}else{ //空闲区总和不足printf("分派失败\n\n");}}else{//有足够大的distribute(L,&p);PrintList(L);//compact(L,pList); //紧凑}}else{//回收if(pLength>0){recycle(L,pList);//compact(L,pList); //紧凑}else{printf("无可回收内存!");}}//system("pause");// scanf("%d")} //whilereturn 0;}四、结果及其相关分析结果分析:持续进行4次装入的操作后内存中还剩30K的空间,接着进行一次回收内存的操作,回收作业1后不持续的空闲内存共有50K,接着再装入一个35K的作业,分散的两个分区都不能装入作业,可是总和能够装入,因此先进行紧凑再分派,从头分派后还剩15K 的内存。

c++动态分区分配算法模拟(操作系统课程设计)

c++动态分区分配算法模拟(操作系统课程设计)

学习操作系统和计算机网 络,了解计算机系统的工 作原理
参加编程比赛和项目实践, 提高解决问题的能力
关注行业动态和技术发展, 不断学习新知识和技能
感谢您的观看
汇报人:
算法性能评估
时间复杂度:O(n)
空间复杂度:O(1)
稳定性:稳定
适用场景:适用于动态分 区分配问题
模拟结果总结与反思
模拟结果:动态分区分配算法的性能表现 优点:提高了内存利用率,减少了内存碎片 缺点:增加了内存管理开销,可能导致内存碎片 改进方向:优化内存管理算法,提高内存利用率和性能
05 课程设计总结与展望优化目标Leabharlann 提高 算法的执行效率 和内存利用率
优化策略:采用 动态调整分区大 小、优化内存分 配策略等方法
优化效果:通过 优化,可以提高 算法的执行效率 和内存利用率, 降低内存碎片率, 提高系统的稳定 性和可靠性。
04 模拟结果分析
内存分配情况统计
内存分配次数:统 计模拟过程中内存 分配的次数
确定分区大小和数量
确定分区大小:根据需求确定分区大小,如1KB、2KB等 确定分区数量:根据需求确定分区数量,如10个、20个等 分区分配策略:采用最佳适应算法、最坏适应算法、首次适应算法等 分区合并策略:采用分区合并算法,如合并空闲分区、合并相邻空闲分区等
实现分区分配算法
初始化:设置分区表,记录每个分区的状态和位置 分配:根据请求大小,查找合适的分区 合并:将相邻的空闲分区合并为一个大分区 分割:将大分区分割为多个小分区 回收:释放不再使用的分区,将其加入空闲分区列表 维护:定期整理分区表,保持分区信息的准确性
实现内存回收函数
内存回收函数的作用:释放不再使用的内存空间,提高内存利用率 内存回收函数的实现:通过遍历内存块链表,找到空闲内存块,将其添加到空闲链表中 内存回收函数的调用:在程序运行过程中,当需要释放内存时,调用内存回收函数 内存回收函数的优化:通过改进算法,提高内存回收的效率和准确性

计算机操作系统课程设计报告《存储管理——动态分区分配算法的模拟》

计算机操作系统课程设计报告《存储管理——动态分区分配算法的模拟》

《计算机操作系统》课程设计题目:—存储管理一一动态分区分配算法的模拟 _专业: _________ 软件工程_______________年级: __________ 2012级 ___________小组成员:_____________________________ 指导教师:______________________________ 时间:________________________________地点:________________________________2012年5月目录目录 (1)概述 (3)2. ................................................................................................................................ 课程设计任务及要求. (3)2.1 设计任务 (3)2.2 设计要求 (3)2.3 课程设计任务安排 (3)3. 算法及数据结构 (4)3.1 算法的总体思想(流程) (4)3.2 首次适应算法 (4)3.2.1 功能 (4)3.2.2 数据结构(包括变量的定义,要注释!) (4)323算法(流程图表示,或伪C表示) (5)3.3 循环首次适应算法 (6)3.3.1 功能 (6)3.3.2 数据结构 (6)3.3.3 算法 (7)3.4 最佳适应算法 (8)3.4.1 功能 (8)3.4.2 数据结构 (8)3.4.3 算法 (8)3.5 最坏适应算法 (10)3.5.1 功能 (10)3.5.2 数据结构 (10)3.5.3 算法 (11)4. 程序设计与实现 (12)4.1 程序流程图 (12)4.2 程序代码(要注释) (12)4.3 实验结果 (21)5. 结论 (23)6. 收获、体会和建议。

(23)A的总结: (23)B的总结: (23)7. 参考文献。

OS课程设计模拟内存分配算法MFC实现

OS课程设计模拟内存分配算法MFC实现

课程设计报告设计题目:内存的连续分配算法班级: 1003学号:211011023姓名:指导老师:设计时间:2012年8月摘要1、主要算法包括:固定分区分配、动态分区分配、伙伴算法、可重定位分区分配。

2、内容要求:1)定义与算法相关的数据结构,如PCB,空闲分区表;2)至少实现两种以上分配算法,且用户可以选择在某次执行过程中使用何种算法;3)在使用动态分区分配或可重定位分区分配算法时必须实现紧凑和对换功能;4)动态分区分配和可重定位分区分配必选一个实现。

本系统模拟了操作系统内存分配算法的实现,实现了固定分区分配和动态分区分配,以及可重定位分区分配算法,采用PCB 定义结构体来表示一个进程,定义了进程的名称和大小,进程内存起始地址和进程状态。

内存分区表采用单链表来模拟实现。

关键词:固定分区分配、动态分区分配、可重定位分区分配。

目录1. 概述 (4)2. 课程设计任务及要求2.1 设计任务 (4)2.2 设计要求 (4)3. 算法及数据结构3.1算法的总体思想(流程) (5)3.2 PCB模块3.2.1 功能(运算) (5)3.2.2 数据结构(存储结构) (5)3.2.3 算法(实现) (5)3.3 进程队列模块3.3.1功能 (6)3.3.2 数据结构 (6)3.3.3算法 (6)4. 程序设计与实现4.1 程序流程图 (7)4.2 程序说明(代码)4.3 实验结果 (9)5. 结论 (10)6. 参考文献。

(10)7. 收获、体会和建议。

(10)一:概述本系统模拟了操作系统内存分配算法的实现,实现了固定分区分配和动态分区分配,以及可重定位分区分配算法,采用PCB定义结构体来表示一个进程,定义了进程的名称和大小,进程内存起始地址和进程状态。

内存分区表采用单链表来模拟实现。

固定分区实现就是将单链表的每个节点的大小设为固定大小,系统默认如果按固定分区分配的话,只能分成20个相等大小的分区,因此系统只能最多运行20个进程。

【免费下载】实验六连续动态内存管理模拟实现

【免费下载】实验六连续动态内存管理模拟实现

【免费下载】实验六连续动态内存管理模拟实现情况汇报1、⼀⽉份完成情况1.1 完成产值情况截⽌本⽉23⽇,我项⽬部1⽉份完成产值5431.3万元,占局指挥部下达⽉计划6694万元的81.1%。

其中隧道⼯程完成投资额4982.3万元,桥梁⼯程完成投资额190.4万元。

1.2 施⼯准备、进场⼈员、机械情况⑴施⼯情况隧道⼯程⽅⾯,我项⽬部隧道均在施⼯,其中格⽃隧道已经顺利出洞。

临近春节以及安全步距超标的影响,除了⼤⽯头隧道放缓掌⼦⾯施⼯外,其他隧道都在进⾏下台阶、仰拱和⼆衬施⼯。

桥梁⼯程⽅⾯,清⽔江特⼤桥、胜秉特⼤桥、岑头坡⼤桥、冰冻破⼤桥、⽯⼝溪中桥、格⽃中桥正在施⼯。

两个涵洞涵⾝已经施⼯完毕,正在施⼯⼋字墙。

路基⼯程⽅⾯正在进⾏路堑挡⼟墙施⼯。

⑵进场施⼯⼈员情况现场施⼯⼈员1390⼈。

其中管理⼈员48⼈、技术⼈员60⼈、施⼯作业⼈员1282⼈。

⑶进场施⼯机械情况我项⽬部累计进场机械设备247台套,主要设备有:拌和机组6套、衬砌台车14套、挖掘机18台、装载机20台、⾃卸车49台、空压机36台、湿喷机24台、砼运输车32台、电焊机63台、发电机22台、通风机12台。

1.3 征地拆迁情况我项⽬部管段征地拆迁⼯作已基本完成。

1.4 三电迁改情况我项⽬部管段内所有电⼒及通讯线路已经全部迁改完毕。

1.5 ⼀⽉份施⼯进度情况我项⽬部本⽉有7个隧道正在施⼯,开⼯隧道⼯作⾯共14个,隧道合计完成828.5延⽶;正在施⼯的桥梁有城头清⽔江特⼤桥、胜秉特⼤桥、岑头坡⼤桥、冰冻坡⼤桥、⽯⼝溪中桥和格⽃中桥,桥涵合计完成29.97延⽶。

各⼯点形象进度如下表:1⽉份各⼯点完成形象进度表⼯程类别⼯点名称完成形象进度备注栋梁坡隧道376.5延长⽶格⽃隧道47.1延长⽶坡脚隧道141.3延长⽶细宁沟隧道116.6延长⽶西岭隧道53.2延长⽶⾦购坡隧道38.1延长⽶隧道⼯程⼤⽯头隧道55.7延长⽶隧道合计完成 828.5延长⽶胜秉特⼤桥12#承台,18#墩⾝及顶帽岑头坡⼤桥9根桩基,1#承台,3#、4#墩⾝及顶帽格⽃中桥3#桥台清⽔江特⼤桥连续梁6m 桥涵⼯程⽯⼝溪中桥5根桩基桥涵合计完成29.97延长⽶1.6重难点控制性⼯程完成情况我项⽬重难点控制性⼯程为栋梁坡隧道和城头清⽔江特⼤桥,栋梁坡隧道本⽉完成376.5成洞⽶,开累完成5278.3成洞⽶,较指导性施⼯组织设计滞后4.8个⽉,城头清⽔江特⼤桥本⽉已完成2#块的施⼯,能按指导性施⼯组织设计完成任务。

操作系统课程设计实验报告内存的连续分配算法

操作系统课程设计实验报告内存的连续分配算法

组号成绩计算机操作系统课程设计报告题目内存的连续分配算法专业:计算机科学与技术班级:学号姓名:指导教师:2016年12月 26 日一、设计目的掌握内存的里联系分配方式的各种算法。

二、设计内容本系统模拟操作系统内存分配算法的实现,实现可重定位分区分配算法,采用PCB定义结构体来表示一个进程,定义了进程的名称和大小,进程内存起始地址和进程状态。

内存分区表用空闲分区表的形式来模拟实现。

三、设计原理动态分区的实现是根据进程所申请的内存大小来决定动态的由系统进行分配内存空间大小,因此分区表里的空闲分区个数是不定的,根据进程数和进程大小决定的。

可重定位分区算法比动态分区算法增加了紧凑的功能。

四、详细设计及编码1、模块分析该实验可分为三大部分,每一部分又由个数不同的几个函数实现。

第一部分是装入作业,第二部分是内存回收,第三部分是进行紧凑。

装入作业的时候首先初始化一个链表,根据用户输入的操作代号进行相应的操作。

若用户选择装入作业首先判断空闲分区表里有没有比作业需要的内存大的分区,若有直接分配,若没有进行紧凑操作,再将紧凑后的空闲分区与作业大小比较,若能装的下则分配给作业,若是进行紧凑后的空闲分区仍不能装入整个作业则通知用户内存不够。

2、流程图2、代码实现#include<stdio.h>#include<stdlib.h>#include<time.h>#include<windows.h>#define TURE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1#define OVERFLOW -2#define SIZE 3//进程表int ppNo=1; //用于递增生成进程号int pLength=0;struct PCB{int pNo; //进程号(名)int pSize; // 进程大小int pOccupy; // 实际占用的内存int pStartAddr; // 进程起始地址int pState; //进程状态};struct PCB pList[200];//////////////////空闲分区表部分/////////////////////////////////////////////////////typedef int Status;typedef struct emptyNode{ //空闲分区结构体int areaSize; //空闲分区大小int aStartAddr; //空闲分区始址struct emptyNode *next;}emptyNode,*LinkList;int ListDelete(struct PCB *pList,int i);//删除下标为i的进程void pSort(struct PCB *pList); //内存中的进程按始址递增排序void compact(LinkList &L,struct PCB *pList);//紧凑,内存中进程移动,修改进程数据结构;空闲分区合并,修改空闲分区表数据结构void amalgamate(LinkList &L); //回收后进行合并空闲分区void recycle(LinkList &L,struct PCB *pList); //回收,从进程表中删除进程,把释放出的空间插入到空闲分区链表中Status InitList(LinkList &L); ///构造一个新的有头节点的空链表L Status ClearList(LinkList &L); ///将链表L重置为空表Status ListInsert(LinkList &L,LinkList s1); //根据始址进行插入void DeleteElem(LinkList &L,int aStartAddr);//删除线性表中始址值为aStartAddr的结点void PrintList(LinkList L); //输出各结点的值void creatP(struct PCB *p); ///初始化进程int search(LinkList &L,int pSize); //检索分区表,返回合适分区的首址int add(LinkList &L); //返回空闲分区总和void pListPrint(struct PCB *pList); //AAA/输出内存中空间占用情况void distribute(LinkList &L,struct PCB *process);int ListDelete(struct PCB *pList,int i)//AAA/删除下标为i的进程{for(;i<pLength-1;i++){pList[i]=pList[i+1];}pLength--;}//ListDeletevoid pSort(struct PCB *pList){ //AAA/内存中的进程按始址递增排序int i,j;struct PCB temp;for(i=0;i<pLength-1;i++){for(j=0;j<pLength-i-1;j++){if(pList[j].pStartAddr>pList[j+1].pStartAddr){temp=pList[j];pList[j]=pList[j+1];pList[j+1]=temp;}}}}void compact(LinkList &L,struct PCB *pList){//AAA/紧凑,内存中进程移动,修改进程数据结构;空闲分区合并,修改空闲分区表数据结构printf("进行紧凑\n");//1、进程移动,修改进程数据结构int i;pList[0].pStartAddr=0; //第一个进程移到最上面for(i=0;i<pLength-1;i++){pList[i+1].pStartAddr=pList[i].pStartAddr+pList[i].pOccupy;}//2、空闲分区合并,修改空闲分区表数据结构LinkList p=L->next,s;int sumEmpty=0;while(p!=NULL)//求空闲区总和{sumEmpty+=p->areaSize;p=p->next;}//printf("清空前\n");//PrintList(L);ClearList(L); //清空空闲分区表//printf("清空后\n");//PrintList(L);s=(LinkList)malloc(sizeof(emptyNode));s->aStartAddr=pList[pLength-1].pStartAddr+pList[pLength-1].pOccupy;s->areaSize=sumEmpty;ListInsert(L,s);//printf("插入后\n");//PrintList(L);// p rintf("\n紧凑后的>>>>\n");pListPrint(pList);PrintList(L);}void amalgamate(LinkList &L){//AAA/回收后进行合并空闲分区LinkList p=L->next,q=p->next;while(q!=NULL){if(p->aStartAddr+p->areaSize==q->aStartAddr){p->areaSize+=q->areaSize;DeleteElem(L,q->aStartAddr);//删除被合并的结点q=p->next;}else{p=q;q=q->next;}}}void recycle(LinkList &L,struct PCB *pList){//AAA/回收,从进程表中删除进程,把释放出的空间插入到空闲分区链表中int index,delPNo,delPSize,delPOccupy,delPStartAddr;LinkList s;//srand(time(0));//index=rand()%pLength;printf("请输入要回收的进程号:");scanf("%d",&index);delPNo=pList[index-1].pNo;delPSize=pList[index-1].pSize;delPOccupy=pList[index-1].pOccupy;delPStartAddr=pList[index-1].pStartAddr;//printf("__________________________________________________________________ ______________");ListDelete(pList,index-1);//pListPrint(pList);s=(LinkList)malloc(sizeof(emptyNode));s->areaSize=delPOccupy;s->aStartAddr=delPStartAddr;ListInsert(L,s);amalgamate(L);pListPrint(pList);//输出内存中空间占用情况PrintList(L);/////////////////////////////////////////////////////////////////////////////Status InitList(LinkList &L) //1AAA/构造一个新的有头节点的空链表L {LinkList s;L=(LinkList)malloc(sizeof(emptyNode)); //生成新节点(头结点)if(!L) return ERROR; //申请内存失败s=(LinkList)malloc(sizeof(emptyNode));s->areaSize=100;s->aStartAddr=0;L->next=s; //头节点的指针域指向第一个结点s->next=NULL;return OK;}//InitListStatus ClearList(LinkList &L) //2AAA/将链表L重置为空表{LinkList p,r;p=L->next; r=p->next;while(p!=NULL){free(p);if(r==NULL){p=NULL;}else{p=r;r=p->next;}}L->next=NULL;return OK;}//ClearListStatus ListInsert(LinkList &L,LinkList s1) //AAA/*****根据始址进行插入{LinkList r=L,p=L->next,s;//指针s=(LinkList)malloc(sizeof(emptyNode));s->areaSize=s1->areaSize;s->aStartAddr=s1->aStartAddr;if(p==NULL){L->next=s;s->next=NULL;}else{while(p!=NULL){if(s1->aStartAddr < p->aStartAddr){s->next=r->next;r->next=s;break;}r=p;p=p->next; //后移}if(p==NULL){r->next=s;s->next=NULL;}}return OK;}//ListInsert2void DeleteElem(LinkList &L,int aStartAddr)//*****删除线性表中始址值为aStartAddr 的结点{LinkList p=L,q;while(p->next!=NULL){q=p->next;if(q->aStartAddr==aStartAddr){p->next=q->next;free(q);}elsep=p->next;}}//DeleteElem///////////////////////////////////////////////////////////////////////////////void PrintList(LinkList L)//AAA/*****输出各结点的值{LinkList p=L->next;while(p!=NULL){printf(" %d \t\t\t%d KB\n",p->aStartAddr,p->areaSize);p=p->next;}printf("\n");}//PrintListvoid creatP(struct PCB *p){ //AAA/初始化进程int size;//srand(time(NULL));//size=rand()%7+1;printf("请输入进程大小:");scanf("%d",&size);//size=10;p->pNo=ppNo++;p->pSize=size;p->pOccupy=0;p->pStartAddr=0;p->pState=0;}int search(LinkList &L,int pSize){ //AAA/检索分区表,返回合适分区的首址LinkList p=L->next;while(p!=NULL){if(p->areaSize>=pSize){////成功printf("search分区%d %d\n",p->areaSize,pSize);return p->aStartAddr;}p=p->next;}return -1;//没有足够大的}int add(LinkList &L){ //AAA/返回空闲分区总和LinkList p=L->next;int sum=0;while(p!=NULL){sum+=p->areaSize;p=p->next;}return sum;}void pListPrint(struct PCB *pList){//AAA/输出内存中空间占用情况printf("\n进程分配情况: 起始地址\t\t大小\t\t进程号\n");for(int i=0;i<pLength;i++){printf(" %d\t\t\t %d K\t\t%d\n",pList[i].pStartAddr,pList[i].pOccupy,pList[i].pNo);}}void distribute(LinkList &L,struct PCB *process){LinkList p=L->next;while(p!=NULL){if(p->areaSize>=process->pSize)break;p=p->next;}//printf("%d KB < %d KB",process->pSize,p->areaSize);////////////////////if(p->areaSize-process->pSize<=SIZE){//不用分割全部分配(直接删除此空闲分区结点)process->pStartAddr=p->aStartAddr; //进程始址变化process->pState=1; //进程状态process->pOccupy=p->areaSize; //进程实际占用内存为改空闲分区的大小pList[pLength++]= *process; //把进程加入进程列表pSort(pList);pListPrint(pList);//输出内存中空间占用情况DeleteElem(L,p->aStartAddr);}else{//分割分配process->pStartAddr=p->aStartAddr; //进程始址变化process->pState=1; //进程状态process->pOccupy=process->pSize; //进程实际占用内存为该进程的大小pList[pLength++]= *process; //把进程加入进程列表pSort(pList); //进程排序pListPrint(pList);//输出内存中空间占用情况p->aStartAddr+=process->pSize; //空闲分区始址变化p->areaSize-=process->pOccupy; //空闲分区大小变化}}///////////////////////////////////////////////////////int main(){struct PCB p;int i,num,dele,k,stAddr,flag;LinkList s,L;if(!InitList(L)) //初始化空闲分区表printf("创建表失败\n");while(1){printf("请选择要进行的操作(1:装入;2:回收)");int flag;scanf("%d",&flag);if(flag==1){creatP(&p);//初始化进程//printf("_________________________________________________________________ _______________");printf("待装入作业:%d Size = %d KB\n",p.pNo,p.pSize);//1、请求分配size//2、检索空闲分区表(首次适应FF)//PrintList(L);stAddr=search(L,p.pSize);//得到足够大的分区的始址,没有则返回-1if(stAddr==-1){//没有足够大的分区if(add(L)>=p.pSize){//空闲区总和足够大// printf("没有足够大的空闲分区但空闲总和足够大\n");//紧凑compact(L,pList);//按动态分区方式分配distribute(L,&p);PrintList(L);//compact(L,pList); //紧凑}else{ //空闲区总和不足printf("分配失败\n\n");}}else{//有足够大的distribute(L,&p);PrintList(L);//compact(L,pList); //紧凑}}else{//回收if(pLength>0){recycle(L,pList);//compact(L,pList); //紧凑}else{printf("无可回收内存!");}}//system("pause");// scanf("%d")} //whilereturn 0;}四、结果及其相关分析结果分析:连续进行4次装入的操作后内存中还剩30K的空间,接着进行一次回收内存的操作,回收作业1后不连续的空闲内存共有50K,接着再装入一个35K的作业,分散的两个分区都不能装入作业,但是总和可以装入,所以先进行紧凑再分配,重新分配后还剩15K的内存。

操作系统课程设计报告 内存管理算法模拟

操作系统课程设计报告 内存管理算法模拟

课程设计说明书操作系统课程设计题目: 操作系统院系:专业班级:学号:学生姓名:指导教师:2010年 5月 15日安徽理工大学课程设计(论文)任务书年月日课程设计(论文)成绩评定表动态分区分配是根据进程的实际需要,动态的为之分配内存空间。

在实现可变分区时,将涉及到分区分配中所用的数据结构、分区分配算法与回收操作等问题。

为了实现分区分配,系统中必须配置相应的数据结构。

数据结构包括空闲分区表和空闲分区链。

为把一个新作业装入内存,必须按照一定的分配方法,从空闲分区表或空闲分区链中选出一分区分配给作业。

常用的分配算法有五种,首次适应算法(FIRST FIT)、循环首次适应算法(NEXT FIT)、最佳适应算法(BEST FIT)、快速适应算法(QUICK FIT)和最坏适应算法(WORST FIT)。

关键词:动态分区分配内存分配算法1系统分析.................................................................. 错误!未定义书签。

1.1问题描述 (1)1.2算法描述 (1)1.3设计目的 (1)2 系统设计 (2)2.1设计要求 (2)2.2设计原理 (2)2.3设计流程图 (3)3系统实现 (6)3.1数据结构 (6)3.2函数声明与定义 (6)3.3运行结果 (11)4总结 (16)参考文献 (16)1系统分析1.1问题描述用高级语言编写一个模拟内存分配算法的程序,设计过程中应选择适当的数据结构。

功能有以下几个,利用分区分配算法为作业分配内存空间,可以对已分配的内存空间进行回收,并可以查看分配的情况。

1.2算法描述动态分区分配是根据进程的实际需要,动态的为之分配内存空间。

在实现可变分区时,将涉及到分区分配中所用的数据结构、分区分配算法与回收操作等问题。

为了实现分区分配,系统中必须配置相应的数据结构。

数据结构包括空闲分区表和空闲分区链。

为把一个新作业装入内存,必须按照一定的分配方法,从空闲分区表或空闲分区链中选出一分区分配给作业。

c++动态分区分配算法模拟(操作系统课程设计)

c++动态分区分配算法模拟(操作系统课程设计)

课程设计课程设计名称:操作系统课程设计专业班级:学生姓名:学号:指导教师:课程设计时间:6月13日-——6月17日计算机科学专业课程设计任务书学生姓名马飞扬专业班级学号题目动态分区分配方式的模拟1课题性质其它课题来源自拟课题指导教师同组姓名主要内容1)用C语言实现采用首次适应算法的动态分区分配过程alloc()和回收过程free()。

其中,空闲分区通过空闲分区链表来管理,在进行内存分配时,系统优先使用空闲区低端的空间。

2)假设初始状态如下,可用的内存空间为640KB,并有下列的请求序列;作业1申请130KB;作业2申请60KB;作业3申请100KB;作业2释放60KB;作业4申请200 KB;作业3释放100 KB;作业1释放130 KB;作业5申请140 KB;作业6申请60 KB;作业7申请50KB;作业6释放60 KB请采用首次适应算法进行内存块的分配和回收,同时显示内存块分配和回收后空闲内存分区链的情况。

任务要求了解动态分区分配中使用的数据结构和分配算法,并进一步加深对动态分区存储管理方式及其实现过程的理解。

参考文献任满杰等《操作系统原理实用教程》电子工业出版社 2006汤子瀛《计算机操作系统》(修订版)西安电子科技大学出版社 2001张尧学史美林《计算机操作系统教程》实验指导清华大学出版社 2000 罗宇等《操作系统课程设计》机械工业出版社2005审查意见指导教师签字:教研室主任签字:年月日说明:本表由指导教师填写,由教研室主任审核后下达给选题学生,装订在设计(论文)首页1:需求分析(1)用C语言实现采用首次适应算法的动态分区分配过程alloc()和回收过程free()。

其中,空闲分区通过空闲分区链表来管理,在进行内存分配时,系统优先使用空闲区低端的空间。

(2)假设初始状态下,可用的内存空间为640KB,并有下列的请求序列:作业1申请130KB;作业2申请60KB;作业3申请100KB;作业2释放60KB;作业4申请200 KB;作业3释放100 KB;作业1释放130 KB;作业5申请140 KB;作业6申请60 KB;作业7申请50KB;作业6释放60 KB。

操作系统 动态分区分配算法课程设计 JAVA版

操作系统 动态分区分配算法课程设计 JAVA版
//选择算法 //1-首次适应算法 //2-循环首次适应算法
//4-最坏适应算法 //5-快速适应算法 switch(option) { case 1:
System.out.println("对作业用首次适应算法进行空间分配:"); First(); output(); break; case 2: System.out.println("对作业用循环首次适应算法进行空间分配:"); CycleFirst(); output(); break; case 3: System.out.println("对作业用最佳适应算法进行空间分配:"); Best(); output(); break; case 4: System.out.println("对作业用最坏适应算法进行空间分配:"); Worst(); output(); break; case 5: System.out.println("对作业用快速适应算法进行空间分配:"); Worst(); output(); break;
//2——循环首次适应算法
public static void CycleFirst()
{
i=0;
j=0;
while((i<n) && (j<m))
{
if((ProcessNeed[i] <= FreePartition[j]) && (!state[i]))
{
for(k=0;k<3;k++)
//记录作业分配
//3——最佳适应算法
public static void Best()
{

操作系统课程设计报告_动态分区分配

操作系统课程设计报告_动态分区分配

青岛理工大学操作系统课程设计报告院(系):计算机工程学院专业:计算机科学与技术专业学生姓名:__牛利利班级:__计算073 _学号:200707106题目:_动态分区分配模拟____起迄日期:_2010年7月5日至7月16日_设计地点:2号实验楼402室指导教师:李兰2009—2010年度第2 学期完成日期: 2010 年7 月16 日一、课程设计目的操作系统是最重要的计算机系统软件,同时也是最活跃的学科之一。

计算机系统由硬件和软件两部分组成。

操作系统是配置在计算机硬件上的第一层软件,是对硬件的首次扩充。

本次课程设计的主要目的是在学习操作系统理论知识的基础上,对操作系统整体的一个模拟。

也是对本学期所学知识的一个总体的检测,使理论知识应用到实际的编程中,根据理论的算法来实现具体的编程操作。

同时通过本次课程设计加深对操作系统理论知识各个部分管理功能的感性认识,进一步分析和理解各个部分之间的联系和功能,最后达到对完整系统的理解。

同时,可以提高运用操作系统知识和解决实际问题的能力;并且锻炼自己的编程能力、创新能力以及开发软件的能力;还能提高自己的调查研究、查阅文献、资料以及编写软件设计文档的能力并提高分析问题的能力。

操作系统课程设计的主要任务是研究计算机操作系统的基本原理和算法,掌握操作系统的存储器管理、设备管理、文件管理和进程管理的基本原理和算法。

使学生掌握基本的原理和方法,最后达到对完整系统的理解。

二、课程设计内容仿真实现动态可变分区存储管理模拟系统。

内存调度策略可采用首次适应算法、循环首次适应算法和最佳适应法等,并对各种算法进行性能比较。

为了实现分区分配,系统中必须配置相应的数据结构,用来描述空闲区和已分配区的情况,为分配提供依据。

常用的数据结构有两种形式:空闲分区表和空闲分区链。

为把一个新作业装入内存,须按照一定的算法,从空闲分区表或空闲分区链中选出一个分区分配给该作业。

三、系统分析与设计1、系统分析:动态分区分配是根据进程的实际需要,动态地为之分配内存空间。

动态分区存储管理的模拟实现

动态分区存储管理的模拟实现
scanf("%d", &taskId);
printf("请输入需要分配的内存大小(KB):");
scanf("%d", &size);
if (size <= 0)
{
printf("错误:分配内存大小必须为正值\n");
continue;
}
//调用分配算法
bestFit(taskId, size);
definecrtsecurenowarnings1includestdiohincludestdlibhenumstatefreebusy划出所需大小区分配给请求一个表项下为空上下都为空上下都不为空将上面的空闲区合并并回收将下面的空闲区合并并回收将上下的空闲区合并并回收直接将其回收intaddr
计算机科学与工程学院学生实验报告
#include<stdlib.h>
enum STATE
{
Free,
Busy
};
struct subAreaNode
{
int addr; //起始地址
int size; //分区大小
int taskId; //作业号
STATE state; //分区状态
subAreaNode *pre; //分区前向指针
}used_table[n];/*已分配区表*/
(2)未分配区表:
#define m 10/*假定系统允许的空闲区表最大为m,m值为10*/
struct
{int number;/*序号*/
int address;/*空闲区起始地址,单位为KB */
int length;/*空闲区长度,单位为KB*/

实验五 动态分区存储管理系统模拟

实验五 动态分区存储管理系统模拟

实验五动态分区存储管理模拟一、实验目的深入了解可变分区存储管理方式主存分配回收的实现。

二、实验预备知识可变分区存储管理方式不预先将主存划分成几个区域,而把主存除操作系统占用区域外的空间看作一个大的空闲区。

当进程要求装入主存时,根据进程需要主存空间的大小查询主存内各个空闲区,当从主存空间找到一个大于或等于该进程大小要求的主存空闲区时,选择其中一个空闲区,按进程需求量划出一个分区装入该进程。

进程执行完后,它所占的主存分区被回收,成为一个空闲区。

如果该空闲区的相邻分区也是空闲区,则需要将相邻空闲区合并成一个空闲区。

这个实验主要需要考虑三个问题:(1)设计记录主存使用情况的数据表格,用来记录空闲区和进程占用的区域;(2)在设计的数据表格基础上设计主存分配算法;(3)在设计的数据表格基础上设计主存回收算法。

首先,考虑第一个问题:设计记录主存使用情况的数据表格,用来记录空闲区和进程占用的区域。

由于可变分区的大小是由进程需求量决定的,故分区的长度是预先不固定的,且分区的个数也随主存分配和回收而变动。

总之,所有分区情况随时可能发生变化,数据表格的设计必须和这个特点相适应。

由于分区长度不同,因此设计的表格应该包括分区在主存中的起始地址和长度。

由于分配时空闲区有时会变成两个分区:空闲区和已分分区,回收主存分区时,可能会合并空闲分区,这样如果整个主存采用一张表格记录已分分区和空闲区,就会使表格操作繁琐。

主存分配时查找空闲区进行分配,然后填写已分分区表,主要操作在空闲区;某个进程执行完成后,将该分区变成空闲区,并将其与相邻空闲区合并,主要操作也在空闲区。

由此可见,主存分配和回收主要是对空闲区的操作。

这样,为了便于对主存空间的分配和回收,就建立两张分区表记录主存使用情况,一张表格记录进程占用分区的“已分分区表”;一张是记录空闲区的“空闲区表”。

这两张表的实现方法一般有两种,一种是链表形式,一种是顺序表形式。

在实验中,采用顺序表形式,用数组模拟。

计算机操作系统课程设计报告《存储管理——动态分区分配算法的模拟》

计算机操作系统课程设计报告《存储管理——动态分区分配算法的模拟》

《计算机操作系统》课程设计题目:存储管理——动态分区分配算法的模拟专业:软件工程年级:2012级小组成员:指导教师:时间:地点:2012年5 月目录目录 (1)概述 (3)2. 课程设计任务及要求 (3)2.1 设计任务 (3)2.2 设计要求 (3)2.3 课程设计任务安排 (3)3. 算法及数据结构 (4)3.1算法的总体思想(流程) (4)3.2首次适应算法 (4)3.2.1 功能 (4)3.2.2 数据结构(包括变量的定义,要注释!) (4)3.2.3 算法(流程图表示,或伪C表示) (5)3.3循环首次适应算法 (6)3.3.1功能 (6)3.3.2 数据结构 (6)3.3.3算法 (7)3.4最佳适应算法 (8)3.4.1功能 (8)3.4.2 数据结构 (8)3.4.3算法 (8)3.5最坏适应算法 (10)3.5.1功能 (10)3.5.2 数据结构 (10)3.5.3算法 (11)4. 程序设计与实现 (12)4.1 程序流程图 (12)4.2 程序代码(要注释) (12)4.3 实验结果 (21)5. 结论 (23)6. 收获、体会和建议。

(23)A的总结: (23)B的总结: (23)7. 参考文献。

(24)概述动态分区分配是根据进程的实际需要,动态地为之分配内存空间,而在分配时,须按照一定的分配算法,从空闲分区表或空闲分区链中选出一分区分配给该作业。

在本实验中运用了五种分配算法,分别是:1.首次适应算法2.循环首次适应算法3.最坏适应算法4.最佳适应算法5. 快速适应算法2. 课程设计任务及要求2.1设计任务要求设计主界面以灵活选择其中算法,5种算法都要求实现。

2.2设计要求1)首先由系统生成当前的内存状态,要求未分配的分区数量不少于3个,且空间大小随机,然后随机生成一个数,表示等待分配进程的大小。

2)然后显示上述算法由用户选择,结果显示分配后的状态。

3. 算法及数据结构3.1算法的总体思想(流程)设计程序模拟四种动态分区分配算法:首次适应算法、循环首次适应算法、最佳适应算法和最坏适应算法的工作过程。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

(操作系统课程设计)连续动态分区内存管理模拟实现目录《操作系统》课程设计 (1)引言 (3)课程设计目的和内容 (3)需求分析 (3)概要设计 (3)开发环境 (4)系统分析设计 (4)有关了解内存管理的相关理论 (4)内存管理概念 (4)内存管理的必要性 (4)内存的物理组织 (4)什么是虚拟内存 (5)连续动态分区内存管理方式 (5)单一连续分配(单个分区) (5)固定分区存储管理 (5)可变分区存储管理(动态分区) (5)可重定位分区存储管理 (5)问题描述和分析 (6)程序流程图 (6)数据结构体分析 (8)主要程序代码分析 (9)分析并实现四种内存分配算法 (11)最先适应算 (11)下次适应分配算法 (13)最优适应算法 (16)最坏适应算法......................................................... (18)回收内存算法 (20)调试与操作说明 (22)初始界面 (22)模拟内存分配 (23)已分配分区说明表面 (24)空闲区说明表界面 (24)回收内存界面 (25)重新申请内存界面..........................................................26.总结与体会 (28)参考文献 (28)引言操作系统是最重要的系统软件,同时也是最活跃的学科之一。

我们通过操作系统可以理解计算机系统的资源如何组织,操作系统如何有效地管理这些系统资源,用户如何通过操作系统与计算机系统打交道。

存储器是计算机系统的重要组成部分,近年来,存储器容量虽然一直在不断扩大,但仍不能满足现代软件发展的需要,因此,存储器仍然是一种宝贵而又紧俏的资源。

如何对它加以有效的管理,不仅直接影响到存储器的利用率,而且还对系统性能有重大影响。

而动态分区分配属于连续分配的一种方式,它至今仍在内存分配方式中占有一席之地。

课程设计目的和内容:理解内存管理的相关理论,掌握连续动态分区内存管理的理论;通过对实际问题的编程实现,获得实际应用和编程能力。

编写程序实现连续动态分区内存管理方式,该程序管理一块虚拟内存,实现内存分配和回收功能。

分析并实现四种内存分配算法,即最先适应算法,下次最先适应算法,最优适应算法,最坏适应算法。

内存分配算法和回收算法的实现。

需求分析动态分区分配是根据进程的实际需要,动态地为之分配内存空间。

在实现动态分区分配时,将涉及到分区分配中所用的数据结构、分区分配算法和分区的分配和回收操作这样三个问题。

常用的数据结构有动态分区表和动态分区链。

在对数据结构有一定掌握程度的情况下设计合理的数据结构来描述存储空间,实现分区存储管理的内存分配功能,应该选择最合适的适应算法(首次适应算法,最佳适应算法,最后适应算法,最坏适应算法),在动态分区存储管理方式中主要实现内存分配和内存回收算法,在这些存储管理中间必然会有碎片的产生,当碎片产生时,进行碎片的拼接等相关的内容概要设计本程序采用机构化模块化的设计方法,共分为四大模块。

⑴最先适应算法实现从空闲分区表的第一个表目起查找该表,把最先能够满足要求的空闲区分配给作业,这种方法目的在于减少查找时间。

为适应这种算法,空闲分区表(空闲区链)中的空闲分区要按地址由低到高进行排序。

该算法优先使用低址部分空闲区,在低址空间造成许多小的空闲区,在高地址空间保留大的空闲区。

⑵下次适应分配算法实现该算法是最先适应算法的变种。

在分配内存空间时,不再每次从表头(链首)开始查找,而是从上次找到空闲区的下一个空闲开始查找,直到找到第一个能满足要求的的空闲区为止,并从中划出一块与请求大小相等的内存空间分配给作业。

该算法能使内存中的空闲区分布得较均匀。

⑶最优适应算法实现它从全部空闲区中找出能满足作业要求的、且大小最小的空闲分区,这种方法能使碎片尽量小。

为适应此算法,空闲分区表(空闲区链)中的空闲分区要按从小到大进行排序,自表头开始查找到第一个满足要求的自由分区分配。

⑷最坏算法实现最坏适应分配算法要扫描整个空闲分区或链表,总是挑选一个最大的空闲分区分割给作业使用。

该算法要求将所有的空闲分区按其容量从大到小的顺序形成一空闲分区链,查找时只要看第一个分区能否满足作业要求。

开发环境:win7 下 VC++6.0系统分析设计:相关算法原理,算法流程图,涉及的数据结构内容都相应包含在各章节中有关了解内存管理的相关理论内存管理概念:内存管理,是指软件运行时对计算机内存资源的分配和使用的技术。

其最主要的目的是如何高效,快速的分配,并且在适当的时候释放和回收内存资源。

内存不是预先划分好的,而是在系统运行的过程中建立分区.当作业装入主存时,根据作业所需要的主存容量查看是否有足够的主存空间,若有则按需要分割一个分区给该作业;否则令该作业等待.分区长度不固定分区个数不固定。

这种存储管理的方法克服了固定分区严重浪费主存的问题,提高了主存资源的利用率。

内存管理的必要性:内存管理对于编写出高效率的 Windows 程序是非常重要的,这是因为Windows 是多任务系统,它的内存管理和单任务的 DOS 相比有很大的差异。

DOS 是单任务操作系统,应用程序分配到内存后,如果它不主动释放,系统是不会对它作任何改变的;但 Windows 却不然,它在同一时刻可能有多个应用程序共享内存,有时为了使某个任务更好地执行,Windows 系统可能会对其它任务分配的内存进行移动,甚至删除。

因此,我们在 Windows 应用程序中使用内存时,要遵循Windows 内存管理的一些约定,以尽量提高 Windows 内存的利用率。

1.3 内存的物理组织:物理地址:把内存分成若干个大小相等的存储单元,每个存储单元占 8 位,称作字节(byte)。

每个单元给一个编号,这个编号称为物理地址(内存地址、绝对地址、实地址)。

二、物理地址空间:物理地址的集合称为物理地址空间(主存地址空间),它是一个一维空间。

什么是虚拟内存:虚拟内存是内存管理技术的一个极其实用的创新。

它是一段程序(由操作系统调度),持续监控着所有物理内存中的代码段、数据段,并保证他们在运行中的效率以及可靠性,对于每个用户层(user-level)的进程分配一段虚拟内存空间。

当进程建立时,不需要在物理内存件之间搬移数据,数据储存于磁盘内的虚拟内存空间,也不需要为该进程去配置主内存空间,只有当该进程被被调用的时候才会被加载到主内存。

连续动态分区内存管理方式的实现在早期的操作系统中,主存分配广泛采用连续分配方式。

连续分配方式,是指为一个用户程序分配一个连续的内存空间,该连续内存空间指的的是物理内存。

下面介绍连续分配的四种方式。

单一连续分配(单个分区)最简单的存储管理方式,用于多道程序设计技术之前。

内存分为系统区和用户区,系统区由操作系统使用。

用户区作为一个连续的分区分配给一个作业。

分区存储管理是满足多道程序设计的最简单的一种存储管理方法,它允许多 4个用户程序同时存在系统内存中,即共享内存空间。

按分区划分方式可分为固定分区和可变分区。

固定分区存储管理把内存的用户区预先划分成多个分区,每个分区大小可以相同,也可以不同。

(分区的划分由计算机的操作员或者由操作系统给出,并给出主存分配表)分区个数固定,分区的大小固定。

一个分区中可装入一个作业,作业执行过程中不会改变存放区域。

早期的 IBM 的 OS/MFT(具有固定任务数的多道程序系统)采用了这种固定分区的方法。

可变分区存储管理(动态分区)内存不是预先划分好的,而是在系统运行的过程中建立分区.当作业装入主存时,根据作业所需要的主存容量查看是否有足够的主存空间,若有则按需要分割一个分区给该作业;否则令该作业等待。

分区长度不固定分区个数不固定。

这种存储管理的方法克服了固定分区严重浪费主存的问题,提高了主存资源的利用率。

IBM操作系统OS/MVT采用可变分区存储管理。

可重定位分区存储管理解决碎片问题的一种简单方法是采用可重定位分区分配.。

其中心思想是,把不同程序,且在内存中地址不连续的想法让他们连续。

例:内存中现有 3 个空闲区,现有一作业到达,要求获得 30k 内存空间,没有分区满足容量要求,若想把作业装入,可将内存中所有作业进行移动,这样把原来分散的空闲区汇集成一个大的空闲区。

将内存中的作业进行移动使它们连接在一起把原来分散的多个小分区拼接成一个大的空闲区.这个过程称为”紧凑”或”移动”。

需解决的问题:每次”紧凑”后程序或数据装入的物理地址变化采用动态重定位。

问题描述和分析系统应利用某种分配算法,从空闲分区链表中找到所需大小的分区,如果空闲分区大小大于请求分区大小,则从该分区中按改请求的大小划分出一块内存空间大小划分出一块内存空间分配出去,余下的部分仍留在空闲链表中。

然后,将分配区的首址返回给调用者。

当进程运行完毕师范内存时,系统根据回收区的首址,从空闲区中找到相应的插入点,此时可能出现以下四种情况之一:⑴该空闲区的上下两相邻分区都是空闲区:将三个空闲区合并为一个空闲区。

新空闲区的起始地址为上空闲区的起始地址,大小为三个空闲区之和。

空闲区合并后,取消可用表或自由链中下空闲区的表目项或链指针,修改上空闲区的对应项。

⑵该空闲区的上相邻区是空闲区:将释放区与上空闲区合并为一个空闲区,其起始地址为上空闲区的起始地址,大小为上空闲区与释放区之和。

合并后,修改上空闲区对应的可用表的表目项或自由链指针。

⑶该空闲区的下相邻区是空闲区:将释放区与下空闲区合并,并将释放区的起始地址作为合并区的起始地址。

合并区的长度为释放区与下空闲区之和。

同理,合并后修改可用表或自由链中相应的表目项或链指针。

⑷两相邻区都不是空闲区:释放区作为一个新空闲可用区插入可用表或自由链。

程序流程图内存分配流程图,如图内存回收流程图,如图数据结构体分析⑴进程属性结构体typedef struct readyque{char name[10];int size;}readyque,*readyqueue;⑵空闲链表结构体typedef struct idlyspace{int from;int size;idlyspace * next;}idlyspace,*idly;⑶已分配链表结构体typedef struct busyspace{int from;readyque r;busyspace * next;}busyspace,*busy主要程序代码分析⑴主函数//代码请添加适当的注释。

int main(){Is=(idly)malloc(sizeof(idlyspace));Is->from=0;Is->size=256;Is->next=NULL;Is2=Is;Bs=(busy)malloc(sizeof(busyspace));Bs->next=NULL;int t,t1;printf("\n.......................欢迎来到动态分区存储管理系统..................\n\n"); printf("...........................请选择要执行的算法:...........................\n");printf("......................... 1.最先适应算法...............................\n");printf("......................... 2.下次适应算法............................\n");printf("..........................3.最优适应算法...............................\n");printf("......................... 4.最坏适应算法................................\n");printf("........................................................................\n");printf("请输入您的选择:");scanf("%d",&t);int i;while(i!=5){printf("........................................................................\n");printf(".........................操作菜单如下:(请选择).......................n"); printf("..........................1.输入进程分配空间...........................n");printf("......................... 2.进程撤销回收空间...........................\n");printf("......................... 3.输出所有空闲分区..........................\n"); printf("..........................4.输出所有已分配分区..........................\n"); printf(".......................... 5.退出..........................\n");printf("........................................................................\n");scanf("%d",&i);switch(i){case 1:switch(t){case 1:t1=FF();break;case 2:t1=NF();break;case 3:t1=BF();break;case 4:t1=WF();break;default:printf("选择算法错误\n");return 1;}if(t1)printf("分配空间成功\n");elseprintf("分配空间失败\n");break;case 2:t1=recover();if(t1)printf("回收成功\n");elseprintf("回收失败\n");break;case 3:Isprint();break;case 4:Bsprint();break;}}return 0;}第三章:分析并实现四种内存分配算法最先适应算法空闲区按地址从小到大的次序排列。

相关文档
最新文档