操作系统课程设计动态分区分配存储管理.docx

操作系统课程设计动态分区分配存储管理.docx

《操作系统课程设计动态分区分配存储管理.docx》由会员分享，可在线阅读，更多相关《操作系统课程设计动态分区分配存储管理.docx（17页珍藏版）》请在冰豆网上搜索。

操作系统课程设计动态分区分配存储管理

操作系统课程设计

动态分区分配存储管理

$

吕霆

计算机10-01班

~

第一章课程设计概述

设计任务:

动态分区分配存储管理

设计要求

建立描述内存分配状况的数据结构；

建立描述进程的数据结构；

使用两种方式产生进程：

（a）自动产生，（b）手工输入；

在屏幕上显示内存的分配状况、每个进程的执行情况；

建立分区的分配与回收算法，支持紧凑算法；

时间的流逝可用下面几种方法模拟：

（a）按键盘，每按一次可认为过一个时间单位；（b）响应WM_TIMER；

将一批进程的执行情况存入磁盘文件，以后可以读出并重放；

支持算法：

首次适应算法、循环首次适应算法、最佳适应算法：

最坏适应算法。

设计目的

旨在让我们更好的了解动态分区管理方面的知识.

第二章原理及算法描述

动态分区分配算法原理

首次适应算法

*算法概述：

分配内存时，从链首开始顺序查找，找到满足的空闲分区则划出空间分配，余下的空闲空间仍保留在空闲链表中

*实现方法：

分配时从数组第一个元素开始比较，若符合条件则将该元素减去对应作业的值

循环首次适应算法

*算法概述：

由首次适应算法演变，只是每次分配改为由上一次找到的空闲分区开始查找

*实现方法：

在首次适应算法的基础上增加一个值用于记录找到的空闲分区的位置

最佳适应算法

*算法概述：

每次为作业分配内存时，总是把能满足要求、又是最小的空闲分区分配给作业

*实现方法：

我们决定每次分配先把空闲分区按从小到大的顺序排列，然后将第一个匹配分区分配给作业

最坏适应算法

*算法概述：

每次为作业分配内存时，总是挑选一个最大的空闲分区分割给作业使用

*实现方法：

算法与最佳适应算法几乎相同，仅在排序时把空闲分区表按从大到小的顺序排列，所以未作详细注释

回收分区

当进程运行完毕释放内存时,系统根据回收区的首址,从空闲区链（表）中找到相应的插入点,此时可能出现以下四种情况之一;

1）回收区与插入点的前一个空闲分区F1相邻接,此时应将回收区与插入点的前一分区合并,不必为回收区分配新表项,而只需修改其前一分区F1的大小.

2）回收分区与插入点的后一空闲分区F2相邻接,此时也可将两分区合并,形成新的空闲分区,但用回收区的首址作为新空闲区的首址,大小为两者之和.

3）回收区同时与插入点的前,后两个分区邻接,此时将三个分区合并,使用F1的表项和F1的首址,取消F2的表项,大小为三者之和.

4）回收区既不与F1相邻接,又不与F2邻接.这时应为回收区单独建立一新表项,填写回收区的首址和大小,并根据其首址插入到空闲链中的适当位置.

紧凑算法

通过移动内存中的作业的位置,以把原来多个分散的小分区拼接成一个大分区的方法.

第三章开发环境

此程序是本人利用c++语言在vs2012的开发环境中实现的

第四章程序实现--数据结构

#include

#include

#include

usingnamespacestd;

ofstreamstream;1）回收区上邻接着空闲盘块，下连接着已分配盘块

（2）回收区下邻接着空闲盘块，上邻接着已分配盘块

（3）回收区上下连接的都是空闲盘块

（4）空闲区上下邻接的都是已分配盘块

（5）要回收的盘块就是第一个盘块，并且向下邻接着空闲盘块

（6）要回收的盘块就是第一个盘块，但是向下邻接着已分配盘块

（7）要回收的盘块就是最后一个盘块，并且向上邻接的是空闲盘块

（8）要回收的盘块就是最后一个盘块，但是向上邻接的是已分配盘块

*/

voidapply_recycle（）

