操作系统实验四进程控制.docx
《操作系统实验四进程控制.docx》由会员分享，可在线阅读，更多相关《操作系统实验四进程控制.docx（16页珍藏版）》请在冰豆网上搜索。
操作系统实验四进程控制
暨南大学本科实验报告专用纸
课程名称《操作系统原理实验》成绩评定
实验项目名称进程控制指导教师戴红
实验项目编号0806002904实验项目类型综合型实验地点
学生姓名岑江斌学号**********
学院电气信息学院系计算机科学系专业软件工程
实验时间年月日下午温度℃湿度
一，实验目的。
通过动态优先权算法的模拟加深对进程概念和进程调度过程的理解。
二，实验内容。
（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
===============================================
ID 0 1 2 3 4
PRIORITY P0 P1 P2 P3 P4
CPUTIME C0 C1 C2 C3 C4
ALLTIME A0 A1 A2 A3 A4
STARTBLOCK T0 T1 T2 T3 T4 BLOCKTIME B0 B1 B2 B3 B4
STATE S0 S1 S2 S3 S4
三，实验源代码。
#include
#include//EOF（=^Z或F6）,NULL
#include//atoi（）
#include//cout,cin
#include
#defineREADY1 //进程就绪
#defineWORK2 //进程运行
#defineBLOCK-1 //进程阻塞
#defineFINISH-2 //进程完成
#defineListHeade-3 //ListHeade队列头节点
structPCB
{
intID; //进程标识数ID;
intPRIORITY; //进程优先数PRIORITY，并规定优先数越大的进程，其优先权越高;
intCPUTIME; //进程已占用的CPU时间CPUTIME;
intALLTIME; //进程还需占用的CPU时间ALLTIME。
当进程运行完毕时，ALLTIME变为0;
intSTARTBLOCK; //进程的阻塞时间STARTBLOCK，表示当进程再运行STARTBLOCK个时间片后，进程将进入阻塞状态;
intBLOCKTIME; //进程被阻塞的时间BLOCKTIME，表示已阻塞的进程再等待BLOCKTIME个时间片后，进程将转换成就绪状态;
intSTATE; //进程状态STATE;
PCB*next; //队列指针NEXT，用来将PCB排成队列。
};
typedefPCB*PCBlist;
PCBlistreadylist; //就绪队列
PCBlistblocklist; //阻塞队列
PCBlistrun; //被执行的进程
PCBlistfinishlist; //完成队列
void InitQueue（）
{
readylist=（PCBlist）malloc（sizeof（PCB））;
readylist->next=NULL;//*/={65535,65535,0,0,0,0,-3,NULL};
blocklist=（PCBlist）malloc（sizeof（PCB））;
blocklist->next=NULL;//*/={65535,65535,0,0,0,0,-3,NULL};
finishlist=（PCBlist）malloc（sizeof（PCB））;
finishlist->next=NULL;//*/={65535,65535,0,0,0,0,-3,NULL};
}
voidInsert（PCBlistlist,PCB&a） //将PCBa插入队列list
{
PCBlistp,q;
p=list;
q=list->next;
while（q!
=NULL&&（q->PRIORITY）>（a.PRIORITY））
{ //查找插入的位置是对列按
p=q; //PCB的优先权由大到小排列
q=q->next;
}
a.next=q;
p->next=&a;
}
void CreatePS（intid,intpriority,intCPUtime,intalltime,intstartblock,intblocktime）
{
PCBlistp; //创建PCB
p=（PCBlist）malloc（sizeof（PCB））;
p->ID=id; //初始化PCB
p->PRIORITY=priority;
p->CPUTIME=CPUtime;
p->ALLTIME=alltime;
p->STARTBLOCK=startblock;
p->BLOCKTIME=blocktime;
p->STATE=READY;
p->next=NULL;
Insert（readylist,*p）; //将其插入就绪队列
}
voidGetPriority（）
{
run=readylist->next;
if（run）
{
readylist->next=run->next;
run->next=NULL;
}
elsereadylist->next=NULL;
}
voidKillPS（）
{
Insert（finishlist,*run）;
run->STATE=FINISH;
run=NULL;
}
voidResetPriority（）
{
run->PRIORITY=（（run->PRIORITY）-3）;
if（（run->PRIORITY）<0）run->PRIORITY=0;
PCB*p;
p=（readylist->next）;
while（p!
=NULL）
{
（p->PRIORITY）++;
p=（p->next）;
}
}
voidResetBlockList（）
{
PCBlistq1,q2;
q2=blocklist;
q1=（blocklist->next）;
while（q1!
=NULL）
{
q1->BLOCKTIME--;
if（q1->BLOCKTIME==0）
{
q2->next=q1->next;
Insert（readylist,*q1）;
q1->STATE=READY;
q1=q2->next;
}
elseq1=q1->next;
}
}
voidExcutePS（）
{
（run->CPUTIME）++;
（run->ALLTIME）--;
}
voidprint（）
{
if（run）cout<<"\tRUNNINGPROG:
P"<ID< cout<<"\tREADY_QUEUE:
";
PCBlistr;
r=readylist->next;
while（r!
=NULL）
{
cout<<"->"<ID;
r=r->next;
}
cout< cout<<"\tBLOCK_QUEUE:
";
r=blocklist->next;
while（r!
=NULL）
{
cout<<"->"<ID;
r=r->next;
}
cout< cout<<"======================================="< PCBlistP0,P1,P2,P3,P4;
r=run;
while（r!
=NULL）
{
switch（r->ID）
{
case0:
P0=r;break;
case1:
P1=r;break;
case2:
P2=r;break;
case3:
P3=r;break;
case4:
P4=r;break;
}
r=r->next;
}
r=readylist->next;
while（r!
=NULL）
{
switch（r->ID）
{
case0:
P0=r;break;
case1:
P1=r;break;
case2:
P2=r;break;
case3:
P3=r;break;
case4:
P4=r;break;
}
r=r->next;
}
r=blocklist->next;
while（r!
=NULL）
{
switch（r->ID）
{
case0:
P0=r;break;
case1:
P1=r;break;
case2:
P2=r;break;
case3:
P3=r;break;
case4:
P4=r;break;
}
r=r->next;
}
r=finishlist->next;
while（r!
=NULL）
{
switch（r->ID）
{
case0:
P0=r;break;
case1:
P1=r;break;
case2:
P2=r;break;
case3:
P3=r;break;
case4:
P4=r;break;
}
r=r->next;
}
cout<<"ID"<<'\t'<<'\t'<ID<<'\t'<ID<<'\t'<ID<<'\t'<ID<<'\t'<ID< cout<<"PRIORITY"<<'\t'<PRIORITY<<'\t'<PRIORITY<<'\t'<PRIORITY<<'\t'<PRIORITY<<'\t'<PRIORITY< cout<<"CPUTIME"<<'\t'<<'\t'<CPUTIME<<'\t'<CPUTIME<<'\t'<CPUTIME<<'\t'<CPUTIME<<'\t'<CPUTIME< cout<<"ALLTIME"<<'\t'<<'\t'<ALLTIME<<'\t'<ALLTIME<<'\t'<ALLTIME<<'\t'<ALLTIME<<'\t'<ALLTIME< cout<<"STARTBLOCK"<<'\t'<STARTBLOCK<<'\t'<STARTBLOCK<<'\t'<STARTBLOCK<<'\t'<STARTBLOCK<<'\t'<STARTBLOCK< cout<<"BLOCKTIME"<<'\t'<BLOCKTIME<<'\t'<BLOCKTIME<<'\t'<BLOCKTIME<<'\t'<BLOCKTIME<<'\t'<BLOCKTIME< cout<<"STATE"<<'\t'<<'\t';
switch（P0->STATE）
{
caseREADY:
cout<<"READY"<<'\t';break;
caseWORK:
cout<<"WORK"<<'\t';break;
caseBLOCK:
cout<<"BLOCK"<<'\t';break;
caseFINISH:
cout<<"FINISH"<<'\t';break;
}
switch（P1->STATE）
{
caseREADY:
cout<<"READY"<<'\t';break;
caseWORK:
cout<<"WORK"<<'\t';break;
caseBLOCK:
cout<<"BLOCK"<<'\t';break;
caseFINISH:
cout<<"FINISH"<<'\t';break;
}
switch（P2->STATE）
{
caseREADY:
cout<<"READY"<<'\t';break;
caseWORK:
cout<<"WORK"<<'\t';break;
caseBLOCK:
cout<<"BLOCK"<<'\t';break;
caseFINISH:
cout<<"FINISH"<<'\t';break;
}
switch（P3->STATE）
{
caseREADY:
cout<<"READY"<<'\t';break;
caseWORK:
cout<<"WORK"<<'\t';break;
caseBLOCK:
cout<<"BLOCK"<<'\t';break;
caseFINISH:
cout<<"FINISH"<<'\t';break;
}
switch（P4->STATE）
{
caseREADY:
cout<<"READY"< caseWORK:
cout<<"WORK"< caseBLOCK:
cout<<"BLOCK"< caseFINISH:
cout<<"FINISH"< }
cout<<"Printanykeytocontinue"<// getchar（）;
}
voidRunPS（）
{
GetPriority（）;
run->STATE=WORK;
print（）;
while（run!
=NULL）
{
ExcutePS（）;
ResetPriority（）; //重置优先级，本回合唤醒的阻塞进程优先权不加一（不参与重置）
if（run->ALLTIME==0）KillPS（）;
if（run&&run->STARTBLOCK!
=-1）（run->STARTBLOCK）--;
if（（blocklist->next）!
=NULL）ResetBlockList（）;
if（run&&run->STARTBLOCK==0）
{
Insert（blocklist,*run）;
run->STATE=BLOCK;
}
else
{
if（run）
{
Insert（readylist,*run）;
run->STATE=READY;
}
}
print（）;
GetPriority（）;
print（）;
}
}
intmain（）
{
InitQueue（）;
CreatePS（0,9,0,3,2,3）;
CreatePS（1,38,0,3,-1,0）;
CreatePS（2,30,0,6,-1,0）;
CreatePS（3,29,0,3,-1,0）;
CreatePS（4,0,0,4,-1,0）;
RunPS（）;
return0;
}
四，实验结果分析。
部分截图：
最后程序运行结束：
当两个进程的优先级相同时，按照进程还需占用CPU时间来决定进程优先。
五、实验心得
通过这次实验，了解了多个进程调用时是根据其优先权的大小而优先进行的，而且其他进程的状态变化，所以，在每次调用进程时，都需要比较每个进程的优先权
升级会员 