处理机调度实验报告1Word文档下载推荐.docx
- 文档编号:20625999
- 上传时间:2023-01-24
- 格式:DOCX
- 页数:26
- 大小:350.10KB
处理机调度实验报告1Word文档下载推荐.docx
《处理机调度实验报告1Word文档下载推荐.docx》由会员分享,可在线阅读,更多相关《处理机调度实验报告1Word文档下载推荐.docx(26页珍藏版)》请在冰豆网上搜索。
二、方法、步骤:
(说明程序相关的算法原理或知识内容,程序设计的思路和方法,可以用流程图表述,程序主要数据结构的设计、主要函数之间的调用关系等)
先来先服务算法:
按到达时间先后,选择最先来的作业最先执行
实现思想:
对作业的到达时间按大小进行排序,然后按顺序执行
短作业优先算法:
在后备队列中,选择服务时间最短的作业最先执行
对作业按到达时间排序,接着对到达的作业,即后备队列中的作业按服务时间排序,取服务时间最小的作业最先执行
高响应比算法:
对作业的优先权(响应时间/要求服务时间)进行计算,对优先权最高的最先执行
实现实现:
计算后备队列中作业的优先权,并排序,优先权最高的最先执行
时间片轮转算法:
将所有就绪进程按先来先服务排成队列,把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;
}
}
if(pcbdata3[t_re
- 配套讲稿:
如PPT文件的首页显示word图标,表示该PPT已包含配套word讲稿。双击word图标可打开word文档。
- 特殊限制:
部分文档作品中含有的国旗、国徽等图片,仅作为作品整体效果示例展示,禁止商用。设计者仅对作品中独创性部分享有著作权。
- 关 键 词:
- 处理机 调度 实验 报告