(第五讲磁盘调度算法)
磁盘调度算法的模拟实现及对比
磁盘调度算法的模拟实现及对比磁盘调度算法是操作系统中的一个重要组成部分，用于优化磁盘读写操作的效率，提高系统的响应速度和运行效率。
常见的磁盘调度算法包括先来先服务(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`，然后不断选择离当前磁道最近的请求处理，直到所有请求处理完毕。
磁盘调度算法
实验六磁盘调度算法【实验目的】通过这次实验，加深对磁盘调度算法的理解，进一步掌握先来先服务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）输出：每种算法的平均寻道长度。
实现提示：用C++语言实现提示：1）程序中变量定义参考（根据需要可添加）如下：const int MaxNumber=100;int TrackOrder[MaxNumber];int MoveDistance[MaxNumber];double AverageDistance;bool direction;2）页面置换的实现过程如下：变量初始化；接收用户输入磁道个数n和磁盘访问序列，选择算法1-FCFS，2-SSTF，3-SCAN，4-循环SCAN，输入开始磁盘号m和磁头移动方向；根据用户选择的算法进行磁道访问，输出磁盘调度算法的模拟过程；计算选择每次移动的磁头移动距离和算法的平均寻道长度；输出选择算法的平均寻道长度。
实验要求：1）上机前认真复习磁盘调度算法，熟悉FCFS、SSTF、SCAN 和循环SCAN算法的过程；2）上机时独立编程、调试程序；3）根据具体实验要求，完成好实验报告（包括实验的目的、内容、要求、源程序、实例运行结果截图、发现的问题以及解决方法）。
磁盘调度算法
磁盘调度算法⼀次磁盘读写操作的时间由寻找(寻道)时间、延迟时间和传输时间决定: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、缺点:效率不⾼，相邻两次请求可能会造成最内到最外的柱⾯寻道，使磁头反复移动，增加了服务时间，对机械也不利。
磁盘调度算法
文件系统的物理基础是磁盘存储设备。所以， 文件系统的物理基础是磁盘存储设备。所以， 磁盘存储器的服务效率很重要， 磁盘存储器的服务效率很重要，为了提高文件 系统的性能，我们必须对磁盘进行合理的管理 系统的性能， 、调度，对磁盘调度算法进行优化。 调度，对磁盘调度算法进行优化。
第五章 磁盘存储器管理
第五章 磁盘存储器管理
2012-5-2
17
总结： 总结：
1． 先来先服务 ． 2. 最短寻道时间优先 最短寻道时间优先(SSF) 3. 扫描算法（电梯算法） 扫描算法（电梯算法） 4 .循环扫描调度算法 循环扫描调度算法
5. N-Step-SCAN和FSCAN调度算法 了解 和 调度算法(了解 调度算法 了解)
第五章 磁盘存储器管理 2012-5-2 4
1． 先来先服务 ．
按访问请求到达的先后次序服务 优点：简单，公平； 优点：简单，公平； 缺点：效率不高， 缺点：效率不高，相邻两次请求可 能会造成最内到最外的柱面寻道， 能会造成最内到最外的柱面寻道，使 磁头反复移动，增加了服务时间， 磁头反复移动，增加了服务时间，对 机械也不利
第五章 磁盘存储器管理 2012-5-2 5
例
假设磁盘访问序列： ， 假设磁盘访问序列：98，183，37，122， ， ， ， 14，124，65，67。移动臂的运动方向：沿 ， ， ， 。移动臂的运动方向： 磁道号递减的方向移动。 磁道号递减的方向移动。 读写头起始位置： 读写头起始位置：53 1） （1）安排磁头服务序列 （2）计算磁头移动总距离（道数） ）计算磁头移动总距离（道数）
课后任务： 课后任务：为了更好的掌握本节课所学的内 请大家完成书后习题6的第 小题。 的第12小题 容。请大家完成书后习题 的第 小题。
磁盘调度算法操作系统的任务之一就是有效地使用硬件对磁盘
8.2 磁盘调度算法操作系统的任务之一就是有效地使用硬件。
对磁盘驱动器来说，满足这一要求意味着要有较快的访问速度和较宽的磁盘带宽。
访问时间包括两个主要部分是寻道时间和旋转延迟。
寻道时间是磁臂将磁头移动到包含目标扇区的柱面的时间。
旋转延迟是磁盘需要将目标扇区转动到磁头下的时间。
磁盘带宽是所传递的总的字节数除以从服务请求开始到最后传递结束时的总时间。
可以通过使用适当的访问顺序来调度磁盘I/O请求，提高访问速度和带宽。
每当一个进程需要对磁盘进行I/O操作，它就向操作系统发出一个系统调用。
该调用请求指定了一些信息：·操作是输入还是输出？·所传输的磁盘地址是什么？·所传输的内存地址是什么？·所传输的扇区数是多少？如果所需的磁盘驱动器和控制器空闲，那么该请求会马上处理。
如果磁盘驱动器或控制器忙，那么任何新的服务请求都会加到该磁盘驱动器的待处理请求队列上。
对于一个有多个进程的多道程序设计系统，磁盘队列可能有多个待处理请求。
因此，当完成一个请求时，操作系统可以选择处理哪个待处理请求。
那么操作系统该如何选择呢？有多个磁盘调度算法可供使用，接下来将会加以讨论磁盘调度算法用以改善磁盘的平均寻道时间。
典型算法有FCFS算法、最短寻道时间优先算法SSTF、SCAN算法、C-SCAN算法。
目前常用的磁盘调度算法有：先来先服务、最短寻道时间优先、扫描算法和循环扫描算法等。
（1）先来先服务算法FCFS（First Come First Served）这是一种最简单的磁盘调度算法。
它根据进程请求访问磁盘的先后次序进行调度。
此算法的优点是公平、简单，且每个进程的请求都能依次得到处理，不会出现某一进程的请求长期得不到满足的情况。
但此算法由于未对寻道进行优化，致使平均寻道时间可能较长。
假定有一个磁盘请求队列，其I/O对各柱面上块的请求序列如下：（磁道编号从0－199）98, 183, 37, 122, 14, 124, 65, 67如果当前磁头位置位于53，图8.4显示了FCFS调度算法的磁头移动路径，总的磁头移动为640柱面。
磁盘调度算法-电脑资料.
磁盘调度算法 -电脑资料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个磁道这种调度法产生的磁头移动服务太大，磁头频繁的大幅度移动，容易产生机械振动和误差，对使用寿命有损害。
磁盘调度算法简述
磁盘调度算法简述⼀⼂意义：良好的调度算法，能减少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指向磁头的当前磁道和扇区对应的线形距离数字，对前置后驱元素进⾏判定，以距离较短者作为下次磁盘访问对象。
磁盘调度算法实验设计报告
实验五磁盘调度算法班级： xxxxxxxxxxxx姓名：xxxxxxxx学号：xxxxxxxxxxxxxxxxxxxxx上级日期：2018年11月成绩：___________________________一、实验目的:通过磁盘调度算法设计一个磁盘调度模拟系统，从而使磁盘调度算法更加形象化，容易理解，使磁盘调度的特点更简单明了，加深对先来先服务算法、最短寻道时间优先算法、扫描算法以及循环扫描算法等磁盘调度算法的理解二、实验内容1、程序流程图模块调用关系图模块程序流程图FCFS算法（先来先服务）流程图SSTF（最短寻道时间优先算法）流程图SCAN算法（扫描算法）流程图CSCAN算法（循环扫描算法）流程图2、程序源码1.#include<stdio.h>2.#include<stdlib.h>3.#include<iostream>4.#include<math.h>ing namespace std;6.#define maxsize 10007./*********************判断输入数据是否有效**************************/8.int decide(char str[]) //判断输入数据是否有效9.{10.int i = 0;11.while (str[i] != '\0')12. {13.if (str[i]<'0' || str[i]>'9')14. {15.return 0;16.break;17. }18. i++;19. }20.return i;21.}22./******************将字符串转换成数字***********************/23.int trans(char str[], int a) //将字符串转换成数字24.{25.int i;26.int sum = 0;27.for (i = 0; i<a; i++)28. {29. sum = sum + (int)((str[i] - '0')*pow(10, a - i - 1));30. }31.return sum;32.}33./*********************冒泡排序算法**************************/34.int *bubble(int cidao[], int m)35.{36.int i, j;37.int temp;38.for (i = 0; i<m; i++) //使用冒泡法按从小到大顺序排列39.for (j = i + 1; j<m; j++)40. {41.if (cidao[i]>cidao[j])42. {43. temp = cidao[i];44. cidao[i] = cidao[j];45. cidao[j] = temp;46. }47. }48. cout << "排序后的磁盘序列为：";49.for (i = 0; i<m; i++) //输出排序结果50. {51. cout << cidao[i] << " ";52. }53. cout << endl;54.return cidao;55.}56./*********************先来先服务调度算法************************/57.void FCFS(int cidao[], int m) //磁道号数组，个数为m58.{59.int now;//当前磁道号60.int sum = 0; //总寻道长度61.int j, i;62.int a;63.char str[100];64.float ave; //平均寻道长度65. cout << "磁盘请求序列为：";66.for (i = 0; i<m; i++) //按先来先服务的策略输出磁盘请求序列67. {68. cout << cidao[i] << " ";69. }70. cout << endl;71. cout << "请输入当前的磁道号：";72.B: cin >> str; //对输入数据进行有效性判断73. a = decide(str);74.if (a == 0)75. {76. cout << "输入数据的类型错误,请重新输入！" << endl;77.goto B;78. }79.else80. now = trans(str, a); //输入当前磁道号81. sum += abs(cidao[0] - now);82. cout << "磁盘扫描序列为：";83.for (i = 0; i<m; i++) //输出磁盘扫描序列84. {85. cout << cidao[i] << " ";86. }87.for (i = 0, j = 1; j<m; i++, j++) //求平均寻道长度88. {89. sum += abs(cidao[j] - cidao[i]);90. ave = (float)(sum) / (float)(m);91. }92. cout << endl;93. cout << "平均寻道长度：" << ave << endl;94.}95./**********************最短寻道时间优先调度算法********************/96.void SSTF(int cidao[], int m)97.{98.int k = 1;99.int now, l, r;100.int i, j, sum = 0;101.int a;102.char str[100];103.float ave;104. cidao = bubble(cidao, m); //调用冒泡排序算法排序105. cout << "请输入当前的磁道号：";106.C: cin >> str; //对输入数据进行有效性判断107. a = decide(str);108.if (a == 0)109. {110. cout << "输入数据的类型错误,请重新输入！" << endl;111.goto C;112. }113.else114. now = trans(str, a); //输入当前磁道号115.if (cidao[m - 1] <= now) //若当前磁道号大于请求序列中最大者，则直接由外向内依次给予各请求服务116. {117. cout << "磁盘扫描序列为：";118.for (i = m - 1; i >= 0; i--)119. cout << cidao[i] << " ";120. sum = now - cidao[0];121. }122.if (cidao[0] >= now) //若当前磁道号小于请求序列中最小者，则直接由内向外依次给予各请求服务123. {124. cout << "磁盘扫描序列为：";125.for (i = 0; i<m; i++)126. cout << cidao[i] << " ";127. sum = cidao[m - 1] - now;128. }129.if (now>cidao[0] && now<cidao[m - 1]) //若当前磁道号大于请求序列中最小者且小于最大者130. {131. cout << "磁盘扫描序列为：";132.while (cidao[k]<now) //确定当前磁道在已排的序列中的位置，后面的算法都用到了，可以直接复制后少量修改，节省时间。
磁盘调度算法的实现
实验五、磁盘调度算法的实现一、实验目的实验程序模拟先来先服务FCFS，最短寻道时间优先SSTF，SCAN和循环SCAN 算法的工作过程。
假设有n个磁道号所组成的磁道访问序列，给定开始磁道号m 和磁头移动的方向（正向或者反向），分别利用不同的磁盘调度算法访问磁道序列，给出每一次访问的磁头移动距离，计算每种算法的平均寻道长度，本程序采用随机数来产生磁道数。
二、实验要求算法所需的各种参数由输入产生（手工输入或者随机数产生）。
最后的结果要求是在运行四种算法的程序后，能够输出调度过程、平均寻道长度的正确结果。
三、实验说明(1) 先来先服务．(FCFS):这是一种简单的磁盘调度算法。
它根据进程请求访问磁盘的先后次序进行调度。
此算法的优点是公平、简单，且每个进程的请求都能依次得到处理，不会出现某一进程的请求长期得不到满足的情况。
但此算法由于未对寻道进行优化，致使平均寻道时间可能较长。
(2) 最短寻道时间优先(SSTF):该算法选择这样的进程，其要求访问的磁道与当前磁头所在的磁道距离最近，以使每次的寻道时间最短，但这种调度算法却不能保证平均寻道时间最短。
(3) 扫描算法(SCAN):SCAN算法不仅考虑到欲访问的磁道与当前磁道的距离，更优先考虑的是磁头的当前移动方向。
例如，当磁头正在自里向外移动时，SCAN算法所选择的下一个访问对象应是其欲访问的磁道既在当前磁道之外，又是距离最近的。
这样自里向外地访问，直到再无更外的磁道需要访问才将磁臂换向，自外向里移动。
这时，同样也是每次选择这样的进程来调度，即其要访问的磁道，在当前磁道之内，从而避免了饥饿现象的出现。
由于这种算法中磁头移动的规律颇似电梯的运行，故又称为电梯调度算法。
（4）循环扫描算法（CSCAN）CSCAN算法是对扫描算法的改进。
如果对磁道的访问请求是均匀分布的，当磁头到达磁盘的一端，并反向运动时落在磁头之后的访问请求相对较少。
这是由于这些磁道刚被处理，而磁盘另一端的请求密度相当高，且这些访问请求等待的时间较长，为了解决这种情况，循环扫描算法规定磁头单向移动。
第五章_磁盘移臂调度算法
共移动120柱面
(0+4+24+8+8+72+4)*3=120*3=360 ms
（3）电梯调度算法： 由于未指明开始移动的方向，分成两种情形： OUT：
40 → 40 → 20 → 12 → 4 → 44 ） （40） （32） （4）
其中进程是按其发出 进程号 磁道号 移动距离(磁道数) 请求的先后顺序排列的。 4 19 81 9 376 357 采用的是FCFS调度策略。 23 205 171 完成这组I/O操作需移动 7 134 71 磁头的总距离为1604磁道。 34 18 116 22 56 38 优点： 公平、简单，且 14 192 136 每个进程的请求都能依次 3 396 204 32 29 367 得到处理，不会出现某进 17 3 26 程的请求长期得不到满足 12 19 16 29 40 21 的情况。 磁头移动的总距离=1604 (磁道) 缺点：与后面讲的几种 调度算法相比，其平均寻道距离较大。故此算法仅 适用于请求磁盘上的进程数较少的场合。
2 FSCAN算法 FSCAN算法实质上是N-Step-SCAN算法 的简化。它只将磁盘请求访问队列分成两个 子队列。 一是当前所有请求磁盘I/O的进程形成的 队列，由磁盘调度按SCAN算法进行处理。 另一个队列则是在扫描期间，新出现的 所有请求磁盘I/O进程的队列，把它们排入另 一个等待处理的请求队列。 这样，所有的新请求都将被推迟到下一 次扫描时处理。
一、先来先服务FCFS
(First-Come, First-Served)
这是一种最简单的磁盘调度算法。它根 据进程请求访问磁盘的先后次序进行调度。
操作系统实验 第五讲 磁盘调度算法讲课讲稿
操作系统实验第五讲磁盘调度算法操作系统实验报告哈尔滨工程大学计算机科学与技术学院第六讲磁盘调度算法一、实验概述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 算法源代码的基础上进行改写，要求不再使用双重循环，而是只遍历一次请求队列中的请求，就可以选中下一个要处理的请求。
算法流程图如下图所示。
图 3.1.1 SCAN算法IopDiskSchedule函数流程图（2）编写循环扫描（CSCAN）磁盘调度算法在已经完成的SCAN算法源代码的基础上进行改写，不再使用全局变量ScanInside确定磁头移动的方向，而是规定磁头只能从外向内移动。
当磁头移动到最内的被访问磁道时，磁头立即移动到最外的被访问磁道，即将最大磁道号紧接着最小磁道号构成循环，进行扫描。
算法流程图如下图所示。
图 3.1.2 CSCAN算法IopDiskSchedule函数流程图（3）编写N-Step-SCAN磁盘调度算法在已经完成的 SCAN 算法源代码的基础上进行改写，将请求队列分成若干个长度为 N 的子队列，调度程序按照 FCFS原则依次处理这些子队列，而每处理一个子队列时，又是按照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";}。
磁盘的调度算法
实验七磁盘的调度算法一.实验要求设计五个算法,分别是先来先服务算法,最短寻道时间优先算法,扫描(SCAN)算法,循环扫描(CSCAN)算法,NStepSCAN算法.由人工输入当前的磁道数,由系统随即生成要访问的磁道.二、开发环境操作系统:Rad Hat Linux ,开发环境:C语言.三、分析设计（一）实验原理.磁盘是可被多个进程共享的设备。
当有多个进程都请求访问磁盘时，应采用一种适当的调度算法，以使各进程对磁盘的平均访问(主要是寻道)时间最小。
由于在访问磁盘的时间中，主要是寻道时间，因此，磁盘调度的目标应是使磁盘的平均寻道时间最少。
(1) 先来先服务．(First-Come，First-Served，FCFS):这是一种简单的磁盘调度算法。
它根据进程请求访问磁盘的先后次序进行调度。
此算法的优点是公平、简单，且每个进程的请求都能依次得到处理，不会出现某一进程的请求长期得不到满足的情况。
但此算法由于未对寻道进行优化，致使平均寻道时间可能较长。
(2) 最短寻道时间优先(ShortestSeekTimeFirst，SSTF):该算法选择这样的进程，其要求访问的磁道与当前磁头所在的磁道距离最近，以使每次的寻道时间最短，但这种调度算法却不能保证平均寻道时间最短。
(3) 扫描(SCAN)算法:SCAN算法不仅考虑到欲访问的磁道与当前磁道的距离，更优先考虑的是磁头的当前移动方向。
例如，当磁头正在自里向外移动时，SCAN算法所选择的下一个访问对象应是其欲访问的磁道既在当前磁道之外，又是距离最近的。
这样自里向外地访问，直到再无更外的磁道需要访问才将磁臂换向，自外向里移动。
这时，同样也是每次选择这样的进程来调度，即其要访问的磁道，在当前磁道之内，从而避免了饥饿现象的出现。
由于这种算法中磁头移动的规律颇似电梯的运行，故又称为电梯调度算法。
(4) 循环扫描(CSCAN)算法:处理该进程的请求，致使该进程的请求被严重地推迟。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实用标准文案操作系统实验报告哈尔滨工程大学计算机科学与技术学院一、实验概述1. 实验名称磁盘调度算法2. 实验目的(1)通过学习EOS 实现磁盘调度算法的机制，掌握磁盘调度算法执行的条件和时机。
(2)观察EOS实现的FCFS、SSTF和SCAN磁盘调度算法，了解常用的磁盘调度算法。
( 3)编写CSCAN 和N-Step-SCAN 磁盘调度算法，加深对各种扫描算法的理解。
3. 实验类型验证，设计4. 实验内容( 1)准备实验(2)验证先来先服务(FCFS)磁盘调度算法(3)验证最短寻道时间优先(SSTF)磁盘调度算法(4)验证SSTF 算法造成的线程“饥饿”现象(5.1)验证扫描(SCAN)磁盘调度算法(5.2)验证SCAN 算法能够解决“饥饿”现象( 6 ) 改写SCAN 调度算法二、实验环境EOS 操作系统与IDE 环境组成的“操作系统集成实验环境OS Lab ”。
三、实验过程（一）实验问题及解答1. 实验指导P176-3.2验证先来先服务（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: 40 Cylinder: 10 Offset: 2 -Total offset: 360 Transfer times: 10 Average offset: 362. 实验指导P177-3.3验证验证最短寻道时间优先（SSTF）磁盘调度算法, 要求请给出在“输出”窗口中的结果。
答：输出结果复制如下：制作软盘镜像...正在启动Virtual PC...开始调试...****** Disk schedule start working ******Start Cylinder: 10TID: 37 Cylinder: 10 Offset: 0 =TID: 40 Cylinder: 10 Offset: 0 =TID: 33 Cylinder: 9 Offset: 1 -TID: 31 Cylinder: 8 Offset: 1 -TID: 32 Cylinder: 21 Offset: 9 +TID: 36 Cylinder: 41 Offset: 20 +TID: 40 Cylinder: 10 Offset: 2 -TID: 39 Cylinder: 12 Offset: 4 +TID: 32 Cylinder: 21 Offset: 9 + TID: 36 Cylinder: 41 Offset: 20 +TID: 38 Cylinder: 67 Offset: 26 +TID: 34 Cylinder: 78 Offset: 11 +TID: 35 Cylinder: 0 Offset: 78 -Total offset: 150 Transfer times: 10 Average offset: 153. 实验指导P178-3.4 验证SSTF 算法造成的线程“饥饿”现象，要求请给出在“输出”窗口中的结果。
答：输出结果复制如下：制作软盘镜像...正在启动Virtual PC...开始调试...****** Disk schedule start working ******Start Cylinder: 10TID: 37 Cylinder: 10 Offset: 0 =TID: 40 Cylinder: 10 Offset: 0 =TID: 33 Cylinder: 9 Offset: 1 -TID: 34 Cylinder: 8 Offset: 1 -TID: 35 Cylinder: 11 Offset: 3 +TID: 39 Cylinder: 12 Offset: 1 +TID: 32 Cylinder: 21 Offset: 9 +TID: 36 Cylinder: 41 Offset: 20 +TID: 38 Cylinder: 67 Offset: 26 +TID: 31 Cylinder: 78 Offset: 11 +Total offset: 72 Transfer times: 10 Average offset: 74. 实验指导P179-3.5 验证扫描（SCAN ）磁盘调度算法，要求在非饥饿（即《实验指导》P176-3.2 节中的数据）和饥饿（即《实验指导》P178-3.4 节中的数据）请给出在“输出”窗口中的结果，并且要求在每次输入两次“ds”命令（注意不要连续输入，要等第一次“ ds ”命令执行完，再输入第二次“ ds ”命令），分析结果为什么不同。
答：输出结果复制如下：（ 1 ）非饥饿状态，两次输入ds 指令制作软盘镜像...正在启动Virtual PC...开始调试...****** Disk schedule start working ******Start Cylinder: 10TID: 37 Cylinder: 10 Offset: 0 =TID: 40 Cylinder: 10 Offset: 0 =TID: 39 Cylinder: 12 Offset: 2 +TID: 32 Cylinder: 21 Offset: 9 +TID: 36 Cylinder: 41 Offset: 20 +TID: 38 Cylinder: 67 Offset: 26 +TID: 34 Cylinder: 78 Offset: 11 +TID: 33 Cylinder: 9 Offset: 69 -TID: 31 Cylinder: 8 Offset: 1 -TID: 35 Cylinder: 0 Offset: 8 -Total offset: 146 Transfer times: 10 Average offset: 14 ****** Disk schedule stop working ************ Disk schedule start working ******Start Cylinder: 10TID: 47 Cylinder: 10 Offset: 0 =TID: 50 Cylinder: 10 Offset: 0 =TID: 43 Cylinder: 9 Offset: 1 -TID: 41 Cylinder: 8 Offset: 1 -TID: 45 Cylinder: 0 Offset: 8 -TID: 49 Cylinder: 12 Offset: 12 +TID: 42 Cylinder: 21 Offset: 9 +TID: 46 Cylinder: 41 Offset: 20 +TID: 48 Cylinder: 67 Offset: 26 +TID: 44 Cylinder: 78 Offset: 11 +Total offset: 88 Transfer times: 10 Average offset: 8 2）饥饿状态，两次输入ds 指令制作软盘镜像...正在启动Virtual PC...开始调试...****** Disk schedule start working ******Start Cylinder: 10TID: 37 Cylinder: 10 Offset: 0 =TID: 40 Cylinder: 10 Offset: 0 =TID: 35 Cylinder: 11 Offset: 1 +TID: 39 Cylinder: 12 Offset: 1 +TID: 32 Cylinder: 21 Offset: 9 +TID: 36 Cylinder: 41 Offset: 20 +TID: 38 Cylinder: 67 Offset: 26 +TID: 31 Cylinder: 78 Offset: 11 +TID: 33 Cylinder: 9 Offset: 69 -TID: 34 Cylinder: 8 Offset: 1 -Total offset: 138 Transfer times: 10 Average offset: 13 ****** Disk schedule stop working ************ Disk schedule start working ******Start Cylinder: 10TID: 47 Cylinder: 10 Offset: 0 =TID: 50 Cylinder: 10 Offset: 0 =TID: 43 Cylinder: 9 Offset: 1 -TID: 44 Cylinder: 8 Offset: 1 -TID: 45 Cylinder: 11 Offset: 3 +TID: 49 Cylinder: 12 Offset: 1 +TID: 42 Cylinder: 21 Offset: 9 +TID: 46 Cylinder: 41 Offset: 20 +TID: 48 Cylinder: 67 Offset: 26 +TID: 41 Cylinder: 78 Offset: 11 +Total offset: 72 Transfer times: 10 Average offset: 7分析两次结果为何不同：执行完一次ds 命令后，该次搜索的指针方向被保存，但是和初始值相比，搜索的方向发生了变化。
根据SCAN 算法，按一个方向访问磁盘，一个方向访问到尽头后再换一个方向继续访问。
下次访问，按上次访问结束时的方向继续访问。
于是第二次访问的方向会与第一次不同，造成两次DS 命令输出的结果不同。
（二）实验代码及解释实验结果：制作软盘镜像...正在启动Virtual PC...开始调试...****** Disk schedule start working ******Start Cylinder: 10TID: 37 Cylinder: 11 Offset: 0 =TID: 40 Cylinder: 10 Offset: 0 =TID: 39 Cylinder: 12 Offset: 2 +TID: 32 Cylinder: 21 Offset: 9 +TID: 36 Cylinder: 41 Offset: 20 +TID: 38 Cylinder: 67 Offset: 26 +TID: 34 Cylinder: 78 Offset: 11 +TID: 33 Cylinder: 9 Offset: 69 -TID: 31 Cylinder: 8 Offset: 1 -TID: 35 Cylinder: 0 Offset: 8 -Total offset: 146 Transfer times: 10 Average offset: 14 ****** Disk schedule stop working ************ Disk schedule start working ******Start Cylinder: 10TID: 47 Cylinder: 10 Offset: 0 =TID: 50 Cylinder: 10 Offset: 0 =TID: 49 Cylinder: 12 Offset: 12 +TID: 42 Cylinder: 21 Offset: 9 +TID: 43 Cylinder: 9 Offset: 1 -TID: 41 Cylinder: 8 Offset: 1 -TID: 45 Cylinder: 0 Offset: 8 -TID: 46 Cylinder: 41 Offset: 20 +TID: 48 Cylinder: 67 Offset: 26 +TID: 44 Cylinder: 78 Offset: 11 +Total offset: 88 Transfer times: 10 Average offset: 8 源代码：PREQUESTIopDiskSchedule(VOID){PLIST_ENTRY pListEntry;PREQUEST pRequest;LONG Offset;13ULONG InsideShortestDistance = 0xFFFFFFFF;ULONG OutsideShortestDistance = 0xFFFFFFFF;PREQUEST pNextRequest0NULL,pNextRequest1=NULL,pNextRequest2=NULL;//// 需要遍历请求队列一次或两次//for (pListEntry = RequestListHead.Next; // 请求队列中的第一个请求是链表头指向的下一个请求。