武汉理工大学操作系统处理机调度实验报告资料.docx

武汉理工大学操作系统处理机调度实验报告资料.docx

《武汉理工大学操作系统处理机调度实验报告资料.docx》由会员分享，可在线阅读，更多相关《武汉理工大学操作系统处理机调度实验报告资料.docx（20页珍藏版）》请在冰点文库上搜索。

武汉理工大学操作系统处理机调度实验报告资料

学生学号

Xxx

实验课成绩

学生实验报告书

实验课程名称

操作系统C

开课学院

计算机科学与技术学院

指导教师姓名

xxx

学生姓名

xxx

学生专业班级

xxxx

2016

--

2017

学年

第

1

学期

实验课程名称：

操作系统C

实验项目名称

处理机调度

报告成绩

实验者

陈硕

专业班级

计算机zy1401

组别

同组者

完成日期

2016年11月25日

第一部分：

实验分析与设计（可加页）

一、实验目的和要求

1.目的

掌握处理机调度的相关内容

对进程调度算法有深入的理解

2.要求

模拟实现进程调度功能

任选一种计算机高级语言编程实现

选择1-2种进程调度算法，例如：

先来先服务、短进程优先、最高响应比优先、时间片轮转、优先级法等

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

根据选择的调度算法显示进程的调度顺序

显示完成调度后每个进程的开始时间、完成时间和周转时间、带权周转时间

计算平均周转时间和平均带权周转时间

二、分析与设计

1.实验原理分析

（1）先来先服务调度算法的基本原理

按照作业提交/进程变为就绪状态放的先后次序，调入系统或分派CPU，（即调度程序每次选择的作业或进程是等待时间最久的，而不管其运行时间的长短。

）

（2）短进程优先调度算法的基本原理

对预计执行时间短的作业（进程）优先处理。

通常后来的短作业不抢先正在执行的作业。

（3）优先级调度算法的基本原理

对优先级高的作业（进程）优先处理。

可分为抢占式和非抢占式。

本实验采用非抢占式。

（4）最高响应比优先调度算法的基本原理

响应比优先算法是介于FCFS算法和SJF算法之间的一种折中算法，同时考虑每个作业的等待时间和估计需要运行的时间，从中选出响应比最高的作业投入运行。

依据上述的实验目的与要求，可导出实现处理机调度的流程为：

①将作业信息保存到结构体数组中

②设计不同的进程调度算法

③用while进行循环控制选择不同的算法

2.数据结构的设计

●记录不同作业信息的结构体数组。

structnodejob[100];

记录作业/进程详细信息的结构体

typedefstructnode{

stringname;

doublesubmit;//提交时间

doublestart;//开始时间

doublerun;//运行时间

doubleend;//完成时间

doubleTi;//周转时间

doubleWi;//带权周转时间

doubleH;//响应比

intpriority;//优先级

}*work;

3.核心算法设计

（1）按提交时间进行排序的算法

Input：

workp//指向作业的指针

intN//作业的个数

Process：

voidsort（workp,intN）

{

for（inti=0;i

{

for（intj=0;j

{

if（p[i].submit

{

nodetemp;

temp=p[i];

p[i]=p[j];

p[j]=temp;

}

}

}

}

（2）先来先服务算法

Input：

workp//指向作业的指针

intN//作业的个数

Process：

voidFCFS（workp,intN）

{

sort（p,N）;//调用排序算法

for（k=0;k

{

if（k==0）

{

p[k].start=p[k].submit;

p[k].end=p[k].start+p[k].run;

p[k].Ti=p[k].end-p[k].submit;

p[k].Wi=p[k].Ti/p[k].run;

}

else

{

if（p[k].submit

{

p[k].start=p[k-1].end;

p[k].end=p[k].start+p[k].run;

p[k].Ti=p[k].end-p[k].submit;

p[k].Wi=p[k].Ti/p[k].run;

}

else

{

p[k].start=p[k].submit;//作业完成时还没有提交的作业计算方法

p[k].end=p[k].start+p[k].run;

p[k].Ti=p[k].end-p[k].submit;

p[k].Wi=p[k].Ti/p[k].run;

}

}

sumTi=sumTi+p[k].Ti;

sumWi=sumWi+p[k].Wi;

}

T=sumTi/N;//计算平均周转时间

W=sumWi/N;//计算平均带权周转时间

output（p,N）;//调用输出函数

}

（3）短进程优先算法

