处理机低级调度模拟系统.docx
《处理机低级调度模拟系统.docx》由会员分享，可在线阅读，更多相关《处理机低级调度模拟系统.docx（25页珍藏版）》请在冰豆网上搜索。
处理机低级调度模拟系统
《高级程序设计语言》课程设计报告
题目：
处理机低级调度模拟系统
专业：
网络工程
班级：
0902
学号：
0930040250
姓名：
郭文明
指导教师：
郑荔敏
完成日期：
2011年11月25日
1、课程设计目的
1、掌握C语言数组、函数、指针、结构体的综合应用。
2、掌握使用C语言，进行应用性的开发。
3、掌握系统数据结构与算法的设计。
二、课程设计内容
课程设计题目：
处理机低级调度模拟系统
课程设计内容：
根据操作系统处理机不同的调度算法，使用C语言模拟实现处理机调度过程。
1、系统数据结构
（1）进程控制块（pcb）：
进程名称、到达时间、进程要求运行时间、进程已运行时间、指针、进程状态等等（要根据不同算法的需要定义全面的数据结构）
（2）进程队列（PQueue）:
链表……
2、调度算法
（1）先来先服务调度（FCFS）：
按照进程提交给系统的先后顺序来挑选进程，先提交的先被挑选。
（2）短进程优先调度（SJF）：
是以进入系统的进程所提出的“执行时间”为标准，总是优先选取执行时间最短的进程。
（3）高响应比优先调度（HRN）：
是在每次调度前都要计算所有被选进程（在后备队列中）的响应比，然后选择响应比最高的进程执行。
（4）多级反馈队列调度（FB，第i级队列的时间片=2i-1）：
（a）应设置多个就绪队列，并为各个队列赋予不同的优先级。
（b）当一个新进程进入内存后，首先将它放入第一队列的末尾，按FCFS的原则排队等待调度。
当轮到该进程执行时，如他能在该时间片内完成，便可准备撤离系统；如果它在一个时间片结束时尚未完成，调度程序便将该进程转入第二队列的末尾，再同样地按FCFS原则等待调度执行；如果它在第二队列中运行一个时间片后仍未完成，再依次将它放入第三队列……，如此下去，当一个长作业进程从第一队列依次降到第N队列后，在第N队列中便采取时间片轮转的方式运行。
（c）仅当第一队列空闲时，调度程序才调度第二队列中的进程运行。
三、课程设计的要求
1、按照给出的题目内容
（1）完成系统数据结构设计与实现、系统算法设计与实现、系统模块设计与实现、系统总体的设计与实现。
（2）系统需要一个简单操作界面，例如：
===========================
1.先来先服务调度
2.短进程优先调度
3.高响应比优先调度
4.多级反馈队列调度
5.退出
（按数字1、2、3、4、5，选择操作）
===========================
（3）对每种调度算法都要求输出每个进程（进程数不少于5）开始运行时刻、完成时刻、周转时间，以及这组进程的平均周转时间。
（4）画出每种调度算法流程图。
2、写出课程设计报告，设计报告提交形式：
电子文档提交
3、个人独立完成。
4、完成时间（1周）
四、课程设计过程
1、系统中所使用的数据结构及说明
//-----------------数据结构的定义----------------------------
//定义进程控制块PCB
typedefstructPCB
{
charPID[5];//进程标示符
charName[10];//进程名称
intPRI;//进程的优先级（越小越高）
floatNeedTime;//进程要求运行时间（服务时间）
floatStartTime;//进程进入就绪队列的时间（到达时间）
floatRunBeginTime;//开始运行时间
floatUpTime;//进程已运行时间
floatOverTime;//进程运行完成的时间
floatTurnaroundTime;//周转时间
floatRightTTime;//带权周转时间
structPCB*next;
}PCB,*QueuePtr;
//定义进程队列
typedefstruct
{
QueuePtrfront,rear;//队头、队尾指针
}PQueue;
2、系统功能结构
本系统是处理机低级调度模拟系统，主要通过模拟来实现处理机调度，调度方式有先来先服务调度（FCFS）、短进程优先调度（SJF）、高响应比优先调度（HRN）、多级反馈队列调度（FB）四种调度方式。
系统运行过程如下：
输入进程个数，输入进程详细信息，通过简单操作界面来选择调度方式，调度的过程和结果，重新选择调度方式或者选择结束。
3、调度算法流程图（如下图所示）
4、程序清单及其描述
#include
#include
#include
#include
#include
#include
#defineNULL0
intProcessNum;//进程个数
floatAverageTurnoverTime;//平均周转时间
floatAverageRightTTime;//平均带权周转时间
//-----------------函数结果状态代码----------------------------
#defineTRUE1
#defineFALSE0
#defineOK1
#defineERROR0
//-----------------数据结构的定义----------------------------
//定义进程控制块PCB
typedefstructPCB
{
charPID[5];//进程标示符
charName[10];//进程名称
intPRI;//进程的优先级（越小越高）
floatNeedTime;//进程要求运行时间（服务时间）
floatStartTime;//进程进入就绪队列的时间（到达时间）
floatRunBeginTime;//开始运行时间
floatUpTime;//进程已运行时间
floatOverTime;//进程运行完成的时间
floatTurnaroundTime;//周转时间
floatRightTTime;//带权周转时间
structPCB*next;
}PCB,*QueuePtr;
//定义进程队列
typedefstruct
{
QueuePtrfront,rear;//队头、队尾指针
}PQueue;
//-----------------函数的申明---------------------------------
intInitQueue（PQueue&Q）;//构造一个空队列
intEnQueue（PQueue&Q）;//插入一个新的进程到队尾
intQueueEmpty（PQueueQ）;//队列判空，若Q为空队列,则返回1,否则返回0
voidPoolQueue（PQueue*Q）;//建立后备队列
intprint（PQueueQ）;//进程队列输出
voidFCFSsort（PQueue&Q）;//先来先服务调度的对到达时间进行排序
voidSPFsort（PQueue&Q）;//短进程优先调度的对服务时间进行排序
voidHRNsort（PQueue&Q）;//高响应比优先调度的对服务时间进行排序
voidDispatcher（PQueue&Q）;//先来先服务调度
voidFB（PQueue&Q）;//多级反馈队列调度
voidManagesChooses（PQueue&Q）;//调度方式选择
//--------------------------------函数的定义---------------------------------
//--------------------------------构造一个空队列---------------------------------
intInitQueue（PQueue&Q）
{
Q.front=Q.rear=（QueuePtr）malloc（sizeof（PCB））;
if（!
Q.front）
exit（0）;
Q.front->next=NULL;
return1;
}
//--------------------------------插入一个新的进程到队尾---------------------------------
intEnQueue（PQueue&Q）
{
QueuePtrp;
if（!
（p=（QueuePtr）malloc（sizeof（PCB））））//存储分配失败
exit（0）;
scanf（"%s",p->PID）;//输入进程标示符
scanf（"%s",p->Name）;//输入进程名
scanf（"%d%f%f",&p->PRI,&p->NeedTime,&p->StartTime）;//输入进程优先级、要求运行时间、到达时间
p->next=NULL;
Q.rear->next=p;
Q.rear=p;
return1;
}
//--------------------------------队列判空，若Q为空队列,则返回1,否则返回0---------------------------------
intQueueEmpty（PQueueQ）
{//若Q为空队列,则返回1,否则返回0
if（Q.front==Q.rear）
return1;
else
return0;
}
//--------------------------------建立后备队列---------------------------------
voidPoolQueue（PQueue*Q）
{
inti;
printf（"请输入进程的个数：
"）;
scanf（"%d",&ProcessNum）;
printf（"请输入%d个进程的信息（T代表时间）\n标示符进程名优先级服务T到达T\n",ProcessNum）;
for（i=1;i<=ProcessNum;i++）
EnQueue（*Q）;
}
//--------------------------------进程队列输出---------------------------------
intprint（PQueueQ）
{
QueuePtrp;
if（Q.front==Q.rear）
return0;
p=Q.front->next;
printf（"（T代表时间）\n标示符进程名优先级服务T到达T\n"）;
while（p!
=NULL）//当队列不空
{
printf（"%s\t%s\t%d\t%4.3f\t%4.3f\n",p->PID,p->Name,p->PRI,p->NeedTime,p->StartTime）;
p=p->next;
}
}
//--------------------------------先来先服务调度的对到达时间进行排序---------------------------------
voidFCFSsort（PQueue&Q）
{
QueuePtrtail,p=Q.front;
QueuePtrq=p->next;
tail=NULL;
for（;p->next->next!
=tail;p=Q.front,q=p->next）//选择排序
{
while（q->next!
=tail）
{
if（p->next->StartTime>q->next->StartTime）
{
p->next=q->next;
q->next=q->next->next;
p->next->next=q;
}
p=p->next;
q=p->next;
}
tail=q;
}
}
//--------------------------------短进程优先调度的对服务时间进行排序---------------------------------
voidSPFsort（PQueue&Q）
{
floatdeltaT,Time=0;//deltaT是时间差
QueuePtrtemp1,temp2,tail,p=Q.front;
QueuePtrq=p->next;
tail=NULL;
for（;q->next!
=tail;）//找出第一个到达而且服务时间最少的进程
{
if（p->next->StartTime>q->next->StartTime）
{
temp1=p->next;
temp2=q->next;
p->next=temp2;
q->next=temp2->next;
p->next->next=temp1;
}
else
{
q=q->next;
}
}
if（p->next->StartTime>Time）
Time=p->StartTime;
Time=Time+p->next->NeedTime;
for（p=p->next,q=p->next;p->next->next!
=tail;p=p->next,q=p->next）//对队列按到达时间与服务时间长短进行选择排序（从第二个元素开始）
{
while（q->next!
=tail）
{
if（（p->next->StartTime<=Time））
{
if（（q->next->StartTime<=Time）&&（p->next->NeedTime>q->next->NeedTime））
{
temp1=p->next;
temp2=q->next;
p->next=temp2;
q->next=temp2->next;
p->next->next=temp1;
}
else
{
q=q->next;
}
}
elseif（（p->next->StartTime>Time）&&（q->next->StartTime<=Time））
{
temp1=p->next;
temp2=q->next;
p->next=temp2;
q->next=temp2->next;
p->next->next=temp1;
}
else
{
q=q->next;
}
}
if（p->next->StartTime>Time）
{
deltaT=p->StartTime-Time;
Time=Time+deltaT;
}
Time=Time+p->next->NeedTime;
}
}
//--------------------------------高响应比优先调度的对服务时间进行排序---------------------------------
voidHRNsort（PQueue&Q）
{
floatdeltaT,PResponseRatio,QResponseRatio,Time=0;//deltaT是时间差,PResponseRatio、QResponseRatio是响应比
QueuePtrtemp1,temp2,tail,p=Q.front;
QueuePtrq=p->next;
tail=NULL;
for（;q->next!
=tail;）//找出第一个到达而且服务时间最少的进程
{
if（p->next->StartTime>q->next->StartTime）
{
temp1=p->next;
temp2=q->next;
p->next=temp2;
q->next=temp2->next;
p->next->next=temp1;
}
else
{
q=q->next;
}
}
if（p->next->StartTime>Time）
Time=p->StartTime;
Time=Time+p->next->NeedTime;
for（p=p->next,q=p->next;p->next->next!
=tail;p=p->next,q=p->next）//对队列按响应比大小排序（从第二个元素开始）
{
while（q->next!
=tail）
{
if（（p->next->StartTime<=Time）&&（q->next->StartTime<=Time））
{
PResponseRatio=（（（Time-p->next->StartTime）+p->next->NeedTime）/（p->next->NeedTime））;
QResponseRatio=（（（Time-q->next->StartTime）+q->next->NeedTime）/（q->next->NeedTime））;
if（PResponseRatio{
temp1=p->next;
temp2=q->next;
p->next=temp2;
q->next=temp2->next;
p->next->next=temp1;
}
else
{
q=q->next;
}
}
elseif（（p->next->StartTime>Time）&&（q->next->StartTime<=Time））
{
temp1=p->next;
temp2=q->next;
p->next=temp2;
q->next=temp2->next;
p->next->next=temp1;
}
else
{
q=q->next;
}
}
if（p->next->StartTime>Time）
{
deltaT=p->StartTime-Time;
Time=Time+deltaT;
}
Time=Time+p->next->NeedTime;
}
}
//--------------------------------调度---------------------------------
voidDispatcher（PQueue&Q）
{
floatSumTurnaroundTime=0;//定义周转时间总和并赋值0
floatSumRightTTime=0;//定义带权周转时间总和并赋值0
floatdeltaT,Time=0;//deltaT是时间差
QueuePtrp=Q.front->next;
printf（"（T代表时间）\n标示符进程名到达T服务T开始T完成T周转T带权周转T\n"）;
for（;p!
=NULL;p=p->next）
{
if（p->StartTime>Time）
{
deltaT=p->StartTime-Time;
Time=deltaT;
}
p->RunBeginTime=Time;
p->OverTime=Time+p->NeedTime;
p->TurnaroundTime=p->OverTime-p->StartTime;
p->RightTTime=p->TurnaroundTime/p->NeedTime;
printf（"%s\t%s\t%4.3f\t%4.3f\t%4.3f\t%4.3f\t%4.3f\t%4.3f\n",p->PID,p->Name,p->StartTime,p->NeedTime,p->RunBeginTime,p->OverTime,p->TurnaroundTime,p->RightTTime）;
Time=p->OverTime;
}
for（p=Q.front->next;p!
=NULL;p=p->next）//计算平均周转时间和平均带权周转时间
{
SumTurnaroundTime=SumTurnaroundTime+p->TurnaroundTime;
SumRightTTime=SumRightTTime+p->RightTTime;
}
AverageTurnoverTime=SumTurnaroundTime/ProcessNum;
AverageRightTTime=SumRightTTime/ProcessNum;
printf（"此调度方式的平均周转时间为%4.3f,平均带权周转时间为%4.3f\n",AverageTurnoverTime,AverageRightTTime）;
}
//--------------------------------多级反馈队列调度---------------------------------
voidFB（PQueue&Q）
{
PQueueM,N;
InitQueue（M）;//初始化第二队列
InitQueue（N）;//初始化第三队列
FCFSsort（Q）;
printf（"调度前进程排列如下:
\n"）;
print（Q）;
QueuePtrp,q,r;
q=M.front;
r=N.front;
floati,deltaT,Time=0;//deltaT是时间差
floatT1,T2,T3;
T1=2*1-1;//第一队列Q的时间片
T2=2*2-1;//第二队列M的时间片
T3
升级会员 