计算机操作系统课程设计报告《存储管理动态分区分配算法的模拟》.docx
《计算机操作系统课程设计报告《存储管理动态分区分配算法的模拟》.docx》由会员分享，可在线阅读，更多相关《计算机操作系统课程设计报告《存储管理动态分区分配算法的模拟》.docx（24页珍藏版）》请在冰豆网上搜索。
计算机操作系统课程设计报告《存储管理动态分区分配算法的模拟》
《计算机操作系统》课程设计
题目：
存储管理——动态分区分配算法的模拟
专业：
软件工程
年级：
2012级
小组成员：
指导教师：
时间：
地点：
2012年5月
概述
动态分区分配是根据进程的实际需要，动态地为之分配内存空间，而在分配时，须按照一定的分配算法，从空闲分区表或空闲分区链中选出一分区分配给该作业。
在本实验中运用了五种分配算法，分别是：
1.首次适应算法
2.循环首次适应算法
3.最坏适应算法
4.最佳适应算法
5.快速适应算法
2.课程设计任务及要求
2.1设计任务
要求设计主界面以灵活选择其中算法，5种算法都要求实现。
2.2设计要求
1）首先由系统生成当前的内存状态，要求未分配的分区数量不少于3个，
且空间大小随机，然后随机生成一个数，表示等待分配进程的大小。
2）然后显示上述算法由用户选择，结果显示分配后的状态。
2.3课程设计任务安排
日期
A
B
星期三下午
研究算法
研究算法
星期四早上
设计算法
参与设计
星期四下午
设计算法，编写界面
参与设计
星期五早上
编写算法
完成部分文档
星期五下午
程序测试并优化
程序测试，完成文档
3.算法及数据结构
3.1算法的总体思想（流程）
设计程序模拟四种动态分区分配算法：
首次适应算法、循环首次适应算法、最佳适应算法和最坏适应算法的工作过程。
假设内存中空闲分区个数为n，空闲分区大小分别为P1,…,Pn，在动态分区分配过程中需要分配的进程个数为m（m≤n），它们需要的分区大小分别为S1,…,Sm，分别利用四种动态分区分配算法将m个进程放入n个空闲分区，进程在空闲分区中的分配情况。
3.2首次适应算法
3.2.1功能
在首次适应算法中，是从已建立好的数组中顺序查找，直至找到第一个大小能满足要求的空闲分区为止，然后再按照作业大小，从该分区中划出一块内存空间分配给请求者，余下的空间令开辟一块新的地址，大小为原来的大小减去作业大小，若查找结束都不能找到一个满足要求的分区，则此次内存分配失败。
3.2.2数据结构（包括变量的定义，要注释！
）
privatestaticintMaxNum=100;
//空闲分区个数
privatestaticintn;
//作业个数
privatestaticintm;
//空闲分区大小
privatestaticintFreePartition[]=newint[MaxNum];
//作业名称
privatestaticcharProcessName[]=newchar[MaxNum];
//作业需求空间大小
privatestaticintProcessNeed[]=newint[MaxNum];
//作业分配标志
privatestaticbooleanstate[]=newboolean[MaxNum];
//空闲分区个数
privatestaticintPartitionNum;
//作业个数
privatestaticintProcessNum;
//记录作业分配
privatestaticcharorder[][]=newchar[MaxNum][MaxNum];
3.2.3算法（流程图表示，或伪C表示）
publicstaticvoidFirst（）
{
for（i=0;i{
for（j=0;j{
//找到第一个合适的空闲分区
if（（ProcessNeed[i]<=FreePartition[j]）&&（!
state[i]））
{
for（k=0;k<3;k++）//记录作业分配
{
if（order[j][k]==0）//为空
{
order[j][k]=ProcessName[i];
break;
}
else
continue;
}
FreePartition[j]=FreePartition[j]-ProcessNeed[i];
state[i]=true;
}
}
}
}
3.3循环首次适应算法
3.3.1功能
该算法是由首次适应算法演变而成，在为进程分配内存空间时，不再是每次都从第一个空间开始查找，而是从上次找到的空闲分区的下一个空闲分区开始查找，直至找到第一个能满足要求的空闲分区，从中划出一块与请求大小相等的内存空间分配给作业，为实现本算法，设置一个全局变量f，来控制循环查找，当f%N==0时，f=0；若查找结束都不能找到一个满足要求的分区，则此次内存分配失败。
3.3.2数据结构
privatestaticintMaxNum=100;
//空闲分区个数
privatestaticintn;
//作业个数
privatestaticintm;
//空闲分区大小
privatestaticintFreePartition[]=newint[MaxNum];
//作业名称
privatestaticcharProcessName[]=newchar[MaxNum];
//作业需求空间大小
privatestaticintProcessNeed[]=newint[MaxNum];
//作业分配标志
privatestaticbooleanstate[]=newboolean[MaxNum];
//空闲分区个数
privatestaticintPartitionNum;
//作业个数
privatestaticintProcessNum;
//记录作业分配
privatestaticcharorder[][]=newchar[MaxNum][MaxNum];
3.3.3算法
publicstaticvoidCycleFirst（）
{
i=0;
j=0;
while（（i{
if（（ProcessNeed[i]<=FreePartition[j]）&&（!
state[i]））
{
for（k=0;k<3;k++）//记录作业分配
{
if（order[j][k]==0）
{
order[j][k]=ProcessName[i];
break;
}
else
continue;
}
FreePartition[j]=FreePartition[j]-ProcessNeed[i];
state[i]=true;
i++;
}
else
j++;
}
}
3.4最佳适应算法
3.4.1功能
最佳适应分配算法是每次为作业分配内存时，扫描整个数组，总是把能满足条件的，又是最小的空闲分区分配给作业，避免“大材小用”。
该算法要求将所有的空闲分区按其容量以从小到大的顺序形成一空闲分区链。
这样，第一次找到的能满足要求的空闲区必然是最佳的。
3.4.2数据结构
privatestaticintMaxNum=100;
//空闲分区个数
privatestaticintn;
//作业个数
privatestaticintm;
//空闲分区大小
privatestaticintFreePartition[]=newint[MaxNum];
//作业名称
privatestaticcharProcessName[]=newchar[MaxNum];
//作业需求空间大小
privatestaticintProcessNeed[]=newint[MaxNum];
//作业分配标志
privatestaticbooleanstate[]=newboolean[MaxNum];
//空闲分区个数
privatestaticintPartitionNum;
//作业个数
privatestaticintProcessNum;
//记录作业分配
privatestaticcharorder[][]=newchar[MaxNum][MaxNum];
3.4.3算法
publicstaticvoidBest（）
{
for（i=0;i{
temp=FreePartition[0];
k=0;
//找到第一个合适的空闲分区
while（ProcessNeed[i]>temp）
{
k++;
temp=FreePartition[k];
}
for（j=0;j{
//按最佳适应算法找到符合的空闲区
if（（ProcessNeed[i]<=FreePartition[j]）&&（temp>FreePartition[j]）&&（!
state[i]））
{
temp=FreePartition[j];
k=j;
}
else
continue;
}
for（d=0;d<3;d++）//记录作业分配
{
if（order[k][d]==0）
{
order[k][d]=ProcessName[i];
break;
}
else
continue;
}
FreePartition[k]=FreePartition[k]-ProcessNeed[i];
state[i]=true;
}
}
3.5最坏适应算法
3.5.1功能
最坏适应分配算法选择空闲分区的策略正好与最佳适应算法相反。
是每次为作业分配内存时，扫描整个数组，总是把能满足条件的，又是最大的空闲分区分配给作业。
对中小作业
有利，同时查找效率很高。
3.5.2数据结构
privatestaticintMaxNum=100;
//空闲分区个数
privatestaticintn;
//作业个数
privatestaticintm;
//空闲分区大小
privatestaticintFreePartition[]=newint[MaxNum];
//作业名称
privatestaticcharProcessName[]=newchar[MaxNum];
//作业需求空间大小
privatestaticintProcessNeed[]=newint[MaxNum];
//作业分配标志
privatestaticbooleanstate[]=newboolean[MaxNum];
//空闲分区个数
privatestaticintPartitionNum;
//作业个数
privatestaticintProcessNum;
//记录作业分配
privatestaticcharorder[][]=newchar[MaxNum][MaxNum];
3.5.3算法
publicstaticvoidWorst（）
{
for（i=0;i{
temp=FreePartition[0];
k=0;
for（j=0;j{
//按最坏适应算法找到合适的空闲分区
if（（ProcessNeed[i]<=FreePartition[j]）&&（tempstate[i]））
{
temp=FreePartition[j];
k=j;
}
else
continue;
}
for（d=0;d<3;d++）//记录作业分配
{
if（order[k][d]==0）
{
order[k][d]=ProcessName[i];
break;
}
else
continue;
}
FreePartition[k]=FreePartition[k]-ProcessNeed[i];
state[i]=true;
}
}
4.程序设计与实现
4.1程序流程图
4.2程序代码（要注释）
D_ProcessPartition.java
importjava.io.BufferedInputStream;
importjava.io.FileInputStream;
importjava.io.FileNotFoundException;
importjava.util.Random;
importjava.util.Scanner;
publicclassD_ProcessPartition{
privatestaticintMaxNum=100;
//空闲分区个数
privatestaticintn;
//作业个数
privatestaticintm;
//空闲分区大小
privatestaticintFreePartition[]=newint[MaxNum];
//作业名称
privatestaticcharProcessName[]=newchar[MaxNum];
//作业需求空间大小
privatestaticintProcessNeed[]=newint[MaxNum];
//作业分配标志
privatestaticbooleanstate[]=newboolean[MaxNum];
//空闲分区个数
privatestaticintPartitionNum;
//作业个数
privatestaticintProcessNum;
//记录作业分配
privatestaticcharorder[][]=newchar[MaxNum][MaxNum];
//?
?
?
?
?
privatestaticcharch[]=newchar[MaxNum];
//临时变量
privatestaticinttemp;
//算法选择
//1-首次适应算法
//2-循环首次适应算法
//3-最佳适应算法
//4-最坏适应算法
privatestaticintoption=0;
//for循环中使用
privatestaticinti;
privatestaticintj;
privatestaticintk;
privatestaticintd;
privatestaticScannerstdin;
publicStringD_ProcessPartition（intoption,intn）throwsFileNotFoundException{
Stringxinxi="";
Stringzuoyexinxi="";
StringsuanfaString="";
//输入数据
xinxi=input（n）;
//选择算法
//1-首次适应算法
//2-循环首次适应算法
//3-最佳适应算法
//4-最坏适应算法
switch（option）
{
case1:
suanfaString="首次适应算法";
First（n）;
zuoyexinxi="对作业用首次适应算法进行空间分配:
\n"+output（n）;
break;
case2:
suanfaString="循环首次适应算法";
CycleFirst（n）;
zuoyexinxi="对作业用循环首次适应算法进行空间分配:
\n"+output（n）;
break;
case3:
suanfaString="最佳适应算法";
Best（n）;
zuoyexinxi="对作业用最佳适应算法进行空间分配:
\n"+output（n）;
break;
case4:
suanfaString="最坏适应算法";
Worst（n）;
zuoyexinxi="对作业用最坏适应算法进行空间分配:
\n"+output（n）;
break;
}
//返回数据在JTA上显示出来
Stringall="你选择了"+suanfaString+"\n\n"+xinxi+"\n\n"+zuoyexinxi;
returnall;
}
//输入数据
publicstaticStringinput（intn）throwsFileNotFoundException
{
//算法选择
//1-首次适应算法
//2-循环首次适应算法
//3-最佳适应算法
//4-最坏适应算法
Stringresult="";
//请依次输入空闲分区大小（KB）
for（i=0;iFreePartition[i]=RandomTest（）;
result=result+FreePartition[i]+"";
}
result="随机的"+n+"个空闲分区大小为:
"+result+"\n"+"随机的作业大小为:
";
//请输入作业个数,按题目要求默认为1可设置
m=1;
//固定的作业名称
ProcessName[i]="Process".charAt（0）;
ch[i]=ProcessName[i];
//按题目要求随机作业大小（KB）
for（i=0;i{
ProcessNeed[i]=RandomTest（）;
state[i]=false;
result=result+ProcessNeed[i];
}
returnresult;
}
publicstaticintRandomTest（）{
intmin=1;
Randomrandom=newRandom（）;
ints=random.nextInt（MaxNum）%（MaxNum-min+1）+min;
System.out.println（s）;
returns;
}
//1——首次适应算法
publicstaticvoidFirst（intn）
{
for（i=0;i{
for（j=0;j{
//找到第一个合适的空闲分区
if（（ProcessNeed[i]<=FreePartition[j]）&&（!
state[i]））
{
for（k=0;k<3;k++）//记录作业分配
{
if（order[j][k]==0）//为空
{
order[j][k]=ProcessName[i];
break;
}
else
continue;
}
FreePartition[j]=FreePartition[j]-ProcessNeed[i];
state[i]=true;
}
}
}
}
//2——循环首次适应算法
publicstaticvoidCycleFirst（intn）
{
i=0;
j=0;
while（（i{
if（（ProcessNeed[i]<=FreePartition[j]）&&（!
state[i]））
{
for（k=0;k<3;k++）//记录作业分配
{
if（order[j][k]==0）
{
order[j][k]=ProcessName[i];
break;
}
else
continue;
}
FreePartition[j]=FreePartition[j]-ProcessNeed[i];
state[i]=true;
i++;
}
else
j++;
}}
//3——最佳适应算法
publicstaticvoidBest（intn）
{
for（i=0;i{
temp=FreePartition[0];
k=0;
//找到第一个合适的空闲分区
while（ProcessNeed[i]>temp）
{
k++;
temp=FreePartition[k];
}
for（j=0;j{
//按最佳适应算法找到符合的空闲区
if（（ProcessNeed[i]<=FreePartition[j]）&&（temp>FreePartition[j]）&&（!
state[i]））
{
temp=FreePartition[j];
k=j;
}
else
continue;
升级会员 