操作系统课程设计动态分区分配存储管理Word文档下载推荐.docx
《操作系统课程设计动态分区分配存储管理Word文档下载推荐.docx》由会员分享，可在线阅读，更多相关《操作系统课程设计动态分区分配存储管理Word文档下载推荐.docx（41页珍藏版）》请在冰豆网上搜索。
最坏适应算法
每次为作业分配内存时，总是挑选一个最大的空闲分区分割给作业使用
算法与最佳适应算法几乎相同，仅在排序时把空闲分区表按从大到小的顺序排列，所以未作详细注释
回收分区
当进程运行完毕释放内存时,系统根据回收区的首址,从空闲区链（表）中找到相应的插入点,此时可能出现以下四种情况之一;
1）回收区与插入点的前一个空闲分区F1相邻接,此时应将回收区与插入点的前一分区合并,不必为回收区分配新表项,而只需修改其前一分区F1的大小.
2）回收分区与插入点的后一空闲分区F2相邻接,此时也可将两分区合并,形成新的空闲分区,但用回收区的首址作为新空闲区的首址,大小为两者之和.
3）回收区同时与插入点的前,后两个分区邻接,此时将三个分区合并,使用F1的表项和F1的首址,取消F2的表项,大小为三者之和.
4）回收区既不与F1相邻接,又不与F2邻接.这时应为回收区单独建立一新表项,填写回收区的首址和大小,并根据其首址插入到空闲链中的适当位置.
紧凑算法
通过移动内存中的作业的位置,以把原来多个分散的小分区拼接成一个大分区的方法.
第三章开发环境
此程序是本人利用c++语言在vs2012的开发环境中实现的
第四章程序实现--数据结构
#include<
iostream>
string>
fstream>
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"
if（id1==3）stream.open（"
best_fit.txt"
ios:
if（id1==4）stream.open（"
worst_fit.txt"
if（id1==5）stream.open（"
compact.txt"
if（id1==6）stream.open（"
huishou.txt"
cout<
<
"
-------------内存分配状态-------------"
endl;
分区号大小/KB始址/KB状态"
stream<
for（j=0;
j<
m;
j++）
{
cout<
ary1[j][0]<
"
;
stream<
ary1[j][1]<
ary1[j][2]<
if（ary1[j][3]==2）{
cout<
已分配"
stream<
}
else{
未分配"
}
}
cout<
--------空闲分区链--------"
分区号大小/KB起址/KB"
for（i=0;
i<
n;
i++）
cout<
ary2[i][0]<
ary2[i][1]<
ary2[i][2];
--------------------------"
stream.close（）;
//作业信息的自动产生
voidcreate_pro（）
{
q;
ary3[i]=rand（）%100;
if（ary3[i]==0）
{i--;
ary3[0]=42;
ary3[1]=86;
产生"
q<
个随机进程"
大小分别是:
i++）{
["
ary3[i]<
]"
//作业的手动生成
voidcreate_zuoye（）{
intchoice2;
intid3=rand（）%10;
m=id3;
//内存区数量
---您将创建几个进程---：
;
cin>
>
choice2;
q=choice2;
输入想创建的作业请求大小"
for（inti=0;
cin>
j;
ary3[i]=j;
你创建了"
choice2<
个进程"
//内存信息的自动产生
voidcreate_apply（）
for（i=0;
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）
intk=0;
//空闲区数量
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;
输入想创建的内存分区块数:
k;
输入"
k<
个内存分区块大小"
ary1[i][0]=i;
//序号
x;
ary1[i][1]=x;
//大小
输入内存块的分配状态"
y;
if（y==2）{
n++;
ary1[i][3]=y;
//状态
ary1[0][2]=0;
ary1[1][2]=ary1[0][1];
for（inti=2;
ary1[i][2]=ary1[i-1][2]+ary1[i-1][1];
//起始地址
m=k;
for（inti=0;
=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（）;
intk;
intl;
intd;
//用来保存第k个的值
intid2=0;
i++）//为每个进程分配空间
for（j=0;
j++）//查找空闲链表每项
if（ary2[j][1]>
=ary3[i]）//进程占用空间小于等于其中一个空闲区的大小
{
cout<
]与"
ary2[j][1]<
]相匹配"
stream.open（"
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];
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<
id2++）
if（ary1[id2][3]!
{
ary2[k][0]=ary1[id2][0];
ary2[k][1]=ary1[id2][1];
ary2[k][2]=ary1[id2][2];
k++;
}
n=k;
break;
}
else
]不匹配"
}
vision（）;
//首次循环适应算法
voidnext_fit（）
inti;
intj;
intk;
ints;
intd;
intid2;
for（i=0;
i++）//对每一个进程队列中的进程分配资源
for（j=r;
if（ary3[i]<
=ary2[j][1]）
stream.open（"
if（ary3[i]==ary2[j][1]）
//---改变内存分配---
k=ary2[j][0];
//得到对应空闲块对应内存块的序号
k--;
ary1[k][3]=2;
//把对应内存块标志位上改成已分配
//------------------
//--改变空闲块表：
把从这块空闲块以下的所有空闲块向上移一格--
for（k=j;
ary2[k][0]=ary2[k+1][0];
ary2[k][1]=ary2[k+1][1];
ary2[k][2]=ary2[k+1][2];
vision（）;
else//对应的空闲块大小大于进程需要大小
//-----改变内存分配情况-----
r=（r+1）%n;
//改变第k块的内容
d=ary1[k-1][1];
ary1[k-1][1]=ary3[i];
ary1[k-1][3]=2;
//从k+1之后所有向后移一格
//内存块数增加1
for（s=m-1;
s>
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];
//--------------------------
//----改变空闲表分配情况----
//思路：
先把空闲列表检索一遍，选出最佳答案，进行分配
voidbest_fit（）//最佳算法--按顺序检索，把与进程要求内存大小最接近的快分配给进程
ints;
intj=-9999;
//用来保存最接近的答案
inte;
//用来存放进行比较时的中间结果
intid2;
{e=9999;
j=-9999;
for（s=0;
s<
s++）
if（（ary2[s][1]>
=ary3[i]）&
&
（e>
ary2[s][1]））//满足分配要求
e=ary2[s][1];
j=s;
if（j<
0）
所有空闲盘块不匹配"
stream.close（）;
}else
]最佳相匹配"
if（ary2[j][1]==ary3[i]）
for（l=k;
l<
l++）
ary2[l-1][0]=ary2[l][0];
ary2[l-1][1]=ary2[l][1];
ary2[l-1][2]=ary2[l][2];
//把对应的内存分配进行更改
for（l=m;
l>
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];
ary1[k][0]=k+1;
ary1[k][3]=0;
k=0;
ary2[k][0]++;
//最坏适应算法
voidworst_fit（）
intj=-99
升级会员 