实验五动态分区存储管理模拟.docx

实验五动态分区存储管理模拟.docx

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

实验五动态分区存储管理模拟

本页仅作为文档封面，使用时可以删除Thisdocumentisforreferenceonly-rar21year.March

实验五-动态分区存储管理模拟（总12页）

实验五动态分区存储管理模拟

一、实验目的

深入了解可变分区存储管理方式主存分配回收的实现。

二、实验预备知识

可变分区存储管理方式不预先将主存划分成几个区域，而把主存除操作系统占用区域外的空间看作一个大的空闲区。

当进程要求装入主存时，根据进程需要主存空间的大小查询主存内各个空闲区，当从主存空间找到一个大于或等于该进程大小要求的主存空闲区时，选择其中一个空闲区，按进程需求量划出一个分区装入该进程。

进程执行完后，它所占的主存分区被回收，成为一个空闲区。

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

这个实验主要需要考虑三个问题：

（1）设计记录主存使用情况的数据表格，用来记录空闲区和进程占用的区域；

（2）在设计的数据表格基础上设计主存分配算法；

（3）在设计的数据表格基础上设计主存回收算法。

首先，考虑第一个问题：

设计记录主存使用情况的数据表格，用来记录空闲区和进程占用的区域。

由于可变分区的大小是由进程需求量决定的，故分区的长度是预先不固定的，且分区的个数也随主存分配和回收而变动。

总之，所有分区情况随时可能发生变化，数据表格的设计必须和这个特点相适应。

由于分区长度不同，因此设计的表格应该包括分区在主存中的起始地址和长度。

由于分配时空闲区有时会变成两个分区：

空闲区和已分分区，回收主存分区时，可能会合并空闲分区，这样如果整个主存采用一张表格记录已分分区和空闲区，就会使表格操作繁琐。

主存分配时查找空闲区进行分配，然后填写已分分区表，主要操作在空闲区；某个进程执行完成后，将该分区变成空闲区，并将其与相邻空闲区合并，主要操作也在空闲区。

由此可见，主存分配和回收主要是对空闲区的操作。

这样，为了便于对主存空间的分配和回收，就建立两张分区表记录主存使用情况，一张表格记录进程

占用分区的“已分分区表”；一张是记录空闲区的“空闲区表”。

这两张表的实现方法一般有两种，一种是链表形式，一种是顺序表形式。

在实验中，采用顺序表形式，用数组模拟。

由于顺序表的长度必须提前固定，所以无论是“已分分区表”还是“空闲区表”都必须事先确定长度。

它们的长度必须是系统可能的最大项数，系统运行过程中才不会出错，因而在多数情况下，无论是“已分分区表”还是“空闲区表”都有空闲栏目。

已分分区表中除了分区起始地址、长度外，也至少还要有一项“标志”，如果是空闲栏目，内容为“空”，如果为某个进程占用分区的登记项，内容为该进程的进程名；空闲区表中除了分区起始地址、长度外，也要有一项“标志”，如果是空闲栏目，内容为“空”，如果为某个空闲区的登记项，内容为“未分配”。

在实际系统中，这两个表格的内容可能还要更多，实验中仅仅使用上述必须的数据。

为此，“已分分区表”和“空闲区表”在实验中有如下的结构定义：

已分分区表的定义：

#definen10//假定系统允许的进程数量最多为n

struct

{

floataddress;//已分分区起始地址

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

intflag;//已分分区表登记栏标志，“0”表示空栏目，实验中只支持一个字符的进程名

}used_table[n];//已分分区表

空闲区表的定义：

#definem10//假定系统允许的空闲区数量最多为m

struct

{

floataddress;//空闲区起始地址

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

intflag;//空闲区表登记栏标志，“0”表示空栏目，用“1”表示未分配

}free_table[m];//空闲区表

其中分区起始地址和长度数值太大，超出了整型的表达范围，所以采用了float类型。

然后，就要考虑如何在设计的数据表格上进行主存的分配。

当要装入一个进程时，从空闲区表中查找标志为“未分配”的空闲区，从中找到一个能容纳该进程的空闲区。

如果找到的空闲区正好等于该进程的长度，则把该分区全部分配给进程。

这时应该把该空闲区登记栏中的标志改为“空”，同时在已分分区表中找到一个标志为“空”的栏目登记新装入进程所占用分区的起始地址、长度和进程名。

如果找到的空闲区大于进程长度，则把空闲区分成两部分，一部分用来装入进程，另外一部分仍为空闲区。

这时只要修改元空闲区的长度，且把新装入的进程登记到已分分区表中。

实验示例程序中主存分配算法采用最佳适应算法。

最佳适应算法是按进程要求挑选一个能满足进程要求的最小空闲区，这样保证可以不去分割一个大的区域，使装入大进程时比较容易得到满足。

