使用动态优先权的进程调度算法的模拟.docx

使用动态优先权的进程调度算法的模拟.docx

《使用动态优先权的进程调度算法的模拟.docx》由会员分享，可在线阅读，更多相关《使用动态优先权的进程调度算法的模拟.docx（18页珍藏版）》请在冰点文库上搜索。

使用动态优先权的进程调度算法的模拟

实验四使用动态优先权的进程调度算法的模拟

1、实验目的

通过动态优先权算法的模拟加深对进程概念和进程调度过程的理解。

2、实验内容

（1）用C语言来实现对N个进程采用动态优先算法的进程调度；

（2）每个用来标识进程的进程控制块PCB用结构来描述，包括以下字段：

●进程标识符id

●进程优先数priority，并规定优先数越大的进程，其优先权越高；

●进程已占用的CPU时间cputime；

●进程还需占用的CPU时间alltime，当进程运行完毕时，alltime变为0；

●进程的阻塞时间startblock，表示当进程再运行startblock个时间片后，进程将进入阻塞状态；

●进程被阻塞的时间blocktime，表示已阻塞的进程再等待blocktime个时间片后，将转换成就绪态

●进程状态state；

●队列指针next，用来将PCB排成队列

（3）优先数改变的原则：

●进程在就绪队列中呆一个时间片，优先数增加1

●进程每运行一个时间片，优先数减3。

（4）假设在调度前，系统中有5个进程，它们的初始状态如下：

ID

0

1

2

3

4

PRIORITY

9

38

30

29

0

CPUTIME

0

0

0

0

0

ALLTIME

3

3

6

3

4

STARTBLOCK

2

-1

-1

-1

-1

BLOCKTIME

3

0

0

0

0

STATE

READY

READY

READY

READY

READY

（5）为了清楚地观察诸进程的调度过程，程序应将每个时间片内的进程的情况显示出来，参照的具体格式如下：

RUNNINGPROG：

i

READY_QUEUE:

->id1->id2

BLOCK_QUEUE:

->id3->id4

==================================

ID01234

PRIORITYP0P1P2P3P4

CPUTIMEC0C1C2C3C4

ALLTIMEA0A1A2A3A4

STARTBLOCKT0T1T2T3T4

BLOCKTIMEB0B1B2B3B4

STATES0S1S2S3S4

程序：

2、程序示例：

//A.4使用动态优先权的进程调度算法的模拟

//byYanQiwei

#include

#defineN5

voidinit（）;

voidprint（）;

intgetRunning（）;

voidsort（）;

intrun（inttime）;

enumSTATE{Ready,Run,Block,RunOut};

structPROCESS{

intID;

intPriority;

intCputime;

intAlltime;

intStartblock;

intBlocktime;

enumSTATEState;

}Process[N];

intREADY[N];

intBLOCK[N];

intRUNOUT[N][2];

intmain（）{

intTime=0;

init（）;

printf（"Time:

%d\n",Time）;

sort（）;

print（）;

while

（1）{

Time++;

getchar（）;

printf（"Time:

%d\n",Time）;

if（run（Time））

break;

//sort（）;

}

//print（Time）;

return0;

}

voidinit（）

{

inti;

//printf（"Inputpropertiesof%dprocess（PRIORITY,ALLTIME,STARTBLOCK,BLOCKTIME）:

\n",

//N）;

for（i=0;i

READY[i]=-1;

BLOCK[i]=-1;

RUNOUT[i][0]=-1;

RUNOUT[i][1]=-1;

Process[i].ID=i;

Process[i].Cputime=0;

Process[i].State=Ready;

/*printf（"Number%d:

",i）;

scanf（"%d,%d,%d,%d",&Process[i].Priority,&Process[i].Alltime,

&Process[i].Startblock,&Process[i].Blocktime）;

*/

Process[i].Startblock=-1;Process[i].Blocktime=0;

}

Process[0].Priority=9;Process[0].Alltime=3;Process[0].Startblock=2;Process[0].Blocktime=3;

Process[1].Priority=38;Process[1].Alltime=3;

Process[2].Priority=30;Process[2].Alltime=6;

Process[3].Priority=29;Process[3].Alltime=3;

Process[4].Priority=0;Process[4].Alltime=4;

}

voidprint（）

{

inti;

if（getRunning（）>=0）

printf（"\tRUNNINGPROG:

%d\n",getRunning（））;

printf（"\tREADY_QUEUE:

"）;

for（i=0;i

if（READY[i]>=0）

printf（"->%d",Process[READY[i]].ID）;

else{

break;

}

}

