实验四 磁盘驱动调度算法的模拟
磁盘调度算法的模拟实现及对比
磁盘调度算法的模拟实现及对比磁盘调度算法是操作系统中的一个重要组成部分，用于优化磁盘读写操作的效率，提高系统的响应速度和运行效率。
常见的磁盘调度算法包括先来先服务(FCFS)算法、最短寻道时间优先(SSTF)算法、电梯(Elevator)算法等。
在进行磁盘调度算法的比较和模拟之前，我们首先需要了解磁盘读写操作的基本原理。
磁盘是由许多磁道和扇区组成的，当操作系统需要对磁盘进行读写操作时，读写头需要按照特定的路径移动到目标扇区，这个过程称为寻道。
而磁头在寻道的过程中所花费的时间称为寻道时间。
不同的磁盘调度算法的主要目标就是使得寻道时间尽可能地短，从而提高磁盘的读写操作效率。
首先，我们来实现一个先来先服务(FCFS)算法的模拟。
FCFS算法是最简单的磁盘调度算法，它按照磁盘请求的先后顺序进行处理。
具体实现如下：```pythondef fcfs(disk_queue, start):head_movement = 0curr_pos = startfor request in disk_queue:head_movement += abs(request - curr_pos)curr_pos = requestreturn head_movement```上述代码中，`disk_queue`表示磁盘请求队列，`start`表示起始磁道号。
算法首先将磁头移动到起始磁道号`start`，然后按照磁盘请求的先后顺序对队列中的请求进行处理，计算磁头的移动距离。
最后返回磁头的总移动距离。
接下来，我们实现一个最短寻道时间优先(SSTF)算法的模拟。
SSTF 算法会选择离当前磁道最近的请求进行处理，从而减少磁头的寻道时间。
具体实现如下：```pythondef sstf(disk_queue, start):head_movement = 0curr_pos = startwhile disk_queue:min_distance = float('inf')min_index = -1for i, request in enumerate(disk_queue):distance = abs(request - curr_pos)if distance < min_distance:min_distance = distancemin_index = ihead_movement += min_distancecurr_pos = disk_queue.pop(min_index)return head_movement```上述代码中，算法首先将磁头移动到起始磁道号`start`，然后不断选择离当前磁道最近的请求处理，直到所有请求处理完毕。
磁盘调度操作系统实验报告
磁盘调度操作系统实验报告一、实验目的：本次实验主要目的是通过模拟实现磁盘调度算法，加深对操作系统磁盘调度原理的理解，并学会使用操作系统磁盘调度算法解决实际问题。
二、实验内容：1.磁盘调度算法原理分析：磁盘调度算法是操作系统中的重要组成部分，它的任务是合理安排磁盘上数据的存取顺序，以提高磁盘的效率。
常见的磁盘调度算法有先来先服务（FCFS）、最短寻道时间优先（SSTF）、电梯算法（SCAN）等。
2.模拟实现磁盘调度算法：本实验选择最短寻道时间优先算法（SSTF）作为示例进行模拟实现。
SSTF算法的原理是优先选择离当前磁头位置最近的磁道进行访问，以减少磁头移动时间。
实验步骤：1.根据实际情况，创建一个磁道队列，记录需要访问的磁道序号。
2.初始化磁盘的起始位置和访问队列。
3.对访问队列进行排序，按照磁头当前位置到磁道的距离从小到大排列。
4.根据排序后的队列顺序，依次访问磁道，并记录磁头移动的距离。
5.计算平均寻道长度。
三、实验结果分析：通过模拟实现SSTF磁盘调度算法，我们获得了磁头对每个磁道的访问顺序和总共的磁头移动距离。
根据实验结果，我们可以发现SSTF算法相对于其他算法具有一定的优势。
在实际应用中，根据不同的实际情况，可以选择合适的磁盘调度算法以优化磁盘的访问效率。
四、实验总结：通过本次实验，我们对磁盘调度算法的原理和实现有了更深入的了解。
磁盘调度算法作为操作系统中一个重要的模块，对提高磁盘的读写效率起着重要的作用。
在实际应用中，我们需要根据具体问题选择合适的磁盘调度算法，以达到最优的访问效果。
磁盘调度算法的模拟实现
磁盘调度算法的模拟实现学院专业学号学生姓名指导教师姓名2014年3月19日目录一、课设简介 (2)1.1 课程设计题目 (2)1.2 课程设计目的 (2)1.3 课程设计要求 (2)二、设计内容 (3)2.1功能实现 (3)2.2流程图 (3)2.3具体内容 (3)三、测试数据 (4)3.3 测试用例及运行结果 (4)四、源代码 (5)五、总结 (12)5.1 总结............................................一、课设简介1.1课程设计题目磁盘调度算法的模拟实现11.2程序设计目的操作系统课程设计是计算机专业重要的教学环节，它为学生提供了一个既动手又动脑，将课本上的理论知识和实际有机的结合起来，独立分析和解决实际问题的机会。
1）进一步巩固和复习操作系统的基础知识。
2）培养学生结构化程序、模块化程序设计的方法和能力。
3）提高学生调试程序的技巧和软件设计的能力。
4）提高学生分析问题、解决问题以及综合利用C语言进行程序设计的能力。
1.3 设计要求1）磁头初始磁道号，序列长度，磁道号序列等数据可从键盘输入，也可从文件读入。
2）最好能实现磁道号序列中磁道号的动态增加。
3）磁道访问序列以链表的形式存储4）给出各磁盘调度算法的调度顺序和平均寻道长度二、设计内容2.1 功能实现设计并实现一个本别利用下列磁盘调度算法进行磁盘调度的模拟程序。
1） 先来先服务算法FCFS 2） 最短寻道时间优先算法SSTF 2.2流程图2.3具体内容1)先来先服务算法FCFS这是一种比较简单的磁盘调度算法。
它根据进程请求访问磁盘的先后次序进行调度。
此算法的优点是公平、简单，且每个进程的请求都能依次得到处理，不会出现某一进程的请求长期得不到满足的情况。
此算法由于未对寻道进行优化，在对磁盘的访问请求比较多的情开始 选择算法 F C F S S S T F 结束况下，此算法将降低设备服务的吞吐量，致使平均寻道时间可能较长，但各进程得到服务的响应时间的变化幅度较小。
磁盘驱动调度算法的模拟
实验四磁盘驱动调度算法的模拟一．实验内容：熟悉磁盘的结构以及磁盘的驱动调度算法的模拟，编程实现简单常用的磁盘驱动调度算法先来先服务（FIFO）、电梯调度算法、最短寻找时间优先算法、扫描（双向扫描）算法、单向扫描（循环扫描）算法等。
编程只需实现两个算法。
题目可以选取教材或习题中的相关编程实例。
编程语言建议采用c/c++或Java。
模拟程序鼓励采用随机数技术、动态空间分配技术，有条件的最好能用图形界面展现甚至用动画模拟。
实验性质：验证型。
二．实验目的和要求1）掌握使用一门语言进行磁盘驱动调度算法的模拟；2）编写程序将磁盘驱动调度算法的过程和结果能以较简明直观的方式展现出来。
三．实验原理、方法和步骤1. 实验原理磁盘驱动调度对磁盘的效率有重要影响。
磁盘驱动调度算法的好坏直接影响辅助存储器的效率，从而影响计算机系统的整体效率。
常用的磁盘驱动调度算法有：最简单的磁盘驱动调度算法是先入先出（F IFO）法。
这种算法的实质是，总是严格按时间顺序对磁盘请求予以处理。
算法实现简单、易于理解并且相对公平，不会发生进程饿死现象。
但该算法可能会移动的柱面数较多并且会经常更换移动方向，效率有待提高。
最短寻找时间优先算法：总是优先处理最靠近的请求。
该算法移动的柱面距离较小，但可能会经常改变移动方向，并且可能会发生进程饥饿现象。
电梯调度：总是将一个方向上的请求全部处理完后，才改变方向继续处理其他请求。
扫描（双向扫描）：总是从最外向最里进行扫描，然后在从最里向最外扫描。
该算法与电梯调度算法的区别是电梯调度在没有最外或最里的请求时不会移动到最外或最里柱面，二扫描算法总是移到最外、最里柱面。
两端的请求有优先服被务的迹象。
循环扫描（单向扫描）：从最外向最里进行柱面请求处理，到最里柱面后，直接跳到最外柱面然后继续向里进行处理。
该算法与扫描算法的区别是，回来过程不处理请求，基于这样的事实，因为里端刚被处理。
2. 实验方法1）使用流程图描述演示程序的设计思想；2）选取c/c++、Java等计算机语言，编程调试，最终给出运行正确的程序。
驱动调度
实验4 驱动调度一、实验内容模拟电梯调度算法，实现对磁盘的驱动调度。
二、实验目的磁盘是一种高速、大量旋转型、可直接存取的存储设备。
它作为计算机系统的辅助存储器，负担着繁重的输入输出任务，在多道程序设计系统中，往往同时会有若干个要求访问磁盘的输入输出请示等待处理。
系统可采用一种策略，尽可能按最佳次序执行要求访问磁盘的诸输入输出请求，这就叫驱动调度，使用的算法称驱动调度算法。
驱动调度能降低为若干个输入输出请求服务所须的总时间，从而提高系统效率。
本实验要求学生模拟设计一个驱动调度程序，观察驱动调度程序的动态运行过程。
三、实验原理模拟电梯调度算法，对磁盘调度。
磁盘是要供多个进程共享的存储设备，但一个磁盘每个时刻只能为一个进程服务。
当有进程在访问某个磁盘时，其他想访问该磁盘的进程必须等待，直到磁盘一次工作结束。
当有多个进程提出输入输出请求处于等待状态，可用电梯调度算法从若干个等待访问者中选择一个进程，让它访问磁盘。
当存取臂仅需移到一个方向最远的所请求的柱面后,如果没有访问请求了,存取臂就改变方向。
假设磁盘有200个磁道，用C语言随机函数随机生成一个磁道请求序列（不少于15个）放入模拟的磁盘请求队列中，假定当前磁头在100号磁道上，并向磁道号增加的方向上移动。
请给出按电梯调度算法进行磁盘调度时满足请求的次序,并计算出它们的平均寻道长度。
四、算法流程图五、源程序和注释1.程序中使用的数据结构及符号说明。
#define NUM 15 //数组大小#define NOW 100 //起始寻道地址int C[NUM*2],flag,temp,i,j; //C[]数组,flag标志,temp交换标志double total=0; //平均寻道长度2. 源程序和注释#include<stdio.h>#include<stdlib.h>#include<math.h>#define NUM 15 //数组大小#define NOW 100 //起始寻道地址int C[NUM*2],flag,temp,i,j; //C[]数组,flag标志,temp交换标志double total=0; //平均寻道长度void input()//产生15个数字均小于200{printf("\n15 random numbers from 0 to 199\n\n");for(i=0;i<NUM;i++){C[i]=rand()%200;printf("C[%d]=%d;\t",i,C[i]);}}void turn()//次序对换{for(i=0;i<NUM/2;i++){temp=C[i];C[i]=C[NUM-i-1];C[NUM-i-1]=temp;}}void last(){for(i=0;i<flag+1;i++)//部分后移{C[i+NUM]=C[i];C[i]=0;}for(i=0;i<NUM;i++)//整体前移{C[i]=C[i+flag+1];}}void output()//输出数组的值{printf("\n15 order numbers from 0 to 199\n\n");for(i=0;i<NUM;i++){printf("C[%d]=%d;\t",i,C[i]);}}void order_1()//对15个数字进行从小到大排序{for(i=0;i<NUM;i++){for(j=i;j<NUM;j++){if(C[j]<C[i]){temp=C[j];C[j]=C[i];C[i]=temp;}}}}void order_2()//判定100的分界线{if(C[0]>=NOW)//均大于NOW{flag=15;}else if(C[14]<NOW)//均小于NOW{flag=14;}else{for(i=0;i<NUM-1;i++){if(C[i]<NOW&&C[i+1]>=NOW){flag=i;}}}}void work()//求平均寻道{total=fabs(C[0]-100);for(i=0;i<NUM-1;i++){total=total+fabs(C[i+1]-C[i]);}total=total/15;printf("total=%f;\n",total);}void main(){input();order_1();order_2();last();output();work();}六、程序运行时的初值和运行结果。
磁盘调度算法的模拟实现
磁盘调度算法的模拟实现学院专业学号学生姓名指导教师姓名2014年3月19日目录一、课设简介 (2)1.1 课程设计题目 (2)1.2 课程设计目的 (2)1.3 课程设计要求 (2)二、设计内容 (3)2.1功能实现 (3)2.2流程图 (3)2.3具体内容 (3)三、测试数据 (4)3.3 测试用例及运行结果 (4)四、源代码 (5)五、总结 (12)5.1 总结............................................一、课设简介1.1课程设计题目磁盘调度算法的模拟实现11.2程序设计目的操作系统课程设计是计算机专业重要的教学环节，它为学生提供了一个既动手又动脑，将课本上的理论知识和实际有机的结合起来，独立分析和解决实际问题的机会。
1）进一步巩固和复习操作系统的基础知识。
2）培养学生结构化程序、模块化程序设计的方法和能力。
3）提高学生调试程序的技巧和软件设计的能力。
4）提高学生分析问题、解决问题以及综合利用C语言进行程序设计的能力。
1.3 设计要求1）磁头初始磁道号，序列长度，磁道号序列等数据可从键盘输入，也可从文件读入。
2）最好能实现磁道号序列中磁道号的动态增加。
3）磁道访问序列以链表的形式存储4）给出各磁盘调度算法的调度顺序和平均寻道长度二、设计内容2.1 功能实现设计并实现一个本别利用下列磁盘调度算法进行磁盘调度的模拟程序。
1） 先来先服务算法FCFS 2） 最短寻道时间优先算法SSTF 2.2流程图2.3具体内容1)先来先服务算法FCFS这是一种比较简单的磁盘调度算法。
它根据进程请求访问磁盘的先后次序进行调度。
此算法的优点是公平、简单，且每个进程的请求都能依次得到处理，不会出现某一进程的请求长期得不到满足的情况。
此算法由于未对寻道进行优化，在对磁盘的访问请求比较多的情开始 选择算法 F C F S S S T F 结束况下，此算法将降低设备服务的吞吐量，致使平均寻道时间可能较长，但各进程得到服务的响应时间的变化幅度较小。
(完整word版)程序模拟磁盘调度设计实验4实验报告
《操作系统》实验报告三、实验过程或算法（源程序）程系统主界面可以灵活选择某种算法，算法包括：先来先服务算法（FCFS）、最短寻道时间优先算法（SSTF）、扫描算法（SCAN）、循环扫描算法（CSCAN）。
模块调用关系图：1、先来先服务算法（FCFS）这是一种比较简单的磁盘调度算法。
它根据进程请求访问磁盘的先后次序进行调度。
此算法的优点是公平、简单，且每个进程的请求都能依次得到处理，不会出现某一进程的请求长期得不到满足的情况。
此算法由于未对寻道进行优化，在对磁盘的访问请求比较多的情况下，此算法将降低设备服务的吞吐量，致使平均寻道时间可能较长，但各进程得到服务的响应时间的变化幅度较小。
2、最短寻道时间优先算法（SSTF）该算法选择这样的进程，其要求访问的磁道与当前磁头所在的磁道距离最近，以使每次的寻道时间最短，该算法可以得到比较好的吞吐量，但却不能保证平均寻道时间最短。
其缺点是对用户的服务请求的响应机会不是均等的，因而导致响应时间的变化幅度很大。
在服务请求很多的情况下，对内外边缘磁道的请求将会无限期的被延迟，有些请求的响应时间将不可预期。
3、扫描算法（SCAN）扫描算法不仅考虑到欲访问的磁道与当前磁道的距离，更优先考虑的是磁头的当前移动方向。
例如，当磁头正在自里向外移动时，扫描算法所选择的下一个访问对象应是其欲访问的磁道既在当前磁道之外，又是距离最近的。
这样自里向外地访问，直到再无更外的磁道需要访问才将磁臂换向，自外向里移动。
这时，同样也是每次选择这样的进程来调度，即其要访问的磁道，在当前磁道之内，从而避免了饥饿现象的出现。
由于这种算法中磁头移动的规律颇似电梯的运行，故又称为电梯调度算法。
此算法基本上克服了最短寻道时间优先算法的服务集中于中间磁道和响应时间变化比较大的缺点，而具有最短寻道时间优先算法的优点即吞吐量较大，平均响应时间较小，但由于是摆动式的扫描方法，两侧磁道被访问的频率仍低于中间磁道。
4、循环扫描算法（CSCAN）循环扫描算法是对扫描算法的改进。
磁盘调度算法的模拟
磁盘调度算法的模拟实验要求：⏹ 请分别用SCAN 和SSTF 模拟磁盘调度，并打印出磁盘磁道的调度顺序。
⏹磁头的方向可以动态的规定 ⏹磁道请求个数及序列可以动态地写入 ⏹ 总结收获体会及对该题解的改进意见和见解先将请求的磁道序列排序，以当前磁道号将该序列分界，根据当前磁道移动方向决定 先读左边的还是先读右边的SSTF算法：先将请求的磁道序列排序，以当前磁道号将该序列分界，然后当前磁道号分别与左边、右边磁道作差比较，选作差最小的，也即最短的。
并修改当前磁道号及其访问位(1为已访问完，0为未访问)。
（注：还要考虑左边或右边没有磁道的情况，如何确定所要与之比较的磁道）利用数组相关知识（图SSTF1. 当前磁道号在已排序的磁道请求序列中间的运行结果）（图SSTF2 当前磁道号在已排序的磁道请求序列最右边的运行结果）（图SSTF2 当前磁道号在已排序的磁道请求序列最左边的运行结果）SCAN源代码：#include<stdio.h>void main(){int m=0,n,Seek[100],SCurrent,t,i=0,j,k,option;printf("请输入当前的磁道号:");scanf("%d",&SCurrent);printf("\n----1.向磁道号增加的方向访问\t2.向磁道号减少的方向访问----\n");printf("---请选择的当前磁头移动方向(1/2):");scanf("%d",&option);printf("\n请输入磁道请求序列(以-999结束):\n");scanf("%d",&n);while(n!=-999){Seek[i]=n;m++;i++;scanf("%d",&n);}/* 冒泡排序使磁道请求序列从小到大排序 */for(j=0;j<m-1;j++){for(i=0;i<m-1-j;i++)if(Seek[i]>Seek[i+1]){t=Seek[i];Seek[i]=Seek[i+1];Seek[i+1]=t;}}/* 找到当前磁道号在磁道请求序列中的排序位置 */k=0;for(i=0;i<m;i++){if(Seek[i]<SCurrent)k++;elsebreak;}printf("\n--------------扫描(SCAN)算法后的磁盘调度序列----------\n");/* 第一种: 当前磁道号先向外再向里读 */if(option==1){for(i=k;i<m;i++)printf("%5d",Seek[i]);for(i=k-1;i>=0;i--)printf("%5d",Seek[i]);}/* 第二种: 当前磁道号先向里再向外读 */if(option==2){for(i=k-1;i>=0;i--)printf("%d ",Seek[i]);for(i=k;i<m;i++)printf("%5d",Seek[i]);}printf("\n");}SSTF源代码：#include<stdio.h>void main(){int m=0,n,Seek[100],Flag[100],SCurrent,t,i=0,j,k,i0,j0;printf("请输入当前的磁道号:");scanf("%d",&SCurrent);printf("\n请输入磁道请求序列(以-999结束):\n");scanf("%d",&n);while(n!=-999){Seek[i]=n;m++;i++;scanf("%d",&n);}/* 初始化置对应的磁道访问位为零 */for(i=0;i<m;i++)Flag[i]=0;/* 冒泡排序使磁道请求序列从小到大排序 */for(j=0;j<m-1;j++){for(i=0;i<m-1-j;i++)if(Seek[i]>Seek[i+1]){t=Seek[i];Seek[i]=Seek[i+1];Seek[i+1]=t;}}printf("\n--------------最短寻道时间优先(SSTF)算法后的磁盘调度序列----------\n");/* 找到当前磁道号在磁道请求序列中的排序位置 */k=0;for(i=0;i<m;i++){if(Seek[i]<SCurrent)k++;elsebreak;}//a. 已排序的磁道请求序列均在当前磁道号的右边//if(k==0){for(i=0;i<m;i++)printf("%5d",Seek[i]);k=-1;}//b. 已排序的磁道请求序列均在当前磁道号的左边//if(k==m){for(i=m-1;i>=0;i--)printf("%5d",Seek[i]);k=-1;}// c. 当前磁道号在已排序的请求序列的中间//if(k>0&&k<m){// 前后数与当前磁道号作差比较,选最近(差值最小)的if(Seek[k]-SCurrent>SCurrent-Seek[k-1])k--;printf("%5d",Seek[k]);SCurrent=Seek[k];Flag[k]=1;}while(k!=-1){i0=k-1;j0=k+1; //i0为当前磁道的靠左边的磁道号，j0为靠右边while(Flag[i0]==1&&i0>=0)i0--;while(Flag[j0]==1&&j0<m)j0++;// 1. 当前磁道号在已排序的磁道序列的最左边 //if(i0<0&&j0<m){for(i=j0;i<m;i++)printf("%5d",Seek[i]);k=-1;}// 2.当前磁道号在已排序的磁道序列的最右边 //if(i0>=0&&j0>=m){for(i=i0;i>=0;i--)printf("%5d",Seek[i]);k=-1;}// 3.当前磁道号在已排序的磁道序列的中间 //if(i0>=0&&j0<m){if(SCurrent-Seek[i0]<Seek[j0]-SCurrent){printf("%5d",Seek[i0]);Flag[i0]=1;SCurrent=Seek[i0];k=i0;}else{printf("%5d",Seek[j0]);Flag[j0]=1;SCurrent=Seek[j0];k=j0;}}}printf("\n");}。
磁盘调度的实验报告(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算法在请求序列较长时性能更稳定，且磁头移动次数更少。
操作系统课程设计-模拟电梯调度算法 实现对磁盘的驱动调度
衡阳师范学院操作系统课程设计报告设计题目：驱动调度系别：计算机科学系专业：计算机科学与技术（师范）班级：1001班姓名：XXX学号：XXX指导教师：XXX2012年11月26日目录一、程序设计内容原理及目的·······························1、设计内容················································`2、设计原理·················································3、设计目的·················································二、程序设计过程·········································1、驱动调度中的数据结构设计·································2、程序算法设计··············································三、用户手册··············································1、运行坏境··················································2、执行文件··················································四、程序实现及运行结果····································1、源代码····················································2、代码······················································3、运行结果·················································五、心得总结···············································六、参考文献···············································二、程序设计内容原理及目的1、设计内容模拟电梯调度算法，实现对磁盘的驱动调度。
磁盘驱动调度算法
操作系统课程设计题目：磁盘驱动调度算法模拟班级:姓名：学号：指导教师:成绩:6 月磁盘驱动调度算法模拟菜单显示FCFS算法SCAN算法SSTF算法CSCAN算法沿磁道增加方向沿磁道减小方向沿磁道增加方向沿磁道减小方向一、课程设计目的1.进一步加深对磁盘驱动调度算法的理解。
2.编程实现“先来先服务”、“最短寻道时间优先”、“电梯调度”、“循环扫描”算法。
二、课题内容1.假设一种磁盘含有4 个盘片，每个盘片有100 个磁道，每道有8 个扇区，模拟格式化时对柱面和扇区进行编号的过程。
2.设计若干磁道访问请求，规定顾客输入线性块号，系统能将其转换为对应的磁道号（柱面号），并计算出分别采用“先来先服务”、“最短寻道时间优先”、“电梯调度”、“循环扫描”算法的寻道总长度。
3．提供可视化且简洁清晰的顾客界面，能直观且动态地描述磁头移动。
三、设计思路（一）系统概要设计1.整体模块设计图2.有关知识磁盘调度：当有多个进程都请求访问磁盘时，采用一种合适的驱动调度算法，使各进程对磁盘的平均访问（重要是寻道）时间最小。
现在惯用的磁盘调度算法有：1）先来先服务2）最短寻道时间优先3）扫描算法4）循环扫描算法等3.算法思想介绍（1）先来先服务算法（FCFS）即先来的请求先被响应。
FCFS 方略看起来似乎是相称"公平"的，但是当请求的频率过高的时候FCFS 方略的响应时间就会大大延长。
FCFS 方略为我们建立起一种随机访问机制的模型，但是如果用这个方略重复响应从里到外的请求，那么将会消耗大量的时间。
为了尽量减少寻道时间，看来我们需要对等待着的请求进行合适的排序，而不是简朴的使用FCFS 方略。
这个过程就叫做磁盘调度管理。
有时候FCFS 也被看作是最简朴的磁盘调度算法。
（2）最短寻道时间优先算法（SSTF）最短时间优先算法选择这样的进程。
规定访问的磁道，与现在磁头所在的磁道距离近来，以使每次的寻道时间最短。
磁盘调度实验报告_4
磁盘调度一、实验目的:磁盘是高速、大容量、旋转型、可直接存取的存储设备。
它作为计算机系统的辅助存储器, 担负着繁重的输入输出工作, 在现代计算机系统中往往同时会有若干个要求访问磁盘的输入输出要求。
系统可采用一种策略, 尽可能按最佳次序执行访问磁盘的请求。
由于磁盘访问时间主要受寻道时间T的影响, 为此需要采用合适的寻道算法, 以降低寻道时间。
本实验要求学生模拟设计一个磁盘调度程序, 观察调度程序的动态运行过程。
通过实验让学生理解和掌握磁盘调度的职能。
二、概要设计:要求设计主界面能灵活选择某算法, 且实现以下算法：（1）先来先服务算法（FCFS）（2）最短寻道时间优先算法（SSTF）（3）扫描算法（SCAN）（4）循环扫描算法（CSCAN）本系统划分为四个模块: 先来先服务算法模块void FCFS(int array[],int m)、最短寻道时优先算法模块void SSTF(int array[],int m)、扫描算法模块void SCAN(int array[],int m)、循环扫描算法模块void SCAN(int array[],int m)设备的动态分配算法与进程调度相似, 也是基于一定的分配策略的。
常用的分配策略有先请求先分配、优先级高者先分配等策略。
在多道程序系统中, 低效率通常是由于磁盘类旋转设备使用不当造成的。
操作系统中, 对磁盘的访问要求来自多方面, 常常需要排队。
这时, 对众多的访问要求按一定的次序响应, 会直接影响磁盘的工作效率, 进而影响系统的性能访问磁盘的时间因子由3部分构成, 它们是：查找（查找磁道）时间、等待（旋转等待扇区）时间和数据传输时间, 其中查找时间是决定因素。
因此, 磁盘调度算法先考虑优化查找策略, 需要时再优化旋转等待策略。
平均寻道长度（L）为所有磁道所需移动距离之和除以总的所需访问的磁道数（N）, 即：（M1+M2+……+Mi+……+MN）/N 其中Mi为所需访问的磁道号所需移动的磁道数。
程序模拟磁盘调度设计实验4实验报告
《操作系统》实验报告三、实验过程或算法（源程序）程系统主界面可以灵活选择某种算法，算法包括：先来先服务算法（FCFS ）、最短寻道时间优先算法（SSTF）、扫描算法（SCAN ）、循环扫描算法（CSCAN ）。
模块调用关系图：1、先来先服务算法（FCFS这是一种比较简单的磁盘调度算法。
它根据进程请求访问磁盘的先后次序进行调度。
此算法的优点是公平、简单，且每个进程的请求都能依次得到处理，不会出现某一进程的请求长期得不到满足的情况。
此算法由于未对寻道进行优化，在对磁盘的访问请求比较多的情况下，此算法将降低设备服务的吞吐量，致使平均寻道时间可能较长，但各进程得到服务的响应时间的变化幅度较小。
2、最短寻道时间优先算法（SSTF）该算法选择这样的进程，其要求访问的磁道与当前磁头所在的磁道距离最近，以使每次的寻道时间最短，该算法可以得到比较好的吞吐量，但却不能保证平均寻道时间最短。
其缺点是对用户的服务请求的响应机会不是均等的，因而导致响应时间的变化幅度很大。
在服务请求很多的情况下，对内外边缘磁道的请求将会无限期的被延迟，有些请求的响应时间将不可预期。
求平均寻道长度,输出穆动的平均晞遣齣•3、扫描算法（SCAN扫描算法不仅考虑到欲访问的磁道与当前磁道的距离，更优先考虑的是磁头的当前移动方向。
例如，当磁头正在自里向外移动时，扫描算法所选择的下一个访问对象应是其欲访问的磁道既在当前磁道之外，到再无更外的磁道需要访问才将磁臂换向, 这样的进程来调度，即其要访问的磁道,现。
由于这种算法中磁头移动的规律颇似电梯的运又是距离最近的。
自外向里移动。
在当前磁道之内，这样自里向外地访问，直这时，同样也是每次选择从而避免了饥饿现象的出随机生咸磁适号-输出^商序的薪道序務动到最小f刘号, 改冋外【内〉穆动扫行，故又称为电梯调度算法。
此算法基本上克服了最短寻道时间优先算法的服务集中于中间磁道和响应时间变化比较大的缺点，而具有最短寻道时间优先算法的优点即吞吐量较大，平均响应时间较小，但由于是摆动式的扫描方法，两侧磁道被访问的频率仍低于中间磁道。
磁盘调度算法的模拟实现
磁盘调度算法的模拟实现学院专业学号学生姓名指导教师2021年3月19日目录一、课设简介21.1 课程设计题目21.2 课程设计目的21.3 课程设计要求2二、设计容32.1功能实现32.2流程图32.3具体容 (3)三、测试数据 (4)3.3 测试用例及运行结果4四、源代码5五、总结125.1 总结............................................一、课设简介1.1课程设计题目磁盘调度算法的模拟实现11.2程序设计目的操作系统课程设计是计算机专业重要的教学环节，它为学生提供了一个既动手又动脑，将课本上的理论知识和实际有机的结合起来，独立分析和解决实际问题的时机。
1〕进一步稳固和复习操作系统的根底知识。
2〕培养学生构造化程序、模块化程序设计的方法和能力。
3〕提高学生调试程序的技巧和软件设计的能力。
4〕提高学生分析问题、解决问题以及综合利用C语言进展程序设计的能力。
1.3 设计要求1〕磁头初始磁道号，序列长度，磁道号序列等数据可从键盘输入，也可从文件读入。
2〕最好能实现磁道号序列中磁道号的动态增加。
3〕磁道访问序列以链表的形式存储4〕给出各磁盘调度算法的调度顺序和平均寻道长度二、设计容2.1 功能实现设计并实现一个本别利用以下磁盘调度算法进展磁盘调度的模拟程序。
1）先来先效劳算法FCFS2）最短寻道时间优先算法SSTF2.2流程图开场选择算法F C F SSSTF 完毕2.3具体容1)先来先效劳算法FCFS这是一种比较简单的磁盘调度算法。
它根据进程请求访问磁盘的先后次序进展调度。
此算法的优点是公平、简单，且每个进程的请求都能依次得到处理，不会出现某一进程的请求长期得不到满足的情况。
此算法由于未对寻道进展优化，在对磁盘的访问请求比较多的情况下，此算法将降低设备效劳的吞吐量，致使平均寻道时间可能较长，但各进程得到效劳的响应时间的变化幅度较小。
2)最短寻道时间优先算法SSTF该算法选择这样的进程，其要求访问的磁道与当前磁头所在的磁道距离最近，以使每次的寻道时间最短，该算法可以得到比较好的吞吐量，但却不能保证平均寻道时间最短。
模拟实现磁盘调度算法
《操作系统》课程实验实验课题：模拟实现磁盘调度算法姓名：****学号：*****年级班级：08级信息与计算科学教学班级：操作系统专业方向：08信本软件方向指导教师：实验时间：2010-12-9一、实验名称:模拟实现磁盘调度算法1 实验目的：a、观察、体会操作系统的磁盘调度方法，并通过一个简单的磁盘调度模拟程序的实现，加深对磁盘调度的理解。
b、提高实际动手编程能力，为日后从事软件开发工作打下坚实基础。
2 实验要求：a、使用模块化设计思想来设计。
b、给出主函数和各个算法函数的流程图。
c、学生可按照自身条件，随意选择采用的算法。
二、实验算法分析总流程图三、实验内容及实验步骤1 实验内容a、模拟实现磁盘调度算法：FCFS，最短寻道优先，电梯算法（实现其中之一种以上）。
b、磁道请求服务顺序由用户输入（可通过从指定的文本文件（TXT文件）中取出）。
2 实验步骤1) 打开microsoft vasual C++ 6.0“开始”菜单—所有程序—单击“microsoft vasual C++ 6.0”，进入创建页面。
2）单击标题栏“文件”选择“新建”进入界面如下：选择‘工程，win32 console application’编辑工程名称‘zhuxuemin4’存储在d盘，创建‘创建新工作区’确定。
3）创建文件：单击标题栏“文件”选择“新建”进入界面类似于上面的界面。
4）在建好的文件中加入附件中的源程序，并进行编译。
四、实验原始记录及结果分析1 先来先服务调度算法2 最短寻道优先调度算法3 电梯调度算法五、参考代码#include<stdio.h>#include<iostream.h>#include<string.h>#include<math.h>const int MAXQUEUE=200; //定义请求队列最大长度//磁道号请求结构体定义typedef struct TRACK_Node{ int iGo; //要访问的磁道号int iVisited; //磁道是否已经访问标志（1：已访问；0：末访问）}TRACK;TRACK queue[MAXQUEUE]; //磁道号请求队列数组int iReqNum=0; //磁道访问请求数int iStart=0; //磁头初始位置int iNow=0; //磁头当前位置int iSum=0; //总移动磁道数int iInput; //用户当前输入的整数char sFileName[20]; //文件名void Init() //初始化函数{int i;for(i=0;i<MAXQUEUE;i++){ queue[i].iGo=-1; //设置要访问的磁道号为不可能的数-1，以区别正常请求磁道号queue[i].iVisited=0; //设置磁道是否已经访问标志为0：末访问} } //voidInit()void Reset() //重置访问标志、磁头当前位置、总移动磁道数{ int i;for(i=0;i<iReqNum;i++){ queue[i].iVisited=0; //设置磁道是否已经访问标志为0：末访问} printf( "\n 请输入磁头的初始磁道号（整数）: ");scanf("%d",&iStart); //从标准输入获取用户当前输入的磁头初始位置iNow=iStart; //磁头当前位置iSum=0; //总移动磁道数 } //void Reset()int ReadTrackFile() //读入磁道号流文件{ FILE *fp;int iTemp;cout<<" \n 请输入磁道号流（文本）文件名（注意：包括后缀名）: ";cin>>sFileName; //从标准输入获取用户当前输入的文件名if((fp=fopen(sFileName,"r"))==NULL){ cout<<endl<<" 错误：磁道号流文件 "<<sFileName<<" 打不开，请检查文件名和路径!!"<<endl; return -1; } else{ while(!feof(fp)) //将文件中输入的磁道号依次存入磁道号请求队列数组{ fscanf(fp,"%d ",&iTemp);queue[iReqNum].iGo=iTemp;iReqNum++; //磁道访问请求数} } //if((fp=fopen(sFileName,"r"))==NULL)return 0;} //void ReadTrackFile()void FCFS() //先来先服务调度算法{int i;Reset(); //重置访问标志、磁头当前位置、总移动磁道数cout<<endl<<"---------------------------------------------"<<endl;cout<<" 先来先服务调度算法的调度结果: "<<endl<<endl;cout<<" 初始磁道号: "<<iStart<<endl;cout<<" 序号下一磁道号移动的磁道数"<<endl;for(i=0;i<iReqNum;i++){ cout<<" "<<i+1<<" "<<queue[i].iGo<<""<<abs(queue[i].iGo-iNow)<<endl;iSum+=abs(queue[i].iGo-iNow); //累加总移动磁道数iNow=queue[i].iGo; //设置磁头当前位置为当前访问磁道号} cout<<endl<<" 总调度次数: "<<iReqNum<<endl;cout<<endl<<" 总移动磁道数: "<<iSum<<endl;printf("\n 平均移动磁道数: %.2f\n\n",(float)iSum / (float)iReqNum);} //void FCFS()void SSTF() //最短寻道优先调度算法{ int i,j;int iNext; //下一磁道号Reset(); //重置访问标志、磁头当前位置、总移动磁道数cout<<endl<<"---------------------------------------------"<<endl;cout<<endl<<"---------------------------------------------"<<endl;cout<<" 最短寻道优先调度算法的调度结果: "<<endl<<endl;cout<<" 初始磁道号: "<<iStart<<endl;cout<<" 序号下一磁道号移动的磁道数"<<endl;for(i=0;i<iReqNum;i++){ iNext=0;while(queue[iNext].iVisited!=0) //跳过已访问的磁道号{ iNext++; } //whilefor(j=iNext;j<iReqNum;j++){ //寻找下一个寻道距离最短的末访问磁道号if((queue[j].iVisited==0)&&(abs(iNow-queue[iNext].iGo)>abs(iNow-queue[j].iG o))){ iNext=j; } } //for(j=iNext;j<iReqNum;j++)cout<<" "<<i+1<<" "<<queue[iNext].iGo<<" "<<abs(queue[iNext].iGo-iNow)<<endl;iSum+=abs(queue[iNext].iGo-iNow); //累加总移动磁道数queue[iNext].iVisited=1; //设置磁道是否已经访问标志为1：已访问iNow=queue[iNext].iGo; //设置磁头当前位置为当前访问磁道号} //for(i=0;i<iReqNum;i++)cout<<endl<<" 总调度次数: "<<iReqNum<<endl;cout<<endl<<" 总移动磁道数: "<<iSum<<endl;printf("\n 平均移动磁道数: %.2f\n\n",(float)iSum / (float)iReqNum);} //void SSTF()void SCAN() //电梯调度算法{ int i,j;int iNext; //下一磁道号int iMinMove; //当前方向上最短寻道距离cout<<endl<<"---------------------------------------------"<<endl;cout<<endl<<" 请选择磁头初始方向（1 OR 2）："<<endl<<endl;cout<<" 1 磁头初始向内"<<endl<<endl<<" 2 磁头初始向外"<<endl<<endl<<" "; cin>>iInput; //从标准输入获取用户当前输入的整数switch(iInput) //用户当前输入的整数{case 1: //磁头初始向内Reset(); //重置访问标志、磁头当前位置、总移动磁道数cout<<endl<<"---------------------------------------------"<<endl;cout<<" 电梯调度算法--磁头初始向内的调度结果: "<<endl<<endl;cout<<" 初始磁道号: "<<iStart<<endl;cout<<" 序号下一磁道号移动的磁道数"<<endl;for(i=0;i<iReqNum;i++){iMinMove=9999;iNext=-1;for(j=0;j<iReqNum;j++) //寻找当前方向上寻道距离最短的末访问磁道号{ if((queue[j].iVisited==0)&&(queue[j].iGo>=iNow)){ if(abs(queue[j].iGo-iNow)<iMinMove){ iNext=j;iMinMove=abs(queue[j].iGo-iNow);} //if(abs(queue[j].iGo-iNow)<iMinMove)} //if((queue[j].iVisited==0)&&(queue[j].iGo>=iNow))} //for(j=0;j<iReqNum;j++)if(iNext!=-1){ cout<<" "<<i+1<<" "<<queue[iNext].iGo<<" "<<abs(queue[iNext].iGo-iNow)<<endl;iSum+=abs(queue[iNext].iGo-iNow); //累加总移动磁道数iNow=queue[iNext].iGo; //设置磁头当前位置为当前访问磁道号queue[iNext].iVisited=1; //设置磁道是否已经访问标志为1：已访问}//if(iNext!=-1)else //掉头向外{ for(j=0;j<iReqNum;j++) //寻找当前方向上寻道距离最短的末访问磁道号{ if((queue[j].iVisited==0)&&(queue[j].iGo<iNow)){ if(abs(queue[j].iGo-iNow)<iMinMove){ iNext=j;iMinMove=abs(queue[j].iGo-iNow);} } } //for(j=0;j<iReqNum;j++)cout<<" "<<i+1<<" "<<queue[iNext].iGo<<" "<<abs(queue[iNext].iGo-iNow)<<endl;iSum+=abs(queue[iNext].iGo-iNow); //累加总移动磁道数iNow=queue[iNext].iGo; //设置磁头当前位置为当前访问磁道号queue[iNext].iVisited=1; //设置磁道是否已经访问标志为1：已访问}//if(iNext!=-1) } //for(i=0;i<iReqNum;i++)cout<<endl<<" 总调度次数: "<<iReqNum<<endl;cout<<endl<<" 总移动磁道数: "<<iSum<<endl;printf("\n 平均移动磁道数: %.2f\n\n",(float)iSum / (float)iReqNum);break;case 2: //磁头初始向外Reset(); //重置访问标志、磁头当前位置、总移动磁道数cout<<endl<<"---------------------------------------------"<<endl;cout<<endl<<endl<<" 电梯调度算法--磁头初始向外的调度结果: "<<endl<<endl;cout<<" 初始磁道号: "<<iStart<<endl;cout<<" 序号下一磁道号移动的磁道数"<<endl;for(i=0;i<iReqNum;i++){ iMinMove=9999;iNext=-1;for(j=0;j<iReqNum;j++) //寻找当前方向上寻道距离最短的末访问磁道号{ if((queue[j].iVisited==0)&&(queue[j].iGo<=iNow)){ if(abs(queue[j].iGo-iNow)<iMinMove){ iNext=j;iMinMove=abs(queue[j].iGo-iNow);} //if(abs(queue[j].iGo-iNow)<iMinMove)} //if((queue[j].iVisited==0)&&(queue[j].iGo<=iNow))} //for(j=0;j<iReqNum;j++)if(iNext!=-1){ cout<<" "<<i+1<<" "<<queue[iNext].iGo<<" "<<abs(queue[iNext].iGo-iNow)<<endl;iSum+=abs(queue[iNext].iGo-iNow); //累加总移动磁道数iNow=queue[iNext].iGo; //设置磁头当前位置为当前访问磁道号queue[iNext].iVisited=1; //设置磁道是否已经访问标志为1：已访问} else //掉头向内{ for(j=0;j<iReqNum;j++) //寻找当前方向上寻道距离最短的末访问磁道号{ if((queue[j].iVisited==0)&&(queue[j].iGo>iNow)){ if(abs(queue[j].iGo-iNow)<iMinMove){ iNext=j;iMinMove=abs(queue[j].iGo-iNow); } //if(abs(queue[j].iGo-iNow)<iMinMove)} //if((queue[j].iVisited==0)&&(queue[j].iGo>iNow))}//for(j=0;j<iReqNum;j++)cout<<" "<<i+1<<" "<<queue[iNext].iGo<<" "<<abs(queue[iNext].iGo-iNow)<<endl;iSum+=abs(queue[iNext].iGo-iNow); //累加总移动磁道数iNow=queue[iNext].iGo; //设置磁头当前位置为当前访问磁道号queue[iNext].iVisited=1; //设置磁道是否已经访问标志为1：已访问 } //if(iNext!=-1)} //for(i=0;i<iReqNum;i++)cout<<endl<<" 总调度次数: "<<iReqNum<<endl;cout<<endl<<" 总移动磁道数: "<<iSum<<endl;printf("\n 平均移动磁道数: %.2f\n\n",(float)iSum / (float)iReqNum);break;default:printf("\n 输入错误!!\n\n");return;} //switch(iInput)} //void SCAN()void Version() //显示版权信息函数{ cout<<endl<<endl;cout<<" ┏━━━━━━━━━━━━━━━━━━━━━━━┓"<<endl;cout<<" ┃磁盘调度算法模拟系统┃"<<endl;cout<<" ┠───────────────────────┨"<<endl;cout<<" ┃(c)All Right Reserved ┃"<<endl;cout<<" ┃程坤┃"<<endl;cout<<" ┃Version 2010 build 2.0 ┃"<<endl;cout<<" ┗━━━━━━━━━━━━━━━━━━━━━━━┛"<<endl;cout<<endl<<endl; }// void Version()void main(){ int i;bool bGoOn; //是否继续磁盘调度算法模拟的标志char sGoOn[1]; //用户输入是否继续磁盘调度算法模拟的字母：y、Y、N、nVersion();//显示版权信息函数Init(); //初始化函数if(ReadTrackFile()==-1) //读入磁道号流文件{printf(" 读入磁道号流文件失败!!\n\n"); }else{bGoOn= true;while (bGoOn){cout<<endl<<"---------------------------------------------"<<endl;cout<<" 从磁道号流文件"<<sFileName<<" 所读入的磁道号流如下:"<<endl<<endl<<" ";for(i=0;i<iReqNum;i++){ cout<<queue[i].iGo<<" "; }cout<<endl<<endl<<" 请求数为: "<<iReqNum<<endl<<endl;iInput=-1; //用户输入的整数以选择算法cout<<endl<<" 请输入算法编号（1 OR 2 OR 3）选择调度算法："<<endl<<endl; cout<<"1 先来先服务调度算法"<<endl<<endl<<"2 最短寻道优先调度算法"<<endl<<endl<<"3 电梯调度算法 "<<endl<<endl<<" ";cin>>iInput; //从标准输入获取用户当前输入的整数switch(iInput) //用户输入的整数以选择算法{case 1: FCFS(); //先来先服务调度算法break;case 2: SSTF(); //最短寻道优先调度算法break;case 3:SCAN(); //电梯调度算法.break;default:printf("\n 输入的算法编号错误!!\n\n");return; } //switch(iInput)bGoOn= false;strcpy(sGoOn," ");cout<<" 要继续进行磁盘调度算法模拟吗?(Y/N) "<<endl<<" ";cin>>sGoOn;bGoOn=(sGoOn[0]=='y'||sGoOn[0]=='Y');} //while bGoOn } //if(ReadTrackFile()==-1) }. . .。
磁盘调度算法的实现
一、实验目的:通过模拟设计磁盘驱动调度程序，观察驱动调度程序的动态运行过程，理解和掌握磁盘驱动调度的职能，并比较各种算法的调度结果。
二、实验容:要求设计主界面能灵活选择某算法，且以下算法都要实现。
（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）测试结果四、设计总结:此次设计基本完成了本实验所规定的功能，但是还不够完善，很多东西做的不够好，程序不够完善和严谨。
操作系统实验四 磁盘调度算法
实验四磁盘调度一、实验目的：本实验要求学生模拟设计一个磁盘调度程序，观察调度程序的动态运行过程。
通过实验让学生理解和掌握磁盘调度的职能。
二、实验内容：对磁盘进行移臂操作，模拟磁盘调度算法并计算平均寻道时间三、实验准备：1.相关理论知识：（1）假设磁盘只有一个盘面，并且磁盘是可移动头磁盘。
（3）磁盘是高速、大容量、旋转型、可直接存取的存储设备。
它作为计算机系统的辅助存储器，担负着繁重的输入输出工作，在现代计算机系统中往往同时会有若干个要求访问磁盘的输入输出要求。
系统可采用一种策略，尽可能按最佳次序执行访问磁盘的请求。
由于磁盘访问时间主要受寻道时间T的影响，为此需要采用合适的寻道算法，以降低寻道时间。
（2）磁盘是可供多个进程共享的存储设备，但一个磁盘每个时刻只能为一个进程服务。
当有进程在访问某个磁盘时，其它想访问该磁盘的进程必须等待，直到磁盘一次工作结束。
当有多个进程提出输入输出请求而处于等待状态时，可用磁盘调度算法从若干个等待访问者中选择一个进程，让它访问磁盘。
2.测试数据：磁盘读写请求队列：20，44，40，4，80，12，76当前磁头位置：50试问采用FCFS、SSTF、SCAN磁盘调度算法时寻道顺序及平均寻道时间分别为多少？四、实验过程：1.流程图SCAN算法（扫描算法）流程图：2. 源代码#include<stdio.h>#include<stdlib.h>#include<iostream.h>#include<math.h>#define maxsize 1000/*********************判断输入数据是否有效**************************/int decide(char str[]) //判断输入数据是否有效{int i=0;while(str[i]!='\0'){if(str[i]<'0'||str[i]>'9'){return 0;break;}i++;}return i;}/******************将字符串转换成数字***********************/ int trans(char str[],int a) //将字符串转换成数字{int i;int sum=0;for(i=0;i<a;i++){sum=sum+(int)((str[i]-'0')*pow(10,a-i-1));}return sum;}/*********************冒泡排序算法**************************/ int *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;int a;char str[100];float ave; //平均寻道长度cout<<"磁盘请求序列为：";for( i=0;i<m;i++) //按先来先服务的策略输出磁盘请求序列{cout<<cidao[i]<<" ";}cout<<endl;cout<<"请输入当前的磁道号：";B: cin>>str; //对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入！"<<endl;goto B;}elsenow=trans(str,a); //输入当前磁道号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){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) //确定当前磁道在已排的序列中的位置，后面的算法都用到了，可以直接复制后少量修改，节省时间。
模拟电梯调度算法,实现对磁盘的驱动调度。
操作系统实验（第三次）一、实验内容模拟电梯调度算法，实现对磁盘的驱动调度。
二、实验目的磁盘是一种高速、大容量、旋转型、可直接存取的存储设备。
它作为计算机系统的辅助存储器，担负着繁重的输入输出任务、在多道程序设计系统中，往往同时会有若干个要求访问磁盘的输入输出请求等待处理。
系统可采用一种策略，尽可能按最佳次序执行要求访问磁盘的诸输入输出请求。
这就叫驱动调度，使用的算法称为驱动调度算法。
驱动调度能降低为若干个输入输出请求服务所需的总时间，从而提高系统效率。
本实验要求学生模拟设计一个驱动调度程序，观察驱动调度程序的动态运行过程。
通过实验使学生理解和掌握驱动调度的职能。
三、实验题目模拟电梯调度算法，对磁盘进行移臂和旋转调度。
[提示]：（1）磁盘是可供多个进程共享的存储设备，但一个磁盘每时刻只能为一个进程服务。
当有进程在访问某个磁盘时，其他想访问该磁盘的进程必须等待，直到磁盘一次工作结束。
当有多个进程提出输入输出要求而处于等待状态时，可用电梯调度算法从若干个等待访问者中选择一个进程，让它访问磁盘。
选择访问者的工作由“驱动调度”进程来完成。
由于磁盘与处理器是可以并行工作的、所以当磁盘在作为一个进程服务时，占有处理器的另一进程可以提出使用磁盘的要求，也就是说，系统能动态地接收新的输入输出请求。
为了模拟这种情况，在本实验中设置了一个“接收请求”进程。
“驱动调度”进程和“接收请求”进程能否占有处理器运行，取决于磁盘的结束中断信号和处理器调度策略。
在实验中可用随机数来模拟确定这两个进程的运行顺序，以代替中断四、处理和处理器调度选择的过程。
因而，程序的结构可参考图3—1（2）“接收请求”进程建立一张“请求I/O”表，指出访问磁盘的进程要求访问的物理地址，表的格式为：假定某个磁盘组共有200 个柱面，由外向里顺序编号（0—199），每个柱面上有20 个磁道，编号为0—19，每个磁道分成8 个物理记录，编号0—7。
进程访问磁盘的物理地址可以用键盘输入的方法模拟得到。
模拟实现磁盘调度算法
《操作系统》课程实验实验课题：模拟实现磁盘调度算法姓名：****学号：*****年级班级：08级信息与计算科学教学班级：操作系统专业方向：08信本软件方向指导教师：实验时间：2010-12-9一、实验名称:模拟实现磁盘调度算法1 实验目的：a、观察、体会操作系统的磁盘调度方法，并通过一个简单的磁盘调度模拟程序的实现，加深对磁盘调度的理解。
b、提高实际动手编程能力，为日后从事软件开发工作打下坚实基础。
2 实验要求：a、使用模块化设计思想来设计。
b、给出主函数和各个算法函数的流程图。
c、学生可按照自身条件，随意选择采用的算法。
二、实验算法分析总流程图三、实验内容及实验步骤1 实验内容a、模拟实现磁盘调度算法：FCFS，最短寻道优先，电梯算法（实现其中之一种以上）。
b、磁道请求服务顺序由用户输入（可通过从指定的文本文件（TXT文件）中取出）。
2 实验步骤1) 打开microsoft vasual C++ 6.0“开始”菜单—所有程序—单击“microsoft vasual C++ 6.0”，进入创建页面。
2）单击标题栏“文件”选择“新建”进入界面如下：选择‘工程，win32 console application’编辑工程名称‘zhuxuemin4’存储在d盘，创建‘创建新工作区’确定。
3）创建文件：单击标题栏“文件”选择“新建”进入界面类似于上面的界面。
4）在建好的文件中加入附件中的源程序，并进行编译。
四、实验原始记录及结果分析1 先来先服务调度算法2 最短寻道优先调度算法3电梯调度算法五、参考代码#include<stdio.h>#include<iostream.h>#include<string.h>#include<math.h>const int MAXQUEUE=200; //定义请求队列最大长度//磁道号请求结构体定义typedef struct TRACK_Node{ int iGo; //要访问的磁道号int iVisited; //磁道是否已经访问标志（1：已访问；0：末访问）}TRACK;TRACK queue[MAXQUEUE]; //磁道号请求队列数组int iReqNum=0; //磁道访问请求数int iStart=0; //磁头初始位置int iNow=0; //磁头当前位置int iSum=0; //总移动磁道数int iInput; //用户当前输入的整数char sFileName[20]; //文件名void Init() //初始化函数{int i;for(i=0;i<MAXQUEUE;i++){ queue[i].iGo=-1; //设置要访问的磁道号为不可能的数-1，以区别正常请求磁道号queue[i].iVisited=0; //设置磁道是否已经访问标志为0：末访问} } //void Init()void Reset() //重置访问标志、磁头当前位置、总移动磁道数{ int i;for(i=0;i<iReqNum;i++){ queue[i].iVisited=0; //设置磁道是否已经访问标志为0：末访问} printf( "\n 请输入磁头的初始磁道号（整数）: ");scanf("%d",&iStart); //从标准输入获取用户当前输入的磁头初始位置iNow=iStart; //磁头当前位置iSum=0; //总移动磁道数} //void Reset()int ReadTrackFile() //读入磁道号流文件{ FILE *fp;int iTemp;cout<<" \n 请输入磁道号流（文本）文件名（注意：包括后缀名）: ";cin>>sFileName; //从标准输入获取用户当前输入的文件名if((fp=fopen(sFileName,"r"))==NULL){ cout<<endl<<" 错误：磁道号流文件"<<sFileName<<" 打不开，请检查文件名和路径!!"<<endl; return -1; } else{ while(!feof(fp)) //将文件中输入的磁道号依次存入磁道号请求队列数组{ fscanf(fp,"%d ",&iTemp);queue[iReqNum].iGo=iTemp;iReqNum++; //磁道访问请求数} } //if((fp=fopen(sFileName,"r"))==NULL) return 0;} //void ReadTrackFile()void FCFS() //先来先服务调度算法{int i;Reset(); //重置访问标志、磁头当前位置、总移动磁道数cout<<endl<<"---------------------------------------------"<<endl;cout<<" 先来先服务调度算法的调度结果: "<<endl<<endl;cout<<" 初始磁道号: "<<iStart<<endl;cout<<" 序号下一磁道号移动的磁道数"<<endl;for(i=0;i<iReqNum;i++){ cout<<" "<<i+1<<" "<<queue[i].iGo<<" "<<abs(queue[i].iGo-iNow)<<endl;iSum+=abs(queue[i].iGo-iNow); //累加总移动磁道数iNow=queue[i].iGo; //设置磁头当前位置为当前访问磁道号} cout<<endl<<" 总调度次数: "<<iReqNum<<endl;cout<<endl<<" 总移动磁道数: "<<iSum<<endl;printf("\n 平均移动磁道数: %.2f\n\n",(float)iSum / (float)iReqNum);} //void FCFS()void SSTF() //最短寻道优先调度算法{ int i,j;int iNext; //下一磁道号Reset(); //重置访问标志、磁头当前位置、总移动磁道数cout<<endl<<"---------------------------------------------"<<endl;cout<<endl<<"---------------------------------------------"<<endl;cout<<" 最短寻道优先调度算法的调度结果: "<<endl<<endl;cout<<" 初始磁道号: "<<iStart<<endl;cout<<" 序号下一磁道号移动的磁道数"<<endl;for(i=0;i<iReqNum;i++){ iNext=0;while(queue[iNext].iVisited!=0) //跳过已访问的磁道号{ iNext++; } //whilefor(j=iNext;j<iReqNum;j++){ //寻找下一个寻道距离最短的末访问磁道号if((queue[j].iVisited==0)&&(abs(iNow-queue[iNext].iGo)>abs(iNow-queue[j].iGo))) { iNext=j; } } //for(j=iNext;j<iReqNum;j++)cout<<" "<<i+1<<" "<<queue[iNext].iGo<<" "<<abs(queue[iNext].iGo-iNow)<<endl;iSum+=abs(queue[iNext].iGo-iNow); //累加总移动磁道数queue[iNext].iVisited=1; //设置磁道是否已经访问标志为1：已访问iNow=queue[iNext].iGo; //设置磁头当前位置为当前访问磁道号} //for(i=0;i<iReqNum;i++)cout<<endl<<" 总调度次数: "<<iReqNum<<endl;cout<<endl<<" 总移动磁道数: "<<iSum<<endl;printf("\n 平均移动磁道数: %.2f\n\n",(float)iSum / (float)iReqNum);} //void SSTF()void SCAN() //电梯调度算法{ int i,j;int iNext; //下一磁道号int iMinMove; //当前方向上最短寻道距离cout<<endl<<"---------------------------------------------"<<endl;cout<<endl<<" 请选择磁头初始方向（1 OR 2）："<<endl<<endl;cout<<" 1 磁头初始向内"<<endl<<endl<<" 2 磁头初始向外"<<endl<<endl<<" "; cin>>iInput; //从标准输入获取用户当前输入的整数switch(iInput) //用户当前输入的整数{case 1: //磁头初始向内Reset(); //重置访问标志、磁头当前位置、总移动磁道数cout<<endl<<"---------------------------------------------"<<endl;cout<<" 电梯调度算法--磁头初始向内的调度结果: "<<endl<<endl;cout<<" 初始磁道号: "<<iStart<<endl;cout<<" 序号下一磁道号移动的磁道数"<<endl;for(i=0;i<iReqNum;i++){iMinMove=9999;iNext=-1;for(j=0;j<iReqNum;j++) //寻找当前方向上寻道距离最短的末访问磁道号{ if((queue[j].iVisited==0)&&(queue[j].iGo>=iNow)){ if(abs(queue[j].iGo-iNow)<iMinMove){ iNext=j;iMinMove=abs(queue[j].iGo-iNow);} //if(abs(queue[j].iGo-iNow)<iMinMove)} //if((queue[j].iVisited==0)&&(queue[j].iGo>=iNow))} //for(j=0;j<iReqNum;j++)if(iNext!=-1){ cout<<" "<<i+1<<" "<<queue[iNext].iGo<<" "<<abs(queue[iNext].iGo-iNow)<<endl;iSum+=abs(queue[iNext].iGo-iNow); //累加总移动磁道数iNow=queue[iNext].iGo; //设置磁头当前位置为当前访问磁道号queue[iNext].iVisited=1; //设置磁道是否已经访问标志为1：已访问} //if(iNext!=-1) else //掉头向外{ for(j=0;j<iReqNum;j++) //寻找当前方向上寻道距离最短的末访问磁道号{ if((queue[j].iVisited==0)&&(queue[j].iGo<iNow)){ if(abs(queue[j].iGo-iNow)<iMinMove){ iNext=j;iMinMove=abs(queue[j].iGo-iNow);} } } //for(j=0;j<iReqNum;j++)cout<<" "<<i+1<<" "<<queue[iNext].iGo<<" "<<abs(queue[iNext].iGo-iNow)<<endl;iSum+=abs(queue[iNext].iGo-iNow); //累加总移动磁道数iNow=queue[iNext].iGo; //设置磁头当前位置为当前访问磁道号queue[iNext].iVisited=1; //设置磁道是否已经访问标志为1：已访问} //if(iNext!=-1) } //for(i=0;i<iReqNum;i++)cout<<endl<<" 总调度次数: "<<iReqNum<<endl;cout<<endl<<" 总移动磁道数: "<<iSum<<endl;printf("\n 平均移动磁道数: %.2f\n\n",(float)iSum / (float)iReqNum);break;case 2: //磁头初始向外Reset(); //重置访问标志、磁头当前位置、总移动磁道数cout<<endl<<"---------------------------------------------"<<endl;cout<<endl<<endl<<" 电梯调度算法--磁头初始向外的调度结果: "<<endl<<endl;cout<<" 初始磁道号: "<<iStart<<endl;cout<<" 序号下一磁道号移动的磁道数"<<endl;for(i=0;i<iReqNum;i++){ iMinMove=9999;iNext=-1;for(j=0;j<iReqNum;j++) //寻找当前方向上寻道距离最短的末访问磁道号{ if((queue[j].iVisited==0)&&(queue[j].iGo<=iNow)){ if(abs(queue[j].iGo-iNow)<iMinMove){ iNext=j;iMinMove=abs(queue[j].iGo-iNow);} //if(abs(queue[j].iGo-iNow)<iMinMove)} //if((queue[j].iVisited==0)&&(queue[j].iGo<=iNow))} //for(j=0;j<iReqNum;j++)if(iNext!=-1){ cout<<" "<<i+1<<" "<<queue[iNext].iGo<<" "<<abs(queue[iNext].iGo-iNow)<<endl;iSum+=abs(queue[iNext].iGo-iNow); //累加总移动磁道数iNow=queue[iNext].iGo; //设置磁头当前位置为当前访问磁道号queue[iNext].iVisited=1; //设置磁道是否已经访问标志为1：已访问} else //掉头向内{ for(j=0;j<iReqNum;j++) //寻找当前方向上寻道距离最短的末访问磁道号{ if((queue[j].iVisited==0)&&(queue[j].iGo>iNow)){ if(abs(queue[j].iGo-iNow)<iMinMove){ iNext=j;iMinMove=abs(queue[j].iGo-iNow); } //if(abs(queue[j].iGo-iNow)<iMinMove)} //if((queue[j].iVisited==0)&&(queue[j].iGo>iNow))} //for(j=0;j<iReqNum;j++) cout<<" "<<i+1<<" "<<queue[iNext].iGo<<" "<<abs(queue[iNext].iGo-iNow)<<endl;iSum+=abs(queue[iNext].iGo-iNow); //累加总移动磁道数iNow=queue[iNext].iGo; //设置磁头当前位置为当前访问磁道号queue[iNext].iVisited=1; //设置磁道是否已经访问标志为1：已访问} //if(iNext!=-1)} //for(i=0;i<iReqNum;i++)cout<<endl<<" 总调度次数: "<<iReqNum<<endl;cout<<endl<<" 总移动磁道数: "<<iSum<<endl;printf("\n 平均移动磁道数: %.2f\n\n",(float)iSum / (float)iReqNum);break;default:printf("\n 输入错误!!\n\n");return;} //switch(iInput)} //void SCAN()void Version() //显示版权信息函数{ cout<<endl<<endl;cout<<" ┏━━━━━━━━━━━━━━━━━━━━━━━┓"<<endl;cout<<" ┃磁盘调度算法模拟系统┃"<<endl;cout<<" ┠───────────────────────┨"<<endl;cout<<" ┃(c)All Right Reserved ┃"<<endl;cout<<" ┃程坤┃"<<endl;cout<<" ┃Version 2010 build 2.0 ┃"<<endl;cout<<" ┗━━━━━━━━━━━━━━━━━━━━━━━┛"<<endl;cout<<endl<<endl; }// void Version()void main(){ int i;bool bGoOn; //是否继续磁盘调度算法模拟的标志char sGoOn[1]; //用户输入是否继续磁盘调度算法模拟的字母：y、Y、N、nVersion();//显示版权信息函数Init(); //初始化函数if(ReadTrackFile()==-1) //读入磁道号流文件{printf(" 读入磁道号流文件失败!!\n\n"); }else{bGoOn= true;while (bGoOn){cout<<endl<<"---------------------------------------------"<<endl;cout<<" 从磁道号流文件"<<sFileName<<" 所读入的磁道号流如下:"<<endl<<endl<<" ";for(i=0;i<iReqNum;i++){ cout<<queue[i].iGo<<" "; }cout<<endl<<endl<<" 请求数为: "<<iReqNum<<endl<<endl;iInput=-1; //用户输入的整数以选择算法cout<<endl<<" 请输入算法编号（1 OR 2 OR 3）选择调度算法："<<endl<<endl; cout<<"1 先来先服务调度算法"<<endl<<endl<<"2 最短寻道优先调度算法"<<endl<<endl<<"3 电梯调度算法"<<endl<<endl<<" ";cin>>iInput; //从标准输入获取用户当前输入的整数switch(iInput) //用户输入的整数以选择算法{case 1: FCFS(); //先来先服务调度算法break;case 2: SSTF(); //最短寻道优先调度算法break;case 3:SCAN(); //电梯调度算法break;default:printf("\n 输入的算法编号错误!!\n\n");return; } //switch(iInput)bGoOn= false;strcpy(sGoOn," ");cout<<" 要继续进行磁盘调度算法模拟吗?(Y/N) "<<endl<<" ";cin>>sGoOn;bGoOn=(sGoOn[0]=='y'||sGoOn[0]=='Y');} //while bGoOn } //if(ReadTrackFile()==-1) }。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验四磁盘驱动调度算法的模拟
一．实验内容：
熟悉磁盘的结构以及磁盘的驱动调度算法的模拟，编程实现简单常用的磁盘驱动调度算法：先来先服务（FIFO）、电梯调度算法、最短寻道时间优先算法、扫描（双向扫描）算法、循环扫描算法等。
编程语言建议采用c/c++或Java。
模拟程序鼓励采用随机数技术、动态空间分配技术，有条件的最好能用图形界面展现甚至用动画模拟。
实验性质：验证型。
二．实验目的和要求
1）掌握使用一门语言进行磁盘驱动调度算法的模拟；
2）编写程序将磁盘驱动调度算法的过程和结果能以较简明直观的方式展现出来。
三．实验原理、方法和步骤
1. 实验原理
磁盘驱动调度对磁盘的效率有重要影响。
磁盘驱动调度算法的好坏直接影响辅助存储器的效率，从而影响计算机系统的整体效率。
常用的磁盘驱动调度算法有：
最简单的磁盘驱动调度算法是先入先出（FIFO）法。
这种算法的实质是，总是严格按时间顺序对磁盘请求予以处理。
算法实现简单、易于理解并且相对公平，不会发生进程饿死现象。
但该算法可能会移动的柱面数较多并且会经常更换移动方向，效率有待提高。
最短寻道时间优先算法：总是优先处理最靠近的请求。
该算法移动的柱面距离较小，但可能会经常改变移动方向，并且可能会发生进程饥饿现象。
电梯调度：总是将一个方向上的请求全部处理完后，才改变方向继续处理其他请求。
扫描（双向扫描）：总是从最外向最里进行扫描，然后在从最里向最外扫描。
该算法与电梯调度算法的区别是电梯调度在没有最外或最里的请求时不会移动到最外或最里柱面，二是扫描算法总是移到最外、最里柱面。
循环扫描（单向扫描）：从最外向最里进行柱面请求处理，到最里柱面后，直接跳到最外柱面然后继续向里进行处理。
2. 实验方法
1）使用流程图描述演示程序的设计思想；
2）选取c/c++、Java等计算机语言，编程调试，最终给出运行正确的程序。