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

- -
实验一磁盘调度算法实现
一、实验目的
本课程设计的目的是通过磁盘调度算法设计一个磁盘调度模拟系统，从而使磁盘调度算法更加形象化，容易使人理解，使磁盘调度的特点更简单明了，能使使用者加深对先来先效劳算法、最短寻道时间优先算法、扫描算法以及循环扫描算法等磁盘调度算法的理解。
二、实验内容
系统主界面可以灵活选择某种算法，算法包括：先来先效劳算法〔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 循环扫描算法的流程图
四、 源程序
#include<stdio.h>
#include<stdlib.h>
#include<iostream.h>
#include<math.h>
#define maxsize 1000

/*********************判断输入数据是否有效**************************/
int decide(char str[]) //判断输入数据是否有效
{
int i=0;
while(str[i]!='\0'){
if(str[i]<'0'||str[i]>'9'){
return 0;
break;
}
i++;
}
return i;
}

/******************将字符串转换成数字***********************/
int trans(char str[],int a) //将字符串转换成数字
{
int i;
int sum=0;
for(i=0;i<a;i++) sum=sum+(int)((str[i]-'0')*pow(10,a-i-1));
return sum;
}

/*********************冒泡排序算法**************************/
int *bubble(int cidao[],int m)
{
int i,j;
int temp;
for(i=0;i<m;i++) //使用冒泡法按从小到大顺序排列
for(j=i+1;j<m;j++){
if(cidao[i]>cidao[j]){
temp=cidao[i];
cidao[i]=cidao[j];
cidao[j]=temp;
}
}
cout<<" 排序后的磁盘序列为：";
for( i=0;i<m;i++) //输出排序结果
cout<<cidao[i]<<" ";
cout<<endl;
return cidao;
}

/*********************先来先效劳调度算法**************************/
void FCFS(int cidao[],int m) //磁道号数组，个数为m
{
int now;//当前磁道号
int sum=0; //总寻道长度
int j,i;
int a;

char str[100];
float ave; //平均寻道长度
cout<<" 磁盘请求序列为：";
for( i=0;i<m;i++) //按先来先效劳的策略输出磁盘请求序列
cout<<cidao[i]<<" ";
cout<<endl;
cout<<" 请输入当前的磁道号：";
B: cin>>str; //对输入数据进展有效性判断
a=decide(str);
if(a==0){
cout<<"输入数据的类型错误,请重新输入！"<<endl;
goto B;
}
else now=trans(str,a); //输入当前磁道号
sum+=abs(cidao[0]-now);
cout<<" 磁盘扫描序列为：";
for( i=0;i<m;i++) //输出磁盘扫描序列
cout<<cidao[i]<<" ";
for(i=0,j=1;j<m;i++,j++) //求平均寻道长度
{
sum+=abs(cidao[j]-cidao[i]);
ave=(float)(sum)/(float)(m);
}
cout<<endl;
cout<<" 平均寻道长度："<<ave<<endl;
}

