操作系统课程设计报告进程调度.docx
《操作系统课程设计报告进程调度.docx》由会员分享，可在线阅读，更多相关《操作系统课程设计报告进程调度.docx（25页珍藏版）》请在冰豆网上搜索。
操作系统课程设计报告进程调度
前言
操作系统（OperatingSystem，简称OS）是管理和控制计算机硬件与软件资源的计算机程序，是直接运行在“裸机”上的最基本的系统软件，任何其他软件都必须在操作系统的支持下才能运行。
操作系统是用户和计算机的接口，同时也是计算机硬件和其他软件的接口。
操作系统的功能包括管理计算机系统的硬件、软件及数据资源，控制程序运行，改善人机界面，为其它应用软件提供支持，让计算机系统所有资源最大限度地发挥作用，提供各种形式的用户界面，使用户有一个好的工作环境，为其它软件的开发提供必要的服务和相应的接口等。
实际上，用户是不用接触操作系统的，操作系统管理着计算机硬件资源，同时按照应用程序的资源请求，分配资源，如：
划分CPU时间，内存空间的开辟，调用打印机等。
操作系统的主要功能是资源管理，程序控制和人机交互等。
计算机系统的资源可分为设备资源和信息资源两大类。
设备资源指的是组成计算机的硬件设备，如中央处理器，主存储器，磁盘存储器，打印机，磁带存储器，显示器，键盘输入设备和鼠标等。
信息资源指的是存放于计算机内的各种数据，如系统软件和应用软件等。
操作系统位于底层硬件与用户之间，是两者沟通的桥梁。
用户可以通过操作系统的用户界面，输入命令。
操作系统则对命令进行解释，驱动硬件设备，实现用户要求。
本次课程设计我们将对上学期所学的知识进行系统的应用，而达到巩固知识的作用
1问题概述
编写一个进程调度程序，允许多个进程并发执行。
采取多种进程调度算法（先来先服务（FCFS）调度算法，短进程调度算法（SPF），高响应比优先调度算法，优先级调度（非抢占式）算法）。
分析比较各个算法的优缺点。
2需求分析
进程调度的功能是记录系统中所有进程的执行情况、从就绪态队列中选择一个进程，进行进程上下文的切换。
采取不同的算法根据外部环境及条件进行进程的切换。
3概要设计
3.1主要功能
进程调度的功能是记录系统中所有进程的执行情况、从就绪态队列中选择一个进程，进行进程上下文的切换。
采用先来先服务（FCFS）调度算法，短进程调度算法（SPF），高响应比优先调度算法，优先级调度（非抢占式）算法进行进程的切换。
3.2模块功能结构
图3.2系统结构图
3.3软硬件环境
本程序所适用的计算机系统软硬件环境要求为:
硬件环境:
Pentium III 500以上内存：
256M
软件环境:
LinuxWindows7
应用软件：
Dev-C++
3.4数据结构设计
structPCB_struct
{
charname[10];//进程名称
intpriority;//优先级
intnumber;//进程编号
floatcome_T;//到达时间
floatrun_begin_T;//开始运行时间
floatrun_end_T;//结束运行时间
floatrun_T;//运行时间
intorder;//运行次序
intrun_flag;//调度标志
}PCB[MAX];
4详细设计
4.1“先来先服务（FCFS）调度算法”
4.1.1具体方法
先来先服务算法是按照进程到达先后次序来进行调度。
进入该函数后读取每个进程控制块PCB中的到达时间come_T从come_T最早的开始运行，依次运行完毕。
记录开始运行时间run_begin_T和结束运行时间run_end_T，并记录运行次序。
最后调用调度结果输出函数，输出进程信息和平均周转时间和平均带权周转时间。
4.1.2运行结果
图4.1.2“先来先服务调度算法”运行结果图
4.1.3系统流程图
图4.1.3“先来先服务（FCFS）调度算法”
4.2“短进程调度算法（SPF）”
4.2.1具体方法
短进程调度算法是指对短进程优先调度的算法，这里进程的长短是以进程要求运行的时间的长短来衡量。
进入该函数后读取每个进程控制块中的到达时间come_T，选取最早的，若时间相同则选运行时间最短的进程进行调度，记录开始运行时间run_begin_T和结束运行时间run_end_T，并记录运行次序。
一个进程运行完成后，在查看在此进程运行时间内到达的进程，选取运行时间最短的运行，依次重复，直至所有进程运行完毕，最后调用调度结果输出函数，输出进程信息和平均周转时间和平均带权周转时间。
4.2.2运行结果
图4.2.2“短进程调度算法”运行结果图
4.2.3系统流程图
图4.2.3短进程调度算法（SPF）流程图
4.3“高响应比优先调度算法”
4.3.1具体方法
响应比高者进程优先的算法，响应比的定义是指R=（已等待时间+服务要求时间）/要求服务时间。
实际上，高响应比优先调度算法是先来先服务调度算法和短作业优先调度算法的综合调度算法。
进入该函数后读取每个进程控制块中的到达时间come_T，选取最早的，记录开始运行时间run_begin_T和结束运行时间run_end_T，并记录运行次序。
运行结束后，在查看在此进程运行时间内到达的进程，选取响应比最高的进程运行，依次重复，直至所有进程运行完毕，最后调用调度结果输出函数，输出进程信息和平均周转时间和平均带权周转时间。
4.3.2运行结果
图4.3.2“高响应比优先调度算法”运行结果图
4.3.3系统流程图
图4.3.3“高响应比优先调度算法”流程图
4.4“优先级调度（非抢占式）算法”
4.4.1具体方法
优先级调度算法也成优先权调度算法，本次采用非抢占式优先级算法，在进程输入时确定进程的优先级，数字越大优先级别越高。
进入该函数后读取每个进程控制块中的到达时间come_T，选取最早的，若时间相同则选优先级别高的的进程进行调度，记录开始运
行时间run_begin_T和结束运行时间run_end_T，并记录运行次序。
一个进程运行完成后，在查看在此进程运行时间内到达的进程，选取优先级别高者的进程运行，依次重复，直至所有进程运行完毕，最后调用调度结果输出函数，输出进程信息和平均周转时间和平均带权周转时间。
4.4.2执行结果
图4.4.2“优先级调度（非抢占式）算法”运行结果图
4.4.3系统流程图
图4.4.3“优先级调度（非抢占式）算法”流程图
5系统测试及调试
5.1测试
5.1.1实际测试数据
表5.1.1实际测试数据
5.1.2预期结果
表5.1.2预期结果数据
5.1.3实际运行结果
表5.1.3实际运行结果数据
5.1.4测试结论分析
在这组测试数据中，当进程采用短进程调度优先时，平均带全周转时间最短，效率最好。
但由于进程的数据不同，我们可以采用不同的调度算法，应视情况而选取最佳的调度算法。
5.2调试过程中遇到的问题
5.2.1算法切换时的参数初始化问题
因为该程要实现进程调度中几种主要的算法的调度演示，并计算周转时间进行比较，那么就需要在一组进程上调用不同的算法，并可重复使用该数组。
但是当从一个算法转换到另一个算法的时候，涉及到一些关键变量的初始化问题。
一开始我并没有注意到这个问题，导致运行下一个算法时，因经过一次调度后，所有进程的状态都为执行完毕，所以第二次以及往后都不能得出正确的结论。
经过多次测试后，在每个算法的子函数中加入，状态初始化语句，使得程序能以正常运行，得出正确的数据。
5.2.2输出数据时显示不全且乱
输出是开始时做的函数，然而就遇到了挺烦的困难，因为每个进程的数据项多且杂，输出后不挨个对着看根本不知道谁是谁，XX了很多个案例后决定每个数据输出时严格控制格式，采用|将其分隔。
使其看上去更加严谨，美观。
其实很多小细节也要处理好才能更好体现出这个系统的优点。
6心得体会
通过这次课程设计，使我更加扎实的掌握了有关操作系统方面的知识，特别是进程以及各种调度算法。
进程调度虽然是在系统内部的低级调度，但进程调度的优劣直接影响作业调度的性能。
反映作业调度优劣的周转时间和平均周转时间只在某种程度上反映了进程调度的性能，例如，其执行时间部分中实际上包含有进程等待（包括就绪状态时的等待）时间，而进程等待时间的多少是要依靠进程调度策略和等待事件何时发生等来决定的。
因此，进程调度性能的商量是操作系统设计的一个重要指标。
所以进程调度的重要性也是不可忽视的。
这次的课程设计从选题到完成程序到最后写出课设报告，中间遇到了很多大大小小的问题，但是经过多方努力都得以解决，虽然它并不是一个完善的系统，还存在着这样那样的问题，但是已经进我的努力去完善它。
遇到问题时一定要不懈努力，不能遇到问题就想到要退缩，一定要不厌其烦的发现问题所在，然后一一进行解决，只有这样，才能成功的做成想做的事。
最后，感谢老师的帮助及悉心的指导，感谢同学们的相互帮助，没有他们我自己也不可能完成此次在项目中的任务，更加让我明白了一个团队的重要性，以及个人力量的单薄。
总而言之，还是谢谢大家的互帮互助，而完成这个项目，完成这次课设！
7参考文献
[1]王红.《操作系统原理及应用——Linux》.第二版.北京:
中国水利水电出版社,2005.
[2]王红.《操作系统实训（Linux）——习题解答、例题解析、实验指导》.第二版.北京：
中国水利水电出版社，2008.
[3]孟静.《操作系统原理教程》.北京:
清华大学出版社,2000.
[4]周苏、金海溶.《操作系统原理实验》.北京:
科学出版社,2000.
8附录
#include
#include
#include
usingnamespacestd;//这样命名空间std内定义的所有标识符都有效（曝光）。
就好像它们被声明为全局变量一样。
#defineMAX10
structPCB_struct
{
charname[10];//进程名称
intnumber;//进程编号
intpriority;//优先级
floatcome_T;//到达时间
floatrun_begin_T;//开始运行时间
floatrun_end_T;//开始结束时间
floatrun_T;//运行时间
intorder;//运行次序
intrun_flag;//调度标志
}PCB[MAX],pcb;
intcounter;//实际生成进程个数
voidFCFS（）;//先来先服务算法
voidSPF（）;//短进程调度算法
voidHRRN（）;//高响应比优先调度算法
voidPRI（）;//优先级调度（非抢占式）算法
voidInput（）;//进程输入
voidOutput（）;//调度结果输出
intmain（void）
{
intoption;
while
（1）
{
printf（"\n\n************************进程调度管理**********************"）;
printf（"\n\n*****1进程信息输入"）;
printf（"\n\n*****2采用先来先服务算法进行进程调度并输出"）;
printf（"\n\n*****3采用短进程调度算法进行进程调度并输出"）;
printf（"\n\n*****4采用高响应比优先调度算法进行进程调度并输出"）;
printf（"\n\n*****5采用优先级调度（非抢占式）算法进行进程调度并输出"）;
printf（"\n\n*****0退出"）;
printf（"\n\n请选择：
"）;
scanf（"%d",&option）;
switch（option）
{
case0:
printf（"运行结束，再见"）;
exit（0）;
break;
case1:
Input（）;
break;
case2:
printf（"\n*****对进程按先来先服务调度:
\n\n"）;
FCFS（）;
Output（）;
break;
case3:
printf（"\n*****对进程按短进程调度:
\n\n"）;
SPF（）;
Output（）;
break;
case4:
printf（"\n*****对进程按高响应比优先调度:
\n\n"）;
HRRN（）;
Output（）;
break;
case5:
printf（"\n*****对进程按优先级调度（非抢占式）调度:
\n\n"）;
PRI（）;
Output（）;
break;
default:
printf（"\n*****输入错误！
请重新输入:
"）;
}
}
}
voidInput（）
{
inti;
printf（"\n*****请输入即将运行的进程的个数：
"）;
scanf（"%d",&counter）;
for（i=0;iprintf（"\n*****请输入第%d个进程的信息：
\n",i+1）;
printf（"\n*****请输入进程名字：
"）;
scanf（"%s",PCB[i].name）;
printf（"\n*****请输入进程编号：
"）;
scanf（"%d",&PCB[i].number）;
printf（"\n*****请输入进程的优先级：
"）;
scanf（"%d",&PCB[i].priority）;
printf（"\n*****请输入进程的到达时间：
"）;
scanf（"%f",&PCB[i].come_T）;
printf（"\n*****请输入进程的运行时间：
"）;
scanf（"%f",&PCB[i].run_T）;
PCB[i].run_begin_T=0;
PCB[i].run_end_T=0;
PCB[i].order=0;
PCB[i].run_flag=0;
}
printf（"\n*****录入结束！
"）;
}
voidOutput（）
{
inti;
floatturn_round_T=0,f1,w=0;//f1是周转时间w是平均带权周转时间
printf（"\n|进程名称|进程编号|优先级|到达时间|运行时间|开始时间|结束时间|运行次序|周转时间|"）;
for（i=0;i{
f1=PCB[i].run_end_T-PCB[i].come_T;
turn_round_T=turn_round_T+f1;
w=w+（f1/PCB[i].run_T）;
printf（"||||||||||"）;
printf（"|%s|%d|%d|%5.2f|%5.2f|%5.2f|%5.2f|%d|%5.2f|",
PCB[i].name,PCB[i].number,PCB[i].priority,PCB[i].come_T,PCB[i].run_T,PCB[i].run_begin_T,PCB[i].run_end_T,PCB[i].order,f1）;
}
printf（"\n*****平均周转时间为：
%5.2f",turn_round_T/counter）;
printf（"\n*****平均带权周转时间为：
%5.2f",w/counter）;
}
voidFCFS（）
{
inti,j,time;
if（counter!
=1）
{
for（i=0;i{
for（j=0;j{
if（PCB[j].come_T>PCB[j+1].come_T）
{
pcb=PCB[j];
PCB[j]=PCB[j+1];
PCB[j+1]=pcb;
}
}
}
}//根据到达时间对进程进行排序
time=0;
for（i=0;i{
if（timePCB[i].run_begin_T=PCB[i].come_T;
else
PCB[i].run_begin_T=time;
PCB[i].run_end_T=PCB[i].run_begin_T+PCB[i].run_T;
PCB[i].run_flag=1;
time=PCB[i].run_end_T;
PCB[i].order=i+1;
}//运行每个程序
}
voidSPF（）
{
floattime=0;
inti=0,j;
intnumber=0,temp;
floatrun_time;
run_time=PCB[i].run_T;
j=1;
for（i=0;i{
PCB[i].run_flag=0;
}
i=0;
while（（j{
if（PCB[j].run_T{
run_time=PCB[j].run_T;
i=j;
}
j++;
}//查找第一个被调度的进程
//对第一个被调度的进程运行
number=i;
if（timePCB[number].run_begin_T=PCB[number].come_T;
else
PCB[number].run_begin_T=time;
PCB[number].run_end_T=PCB[number].run_begin_T+PCB[number].run_T;
PCB[number].run_flag=1;
time=PCB[number].run_end_T;
PCB[number].order=1;
temp=1;
while（temp{
for（j=0;j{
if（（PCB[j].come_T<=time）&&（PCB[j].run_flag!
=1））
{
run_time=PCB[j].run_T;
number=j;
break;
}
}
for（j=0;j{
if（（PCB[j].come_T<=time）&&（PCB[j].run_flag!
=1））
{
if（PCB[j].run_T{
run_time=PCB[j].run_T;
number=j;
}
}
}//查找下一个被调度的进程
//对找到的下一个被调度的进程求运行
PCB[number].run_begin_T=time;
PCB[number].run_end_T=PCB[number].run_begin_T+PCB[number].run_T;
PCB[number].run_flag=1;
time=PCB[number].run_end_T;
temp++;
PCB[number].order=temp;
}
}
voidHRRN（）
{
inti,j,number,temp_counter;
floattime=0,response_rate,max_response_rate;
for（i=0;i{
PCB[i].run_flag=0;
}
//运行第一个进程
if（timePCB[0].run_begin_T=PCB[0].come_T;
else
PCB[0].run_begin_T=time;
PCB[0].run_end_T=PCB[0].run_begin_T+PCB[0].run_T;
PCB[0].run_flag=1;
time=PCB[0].run_end_T;
PCB[0].order=1;
temp_counter=1;
//运行其他进程
while（temp_counter{
max_response_rate=0;
for（j=1;j{
if（（PCB[j].come_T<=time）&&（!
PCB[j].run_flag））
{
response_rate=（（time-PCB[j].come_T）/PCB[j].run_T）;
if（response_rate>max_response_rate）
{
max_response_rate=response_rate;
number=j;
}
}
}
if（timePCB[number].run_begin_T=PCB[number].come_T;
else
PCB[number].run_begin_T=time;
PCB[number].run_end_T=PCB[number].run_begin_T+PCB[number].run_T;
PCB[number].run_flag=1;
time=PCB[number].run_end_T;
temp_counter++;
PCB[number].order=temp_counter;
}
}
voidPRI（）
{
floattime=0;
inti=0,j=1;
intnumber,temp;
intmax;
max=PCB[0].priority;
for（i=0;i{
PCB[i].run_flag=0;
}
i=0;
//寻找第一个进程
if（counter!
=1）{
while（（j{
if（PCB[j].priority>PCB[i].priority）
{
max=PCB[j].priority;
i=j;
}
j++;
}
}
//运行第一个进程
number=i;
if（time
升级会员 