操作系统实验 磁盘调度算法
磁盘调度操作系统实验报告
磁盘调度操作系统实验报告一、实验目的：本次实验主要目的是通过模拟实现磁盘调度算法，加深对操作系统磁盘调度原理的理解，并学会使用操作系统磁盘调度算法解决实际问题。
二、实验内容：1.磁盘调度算法原理分析：磁盘调度算法是操作系统中的重要组成部分，它的任务是合理安排磁盘上数据的存取顺序，以提高磁盘的效率。
常见的磁盘调度算法有先来先服务（FCFS）、最短寻道时间优先（SSTF）、电梯算法（SCAN）等。
2.模拟实现磁盘调度算法：本实验选择最短寻道时间优先算法（SSTF）作为示例进行模拟实现。
SSTF算法的原理是优先选择离当前磁头位置最近的磁道进行访问，以减少磁头移动时间。
实验步骤：1.根据实际情况，创建一个磁道队列，记录需要访问的磁道序号。
2.初始化磁盘的起始位置和访问队列。
3.对访问队列进行排序，按照磁头当前位置到磁道的距离从小到大排列。
4.根据排序后的队列顺序，依次访问磁道，并记录磁头移动的距离。
5.计算平均寻道长度。
三、实验结果分析：通过模拟实现SSTF磁盘调度算法，我们获得了磁头对每个磁道的访问顺序和总共的磁头移动距离。
根据实验结果，我们可以发现SSTF算法相对于其他算法具有一定的优势。
在实际应用中，根据不同的实际情况，可以选择合适的磁盘调度算法以优化磁盘的访问效率。
四、实验总结：通过本次实验，我们对磁盘调度算法的原理和实现有了更深入的了解。
磁盘调度算法作为操作系统中一个重要的模块，对提高磁盘的读写效率起着重要的作用。
在实际应用中，我们需要根据具体问题选择合适的磁盘调度算法，以达到最优的访问效果。
操作系统磁盘调度算法实验报告及代码
操作系统磁盘调度算法实验报告及代码一、实验目的通过实验掌握磁盘调度算法的实现过程，了解各种不同磁盘调度算法的特点和优缺点，并比较它们的性能差异。
二、实验原理磁盘调度是操作系统中的重要内容，其主要目的是提高磁盘的利用率和系统的响应速度。
常见的磁盘调度算法有：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算法通过选择离当前磁道最近的请求进行处理，能够减少平均寻道时间，提高磁盘性能。
五、实验总结通过本次实验，我们学习了操作系统中磁盘调度算法的原理和实现过程。
不同的磁盘调度算法具有不同的优缺点，我们需要根据实际情况选择合适的算法。
操作系统实验报告—磁盘调度算法
操作系统实验报告—磁盘调度算法操作系统实验报告实验3磁盘调度算法报告日期：20XX-6-17姓名：学号：班级：任课教师：实验3磁盘调度算法一、实验内容模拟电梯调度算法，实现对磁盘的驱动调度。
二、实验目的磁盘是一种高速、大量旋转型、可直接存取的存储设备。
它作为计算机系统的辅助存储器，负担着繁重的输入输出任务，在多道程序设计系统中，往往同时会有若干个要求访问磁盘的输入输出请示等待处理。
系统可采用一种策略，尽可能按最佳次序执行要求访问磁盘的诸输入输出请求，这就叫驱动调度，使用的算法称驱动调度算法。
驱动调度能降低为若干个输入输出请求服务所须的总时间，从而提高系统效率。
本实验要求学生模拟设计一个驱动调度程序，观察驱动调度程序的动态运行过程。
三、实验原理模拟电梯调度算法，对磁盘调度。
磁盘是要供多个进程共享的存储设备，但一个磁盘每个时刻只能为一个进程服务。
当有进程在访问某个磁盘时，其他想访问该磁盘的进程必须等待，直到磁盘一次工作结束。
当有多个进程提出输入输出请求处于等待状态，可用电梯调度算法从若干个等待访问者中选择一个进程，让它访问磁盘。
当存取臂仅需移到一个方向最远的所请求的柱面后,如果没有访问请求了,存取臂就改变方向。
假设磁盘有200个磁道，用C语言随机函数随机生成一个磁道请求序列放入模拟的磁盘请求队列中，假定当前磁头在100号磁道上，并向磁道号增加的方向上移动。
请给出按电梯调度算法进行磁盘调度时满足请求的次序,并计算出它们的平均寻道长度。
四、实验过程1.画出算法流程图。
2．源代码#include #include #include int *Init(intarr) {int i = 0;srand((unsignedint)time(0)); for (i = 0; i = num) {a[j+1] = arr[i]; j++; } else {b[k+1] = arr[i]; k++; } }printf(\访问序列：\\n\); for (i = 1; i 0; i--) { printf(\, b[i]); }sum = ((a[j]-100)*2+(100- b[1]))/15;printf(\平均寻道长度：%d\, sum); }int main {int arr[15] = { 0 }; int *ret=Init(arr); two_part(ret); getchar ; return 0;}4运行结果：五、实验小结通过本次实验，我对scan算法更加深入理解，用C语言模拟电梯调度算法，实现对磁盘的驱动调度，这个相比前两个实验实现起来相对简单，理解了算法实现起来尤为简单，程序敲出来之后没有错误，可直接运行，结果验证也无误。
磁盘调度实验报告实验总结
磁盘调度实验报告实验总结磁盘调度是操作系统中的一个重要概念，它是指操作系统通过合理的算法和策略来管理和调度磁盘上的数据访问请求。
磁盘调度的目的是提高磁盘的读写效率，减少磁盘访问的时间开销，从而提高系统的整体性能。
本次实验主要对比了三种常见的磁盘调度算法：先来先服务（FCFS）、最短寻道时间优先（SSTF）和电梯算法（SCAN）。
通过对比实验结果分析各种算法的性能表现和特点，并给出相应的实验总结。
实验总结如下：一、先来先服务（FCFS）算法FCFS算法是一种简单直接的磁盘调度算法，它按照请求的顺序依次进行访问。
实验结果表明，FCFS算法的平均寻道时间较高，且易产生长期等待现象。
这是因为FCFS算法无法优化磁头的移动顺序，只能按照请求的先后顺序安排磁道的访问，从而导致了较差的性能表现。
二、最短寻道时间优先（SSTF）算法SSTF算法根据当前磁头位置选择距离最近的请求进行服务。
实验结果表明，SSTF算法的平均寻道时间明显优于FCFS算法，且缓解了长期等待现象。
这是因为SSTF算法可以选择离当前磁头位置最近的请求，从而减少了寻道时间，提高了磁道的访问效率。
三、电梯算法（SCAN）算法SCAN算法也称为电梯算法，它模拟了电梯运行的原理。
SCAN算法先将磁头移动到一个极限位置，然后沿着一个方向依次访问请求，直到到达另一个极限位置，再改变方向重复上述过程。
实验结果表明，SCAN算法的平均寻道时间与SSTF 算法相当，且具有较好的均衡性。
这是因为SCAN算法可以使得磁头在磁盘上的行进路线保持平衡，避免了过多的磁道之间的跳跃，从而提高了磁道的访问效率。
综上所述，不同的磁盘调度算法具有不同的性能表现和特点。
在实际应用中，需要根据具体的场景和需求选择合适的磁盘调度算法。
一般而言，SSTF算法和SCAN算法在性能上表现较好，可以提高磁盘的读写效率，减少寻道时间开销。
而FCFS算法在实际应用中较为有限，对于长期等待和寻道时间要求较高的场景不太适用。
磁盘调度的实验报告(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算法在请求序列较长时性能更稳定，且磁头移动次数更少。
磁盘调度算法实验小结
磁盘调度算法实验小结1. 实验目的本次实验旨在通过模拟磁盘调度算法，深入理解不同调度算法的性能差异，并比较其优劣。
通过实验，我们期望能够掌握磁盘调度算法的基本原理，理解其在实际应用中的适用场景。
2. 算法原理在磁盘调度算法中，我们主要讨论了FCFS（先进先出）、SSTF（最短寻道时间优先）、SCAN（扫描）、C-SCAN（循环扫描）和LOOK（LOOK扫描）等算法。
这些算法的主要思想是通过不同的方式优化磁盘读/写请求的寻道时间，从而提高磁盘的I/O性能。
3. 实验环境实验环境包括一台服务器和一块磁盘。
服务器上安装了Linux操作系统，并使用C语言编写了磁盘调度算法的模拟程序。
磁盘具有多个柱面，每个柱面包含多个块。
4. 实验过程在实验过程中，我们首先对FCFS、SSTF、SCAN、C-SCAN和LOOK等算法进行了模拟。
然后，我们根据不同的磁盘读写请求，使用不同的算法进行寻道时间模拟。
最后，我们对模拟结果进行了分析和比较。
5. 实验结果通过模拟实验，我们得到了不同算法在不同磁盘读写请求下的寻道时间。
实验结果表明，SCAN和C-SCAN算法在平均寻道时间上表现较好，而SSTF算法在局部请求密集的情况下表现较好。
同时，我们发现FCFS算法的性能最差。
6. 性能比较通过对不同算法的寻道时间进行比较，我们发现SCAN 和C-SCAN算法在平均寻道时间上表现较好。
这是因为它们能够根据磁盘头部的移动方向来优化寻道时间。
而SSTF算法在局部请求密集的情况下表现较好，因为它的策略是优先寻找最近未被访问的柱面，这可以减少磁盘头部的移动距离。
然而，FCFS算法的性能最差，因为它总是按照请求的顺序进行寻道，没有考虑到磁盘头部的移动方向和局部请求的密集程度。
7. 结论通过本次实验，我们深入了解了不同磁盘调度算法的性能差异。
SCAN和C-SCAN算法在平均寻道时间上表现较好，适用于需要平衡寻道时间和I/O性能的情况；而SSTF算法在局部请求密集的情况下表现较好，适用于需要快速响应局部请求的情况。
操作系统实验 第五讲 磁盘调度算法讲课讲稿
操作系统实验第五讲磁盘调度算法操作系统实验报告哈尔滨工程大学计算机科学与技术学院第六讲磁盘调度算法一、实验概述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. 实验名称磁盘调度算法2. 实验目的通过学习EOS实现磁盘调度算法的机制，掌握磁盘调度算法执行的条件和时机；观察EOS实现的FCFS、SSTF和SCAN磁盘调度算法，了解常用的磁盘调度算法；编写CSCAN和N-Step-SCAN磁盘调度算法，加深对各种扫描算法的理解。
3. 实验类型验证＋设计4. 实验内容理解EOS是如何实现磁盘调度算法的；学习EOS是如何测试磁盘调度算法的，并体会这种测试方法的优缺点。
二、实验环境操作系统：Windows XP 操作系统集成实验环境软件：Tevation OS Lab编译语言：C 参考书：EOS操作系统实验教程三、实验过程1.实验指导P176-3.2验证先来先服务（FCFS）磁盘调度算法，要求请给出在“输出”窗口中的结果。
****** 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.实验指导P177-3.3验证验证最短寻道时间优先（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个磁道。
操作系统课程设计报告磁盘调度算法
课程设计课程设计名称：操作系统应用课程设计专业班级：学生姓名：xxxxx学号：指导教师：课程设计时间： 2010.12.20-2010.12.26计算机科学专业课程设计任务书说明：本表由指导教师填写，由教研室主任审核后下达给选题学生，装订在设计（论文）首页一 .课程设计需求分析操作系统是计算机系统的一个重要系统软件。
我们在本课程的实验过程中，了解实际操作系统的工作过程，在实践中加深对操作系统原理的理解。
磁盘存储器不仅容量大，存取速度快，而且可以实现随机存取，是当前存放大量程序和数据的理想设备，故在现代计算机系统中，都配置了磁盘存储器，并以它为主来存放文件。
这样，对文件的操作，都将涉及到对磁盘的访问。
磁盘I/O速度的高低和磁盘系统的可靠性都将直接影响到系统性能。
因此，设法改善磁盘系统的性能，已成为现代操作系统的重要任务之一。
磁盘性能有数据的组织、磁盘的类型和访问时间等。
磁盘调度的目标是使磁盘的平均寻道时间最少。
也正因为这样，我们有必要对各算法进行模拟，进而比较、分析、了解。
本实验设计的目的是通过设计一个磁盘调度模拟系统，以加深对最短寻道时间优先（SSTF）、N步扫描算法（NStepSCAN）等磁盘调度算法的理解。
让我们更好地掌握操作系统的原理及实现方法,加深对操作系统基础理论和重要算法的理解，加强动手能力。
二.课程设计原理设备的动态分配算法与进程调度相似，也是基于一定的分配策略的。
常用的分配策略有先请求先分配、优先级高者先分配等策略。
在多道程序系统中，低效率通常是由于磁盘类旋转设备使用不当造成的。
操作系统中，对磁盘的访问要求来自多方面，常常需要排队。
这时，对众多的访问要求按一定的次序响应，会直接影响磁盘的工作效率，进而影响系统的性能。
访问磁盘的时间因子由3部分构成，它们是查找（查找磁道）时间、等待（旋转等待扇区）时间和数据传输时间，其中查找时间是决定因素。
因此，磁盘调度算法先考虑优化查找策略，需要时再优化旋转等待策略。
磁盘调度算法的设计实验报告
磁盘调度算法的设计实验报告一、实验背景磁盘调度算法是操作系统中的重要内容之一，它的主要作用是优化磁盘的读写效率，提高系统的性能。
本次实验旨在通过设计不同的磁盘调度算法，比较它们在不同情况下的性能表现。
二、实验环境本次实验使用了Linux操作系统和C语言编程语言。
硬件环境为Intel Core i5处理器、4GB内存和500GB硬盘。
三、实验过程1. 先来看看什么是磁盘调度算法。
磁盘调度算法是指操作系统中用于管理磁盘I/O请求队列的算法。
常见的磁盘调度算法有FCFS(先来先服务)、SSTF(最短寻道时间优先)、SCAN(扫描)、LOOK(往返扫描)等。
2. 接下来我们分别对这些算法进行设计和实现，并进行性能测试。
3. 首先是FCFS算法。
FCFS算法就是按照请求到达时间的顺序进行服务，即先来先服务。
我们通过模拟生成一组随机数作为请求队列，然后计算出每个请求需要移动的距离，并计算出平均寻道长度。
4. 然后是SSTF算法。
SSTF算法是指选择距离当前磁头位置最近的请求进行服务。
我们同样使用模拟生成一组随机数作为请求队列，然后计算出每个请求与当前磁头位置的距离，并按照距离从小到大进行排序，然后依次服务每个请求，并计算出平均寻道长度。
5. 接下来是SCAN算法。
SCAN算法是指磁头从一端开始移动，直到到达另一端，然后返回原点继续移动。
我们同样使用模拟生成一组随机数作为请求队列，并将其按照磁头当前位置的左右分成两部分，分别从左往右和从右往左进行服务，并计算出平均寻道长度。
6. 最后是LOOK算法。
LOOK算法和SCAN类似，不同之处在于当服务完最远的请求时不会返回原点，而是直接返回最近的请求。
我们同样使用模拟生成一组随机数作为请求队列，并将其按照磁头当前位置的左右分成两部分，分别从左往右和从右往左进行服务，并计算出平均寻道长度。
四、实验结果通过对以上四种磁盘调度算法进行测试，得到以下结果：1. FCFS平均寻道长度：1622. SSTF平均寻道长度：783. SCAN平均寻道长度：984. LOOK平均寻道长度：87五、实验结论从实验结果可以看出，SSTF算法的性能最优，平均寻道长度最短。
磁盘调度操作系统实验报告
实验一磁盘调度算法实现一、实验目的本课程设计的目的是通过磁盘调度算法设计一个磁盘调度模拟系统,从而使磁盘调度算法更加形象化,容易使人理解,使磁盘调度的特点更简单明了,能使使用者加深对先来先服务算法、最短寻道时间优先算法、扫描算法以及循环扫描算法等磁盘调度算法的理解;二、实验内容系统主界面可以灵活选择某种算法,算法包括：先来先服务算法FCFS、最短寻道时间优先算法SSTF、扫描算法SCAN、循环扫描算法CSCAN;先来先服务算法 FCFS这是一种比较简单的磁盘调度算法;它根据进程请求访问磁盘的先后次序进行调度;此算法的优点是公平、简单,且每个进程的请求都能依次得到处理,不会出现某一进程的请求长期得不到满足的情况;此算法由于未对寻道进行优化,在对磁盘的访问请求比较多的情况下,此算法将降低设备服务的吞吐量,致使平均寻道时间可能较长,但各进程得到服务的响应时间的变化幅度较小;最短寻道时间优先算法 SSTF该算法选择这样的进程,其要求访问的磁道与当前磁头所在的磁道距离最近,以使每次的寻道时间最短,该算法可以得到比较好的吞吐量,但却不能保证平均寻道时间最短;其缺点是对用户的服务请求的响应机会不是均等的,因而导致响应时间的变化幅度很大;在服务请求很多的情况下,对内外边缘磁道的请求将会无限期的被延迟,有些请求的响应时间将不可预期;扫描算法 SCAN扫描算法不仅考虑到欲访问的磁道与当前磁道的距离,更优先考虑的是磁头的当前移动方向;例如,当磁头正在自里向外移动时,扫描算法所选择的下一个访问对象应是其欲访问的磁道既在当前磁道之外,又是距离最近的;这样自里向外地访问,直到再无更外的磁道需要访问才将磁臂换向,自外向里移动;这时,同样也是每次选择这样的进程来调度,即其要访问的磁道,在当前磁道之内,从而避免了饥饿现象的出现;由于这种算法中磁头移动的规律颇似电梯的运行,故又称为电梯调度算法;此算法基本上克服了最短寻道时间优先算法的服务集中于中间磁道和响应时间变化比较大的缺点,而具有最短寻道时间优先算法的优点即吞吐量较大,平均响应时间较小,但由于是摆动式的扫描方法,两侧磁道被访问的频率仍低于中间磁道;循环扫描算法 CSCAN循环扫描算法是对扫描算法的改进;如果对磁道的访问请求是均匀分布的,当磁头到达磁盘的一端,并反向运动时落在磁头之后的访问请求相对较少;这是由于这些磁道刚被处理,而磁盘另一端的请求密度相当高,且这些访问请求等待的时间较长,为了解决这种情况,循环扫描算法规定磁头单向移动;例如,只自里向外移动,当磁头移到最外的被访问磁道时,磁头立即返回到最里的欲访磁道,即将最小磁道号紧接着最大磁道号构成循环,进行扫描;三、实验流程系统功能图图3-1 系统功能图算法流程图本次实验为实现磁盘调度算法,分别实现四个算法并调试;四个算法算法包括：先来先服务算法FCFS、最短寻道时间优先算法SSTF、扫描算法SCAN、循环扫描算法CSCAN;四个算法的流程图分析如下;1）先来先服务算法FCFS的流程图图3-2 先来先服务算法的流程图2）最短寻道时间优先算法SSTF的流程图图3-3 最短寻道时间优先算法的流程图3）扫描算法SCAN的流程图图3-4扫描算法的流程图4）循环扫描算法CSCAN的流程图图3-5 循环扫描算法的流程图四、源程序include<>include<>include<>include<>define maxsize 1000/判断输入数据是否有效/int decidechar str 来先服务 2.最短寻道时间优先 3.扫描调度 4.循环扫描 5.退出\n"<<endl;cout<<" -------------------------------------------------------------------------"<<endl;G:cout<<" 请选择算法: ";F:cin>>str; //对输入数据进行有效性判断a=decidestr;ifa==0{cout<<" 输入数据的类型错误,请重新输入"<<endl;goto F;//输入错误,跳转到F,重新输入}else c=transstr,a;ifc==5 break;ifc>5{cout<<" 输入的数据错误请重新输入"<<endl;goto G;}switchc{case 1: //使用FCFS算法FCFScidao,count;break;case 2: //使用SSTF算法SSTFcidao,count;break;case 3: //使用SCAN算法SCANcidao,count;break;case 4: //使用CSCAN算法CSCANcidao,count;break;}}}五、实验结果程序主界面运行程序后,将会提示用户输入磁道序列,并且以0结束;当用户输入磁道序列后,系统将会重新显示用户输入的磁道序列;程序主界面运行图如图5-1所示;图5-1 程序主界面先来先服务算法FCFS运行结果选择算法1之后,进入算法1 的操作;系统会显示磁盘的请求序列;用户需要输入当前的磁道号,系统会显示出磁盘的扫描序列和平均寻道长度;由运行结果可得出,先来先服务算法的平均寻道长度为;先来先服务算法的运行图如图5-2所示;图5-2 先来先服务算法运行结果图最短寻道时间优先算法SSTF运行结果选择算法2之后,进入算法2 的操作;系统会显示磁盘的请求序列;用户需要输入当前的磁道号,系统会显示出磁盘的扫描序列和平均寻道长度;由运行结果可得出,先来先服务算法的平均寻道长度为;最短寻道时间优先算法的运行图如图5-3所示;图5-3 最短寻道时间优先算法运行结果图扫描算法SCAN运行结果选择算法3之后,进入算法3的操作;系统会显示磁盘的请求序列;用户需要输入当前的磁道号,系统会显示出磁盘的扫描序列和平均寻道长度;由运行结果可得出,先来先服务算法的平均寻道长度为11;扫描算法的运行图如图5-4所示;图5-4 扫描算法运行结果图循环扫描算法CSCAN运行结果选择算法4之后,进入算法4的操作;系统会显示磁盘的请求序列;用户需要输入当前的磁道号,系统会显示出磁盘的扫描序列和平均寻道长度;由运行结果可得出,先来先服务算法的平均寻道长度为11;扫描算法的运行图如图5-5所示;图5-5 循环扫描算法运行结果图六、总结通过本次实验,学习了解磁盘调度四种调度算法先来先服务算法；最短寻道时间优先算法；扫描算法；循环扫描算法的工作原理以及四种调度算法之间的差异和共性,并且在当中发现了自己的不足,对以前所学过的知识理解得不够深刻,掌握得不够牢固,看到了自己的实践经验还是比较缺乏,实践能力还需要提高;。
操作系统实验第五讲磁盘调度算法
操作系统实验报告哈尔滨工程大学计算机科学与技术学院第六讲磁盘调度算法一、实验概述1. 实验名称磁盘调度算法2. 实验目的（1）通过学习EOS 实现磁盘调度算法的机制，掌握磁盘调度算法执行的条件和时机；（2）观察EOS 实现的FCFS、SSTF和SCAN磁盘调度算法，了解常用的磁盘调度算法；（3）编写CSCAN和N-Step-SCAN磁盘调度算法，加深对各种扫描算法的理解。
3. 实验类型验证性+设计性实验4. 实验内容（1）验证先来先服务（FCFS）磁盘调度算法；（2）验证最短寻道时间优先（SSTF）磁盘调度算法；（3）验证SSTF算法造成的线程“饥饿”现象；（4）验证扫描（SCAN）磁盘调度算法；（5）改写SCAN算法。
二、实验环境在OS Lab实验环境的基础上，利用EOS操作系统，由汇编语言及C语言编写代码，对需要的项目进行生成、调试、查看和修改，并通过EOS应用程序使内核从源代码变为可以在虚拟机上使用。
三、实验过程1. 设计思路和流程图（1）改写SCAN算法在已有SCAN 算法源代码的基础上进行改写，要求不再使用双重循环，而是只遍历一次请求队列中的请求，就可以选中下一个要处理的请求。
算法流程图如下图所示。
图SCAN算法IopDiskSchedule函数流程图（2）编写循环扫描（CSCAN）磁盘调度算法在已经完成的SCAN算法源代码的基础上进行改写，不再使用全局变量ScanInside确定磁头移动的方向，而是规定磁头只能从外向内移动。
当磁头移动到最内的被访问磁道时，磁头立即移动到最外的被访问磁道，即将最大磁道号紧接着最小磁道号构成循环，进行扫描。
算法流程图如下图所示。
图CSCAN算法IopDiskSchedule函数流程图（3）编写N-Step-SCAN磁盘调度算法在已经完成的SCAN 算法源代码的基础上进行改写，将请求队列分成若干个长度为N 的子队列，调度程序按照FCFS原则依次处理这些子队列，而每处理一个子队列时，又是按照SCAN算法。
磁盘调度实验报告
磁盘调度实验报告一、实验目的1.掌握磁盘调度算法的基本原理和思想；2.理解磁盘调度算法的性能指标及其关系；3.利用实验验证各种磁盘调度算法的性能差异。
二、实验原理磁盘调度算法是操作系统中用来调度磁盘的读写操作的一种方法。
磁盘访问的时间主要包括寻道时间、旋转延迟和数据传输时间。
磁盘调度算法的目标是尽可能减少磁头的移动和等待时间，提高磁盘的访问效率。
常用的磁盘调度算法有先来先服务（FCFS）、最短寻找时间优先（SSTF）、电梯扫描（SCAN）和循环扫描（CSCAN）等。
FCFS算法就是按照请求的先后顺序进行访问，即先来的请求先执行。
SSTF算法每次选择最短寻找时间的磁道进行访问，减少了寻道时间。
SCAN算法则是磁头按照一个方向进行扫描，直到扫描到磁盘的一侧，然后改变方向继续扫描。
CSCAN算法是类似于SCAN算法，只是当扫描到磁盘的一侧时，直接跳到另一侧进行扫描。
这些算法各有优缺点，适用于不同的场景和需求。
三、实验过程1.实验环境搭建：选择一台计算机作为实验机器，安装操作系统和相应的磁盘调度算法软件；2.实验数据准备：生成一组磁道访问的请求序列，包括请求的磁道号和读写操作；3.实验数据输入：将生成的请求序列输入到磁盘调度软件中，选择不同的调度算法进行模拟；4.实验结果记录：记录各种调度算法的磁头移动次数和平均访问时间；5.实验数据分析：根据实验结果进行数据分析，比较各种算法的性能差异。
四、实验结果分析根据实验数据进行结果分析，比较不同调度算法的性能差异。
以磁头移动次数和平均访问时间为评价指标，可以看出不同算法对磁盘访问的影响。
在一些情况下，可能一些算法的磁头移动次数更少，但平均访问时间可能并不是最低的，需要综合考虑多个因素。
根据实验结果可以发现，FCFS算法的磁头移动次数和平均访问时间相对较高，因为它只按照请求的先后顺序进行访问，没有考虑磁道之间的距离。
SSTF算法在减少磁头移动次数和平均访问时间方面有一定的优势，因为它每次选择最短寻找时间的磁道进行访问。
操作系统磁盘调度算法实验报告
目录1．课程设计目的1.1编写目的本课程设计的目的是通过磁盘调度算法设计一个磁盘调度模拟系统，从而使磁盘调度算法更加形象化，容易使人理解，使磁盘调度的特点更简单明了，能使使用者加深对先来先服务算法、最短寻道时间优先算法、扫描算法以及循环扫描算法等磁盘调度算法的理解。
2．课程设计内容2.1设计内容系统主界面可以灵活选择某种算法，算法包括：先来先服务算法（FCFS）、最短寻道时间优先算法（SSTF）、扫描算法（SCAN）、循环扫描算法（CSCAN）。
1、先来先服务算法（FCFS）这是一种比较简单的磁盘调度算法。
它根据进程请求访问磁盘的先后次序进行调度。
此算法的优点是公平、简单，且每个进程的请求都能依次得到处理，不会出现某一进程的请求长期得不到满足的情况。
此算法由于未对寻道进行优化，在对磁盘的访问请求比较多的情况下，此算法将降低设备服务的吞吐量，致使平均寻道时间可能较长，但各进程得到服务的响应时间的变化幅度较小。
2、最短寻道时间优先算法（SSTF）该算法选择这样的进程，其要求访问的磁道与当前磁头所在的磁道距离最近，以使每次的寻道时间最短，该算法可以得到比较好的吞吐量，但却不能保证平均寻道时间最短。
其缺点是对用户的服务请求的响应机会不是均等的，因而导致响应时间的变化幅度很大。
在服务请求很多的情况下，对内外边缘磁道的请求将会无限期的被延迟，有些请求的响应时间将不可预期。
3、扫描算法（SCAN）扫描算法不仅考虑到欲访问的磁道与当前磁道的距离，更优先考虑的是磁头的当前移动方向。
例如，当磁头正在自里向外移动时，扫描算法所选择的下一个访问对象应是其欲访问的磁道既在当前磁道之外，又是距离最近的。
这样自里向外地访问，直到再无更外的磁道需要访问才将磁臂换向，自外向里移动。
这时，同样也是每次选择这样的进程来调度，即其要访问的磁道，在当前磁道之内，从而避免了饥饿现象的出现。
由于这种算法中磁头移动的规律颇似电梯的运行，故又称为电梯调度算法。
操作系统实验磁盘调度算法实验报告
操作系统实验磁盘调度算法实验报告一.实验目的本实验旨在通过磁盘调度算法的模拟，探究不同调度算法对磁盘访问性能的影响，了解各种算法的特点和适用场景。
二.实验方法本实验通过编写磁盘调度模拟程序，实现了三种常见的磁盘调度算法：FCFS（先来先服务）、SSTF（最短寻找时间优先）和SCAN（扫描算法）。
实验中使用C语言编程语言，并通过随机生成的队列模拟磁盘访问请求序列。
三.实验过程1.FCFS（先来先服务）算法FCFS算法是一种非常简单的调度算法，它按照请求到达的顺序进行调度。
在实验中，我们按照生成的请求队列顺序进行磁盘调度，记录每次磁头移动的距离。
2.SSTF（最短寻找时间优先）算法SSTF算法是一种动态选择离当前磁头位置最近的磁道进行调度的算法。
在实验中，我们根据当前磁头位置和请求队列中的磁道位置，选择距离最近的磁道进行调度。
然后将该磁道从请求队列中移除，并记录磁头移动的距离。
3.SCAN（扫描算法）算法SCAN算法是一种按照一个方向进行扫描的算法，它在每个方向上按照磁道号的顺序进行调度，直到扫描到最边缘磁道再折返。
在实验中，我们模拟磁头从一个端点开始，按照磁道号从小到大的顺序进行调度，然后再折返。
记录磁头移动的距离。
四.实验结果与分析我们通过生成不同数量的请求队列进行实验，记录每种算法的磁头移动距离，并进行比较。
实验结果显示，当请求队列长度较小时，FCFS算法的磁头移动距离较短，因为它按照请求到达的顺序进行调度，无需寻找最短的磁道。
然而，当请求队列长度较大时，FCFS算法的磁头移动距离会显著增加，因为它不能根据距离进行调度。
SSTF算法相对于FCFS算法在磁头移动距离上有了明显改进。
SSTF算法通过选择最短的寻找时间来决定下一个访问的磁道，因此可以减少磁头的移动距离。
然而，在请求队列中存在少量分散的请求时，SSTF算法可能会产生扇区的服务死锁现象，导致一些磁道无法及时访问。
SCAN算法通过扫描整个磁盘来进行调度，有效解决了FCFS算法有可能导致的服务死锁问题。
操作系统实验三 磁盘调度算法的实现
天津理工大学计算机与通信工程学院实验报告2013 至2014 学年第一学期课程名称操作系统学号学生姓名年级专业教学班号实验地点实验时间2013年月日第节至月日第节主讲教师辅导教师实验（三）实验名称磁盘调度算法的实现软件环境VC++6.0硬件环境PC机实验目的《操作系统》是计算机科学与技术专业和信息与计算科学专业本科教学计划中的一门重要的专业基础课程，是对计算机系统硬﹑软件资源进行管理的系统软件，是计算机系统的管理和指挥中心。
通过本课程实验，使学生综合运用程序设计基础与语言、数据结构、计算机原理与接口等先行课程的知识以及操作系统课程的知识在各种资源管理调度策略下，设计操作系统资源管理的模拟程序，使学生加深了解操作系统的工作机理，对操作系统的功能及结构设计有更加深入的实践，为开发系统软件和应用软件打下基础。
实验内容（应包括实验题目、实验要求、实验任务等）实验内容：1、本实验是模拟操作系统的磁盘寻道方式，运用磁盘访问顺序的不同来设计磁盘的调度算法。
2、实现的磁盘调度算法有FCFS，SSTF，SCAN，CSCAN和NStepSCAN算法。
3、设定开始磁道号寻道范围，依据起始扫描磁道号和最大磁道号数，随机产生要进行寻道的磁道号序列。
4、选择磁盘调度算法，显示该算法的磁道访问顺序，计算出移动的磁道总数和平均寻道总数。
5、按算法的寻道效率进行排序，并对各算法的性能进行分析比较。
实验要求：学生应正确地设计有关的数据结构与各个功能模块，画出程序的流程图，编写程序，程序执行结果应正确实验过程与实验结果（可包括实验实施的步骤、算法描述、流程、结论等）在VC++6.0编写如下代码#include<iostream>#include<ctime>using namespace std;void FCFS(int a[],int n);void SSTF(int a[],int n);void SCAN(int a[],int n);void CSCAN(int a[],int n);int main(){int n;//磁道的个数int s;//功能号cout<<"请输入磁道的个数："<<endl;cin>>n;int *a=new int[n];cout<<"生成随机磁道号..."<<endl;srand((unsigned)time(NULL));for(int i=0;i<n;i++){a[i]=(rand()%100)+1;cout<<a[i]<<" "; }cout<<endl;while(1) {cout<<endl;cout<<"1、先来先服务算法（FCFS）"<<endl;cout<<"2、最短寻道时间算法（SSTF）"<<endl; cout<<"3、扫描算法（SCAN）"<<endl;cout<<"4、循环扫描算法（CSCAN）"<<endl;cout<<"0、退出"<<endl;cout<<endl;cout<<"请选择功能号:";cin>>s;if(s>4){cout<<"输入有误！"<<endl;}else{switch(s){ case 0: exit(0);break ; case 1:FCFS(a,n); break;case 2:SSTF(a, n);break;case 3:SCAN(a, n);break;case 4:CSCAN(a,n);break; } }} return 0; }//先来先服务调度算法（FCFS）void FCFS(int a[],int n){int sum=0,j,i,first=0,now;cout<<"请输入当前磁道号：";cin>>now;//确定当前磁头所在位置cout<<"磁盘调度顺序为："<<endl;for( i=0;i<n;i++)//按访问顺序输出磁道号{cout<<a[i]<<" ";}//计算sumfor(i=0,j=1;j<n;i++,j++){first+=abs(a[j]-a[i]);//外围磁道与最里面磁道的距离}sum+=first+abs(now-a[0]);cout<<endl;cout<<"移动的总磁道数： "<<sum<<endl;}//最短寻道时间算法（SSTF）void SSTF(int a[],int n){int temp;int k=1;int now,l,r;int i,j,sum=0;//将磁道号按递增排序for(i=0;i<n;i++)for(j=i+1;j<n;j++){if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp; }}cout<<"按递增顺序排好的磁道："<<endl;for( i=0;i<n;i++){cout<<a[i]<<" ";//输出排好的磁道顺序}cout<<endl;cout<<"请输入当前的磁道号：";cin>>now;//确定当前磁头所在位置cout<<"磁盘调度顺序为："<<endl;if(a[n-1]<=now)//当前磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--)cout<<a[i]<<" ";sum=now-a[0];}elseif(a[0]>=now)//当前磁头位置小于最里欲访问磁道{for(i=0;i<n;i++)cout<<a[i]<<" ";sum=a[n-1]-now;}else{while(a[k]<now)//确定当前磁道在已排的序列中的位置{k++;}l=k-1;//在磁头位置的前一个欲访问磁道r=k;//磁头欲访问磁道while((l>=0)&&(r<n)){if((now-a[l])<=(a[r]-now))//选择离磁头近的磁道 {cout<<a[l]<<" ";sum+=now-a[l];now=a[l];l=l-1; }else{cout<<a[r]<<" ";sum+=a[r]-now;now=a[r];r=r+1;} }if(l=-1)//磁头位置里侧的磁道已访问完{for(j=r;j<n;j++)//访问磁头位置外侧的磁道{cout<<a[j]<<" ";}sum+=a[n-1]-a[0];}if(r==n)//磁头位置外侧的磁道已访问完{for(j=k-1;j>-1;j--) //访问磁头位置里侧的磁道{cout<<a[j]<<" ";}sum+=a[n-1]-a[0];} }cout<<endl;cout<<"移动的总道数:"<<sum<<endl;}//扫描算法（SCAN）void SCAN(int a[],int n){int temp;int k=1;int now,l,r;int i,j,sum=0;for(i=0;i<n;i++)//对访问磁道按由小到大顺序排列输出for(j=i+1;j<n;j++){if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}cout<<"按递增顺序排好的磁道："<<endl;for( i=0;i<n;i++){cout<<a[i]<<" ";}cout<<endl;cout<<"请输入当前的磁道号：";cin>>now;//以下算法确定磁道访问顺序if(a[n-1]<=now) //磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--)cout<<a[i]<<" ";sum=now-a[0];}elseif(a[0]>=now) //磁头位置小于最里欲访问磁道{for(i=0;i<n;i++)cout<<a[i]<<" ";sum=a[n-1]-now;}else //磁头位置在最里侧磁道与最外侧磁道之间{ int d;while(a[k]<now){ //确定当前磁道在已排的序列中的位置k++;}l=k-1;//在磁头位置的前一个欲访问磁道r=k; //磁头欲访问磁道cout<<"请输入当前磁头移动的方向 (0 表示向内，1表示向外) : "; cin>>d; //确定磁头访问的方向cout<<"磁盘调度顺序为：";if(d==0||d==1){if(d==0) //磁头向内{for(j=l;j>=0;j--){cout<<a[j]<<" ";}for(j=r;j<n;j++){cout<<a[j]<<" ";}sum=now-2*a[0]+a[n-1];}if(d==1) //磁头向外{for(j=r;j<n;j++){cout<<a[j]<<" ";}for(j=l;j>=0;j--){cout<<a[j]<<" ";}sum=2*a[n-1]-now-a[0];}}elsecout<<"请输入0或1！"<<endl;}cout<<endl;cout<<"移动的总道数： "<<sum<<endl;}//循环扫描算法（CSCAN）void CSCAN(int a[],int n){int temp;int now,l,r;int i,j,sum=0;int k=1;for(i=0;i<n;i++)//对访问磁道按由小到大顺序排列输出for(j=i+1;j<n;j++){if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}cout<<"按递增顺序排好的磁道："<<endl;for( i=0;i<n;i++){cout<<a[i]<<" ";}cout<<endl;cout<<"请输入当前的磁道号：";cin>>now;//确定当前磁道号if(a[n-1]<=now)//磁头位置大于最外围欲访问磁道{for(i=0;i<n;i++)cout<<a[i]<<" ";sum=now-2*a[0]+a[n-1];}elseif(a[0]>=now)//磁头位置小于最里欲访问磁道{for(i=0;i<n;i++)cout<<a[i]<<" ";sum=a[n-1]-now;}else //磁头位置在最里侧磁道与最外侧磁道之间{ int d;while(a[k]<now){k++;}l=k-1;//在磁头位置的前一个欲访问磁道r=k; //磁头欲访问磁道cout<<"请输入当前磁头移动的方向 (0 表示向内，1表示向外) : "; cin>>d; //确定磁头访问的方向cout<<"磁盘调度顺序为：";if(d==0||d==1){if(d==1) //磁头向外侧访问{for(j=r;j<n;j++)//先访问外侧磁道再转向最里欲访问磁道{cout<<a[j]<<" ";}for(j=0;j<r;j++){cout<<a[j]<<" ";}sum=2*a[n-1]-now-2*a[0]+a[l];}if(d==0) //磁头向内侧访问 {for(j=r-1;j>=0;j--){cout<<a[j]<<" ";}for(j=n-1;j>=r;j--)//{cout<<a[j]<<" ";}sum=2*a[n-1]-2*a[0]+now-a[r];}}elsecout<<"请输入0或1！";}cout<<endl;cout<<"移动的总道数： "<<sum<<endl;}实验结果：1.先来先服务算法（FCFS）测试结果2.最短寻道时间算法（SSTF）测试结果3.循环扫描算法（SCAN）测试结果4.循环扫描算法（CSCAN）测试结果由以上测试结果可知，在相同的实验前提下，SSTF移动的总道数最少，性能最优。
操作系统实验四 磁盘调度算法
实验四磁盘调度一、实验目的：本实验要求学生模拟设计一个磁盘调度程序，观察调度程序的动态运行过程。
通过实验让学生理解和掌握磁盘调度的职能。
二、实验内容：对磁盘进行移臂操作，模拟磁盘调度算法并计算平均寻道时间三、实验准备：1.相关理论知识：（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、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
操作系统实验报告哈尔滨工程大学计算机科学与技术学院第六讲磁盘调度算法一、实验概述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算法。
算法流程图如下图所示。
图 3.1.3 N-Step-SCAN算法IopDiskSchedule函数流程图2.算法实现（1）改写SCAN算法在一次遍历中，不再关心当前磁头移动的方向，而是同时找到两个方向上移动距离最短的线程所对应的请求，这样就不再需要遍历两次。
在计算出线程要访问的磁道与当前磁头所在磁道的偏移后，可以将偏移分为三种类型：偏移为0，表示线程要访问的磁道与当前磁头所在磁道相同，此情况应该优先被调度，可立即返回该线程对应的请求的指针；偏移大于 0，记录向内移动距离最短的线程对应的请求；偏移小于 0，记录向外移动距离最短的线程对应的请求。
循环结束后，根据当前磁头移动的方向选择同方向移动距离最短的线程，如果在同方向上没有线程，就变换方向，选择反方向移动距离最短的线程。
（2）编写循环扫描（CSCAN）磁盘调度算法由于规定了磁头只能从外向内移动，所以在每次遍历中，总是同时找到向内移动距离最短的线程和向外移动距离最长的线程。
注意，与 SCAN 算法查找向外移动距离最短线程不同，这里查找向外移动距离最长的线程。
在开始遍历前，可以将用来记录向外移动最长距离的变量赋值为0。
在计算出线程要访问的磁道与当前磁头所在磁道的偏移后，同样可以将偏移分为三种类型：偏移为 0，表示线程要访问的磁道与当前磁头所在磁道相同，此情况应优先被调度，可立即返回该线程对应的请求的指针；偏移大于 0，记录向内移动距离最短的线程对应的请求；偏移小于 0，记录向外移动距离最长的线程对应的请求。
循环结束后，选择向内移动距离最短的线程，如果没有向内移动的线程，就选择向外移动距离最长的线程。
（3）编写N-Step-SCAN磁盘调度算法在 block.c 文件中的第360 行定义了一个宏 SUB_QUEUE_LENGTH，表示子队列的长度（即N 值）。
目前这个宏定义的值为6。
在第 367行定义了一个全局变量SubQueueRemainLength，表示第一个子队列剩余的长度，并初始化其值为SUB_QUEUE_LENGTH。
在执行 N-Step-SCAN算法时，要以第一个子队列剩余的长度做为计数器，确保只遍历第一个子队列剩余的项。
所以，结束遍历的条件就既包括第一个子队列结束，又包括整个队列结束（如果整个队列的长度小于第一个子队列剩余的长度）。
注意，不要直接使用第一个子队列剩余的长度做为计数器，可以定义一个新的局部变量来做为计数器。
按照 SCAN 算法从第一个子队列剩余的项中选择一个合适的请求。
最后，需要将第一个子队列剩余长度减少1（SubQueueRemainLength减少1），如果第一个子队列剩余长度变为 0，说明第一个子队列处理完毕，需要将子队列剩余的长度重新变为 N （SubQueueRemainLength 重新赋值为SUB_QUEUE_LENGTH），从而开始处理下一个子队列。
3.需要解决的问题及解答（1）实验指导P176-3.2验证先来先服务（FCFS）磁盘调度算法，要求请给出在“输出”窗口中的结果。
答：先来先服务（FCFS）磁盘调度算法在“输出”窗口中的结果如下图所示。
图 3.3.1（2）实验指导P177-3.3验证验证最短寻道时间优先（SSTF）磁盘调度算法，要求请给出在“输出”窗口中的结果。
答：最短寻道时间优先（SSTF）磁盘调度算法在“输出”窗口中的结果如下图所示。
图 3.3.2（3）实验指导P178-3.4验证SSTF算法造成的线程“饥饿”现象，要求请给出在“输出”窗口中的结果。
答：SSTF算法造成的线程“饥饿”现象在“输出”窗口中的结果如下图所示。
图 3.3.3（4）实验指导P179-3.5验证扫描（SCAN）磁盘调度算法，要求在非饥饿（即《实验指导》P176-3.2节中的数据）和饥饿（即《实验指导》P178-3.4节中的数据）请给出在“输出”窗口中的结果，并且要求在每次输入两次“ds”命令（注意不要连续输入，要等第一次“ds”命令执行完，再输入第二次“ds”命令），分析结果为什么不同。
答：在非饥饿情况下，“输出”窗口中的结果如下图所示。
图 3.3.4在饥饿情况下，“输出”窗口中的结果如下图所示。
图 3.3.5ScanInside是一个全局变量，当第一次执行“ds”命令时，调用IopDiskSchedule 函数，ScanInside被修改了一次，再次执行“ds”命令时，ScanInside不会被重置，因此输出的结果会不一样。
（5）在执行 SCAN、N-Step-SCAN 磁盘调度算法时，如果在EOS控制台中多次输入“ds”命令，调度的顺序会发生变化，说明造成这种现象的原因（提示：注意这两种算法使用的全局变量）。
尝试修改源代码，使这两种算法在多次执行时，都能确保调度的顺序一致（提示：可以参考io/block.c 文件中IopReceiveRequest 函数和IopProcessNextRequest 函数判断磁盘调度算法开始工作和结束工作的方法）。
答：ScanInside是一个全局变量，当第一次执行“ds”命令时，调用IopDiskSchedule 函数，ScanInside被修改了一次，再次执行“ds”命令时，ScanInside不会被重置，因此输出的结果会不一样。
只需在for循环结束后添加如下代码，就能确保调度的顺序一致。
图 3.3.6（6）尝试在 io/block.c 文件中定义一个全局的函数指针变量 DiskScheduleFunc，该函数指针初始指向实现了 FCFS 算法的 IopDiskSchedule 函数。
修改 io/block.c 文件中的 IopProcessNextRequest 函数，在该函数中不再直接调用 IopDiskSchedule 函数，而是调用函数指针 DiskScheduleFunc 指向的磁盘调度算法函数；ke/sysproc.c 文件中的 ConsoleCmdDiskSchedule 函数中也不再直接调用IopDiskSchedule函数，也要修改为调用函数指针DiskScheduleFunc指向的磁盘调度算法函数。
最后，添加一个控制台命令“sstf”，该命令使函数指针 DiskScheduleFunc 指向实现了 SSTF 算法的函数。
这样，在 EOS启动后默认会执行FCFS 算法，执行控制台命令“sstf”后，会执行SSTF 算法。
按照这种方式依次实现“fcfs”、“scan”、“cscan”和“nstepscan”命令。
说明这种在EOS运行时动态切换磁盘调度算法的好处。
答：首先在block.c 中定义一个全局的函数指针变量 DiskScheduleFunc。
图 3.3.7修改IopProcessNextRequest 函数和ConsoleCmdDiskSchedule 函数，使其不再直接调用 IopDiskSchedule 函数而是调用函数指针DiskScheduleFunc指向的磁盘调度算法函数。
图 3.3.8调用函数前先声明。
图 3.3.9添加一个控制台命令“sstf”，该命令使函数指针 DiskScheduleFunc 指向实现了SSTF 算法的函数。
验证结果如下图所示。
（7）分析已经实现的各种磁盘调度算法的优缺点，尝试实现更多其它的磁盘调度算法。
答：先来先服务算法是一种比较简单的磁盘调度算法，它根据进程请求访问磁盘的先后次序进行调度，此算法的优点是公平、简单，且每个进程的请求都能依次得到处理，不会出现某一进程的请求长期得不到满足的情况，在对磁盘的访问请求比较多的情况下，致使平均寻道时间可能较长；最短寻道时间优先算法选择这样的进程，其要求访问的磁道与当前磁头所在的磁道距离最近，以使每次的寻道时间最短，该算法可以得到比较好的吞吐量，但却不能保证平均寻道时间最短，其缺点是在服务请求很多的情况下，对内外边缘磁道的请求将会无限期的被延迟；扫描算法不仅考虑到欲访问的磁道与当前磁道的距离，更优先考虑的是磁头的当前移动方向，此算法基本上克服了最短寻道时间优先算法的服务集中于中间磁道和响应时间变化比较大的缺点，而具有最短寻道时间优先算法的优点即吞吐量较大，平均响应时间较小，但由于是摆动式的扫描方法，两侧磁道被访问的频率仍低于中间磁道；循环扫描算法是对扫描算法的改进，如果对磁道的访问请求是均匀分布的，当磁头到达磁盘的一端，并反向运动时落在磁头之后的访问请求相对较少；N-Step-SCAN算法是扫描算法和先来先服务算法的一个综合算法，将请求队列分成若干个长度为 N 的子队列，调度程序按照 FCFS原则依次处理这些子队列，而每处理一个子队列时，又是按照SCAN算法，所以它是一种性能比较平均的算法。