操作系统实验报告2剖析.docx
《操作系统实验报告2剖析.docx》由会员分享，可在线阅读，更多相关《操作系统实验报告2剖析.docx（13页珍藏版）》请在冰豆网上搜索。
操作系统实验报告2剖析
深圳大学实验报告
课程名称：
操作系统
实验项目名称：
进程调度
学院：
软件学院
专业：
软件工程
指导教师：
梁正平
报告人：
文成学号：
2011150259班级：
2
实验时间：
2013.04.27
实验报告提交时间：
2013.04.30
教务处制
一.实验目的
模拟在单处理器多进程情况下的处理器调度，帮助学生加深了解处理器调度的工作。
该实验为模拟实验，不要求创建真正的进程调度。
主要目的是编写程序模拟调度即可。
1、编写并调试一个模拟的进程调度程序，采用“最高优先数优先”调度算法对进程进行调度。
“最高优先数优先调度算法的基本思想是把CPU分配给就绪队列中优先数最高的进程。
尝试静态优先数与动态优先数两种方法：
a）静态优先数是指优先数在整个进程运行期间不再改变。
优先数可以在数据输入时指定，也可以根据到达顺序、运行时间确定。
b）动态优先数是指进程的优先数在创建进程时可以给定一个初始值，并且可以按一定原则修改优先数。
例如进程获得一次CPU后就将其优先数减少1。
或者进程等待的时间超过某一时限时增加其优先数的值。
2、编写并调试一个模拟的进程调度程序，模拟实现多级反馈队列调度算法。
3、编写并调试一个模拟的进程调度程序，模拟实现最低松弛度优先算法。
二.实验要求
程序与报告要求：
a）对上述要求1、2、3，至少要完成一项，鼓励尝试多种算法。
b）输出结果要尽量详细清晰，能够反映调度后队列变化，PCB内部变化。
c）可以选择在Windows或Linux环境下编写、运行程序
d）鼓励使用不同的开发工具在不同平台环境上进行开发比较。
在实验报告中，一方面可以对实验结果进行分析，一方面可以对各种算法进行比较，分析它们的优劣，说明各种算法适用于哪些情况下的调度。
三.方法、步骤
实验方法：
统一利用例程中程序的功能和实现过程，进行修改并调式。
实验步骤：
1．按照实验指导的例程，在WINDOWS下运行VirsualC++6.0。
2．按照实验要求编写程序，内容在下面会有提及。
3．运行并调试编写好的程序，测试其运作过程及结果。
得出实验结论。
四.实验过程及内容
1、设计一个有N个进程共行的进程调度程序。
2、每个进程有一个进程控制块PCB来表示，进程控制块的格式为：
进程名
优先数
到达时间
需要运行时间
已占用CPU时间
进程状态
a）进程优先数、需要运行时间、到达时间可以事先人为地指定，也可以随机产生，注意初始化上述数值时要尽量使进程并发执行，而不是按到达时间顺序调度。
b）进程的运行时间以时间片为单位进行计算。
c）进程状态分为就绪、运行、完成三种状态之，分别用W、R、F表示。
3、进程调度规则如下：
a）就绪进程获得CPU后都只能运行一个时间片。
用已占用CPU时间加1来表示。
b）如果运行一个时间片后，进程已占用CPU时间达到所需要运行时间，则进程完成，撤销该进程。
c）如果运行一个时间片后，进程已占用CPU时间还未达到所需要运行时间，即进程需要继续运行，将它插入就绪队列，队列重新排序，等待CPU。
d）重复以上过程，直到所要进程都完成为止。
4、算法流程图如下：
五.源程序清单
选择实现先来先服务和短作业优先算法
#include
#include
#defineNumber5
voidmain（）
{
intn;
intdaoda[Number],fuwu[Number],i;
cout<<"请依次输入各个进程的到达时间并以空格间隔:
";
for（i=0;i{
cin>>daoda[i];
}
cout<<"请依次输入各个进程的服务时间，并以空格间隔:
";
for（i=0;i{
cin>>fuwu[i];
}
cout<<"请输入n=1选择FCFS或者n=2选择SJF或者n=3同时调用FCFS和SJF,n=";
cin>>n;
while（n<1||n>3）{
cout<<"输入的n有误，请重新输入n，n=";
cin>>n;
}
structstatedd//声明结构
{
booldoneF,doneS;
intdaoda,fuwu;
floatwancheng,zhouzhuan,daiquan,wan,zhou,dai;
};
stateddprocess[Number];
inttimeflyF=0,timeflyS=0;//定义两个类似于秒表的变量
intj,k,l,nextproF,nextproS;
//获取数据
for（i=0;i{
process[i].doneF=false;
process[i].doneS=false;
process[i].wancheng=0;
process[i].zhouzhuan=0;
process[i].daiquan=0;
process[i].wan=0;
process[i].zhou=0;
process[i].dai=0;
process[i].daoda=daoda[i];
process[i].fuwu=fuwu[i];
}
//获取最先到达的进程下标first
intfirst=0;
l=first;
for（i=1;i{
if（daoda[first]>daoda[i]）
first=i;
}
process[first].doneF=true;
process[first].doneS=true;
process[first].wancheng=process[first].fuwu+process[first].daoda;
process[first].wan=process[first].fuwu+process[first].daoda;
timeflyF+=process[first].daoda+process[first].fuwu;
timeflyS+=process[first].daoda+process[first].fuwu;
//接下去到达的进程
//*************************************************************
//fcfs********************************************************
for（j=1;j{
nextproF=Number+1;
for（k=0;k{
if（!
process[k].doneF）
{
if（process[k].daoda<=timeflyF）//到达
{
if（nextproF==Number+1）
nextproF=k;
else
{
if（process[nextproF].daoda>process[k].daoda）
nextproF=k;//获取到达时刻最先的进程
}//else
}//if2
}//if1
}//for
//处理
process[nextproF].wancheng=process[nextproF].fuwu+timeflyF;
timeflyF+=process[nextproF].fuwu;
process[nextproF].doneF=true;
}//circle2
//SJF**********************************************
for（j=1;j{
nextproS=Number+1;
for（k=0;k{
if（!
process[k].doneS）
{
if（process[k].daoda<=timeflyS）//到达
{
if（nextproS==Number+1）
nextproS=k;
else
{
if（process[nextproS].fuwu>process[k].fuwu）
nextproS=k;//获取服务时间最小的进程
}//else
}//if2
}//if1
}//for
//处理
process[nextproS].wan=process[nextproS].fuwu+timeflyS;
timeflyS+=process[nextproS].fuwu;
process[nextproS].doneS=true;
}//circle2
//****************************************************************
floatFz=0,Fdq=0,Sz=0,Sdq=0;//
for（i=0;i{//----------------------------------------------------
process[i].zhouzhuan=process[i].wancheng-process[i].daoda;
Fz+=process[i].zhouzhuan;
process[i].daiquan=process[i].zhouzhuan/process[i].fuwu;
Fdq+=process[i].daiquan;
//----------------------------------------------------
process[i].zhou=process[i].wan-process[i].daoda;
Sz+=process[i].zhou;
process[i].dai=process[i].zhou/process[i].fuwu;
Sdq+=process[i].dai;
}
//=========================输出==================================
//-------------------------------------------------------------------
if（n==1||n==3）{
cout<<"\t"<cout<<"FCFS:
"<for（i=0;i{
if（i<1）
{
cout<<"时刻"<进程"<}
else
{
cout<<"时刻"<进程"<}
}
cout<cout<cout<cout<for（i=0;i{
cout<cout<:
fixed）<（2）<cout<:
fixed）<（2）<cout<:
fixed）<（2）<}
cout<<"平均周转时间为：
"<:
fixed）<（2）<cout<<"平均带权周转时间为：
"<:
fixed）<（2）<}
//-------------------------------------------------------------------
if（n==2||n==3）{
cout<<"\t"<cout<<"SJF:
"<for（i=0;i{
if（i<1）
{
cout<<"时刻"<进程"<}
else
{
cout<<"时刻"<进程"<}
}
cout<cout<cout<cout<for（i=0;i{
cout<cout<:
fixed）<（2）<cout<:
fixed）<（2）<cout<:
fixed）<（2）<}
cout<<"平均周转时间为：
"<:
fixed）<（2）<cout<<"平均带权周转时间为：
"<:
fixed）<（2）<cout<<"\t"<}
}
六.测试数据与结果分析
说明：
五个进程，到达时间分别为0,1,3,4,6
服务时间分别为5,7,3,8,2
设置选择量n，
当n=1时，选择FCFS
当n=2时，选择SJF
n不为1或2时提示错误，重新输入n；
来先服务算法顾名思义先到的先参与调度，本利中按照1，2，3，4，5的顺序。
因为只有非抢占方式，所以先到的进程必须执行完来才能执行下一个进程，下一个进程的开始时间也就取决于到达时间和上一个进程的结束时间中较晚的一个。
而短作业优先则是在执行完当前进程时，选择短的做。
1-FCFS算法
2-SJF算法
七.实验结论
FCFS算法容易实现。
但效率不高，只顾及作业等候时间，没考虑作业要求服务时间的长短。
因此优待了长作业而不利于短作业。
而SJF算法以进入系统的作业所要求的CPU时间为标准，总选取估计计算时间最短的作业投入运行，主要弱点是忽视了作业等待时间，会出现饥饿现象。
总之，两种算法各有优劣。
指导教师批阅意见：
成绩评定：
指导教师签字：
年月日
备注：
注：
1、报告内的项目或内容设置，可根据实际情况加以调整和补充。
2、教师批改学生实验报告时间应在学生提交实验报告时间后10日内。
升级会员 