操作系统实验报告实验四-动态分区分配算法有运行图

配程序执行之后的结果图

实验目的

通过这次实验，加深对动态分区分配算法的理解，进一步掌握首次适应算法、循环首次适应算法、最佳适应算法和最坏适应算法的实现方法。

【实验内容】

问题描述：

设计程序模拟四种动态分区分配算法：首次适应算法、循环首次适应算法、最佳适应算法和最坏适应算法的工作过程。假设内存中空闲分区个数为n，空闲分区大小分别为P1, … ,Pn，在动态分区分配过程中需要分配的进程个数为m（m≤n），它们需要的分区大小分别为S1, … ,Sm，分别利用四种动态分区分配算法将m个进程放入n个空闲分区，给出进程在空闲分区中的分配情况。 程序要求如下：

1）利用首次适应算法、循环首次适应算法、最佳适应算法和最坏适应算法四种动态分区分配算法模拟分区分配过程。

2）模拟四种算法的分区分配过程，给出每种算法进程在空闲分区中的分配情况。

3）输入：空闲分区个数n，空闲分区大小P1, … ,Pn，进程个数m，进程需要的分区大小S1, … ,Sm，算法选择1-首次适应算法，2-循环首次适应算法，3-最佳适应算法，4-最坏适应算法。

4）输出：最终内存空闲分区的分配情况。

实现提示：

配程序执行之后的结果图

用C++语言实现提示：

1）程序中变量定义参考（根据需要可添加）如下：

const int MaxNumber=100; int FreePartition[MaxNumber]; int FirstPartition[MaxNumber]; int CycleFirstPartition[MaxNumber]; int BestPartition[MaxNumber]; int WorstPartition[MaxNumber]; int ProcessNeed[MaxNumber]; int PartitionNum,ProcessNum;

2）页面置换的实现过程如下：

变量初始化；

空闲分区个数n，空闲分区大小P1, … ,Pn，进程个数m，进程需要的分区大小S1, … ,Sm，算法选择1-首次适应算法，2-循环首次适应算法，3-最佳适应算法，4-最坏适应算法；

根据用户选择的算法进行动态分区分配；

输出所有进程分配后的空闲分区分配情况。

实验要求：

1) 上机前认真复习动态分区分配算法，熟悉首次适应算法、循环首次适应算法、最佳适应算法和最坏适应算法的计算过程；

2) 上机时独立编程、调试程序；

3) 根据具体实验要求，完成好实验报告（包括实验的目的、内容、要求、源

配程序执行之后的结果图

程序、实例运行结果截图）。

【源程序】

头文件First.h

#include<iostream.h>

#include<string.h>

#include<iomanip.h>

#include<stdlib.h>

#define Proprintf printf("|-----+-----+-----+-----+-----+-----+-----+-----+-----|\n")

#define Myprintf printf("|++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++|\n") #define MaxNum 100

typedef struct ProcessPartition_struct{

int FreePartition[MaxNum]; //空闲分区大小

char ProcessName[MaxNum]; //作业名称

int ProcessNeed[MaxNum]; //作业需求空间大小

int state[MaxNum]; //作业分配标志

int PartitionNum,ProcessNum; //空闲分区个数，作业个数

}Process;

Process p;

int i,j,k,d,temp;

char order[MaxNum][MaxNum];

char ch[MaxNum];

int m; //作业个数

int n; //空闲分区个数

int First();

int CycleFirst();

int Best();

int Worst();

int Option(); //选择算法

int Pinput(); //参数输入

int Poutput(); //结果输出

int Pinput() //参数输入

{

printf("请输入空闲分区个数:\n");

scanf("%d",&n);

printf("请依次输入空闲分区大小(KB):\n");

for(i=0;i<n;i++)

{

配程序执行之后的结果图

scanf("%d",&p.FreePartition[i]);

}

printf("请输入作业个数:\n");

scanf("%d",&m);

printf("请依次输入作业名称:\n");

for(i=0;i<m;i++)

{

scanf("%c%c",&ch[i],&p.ProcessName[i]);

}

printf("请依次输入作业大小(KB):\n");

for(i=0;i<m;i++)

{

scanf("%d",&p.ProcessNeed[i]);

p.state[i]=0;

}

Proprintf;

for(i=0;i<n;i++)

{

printf("|%3d ",p.FreePartition[i]);

}

printf("|\n");

Proprintf;

printf("作业信息如下:\n");

for(i=0;i<m;i++)

{

printf("%3c",p.ProcessName[i]);

}

printf("\n");

for(i=0;i<m;i++)

{

printf("%3d",p.ProcessNeed[i]);

}

printf("\n");

return 0;

}

int First() //首次适应算法

