处理机调度实验报告.docx
《处理机调度实验报告.docx》由会员分享，可在线阅读，更多相关《处理机调度实验报告.docx（26页珍藏版）》请在冰豆网上搜索。
处理机调度实验报告
深圳大学实验报告
课程名称:
操作系统
试验项目名称:
处理机调度
学院:
计算机与软件学院
专业:
软件工程
指导老师:
汇报人:
学号:
班级:
试验时间:
5月7日
试验汇报提交时间:
5月22日
教务处制
一、试验目与要求:
试验目:
模拟在单处理器多进程操作系统CPU调度。
帮助学生掌握多个CPU调度算法知识原理和运作机制。
本试验为模拟试验,不要求实现真正进程创建与进程调度。
关键实现多种调度算法。
试验要求:
1、阅读了解例程,掌握例程运作步骤。
运行例程,了解先来先服务算法调度原理和运行结果。
2、参考先来先服务算法,尝试实现其她四种调度算法:
短作业优先、高响应比、时间片轮转、多级反馈队列。
要求最少实现一个算法。
a）除了多级反馈队列,其她算法采取非抢占调度
b）短作业优先算法使用例题一数据或程序内置数据,要求运行结果给出调度次序、完成时间、周转时间、带权周转时间
c）高响应比算法使用例题二数据,要求运行结果给出调度次序、完成时间、周转时间、带权周转时间
d）时间片轮转算法能够使用程序内置数据,要求运行结果给出每个时间片是被哪个进程使用,每个进程完成时,要修改状态并输出提醒。
e）多级反馈队列算法使用例题三数据,要求运行结果给出正确进程调度次序和过程描述。
二、方法、步骤:
（说明程序相关算法原理或知识内容,程序设计思绪和方法,能够用步骤图表述,程序关键数据结构设计、关键函数之间调用关系等）
先来先服务算法:
按抵达时间前后,选择最先来作业最先实施
实现思想:
对作业抵达时间按大小进行排序,然后按次序实施
短作业优先算法:
在后备队列中,选择服务时间最短作业最先实施
实现思想:
对作业按抵达时间排序,接着对抵达作业,即后备队列中作业按服务时间排序,取服务时间最小作业最先实施
高响应比算法:
对作业优先权（响应时间/要求服务时间）进行计算,对优先权最高最先实施
实现实现:
计算后备队列中作业优先权,并排序,优先权最高最先实施
时间片轮转算法:
将全部就绪进程按先来先服务排成队列,把CPU分配给队首进程,进程只实施一个时间片,时间片用完后,将已使用时间片进程送往就绪队列末尾,分配处理机给就绪队列中下一进程
实现思想:
将作业按抵达时间排序,在后备队列中选择第一个作业,把CPU分配给它,实施一个时间片,时间片用完后,将作业送往后备队列末尾,把CPU分配给下一个作业,直到全部作业完成
多级反馈队列调度算法:
设置多个就绪队列,各个队列优先级逐一降低,各个队列时间片逐一增加,优先级越高队列实施时间片就越短,通常时间片按倍增规则,每个新进程首优异入第一个队列,遵照FCFS,在目前队列时间片内,进程若能完成,退出,进程若未完成,降级到第二个队列,一样遵照FCFS依次类推,若在第二个队列时间片内仍未完成,再降级到第三个队列……
实现思想:
设置多个就绪队列,各个队列优先级逐一降低,各个队列时间片逐一增加,优先级越高队列实施时间片就越短,通常时间片按倍增规则,比如,第二队列时间片要比第一个队列时间片长一倍,……,第i+1个队列时间片要比第i个队列时间片长一倍,整合了时间片、FCFS、优先级三种机制。
三．试验过程及内容:
（对程序代码进行说明和分析,越具体越好,代码排版要整齐,可读性要高）
#include"stdio.h"
#include
//#include
#include
#include
//#defineNULL0
#definegetpch（type）（type*）malloc（sizeof（type））
typedefstructpcbPCB;
structpcb{//定义进程控制块PCB
intid;//标示符
charname[10];//名称
inttime_start;//抵达时间
inttime_need;//服务时间
inttime_left;//剩下运行时间
inttime_used;//已使用时间
charstate;//进程状态
};
//****************系统函数
void_sleep（intn）
{
clock_tgoal;
goal=（clock_t）n*CLOCKS_PER_SEC+clock（）;
while（goal>clock（））;
}
char_keygo（）
{
charc;
printf（"按任意键继续……\n"）;
c=getchar（）;
returnc;
}
//******************用户函数
inttime_unit=2;
intnum=5;//实际进程数量
PCBpcbdata[10]={
//例程内置数据
{1000,"A",0,4,4,0,'R'},
{1001,"B",1,3,3,0,'R'},
{1002,"C",2,5,5,0,'R'},
{1003,"D",3,2,2,0,'R'},
{1004,"E",4,4,4,0,'R'},
};
intnum1=4;
PCBpcbdata1[10]={
//例题一数据
{1000,"Job1",1,9,9,0,'R'},
{1001,"Job2",1,16,16,0,'R'},
{1002,"Job3",1,3,3,0,'R'},
{1003,"Job4",1,11,11,0,'R'},
};
intnum2=4;
PCBpcbdata2[10]={
//例题二数据
{1000,"P1",10,8,8,0,'R'},
{1001,"P2",12,12,12,0,'R'},
{1002,"P3",14,4,4,0,'R'},
{1003,"P4",16,6,6,0,'R'},
};
intnum3=4;
PCBpcbdata3[10]={
//例程三数据
{1000,"A",0,7,7,0,'R'},
{1001,"B",5,4,4,0,'R'},
{1002,"C",7,13,13,0,'R'},
{1003,"D",12,9,9,0,'R'},
};
intready[10];//就绪队列,存放进程在pcbdata中位置
intorder[10];//统计排序使用哪个数值作为排序对象
voidintput（）
{
inti;
printf（"进程总数为:
"）;
scanf（"%d",&num）;
for（i=0;i{
pcbdata[i].id=1000+i;
printf（"输入第%d个进程名:
",i+1）;
scanf（"%s",&pcbdata[i].name）;
printf（"输入第%d个进程抵达时间:
",i+1）;
scanf（"%d",&pcbdata[i].time_start）;
printf（"输入第%d个进程服务时间:
",i+1）;
scanf（"%d",&pcbdata[i].time_need）;
pcbdata[i].time_left=pcbdata[i].time_need;
printf（"\n"）;
pcbdata[i].time_used=0;
pcbdata[i].state='R';
}
}
//**************调度函数
voidFCFS（）
{
inti,j,temp;
doublek;
for（i=0;i{order[i]=pcbdata[i].time_start;
ready[i]=i;
}
for（i=0;ifor（j=i+1;j{
if（order[i]>order[j]）
{
temp=order[i];
order[i]=order[j];
order[j]=temp;
temp=ready[i];
ready[i]=ready[j];
ready[j]=temp;
}
}
printf（"---先来先服务算法调度:
非抢占,无时间片---\n"）;
temp=pcbdata[ready[0]].time_start;
for（i=0;i{
printf（"第%d个进程--%s,",i+1,pcbdata[ready[i]].name）;
printf（"本进程正在运行…………"）;
_sleep
（1）;
printf（"运行完成\n"）;
temp+=pcbdata[ready[i]].time_need;
j=temp-pcbdata[ready[i]].time_start;
k=（float）j/pcbdata[ready[i]].time_need;
printf（"完成时间--%d,周转时间--%d,带权周转时间--%.1f\n",temp,j,k）;
}
printf（"------全部进程调度完成-------------\n"）;
}
voidSJF（）
{
inti,j,temp,l,temp_num;
doublek;
inttime=0;
for（i=0;i{
order[i]=pcbdata1[i].time_start;
ready[i]=i;
}
for（i=0;ifor（j=i+1;j{
if（order[i]>order[j]）
{
temp=order[i];
order[i]=order[j];
order[j]=temp;
temp=ready[i];
ready[i]=ready[j];
ready[j]=temp;
}
}
printf（"---短作业算法调度:
非抢占,无时间片---\n"）;
intt_ready[10];//就绪队列,存放进程在pcbdata中位置
intt_order[10];//统计排序使用哪个数值作为排序对象
for（i=0;i{
t_order[i]=pcbdata1[ready[i]].time_need;//服务时间作为排序对象
t_ready[i]=ready[i];
}
time=order[0];
for（l=0;l//判定抵达进程数,用temp_num存放
for（i=0;itemp_num=i+1;
//把抵达进程按服务时间大小进行排序
for（i=0;ifor（j=i+1;j{
if（t_order[i]>t_order[j]&&t_order[j]!
=0||t_order[i]==0）
{
temp=t_order[i];
t_order[i]=t_order[j];
t_order[j]=temp;
temp=t_ready[i];
t_ready[i]=t_ready[j];
t_ready[j]=temp;
}
}
printf（"第%d个进程--%s,",l+1,pcbdata1[t_ready[0]].name）;
printf（"正在运行…………"）;
_sleep
（1）;
printf（"运行完成\n"）;
time+=pcbdata1[t_ready[0]].time_need;
j=time-pcbdata1[t_ready[0]].time_start;
k=（float）j/pcbdata1[t_ready[0]].time_need;
t_order[0]=0;
printf（"完成时间--%d,周转时间--%d,带权周转时间--%.1f\n",time,j,k）;
}
printf（"------全部进程调度完成-------------\n"）;
}
voidHRF（）
{
inti,j,temp,l,temp_num;
doublek;
inttime=0;
for（i=0;i{
order[i]=pcbdata2[i].time_start;
ready[i]=i;
}
for（i=0;ifor（j=i+1;j{
if（order[i]>order[j]）
{
temp=order[i];
order[i]=order[j];
order[j]=temp;
temp=ready[i];
ready[i]=ready[j];
ready[j]=temp;
}
}
printf（"---高响应比算法调度:
非抢占,无时间片---\n"）;
intt_ready[10];
intt_order[10];
for（i=0;i{
t_order[i]=1;
t_ready[i]=ready[i];
}
time=order[0];
for（l=0;l//判定抵达进程数
for（i=0;itemp_num=i+1;
for（i=0;i{
if（t_order[i]）
t_order[i]=（time-pcbdata2[t_ready[i]].time_start+pcbdata2[t_ready[i]].time_need）/pcbdata2[t_ready[i]].time_need;
}
for（i=0;ifor（j=i+1;j{
if（t_order[i]{
temp=t_order[i];
t_order[i]=t_order[j];
t_order[j]=temp;
temp=t_ready[i];
t_ready[i]=t_ready[j];
t_ready[j]=temp;
}
}
printf（"第%d个进程--%s,",l+1,pcbdata2[t_ready[0]].name）;
printf（"正在运行…………"）;
_sleep
（1）;
printf（"运行完成\n"）;
time+=pcbdata2[t_ready[0]].time_need;
j=time-pcbdata2[t_ready[0]].time_start;
k=（float）j/pcbdata2[t_ready[0]].time_need;
t_order[0]=0;
printf（"完成时间--%d,周转时间--%d,带权周转时间--%.1f\n",time,j,k）;
}
printf（"------全部进程调度完成-------------\n"）;
}
voidTimeslice（）
{
inti,j,temp,l,temp_num;
doublek;
inttime=0;
intdone=0;
for（i=0;i{
order[i]=pcbdata[i].time_start;
ready[i]=i;
}
for（i=0;ifor（j=i+1;j{
if（order[i]>order[j]）
{
temp=order[i];
order[i]=order[j];
order[j]=temp;
temp=ready[i];
ready[i]=ready[j];
ready[j]=temp;
}
}
printf（"---时间片轮转算法调度:
非抢占,时间片大小为2---\n"）;
intt_ready[10];
for（i=0;i{
t_ready[i]=ready[i];
}
time=order[0];
for（l=0;done//判定抵达进程数
for（i=0;itemp_num=i+1;
if（time!
=order[0]）{
//将已使用时间片进程,即第一个移到队列末尾
for（i=1;itemp=t_ready[i];
t_ready[i]=t_ready[i-1];
t_ready[i-1]=temp;
}
}
if（pcbdata[t_ready[0]].state!
='F'）{
printf（"第%d个时间片被进程%s使用,",l+1,pcbdata[t_ready[0]].name）;
printf（"正在运行……\n"）;
_sleep
（1）;
printf（"时间片使用完,所需时间%d,",pcbdata[t_ready[0]].time_left）;
time+=2;
pcbdata[t_ready[0]].time_used+=2;
pcbdata[t_ready[0]].time_left-=2;
printf（"使用时间%d,还需时间%d,",2,pcbdata[t_ready[0]].time_left）;
//判定进程是否结束
if（pcbdata[t_ready[0]].time_left<=0）{
printf（"进程%s结束\n",pcbdata[t_ready[0]].name）;
done++;
pcbdata[t_ready[0]].state='F';
}
else
printf（"进程%s就绪\n",pcbdata[t_ready[0]].name）;
}
}
printf（"------全部进程调度完成-------------\n"）;
}
voidMRLA（）
{
inti,j,temp,l,temp_num,temp_num2;
doublek;
inttime=0;//系统时间
intdone=0;//已完成进程
intt_ready[10];
intqueue[10];//进程对应队列
intqtime[10];//进程对应时间片
for（i=0;i{
order[i]=pcbdata3[i].time_start;
ready[i]=i;
queue[i]=1;
qtime[i]=0;
}
for（i=0;ifor（j=i+1;j{
if（order[i]>order[j]）
{
temp=order[i];
order[i]=order[j];
order[j]=temp;
temp=ready[i];
ready[i]=ready[j];
ready[j]=temp;
}
}
printf（"---多级反馈算法调度:
抢占式,时间片大小为2---\n"）;
for（i=0;i{
t_ready[i]=ready[i];
}
time=order[0];
for（l=0;done//判定抵达进程数
for（i=0;itemp_num=i+1;
if（time!
=order[0]）{
for（i=0;ifor（j=1;jif（pcbdata3[t_ready[j-1]].state=='F'||（queue[j-1]>queue[j]&&pcbdata3[t_ready[j]].state!
='F'））{
temp=queue[j-1];
queue[j-1]=queue[j];
queue[j]=temp;
temp=t_ready[j-1];
t_ready[j-1]=t_ready[j];
t_ready[j]=temp;
temp=qtime[j-1];
qtime[j-1]=qtime[j];
qtime[j]=temp;
升级会员 