操作系统概论作业第三章.docx
《操作系统概论作业第三章.docx》由会员分享，可在线阅读，更多相关《操作系统概论作业第三章.docx（14页珍藏版）》请在冰豆网上搜索。
操作系统概论作业第三章
第3章与存储管理有关的操作系统算法实践作业
#include"stdio.h"
#include"stdlib.h"
voidCopyL（intSour[],intDist[],intx）;//数组Sour复制到数组Dist，复制到x个数
voidSetDI（intDiscL[]）; //随机生成磁道数
voidPrint（intPri[],intx）; //打印输出数组Pri
voidDelInq（intSour[],intx,inty）; //数组Sour把x位置的数删除，并把y前面的数向前移动，y后的数保持不变（即会出现2个y）
voidFCFS（intHan,intDiscL[]）; //先来先服务算法（FCFS）
voidSSTF（intHan,intDiscL[]）; //最短寻道时间优先算法（SSTF）
intSCAN（intHan,intDiscL[],intx,inty）; //扫描算法（SCAN）
voidCSCAN（intHan,intDiscL[]）; //循环扫描算法（CSCAN）
//voidN_Step_SCAN（intHan1,intDiscL[]）; //N步扫描算法（NStepScan）
voidPaiXu（）; //寻道长度由低到高排序
voidPri（）;
intNAll=0;
intBest[5][2];//用作寻道长度由低到高排序时存放的数组
intLimit=0;//输入寻找的范围磁道数i
intJage;
floatAver=0;
intmain（）
{
inti;
intDiscLine[10]; //声明准备要生成的随机磁道号的数组
intHand; //磁道数
intCon=1;
intn;
while（Con==1）
{
Jage=0;
printf（"\n请输入初始的磁道数（0"）;
scanf（"%d",&Hand）;
printf（"\n+输入寻找的范围:
"）;
scanf（"%d",&Limit）;
if（Limit>65536）{
printf（"超出范围!
"）;
}
else{
printf（" *********************************************\n"）;
printf（" ****************磁盘调度算法******************\n"）;
printf（" *********************************************\n"）;
printf（" * 1.先来先服务算法（FCFS） *\n"）;
printf（" * 2.最短寻道时间优先算法（SSTF） *\n"）;
printf（" * 3.扫描算法（SCAN） *\n"）;
printf（" * 4.循环扫描算法（CSCAN） *\n"）;
printf（" *********************************************\n"）;
scanf（"%d",&n）;
if（n==0）exit（0）;
printf（"\n"）;
switch（n）
{
case1:
SetDI（DiscLine）; //随机生成磁道数
FCFS（Hand,DiscLine）;//先来先服务算法（FCFS）
break;
case2:
SetDI（DiscLine）; //随机生成磁道数
SSTF（Hand,DiscLine）;//最短寻道时间优先算法（SSTF）
break;
case3:
SetDI（DiscLine）; //随机生成磁道数
SCAN（Hand,DiscLine,0,9）; //扫描算法（SCAN）
break;
case4:
SetDI（DiscLine）; //随机生成磁道数
CSCAN（Hand,DiscLine）;//循环扫描算法（CSCAN）
break;
case5:
SetDI（DiscLine）; //随机生成磁道数
SetDI（DiscLine）; //随机生成磁道数
FCFS（Hand,DiscLine）;//先来先服务算法（FCFS）
SSTF（Hand,DiscLine）;//最短寻道时间优先算法（SSTF）
SCAN（Hand,DiscLine,0,9）;//扫描算法（SCAN）
CSCAN（Hand,DiscLine）; //循环扫描算法（CSCAN）
PaiXu（）; //寻道长度由低到高排序
printf（"\n\n+寻道长度由低到高排序:
"）;
for（i=0;i<5;i++）
{
printf（"%4d",Best[i][0]）;
}
break;
}
printf（"\n\n+是否继续（按0结束,按1继续）?
"）;
scanf（"%5d",&Con）;
}
}
}
//数组Sour复制到数组Dist，复制到x个数
voidCopyL（intSour[],intDist[],intx）
{
inti;
for（i=0;i<=x;i++）
{
Dist[i]=Sour[i];
}
}
//打印输出数组Pri
voidPrint（intPri[],intx）
{
inti;
for（i=0;i<=x;i++）
{
printf（"%5d",Pri[i]）;
}
}
//随机生成磁道数
voidSetDI（intDiscL[]）
{
inti;
for（i=0;i<=9;i++）
{
DiscL[i]=rand（）%Limit;//随机生成10个磁道号
}
printf（"+需要寻找的磁道号:
"）;
Print（DiscL,9）; //输出随机生成的磁道号
printf（"\n"）;
}
//数组Sour把x位置的数删除，并把y前面的数向前移动，y后的数保持不变（即会出现2个y）
voidDelInq（intSour[],intx,inty）
{
inti;
for（i=x;i {
Sour[i]=Sour[i+1];
x++;
}
}
//先来先服务算法（FCFS）
voidFCFS（intHan,intDiscL[]）
{
intRLine[10]; //将随机生成的磁道数数组Discl[]复制给数组RLine[]
inti,k,All,Temp; //Temp是计算移动的磁道距离的临时变量
All=0; //统计全部的磁道数变量
k=9; //限定10个的磁道数
CopyL（DiscL,RLine,9）; //复制磁道号到临时数组RLine
printf（"\n+按照FCFS算法磁道的访问顺序为:
"）;
All=Han-RLine[0];
for（i=0;i<=9;i++）
{
Temp=RLine[0]-RLine[1];//求出移动磁道数,前一个磁道数减去后一个磁道数得出临时的移动距离
if（Temp<0）
Temp=（-Temp）;//移动磁道数为负数时,算出相反数作为移动磁道数
printf（"%5d",RLine[0]）;
All=Temp+All;//求全部磁道数的总和
DelInq（RLine,0,k）;//每个磁道数向前移动一位
k--;
}
Best[Jage][1]=All;//Best[][1]存放移动磁道数
Best[Jage][0]=1;//Best[][0]存放算法的序号为:
1
Jage++;//排序的序号加1
Aver=（（float）All）/10;//求平均寻道次数
printf（"\n+移动磁道数:
<%5d>",All）;
printf（"\n+平均寻道长度:
*%0.2f*",Aver）;
}
//最短寻道时间优先算法（SSTF）
voidSSTF（intHan,intDiscL[]）
{
inti,j,k,h,All;
intTemp; //Temp是计算移动的磁道距离的临时变量
intRLine[10]; //将随机生成的磁道数数组Discl[]复制给数组RLine[]
intMin;
All=0; //统计全部的磁道数变量
k=9; //限定10个的磁道数
CopyL（DiscL,RLine,9）; //复制磁道号到临时数组RLine
printf（"\n+按照SSTF算法磁道的访问顺序为:
"）;
for（i=0;i<=9;i++）
{
Min=64000;
for（j=0;j<=k;j++）//内循环寻找与当前磁道号最短寻道的时间的磁道号
{
if（RLine[j]>Han） //如果第一个随机生成的磁道号大于当前的磁道号，执行下一句
Temp=RLine[j]-Han; //求出临时的移动距离
else
Temp=Han-RLine[j]; //求出临时的移动距离
if（Temp {
Min=Temp; //Temp临时值赋予Min
h=j; //把最近当前磁道号的数组下标赋予h
}
}
All=All+Min; //统计一共移动的距离
printf（"%5d",RLine[h]）;
Han=RLine[h];
DelInq（RLine,h,k）; //每个磁道数向前移动一位
k--;
}
Best[Jage][1]=All;//Best[][1]存放移动磁道数
Best[Jage][0]=2;//Best[][0]存放算法的序号为:
2
Jage++;//排序序号加1
Aver=（（float）All）/10;//求平均寻道次数
printf（"\n+移动磁道数:
<%5d>",All）;
printf（"\n+平均寻道长度:
*%0.2f*",Aver）;
}
//扫描算法（SCAN）
intSCAN（intHan,intDiscL[],intx,inty）
{
intj,n,k,h,m,All;
intt=0;
intTemp;
intMin;
intRLine[10];//将随机生成的磁道数数组Discl[]复制给数组RLine[]
intOrder;
Order=1;
k=y;
m=2; //控制while语句的执行，即是一定要使当前磁道向内向外都要扫描到
All=0; //统计全部的磁道数变量
CopyL（DiscL,RLine,9）; //复制磁道号到临时数组RLine
printf（"\n+按照SCAN算法磁道的访问顺序为:
"）;
Min=64000;
for（j=x;j<=y;j++） //寻找与当前磁道号最短寻道的时间的磁道号
{
if（RLine[j]>Han） //如果第一个随机生成的磁道号大于当前的磁道号，执行下一句
Temp=RLine[j]-Han; //求出临时的移动距离
else
Temp=Han-RLine[j]; //求出临时的移动距离
if（Temp {
Min=Temp; //Temp临时值赋予Min
h=j; //把最近当前磁道号的数组下标赋予h
}
}
All=All+Min;
printf（"%5d",RLine[h]）;
if（RLine[h]>=Han）{ //判断磁道的移动方向，即是由里向外还是由外向里
Order=0;
t=1;
}
Han=RLine[h];
DelInq（RLine,h,k）; //每个磁道数向前移动一位
k--;
while（m>0）
{
if（Order==1） //order是判断磁盘扫描的方向标签，order是1的话，磁道向内移动
{
for（j=x;j<=y;j++）
{
h=-1;
Min=64000;
for（n=x;n<=k;n++） //判断离当前磁道最近的磁道号
{
if（RLine[n]<=Han）
{
Temp=Han-RLine[n];
if（Temp {
Min=Temp; //Temp临时值赋予Min
h=n; //把最近当前磁道号的数组下标赋予h
}
}
}
if（h!
=-1）
{
All=All+Min; //叠加移动距离
printf（"%5d",RLine[h]）;
Han=RLine[h];//最近的磁道号作为当前磁道
DelInq（RLine,h,k）;
k--;
}
}
Order=0; //当完成向内的移动，order赋予0，执行else语句，使磁道向外移动
m--; //向内完成一次，m减一次，保证while循环执行两次
}
else //order是0的话，磁道向外移动
{
for（j=x;j<=y;j++）
{
h=-1;
Min=64000;
for（n=x;n<=k;n++） //判断离当前磁道最近的磁道号
{
if（RLine[n]>=Han）
{
Temp=RLine[n]-Han;
if（Temp {
Min=Temp; //Temp临时值赋予Min
h=n; //把最近当前磁道号的数组下标赋予h
}
}
}
if（h!
=-1）
{
All=All+Min; //叠加移动距离
printf（"%5d",RLine[h]）;
Han=RLine[h]; //最近的磁道号作为当前磁道
DelInq（RLine,h,k）;
k--;
}
}
Order=1; //当完成向内的移动，order赋予0，执行else语句，使磁道向外移动
m--; //向内完成一次，m减一次，保证while循环执行两次
}
}
NAll=NAll+All;
if（（y-x）>5）
{
Best[Jage][1]=All;//Best[][1]存放移动磁道数
Best[Jage][0]=3;//Best[][0]存放算法的序号为:
3
Jage++;//排序序号加1
Aver=（（float）All）/10;//求平均寻道次数
printf（"\n+移动磁道数:
<%5d>",All）;
printf（"\n+平均寻道长度:
*%0.2f*",Aver）;
}
if（t==1）printf（"\n+磁道由内向外移动"）;
elseprintf（"\n+磁道由外向内移动"）;
return（Han）;
}
//循环扫描算法（CSCAN）
voidCSCAN（intHan,intDiscL[]）
{
intj,h,n,Temp,m,k,All,Last,i;
intRLine[10]; //将随机生成的磁道数数组Discl[]复制给数组RLine[]
intMin;
inttmp=0;
m=2;
k=9;
All=0; //统计全部的磁道数变量
Last=Han;
CopyL（DiscL,RLine,9）; //复制磁道号到临时数组RLine
printf（"\n+按照CSCAN算法磁道的访问顺序为:
"）;
while（k>=0）
{
for（j=0;j<=9;j++） //从当前磁道号开始，由内向外搜索离当前磁道最近的磁道号
{
h=-1;
Min=64000;
for（n=0;n<=k;n++）
{
if（RLine[n]>=Han）
{
Temp=RLine[n]-Han;
if（Temp {
Min=Temp;
h=n;
}
}
}
if（h!
=-1）
{
All=All+Min; //统计一共移动的距离
printf（"%5d",RLine[h]）;
Han=RLine[h];
Last=RLine[h];
DelInq（RLine,h,k）;
k--;
}
}
if（k>=0）
{tmp=RLine[0];
for（i=0;i {
if（tmp>RLine[i]）tmp=RLine[i];
}
Han=tmp;//把最小的磁道号赋给Han
Temp=Last-tmp;//求出最大磁道号和最小磁道号的距离差
All=All+Temp;
}
}
Best[Jage][1]=All;//Best[][1]存放移动磁道数
Best[Jage][0]=4;//Best[][0]存放算法的序号为:
4
Jage++;//排序序号加1
Aver=（（float）All）/10;//求平均寻道次数
printf（"\n+移动磁道数:
<%5d>",All）;
printf（"\n+平均寻道长度:
*%0.2f*",Aver）;
}
voidPaiXu（）
{
inti,j,Temp;
for（i=0;i<5;i++）
{
for（j=0;j<4;j++）
{
if（Best[j][1]>Best[j+1][1]） //如果前一个算法的移动磁道距离大于后一个移动磁道数，执行下面语句
{
Temp=Best[j+1][1]; //从这起下三行执行冒泡法将移动距离大小排序，排完后则执行每个算法的排序
Best[j+1][1]=Best[j][1];
Best[j][1]=Temp;
Temp=Best[j+1][0]; //将每个算法的序号用冒泡法排序
Best[j+1][0]=Best[j][0];
Best[j][0]=Temp;
升级会员 