进程调度实验.docx
《进程调度实验.docx》由会员分享，可在线阅读，更多相关《进程调度实验.docx（16页珍藏版）》请在冰点文库上搜索。
进程调度实验
/*这是一个关于操作系统中进程调度的简单程序，里面包括先来先服务、短作业优先、时间片轮转三个调度算法，其中包括手动测试和自动测试*/
Os.h
#include
#include
#include
#include
#include
#include
intmyrand（inta,intb）//产生a到b之间的随机数
{
/*inti=0;
unsignedsum=0;
for（i;i<100;i++）
{
sum=sum+i;
}*/
Sleep（1000）;
srand（（unsigned）time（NULL））;
return（rand（）%（b-a+1）+a）;
}
structPCB
{
unsignedINID;
charOUTID[20];
unsignedprarentID;
unsignedchildID;
unsignedUSERID;
unsignedstatus;
unsignedpriority;
unsignedcometime;//到达时间
unsignedservertime;//服务时间
unsignedstarttime;//开始执行时间
unsignedendtime;//完成时间
unsignedcosttime;//已经服务的时间
unsignedT;//周转时间
floatTs;//带权周转时间
unsignedrequesttime;//还需的时间
structPCB*next;
structPCB*all_q_next;
char*start_addr;
};
//给链表尾添加成员
voidlinkadd（structPCB*p,structPCBa）
{
structPCB*q;
q=（structPCB*）malloc（sizeof（structPCB））;
if（NULL==q）
{
exit（0）;
}
q->INID=a.INID;
strcpy（q->OUTID,a.OUTID）;
q->status=a.status;
q->priority=a.priority;
q->cometime=etime;
q->servertime=a.servertime;
q->starttime=a.starttime;//开始执行时间
q->endtime=a.endtime;//完成时间
q->costtime=a.costtime;
q->T=a.T;//周转时间
q->Ts=a.Ts;//带权周转时间
q->requesttime=a.requesttime;
q->next=NULL;
while（p->next!
=NULL）
{
p=p->next;
}
p->next=q;
}
//创建链表
structPCB*linkcreak（）
{
structPCB*H=NULL;
structPCB*p;
p=（structPCB*）malloc（sizeof（structPCB））;
if（NULL==p）
{
exit（0）;
}
p->next=NULL;
H=p;
returnH;
}
/*voiddelay（longdelaytiem）//延时函数
{
while（delaytime>0）;
delaytime--;
}*/
0s.c
#include"os.h"
#defineN4//时间片大小
structPCB*creque（）;
structPCB*crerandque（）;
structPCB*head;//进程队列头指针
voidFCFS（structPCB*head）;
voidprintall（structPCB*Head）;
intpcbid=0;//进程数目
//intservernum=0;
structPCB*readylink;//就绪队列头指针
voidRR（）;
intmain（）
{
//head=creque（）;
head=crerandque（）;
readylink=linkcreak（）;//创建一个带头结点的就绪队列链表
readylink->INID=0;//就绪队列的进程数目
//printall（head）;
//FCFS（head）;
RR（）;
return0;
}
//创建进程队列
structPCB*creque（）
{
structPCB*head;
structPCBa;
inti;
intn=1;//用来打印进程数目显示
printf（"开始创建进程队列\n"）;
head=linkcreak（）;
printf（"输入要创建的进程总数:
"）;
scanf（"%d",&i）;
while（i>0）
{
a.INID=pcbid++;
a.status=0;
a.starttime=0;//开始执行时间
a.endtime=0;//完成时间
a.costtime=0;//已经服务的时间
a.T=0;//周转时间
a.Ts=0;//带权周转时间
//还需的时间
printf（"创建第%d个进程\n",n++）;
/*printf（"进程外部标识符（<20个字符）:
"）;
scanf（"%s",a.OUTID）;
printf（"进程优先级（数字1到5，1最大）:
"）;
scanf（"%ud",&a.priority）;*/
printf（"到达时间（正整数）:
"）;
scanf（"%ud",&etime）;
printf（"服务时间（整数,单位为秒）:
"）;
scanf（"%ud",&a.servertime）;
a.requesttime=a.servertime-a.costtime;
linkadd（head,a）;
i--;
}
returnhead;
}
voidFCFS（structPCB*head）
{
unsignedtime=0;
structPCB*test=head->next;
printf（"\t\tＦＣＦＳ调度\n"）;
for（time;time<100;time++）
{
while（NULL!
=test）
{
if（test->cometime<=time）//在所有小于等于此时刻的进程中选最先到达的执行
{
test->starttime=time;
time+=test->servertime;
test->endtime=time;
test->T=test->endtime-test->cometime;
test->Ts=test->T/test->servertime;
printf（"到达时间服务时间开始执行时间完成时间周转时间带权周转时间\n"）;
printf（"%d\t%d\t\t%d\t%d\t\t%d\t%f\n",test->cometime,test->servertime,
test->starttime,test->endtime,test->T,test->Ts）;
test=test->next;
}
else
{
test=test->next;
}
}
if（NULL==test）
{
break;
}
}
//next:
printf（"第一个进程执行的时间是:
%d\n",time）;
/*while（NULL!
=test）
{
for（time;time<100;）
{
if（test->cometime<=time）
{
printf（"执行的时间:
%d\n",time）;
test->starttime=time;
printf（"服务时间:
%d\n",test->servertime）;
time+=test->servertime;
test->endtime=time;
printf（"完成时间:
%d\n\n",time）;
break;
}
else
{
time++;
}
}
test=test->next;
}
*/
}
voidprintall（structPCB*Head）//输出链表中的所有节点
{
if（NULL==Head->next）
{
printf（"NOPCB\n"）;
}
else
{
Head=Head->next;
while（Head!
=NULL）
{
printf（"到达时间:
%d\t服务时间:
%d\n",Head->cometime,Head->servertime）;
Head=Head->next;
}
}
}
voidSPF（structPCB*head）
{
unsignedtime=0;
structPCB*test=head->next;
printf（"\t\tSPF调度\n"）;
for（time;time<100;time++）
{
}
}
voidaddreadylink（inttime1,inttime2）//把在time1time2期间到来的进程加入到就绪队列（左开右闭区间）
{
structPCB*p;
inti;
i=time1+1;
printf（"把在%d--%d（闭区间）期间到来的进程加入到就绪队列\n",i,time2）;
for（i;i<=time2;i++）
{
//printf（"\n\t\t%d时刻添加到就绪队列的进程信息\n",i）;
p=head->next;
while（p!
=NULL）
{
if（p->cometime==i）
{
linkadd（readylink,*p）;
readylink->INID++;
printf（"到达时间:
%d,服务世间:
%d\n",p->cometime,p->servertime）;
}
p=p->next;
}
}
}
voidRR（）
{
inttime=-1;//系统时间
intruntime=1;//进程实际执行时间
structPCB*temp=NULL;
inti=0;
printf（"\n\t\t\t\t开始模拟时间片轮转调度算法\n\n"）;
//readylink=linkcreak（）;//创建一个带头结点的就绪队列链表
for（time;time<40;）
{
printf（"______________________%d__________________\n",time+runtime）;
addreadylink（time,time+runtime）;//把在这个进程运行期间到来的进程加入到就绪队列（左开右闭区间）
printf（"现在就绪队列中所有的进程如下\n"）;
printall（readylink）;
if（（1==i）||（i==2））
{
printf（"%d时刻到达的进程,现移到就绪队列的末尾\n",temp->cometime）;
readylink->next=readylink->next->next;
temp->next=NULL;
//printf（"______________________________%d\n",readylink->INID）;
linkadd（readylink,*temp）;
printf（"现在就绪队列中所有的进程如下\n"）;
printall（readylink）;
i=0;
//}
//if（i==2）
/*{
printf（"%d时刻到达的进程,现移到就绪队列的末尾\n",temp->cometime）;
readylink->next=readylink->next->next;
temp->next=NULL;
//printf（"______________________________%d\n",readylink->INID）;
linkadd（readylink,*temp）;
printf（"现在就绪队列中所有的进程如下\n"）;
printall（readylink）;
i==0;*/
}
time+=runtime;
if（readylink->next!
=NULL）//就绪队列还有进程
{
if（readylink->next->requesttime<=N）//所需时间小于等于一个时间片，此次执行会结束这个进程
{
runtime=readylink->next->requesttime;
readylink->next->costtime+=runtime;
readylink->next->requesttime=readylink->next->servertime-readylink->next->costtime;
readylink->next->endtime=time+runtime;
readylink->INID--;
printf（"%d时刻到达的进程被执行一次，执行了%d个时间点，现服务时间完成，从就绪队列删除\n",readylink->next->cometime,runtime）;
printf（"\t一个进程运行完毕：
此进程到达时间:
%d\t完成时间：
%d\n",readylink->next->cometime,readylink->next->endtime）;
readylink->next=readylink->next->next;//删除这个执行完的进程
printf（"现在就绪队列中所有的进程如下\n"）;
printall（readylink）;
}
else
{
runtime=N;
readylink->next->costtime+=runtime;
readylink->next->requesttime=readylink->next->servertime-readylink->next->costtime;
if（readylink->INID!
=1）
{
//linkadd（readylink,*readylink->next）;//把这个进程加到就绪队列的末尾
//printf（"%d时刻到达的进程被执行一次，执行了%d个时间点，现移到就绪队列的末尾\n",readylink->next->cometime,runtime）;
printf（"%d时刻到达的进程被执行一次，执行了%d个时间点\n",readylink->next->cometime,runtime）;
//readylink->next=readylink->next->next;
temp=readylink->next;
i=2;
printf（"现在就绪队列中所有的进程如下\n"）;
printall（readylink）;
}
else//当就绪队列中仅有一个进程时，
{//先把在执行最后一个进程过程中到来的进程加到队列中再将此进程加末尾
printf（"%d时刻到达的进程被执行一次，执行了%d个时间点，\n",readylink->next->cometime,runtime）;
temp=readylink->next;
i=1;
}
}
}
else//就绪队列无进程
{
//time++;
//runtime=0;
runtime=1;
}
}
}
structPCB*crerandque（）
{
structPCB*head;
structPCBa;
inti;
unsignedx=0;//创建进程的最大数目
//printf（"请输入要创建进程的最大数目：
\n"）;
//scanf（"%u",&x）;
i=myrand（1,5）;
printf（"下面要开始创建有%d个进程的进程队列（随机产生）\n",i）;
head=linkcreak（）;
while（i>0）
{
printf（"创建第%d个进程\n",++pcbid）;
a.INID=pcbid;
printf（"此进程的内部标识为:
%u\t",pcbid）;
a.priority=myrand（1,5）;
printf（"进程优先级:
%u\n",a.priority）;
etime=myrand（0,20）;
printf（"到达时间:
%u\n",etime）;
a.servertime=myrand（1,20）;
printf（"服务时间:
%u\n",a.servertime）;
a.status=0;
a.starttime=0;//开始执行时间
a.endtime=0;//完成时间
a.costtime=0;//已经服务的时间
a.T=0;//周转时间
a.Ts=0;//带权周转时间
a.requesttime=a.servertime-a.costtime;
linkadd（head,a）;
i--;
}
returnhead;
}
升级会员 