/**********************最短寻道时间优先调度算法********************/
void SSTF(int cidao[],int m)
{
int k=1;
int now,l,r;
int i,j,sum=0;
int a;
char str[100];
float ave;
cidao=bubble(cidao,m); //调用冒泡排序算法排序
cout<<" 请输入当前的磁道号：";
C: cin>>str; //对输入数据进展有效性判断
a=decide(str);
if(a==0){
cout<<" 输入数据的类型错误,请重新输入！"<<endl;
goto C;
}
else now=trans(str,a); //输入当前磁道号
if(cidao[m-1]<=now) //假设当前磁道号大于请求序列中最大者，那么直接由外向内依次给予各请求效劳
{
cout<<" 磁盘扫描序列为：";
for(i=m-1;i>=0;i--) cout<<cidao[i]<<" ";
sum=now-cidao[0];
}
if(cidao[0]>=now) //假设当前磁道号小于请求序列中最小者，那么直接由内向外依次给予各请求效劳
{
cout<<" 磁盘扫描序列为：";
for(i=0;i<m;i++) cout<<cidao[i]<<" ";
sum=cidao[m-1]-now;
}
if(now>cidao[0]&&now<cidao[m-1]) //假设当前磁道号大于请求序列中最小者且小于最大者
{
cout<<" 磁盘扫描序列为：";
while(cidao[k]<now) //确定当前磁道在已排的序列中的位置，后面的算法都用到了，可以直接复制后少量修改，节省时间。
k++;
l=k-1;
r=k;
while((l>=0)&&(r<m)) //当前磁道在请求序列范围内
{
if((now-cidao[l])<=(cidao[r]-now)) //选择与当前磁道最近的请求给予效劳
{
cout<<cidao[l]<<" ";
sum+=now-cidao[l];
now=cidao[l];
l=l-1;
}
else{
cout<<cidao[r]<<" ";
sum+=cidao[r]-now;
now=cidao[r];
r=r+1;
}
}
}
if(l==-1) //磁头移动到序列的最小号，返回外侧扫描仍未扫描的磁道
{
for(j=r;j<m;j++) cout<<cidao[j]<<" ";
sum+=cidao[m-1]-cidao[0];
}
else //磁头移动到序列的最大号，返回内侧扫描仍未扫描的磁道
{
for(j=l;j>=0;j--) cout<<cidao[j]<<" ";
sum+=cidao[m-1]-cidao[0];
}
ave=(float)(sum)/(float)(m);
cout<<endl;
cout<<" 平均寻道长度： "<<ave<<endl;
}

/*****************************扫描调度算法*******************************/
void SCAN(int cidao[],int m) //先要给出当前磁道号和移动臂的移动方向
{
int k=1;
int now,l,r,d;
int i,j,sum=0;
int a;
char str[100];
float ave;
cidao=bubble(cidao,m); //调用冒泡排序算法排序
cout<<" 请输入当前的磁道号：";
D: cin>>str; //对输入数据进展有效性判断
a=decide(str);
if(a==0){
cout<<" 输入数据的类型错误,请重新输入！"<<endl;
goto D;
}
else now=trans(str,a); //输入当前磁道号
if(cidao[m-1]<=now) //假设当前磁道号大于请求序列中最大者，那么直接由外向内依次给予各请求效劳,此情况同最短寻道优先
{
cout<<" 磁盘扫描序列为：";
for(i=m-1;i>=0;i--)
cout<<cidao[i]<<" ";
sum=now-cidao[0];
}
if(cidao[0]>=now) //假设当前磁道号小于请求序列中最小者，那么直接由内向外依次给予各请求效劳,此情况同最短寻道优先
{
cout<<" 磁盘扫描序列为：";
for(i=0;i<m;i++)
cout<<cidao[i]<<" ";
sum=cidao[m-1]-now;
}
if(now>cidao[0]&&now<cidao[m-1]) //假设当前磁道号大于请求序列中最小者且小于最大者
{
while(cidao[k]<now) k++;
l=k-1;
r=k;
cout<<" 请输入当前移动臂的移动的方向:\n"<<endl;
cout<<" 0:表示向内1 :表示向外: "<<endl;
cin>>d;
if(d==0) //选择移动臂方向向内，那么先向内扫描
{
cout<<" 磁盘扫描序列为：";
for(j=l;j>=0;j--) cout<<cidao[j]<<" "; //输出向内扫描的序列
for(j=r;j<m;j++) //磁头移动到最小号，那么改变方向向外扫描未扫描的磁道
cout<<cidao[j]<<" "; //输出向外扫描的序列
sum=now-2*cidao[0]+cidao[m-1];
}
else //选择移动臂方向向外，那么先向外扫描
{
cout<<" 磁盘扫描序列为：";
for(j=r;j<m;j++) cout<<cidao[j]<<" "; //输出向外扫描的序列
for(j=l;j>=0;j--) //磁头移动到最大号，那么改变方向向内扫描未扫描的磁道
cout<<cidao[j]<<" ";
sum=-now-cidao[0]+2*cidao[m-1];
}
}
ave=(float)(sum)/(float)(m);
cout<<endl;
cout<<" 平均寻道长度： "<<ave<<endl;
}

