处理机调度实验报告1docx.docx
《处理机调度实验报告1docx.docx》由会员分享，可在线阅读，更多相关《处理机调度实验报告1docx.docx（44页珍藏版）》请在冰豆网上搜索。
处理机调度实验报告1docx
.
深圳大学实验报告
课程名称：
操作系统
实验项目名称：
处理机调度
学院：
计算机与软件学院
专业：
软件工程
指导教师：
报告人：
学号：
班级：
实验时间：
2013年5月7日
实验报告提交时间：
2013年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;i
for（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;i
for（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;i
temp_num=i+1;
//把到达的进程按服务时间大小进行排序
for（i=0;i
for（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;i
for（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;i
temp_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_n
eed;
}
for（i=0;i
for（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;i
for（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;i
temp_num=i+1;
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'）{
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;i
for（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
升级会员 