课程设计处理器调度算法模拟.docx
《课程设计处理器调度算法模拟.docx》由会员分享，可在线阅读，更多相关《课程设计处理器调度算法模拟.docx（29页珍藏版）》请在冰豆网上搜索。
课程设计处理器调度算法模拟
南通大学计算机学院
操作系统课程设计
报告书
设计题目处理器调度算法模拟
专业班级软嵌161
学生姓名候玉权
学号**********
指导教师丁红
日期2018.07.05
实验报告正文内容
1、课程设计的目的
在采用多道程序设计的系统中，往往有若干个进程同时处于就绪状态。
当就绪状态进程个数大于处理器数时，就必须依照某种策略来决定哪些进程优先占用处理器。
本实验模拟在单处理器情况下处理器调度，帮助学生加深了解处理器调度的工作。
2、课程设计的要求
用C++语言编写程序完成单处理机的进程调度
3、课程设计的环境
在机房完成，运行环境vs2017
4、问题描述
对cpu调度算法进行模拟实现，包含先来先服务，短作业优先，响应比最高优先，时间片轮转等算法。
5、算法分析
数据结构
structef
{
charname[10];//进程名称
intnumber;//进程编号
floatdaodatime;//到达时间
floatkaishitime;//开始运行时间
floatyunxingtime;//运行时间
floatjieshutime;//运行结束时间
intshengyutime;//剩余时间
intfuwutime;//服务时间
intorder;//运行次序
intrun_flag;//调度标志
intpriority;//优先级
structef*next;
}
先来先服务算法
intfcfs（）//先来先服务
{
floattp=0;
inti;
intzx;
tp=ef[0].daodatime;
for（i=0;i{
ef[i].kaishitime=tp;
ef[i].jieshutime=ef[i].kaishitime+ef[i].yunxingtime;
ef[i].run_flag=1;
tp=ef[i].jieshutime;
zx=i;
ef[zx].order=i+1;
}
return0;
}
短作业优先
intsjf（）//短作业优先
{
floattemp_time=0;
inti=0,j;
intzx,tc;
floatyunxingtime;
yunxingtime=ef[i].yunxingtime;
j=1;
while（（j{
if（ef[j].yunxingtime{
yunxingtime=ef[j].yunxingtime;
i=j;
}
j++;
}//查找第一个被调度的进程
//对第一个被调度的进程求相应的参数
zx=i;
ef[zx].kaishitime=ef[zx].daodatime;
ef[zx].jieshutime=ef[zx].kaishitime+ef[zx].yunxingtime;
ef[zx].run_flag=1;
temp_time=ef[zx].jieshutime;
ef[zx].order=1;
tc=1;
while（tc{
for（j=0;j{
if（（ef[j].daodatime<=temp_time）&&（!
ef[j].run_flag））
{
yunxingtime=ef[j].yunxingtime;zx=j;break;
}
}
for（j=0;j{
if（（ef[j].daodatime<=temp_time）&&（!
ef[j].run_flag））
if（ef[j].yunxingtime{
yunxingtime=ef[j].yunxingtime;
zx=j;
}
}
//查找下一个被调度的进程
//对找到的下一个被调度的进程求相应的参数
ef[zx].kaishitime=temp_time;
ef[zx].jieshutime=ef[zx].kaishitime+ef[zx].yunxingtime;
ef[zx].run_flag=1;
temp_time=ef[zx].yunxingtime;
tc++;
ef[zx].order=tc;
}return0;
}
响应比高优先
inthrrf（）//响应比高优先
{
intj,zx,tc;
floattemp_time,respond_rate,max_respond_rate;
//第一个进程被调度
ef[0].kaishitime=ef[0].daodatime;
ef[0].jieshutime=ef[0].kaishitime+ef[0].yunxingtime;
temp_time=ef[0].jieshutime;
ef[0].run_flag=1;
ef[0].order=1;
tc=1;
//调度其他进程
while（tc{
max_respond_rate=0;
for（j=1;j{
if（（ef[j].daodatime<=temp_time）&&（!
ef[j].run_flag））
{
respond_rate=（temp_time-ef[j].daodatime）/ef[j].yunxingtime;
if（respond_rate>max_respond_rate）
{
max_respond_rate=respond_rate;
zx=j;
}
}
}
//找响应比高的进程
ef[zx].kaishitime=temp_time;
ef[zx].jieshutime=ef[zx].kaishitime+ef[zx].yunxingtime;
temp_time=ef[zx].jieshutime;
ef[zx].run_flag=1;
tc+=1;
ef[zx].order=tc;
}
return0;
}
时间片轮
structef*input（）
{
intN,i;
//定义队首、队尾
structef*head,*rear;
//p是队尾指针，q是队首指针，t是执行时间
structef*p,*q,*t;
//初始化队首和队尾为空
head=rear=NULL;
cout<<"请输入进程数目：
"<cin>>N;
for（i=0;i{
//初始化一个空间给进程
p=（structef*）malloc（sizeof（structef））;
cout<<"请输入第"<cin>>p->name;
cout<<"请输入第"<\n"<cin>>p->number;
cout<<"请输入第"<\n"<cin>>p->daodatime;
cout<<"请输入第"<\n"<cin>>p->fuwutime;
p->shengyutime=p->fuwutime;
p->next=NULL;
//当输入结束时，把p的数据放到队首，以便下一步执行
if（rear==NULL）
{
head=p;
p->next=NULL;
rear=p;
}
//否则执行时间为空，队首变成q
else
{
t=NULL;
q=head;
//当q和q的到达时间小于p的到达时间时，把执行时间给q
while（q&&q->daodatimedaodatime）
{
t=q;
q=q->next;
}
//当q是队首时，则下一个队首变成p,以便每个进程都能够得到时间片
if（q==head）
{
p->next=head;
head=p;
}
//当执行时间片到达队尾时（执行完成），返回给队首p
elseif（t==rear）
{
rear->next=p;
p->next=NULL;
rear=p;
}
//否则给队首p占用执行时间，p执行完后到q
else
{
t->next=p;
p->next=q;
}
}
}
//返回队首
returnhead;
}
voidrun（structef*head）
{
structef*p,*t,*r;
intnum;
//运行过程
vectorvec_out;
cout<<"请输入时间片：
"<cin>>num;
//当队首不为空时，把p给队首
while（head!
=NULL）
{
r=p=head;
//把执行时间给队首
while（p!
=NULL）
{
t=head;
//p的剩余时间=剩余时间-时间片
p->shengyutime=p->shengyutime-num;
p->jieshutime=p->kaishitime+p->fuwutime;
strings=p->name;
vec_out.push_back（s）;
//当p运行完，即剩余时间小于0时，仍然把它当做0处理
if（p->shengyutime<0）
p->shengyutime=0;
cout<<"进程编号到达时间服务时间剩余时间完成时间\n"<//时间不为空时，输出当前进程的信息，并把时间片交给下一个进程
while（t!
=NULL）
{
cout<<""<name<<""<number<<""<daodatime<<""<fuwutime<<""<shengyutime<<""<jieshutime<t=t->next;
}
//当队首的剩余时间为0时，先把队首改成p的下一个，然后释放内存，删除队首节点
if（p->shengyutime==0）
{
if（p==head）
{
head=p->next;
free（p）;
p=head;
}
//否则返回执行，把队尾的下一个指针变成p的下一个指针，队尾的位置移动到队首
else
{
r->next=p->next;
p=r->next;
r=p;
}
}
//否则把队首的位置给队尾，把队首的状态显示为“就绪”状态
else
{
r=p;
p=p->next;
}
}
}
cout<<"执行顺序：
\n"<cout<for（inti=1;i{
cout<}
}
voidyunxing（）
{
//定义时间片的队首结构体
structef*head;
//队首执行的时间
head=input（）;
run（head）;
}
6、流程图
7、程序源代码
#include"stdafx.h"
#include
#include
usingnamespacestd;
#defineMAX10
intc;//实际进程个数
intfcfs（）;//先来先服务
intsjf（）;//短作业优先
inthrrf（）;//响应比高优先
intyxj（）;//优先级调度
intin（）;//进程参数输入
intout（）;//调度结果输出
structef
{
charname[10];//进程名称
intnumber;//进程编号
floatdaodatime;//到达时间
floatkaishitime;//开始运行时间
floatyunxingtime;//运行时间
floatjieshutime;//运行结束时间
intshengyutime;//剩余时间
intfuwutime;//服务时间
intorder;//运行次序
intrun_flag;//调度标志
intpriority;//优先级
structef*next;
}ef[MAX];
intfcfs（）//先来先服务
{
floattp=0;
inti;
intzx;
tp=ef[0].daodatime;
for（i=0;i{
ef[i].kaishitime=tp;
ef[i].jieshutime=ef[i].kaishitime+ef[i].yunxingtime;
ef[i].run_flag=1;
tp=ef[i].jieshutime;
zx=i;
ef[zx].order=i+1;
}
return0;
}
intyxj（）//优先级调度
{
floattemp_time=0;
inti=0,j;
intzx,tc;
intmax_priority;
max_priority=ef[i].priority;
j=1;
while（（j{
if（ef[j].priority>ef[i].priority）
{
max_priority=ef[j].priority;
i=j;
}
j++;
}//查找第一个被调度的进程
//对第一个被调度的进程求相应的参数
zx=i;
ef[zx].kaishitime=ef[zx].kaishitime;
ef[zx].jieshutime=ef[zx].kaishitime+ef[zx].yunxingtime;
ef[zx].run_flag=1;
temp_time=ef[zx].jieshutime;
ef[zx].order=1;
tc=1;
while（tc{
max_priority=0;
for（j=0;j{
if（（ef[j].daodatime<=temp_time）&&（!
ef[j].run_flag））
if（ef[j].priority>max_priority）
{
max_priority=ef[j].priority;
zx=j;
}
}
//查找下一个被调度的进程//
//对找到的下一个被调度的进程求相应的参数
ef[zx].kaishitime=temp_time;
ef[zx].jieshutime=ef[zx].kaishitime+ef[zx].yunxingtime;
ef[zx].run_flag=1;
temp_time=ef[zx].jieshutime;
tc++;
ef[zx].order=tc;
}return0;
}
intsjf（）//短作业优先
{
floattemp_time=0;
inti=0,j;
intzx,tc;
floatyunxingtime;
yunxingtime=ef[i].yunxingtime;
j=1;
while（（j{
if（ef[j].yunxingtime{
yunxingtime=ef[j].yunxingtime;
i=j;
}
j++;
}//查找第一个被调度的进程
//对第一个被调度的进程求相应的参数
zx=i;
ef[zx].kaishitime=ef[zx].daodatime;
ef[zx].jieshutime=ef[zx].kaishitime+ef[zx].yunxingtime;
ef[zx].run_flag=1;
temp_time=ef[zx].jieshutime;
ef[zx].order=1;
tc=1;
while（tc{
for（j=0;j{
if（（ef[j].daodatime<=temp_time）&&（!
ef[j].run_flag））
{
yunxingtime=ef[j].yunxingtime;zx=j;break;
}
}
for（j=0;j{
if（（ef[j].daodatime<=temp_time）&&（!
ef[j].run_flag））
if（ef[j].yunxingtime{
yunxingtime=ef[j].yunxingtime;
zx=j;
}
}
//查找下一个被调度的进程
//对找到的下一个被调度的进程求相应的参数
ef[zx].kaishitime=temp_time;
ef[zx].jieshutime=ef[zx].kaishitime+ef[zx].yunxingtime;
ef[zx].run_flag=1;
temp_time=ef[zx].yunxingtime;
tc++;
ef[zx].order=tc;
}return0;
}
inthrrf（）//响应比高优先
{
intj,zx,tc;
floattemp_time,respond_rate,max_respond_rate;
//第一个进程被调度
ef[0].kaishitime=ef[0].daodatime;
ef[0].jieshutime=ef[0].kaishitime+ef[0].yunxingtime;
temp_time=ef[0].jieshutime;
ef[0].run_flag=1;
ef[0].order=1;
tc=1;
//调度其他进程
while（tc{
max_respond_rate=0;
for（j=1;j{
if（（ef[j].daodatime<=temp_time）&&（!
ef[j].run_flag））
{
respond_rate=（temp_time-ef[j].daodatime）/ef[j].yunxingtime;
if（respond_rate>max_respond_rate）
{
max_respond_rate=respond_rate;
zx=j;
}
}
}
//找响应比高的进程
ef[zx].kaishitime=temp_time;
升级会员 