操作系统实验报告四磁盘调度算法Word格式文档下载.docx

操作系统实验报告四磁盘调度算法Word格式文档下载.docx

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

//----移动距离;

intFindOrder[MaxNumber];

//-----寻好序列。

doubleAverageDistance;

//-----平均寻道长度

booldirection;

//-----方向true时为向外，false为向里

intBeginNum;

//----开始磁道号。

intM;

//----磁道数。

intN;

//-----提出磁盘I/O申请的进程数

intSortOrder[MaxNumber];

//----排序后的序列

boolFinished[MaxNumber];

voidInith（）

{

cout<

<

"

请输入磁道数：

;

cin>

>

M;

请输入提出磁盘I/O申请的进程数:

N;

请依次输入要访问的磁道号：

for（inti=0;

i<

i++）

cin>

TrackOrder[i];

for（intj=0;

j<

j++）

MoveDistance[j]=0;

cout<

请输入开始磁道号：

BeginNum;

for（intk=0;

k<

k++）

Finished[k]=false;

for（intl=0;

l<

l++）

SortOrder[l]=TrackOrder[l];

}

//=====================排序函数，将各进程申请的磁道按从小到大排列=================

voidSort（）

{//------冒泡排序

inttemp;

for（inti=N-1;

i>

=0;

i--）

for（intj=0;

i;

{

if（SortOrder[j]>

SortOrder[j+1]）

{

temp=SortOrder[j];

SortOrder[j]=SortOrder[j+1];

SortOrder[j+1]=temp;

}

}

//========SSTF,最短寻道法=============================

voidSSTF（）

inttemp,n;

intA=M;

temp=BeginNum;

//--------将BeginNum赋给temp作为寻道时的当前所在磁道号

{

j++）//-------寻找最短的寻道长度

if（abs（TrackOrder[j]-temp）<

A&

&

Finished[j]==false）

A=abs（TrackOrder[j]-temp）;

n=j;

elsecontinue;

Finished[n]=true;

//-------将已经寻找到的Finished赋值为true

MoveDistance[i]=A;

//-------寻道长度

temp=TrackOrder[n];

//-------当前寻道号。

A=M;

//-----重置A值

FindOrder[i]=TrackOrder[n];

//----寻好的赋给寻好序列

}

//=====================SCAN,扫描算法==========================

voidSCAN（）

intm,n,temp;

Sort（）;

//------排序

请选择开始方向：

1--向外;

0---向里"

//------选择扫描方向

m;

if（m==1）

direction=true;

elseif（m==0）

direction=false;

else

输入错误"

if（SortOrder[i]<

BeginNum）

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;

j>

j--）

MoveDistance[N-1-j]=abs（SortOrder[j]-temp）;

temp=SortOrder[j];

FindOrder[N-1-j]=SortOrder[j];

else//-------选择向里

for（inti=n-1;

MoveDistance[N-i-4]=abs（SortOrder[i]-temp）;

temp=SortOrder[i];

FindOrder[N-i-4]=SortOrder[i];

for（intj=n;

MoveDistance[j]=abs（SortOrder[j]-temp）;

temp=TrackOrder[j];

FindOrder[j]=SortOrder[j];

//=================CSCAN,循环扫描算法=======================

voidCSCAN（）

if（direction==true）

n;

MoveDistance[N-n+j]=abs（SortOrder[j]-temp）;

FindOrder[N-n+j]=SortOrder[j];

MoveDistance[n-1-i]=abs（SortOrder[i]-temp）;

FindOrder[n-1-i]=SortOrder[i];

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（）

================从"

BeginNum<

号磁道开始====================="

endl;

setw（20）<

被访问的下一个磁道号"

移动距离（磁道数）"

setw（15）<

FindOrder[i]<

MoveDistance[i]<

平均寻道长度:

AverageDistance<

intmain（）

inty=1;

ints;

Inith（）;

while（y）

请选择寻道方式：

1--SSTF;

2--SCAN;

3--CSCSN;

s;

switch（s）

case1:

SSTF（）;

Count（）;

Show（）;

break;

case2:

SCAN（）;

case3:

CSCAN（）;

是否继续选择寻道算法？

1--是；

2--否"

intp;

p;

y=p;

return0;

[实验结果]

[心得体会]

通过模拟常见的几种磁盘寻道算法，通过计算平均寻道的长度，我们可以很直观的了解到不同寻道算法的效率，以加深对最短寻道时间以及电梯等磁盘调度算法的理解。

让我们更好地掌握操作系统的原理及实现方法,加深对操作系统基础理论和重要算法的理解。

而且通过实验操作让我加深了对理论知识掌握。