动态分区分配算法资料.docx

动态分区分配算法资料.docx

《动态分区分配算法资料.docx》由会员分享，可在线阅读，更多相关《动态分区分配算法资料.docx（22页珍藏版）》请在冰豆网上搜索。

动态分区分配算法资料

动态分区分配算法

一实验内容与要求

内容：

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

在本实验中运用了三种分配算法，分别是1.首次适应算法，2.循环首次适应算法，3.最佳适应算法。

要求：

动态分区算法也称为可变分区分配算法，常见的空闲区查找算法有首次适应算法，循环首次适应算法，最佳适应算法。

特别注意分区回收时，相邻空闲分区需要合并。

（1）参考操作系统教材理解这3种分配算法以及回收算法。

（2）实现3种分配算法以及回收算法。

（3）已知作业申请内存和释放内存的序列，给出内存的使用情况。

（4）作业申请内存和释放内存的序列可以存放在文本文件中。

（5）设计简单的交互界面，演示所设计的功能。

（可以使用MFC进行界面的设计）

（6）可根据自己能力，在完成以上基本要求后，对程序功能进行适当扩充。

二、需求分析

本次实验通过用C语言进行编程并调试、运行，形象地表现出动态分区的分配方式，直观地展现了首次适应算法和最佳适应算法对内存的释放和回收方式之间的区别。

加深了我们对两种算法优缺点的理解，帮助我们了解一些数据结构和分配算法，进一步加深我们对动态分区存储器管理方式及其实现过程的理解。

主要的问题在于，如何解决两种算法对内存的释放和回收空间的表示。

动态分区分配：

又称为可变分区分配，这种分配方式并不事先先将主存划分成一块块的分区，而是在作业进入主存时，根据作业的大小动态地建立分区。

并使分区的大小正好适应作业的需要。

因此系统中分区的大小是可变的，分区的数目也是可变的。

分区分配算法：

1.首次适应法：

为作业选择分区时总是按地址从高到低搜索，只要找到可以容纳该作业的空白块，就把该空白块分配给该作业。

特点：

优先利用内存中底地址部分的空闲分区（将所有空闲区,按其地址递增的顺序链接）

2.循环首次适应算法

该算法是由首次适应算法演变而成，在为进程分配内存空间时，不再是每次都从第一个空间开始查找，而是从上次找到的空闲分区的下一个空闲分区开始查找，直至找到第一个能满足要求的空闲分区，从中划出一块与请求大小相等的内存空间分配给作业，为实现本算法，设置一个全局变量f，来控制循环查找，当f%N==0时，f=0；若查找结束都不能找到一个满足要求的分区，则此次内存分配失败。

3.最佳适应算法：

接到内存申请时，在空闲块表中找到一个不小于请求的最小空块进行分配;为作业选择分区时总是寻找其大小最接近于作业所要求的存储区域。

三、概要设计

动态分区常用的数据结构有空闲分区表和空闲分区链，用来记录内存的使用情况，此题中我采用的是空闲分区链的结构，用链指针将所有的分区链接成一条链，每个分区的结构如下所示：

typedefstructfreearea//定义一个空闲区说明表结构

{

intID;//分区号

longsize;//分区大小

longaddress;//分区地址

intstate;//状态

}ElemType;

typedefstructDuLNode//doublelinkedlist

{

ElemTypedata;

structDuLNode*prior;//前趋指针

structDuLNode*next;//后继指针

}DuLNode,*DuLinkList;

前向指针和后向指针分别用于与当前分区的前后分区相链接，address用于说明当前分区的起始地址，状态字为0时表示当前分区空闲，为1时表示已分配，id为分配的作业号，size表示分配的内存大小。

流程图：

四、详细设计

#include

#include

#include

#include

usingnamespacestd;

#defineFree0//空闲状态

#defineBusy1//已用状态

#defineOK1//完成

#defineERROR0//出错

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

typedefintStatus;

typedefstructfreearea//定义一个空闲区说明表结构

{

intID;//分区号

longsize;//分区大小

longaddress;//分区地址

intstate;//状态

}ElemType;

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

typedefstructDuLNode//doublelinkedlist

{

ElemTypedata;

structDuLNode*prior;//前趋指针

structDuLNode*next;//后继指针

}DuLNode,*DuLinkList;

DuLinkListblock_first;//头结点