/************************循环扫描调度算法*****************************/
void CSCAN(int cidao[],int m)
{
int k=1;
int now,l,r;
int i,j,sum=0;
int a;
char str[100];
float ave;
cidao=bubble(cidao,m); //调用冒泡排序算法排序
cout<<" 请输入当前的磁道号：";
E: cin>>str; //对输入数据进展有效性判断
a=decide(str);
if(a==0){
cout<<" 输入数据的类型错误,请重新输入！"<<endl;
goto E;
}
else now=trans(str,a); //输入当前磁道号
if(cidao[m-1]<=now) //假设当前磁道号大于请求序列中最大者，那么直接将移动臂移动到最小号磁道依次向外给予各请求效劳
{
cout<<" 磁盘扫描序列为：";
for(i=0;i<m;i++) cout<<cidao[i]<<" ";
sum=now-2*cidao[0]+cidao[m-1];
}
if(cidao[0]>=now) //假设当前磁道号小于请求序列中最小者，那么直接由内向外依次给予各请求效劳,此情况同最短寻道优先
{
cout<<" 磁盘扫描序列为：";
for(i=0;i<m;i++) cout<<cidao[i]<<" ";
sum=cidao[m-1]-now;
}
if(now>cidao[0]&&now<cidao[m-1]) //假设当前磁道号大于请求序列中最小者且小于最大者
{
cout<<" 磁盘扫描序列为：";
while(cidao[k]<now) //单向反复地从内向外扫描
k++;
l=k-1;
r=k;
for(j=r;j<m;j++) cout<<cidao[j]<<" "; //输出从当前磁道向外扫描的序列
for(j=0;j<r;j++) //当扫描完最大号磁道，磁头直接移动到最小号磁道，再向外扫描未扫描的磁道
cout<<cidao[j]<<" ";
sum=2*cidao[m-1]+cidao[l]-now-2*cidao[0];
}
ave=(float)(sum)/(float)(m);
cout<<endl;
cout<<" 平均寻道长度： "<<ave<<endl;
}

void main()
{
int a;
int c; //菜单项
int cidao[maxsize];
int i=0,count;
char str[100];
cout<<" 请输入磁道序列(输入0完毕): "<<endl;
A:cin>>str; //对输入数据进展有效性判断
a=decide(str);
if(a==0){
cout<<" 输入数据的类型错误,请重新输入！"<<endl;
goto A;//输入错误，跳转到A，重新输入
}
else cidao[i]=trans(str,a);
i++;
while(cidao[i-1]!=0){
cin>>str; //对输入数据进展有效性判断
a=decide(str);
if(a==0) cout<<" 输入数据的类型错误,请重新输入！"<<endl;
else{
cidao[i]=trans(str,a);
i++;
}
}
count=i-1; //要访问的磁道数
cout<<" 输入的磁道序列为：";
for(i=0;i<count;i++) cout<<cidao[i]<<" "; //输出磁道序列
cout<<endl;
while(1){
cout<<endl;
cout<<" -------------------------------------------------------------------------"<<endl;
cout<<"\n 1.先来先效劳 2.最短寻道时间优先 3.扫描调度 4.循环扫描 5.退出 \n"<<endl;
cout<<" -------------------------------------------------------------------------"<<endl;
G:cout<<" 请选择算法: ";
F:cin>>str; //对输入数据进展有效性判断
a=decide(str);
if(a==0){
cout<<" 输入数据的类型错误,请重新输入！"<<endl;
goto F;//输入错误，跳转到F，重新输入
}
else c=trans(str,a);
if(c==5) break;
if(c>5){
cout<<" 输入的数据错误！请重新输入"<<endl;
goto G;
}
switch(c){
case 1: //使用FCFS算法
FCFS(cidao,count);
break;
case 2: //使用SSTF算法
SSTF(cidao,count);
break;
case 3: //使用SCAN算法
SCAN(cidao,count);
break;
case 4: //使用CSCAN算法
CSCAN(cidao,count);
break;
}
}
}
五、 实验结果
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 循环扫描算法运行结果图

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

- word.zl-