{

for(i=0;i<m;i++)

{

for(j=0;j<n;j++)

{

//找到第一个合适的空闲分区

if((p.ProcessNeed[i] <= p.FreePartition[j]) && (!p.state[i]))

配程序执行之后的结果图

for(k=0;k<3;k++) //记录作业分配

{

if(order[j][k]==NULL)

{

order[j][k]=p.ProcessName[i];

break;

}

else

continue;

}

p.FreePartition[j]=p.FreePartition[j]-p.ProcessNeed[i];

p.state[i]=1;

}

}

}

return 0;

}

头文件CycleFirst.h

#include<iostream.h>

#include<string.h>

#include<iomanip.h>

#include<stdlib.h>

int CycleFirst() //循环首次适应算法

{

i=0;

j=0;

while((i<n) && (j<m))

{

if((p.ProcessNeed[i] <= p.FreePartition[j]) && (!p.state[i]))

{

for(k=0;k<3;k++) //记录作业分配

{

if(order[j][k]==NULL)

{

order[j][k]=p.ProcessName[i];

break;

}

else

continue;

}

p.FreePartition[j]=p.FreePartition[j]-p.ProcessNeed[i];

p.state[i]=1;

配程序执行之后的结果图

}

else

j++;

}

return 0;

}

头文件Best.h

#include<iostream.h>

#include<string.h>

#include<iomanip.h>

#include<stdlib.h>

int Best() //最佳适应算法

{

for(i=0;i<m;i++)

{

temp=p.FreePartition[0];

k=0;

//找到第一个合适的空闲分区

while(p.ProcessNeed[i] > temp)

{

k++;

temp=p.FreePartition[k];

}

for(j=0;j<n;j++)

{

//按最佳适应算法找到符合的空闲区

if((p.ProcessNeed[i] <= p.FreePartition[j]) && (temp > p.FreePartition[j]) && (!p.state[i]))

{

temp=p.FreePartition[j];

k=j;

}

else

continue;

}

for(d=0;d<3;d++) //记录作业分配

{

if(order[k][d]==NULL)

{

order[k][d]=p.ProcessName[i];

break;

}

配程序执行之后的结果图

else

continue;

}

p.FreePartition[k]=p.FreePartition[k]-p.ProcessNeed[i];

p.state[i]=1;

}

return 0;

}

头文件Worst.h

#include<iostream.h>

#include<string.h>

#include<iomanip.h>

#include<stdlib.h>

int Worst() //最坏适应算法

{

for(i=0;i<m;i++)

{

temp=p.FreePartition[0];

k=0;

for(j=0;j<n;j++)

{

//按最坏适应算法找到合适的空闲分区

if((p.ProcessNeed[i] <= p.FreePartition[j]) && (temp < p.FreePartition[j]) && (!p.state[i]))

{

temp=p.FreePartition[j];

k=j;

}

else

continue;

}

for(d=0;d<3;d++) //记录作业分配

{

if(order[k][d]==NULL)

{

order[k][d]=p.ProcessName[i];

break;

}

else

continue;

}

p.FreePartition[k]=p.FreePartition[k]-p.ProcessNeed[i];

p.state[i]=1;

配程序执行之后的结果图

}

return 0;

}

主程序Main.cpp

#include<iostream.h>

#include<string.h>

#include<iomanip.h>

#include<stdlib.h>

#include<First.h>

#include<CycleFirst.h>

#include<Best.h>

#include<Worst.h>

int Option() //选择算法

{

int option;

printf("请选择算法:\n");

printf("0-退出\n");

printf("1-首次适应算法\n");

printf("2-循环首次适应算法\n");

printf("3-最佳适应算法\n");

printf("4-最坏适应算法\n");

printf("请输入你选择的算法的序号:\n");

scanf("%d",&option);

switch(option)

{

case 0:

printf("程序运行结束\n");

break;

case 1:

printf("对作业用首次适应算法进行空间分配:\n");

First();

Poutput();

break;

case 2:

printf("对作业用循环首次适应算法进行空间分配:\n"); CycleFirst();

Poutput();

break;

case 3:

printf("对作业用最佳适应算法进行空间分配:\n");

Best();

配程序执行之后的结果图

Poutput();

break;

case 4:

printf("对作业用最坏适应算法进行空间分配:\n");

Worst();

Poutput();

break;

default:

printf("********error!*****");

}

return 0;

}

int Poutput() //结果输出

{

Myprintf;

for(i=0;i<n;i++)

{

printf("|");

for(j=0;j<3;j++)

{

if(order[i][j]==' ')

printf(" ");

else

printf("%2c",order[i][j]);

}

}

printf("|\n");

Myprintf;

return 0;

}

void main() //主函数

{

Pinput();

Option();

}

【实例运行结果截图】

实例

配程序执行之后的结果图

下面依次是测试数据、First、CycleFirst、Best和Worst算法执行的截图：

配程序执行之后的结果图

本文来源：https://www.bwwdw.com/article/vvji.html