操作系统实践报告.docx
《操作系统实践报告.docx》由会员分享,可在线阅读,更多相关《操作系统实践报告.docx(23页珍藏版)》请在冰点文库上搜索。
操作系统实践报告
《计算机操作系统》
课外实践报告
一、实验目标:
通过设计一个磁盘调度模拟系统,从而使磁盘调度算法更加形象化,容易使人理解,使磁盘调度的特点更简单明了,能使使用者加深对先来先服务算法、最短寻道时间优先算法、扫描算法以及循环扫描算法等磁盘调度算法的理解。
二、实验要求
系统主界面可以灵活选择某种算法,算法包括:
先来先服务算法(FCFS)、最短寻道时
间优先算法(SSTF)、扫描算法(SCAN)、循环扫描算法(CSCAN)。
三.实践内容简要描述
1、实践环境
windows2000/xp,visualc6.0
2、算法思路
磁盘设备在工作时以恒定的速率旋转。
为了读或写,磁头必须能移动到所要求的磁道上,并等待所要求的扇区开始位置旋转到磁头下,然后或开始读或写数据。
故可把磁盘访问时间分成以下三部分。
(1)寻道时间Ts
这是把磁头移动到指定磁道上所经历的时间。
该时间是启动磁臂的时间s与磁头移动n条磁道所花费的时间之和,即
Ts=m*n+s
其中,m是一常数,与磁盘驱动器的速度有关。
对于一般磁盘,m=0.2;对于高速磁盘,
m<=0.1,磁臂的启动时间+约为2ms。
这样,对于一般的温盘,对于一般的温盘,其寻道时间将随着寻道距离的增加而增大,大体上是5~30ms。
(2)旋转延迟时间Tr这是指定扇区移动到磁头下面所经历的时间。
不同的磁盘类型中,旋转速度至少相差一个数量级,如软盘为300r/min,硬盘一般为7200~15000r/min,甚至更高。
对于磁盘旋转延迟时间而言,如硬盘,旋转速度为15000r/min,每转需时4ms,平均旋转延迟时间Tr为2ms;而软盘,其旋转速度为300r/min或600r/min,这样,平均Tr为50~100ms。
(3)传输时间Tt
这时指把数据从磁盘读出或向磁盘写入数据所经历的时间。
Tt的大小与每次所读/写的字节数b和旋转速度有关:
Tt=b/(r*N)
其中,r为磁盘每秒钟的转数;N为一条磁道上的字节数,当一次读/写的字节数相当于半条磁道上的字节数时,T3与T2相同。
因此,可将访问时间Ta表示为
Ta=Ts+1/(2*r)+b/(r*N)由上式可以看出,在访问时间中,寻道时间和旋转延迟时间基本上都与所读/写数据的多少无关,而且它通常占据了访问时间中的大头。
磁盘是可供多个进程共享的设备,当有多个进程都要求访问磁盘时,应采用一种最佳调度算法,以使各进程对磁盘的平均访问时间最小。
由于在访问磁盘的时间中,主要是寻道时间,因此,磁盘调度的目标是使磁盘的平均寻道时间最少。
现在我们考虑平均寻道长度:
所有磁
道所需移动距离之和除以总的所需访问的磁道数,所以寻道长度决定了寻道时间,我们需要
从上面的算法中选择最优者。
3、算法原理
磁盘驱动调度对磁盘的效率有重要影响。
磁盘驱动调度算法的好坏直接影响辅助存储器的效率,从而影响计算机系统的整体效率。
常用的磁盘驱动调度算法有:
最简单的磁盘驱动调度算法是先入先出(FIFO)法:
这种算法的实质是,总是严格按
时间顺序对磁盘请求予以处理。
算法实现简单、易于理解并且相对公平,不会发生进程饿死现象。
但该算法可能会移动的柱面数较多并且会经常更换移动方向,效率有待提高。
最短寻找时间优先算法(SSTF):
总是优先处理最靠近的请求。
该算法移动的柱面距离较小,但可能会经常改变移动方向,并且可能会发生进程饥饿现象。
电梯调度(SCAN):
总是将一个方向上的请求全部处理完后,才改变方向继续处理其他请求。
循环扫描(CSCA)N:
从最外向最里(或从最里向最外)进行柱面请求处理,到最里柱面后,直接跳到最外柱面然后继续向里进行处理。
该算法与扫描算法的区别是,回来过程不处理请求,基于这样的事实,因为里端的请求刚被处理。
4、数据结构
利用数组对算法进行处理。
now:
当前磁道号
,先来先服务算法,最短寻到时间优先算法,扫描算法
,循环扫描算法
cidao[],放置磁道号的数组voidFCFS(intcidao[],intm)voidSSTF(intcidao[],intm)voidSCAN(intcidao[],intm)voidCSCAN(intcidao[],intm)
四、算法分析:
(1)
先来先服务算法(FCFS)
优点是公平、简单,且每个进程的请求都能依次地得到处理,不会出现某一进程的请求长期得不到满足的情况。
但是此算法由于未对寻道进行优化,致使平均寻道时间可能较长。
当有进程先后提出磁盘I/O请求时,先按他们发出请求的先后次序排队。
然后依次给予服务。
其平均寻道距离较大,故先来先服务算法仅适用于请求磁盘I/O进程数目较少的场合。
(2)最短寻道时间优先算法(SSTF)
该算法选择这样的进程:
其要求访问的磁道与当前磁头所在的磁道距离最近,以使每次寻道时间最短。
但这种算法不能保证平均寻道时间最短。
有可能导致某个进程出现“饥饿”现象,因为只要不断有新进程请求到达,且其所要访问的磁道与磁头当前所在的磁道的距离较近,这种新进程的I/O请求必然优先满足。
(3)扫描算法(SCAN)
该算法不仅考虑到正欲访问的磁道与当前磁道间的距离,更优先考虑的是磁头当前的移
动方向。
例如,当磁头正在自里向外移动时,SCAN算法所考虑的下一个访问对象应该是其
欲访问的磁道之外,又是距离最近的。
这样自里向外地访问,直至再无更外的磁道需要访问时,才将磁臂换向为自外向里移动。
这时,同样也是每次选择这样的进程来调度,既要访问的磁道在当前位置内距离最近者,这样,磁头又逐步地从外向里移动,直至再无更里面的磁道要访问,从而避免了出现“饥饿”现象。
由于在这种算法中磁头移动的规律颇似电梯的运行,因而又常称之为电梯调度算法。
(4)循环扫描算法(CSCAN)
CSCAN算法规定磁头单向移动,例如,只是自里向外移动,当磁头移动到最外的磁道并访问后,磁头立即返回到最里的欲访问的磁道,亦即将最小磁道号紧接着最大的磁道号构成循环,进行循环扫描。
五、系统流程图
FCFS算法(先来先服务)流程图:
SSTF(最短寻道时间优先算法)
算法流程图:
SCAN算法(扫描算法)流程图:
源代码
#include
#include#include#include#definemaxsize1000
/*********************
判断输入数据是否有效**************************/
intdecide(charstr[])
//判断输入数据是否有效
{
inti=0;
while(str[i]!
='\0'){
if(str[i]<'0'||str[i]>'9')
{
return0;
break;}i++;
}
returni;
将字符串转换成数字***********************/
inttrans(charstr[],inta)//将字符串转换成数字
{
inti;
intsum=0;for(i=0;i{sum=sum+(int)((str[i]-'0')*pow(10,a-i-1));
}returnsum;
}
int*bubble(intcidao[],intm)
{
inti,j;
inttemp;
for(i=0;ifor(j=i+1;j{
if(cidao[i]>cidao[j])
{
temp=cidao[i];
cidao[i]=cidao[j];
cidao[j]=temp;
}
}
cout<<"排序后的磁盘序列为:
";
for(i=0;i{
cout<}
cout<returncidao;
}
先来先服务调度算法
voidFCFS(intcidao[],intm)//磁道号数组,个数为m
{
intnow;//当前磁道号
intsum=0;//总寻道长度
intj,i;inta;
charstr[100];
floatave;//平均寻道长度cout<<"磁盘请求序列为:
";
for(i=0;i{
cout<}
cout<cout<<"请输入当前的磁道号:
";
B:
cin>>str;//对输入数据进行有效性判断
a=decide(str);
if(a==0)
{
cout<<"输入数据的类型错误,请重新输入!
"<gotoB;}else
now=trans(str,a);//输入当前磁道号sum+=abs(cidao[0]-now);cout<<"磁盘扫描序列为:
";for(i=0;i{
cout<}
for(i=0,j=1;j{
sum+=abs(cidao[j]-cidao[i]);
ave=(float)(sum)/(float)(m);
}cout<cout<<"平均寻道长度:
"<最短寻道时间优先调度算法********************/
voidSSTF(intcidao[],intm){
intk=1;
intnow,l,r;
inti,j,sum=0;
inta;
charstr[100];
floatave;
cidao=bubble(cidao,m);//调用冒泡排序算法排序
cout<<"请输入当前的磁道号:
";
C:
cin>>str;//对输入数据进行有效性判断
a=decide(str);
if(a==0)
{
cout<<"输入数据的类型错误,请重新输入!
"<gotoC;
}
else
now=trans(str,a);//输入当前磁道号
if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接由外向内依次给予各请求服务
{
cout<<"磁盘扫描序列为:
";
for(i=m-1;i>=0;i--)cout<sum=now-cidao[0];
}
if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务
{
cout<<"磁盘扫描序列为:
";
for(i=0;isum=cidao[m-1]-now;
}
if(now>cidao[0]&&now{
cout<<"磁盘扫描序列为:
";
while(cidao[k]制后少量修改,节省时间。
{
k++;
}
l=k-1;
r=k;
while((l>=0)&&(r{
cout<sum+=now-cidao[l];
now=cidao[l];
l=l-1;
}
else
{
cout<sum+=cidao[r]-now;now=cidao[r];r=r+1;
}
}
if(l==-1)//磁头移动到序列的最小号,返回外侧扫描仍未扫描的磁道
{
for(j=r;j{cout<}sum+=cidao[m-1]-cidao[0];
}
else//磁头移动到序列的最大号,返回内侧扫描仍未扫描的磁道
{
for(j=l;j>=0;j--)
{cout<}sum+=cidao[m-1]-cidao[0];
}
}
ave=(float)(sum)/(float)(m);
cout<cout<<"平均寻道长度:
"<}
/*************************voidSCAN(intcidao[],intm){
intk=1;
intnow,l,r,d;inti,j,sum=0;inta;
charstr[100];
floatave;
cidao=bubble(cidao,m);//调用冒泡排序算法排序
cout<<"请输入当前的磁道号:
";
D:
cin>>str;//对输入数据进行有效性判断
a=decide(str);
if(a==0)
{
cout<<"输入数据的类型错误,请重新输入!
"<gotoD;
}
else
now=trans(str,a);//输入当前磁道号
if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接由外向内依次给予各请求服务此情况同最短寻道优先
{
cout<<"磁盘扫描序列为:
";
for(i=m-1;i>=0;i--)cout<此
}
if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务
情况同最短寻道优先
{
cout<<"磁盘扫描序列为:
";
for(i=0;icout<}if(now>cidao[0]&&nowwhile(cidao[k]{
k++;
}
l=k-1;
r=k;
cout<<"请输入当前移动臂的移动的方向(1表示向外,0表示向内):
";cin>>d;
if(d==0)//选择移动臂方向向内,则先向内扫描
{
cout<<"磁盘扫描序列为:
";
for(j=l;j>=0;j--)
{
}
for(j=r;j{cout<}sum=now-2*cidao[0]+cidao[m-1];
}
else//选择移动臂方向向外,则先向外扫描
{
cout<<"磁盘扫描序列为:
";for(j=r;j{
cout<}
for(j=l;j>=0;j--)//磁头移动到最大号,则改变方向向内扫描未扫描的磁道
{
cout<}sum=-now-cidao[0]+2*cidao[m-1];
}
}ave=(float)(sum)/(float)(m);
cout<"<cout<<"平均寻道长度:
}
循环扫描调度算法*****************************/
/************************
voidCSCAN(intcidao[],intm)
{
intk=1;
intnow,l,r;
inti,j,sum=0;
inta;
charstr[100];
floatave;
//调用冒泡排序算法排序
cidao=bubble(cidao,m);
cout<<"请输入当前的磁道号:
";
E:
cin>>str;//对输入数据进行有效性判断a=decide(str);
if(a==0)
{
cout<<"输入数据的类型错误,请重新输入!
"<gotoE;
}
else
now=trans(str,a);//输入当前磁道号
if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接将移动臂移动到最小号磁道依次
向外给予各请求服务
{
cout<<"磁盘扫描序列为:
";
for(i=0;icout<sum=now-2*cidao[0]+cidao[m-1];
}
if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务,此情况
同最短寻道优先
{
cout<<"磁盘扫描序列为:
";
for(i=0;icout<sum=cidao[m-1]-now;
}
if(now>cidao[0]&&now{
cout<<"磁盘扫描序列为:
";
while(cidao[k]{
k++;
}
l=k-1;
r=k;
for(j=r;j{
cout<}
for(j=0;j{
cout<}
sum=2*cidao[m-1]+cidao[l]-now-2*cidao[0];
}
ave=(float)(sum)/(float)(m);
cout<cout<<"平均寻道长度:
"<}
voidmain()
{
inta;
intc;//菜单项
intcidao[maxsize];
inti=0,count;
charstr[100];cout<<"请输入磁道序列(0结束):
"<A:
cin>>str;//对输入数据进行有效性判断a=decide(str);
if(a==0)
{
cout<<"输入数据的类型错误,请重新输入!
"<}
elsecidao[i]=trans(str,a);
i++;
while(cidao[i-1]!
=0)
{
cin>>str;//对输入数据进行有效性判断a=decide(str);
if(a==0)
cout<<"输入数据的类型错误,请重新输入!
"<{
cidao[i]=trans(str,a);
i++;
}
}
count=i-1;//要访问的磁道数
cout<<"你输入的磁道序列为:
";
for(i=0;i{
cout<}
cout<(1)
{
cout<cout<<"
<cout<<"
系统菜单******"<cout<<"
"<cout<<"***cout<<"**
1.先来先服务
***"<**"<cout<<"**
**"<
cout<<"**
2.最短寻道时间优先
**"<cout<<"**
**"<cout<<"**
3.扫描调度
**"<cout<<"**
**"<cout<<"**
4.循环扫描
**"<cout<<"**
**"<cout<<"**
5.退出
**"<cout<<"***
***"<
cout<<"**********************************************"<cout<<"**********************************************"<G:
cout<<"请选择算法:
F:
cin>>str;//对输入数据进行有效性判断
a=decide(str);
if(a==0)
{
cout<<"输入数据的类型错误,请重新输入!
"<gotoF;//输入错误,跳转到F,重新输入
}
else
c=trans(str,a);
if(c==5)
break;
if(c>5)
{
cout<<"数据输入错误!
请重新输入"<}
switch(c)
{
case1:
//使用FCFS算法
FCFS(cidao,count);
break;
case2:
//使用SSTF算法
SSTF(cidao,count);
break;
case3:
//使用SCAN算法
SCAN(cidao,count);
break;
case4:
//使用CSCAN算法
CSCAN(cidao,count);
break;
}
七、实验结果分析
程序开始
选择先来先服务算法,结果如下:
选择最短寻到时间优先算法,结果如下:
选择扫描调度算法,结果如下:
选择循环扫描算法,结果如下:
八、实践总结与体会
通过这次试验,我清楚的了解到磁盘调度的详细过程和四种调度算法(先来先服务算法;
最短寻道时间优先算法;扫描算法;循环扫描算法)以及四种调度算法之间的差异和共性,同时,也看到了经过优化的算法会带来的好处!
在实验过程中,也遇到了不少问题,在实现扫描算法时出现了问题!
当输入的当前的磁道号不在磁盘请求序列中时,程序可以正常执行,当输入的当前的磁道号在磁盘请求序列中时,程序执行时出现处理序列顺序错误的问题,通过和同学的讨论,发现有两个循环中的自变量初值设置有问题,经过调整后,程序执行无误!
以后,在实现代码的过程中,一定会更加小心,防止出现低级错误导致程序出错!