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

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

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

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

计算机操作系统

实验报告

实验二

实验题目：

存储器管理

系别：

计算机科学与技术

系

班级：

姓名：

学号：

2

一、实验目的

深入理解动态分区存储管理方式下的内存空间的分配与回收。

二、实验内容

编写程序完成动态分区存储管理方式下的内存分配和回收的实现。

具体内容

包括：

确定用来管理内存当前使用情况的数据结构；

采用首次适应算法完成内存空间的分配；

分情况对作业进行回收；

编写主函数对所做工作进行测试。

三、实验原理

分配：

动态分区存储管理方式把内存除 OS 占用区域外的空间看作一个大的

空闲区。

当作业要求装入内存时，根据作业需要内存空间的大小查询内存中

各个空闲区，当从内存中找到一个大于或等于该作业大小的内存空闲区时，

选择其中一个空闲区，按作业要求划出一个分区装入该作业。

回收：

作业执行完后，它所占用的内存空间被收回，成为一个空闲区。

如果

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

四、实验方法

实现动态分区的分配与回收，主要考虑三个问题：

第一、设计记录内存使用情况的数据表格，用来记录空闲区和作业占用的区

域（利用结构体类型数组来保存数据）；

第二、在设计的数据表格基础上设计内存分配算法（采用首次适应算法找合

适的分区（对空闲分区表进行排序），分配时要考虑碎片问题）；

第三、在设计的数据表格基础上设计内存回收算法（分四种情况进行回收

（上邻、下邻、上下邻和无相邻分区）。

五、实验步骤

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

● 已分配分区表：

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

配”）

● 空闲分区表：

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

分配”）

　struct used_table {

float address;//已分分区起始地址

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

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

char zuoyename;

};//已分配区表

Struct free_table[ {

float address;//空闲分区起始地址

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

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

配

}; //空闲分区表

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

● 首次适应算法：

为作业分配内存，要求每次找到一个起始地址最小的适

合作业的分区（按起始地址递增排序）。

● 最大碎片 size：

要求当找到的空闲分区－作业的大小的值小于或等于

size 时，将该分区全部分配给作业（数组后面元素向前移）；

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

（空闲分区长度=空闲分区长度-作业长度,

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

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

1、上邻：

条件:

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

操作：

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

2、下邻：

条件:

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

操作：

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

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

3、上下邻：

条件:

1，2 条件同时成立

操作：

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

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

删除下邻

4、无上下邻：

操作：

找 flag=0 的行

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

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

六、实验代码

# include

# include

#define M 10//允许的空闲区表长最大为 m

#define N 10//允许的最大作业数量为 n

#define MIN 1//碎片的最大值

#define SADDRESS 200//空闲分区初始的起始地址

#define SLENGTH150000//空闲分区的初始长度

struct used_t{

float address;//已分分区起始地址

float length;//已分分区长度

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

}used_table[N];

struct free_t{

float address;//空闲分区起始地址

float length;//空闲分区长度

int flag;//空闲分区表登记栏目用 0 表示空栏目，1 表

示未分配

}free_table[M];//空闲分区表

void allocate（char,float）;//分配算法子程序

void reclaim（char）;//回收算法子程序

void main（）{

int i,a;

float zyl;

char zyn;

//空闲分区表初始化

free_table[0].address=SADDRESS;//空闲分区表的起始地址

free_table[0].length=SLENGTH;//空闲分区表的长度

free_table[0].flag=1;//标志位置 1 表示未分配

for（i=1;i

{free_table[i].address=0;

free_table[i].length=0;

free_table[i].flag=0; }//0 表示空栏目

//已分分区表初始化

for（i=0;i

{used_table[i].address=0;

used_table[i].length=0;

used_table[i].flag=0;}

while

（1）{cout<<"请选择功能项：

"<

<<"1-分配主存"<

<<"2-回收主存"<

<<"3-显示主存"<

<<"0-退出"<

<<"选择功能项（0-3）:

";

cin>>a;

switch（a）{case 0:

//当选择 0 时退出程序

return;

case 1:

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

cout<<"\n 请输入作业名 zyn 和作业所需长度 zyl（作业名

为一个字符，长度 zyl 要小于"<

"<

cin>>zyn>>zyl;

allocate（zyn,zyl）;//为作业 zyn 分配主存空间

break;

}

case 2:

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

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

";

cin>>zyn;

reclaim（zyn）;//回收作业 zyn 的主存空间

break;}

case 3:

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

cout<<"\n 输出空闲区表：

"<

<<"起始地址分区长度标志"<

for（i=0;i

if（free_table[i].flag!

=0）

cout<

<

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

cin.get（）;

cout<<"\n 输出已分配区表：

"<

<<"起始地址分区长度标志"<

for（i=0;i

if（used_table[i].flag!

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

cout<

<

break;}

default:

{

cout<<"\n 没有该选项！

"<

break;

}}}

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

void allocate（char zyn,float zyl）

{float ad;

int k=-1;

int i=0;

while（i

{//找空间大于 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;i

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&&i

used_table[i].address=ad;

used_table[i].length=zyl;

used_table[i].flag=zyn;

return;}//allocate

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

void reclaim（char zyn）{

int i,k,j,s,t;

float S,L;

s=0;

while（（used_table[s].flag!

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

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

if（s>=N）{

cout<<"找不到该作业！

"<

used_table[s].flag=0;//修改以分配表表目 s 标志为为空表

目

S=used_table[s].address;//取作业 zyn 在内存中的首地址

L=used_table[s].length;//取作业 zyn 所分配到的内存的长度

j=-1;

k=-1;

i=0;

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

while（i

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;}

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 无上邻空闲区

if（j!

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

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

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

！

"<

used_table[s].flag=zyn;

return;

}

free_table[t].address=S;

free_table[t].length=L;

free_table[t].flag=1; }}

for（i=0;i<=M-1;i++）

for（int j=i;j

if（free_table[i].address>free_table[j].address）

{

free_t temp;

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、实验过程中遇到了问题，学会了与同学探讨解决