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

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

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

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

操作系统课程设计

动态分区分配存储管理

吕霆

20102675

计算机10-01班

第一章课程设计概述

1.1设计任务:

动态分区分配存储管理

1.2设计要求

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

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

使用两种方式产生进程：

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

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

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

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

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

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

支持算法：

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

最坏适应算法。

1.3设计目的

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

第二章原理及算法描述

2.1动态分区分配算法原理

首次适应算法

*算法概述：

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

*实现方法：

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

循环首次适应算法

*算法概述：

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

*实现方法：

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

最佳适应算法

*算法概述：

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

*实现方法：

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

最坏适应算法

*算法概述：

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

*实现方法：

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

回收分区

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

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

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

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

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

紧凑算法

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

第三章开发环境

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

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

#include

#include

#include

usingnamespacestd;

ofstreamstream;//输出流对象

intary1[20][4];//内存分配状态

intary2[20][3];//空闲分区状态

intary3[10];//进程分配状态

intrecycle;//需要回收的盘块序号

intid1;//算法选择号

intm;//内存区数

intn;//空闲区数

intq;//进程数

intr=0;//循环首次适应算法：

对应的这次查找到的空闲分区序号

//打印输出函数

voidvision（）

{

inti;

intj;

if（id1==1）stream.open（"first_fit.txt",ios:

:

app）;

if（id1==2）stream.open（"nextfirst_fit.txt",ios:

:

app）;

if（id1==3）stream.open（"best_fit.txt",ios:

:

app）;

if（id1==4）stream.open（"worst_fit.txt",ios:

:

app）;

if（id1==5）stream.open（"compact.txt",ios:

:

app）;

if（id1==6）stream.open（"huishou.txt",ios:

:

app）;

cout<<"-------------内存分配状态-------------"<

cout<<"分区号大小/KB始址/KB状态"<

stream<<"-------------内存分配状态-------------"<

stream<<"分区号大小/KB始址/KB状态"<

for（j=0;j

{

cout<

stream<

cout<

stream<

cout<

stream<

if（ary1[j][3]==2）{

cout<<"已分配";

stream<<"已分配";}

else{

cout<<"未分配";

stream<<"未分配";

}

cout<

stream<

}

cout<

cout<<"--------空闲分区链--------"<

cout<<"分区号大小/KB起址/KB"<

stream<<"--------空闲分区链--------"<

stream<<"分区号大小/KB起址/KB"<

for（i=0;i

{

cout<

stream<

cout<

stream<

cout<

stream<

cout<

stream<

}

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

stream<<"--------------------------"<

cout<

stream.close（）;

}

//作业信息的自动产生

voidcreate_pro（）

{

inti;

for（i=0;i

{

ary3[i]=rand（）%100;

if（ary3[i]==0）

{i--;}

}

ary3[0]=42;

ary3[1]=86;

cout<<"产生"<

cout<<"大小分别是:

";

for（i=0;i

cout<<"["<

}

cout<

}

//作业的手动生成

voidcreate_zuoye（）{

intj;

intchoice2;

intid3=rand（）%10;

m=id3;//内存区数量

cout<<"---您将创建几个进程---：

";

cin>>choice2;

q=choice2;

cout<<"输入想创建的作业请求大小"<

for（inti=0;i

{

cin>>j;

ary3[i]=j;

}

cout<<"你创建了"<

for（inti=0;i

cout<

}

cout<

}

//内存信息的自动产生

voidcreate_apply（）

{

inti;

for（i=0;i

{

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

ary1[i][1]=rand（）%100;

if（i==0）

ary1[i][2]=0;

else

{

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

}

ary1[i][3]=rand（）%3;

//cout<

if（ary1[i][1]==0）

{i--;}

}

intk=0;//空闲区数量

for（i=0;i

{

if（ary1[i][3]!

=2）

{ary2[k][0]=ary1[i][0];

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

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

k++;

}

}

n=k;//空闲块数量

}

//内存信息的手动生成

intcreate_fenqu（）{

intk,x,y,o=0;

inta=0;

cout<<"输入想创建的内存分区块数:

";

cin>>k;

cout<<"输入"<

for（inti=0;i

ary1[i][0]=i;//序号

cin>>x;

ary1[i][1]=x;//大小

}

cout<<"输入内存块的分配状态"<

for（inti=0;i

cin>>y;

if（y==2）{

n++;

}

ary1[i][3]=y;//状态

}

ary1[0][2]=0;

ary1[1][2]=ary1[0][1];

for（inti=2;i

ary1[i][2]=ary1[i-1][2]+ary1[i-1][1];//起始地址

}

m=k;

for（inti=0;i

{

if（ary1[i][3]!

=2）{

ary2[a][0]=ary1[i][0];

ary2[a][1]=ary1[i][1];

ary2[a][2]=ary1[i][2];

a++;

}

}

n=a;

returnm,n;

}

//首次适应算法

voidfirst_fit（）

