进程调度模拟设计时间片轮转强占式短进程优先算法.docx

进程调度模拟设计时间片轮转强占式短进程优先算法.docx

《进程调度模拟设计时间片轮转强占式短进程优先算法.docx》由会员分享，可在线阅读，更多相关《进程调度模拟设计时间片轮转强占式短进程优先算法.docx（23页珍藏版）》请在冰豆网上搜索。

进程调度模拟设计时间片轮转强占式短进程优先算法

学号：

课程设计

题目

进程调度模拟设计——时间片轮转、强占式短进程优先算法

学院

计算机科学与技术

专业

计算机科学与技术

班级

姓名

指导教师

2011

年

1

月

20

日

课程设计任务书

学生姓名：

专业班级：

计算机科学与技术学院

指导教师：

工作单位：

计算机科学与技术学院

题目:

进程调度模拟设计——时间片轮转、强占式短进程优先算法

初始条件：

1．预备内容：

阅读操作系统的处理机管理章节内容，对进程调度的功能以及进程调度算法有深入的理解。

2．实践准备：

掌握一种计算机高级语言的使用。

要求完成的主要任务:

（包括课程设计工作量及其技术要求，以及说明书撰写等具体要求）

1．模拟进程调度，能够处理以下的情形：

⑴能够选择不同的调度算法（要求中给出的调度算法）；

⑵能够输入进程的基本信息，如进程名、到达时间和运行时间等；

⑶根据选择的调度算法显示进程调度队列；

⑷根据选择的调度算法计算平均周转时间和平均带权周转时间。

2．设计报告内容应说明：

⑴课程设计目的与功能；

⑵需求分析，数据结构或模块说明（功能与框图）；

⑶源程序的主要部分；

⑷测试用例，运行结果与运行情况分析；

⑸自我评价与总结：

）你认为你完成的设计哪些地方做得比较好或比较出色；

）什么地方做得不太好，以后如何改正；

）从本设计得到的收获（在编写，调试，执行过程中的经验和教训）；

）完成本题是否有其他方法（如果有，简要说明该方法）；

）对实验题的评价和改进意见，请你推荐设计题目。

时间安排：

设计安排一周：

周1、周2：

完成程序分析及设计。

周2、周3：

完成程序调试及测试。

周4、周5：

验收、撰写课程设计报告。

（注意事项：

严禁抄袭，一旦发现，抄与被抄的一律按0分记）

指导教师签名：

年月日

系主任（或责任教师）签名：

年月日

进程调度模拟设计

（时间片轮转、强占式短进程优先算法）

1.需求分析

通过设计一个模拟进程调度的系统，来实现进程调度，对进程调度的功能以及进程调度算法有一个更加深入的理解。

进程PCB（包含进程名、到达时间、预计运行时间等）

调度算法（时间片轮转、强占式短进程优先）

能够处理以下的情形：

（1）能够选择不同的调度算法（要求中给出的调度算法）

（2）能够输入进程的基本信息，如进程名、到达时间和运行时间等

（3）根据选择的调度算法显示进程调度队列

（4）根据选择的调度算法计算平均周转时间和平均带权周转时间

此次做的进程调度模拟系统，用户可以输入各进程信息（包含进程名、到达时间、估计运行时间）；输入完毕确认后，可选择两种调度算法中的一种执行，查看结果可得到相应算法的调度序列，每个进程的到达时间、预计运行时间、开始时间、结束时间和周转时间、带权周转时间，以及平均周转时间和平均带权周转时间。

1.1对进程信息的描述和实现

此次课程设计中，进程作为基本数据处理单元，需要对进程的基本信息进行相关的描述。

进程的基本信息包括进程进程名、到达的时间、预计的进程运行时间、进程开始运行时间、进程仍需运行的时间、进程完成的时间、进程运行的次数等。

在此，可以定义一个结构体链表来储存进程信息。

并在此基础上进行其他操作。

数据结构如下：

structPCB

