操作系统实验四动态分区分配算法源代码.docx

操作系统实验四动态分区分配算法源代码.docx

《操作系统实验四动态分区分配算法源代码.docx》由会员分享，可在线阅读，更多相关《操作系统实验四动态分区分配算法源代码.docx（13页珍藏版）》请在冰豆网上搜索。

操作系统实验四动态分区分配算法源代码

实验四操作系统-动态分区分配算法

萨斯的发生的v设计程序模拟四种动态分区分配算法:

首次适应算法、循环首次适应算法、最佳适应算法与最坏适应算法的工作过程。

假设内存中空闲分区个数为n,空闲分区大小分别为P1,…,Pn,在动态分区分配过程中需要分配的进程个数为m（m≤n）,它们需要的分区大小分别为S1,…,Sm,分别利用四种动态分区分配算法将m个进程放入n个空闲分区,给出进程在空闲分区中的分配情况。

程序要求如下:

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

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

3）输入:

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

4）输出:

最终内存空闲分区的分配情况。

代码实现:

#include

#include

#include

usingnamespacestd;

constintMaxNumber=100;

intFreePartition[MaxNumber];//空闲分区大小

intFirstPartition[MaxNumber];//1-首次适应算法

intCycleFirstPartition[MaxNumber];//2-循环首次适应算法

intBestPartition[MaxNumber];//3-最佳适应算法

intWorstPartition[MaxNumber];//4-最坏适应算法

intProcessNeed[MaxNumber];//进程需要的分区大小

intPartitionNum,ProcessNum;

charProcessName[MaxNumber];//进程名

charProcessPartition[MaxNumber];//进程分配的序列

intPartition[MaxNumber];

charstr[MaxNumber][MaxNumber];

voidFirstFit（intn,intm）;

voidNextFit（intn,intm）;

voidBestFit（intn,intm）;

voidWorstFit（intn,intm）;

voidPrint（intn,intm）;

voidPrint2（intn,intm）;

//========================================================

voidFirstFit（intn,intm）

{

cout<<"选择了首次适应算法!

"<

cout<

inti,j,k=0;

for（i=0;i

{

FirstPartition[i]=FreePartition[i];

}

for（j=0;j

{

for（i=0;i

{

if（ProcessNeed[j]<=FirstPartition[i]）

{

ProcessPartition[j]=i;

//str[i][k]=ProcessName[j];

FirstPartition[i]=FirstPartition[i]-ProcessNeed[j];

break;

}

}

}

Print（n,m）;

cout<<"空间序号:

"<<"";

for（i=0;i

{

cout<<"|"<

}

cout<

cout<<"分区大小:

"<<"";

for（i=0;i

{

cout<<"|"<

:

left）<

}

cout<

cout<<"剩余分区大小:

";

for（i=0;i

{

cout<<"|"<

:

left）<

}

cout<

Print2（n,m）;

}

voidNextFit（intn,intm）

{

cout<<"选择了循环首次适应算法!

"<

cout<

inti,j,flag=0;

for（i=0;i

{

CycleFirstPartition[i]=FreePartition[i];

}

for（j=0;j

{

for（i=flag;i

{

if（ProcessNeed[j]<=CycleFirstPartition[i]）

{

ProcessPartition[j]=i;

CycleFirstPartition[i]=CycleFirstPartition[i]-ProcessNeed[j];

flag=i+1;

if（i==n-1）

{

flag=0;

}

break;

}

}

}

Print（n,m）;

cout<<"空间序号:

"<<"";

for（i=0;i

{

cout<<"|"<

}

cout<

cout<<"分区大小:

"<<"";

for（i=0;i

{

cout<<"|"<

:

left）<

}

cout<

cout<<"剩余分区大小:

";

for（i=0;i

{

cout<<"|"<

:

left）<

}

cout<

Print2（n,m）;

}

voidBestFit（intn,intm）

{

cout<<"选择了最佳适应算法!

"<

cout<

inti,j,flag=0,temp,id=0,flag1=0;

for（i=0;i

{

BestPartition[i]=FreePartition[i];

}

while（flag1

{

flag=0;

for（i=0;i

{

Partition[i]=0;

}

for（i=0;i

{

if（ProcessNeed[flag1]<=BestPartition[i]）

{

Partition[flag]=i;

flag+=1;

}

}

temp=BestPartition[Partition[0]];

id=Partition[0];

for（i=1;i

{

if（temp>BestPartition[Partition[i]]）

{

temp=BestPartition[Partition[i]];

id=Partition[i];

}

}

BestPartition[id]=BestPartition[id]-ProcessNeed[flag1];

ProcessPartition[flag1]=id;

flag1+=1;

}

Print（n,m）;

cout<<"空间序号:

"<<"";

for（i=0;i

{

cout<<"|"<

}

cout<

cout<<"分区大小:

"<<"";

for（i=0;i

{

cout<<"|"<

:

left）<

}

cout<

cout<<"剩余分区大小:

";

for（i=0;i

{

cout<<"|"<

:

left）<

}

cout<

Print2（n,m）;

}

voidWorstFit（intn,intm）

{

cout<<"选择了最坏适应算法!

"<

cout<

inti,j,flag=0,temp,id=0,flag1=0;

for（i=0;i

{

WorstPartition[i]=FreePartition[i];

}

while（flag1

{

flag=0;

for（i=0;i

{

Partition[i]=0;

}

for（i=0;i

{

if（ProcessNeed[flag1]<=WorstPartition[i]）

{

Partition[flag]=i;

flag+=1;

}

}

temp=WorstPartition[Partition[0]];

id=Partition[0];

for（i=1;i

{

if（WorstPartition[Partition[i]]>temp）

{

temp=WorstPartition[Partition[i]];

id=Partition[i];

}

}

WorstPartition[id]=WorstPartition[id]-ProcessNeed[flag1];

ProcessPartition[flag1]=id;

flag1+=1;

}

Print（n,m）;

cout<<"空间序号:

"<<"";

for（i=0;i

{

cout<<"|"<

}

cout<

cout<<"分区大小:

"<<"";

for（i=0;i

{

cout<<"|"<

:

left）<

}

cout<

cout<<"剩余分区大小:

";

for（i=0;i

{

cout<<"|"<