{

vision（）;

inti;

intj;

intk;

intl;

intd;//用来保存第k个的值

intid2=0;

for（i=0;i

{

for（j=0;j

{

if（ary2[j][1]>=ary3[i]）//进程占用空间小于等于其中一个空闲区的大小

{

cout<<"["<

stream.open（"first_fit.txt",ios:

:

app）;

stream<<"["<

stream.close（）;

if（ary2[j][1]==ary3[i]）//进程占用空间等于其中一个空闲区块大小

{

ary1[ary2[j][0]-1][3]=2;

for（k=j+1;k

{

ary2[k-1][0]=ary2[k][0];

ary2[k-1][1]=ary2[k][1];

ary2[k-1][2]=ary2[k][2];

}

n--;

}else//否则的话，空闲链对应的地方盘块大小小了进程占用的大小，并且内存分配从对应的那一项开始增加一项

{

l=ary2[j][0];

d=ary1[l-1][1];//大小

ary1[l-1][1]=ary3[i];

ary1[l-1][3]=2;

m++;

for（k=m;k>ary2[j][0]+1;k--）

{

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

ary1[k-1][1]=ary1[k-2][1];

ary1[k-1][2]=ary1[k-2][2];

ary1[k-1][3]=ary1[k-2][3];

}

l=ary2[j][0];

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

ary1[l][1]=d-ary3[i];

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

ary1[l][3]=0;

k=0;

for（id2=0;id2

{

if（ary1[id2][3]!

=2）

{

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

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

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

k++;

}

}

n=k;

}

break;

}

else

{

cout<<"["<

stream.open（"first_fit.txt",ios:

:

app）;

stream<<"["<

stream.close（）;

}

}

vision（）;

}

}

//首次循环适应算法

voidnext_fit（）

{

vision（）;

inti;

intj;

intk;

ints;

intd;

intid2;

for（i=0;i

{

for（j=r;j

{

if（ary3[i]<=ary2[j][1]）

{

cout<<"["<

stream.open（"nextfirst_fit.txt",ios:

:

app）;

stream<<"["<

stream.close（）;

if（ary3[i]==ary2[j][1]）

{

//---改变内存分配---

k=ary2[j][0];//得到对应空闲块对应内存块的序号

k--;

ary1[k][3]=2;//把对应内存块标志位上改成已分配

//------------------

//--改变空闲块表：

把从这块空闲块以下的所有空闲块向上移一格--

n--;

for（k=j;k

{

ary2[k][0]=ary2[k+1][0];

ary2[k][1]=ary2[k+1][1];

ary2[k][2]=ary2[k+1][2];

}

vision（）;

//------------------

break;

}

else//对应的空闲块大小大于进程需要大小

{

//-----改变内存分配情况-----

r=（r+1）%n;

//改变第k块的内容

k=ary2[j][0];

d=ary1[k-1][1];

ary1[k-1][1]=ary3[i];

ary1[k-1][3]=2;

//从k+1之后所有向后移一格

m++;//内存块数增加1

for（s=m-1;s>k;s--）

{

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

ary1[s][1]=ary1[s-1][1];

ary1[s][2]=ary1[s-1][2];

ary1[s][3]=ary1[s-1][3];

}

//改变第k+1块内容：

对应的数组是ary1[k]

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

ary1[k][1]=d-ary1[k-1][1];

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

//--------------------------

//----改变空闲表分配情况----

k=0;

for（id2=0;id2

{

if（ary1[id2][3]!

=2）

{

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

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

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

k++;

}

}

n=k;

//--------------------------

vision（）;

break;

}

}

else{

cout<<"["<

stream.open（"nextfirst_fit.txt",ios:

:

app）;

stream<<"["<

stream.close（）;

}

}

}

}

//思路：

先把空闲列表检索一遍，选出最佳答案，进行分配

voidbest_fit（）//最佳算法--按顺序检索，把与进程要求内存大小最接近的快分配给进程

{

inti;

ints;

intj=-9999;//用来保存最接近的答案

inte;//用来存放进行比较时的中间结果

intk;

intl;

intd;

intid2;

vision（）;

for（i=0;i

{e=9999;

j=-9999;

for（s=0;s

{

if（（ary2[s][1]>=ary3[i]）&&（e>ary2[s][1]））//满足分配要求

{

e=ary2[s][1];

j=s;

}

}

if（j<0）

{

cout<<"["<

stream.open（"best_fit.txt",ios:

:

app）;

stream<<"["<

stream.close（）;

}else

{

cout<<"["<

stream.open（"best_fit.txt",ios:

:

app）;

stream<<"["<

stream.close（）;

if（ary2[j][1]==ary3[i]）

{

k=ary2[j][0];

ary1[k-1][3]=2;

for（l=k;l

{

ary2[l-1][0]=ary2[l][0];

ary2[l-1][1]=ary2[l][1];

ary2[l-1][2]=ary2[l][2];

}

n--;

}

else

{

//把对应的内存分配进行更改

k=ary2[j][0];

d=ary1[k-1][1];

ary1[k-1][1]=ary3[i];

ary1[k-1][3]=2;

m++;

for（l=m;l>ary2[j][0]+1;l--）

{

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

ary1[l-1][1]=ary1[l-2][1];

ary1[l-1][2]=ary1[l-2][2];

ary1[l-1][3]=ary1[l-2][3];

}

k=ary2[j][0];

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

ary1[k][1]=d-ary1[k-1][1];

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

ary1[k][3]=0;

k=0;

for（id2=0;id2

{

if（ary1[id2][3]!

=2）

{

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

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

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

k++;

}

}

n=k;

for（k=j+1;k

{

ary2[k][0]++;

}

}

}

vision（）;

}

}

//最坏适应算法

voidworst_fit（）

{

inti;

ints;

intj=-99