某实验报告材料二进程调度算法.docx

某实验报告材料二进程调度算法.docx

《某实验报告材料二进程调度算法.docx》由会员分享，可在线阅读，更多相关《某实验报告材料二进程调度算法.docx（19页珍藏版）》请在冰豆网上搜索。

某实验报告材料二进程调度算法

实验报告二

——进程调度算法的设计

姓名：

xxxx学号：

xxxxx班级：

xxxx

一、实习内容

•实现短进程优先调度算法（SPF）

•实现时间片轮转调度算法（RR）

二、实习目的

•通过对进程调度算法的设计，深入理解进程调度的原理。

•进程是程序在一个数据集合上运行的过程，它是系统进行资源分配和调度的一个独立单位。

•进程调度分配处理机，是控制协调进程对CPU的竞争，即按一定的调度算法从就绪队列中选中一个进程，把CPU的使用权交给被选中的进程。

三、实习题目

1.先来先服务（FCFS）调度算法

•原理：

每次调度是从就绪队列中，选择一个最先进入就绪队列的进程，把处理器分配给该进程，使之得到执行。

该进程一旦占有了处理器，它就一直运行下去，直到该进程完成或因发生事件而阻塞，才退出处理器。

•将用户作业和就绪进程按提交顺序或变为就绪状态的先后排成队列，并按照先来先服务的方式进行调度处理，是一种最普遍和最简单的方法。

它优先考虑在系统中等待时间最长的作业，而不管要求运行时间的长短。

•按照就绪进程进入就绪队列的先后次序进行调度，简单易实现，利于长进程，CPU繁忙型作业，不利于短进程，排队时间相对过长。

2.时间片轮转调度算法RR

•原理：

时间片轮转法主要用于进程调度。

采用此算法的系统，其程序就绪队列往往按进程到达的时间来排序。

进程调度按一定时间片（q）轮番运行各个进程.

•进程按到达时间在就绪队列中排队，调度程序每次把CPU分配给就绪队列首进程使用一个时间片，运行完一个时间片释放CPU，排到就绪队列末尾参加下一轮调度，CPU分配给就绪队列的首进程。

•固定时间片轮转法：

1所有就绪进程按FCFS规则排队。

2处理机总是分配给就绪队列的队首进程。

3如果运行的进程用完时间片，则系统就把该进程送回就绪队列的队尾，重新排队。

4因等待某事件而阻塞的进程送到阻塞队列。

5系统把被唤醒的进程送到就绪队列的队尾。

•可变时间片轮转法：

1进程状态的转换方法同固定时间片轮转法。

2响应时间固定，时间片的长短依据进程数量的多少由T=N×（q+t）给出的关系调整。

3根据进程优先级的高低进一步调整时间片，优先级越高的进程，分配的时间片越长。

3.算法类型:

4.模拟程序可由两部分组成，先来先服务（FCFS）调度算法，时间片轮转。

流程图如图所示:

四、主要数据结构及符号说明

enumStatus{running,ready,block}用枚举类型来列举进程的状态

enumAlgorithm{spf,rr}用枚举类型来列举两种进程调度算法

typedefclassPCB//definePCBclasswhichstoreinformationofPCB

{

public:

intid,cputime,alltime,startblock,blocktime;//进程号、已经运行时间、还需要的时间、何时开始阻塞及阻塞时间的变量

Statusstate;//进程的状态

classPCB*next;//指向下一个进程的指针

PCB（）

{}

}PCB,*PCBptr,**PCBpp;

定义类类型来存储一个进程的相关信息，并用链表的方式来存放进程

五、实现代码为：

#defineMAX100

#include

#include

intm,b,n,x;

intrt[10];//到达时间

intst[10];//服务时间

intct[10];//完成时间

intcyt[10];//周转时间

/**************RR算法***************/

voidRR（intN）