{

inti;

intj;

intk;

if（m==1）

{

ary1[0][3]=0;

n++;

ary2[0][0]=1;

ary2[0][1]=ary1[0][1];

ary2[0][2]=ary1[0][2];

vision（）;

}

else

{

if（recycle==1）

{//cout<

if（ary1[1][3]!

=2）

{

cout<<"要回收的盘块就是第一个盘块，并且向下邻接着空闲盘块"<

（"",ios:

:

app）;

stream<<"要回收的盘块就是第一个盘块，并且向下邻接着空闲盘块"<

（）;

ary1[0][1]=ary1[0][1]+ary1[1][1];

ary1[0][3]=0;

for（i=1;i

{

ary1[i][0]=ary1[i+1][0]-1;

ary1[i][1]=ary1[i+1][1];

ary1[i][2]=ary1[i+1][2];

ary1[i][3]=ary1[i+1][3];

//cout<<"ary1[i][3]"<

}

m--;

//cout<<""

k=0;

vision（）;

//cout<<"ary1[0][3]"<

//cout<<"ary1[1][3]"<

//cout<<"ary1[2][3]"<

//cout<<"ary1[3][3]"<

for（j=0;j

{

cout<<"ary1[j][3]"<

if（ary1[j][3]!

=2）

{

ary2[k][0]=ary1[j][0];

ary2[k][1]=ary1[j][1];

ary2[k][2]=ary1[j][2];

k++;

}

}

n=k;

vision（）;

}

else{

cout<<"要回收的盘块就是第一个盘块，但是向下邻接着已分配盘块"<

（"",ios:

:

app）;

stream<<"要回收的盘块就是第一个盘块，但是向下邻接着已分配盘块"<

（）;

ary1[0][3]=0;

k=0;

for（j=0;j

{

//cout<<"ary1[j][3]"<

if（ary1[j][3]!

=2）

{

ary2[k][0]=ary1[j][0];

ary2[k][1]=ary1[j][1];

ary2[k][2]=ary1[j][2];

k++;

}

}

n=k;

vision（）;

}

}

elseif（recycle==m）

{

if（ary1[recycle-2][3]!

=2）

{

cout<<"要回收的盘块就是最后一个盘块，并且向上邻接的是空闲盘块"<

（"",ios:

:

app）;

stream<<"要回收的盘块就是最后一个盘块，并且向上邻接的是空闲盘块"<

（）;

ary1[recycle-2][3]=0;

ary1[recycle-2][1]=ary1[recycle-2][1]+ary1[recycle-1][1];

m--;

k=0;

for（j=0;j

{

//cout<<"ary1[j][3]"<

if（ary1[j][3]!

=2）

{

ary2[k][0]=ary1[j][0];

ary2[k][1]=ary1[j][1];

ary2[k][2]=ary1[j][2];

k++;

}

}

n=k;

vision（）;

}

else{

cout<<"要回收的盘块就是最后一个盘块，但是向上邻接的是已分配盘块"<

（"",ios:

:

app）;

stream<<"要回收的盘块就是最后一个盘块，但是向上邻接的是已分配盘块"<

（）;

ary1[recycle-1][3]=0;

k=0;

for（j=0;j

{

//cout<<"ary1[j][3]"<

if（ary1[j][3]!

=2）

{

ary2[k][0]=ary1[j][0];

ary2[k][1]=ary1[j][1];

ary2[k][2]=ary1[j][2];

k++;

}

}

n=k;

vision（）;

}

}

else{//剩下比较复杂的四种情况

if（（ary1[recycle-2][3]!

=2）&&（ary1[recycle][3]==2））//回收区上邻接着空闲盘块，下连接着已分配盘块

{cout<<"回收区上邻接着空闲盘块，下连接着已分配盘块"<

（"",ios:

:

app）;

stream<<"回收区上邻接着空闲盘块，下连接着已分配盘块"<

（）;

ary1[recycle-2][1]=ary1[recycle-2][1]+ary1[recycle-1][1];

for（i=recycle-1;i

{

ary1[i][0]=ary1[i+1][0]-1;

ary1[i][1]=ary1[i+1][1];

ary1[i][2]=ary1[i+1][2];

ary1[i][3]=ary1[i+1][3];

}

m--;

k=0;

for（j=0;j

{

//cout<<"ary1[j][3]"<

if（ary1[j][3]!

=2）

{

ary2[k][0]=ary1[j][0];

ary2[k][1]=ary1[j][1];

ary2[k][2]=ary1[j][2];

k++;

}

}

n=k;

vision（）;

}

if（（ary1[recycle][3]!

=2）&&（ary1[recycle-2][3]==2））//回收区下邻接着空闲盘块，上邻接着已分配盘块

{

cout<<"回收区下邻接着空闲盘块，上邻接着已分配盘块"<

（"",ios:

:

app）;

stream<<"回收区下邻接着空闲盘块，上邻接着已分配盘块"<

（）;

ary1[recycle-2][3]=0;

ary1[recycle-2][1]=ary1[recycle-2][1]+ary1[recycle-1][1];

for（i=recycle-1;i

{

ary1[i][0]=ary1[i+1][0]-1;

ary1[i][1]=ary1[i+1][1];

ary1[i][2]=ary1[i+1][2];

ary1[i][3]=ary1[i+1][3];

}

m--;

k=0;

for（j=0;j

{

//cout<<"ary1[j][3]"<

if（ary1[j][3]!

=2）

{

ary2[k][0]=ary1[j][0];

ary2[k][1]=ary1[j][1];

ary2[k][2]=ary1[j][2];

k++;

}

}

n=k;

vision（）;

}

if（（ary1[recycle-2][3]!

=2）&&（ary1[recycle][3]!

=2））//回收区上下连接的都是空闲盘块

{

cout<<"回收区上下连接的都是空闲盘块"<

（"",ios:

:

app）;

stream<<"回收区下邻接着空闲盘块，上邻接着已分配盘块"<

（）;

ary1[recycle-2][1]=ary1[recycle-2][1]+ary1[recycle-1][1]+ary1[recycle][1];

cout<<"回收区上下连接的都是空闲盘块"<

cout<

for（i=recycle+1;i

{

ary1[recycle-1][0]=ary1[recycle+1][0]-2;

ary1[recycle-1][1]=ary1[recycle+1][1];

ary1[recycle-1][2]=ary1[recycle+1][2];

ary1[recycle-1][3]=ary1[recycle+1][3];

}

m=m-2;

k=0;

for（j=0;j

{

//cout<<"ary1[j][3]"<

if（ary1[j][3]!

=2）

{

ary2[k][0]=ary1[j][0];

ary2[k][1]=ary1[j][1];

ary2[k][2]=ary1[j][2];

k++;

}

}

n=k;

vision（）;

}

if（（ary1[recycle-2][3]==2）&&（ary1[recycle][3]==2））//空闲区上下邻接的都是已分配盘块

{

ary1[recycle-1][3]=0;

k=0;

for（j=0;j

{

//cout<<"ary1[j][3]"<

if（ary1[j][3]!

=2）

{

ary2[k][0]=ary1[j][0];

ary2[k][1]=ary1[j][1];

ary2[k][2]=ary1[j][2];

k++;

}

}

n=k;

vision（）;

}

}

}

}

