动态分区分配方式的模拟实验报告模板.docx

动态分区分配方式的模拟实验报告模板.docx

《动态分区分配方式的模拟实验报告模板.docx》由会员分享，可在线阅读，更多相关《动态分区分配方式的模拟实验报告模板.docx（43页珍藏版）》请在冰豆网上搜索。

动态分区分配方式的模拟实验报告模板

华北电力大学

实验报告

实验名称动态分区分配方式的模拟

课程名称计算机操作系统

专业班级：

学生姓名：

学号：

成绩：

指导教师：

实验日期：

一﹑实验目的：

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

二﹑实验内容：

（1）用C语言分别实现采用首次适应算法和最佳适应算法的动态分区分配过程alloc（）和回收过程free（）。

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

（2）假设初始状态下，可用内存空间为640K，并有下列请求序列：

◎作业1申请130KB。

◎作业2申请60KB。

◎作业3申请100KB。

◎作业2释放60KB。

◎作业4申请200KB。

◎作业3释放100KB。

◎作业1释放130KB。

◎作业5申请140KB。

◎作业6申请60KB。

◎作业7申请50KB。

◎作业6释放60KB。

请分别用首次适应算法和最佳适应算法进行内存块的分配和回收，要求每次分配和回收后显示出空闲内存分区链的情况。

四﹑设计思路和方法：

首次适应算法（First-fit）：

当要分配内存空间时，就查表，在各空闲区中查找满足大小要求的可用块。

只要找到第一个足以满足要球的空闲块就停止查找，并把它分配出去；如果该空闲空间与所需空间大小一样，则从空闲表中取消该项；如果还有剩余，则余下的部分仍留在空闲表中，但应修改分区大小和分区始址。

最佳适应算法（Best-fit）：

当要分配内存空间时，就查找空闲表中满足要求的空闲块，并使得剩余块是最小的。

然后把它分配出去，若大小恰好合适，则直按分配；若有剩余块，则仍保留该余下的空闲分区，并修改分区大小的起始地址。

内存回收：

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

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

五﹑主要数据结构和算法：

主要数据结构：

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

structfreearea{

intID;//分区号

longsize;//分区大小

longaddress;//分区地址

intstate;//状态

}ElemType;

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

structDuLNode//doublelinkedlist

{

ElemTypedata;

structDuLNode*prior;//前趋指针

structDuLNode*next;//后继指针

}DuLNode,*DuLinkList;

算法：

首次适应算法：

是在分配内存时，从链首开始顺序查找，直到找到一个大小能够满足要求的分区，即进行分配。

最佳适应算法：

是在分配内存时，从链首开始顺序查找，查找到链尾，并记录一个大小不小于要求的分区的最小分区，在查找完毕后进行分配。

六﹑程序代码和输出

1程序代码如下

//***************************************************************

//********动态分区分配方式的模拟*********

//***************************************************************

#include

#include

#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_last;//尾结点

Statusalloc（int）;//内存分配

Statusfree（int）;//内存回收

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

StatusBest_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==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-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->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;

}

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（）

{

intch;//算法选择标记

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

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

cout<<"**1）首次适应算法2）最佳适应算法**\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）break;//退出

else//输入操作有误

{

cout<<"输入有误，请重试！

"<

continue;

}

}

}

2输入和输出结果

（1）首次适应算法

动态分区分配方式的模拟

************************************

**1）首次适应算法2）最佳适应算法**

************************************

请选择分配算法：

1

********************************************

**1:

分配内存2:

回收内存**

**3:

查看分配0:

退出**

********************************************

请输入您的操作：

1

请输入作业（分区号）：

1

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

KB）：

130

分配成功！

********************************************

**1:

分配内存2:

回收内存**

**3:

查看分配0:

退出**

********************************************

请输入您的操作：

3

+++++++++++++++++++++++++++++++++++++++

+++主存分配情况+++

+++++++++++++++++++++++++++++++++++++++

分区号：

1

起始地址：

0

分区大小：

130KB

状态：

已分配

——————————————

分区号：

Free

起始地址：

130

分区大小：

510KB

状态：

空闲

——————————————

********************************************

**1:

分配内存2:

回收内存**

**3:

查看分配0:

退出**

********************************************

请输入您的操作：

1

请输入作业（分区号）：

2

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

KB）：

60

分配成功！

********************************************

**1:

分配内存2:

回收内存**

**3:

查看分配0:

退出**

********************************************

请输入您的操作：

3

+++++++++++++++++++++++++++++++++++++++

+++主存分配情况+++

+++++++++++++++++++++++++++++++++++++++

分区号：

1

起始地址：

0

分区大小：

130KB

状态：

已分配

——————————————

分区号：

2

起始地址：

130

分区大小：

60KB

状态：

已分配

——————————————

分区号：

Free

起始地址：

190

分区大小：

450KB

状态：

空闲

——————————————

********************************************

**1:

分配内存2:

回收内存**

**3:

查看分配0:

退出**

********************************************

请输入您的操作：

1

请输入作业（分区号）：

3

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

KB）：

100

分配成功！

********************************************

**1:

分配内存2:

回收内存**

**3:

查看分配0:

退出**

********************************************

请输入您的操作：

3

+++++++++++++++++++++++++++++++++++++++

+++主存分配情况+++

+++++++++++++++++++++++++++++++++++++++

分区号：

1

起始地址：

0

分区大小：

130KB

状态：

已分配

——————————————

分区号：

2

起始地址：

130

分区大小：

60KB

状态：

已分配

——————————————

分区号：

3

起始地址：

190

分区大小：

100KB

状态：

已分配

——————————————

分区号：

Free

起始地址：

290

分区大小：

350KB

状态：

空闲

——————————————

********************************************

**1:

分配内存2:

回收内存**

**3:

查看分配0:

退出**

********************************************

请输入您的操作：

2

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

2

********************************************

**1:

分配内存2:

回收内存**

**3:

查看分配0:

退出**

********************************************

请输入您的操作：

3

+++++++++++++++++++++++++++++++++++++++

+++主存分配情况+++

+++++++++++++++++++++++++++++++++++++++

分区号：

1

起始地址：

0

分区大小：

130KB

状态：

已分配

——————————————

分区号：

Free

起始地址：

130

分区大小：

60KB

状态：

空闲

——————————————

分区号：

3

起始地址：

190

分区大小：

100KB

状态：

已分配

——————————————

分区号：

Free

起始地址：

290

分区大小：

350KB

状态：

空闲

——————————————

********************************************

**1:

分配内存2:

回收内存**

**3:

查看分配0:

退出**

********************************************

请输入您的操作：

1

请输入作业（分区号）：

4

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

KB）：

200

分配成功！

******************