{

inti,t,k;

inta[MAX];//存放进程的剩余时间

intcnt[MAX];//存放进程调度次数

printf（"pleaseinputthetimepiece（t）:

"）;

scanf（"%d",&t）;

for（i=0;i

{

printf（"pleaseinputtheserivetimeofprocess%d:

\n",i+1）;

scanf（"%d",&a[i]）;

cnt[i]=0;

}

k=1;

while（k）

{

for（i=0;i

{

if（a[i]!

=0）

if（a[i]>=t）

{

a[i]-=t;

b+=t;

cnt[i]=cnt[i]+1;

printf（"processname:

%d\ncallednumber:

%d\nendtime:

%d\nlefttime:

%d\n",i+1,cnt[i],b,a[i]）;

printf（"*********************************\n"）;

}

else

{

b=b+a[i];

cnt[i]=cnt[i]+1;

a[i]=0;

printf（"processname:

%d\ncallednumber:

%d\nendtime:

%d\nlefttime:

%d\n",i+1,cnt[i],b,a[i]）;

printf（"*********************************\n"）;

}

elsecontinue;

}

for（i=0;i

if（a[i]!

=0）

{

k=1;break;

}

else

continue;

if（i>=N）

k=0;

}

printf（"alltheprocesshavebeendone\n"）;

}

/********SPF算法*********/

//定义进程结构体

structpro

{

intnum;//进程号

intarriveTime;//到达时间

intservice;//执行时间

structpro*next;

};

//函数声明

structpro*creatList（）;//创建链表，按照进程的到达时间排列

voidinsert（structpro*head,structpro*s）;//插入节点

structpro*searchByAT（structpro*head,intAT）;//查找第一个到达时间大于AT的节点，返回其前一个指针

voidrun（structpro*head）;//按短进程优先算法调度，并输出其运行情况

voiddel（structpro*p）;//删除p的下一个节点

intgetCount（structpro*head,inttime）;//查看当前就绪队列中的进程数

structpro*creatList（）//创建链表，按照进程的到达时间排列

{

structpro*head=（structpro*）malloc（sizeof（structpro））;

structpro*s;

inti;

head->next=NULL;

for（i=0;i

{

s=（structpro*）malloc（sizeof（structpro））;

printf（"plaeseinputprocessname（number）:

\n"）;

scanf（"%d",&（s->num））;

printf（"pleaseinputprocessarrivetime\n"）;

scanf（"%d",&（s->arriveTime））;

printf（"pleaseinputservicetime\n"）;

scanf（"%d",&（s->service））;

s->next=NULL;

insert（head,s）;

}

returnhead;

}

voidinsert（structpro*head,structpro*s）//插入节点

{

structpro*p=searchByAT（head,s->arriveTime）;

s->next=p->next;

p->next=s;

return;

}

structpro*searchByAT（structpro*head,intAT）//查找第一个到达时间大于AT的节点，返回其前一个指针

{

structpro*p,*q;

p=head;

q=head->next;

while（q!

=NULL&&q->arriveTime<=AT）

{

p=q;

q=q->next;

}

returnp;

}

voiddel（structpro*p）//删除p的下一个节点

{

structpro*tmp;

tmp=p->next;

p->next=tmp->next;

free（tmp）;

return;

}

intgetCount（structpro*head,inttime）//查看当前就绪队列中的进程数

{

intcount=0;

structpro*p,*q;

p=head;

q=p->next;

while（q!

=NULL&&q->arriveTime<=time）

{

count++;

p=q;

q=q->next;

}

returncount;

}

structpro*SPF（structpro*head,intcount）//在头节点后的count个节点中选择service最小的，返回其前一个节点的指针

{

intmin;

structpro*p,*q,*flag;

p=head;

q=p->next;

min=q->service;

flag=p;//flag记录返回值

while（count>0）

{

if（q->service

{

min=q->service;

flag=p;

}

count--;

p=q;

q=q->next;

}

returnflag;

}

voidrun（structpro*head）//按短进程优先算法调度，并输出其运行情况

