处理机调度实验报告Word文档下载推荐.docx
《处理机调度实验报告Word文档下载推荐.docx》由会员分享，可在线阅读，更多相关《处理机调度实验报告Word文档下载推荐.docx（26页珍藏版）》请在冰豆网上搜索。
d）时间片轮转算法能够使用程序内置数据,要求运行结果给出每个时间片是被哪个进程使用,每个进程完成时,要修改状态并输出提醒。
e）多级反馈队列算法使用例题三数据,要求运行结果给出正确进程调度次序和过程描述。
二、方法、步骤:
（说明程序相关算法原理或知识内容,程序设计思绪和方法,能够用步骤图表述,程序关键数据结构设计、关键函数之间调用关系等）
先来先服务算法:
按抵达时间前后,选择最先来作业最先实施
实现思想:
对作业抵达时间按大小进行排序,然后按次序实施
短作业优先算法:
在后备队列中,选择服务时间最短作业最先实施
对作业按抵达时间排序,接着对抵达作业,即后备队列中作业按服务时间排序,取服务时间最小作业最先实施
高响应比算法:
对作业优先权（响应时间/要求服务时间）进行计算,对优先权最高最先实施
实现实现:
计算后备队列中作业优先权,并排序,优先权最高最先实施
时间片轮转算法:
将全部就绪进程按先来先服务排成队列,把CPU分配给队首进程,进程只实施一个时间片,时间片用完后,将已使用时间片进程送往就绪队列末尾,分配处理机给就绪队列中下一进程
将作业按抵达时间排序,在后备队列中选择第一个作业,把CPU分配给它,实施一个时间片,时间片用完后,将作业送往后备队列末尾,把CPU分配给下一个作业,直到全部作业完成
多级反馈队列调度算法:
设置多个就绪队列,各个队列优先级逐一降低,各个队列时间片逐一增加,优先级越高队列实施时间片就越短,通常时间片按倍增规则,每个新进程首优异入第一个队列,遵照FCFS,在目前队列时间片内,进程若能完成,退出,进程若未完成,降级到第二个队列,一样遵照FCFS依次类推,若在第二个队列时间片内仍未完成,再降级到第三个队列……
设置多个就绪队列,各个队列优先级逐一降低,各个队列时间片逐一增加,优先级越高队列实施时间片就越短,通常时间片按倍增规则,比如,第二队列时间片要比第一个队列时间片长一倍,……,第i+1个队列时间片要比第i个队列时间片长一倍,整合了时间片、FCFS、优先级三种机制。
三．试验过程及内容:
（对程序代码进行说明和分析,越具体越好,代码排版要整齐,可读性要高）
#include"
stdio.h"
#include<
stdlib.h>
//#include<
conio.h>
time.h>
math.h>
//#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,'
{1002,"
C"
2,5,5,0,'
{1003,"
D"
3,2,2,0,'
{1004,"
E"
4,4,4,0,'
intnum1=4;
PCBpcbdata1[10]={
//例题一数据
Job1"
1,9,9,0,'
Job2"
1,16,16,0,'
Job3"
Job4"
1,11,11,0,'
intnum2=4;
PCBpcbdata2[10]={
//例题二数据
P1"
10,8,8,0,'
P2"
12,12,12,0,'
P3"
14,4,4,0,'
P4"
16,6,6,0,'
intnum3=4;
PCBpcbdata3[10]={
//例程三数据
0,7,7,0,'
5,4,4,0,'
7,13,13,0,'
12,9,9,0,'
intready[10];
//就绪队列,存放进程在pcbdata中位置
intorder[10];
//统计排序使用哪个数值作为排序对象
voidintput（）
inti;
进程总数为:
"
scanf（"
%d"
&
num）;
for（i=0;
i<
num;
i++）
{
pcbdata[i].id=1000+i;
printf（"
输入第%d个进程名:
i+1）;
scanf（"
%s"
pcbdata[i].name）;
输入第%d个进程抵达时间:
pcbdata[i].time_start）;
输入第%d个进程服务时间:
pcbdata[i].time_need）;
pcbdata[i].time_left=pcbdata[i].time_need;
\n"
pcbdata[i].time_used=0;
pcbdata[i].state='
;
}
//**************调度函数
voidFCFS（）
inti,j,temp;
doublek;
{order[i]=pcbdata[i].time_start;
ready[i]=i;
i++）//按抵达时间排序
for（j=i+1;
j<
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;
}
}
---先来先服务算法调度:
非抢占,无时间片---\n"
temp=pcbdata[ready[0]].time_start;
for（i=0;
printf（"
第%d个进程--%s,"
i+1,pcbdata[ready[i]].name）;
本进程正在运行…………"
_sleep
（1）;
运行完成\n"
temp+=pcbdata[ready[i]].time_need;
j=temp-pcbdata[ready[i]].time_start;
k=（float）j/pcbdata[ready[i]].time_need;
完成时间--%d,周转时间--%d,带权周转时间--%.1f\n"
temp,j,k）;
------全部进程调度完成-------------\n"
voidSJF（）
inti,j,temp,l,temp_num;
inttime=0;
num1;
order[i]=pcbdata1[i].time_start;
ready[i]=i;
---短作业算法调度:
intt_ready[10];
//就绪队列,存放进程在pcbdata中位置
intt_order[10];
t_order[i]=pcbdata1[ready[i]].time_need;
//服务时间作为排序对象
t_ready[i]=ready[i];
time=order[0];
for（l=0;
l<
l++）{
//判定抵达进程数,用temp_num存放
for（i=0;
num&
&
pcbdata1[ready[i]].time_start<
=time;
temp_num=i+1;
//把抵达进程按服务时间大小进行排序
temp_num;
for（j=i+1;
{
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（"
l+1,pcbdata1[t_ready[0]].name）;
正在运行…………"
_sleep
（1）;
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;
time,j,k）;
voidHRF（）
num2;
order[i]=pcbdata2[i].time_start;
---高响应比算法调度:
t_order[i]=1;
//判定抵达进程数
pcbdata2[ready[i]].time_start<
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;
i++）//按优先权排序
if（t_order[i]<
t_order[j]）
}
l+1,pcbdata2[t_ready[0]].name）;
time+=pcbdata2[t_ready[0]].time_need;
j=time-pcbdata2[t_ready[0]].time_start;
k=（float）j/pcbdata2[t_ready[0]].time_need;
voidTimeslice（）
intdone=0;
order[i]=pcbdata[i].time_start;
---时间片轮转算法调度:
非抢占,时间片大小为2---\n"
{
done<
l++）{
//判定抵达进程数
pcbdata[ready[i]].time_start<
if（time!
=order[0]）{
//将已使用时间片进程,即第一个移到队列末尾
for（i=1;
i++）{
temp=t_ready[i];
t_ready[i]=t_ready[i-1];
t_ready[i-1]=temp;
}
if（pcbdata[t_ready[0]].state!
='
F'
）{
第%d个时间片被进程%s使用,"
l+1,pcbdata[t_ready[0]].name）;
正在运行……\n"
时间片使用完,所需时间%d,"
pcbdata[t_ready[0]].time_left）;
time+=2;
pcbdata[t_ready[0]].time_used+=2;
pcbdata[t_ready[0]].time_left-=2;
使用时间%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='
else
进程%s就绪\n"
}
voidMRLA（）
{
inti,j,temp,l,temp_num,temp_num2;
//系统时间
//已完成进程
intt_ready[10];
intqueue[10];
//进程对应队列
intqtime[10];
//进程对应时间片
num3;
order[i]=pcbdata3[i].time_start;
queue[i]=1;
qtime[i]=0;
---多级反馈算法调度:
抢占式,时间片大小为2---\n"
l++）{
num3&
pcbdata3[ready[i]].time_start<
for（i=0;
i++）//按队列优先级排序
for（j=1;
temp_num-i;
j++）{
if（pcbdata3[t_ready[j-1]].state=='
||（queue[j-1]>
queue[j]&
pcbdata3[t_ready[j]].state!
））{
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;
升级会员 