Input：

workp//指向作业的指针

intN//作业的个数

Process：

voidSJF（workp,intN）

{

sort（p,N）;//按提交时间排序

for（k=0;k

{

if（k==0）

{

p[k].start=p[k].submit;

p[k].end=p[k].start+p[k].run;

p[k].Ti=p[k].end-p[k].submit;

p[k].Wi=p[k].Ti/p[k].run;

for（n=k+1;n

{

if（p[n].submit>p[k].end）

{

break;

}

}

for（m=k+1;m

{

for（intl=k+1;l

{

if（p[m].run

{

nodetemp;

temp=p[m];

p[m]=p[l];

p[l]=temp;

}

}

}

}

else

{

if（p[k].submit

{

p[k].start=p[k-1].end;

p[k].end=p[k].start+p[k].run;

p[k].Ti=p[k].end-p[k].submit;

p[k].Wi=p[k].Ti/p[k].run;

}

else

{

p[k].start=p[k].submit;

p[k].end=p[k].start+p[k].run;

p[k].Ti=p[k].end-p[k].submit;

p[k].Wi=p[k].Ti/p[k].run;

}

for（n=k+1;n

{

if（p[n].submit>p[k].end）

{

break;

}

}

for（m=k+1;m

{

for（intl=k+1;l

{

if（p[m].run

{

nodetemp;

temp=p[m];

p[m]=p[l];

p[l]=temp;

}

}

}

}

sumTi=sumTi+p[k].Ti;

sumWi=sumWi+p[k].Wi;

}

T=sumTi/N;

W=sumWi/N;

output（p,N）;

}

（4）最高响应比优先算法

Input：

workp//指向作业的指针

intN//作业的个数

Process：

voidHRN（workp,intN）

{

sort（p,N）;//按提交时间排序

for（k=0;k

{

if（k==0）

{

p[k].start=p[k].submit;

p[k].end=p[k].start+p[k].run;

p[k].Ti=p[k].end-p[k].submit;

p[k].Wi=p[k].Ti/p[k].run;

for（n=k+1;n

{

if（p[n].submit>p[k].end）

{

break;

}

}

inty=k+1;

for（intx=k+1;x

{

p[x].H=1.00+（（p[y-1].end-p[x].submit）/p[x].run）;//注意在计算响应比时不能用变量X进行循环计算。

}

for（m=k+1;m

{

for（intl=k+1;l

{

if（p[m].H>p[l].H）

{

nodetemp;

temp=p[m];

p[m]=p[l];

p[l]=temp;

}

}

}

}

else

{

if（p[k].submit

{

p[k].start=p[k-1].end;

p[k].end=p[k].start+p[k].run;

p[k].Ti=p[k].end-p[k].submit;

p[k].Wi=p[k].Ti/p[k].run;

}

else

{

p[k].start=p[k].submit;

p[k].end=p[k].start+p[k].run;

p[k].Ti=p[k].end-p[k].submit;

p[k].Wi=p[k].Ti/p[k].run;

}

for（n=k+1;n

{

if（p[n].submit>p[k].end）

{

break;

}

}

inty=k+1;

for（intx=k+1;x

{

p[x].H=1.00+（（p[y-1].end-p[x].submit）/p[x].run）;

}

for（m=k+1;m

{

for（intl=k+1;l

{

if（p[m].H>p[l].H）

{

nodetemp;

temp=p[m];

p[m]=p[l];

p[l]=temp;

}

}

}

}

sumTi=sumTi+p[k].Ti;

sumWi=sumWi+p[k].Wi;

}

T=sumTi/N;

W=sumWi/N;

output（p,N）;

}

（5）优先级响应算法

Input：

workp//指向作业的指针

intN//作业的个数

Process：

voidPS（workp,intN）//优先级调度算法