但是最佳适应算法容易出现找到的一个分区可能只比进程所要求的长度略大一点的情况，这时，空闲区分割后剩下的空闲区就很小，这种很小的空闲区往往无法使用，影响了主存的使用。

为了一定程度上解决这个问题，如果空闲区的大小比进程要求的长度略大一点，不再将空闲区分成空闲区和已分分区两部分，而是将整个空闲区分配给进程。

在实现最佳适应算法时，可把空闲区按长度以递增方式登记在空闲区中。

分配时顺序查找空闲表，查找到的第一个空闲区就是满足进程要求的最小分区。

这样查找速度快，但是为使空闲区按长度以递增顺序登记在空闲分区表中，就必须在分配回收时进行空闲区表的调整。

空闲区表调整时移动表目的代价要高于查询整张表的代价，所以实验中不采用空闲区有序登记在空闲表中的方法。

动态分区方式的主存分配流程图如图5-1所示。

Y

N

N

Y

N

Y

N

Y

Y

N

N

Y

N

Y

N

进程P申请xk大小的主存空间

i=0;k=-1;

i是空闲区表中一栏（i<=m）

第i栏标志为“未分配”且满足进程需求xk？

i=i+1

第i栏空闲区为第一个满足需求的或第i栏空闲区长度小于第k栏空闲区长度？

k=i

是否找到满足需求的分区k？

主存分配失败

结束

第k栏长度－进程需求<=minsize？

分配整个分区：

第k栏状态为“空”；

ad=第k栏起始地址；

xk=第k栏长度；

切割空闲区：

第k栏长度减去xk；

ad=第k栏起始地址－第k栏长度；

i=0

第i栏是已分配区表中一栏且第i栏状态不为空？

i=i+1

第i栏是已分配表中的一栏？

空闲分区表第k栏状态为空？

填写已分配空闲区：

第j栏起始地址=ad；

第j栏长度=xk；

第j栏状态=作业名J；

空闲区表状态未分配

空闲区表第k栏长度加xk

已分配分区表长度不足，分配失败

结束

图5-1动态分区最佳分配算法流程图

最后，是可变分区方式下的主存回收问题。

可变分区方式下回收主存空间时，应该检查是否有与归还区相邻的空闲区。

若有，则应该合并成一个空闲区。

一个归还区可能有上邻空闲区，也可能有下邻空闲区，或者既有上邻空闲区又有下邻空闲区，或者既无上邻空闲区又无下邻空闲区

。

在实现回收时，

首先，将进程归还的区域在已分分区表中找到，将该栏目的状态变为“空”；然后，检查空闲区表中标志为“未分配”的栏目，查找是否有相邻空闲区；最后，合并空闲区，修改空闲区表。

假定进程归还得分区起始地址为S，长度为L，则：

（1）归还区有下邻空闲区

如果S+L正好等于空闲区表中某个登记栏目（假定为第j栏）的起始地址，则表明归还区有一个下邻空闲区。

这时只要修改第j栏登记项的内容：

起始地址=S；

第j栏长度=第j栏长度+L；

则第j栏指示的空闲区是归还区和下邻空闲区合并后的大空闲区。

（2）归还区有上邻空闲区

如果空闲区表中某个登记栏目（假定为第k栏）的“起始地址+长度”正好等于S，则表明归还区有一个上邻空闲区。

这时要修改第k栏登记项的内容（起始地址不变）：

第k栏长度=第k栏长度+L；

则第k栏指示的空闲区是归还区和上邻空闲区合并后的大空闲区。

（3）归还区既有上邻空闲区又有下邻空闲区

如果S+L正好等于空闲区表中某个登记栏目（假定为第j栏）的起始地址，同时还有某个登记栏目（假定为第k栏）的“起始地址+长度”正好等于S，这表明归还区既有一个上邻空闲区，又有一个下邻空闲区。

这时对空闲区表的修改如下：

第k栏长度=第k栏长度+第j栏长度+L；（第k栏起始地址不变）

第j栏状态=“空”；（将第j栏登记项删除）

则第k栏指示的空闲区是归还区和上、下邻空闲区合并后的大空闲区；原来的下邻空闲区登记项（第j栏）被删除，置为“空”。

（1）归还区既无上邻空闲区又无下邻空闲区

如果在检查空闲区表时，无上述三种情况出现，则表明归还区既无上邻空闲区又无下邻空闲区。

这时，应该在空闲区表中查找一个状态为“空”的栏目（假定查到的是第t栏），则第t栏的内容修改如下：

第t栏起始地址=S；

第t栏长度=L；

第t栏状态=“未分配”

这样，第t栏指示的空闲区是归还区。

按上述方法归还主存区域的流程图如图5-2所示。

由于是模拟实验，没有真正的主存要分配，所以在实验中：

首先，应建立一张空闲区表，初始状态只有一个空闲登记项（假定的主存空闲区）和一张所有状态都为“空”的已分分区表，假定主存空间为110KB，操作系统占用10KB，其余为空闲区；

