操作系统实验磁盘调度扫描算法循环扫描算法
操作系统磁盘调度算法实验报告及代码
操作系统磁盘调度算法实验报告及代码一、实验目的通过实验掌握磁盘调度算法的实现过程,了解各种不同磁盘调度算法的特点和优缺点,并比较它们的性能差异。
二、实验原理磁盘调度是操作系统中的重要内容,其主要目的是提高磁盘的利用率和系统的响应速度。
常见的磁盘调度算法有:FCFS(先来先服务)、SSTF (最短寻道时间)、SCAN(扫描)、C-SCAN(循环扫描)等。
三、实验过程1.编写代码实现磁盘调度算法首先,我们需要定义一个磁盘请求队列,其中存放所有的IO请求。
然后,根据所选的磁盘调度算法,实现对磁盘请求队列的处理和IO请求的调度。
最后,展示运行结果。
以FCFS算法为例,伪代码如下所示:```diskQueue = new DiskQueue(; // 创建磁盘请求队列while (!diskQueue.isEmpty()request = diskQueue.dequeue(; // 取出队列头的IO请求//处理IO请求displayResult(; // 展示运行结果```2.运行实验并记录数据为了验证各种磁盘调度算法的性能差异,我们可以模拟不同的场景,例如,随机生成一批磁盘IO请求,并使用不同的磁盘调度算法进行处理。
记录每种算法的平均响应时间、平均等待时间等指标。
3.撰写实验报告根据实验数据和结果,撰写实验报告。
实验报告通常包括以下内容:引言、实验目的、实验原理、实验步骤、实验结果、实验分析、结论等。
四、实验结果与分析使用不同的磁盘调度算法对磁盘IO请求进行处理,得到不同的实验结果。
通过对比这些结果,我们可以看出不同算法对磁盘IO性能的影响。
例如,FCFS算法对于请求队列中的请求没有排序,可能会导致一些请求等待时间过长。
而SSTF算法通过选择离当前磁道最近的请求进行处理,能够减少平均寻道时间,提高磁盘性能。
五、实验总结通过本次实验,我们学习了操作系统中磁盘调度算法的原理和实现过程。
不同的磁盘调度算法具有不同的优缺点,我们需要根据实际情况选择合适的算法。
操作系统课程设计-磁盘调度算法
序止之阳早格格创做纲要:本课程安排的脚段是通过安排一个磁盘调动模拟系统,进而使磁盘调动算法越收局里化,使磁盘调动的特性更简朴明白,那里主要真止磁盘调动的四种算法,分别是:1、先去先服务算法(FCFS)2、最短觅道时间劣先算法(SSTF)3、扫描算法(SCAN)4、循环扫描算法(CSCAN). 开用磁盘真止输进输出支配时,要把移动臂移动到指定的柱里,再等待指定扇区的转动到磁头位子下,而后让指定的磁头举止读写,完毕疑息传递;果此,真止一次输进输出所花的时间有:觅找时间——磁头正在移动臂戴动下移动到指定柱里所花的时间. 延缓时间——指定扇区转动到磁头下所需的时间. 传递时间——由磁头进程读写完毕疑息传递的时间,觅道时间——指估计机正在收出一个觅址下令,到相映目标数据被找到所需时间;其中传递疑息所花的时间,是正在硬件安排时牢固的,而觅找时间战延缓时间是与疑息正在磁盘上的位子有关;而后安排出磁盘调动的安排办法,包罗算法思路、步调,以及要用到的主要数据结构、函数模块及其之间的调用关系等,并给出仔细的算法安排,对付编码举止了尝试与分解. 末尾举止部分归纳与安排体验.关键词汇:最短觅道时间劣先算法、扫描算法、总觅道少度.目录前止22. 课程安排任务及央供42.1 安排任务42.2 安排央供43. 算法及数据结构53.1算法的总体思维(过程)53.2 真止历程中用到的数据结构63.3 真止历程中用到的系统调用114. 步调安排与真止114.1 最短觅道时间劣先算法(SSTF)模块114.1.2 步调证明134.1.3 步调关键代码134.2扫描算法(SCAN)模块144.2.1 步调过程图144.2.2 步调证明164.2.3 步调关键代码164.3 真验截止175. 论断266. 参照文献267. 支获、体验战提议272. 课程安排任务及央供2.1 安排任务1.认识并掌握磁盘调动算法管制系统的安排要领,加强对付所教百般调动算法及相映算法的特性相识.2.掌握磁盘调动的基础观念,深刻体验各个算法的劣缺面,以及算法间的相似面.2.2 安排央供1)定义与算法相关的数据结构,如PCB、行列等;2)真止2种分歧的调动算法(可使用真代码大概过程图举止分解);3)算法真止中断时,应给出总的觅道少度;4)磁道考察序列随机死成,且要谦脚一定的数量央供(很多于100个);5)系统真止必须提供一定的接互性,所需尝试数据应当以文献形式提供大概者由用户正在尝试历程中给出,不可将尝试数据“写死”正在系统真止代码中;6)必须给出脚够的注释,注释量不得少于代码量的一半;7)对付于系统中所使用到的系统调用(API函数),必须给出函数的定义本型、使用要领,参数较为搀纯的,还该当给出参数的简曲形貌;3. 算法及数据结构3.1算法的总体思维(过程)图a SSTF 调动算法示例图用冒泡法对付磁道数组举止排序 返回内侧(中侧)扫描 图b SSTF 算法过程示例图 本磁道号随机组成的数组:cidao[]={55,58,39,18,90,160,150,38,184}; 排序后的数组={18,38,39,5,58,90,150,160,184};输进目前磁道号:now=100;ciidao[]={55,58,39,18,90,160,150,38,184}(可随机死成多个)用户输进目前磁道号now ,比较目前磁道到每个磁道的移动距离,采用最短距离的磁道举止移动.now 指背目前磁道号,将目前磁道号与结余不考察的磁道号举止比较,沉复上述支配.并估计仄衡觅道少度ave.3839 3955 55 5558 58 58 5890 90 90 90 90now值:100 90 58 55 39184160 160150 150 15018 18 18 1838 38 38 3839 39 39 3955 55 55 5558 58 58 5890 90 90 90now值:18 150 160 184图c SSTF算法行列示企图(按磁道考察程序)2.扫描(SCAN)算法图d SCAN算法示例图本磁道号随机组成的数组:cidao[]={55,58,39,18,90,160,150,38,184};排序后的数组={18,38,39,5,58,90,150,160,184};输进目前磁道号:now=100;采用磁道移动目标;以磁道号减少的目标移动为例:5558 5890 90 90184 184 184 184160 160 160 160 160150 150 150 150 150 150now值:100 150 160 184 90 581838 3839 39 3955 55 5558 58 5890 90 90184 184 184160 160 160150 150 150now值:55 39 38图e SCAN算法行列示企图(按磁道考察程序)3.3 真止历程中用到的系统调用系统模块调用关系图4.4.14.1.2①最短②100号柱里上真的柱里为90真止支配的序次时,读写磁头总合移动多个柱里的距离,与先去先服务、算法比较,大幅度天缩小了觅找时间,具备更佳的觅道本能,果而支缩了为各考察者哀供服务的仄衡时间,也便普及了系统效用.但是最短查找时间劣先(SSTF)调动,FCFS 会引起读写头正在盘里上的大范畴移动,SSTF查找距离磁头最短(也便是查找时间最短)的哀供动做下一次服务的对付象.SSTF查找模式有下度局部化的倾背,会推早一些哀供的服务,以至引起无限缓慢(又称饥饥).算法过程:输进磁头初初磁道号,序列少度,磁道号序列.采用磁盘调动算法(最短觅道时间劣先调动(SSTF))大概(扫描调动算法(SCAN))中的任性一个,若采用SSTF,则输出各进程被调动的程序,并估计总的觅道少度战仄衡觅道少度,采用关关则中断磁盘调动.4.1.3 步调关键代码for(i=0;i<m;i++)/*使用冒泡法按从小到大程序排列*/for(j=i+1;j<m;j++){if(array[i]>array[j]){temp=array[i];array[i]=array[j];array[j]=temp;}}if(array[m-1]<=now) /*若目前磁道号大于哀供序列中最大者,则间接由中背内依次赋予各哀供服务*/ {for(i=m-1;i>=0;i--)cout<<array[i]<<" ";sum=now-array[0];}elseif(array[0]>=now) /*若目前磁道号小于哀供序列中最小者,则间接由内背中依次赋予各哀供服务*/ while((l>=0)&&(r<m)) /*目前磁道正在哀供序列范畴内*/{if((now-array[l])<=(array[r]-now)) /*采用与目前磁道迩去的哀供赋予服务*/{cout<<array[l]<<" ";sum+=now-array[l];now=array[l];l=l-1;}扫描算法(SCAN )模块4.2.1 步调过程图4.2.2 ①消了SSTF ②SCAN 法.3位搭客弛10层;弛二正在55.那里是:100号柱里的③SCAN 4.2.3 if {for {cout<<array[j]<<" "; /*输出背内扫描的序列*/}for(j=r;j<m;j++) /*磁头移动到最小号,则改变目标背中扫描已扫描的磁道*/{cout<<array[j]<<" "; /*输出背中扫描的序列*/}sum=now-2*array[0]+array[m-1];}else/*采用移动臂目标背中,则先背中扫描*/{for(j=r;j<m;j++){cout<<array[j]<<" "; /*输出背中扫描的序列*/}for(j=l;j>=0;j--) /*磁头移动到最大号,则改变目标背内扫描已扫描的磁道*/{cout<<array[j]<<" ";}sum=-now-array[0]+2*array[m-1];}ave=(float)(sum)/(float)(m);4.3真验截止运止界里截图及相映代码1.主界里void display(){cout<<"\n\n\n\n Operating Systems Curriculum Design\n";cout<<"\n ╔———————————————————————————————╗"; cout<<"\n ││";cout<<"\n │称呼: 磁盘调动│"; cout<<"\n ││";cout<<"\n │工具: Visual Studio 2010 │"; cout<<"\n ││";cout<<"\n │班级:1205 │"; cout<<"\n ││";cout<<"\n │做家:施静│"; cout<<"\n ││";cout<<"\n │教号:211214020 │"; cout<<"\n ││";cout<<"\n ╚———————————————————————————————╝\n"; system("pause");system("cls");2.序止提示用户此步调真止的算法cout<<"【载进完毕】"<<endl<<endl;cout<<" 序止"<<endl<<endl;cout<<" 欢迎使用『磁盘调动算法系统』,本步调真止了时常使用的磁盘调动算法如下所示:\n\n";cout<<" ①最短觅道时间劣先(SSTF):最短觅道时间劣先算法央供考察的磁盘与目前磁头天圆的\n";cout<<" 磁盘距离迩去,以使屡屡的觅道时间最短.\n\n";cout<<" ②扫描算法(SCAN)电梯调动:扫描算法不但是思量到欲考察的磁道与目前磁道的距离\n";cout<<" 更劣先思量的是磁头的目前移动目标.\n\n";system("pause");system("cls");//浑屏3.用户采用所使用的算法(先随机死成101个磁道号)void showMenu(int cidao[],int n){int choice;while(true){cout<<"请您采用喜欢的算法去真止调动(输进1-3):";cout<<"\n ╔—————————————╗"; cout<<"\n ││";cout<<"\n │ 1.最短觅道时间劣先(SSTF) |"; cout<<"\n ││";cout<<"\n │ 2.扫描算法(SCAN) │"; cout<<"\n ││";cout<<"\n │ 3.退出(EXIT) │"; cout<<"\n ││";cout<<"\n ╚—————————————╝\n"; cout<<endl;while(true){cout<<"目前您采用的算法号是(1-3):";cin>>choice;switch(choice){ /*case 1:FCFS(a,n);break;*/case 1:SSTF(cidao,n);break;case 2:SCAN(cidao,n);break;case 3:cout<<"\n要退出系统了欢迎使用本系统\n";exit(0);}}}}4.最短觅道时间劣先算法/**********************最短觅道时间劣先调动算法********************/ void SSTF(int cidao[],int m){system("cls");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;}elsenow=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<<"总的觅道少度: "<<sum<<endl;cout<<"仄衡觅道少度: "<<ave<<endl;cout<<"请按任性键返回系统菜单"<<endl;getch();showMenu(cidao,m); //回到主界里}最短觅道时间劣先(SSTF)算法真止界里(2)扫描(SCAN)算法/*****************************扫描调动算法*******************************/ void SCAN(int cidao[],int n)//先要给出目前磁道号战移动臂的移动目标{int temp;int i,j;int now;int sum;for(i=0;i<n;i++) //给磁道号排序for(j=i+1;j<n;j++){if(cidao[i]>cidao[j]){temp=cidao[i];cidao[i]=cidao[j];cidao[j]=temp;}}cout<<"\n按非递减程序排列佳的磁道: \n";for(i=0;i<n;i++) //输出排佳序的磁道号cout<<cidao[i]<<" ";cout<<endl;cout<<"\n请输进目前的磁道号: ";cin>>now; //用户自定义目前磁道号if(cidao[n-1]<=now){for(i=n-1;i>=0;i--)cout<<cidao[i]<<" ";sum=now-cidao[0];}else//cidao[n-1]>nowif(cidao[0]>=now){for(i=0;i<n;i++)cout<<cidao[i]<<" ";sum=cidao[n-1]-now;}else//cidao[0]<now && cidao[n-1]>now{int pointer;int location=1;int left,right;while(cidao[location]<now)location++;left=location-1;right=location;cout<<"\n请输进目前磁头念要移动的目标(1 磁道号减少目标,0 磁道号减小目标): "; loop:cin>>pointer;cout<<"\n磁盘调动程序为: \n";if(pointer==0 || pointer==1){if(pointer==0)//磁头背左移动到最小号,再改变目标背中扫描已扫描的磁道{for(j=left;j>=0;j--)cout<<cidao[j]<<" ";for(j=right;j<n;j++)cout<<cidao[j]<<" ";sum=now+cidao[n-1]-2*cidao[0];cout<<endl;}if(pointer==1)//磁头背左移动到最大号,再改变目标背内扫描已扫描的磁道{for(j=right;j<n;j++)cout<<cidao[j]<<" ";for(j=left;j>=0;j--)cout<<cidao[j]<<" ";sum=2*cidao[n-1]-now-cidao[0];//供总觅道少度cout<<endl;}}else{cout<<"\n输进分歧法!!请输进0大概1:\n"; goto loop;}}cout<<"\n\n需要移动的总磁道数为: "<<sum<<endl; cout<<"请按任性键返回系统菜单"<<endl;getch();showMenu(cidao,n); //回到主界里5.论断(1)用户界里友佳,采与了采用菜单模式,用户只需按“回车键”即可再现主界里;结构浑晰,支配简朴易懂,界里浑爽整净;(2)统制变量对付比,各磁盘调动算法均对付共一组随机磁道号举止调动,但是本去不会改变随机磁道真质,包管了仄衡觅道少度对付比的真正在性、灵验性. (3)百般算法皆有便宜,也各有缺累,需要权衡利弊,使用才搞达到最佳的效验.6.参照文献《估计机支配系统(建订版)》汤子瀛西安电子科技大教出版社《支配系统教程》圆敏编西安电子科技大教出版社《数据结构(C++版)》王白梅、胡明、王涛编著浑华大教出版社7.支获、体验战提议正在搞本次课程安排之前,对付于磁盘调动,尔真足不观念.通过齐力以及分离教授之前道的真质,尔毕竟深刻明白了磁盘调动算法的内涵.正在钻研自己所选的二种算法的共时,对付磁盘调动的四种算法——先去先服务算法(FCFS)、最短觅道时间劣先算法(SSTF)、扫描算法(SCAN)、循环扫描算法(CSCAN)皆有了更深刻的明白战掌握,使尔不妨为磁盘调动采用适合的算法,普及CPU处事效用.安排历程中逢到的艰易正在教授战共教的助闲下乐成办理并通过了查支,尔深刻认识到算法的逻辑性对付步调的要害做用,算法的准确度对付步调运止截止的要害做用,那对付尔以去正在支配系统的教习中有极大助闲.每一次的课程安排皆是对付自己之前所教知识的加强,是一次罕见的教习机会.正在课程安排的每一个步调、每一段代码的真止,皆要反复去斟酌,反复运止调试,一面面的小偏偏好皆市引导波折.果为乐成阻挡易,所以当调试板上隐现“死成乐成”时,谦背的成便感是不问可知的.通过自己的动脚动脑,不但是减少了知识,还给了尔博业知识以及博业技能上的提下,对付普及自己的思维本领战支配本领也有很大的助闲.共时尔也会越收有自疑心,越收齐力,严肃教习,争与正在以去的课程中搞得更佳!。
C语言 磁盘调度算法 (FCFS SSTF SCAN CSCAN)
1.FCFS算法实现
2.SSTF算法实现
3.SCAN算法实现
4.CSCAN算法
5.显示对比表
=================================
【实验要求】可选编程语言:C/C++/Java/C#/Python;
实现在同一个程序文件中(C/C++);
请适当注释;
报告正文(运行屏幕截图及源代码)
{
sum += abs(track[i] - adress);
adress = track[i];
}
return sum;
}
int Get_SSTF_index(int t, int *flag)
{
int i, f = 0, min = 10000, juli = 0, l;
for(i = 0; i < 9; i++)
{
juli = abs(track[i] - t);
if(juli > 0 && juli < min && flag[i] ==0)
{
min = juli;
f = i;
}
}
return f;
}
bool IsEmpty(int *flag)
{
int i = 0;
for(i = 0; i < 9; i++)
一.截屏。
2.附录。
#include<stdio.h>
#include<Math.h>
static int track[9] = {55, 58, 39, 18, 90, 160, 150, 38, 184};
操作系统实验磁盘调度扫描算法循环扫描算法
学号P1514032专业计算机迷信与技术姓名之袁州冬雪创作实验陈述【实验称号】磁盘调度(二)【实验目标】磁盘调度中寻道时间直接影响到数据访问的快慢,处理好磁盘寻道时间是关键.分别采取扫描战略、循环扫描战略处理.【实验原理】1. 扫描算法(SCAN算法)SCAN算法,也就是很形象的电梯调度算法.先依照一个方向(比方从外向内扫描),扫描的过程中依次调度颠末的磁道.当扫描到最里层的一个磁道时反向扫描直至所有磁道都被调度.2.循环扫描算法(CSCAN算法)CSCAN算法,循环扫描算法,它的思想是,访问完最外面一个要求服务的序列之后,从最外层的序号开端往里走.也就是始终坚持一个方向,故称为循环扫描算法.【数据布局和符号说明】(1)数据布局和符号说明编译语言:C++数据布局:布局体数组符号定义:typedefstruct Track//磁道布局体{int id;//磁道序列int state=0;//是否访问过,未被访问置状态为0} Track;Track track[N];//最大磁道数为100Track track1[N];//复制的磁道数组用于输出int step[N];//移动间隔int num,i,current_track,num1; //当前磁道即部分中间变量函数说明:void init()//初始化程序void input()//输入函数void sort1()//从小到大排序int abs(inta,int b)//相减的相对值intfind_first_bignum()//寻找第一个最大值intfind_first_smallnum()//寻找第一个最小值void SCAN(intup_or_down)//扫描算法void CSCAN(intup_or_down)//循环扫描算法void output(Track a[])//输出函数void output_average_track()//输出平均寻道时间int show()//显示用户界面//返回值为输入的选择项流程图:SCAN算法:CSCAN算法(与SCAN算法基本近似):代码:#include<stdio.h>#define N 100typedefstruct Track{int id;//磁道序列int state=0;//是否访问过,未被访问置状态为0 } Track;Track track[N];//最大磁道数为100Track track1[N];int step[N];//移动间隔int num,i,current_track,num1;void init()//初始化程序{num=0;for (i=0; i<num; i++){track[i].state=-1;//id置为1track1[i].state=-1;step[i]=-1;//移动间隔为-1}}void input()//输入函数{printf("输入当前磁道\n");scanf("%d",¤t_track);num1=current_track;printf("输入要访问的磁道数目\n");scanf("%d",&num);printf("输入要访问磁道序列\n");for(i=0; i<num; i++)scanf("%d",&track[i].id);}void FCFS()//先来先服务{for(i=0; i<num; i++){if((current_track-track[i].id)<0)//求移动间隔step[i]=track[i].id-current_track;elsestep[i]=current_track-track[i].id;//取相对值track[i].state=1;//状态置为1current_track=track[i].id;//更新当前磁道}}int abs(inta,int b)//相减的相对值{return a-b>0?a-b:b-a;}intSerch_min_pos()//寻找到当前磁道最短的需求磁道{int min=45536;//最小间隔标记intpos;for(inti=0; i<num; i++)if(track[i].state==1)continue;elseif(min>abs(track[i].id,current_track))//寻找最小间隔{min=abs(track[i].id,current_track);pos=i;}track[pos].state=1;return pos;//返回在数组中的位置}void SSTF()//最短寻道优先{for(i=0; i<num; i++)//计数器{track1[i]=track[Serch_min_pos()];//更新到要输出的数组中step[i]=abs(track1[i].id,current_track);//移动间隔current_track= track1[i].id;//标记}}void output(Track a[])//输出函数{printf("\n\n <从%d号磁道开端>\n",num1);printf("=========================================== =======\n");//排班printf("被访问的下一个磁道\t\t移动间隔(磁道数)\n"); for(i=0; i<num; i++)printf("\t%4d\t\t||\t%4d\n",a[i].id,step[i]);printf("=========================================== =======\n");}void output_average_track()//输出平均寻道时间{double sum=0;//和for(i=0; i<num; i++)sum+=step[i];printf(" 平均寻道长度%3.2f\n\n\n",sum/num);//输出}int show()//显示用户界面{int choose;//选择printf("\n******************早期的磁盘调度算法******************\n");printf("\t\t1、先来先服务(FCFS)\n");printf("\t\t2、最短寻道时间优先(SSTF)\n");printf("\t\t3、退出(EXIT)\n");scanf("%d",&choose);return choose;}int main(){do{init();switch(show())//返回值是选择 {case 1://FCFSinput();FCFS();output(track);output_average_track();break;case 2://最短寻道input();SSTF();output(track1);output_average_track();break;case 3://退出return 0;default:break;}}while(1);return 0;}截图:主界面开端,输入选择先来先服务还是最短寻道优先,输入当前磁道,输入要访问的磁道,输入要访问的磁道序列. SCAN算法输入当前磁道100 ,9个磁道,分别为55 58 39 18 90 160 150 38 184,此时选择方向向上成果正确.输入当前磁道100 ,9个磁道,分别为55 58 39 18 90 160 150 38 184,此时选择方向向下成果正确.CSCAN算法输入当前磁道100 ,9个磁道,分别为55 58 39 18 90 160 150 38 184,此时选择方向向上成果正确.输入当前磁道100 ,9个磁道,分别为55 58 39 18 90 160 150 38 184,此时选择方向向上成果正确.【小结与讨论】1、扫描算法又称为电梯算法,其原理与电梯运行情况相似,即运行方向上的请求优先,若是访问方向向上,则先依次访问较大的磁道号至顶,再向下访问娇小的磁道号;若是访问方向向下,则先依次访问较小的磁道号至底,再向上访问娇大的磁道号.2、循环扫描算法又称为单向电梯算法,若是访问方向向上,则向上依次访问完较大的磁道号后,返回最低端,依次向上访问较小的磁道号;若是访问方向向下,则向下依次访问完较小的磁道号后,返回最顶端,依次向下访问较大的磁道号.3、此次实验我用两个数组分别存放了一个磁道表和复制的磁道表,根据两个算法的原理,只要将其停止排序,然后分别对两个数组停止正向和逆向的访问即可.4、详细实现时,我将两种算法的两种初始扫描方向写在了一个函数之中,调用时通过参数scan和参数up_or_down设置.并设置了寻找大于当前数组的最近最小值和最近的大值停止选择成果,这是因为初始磁道号将磁道数组分成上下(高低地址)两块,这两块根据分歧的扫描方向重新选择高低地址,又连系分歧的算法决议正序摆列还是反序摆列.实现起来还是比较简单的.5、由于CSCAN算法的思想是,访问完最外面一个要求服务的序列之后,从最外层的序号开端往里走.也就是始终坚持一个方向.所以如果用循环队列实现,时间复杂度会更低,效率更高.6、此次实验虽然较为简单,但还是发现了自己知识点有些方面的缺乏,让我更好的懂得了磁盘调度的原理,使我收获颇多.。
磁盘寻道算法 实验报告
操作系统实验报告四[实验题目]磁盘调度算法SSTF、SCAN、C-SCAN[实验目的]通过设计一个磁盘调度模拟系统,从而使磁盘调度算法更加形象化,容易理解,使磁盘调度的特点更简单明了,能使使用者加深对最短寻道时间优先算法、扫描算法以及循环扫描算法的理解。
[实验内容]编程实现如下内容:1. 最短寻道时间优先算法(SSTF);2. 扫描算法(SCAN)(又叫电梯调度算法);3. 循环扫描算法(CSCAN)代码如下:#define _CRT_SECURE_NO_WARNINGS#include<stdio.h>#include<stdlib.h>#include<time.h>#include<Windows.h>/*最短寻道时间函数SSTF*/void SSTF(int a[], int n){int temp;int now;int sum = 0, i, j, k=0;//冒泡排序法对磁道号进行排序printf("排序后的磁道分布:\n");for (i = 0; i < n; i++){for (j = i + 1; j < n; j++){if (a[i]>a[j]){temp = a[i];a[i] = a[j];a[j] = temp;}}printf("%d \t", a[i]);if (i % 10 == 9){printf("\n");}}printf("\n");printf("请输入当前磁道号:\n");scanf("%d", &now);if (a[0] >=now){printf("当前访问的磁道%d\n", a[0]);for (i = 0; i < n-1; i++){printf("当前访问的磁道:\t%d\n",a[i+1]);}sum = a[n - 1] - now;printf("移动的总磁道数:%d\n", sum);}else if (a[n - 1] <= now){printf("当前访问的磁道:%d\n", a[n-1]);for (j=n-1; i<n-1;j--){printf("当前访问的磁道:\t%d\n",a[j-1]);}sum = now-a[0];printf("移动的总磁道数:%d\n", sum);}else{while (a[k] < now){k++;}j = k-1;i = 0;while ((j>=0)&&(k<n)){i++;if (now - a[j] >= a[k] - now){printf("当前访问的磁道:\t%d\n", a[k]);sum += a[k] - now;now = a[k];k++;}else{printf("当前访问的磁道:\t%d\n", a[j]);sum += now - a[j];now = a[j];j--;}}if (k > n-1){for (int t = j; t > 0; t--){i++;if (t == j){printf("当前访问的磁道:\t%d\n",a[j]);}else{printf("当前访问的磁道:\t%d\n", a[t+1]); }}sum += a[n - 1] - a[0];}if (j <0){for (int t = k; t < n; t++){i++;if (t == k){printf("当前访问的磁道:\t%d\n",a[k]);}else{printf("当前访问的磁道:\t%d\n",a[t]);}}sum += a[n - 1] - a[0];}}printf("经过的总磁道数为:%d\n", sum);printf("移动的平均磁道数:%.2lf\n", 1.0*sum / n);printf("请再次输入你想使用的方法:\n");}/*扫描算法*/void SCAN(int a[], int n){int temp;int now;int sum = 0, i, j, k = 0;//冒泡排序法对磁道号进行排序printf("排序后的磁道分布:\n");for (i = 0; i < n; i++){for (j = i + 1; j < n; j++){if (a[i]>a[j]){temp = a[i];a[i] = a[j];a[j] = temp;}}printf("%d \t", a[i]);if (i % 10 == 9){printf("\n");}}printf("\n请输入当前磁道号:\n");scanf("%d", &now);if (a[0] >= now){printf("当前访问的磁道:%d\n", a[0]);for (i = 0; i < n - 1; i++){printf("当前访问的磁道:\t%d\n", a[i + 1]);}sum = a[n - 1] - now;printf("移动的总磁道数:%d\n", sum);}else if (a[n - 1] <= now){printf("当前访问的磁道:%d\n", a[n - 1]);for ( j = n - 1; i<n - 1; j--){printf("当前访问的磁道:\t%d\n", a[j - 1]);}sum = now - a[0];printf("移动的总磁道数:%d\n", sum);}else{int d;while (a[k] < now){k++;}j = k - 1;printf("请输入当前磁头移动的方向(0向内,1向外):\n"); scanf("%d", &d);if (d == 1){for (int t = k; t < n; t++){printf("当前访问的磁道:\t%d\n",a[t]);sum += a[t] - now;now = a[t];}for (int t = j; t >=0; t--){printf("当前访问的磁道:\t%d\n",a[t]);}sum += a[n - 1] - a[0];}else if (d == 0){for (int t = j; t >= 0; t--){printf("当前访问的磁道:\t%d\n", a[t]);sum += now - a[t];now = a[t];}for (int t = k; t < n; t++){printf("当前访问的磁道:\t%d\n",a[t]); }sum += a[n - 1] - a[0];}else{printf("输入错误,重新回到选择算法界面!\n"); }}printf("经过的总磁道数为:%d\n", sum);printf("移动的平均磁道数:%.2lf\n", 1.0*sum/n);printf("请再次输入你想使用的方法:\n");}/*循环扫描算法*/void CSCAN(int a[], int n){int temp;int now;int sum = 0, i, j, k = 0;//冒泡排序法对磁道号进行排序printf("排序后的磁道分布:\n");for (i = 0; i < n; i++){for (j = i + 1; j < n; j++){if (a[i]>a[j]){temp = a[i];a[i] = a[j];a[j] = temp;}}printf("%d \t", a[i]);if (i % 10 == 9){printf("\n");}}printf("\n请输入当前磁道号:\n");scanf("%d", &now);if (a[0] >= now){printf("当前访问的磁道:%d\n", a[0]);for (i = 0; i < n - 1; i++){printf("当前访问的磁道:\t%d\n", a[i + 1]);}sum = a[n - 1] - now;printf("移动的总磁道数:%d\n", sum);}else if (a[n - 1] <= now){printf("当前访问的磁道:%d\n", a[n - 1]);for ( j = n - 1; i>=0; j--){printf("当前访问的磁道:\t%d\n",a[j - 1]);}sum = now - a[0];printf("移动的总磁道数:%d\n", sum);}else{int d;while (a[k] < now){k++;}j = k - 1;printf("请输入当前磁头移动的方向(0向内,1向外):\n"); scanf("%d", &d);if (d == 1){int i = 0;for (int t = k; t < n; t++){printf("当前访问的磁道:\t%d\n", a[t]);sum += a[t] - now;now = a[t];}for (int t = 0; t < k; t++){printf("当前访问的磁道:\t%d\n", a[t]); }sum += a[n-1] - a[0]+a[j]-a[0];}else if (d == 0){for (int t = j; t >= 0; t--){printf("当前访问的磁道:\t%d\n", a[t]); sum += now - a[t];now = a[t];}for (int t = n-1; t >=k; t--){printf("当前访问的磁道:\t%d\n", a[t]); }sum += a[n - 1] - a[0]+a[n-1]-a[k];}else{printf("输入错误,重新回到选择算法界面!\n"); }}printf("经过的总磁道数为:%d\n", sum);printf("移动的平均磁道数:%.2lf\n", 1.0*sum / n); printf("请再次输入你想使用的方法:\n");}/* 主函数*/int main(){int n;//磁道数int control=1;//控制处理的方式printf("请输入要处理的磁道数:\n");scanf("%d",&n);int c[1000];printf("随机生成磁道号:\n");srand((unsigned)time(NULL));//srand((unsigned)time(NULL));for (int i = 0; i < n; i++){c[i] = (rand() % 100) + 1;printf("%d \t", c[i]);if (i % 10 ==9){printf("\n");}}printf("\n 数据生成成功!\n");printf("\n");printf("算法选择\n");printf("2.最短寻道时间算法\n");printf("3.扫描算法\n");printf("4.循环扫描算法\n");printf("0.退出程序\n");printf("\n");/*算法选择*/printf("请输入你想使用的方法:\n");while (control){scanf("%d", &control);switch (control){case 0:break;case 2:SSTF(c, n);break;case 3:SCAN(c, n);break;case 4:CSCAN(c, n);break;default:printf("选项错误!重新选择!"); break;}}printf("程序退出成功,谢谢使用!");system("pause");return 0;}[实验结果][心得体会]通过本次试验,我清楚的理解到了磁盘扫描算法;最短寻道算法、循环算法、扫描算法。
操作系统有哪些主要调度算法
操作系统有哪些主要调度算法操作系统调度算法一、磁盘调度1.先来先服务fcfs:是按请求访问者的先后次序启动磁盘驱动器,而不考虑它们要访问的物理位置2.最短一般说来时间优先sstf:使距当前磁道最近的命令访问者启动磁盘驱动器,即是使查找时间最短的那个作业先继续执行,而不考量命令访问者到来的先后次序,这样就消除了先来先服务调度算法中磁臂移动过小的问题3.扫描算法scan或电梯调度算法:总是从磁臂当前位置开始,沿磁臂的移动方向去选择离当前磁臂最近的那个柱面的访问者。
如果沿磁臂的方向无请求访问时,就改变磁臂的移动方向。
在这种调度方法下磁臂的移动类似于电梯的调度,所以它也称为电梯调度算法。
4.循环读取算法cscan:循环读取调度算法就是在读取算法的基础上改良的。
磁臂改成单项移动,由外向里。
当前边线已经开始沿磁臂的移动方向回去挑选距当前磁臂最近的哪个柱面的访问者。
如果沿磁臂的方向并无命令出访时,再返回最外,出访柱面号最轻的作业命令。
操作系统调度算法二、进程调度算法1.先进先出算法fifo:按照进程步入准备就绪队列的先后次序去挑选。
即为每当步入进程调度,总是把准备就绪队列的队首进程资金投入运转。
2.时间片轮转算法rr:分时系统的一种调度算法。
轮转的基本思想是,将cpu的处理时间划分成一个个的时间片,就绪队列中的进程轮流运行一个时间片。
当时间片结束时,就强迫进程让出cpu,该进程进入就绪队列,等待下一次调度,同时,进程调度又去选择就绪队列中的一个进程,分配给它一个时间片,以投入运行。
3.最低优先级算法hpf:进程调度每次将处理机分配给具备最低优先级的准备就绪进程。
最低优先级算法可以与相同的cpu方式融合构成可以抢占市场式最低优先级算法和不容抢占市场式最低优先级算法。
4.多级队列反馈法:几种调度算法的结合形式多级队列方式。
操作系统调度算法三、常用的批处理作业调度算法1.先来先服务调度算法fcfs:就是按照各个作业进入系统的自然次序来调度作业。
磁盘扫描算法实验报告
一、实验目的1. 了解磁盘调度算法的基本原理和分类。
2. 掌握磁盘扫描算法(SCAN)和循环扫描算法(CSCAN)的实现方法。
3. 通过实验验证两种算法的效率和适用场景。
二、实验内容1. 实验环境:Windows操作系统,C++编程语言,Qt开发环境。
2. 实验任务:实现磁盘扫描算法(SCAN)和循环扫描算法(CSCAN),模拟磁盘调度过程,并对比两种算法的效率和适用场景。
三、实验原理磁盘调度算法是为了提高磁盘访问效率而设计的一系列算法。
磁盘扫描算法(SCAN)和循环扫描算法(CSCAN)是常见的磁盘调度算法之一。
1. 磁盘扫描算法(SCAN):该算法从磁头当前位置开始,按照一定的方向(如从低磁道到高磁道或从高磁道到低磁道)依次访问所有请求的磁道,直到访问完所有磁道。
访问完所有磁道后,磁头反向移动,重复上述过程。
2. 循环扫描算法(CSCAN):该算法与SCAN算法类似,但访问完所有磁道后,磁头会直接返回到起始位置,而不是反向移动。
这样可以减少磁头的移动距离,提高磁盘访问效率。
四、实验步骤1. 设计实验界面,包括磁头初始位置、请求磁道序列、总寻道长度、平均寻道长度等显示信息。
2. 编写SCAN算法代码,实现以下功能:(1)初始化磁头位置和请求磁道序列。
(2)按照SCAN算法的规则,计算总寻道长度和平均寻道长度。
(3)在实验界面上显示总寻道长度和平均寻道长度。
3. 编写CSCAN算法代码,实现以下功能:(1)初始化磁头位置和请求磁道序列。
(2)按照CSCAN算法的规则,计算总寻道长度和平均寻道长度。
(3)在实验界面上显示总寻道长度和平均寻道长度。
4. 对比两种算法的效率和适用场景,分析实验结果。
五、实验结果与分析1. 实验数据磁头初始位置:100请求磁道序列:55,58,39,18,90,160,150,38,1842. SCAN算法结果总寻道长度:508平均寻道长度:50.83. CSCAN算法结果总寻道长度:492平均寻道长度:49.24. 分析从实验结果可以看出,CSCAN算法的总寻道长度和平均寻道长度均低于SCAN算法。
磁盘调度的实验报告(3篇)
第1篇一、实验目的1. 理解磁盘调度算法的基本原理和重要性。
2. 掌握几种常见的磁盘调度算法,包括先来先服务(FCFS)、最短寻道时间优先(SSTF)、扫描(SCAN)和循环扫描(C-SCAN)算法。
3. 通过模拟实验,分析不同磁盘调度算法的性能差异。
4. 优化磁盘调度策略,提高磁盘访问效率。
二、实验环境1. 操作系统:Windows 102. 编程语言:Python3.83. 磁盘调度算法模拟库:PyDiskScheduling三、实验内容1. FCFS算法:模拟实现先来先服务算法,按照请求顺序访问磁盘。
2. SSTF算法:模拟实现最短寻道时间优先算法,优先访问距离当前磁头最近的请求。
3. SCAN算法:模拟实现扫描算法,磁头从0号磁道开始向0号磁道移动,访问所有请求,然后返回到0号磁道。
4. C-SCAN算法:模拟实现循环扫描算法,与SCAN算法类似,但磁头在到达末尾磁道后返回到0号磁道。
四、实验步骤1. 导入PyDiskScheduling库。
2. 创建一个磁盘调度对象,指定磁头初始位置、请求序列和调度算法。
3. 运行调度算法,获取磁头移动轨迹和访问时间。
4. 分析算法性能,包括磁头移动次数、平均访问时间和响应时间等。
五、实验结果与分析1. FCFS算法:在请求序列较短时,FCFS算法表现较好。
但随着请求序列长度增加,磁头移动次数和访问时间明显增加。
2. SSTF算法:SSTF算法在请求序列较短时表现最佳,平均访问时间和响应时间较低。
但当请求序列较长时,算法性能下降,磁头移动次数增加。
3. SCAN算法:SCAN算法在请求序列较短时性能较好,但随着请求序列长度增加,磁头移动次数和访问时间逐渐增加。
与SSTF算法相比,SCAN算法在请求序列较长时性能更稳定。
4. C-SCAN算法:C-SCAN算法在请求序列较短时表现较好,但随着请求序列长度增加,磁头移动次数和访问时间逐渐增加。
与SCAN算法相比,C-SCAN算法在请求序列较长时性能更稳定,且磁头移动次数更少。
Linux操作系统磁盘调度算法分析
Linux操作系统磁盘调度算法分析磁盘调度算法是指操作系统中用于处理磁盘上的请求的一套算法。
在现代计算机系统中,磁盘是一种非常重要的存储设备,因此如何高效地处理磁盘请求对于提高系统性能至关重要。
Linux操作系统作为一种广泛使用的开源操作系统,也采用了多种磁盘调度算法来提高磁盘访问效率。
本文将对Linux操作系统中常用的磁盘调度算法进行详细分析。
1. 先来先服务(FCFS)调度算法先来先服务是最基本的磁盘调度算法之一。
它按照磁盘请求的提交顺序进行处理。
当一个请求被完成后,下一个请求将按照提交的顺序进行处理。
这种算法的优点是简单易实现,但并不考虑磁盘访问位置和移动时间。
由于磁盘的读写时间和移动时间往往不同,因此FCFS算法可能会导致一些请求等待时间过长,影响系统的响应速度。
2. 最短寻道时间优先(SSTF)调度算法最短寻道时间优先算法是根据当前磁头位置选择离磁头最近的下一个请求进行处理。
该算法考虑了磁头的移动距离,因此能够减少磁头的寻道时间。
但是由于该算法总是选择最近的请求处理,可能导致一些远离磁头的请求等待时间过长,造成一些请求的饥饿现象。
3. 扫描(SCAN)调度算法扫描算法是磁盘调度算法中常用的一种。
它模拟磁头在磁盘上进行的一次扫描操作,沿着一定方向进行磁道的访问。
当磁头到达磁盘的一端时,会改变方向进行下一次扫描。
该算法比较公平,能够较均匀地处理所有磁盘请求,但是由于需要扫描整个磁道,可能导致一些请求等待时间较长。
4. 循环扫描(C-SCAN)调度算法循环扫描算法是对扫描算法的一种改进。
该算法在到达磁盘的一端后不会改变方向,而是直接返回到磁道的另一端进行下一次扫描。
这意味着所有请求都会等待直到磁头回到磁道的起始位置,这样能够减少等待时间,但是也可能导致一些请求的响应时间较长。
5. 最不常用(LFU)调度算法最不常用算法是根据请求的使用频率进行处理的一种算法。
它将优先处理那些使用频率较低的请求,这样能够提高系统的整体性能。
磁盘的调度算法
实验七磁盘的调度算法一.实验要求设计五个算法,分别是先来先服务算法,最短寻道时间优先算法,扫描(SCAN)算法,循环扫描(CSCAN)算法,NStepSCAN算法.由人工输入当前的磁道数,由系统随即生成要访问的磁道.二、开发环境操作系统:Rad Hat Linux ,开发环境:C语言.三、分析设计(一)实验原理.磁盘是可被多个进程共享的设备。
当有多个进程都请求访问磁盘时,应采用一种适当的调度算法,以使各进程对磁盘的平均访问(主要是寻道)时间最小。
由于在访问磁盘的时间中,主要是寻道时间,因此,磁盘调度的目标应是使磁盘的平均寻道时间最少。
(1) 先来先服务.(First-Come,First-Served,FCFS):这是一种简单的磁盘调度算法。
它根据进程请求访问磁盘的先后次序进行调度。
此算法的优点是公平、简单,且每个进程的请求都能依次得到处理,不会出现某一进程的请求长期得不到满足的情况。
但此算法由于未对寻道进行优化,致使平均寻道时间可能较长。
(2) 最短寻道时间优先(ShortestSeekTimeFirst,SSTF):该算法选择这样的进程,其要求访问的磁道与当前磁头所在的磁道距离最近,以使每次的寻道时间最短,但这种调度算法却不能保证平均寻道时间最短。
(3) 扫描(SCAN)算法:SCAN算法不仅考虑到欲访问的磁道与当前磁道的距离,更优先考虑的是磁头的当前移动方向。
例如,当磁头正在自里向外移动时,SCAN算法所选择的下一个访问对象应是其欲访问的磁道既在当前磁道之外,又是距离最近的。
这样自里向外地访问,直到再无更外的磁道需要访问才将磁臂换向,自外向里移动。
这时,同样也是每次选择这样的进程来调度,即其要访问的磁道,在当前磁道之内,从而避免了饥饿现象的出现。
由于这种算法中磁头移动的规律颇似电梯的运行,故又称为电梯调度算法。
(4) 循环扫描(CSCAN)算法:处理该进程的请求,致使该进程的请求被严重地推迟。
操作系统-磁盘调度算法
操作系统-磁盘调度算法1 一次磁盘读/写操作需要的时间寻找时间(寻道时间)T s:在读/写数据前,需要将磁头移动到指定磁道所花费的时间。
寻道时间分两步:(1) 启动磁头臂消耗的时间:s。
(2) 移动磁头消耗的时间:假设磁头匀速移动,每跨越一个磁道消耗时间为m,共跨越n条磁道。
则寻道时间T s= s + m * n。
磁头移动到指定的磁道,但是不一定正好在所需要读/写的扇区,所以需要通过磁盘旋转使磁头定位到目标扇区。
延迟时间T R:通过旋转磁盘,使磁头定位到目标扇区所需要的时间。
设磁盘转速为r(单位:转/秒,或转/分),则平均所需延迟时间T R=(1/2)*(1/r) = 1/2r。
1/r就是转一圈所需的时间。
找到目标扇区平均需要转半圈,因此再乘以1/2。
传输时间T R:从磁盘读出或向磁盘中写入数据所经历的时间,假设磁盘转速为r,此次读/写的字节数为b,每个磁道上的字节数为N,则传输时间T R= (b/N) * (1/r) = b/(rN)。
每个磁道可存N字节数据,因此b字节数据需要b/N个磁道才能存储。
而读/写一个磁道所需的时间刚好是转一圈的时间1/r。
总的平均时间T a= T s+ 1/2r + b/(rN),由于延迟时间和传输时间都是与磁盘转速有关的,且是线性相关。
而转速又是磁盘的固有属性,因此无法通过操作系统优化延迟时间和传输时间。
所以只能优化寻找时间。
2 磁盘调度算法2.1 先来先服务算法(FCFS)算法思想:根据进程请求访问磁盘的先后顺序进行调度。
假设磁头的初始位置是100号磁道,有多个进程先后陆续地请求访问55、58、39、18、90、160、150、38、184号磁道。
按照先来先服务算法规则,按照请求到达的顺序,磁头需要一次移动到55、58、39、18、90、160、150、38、184号磁道。
磁头共移动了 45 + 3 + 19 + 21 + 72 + 70 + 10 + 112 + 146 = 498个磁道。
操作系统课程设计-磁盘调度算法
前言摘要:本课程设计的目的是通过设计一个磁盘调度模拟系统,从而使磁盘调度算法更加形象化,使磁盘调度的特点更简单明了,这里主要实现磁盘调度的四种算法,分别是:1、先来先服务算法(FCFS) 2、最短寻道时间优先算法(SSTF) 3、扫描算法(SCAN) 4、循环扫描算法(CSCAN)。
启动磁盘执行输入输出操作时,要把移动臂移动到指定的柱面,再等待指定扇区的旋转到磁头位置下,然后让指定的磁头进行读写,完成信息传送;因此,执行一次输入输出所花的时间有:寻找时间——磁头在移动臂带动下移动到指定柱面所花的时间。
延迟时间——指定扇区旋转到磁头下所需的时间。
传送时间——由磁头进程读写完成信息传送的时间,寻道时间——指计算机在发出一个寻址命令,到相应目标数据被找到所需时间;其中传送信息所花的时间,是在硬件设计时固定的,而寻找时间和延迟时间是与信息在磁盘上的位置有关;然后设计出磁盘调度的设计方式,包括算法思路、步骤,以及要用到的主要数据结构、函数模块及其之间的调用关系等,并给出详细的算法设计,对编码进行了测试与分析。
最后进行个人总结与设计体会。
关键词:最短寻道时间优先算法、扫描算法、总寻道长度.目录前言 (2)2. 课程设计任务及要求 (4)2.1 设计任务 (4)2.2 设计要求 (4)3. 算法及数据结构 (5)3.1算法的总体思想(流程) (5)3.2 实现过程中用到的数据结构 (6)3.3 实现过程中用到的系统调用 (11)4. 程序设计与实现 (11)4.1 最短寻道时间优先算法(SSTF)模块 (11)4.1.1程序流程图 (11)4.1.2 程序说明 (13)4.1.3 程序关键代码 (13)4.2扫描算法(SCAN)模块 (14)4.2.1 程序流程图 (14)4.2.2 程序说明 (16)4.2.3 程序关键代码 (16)4.3 实验结果 (17)5. 结论 (26)6. 参考文献 (26)7. 收获、体会和建议 (27)2. 课程设计任务及要求2.1 设计任务1.熟悉并掌握磁盘调度算法管理系统的设计方法,加强对所学各种调度算法及相应算法的特点了解。
操作系统实验第五讲磁盘调度算法
操作系统实验报告哈尔滨工程大学计算机科学与技术学院第六讲磁盘调度算法一、实验概述1. 实验名称磁盘调度算法2. 实验目的(1)通过学习EOS 实现磁盘调度算法的机制,掌握磁盘调度算法执行的条件和时机;(2)观察EOS 实现的FCFS、SSTF和SCAN磁盘调度算法,了解常用的磁盘调度算法;(3)编写CSCAN和N-Step-SCAN磁盘调度算法,加深对各种扫描算法的理解。
3. 实验类型验证性+设计性实验4. 实验内容(1)验证先来先服务(FCFS)磁盘调度算法;(2)验证最短寻道时间优先(SSTF)磁盘调度算法;(3)验证SSTF算法造成的线程“饥饿”现象;(4)验证扫描(SCAN)磁盘调度算法;(5)改写SCAN算法。
二、实验环境在OS Lab实验环境的基础上,利用EOS操作系统,由汇编语言及C语言编写代码,对需要的项目进行生成、调试、查看和修改,并通过EOS应用程序使内核从源代码变为可以在虚拟机上使用。
三、实验过程1. 设计思路和流程图(1)改写SCAN算法在已有SCAN 算法源代码的基础上进行改写,要求不再使用双重循环,而是只遍历一次请求队列中的请求,就可以选中下一个要处理的请求。
算法流程图如下图所示。
图SCAN算法IopDiskSchedule函数流程图(2)编写循环扫描(CSCAN)磁盘调度算法在已经完成的SCAN算法源代码的基础上进行改写,不再使用全局变量ScanInside确定磁头移动的方向,而是规定磁头只能从外向内移动。
当磁头移动到最内的被访问磁道时,磁头立即移动到最外的被访问磁道,即将最大磁道号紧接着最小磁道号构成循环,进行扫描。
算法流程图如下图所示。
图CSCAN算法IopDiskSchedule函数流程图(3)编写N-Step-SCAN磁盘调度算法在已经完成的SCAN 算法源代码的基础上进行改写,将请求队列分成若干个长度为N 的子队列,调度程序按照FCFS原则依次处理这些子队列,而每处理一个子队列时,又是按照SCAN算法。
2020年操作系统实验磁盘调度扫描算法循环扫描算法
作者:非成败作品编号:92032155GZ5702241547853215475102时间:2020.12.13学号P1514032 专业计算机科学与技术姓名实验日期2017.12.7教师签字成绩实验报告【实验名称】磁盘调度(二)【实验目的】磁盘调度中寻道时间直接影响到数据访问的快慢,处理好磁盘寻道时间是关键。
分别采用扫描策略、循环扫描策略处理。
【实验原理】1. 扫描算法(SCAN算法)SCAN算法,也就是很形象的电梯调度算法。
先按照一个方向(比如从外向内扫描),扫描的过程中依次调度经过的磁道。
当扫描到最里层的一个磁道时反向扫描直至所有磁道都被调度。
2.循环扫描算法(CSCAN算法)CSCAN算法,循环扫描算法,它的思想是,访问完最里面一个要求服务的序列之后,从最外层的序号开始往里走。
也就是始终保持一个方向,故称为循环扫描算法。
【数据结构和符号说明】(1)数据结构和符号说明编译语言:C++数据结构:结构体数组符号定义:typedef struct Track//磁道结构体{int id;//磁道序列int state=0;//是否访问过,未被访问置状态为0} Track;Track track[N];//最大磁道数为100Track track1[N];//复制的磁道数组用于输出int step[N];//移动距离int num,i,current_track,num1; //当前磁道即部分中间变量函数说明:void init()//初始化程序void input()//输入函数void sort1()//从小到大排序int abs(int a,int b)//相减的绝对值int find_first_bignum()//寻找第一个最大值int find_first_smallnum()//寻找第一个最小值void SCAN(int up_or_down) //扫描算法void CSCAN(int up_or_down) //循环扫描算法void output(Track a[])//输出函数void output_average_track()//输出平均寻道时间int show()//显示用户界面//返回值为输入的选择项流程图:SCAN算法:CSCAN算法(与SCAN算法基本类似):代码:#include<stdio.h>#define N 100typedef struct Track{int id;//磁道序列int state=0;//是否访问过,未被访问置状态为0 } Track;Track track[N];//最大磁道数为100Track track1[N];int step[N];//移动距离int num,i,current_track,num1;void init()//初始化程序{num=0;for (i=0; i<num; i++){track[i].state=-1;//id置为1track1[i].state=-1;step[i]=-1;//移动距离为-1}}void input()//输入函数{printf("输入当前磁道\n");scanf("%d",¤t_track);num1=current_track;printf("输入要访问的磁道数目\n");scanf("%d",&num);printf("输入要访问磁道序列\n");for(i=0; i<num; i++)作者:非成败作品编号:92032155GZ5702241547853215475102时间:2020.12.13scanf("%d",&track[i].id);}void FCFS()//先来先服务{for(i=0; i<num; i++){if((current_track-track[i].id)<0)//求移动距离step[i]=track[i].id-current_track;elsestep[i]=current_track-track[i].id;//取绝对值 track[i].state=1;//状态置为1current_track=track[i].id;//更新当前磁道}}int abs(int a,int b)//相减的绝对值{return a-b>0?a-b:b-a;}int Serch_min_pos()//寻找到当前磁道最短的需求磁道{int min=45536;//最小距离标志int pos;for(int i=0; i<num; i++)if(track[i].state==1)continue;else if(min>abs(track[i].id,current_track))//寻找最小距离{min=abs(track[i].id,current_track);pos=i;}track[pos].state=1;return pos;//返回在数组中的位置}void SSTF()//最短寻道优先{for(i=0; i<num; i++)//计数器{track1[i]=track[Serch_min_pos()];//更新到要输出的数组中step[i]=abs(track1[i].id,current_track);//移动距离current_track= track1[i].id;//标志}}void output(Track a[])//输出函数{printf("\n\n <从%d号磁道开始>\n",num1);printf("==================================================\n");//排班printf("被访问的下一个磁道\t\t移动距离(磁道数)\n");for(i=0; i<num; i++)printf("\t%4d\t\t||\t%4d\n",a[i].id,step[i]);printf("==================================================\n"); }void output_average_track()//输出平均寻道时间{double sum=0;//和for(i=0; i<num; i++)sum+=step[i];printf(" 平均寻道长度%3.2f\n\n\n",sum/num);//输出}int show()//显示用户界面{int choose;//选择printf("\n******************早期的磁盘调度算法******************\n");printf("\t\t1、先来先服务(FCFS)\n");printf("\t\t2、最短寻道时间优先(SSTF)\n");printf("\t\t3、退出(EXIT)\n");scanf("%d",&choose);return choose;}int main(){do{init();switch(show())//返回值是选择{case 1://FCFSinput();FCFS();output(track);output_average_track();break;case 2://最短寻道input();SSTF();output(track1);output_average_track();break;case 3://退出return 0;default:break;作者:非成败作品编号:92032155GZ5702241547853215475102时间:2020.12.13}}while(1);return 0;}截图:主界面开始,输入选择先来先服务还是最短寻道优先,输入当前磁道,输入要访问的磁道,输入要访问的磁道序列。
操作系统课程设计-磁盘调度算法
操作系统课程设计-磁盘调度算法前言摘要:本课程设计的目的是通过设计一个磁盘调度模拟系统,从而使磁盘调度算法更加形象化,使磁盘调度的特点更简单明了,这里主要实现磁盘调度的四种算法,分别是:1、先来先服务算法(FCFS) 2、最短寻道时间优先算法(SSTF) 3、扫描算法(SCAN) 4、循环扫描算法(CSCAN)。
启动磁盘执行输入输出操作时,要把移动臂移动到指定的柱面,再等待指定扇区的旋转到磁头位置下,然后让指定的磁头进行读写,完成信息传送;因此,执行一次输入输出所花的时间有:寻找时间——磁头在移动臂带动下移动到指定柱面所花的时间。
延迟时间——指定扇区旋转到磁头下所需的时间。
传送时间——由磁头进程读写完成信息传送的时间,寻道时间——指计算机在发出一个寻址命令,到相应目标数据被找到所需时间;其中传送信息所花的时间,是在硬件设计时固定的,而寻找时间和延迟时间是与信息在磁盘上的位置有关;然后设计出磁盘调度的设计方式,包括算法思路、步骤,以及要用到的主要数据结构、函数模块及其之间的调用关系等,并给出详细的算法设计,对编码进行了测试与分析。
最后进行个人总结与设计体会。
关键词:最短寻道时间优先算法、扫描算法、总寻道长度.3.2 实现过程中用到的数据结构1.最短寻道时间优先(SSTF)图a SSTF调度算法示例图ciidao[]={55,58,39,18,90,160,150,38,184}(可随机生成多个)用冒泡法对磁道数组进行排序用户输入当前磁道号now,比较当前返回内侧(外侧)扫描将当前磁道号与剩余没有图b SSTF算法流程示例图原磁道号随机组成的数组:cidao[]={55,58,39,18,90,160,150,38,184};排序后的数组={18,38,39,5,58,90,150,160,184};输入当前磁道号:now=100;3839 39 55 55 55 58 58 58 58 90 90 90 90 90 now值:100 90 58 55 39 184160 160150 150 15018 18 18 1838 38 38 3839 39 39 3955 55 55 5558 58 58 5890 90 90 90now值:18 150 160 184图c SSTF算法队列示意图(按磁道访问顺序)2.扫描(SCAN)算法图d SCAN算法示例图原磁道号随机组成的数组:cidao[]={55,58,39,18,90,160,150,38,184};排序后的数组={18,38,39,5,58,90,150,160,184};输入当前磁道号:now=100;选择磁道移动方向;以磁道号增加的方向移动为例:55 58 58 90 90 90 184 184 184 184 160 160 160 160 160 150 150 150 150 150 150 now值:100 150 160 184 90 58 1838 3839 39 3955 55 5558 58 5890 90 90184 184 184160 160 160150 150 150now值:55 39 38图e SCAN算法队列示意图(按磁道访问顺序)3.3 实现过程中用到的系统调用系统模块调用关系图4. 程序设计与实现4.1 最短寻道时间优先算法(SSTF )模块4.1.1程序流程图磁盘调度算法最短寻道扫描算法退出4.1.2 程序说明算法分析①优点:相较于先来先服务算法(FCFS)有更好的寻道性能,使每次的寻道时间最短。
操作系统实验磁盘调度算法实验报告
操作系统实验磁盘调度算法实验报告一.实验目的本实验旨在通过磁盘调度算法的模拟,探究不同调度算法对磁盘访问性能的影响,了解各种算法的特点和适用场景。
二.实验方法本实验通过编写磁盘调度模拟程序,实现了三种常见的磁盘调度算法:FCFS(先来先服务)、SSTF(最短寻找时间优先)和SCAN(扫描算法)。
实验中使用C语言编程语言,并通过随机生成的队列模拟磁盘访问请求序列。
三.实验过程1.FCFS(先来先服务)算法FCFS算法是一种非常简单的调度算法,它按照请求到达的顺序进行调度。
在实验中,我们按照生成的请求队列顺序进行磁盘调度,记录每次磁头移动的距离。
2.SSTF(最短寻找时间优先)算法SSTF算法是一种动态选择离当前磁头位置最近的磁道进行调度的算法。
在实验中,我们根据当前磁头位置和请求队列中的磁道位置,选择距离最近的磁道进行调度。
然后将该磁道从请求队列中移除,并记录磁头移动的距离。
3.SCAN(扫描算法)算法SCAN算法是一种按照一个方向进行扫描的算法,它在每个方向上按照磁道号的顺序进行调度,直到扫描到最边缘磁道再折返。
在实验中,我们模拟磁头从一个端点开始,按照磁道号从小到大的顺序进行调度,然后再折返。
记录磁头移动的距离。
四.实验结果与分析我们通过生成不同数量的请求队列进行实验,记录每种算法的磁头移动距离,并进行比较。
实验结果显示,当请求队列长度较小时,FCFS算法的磁头移动距离较短,因为它按照请求到达的顺序进行调度,无需寻找最短的磁道。
然而,当请求队列长度较大时,FCFS算法的磁头移动距离会显著增加,因为它不能根据距离进行调度。
SSTF算法相对于FCFS算法在磁头移动距离上有了明显改进。
SSTF算法通过选择最短的寻找时间来决定下一个访问的磁道,因此可以减少磁头的移动距离。
然而,在请求队列中存在少量分散的请求时,SSTF算法可能会产生扇区的服务死锁现象,导致一些磁道无法及时访问。
SCAN算法通过扫描整个磁盘来进行调度,有效解决了FCFS算法有可能导致的服务死锁问题。
操作系统实验三 磁盘调度算法的实现
天津理工大学计算机与通信工程学院实验报告2013 至2014 学年第一学期课程名称操作系统学号学生姓名年级专业教学班号实验地点实验时间2013年月日第节至月日第节主讲教师辅导教师实验(三)实验名称磁盘调度算法的实现软件环境VC++6.0硬件环境PC机实验目的《操作系统》是计算机科学与技术专业和信息与计算科学专业本科教学计划中的一门重要的专业基础课程,是对计算机系统硬﹑软件资源进行管理的系统软件,是计算机系统的管理和指挥中心。
通过本课程实验,使学生综合运用程序设计基础与语言、数据结构、计算机原理与接口等先行课程的知识以及操作系统课程的知识在各种资源管理调度策略下,设计操作系统资源管理的模拟程序,使学生加深了解操作系统的工作机理,对操作系统的功能及结构设计有更加深入的实践,为开发系统软件和应用软件打下基础。
实验内容(应包括实验题目、实验要求、实验任务等)实验内容:1、本实验是模拟操作系统的磁盘寻道方式,运用磁盘访问顺序的不同来设计磁盘的调度算法。
2、实现的磁盘调度算法有FCFS,SSTF,SCAN,CSCAN和NStepSCAN算法。
3、设定开始磁道号寻道范围,依据起始扫描磁道号和最大磁道号数,随机产生要进行寻道的磁道号序列。
4、选择磁盘调度算法,显示该算法的磁道访问顺序,计算出移动的磁道总数和平均寻道总数。
5、按算法的寻道效率进行排序,并对各算法的性能进行分析比较。
实验要求:学生应正确地设计有关的数据结构与各个功能模块,画出程序的流程图,编写程序,程序执行结果应正确实验过程与实验结果(可包括实验实施的步骤、算法描述、流程、结论等)在VC++6.0编写如下代码#include<iostream>#include<ctime>using namespace std;void FCFS(int a[],int n);void SSTF(int a[],int n);void SCAN(int a[],int n);void CSCAN(int a[],int n);int main(){int n;//磁道的个数int s;//功能号cout<<"请输入磁道的个数:"<<endl;cin>>n;int *a=new int[n];cout<<"生成随机磁道号..."<<endl;srand((unsigned)time(NULL));for(int i=0;i<n;i++){a[i]=(rand()%100)+1;cout<<a[i]<<" "; }cout<<endl;while(1) {cout<<endl;cout<<"1、先来先服务算法(FCFS)"<<endl;cout<<"2、最短寻道时间算法(SSTF)"<<endl; cout<<"3、扫描算法(SCAN)"<<endl;cout<<"4、循环扫描算法(CSCAN)"<<endl;cout<<"0、退出"<<endl;cout<<endl;cout<<"请选择功能号:";cin>>s;if(s>4){cout<<"输入有误!"<<endl;}else{switch(s){ case 0: exit(0);break ; case 1:FCFS(a,n); break;case 2:SSTF(a, n);break;case 3:SCAN(a, n);break;case 4:CSCAN(a,n);break; } }} return 0; }//先来先服务调度算法(FCFS)void FCFS(int a[],int n){int sum=0,j,i,first=0,now;cout<<"请输入当前磁道号:";cin>>now;//确定当前磁头所在位置cout<<"磁盘调度顺序为:"<<endl;for( i=0;i<n;i++)//按访问顺序输出磁道号{cout<<a[i]<<" ";}//计算sumfor(i=0,j=1;j<n;i++,j++){first+=abs(a[j]-a[i]);//外围磁道与最里面磁道的距离}sum+=first+abs(now-a[0]);cout<<endl;cout<<"移动的总磁道数: "<<sum<<endl;}//最短寻道时间算法(SSTF)void SSTF(int a[],int n){int temp;int k=1;int now,l,r;int i,j,sum=0;//将磁道号按递增排序for(i=0;i<n;i++)for(j=i+1;j<n;j++){if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp; }}cout<<"按递增顺序排好的磁道:"<<endl;for( i=0;i<n;i++){cout<<a[i]<<" ";//输出排好的磁道顺序}cout<<endl;cout<<"请输入当前的磁道号:";cin>>now;//确定当前磁头所在位置cout<<"磁盘调度顺序为:"<<endl;if(a[n-1]<=now)//当前磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--)cout<<a[i]<<" ";sum=now-a[0];}elseif(a[0]>=now)//当前磁头位置小于最里欲访问磁道{for(i=0;i<n;i++)cout<<a[i]<<" ";sum=a[n-1]-now;}else{while(a[k]<now)//确定当前磁道在已排的序列中的位置{k++;}l=k-1;//在磁头位置的前一个欲访问磁道r=k;//磁头欲访问磁道while((l>=0)&&(r<n)){if((now-a[l])<=(a[r]-now))//选择离磁头近的磁道 {cout<<a[l]<<" ";sum+=now-a[l];now=a[l];l=l-1; }else{cout<<a[r]<<" ";sum+=a[r]-now;now=a[r];r=r+1;} }if(l=-1)//磁头位置里侧的磁道已访问完{for(j=r;j<n;j++)//访问磁头位置外侧的磁道{cout<<a[j]<<" ";}sum+=a[n-1]-a[0];}if(r==n)//磁头位置外侧的磁道已访问完{for(j=k-1;j>-1;j--) //访问磁头位置里侧的磁道{cout<<a[j]<<" ";}sum+=a[n-1]-a[0];} }cout<<endl;cout<<"移动的总道数:"<<sum<<endl;}//扫描算法(SCAN)void SCAN(int a[],int n){int temp;int k=1;int now,l,r;int i,j,sum=0;for(i=0;i<n;i++)//对访问磁道按由小到大顺序排列输出for(j=i+1;j<n;j++){if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}cout<<"按递增顺序排好的磁道:"<<endl;for( i=0;i<n;i++){cout<<a[i]<<" ";}cout<<endl;cout<<"请输入当前的磁道号:";cin>>now;//以下算法确定磁道访问顺序if(a[n-1]<=now) //磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--)cout<<a[i]<<" ";sum=now-a[0];}elseif(a[0]>=now) //磁头位置小于最里欲访问磁道{for(i=0;i<n;i++)cout<<a[i]<<" ";sum=a[n-1]-now;}else //磁头位置在最里侧磁道与最外侧磁道之间{ int d;while(a[k]<now){ //确定当前磁道在已排的序列中的位置k++;}l=k-1;//在磁头位置的前一个欲访问磁道r=k; //磁头欲访问磁道cout<<"请输入当前磁头移动的方向 (0 表示向内,1表示向外) : "; cin>>d; //确定磁头访问的方向cout<<"磁盘调度顺序为:";if(d==0||d==1){if(d==0) //磁头向内{for(j=l;j>=0;j--){cout<<a[j]<<" ";}for(j=r;j<n;j++){cout<<a[j]<<" ";}sum=now-2*a[0]+a[n-1];}if(d==1) //磁头向外{for(j=r;j<n;j++){cout<<a[j]<<" ";}for(j=l;j>=0;j--){cout<<a[j]<<" ";}sum=2*a[n-1]-now-a[0];}}elsecout<<"请输入0或1!"<<endl;}cout<<endl;cout<<"移动的总道数: "<<sum<<endl;}//循环扫描算法(CSCAN)void CSCAN(int a[],int n){int temp;int now,l,r;int i,j,sum=0;int k=1;for(i=0;i<n;i++)//对访问磁道按由小到大顺序排列输出for(j=i+1;j<n;j++){if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}cout<<"按递增顺序排好的磁道:"<<endl;for( i=0;i<n;i++){cout<<a[i]<<" ";}cout<<endl;cout<<"请输入当前的磁道号:";cin>>now;//确定当前磁道号if(a[n-1]<=now)//磁头位置大于最外围欲访问磁道{for(i=0;i<n;i++)cout<<a[i]<<" ";sum=now-2*a[0]+a[n-1];}elseif(a[0]>=now)//磁头位置小于最里欲访问磁道{for(i=0;i<n;i++)cout<<a[i]<<" ";sum=a[n-1]-now;}else //磁头位置在最里侧磁道与最外侧磁道之间{ int d;while(a[k]<now){k++;}l=k-1;//在磁头位置的前一个欲访问磁道r=k; //磁头欲访问磁道cout<<"请输入当前磁头移动的方向 (0 表示向内,1表示向外) : "; cin>>d; //确定磁头访问的方向cout<<"磁盘调度顺序为:";if(d==0||d==1){if(d==1) //磁头向外侧访问{for(j=r;j<n;j++)//先访问外侧磁道再转向最里欲访问磁道{cout<<a[j]<<" ";}for(j=0;j<r;j++){cout<<a[j]<<" ";}sum=2*a[n-1]-now-2*a[0]+a[l];}if(d==0) //磁头向内侧访问 {for(j=r-1;j>=0;j--){cout<<a[j]<<" ";}for(j=n-1;j>=r;j--)//{cout<<a[j]<<" ";}sum=2*a[n-1]-2*a[0]+now-a[r];}}elsecout<<"请输入0或1!";}cout<<endl;cout<<"移动的总道数: "<<sum<<endl;}实验结果:1.先来先服务算法(FCFS)测试结果2.最短寻道时间算法(SSTF)测试结果3.循环扫描算法(SCAN)测试结果4.循环扫描算法(CSCAN)测试结果由以上测试结果可知,在相同的实验前提下,SSTF移动的总道数最少,性能最优。
件的硬盘磁盘中的四种算法
您可能是在说磁盘管理中常用的四种调度算法,这些算法用于确定磁头臂移动到磁盘的哪个位置以执行请求。
以下是四种主要的磁盘调度算法:
1. FCFS (先进先出) 算法:这是最简单的调度算法,它按照请求到达的顺序进行服务。
2. SSTF (最短寻道时间优先) 算法:此算法选择距离当前磁头位置最近的请求进行服务。
这可以减少磁头的移动距离,从而提高效率。
3. SCAN (扫描) 算法:也被称为电梯算法,磁头首先向一个方向移动以服务尽可能多的请求,然后改变方向。
4. C-SCAN (循环扫描) 算法:与SCAN类似,但是当磁头到达一个端点时,它会绕过整个磁盘并返回到另一端。
每种算法都有其优点和缺点,适用于不同的应用和环境。
例如,SSTF可能在高请求密度的环境中表现良好,而SCAN和C-SCAN可能更适合于请求分布不均匀的环境。
选择合适的调度算法对于磁盘性能优化至关重要。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
实验报告【实验名称】磁盘调度(二)【实验目的】磁盘调度中寻道时间直接影响到数据访问的快慢,处理好磁盘寻道时间是关键。
分别采用扫描策略、循环扫描策略处理。
【实验原理】1. 扫描算法(SCAN算法)SCAN算法,也就是很形象的电梯调度算法。
先按照一个方向(比如从外向内扫描),扫描的过程中依次调度经过的磁道。
当扫描到最里层的一个磁道时反向扫描直至所有磁道都被调度。
2.循环扫描算法(CSCAN算法)CSCAN算法,循环扫描算法,它的思想是,访问完最里面一个要求服务的序列之后,从最外层的序号开始往里走。
也就是始终保持一个方向,故称为循环扫描算法。
【数据结构和符号说明】(1)数据结构和符号说明编译语言:C++数据结构:结构体数组符号定义:typedef struct Track//磁道结构体{int id;//磁道序列int state=0;//是否访问过,未被访问置状态为0 } Track;Track track[N];//最大磁道数为100Track track1[N];//复制的磁道数组用于输出int step[N];//移动距离int num,i,current_track,num1; //当前磁道即部分中间变量函数说明:void init()//初始化程序void input()//输入函数void sort1()//从小到大排序int abs(int a,int b)//相减的绝对值int find_first_bignum()//寻找第一个最大值int find_first_smallnum()//寻找第一个最小值void SCAN(int up_or_down) //扫描算法void CSCAN(int up_or_down) //循环扫描算法void output(Track a[])//输出函数void output_average_track()//输出平均寻道时间int show()//显示用户界面//返回值为输入的选择项流程图:SCAN算法:CSCAN算法(与SCAN算法基本类似):代码:#include<stdio.h>#define N 100typedef struct Track{int id;//磁道序列int state=0;//是否访问过,未被访问置状态为0 } Track;Track track[N];//最大磁道数为100Track track1[N];int step[N];//移动距离int num,i,current_track,num1;void init()//初始化程序{num=0;for (i=0; i<num; i++){track[i].state=-1;//id置为1track1[i].state=-1;step[i]=-1;//移动距离为-1}}void input()//输入函数{printf("输入当前磁道\n");scanf("%d",¤t_track);num1=current_track;printf("输入要访问的磁道数目\n");scanf("%d",&num);printf("输入要访问磁道序列\n");for(i=0; i<num; i++)scanf("%d",&track[i].id);}void FCFS()//先来先服务{for(i=0; i<num; i++){if((current_track-track[i].id)<0)//求移动距离step[i]=track[i].id-current_track;elsestep[i]=current_track-track[i].id;//取绝对值 track[i].state=1;//状态置为1current_track=track[i].id;//更新当前磁道}}int abs(int a,int b)//相减的绝对值{return a-b>0?a-b:b-a;}int Serch_min_pos()//寻找到当前磁道最短的需求磁道{int min=45536;//最小距离标志int pos;for(int i=0; i<num; i++)if(track[i].state==1)continue;else if(min>abs(track[i].id,current_track))//寻找最小距离{min=abs(track[i].id,current_track);pos=i;}track[pos].state=1;return pos;//返回在数组中的位置}void SSTF()//最短寻道优先{for(i=0; i<num; i++)//计数器{track1[i]=track[Serch_min_pos()];//更新到要输出的数组中step[i]=abs(track1[i].id,current_track);//移动距离current_track= track1[i].id;//标志}}void output(Track a[])//输出函数{printf("\n\n <从%d号磁道开始>\n",num1);printf("==================================================\n");//排班printf("被访问的下一个磁道\t\t移动距离(磁道数)\n");for(i=0; i<num; i++)printf("\t%4d\t\t||\t%4d\n",a[i].id,step[i]);printf("==================================================\n"); }void output_average_track()//输出平均寻道时间{double sum=0;//和for(i=0; i<num; i++)sum+=step[i];printf(" 平均寻道长度%3.2f\n\n\n",sum/num);//输出}int show()//显示用户界面{int choose;//选择printf("\n******************早期的磁盘调度算法******************\n");printf("\t\t1、先来先服务(FCFS)\n");printf("\t\t2、最短寻道时间优先(SSTF)\n");printf("\t\t3、退出(EXIT)\n");scanf("%d",&choose);return choose;}int main(){do{init();switch(show())//返回值是选择{case 1://FCFSinput();FCFS();output(track);output_average_track();break;case 2://最短寻道input();SSTF();output(track1);output_average_track();break;case 3://退出return 0;default:break;}}while(1);return 0;}截图:主界面开始,输入选择先来先服务还是最短寻道优先,输入当前磁道,输入要访问的磁道,输入要访问的磁道序列。
SCAN算法输入当前磁道100 ,9个磁道,分别为55 58 39 18 90 160 150 38 184,此时选择方向向上结果正确。
输入当前磁道100 ,9个磁道,分别为55 58 39 18 90 160 150 38 184,此时选择方向向下结果正确。
CSCAN算法输入当前磁道100 ,9个磁道,分别为55 58 39 18 90 160 150 38 184,此时选择方向向上结果正确。
输入当前磁道100 ,9个磁道,分别为55 58 39 18 90 160 150 38 184,此时选择方向向上结果正确。
【小结与讨论】1、扫描算法又称为电梯算法,其原理与电梯运行情况相似,即运行方向上的请求优先,若是访问方向向上,则先依次访问较大的磁道号至顶,再向下访问娇小的磁道号;若是访问方向向下,则先依次访问较小的磁道号至底,再向上访问娇大的磁道号。
2、循环扫描算法又称为单向电梯算法,若是访问方向向上,则向上依次访问完较大的磁道号后,返回最低端,依次向上访问较小的磁道号;若是访问方向向下,则向下依次访问完较小的磁道号后,返回最顶端,依次向下访问较大的磁道号。
3、此次实验我用两个数组分别存放了一个磁道表和复制的磁道表,根据两个算法的原理,只要将其进行排序,然后分别对两个数组进行正向和逆向的访问即可。
4、具体实现时,我将两种算法的两种初始扫描方向写在了一个函数之中,调用时通过参数scan和参数up_or_down设置。
并设置了寻找大于当前数组的最近最小值和最近的大值进行选择结果,这是因为初始磁道号将磁道数组分成上下(高低地址)两块,这两块根据不同的扫描方向重新选择高低地址,又结合不同的算法决定正序排列还是反序排列。
实现起来还是比较简单的。
5、由于CSCAN算法的思想是,访问完最里面一个要求服务的序列之后,从最外层的序号开始往里走。
也就是始终保持一个方向。
所以如果用循环队列实现,时间复杂度会更低,效率更高。
6、此次实验虽然较为简单,但还是发现了自己知识点有些方面的不足,让我更好的了解了磁盘调度的原理,使我收获颇多。