实验A4使用动态优先权地进程调度算法地模拟Word下载.docx
《实验A4使用动态优先权地进程调度算法地模拟Word下载.docx》由会员分享，可在线阅读，更多相关《实验A4使用动态优先权地进程调度算法地模拟Word下载.docx（22页珍藏版）》请在冰豆网上搜索。
id1->
id2
BLOCK_QUEUE:
id3->
id4
==================================
ID01234
PRIORITYP0P1P2P3P4
CPUTIMEC0C1C2C3C4
ALLTIMEA0A1A2A3A4
STARTBLOCKT0T1T2T3T4
BLOCKTIMEB0B1B2B3B4
STATES0S1S2S3S4
3、思考题
（1）在实际的调度中，除了按调度算法选择下一个执行的进程外，还应处理哪些工作？
队列实现：
#include<
malloc.h>
//#defineNULL0
#defineM10
typedefstructnode
{intid;
intpr;
intct;
intat;
intbt;
intsb;
structnode*next;
}jd;
jd*max（jd*p）
{
jd*maxnode=NULL,*p1,*p2,*p3=p;
intmaxnum;
p1=p;
p2=p;
if（p->
next==NULL）
returnNULL;
maxnum=p->
next->
pr;
while（p1->
next!
=NULL）
{p2=p1->
next;
if（maxnum<
=p2->
pr）
{
maxnode=p2;
p3=p1;
maxnum=p2->
}
p1=p1->
}
p3->
next=maxnode->
maxnode->
next=NULL;
returnmaxnode;
}
voidblocktoready（jd*pblock,jd*pready）
jd*p1=pblock,*p3;
{
p3=p1->
if（p3->
bt==0）
p1->
next=p3->
next=pready->
pready->
next=p3;
if（p1==NULL）
break;
voidready（jd*p）
jd*p1=p->
while（p1!
pr++;
voidrun（jd*p）
jd*p1;
{
p1=p->
pr=p1->
pr-3;
at--;
ct++;
}
voidblock（jd*p）
bt--;
voidruntoreadyorblock（jd*prun,jd*pready,jd*pblock）
jd*p;
if（prun->
return;
p=prun->
at==0）
prun->
else
ct==p->
sb）
{p->
next=pblock->
pblock->
next=p;
else{
p->
jd*head（jdpcb[],intL）
inti;
for（i=0;
i<
L;
i++）
printf（"
inputpcd%dinformation\n"
i）;
PRIORITY:
"
）;
scanf（"
%d"
&
pcb[i].pr）;
ALLTIME:
pcb[i].at）;
STARTBLOCK:
pcb[i].sb）;
BLOCKTIME:
pcb[i].bt）;
pcb[i].id=i;
pcb[i].ct=0;
L-1;
pcb[i].next=&
pcb[i+1];
pcb[L-1].next=NULL;
return&
pcb[0];
voidprint（jd*p）
\t\tthequeueareempty\n"
while（p->
\t\t%d\t%d\t%d\t%d\t%d\t%d\n"
p1->
id,p1->
pr,p1->
ct,p1->
at,p1->
sb,p1->
bt）;
p=p->
if（p==NULL）
intmain（）
jdpcb[M];
jd*pready=（jd*）malloc（sizeof（jd））;
jd*prun=（jd*）malloc（sizeof（jd））;
jd*pblock=（jd*）malloc（sizeof（jd））;
intL,i,n=1;
pleaseinputthenumberofpcb:
\n"
L）;
next=head（pcb,L）;
while
（1）
next=max（pready）;
run（prun）;
ready（pready）;
block（pblock）;
running%deverypcbinformation:
n）;
\t\tid\tpr\tct\tat\tsb\tbt\n"
thereadypcb:
print（pready）;
therunpcb:
print（prun）;
theblockpcb:
print（pblock）;
theallpcb:
\t\t%d\t%d\t%d\t%d\t%d\t%d\n"
pcb[i].id,pcb[i].pr,pcb[i].ct,pcb[i].at,pcb[i].sb,pcb[i].bt）;
blocktoready（pblock,pready）;
runtoreadyorblock（prun,pready,pblock）;
n++;
if（pready->
next==NULL&
&
}xt=head（pcb,L）;
运行结果:
[rootlocalhostroot]#gcc-oashiyan4.c
[rootlocalhostroot]#./a
数组实现：
实验目的
2、
实验容：
（1）
用C语言来实现对N个进程采用动态优先权优先算法的进程调度。
（2）
每个用来标识进程的进程控制块PCB用结构来描述，包括以下字段：
进程标识数ID
进程优先数PRIORITY，并规定优先数越大的进程，其优先权越高
进程已占用的CPU时间CUPTIME
进程还需占用的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
ALLTIME
6
STARTBLOCK
-1
-1
BLOCKTIME
STATE
READY
READY
（5）为了清楚地观察诸进程的调度过程，程序将每个时间片的进程的情况显示出来，参照的具体格式如下：
RUNINGPROG:
i
READY_QUEUE:
->
BLOCK_QUEUE:
P0
P1
P2
P3
P4
C0
C1
C2
C3
C4
A0
A1
A2
A3
A4
T0
T1
T2
T3
T4
B0
B1
B2
B3
B4
S0
S1
S2
S3
S4
#include<
stdio.h>
iostream>
usingnamespacestd;
inti;
//循环值
intj;
//还在阻塞或就绪队列中的进程数
ints;
intm;
//最大priority的id
structpcb
intid;
intp;
//priority
intcputime;
intalltime;
intstartblock;
intblocktime;
intstate;
//0表示ready1表示end-1表示block
};
structpcbpro[5]={
{0,9,0,3,2,3,0},
{1,38,0,3,-1,0,0},
{2,30,0,6,-1,0,0},
{3,29,0,3,-1,0,0},
{4,0,0,4,-1,0,0}
intchangestate0（）
if（pro[0].startblock==0）
pro[0].state=-1;
pro[0].startblock--;
return1;
}
if（pro[0].blocktime==0）
pro[0].state=0;
if（pro[0].state==0&
pro[0].startblock!
=-1）
pro[0].startblock--;
return1;
if（pro[0].state==-1&
pro[0].blocktime!
=0）
{
pro[0].blocktime--;
}
intstate0（）
changestate0（）;
s=pro[0].p;
if（pro[0].state==-1）
s=-100;
returns;
intmaxp（）//求出最大priority
state0（）;
intmax=s;
m=pro[0].id;
j;
i++）
if（pro[i+1].p>
pro[i].p）
max=pro[i+1].p;
m=pro[i+1].id;
returnm;
voidchange（）
maxp（）;
intx;
//得到m现在的数组编号
pro[i].p++;
if（pro[i].id==m）
x=i;
pro[x].cputime++;
pro[x].p=pro[x].p-4;
pro[x].alltime--;
if（pro[x].alltime==0）
pro[x].state=1;
voiddisplay（）
change（）;
cout<
<
RUNNINGPROG:
m<
endl;
===============================================================\n"
;
ID"
cout.width（10）;
pro[i].id;
endl<
PRIORITY"
pro[i].p;
CPUTIME"
pro[i].cputime;
ALLTIME"
pro[i].alltime;
STARTBLOCK"
pro[i].startblock;
BLOCKTIME"
pro[i].blocktime;
STATE"
pro[i].state;
intmain（）
j=5;
//刚开始有5个进程
while（j!
if（pro[i].state==1）{
for（;
{
pro[i]=pro[i+1];
j=j-1;
}
display（）;
getchar（）;
运行结果：
[rootlocalhostroot]#g++-occ.c
[rootlocalhostroot]#./c
===============================================================
10
35
31
1
11
升级会员 