操作系统课程设计报告处理机调度程序.docx
《操作系统课程设计报告处理机调度程序.docx》由会员分享，可在线阅读，更多相关《操作系统课程设计报告处理机调度程序.docx（14页珍藏版）》请在冰豆网上搜索。
操作系统课程设计报告处理机调度程序
操作系统
课程设计报告
学校：
广州大学
学院：
计算机科学与教育软件学院
班级：
计算机127班
课题：
处理机调度程序
任课老师：
陶文正、陈文彬
姓名：
***
学号：
**********
班内序号：
27
成绩：
日期：
2015年1月6日
一、设计目的
在多道程序和多任务系统中，系统内同时处于就绪状态的进程可能有若干个。
也就是说能运行的进程数大于处理机个数。
为了使系统中的进程能有条不紊地工作，必须选用某种调度策略，选择一进程占用处理机。
要求学生设计一个模拟处理机调度算法，以巩固和加深处理机调度的概念。
二、设计要求
1）进程调度算法包括：
时间片轮转法，短作业优先算法，动态优先级算法。
2）可选择进程数量
3）本程序包括三种算法，用C语言实现，执行时在主界面选择算法（可用函数实现）（进程数，运行时间，优先数由随机函数产生）执行，显示结果。
三、设计思路及算法思想
1.界面菜单选项
一级菜单提供2个选项：
①自动生成进程数量
②手动输入所需进程数量
一级菜单选择完毕后进入二级菜单：
①重新生成进程
②时间片轮转法
③短作业优先算法
④动态优先级算法
⑤退出程序
2.调度算法
程序所用PCB结构体
需要用到的进程结构体如上图所示
1）时间片轮转法
主要是设置一个当前时间变量，curTime和时间片roundTime。
遍历进程组的时候，每运行一个进程，就把curTime+=roundTime。
进程已运行时间加roundTime
2）短作业优先算法
遍历进程组，找到未运行完成并且运行时间最短的进程，让它一次运行完成，如此往复，直到所有进程都运行完成为止。
3）动态优先级算法
做法跟短作业优先算法类似，此处主要是比较进程的优先数，优先级高者，先执行。
直到全部执行完毕。
当一个进程运行完毕后，适当增减其余进程的优先数，以达到动态调成优先级的效果。
3.程序流程图
四、运行截图
1）启动后输入5，生成5个进程
2）输入1，选择时间片轮转法。
自动输出结果，分别是时间片为1和4的结果
3）输入2，选择短作业优先算法
4）输入3，选择动态优先级算法
5）输入0，重新生成进程，再输入3，生成3个进程，选择2.短作业优先算法
6）输入q，退出
五、心得体会
通过这次实验，让我对操作系统的进程调度有了更进一步的了解。
这个实验的模拟程度跟真实系统相比只是冰山一角，由此可见操作系统是何其复杂的软件产品，仅进程调度就有那么丰富和内涵的知识需要掌握。
但是再复杂的系统，都是由小部件构成的。
古语云：
不积跬步,无以至千里。
不积小流,无以成江海。
掌握这些基础的知识，可以为以后打下扎实的基础。
六、附录（源代码）
//
//main.c
//ProcessDispatch
//
//CreatedbyJeanson1/5/15.
//Copyright（c）2015Jeans.Allrightsreserved.
//
#include
#include
//最小进程数
#defineMIN_PROCESS2
//最大进程数
#defineMAX_PROCESS20
//最小优先数
#defineMIN_PRIORITY0
//最大优先数
#defineMAX_PRIORITY10
//最小运行时间
#defineMIN_RUNNING_TIME1
//最大运行时间
#defineMAX_RUNNING_TIME20
typedefstructPCB{
charname;//进程名
intpriority;//优先数
intrunningTime;//运行时间
intarriveTime;//到达时间
intbeginTime;//开始时间
intfinishTime;//完成时间
intcyclingTime;//周转时间
doubleweigthCyclingTime;//带权周转时间
inthadRunTime;//已经运行时间
intfinish;//是否完成
}PCB;
//获取随机数
intGetRandomNumber（intmin,intmax）{
returnarc4random（）%（max-min）+min;
}
//初始化PCB组
voidInitPCBGroup（PCBp[],intnum）{
charname='A';
for（inti=0;ip[i].name=name;
p[i].priority=GetRandomNumber（MIN_PRIORITY,MAX_PRIORITY）;
p[i].runningTime=GetRandomNumber（MIN_RUNNING_TIME,MAX_RUNNING_TIME）;
name++;
}
}
voidPrintResult（PCBp[],intnum）{
doubleavgCycTime=0,avgWeiCycTime=0;
printf（"|进程名到达时间运行时间开始时间完成时间周转时间带权周转时间优先数|\n"）;
for（inti=0;iprintf（"|%3c%-4d%-4d%-4d%-4d%-4d%-6.2f%-4d|\n",p[i].name,p[i].arriveTime,p[i].runningTime,p[i].beginTime,p[i].finishTime,p[i].cyclingTime,p[i].weigthCyclingTime,p[i].priority）;
avgCycTime+=p[i].cyclingTime;
avgWeiCycTime+=p[i].weigthCyclingTime;
//还原
p[i].arriveTime=0;
p[i].beginTime=0;
p[i].finishTime=0;
p[i].cyclingTime=0;
p[i].weigthCyclingTime=0;
p[i].hadRunTime=0;
p[i].finish=0;
}
avgWeiCycTime/=num;
avgCycTime/=num;
printf（"平均周转时间：
%.2f平均带权周转时间:
%.2f\n",avgCycTime,avgWeiCycTime）;
}
//时间片轮转法
voidRealRoundRobin（PCBp[],intnum,introundTime）{
printf（"\n\n-----------------------------时间片：
%d-------------------------------------\n",roundTime）;
intfinishNum=0;
intcurTime=0;
while（finishNum!
=num）{
for（inti=0;iif（p[i].finish）continue;
//开始时间
if（p[i].beginTime==0&&i!
=0）{
p[i].beginTime=curTime;
}
//已经完成
if（p[i].hadRunTime+roundTime>=p[i].runningTime）{
p[i].finishTime=curTime+p[i].runningTime-p[i].hadRunTime;
p[i].cyclingTime=p[i].finishTime-p[i].arriveTime;
p[i].weigthCyclingTime=p[i].cyclingTime/（double）p[i].runningTime;
p[i].finish=1;
finishNum++;
curTime+=p[i].runningTime-p[i].hadRunTime;
}else{
p[i].hadRunTime+=roundTime;
curTime+=roundTime;
}
}
}
PrintResult（p,num）;
}
voidRoundRobin（PCBp[],intnum）{
RealRoundRobin（p,num,1）;//时间片为1的结果
RealRoundRobin（p,num,4）;//时间片为4的结果
}
//短作业优先算法
voidShortestJobFirst（PCBp[],intnum）{
printf（"\n\n-----------------------------短作业优先算法---------------------------------\n"）;
intfinishNum=0;
intcurTime=0;
while（finishNum!
=num）{
intmin=0;
//查找短作业下标
for（inti=1;iif（p[i].finish==0&&p[min].runningTime>=p[i].runningTime）
min=i;
elseif（p[i].finish==0&&p[min].finish==1）
min=i;
}
p[min].beginTime=curTime;
p[min].hadRunTime=p[min].runningTime;
p[min].finishTime=p[min].beginTime+p[min].runningTime;
p[min].cyclingTime=p[min].finishTime-p[min].arriveTime;
p[min].weigthCyclingTime=p[min].cyclingTime/（double）p[min].runningTime;
p[min].finish=1;
finishNum++;
curTime=p[min].finishTime;
}
PrintResult（p,num）;
}
//动态优先级算法
voidDynamicPriorityFirst（PCBp[],intnum）{
printf（"\n\n-----------------------------动态优先级算法---------------------------------\n"）;
intfinishNum=0;
intcurTime=0;
while（finishNum!
=num）{
intmin=0;
//查找优先级最高下标
for（inti=1;iif（p[i].finish==0&&p[min].priority>=p[i].priority）
min=i;
elseif（p[i].finish==0&&p[min].finish==1）
min=i;
}
p[min].beginTime=curTime;
p[min].hadRunTime=p[min].runningTime;
p[min].finishTime=p[min].beginTime+p[min].runningTime;
p[min].cyclingTime=p[min].finishTime-p[min].arriveTime;
p[min].weigthCyclingTime=p[min].cyclingTime/（double）p[min].runningTime;
p[min].finish=1;
finishNum++;
curTime=p[min].finishTime;
}
PrintResult（p,num）;
}
intmain（intargc,constchar*argv[]）{
PCBpcbGroup[30];//pcb数组
intprocessNum=0;//进程数
while
（1）{
//选择进程数量
while
（1）{
if（processNum!
=0）
break;
printf（"\n------------------------------------------------------------------------\n"）;
printf（"当前默认进程数范围%d--%d\n",MIN_PROCESS,MAX_PROCESS）;
printf（"1）输入0可随机生成进程数目\n2）输入%d-%d范围内数字，回车，可生成指定数目进程\n>>>>>>",MIN_PROCESS,MAX_PROCESS）;
intnum=0;
scanf（"%d",&num）;
if（num==0）{
processNum=GetRandomNumber（MIN_PROCESS,MAX_PROCESS）;
break;
}else{
if（（num>=MIN_PROCESS）&&（num<=MAX_PROCESS））{
processNum=num;
InitPCBGroup（pcbGroup,processNum）;
break;
}else
printf（"\n输入有误，请重新输入.\n"）;
}
}
//选择算法
printf（"\n-----------------------------请输入对应选项序号-----------------------------\n"）;
printf（"0.重新生成进程|1.时间片轮转法|2.短作业优先算法|3.动态优先级算法|q.退出\n>>>>>>"）;
charch;
while（（ch=getchar（））=='\n'）;
switch（ch）{
case'0':
//0重新生成进程
processNum=0;break;
case'1':
//1时间片轮转法
RoundRobin（pcbGroup,processNum）;break;
case'2':
//2短作业优先算法
ShortestJobFirst（pcbGroup,processNum）;break;
case'3':
//3动态优先级算法
DynamicPriorityFirst（pcbGroup,processNum）;break;
case'q':
//q退出
exit（0）;
default:
break;
}
}
return0;
}
升级会员 