c语言课程设计处理机低级调度模拟系统Word格式.docx
- 文档编号:18343383
- 上传时间:2022-12-15
- 格式:DOCX
- 页数:24
- 大小:459.71KB
c语言课程设计处理机低级调度模拟系统Word格式.docx
《c语言课程设计处理机低级调度模拟系统Word格式.docx》由会员分享,可在线阅读,更多相关《c语言课程设计处理机低级调度模拟系统Word格式.docx(24页珍藏版)》请在冰豆网上搜索。
1、按照给出的题目内容
(1)完成系统数据结构设计与实现、系统算法设计与实现、系统模块设计与实现、系统总体的设计与实现。
(2)系统需要一个简单操作界面,例如:
===========================
1.先来先服务调度
2.多级反馈队列调度
3.退出
(按数字1、2、3、,选择操作)
(3)对每种调度算法都要求输出每个进程(进程数不少于5)开始运行时刻、完成时刻、周转时间,以及这组进程的平均周转时间。
(4)画出每种调度算法流程图。
1.先来先服务调度:
2.多级反馈队列调度:
四:
课程设计过程:
1.系统中所使用的数据结构及说明
……..数据结构的定义…………..
定义进程控制块PCB
structPCB{
charname[10];
//进程名字
floatarrivetime;
//进程到达时间
floatservicetime;
//进程服务时间
floatsuper;
//响应比
floatstarttime;
//开始运行时间
floatfinishtime;
//完成时间
floatTurnaroundTime;
//周转时间
charstate;
//进程的状态,W就绪态,R执行态,F完成态
intprio;
//优先级
intround;
//时间片
intcputime;
//cpu时间
intneedtime;
//进程运行时间
intcount;
//计数器
structPCB*next;
}*ready=NULL,*p,*q;
定义就绪队列:
typedefstructQueue//多级就绪队列节点信息
{
PCB*LinkPCB;
//就绪队列中的进程队列指针
//本就绪队列的优先级
//本就绪队列所分配的时间片
structQueue*next;
//指向下一个就绪队列的链表指针
}ReadyQueue;
2.系统功能结构
本系统是处理机低级调度模拟系统,主要通过模拟来实现处理机调度,调度方式有先来先服务调度(FCFS)、短进程优先调度(SJF)、高响应比优先调度(HRN)、多级反馈队列调度(FB)四种调度方式。
系统运行过程如下:
输入进程个数,输入进程详细信息,通过简单操作界面来选择调度方式,调度的过程和结果,重新选择调度方式或者选择结束。
3.程序清单及描述
#defineNULL0
#include<
stdio.h>
stdlib.h>
conio.h>
string.h>
windows.h>
PCBa[100];
intN;
voidcreateProcess(PCB*p)//创建进程函数
inti;
printf("
输入进程名&
到达时间&
服务时间:
\n例如:
a0100\n"
);
for(i=0;
i<
=N-1;
i++)
{
printf("
输入第%d个进程的信息:
\n"
i+1);
scanf("
%s%f%f"
&
p[i].name,&
p[i].arrivetime,&
p[i].servicetime);
}
}
voidsort(PCB*p,intN)//到达时间排序
{
for(inti=0;
for(intj=0;
j<
=i;
j++)
if(p[i].arrivetime<
p[j].arrivetime)
PCBtemp;
temp=p[i];
p[i]=p[j];
p[j]=temp;
voidrunning(PCB*p,floatarrivetime,floatservicetime,floatstarttime,floatfinishtime,float&
TurnaroundTime,intN)//计算进程时间
intk;
for(k=0;
k<
k++)
if(k==0)
{
p[k].starttime=p[k].arrivetime;
p[k].finishtime=p[k].arrivetime+p[k].servicetime;
}
else
{
p[k].starttime=p[k-1].finishtime;
p[k].finishtime=p[k-1].finishtime+p[k].servicetime;
}
p[k].TurnaroundTime=p[k].finishtime-p[k].arrivetime;
voidprint(PCB*p,floatarrivetime,floatservicetime,floatstarttime,floatfinishtime,floatTurnaroundTime,intN)//进程输出各种时间
{intk;
运行次序:
"
%s"
p[0].name);
for(k=1;
N;
-->
p[k].name);
\n进程的信息:
\n进程名\t到达\t服务\t开始\t完成\t周转\n"
%s\t%-.2f\t%-.2f\t%-.2f\t%-.2f\t%-.2f\t\n"
p[k].name,p[k].arrivetime,p[k].servicetime,p[k].starttime,p[k].finishtime,p[k].TurnaroundTime);
}
voidfcfs(PCB*p)//先来先服务调度算法
system("
cls"
请输入作业数:
scanf("
%d"
N);
while(N<
5)//进程小于5的话,重新选择输入
system("
\n\7\7作业数小于5,重新输入:
createProcess(a);
floatarrivetime=0,servicetime=0,starttime=0,finishtime=0,TurnaroundTime=0;
sort(p,N);
//排序
running(p,arrivetime,servicetime,starttime,finishtime,TurnaroundTime,N);
//模拟运行
print(p,arrivetime,servicetime,starttime,finishtime,TurnaroundTime,N);
//打印输入结果
PCB*run=NULL,*finish=NULL;
//定义三个队列,就绪队列,执行队列和完成队列
ReadyQueue*Head=NULL;
//定义第一个就绪队列
intnum;
//进程个数
intReadyNum;
//就绪队列个数
voidOutput();
//进程信息输出函数
voidInsertFinish(PCB*in);
//将进程插入到完成队列尾部
voidInsertPrio(ReadyQueue*in);
//创建就绪队列,规定优先数越小,优先级越低
voidPrioCreate();
//创建就绪队列输入函数
voidGetFirst(ReadyQueue*queue);
//取得某一个就绪队列中的队头进程
voidInsertLast(PCB*in,ReadyQueue*queue);
//将进程插入到就绪队列尾部
voidProcessCreate();
//进程创建函数
voidRoundRun(ReadyQueue*timechip);
//时间片轮转调度算法
voidMultiDispatch();
//多级调度算法,每次执行一个时间片
voidOutput()//进程信息输出函数
ReadyQueue*print=Head;
PCB*p;
进程名\t优先级\t轮数\tcpu时间\t需要时间\t进程状态\t计数器\n"
while(print)
{
if(print->
LinkPCB!
=NULL)
p=print->
LinkPCB;
while(p)
{
printf("
%s\t%d\t%d\t%d\t%d\t\t%c\t\t%d\n"
p->
name,p->
prio,p->
round,p->
cputime,p->
needtime,p->
state,p->
count);
p=p->
next;
}
print=print->
p=finish;
while(p!
=NULL)
p=p->
p=run;
p=p->
}
voidInsertFinish(PCB*in)//将进程插入到完成队列尾部
PCB*fst;
fst=finish;
if(finish==NULL)
in->
next=finish;
finish=in;
else
while(fst->
next!
fst=fst->
in->
next=fst->
fst->
next=in;
voidInsertPrio(ReadyQueue*in)//创建就绪队列,规定优先数越小,优先级越低
ReadyQueue*fst,*nxt;
fst=nxt=Head;
if(Head==NULL)//没有队列,则为第一个元素
in->
next=Head;
Head=in;
else//查到合适的位置进行插入
if(in->
prio>
=fst->
prio)//比第一个还要大,则插入到队头
in->
Head=in;
else
while(fst->
=NULL)//移动指针查找第一个别它小的元素的位置进行插入
nxt=fst;
fst=fst->
if(fst->
next==NULL)//已经搜索到队尾,则其优先级数最小,将其插入到队尾即可
in->
fst->
else//入到队列中
nxt=in;
next=fst;
voidPrioCreate()//创建就绪队列输入函数
ReadyQueue*tmp;
输入就绪队列的个数:
ReadyNum);
输入每个就绪队列的CPU时间片:
(一次行输完所有,再按回车结束,如:
123)\n"
for(i=0;
i<
ReadyNum;
i++)
if((tmp=(ReadyQueue*)malloc(sizeof(ReadyQueue)))==NULL)
perror("
malloc"
exit
(1);
(tmp->
round));
//输入此就绪队列中给每个进程所分配的CPU时间片
tmp->
prio=50-tmp->
round;
//置其优先级,时间片越高,其优先级越低
LinkPCB=NULL;
//初始化其连接的进程队列为空
next=NULL;
InsertPrio(tmp);
//照优先级从高到低,建立多个就绪队列
voidGetFirst(ReadyQueue*queue)//取得某一个就绪队列中的队头进程
run=queue->
if(queue->
run->
state='
R'
;
queue->
LinkPCB=queue->
LinkPCB->
voidInsertLast(PCB*in,ReadyQueue*queue)//将进程插入到就绪队列尾部
fst=queue->
if(queue->
LinkPCB==NULL)
next=queue->
queue->
LinkPCB=in;
voidProcessCreate()//针对多级反馈队列算法的进程创建函数
PCB*tmp;
num);
if(num<
5)
ProcessCreate();
输入进程名字和进程所需时间:
(一次性输完,再按回车结束如:
a1b2c3d4e5)\n"
num;
if((tmp=(PCB*)malloc(sizeof(PCB)))==NULL)
tmp->
name);
getchar();
needtime));
cputime=0;
state='
W'
needtime;
//置其优先级,需要的时间越多,优先级越低
round=Head->
count=0;
InsertLast(tmp,Head);
//照优先级从高到低,插入到就绪队列
voidRoundRun(ReadyQueue*timechip)//时间片轮转调度算法
intflag=1;
GetFirst(timechip);
while(run!
while(flag)
run->
count++;
cputime++;
needtime--;
if(run->
needtime==0)
run->
F'
InsertFinish(run);
flag=0;
elseif(run->
count==timechip->
round)//间片用完
run->
//数器清零,为下次做准备
InsertLast(run,timechip);
flag=1;
GetFirst(timechip);
voidMultiDispatch()//多级调度算法,每次执行一个时间片
intk=0;
您选择的是多级反馈队列算法\n"
PrioCreate();
//建就绪队列
ProcessCreate();
//创建就绪进程队列
ReadyQueue*point;
point=Head;
GetFirst(point);
Output();
if(Head->
LinkPCB!
point=Head;
run->
if(run->
needtime==0)//程执行完毕
count==run->
if(point->
next!
{
run->
round=point->
next->
//置其时间片是下一个就绪队列的时间片
InsertLast(run,point->
next);
//进程插入到下一个就绪队列中
flag=0;
}
else
RoundRun(point);
//果为最后一
- 配套讲稿:
如PPT文件的首页显示word图标,表示该PPT已包含配套word讲稿。双击word图标可打开word文档。
- 特殊限制:
部分文档作品中含有的国旗、国徽等图片,仅作为作品整体效果示例展示,禁止商用。设计者仅对作品中独创性部分享有著作权。
- 关 键 词:
- 语言 课程设计 处理机 低级 调度 模拟 系统