计算机操作系统动态分区存储管理方式下的内存空间的分配与回收实验报告Word下载.docx

计算机操作系统动态分区存储管理方式下的内存空间的分配与回收实验报告Word下载.docx

《计算机操作系统动态分区存储管理方式下的内存空间的分配与回收实验报告Word下载.docx》由会员分享，可在线阅读，更多相关《计算机操作系统动态分区存储管理方式下的内存空间的分配与回收实验报告Word下载.docx（11页珍藏版）》请在冰豆网上搜索。

第一、设计记录内存使用情况的数据表格，用来记录空闲区和作业占用的区域（利用结构体类型数组来保存数据）；

第二、在设计的数据表格基础上设计内存分配算法（采用首次适应算法找合适的分区（对空闲分区表进行排序），分配时要考虑碎片问题）；

第三、在设计的数据表格基础上设计内存回收算法（分四种情况进行回收（上邻、下邻、上下邻和无相邻分区）。

五、实验步骤

第一，设计记录内存使用情况的数据表格

●已分配分区表：

起始地址、长度、标志（0表示“空表项”，1表示“已分配”）

●空闲分区表：

起始地址、长度、标志（0表示“空表项”，1表示“未分配”）

　structused_table{

floataddress;

//已分分区起始地址

floatlength;

//已分分区长度，单位为字节

intflag;

//已分配表区登记栏标志，用0表示空栏目，

charzuoyename;

};

//已分配区表

