磁盘调度实验报告
磁盘调度算法实验报告
![磁盘调度算法实验报告](https://img.taocdn.com/s3/m/484af2fe8bd63186bcebbcce.png)
操作系统实验报告哈尔滨工程大学计算机科学与技术学院磁盘调度算法一.实验概述:1.实验名称:磁盘调度算法2.实验目的:1)通过学习EOS 实现磁盘调度算法的机制,掌握磁盘调度算法执行的条件和时机;2)观察EOS 实现的FCFS、SSTF 和SCAN 磁盘调度算法,了解常用的磁盘调度算法;3)编写CSCAN 和N-Step-SCAN 磁盘调度算法,加深对各种扫描算法的理解。
3.实验类型:验证、设计4.实验内容:1)准备实验,创建一个EOS Kernel项目;2)验证先来先服务(FCFS)磁盘调度算法;3)验证最短寻道时间优先(SSTF)磁盘调度算法;4)验证SSTF算法造成的线程“饥饿现象”;5)验证扫描(SCAN)磁盘调度算法;6)改写SCAN算法;7)编写循环扫描(CSCAN)磁盘调度算法;8)验证SSTF、SCAN及CSCAN算法中的“磁臂粘着”现象;9)编写N-Step-SCAN磁盘调度算法。
二.实验环境操作系统:windows XP编译器:Tevalaton OS Lab语言:C三.实验过程1.设计思路和流程图:SCAN算法流程图:SSTF算法的流程图:CSACN流程图:N-STEP-SCAN算法调度:Array2.实验过程:1)新建一个EOS Kernel 项目;2)在sysproc.c 文件中找到控制台命令“ds”对应的函数ConsoleCmdDiskSchedule。
“ds”命令专门用来测试磁盘调度算法。
阅读该函数中的源代码,目前该函数使磁头初始停留在磁道10,其它被阻塞的线程依次访问磁道8、21、9、78、0、41、10、67、12、10;3)打开io/block.c 文件,在第378 行找到磁盘调度算法函数IopDiskSchedule。
阅读该函数中的源代码,目前此函数实现了FCFS 磁盘调度算法,流程图如下:4)生成项目,启动调试,待EOS 启动完毕,在EOS 控制台中输入命令“ds”后按回车;在EOS 控制台中会首先显示磁头的起始位置是10 磁道,然后按照线程被阻塞的顺序依次显示线程的信息(包括线程ID 和访问的磁道号)。
磁盘调度操作系统实验报告
![磁盘调度操作系统实验报告](https://img.taocdn.com/s3/m/33a6de97370cba1aa8114431b90d6c85ed3a884b.png)
磁盘调度操作系统实验报告一、实验目的:本次实验主要目的是通过模拟实现磁盘调度算法,加深对操作系统磁盘调度原理的理解,并学会使用操作系统磁盘调度算法解决实际问题。
二、实验内容:1.磁盘调度算法原理分析:磁盘调度算法是操作系统中的重要组成部分,它的任务是合理安排磁盘上数据的存取顺序,以提高磁盘的效率。
常见的磁盘调度算法有先来先服务(FCFS)、最短寻道时间优先(SSTF)、电梯算法(SCAN)等。
2.模拟实现磁盘调度算法:本实验选择最短寻道时间优先算法(SSTF)作为示例进行模拟实现。
SSTF算法的原理是优先选择离当前磁头位置最近的磁道进行访问,以减少磁头移动时间。
实验步骤:1.根据实际情况,创建一个磁道队列,记录需要访问的磁道序号。
2.初始化磁盘的起始位置和访问队列。
3.对访问队列进行排序,按照磁头当前位置到磁道的距离从小到大排列。
4.根据排序后的队列顺序,依次访问磁道,并记录磁头移动的距离。
5.计算平均寻道长度。
三、实验结果分析:通过模拟实现SSTF磁盘调度算法,我们获得了磁头对每个磁道的访问顺序和总共的磁头移动距离。
根据实验结果,我们可以发现SSTF算法相对于其他算法具有一定的优势。
在实际应用中,根据不同的实际情况,可以选择合适的磁盘调度算法以优化磁盘的访问效率。
四、实验总结:通过本次实验,我们对磁盘调度算法的原理和实现有了更深入的了解。
磁盘调度算法作为操作系统中一个重要的模块,对提高磁盘的读写效率起着重要的作用。
在实际应用中,我们需要根据具体问题选择合适的磁盘调度算法,以达到最优的访问效果。
操作系统磁盘调度算法实验报告及代码
![操作系统磁盘调度算法实验报告及代码](https://img.taocdn.com/s3/m/7f4852dfdbef5ef7ba0d4a7302768e9950e76e56.png)
操作系统磁盘调度算法实验报告及代码一、实验目的通过实验掌握磁盘调度算法的实现过程,了解各种不同磁盘调度算法的特点和优缺点,并比较它们的性能差异。
二、实验原理磁盘调度是操作系统中的重要内容,其主要目的是提高磁盘的利用率和系统的响应速度。
常见的磁盘调度算法有: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算法通过选择离当前磁道最近的请求进行处理,能够减少平均寻道时间,提高磁盘性能。
五、实验总结通过本次实验,我们学习了操作系统中磁盘调度算法的原理和实现过程。
不同的磁盘调度算法具有不同的优缺点,我们需要根据实际情况选择合适的算法。
操作系统实验报告—磁盘调度算法
![操作系统实验报告—磁盘调度算法](https://img.taocdn.com/s3/m/e8ddb6c5551810a6f4248606.png)
操作系统实验报告—磁盘调度算法操作系统实验报告实验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语言模拟电梯调度算法,实现对磁盘的驱动调度,这个相比前两个实验实现起来相对简单,理解了算法实现起来尤为简单,程序敲出来之后没有错误,可直接运行,结果验证也无误。
《操作系统》实验六磁盘调度报告
![《操作系统》实验六磁盘调度报告](https://img.taocdn.com/s3/m/5103d30de418964bcf84b9d528ea81c759f52e70.png)
《操作系统》实验六磁盘调度报告磁盘调度是指操作系统对存储在磁盘中的数据进行管理和调度,以提高磁盘的利用率和系统的性能。
在实验六中,我们将学习和实现几种经典的磁盘调度算法,并通过实验比较它们的性能。
本次实验中,我们实现了以下几种磁盘调度算法:先来先服务(FCFS)、最短寻道时间优先(SSTF)、电梯算法(SCAN)和循环扫描(C-SCAN)。
下面将对这几种算法进行具体的介绍和分析。
首先是先来先服务算法(FCFS)。
该算法按照请求的顺序进行磁盘访问,先到达的请求先被服务。
该算法实现简单,但是它无法根据磁盘的物理布局情况进行优化,因此可能出现不连续访问磁盘的情况,导致磁盘的寻道时间增加。
实验结果显示,在磁盘请求序列比较随机的情况下,FCFS算法的性能较差。
第二种算法是最短寻道时间优先算法(SSTF)。
该算法选择与当前磁头位置最近的磁道进行访问,以减少寻道时间。
实验结果显示,SSTF算法在磁盘请求序列比较随机的情况下,相较于FCFS算法,可以有效地减少寻道时间。
然而,当一些磁道频繁被请求时,SSTF算法会优先访问该磁道,导致其他磁道的请求被延迟,出现饥饿现象。
第三种算法是电梯算法(SCAN)。
该算法模拟电梯的运行过程,在一个方向上依次访问磁道,直到到达磁盘的最边缘,然后改变方向继续访问。
实验结果显示,SCAN算法可以很好地优化磁盘访问的顺序,减少寻道时间。
但是,SCAN算法可能导致一些请求在磁盘的一侧永远得不到服务,造成饥饿现象。
最后是循环扫描算法(C-SCAN)。
该算法和SCAN算法类似,不同之处是C-SCAN算法在到达磁盘最边缘后,直接返回到磁道的起始位置继续扫描。
实验结果显示,C-SCAN算法可以减少饥饿现象,但是可能出现磁盘一侧被连续访问导致其他区域的访问不均衡。
综上所述,不同的磁盘调度算法在不同的应用场景下有不同的性能表现。
在磁盘请求序列比较随机的情况下,SSTF算法能够最大程度地减少寻道时间。
磁盘调度实验报告
![磁盘调度实验报告](https://img.taocdn.com/s3/m/36df9ec1312b3169a451a4ad.png)
实验五磁盘调度实验学时:2学时实验类型:设计实验要求:必修一、实验目的:磁盘是高速、大容量、旋转型、可直接存取的存储设备。
它作为计算机系统的辅助存储器,担负着繁重的输入输出工作,在现代计算机系统中往往同时会有若干个要求访问磁盘的输入输出要求。
系统可采用一种策略,尽可能按最佳次序执行访问磁盘的请求。
由于磁盘访问时间主要受寻道时间T的影响,为此需要采用合适的寻道算法,以降低寻道时间。
本实验要求学生模拟设计一个磁盘调度程序,观察调度程序的动态运行过程。
通过实验让学生理解和掌握磁盘调度的职能。
二、实验内容:模拟电梯调度算法,对磁盘进行移臂操作三、提示及要求:1、假设磁盘只有一个盘面,并且磁盘是可移动头磁盘。
2、磁盘是可供多个进程共享的存储设备,但一个磁盘每个时刻只能为一个进程服务。
当有进程在访问某个磁盘时,其它想访问该磁盘的进程必须等待,直到磁盘一次工作结束。
当有多个进程提出输入输出请求而处于等待状态时,可用电梯调度算法从若干个等待访问者中选择一个进程,让它访问磁盘。
为此设置“驱动调度”进程。
3、由于磁盘与处理器是并行工作的,所以当磁盘在为一个进程服务时,占有处理器的其它进程可以提出使用磁盘(这里我们只要求访问磁道),即动态申请访问磁道,为此设置“接受请求”进程。
4、为了模拟以上两个进程的执行,可以考虑使用随机数来确定二者的允许顺序,程序结构图参考附图:5、“接受请求”进程建立一张“进程请求I/O”表,指出等待访问磁盘的进程要求访问的磁道,表的格式如下:6、“磁盘调度”的功能是查“请求I/O”表,当有等待访问的进程时,按电梯调度算法(SCAN算法)从中选择一个等待访问的进程,按其指定的要求访问磁道。
SCAN算法参考课本第九章。
算法模拟框图略。
7、附图中的“初始化”工作包括:初始化“请求I/O”表,设置置当前移臂方向;当前磁道号。
并且假设程序运行前“请求I/O”表中已有若干进程(4~8个)申请访问相应磁道。
磁盘调度实验报告实验总结
![磁盘调度实验报告实验总结](https://img.taocdn.com/s3/m/f12942868ad63186bceb19e8b8f67c1cfbd6ee61.png)
磁盘调度实验报告实验总结磁盘调度是操作系统中的一个重要概念,它是指操作系统通过合理的算法和策略来管理和调度磁盘上的数据访问请求。
磁盘调度的目的是提高磁盘的读写效率,减少磁盘访问的时间开销,从而提高系统的整体性能。
本次实验主要对比了三种常见的磁盘调度算法:先来先服务(FCFS)、最短寻道时间优先(SSTF)和电梯算法(SCAN)。
通过对比实验结果分析各种算法的性能表现和特点,并给出相应的实验总结。
实验总结如下:一、先来先服务(FCFS)算法FCFS算法是一种简单直接的磁盘调度算法,它按照请求的顺序依次进行访问。
实验结果表明,FCFS算法的平均寻道时间较高,且易产生长期等待现象。
这是因为FCFS算法无法优化磁头的移动顺序,只能按照请求的先后顺序安排磁道的访问,从而导致了较差的性能表现。
二、最短寻道时间优先(SSTF)算法SSTF算法根据当前磁头位置选择距离最近的请求进行服务。
实验结果表明,SSTF算法的平均寻道时间明显优于FCFS算法,且缓解了长期等待现象。
这是因为SSTF算法可以选择离当前磁头位置最近的请求,从而减少了寻道时间,提高了磁道的访问效率。
三、电梯算法(SCAN)算法SCAN算法也称为电梯算法,它模拟了电梯运行的原理。
SCAN算法先将磁头移动到一个极限位置,然后沿着一个方向依次访问请求,直到到达另一个极限位置,再改变方向重复上述过程。
实验结果表明,SCAN算法的平均寻道时间与SSTF 算法相当,且具有较好的均衡性。
这是因为SCAN算法可以使得磁头在磁盘上的行进路线保持平衡,避免了过多的磁道之间的跳跃,从而提高了磁道的访问效率。
综上所述,不同的磁盘调度算法具有不同的性能表现和特点。
在实际应用中,需要根据具体的场景和需求选择合适的磁盘调度算法。
一般而言,SSTF算法和SCAN算法在性能上表现较好,可以提高磁盘的读写效率,减少寻道时间开销。
而FCFS算法在实际应用中较为有限,对于长期等待和寻道时间要求较高的场景不太适用。
磁盘调度的实验报告(3篇)
![磁盘调度的实验报告(3篇)](https://img.taocdn.com/s3/m/4cdf4f8cb9f67c1cfad6195f312b3169a451eac8.png)
第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算法在请求序列较长时性能更稳定,且磁头移动次数更少。
磁盘调度实验报告
![磁盘调度实验报告](https://img.taocdn.com/s3/m/28917354c281e53a5902ff0f.png)
操作系统实验报告磁盘调度实验六:磁盘调度算法一.实验目的复习模拟实现一种磁盘调度算法,进一步加深对磁盘调度效率的理解。
二.实验属性该实验为设计性实验。
三.实验仪器设备及器材普通PC386以上微机四.实验要求本实验要求2学时完成。
本实验要求完成如下任务:(1)建立相关的数据结构,作业控制块、已分配分区及未分配分区(2)实现一个分区分配算法,如最先适应分配算法、最优或最坏适应分配算法(3)实现一个分区回收算法(4)给定一批作业/进程,选择一个分配或回收算法,实现分区存储的模拟管理实验前应复习实验中所涉及的理论知识和算法,针对实验要求完成基本代码编写并完成预习报告、实验中认真调试所编代码并进行必要的测试、记录并分析实验结果。
实验后认真书写符合规范格式的实验报告(参见附录A),并要求用正规的实验报告纸和封面装订整齐,按时上交。
五 .主要算法分析各个算法分析1.先来先服务算法(FCFS)先来先服务(FCFS)调度:按先来后到次序服务,未作优化。
最简单的移臂调度算法是“先来先服务”调度算法,这个算法实际上不考虑访问者要求访问的物理位置,而只是考虑访问者提出访问请求的先后次序。
例如,如果现在读写磁头正在50号柱面上执行输出操作,而等待访问者依次要访问的柱面为130、199、32、159、15、148、61、99,那么,当50号柱面上的操作结束后,移动臂将按请求的先后次序先移到130号柱面,最后到达99号柱面。
采用先来先服务算法决定等待访问者执行输入输出操作的次序时,移动臂来回地移动。
先来先服务算法花费的寻找时间较长,所以执行输入输出操作的总时间也很长。
2.最短寻道时间优先算法(SSTF)最短寻找时间优先调度算法总是从等待访问者中挑选寻找时间最短的那个请求先执行的,而不管访问者到来的先后次序。
现在仍利用同一个例子来讨论,现在当50号柱面的操作结束后,应该先处理61号柱面的请求,然后到达32号柱面执行操作,随后处理15号柱面请求,后继操作的次序应该是99、130、148、159、199。
磁盘调度操作系统实验报告
![磁盘调度操作系统实验报告](https://img.taocdn.com/s3/m/f7384b424431b90d6c85c773.png)
实验一磁盘调度算法实现一、实验目的本课程设计的目的是通过磁盘调度算法设计一个磁盘调度模拟系统,从而使磁盘调度算法更加形象化,容易使人理解,使磁盘调度的特点更简单明了,能使使用者加深对先来先服务算法、最短寻道时间优先算法、扫描算法以及循环扫描算法等磁盘调度算法的理解。
二、实验内容系统主界面可以灵活选择某种算法,算法包括:先来先服务算法(FCFS)、最短寻道时间优先算法(SSTF)、扫描算法(SCAN)、循环扫描算法(CSCA)N。
2.1 先来先服务算法(FCFS )这是一种比较简单的磁盘调度算法。
它根据进程请求访问磁盘的先后次序进行调度。
此算法的优点是公平、简单,且每个进程的请求都能依次得到处理,不会出现某一进程的请求长期得不到满足的情况。
此算法由于未对寻道进行优化,在对磁盘的访问请求比较多的情况下,此算法将降低设备服务的吞吐量,致使平均寻道时间可能较长,但各进程得到服务的响应时间的变化幅度较小。
2.2 最短寻道时间优先算法(SSTF )该算法选择这样的进程,其要求访问的磁道与当前磁头所在的磁道距离最近,以使每次的寻道时间最短,该算法可以得到比较好的吞吐量,但却不能保证平均寻道时间最短。
其缺点是对用户的服务请求的响应机会不是均等的,因而导致响应时间的变化幅度很大。
在服务请求很多的情况下,对内外边缘磁道的请求将会无限期的被延迟,有些请求的响应时间将不可预期。
2.3 扫描算法(SCAN)扫描算法不仅考虑到欲访问的磁道与当前磁道的距离,更优先考虑的是磁头的当前移动方向。
例如,当磁头正在自里向外移动时,扫描算法所选择的下一个访问对象应是其欲访问的磁道既在当前磁道之外,又是距离最近的。
这样自里向外地访问,直到再无更外的磁道需要访问才将磁臂换向,自外向里移动。
这时,同样也是每次选择这样的进程来调度,即其要访问的磁道,在当前磁道之内,从而避免了饥饿现象的出现。
由于这种算法中磁头移动的规律颇似电梯的运行,故又称为电梯调度算法。
操作系统磁盘调度实验报告
![操作系统磁盘调度实验报告](https://img.taocdn.com/s3/m/43677665a4e9856a561252d380eb6294dd8822cb.png)
操作系统磁盘调度实验报告一、实验目的:1.了解磁盘调度算法的基本原理;2.熟悉磁盘I/O的实验操作;3.掌握C语言程序编写的磁盘调度算法实现。
二、实验原理:磁盘调度是指操作系统为了提高磁盘I/O的效率而对磁盘请求进行排序和调度的过程。
常见的磁盘调度算法有FCFS(先来先服务)、SSTF (最短寻道时间优先)、SCAN(扫描)、C-SCAN(循环扫描)等。
本次实验中,我们将选择SSTF算法来对磁盘请求进行调度。
SSTF算法的基本思想是选择离当前磁头最近的磁道先进行访问。
三、实验环境:1. 操作系统:Windows 10;2. 开发工具:Visual Studio 2024四、实验步骤:1.创建C语言项目并添加源代码文件;2.实现磁盘调度算法的主要函数,包括判断方向函数、SSTF算法函数;3.在主函数中读取磁道请求,调用SSTF算法函数进行磁道调度;4.运行程序,观察磁道调度结果。
五、实验代码:```c#include<stdio.h>#include<stdlib.h>#include<limits.h>//定义磁盘请求的最大数量#define MAX_REQUEST 100//定义磁盘请求结构体typedef struct diskRequestint track; //磁道号int visited; //记录当前请求是否被访问过(0表示未访问,1表示已访问)} DiskRequest;//全局变量,用来记录磁盘请求的数量int n;//方向判断函数,若当前头部位置比目标位置小,则返回1;否则返回-1int determineDirection(int current, int target)if (current < target)return 1;elsereturn -1;//SSTF算法函数,使用SSTF算法将未被访问的磁道号按顺序调度//current: 当前磁头所在磁道号//requests: 磁盘请求数组void SSTF(int current, DiskRequest* requests)int visited = 0; //记录已访问的磁道数量int totalSeekTime = 0; //记录总寻道时间int direction = determineDirection(current,requests[0].track); //记录当前移动方向int next = current; //记录下一个要访问的磁道号//循环调度直到所有磁道访问完毕while (visited < n)int minSeekTime = INT_MAX; //记录最短寻道时间//遍历从当前位置开始的所有未被访问的磁道for (int i = 0; i < n; i++)if (!requests[i].visited)//计算当前未被访问的磁道与当前位置的距离int seekTime = abs(current - requests[i].track); if (seekTime < minSeekTime)minSeekTime = seekTime;next = requests[i].track;}}}//更新总寻道时间totalSeekTime += minSeekTime;//将当前访问的磁道标记为已访问for (int i = 0; i < n; i++)if (requests[i].track == next)requests[i].visited = 1;visited++;break;}}//更新当前位置current = next;}printf("SSTF Algorithm:\n");printf("Total Seek Time: %d\n", totalSeekTime);printf("Average Seek Time: %.2f\n", (float)totalSeekTime / n);int mainDiskRequest* requests; //磁盘请求数组int current; //当前磁头所在磁道号//读取输入,获取磁盘请求的数量和当前磁头所在的磁道号printf("Please enter the number of disk requests: ");scanf("%d", &n);printf("Please enter the current disk track: ");scanf("%d", ¤t);//动态分配内存给磁盘请求数组requests = (DiskRequest*)malloc(n * sizeof(DiskRequest));//读取磁盘请求的磁道号printf("Please enter the disk requests:\n");for (int i = 0; i < n; i++)scanf("%d", &requests[i].track);requests[i].visited = 0; //初始化磁道为未访问状态}//调用SSTF算法对磁盘请求进行调度SSTF(current, requests);//释放内存free(requests);return 0;```六、实验结果与分析:1.实验输入:```Please enter the number of disk requests: 5Please enter the current disk track: 50Please enter the disk requests:4560102030```2.实验输出:```SSTF Algorithm:Total Seek Time: 75Average Seek Time: 15.00```3.实验分析:根据实验输入,我们可以得知当前磁头的位置为50,磁盘请求的磁道号依次为45、60、10、20、30。
磁盘调度算法实验报告
![磁盘调度算法实验报告](https://img.taocdn.com/s3/m/a367549bac51f01dc281e53a580216fc700a5312.png)
磁盘调度算法实验报告磁盘调度算法实验报告引言:磁盘调度算法是操作系统中的重要组成部分,它负责决定磁盘上数据的访问顺序,以提高磁盘的访问效率。
在本次实验中,我们对比了三种常见的磁盘调度算法:先来先服务(FCFS)、最短寻道时间优先(SSTF)和扫描(SCAN)算法。
通过对比实验结果,我们将分析不同算法的优缺点,并对其适用场景进行探讨。
实验过程:为了模拟磁盘调度算法在实际应用中的情况,我们使用了一个包含100个磁道的磁盘模型。
我们随机生成了一组磁道请求序列,并以此作为实验数据。
首先,我们使用FCFS算法对数据进行访问,记录下访问每个磁道所需的时间。
然后,我们分别使用SSTF和SCAN算法进行同样的操作,并记录下相应的访问时间。
实验结果:经过实验,我们得到了不同调度算法的访问时间数据。
在FCFS算法中,由于它按照请求的先后顺序进行访问,所以磁头需要频繁地在磁道之间移动,导致访问时间较长。
SSTF算法则根据当前磁头位置选择最近的磁道进行访问,因此其访问时间相对较短。
而SCAN算法则将磁头从一端移动到另一端,期间访问所有请求的磁道,这样可以减少磁头的移动次数,从而提高访问效率。
讨论与分析:从实验结果可以看出,不同的磁盘调度算法在不同的场景下有着不同的优势。
FCFS算法适用于请求较少、请求之间没有明显关联的情况。
因为它简单易实现,不需要额外的计算和判断,但在高负载情况下容易导致磁头抖动,降低整体性能。
SSTF算法适用于请求之间有明显关联的情况,因为它能够选择最近的磁道进行访问,减少了磁头的移动次数。
但是,当请求分布不均匀时,SSTF算法可能会导致某些磁道长时间得不到访问。
SCAN算法则适用于对整个磁盘进行扫描的场景,因为它能够在一个方向上连续访问多个磁道,减少了磁头的移动次数。
但是,SCAN算法可能会导致某些磁道长时间得不到访问,因此在请求分布不均匀的情况下,其性能可能会受到影响。
结论:通过本次实验,我们对比了三种常见的磁盘调度算法,并分析了它们的优缺点及适用场景。
操作系统-磁盘调度算法实验报告
![操作系统-磁盘调度算法实验报告](https://img.taocdn.com/s3/m/892bd30453d380eb6294dd88d0d233d4b14e3f06.png)
操作系统实验报告实验六磁盘调度算法班级:学号:姓名:一、需求分析1、实验目的:通过这次实验,加深对磁盘调度算法的理解,进一步掌握先来先服务FCFS、最短寻道时间优先SSTF、SCAN和循环SCAN算法的实现方法。
2、问题描述:设计程序模拟先来先服务FCFS、最短寻道时间优先SSTF、SCAN和循环SCAN算法的工作过程。
假设有n个磁道号所组成的磁道访问序列,给定开始磁道号m和磁头移动的方向(正向或者反向),分别利用不同的磁盘调度算法访问磁道序列,给出每一次访问的磁头移动距离,计算每种算法的平均寻道长度。
3、程序要求:1)利用先来先服务FCFS、最短寻道时间优先SSTF、SCAN 和循环SCAN算法模拟磁道访问过程。
2)模拟四种算法的磁道访问过程,给出每个磁道访问的磁头移动距离。
3)输入:磁道个数n和磁道访问序列,开始磁道号m和磁头移动方向(对SCAN和循环SCAN算法有效),算法选择1-FCFS,2-SSTF,3-SCAN,4-循环SCAN。
4)输出:每种算法的平均寻道长度。
二、概要设计1、程序中的变量及数据结构的定义a) 自定义的整型向量类型:typedef vector<int> vInt;b) 磁道的结构体:struct OrderItem{int Data; //磁道号bool IsVisited;//磁道是否已被访问};c) 磁道序列类型:typedef vector<OrderItem> Order;d) 存储待访问磁道序列:Order InitOrder;e) 存储已被访问的磁道序列:vInt TrackOrder;f) 移动距离序列:vInt MoveDistance;g) 平均寻道长度:double AverageDistance;2、主要函数说明a)获取用户输入的磁盘个数和磁盘的访问序列:void InitDate(int &num);参数num为磁道个数b)先来先服务算法:void FCFS(int disk);c)最短寻道时间优先算法:void SSTF(int disk);d)扫描算法:void SCAN(int disk);e)循环扫描算法:void CSCAN(int disk);f)void Show(int disk);3、主函数的流程三、详细设计1.FCFS算法a)说明:根据进程请求访问磁盘的先后次序进行调度。
磁盘调度算法的设计实验报告
![磁盘调度算法的设计实验报告](https://img.taocdn.com/s3/m/3c0ada8264ce0508763231126edb6f1aff0071f8.png)
磁盘调度算法的设计实验报告一、实验背景磁盘调度算法是操作系统中的重要内容之一,它的主要作用是优化磁盘的读写效率,提高系统的性能。
本次实验旨在通过设计不同的磁盘调度算法,比较它们在不同情况下的性能表现。
二、实验环境本次实验使用了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算法的性能最优,平均寻道长度最短。
磁盘调度实验报告
![磁盘调度实验报告](https://img.taocdn.com/s3/m/a3eb0555876fb84ae45c3b3567ec102de2bddfb0.png)
磁盘调度实验报告一、实验目的1.掌握磁盘调度算法的基本原理和思想;2.理解磁盘调度算法的性能指标及其关系;3.利用实验验证各种磁盘调度算法的性能差异。
二、实验原理磁盘调度算法是操作系统中用来调度磁盘的读写操作的一种方法。
磁盘访问的时间主要包括寻道时间、旋转延迟和数据传输时间。
磁盘调度算法的目标是尽可能减少磁头的移动和等待时间,提高磁盘的访问效率。
常用的磁盘调度算法有先来先服务(FCFS)、最短寻找时间优先(SSTF)、电梯扫描(SCAN)和循环扫描(CSCAN)等。
FCFS算法就是按照请求的先后顺序进行访问,即先来的请求先执行。
SSTF算法每次选择最短寻找时间的磁道进行访问,减少了寻道时间。
SCAN算法则是磁头按照一个方向进行扫描,直到扫描到磁盘的一侧,然后改变方向继续扫描。
CSCAN算法是类似于SCAN算法,只是当扫描到磁盘的一侧时,直接跳到另一侧进行扫描。
这些算法各有优缺点,适用于不同的场景和需求。
三、实验过程1.实验环境搭建:选择一台计算机作为实验机器,安装操作系统和相应的磁盘调度算法软件;2.实验数据准备:生成一组磁道访问的请求序列,包括请求的磁道号和读写操作;3.实验数据输入:将生成的请求序列输入到磁盘调度软件中,选择不同的调度算法进行模拟;4.实验结果记录:记录各种调度算法的磁头移动次数和平均访问时间;5.实验数据分析:根据实验结果进行数据分析,比较各种算法的性能差异。
四、实验结果分析根据实验数据进行结果分析,比较不同调度算法的性能差异。
以磁头移动次数和平均访问时间为评价指标,可以看出不同算法对磁盘访问的影响。
在一些情况下,可能一些算法的磁头移动次数更少,但平均访问时间可能并不是最低的,需要综合考虑多个因素。
根据实验结果可以发现,FCFS算法的磁头移动次数和平均访问时间相对较高,因为它只按照请求的先后顺序进行访问,没有考虑磁道之间的距离。
SSTF算法在减少磁头移动次数和平均访问时间方面有一定的优势,因为它每次选择最短寻找时间的磁道进行访问。
校正版磁盘调度算法实验报告
![校正版磁盘调度算法实验报告](https://img.taocdn.com/s3/m/d8f09b0d86c24028915f804d2b160b4e767f81fc.png)
(校正版)磁盘调度算法实验报告磁盘调度算法实验报告磁盘调度算法实验报告文档1.依次输入9个磁道数:XXXXXXX014XXXX48592.选择调度算法:先来先服务算法访问顺序和平均寻道长度:最短寻道时间优先的访问顺序和平均寻道长度:扫描算法的磁道访问顺序和平均寻道长度:1.移动壁由里向外2.移动壁由外向里循环算法的磁道访问顺序和平均寻道长度:1.移动壁由里向外2.移动壁由外向里源代码为:includeincludevoidFCFS(intb[],intn,intinit)/先来先服务{inti,s,sum;inta[20];for(i=0;ia[i]=b[i];s=init;sum=0;for(i=0;iprintf("第%d次访问的磁道:%d ",i+1,a[i]);sum+=abs(s-a[i]);s=a[i];printf("平均寻道长度:%f",sum1.0/n);}voidSSTF(intb[],intn,intk)/最短寻道法inti,j,s,sum=0,p;inta[20];for(i=0;ia[i]=b[i];for(i=n-1;i>=0;i--)s=a[0];p=0;for(j=0;jif(abs(a[j]-k)s=a[j];p=j;a[p]=a[i];printf("第%d次访问的磁道:%d",n-i,s);sum+=abs(s-k);k=s;printf("平均寻道长度:%f",sum1.0/n);}voidSCAN1(intb[],intn,intk)/扫描算法{inti,j,s,sum=0,p,biaoji;inta[20];for(i=0;ia[i]=b[i];for(i=n-1;i>=0;i--)biaoji=0;for(j=0;jif(a[j]-kbiaoji=1;p=j;break;if(biaoji==1)s=a[p];for(j=0;jif(a[j]s=a[j];p=j;a[p]=a[i];printf("第%d次访问的磁道:%d ",n-i,s);sum+=k-s;k=s;elses=a[0];for(j=0;jif(a[j]-ks=a[j];p=j;a[p]=a[i];printf("第%d次访问的磁道:%d",n-i,s);sum+=abs(k-s);k=s;printf("平均寻道长度:%f",sum1.0/n);voidSCAN2(intb[],intn,intk)/循环算法{ inti,j,s,sum=0,p,biaoji;inta[20];for(i=0;ia[i]=b[i];for(i=n-1;i>=0;i--)biaoji=0;for(j=0;jif(a[j]-k>0)biaoji=1;p=j;break;if(biaoji==1)s=a[p];for(j=0;jif(a[j]>ka[j]-ks=a[j];p=j;a[p]=a[i];printf("第%d次访问的磁道:%d",n-i,s);sum+=s-k;k=s;elses=a[0];for(j=0;jif(k-a[j]s=a[j];p=j;a[p]=a[i];printf("第%d次访问的磁道:%d",n-i,s);sum+=abs(k-s);k=s;printf("平均寻道长度:%f",sum1.0/n);voidC_SCAN(intarray[],intm)inttemp;intk=1;intnow,l,r,d;inti,j,sum=0;intavg;for(i=0;ifor(j=i+1;j{if(array[i]>array[j])/对磁道号进行从小到大排列{temp=array[i];array[i]=array[j];array[j]=temp;}}}printf("请输入当前的磁道号:");scanf("%d",now);if(array[m-1]=now)/判断整个数组里的数是否都大于当前磁道号{printf("CSCAN调度结果:");for(i=0;iif(d==0)for(j=l;j>=0;j--)printf("%d",array[j]);for(j=m-1;j>=r;j--)printf("%d",array[j]);sum=2(array[m-1]-array[0])-array[r]+now;/计算移动距离}/磁道号减小方向elsefor(j=r;jprintf("%d",array[j]);for(j=0;jprintf("%d",array[j]);sum=2(array[m-1]-array[0])+array[r-1]-now;/计算移动距离} }/磁道号增加方向avg=sum/m;printf("平均寻道长度:%d",avg);voidmain()inta[20];inti,n,k,k1,init;printf("请输入需要访问的磁道总数:");scanf("%d",n);for(i=0;iprintf("需要访问的磁道%d:",i+1);scanf("%d",a[i]);printf("请输入指针所在磁道:");}scanf("%d",init);k=1;while(k){printf("");printf("磁盘调度算法");printf("1.先来先服务(FCFS)2.最短寻道时间优先(SSTF)");printf("3.扫描算法(SCAN)4.循环算法(C-SCAN)");printf("");printf("请在下面输入您的选择:");scanf("%d",k);switch(k){case1:FCFS(a,n,init);break;case2:S STF(a,n,init);break;case3:k1=1;while(k1){printf("扫描算法");printf("1.移动臂由里向外2.移动臂由外向里");printf("0.返回上一层");printf("");printf("请在下面输入您的选择:");scanf("%d",k1);switch(k1){case1:SCAN1(a,n,init);break;cas e2:SCAN2(a,n,init);break;}}break;case4:C_SCAN(a,n,init);break;} }。
磁盘调度操作系统试验报告
![磁盘调度操作系统试验报告](https://img.taocdn.com/s3/m/badd8027c4da50e2524de518964bcf84b9d52d94.png)
实验一磁盘调度算法实现一、实验目的本课程设计的目的是通过磁盘调度算法设计一个磁盘调度模拟系统,从而使磁盘调度算法更加形象化,容易使人理解,使磁盘调度的特点更简单明了,能使使用者加深对先来先服务算法、最短寻道时间优先算法、扫描算法以及循环扫描算法等磁盘调度算法的理解。
二、实验内容系统主界面可以灵活选择某种算法,算法包括:先来先服务算法(FCFS)、最短寻道时间优先算法(SSTF)、扫描算法(SCAN)、循环扫描算法(CSCAN)。
2.1先来先服务算法(FCFS)这是一种比较简单的磁盘调度算法。
它根据进程请求访问磁盘的先后次序进行调度。
此算法的优点是公平、简单,且每个进程的请求都能依次得到处理,不会出现某一进程的请求长期得不到满足的情况。
此算法由于未对寻道进行优化,在对磁盘的访问请求比较多的情况下,此算法将降低设备服务的吞吐量,致使平均寻道时间可能较长,但各进程得到服务的响应时间的变化幅度较小。
2.2最短寻道时间优先算法(SSTF)该算法选择这样的进程,其要求访问的磁道与当前磁头所在的磁道距离最近,以使每次的寻道时间最短,该算法可以得到比较好的吞吐量,但却不能保证平均寻道时间最短。
其缺点是对用户的服务请求的响应机会不是均等的,因而导致响应时间的变化幅度很大。
在服务请求很多的情况下,对内外边缘磁道的请求将会无限期的被延迟,有些请求的响应时间将不可预期。
2.3扫描算法(SCAN)扫描算法不仅考虑到欲访问的磁道与当前磁道的距离,更优先考虑的是磁头的当前移动方向。
例如,当磁头正在自里向外移动时,扫描算法所选择的下一个访问对象应是其欲访问的磁道既在当前磁道之外,又是距离最近的。
这样自里向外地访问,直到再无更外的磁道需要访问才将磁臂换向,自外向里移动。
这时,同样也是每次选择这样的进程来调度,即其要访问的磁道,在当前磁道之内,从而避免了饥饿现象的出现。
由于这种算法中磁头移动的规律颇似电梯的运行,故又称为电梯调度算法。
操作系统实验磁盘调度算法实验报告
![操作系统实验磁盘调度算法实验报告](https://img.taocdn.com/s3/m/9a34b362cec789eb172ded630b1c59eef8c79a2d.png)
操作系统实验磁盘调度算法实验报告一.实验目的本实验旨在通过磁盘调度算法的模拟,探究不同调度算法对磁盘访问性能的影响,了解各种算法的特点和适用场景。
二.实验方法本实验通过编写磁盘调度模拟程序,实现了三种常见的磁盘调度算法:FCFS(先来先服务)、SSTF(最短寻找时间优先)和SCAN(扫描算法)。
实验中使用C语言编程语言,并通过随机生成的队列模拟磁盘访问请求序列。
三.实验过程1.FCFS(先来先服务)算法FCFS算法是一种非常简单的调度算法,它按照请求到达的顺序进行调度。
在实验中,我们按照生成的请求队列顺序进行磁盘调度,记录每次磁头移动的距离。
2.SSTF(最短寻找时间优先)算法SSTF算法是一种动态选择离当前磁头位置最近的磁道进行调度的算法。
在实验中,我们根据当前磁头位置和请求队列中的磁道位置,选择距离最近的磁道进行调度。
然后将该磁道从请求队列中移除,并记录磁头移动的距离。
3.SCAN(扫描算法)算法SCAN算法是一种按照一个方向进行扫描的算法,它在每个方向上按照磁道号的顺序进行调度,直到扫描到最边缘磁道再折返。
在实验中,我们模拟磁头从一个端点开始,按照磁道号从小到大的顺序进行调度,然后再折返。
记录磁头移动的距离。
四.实验结果与分析我们通过生成不同数量的请求队列进行实验,记录每种算法的磁头移动距离,并进行比较。
实验结果显示,当请求队列长度较小时,FCFS算法的磁头移动距离较短,因为它按照请求到达的顺序进行调度,无需寻找最短的磁道。
然而,当请求队列长度较大时,FCFS算法的磁头移动距离会显著增加,因为它不能根据距离进行调度。
SSTF算法相对于FCFS算法在磁头移动距离上有了明显改进。
SSTF算法通过选择最短的寻找时间来决定下一个访问的磁道,因此可以减少磁头的移动距离。
然而,在请求队列中存在少量分散的请求时,SSTF算法可能会产生扇区的服务死锁现象,导致一些磁道无法及时访问。
SCAN算法通过扫描整个磁盘来进行调度,有效解决了FCFS算法有可能导致的服务死锁问题。
磁盘调度实验报告
![磁盘调度实验报告](https://img.taocdn.com/s3/m/1eb3947182c4bb4cf7ec4afe04a1b0717fd5b331.png)
磁盘调度实验报告磁盘调度实验报告一、引言磁盘调度是操作系统中的一个重要组成部分,其作用是对磁盘上的数据进行合理的调度和管理,以提高磁盘的读写效率。
本文将对磁盘调度实验进行详细的分析和总结,探讨不同的磁盘调度算法对磁盘性能的影响。
二、实验目的本次实验的目的是通过模拟不同的磁盘调度算法,比较它们在不同情况下的性能表现,包括平均寻道时间、平均旋转延迟时间和平均访问时间等指标。
通过实验结果的对比分析,我们可以了解不同磁盘调度算法的优劣,并选择适合特定应用场景的磁盘调度算法。
三、实验环境和方法本次实验使用了模拟磁盘调度的软件,并设置了不同的磁盘调度算法进行对比。
实验环境为一台配置良好的计算机,操作系统为Windows 10。
实验方法是通过设置不同的磁盘访问序列,模拟磁盘的读写操作,并记录相应的性能指标。
四、实验结果和分析在本次实验中,我们选择了三种常见的磁盘调度算法进行对比,分别是先来先服务(FCFS)、最短寻道时间优先(SSTF)和电梯算法。
下面将分别对这三种算法的实验结果进行分析。
1. 先来先服务(FCFS)先来先服务算法是最简单的一种磁盘调度算法,它按照请求的顺序进行调度。
实验结果显示,当磁盘访问序列较为随机时,FCFS算法的性能表现较差。
这是因为当磁盘访问序列随机时,FCFS算法无法充分利用磁盘的局部性原理,导致平均寻道时间较长。
2. 最短寻道时间优先(SSTF)最短寻道时间优先算法是一种比较常用的磁盘调度算法,它选择离当前磁头位置最近的磁道进行访问。
实验结果显示,SSTF算法在随机磁盘访问序列下表现优秀,平均寻道时间较短。
这是因为SSTF算法能够充分利用磁盘的局部性原理,尽可能减小寻道时间。
3. 电梯算法电梯算法是一种比较灵活的磁盘调度算法,它模拟了电梯的运行方式。
当磁头移动的方向没有改变时,电梯算法按照最短寻道时间优先的原则进行调度;当磁头移动的方向改变时,电梯算法改变调度方向,并按照当前方向上最远的磁道进行访问。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
操作系统实验报告磁盘调度实验六:磁盘调度算法一.实验目的复习模拟实现一种磁盘调度算法,进一步加深对磁盘调度效率的理解。
二.实验属性该实验为设计性实验。
三.实验仪器设备及器材普通PC386以上微机四.实验要求本实验要求2学时完成。
本实验要求完成如下任务:(1)建立相关的数据结构,作业控制块、已分配分区及未分配分区(2)实现一个分区分配算法,如最先适应分配算法、最优或最坏适应分配算法(3)实现一个分区回收算法(4)给定一批作业/进程,选择一个分配或回收算法,实现分区存储的模拟管理实验前应复习实验中所涉及的理论知识和算法,针对实验要求完成基本代码编写并完成预习报告、实验中认真调试所编代码并进行必要的测试、记录并分析实验结果。
实验后认真书写符合规格式的实验报告(参见附录A),并要求用正规的实验报告纸和封面装订整齐,按时上交。
五.主要算法分析各个算法分析1.先来先服务算法(FCFS)先来先服务(FCFS)调度:按先来后到次序服务,未作优化。
最简单的移臂调度算法是“先来先服务”调度算法,这个算法实际上不考虑访问者要求访问的物理位置,而只是考虑访问者提出访问请求的先后次序。
例如,如果现在读写磁头正在50号柱面上执行输出操作,而等待访问者依次要访问的柱面为130、199、32、159、15、148、61、99,那么,当50号柱面上的操作结束后,移动臂将按请求的先后次序先移到130号柱面,最后到达99号柱面。
采用先来先服务算法决定等待访问者执行输入输出操作的次序时,移动臂来回地移动。
先来先服务算法花费的寻找时间较长,所以执行输入输出操作的总时间也很长。
2.最短寻道时间优先算法(SSTF)最短寻找时间优先调度算法总是从等待访问者中挑选寻找时间最短的那个请求先执行的,而不管访问者到来的先后次序。
现在仍利用同一个例子来讨论,现在当50号柱面的操作结束后,应该先处理61号柱面的请求,然后到达32号柱面执行操作,随后处理15号柱面请求,后继操作的次序应该是99、130、148、159、199。
采用最短寻找时间优先算法决定等待访问者执行操作的次序时,读写磁头总共移动了200多个柱面的距离,与先来先服务、算法比较,大幅度地减少了寻找时间,因而缩短了为各访问者请求服务的平均时间,也就提高了系统效率。
但最短查找时间优先(SSTF)调度,FCFS会引起读写头在盘面上的大围移动,SSTF查找距离磁头最短(也就是查找时间最短)的请求作为下一次服务的对象。
SSTF查找模式有高度局部化的倾向,会推迟一些请求的服务,甚至引起无限拖延(又称饥饿)。
3.扫描算法(SCAN)SCAN 算法又称电梯调度算法。
SCAN算法是磁头前进方向上的最短查找时间优先算法,它排除了磁头在盘面局部位置上的往复移动,SCAN算法在很大程度上消除了SSTF算法的不公平性,但仍有利于对中间磁道的请求。
“电梯调度”算法是从移动臂当前位置开始沿着臂的移动方向去选择离当前移动臂最近的那个柱访问者,如果沿臂的移动方向无请求访问时,就改变臂的移动方向再选择。
这好比乘电梯,如果电梯已向上运动到4层时,依次有3位乘客生、伍生、生在等候乘电梯。
他们的要:生在2层等待去10层;伍生在5层等待去底层;生在8层等待15层。
由于电梯目前运动方向是向上,所以电梯的形成是先把乘客生从8层带到15层,然后电梯换成下行方向,把乘客伍生从5层带到底层,电梯最后再调换方向,把乘客生从2层送到10层。
但是,“电梯调度”算法在实现时,不仅要记住读写磁头的当前位置,还必须记住移动臂的当前前进方向。
六、程序代码#include<iostream.h>#include<stdio.h>#include<stdlib.h>void FCFS(int array[],int m)// 先来先服务算法{ int j,i,now;float sum = 0,avg;cout<<"输入当前的磁道号:";//输入当前磁道号cin>>now;sum=abs(now-array[0]);cout<<"先来先服务算法(FCFS)调度后的序列为"<<array[0]<<" ";//输出磁盘调度序列for(i=0,j=1;j<m;i++,j++){sum=sum+abs(array[j]-array[i]);cout<<array[j]<<" "; //输出磁盘调度序列}avg=sum/(m);cout<<endl<<"平均寻道长度:"<<avg<<endl;//输出平均寻道长度}////////////////////////////////////////////////////////////////////////////////////////////////////////// //////////////////void SSTF(int array[],int m)// 最短寻道时间优先算法{ int temp;int k=1;int now,l,r;int i,j;float sum=0,avg=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;} }cout<<"请输入当前的磁道号:"; //输入当前磁道号cin>>now;cout<<"最短寻道时间优先算法(SSTF)调度后的序列为";//输出磁盘调度序列if(array[m-1]<=now) //若被访问的下一最大的磁道号不大于当前的磁道号{for(i=m-1;i>=0;i--){ cout<<array[i]<<" ";//输出磁盘调度序列sum=now-array[i];now=array[i]; }}else{f(array[0]>=now) //若被访问的下一最小的磁道号不小于当前的磁道号{ for(i=0;i<m;i++){ cout<<array[i]<<" ";//输出磁盘调度序列sum=array[i]-now;now=array[i]; }}else //当前的磁道号的值在若所有被访问的下的磁道号之间{ while(array[k]<now) //确定当前磁道在已排的序列中的位置{ k++; }l=k-1;r=k;if((now-array[l])<=(array[r]-now)){ while(l>=0) //先向磁道号减小方向访问{cout<<array[l]<<" "; //输出磁盘调度序列sum=sum+now-array[l];now=array[l];l=l-1;}now=array[0];for(j=r;j<m;j++) //再向磁道号增加方向访问{ cout<<array[j]<<" "; //输出磁盘调度序列sum+=array[j]-now;now=array}}else //先向磁道号增加方向访问{ while(r<m){ cout<<array[r]<<" ";//输出磁盘调度序列sum+=array[r]-now;now=array[r];r=r+1; }now=array[m-1];for(j=l;j>=0;j--) //再向磁道号减小方向访问{ cout<<array[j]<<" "; //输出磁盘调度序列sum+=now-array[j];now=array[j]; }} }}avg=sum/(m);cout<<endl<<"平均寻道长度:"<<avg<<endl;//输出平均寻道长度}////////////////////////////////////////////////////////////////////////////////////////////////////////// //////////////////void SCAN(int array[],int m) //扫描算法{ int temp;int k=1;int now,d,l,r;int i,j;float sum=0,avg=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;}}cout<<"请输入当前的磁道号:";//输入当前磁道号cin>>now;cout<<"请输入当前移动臂的移动的方向(1 表示向磁道号增加方向,0 表示向磁道号减小方向): ";cin>>d; //先要给出当前磁道号和移动臂的移动方向cout<<"扫描算法(SCAN)调度后的序列为";if(array[m-1]<=now) //若被访问的下一最大的磁道号不大于当前的磁道号{ for(i=m-1;i>=0;i--){ cout<<array[i]<<" "; //输出磁盘调度序列sum=now-array[i];now=array[i];}}else{if(array[0]>=now) //若被访问的下一最小的磁道号不小于当前的磁道号{ for(i=0;i<m;i++){ cout<<array[i]<<" "; //输出磁盘调度序列sum=array[i]-now;now=array[i];}}else //当前的磁道号的值在若所有被访问的下的磁道号之间{ while(array[k]<now) //确定当前磁道在已排的序列中的位置{ k++; }l=k-1;r=k;switch(d){ case 0: //先向磁道号减小方向访问{ while(l>=0){ cout<<array[l]<<" "; //输出磁盘调度序列sum=sum+now-array[l];now=array[l];l=l-1;}now=array[0];for(j=r;j<m;j++){ cout<<array[j]<<" "; //输出磁盘调度序列sum+=array[j]-now;now=array[j];} break;}case 1: //先向磁道号增加方向访问{while(r<m){cout<<array[r]<<" ";//输出磁盘调度序列sum+=array[r]-now;now=array[r];r=r+1;}now=array[m-1];for(j=l;j>=0;j--){ cout<<array[j]<<" "; //输出磁盘调度序列sum+=now-array[j];now=array[j];}break;}default: cout<<"输入有误"<<endl;}}}avg=sum/(m);cout<<endl<<"平均寻道长度:"<<avg<<endl;//输出平均寻道长度}////////////////////////////////////////////////////////////////////////////////////////////////////////// //////////////////void main(){int i,m,n,flag=1,array[100];cout<<"输入磁盘调度序列的个数:";cin>>m;cout<<"分别输入磁盘调度序列:";for(i=0;i<m;i++){ cin>>array[i]; }do{cout<<"0 终止"<<endl;cout<<"1 先来先服务算法(FCFS)"<<endl;cout<<"2 最短寻道时间优先算法(SSTF)"<<endl;cout<<"3 最短寻道时间优先算法(SCAN)"<<endl;cout<<"选择以上的算法:";cin>>n;switch(n){case 0: { flag=0; break; } //终止程序case 1:{ FCFS(array,m); break; } //先来先服务算法(FCFS)case 2:{ SSTF(array,m); break; }//最短寻道时间优先算法(SSTF)case 3:{ SCAN(array,m); break; }//最短寻道时间优先算法(SCAN)default: cout<<"输入有误,请重新输入:"<<endl;}}while(flag!=0);}七、各算法的流程图1..先来先服务算法流程图3. 扫描算法流程图八.课程设计运行结果一. 运行后的开始界面如下:二、运行各个算法结果如下1.运行先来先服务(FCFS)算法调度后程序结果如下:2.运行最短寻道时间优先(SSTF)算法调度程序结果如下:3.运行扫描(SCAN)算法调度程序结果如下:5.选择退出后程序界面如下:九.心得体会整个设计中最麻烦的就是整个程序模块的划分和各模块之间接口设计,编程中经常犯想当然的错误,编程中出现了不少奇怪的错误。