时间片轮转调度算法.docx
《时间片轮转调度算法.docx》由会员分享,可在线阅读,更多相关《时间片轮转调度算法.docx(14页珍藏版)》请在冰豆网上搜索。
时间片轮转调度算法
#include
#include
#include
#include
/*进程控制块数据结构*/
typedefstructnode
{
charname[10];/*进程名*/
intprio;/*进程优先级*/
intround;/*循环轮转法进程每次轮转的时间片*/
intcputime;/*进程累计消耗的CUP时间*/
intneedtime;/*进程到完成还需要的CUP时间*/
intcount;/*循环轮转法一个时间片进程运行时间*/
charstate;/*进程的状态:
'R':
运行,'W':
等待,'F':
结束*/
structnode*next;/*指向下一个进程的链指针*/
}PCB;
PCB*finish,*ready,*tail,*run;/*指向三个队列的队首的指针,
finish为完成队列头指针,
ready为就绪队列头指针,
tail为就绪队列的队尾指针,
run为当前运行进程头指针*/
intN;/*定义进程的数目*/
voidfirstin(void);//调度就绪队列的第一个进程投入运行;
voidprint1(chara);//打印表头行信息
voidprint2(charchose,PCB*p);//打印每一行的状态信息
voidprint(charchose);//打印每执行一次算法后所有的进程的状态信息
voidinsert_prio(PCB*q);//在优先数算法中,将尚未完成的PCB按优先数顺序插入到就绪队列中;
voidprior_init(charchose);//进程优先级法初始化将进程按优先级插入到就绪队列里
voidpriority(charchose);//进程优先级算法总函数
voidinsert_rr(PCB*q);//在轮转法中,将执行了一个时间片单位(为2),但尚未完成的进程的PCB,插到就绪队列的队尾;
voidroundrun_init(charchose);//循环轮转法初始化将就绪队列保存为FIFO队列
voidroundrun(charchose);//循环轮转法总算法
voidmain()//主函数
{
charchose='';
while((chose!
='e')&&(chose!
='E'))
{
fflush(stdin);
system("cls");
/*printf("\t\t\t两种进程调度算法的模拟\n\n");
printf("\tP.进程优先级算法模拟\n\n");*/
printf("\tR.循环轮转算法模拟\n\n");
printf("\tE.退出程序\n\n");
printf("\t请输入你的选择:
");
scanf("%c",&chose);
if((chose!
='e')&&(chose!
='E'))
{
system("cls");
/*if((chose=='P')||(chose=='p'))
{
prior_init(chose);
priority(chose);
system("cls");
}*/
/*else*/if((chose=='r')||(chose=='R'))
{
roundrun_init(chose);
roundrun(chose);
system("cls");
}
}
}
printf("\n\t\t使用!
!
!
\n");
}
voidfirstin(void)//调度就绪队列的第一个进程投入运行;
{
if(ready!
=NULL)
{
run=ready;
ready=ready->next;
run->state='R';
run->next=NULL;
}
else
{
run=NULL;
}
}
voidprint1(chara)//打印表头行信息
{
if(toupper(a)=='P')
{
printf("namecputimeneedtimeprioritystate\n");
}
else
{
printf("namecputimeneedtimecountroundstate\n");
}
}
voidprint2(charchose,PCB*p)//打印每一行的状态信息
{
if(toupper(chose)=='P')
{
printf("%s\t%d\t%d\t%d\t%c\n",p->name,p->cputime,p->needtime,p->prio,p->state);
}
else
{
printf("%s\t%d\t%d\t%d\t%d\t%c\n",p->name,p->cputime,p->needtime,p->count,p->round,p->state);
}
}
voidprint(charchose)//打印每执行一次算法后所有的进程的状态信息
{
PCB*p;
print1(chose);
if(run!
=NULL)
{
print2(chose,run);
}
p=ready;
while(p!
=NULL)
{
print2(chose,p);
p=p->next;
}
p=finish;
while(p!
=NULL)
{
print2(chose,p);
p=p->next;
}
}
voidinsert_prio(PCB*q)/*在优先数算法中,将尚未
完成的PCB按优先数顺序插入到就绪队列中;*/
{
PCB*p,*s,*r;/*p,r用来控制就绪队列滚动,S指向插入的队列*/
s=q;
p=ready;
r=p;
if(s->prio>ready->prio)//要插入的进程的优先级大于ready的优先级
{
s->next=ready;
ready=s;
}
else//要插入的进程的优先级不大于ready的优先级
{
while(p)
{
if(p->prio>=s->prio)
{
r=p;
p=p->next;
}
else
break;
}//找到要插入的位置
s->next=p;
r->next=s;
}
}
/*voidprior_init(charchose)/*进程优先级法初始化
将进程按优先级插入到就绪队列里
{
PCB*p;
inti,time;
charna[10];
ready=NULL;
finish=NULL;
run=NULL;
printf("\t\t进程优先级算法模拟全过程\n\n");
printf("输入进程的个数N:
\n");
scanf("%d",&N);
for(i=0;i{
p=(PCB*)malloc(sizeof(PCB));
printf("输入第%d个进程名\n",i+1);
scanf("%s",na);
printf("完成进程需要的时间片数\n");
scanf("%d",&time);
strcpy(p->name,na);
p->cputime=0;
p->needtime=time;
p->state='W';
p->prio=50-time;//设置进程优先值初值
if(ready==NULL)
{
ready=p;
ready->next=NULL;
}
else
{
insert_prio(p);
}
printf("当前就绪队列的进程的信息\n");
print(chose);
}
printf("%d个进程已按优先级从高到低进到就绪队列中\n",N);
printf("按回车键开始模拟优先级算法.....\n");
fflush(stdin);
getchar();
firstin();
}*/
/*voidpriority(charchose)//进程优先级算法总函数
{
inti=1;
while(run!
=NULL)
{
run->cputime+=1;
run->needtime-=1;
run->prio-=1;
if(run->needtime==0)
{
run->next=finish;
finish=run;
run->state='F';
run->prio=0;
run=NULL;
firstin();
}
else
{
if((ready!
=NULL)&&(run->prioprio))
{
run->state='W';
insert_prio(run);
run=NULL;
firstin();
}
}
printf("第%d次执行优先级算法\n",i++);
print(chose);
if(run)
{
printf("按回车键继续下一次优先级算法.....\n");
}
else
printf("优先级算法模拟过程结束!
!
\n");
fflush(stdin);
getchar();
}
}*/
voidinsert_rr(PCB*q)//在轮转法中,将执行了一个时间片单位(为2),
//但尚未完成的进程的PCB,插到就绪队列的队尾;
{
tail->next=q;
tail=q;
q->next=NULL;
}
voidroundrun_init(charchose)/*循环轮转法初始化
将就绪队列保存为FIFO队列*/
{
PCB*p;
inti,time;
charna[10];
ready=NULL;
finish=NULL;
run=NULL;
printf("\t\t循环轮转算法模拟全过程\n\n");
printf("输入进程的个数N:
\n");
scanf("%d",&N);
for(i=0;i{
p=(PCB*)malloc(sizeof(PCB));
printf("输入第%d个进程名\n",i+1);
scanf("%s",na);
printf("完成进程需要的时间片数\n");
scanf("%d",&time);
strcpy(p->name,na);
p->cputime=0;
p->needtime=time;
p->count=0;
p->state='W';
p->round=2;
if(ready!
=NULL)
{
insert_rr(p);
}
else
{
p->next=ready;
ready=p;
tail=p;
}
printf("当前就绪队列的进程的信息\n");
print(chose);
}
printf("%d个进程已按FIFO进到就绪队列中\n",N);
printf("按回车键开始模循环轮转算法.....\n");
fflush(stdin);
getchar();
run=ready;
ready=ready->next;
run->state='R';
}
voidroundrun(charchose)//循环轮转法总算法
{
inti=1;
while(run!
=NULL)
{
run->cputime+=1;
run->needtime-=1;
run->count+=1;
if(run->needtime==0)
{
run->next=finish;
finish=run;
run->state='F';
run->prio=0;
run=NULL;
if(ready!
=NULL)
{
firstin();
}
}
else
{
if(run->count==run->round)
{
run->count=0;
if(ready!
=NULL)
{
run->state='W';
insert_rr(run);
firstin();
}
}
}
printf("第%d次执行循环轮转算法\n",i++);
print(chose);
if(run)
{
printf("按回车键继续下一次循环轮转算法.....\n");
}
else
printf("循环轮转算法模拟过程结束!
!
\n");
fflush(stdin);
getchar();
}
}