{stringname;//进程名

intta;//进程到达时间

intts;//进程估计运行的时间

inttb;//进程开始运行时间

inttm;//进程仍需运行的时间

intto;//进程完成的时间

intrn;//进程运行的次数

inttotalTime;//周转时间

doubleweightTotalTime;//带权周转时间（周转时间/估计运行时间）

PCB*next;//定义指向下一个进程的指针};

1.2对调度算法的描述和实现

进程基本信息所构成的模块作为基本单元，并且相关调度算法的侧重进程基本信息点不同，所以要根据其调度算法的特点来结合基本信息进行对应的设计。

此次课程设计要求的调度算法描述如下：

1.2.1时间片轮转调度算法

时间片轮转法的中心思想在于将CPU的运行划分为一个个时间片，然后将这些时间片平均分配给已经准备就绪的进程，在一个时间片内只允许一个进程占用处理器。

如果当前进程运行结束则时间片终止。

这样可以较公平的分配处理器运行时间，使每个进程都可以得到处理。

1.2.2强占式短进程优先调度算法

此调度算法和先来先服务调度算法相区别，强占式短进程优先调度算法

对强占式短进程优先调度算法而言，其本质特征便是按进程的预计运行时间长短进行排序，先执行短进程。

若内存中运行的进程优先级比就绪队列中的某进程优先级低（即运行的进程预计运行时间比就绪队列中的某进程长），此运行的进程让出内存并进入就绪队列，优先级更高的短进程强占内存资源并运行直到结束或者遇到优先级更高的进程强占为止。

2功能设计及模块说明）

几个主要函数的功能如下:

voidmain（）程序主函数,提示用户输入相关信息并输出时间片轮转,强占式短进程算法的运行结果

PCB*create（PCB*head）;//创建进程队列

voidSJFrun（PCB*head）;//强占式短进程优先算法

voidcyclerun（PCB*head）;//时间片轮转算法

程序的主程序流程如下：

voidmain（）

{

charchoice;

cout<<"*进程调度模拟设计——时间片轮转、强占式短进程优先算法*"<

cout<<"***********1.时间片轮转算法***************************"<

cout<<"***********2.强占式短进程优先算法*********************"<

cout<<"***********else退出*************************************"<

cout<<"请输入您的选择：

"<

cin>>choice;

while（choice=='1'||choice=='2'）

{

PCB*head=NULL;

switch（choice）

{

case'1':

head=create（head）;cyclerun（head）;break;

case'2':

head=create（head）;SJFrun（head）;break;

}

cout<<"*进程调度模拟设计——时间片轮转、强占式短进程优先算法*"<

cout<<"***********1.时间片轮转算法***************************"<

cout<<"***********2.强占式短进程优先算法*********************"<

cout<<"***********else退出*************************************"<

cout<<"请输入您的选择：

"<

cin>>choice;

}

}

3源程序的主要部分

本次实验是使用VC++6.0进行编程,测试结果正确,程序运行无误.

本次课设设计重要代码如下：

3.1时间片轮转算法

voidcyclerun（PCB*head）//时间片轮转算法

{

sort（head）;

inttime=0;//记录当前时间

intnewarrive;//新到达进程数

PCB*rhead;

rhead=newPCB;

rhead->next=rhead;//创建新的循环链表，存放当前就绪队列中的进程

PCB*p,*q;

p=rhead;

q=p->next;//q记录当前应当运行的进程

cout<<"******************************************************"<

cout<<"时间片长度为"<

cout<<"******************************************************"<

while（time<=total）

{

newarrive=getCount（head,time）;

if（newarrive>0）move（head,rhead,newarrive）;//将head后的newarrive个节点移动到rhead队列中

if（rhead->next==rhead）time++;

elseif（q==rhead）

{

p=q;q=q->next;

}

else

{

cout<<"进程名:

"<name<

cout<<"到达时间:

"<ta<

if（q->rn==1）

{

cout<<"第"<rn<<"次运行开始时间：

"<

q->tb=time;

}

if（q->tm<=QT）

{

time+=q->tm;

q->to=time;

q->totalTime=time-q->ta;

cout<<"进程"<name<<"运行结束时间：

"<

cout<<"周转时间：

"<totalTime<

q->weightTotalTime=q->totalTime/（double）q->ts;

weight+=q->weightTotalTime;

cout<<"带权周转时间：

"<weightTotalTime<

cout<<"******************************************************"<

PCB*tmp=q;

q=q->next;

p->next=q;

free（tmp）;

}

else

{

if（q->rn!

=1）cout<<"第"<rn<<"次运行开始时间：

"<

time+=QT;

cout<<"第"<rn<<"次运行结束时间：

"<

cout<<"******************************************************"<

q->tm-=QT;

q->rn++;

p=q;q=q->next;

}

}

}

cout<<"平均周转时间：

"<

cout<<"平均带权周转时间：

"<

cout<<"******************************************************"<

}

3.2强占式短进程优先算法

voidSJFrun（PCB*head）//强占式短进程优先算法

{

sort（head）;

inttime=0,count;

PCB*p,*q;

stringre="";

while（head->next!

=NULL）

{

count=getCount（head,time）;

if（count==0）time++;

else

{

if（count==1）

{

p=head;

q=p->next;

if（q->name!

=re）

{

cout<<"******************************************************"<

cout<<"进程名：

"<name<

re=q->name;

cout<<"到达时间：

"<ta<

}

if（q->rn==1）cout<<"进程开始运行时间：

"<

++time;

++q->rn;

--q->tm;

if（q->tm==0）

{

cout<<"进程"<name<<"运行结束时间：

"<

q->totalTime=time-q->ta;

cout<<"周转时间：

"<totalTime<

q->weightTotalTime=q->totalTime/（double）q->ts;

weight+=q->weightTotalTime;

cout<<"带权周转时间：

"<weightTotalTime<

cout<<"******************************************************"<

del（p）;

}

}

else

{

p=SJF（head,count）;

q=p->next;

if（q->name!

=re）

{

cout<<"******************************************************"<

cout<<"进程名：

"<name<

re=q->name;

cout<<"到达时间：

"<ta<

}

if（q->rn==1）cout<<"进程开始运行时间：

"<

++time;

++q->rn;

--q->tm;

if（q->tm==0）

{

cout<<"进程"<name<<"运行结束时间：

"<

q->totalTime=time-q->ta;

cout<<"周转时间：

"<totalTime<

q->weightTotalTime=q->totalTime/（double）q->ts;

weight+=q->weightTotalTime;

cout<<"带权周转时间：

"<weightTotalTime<

cout<<"******************************************************"<

del（p）;

}

}

}

}

cout<<"平均周转时间：

"<

cout<<"平均带权周转时间：

"<

cout<<"******************************************************"<

}

以上2个重要函数的思想是根据功能设计里面设计的来编程的。

其他几个函数在附录里的代码有详细记录.在此不做过多给出.

4测试用例，运行结果与运行情况分析

关于本程序的输入格式，其中开始时根据之前给出的main函数可以清楚地进行选择算法以及退出操作。

选择完算法后输入各进程的信息来初始化PCB表。

每个进程信息用回车键分开，同一进程各信息用空格键隔开。

测试情况如下：

4.1时间片轮转算法：

进程名进程到达时间预计运行时间

a510

b010

c210

运行结果如下：

由于时间片轮转法时间片固定为2，因此程序的执行流程过长，在此只将需要运行结果的最后总结部分截图在此。

4.2强占式短进程优先算法：

进程名进程到达时间预计运行时间

a510

b010

c25

运行结果如下：

经分析进程b先运行，运行到第2秒时进程c抢占了处理器，于是运行c，而第5秒时a准备就绪但是根据短进程优先b和c的优先级都比较高于是a最后运行。

综上所述，2种方法的结果与分析的运行结果一致，程序正确。

5自我评价与总结

本次课程设计比较简单，其中具体的思路我们在操作系统课程上已经全部学会了，而设计到的具体代码也比较容易完成，因此我对于本次课程设计还是比较满意的。

但是我的程序还是存在一些不足的。

不足：

在课程设计将要结束时，我发现我在定义数据结构的时候出了一个问题，那就是我的时间都是定义成int型的，也就意味着我不能处理毫秒级别的问题，

处理时间片轮转法时我是将时间片固定为2秒，并不能根据具体的进程来具体分析。

意味着如果需要处理的进程的运行时间都很长的话，会浪费比较多的系统资源来轮转处理器的执行。

优势：

我在刚开始具体课程设计的时候定义了一个结构体PCB，本来我是准备使用单链表来完成全部的2个算法的。

但是在具体编程时我发现对于轮转法来说，使用循环链表这一结构体来实现算法会方便的多，时间复杂度也会小一些。

于是我就重写了轮转法的运行部分，使用这一方法虽然使我的2种调度算法区别变大了，增加了思考和代码量。

但是这使我的程序能比别人快上那么一丝，在进程调度这种时间宝贵的问题上我觉得还是值得的。

收获：

通过这次设计，我更加深刻的理解了2种调度算法之间的共同点、差别、以及在不同情况下的优劣。

不过在关于本次课程设计时遇到的具体问题时，我的收获可能还是在于C++方面，在程序的最后运行时我遇到一个问题，在于开始的时候我将choice这一变量设为了int型，但是由于C++流的问题，在输入字母如g的时候并不能正确的表示choice，这将会导致程序进入死循环阶段，因为cin>>choice的时候流并不能将一个g正确赋给choice，而是停留在缓冲区。

为了解决这一问题，我只能将choice设为char。

虽然只有一字之差，但是结果就不一样。

本次课程设计还算简单，所花时间不多。

希望下次能难一些。

6程序代码附录

（重要代码在之前已经贴出来了，在此省略）

#include

#include

usingnamespacestd;

#defineQT2//定义时间片长度为2

structPCB

{

stringname;//进程名

intta;//进程到达时间

intts;//进程估计运行的时间

inttb;//进程开始运行时间

inttm;//进程仍需运行的时间

intto;//进程完成的时间

intrn;//进程运行的次数

inttotalTime;//周转时间

doubleweightTotalTime;//带权周转时间（周转时间/估计运行时间）

PCB*next;//定义指向下一个进程的指针

};

intpronum;//定义进程数为pronum

inttotal;//记录所有进程的总时间

doubleweight;//记录所有进程的总带权周转时间

PCB*create（PCB*head）;//创建进程队列

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

voidsort（PCB*head）;//将进程按到达的先后顺序排列

intgetCount（PCB*head,inttime）;//察看在time之前到达但未移动到运行队列的进程数量

PCB*searchEnd（PCB*head）;//查找并返回循坏队列的尾节点

voidmove（PCB*headF,PCB*headT,intn）;//将headF后的n个节点移动到循环队列headT中

voidcyclerun（PCB*head）;//时间片轮转算法

PCB*SJF（PCB*head,intcount）;//在头节点后的count个节点中选择需时间最小的返回

voidSJFrun（PCB*head）;//强占式短进程优先算法

PCB*create（PCB*head）

{

PCB*p1,*p2;

p1=p2=newPCB;

head=p1;

cout<<"请输入进程数：

";

cin>>pronum;

for（inti=0;i

{

p2=p1;

p1=newPCB;

p1->next=NULL;

cout<<"请依次输入第"<

"<

cin>>p1->name>>p1->ta>>p1->ts;

p1->tm=p1->ts;

p1->rn=1;

total+=p1->ts;

p2->next=p1;

}

returnhead;

}

voidsort（PCB*head）//将进程按到达的先后顺序排列

{

PCB*p,*q,*r,*s;

if（head->next!

=NULL）

{

p=head->next->next;

head->next->next=NULL;

}

while（p）

{

q=p;

p=p->next;

r=head;

s=head->next;

while（s&&s->ta<=q->ta）

{

r=s;

s=s->next;

}

r->next=q;

q->next=s;

}

}

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

{

PCB*tmp;

tmp=p->next;

p->next=tmp->next;

free（tmp）;

}

intgetCount（PCB*head,inttime）//察看在time之前到达但未移动到运行队列的进程数量

{

intcount=0;

PCB*s,*t;

s=head;

t=s->next;

while（t!

=NULL&&t->ta<=time）

{

s=t;

t=t->next;

count++;//count记录当前时刻到达的进程数

}

returncount;

}

PCB*searchEnd（PCB*head）//查找并返回循坏队列的尾节点

{

PCB*p,*q;

p=head;

q=head->next;

while（q->next!

=head）

{