操作系统优秀课程设计优质报告进程调度.docx

序言
操作系统（Operating System，简称OS）是管理和控制计算机硬件和软件资源计算机程序，是直接运行在“裸机”上最基础系统软件，任何其它软件全部必需在操作系统支持下才能运行。
操作系统是用户和计算机接口，同时也是计算机硬件和其它软件接口。操作系统功效包含管理计算机系统硬件、软件及数据资源，控制程序运行，改善人机界面，为其它应用软件提供支持，让计算机系统全部资源最大程度地发挥作用，提供多种形式用户界面，使用户有一个好工作环境，为其它软件开发提供必需服务和对应接口等。实际上，用户是不用接触操作系统，操作系统管理着计算机硬件资源，同时根据应用程序资源请求，分配资源，如：划分CPU时间，内存空间开辟，调用打印机等。
操作系统关键功效是资源管理，程序控制和人机交互等。计算机系统资源可分为设备资源和信息资源两大类。设备资源指是组成计算机硬件设备，如中央处理器，主存放器，磁盘存放器，打印机，磁带存放器，显示器，键盘输入设备和鼠标等。信息资源指是存放于计算机内多种数据，如系统软件和应用软件等。
操作系统在底层硬件和用户之间，是二者沟通桥梁。用户能够经过操作系统用户界面，输入命令。操作系统则对命令进行解释，驱动硬件设备，实现用户要求。
此次课程设计我们将对上学期所学知识进行系统应用，而达成巩固知识作用

目录
1问题概述 2
2需求分析 2
3 概要设计 2
3.1关键功效 2
3.2 模块功效结构 3
3.3 软硬件环境 3
3.4数据结构设计 3
4 具体设计 4
4.1“先来先服务（FCFS）调度算法” 4
4.2“短进程调度算法（SPF）” 6
4.3“高响应比优先调度算法” 8
4.4“优先级调度（非抢占式）算法” 10
5 系统测试及调试 12
5.1测试 12
5.2调试过程中碰到问题 13
6 心得体会 14
7 参考文件 15
8 附录 16

1问题概述
编写一个进程调度程序，允很多个进程并发实施。采取多个进程调度算法（先来先服务（FCFS）调度算法，短进程调度算法（SPF），高响应比优先调度算法，优先级调度（非抢占式）算法）。分析比较各个算法优缺点。

2需求分析
进程调度功效是统计系统中全部进程实施情况、从就绪态队列中选择一个进程，进行进程上下文切换。采取不一样算法依据外部环境及条件进行进程切换。

3 概要设计
3.1关键功效
进程调度功效是统计系统中全部进程实施情况、从就绪态队列中选择一个进程，进行进程上下文切换。采取先来先服务（FCFS）调度算法，短进程调度算法（SPF），高响应比优先调度算法，优先级调度（非抢占式）算法进行进程切换。

3.2 模块功效结构

主界面
1进程信息输入
2先来先服务算法
3短进程调度算法
4高响应比优先调度算法
5优先级调度算法
0退出

