移臂调度算法分析.docx

移臂调度算法分析.docx

《移臂调度算法分析.docx》由会员分享，可在线阅读，更多相关《移臂调度算法分析.docx（12页珍藏版）》请在冰豆网上搜索。

移臂调度算法分析

移臂调度算法

一、实验目的

作为操作系统的辅助存储器，用来存放文件的磁盘是一类高速大容量旋转型存储设备，在繁重的I/O设备负载下，同时会有若干传输请求来到并等待处理，系统必须采用一种调度策略，能够按最佳次序执行要求访问的诸多请求，这叫做驱动调度，所使用的算法叫做驱动调度算法。

驱动调度算法能减少为若干I/O请求服务所需消耗的总时间，从而提高系统效率。

对于磁盘设备，在启动之前按驱动调度策略对访问的请求优化其排序十分必要。

除了使旋转圈数达到最少的调度策略外，还应考虑使移动臂的移动时间最短的调度策略。

二、实验要求

书写实验报告，应该包括以下几项内容:

（1）实验题目；

（2）程序中使用的数据结构及主要符号说明；

（3）程序流程图和带有注释的源程序；

（4）执行程序名，并打印程序运行时的初值和运行结果；

（5）通过实验后的收获与体会及对实验的改进意见和见解。

三、程序及主要符号说明

（1）先来先服务（FCFS）

这是一种简单的磁盘调度算法。

它根据进程请求访问磁盘的先后次序进行调度。

此算法的优点是公平、简单，且每个进程的请求都能依次得到处理，不会出现某一进程的请求长期得不到满足的情况。

但此算法由于未对寻道进行优化，致使平均寻道时间可能较长。

（2）最短寻道时间优先（SSTF）

该算法选择这样的进程，其要求访问的磁道与当前磁头所在的磁道距离最近，以使每次的寻道时间最短，但这种调度算法却不能保证平均寻道时间最短。

（3）扫描算法（SCAN）

SCAN算法不仅考虑到欲访问的磁道与当前磁道的距离，更优先考虑的是磁头的当前移动方向。

例如，当磁头正在自里向外移动时,SCAN算法所选择的下一个访问对象应是其欲访问的磁道既在当前磁道之外，又是距离最近的。

这样自里向外地访问，直到再无更外的磁道需要访问才将磁臂换向，自外向里移动。

这时，同样也是每次选择这样的进程来调度，即其要访问的磁道，在当前磁道之内，从而避免了饥饿现象的出现。

由于这种算法中磁头移动的规律颇似电梯的运行，故又称为电梯调度算法。

四、实验结果

1、先来先服务调度（FCFS）

2、最短寻道时间优先调度（SSTF）

3、扫描调度算法（SCAN）

五、实验体会

通过这次的实验，更加深入的了解了移臂调度算法的具体过程，运用起来也更加熟练，将课堂上的理论知识得到更好的体现。

平时课堂上有些概念理解不清楚，导致在做实验时有点茫然，不知从何下手。

因为知识掌握的不够好，在本次实验中出现了很多问题，不过通过看书和同学的帮助也得以解决。

在本次实验中，我收获了很多，做出实验时有种前所未有的成就感。

附录:

实验源程序

#include

usingnamespacestd;

voidCopyL（intSour[],intDist[],intx）;//数组Sour复制到数组Dist，复制到x个数

voidSetDI（intDiscL[]）;//随机生成磁道数

voidPrint（intPri[],intx）;//打印输出数组Pri

voidDelInq（intSour[],intx,inty）;//数组Sour把x位置的数删除，并把y前面的数向前移动，y后的数保持不变（即会出现2个y）

voidFCFS（intHan,intDiscL[]）;//先来先服务算法（FCFS）

voidSSTF（intHan,intDiscL[]）;//最短寻道时间优先算法（SSTF）

intSCAN（intHan,intDiscL[],intx,inty）;//扫描算法（SCAN）

voidCSCAN（intHan,intDiscL[]）;//循环扫描算法（CSCAN）

voidPaiXu（）;//寻道长度由低到高排序

voidPri（）;

intNAll=0;

intBest[5][2];//用作寻道长度由低到高排序时存放的数组

intLimit=0;//输入寻找的范围磁道数i

intJage;

floatAver=0;