然后，可以选择进行主存分配或主存回收，如果是分配，要求输入进程名和所需主存空间大小，如果是回收，输入回收进程的进程名，循环进行主存分配和回收后，如果需要，则显示两张表的内容，以检查主存的分配和回收是否正确。

N

Y

Y

Y

Y

Y

Y

Y

Y

Y

Y

N

N

N

N

N

N

N

N

N

N

已分配区表第s栏状态为进程P（s<=n）

S=已分配区表第s栏起始地址

L=已分配区表第s栏长度

已分配区表第s栏状态为空

假设下邻空闲区在第j栏j=-1;

假设上邻空闲区在第k栏k=-1;

进程P归还空间

s=0

s=s+1

s为已分配区表中一栏？

i=0

第i栏不是空闲区表中一栏或回收分区的上下邻空闲区均找到？

第i栏状态为“未分配”

第i栏为回收分区的上邻？

第i栏为回收分区的下邻？

i=i+1

j=i

j=i

回收分区有上邻？

回收分区有下邻？

回收分区有下邻？

和上下邻三项合并：

第k栏长度=第k栏长度+第j栏长度+L；

第j栏状态=“空”

和上邻合并：

第k栏长度=第k栏长度+L

和下邻合并：

第j栏长度=第j栏长度+L；

第j栏起始地址=S

t=0

第t栏是空闲表中非空栏？

空闲区表满？

t=t+1

归还分区填入空闲区表：

第t栏起始地址=S；

第t栏长度=L；

第t栏状态=“未分配”；

已分配区表第s栏状态为J；

空闲表长度不足，回收失败

结束

未找到进程，回收失败

结束

Y

图5-2动态分区回收流程图

三、实验内容

编写程序完成可变分区存储管理方式的主存分配回收的实现。

在已给参考示例程序的基础上，完成如下任务：

（1）采用链表形式的主存分区空闲表；

（2）采用首次适应算法、循环首次适应算法、最差适应算法完成主存空间的分配和回收；

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

参考程序

#definen10//假定系统允许的进程数量最多为n

#definem10//假定系统允许的空闲区数量最多为m

#defineminisize100

struct

{

floataddress;//已分分区起始地址

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

intflag;//已分分区表登记栏标志，“0”表示空栏目，实验中只支持一个字符的进程名

}used_table[n];//已分分区表

struct

{

floataddress;//空闲区起始地址

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

intflag;//空闲区表登记栏标志，“0”表示空栏目，用“1”表示未分配

}free_table[m];//空闲区表

allocate（charP,floatxk）//采用最佳适应算法为进程P分配xk大小的主存空间

{

inti,k;

floatad;

k=-1;

for（i=0;i

if（free_table[i].length>=xk&&free_table[i].flag==1）

if（k==-1||free_table[i].length

k=i;

if（k==-1）//未找到可用空闲区，返回

{printf（“无可用空闲区\n”）;

return;

}

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

若空闲区大小与要求分配的空间差小于或等于minisize，则空闲区全部分配；若空闲区大小与要求分配的空间差大于minisize，则从空闲区划出一部分分配

if（free_table[k].length-xk<=minisize）

{

free_table[k].flag=0;

ad=free_table[k].address;

xk=free_table[k].length;

}

else

{

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

ad=free_table[k].address+free_table[k].length;

}

//修改已分分区表

i=0;

while（used_table[i].flag!

=0&&i

i++;

if（i>=n）//无表目填写已分分区

{

printf（“无表目填写已分分区，错误！

\n”）;

//修正空闲区表

if（free_table[k].flag==0）//前面找到的是整个空闲区

free_table[k].flag=1;

else//前面找到的是某个空闲区的一部分

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

return;

}

else//修改已分分区表

{

used_table[i].address=ad;

used_table[i].length=xk;

used_table[i].flag=J;

}

return;

}//主存分配函数结束

reclaim（charP）//回收进程名为P的进程所占的主存空间

{

inti,k,j,s,t;

floatS,L;

//寻找已分分区表中对应登记项

s=0;

while（（used_table[s].flag!

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

s++;

if（s>=n）//已分分区表中找不到名为P的进程，返回

{

printf（“找不到该进程\n”）;

return;

}

//修改已分分区表

used_table[s].flag=0;

//取得归还分区的起始地址S和长度L

S=used_table[s].address;

L=used_table[s].length;

j=-1;

k=-1;

i=0;

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

while（i

{

if（free_table[i].flag==0）

{

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[j].length+free_table[k].length+L;

free_table[i].flag=0;

}

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

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

else

if（j!

=-1）

{

free_table[j].address=S;

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

}

else

{

t=0;

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

t++;

if（t>m）

{

printf（“空闲区表没有空间，回收空间失败！

\n”）;

used_table[s].flag=J;

return;

}

free_table[t].address=S;

free_table[t].flag==1;

free_table[t].length=L;

}

return（true）;

}//主存回收函数结束