存储管理动态分区分配算法的模拟.docx

存储管理动态分区分配算法的模拟.docx

《存储管理动态分区分配算法的模拟.docx》由会员分享，可在线阅读，更多相关《存储管理动态分区分配算法的模拟.docx（13页珍藏版）》请在冰豆网上搜索。

存储管理动态分区分配算法的模拟

一．题目：

存储管理---动态分区分配算法的模拟

二．任务：

设计主界面以灵活选择某算法，且以下算法都要实现：

首次适应算法、循环首次适应算法、最佳适应算法；。

三．思想：

对任务进行构思和设想。

（1）首次适应算法：

FF算法要求空闲分区链以地址递增的次序链接。

在分配内存时，从链首开始顺巡查找，直到找到一个大小能够满足要求的空闲分区为止；然后再按照作业的大小，从该分区中划出一块内存空间分配给请求者，余下的空闲区间仍留在空闲链中。

若从链首直至链尾都不能找到一个能满足要求的分区，则此次内存分配失败，返回。

该算法倾向于优先利用内存中低址部分的空闲分区，从而保留了高址部分的大空闲区。

这给为以后到达的大作业分配大的内存空间创造了条件。

（2）循环首次适应算法

该算法是由首次适应算法演变而成的。

在为进程分配内存空间时，不再是每次都从链首开始查找，而是从上次找到的空闲分区的下一个空闲分区开始查找，直至找到一个能满足要求的空闲分区，从中划出一块的请求大小相等的内存空间分配给作业。

为实现该算法，应设置一起始查找指针，用于指示下一次起始查询的空闲分区，并采用循环查找方式，即如果最后一个（链尾）空闲分区的大小仍不能满足要求，则返回到第一个空闲分区，比较大小是否满足，找到后，应调整起始查询指针。

（3）最佳适应算法

是将最小的空闲分区分配给作业，避免"大材小用"。

为了加速寻找，该算法要求将所有的空闲分区按照某容量以从小到大的顺序形成一空闲分区链。

这样，第一次找到的能满足要求的空闲区，必然是最佳的。

（4）内存回收：

将释放作业所在内存块的状态改为空闲状态，删除其作业名，设置为空。

并判断该空闲块是否与其他空闲块相连，若释放的内存空间与空闲块相连时，则合并为同一个空闲块，同时修改分区大小及起始地址。

四．目的：

在构思中提出要达到的目的。

（1）按照首次适应算法对内存进行分配，得到

（2）按照循环首次适应算法对内存

（3）按照最佳适应算法对内存进行分配

（4）在作业完成时，释放作业所在内存块，使其能够再次被利用

五．方案：

对构思的细化，提出粗略的方案。

（1）首次适应算法：

设立头指针，每次从头指针开始查找，进行内存分配

（2）最佳适应算法：

设立一个指针纪录最佳位置，然后根据内存大小，对最佳位置进行分配

（3）循环首次适应算法：

设立查找指针，查找指针初始为链首指针，最后位置为查找指针，返回查找指针，第二次运行时从查找指针开始查找。

（4）内存回收：

将释放的空间与前后空闲状态区间合并，改写空闲区间地址和大小

六．框图：

根据方案画出框图并审核框图。

七．程序：

是实施框图的主体并运行和修改。

1.有大小恰好合适的空闲块

if（p->data.state==Free&&p->data.size==request）{p->data.state=Busy;

p->data.ID=ID;

returnOK;

break;}

2.有空闲块能满足需求且有剩余"

if（p->data.state==Free&&p->data.size>request）{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;

returnOK;}

3.回收内存

if（p->data.ID==ID）

p->data.state=Free;

p->data.ID=Free;

if（p->prior->data.state==Free）//与前面的空闲块相连{p->prior->data.size+=p->data.size;

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

p->next->prior=p->prior;}if（p->next->data.state==Free）//与后面的空闲块相连{p->data.size+=p->next->data.size;

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

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

八．文档：

运行环境，输入条件，输出结果，整理成文。

1.运行环境：

操作系统WINDOWSXP

