磁盘调度算法-电脑资料.
磁盘调度算法
磁盘调度算法⼀次磁盘读写操作的时间由寻找(寻道)时间、延迟时间和传输时间决定:1) 寻找时间Ts:活动头磁盘在读写信息前，将磁头移动到指定磁道所需要的时间。
这个时间除跨越n条磁道的时间外，还包括启动磁臂的时间s，即:Ts = m * n + s。
式中，m是与磁盘驱动器速度有关的常数，约为0.2ms，磁臂的启动时间约为2ms。
2)延迟时间Tr:磁头定位到某⼀磁道的扇区(块号)所需要的时间，设磁盘的旋转速度为r，则:Tr = 1 / (2 * r)。
对于硬盘，典型的旋转速度为5400r/m，相当于⼀周11.1ms，则Tr为5.55ms;对于软盘，其旋转速度在300~600r/m之间，则Tr为50~100ms。
3) 传输时间Tt:从磁盘读出或向磁盘写⼊数据所经历的时间，这个时间取决于每次所读/写的字节数b和磁盘的旋转速度:Tt = b / (r * N)。
式中，r为磁盘每秒钟的转数;N为⼀个磁道上的字节数。
在磁盘存取时间的计算中，寻道时间与磁盘调度算法相关，下⾯将会介绍分析⼏种算法，⽽延迟时间和传输时间都与磁盘旋转速度相关，且为线性相关，所以在硬件上，转速是磁盘性能的⼀个⾮常重要的参数。
总平均存取时间Ta可以表⽰为:Ta = Ts + Tr + Tt。
（1）先来先服务（FCFS）按请求者的先后次序启动磁盘驱动器，⽽不考虑它们要访问的物理位置。
FCFS算法根据进程请求访问磁盘的先后顺序进⾏调度，这是⼀种最简单的调度算法。
该算法的优点是具有公平性。
如果只有少量进程需要访问，且⼤部分请求都是访问簇聚的⽂件扇区，则有望达到较好的性能;但如果有⼤量进程竞争使⽤磁盘，那么这种算法在性能上往往接近于随机调度。
所以，实际磁盘调度中考虑⼀些更为复杂的调度算法。
1、算法思想:按访问请求到达的先后次序服务。
2、优点:简单，公平。
3、缺点:效率不⾼，相邻两次请求可能会造成最内到最外的柱⾯寻道，使磁头反复移动，增加了服务时间，对机械也不利。
操作系统磁盘调度算法实验报告及代码
操作系统磁盘调度算法实验报告及代码一、实验目的通过实验掌握磁盘调度算法的实现过程，了解各种不同磁盘调度算法的特点和优缺点，并比较它们的性能差异。
二、实验原理磁盘调度是操作系统中的重要内容，其主要目的是提高磁盘的利用率和系统的响应速度。
常见的磁盘调度算法有：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算法通过选择离当前磁道最近的请求进行处理，能够减少平均寻道时间，提高磁盘性能。
五、实验总结通过本次实验，我们学习了操作系统中磁盘调度算法的原理和实现过程。
不同的磁盘调度算法具有不同的优缺点，我们需要根据实际情况选择合适的算法。
磁盘调度算法简述
磁盘调度算法简述⼀⼂意义：良好的调度算法，能减少IO读取时间（磁盘读取（最慢）+读取+传输）磁盘访问时间=寻道时间+旋转延迟时间+数据传输时间，磁盘读写顺序：由上直下（柱⾯磁道），由外到⾥（柱⾯排序，外磁道速度最快），依次访问对应扇区（512bytes）计算机中，各存储区域访问速度为寄存器约等号≈cache>内存>>磁盘>其他外接物理设备系统每进⾏⼀次IO中断，进⾏数据读写，⾸先要进⾏命中测试，若不在register，cache，memory中，则进⾏磁盘读取，先寻址，再进⾏io读⼊内存，读⼊后才能被cpu使⽤。
由磁盘中读写数据占⽤时间公式可知，其最主要的是寻道时间，旋转延迟时间，良好的磁盘调度算法，能减少IO读写时间，从⽽减少进程等待io时间，增加cpu利⽤率，防⽌磁臂黏着现象的发⽣。
⼆⼂名词解释：1）磁臂粘着--------程序对某些磁道频繁访问，如多次访问同⼀磁道，则io队列中，多次对同⼀磁道进⾏频繁的读取，导致其他磁道的请求被搁置，即为磁臂黏着现象（类似于进程饿死）2）寻道时间：移动磁臂到对应磁道（⼀般全部磁臂同时移动，部分可以分别移动），最慢3）旋转延迟时间：磁盘旋转到对应扇区，对应磁柱进⾏读写4）数据传输时间：读取数据，使⽤IO总线传⼊内存供cpu使⽤三⼂算法简述1.先来先服务算法（FCFS）----FirstComeFirstServer可使⽤链表（若有数量上限则单设头结点记录请求数，超出则拒绝）和数组（数组长度限制为请求数量，防⽌越界），依据请求时间先后，对io请求进⾏队列排列，依次出队优劣：公平、简单；平均寻道时间可能较长2.最短寻道算法（SSTF）其访问规则为距离当前磁头最近的io请求进⾏服务，由“最近”⼀词和磁盘读写顺序可知，其可能会返回对⼀个柱⾯的磁道进⾏多次读写，造成磁盘黏着现象基本实现：动态处理IO请求，可使⽤链表（双向链表，避免越界和前置判空操作）或者数组（内存允许则最好⽤数组，减少寻址时间）实现，使⽤插⼊排序算法，对IO请求进⾏动态排序，指针p指向磁头的当前磁道和扇区对应的线形距离数字，对前置后驱元素进⾏判定，以距离较短者作为下次磁盘访问对象。
操作系统有哪些主要调度算法
操作系统有哪些主要调度算法操作系统调度算法一、磁盘调度1.先来先服务fcfs：是按请求访问者的先后次序启动磁盘驱动器，而不考虑它们要访问的物理位置2.最短一般说来时间优先sstf：使距当前磁道最近的命令访问者启动磁盘驱动器，即是使查找时间最短的那个作业先继续执行，而不考量命令访问者到来的先后次序，这样就消除了先来先服务调度算法中磁臂移动过小的问题3.扫描算法scan或电梯调度算法：总是从磁臂当前位置开始，沿磁臂的移动方向去选择离当前磁臂最近的那个柱面的访问者。
如果沿磁臂的方向无请求访问时，就改变磁臂的移动方向。
在这种调度方法下磁臂的移动类似于电梯的调度，所以它也称为电梯调度算法。
4.循环读取算法cscan：循环读取调度算法就是在读取算法的基础上改良的。
磁臂改成单项移动，由外向里。
当前边线已经开始沿磁臂的移动方向回去挑选距当前磁臂最近的哪个柱面的访问者。
如果沿磁臂的方向并无命令出访时，再返回最外，出访柱面号最轻的作业命令。
操作系统调度算法二、进程调度算法1.先进先出算法fifo：按照进程步入准备就绪队列的先后次序去挑选。
即为每当步入进程调度，总是把准备就绪队列的队首进程资金投入运转。
2.时间片轮转算法rr：分时系统的一种调度算法。
轮转的基本思想是，将cpu的处理时间划分成一个个的时间片，就绪队列中的进程轮流运行一个时间片。
当时间片结束时，就强迫进程让出cpu，该进程进入就绪队列，等待下一次调度，同时，进程调度又去选择就绪队列中的一个进程，分配给它一个时间片，以投入运行。
3.最低优先级算法hpf：进程调度每次将处理机分配给具备最低优先级的准备就绪进程。
最低优先级算法可以与相同的cpu方式融合构成可以抢占市场式最低优先级算法和不容抢占市场式最低优先级算法。
4.多级队列反馈法：几种调度算法的结合形式多级队列方式。
操作系统调度算法三、常用的批处理作业调度算法1.先来先服务调度算法fcfs:就是按照各个作业进入系统的自然次序来调度作业。
操作系统磁盘调度算法例题讲解
操作系统磁盘调度算法例题讲解1. 磁盘调度算法的背景和意义磁盘调度算法是操作系统中的重要组成部分，它的主要目的是优化磁盘访问，提高磁盘I/O操作的效率。
在计算机系统中，磁盘是一个重要的存储介质，它负责存储和读写数据。
然而，由于磁盘访问具有机械运动延迟和寻道时间等特性，使得磁盘I/O操作成为计算机系统中一个性能瓶颈。
为了解决这个问题，人们提出了各种各样的磁盘调度算法。
这些算法通过优化访问顺序、减少寻道时间、提高数据传输率等方式来提高磁盘I/O操作效率。
因此，深入了解和掌握不同类型的磁盘调度算法对于优化计算机系统性能具有重要意义。
2. 先来先服务（FCFS）调度算法先来先服务（First-Come, First-Served）是最简单、最直观的一种磁盘调度算法。
它按请求顺序处理I/O请求。
当一个请求到达时，在当前位置完成当前请求后再处理下一个请求。
然而，在实际应用中，FCFS存在一些问题。
首先，它无法充分利用磁盘的带宽，因为磁盘的读写头可能在处理当前请求时，其他请求已经到达。
其次，由于磁盘请求的随机性，FCFS可能导致某些请求等待时间过长。
3. 最短寻道时间优先（SSTF）调度算法最短寻道时间优先（Shortest Seek Time First）是一种基于当前位置选择下一个最近请求的调度算法。
在SSTF算法中，选择离当前位置最近的请求进行处理。
SSTF算法相对于FCFS算法来说，在减少寻道时间方面有一定的优势。
它能够充分利用磁盘带宽，并且能够减少某些请求等待时间过长的问题。
然而，SSTF算法也存在一些问题。
首先，在某些情况下，由于选择最近的请求进行处理，可能导致某些较远位置上的请求长期等待。
其次，在高负载情况下，由于大量随机访问导致寻道距离变大，SSTF 算法可能会导致饥饿现象。
4. 扫描（SCAN）调度算法扫描（SCAN）是一种按一个方向依次处理I/O请求，并在到达边界后改变方向的调度算法。
SCAN算法从一个方向开始处理请求，直到到达磁盘的边界。
磁盘调度的算法
磁盘调度的算法
磁盘调度是计算机操作系统中的一个重要功能，用于决定磁盘驱动器上的磁盘访问请求的顺序。
磁盘调度算法的目标是尽可能地减少磁盘的寻道时间和旋转延迟，以提高磁盘的访问效率。
常见的磁盘调度算法包括以下几种：
1. 先来先服务（FCFS）：磁盘访问请求按照它们的到达顺序进行处理。
这种算法简单且公平，但是可能导致磁盘的平均寻道时间较长。
2. 最短寻道时间优先（SSTF）：选择距离当前磁头位置最近的磁道作为下一个要访问的磁道。
这种算法能够减少磁头的寻道时间，但是可能会导致某些磁道被连续访问，从而降低了磁盘的整体吞吐量。
3. 扫描算法（SCAN）：磁头按照一个方向移动，处理磁盘上的请求，直到到达磁盘的边界，然后改变方向继续移动。
这种算法可以减少磁盘的平均寻道时间，并且确保所有的磁道都被访问到，但是可能导致某些磁道的访问延迟较长。
4. 循环扫描算法（C-SCAN）：类似于扫描算法，但是在到达磁盘边界后，直接返回到起始位置，而不是改变方向。
这种算法可以进一步降低磁头的寻道时间，并且在某些情况下可以提高磁盘的整体性能。
5. 最佳扫描算法（LOOK）：类似于扫描算法，但是在到达磁盘边界后，只改变方向，而不是反向移动。
这种算法可以根据实际的磁盘访问请求动态调整磁头的移动方向，以减少磁头的寻道时间。
需要注意的是，每种磁盘调度算法都有其适用的场景和优缺点，选择
合适的算法取决于具体的应用需求和性能要求。
磁盘调度算法代码
磁盘调度算法代码磁盘调度算法是操作系统中用于优化磁盘访问性能的重要策略之一。
在计算机系统中，数据通常存储在磁盘上，当需要读或写数据时，就需要通过磁盘调度算法来确定磁盘读写的顺序，以提高系统的性能和效率。
1. 磁盘调度算法的背景在了解磁盘调度算法之前，我们先了解一下磁盘的工作原理。
磁盘由一个或多个盘片组成，每个盘片上包含若干磁道，每个磁道又被分为若干扇区。
磁头在读写数据时需要移动到目标扇区所在的磁道上，而磁头的移动会导致一定的寻道时间。
磁盘调度算法的目标就是通过合理的调度磁盘的访问请求，使得磁头的移动距离最短，从而减少磁盘的寻道时间，提高系统的读写性能。
常见的磁盘调度算法有以下几种：•先来先服务（FCFS）：按照磁盘请求的到达顺序进行调度。
•最短寻道时间优先（SSTF）：选择离当前磁头位置最近的磁道进行访问。
•扫描算法（SCAN）：磁头从一端开始扫描磁道，直到扫描到达磁头上方的最后一个磁道，然后返回起始位置继续扫描。
•循环扫描算法（C-SCAN）：类似于SCAN算法，但是磁头在扫描到磁头上方的最后一个磁道后，直接返回起始位置继续扫描。
•电梯算法（LOOK）：磁头按磁道号的递增或递减顺序移动，直到当前方向上没有更多的磁道请求时改变方向。
2. 磁盘调度算法的代码实现下面以Python语言为例，给出一个简单的磁盘调度算法的代码实现。
这里以最短寻道时间优先（SSTF）算法为例。
首先，需要定义一个函数来计算当前磁头位置到目标磁道的距离：def calculate_distance(current, target):return abs(current - target)然后，我们可以编写一个磁盘调度函数来实现SSTF算法：def sstf(disk_queue, current_head):# 存储按磁道号排序的请求队列sorted_queue = sorted(disk_queue)# 存储已访问的磁道visited = []while sorted_queue:# 存储每个请求到当前磁头的距离distances = []for track in sorted_queue:distance = calculate_distance(current_head, track)distances.append((distance, track))# 根据距离进行排序distances.sort(key=lambda x: x[0])# 获取距离最小的磁道next_track = distances[0][1]# 移动磁头到下一个磁道current_head = next_track# 将访问过的磁道添加到已访问列表中visited.append(next_track)# 从请求队列中移除已访问的磁道sorted_queue.remove(next_track)return visited最后，我们可以使用上述代码来模拟一个磁盘调度的过程：if __name__ == '__main__':disk_queue = [98, 183, 37, 122, 14, 124, 65, 67]current_head = 53visited_tracks = sstf(disk_queue, current_head)print("磁盘访问顺序：", visited_tracks)运行上述代码，输出结果如下：磁盘访问顺序： [65, 67, 37, 14, 98, 122, 124, 183]上述代码实现了简单的SSTF算法，并模拟了一个磁盘访问的过程。
(第五讲磁盘调度算法)
操作系统实验报告哈尔滨工程大学计算机科学与技术学院一、实验概述1. 实验名称磁盘调度算法2.实验目的（1）通过学习EOS实现磁盘调度算法的机制，掌握磁盘调度算法执行的条件和时机。
（2）观察EOS实现的FCFS、SSTF和SCAN磁盘调度算法，了解常用的磁盘调度算法。
（3）编写CSCAN和N-Step-SCAN磁盘调度算法，加深对各种扫描算法的理解。
3. 实验类型验证，设计4. 实验内容（1）准备实验（2）验证先来先服务（FCFS）磁盘调度算法（3）验证最短寻道时间优先（SSTF）磁盘调度算法（4）验证SSTF算法造成的线程“饥饿”现象（）验证扫描（SCAN）磁盘调度算法（）验证SCAN 算法能够解决“饥饿”现象（6）改写SCAN调度算法二、实验环境EOS操作系统与IDE环境组成的“操作系统集成实验环境OS Lab”。
三、实验过程（一）实验问题及解答1.实验指导验证先来先服务（FCFS）磁盘调度算法，要求请给出在“输出”窗口中的结果。
答：输出结果复制如下：制作软盘镜像...正在启动Virtual PC...开始调试...****** Disk schedule start working ******Start Cylinder: 10TID: 31 Cylinder: 8 Offset: 2 -TID: 32 Cylinder: 21 Offset: 13 +TID: 33 Cylinder: 9 Offset: 12 -TID: 34 Cylinder: 78 Offset: 69 +TID: 35 Cylinder: 0 Offset: 78 -TID: 36 Cylinder: 41 Offset: 41 +TID: 37 Cylinder: 10 Offset: 31 -TID: 38 Cylinder: 67 Offset: 57 +TID: 39 Cylinder: 12 Offset: 55 -TID: 40 Cylinder: 10 Offset: 2 -Total offset: 360 Transfer times: 10 Average offset: 362.实验指导验证验证最短寻道时间优先（SSTF）磁盘调度算法，要求请给出在“输出”窗口中的结果。
操作系统-磁盘调度算法
操作系统-磁盘调度算法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个磁道。
磁盘调度scan算法
磁盘调度scan算法
磁盘调度算法是操作系统中用于确定磁盘读写请求执行顺序的一种算法。
SCAN （也称为Elevator）算法是磁盘调度算法中的一种，它模拟了电梯的上下运行过程。
SCAN算法的基本思想是，磁头在磁盘上沿着一个方向移动，直到到达磁盘的边界，然后返回到起始位置，继续移动。
在移动的过程中，磁头会按照请求队列中的请求顺序进行读写操作。
具体实现过程如下：
1. 确定磁头初始位置并指定一个移动方向。
2. 按照确定的移动方向，扫描磁盘，并将请求队列中需要访问的块分为两部分：在磁头当前位置同一方向上的块和在磁头当前位置反方向上的块。
3. 按照确定的移动方向，依次访问同一方向上的块，直到到达边界。
4. 到达边界后，改变移动方向并继续扫描，访问反方向上的块。
5. 重复步骤3和步骤4，直到所有的块都被访问完毕。
SCAN算法的优点是能够避免出现某些块长时间得不到访问的情况，同时也能够提供较高的磁盘访问速度。
然而，对于某些场景下的请求序列，SCAN算法可能会导致一些块的访问延迟较高。
为了解决这个问题，SCAN算法的改进版本如
C-SCAN（Circular SCAN）算法和LOOK算法被提出。
磁盘调度算法
磁盘调度算法现代操作系统中，磁盘利用外层磁道容量较内层磁道大的特点，将盘面划分成若干条环带，使得同一环带内的所有磁道具有相同的扇区数。
磁头在各磁道上移动，当进程请求时根据当前磁头位置和待访问位置决定访问次序。
本实验是模拟操作系统的磁盘寻道方式，运用磁盘访问顺序的不同来设计磁盘的调度算法。
设定开始磁道号寻道范围，依据起始扫描磁道号和最大磁道号数，随机产生要进行寻道的磁道号序列。
磁道访问序列不小于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";}。
sstf磁盘调度算法
sstf磁盘调度算法
磁盘调度算法用于决定磁盘驱动器上的磁头移动顺序，以提高磁盘访问的效率。
其中，SSTF (Shortest Seek Time First) 算法是一种常用的磁盘调度算法，其原理如下：
1. 当有新的磁盘请求到达时，SSTF 算法选择离当前磁头位置最近的请求进行处理。
2. 算法根据磁头当前位置和所有未完成的磁盘请求的
位置计算出它们与当前位置的距离。
3. 选择距离最短的磁盘请求作为下一个要处理的请求，并将磁头移动到该请求的位置。
4. 处理完当前请求后，继续选择距离最短的下一个请求进行处理，重复这个过程直到所有请求被处理完毕。
SSTF 算法的优点是最大程度地减少了磁头的移动距离，从而提高了磁盘访问的速度和效率。
然而，SSTF 算法也存在一些问题，例如可能会导致某些请求长时间等待，出现"饥饿"的情况。
为了解决这个问题，还有其他磁盘调度算法如SCAN、C-SCAN、LOOK、C-LOOK 等被提出并应用于实际系统中。
操作系统课程设计-磁盘调度算法
前言摘要：本课程设计的目的是通过设计一个磁盘调度模拟系统，从而使磁盘调度算法更加形象化，使磁盘调度的特点更简单明了，这里主要实现磁盘调度的四种算法，分别是：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.熟悉并掌握磁盘调度算法管理系统的设计方法，加强对所学各种调度算法及相应算法的特点了解。
磁盘调度算法
磁盘调度在多道程序设计的计算机系统中，各个进程可能会不断提出不同的对磁盘进行读/写操作的请求。
由于有时候这些进程的发送请求的速度比磁盘响应的还要快，因此我们有必要为每个磁盘设备建立一个等待队列，常用的磁盘调度算法有以下四种：先来先服务算法（FCFS），最短寻道时间优先算法（SSTF），扫描算法（SCAN），循环扫描算法（CSCAN）例:假定某磁盘共有200个柱面，编号为0-199，如果在为访问143号柱面的请求者服务后，当前正在为访问125号柱面的请求服务，同时有若干请求者在等待服务，它们每次要访问的柱面号为86，147，91，177，94，150，102，175，1301、先来先服务算法（FCFS）First Come First Service这是一种比较简单的磁盘调度算法。
它根据进程请求访问磁盘的先后次序进行调度。
此算法的优点是公平、简单，且每个进程的请求都能依次得到处理，不会出现某一进程的请求长期得不到满足的情况。
此算法由于未对寻道进行优化，在对磁盘的访问请求比较多的情况下，此算法将降低设备服务的吞吐量，致使平均寻道时间可能较长，但各进程得到服务的响应时间的变化幅度较小。
先来先服务（125）86.147.91.177.94.150.102.175.1302、最短寻道时间优先算法（SSTF）Shortest Seek Time First 该算法选择这样的进程，其要求访问的磁道与当前磁头所在的磁道距离最近，以使每次的寻道时间最短，该算法可以得到比较好的吞吐量，但却不能保证平均寻道时间最短。
其缺点是对用户的服务请求的响应机会不是均等的，因而导致响应时间的变化幅度很大。
在服务请求很多的情况下，对内外边缘磁道的请求将会无限期的被延迟，有些请求的响应时间将不可预期。
最短寻道时间优先（125）130.147.150.175.177.102.94.91.86 3、扫描算法（SCAN）电梯调度扫描算法不仅考虑到欲访问的磁道与当前磁道的距离，更优先考虑的是磁头的当前移动方向。
操作系统磁盘调度算法
操作系统磁盘调度算法磁盘调度算法的作用在计算机系统中，磁盘是一个重要的存储设备，而磁盘调度算法则是管理磁盘读写请求的关键操作之一。
磁盘调度算法可以使磁盘的读写时间最小，提高磁盘的利用率，保证磁盘的可靠性。
常见的磁盘调度算法先来先服务（FCFS）先来先服务是一种简单、易于实现的磁盘调度算法。
它将磁盘请求队列中的请求按照队列顺序进行服务，即磁盘读写请求按照先来先服务的原则被服务。
例如，如果请求队列为1,2,3,4,5，则磁头先会寻找1，完成后再寻找2，以此类推。
当然，这种算法会存在“饥饿”现象，即后面的请求需要等待前面的请求完成后才能获得服务。
最短寻道时间优先（SSTF）SSTF是一种比FCFS更优秀的算法，它选择离当前磁头位置最近的请求为下一个服务对象。
这种算法的好处在于，可以减少磁头的寻道时间。
例如，如果当前磁头在请求队列的3个请求2, 5和8的中间位置，则SSTF会选择请求2，这样会比选择5或8更快地完成磁盘读写。
扫描算法（SCAN）扫描算法，也称电梯算法，是一种沿着磁道的方向移动磁头的算法。
在扫描算法中，磁头在一个方向上移动，直到到达最边缘，然后开始沿着相反的方向移动，直到服务完整个队列。
例如，如果磁头的移动方向是向“外”（即向磁道号增大的方向），磁头将服务最小的请求，然后继续向下寻找。
当磁头到达队列的最大值后，再继续向“内”折回。
这种算法将会循环操作队列，直到完成服务。
循环扫描算法（C-SCAN）循环扫描算法是一种改进版的SCAN算法，它将SCAN算法改进成了一个环形的磁盘，在这个环形的磁盘上磁头运动方向是单向的。
与SCAN算法不同的是，当读写头到达一端时，它不会立即返回而是重新回到另一端继续扫描。
例如，一旦磁头到达队列的最大值，它会马上返回队列的最小值，这样可以更好地利用闲置时间服务队列。
磁盘调度算法的选择在实际应用中，选择适当的磁盘调度算法对于磁盘性能有着至关重要的影响。
FCFS算法简单但性能一般，SSTF算法寻找最近请求可提高系统性能，SCAN和C-SCAN算法可以处理高负载的读写请求。
操作系统实验四 磁盘调度算法
实验四磁盘调度一、实验目的：本实验要求学生模拟设计一个磁盘调度程序，观察调度程序的动态运行过程。
通过实验让学生理解和掌握磁盘调度的职能。
二、实验内容：对磁盘进行移臂操作，模拟磁盘调度算法并计算平均寻道时间三、实验准备：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) //确定当前磁道在已排的序列中的位置，后面的算法都用到了，可以直接复制后少量修改，节省时间。
磁盘调度算法
举例： 若磁头的当前位置为 72 磁道，磁头正向磁 道增加方向移动。现有一磁盘读写请求队列 98 ， 220，37，122，14，124，65，82，试计算出采 用下列不同算法的平均寻道长度各为多少？ （1）FCFS算法 （2）SSTF算法 （3）SCAN算法 （4）CSCAN算法
解：（1）FCFS算法 从72磁道开始
下一磁道 98 220 37 122 14 124 65 82 移动磁道数 26 122 183 85 108 110 59 17
平均寻道长度=710/8=89.75
解：（2）SSTF算法 从72磁道开始
下一磁道 65 82 98 122 124 37 14 220 移动磁道数 7 17 16 24 2 87 23 206
3．扫描算法（SCAN）
在磁头移动方向上选择与当前磁头所在的磁 道距离最近的请求作为下一次服务的对象。 优点：
（1）具有较好的寻道性能；
（2）避免了饥饿现象
缺点： 不利于远离磁头一端的访问请求。
Hale Waihona Puke 4．循环扫描算法（CSCAN）
是对扫描算法（SCAN）的改良，它规定磁头 单向移动，例如自内向外移动，当磁头移动到 最外磁道时立即又返回到最内磁道，如此循环 进行扫描。
磁盘调度算法 磁盘调度算法有若干种，但着眼点都放在 寻道优化上，即寻道时间尽量短，吞吐量尽量 大。目前广泛使用的寻道策略有下列几种：
1．先来先服务寻道算法（FCFS）：
按进程请求访问磁盘的先后次序进行调度。
特点：合理、简单、但未对寻道进行优化。
2 ．最短寻道时间优先算法（SSFT ， ShortestSeek-Time-First） 选择与当前磁头所在的磁道距离最近的请求 作为下一次服务的对象。 缺点： （1）不能保证平均寻道时间最短； （ 2 ）可能会使某些请求总得不到服务（又 称饥饿）。
计算机操作系统第七章--磁盘调度
58
55 39
32
3 16
38
18
1
20
平均寻道长度：27.8
7.1.3 各种扫描算法
二、循环扫描CSCAN(Circular SCAN)单 向扫描 SCAN算法既能获得较好的性能， 又能访止进程饥饿，广泛用于大、中、 小型 机和网络中的磁盘调度。
7.1.3 各种扫描算法
问题：当磁头刚从里向外移动过 某一磁道时，恰有一进程请求访问 此磁道，这时该进程必须等待，待 磁头从里向外，然后再从外向里扫 描完所有要访问的磁道后，才处理 该进程的请求，致使该进程的请求 被严重地推迟。
Tr是指定扇区移动到磁头下面所 经历的时间。对于硬盘，典型的旋转 速度为3 600r/min(54 000r/min或72 000r/min),每转需时16.6ms(11.1,s).平
均旋转延迟时间Tr为8.3ms(5.55ms).对
于软盘，其旋转速度为300或600r/min，
这样，平均Tr为50~100ms.
一、扫描(SCAN)算法 1.进程“饥饿”现象 SSTF算法虽然获得较好的寻道性能， 但它可能导致某些进程发生“饥 饿”(Starvation). 对SSTF算法略加修改后所形成的 SCAN算法，即可防止老进程出现饥饿现 象。
7.1.3 各种扫描算法
2.SCAN算法(Denning首先提出的) 该算法不仅考虑到欲访问的磁道与当 前磁道的距离，更优先考虑的是磁头的当 前移动方向。例如，当磁头正在自里向外 移动时，SCAN算法所选择的下一个访问 对象应既在当前磁道之外，又是距离最近 的磁道。 这样自里向外地访问，直至再无 更外的磁道需要访问时，才将磁臂换向， 自外向里移动。
150
160 184
磁盘调度算法文库
#include"stdio.h"#include"stdlib.h"#include"iostream.h"#define maxsize 100/***************************************************************** *************//* ÏÈÀ´ÏÈ·þÎñµ÷¶ÈËã·¨/***************************************************************** *************/void FCFS(int array[],int m){int sum=0,j,i;for( i=0;i<m;i++){cout<<array[i]<<" ";}for(i=0,j=1;j<m;i++,j++){sum+=abs(array[j]-array[i]);}cout<<"Òƶ¯µÄ×ܵÀÊý£º "<<sum<<endl;}/***************************************************************** *************//* ×î¶ÌÑ°µÀʱ¼äÓÅÏȵ÷¶ÈËã·¨/***************************************************************** *************/void ShortPath(int array[],int m){int temp;int k=1;int now,l,r;int i,j,sum=0;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;}}for( i=0;i<m;i++){cout<<array[i]<<" ";}/*ÅÅÐò*/cout<<"ÇëÊäÈ뵱ǰµÄ´ÅµÀºÅ£º";cin>>now;if(array[m-1]<=now){for(i=m-1;i>=0;i--)cout<<array[i]<<" ";sum=now-array[0];}elseif(array[0]>=now){for(i=0;i<m;i++)cout<<array[i]<<" ";sum=array[m-1]-now;}else{while(array[k]<now){k++;}l=k-1;r=k;/*È·¶¨µ±Ç°´ÅµÀÔÚÒÑÅŵÄÐòÁÐÖеÄλÖ㬺óÃæµÄËã·¨¶¼Óõ½ÁË£¬¿ÉÒÔÖ±½Ó¸´ÔÓºóÉÙÁ¿Ð޸ģ¬½Úʡʱ¼ä¡£*/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;}else{cout<<array[r]<<" ";sum+=array[r]-now;now=array[r];r=r+1;}}if(l=-1){for(j=r;j<m;j++){cout<<array[j]<<" ";}sum+=array[m-1]-array[0];}else{for(j=l;j>=0;j--){cout<<array[j]<<" ";}sum+=array[m-1]-array[0];}}cout<<"Òƶ¯µÄ×ܵÀÊý£º "<<sum<<endl;}</P><P> </P><P>/***************************************************************** *************//* µçÌݵ÷¶ÈËã·¨/***************************************************************** *************/void Elevator(int array[],int m) <a>file://ÏÈ</A>Òª¸ø³öµ±Ç°´ÅµÀºÅºÍÒƶ¯±ÛµÄÒƶ¯·½Ïò{int temp;int k=1;int now,l,r,d;int i,j,sum=0;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;}}for( i=0;i<m;i++){cout<<array[i]<<" ";}cout<<"ÇëÊäÈ뵱ǰµÄ´ÅµÀºÅ£º";cin>>now;if(array[m-1]<=now){for(i=m-1;i>=0;i--)cout<<array[i]<<" ";sum=now-array[0];}elseif(array[0]>=now){for(i=0;i<m;i++)cout<<array[i]<<" ";sum=array[m-1]-now;}else{while(array[k]<now){k++;}l=k-1;r=k;cout<<"ÇëÊäÈ뵱ǰÒƶ¯±ÛµÄÒƶ¯µÄ·½Ïò (1 ±íʾÏòÄÚ £¬0±íʾÏòÍâ) : "; cin>>d;if(d==0){for(j=l;j>=0;j--){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];}}cout<<"Òƶ¯µÄ×ܵÀÊý£º "<<sum<<endl;}</P><P>/***************************************************************** *************//* µ¥ÏòɨÃèµ÷¶ÈËã·¨/***************************************************************** *************/void SCAN(int array[],int m){int temp;int k=1;int now,l,r;int i,j,sum=0;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;}}for( i=0;i<m;i++){cout<<array[i]<<" ";}cout<<"ÇëÊäÈ뵱ǰµÄ´ÅµÀºÅ£º";cin>>now;if(array[m-1]<=now){for(i=0;i<m;i++)cout<<array[i]<<" ";sum=now-array[0]+array[m-1];}elseif(array[0]>=now){for(i=0;i<m;i++)cout<<array[i]<<" ";sum=array[m-1]-now;}else{while(array[k]<now){k++;}l=k-1;r=k;for(j=r;j<m;j++){cout<<array[j]<<" ";}for(j=0;j<r;j++){cout<<array[j]<<" ";}sum=2*array[m-1]-now;}cout<<"Òƶ¯µÄ×ܵÀÊý£º "<<sum<<endl; }void main(){int c;FILE *fp;int cidao[maxsize];int i=0,count;fp=fopen("cidao.txt","r+");if(fp==NULL){cout<<"can not find file!"<<endl;exit(0);}while(!feof(fp)){fscanf(fp,"%d",&cidao[i]);i++;}count=i-1;for(i=0;i<count;i++){printf("%5d",cidao[i]);}cout<<endl;while(1){cout<<endl<<"ϵͳµÄ²Ëµ¥ÈçÏ£º"<<endl;printf("1. ÏÈÀ´ÏÈ·þÎñ 2. ×î¶ÌÑ°µÀʱ¼äÓÅÏÈ 3. µçÌݵ÷¶È"); cout<<endl;printf("4. µ¥ÏòɨÃè 5. Í˳ö");cout<<endl;cout<<"ÇëÑ¡Ôñ£º";cin>>c;if(c>4)break;switch(c){case 1:FCFS(cidao,count);break;case 2:ShortPath(cidao,count);break;case 3:Elevator(cidao,count);break;case 4:SCAN(cidao,count);break;}}}。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
磁盘调度算法 -电脑资料
2019-01-01
磁盘优点
容量很大每位的价格非常低当关掉电源后存储信息不丢失
物理特性
磁盘表面覆盖着磁性物质，信息记录在磁表面上，。
固定头磁盘的每个磁道单独有一个磁头，这样就能使得计算机可以很快地从一个磁道转换到另一个磁道。
但是这需要大量的头，设备成本很高。
更通用的方式是每个盘面只有一个头，让它从一道移向另一道。
这种动头设备需要硬件设备移动头。
磁盘一般用于文件存储，设计原则是：成本低、容量大、速度高。
扩大存储容量：a.增加每英寸磁道数目; b. 双面记录。
存取盘块中的信息一般要有三部分时间：系统首先要把磁头移到相应的道上或柱面上，这个时间叫做寻道时间;一旦磁头到达指定磁道，必须等待所需要的扇区转到读/写头下，这个延迟时间叫做旋转延迟时间;最后，信息实际在磁盘和内存之间进行传送也要花费时间，这部分时间叫做传送时间。
一次磁盘服务的总时间就是这三者之和。
要使磁盘服务尽可能地快，操作系统要提供合适的调度算法，改善磁盘服务的平均时间。
进程需要和磁盘交换信息时必须要操作系统发出系统调用，对磁盘的请求一般要有下述几部分内容：
1. 输入和输出;
2. 磁盘地址（驱动器、柱面、面号、扇区）;
3. 内存地址;
4. 传送长度。
磁盘调度算法
1、先来先服务调度（FCFS）
FCFS 算法是优先为最先到达的请求服务。
例如，有如下请求磁盘服务队列，要访问的磁道数分别是：
98，183，37，122，14，124，65，67
排在前面的是先到达的请求，假设磁头目前停留在53磁道上，按照先来先服务的算法，接下来磁头的移动顺序依次是：
53—>98—>183—>37—>122—>14—>124—>65—>67
这个过程总共移动了（98-53）+（183-98）+（183-37）+（122-37）+（122-14）+（124-14）+（124-65）+（67-65）=640个磁道
这种调度法产生的磁头移动服务太大，磁头频繁的大幅度移动，容易产生机械振动和误差，对使用寿命有损害。
所以，要设计好的算法来减少磁头移动幅度，减少服务时间，改善磁盘的吞吐量。
2、最短寻道时间优先法（SSTF）
??优先服务接近于磁头当前位置的请求。
SSTF从本质上将是SJF（最短作业优先算法）调度的形式。
使用SSTF调度算法，上面那个请求队列的执行顺序是：
??53—>65—>67—>37—>14—>98—>122—>124—>183
总共移动了236个磁道，比FCFS的三分之一多一点，明显改善了磁盘服务，
《》()。
??但是这种算法并不是最优的。
例如，若把磁头从53道移动到37道（尽管不是靠的最近的），然后移动到14，接下去是65，67，98，122，124，183，总共移动了208个磁道<236。
??SSTF也可能导致某些请求长期得不到服务（即“饥饿”问题）。
如果当前磁头附近总会不断的到来新的请求，那么距离磁头远的请求将会一直等待下去。
3、扫描法（SCAN）
由于请求服务的队列具有动态性质，总会有新的请求到达，因此可采用扫描算法。
读/写磁头从磁盘的一端出发，向另一端移动，遇到所需的磁道时就
进行服务，直至到达磁盘的另一端。
在另一端上，磁头移动方向反过来，继续做下面的服务。
这样磁头就连续从盘的一端扫到另一端。
根据前面的例子，但要知道磁头移动的方向和它最近的位置。
如果磁头向0道方向移动，则先为37道和14道服务。
到达0道，磁头移动方向反过来，并移向磁盘的另一端，接下来服务序列分别是65，67，98，122，124，183。
在具体实现算法时，没有必要让磁头总是从磁盘的一端移到另一端。
更通常的做法是：磁头仅移到每个方向上最远的请求磁道上，一旦在当前方向上没有进一步的服务请求了，磁头的移动方向就会反过来，继续为下面的请求服务。
这种算法也称为“电梯算法”。
例如上面的例子，磁头服务了37，14后发现前面没有新的请求了，就不会向前继续移动到0道，立即掉头服务65道……
这种算法会产生的问题是：假定对磁道的请求是均匀分布的，当磁头到达一方最远端并反过方向时，立即落在磁盘后面的请求相对而言很少，因为这些磁道刚刚得到过服务，而在盘的另一端却有较多的请求，其等待的时间也最长。
4、巡回扫描法（C-SCAN）
C-SCAN是SCAN的变种，可使得等待的时间变的均匀。
与SCAN的区别是，它移动到一端，方向放过来，但是在返回的过程中不进行服务，就是直接从一端切换到另一段，然后再按照刚才的方向移动，遇到请求的磁道就服务。
例如上面的例子，先向0道移动，53–>37–>14，然后反方向，换到另一端，183–>124–>122–>98–>67–>65。
磁盘调度算法的选择
任何调度算法的性能都紧紧的依赖于I/O请求的数量和类型，对于磁盘负荷很重的系统来说选择电梯算法和C-SCAN算法更为合适。
在极个别情况下，若队列中很少有对于一个未完成的请求，那么所有算法实际上都是等效的。
研究表明，通常情况下队列中仅有一个请求。
这时，FCFS也是很合适的算法。
磁盘服务的请求受文件分配方式的影响很大。
读连续文件的程度将产生大量的在盘上挤在一起的请求，磁头的移动有限。
而对于串连或索引文件来说，可能涉及在盘上广泛分配的盘块，要靠减少磁头移动来获取较好的磁盘使用效率。
目录和索引块的位置对I/O请求的队列有很重要的影响。
如果文件的数据和它的目录项在盘上的位置相距很远，则磁头移动距离很长。
如果把目录和索引块放在缓存中，则可明显减少磁头的移动，尤其对读请求更是如此。
以上仅考虑寻道距离对调度算法的影响。
但对于现代磁盘，旋转延迟几乎接均寻道时间。
然而操作系统很难通过调度来改善旋转延迟时间，因为逻辑
块的物理位置对外并未公布。
当然，磁盘制造商通过在控制器硬件中实现调度算法可以缓减这个问题。