Structfree_table[{

//空闲分区起始地址

//空闲分区长度，单位为字节

//空闲分区表登记栏目用0表示空栏目，1表示未配

//空闲分区表

第二，在设计的表格上进行内存分配

●首次适应算法：

为作业分配内存，要求每次找到一个起始地址最小的适合作业的分区（按起始地址递增排序）。

●最大碎片size：

要求当找到的空闲分区－作业的大小的值小于或等于size时，将该分区全部分配给作业（数组后面元素向前移）；

●否则，给作业分割出一部分空间时，其余部分仍作为新的空闲分区登记（空闲分区长度=空闲分区长度-作业长度,

●空闲分区起始地址=空闲分区起始地址+作业长度

第三，在设计的表格上进行内存回收。

1、上邻：

条件:

回收作业的始址=某个空闲区的始址+长度

操作：

空闲区的长度=空闲区的长度+作业的大小

2、下邻：

回收作业的始址+作业的长度=某个空闲区的始址

空闲区的始址=回收作业的始址

空闲区的长度=空闲区的长度+作业的长度

3、上下邻：

1，2条件同时成立

空闲区的始址=上邻的始址

空闲区的长度=上邻的长度+作业的长度+下邻的长度

删除下邻

4、无上下邻：

操作：

找flag=0的行

空闲区的始址=回收作业的始址

空闲区的长度=作业的长度

六、实验代码

#include<

iostream.h>

iomanip.h>

#defineM10//允许的空闲区表长最大为m

#defineN10//允许的最大作业数量为n

#defineMIN1//碎片的最大值

#defineSADDRESS200//空闲分区初始的起始地址

#defineSLENGTH150000//空闲分区的初始长度

structused_t{

//已分分区长度

//已分配表区登记栏标志，用0表示空栏目

}used_table[N];

structfree_t{

//空闲分区长度

//空闲分区表登记栏目用0表示空栏目，1表示未分配

}free_table[M];

voidallocate（char,float）;

//分配算法子程序

voidreclaim（char）;

//回收算法子程序

voidmain（）{

inti,a;

floatzyl;

charzyn;

//空闲分区表初始化

free_table[0].address=SADDRESS;

//空闲分区表的起始地址

free_table[0].length=SLENGTH;

//空闲分区表的长度

free_table[0].flag=1;

//标志位置1表示未分配

for（i=1;

i<

M;

i++）

{free_table[i].address=0;

free_table[i].length=0;

free_table[i].flag=0;

}//0表示空栏目

//已分分区表初始化

for（i=0;

N;

{used_table[i].address=0;

used_table[i].length=0;

used_table[i].flag=0;

}

while

（1）{cout<

<

"

请选择功能项：

endl

<

1-分配主存"

2-回收主存"

3-显示主存"

0-退出"

选择功能项（0-3）:

;

cin>

>

a;

switch（a）{case0:

//当选择0时退出程序

return;

case1:

{//a=1分配主存空间

cout<

\n请输入作业名zyn和作业所需长度zyl（作业名为一个字符，长度zyl要小于"

SLENGTH<

）:

endl;

cin>

zyn>

zyl;

allocate（zyn,zyl）;

//为作业zyn分配主存空间

break;

}

case2:

{//a=2回收主存空间

\n请输入要回收分区的作业名：

zyn;

reclaim（zyn）;

//回收作业zyn的主存空间

case3:

{//a=3显示主存情况，输出空闲区表和已分配区表

cout<

\n输出空闲区表：

起始地址分区长度标志"

for（i=0;

if（free_table[i].flag!

=0）

cout<

setw（10）<

free_table[i].address<

free_table[i].length

<

free_table[i].flag<

\n按任意键，输出已分配区表……"

cin.get（）;

\n输出已分配区表：

i++）{

if（used_table[i].flag!

=0）//输出已分配给作业的表目

cout<

used_table[i].address<

used_table[i].length

<

（char）used_table[i].flag<

}

break;

default:

{

\n没有该选项！

}}}

cin.get（）}//分配算法子程序

voidallocate（charzyn,floatzyl）

{floatad;

intk=-1;

inti=0;

while（i<

M&

&

k==-1）

{//找空间大于zyl的最小空闲区登记项k

if（free_table[i].length>

=zyl&

free_table[i].flag==1）

k=i;

i++;

if（k==-1）

{//未找到可用空闲区，返回

cout<

无可用空闲区！

return;

/*找到可用空闲区，开始分配：

若空闲区大小与作业要求分配的空间差小于MIN,则将找到的空闲区全部分配给该作业；

若空闲区大小与要求分配的空间的差大于minisize,则从空闲区划出一部分分配给作业。

*/

if（free_table[k].length-zyl<

=MIN）

{free_table[k].flag=0;

ad=free_table[k].address;

zyl=free_table[k].length;

for（i=k;

free_table[i]=free_table[i+1];

else{

free_table[k].length=free_table[k].length-zyl;

ad=free_table[k].address;

free_table[k].address=free_table[k].address+zyl;

/*修改已分配区表*/

i=0;

while（used_table[i].flag!

=0&

N）i++;

//找空表目i

used_table[i].address=ad;

used_table[i].length=zyl;

used_table[i].flag=zyn;

return;

}//allocate

//回收作业名为J的作业所占主存空间

voidreclaim（charzyn）{

inti,k,j,s,t;

floatS,L;

s=0;

while（（used_table[s].flag!

=zyn||used_table[s].flag==0）&

s<

N）

s++;

//找到作业zyn在以分配表中的表目s

if（s>

=N）{

找不到该作业！

return;

used_table[s].flag=0;

//修改以分配表表目s标志为为空表目

S=used_table[s].address;

//取作业zyn在内存中的首地址

L=used_table[s].length;

//取作业zyn所分配到的内存的长度

j=-1;

k=-1;

//寻找回收分区的上下邻空闲区，上邻表目k，下邻表目j

（j==-1||k==-1））{

if（free_table[i].flag==1）{

if（free_table[i].address+free_table[i].length==S）k=i;

if（free_table[i].address==S+L）j=i;

if（k!

=-1）{//有上邻空闲区

if（j!

=-1）{//有下邻空闲区即有上下邻空闲区，三项合并

free_table[k].length=free_table[k].length+free_table[j].length+L;

free_table[j].flag=0;

else//上邻空闲区，下邻非空闲区，与上邻合并

free_table[k].length=free_table[k].length+L;

}//if

else{//k==-1无上邻空闲区

=-1）{//无上邻空闲区，有下邻空闲区，与下邻合并

free_table[j].address=S;

free_table[j].length=free_table[j].length+L;

else{//j==-1上下邻均为非空闲区，回收区域直接填入

t=0;

//在空闲区表中寻找空栏目

while（free_table[t].flag==1&

t<

M）t++;

if（t>

=M）{//空闲区表满，回收空间失败，将已分配区表复原

主存空闲表没有空间，回收失败！

！

used_table[s].flag=zyn;

free_table[t].address=S;

free_table[t].length=L;

free_table[t].flag=1;

}}

=M-1;

for（intj=i;

j<

j++）

if（free_table[i].address>

free_table[j].address）

{

free_ttemp;

temp=free_table[i];

free_table[i]=free_table[j];

free_table[j]=temp;

七、实验结果

1、总的存储空间

2、分配空间

3、回收空间

（1）有上下邻

（2）有上邻

（3）有下邻

（4）无上下邻，回收7

八、实验总结

1、通过实验学会了理解动态分区存储管理方式下的内存空间的分配与回收

2、学会了回收的四种方式

3、实验过程中遇到了问题，学会了与同学探讨解决