实验六 磁盘调度算法
实验报告六 磁盘调度算法
实验报告六磁盘调度算法班级：软技2班学号：201467003084 姓名：刘道林一．实验内容：熟悉磁盘的结构以及磁盘的驱动调度算法的模拟，编程实现简单常用的磁盘驱动调度算法先来先服务（FIFO）、电梯调度算法、最短寻找时间优先算法、扫描（双向扫描）算法、单向扫描（循环扫描）算法等。
编程只需实现两个算法。
题目可以选取教材或习题中的相关编程实例。
编程语言建议采用c/c++或Java。
模拟程序鼓励采用随机数技术、动态空间分配技术，有条件的最好能用图形界面展现甚至用动画模拟。
实验性质：验证型。
二．实验目的和要求1）掌握使用一门语言进行磁盘驱动调度算法的模拟；2）编写程序将磁盘驱动调度算法的过程和结果能以较简明直观的方式展现出来。
三．实验原理、方法和步骤1. 实验原理磁盘驱动调度对磁盘的效率有重要影响。
磁盘驱动调度算法的好坏直接影响辅助存储器的效率，从而影响计算机系统的整体效率。
常用的磁盘驱动调度算法有：最简单的磁盘驱动调度算法是先入先出（FIFO）法。
这种算法的实质是，总是严格按时间顺序对磁盘请求予以处理。
算法实现简单、易于理解并且相对公平，不会发生进程饿死现象。
但该算法可能会移动的柱面数较多并且会经常更换移动方向，效率有待提高。
最短寻找时间优先算法：总是优先处理最靠近的请求。
该算法移动的柱面距离较小，但可能会经常改变移动方向，并且可能会发生进程饥饿现象。
电梯调度：总是将一个方向上的请求全部处理完后，才改变方向继续处理其他请求。
扫描（双向扫描）：总是从最外向最里进行扫描，然后在从最里向最外扫描。
该算法与电梯调度算法的区别是电梯调度在没有最外或最里的请求时不会移动到最外或最里柱面，二扫描算法总是移到最外、最里柱面。
两端的请求有优先服被务的迹象。
循环扫描（单向扫描）：从最外向最里进行柱面请求处理，到最里柱面后，直接跳到最外柱面然后继续向里进行处理。
该算法与扫描算法的区别是，回来过程不处理请求，基于这样的事实，因为里端刚被处理。
操作系统课设报告磁盘调度算法
课程设计报告课程名称: 操作系统课程设计课题名称: 磁盘调度算法学院: 软件学院班级:学生姓名:学号：指导教师：磁盘调度算法一、系统需求分析磁盘存储器不仅容量大，存取速度快，而且可以实现随机存取，是当前存放大量程序和数据的理想设备。
所以在现代计算机中都配备了磁盘存储器，以他为主存放文件，这样对文件的读、写操作都涉及到了对磁盘存储器的访问。
磁盘I/O速度的高低和磁盘系统的可靠性，都直接影响到系统的性能。
因此改善磁盘系统的性能成为现代操作系统的重要任务之一。
磁盘性能有数据的组织、磁盘的类型和访问时间等。
可以通过选择好的磁盘调度算法，以减少磁盘的寻道时间。
为了减少对文件的访问时间，应采用一种最佳的磁盘调度算法，以使各进程对磁盘的平均访问时间最少。
由于在访问磁盘的时间中主要是寻道时间，因此，磁盘调度的目标是使磁盘的寻道时间最少。
所以本课程设计对各个算法进行模拟，进而比较分析了解。
二、实验内容和目的.实验内容模拟电梯调度算法，实现对磁盘的驱动调度。
设计要求：编程序实现下述磁盘调度算法,并求出每种算法的平均寻道长度；要求设计主界面可以灵活选择某算法，且以下算法都要实现1、先来先服务算法（FCFS）2、最短寻道时间优先算法（SSTF）3、扫描算法（SCAN）4、循环扫描算法（CSCAN）.实验原理模拟电梯调度算法，对磁盘调度。
磁盘是要供多个进程共享的存储设备，但一个磁盘每个时刻只能为一个进程服务。
当有进程在访问某个磁盘时，其他想访问该磁盘的进程必须等待，直到磁盘一次工作结束。
当有多个进程提出输入输出请求处于等待状态，可用电梯调度算法从若干个等待访问者中选择一个进程，让它访问磁盘。
当存取臂仅需移到一个方向最远的所请求的柱面后,如果没有访问请求了,存取臂就改变方向。
三、总体设计及分类简介算法介绍磁盘调度中常用的有四种算法，功能分别如下：1.先来先服务（FCFS）算法。
即先来的请求先被响应。
FCFS策略看起来似乎是相当"公平"的，但是当请求的频率过高的时候FCFS策略的响应时间就会大大延长。
磁盘调度算法实践报告
《计算机操作系统》课外实践报告题目：磁盘调度模拟系统班级：姓名：学号：指导老师: 设计时间: 2013.6一、实验目标：通过设计一个磁盘调度模拟系统，从而使磁盘调度算法更加形象化，容易使人理解，使磁盘调度的特点更简单明了，能使使用者加深对先来先服务算法、最短寻道时间优先算法、扫描算法以及循环扫描算法等磁盘调度算法的理解。
二、实验要求系统有良好的界面效果，通过主界面可以灵活选择某种算法来模拟对磁盘的调度，再通过其他界面来显示整个调度过程是怎样变化的。
算法包括：⑴先来先服务算法（FCFS）⑵最短寻道时间优先算法（SSTF）⑶扫描算法（SCAN）⑷循环扫描算法（CSCAN）三．实践内容简要描述1、实践环境windows XP/7，visual C++ 6.02、算法思路2.1、先来先服务算法：void FCFS(int cidao[],int m)输入磁道号，按先来先服务的策略按照输入时的顺序依次输出磁盘请求序列，求出平均寻道长度，输出移动平均磁道数。
2.2、最短寻道时间优先算法：void SSTF(int cidao[],int m)将磁道号用冒泡法从小到大排序，输出排好序的磁道序列，输入当前磁道号，根据当前磁道在已排的序列中的位置，确定扫描的顺序：若当前磁道号大于请求序列中最大者，则直接由外向内依次给予各请求服务；若当前磁道号小于请求序列中最小者，则直接由内向外依次给予各请求服务；当前磁道在请求序列范围内，求出距离当前磁道最近的磁道的位置，最后求出平均寻道长度，输出移动的平均磁道数。
2.3、扫描算法：void SCAN(int cidao[],int m)将磁道号用冒泡法从小到大排序，输出排好序的序列，输入当前磁道号，选择移动臂的移动方向，根据当前磁道在已排的序列中的位置，确定当前扫描的顺序：如先向内扫描，磁头移动到最小号，则改变方向向外扫描未扫描的磁道，当扫到最大号后就扫完了所有磁道，求出平均寻道长度，输出移动的平均磁道数。
实习磁盘调度心得体会
实习磁盘调度心得体会在磁盘调度算法的研究中，我对几种常见的磁盘调度算法进行了深入的研究，包括FCFS算法、SSTF算法、SCAN算法等。
我发现不同的磁盘调度算法在不同的场景下有着不同的优势和劣势。
比如，在磁盘上存在大量随机访问的情况下，SSTF算法能够在短时间内完成大量的访问请求，而在需要保证公平性的情况下，SCAN算法能够更好地平衡磁盘上各个磁道的访问次数。
通过对这些算法的研究，我对磁盘调度算法的优缺点有了更清晰的认识，并且在实际工作中能够更好地根据具体情况选择合适的算法。
在实习期间，我还遇到了一些实际工作中的问题，比如磁盘访问速度过慢、磁盘上存在大量碎片等。
为了解决这些问题，我结合自己的理论知识，对实际情况进行了分析和实验，并且提出了一些解决方案。
比如，在面对磁盘访问速度过慢的问题时，我通过优化磁盘的物理结构和调整磁盘调度算法的参数，使得磁盘的访问速度得到了明显的提升。
在解决磁盘碎片问题时，我采用了磁盘碎片整理的方法，通过对磁盘上的文件进行整理和整合，有效地减少了磁盘碎片的数量，提高了磁盘的读写速度。
通过这些实际问题的解决，我对磁盘调度算法的实际应用有了更深入的理解，也积累了一定的经验。
在未来的工作中，我将继续深入研究磁盘调度算法，探索更加高效的解决方案，为提高系统的性能和稳定性做出更大的贡献。
除了在磁盘调度算法的研究和应用方面有所收获外，我在实习期间还学到了很多关于团队合作和沟通的经验。
在团队中，我们每个人都有着不同的专业背景和技能，而且我们互相之间还存在着一定的交流和合作障碍。
为了更好地完成项目任务，我学会了更加主动地和团队成员进行沟通，及时解决问题和分配任务，保证整个团队能够高效地协作。
另外，我还意识到了自身的不足，比如在团队合作中缺乏主动性和领导能力。
在今后的工作中，我将更加努力地提升自己的团队合作能力和领导能力，争取成为更有价值的团队成员。
通过这段时间的实习，我对自己的职业发展方向有了更清晰的认识，也对未来的职业规划有了更明确的目标。
磁盘调度算法的实现
实验五、磁盘调度算法的实现一、实验目的实验程序模拟先来先服务FCFS，最短寻道时间优先SSTF，SCAN和循环SCAN 算法的工作过程。
假设有n个磁道号所组成的磁道访问序列，给定开始磁道号m 和磁头移动的方向（正向或者反向），分别利用不同的磁盘调度算法访问磁道序列，给出每一次访问的磁头移动距离，计算每种算法的平均寻道长度，本程序采用随机数来产生磁道数。
二、实验要求算法所需的各种参数由输入产生（手工输入或者随机数产生）。
最后的结果要求是在运行四种算法的程序后，能够输出调度过程、平均寻道长度的正确结果。
三、实验说明(1) 先来先服务．(FCFS):这是一种简单的磁盘调度算法。
它根据进程请求访问磁盘的先后次序进行调度。
此算法的优点是公平、简单，且每个进程的请求都能依次得到处理，不会出现某一进程的请求长期得不到满足的情况。
但此算法由于未对寻道进行优化，致使平均寻道时间可能较长。
(2) 最短寻道时间优先(SSTF):该算法选择这样的进程，其要求访问的磁道与当前磁头所在的磁道距离最近，以使每次的寻道时间最短，但这种调度算法却不能保证平均寻道时间最短。
(3) 扫描算法(SCAN):SCAN算法不仅考虑到欲访问的磁道与当前磁道的距离，更优先考虑的是磁头的当前移动方向。
例如，当磁头正在自里向外移动时，SCAN算法所选择的下一个访问对象应是其欲访问的磁道既在当前磁道之外，又是距离最近的。
这样自里向外地访问，直到再无更外的磁道需要访问才将磁臂换向，自外向里移动。
这时，同样也是每次选择这样的进程来调度，即其要访问的磁道，在当前磁道之内，从而避免了饥饿现象的出现。
由于这种算法中磁头移动的规律颇似电梯的运行，故又称为电梯调度算法。
（4）循环扫描算法（CSCAN）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个磁道。
操作系统课设报告磁盘调度算法
课程设计报告课程名称: 操作系统课程设计课题名称: 磁盘调度算法学院: 软件学院班级:学生姓名:学号：指导教师：磁盘调度算法一、系统需求分析磁盘存储器不仅容量大，存取速度快，而且可以实现随机存取，是当前存放大量程序和数据的理想设备。
所以在现代计算机中都配备了磁盘存储器，以他为主存放文件，这样对文件的读、写操作都涉及到了对磁盘存储器的访问。
磁盘I/O速度的高低和磁盘系统的可靠性，都直接影响到系统的性能。
因此改善磁盘系统的性能成为现代操作系统的重要任务之一。
磁盘性能有数据的组织、磁盘的类型和访问时间等。
可以通过选择好的磁盘调度算法，以减少磁盘的寻道时间。
为了减少对文件的访问时间，应采用一种最佳的磁盘调度算法，以使各进程对磁盘的平均访问时间最少。
由于在访问磁盘的时间中主要是寻道时间，因此，磁盘调度的目标是使磁盘的寻道时间最少。
所以本课程设计对各个算法进行模拟，进而比较分析了解。
二、实验内容和目的2.1.实验内容模拟电梯调度算法，实现对磁盘的驱动调度。
设计要求：编程序实现下述磁盘调度算法,并求出每种算法的平均寻道长度；要求设计主界面可以灵活选择某算法，且以下算法都要实现1、先来先服务算法（FCFS）2、最短寻道时间优先算法（SSTF）3、扫描算法（SCAN）4、循环扫描算法（CSCAN）2.2.实验原理模拟电梯调度算法，对磁盘调度。
磁盘是要供多个进程共享的存储设备，但一个磁盘每个时刻只能为一个进程服务。
当有进程在访问某个磁盘时，其他想访问该磁盘的进程必须等待，直到磁盘一次工作结束。
当有多个进程提出输入输出请求处于等待状态，可用电梯调度算法从若干个等待访问者中选择一个进程，让它访问磁盘。
当存取臂仅需移到一个方向最远的所请求的柱面后,如果没有访问请求了,存取臂就改变方向。
三、总体设计及分类简介3.1算法介绍磁盘调度中常用的有四种算法，功能分别如下：1.先来先服务（FCFS）算法。
即先来的请求先被响应。
FCFS策略看起来似乎是相当"公平"的，但是当请求的频率过高的时候FCFS策略的响应时间就会大大延长。
磁盘调度算法
磁盘调度算法现代操作系统中，磁盘利用外层磁道容量较内层磁道大的特点，将盘面划分成若干条环带，使得同一环带内的所有磁道具有相同的扇区数。
磁头在各磁道上移动，当进程请求时根据当前磁头位置和待访问位置决定访问次序。
本实验是模拟操作系统的磁盘寻道方式，运用磁盘访问顺序的不同来设计磁盘的调度算法。
设定开始磁道号寻道范围，依据起始扫描磁道号和最大磁道号数，随机产生要进行寻道的磁道号序列。
磁道访问序列不小于6。
选择磁盘调度算法，显示该算法的磁道访问顺序，计算出移动的磁道总数和平均寻道总数。
可选的实现磁盘调度算法有FCFS，SSTF，SCAN，CSCAN和NStepSCAN算法。
选择比较的算法，不小于3。
按算法的寻道效率进行排序，并对各算法的性能进行分析比较。
先来先服务FCFS根据进程请求访问磁盘的先后次序进行调度。
当一个新的磁盘访问请求发生时，不考虑其他因素，仅仅凭借作业的到达次序，作为调度的依据。
程序设定访问磁道的起止道号，如100-500，随机产生不小于6个磁道访问的序列，并明确次序。
按照FCFS方法，依磁道访问序列，确定每个作业的移动磁道数，并输出计算平均寻道长度详细描述实验设计思想、程序结构及各模块设计思路；详细描述程序所用数据结构及算法；明确给出测试用例和实验结果；为增加程序可读性，在程序中进行适当注释说明；认真进行实验总结，包括：设计中遇到的问题、解决方法与收获等；#include<iostream>#include<cmath>using namespace std;#define size 10void FCFS(int input[],int num);void SSTF(int input[],int num);void SCAN(int input[],int num);void CSCAN(int input[],int num);void sort(int input[],int num); //排序函数void main(){int track[200]; //磁道的范围为0~199int PCB[size]; //输入的磁道号int i=0;while(i<200){ //磁道初始化track[i]=i;i++;}cout<<"\n请输入"<<size<<"个待寻磁道号（0~199）"<<endl;for(int j=0;j<size; j++){cin>>PCB[j];}int suanfa; //算法选择while(1){cout<<"选择算法："<<endl;cout<<" 1、FCFS算法\n";cout<<" 2、SSTF算法\n";cout<<" 3、SCAN算法\n";cout<<" 4、CSCAN算法\n";cout<<" 5、退出!\n";scanf("%d",&suanfa);if(suanfa==1) FCFS(PCB,size);else if(suanfa==2) SSTF(PCB,size);else if(suanfa==3) SCAN(PCB,size);else if(suanfa==4) CSCAN(PCB,size);else if(suanfa!=1 || suanfa!=2 || suanfa!=3 || suanfa!=4 )break;}cout<<" 欢迎使用!\n\n\n";}void sort(int input[],int num){ //排序函数int t;for(int j=0;j<num-1;j++)for(int i=0;i<num-1-j;i++)if(input[i]>input[i+1]){t=input[i];input[i]=input[i+1];input[i+1]=t;}}void FCFS(int input[],int num){cout<<"输入当前所在磁道号\n";int dangqian;float sum=0; //记录总访问磁道数float ave; //平均访问磁道数cin>>dangqian;cout<<"访问磁道顺序为：";for(int i=0;i<num;i++){cout<<input[i]<<" ";sum=sum+abs(input[i]-dangqian);dangqian=input[i];}ave=sum/num;cout<<"\n移动的磁道总数:"<<sum;cout<<"\n平均访问磁道数为："<<ave<<endl;cout<<"\n";}void SSTF(int input[],int num){sort(input,size); //对输入的磁道号排序cout<<"输入当前所在磁道号\n";int dangqian;float sum=0; //记录总访问磁道数float ave; //平均访问磁道数cin>>dangqian;cout<<"访问磁道顺序为：";if(dangqian>=input[num-1]){ //如果当前大于最大的磁道号for(int i=num-1;i>=0;i--){cout<<input[i]<<" ";sum=sum+abs(input[i]-dangqian);dangqian=input[i];}}else if(dangqian<=input[0]){ //如果当前小于最大的磁道号for(int i=0;i<num;i++){cout<<input[i]<<" ";sum=sum+abs(input[i]-dangqian);dangqian=input[i];}}else { //如果在最大和最小之间int k=0;int low,high;while(dangqian>input[k]) k++;low=k;high=k+1;while(low>=0 || high <num){if(abs(dangqian-input[low])<=abs(dangqian-input[high])) //如果前一个较近取前一个{cout<<input[low]<<" ";sum=sum+abs(input[low]-dangqian);dangqian=input[low];low--;}else{cout<<input[high]<<" ";sum=sum+abs(input[high]-dangqian);dangqian=input[high];high++;}}}ave=sum/num;cout<<"\n移动的磁道总数:"<<sum;cout<<"\n平均访问磁道数为："<<ave<<endl;cout<<"\n";}void SCAN(int input[],int num){sort(input,size);cout<<"输入当前所在磁道号\n";int dangqian;float sum=0; //记录总访问磁道数float ave; //平均访问磁道数cin>>dangqian;cout<<"选择扫描方向：\n";cout<<" 0、从里向外\n";cout<<" 1、从外向里\n";int k; //记录中间位置cin>>k;int x=0;while(dangqian>input[x]) x++;int temp=x;cout<<"访问磁道顺序为：";if(k==0){ //从里向外while(x<size){cout<<input[x]<<" ";sum=sum+abs(input[x]-dangqian);dangqian=input[x];x++;}int wo=temp;while(wo>0){cout<<input[wo-1]<<" ";sum=sum+abs(input[wo-1]-dangqian);dangqian=input[wo-1];wo--;}}else if(k==1){ //从外向里while(x>0){cout<<input[x-1]<<" ";sum=sum+abs(input[x-1]-dangqian);dangqian=input[x-1];x--;}int wow=temp;while(wow<size){cout<<input[wow]<<" ";sum=sum+abs(input[wow]-dangqian);dangqian=input[wow];wow++;}}else { cout<<"输入错误！\n"; exit(0);}ave=sum/num;cout<<"\n移动的磁道总数:"<<sum;cout<<"\n平均访问磁道数为："<<ave<<endl;cout<<"\n";}void CSCAN(int input[],int num){sort(input,size);cout<<"输入当前所在磁道号\n";int dangqian;float sum=0; //记录总访问磁道数float ave; //平均访问磁道数cin>>dangqian;cout<<"选择扫描方向：\n";cout<<" 0、从里向外\n";cout<<" 1、从外向里\n";int k; //记录中间位置cin>>k;int x=0;while(dangqian>input[x]) x++;int temp=x;cout<<"访问磁道顺序为：";if(k==0){ //从里向外while(x<size){cout<<input[x]<<" ";sum=sum+abs(input[x]-dangqian);dangqian=input[x];x++;}int wo=0;while(wo<temp){cout<<input[wo]<<" ";sum=sum+abs(input[wo]-dangqian);dangqian=input[wo];wo++;}}else if(k==1){ //从外向里while(x>0){cout<<input[x-1]<<" ";sum=sum+abs(input[x-1]-dangqian);dangqian=input[x-1];x--;}int wow=size-1;while(wow>=temp){cout<<input[wow]<<" ";sum=sum+abs(input[wow]-dangqian);dangqian=input[wow];wow--;}}else { cout<<"输入错误！\n"; exit(0);}ave=sum/num;cout<<"\n移动的磁道总数:"<<sum;cout<<"\n平均访问磁道数为："<<ave<<endl;cout<<"\n";}。
操作系统磁盘调度算法例题讲解
磁盘调度算法的优化策略一、磁盘调度算法概述磁盘调度算法是指决定何时访问磁盘的一种算法。
在操作系统中，磁盘调度算法被用来优化磁盘读写操作的效率，从而提高系统的响应速度和吞吐量。
常见的磁盘调度算法包括先来先服务 (FCFS)、最短时间优先 (SSTF)、单向扫描调度算法和顺序扫描调度算法等。
二、磁盘调度算法的优化策略1. 优先级调度算法优先级调度算法是一种基于优先级的磁盘调度算法。
在该算法中，系统为每个进程设置了一个优先级，优先级高的进程将优先获得磁盘访问权限。
这种算法可以有效地避免进程之间的争用，从而提高系统的响应速度和吞吐量。
2. 负载均衡调度算法负载均衡调度算法是一种基于负载均衡的磁盘调度算法。
在该算法中，系统将根据磁盘访问频率和访问时间等因素，将磁盘访问权限分配给不同的磁盘。
这种算法可以有效地避免磁盘的拥堵和负载不均，从而提高系统的性能和可靠性。
3. 动态优先级调度算法动态优先级调度算法是一种基于进程优先级的动态磁盘调度算法。
在该算法中，系统将根据进程的优先级和当前磁盘负载等因素，动态地调整进程的访问权限。
这种算法可以有效地避免进程之间的争用，从而提高系统的响应速度和吞吐量。
4. 轮询调度算法轮询调度算法是一种基于轮询的磁盘调度算法。
在该算法中，系统将定期对所有磁盘进行访问，以确保所有磁盘都得到充分的利用。
这种算法可以有效地避免磁盘的拥堵和负载不均，从而提高系统的性能和可靠性。
三、总结磁盘调度算法是操作系统中重要的一环，其优化策略可以提高系统的响应速度和吞吐量，从而提高系统的性能和可靠性。
常见的磁盘调度算法包括优先级调度算法、负载均衡调度算法、动态优先级调度算法和轮询调度算法等，其中每种算法都有其优势和劣势，系统管理员需要根据具体情况选择合适的算法。
实验六 磁盘调度算法
实验六磁盘调度算法【实验目的】通过这次实验，加深对磁盘调度算法的理解，进一步掌握先来先服务FCFS，最短寻道时间优先SSTF，SCAN和循环SCAN算法的实现方法。
【实验内容】问题描述：设计程序模拟先来先服务FCFS，最短寻道时间优先SSTF，SCAN 和循环SCAN算法的工作过程。
假设有n个磁道号所组成的磁道访问序列，给定开始磁道号m和磁头移动的方向（正向或者反向），分别利用不同的磁盘调度算法访问磁道序列，给出每一次访问的磁头移动距离，计算每种算法的平均寻道长度。
程序要求如下：1）利用先来先服务FCFS，最短寻道时间优先SSTF，SCAN和循环SCAN算法模拟磁道访问过程。
2）模拟四种算法的磁道访问过程，给出每个磁道访问的磁头移动距离。
3）输入：磁道个数n和磁道访问序列，开始磁道号m和磁头移动方向（对SCAN和循环SCAN算法有效），算法选择1-FCFS，2-SSTF，3-SCAN，4-循环SCAN。
4）输出：每种算法的平均寻道长度。
【实验代码】#include <iostream>#include <fstream>#include <iomanip>#include <stdio.h>using namespace std;const int MaxNumber=100;int TrackOrder[MaxNumber];//磁盘访问序列int MoveDistance[MaxNumber];//磁头每次移动的距离double A verageDistance;//平均寻道长度bool direction;//SCAN和CSCAN算法的磁头移动方向int M;//开始磁道号int N;//磁道个数void inputData(){cout<<"请输入磁道个数N: ";cin>>N;cout<<"\n请输入磁盘访问顺序(此部分由文件读入)。
操作系统实验第五讲磁盘调度算法
操作系统实验报告哈尔滨工程大学计算机科学与技术学院第六讲磁盘调度算法一、实验概述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算法。
磁盘调度算法实验报告 (2)
磁盘调度算法学生姓名:学生学号:专业班级:指导老师：2013年6月20日1、实验目的：通过这次实验，加深对磁盘调度算法的理解，进一步掌握先来先服务FCFS、最短寻道时间优先SSTF、SCAN和循环SCAN算法的实现方法。
2、问题描述：设计程序模拟先来先服务FCFS、最短寻道时间优先SSTF、SCAN 和循环SCAN算法的工作过程。
假设有n个磁道号所组成的磁道访问序列，给定开始磁道号m和磁头移动的方向（正向或者反向），分别利用不同的磁盘调度算法访问磁道序列，给出每一次访问的磁头移动距离，计算每种算法的平均寻道长度。
3、需求分析通过这次实验，加深对磁盘调度算法的理解，进一步掌握先来先服务FCFS、最短寻道时间优先SSTF、SCAN和循环SCAN算法的实现方法。
通过已知开始磁道数、访问磁道总数、磁道号访问序列、访问方向及访问方式得到访问序列及移动距离和平均移动距离！(1)输入的形式；int TrackOrder[MaxNumber];//被访问的磁道号序列 int direction;//寻道方向int Num;//访问的磁道号数目int start;//(2)输出的形式；int MoveDistance[MaxNumber]={0};//移动距离double AverageDistance=0;//平均寻道长度移动的序列！(3)程序所能达到的功能；模拟先来先服务FCFS、最短寻道时间优先SSTF、SCAN和循环SCAN 算法的工作过程。
假设有n个磁道号所组成的磁道访问序列，给定开始磁道号m和磁头移动的方向（正向或者反向），分别利用不同的磁盘调度算法访问磁道序列，给出每一次访问的磁头移动距离，计算每种算法的平均寻道长度。
(4)测试数据，包括正确的输入及其输出结果和含有错误的输入及其输出结果。
开始磁道号：100磁道号方向：内（0）和外（1）磁道号数目：9页面序列：55 58 39 18 90 160 150 38 1844、概要设计说明本程序中用到的所有抽象数据类型的定义、主程序的流程以及各程序模块之间的层次(调用)关系。
磁盘调度实验报告
磁盘调度实验报告磁盘调度实验报告一、引言磁盘调度是操作系统中的一个重要组成部分，其作用是对磁盘上的数据进行合理的调度和管理，以提高磁盘的读写效率。
本文将对磁盘调度实验进行详细的分析和总结，探讨不同的磁盘调度算法对磁盘性能的影响。
二、实验目的本次实验的目的是通过模拟不同的磁盘调度算法，比较它们在不同情况下的性能表现，包括平均寻道时间、平均旋转延迟时间和平均访问时间等指标。
通过实验结果的对比分析，我们可以了解不同磁盘调度算法的优劣，并选择适合特定应用场景的磁盘调度算法。
三、实验环境和方法本次实验使用了模拟磁盘调度的软件，并设置了不同的磁盘调度算法进行对比。
实验环境为一台配置良好的计算机，操作系统为Windows 10。
实验方法是通过设置不同的磁盘访问序列，模拟磁盘的读写操作，并记录相应的性能指标。
四、实验结果和分析在本次实验中，我们选择了三种常见的磁盘调度算法进行对比，分别是先来先服务（FCFS）、最短寻道时间优先（SSTF）和电梯算法。
下面将分别对这三种算法的实验结果进行分析。
1. 先来先服务（FCFS）先来先服务算法是最简单的一种磁盘调度算法，它按照请求的顺序进行调度。
实验结果显示，当磁盘访问序列较为随机时，FCFS算法的性能表现较差。
这是因为当磁盘访问序列随机时，FCFS算法无法充分利用磁盘的局部性原理，导致平均寻道时间较长。
2. 最短寻道时间优先（SSTF）最短寻道时间优先算法是一种比较常用的磁盘调度算法，它选择离当前磁头位置最近的磁道进行访问。
实验结果显示，SSTF算法在随机磁盘访问序列下表现优秀，平均寻道时间较短。
这是因为SSTF算法能够充分利用磁盘的局部性原理，尽可能减小寻道时间。
3. 电梯算法电梯算法是一种比较灵活的磁盘调度算法，它模拟了电梯的运行方式。
当磁头移动的方向没有改变时，电梯算法按照最短寻道时间优先的原则进行调度；当磁头移动的方向改变时，电梯算法改变调度方向，并按照当前方向上最远的磁道进行访问。
磁盘调度算法的实现
一、实验目的:通过模拟设计磁盘驱动调度程序，观察驱动调度程序的动态运行过程，理解和掌握磁盘驱动调度的职能，并比较各种算法的调度结果。
二、实验容:要求设计主界面能灵活选择某算法，且以下算法都要实现。
（1）先来先服务算法（FCFS）（2）最短寻道时间优先算法（SSTF）（3）扫描算法（SCAN）（4）循环扫描算法（CSCAN）三、实验步骤（1）需求分析：本设计中可在运行时随机产生一个请求序列，先把序列排序，以方便找到下一个要寻找的磁道。
要求用户选择磁头移动方向，向里和向外移动用1和0表示，若输入值不为0或1，则报错。
选择某种调度算法后，要求显示调度顺序和移动的总磁道数。
（2）详细设计：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;}实验源代码#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;}（3）测试结果：1.先来先服务算法（FCFS）测试结果2.最短寻道时间算法（SSTF）测试结果3.循环扫描算法（SCAN）测试结果4.循环扫描算法（CSCAN）测试结果四、设计总结:此次设计基本完成了本实验所规定的功能，但是还不够完善，很多东西做的不够好，程序不够完善和严谨。
6.磁盘调度实验报告
操作系统实验报告磁盘调度实验六：磁盘调度算法一．实验目的复习模拟实现一种磁盘调度算法，进一步加深对磁盘调度效率的理解。
二．实验属性该实验为设计性实验。
三．实验仪器设备及器材普通PC386以上微机四．实验要求本实验要求2学时完成。
本实验要求完成如下任务：（1）建立相关的数据结构，作业控制块、已分配分区及未分配分区（2）实现一个分区分配算法，如最先适应分配算法、最优或最坏适应分配算法（3）实现一个分区回收算法（4）给定一批作业/进程，选择一个分配或回收算法，实现分区存储的模拟管理实验前应复习实验中所涉及的理论知识和算法，针对实验要求完成基本代码编写并完成预习报告、实验中认真调试所编代码并进行必要的测试、记录并分析实验结果。
实验后认真书写符合规范格式的实验报告（参见附录A），并要求用正规的实验报告纸和封面装订整齐，按时上交。
五 .主要算法分析各个算法分析1.先来先服务算法（FCFS）先来先服务（FCFS）调度:按先来后到次序服务，未作优化。
最简单的移臂调度算法是“先来先服务”调度算法，这个算法实际上不考虑访问者要求访问的物理位置，而只是考虑访问者提出访问请求的先后次序。
例如，如果现在读写磁头正在50号柱面上执行输出操作，而等待访问者依次要访问的柱面为130、199、32、159、15、148、61、99，那么，当50号柱面上的操作结束后，移动臂将按请求的先后次序先移到130号柱面，最后到达99号柱面。
采用先来先服务算法决定等待访问者执行输入输出操作的次序时，移动臂来回地移动。
先来先服务算法花费的寻找时间较长，所以执行输入输出操作的总时间也很长。
2.最短寻道时间优先算法（SSTF）最短寻找时间优先调度算法总是从等待访问者中挑选寻找时间最短的那个请求先执行的，而不管访问者到来的先后次序。
现在仍利用同一个例子来讨论，现在当50号柱面的操作结束后，应该先处理61号柱面的请求，然后到达32号柱面执行操作，随后处理15号柱面请求，后继操作的次序应该是99、130、148、159、199。
磁盘调度算法求平均寻道长度
磁盘调度算法求平均寻道长度磁盘是可供多个进程共享的设备，当有多个进程都要求访问磁盘时，应采用一种最佳调度算法，以使各进程对磁盘的平均访问时间最小。
由于在访问磁盘的时间中，主要是寻道时间，因此，磁盘调度的目标，是使磁盘的平均寻道时间最少。
目前常用的磁盘调度算法有：先来先服务、最短寻道时间优先及扫描算法。
1、FCFS最简单的调度算法是“先来先服务”调度算法，这个算法实际上不考虑访问者要求访问的物理位置，而只是考虑访问者提出访问请求的先后次序。
例如，如果现在读写磁头正在50号柱面上执行输出操作，而等待访问者依次要访问的柱面为130、199、32、159、15、148、61、99，那么，当50号柱面上的操作结束后，移动臂将按请求的先后次序先移到130号柱面，最后到达99号柱面。
采用先来先服务算法决定等待访问者执行输入输出操作的次序时，移动臂来回地移动。
先来先服务算法花费的寻找时间较长，所以执行输入输出操作的总时间也很长。
它是从就绪队列中选择一个估计运行时间最短的进程，将处理器分配给该进程，使之占有处理器并执行，直到该进程完成或因发生事件而阻塞，然后退出处理器，再重新调度。
单项扫描调度算法的基本思想是，不考虑访问者等待的先后次序，总是从0号柱面开始向里道扫描，按照各自所要访问的柱面位置的次序去选择访问者。
在移动臂到达最后一个柱面后，立即快速返回到0号柱面，返回时不为任何的访问者等待服务。
在返回到0号柱面后，再次进行扫描。
对上述相同的例子采用单向扫描调度算法的执行次序由于该例中已假定读写的当前位置在50号柱面，所以，指示了从50号柱面继续向里扫描，依次为61、99、130、148、159、199各柱面的访问者服务，此时移动臂已经是最内的柱面，于是立即返回到0号柱面，重新扫描，依次为15、32号柱面的访问者服务。
当磁头刚从里向外移动而越过了某一磁道进,恰好又有一进程请求访问此磁道,这时,该进程必须等待,待磁头继续从里向外,然后再从外向里扫描完所有要访问的磁道后,才处理该进程的请求,致使该进程的请求被大大地推迟。
磁盘调度算法实验要求及算法
磁盘调度算法编程序实现下述磁盘调度算法，并求出每种算法的平均寻道长度。
设计要求：（1）能够输入程序要访问的磁道序列和磁头当前所在的磁道数。
（2）可以选择某磁盘调度算法（先来先服务算法、最短寻道时间优先算法、扫描算法和循环扫描算法）。
（3）能够以下图形式显示磁盘调度顺序和平均寻道长度。
/*FCFS 先来先服务：根据进程请求访问磁盘的先后次序进行调度；SSTF 最短寻道时间优先：其要求访问的磁头与当前磁头所在的磁道距离最近，以使每次的寻道时间最短；SCAN 扫描算法：CSCAN 循环扫描算法：*/#include<iostream>using namespace std;#include<math.h>#define maxsize 1000int *bubble(int cidao[],int m) //使用冒泡法按从小到大顺序排列{int i,j;int temp;for(i=0;i<m;i++)for(j=i+1;j<m;j++){if(cidao[i]>cidao[j]){temp=cidao[i];cidao[i]=cidao[j];cidao[j]=temp;}}cout<<"排序后的磁盘序列为：";for( i=0;i<m;i++) //输出排序结果{cout<<cidao[i]<<" ";}cout<<endl;return cidao;}void FCFS(int cidao[],int m) //磁道号数组，个数为m{int now;//当前磁道号int sum=0; //总寻道长度int j,i;float ave; //平均寻道长度cout<<"磁盘请求序列为：";for( i=0;i<m;i++) //按先来先服务的策略输出磁盘请求序列{cout<<cidao[i]<<" ";}cout<<endl;cout<<"请输入当前的磁道号：";cin>>now ;sum+= abs(cidao[0]-now); //求绝对值cout<<"磁盘扫描序列为：";for( i=0;i<m;i++) //输出磁盘扫描序列{cout<<cidao[i]<<" ";}for(i=0,j=1;j<m;i++,j++) //求平均寻道长度{sum+=abs(cidao[j]-cidao[i]);ave=(float)(sum)/(float)(m);}cout<<endl;cout<<"平均寻道长度："<<ave<<endl;}void SSTF(int cidao[],int m) //磁道号数组，个数为m{int k=1;int now,l,r;int i,j,sum=0;float ave;cidao=bubble(cidao,m); //调用冒泡排序算法排序从小到大cout<<"请输入当前的磁道号：";cin>>now;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) //确定当前磁道在已排的序列中的位置，后面的算法都用到了，可以直接复制后少量修改，节省时间。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验六磁盘调度算法一、需求分析 (1)1.输入的形式和输入值的范围 (2)2.输出的形式 (2)3.程序所能达到的功能 (3)4.测试数据 (4)二、概要设计 (5)1.抽象数据类型的定义 (5)2.主程序的流程 (6)3.各程序模块之间的层次(调用)关系 (7)三、详细设计 (7)1.void FCFS() (7)2.void sort() (7)3.void SSTF() (8)4.void SCAN() (10)四、调试分析 (14)1.调试过程中遇到的问题以及解决方法，设计与实现的回顾讨论和分析 (14)2.算法的性能分析(包括基本操作和其它算法的时间复杂度和空间复杂度的分析)及其改进设想； (14)3.经验和体会。
(14)五、用户使用说明 (14)六、测试结果 (15)七、附录 (18)一、需求分析●需求磁盘是可供多个进程共享的设备，当有多个进程都要要求访问磁盘时，应采用一种最佳的调度算法，以使各进程对磁盘的平均访问时间最小。
由于在访问磁盘的时间中，主要是寻道时间，因此，磁盘调度的目标是使磁盘的平均寻道时间最少。
●实验目的通过这次实验，加深对磁盘调度算法的理解，进一步掌握先来先服务FCFS、最短寻道时间优先SSTF、SCAN和循环SCAN算法的实现方法。
1.输入的形式和输入值的范围从dos控制台界面按照输入提示输入数据（红色的数字即为输入的内容）：要访问的磁道数（number）：9要访问的磁道号(TrackOrder)：55, 58, 39, 18, 90, 160, 150, 38, 184进程的最大磁道数为100，磁道数位0~100，磁道号为int类型的范围。
2.输出的形式输入数据后，按ENTER键就可在dos控制台界面得到结果。
按照实验要求分别输出模拟先来先服务FCFS、最短寻道时间优先SSTF、SCAN和循环SCAN算法的工作过程。
结果如下：3.程序所能达到的功能程序模拟先来先服务FCFS、最短寻道时间优先SSTF、SCAN和循环SCAN算法的工作过程。
假设有n个磁道号所组成的磁道访问序列，给定开始磁道号m和磁头移动的方向（正向或者反向），分别利用不同的磁盘调度算法访问磁道序列，给出每一次访问的磁头移动距离，计算每种算法的平均寻道长度。
4.测试数据二、概要设计1.抽象数据类型的定义const int MaxNumber=100;int TrackOrder[MaxNumber];int MoveDistance[MaxNumber];double AverageDistance;bool direction;void print();//输出。
模拟过程void FCFS();void SSTF();void SCAN();void CSCAN();void init();//输入值void TurnBack();//还原初始值void sort();//排序2.主程序的流程Init()输入aa=1 a=2 a=3 a=4 a=5结束FCFS()SSIF()SCAN()CSAN()模拟算法磁道访问过程及输出平均寻道长度初始化全局变量：磁道个数和磁道访问序列，开始磁道号否否否否是是是是是否磁头移动方向3.各程序模块之间的层次(调用)关系Main()Init()Print() FCFS()SSTF()SCAN()CSCAN()Print()Print()Print()调用1 2 3 4三、详细设计1.void FCFS()//先来先服务FCFScout<<"先来先服务FCFS\n";TurnBack();for(i=0;i<TrackNum;i++){if(i==0)MoveDistance[i]=abs(begin-FinalOrder[i]);else//取绝对值MoveDistance[i]=abs(FinalOrder[i]-FinalOrder[i-1]);}}2.void sort(){for(i=0;i<TrackNum;i++)SortOrder[i]=TrackOrder[i];//排序，并赋值给SortOrder[]int min,temp;for(i=0;i<TrackNum;i++){min=i;for(j=i;j<TrackNum;j++)if(SortOrder[min]>SortOrder[j])min=j;temp=SortOrder[i];SortOrder[i]=SortOrder[min];SortOrder[min]=temp;}// for(i=0;i<TrackNum;i++)// cout<<SortOrder[i];}3.void SSTF()//最短寻道时间优先SSTFcout<<"最短寻道时间优先SSTF\n";TurnBack();sort();//查找合适的磁道，最接近！赋值给FinalOrder[]；int low=0,high=TrackNum-1,mid;//low标记磁道号的下端起始，high表示磁道号的上端起始//折半查找合适的磁道,mid值是最接近查找值得值while(low<=high){mid=(low+high)/2;if(begin==SortOrder[mid]){low=mid-1;high=mid+1;break;}else if(begin<SortOrder[mid])high=mid-1;elselow=mid+1;}//cout<<"mid: "<<mid<<" high: "<<high<<"low :"<<low<<"begin:"<<begin<<endl;k=0;if(abs(high-low)==2){FinalOrder[k]=SortOrder[mid];k++;}else if(high==low){high++;}else{int t=high;high=low;low=t;}if(abs(SortOrder[low]-begin)<=abs(SortOrder[high]-begin)) {for(i=low;i>=0;i--){FinalOrder[k]=SortOrder[i];k++;}for(i=high;i<TrackNum;i++){FinalOrder[k]=SortOrder[i];k++;}}else{for(i=high;i<TrackNum;i++){FinalOrder[k]=SortOrder[i];k++;}for(i=low;i>=0;i--){FinalOrder[k]=SortOrder[i];k++;}}for(i=0;i<TrackNum;i++){if(i==0)MoveDistance[i]=abs(begin-FinalOrder[i]);else//取绝对值MoveDistance[i]=abs(FinalOrder[i]-FinalOrder[i-1]);}}4.void SCAN()//SCAN算法TurnBack();sort();char c;bool r=true;while(r){cout<<"选择磁头移动方向，向磁道号增加方向：输入'a',向磁道号递减方向：输入'd'\n";cin>>c;if(c=='a'||c=='A')//向磁道号增加方向{ direction=true;r=false;}else if(c=='d'||c=='D'){ direction=false;r=false;}elsecout<<"你的输入有误！请重新输入！";}//查找合适的磁道，最接近！赋值给FinalOrder[]；int low=0,high=TrackNum-1,mid;//low标记磁道号的下端起始，high表示磁道号的上端起始//折半查找合适的磁道,mid值是最接近查找值得值while(low<=high){mid=(low+high)/2;if(begin==SortOrder[mid]){low=mid-1;high=mid+1;break;}else if(begin<SortOrder[mid])high=mid-1;elselow=mid+1;}k=0;if(abs(high-low)==2){FinalOrder[k]=SortOrder[mid];k++;}else if(high==low){high++;}else{int t=high;high=low;low=t;}if(direction)//向磁道号增加方向{for(i=high;i<TrackNum;i++){FinalOrder[k]=SortOrder[i];k++;}for(i=low;i>=0;i--){FinalOrder[k]=SortOrder[i];k++;}}else{for(i=low;i>=0;i--){FinalOrder[k]=SortOrder[i];k++;}for(i=high;i<TrackNum;i++){FinalOrder[k]=SortOrder[i];k++;}}for(i=0;i<TrackNum;i++){if(i==0)MoveDistance[i]=abs(begin-FinalOrder[i]);else//取绝对值MoveDistance[i]=abs(FinalOrder[i]-FinalOrder[i-1]);}}4.void CSCAN()//循环SCAN算法TurnBack();sort();char c;bool r=true;while(r){cout<<"选择磁头移动方向，向磁道号增加方向：输入'a',向磁道号递减方向：输入'd'\n";cin>>c;if(c=='a'||c=='A'){ direction=true;r=false;}else if(c=='d'||c=='D'){ direction=false;r=false;}elsecout<<"你的输入有误！请重新输入！";}//查找合适的磁道，最接近！赋值给FinalOrder[]；int low=0,high=TrackNum-1,mid;//low标记磁道号的下端起始，high表示磁道号的上端起始//折半查找合适的磁道,mid值是最接近查找值得值while(low<=high){mid=(low+high)/2;if(begin==SortOrder[mid]){low=mid-1;high=mid+1;break;}else if(begin<SortOrder[mid])high=mid-1;elselow=mid+1;}k=0;if(abs(high-low)==2){FinalOrder[k]=SortOrder[mid];k++;}else if(high==low){high++;}else{int t=high;high=low;low=t;}if(direction)//向磁道号增加方向{for(i=high;i<TrackNum;i++){FinalOrder[k]=SortOrder[i];k++;}for(i=0;i<=low;i++){FinalOrder[k]=SortOrder[i];k++;}}else{for(i=low;i>=0;i--){FinalOrder[k]=SortOrder[i];k++;}for(i=TrackNum-1;i>=high;i--){FinalOrder[k]=SortOrder[i];k++;}}for(i=0;i<TrackNum;i++){if(i==0)MoveDistance[i]=abs(begin-FinalOrder[i]);else//取绝对值MoveDistance[i]=abs(FinalOrder[i]-FinalOrder[i-1]);}四、调试分析1.调试过程中遇到的问题以及解决方法，设计与实现的回顾讨论和分析在编写扫描（SCAN）算法跟循环扫描（CSCAN）算法时，没有注意到扫描的方向，默认为向磁道号增加的方向。