操作系统实践报告.docx
《操作系统实践报告.docx》由会员分享，可在线阅读，更多相关《操作系统实践报告.docx（29页珍藏版）》请在冰点文库上搜索。
操作系统实践报告
《计算机操作系统》
课外实践报告
一、实验目标：
使容易使人理解，通过设计一个磁盘调度模拟系统，从而使磁盘调度算法更加形象化，磁盘调度的特点更简单明了，能使使用者加深对先来先服务算法、最短寻道时间优先算法、扫描算法以及循环扫描算法等磁盘调度算法的理解。
二、实验要求
系统主界面可以灵活选择某种算法，算法包括：
先来先服务算法（FCFS）、最短寻道时
。
）、扫描算法（SCAN）、循环扫描算法（CSCAN间优先算法（SSTF）三．实践内容简要描述
1、实践环境
windows2000/xp，visualc6.0
2、算法思路
磁盘设备在工作时以恒定的速率旋转。
为了读或写，磁头必须能移动到所要求的磁道上，并等待所要求的扇区开始位置旋转到磁头下，然后或开始读或写数据。
故可把磁盘访问时间分成以下三部分。
（1）寻道时间Ts
这是把磁头移动到指定磁道上所经历的时间。
该时间是启动磁臂的时间s与磁头移动n条磁道所花费的时间之和，即
Ts=m*n+s
其中，m是一常数，与磁盘驱动器的速度有关。
对于一般磁盘，m=0.2；对于高速磁盘，m<=0.1，磁臂的启动时间+约为2ms。
这样，对于一般的温盘，对于一般的温盘，其寻道时间将随着寻道距离的增加而增大，大体上是5~30ms。
（2）旋转延迟时间Tr
这是指定扇区移动到磁头下面所经历的时间。
不同的磁盘类型中，旋转速度至少相差一个数量级，如软盘为300r/min，硬盘一般为7200~15000r/min，甚至更高。
对于磁盘旋转延迟时间而言，如硬盘，旋转速度为15000r/min，每转需时4ms，平均旋转延迟时间Tr为2ms；而软盘，其旋转速度为300r/min或600r/min，这样，平均Tr为50~100ms。
（3）传输时间Tt
这时指把数据从磁盘读出或向磁盘写入数据所经历的时间。
Tt的大小与每次所读/写的字节数b和旋转速度有关：
Tt=b/（r*N）
其中，r为磁盘每秒钟的转数；N为一条磁道上的字节数，当一次读/写的字节数相当于半条磁道上的字节数时，T3与T2相同。
因此，可将访问时间Ta表示为
Ta=Ts+1/（2*r）+b/（r*N）
由上式可以看出，在访问时间中，寻道时间和旋转延迟时间基本上都与所读/写数据的多少无关，而且它通常占据了访问时间中的大头。
磁盘是可供多个进程共享的设备，当有多个进程都要求访问磁盘时，应采用一种最佳调度算法，以使各进程对磁盘的平均访问时间最小。
由于在访问磁盘的时间中，主要是寻道时间，因此，磁盘调度的目标是使磁盘的平均寻道时间最少。
现在我们考虑平均寻道长度：
所有磁我们需要所以寻道长度决定了寻道时间，道所需移动距离之和除以总的所需访问的磁道数，
从上面的算法中选择最优者。
、算法原理3
磁盘驱动调度算法的好坏直接影响辅助存储器磁盘驱动调度对磁盘的效率有重要影响。
的效率，从而影响计算机系统的整体效率。
常用的磁盘驱动调度算法有：
）法：
这种算法的实质是，总是严格按最简单的磁盘驱动调度算法是先入先出（FIFO不会发生进程饿死时间顺序对磁盘请求予以处理。
算法实现简单、易于理解并且相对公平，现象。
但该算法可能会移动的柱面数较多并且会经常更换移动方向，效率有待提高。
：
总是优先处理最靠近的请求。
该算法移动的柱面距离最短寻找时间优先算法（SSTF）较小，但可能会经常改变移动方向，并且可能会发生进程饥饿现象。
才改变方向继续处理其他请求。
：
电梯调度（SCAN）总是将一个方向上的请求全部处理完后，：
从最外向最里（或从最里向最外）进行柱面请求处理，到最里柱面后，直循环扫描（CSCAN）回来过程不处理请求，接跳到最外柱面然后继续向里进行处理。
该算法与扫描算法的区别是，基于这样的事实，因为里端的请求刚被处理。
4、数据结构利用数组对算法进行处理。
当前磁道号now:
，放置磁道号的数组cidao[]，先来先服务算法voidFCFS（intcidao[],intm），最短寻到时间优先算法voidSSTF（intcidao[],intm），扫描算法voidSCAN（intcidao[],intm），循环扫描算法voidCSCAN（intcidao[],intm）四、算法分析：
）FCFS1）先来先服务算法（（这是一种最简单的磁盘调度算法。
它根据请求访问磁盘的先后次序进行调度。
此算法的优点是公平、简单，且每个进程的请求都能依次地得到处理，不会出现某一进程的请求长期得不到满足的情况。
但是此算法由于未对寻道进行优化，致使平均寻道时间可能较长。
当有进程先后提出磁盘I/O请求时，先按他们发出请求的先后次序排队。
然后依次给予服务。
其平均寻道距离较大，故先来先服务算法仅适用于请求磁盘I/O进程数目较少的场合。
（2）最短寻道时间优先算法（SSTF）
该算法选择这样的进程：
其要求访问的磁道与当前磁头所在的磁道距离最近，以使每次寻道时间最短。
但这种算法不能保证平均寻道时间最短。
有可能导致某个进程出现“饥饿”现象，因为只要不断有新进程请求到达，且其所要访问的磁道与磁头当前所在的磁道的距离较近，这种新进程的I/O请求必然优先满足。
（3）扫描算法（SCAN）
该算法不仅考虑到正欲访问的磁道与当前磁道间的距离，更优先考虑的是磁头当前的移动方向。
例如，当磁头正在自里向外移动时，SCAN算法所考虑的下一个访问对象应该是其欲访问的磁道之外，又是距离最近的。
这样自里向外地访问，直至再无更外的磁道需要访问时，才将磁臂换向为自外向里移动。
这时，同样也是每次选择这样的进程来调度，既要访问的磁道在当前位置内距离最近者，这样，磁头又逐步地从外向里移动，直至再无更里面的磁由于在这种算法中磁头移动的规律颇似电梯的运现象。
从而避免了出现“饥饿”道要访问，
行，因而又常称之为电梯调度算法。
（4）循环扫描算法（CSCAN）
CSCAN算法规定磁头单向移动，例如，只是自里向外移动，当磁头移动到最外的磁道并访问后，磁头立即返回到最里的欲访问的磁道，亦即将最小磁道号紧接着最大的磁道号构成循环，进行循环扫描。
五、系统流程图
FCFS算法（先来先服务）流程图:
输入当前磁道now
磁头移动距
sum=abs（now-cidao[0sum+=abs（cidao[j]-cidao[icidao[j]
目前的位置变为当前的位置j++
j输出平均寻道长度
ave=sum/（m）
SSTF（最短寻道时间优先算法）
算法流程图：
将磁道号从小到大排序
输入当前磁道号now
cidao[m-1]<=now
（cidao[0]输出磁盘调度序列>=now
cidao[j]
输出磁盘调度确定当前磁道在已离总距磁头移动排的序列中的位置序列cidao[j]
sum=now-cidao[i]
目前的位置变为当前磁头移动总距离now-cidao[l]）的位置sum=now-cidao[i]=（cidao[r]-now
目前的位置变为i>=0
当前的位置先向磁道号先向磁道号增加方now=cidao[i]
向访访减小方向问，再向磁道问，再向磁道方向向号方增加号减小i输出磁盘输出磁盘调度序列调度序列输出平均寻道长度ave=sum/（m）
SCAN算法（扫描算法）流程图：
将磁道号从小到大排序
输入当前磁道号now,
移动臂的移动的方向
cidao[m-1]<=now
（cidao[0]离距动总磁头移>=now
sum=now-cidao[i]
确定当前磁道在已离距头移动总磁sum=cidao[i]-now排的序列中的位置输出磁盘调度cidao[j]
序列switch（d输出磁盘调度序列cidao[j]
i>=0
case0:
case1:
移动臂移动臂减向磁道号增加号道向磁i输出磁盘输出磁盘调度序列调度序列输出平均寻道长度ave=sum/（m）
源代码
#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;ifor（j=i+1;j{
if（cidao[i]>cidao[j]）
{
temp=cidao[i];
cidao[i]=cidao[j];
cidao[j]=temp;
}
}
;潣瑵?
排序后的磁盘序列为：
输出排序结果//for（i=0;i{
cout<}
cout<returncidao;
}
/*********************先来先服务调度算法************************/
voidFCFS（intcidao[],intm）//磁道号数组，个数为m
{
intnow;//当前磁道号
intsum=0;//总寻道长度
intj,i;
inta;
charstr[100];
floatave;//平均寻道长度
;
潣瑵?
磁盘请求序列为：
for（i=0;i{
cout<}
cout<潣瑵?
请输入当前的磁道号：
;
B:
cin>>str;//对输入数据进行有效性判断
a=decide（str）;
if（a==0）
{
潣瑵?
输入数据的类型错误,请重新输入！
<gotoB;
}
else
now=trans（str,a）;//输入当前磁道号sum+=abs（cidao[0]-now）;
;
磁盘扫描序列为：
潣瑵?
for（i=0;i{
cout<}
for（i=0,j=1;j{
sum+=abs（cidao[j]-cidao[i]）;
ave=（float）（sum）/（float）（m）;
}
cout<潣瑵?
平均寻道长度：
<}
/**********************最短寻道时间优先调度算法********************/
voidSSTF（intcidao[],intm）
{
intk=1;
intnow,l,r;
inti,j,sum=0;
inta;
charstr[100];
floatave;
cidao=bubble（cidao,m）;//调用冒泡排序算法排序
潣瑵?
请输入当前的磁道号：
;
C:
cin>>str;//对输入数据进行有效性判断
a=decide（str）;
if（a==0）
{
潣瑵?
输入数据的类型错误,请重新输入！
<gotoC;
}
else
输入当前磁道号now=trans（str,a）;//若当前磁道号大于请求序列中最大者，则直接由外向内依次给予各请求服务//if（cidao[m-1]<=now）
{
;磁盘扫描序列为：
潣瑵?
for（i=m-1;i>=0;i--）
cout<sum=now-cidao[0];
}
//若当前磁道号小于请求序列中最小者，则直接由内向外依次给予各请求服务if（cidao[0]>=now）
{
;潣瑵?
磁盘扫描序列为：
for（i=0;icout<sum=cidao[m-1]-now;
}
若当前磁道号大于请求序列中最小者且小于最大者//if（now>cidao[0]&&now{
;
潣瑵?
磁盘扫描序列为：
可以直接复//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<<潣瑵?
}
*************************/扫描调度算法/*************************voidSCAN（intcidao[],intm）//先要给出当前磁道号和移动臂的移动方向{
intk=1;
intnow,l,r,d;
inti,j,sum=0;
inta;
charstr[100];
floatave;
cidao=bubble（cidao,m）;//调用冒泡排序算法排序
潣瑵?
请输入当前的磁道号：
;
D:
cin>>str;//对输入数据进行有效性判断
a=decide（str）;
if（a==0）
{
潣瑵?
输入数据的类型错误,请重新输入！
<gotoD;
}
else
输入当前磁道号//now=trans（str,a）;
//若当前磁道号大于请求序列中最大者，则直接由外向内依次给予各请求服务if（cidao[m-1]<=now）
此情况同最短寻道优先{
;磁盘扫描序列为：
潣瑵?
for（i=m-1;i>=0;i--）
cout<sum=now-cidao[0];
}
此若当前磁道号小于请求序列中最小者，则直接由内向外依次给予各请求服务,if（cidao[0]>=now）//情况同最短寻道优先{
磁盘扫描序列为：
;潣瑵?
for（i=0;icout<sum=cidao[m-1]-now;
}
if（now>cidao[0]&&nowwhile（cidao[k]{
k++;
}
l=k-1;
r=k;
）:
;潣瑵?
请输入当前移动臂的移动的方向（1表示向外，表示向内0
cin>>d;
//选择移动臂方向向内，则先向内扫描if（d==0）
{
;磁盘扫描序列为：
潣瑵?
for（j=l;j>=0;j--）
{
cout<}
for（j=r;j{
cout<}
sum=now-2*cidao[0]+cidao[m-1];
}
else//选择移动臂方向向外，则先向外扫描
{
;磁盘扫描序列为：
潣瑵?
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<潣瑵?
平均寻道长度：
<}
/************************循环扫描调度算法*****************************/
voidCSCAN（intcidao[],intm）
{
intk=1;
intnow,l,r;
inti,j,sum=0;
inta;
charstr[100];
floatave;
cidao=bubble（cidao,m）;//调用冒泡排序算法排序
潣瑵?
请输入当前的磁道号：
;
E:
cin>>str;//对输入数据进行有效性判断
a=decide（str）;
if（a==0）
{
潣瑵?
输入数据的类型错误,请重新输入！
<gotoE;
}
else
now=trans（str,a）;//输入当前磁道号
if（cidao[m-1]<=now）//若当前磁道号大于请求序列中最大者，则直接将移动臂移动到最小号磁道依次向外给予各请求服务
{
潣瑵?
磁盘扫描序列为：
;
for（i=0;icout<sum=now-2*cidao[0]+cidao[m-1];
}
if（cidao[0]>=now）//若当前磁道号小于请求序列中最小者，则直接由内向外依次给予各请求服务,此情况同最短寻道优先
{
潣瑵?
磁盘扫描序列为：
;
for（i=0;icout<sum=cidao[m-1]-now;
}
if（now>cidao[0]&&now{
潣瑵?
磁盘扫描序列为：
;
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<<平均寻道长度：
}
voidmain（）
{
inta;
intc;//菜单项
intcidao[maxsize];
inti=0,count;
charstr[100];
潣瑵?
请输入磁道序列（0结束）：
<A:
cin>>str;//对输入数据进行有效性判断
a=decide（str）;
if（a==0）
{
潣瑵?
输入数据的类型错误,请重新输入！
<gotoA;//输入错误，跳转到A，重新输入
}
else
cidao[i]=trans（str,a）;
i++;
while（cidao[i-1]!
=0）
{
cin>>str;//对输入数据进行有效性判断
a=decide（str）;
if（a==0）
潣瑵?
输入数据的类型错误,请重新输入！
<else
{
cidao[i]=trans（str,a）;
i++;
}
}
count=i-1;//要访问的磁道数
潣瑵?
你输入的磁道序列为：
;
for（i=0;i{
cout<}
cout<while
（1）
{
cout<c
升级会员 