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

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

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

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

1．课程设计目的

1.1编写目的

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

2．课程设计内容

2.1设计内容

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

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

1、先来先服务算法（FCFS）

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

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

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

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

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

该算法选择这样的进程，其要求访问的磁道与当前磁头所在的磁道距离最近，以使每次的寻道时间最短，该算法可以得到比较好的吞吐量，但却不能保证平均寻道时间最短。

其缺点是对用户的服务请求的响应机会不是均等的，因而导致响应时间的变化幅度很大。

在服务请求很多的情况下，对内外边缘磁道的请求将会无限期的被延迟，有些请求的响应时间将不可预期。

3、扫描算法（SCAN）

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

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

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

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

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

此算法基本上克服了最短寻道时间优先算法的服务集中于中间磁道和响应时间变化比较大的缺点，而具有最短寻道时间优先算法的优点即吞吐量较大，平均响应时间较小，但由于是摆动式的扫描方法，两侧磁道被访问的频率仍低于中间磁道。

4、循环扫描算法（CSCAN）

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

如果对磁道的访问请求是均匀分布的，当磁头到达磁盘的一端，并反向运动时落在磁头之后的访问请求相对较少。

这是由于这些磁道刚被处理，而磁盘另一端的请求密度相当高，且这些访问请求等待的时间较长，为了解决这种情况，循环扫描算法规定磁头单向移动。

例如，只自里向外移动，当磁头移到最外的被访问磁道时，磁头立即返回到最里的欲访磁道，即将最小磁道号紧接着最大磁道号构成循环，进行扫描。

3.模块流程图

3.1模块调用关系图

3.2模块程序流程图

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

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

算法流程图：

SCAN算法（扫描算法）流程图：

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

4．测试数据和结果

输入磁道序列号：

25160786510062165345

选择算法1，平均寻道长度46.4444；

选择算法2，平均寻道长度为16.6667；

选择算法3，磁臂移动方向为由外向内，平均寻道长度为16.4444

选择算法3，磁臂移动方向为由内向外，平均寻道长度为31.5556；

选择算法4，平均寻道长度为31.4444

5．参考文献

《计算机操作系统（修订版）》汤子瀛西安电子科技大学出版社

《操作系统教程》方敏编西安电子科技大学出版社

《操作系统实用教程（第二版）》任爱华清华大学出版社

《操作系统原理与实践教程》 周湘贞清华出版社

《程序设计基础教程》陈家骏机械工业出版社

6．总结

通过这次试验，我们清楚的了解到磁盘调度的详细过程和四种调度算法（先来先服务算法；最短寻道时间优先算法；扫描算法；循环扫描算法）以及四种调度算法之间的差异和共性，同时，也看到了经过优化的算法会带来的好处！

在实验过程中，也遇到了不少问题，在实现扫描算法时出现了问题！

当输入的当前的磁道号不在磁盘请求序列中时，程序可以正常执行，当输入的当前的磁道号在磁盘请求序列中时，程序执行时出现处理序列顺序错误的问题，通过和同学的讨论，发现有两个循环中的自变量初值设置有问题，经过调整后，程序执行无误！

以后，在实现代码的过程中，一定会更加小心，防止出现低级错误导致程序出错！

附：

#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;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;

}

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

cout<

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

{

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<

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]

{

k++;

}

l=k-1;

r=k;

cout<<"请输入当前移动臂的移动的方向（1表示向外，0表示向内）:

";

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

{

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

cout<

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

}

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

{

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

";

for（i=0;i

cout<

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

"<

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

}

else

cidao[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<

}

cout<

while

（1）

{

cout<

cout<<"**********************************************"<

cout<<"**********************************************"<

cout<<"******"<

cout<<"**1.先来先服务**"<

cout<<"****"<

cout<<"**2.最短寻道时间优先**"<

cout<<"****"<

cout<<"**3.扫描调度**"<

cout<<"****"<

cout<<"**4.循环扫描**"<

cout<<"****"<

cout<<"**5.退出**"<

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<<"数据输入错误！

请重新输入"<

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;

}

}

}