{

sort（p,N）;//按提交时间排序

for（k=0;k

{

if（k==0）//第一个提交的作业单独计算相关调度信息

{p[k].start=p[k].submit;

p[k].end=p[k].start+p[k].run;

p[k].Ti=p[k].end-p[k].submit;

p[k].Wi=p[k].Ti/p[k].run;

/*按优先级进行排序*/

for（n=k+1;n

{

if（p[n].submit>p[k].end）

{

break;

}

}

for（m=k+1;m

{

for（intl=k+1;l

{

if（p[m].priority

{

nodetemp;

temp=p[m];

p[m]=p[l];

p[l]=temp;

}

}

}

}

else

{

if（p[k].submit

{

p[k].start=p[k-1].end;

p[k].end=p[k].start+p[k].run;

p[k].Ti=p[k].end-p[k].submit;

p[k].Wi=p[k].Ti/p[k].run;

}

else

{

p[k].start=p[k].submit;

p[k].end=p[k].start+p[k].run;

p[k].Ti=p[k].end-p[k].submit;

p[k].Wi=p[k].Ti/p[k].run;

}//进行作业相关调度信息的计算

/*按优先级进行排序*/

for（n=k+1;n

{

if（p[n].submit>p[k].end）

{

break;

}

}

for（m=k+1;m

{

for（intl=k+1;l

{

if（p[m].priority

{

nodetemp;

temp=p[m];

p[m]=p[l];

p[l]=temp;

}

}

}

}

sumTi=sumTi+p[k].Ti;

sumWi=sumWi+p[k].Wi;

}

T=sumTi/N;

W=sumWi/N;

output（p,N）;

}

3.测试用例设计

（1）

（2）

三、主要仪器设备及耗材

1．安装了WindowsXP或Windows7或其它版本的Windows操作系统的PC机1台

2．PC机系统上安装了MicrosoftVisualStudio2010开发环境

第二部分：

实验过程和结果（可加页）

一、实现说明

在VS2010中创建一个算法调度项目，对于不同的调度算法分别进行算法设计，对于算法的设计要特别注意作业的提交情况，实验中存储作业信息的结构体是相同的，采用结构体数组保存全部的作业，每次通过对结构体数组进行遍历计算不同算法需要的信息，最后在主函数中用while循环和switch语句进行各个调度算法的选择，最后经过不断的调试和运行，实现四个调度算法分别是先来先服务、短进程优先、优先级和最高响应比优先。

二、调试说明（调试手段、过程及结果分析）

调试过程出现的问题比较多，第一个问题是对于不同作业提交的先后顺序要加以考虑，对于作业提交时间进行排序选择，必须选择提交时间在上一个作业结束时间之前的作业进行短进程，优先级，最高响应比排序，经过排序选择后，出现的问题是在进行作业调度完，有的作业出现了负的结束时间，经过调试分析，发现不能直接用上一个作业的结束时间直接当做下一个作业的开始时间，每次进行作业调度前要进行提交时间与上一个作业结束时间的比较，如果在作业提交前，下一个作业还没有提交，那么在下一个作业的开始时间就是它的提交时间。

第二个问题是在计算响应比时，对于循环变量X的使用出错，使得最高响应比的计算出错，导致按最高响应比排序出错。

后来通过子在出错位置前后进行输出变量的值，不断调试，发现了问题，经过修改算法，调试通过，得到最终正确结果。

三、软件测试（测试效果.界面、综合分析和结论）

1．测试效果.界面

测试用例

（1）运行结果

测试用例

（2）运行结果

2．综合分析和结论

实验结果显示不同调度算法的不同调度策略，其中短进程优先调度算法在平均周转时间和平均带权周转时间上要比先来先服务算法少，可见短进程优先算法较先来先服务算法在调度时间上更优，其中最高相应比优先调度算法则是综合考虑以上两种算法来进行调度，其调度过程考虑的更全面。

优先级调度算法只根据优先级进行调度，其在时间上可能不会很合理。

第三部分：

实验小结、收获与体会

通过这次试验，使我对处理机调度的相关算法有了更深入的理解，在实验过程中首先是对各个算法的基本原理全部掌握，然后进行算法设计和编程。

实验中做得比较出色的地方是提前考虑了作业的提交时间，对于没有提交的作业不能进行排队调度。

试验中没有考虑到的是对于提交时间在上一个进程结束时间之后的进程，它的开始时间应该是它本身的提交时间，而不能直接使用上一个进程的结束时间作为它的开始时间，否则会出现负的时间。

本次试验在中间调试代码时，采用了下断点，在不同位置进行关键信息的输出等调试手段，很好的解决了最高响应比计算出错的问题，可以使调度算法正确执行。

对于这些调试技巧，在以后的编程调试过程中可以多多使用，可以很好地解决出现的一些问题。

本次试验除了使用结构体数组还可以使用类、链表等实现作业的调度。

本次实验题目难度适中，不仅有利于我们更深入的理解处理机调度的实现过程，更能提高我们的编程动手能力，非常适合我们在实验中练习。