磁盘调度算法Word文档格式.docx
《磁盘调度算法Word文档格式.docx》由会员分享，可在线阅读，更多相关《磁盘调度算法Word文档格式.docx（20页珍藏版）》请在冰豆网上搜索。
此算法基本上克服了最短寻道时间优先算法的服务集中于中间磁道和响应时间变化比较大的缺点，而具有最短寻道时间优先算法的优点即吞吐量较大，平均响应时间较小，但由于是摆动式的扫描方法，两侧磁道被访问的频率仍低于中间磁道。
2、循环扫描算法（CSCAN）
循环扫描算法是对扫描算法的改进。
如果对磁道的访问请求是均匀分布的，当磁头到达磁盘的一端，并反向运动时落在磁头之后的访问请求相对较少。
这是由于这些磁道刚被处理，而磁盘另一端的请求密度相当高，且这些访问请求等待的时间较长，为了解决这种情况，循环扫描算法规定磁头单向移动。
例如，只自里向外移动，当磁头移到最外的被访问磁道时，磁头立即返回到最里的欲访磁道，即将最小磁道号紧接着最大磁道号构成循环，进行扫描。
3模块划分
本系统划分为2个模块：
扫描算法模块voidSCAN（）和循环扫描算法模块：
voidCSCAN（）
1.扫描算法模块：
voidSCAN（）
将磁道号用冒泡法从小到大排序，输出排好序的序列，输入当前磁道号，选择移动臂的移动方向，根据当前磁道在已排的序列中的位置，选择扫描的顺序，求出平均寻道长度，输出移动的平均磁道数。
主要代码：
//=====================排序函数，将各进程申请的磁道按从小到大排列=================
voidSort（）
{
inttemp;
for（inti=N-1;
i>
=0;
i--）
for（intj=0;
j<
i;
j++）
if（SortOrder[j]>
SortOrder[j+1]）
temp=SortOrder[j];
SortOrder[j]=SortOrder[j+1];
SortOrder[j+1]=temp;
}
//=====================SCAN,扫描算法==========================
voidSCAN（）
intm,n,temp;
temp=BeginNum;
Sort（）;
cout<
<
"
请选择开始方向：
1--向外;
0---向里:
"
;
cin>
>
m;
if（m==1）
direction=true;
elseif（m==0）
direction=false;
else
输入错误!
for（inti=0;
i<
N;
i++）
if（SortOrder[i]<
BeginNum）
continue;
n=i;
break;
if（direction==true）
for（inti=n;
MoveDistance[i-n]=abs（SortOrder[i]-temp）;
temp=SortOrder[i];
FindOrder[i-n]=SortOrder[i];
for（intj=n-1;
j>
j--）
MoveDistance[N-1-j]=abs（SortOrder[j]-temp）;
FindOrder[N-1-j]=SortOrder[j];
for（inti=n-1;
MoveDistance[i]=abs（SortOrder[i]-temp）;
FindOrder[n-i-1]=SortOrder[i];
for（intj=n;
MoveDistance[j]=abs（SortOrder[j]-temp）;
temp=TrackOrder[j];
FindOrder[j]=SortOrder[j];
3程序流程图
：
4.1测试数据,
扫描算法
（1）当前磁道号大于磁道序列中的最大的磁道号时
输入磁道序列：
555839189016015038184
当前磁道号：
200
（2）当前磁道号小于磁道序列中的最小的磁道号时
输入磁道序列：
（3）当前磁道号大于磁道序列中的最小的磁道号且小于最大磁道号（磁头向外）时
100
（4）当前磁道号大于磁道序列中的最小的磁道号且小于最大磁道号（磁头向内）时
4.2测试结果,测试抓图
5体会
通过此次课程设计，我对操作系统的基础知识了解得更透彻了，同时对磁盘调度的四种算法——先来先服务算法（FCFS）、最短寻道时间优先算法（SSTF）、扫描算法（SCAN）、循环扫描算法（CSCAN）有了更深刻的理解和掌握，使我能够为磁盘调度选择适当的算法，提高CPU工作效率。
设计过程中遇到的困难在老师和同学的帮助下顺利解决并通过了验收，我深刻认识到算法的逻辑性对程序的重要影响，算法的准确度对程序运行结果的重要影响，这对我以后在操作系统的学习中有极大帮助。
6程序源代码
#include<
iostream>
iomanip>
math.h>
usingnamespacestd;
constintMaxNumber=100;
intTrackOrder[MaxNumber];
intMoveDistance[MaxNumber];
//移动距离
intFindOrder[MaxNumber];
//寻好序列
doubleAverageDistance;
//平均寻道长度
booldirection;
//方向true时为向外，false为向里
intBeginNum;
//开始磁道号
intM=500;
//磁道数
intN;
//提出磁盘I/O申请的进程数
intSortOrder[MaxNumber];
//排序后的序列
boolFinished[MaxNumber];
intDataNum（FILE*）;
structStdudNode
intno;
structStdudNode*next;
};
structStdudNode*head,*thisN,*newN;
//structStdudNode*begin;
voidNewNode（void）
newN=（structStdudNode*）malloc（sizeof（structStdudNode））;
if（head==NULL）
head=newN;
else
{
thisN=head;
while（thisN->
next!
=NULL）
thisN=thisN->
next;
thisN->
next=newN;
}
thisN=newN;
cout<
\nenterno:
endl;
cin>
thisN->
no;
thisN->
next=NULL;
voidInith（）
请输入提出磁盘I/O申请的进程数:
for（inti=0;
NewNode（）;
thisN=head;
for（intq=0;
thisN!
=NULL;
q++）
TrackOrder[q]=thisN->
thisN=thisN->
for（intj=0;
MoveDistance[j]=0;
请输入开始磁道号：
BeginNum;
for（intk=0;
k<
k++）
Finished[k]=false;
for（intl=0;
l<
l++）
SortOrder[l]=TrackOrder[l];
voidFileReader（）
{//从文件读取。
FILE*file;
if（file=fopen（"
7.txt"
"
r"
））{
N=DataNum（file）;
for（inti=0;
fscanf（file,"
%d"
&
TrackOrder[i]）;
for（intj=0;
}else{
cout<
Filenotfound!
intDataNum（FILE*f）
inttemp;
inti=0;
while（!
feof（f））{
fscanf（f,"
temp）;
//cout<
temp<
i++;
fseek（f,0L,0）;
//cout<
returni;
//for（inti=N-1;
//for（intj=0;
N-1;
N-1-i;
if（SortOrder[j]>
{
temp=SortOrder[j];
SortOrder[j]=SortOrder[j+1];
SortOrder[j+1]=temp;
}
intm,n,temp;
temp=BeginNum;
Sort（）;
if（m==1）
direction=true;
elseif（m==0）
direction=false;
if（SortOrder[i]<
continue;
else
n=i;
break;
if（direction==true）
for（inti=n;
MoveDistance[i-n]=abs（SortOrder[i]-temp）;
temp=SortOrder[i];
FindOrder[i-n]=SortOrder[i];
for（intj=n-1;
MoveDistance[N-1-j]=abs（SortOrder[j]-temp）;
temp=SortOrder[j];
FindOrder[N-1-j]=SortOrder[j];
for（inti=n-1;
MoveDistance[n-1-i]=abs（SortOrder[i]-temp）;
FindOrder[n-1-i]=SortOrder[i];
for（intj=n;
MoveDistance[j]=abs（SortOrder[j]-temp）;
FindOrder[j]=SortOrder[j];
//=================CSCAN,循环扫描算法=======================
voidCSCAN（）
for（intj=0;
n;
MoveDistance[N-n+j]=abs（SortOrder[j]-temp）;
FindOrder[N-n+j]=SortOrder[j];
for（intj=N-1;
=n;
MoveDistance[N-j+n-1]=abs（SortOrder[j]-temp）;
FindOrder[N-j+n-1]=SortOrder[j];
//========计算平均寻道时间==============
voidCount（）
intTotal=0;
Total+=MoveDistance[i];
AverageDistance=（（double）Total）/（（double）N）;
voidShow（）
setw（20）<
被访问的下一个磁道号"
移动距离（磁道数）"
setw（15）<
FindOrder[i]<
MoveDistance[i]<
平均寻道长度:
AverageDistance<
intmain（）
inty=1;
ints1,s2;
while（y）
选择读取方式：
1--键盘输入;
2--文件读取:
cin>
s1;
请选择寻道方式：
1--SCAN;
2--CSCSN:
s;
switch（s1）
case1:
Inith（）;
cout<
cin>
s2;
switch（s2）
{
case1:
SCAN（）;
Count（）;
Show（）;
break;
case2:
CSCAN（）;
break;
}
}
//case2:
CSCAN（）;
case2:
FileReader（）;
cout<
cin>
break;
是否继续选择寻道算法？
1--是；
0--否:
intp;
p;
y=p;
//exit（0）;
return0;
升级会员 