图3.2系统结构图
3.3 软硬件环境
本程序所适用计算机系统软硬件环境要求为:
硬件环境: Pentium III 500以上 内存：256M 
软件环境: Linux Windows 7
应用软件： Dev-C++ 
3.4数据结构设计
struct PCB_struct
{
char name[10]; //进程名称
int priority; //优先级
int number; //进程编号
float come_T; //抵达时间
float run_begin_T; //开始运行时间
float run_end_T; //结束运行时间
float run_T; //运行时间
int order; //运行次序
int run_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输出数据时显示不全且乱
输出是开始时做函数，然而就碰到了挺烦困难，因为每个进程数据项多且杂，输出后不挨个对着看根本不知道谁是谁，baidu了很多个案例后决定每个数据输出时严格控制格式，采取|将其分隔。使其看上去愈加严谨，美观。其实很多小细节也要处理好才能愈加好表现出这个系统优点。
6 心得体会
经过这次课程设计，使我愈加扎实掌握了相关操作系统方面知识，尤其是进程和多种调度算法。进程调度即使是在系统内部低级调度，但进程调度优劣直接影响作业调度性能。反应作业调度优劣周转时间和平均周转时间只在某种程度上反应了进程调度性能，比如，其实施时间部分中实际上包含有进程等候(包含就绪状态时等候)时间，而进程等候时间多少是要依靠进程调度策略和等候事件何时发生等来决定。所以，进程调度性能商议是操作系统设计一个关键指标。所以进程调度关键性也是不可忽略。
这次课程设计从选题到完成程序到最终写出课设汇报，中间碰到了很多大大小小问题，不过经过多方努力全部得以处理，即使它并不是一个完善系统，还存在着这么那样问题，不过已经进我努力去完善它。碰到问题时一定要不懈努力，不能碰到问题就想到要退缩，一定要不厌其烦发觉问题所在，然后一一进行处理，只有这么，才能成功做成想做事。
最终，感谢老师帮助及悉心指导，感谢同学们相互帮助，没有她们我自己也不可能完成此次在项目中任务，愈加让我明白了一个团体关键性，和个人力量单薄。总而言之，还是谢谢大家互帮互助，而完成这个项目，完成这次课设！

7 参考文件
[1]王红.《操作系统原理及应用——Linux》.第二版.北京:中国水利水电出版社,.
[2]王红.《操作系统实训（Linux）——习题解答、例题解析、试验指导》.第二版.北京：中国水利水电出版社，.
[3]孟静.《操作系统原理教程》.北京:清华大学出版社,.
[4]周苏、金海溶. 《操作系统原理试验》.北京: 科学出版社,.

8 附录
#include<stdio.h>
#include<stdlib.h>
#include<iostream>
using namespace std; //这么命名空间std内定义全部标识符全部有效（曝光）。就仿佛它们被申明为全局变量一样。
#define MAX 10

struct PCB_struct
{
char name[10]; //进程名称
int number; //进程编号
int priority; //优先级
float come_T; //抵达时间
float run_begin_T; //开始运行时间
float run_end_T; //开始结束时间
float run_T; //运行时间
int order; //运行次序
int run_flag; //调度标志
}PCB[MAX],pcb;

int counter; //实际生成进程个数
void FCFS(); //先来先服务算法
void SPF(); //短进程调度算法
void HRRN(); //高响应比优先调度算法
void PRI(); //优先级调度（非抢占式）算法
void Input(); //进程输入
void Output(); //调度结果输出

int main(void)
{
int option;
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)
{
case 0:
printf("运行结束，再见");
exit(0);
break;
case 1:
Input();
break;
case 2:
printf("\n *****对进程按先来先服务调度:\n\n");
FCFS();
Output();
break;
case 3:
printf("\n *****对进程按短进程调度:\n\n");
SPF();
Output();
break;
case 4:
printf("\n *****对进程按高响应比优先调度:\n\n");
HRRN();
Output();
break;
case 5:
printf("\n *****对进程按优先级调度（非抢占式）调度:\n\n");
PRI();
Output();
break;
default:
printf("\n *****输入错误！ 请重新输入: ");
}
}

}

void Input()
{
int i;
printf("\n *****请输入立即运行进程个数：");
scanf("%d",&counter);
for(i=0;i<counter;i++){
printf("\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 *****录入结束！");
}

void Output()
{
int i;
float turn_round_T=0,f1,w=0; //f1是周转时间 w是平均带权周转时间
printf("\n|进程名称|进程编号|优先级|抵达时间|运行时间|开始时间|结束时间|运行次序|周转时间|");
for(i=0;i<counter;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);

}

void FCFS()
{
int i,j,time;
if(counter!=1)
{
for(i=0;i<counter;i++)
{
for(j=0;j<counter-i-1;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<counter;i++)
{
if(time<PCB[i].come_T)
PCB[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;
} //运行每个程序

}

void SPF()
{
float time = 0;
int i=0,j;
int number=0,temp;
float run_time;
run_time=PCB[i].run_T;
j=1;
for(i=0;i<counter;i++)
{
PCB[i].run_flag=0;
}
i=0;
while((j<counter)&&(PCB[i].come_T==PCB[j].come_T))
{
if(PCB[j].run_T<PCB[i].run_T)
{
run_time=PCB[j].run_T;
i=j;
}
j++;
} //查找第一个被调度进程
//对第一个被调度进程运行
number=i;
if(time<PCB[number].come_T)
PCB[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<counter)
{
for(j=0;j<counter;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<counter;j++)
{
if((PCB[j].come_T<=time)&&(PCB[j].run_flag!=1))
{
if(PCB[j].run_T<run_time)
{
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;
}
}

void HRRN()
{
int i,j,number,temp_counter;
float time=0,response_rate,max_response_rate;

for(i=0;i<counter;i++)
{
PCB[i].run_flag=0;
}
//运行第一个进程

if(time<PCB[0].come_T)
PCB[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<counter)
{
max_response_rate=0;
for(j=1;j<counter;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(time<PCB[number].come_T)
PCB[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;

}
}

void PRI()
{
float time=0;
int i=0,j=1;
int number,temp;
int max;
max=PCB[0].priority;
for(i=0;i<counter;i++)
{
PCB[i].run_flag=0;
}
i=0;
//寻求第一个进程
if(counter!=1){
while((j<counter)&&(PCB[i].come_T==PCB[j].come_T))
{
if(PCB[j].priority>PCB[i].priority)
{
max=PCB[j].priority;
i=j;
}
j++;
}
}
//运行第一个进程
number=i;
if(time<PCB[number].come_T)
PCB[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<counter)
{
max=0;
for(j=0;j<counter;j++)
{
if((PCB[j].come_T<=time)&&(PCB[j].run_flag!=1))
if(PCB[j].priority>max)
{
max=PCB[j].priority;
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;

}

}