磁盘调度操作系统实验报告.docx

磁盘调度操作系统实验报告.docx

《磁盘调度操作系统实验报告.docx》由会员分享，可在线阅读，更多相关《磁盘调度操作系统实验报告.docx（21页珍藏版）》请在冰豆网上搜索。

磁盘调度操作系统实验报告

实验一磁盘调度算法实现

一、实验目的

本课程设计的目的是通过磁盘调度算法设计一个磁盘调度模拟系统，从而使磁盘调度算法更加形象化，容易使人理解，使磁盘调度的特点更简单明了，能使使用者加深对先来先服务算法、最短寻道时间优先算法、扫描算法以及循环扫描算法等磁盘调度算法的理解。

二、实验内容

系统主界面可以灵活选择某种算法，算法包括：

先来先服务算法（FCFS）、最短寻道时间优先算法（SSTF）、扫描算法（SCAN）、循环扫描算法（CSCAN）。

2.1先来先服务算法（FCFS）

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

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

行调度。

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

此算法由于未对寻道进行优化，

在对磁盘的访问请求比较多的情况下，此算法将降低设备服务的吞吐量，致使平均寻道时间可能较长，但各进程得到服务的响应时间的变化幅度较小。

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

该算法选择这样的进程，其要求访问的磁道与当前磁头所在的磁道距离最近，

以使每次的寻道时间最短，该算法可以得到比较好的吞吐量，但却不能保证平均

寻道时间最短。

其缺点是对用户的服务请求的响应机会不是均等的，因而导致响

应时间的变化幅度很大。

在服务请求很多的情况下，对内外边缘磁道的请求将会

无限期的被延迟，有些请求的响应时间将不可预期。

2.3扫描算法（SCAN）

扫描算法不仅考虑到欲访问的磁道与当前磁道的距离，更优先考虑的是磁头

的当前移动方向。

例如，当磁头正在自里向外移动时，扫描算法所选择的下一个

访问对象应是其欲访问的磁道既在当前磁道之外，又是距离最近的。

这样自里向

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

这时，

同样也是每次选择这样的进程来调度，即其要访问的磁道，在当前磁道之内，从

而避免了饥饿现象的出现。

由于这种算法中磁头移动的规律颇似电梯的运行，故

又称为电梯调度算法。

此算法基本上克服了最短寻道时间优先算法的服务集中于

中间磁道和响应时间变化比较大的缺点，而具有最短寻道时间优先算法的优点即

吞吐量较大，平均响应时间较小，但由于是摆动式的扫描方法，两侧磁道被访问

的频率仍低于中间磁道。

2.4循环扫描算法（CSCAN）

循环扫描算法是对扫描算法的改进。

如果对磁道的访问请求是均匀分布的，

当磁头到达磁盘的一端，并反向运动时落在磁头之后的访问请求相对较少。

这是

由于这些磁道刚被处理，而磁盘另一端的请求密度相当高，且这些访问请求等待

的时间较长，为了解决这种情况，循环扫描算法规定磁头单向移动。

例如，只自

里向外移动，当磁头移到最外的被访问磁道时，磁头立即返回到最里的欲访磁道，

即将最小磁道号紧接着最大磁道号构成循环，进行扫描。

三、实验流程

3.1系统功能图

图3-1系统功能图

3.2算法流程图

本次实验为实现磁盘调度算法，分别实现四个算法并调试。

四个算法算法包括：

先来先服务算法（FCFS）、最短寻道时间优先算法（SSTF）、扫描算法（SCAN）、循环扫描算法（CSCAN）。

四个算法的流程图分析如下。

1）先来先服务算法（FCFS）的流程图

图3-2先来先服务算法的流程图

2）最短寻道时间优先算法（SSTF）的流程图

图3-3最短寻道时间优先算法的流程图

3）扫描算法（SCAN）的流程图

图3-4扫描算法的流程图

4）循环扫描算法（CSCAN）的流程图

图3-5循环扫描算法的流程图

4、源程序

#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

returnsum;

}

/*********************冒泡排序算法**************************/

int*bubble（intcidao[],intm）

{

inti,j;

inttemp;

for（i=0;i

for（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;

}

elsenow=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;

}

elsenow=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;i

sum=cidao[m-1]-now;

}

if（now>cidao[0]&&now