DuLinkListblock_mid;

DuLinkListblock_last;//尾结点

Statusalloc（int）;//内存分配

Statusalloc2（int）;//内存分配2

Statusfree（int）;//内存回收

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

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

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

voidshow（）;//查看分配

StatusInitblock（）;//开创空间表

intID,request;

longadds=0;

StatusInitblock（）//开创带头结点的内存空间链表

{

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

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

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

block_first->prior=NULL;

block_first->next=block_mid;

block_mid->next=block_last;

block_mid->prior=block_first;

block_last->prior=block_mid;

block_last->next=NULL;

block_mid->data.address=0;

block_mid->data.size=MAX_length;

block_mid->data.ID=0;

block_mid->data.state=Free;

returnOK;

}

//-----------------------分配主存-------------------------

Statusalloc（intch）

{

if（request<0||request==0）

{

cout<<"分配大小不合适，请重试！

"<

returnERROR;

}

switch（ch）

{

case1:

if（First_fit（ID,request）==OK）cout<<"分配成功！

"<

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

"<

ID=0;

request=0;

returnOK;

break;

case2:

if（CycleFirst_fit（ID,request）==OK）cout<<"分配成功！

"<

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

"<

ID=0;

request=0;

returnOK;

break;

case3:

if（Best_fit（ID,request）==OK）cout<<"分配成功！

"<

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

"<

ID=0;

request=0;

returnOK;

break;

default:

cout<<"********ERROR!

********";

}

}

Statusalloc2（intch）

{

intID,request;

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

";

cin>>ID;

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

KB）：

";

cin>>request;

if（request<0||request==0）

{

cout<<"分配大小不合适，请重试！

"<

returnERROR;

}

switch（ch）

{

case1:

if（First_fit（ID,request）==OK）cout<<"分配成功！

"<

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

"<

returnOK;

break;

case2:

if（CycleFirst_fit（ID,request）==OK）cout<<"分配成功！

"<

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

"<

returnOK;

break;

case3:

if（Best_fit（ID,request）==OK）cout<<"分配成功！

"<

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

"<

returnOK;

break;

default:

cout<<"********ERROR!

********";

}

}

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

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;

}

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

StatusCycleFirst_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&&p->data.address==adds）

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

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;

adds=p->data.address;

p->data.size-=request;

cout<

returnOK;

break;

}

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

{

if（First_fit（ID,request）==OK）

returnOK;

}

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-request

{

ch=p->data.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;

}

}

//-----------------------主存回收--------------------

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->next->data.state==Free）//前后都有空闲块

{

p->prior->data.size+=p->data.size;

p->prior->data.size+=p->next->data.size;

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

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

adds=p->prior->data.address;

cout<<"回收成功\n";

break;

}

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

{

p->prior->data.size+=p->data.size;

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

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

adds=p->prior->data.address;

}

if（p->next->data.state==Free）//与后面的空闲块相连

{

p->data.size+=p->next->data.size;

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

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

adds=p->prior->data.address;

}

cout<<"回收成功\n";

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;

if（p==block_last）

{

break;

}

}

}

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

voidmain（）

{

intOpNum;

intSqe[100][100];

FILE*fp;

fp=fopen（"input.txt","r"）;

if（!

fp）

{

cout<<"无法打开文件input.txt";

exit

（1）;

}

fscanf（fp,"%d",&OpNum）;

for（intii=0;ii

{

for（intjj=0;jj<3;jj++）

fscanf（fp,"%d",&Sqe[ii][jj]）;

}

intch;//算法选择标记

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

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

cout<<"**1.首次适应算法**\n";

cout<<"**2.循环首次适应算法**\n";

cout<<"**3.最佳适应算法**\n";

cout<<"**0.退出程序**\n";

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

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

";

cin>>ch;

if（ch==0）

exit（0）;

Initblock（）;//开创空间表

intchoice;//操作选择标记

for（intnn=0;nn

{

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

cout<<"**1.下一操作**\n";

cout<<"**2.查看分配**\n";

cout<<"**0.退出程序**\n";

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

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

";

cin>>choice;

if（choice==1）

{

ID=Sqe[nn][0];

request=Sqe[nn][2];

if（Sqe[nn][1]==0）

{

cout<<"作业"<

alloc（ch）;//操作符为0，则开始分配内存

}