处理机调度实验报告Word文档下载推荐.docx
- 文档编号:22557884
- 上传时间:2023-02-04
- 格式:DOCX
- 页数:26
- 大小:350.47KB
处理机调度实验报告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;
- 配套讲稿:
如PPT文件的首页显示word图标,表示该PPT已包含配套word讲稿。双击word图标可打开word文档。
- 特殊限制:
部分文档作品中含有的国旗、国徽等图片,仅作为作品整体效果示例展示,禁止商用。设计者仅对作品中独创性部分享有著作权。
- 关 键 词:
- 处理机 调度 实验 报告
![提示](https://static.bdocx.com/images/bang_tan.gif)