printf（"\n\tBLOCK_QUEUE:

"）;

for（i=0;i

if（BLOCK[i]>=0）

printf（"->%d",Process[BLOCK[i]].ID）;

else{

break;

}

}

printf（"\n=====================================================\n"）;

printf（"ID\t"）;

for（i=0;i

printf（"\t%d",Process[i].ID）;

}

printf（"\nPRIORITY"）;

for（i=0;i

printf（"\t%d",Process[i].Priority）;

}

printf（"\nCPUTIME\t"）;

for（i=0;i

printf（"\t%d",Process[i].Cputime）;

}

printf（"\nALLTIME\t"）;

for（i=0;i

printf（"\t%d",Process[i].Alltime）;

}

printf（"\nSTARTBLOCK"）;

for（i=0;i

printf（"\t%d",Process[i].Startblock）;

}

printf（"\nBLOCKTIME"）;

for（i=0;i

printf（"\t%d",Process[i].Blocktime）;

}

printf（"\nSTATE\t"）;

for（i=0;i

switch（Process[i].State）{

case0:

printf（"\tReady"）;break;

case1:

printf（"\tRun"）;

if（Process[i].Alltime==0）

{

Process[i].State=RunOut;

}

elseProcess[i].State=Ready;

break;

case2:

printf（"\tBlock"）;break;

case3:

printf（"\tRunOut"）;break;

}

}

printf（"\n"）;

printf（"\tRUNOUTLIST:

"）;

for（i=0;i

if（RUNOUT[i][0]>=0）

printf（"->%d（%d）",Process[RUNOUT[i][0]].ID,RUNOUT[i][1]）;

else{

printf（"\n"）;

break;

}

}

printf（"\n"）;

}

intgetRunning（）

{

inti;

for（i=0;i

if（Process[i].State==Run）

returni;

}

for（i=0;i

if（Process[i].Startblock==0）

returni;

}

return-1;

}

voidsort（）

{

inti,j,k;

for（i=0;i

READY[i]=-1;

BLOCK[i]=-1;

}

for（i=0;i

if（Process[i].State==Ready||Process[i].State==Run）{

//Process[i].State=Ready;

if（Process[i].Alltime==0）

continue;

for（j=0;j

if（READY[j]<0）

{

READY[j]=i;

break;

}

elseif（Process[i].Priority<=Process[READY[j]].Priority）

{continue;}

else{

for（k=N-1;k>j;--k）{

READY[k]=READY[k-1];

}

READY[j]=i;

break;

}

}

}

elseif（Process[i].State==Block）{

for（j=0;j

if（BLOCK[j]<0）

{

BLOCK[j]=i;

break;

}

elseif（Process[i].Blocktime>=Process[BLOCK[j]].Blocktime）

{continue;}

else{

for（k=N-1;k>j;--k）{

BLOCK[k]=BLOCK[k-1];

}

BLOCK[j]=i;

break;

}

}

}

}

}

intrun（inttime）

{

inti,runNum;

runNum=READY[0];

if（runNum<0&&BLOCK[0]<0）{

printf（"EveryprocessisOVER!

\n"）;

return1;

}

else{

if（runNum>=0）{

Process[runNum].Priority-=3;

Process[runNum].Alltime-=1;

Process[runNum].Cputime+=1;

Process[runNum].State=Run;

for（i=0;i

if（i!

=runNum）{

if（Process[i].State==Ready）{

Process[i].Priority+=1;

}

elseif（Process[i].State==Block）{

Process[i].Blocktime-=1;

if（Process[i].Blocktime==0）{

Process[i].State=Ready;

}

}

}

}

//print（）;

if（Process[runNum].Alltime==0）

{

//Process[runNum].State=RunOut;

for（i=0;i

if（RUNOUT[i][0]<0）{

RUNOUT[i][0]=runNum;

RUNOUT[i][1]=time;

break;

}

}

}

elseif（Process[runNum].Startblock>=0）{

Process[runNum].Startblock-=1;

if（Process[runNum].Startblock==0）{

Process[runNum].State=Block;

//Process[runNum].Startblock-=1;

}

}

}

elseif（BLOCK[0]>=0）{

for（i=0;i

if（Process[i].State==Block）{

Process[i].Startblock=-1;

Process[i].Blocktime-=1;

if（Process[i].Blocktime==0）{

Process[i].State=Ready;

}

}

}

//print（）;

}

}

sort（）;

print（）;

return0;

}

3、思考题

（1）在实际的调度中，除了按调度算法选择下一个执行的进程外，还应处理哪些工作？

运行结果；