编译软件MicrosoftVisualC++

电脑配置：

主频

3.0GHz内存512MB

2.输入条件

作业1申请130KB

作业1申请60KB

作业1申请100KB

作业1释放130KB

作业1申请100KB

作业1释放60KB

九．总结：

谈心得体会，特别是开发一个软件的体会。

开发一个软件需要有软件需求分析，软件流程图，根据流程进行软件的编写。

在编写软件时需要很好的结构感，编写的程序需要有框架，编写的程序需要补充

语句说明，让观看着更好的了解程序，使用程序。

十．附件：

完整程序

#include

#include

#defineFree0//空闲状态

#defineBusy1//已用状态

#defineOK1//完成

#defineERROR0//出错

#defineMAX_length640//最大内存空间为640KB

typedefintStatus;

typedefstructfreearea//定义一个空闲区说明表结构{intID;//分区号

longsize;//分区大小

longaddress;//分区地址

intstate;//状态

}ElemType;

//----------线性表的双向链表存储结构------------

typedefstructDuLNode//双向链表{ElemTypedata;

structDuLNode*prior;//前趋指针

structDuLNode*next;//后继指针

}DuLNode,*DuLinkList;

DuLinkListblock_first;//头结点

DuLinkListblock_last;//尾结点

Statusalloc（int）;//内存分配

Statusfree（int）;//内存回收

StatusFirst_fit（int,int）;//首次适应算法

StatusBest_fit（int,int）;//最佳适应算法

StatusNext_fit（int,int）;//循环首次适应算法

voidshow（）;//查看分配

StatusInitblock（）;//开创空间表

StatusInitblock（）//开创带头结点的内存空间链表{block_first=（DuLinkList）malloc（sizeof（DuLNode））;

block_last=（DuLinkList）malloc（sizeof（DuLNode））;

block_first->prior=NULL;

block_first->next=block_last;

block_last->prior=block_first;

block_last->next=NULL;

block_last->data.address=0;

block_last->data.size=MAX_length;

block_last->data.ID=0;

block_last->data.state=Free;

returnOK;}//-----------------------分配主存-------------------------

Statusalloc（intch）{intID,request;

cout<<"请输入作业（分区号）：

";

cin>>ID;

cout<<"请输入需要分配的主存大小（单位:

KB）：

";

cin>>request;

if（request<0||request==0）{cout<<"分配大小不合适，请重试！

"<

returnERROR;}if（ch==3）//选择循环首次适应算法{if（Next_fit（ID,request）==OK）cout<<"分配成功！

"<

elsecout<<"内存不足，分配失败！

"<

returnOK;}elseif（ch==2）//选择最佳适应算法{if（Best_fit（ID,request）==OK）cout<<"分配成功！

"<

elsecout<<"内存不足，分配失败！

"<

returnOK;}else//默认首次适应算法{if（First_fit（ID,request）==OK）cout<<"分配成功！

"<

elsecout<<"内存不足，分配失败！

"<

returnOK;}}

//------------------首次适应算法-----------------------

StatusFirst_fit（intID,intrequest）//传入作业名及申请量{//为申请作业开辟新空间且初始化

DuLinkListtemp=（DuLinkList）malloc（sizeof（DuLNode））;

temp->data.ID=ID;

temp->data.size=request;

temp->data.state=Busy;

DuLNode*p=block_first->next;

while（p）{if（p->data.state==Free&&p->data.size==request）

{//有大小恰好合适的空闲块

p->data.state=Busy;

p->data.ID=ID;

returnOK;

break;}if（p->data.state==Free&&p->data.size>request）

{//有空闲块能满足需求且有剩余"

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;

returnOK;

break;}p=p->next;}returnERROR;}//--------------------最佳适应算法------------------------

StatusBest_fit（intID,intrequest）//传入作业名及申请量{intch;//记录最小剩余空间

DuLinkListtemp=（DuLinkList）malloc（sizeof（DuLNode））;

temp->data.ID=ID;

temp->data.size=request;

temp->data.state=Busy;

DuLNode*p=block_first->next;