{

cout<<"磁盘扫描序列为：

";

while（cidao[k]

k++;

l=k-1;

r=k;

while（（l>=0）&&（r

{

if（（now-cidao[l]）<=（cidao[r]-now））//选择与当前磁道最近的请求给予服务

{

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

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;

}

elsenow=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;i

cout<

sum=cidao[m-1]-now;

}

if（now>cidao[0]&&now

{

while（cidao[k]

l=k-1;

r=k;

cout<<"请输入当前移动臂的移动的方向:

\n"<

cout<<"0:

表示向内1:

表示向外:

"<

cin>>d;

if（d==0）//选择移动臂方向向内，则先向内扫描

{

cout<<"磁盘扫描序列为：

";

for（j=l;j>=0;j--）cout<

for（j=r;j

cout<

sum=now-2*cidao[0]+cidao[m-1];

}

else//选择移动臂方向向外，则先向外扫描

{

cout<<"磁盘扫描序列为：

";

for（j=r;j

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;

}

elsenow=trans（str,a）;//输入当前磁道号

if（cidao[m-1]<=now）//若当前磁道号大于请求序列中最大者，则直接将移动臂移动到最小号磁道依次向外给予各请求服务

{

cout<<"磁盘扫描序列为：

";

for（i=0;i

sum=now-2*cidao[0]+cidao[m-1];

}

if（cidao[0]>=now）//若当前磁道号小于请求序列中最小者，则直接由内向外依次给予各请求服务,此情况同最短寻道优先

{

cout<<"磁盘扫描序列为：

";

for（i=0;i

sum=cidao[m-1]-now;

}

if（now>cidao[0]&&now

{

cout<<"磁盘扫描序列为：

";

while（cidao[k]

k++;

l=k-1;

r=k;

for（j=r;j

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<<"输入数据的类型错误,请重新输入！

"<

gotoA;//输入错误，跳转到A，重新输入

}

elsecidao[i]=trans（str,a）;

i++;

while（cidao[i-1]!

=0）{

cin>>str;//对输入数据进行有效性判断

a=decide（str）;

if（a==0）cout<<"输入数据的类型错误,请重新输入！

"<

else{

cidao[i]=trans（str,a）;

i++;

}

}

count=i-1;//要访问的磁道数

cout<<"输入的磁道序列为：

";

for（i=0;i

cout<

while

（1）{

cout<

cout<<"-------------------------------------------------------------------------"<

cout<<"\n1.先来先服务2.最短寻道时间优先3.扫描调度4.循环扫描5.退出\n"<

cout<<"-------------------------------------------------------------------------"<

G:

cout<<"请选择算法:

";

F:

cin>>str;//对输入数据进行有效性判断

a=decide（str）;

if（a==0）{

cout<<"输入数据的类型错误,请重新输入！

"<

gotoF;//输入错误，跳转到F，重新输入

}

elsec=trans（str,a）;

if（c==5）break;

if（c>5）{

cout<<"输入的数据错误！

请重新输入"<

gotoG;

}

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;

}

}

}

5、实验结果

5.1程序主界面

运行程序后，将会提示用户输入磁道序列，并且以0结束。

当用户输入磁道序列后，系统将会重新显示用户输入的磁道序列。

程序主界面运行图如图5-1所示。

图5-1程序主界面

5.2先来先服务算法（FCFS）运行结果

选择算法1之后，进入算法1的操作。

系统会显示磁盘的请求序列。

用户需要输入当前的磁道号，系统会显示出磁盘的扫描序列和平均寻道长度。

由运行结果可得出，先来先服务算法的平均寻道长度为24.75。

先来先服务算法的运行图如图5-2所示。

图5-2先来先服务算法运行结果图

5.3最短寻道时间优先算法（SSTF）运行结果

选择算法2之后，进入算法2的操作。

系统会显示磁盘的请求序列。

用户需要输入当前的磁道号，系统会显示出磁盘的扫描序列和平均寻道长度。

由运行结果可得出，先来先服务算法的平均寻道长度为20.625。

最短寻道时间优先算法的运行图如图5-3所示。

图5-3最短寻道时间优先算法运行结果图

5.4扫描算法（SCAN）运行结果

选择算法3之后，进入算法3的操作。

系统会显示磁盘的请求序列。

用户需要输入当前的磁道号，系统会显示出磁盘的扫描序列和平均寻道长度。

由运行结果可得出，先来先服务算法的平均寻道长度为11。

扫描算法的运行图如图5-4所示。

图5-4扫描算法运行结果图

5.5循环扫描算法（CSCAN）运行结果

选择算法4之后，进入算法4的操作。

系统会显示磁盘的请求序列。

用户需要输入当前的磁道号，系统会显示出磁盘的扫描序列和平均寻道长度。

由运行结果可得出，先来先服务算法的平均寻道长度为11。

扫描算法的运行图如图5-5所示。

图5-5循环扫描算法运行结果图

6、总结

通过本次实验，学习了解磁盘调度四种调度算法（先来先服务算法；最短寻道时间优先算法；扫描算法；循环扫描算法）的工作原理以及四种调度算法之间的差异和共性，并且在当中发现了自己的不足，对以前所学过的知识理解得不够深刻，掌握得不够牢固，看到了自己的实践经验还是比较缺乏，实践能力还需要提高。