intmain（）{

inti;

intDiscLine[10];//声明准备要生成的随机磁道号的数组

intHand;//磁道数

intCon=1;

intn;

while（Con==1）{

Jage=0;

cout<<“请输入初始的磁道数:

";

intHand;

cout<<输入寻找的范围:

";

intLimit;

if（Limit>65536）{

cout<<"超出磁道范围!

";

}

else{

cout<<"1.先来先服务算法（FCFS）\n";

cout<<"2.最短寻道时间优先算法（SSTF）\n";

cout<<"3.扫描算法（SCAN）\n";

intn;

if（n==0）exit（0）;

cout<<"\n";

switch（n）{

case1:

SetDI（DiscLine）;//随机生成磁道数

FCFS（Hand,DiscLine）;//先来先服务算法（FCFS）

break;

case2:

SetDI（DiscLine）;//随机生成磁道数

SSTF（Hand,DiscLine）;//最短寻道时间优先算法（SSTF）

break;

case3:

SetDI（DiscLine）;//随机生成磁道数

SCAN（Hand,DiscLine,0,9）;//扫描算法（SCAN）

break;

SetDI（DiscLine）;//随机生成磁道数

FCFS（Hand,DiscLine）;//先来先服务算法（FCFS）

SSTF（Hand,DiscLine）;//最短寻道时间优先算法（SSTF）SCAN（Hand,DiscLine,0,9）;//扫描算法（SCAN）

}

cout<<“是否继续（按0结束,按1继续）?

";

scanf（"%5d",&Con）;

}

}

}//数组Sour复制到数组Dist，复制到x个数

voidCopyL（intSour[],intDist[],intx）

{inti;

for（i=0;i<=x;i++）

{

Dist[i]=Sour[i];

}

}//打印输出数组Pri

voidPrint（intPri[],intx）

{

inti;

for（i=0;i<=x;i++）

{

printf（"%5d",Pri[i]）;

}

}//随机生成磁道数

voidSetDI（intDiscL[]）{

inti;

for（i=0;i<=9;i++）{

DiscL[i]=rand（）%Limit;//随机生成10个磁道号

}

cout<<"需要寻找的磁道号:

";

Print（DiscL,9）;//输出随机生成的磁道号

cout<<"\n";

}//数组Sour把x位置的数删除，并把y前面的数向前移动，y后的数保持不变（即会出现2个y）

voidDelInq（intSour[],intx,inty）

{inti;

for（i=x;i

Sour[i]=Sour[i+1];

x++;

}

}//先来先服务算法（FCFS）

voidFCFS（intHan,intDiscL[]）{

intRLine[10];//将随机生成的磁道数数组Discl[]复制给数组RLine[]

inti,k,All,Temp;//Temp是计算移动的磁道距离的临时变量

All=0;//统计全部的磁道数变量

k=9;//限定10个的磁道数

CopyL（DiscL,RLine,9）;//复制磁道号到临时数组RLine

cout<<"FCFS访问顺序为:

";

All=Han-RLine[0];

for（i=0;i<=9;i++）

{

Temp=RLine[0]-RLine[1];//求出移动磁道数前一个磁道数减去后一个磁道数得出临时的移动距离

if（Temp<0）

Temp=（-Temp）;//移动磁道数为负数时算出相反数作为移动磁道数

printf（"%5d",RLine[0]）;

All=Temp+All;//求全部磁道数的总和

DelInq（RLine,0,k）;//每个磁道数向前移动一位

k--;

}

Best[Jage][1]=All;//Best[][1]存放移动磁道数

Best[Jage][0]=1;//Best[][0]

存放算法的序号为:

1

Jage++;//排序的序号加1

Aver=（（float）All）/10;//求平均寻道次数

cout<<"移动磁道数:

"<

cout<<"平均寻道长度:

*%0.2f*"<

}//最短寻道时间优先算法（SSTF）