DuLNode*q=NULL;//记录最佳插入位置

while（p）//初始化最小空间和最佳位置{if（p->data.state==Free&&（p->data.size>request||p->data.size==request））{q=p;

ch=p->data.size-request;

break;}p=p->next;}while（p）{if（p->data.state==Free&&p->data.size==request）

{//空闲块大小恰好合适

p->data.ID=ID;

p->data.state=Busy;

returnOK;

break;}if（p->data.state==Free&&p->data.size>request）

{//空闲块大于分配需求

if（p->data.size-requestdata.size-request;//更新剩余最小值

q=p;//更新最佳位置指向}}

p=p->next;}if（q==NULL）returnERROR;//没有找到空闲块

else

{//找到了最佳位置并实现分配

temp->prior=q->prior;

temp->next=q;

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

q->prior->next=temp;

q->prior=temp;

q->data.address+=request;

q->data.size=ch;

returnOK;}}

//--------------------循环首次适应算法------------------------

StatusNext_fit（intID,intrequest）//传入作业名及申请量{//为申请作业开辟新空间且初始化

DuLinkListtemp=（DuLinkList）malloc（sizeof（DuLNode））;

temp->data.ID=ID;

temp->data.size=request;

temp->data.state=Busy;

staticDuLNode*p=block_first->next;//定义静态指针变量

if（p->data.sizenext;

while（p）{if（p->data.state==Free&&p->data.size==request）

{//有大小恰好合适的空闲块

p->data.state=Busy;

p->data.ID=ID;

returnOK;

break;}if（p->data.state==Free&&p->data.size>request）

{//有空闲块能满足需求且有剩余"

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;

returnOK;

break;}p=p->next;}returnERROR;}//-----------------------主存回收--------------------

Statusfree（intID）{DuLNode*p=block_first;

while（p）{if（p->data.ID==ID）{p->data.state=Free;

p->data.ID=Free;

if（p->prior->data.state==Free）//与前面的空闲块相连{p->prior->data.size+=p->data.size;

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

p->next->prior=p->prior;}if（p->next->data.state==Free）//与后面的空闲块相连{p->data.size+=p->next->data.size;

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

p->prior->next=p->next;}break;}p=p->next;}returnOK;}//---------------显示主存分配情况------------------

voidshow（）{cout<<"+++++++++++++++++++++++++++++++++++++++\n";

cout<<"+++主存分配情况+++\n";

cout<<"+++++++++++++++++++++++++++++++++++++++\n";

DuLNode*p=block_first->next;

while（p）{cout<<"分区号：

";

if（p->data.ID==Free）cout<<"Free"<

elsecout<data.ID<

cout<<"起始地址：

"<data.address<

cout<<"分区大小：

"<data.size<<"KB"<

cout<<"状态：

";

if（p->data.state==Free）cout<<"空闲"<

elsecout<<"已分配"<

cout<<"--------------"<

p=p->next;}}

//-----------------------主函数---------------------------

voidmain（）{loop:

intch;//算法选择标记

cout<<"动态分区分配方式的模拟\n";

cout<<"*********************************************************\n";

cout<<"*********************************************************\n";

cout<<"**1）首次适应算法2）最佳适应算法3）循环首次适应算法**\n";

cout<<"*********************************************************\n";

cout<<"*********************************************************\n";

cout<<"请选择分配算法：

";

cin>>ch;

Initblock（）;//开创空间表

intchoice;//操作选择标记

while

（1）{cout<<"********************************************\n";

cout<<"**1:

分配内存2:

回收内存**\n";

cout<<"**3:

查看分配0:

退出**\n";

cout<<"********************************************\n";

cout<<"请输入您的操作：

";

cin>>choice;

if（choice==1）alloc（ch）;//分配内存

elseif（choice==2）//内存回收{intID;

cout<<"请输入您要释放的分区号：

";

cin>>ID;

free（ID）;}elseif（choice==3）show（）;//显示主存

elseif（choice==0）gotoloop;//退出

else//输入操作有误{cout<<"输入有误，请重试！

"<

continue;}}}