//紧凑算法

voidcompact（）{

intid1=0;//记录已经分配的内存数量

intid2;//循环量

intnum_avl;//记录空闲盘块数量

intsum_avl=0;//总共空闲区大小

intnum_apl=0;

//统计总共空闲区有多大

vision（）;

for（id2=0;id2

{

sum_avl=sum_avl+ary2[id2][1];

}

for（id2=0;id2

{

if（ary1[id2][3]==2）

{

ary1[num_apl][0]=num_apl+1;

ary1[num_apl][1]=ary1[id2][1];

if（num_apl==0）

{

ary1[num_apl][2]=0;

}else{

ary1[num_apl][2]=ary1[num_apl-1][1]+ary1[num_apl-1][2];

}

ary1[num_apl][3]=2;

num_apl++;

//cout<<"num_apl"<

}

}

//最后一块空闲块

ary1[num_apl][0]=num_apl+1;

ary1[num_apl][1]=sum_avl;

ary1[num_apl][2]=ary1[num_apl-1][1]+ary1[num_apl-1][2];

ary1[num_apl][3]=0;

m=num_apl+1;//包括最后一个空闲区

num_avl=0;

for（id2=0;id2

{

if（ary1[id2][3]!

=2）

{

ary2[num_avl][0]=ary1[id2][0];

ary2[num_avl][1]=ary1[id2][1];

ary2[num_avl][2]=ary1[id2][2];

num_avl++;

}

}

n=num_avl;

vision（）;

}

//主函数入口

voidmain（）

{

inti;

intj;

intnum;

intchoice1;//操作选择标记

intchoice2;

intflag=1;//标记是否再执行

while（flag==1）{

cout<<"********************************************"<

cout<<"******信息产生方式******"<

cout<<"******1:

自动生成2:

手动输入******"<

cout<<"********************************************"<

cout<<"请选择产生内存分区和作业信息的方式！

";

cin>>choice1;

if（choice1==1）

{

num=rand（）&10;

q=num;

intid3=2+rand（）%8;

m=id3;//内存区数量

create_apply（）;

create_pro（）;

}

if（choice1==2）

{

create_zuoye（）;

create_fenqu（）;

}

vision（）;

cout<<"**------------------请选择处理算法----------------------**"<

cout<<"**1首次适应算法-----2循环首次适应算法-----3最佳适应算法**"<

cout<<"**4最坏适应算法----------5紧凑算法------------6回收算法**"<

cout<<"**------------------------------------------------------**"<

cin>>id1;

if（id1==1）{first_fit（）;}

if（id1==2）{next_fit（）;}

if（id1==3）{best_fit（）;}

if（id1==4）{worst_fit（）;}

if（id1==5）{compact（）;}

if（id1==6）{

cout<<"*******************生成内存状态******************"<

intid3=rand（）%10;

m=5;//内存区数量

create_apply（）;

vision（）;

cout<<"请您从空闲列表中选出需要回收的内存块（必须是已分配）：

"<

cin>>recycle;

if（（recycle>m）||（recycle<1））

{

cout<<"错误:

内存中不存在此块！

"<

}else{

intid2=-9999;

for（i=0;i

if（ary2[i][0]==recycle）{

cout<<"错误：

输入的为空闲盘块！

"<

id2=1;

break;

}

}

if（id2==-9999）{

apply_recycle（）;}

}

}

cout<<"****************************"<

cout<<"是否继续演示别的算法！

"<

cout<<"1--是0--否"<

cout<<"****************************"<

into;

cin>>o;

flag=o;

}

}

）