voidSSTF（intHan,intDiscL[]）{

inti,j,k,h,All;

intTemp;//Temp是计算移动的磁道距离的临时变量

intRLine[10];//将随机生成的磁道数数组Discl[]复制给数组RLine[]

intMin;

All=0;//统计全部的磁道数变量

k=9;//限定10个的磁道数

CopyL（DiscL,RLine,9）;//复制磁道号到临时数组

RLine

cout<<"SSTF访问顺序为:

";

for（i=0;i<=9;i++）

{Min=64000;

for（j=0;j<=k;j++）//内循环寻找与当前磁道号最短寻道的时间的磁道号

{

if（RLine[j]>Han）//如果第一个随机生成的磁道号大于当前的磁道号，执行下一句

Temp=RLine[j]-Han;//求出临时的移动距离

else

Temp=Han-RLine[j];//求出临时的移动距离

if（Temp

{

Min=Temp;//Temp临时值赋予Min

h=j;//把最近当前磁道号的数组下标赋予h

}

}

All=All+Min;

//统计一共移动的距离

printf（"%5d",RLine[h]）;

Han=RLine[h];

DelInq（RLine,h,k）;//每个磁道数向前移动一位

k--;

}

Best[Jage][1]=All;//Best[][1]存放移动磁道数

Best[Jage][0]=2;//Best[][0]存放算法的序号为:

2

Jage++;//排序序号加1

Aver=（（float）All）/10;//求平均寻道次数

printf（"\n+移动磁道数:

<%5d>",All）;

printf（"\n+平均寻道长度:

*%0.2f*",Aver）;

}//扫描算法（SCAN）

intSCAN（intHan,intDiscL[],intx,inty）{

intj,n,k,h,m,All;

intt=0;

intTemp;

intMin;

intRLine[10];//将随机生成的磁道数数组Discl[]复制给数组RLine[]

intOrder;

Order=1;

k=y;

m=2;//控制while语句的执行，即是一定要使当前磁道向内向外都要扫描到

All=0;//统计全部的磁道数变量

CopyL（DiscL,RLine,9）;//复制磁道号到临时数组RLine

cout<<"SCAN访问顺序为:

";

Min=64000;

for（j=x;j<=y;j++）//寻找与当前磁道号最短寻道的时间的磁道号

{

if（RLine[j]>Han）//如果第一个随机生成的磁道号大于当前的磁道号,执行下一句

Temp=RLine[j]-Han;//求出临时的移动距离

else

Temp=Han-RLine[j];//求出临时的移动距离

if（Temp

{Min=Temp;//Temp临时值赋予Min

h=j;//把最近当前磁道号的数组下标赋予h

}

}

All=All+Min;

printf（"%5d",RLine[h]）;

if（RLine[h]>=Han）

{//判动方向，即是由里向外还是由外向里断磁道的移

Order=0;

t=1;

}

Han=RLine[h];

DelInq（RLine,h,k）;//每个磁道数向前移动一位

k--;

while（m>0）

{if（Order==1）//order是判断磁盘扫描的方向标签，order是1的话，磁道向内移动

{for（j=x;j<=y;j++）

{h=-1;Min=64000;

for（n=x;n<=k;n++）//判断离当前磁道最近的磁道号

{if（RLine[n]<=Han）

{Temp=Han-RLine[n];

if（Temp

{

Min=Temp;//Temp临时值赋予Min

h=n;//把最近当前磁道号的数组下标赋予h

}

}

}

if（h!

=-1）{

All=All+Min;

//叠加移动距离

printf（"%5d",RLine[h]）;

Han=RLine[h];//最近的磁道号作为当前磁道

DelInq（RLine,h,k）;

k--;

}

}

Order=0;//当完成向内的移动，order赋予0，执行else语句，使磁道向外移动

m--;//向内完成一次，m减一次，保证while循环执行两次

}

else//order0的话，磁道向外移动

{

for（j=x;j<=y;j++）

{h=-1;

Min=64000;

for（n=x;n<=k;n++）//判断离当前磁道最近的磁道号

{if（RLine[n]>=Han）

{

Temp=RLine[n]-Han;

if（Temp

Min=Temp;//Temp临时值赋予Min

h=n;//把最近当前磁道号的数组下标赋予h

}

}

}

if（h!

=-1）

{

All=All+Min;//叠加移动距离

printf（"%5d",RLine[h]）;

Han=RLine[h];//最近的磁道号作为当前磁道

DelInq（RLine,h,k）;

}

}

Order=1;//当完成向内的移动，order赋予0，执行else语句，使磁道向外移动m--;//向内完成一次，m减一次，保证while循环执行两次

}

}

NAll=NAll+All;

if（（y-x）>5）{

Best[Jage][1]=All;//Best[][1]存放移动磁道数

Best[Jage][0]=3;//Best[][0]存放算法的序号为:

3

Jage++;//排序序号加1

Aver=（（float）All）/10;//求平均寻道次数

printf（"\n+移动磁道数:

<%5d>",All）;

printf（"\n+平均寻道长度:

*%0.2f*",Aver）;

}

if（t==1）

printf（"\n+磁道由内向外移动"）;

elseprintf（"\n+磁道由外向内移动"）;

return（Han）;

}