{

inttime=0,count,i;

structpro*s,*t;

while（head->next!

=NULL）

{

count=getCount（head,time）;//查看就绪队列中的进程数目

if（count==0）//如果当前就绪队列中没有进程，时间自增

time++;

elseif（count==1）//如果就绪队列中只有一个进程，则必定是第一个节点

{

t=head;

s=t->next;

printf（"processname：

%d\n",s->num）;

printf（"arrivetime:

%d\n",s->arriveTime）;

printf（"serivetime:

%d\n\n",s->service）;

printf（"startime：

%d\n",time）;

time+=s->service;

printf（"endtime:

%d\n",time）;

printf（"turnaroundtime:

%d\n",time-s->arriveTime）;

i=time-s->arriveTime;

printf（"*********************************\n"）;

del（t）;

}

else//如果就绪队列中的进程数≥2，则在head后的count个节点中的短进程优先调度

{

t=SPF（head,count）;

s=t->next;

printf（"processname：

%d\n",s->num）;

printf（"arrivetime:

%d\n",s->arriveTime）;

printf（"serivetime:

%d\n\n",s->service）;

printf（"startime%d\n",time）;

time+=s->service;

printf（"endtime:

%d\n",time）;

printf（"turnaroundtime:

%d\n",time-s->arriveTime）;

i=time-s->arriveTime;

printf（"*********************************\n"）;

del（t）;

}

}

}

/******FCFS算法**********/

voidFCFS（intx）

{

voidinput（）;//输入数据

voidordination（）;//对数据按到达时间进行排序

voidfcfs（）;//先来先服务计算

voidoutput（）;//输出结果

printf（"/*********FCFS*********/\n"）;

input（x）;

ordination（x）;

fcfs（x）;

output（x）;

}

voidinput（intx）

{

printf（"pleaseinputarrivetimeofthe%dprocesses:

",x）;

for（n=0;n

scanf（"%d",&rt[n]）;

printf（"pleaseinputserivcetimeofthe%dprocesses:

",x）;

for（n=0;n

scanf（"%d",&st[n]）;

}

voidordination（intx）

{

inttemp;

for（n=0;n

for（m=0;m

if（rt[m+1]

{

temp=rt[m+1];

rt[m+1]=rt[m];

rt[m]=temp;

temp=st[m+1];

st[m+1]=st[m];

st[m]=temp;

}

}

voidfcfs（intx）{

ct[0]=rt[0]+st[0];

for（n=1;n

{

if（ct[n-1]>=rt[n]）//考虑当前一个进程完成而后一个进程还没有到达的情况

ct[n]=ct[n-1]+st[n];

else

ct[n]=rt[n]+st[n];

}

for（n=0;n

cyt[n]=ct[n]-rt[n];

}

voidoutput（intx）

{

for（n=0;n

printf（"name:

%d\narrivetime:

%d\nserive:

%d\nendtime:

%d\nturnaroundtime:

%d\n",n+1,rt[n],st[n],ct[n],cyt[n]）;

}

voidmain（）

{

intswich;//选择使用算法

structpro*head;

intc=1;//选择是否继续

for（;c==1;）

{

printf（"pleaseinputthenumberoftheprocesses:

"）;

scanf（"%d",&x）;

printf（"pleasechoosemethod（RR:

0SPF:

1FCFS:

2）:

"）;

scanf（"%d",&swich）;

if（swich==0）

RR（x）;

else

if（swich==1）

{

head=creatList（）;

printf（"SPF:

\n"）;

run（head）;

}

else

if（swich==2）

FCFS（x）;

else

printf（"inputerror,pleaseinputagain:

\n"）;

printf（"continue:

1，quit:

0\npleaseinput:

"）;

scanf（"%d",&c）;

}

printf（"*************end***********\n"）;

}

六、在虚拟机上的具体操作

七、实验结果

RR:

SPF:

FCFS:

八、思考题

根据上面的观察结果，比较这两种算法各自的优缺点，根据结果再和其他的算法比较。

FCFS算法可以保证先到的进程先执行,直到进程结束,但是所有进程的平均周转时间长;

RR算法不会使一些较长时间一直等待,但是不一定能够减少平均等待时间和平均周转时间;

SPF算法使短进程优先执行,减少平均等待时间和平均周转时间,有利用短进程的执行,但是不利于长进程.

九、实验总结

通过实验了解了FCFS、SPF、RR算法的具体实现过程，通过实验结果了解各个算法的优缺点，深入学习，由此可以在以后选择更优更合适的算法实现其他内容。