磁盘调度算法的实现

合集下载

磁盘调度算法的模拟实现及对比

磁盘调度算法的模拟实现及对比

磁盘调度算法的模拟实现及对比磁盘调度算法是操作系统中的一个重要组成部分,用于优化磁盘读写操作的效率,提高系统的响应速度和运行效率。

常见的磁盘调度算法包括先来先服务(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(扫描)、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算法通过选择离当前磁道最近的请求进行处理,能够减少平均寻道时间,提高磁盘性能。

五、实验总结通过本次实验,我们学习了操作系统中磁盘调度算法的原理和实现过程。

不同的磁盘调度算法具有不同的优缺点,我们需要根据实际情况选择合适的算法。

qt实现磁盘调度算法

qt实现磁盘调度算法

qt实现磁盘调度算法Qt是一个跨平台的C++图形用户界面应用程序开发框架。

它提供了一套完整的开发工具,包括一个强大的应用程序框架,用于开发具有图形用户界面的应用程序。

磁盘调度算法是一种用于决定磁盘臂在磁盘上移动的顺序的算法。

这些算法通常用于操作系统中,以优化磁盘访问时间。

要在Qt中实现磁盘调度算法,您需要首先理解这些算法的工作原理,然后使用Qt的C++语言编写代码。

下面是一个简单的例子,展示如何在Qt中实现一个简单的先入先出(FIFO)磁盘调度算法:```cppinclude <QCoreApplication>include <QDebug>include <QLinkedList>class DiskScheduler {public:DiskScheduler() {}void addRequest(int track) {(track);}int nextRequest() {if (()) {return -1; // 返回-1表示没有更多的请求}int track = ();();return track;}private:QLinkedList<int> requests; // 使用QLinkedList来保存磁盘请求队列};int main(int argc, char argv[]) {QCoreApplication a(argc, argv);DiskScheduler scheduler;(10);(15);(2);(8);while (true) {int track = ();if (track == -1) {break; // 如果没有更多的请求,退出循环} else {qDebug() << "Track:" << track; // 打印出当前处理的磁道号}}return ();}```在这个例子中,我们创建了一个`DiskScheduler`类,它使用一个`QLinkedList`来保存磁盘请求队列。

操作系统实验报告—磁盘调度算法

操作系统实验报告—磁盘调度算法

操作系统实验报告—磁盘调度算法操作系统实验报告实验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(扫描)、C-SCAN(循环扫描)等。

下面我将分别介绍这几种算法的模拟实现。

1.FCFS(先来先服务)算法模拟实现:首先,我们需要定义一个队列,用于存储用户请求的磁道号。

然后,将用户请求的磁道号加入队列中,按照先来先服务的原则进行服务,即按照队列中的请求顺序依次访问磁盘。

计算总体访问时间等信息,并输出结果。

2.SSTF(最短寻道时间优先)算法模拟实现:首先,我们需要定义一个队列,用于存储用户请求的磁道号。

然后,从当前磁头位置开始,找到与当前位置距离最近的请求磁道号,计算距离最小的请求所在的队列位置,并将该请求从队列中取出访问磁盘。

重复上述过程,直至队列为空。

计算总体访问时间等信息,并输出结果。

3.SCAN(扫描)算法模拟实现:首先,我们需要定义一个队列,用于存储用户请求的磁道号。

然后,将用户请求的磁道号加入队列中,并将队列按磁道号从小到大排序。

假设当前磁头位置为start,将磁头移动到队列中第一个比start大的磁道号,然后按照顺时针方向继续移动,直至访问队列中最大的磁道号。

然后,改变移动方向,回到队列中最小的磁道号为止。

计算总体访问时间等信息,并输出结果。

4.C-SCAN(循环扫描)算法模拟实现:首先,我们需要定义一个队列,用于存储用户请求的磁道号。

然后,将用户请求的磁道号加入队列中,并将队列按磁道号从小到大排序。

假设当前磁头位置为start,将磁头移动到队列中第一个比start大的磁道号,然后按照顺时针方向继续移动,直至访问队列中最大的磁道号,并将磁头移动到队列中最小的磁道号。

计算总体访问时间等信息,并输出结果。

以上是对于不同磁盘调度算法的简要模拟实现。

在实际应用中,还需要考虑更多的细节,如怎样处理新到的请求、队列的管理等。

磁盘调度算法的模拟实现及对比

磁盘调度算法的模拟实现及对比

磁盘调度算法的模拟实现及对比磁盘调度算法是操作系统中的重要组成部分,它负责有效地管理磁盘的数据读取和写入。

在实际中,磁盘调度算法的选择对系统的性能有着重要影响。

为了更好地理解磁盘调度算法的运作原理以及它们之间的差异,我们可以进行模拟实现并对比它们的性能。

1.先来先服务算法(FCFS)FCFS算法简单直接,按照请求的顺序依次进行磁盘访问。

实现思路很简单,我们可以创建一个请求队列来存储待访问的磁盘请求。

当有新的请求到来时,将其加入到队列的末尾。

然后按照队列的顺序进行磁盘访问即可。

2.最短寻道时间优先算法(SSTF)SSTF算法选择距离当前磁头位置最近的磁道进行访问,以减少寻道时间。

实现思路是将磁盘请求按照与当前磁头位置的距离进行排序,然后按照排序后的顺序进行访问。

3.扫描算法(SCAN)SCAN算法按照同一方向扫描,当到达磁盘的边界时,改变扫描方向。

实现思路是维护两个队列,一个存储向磁头当前方向的磁道请求,另一个存储向磁头反方向的磁道请求。

先按照当前方向的队列进行访问,直到访问完毕;然后改变扫描方向,并访问反方向的队列中的请求。

以下是对三种算法进行模拟实现并对比它们性能的步骤:1.首先,我们需要模拟磁盘的读取和写入操作。

可以使用一个整型数组来模拟磁盘的扇区,数组中每个元素代表一个扇区的内容。

2.创建一个请求队列,用于存储待访问的磁道号。

可以随机生成一些待访问的磁道号,并根据算法的不同进行排序。

3.根据算法的要求,对请求队列进行排序。

4.模拟磁盘调度算法的运行过程。

对于每个磁道号,计算当前磁头位置与该磁道的距离,并记录总的移动距离。

5.统计总的移动距离,并计算平均移动距离。

6.对比不同算法的平均移动距离,分析它们的性能差异。

通过以上步骤,我们可以进行磁盘调度算法的模拟实现并对比它们的性能。

根据实际情况,我们可以调整磁道数、磁头位置、磁道位置等参数,以观察不同条件下算法的运行情况。

总的来说,磁盘调度算法的模拟实现及对比可以使我们更好地理解各种算法的运行原理,对于选择和优化磁盘调度算法具有重要意义。

磁盘调度算法

磁盘调度算法

磁盘调度算法As a person, we must have independent thoughts and personality.操作系统实验报告哈尔滨工程大学计算机科学与技术学院一、实验概述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: 39 Cylinder: 12 Offset: 55 -TID: 40 Cylinder: 10 Offset: 2 -Total offset: 360 Transfer times: 10 Average offset: 362.实验指导验证验证最短寻道时间优先(SSTF)磁盘调度算法,要求请给出在“输出”窗口中的结果。

磁盘调度的实验报告(3篇)

磁盘调度的实验报告(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算法在请求序列较长时性能更稳定,且磁头移动次数更少。

磁盘调度算法的模拟实现及对比

磁盘调度算法的模拟实现及对比

磁盘调度算法的模拟实现及对比磁盘调度算法是计算机操作系统中的重要概念,用于管理磁盘上的数据读写请求,使得磁盘的读写操作更加高效和优化。

常见的磁盘调度算法有先来先服务(FCFS)、最短寻道时间优先(SSTF)、电梯算法(SCAN)等。

磁盘调度算法的模拟实现需要先确定请求队列,即需要访问的磁盘扇区的序列。

在实现过程中,需要模拟磁盘的物理结构,包括磁盘的扇区数量、扇区大小等。

具体的模拟实现过程如下:1. 创建请求队列,包括需要访问的磁盘扇区序列;2. 模拟磁盘的物理结构,并将请求队列中的扇区按照物理位置排序;3. 选择一个磁盘调度算法,如FCFS、SSTF、SCAN等;4. 按照选择的算法依次处理请求队列中的磁盘访问请求,模拟磁盘的读写操作;5. 计算并输出磁盘访问的平均寻道时间、平均旋转延迟时间、平均传输时间等性能指标。

下面以FCFS算法为例,介绍磁盘调度算法的模拟实现过程。

FCFS算法是一种简单的磁盘调度算法,按照请求队列中请求的先后顺序进行磁盘访问,即先来先服务。

模拟实现过程如下:1. 创建请求队列,包括需要访问的磁盘扇区序列;2. 模拟磁盘的物理结构,并将请求队列中的扇区按照物理位置排序;3. 按照请求队列中的请求顺序,依次访问磁盘扇区,并记录磁盘访问的时间戳;4. 计算并输出磁盘访问的平均寻道时间、平均旋转延迟时间、平均传输时间等性能指标。

除了FCFS算法,还有SSTF、SCAN等磁盘调度算法。

它们的实现方法和性能指标计算方式略有不同,但实现过程的基本框架和步骤相似。

总之,磁盘调度算法的模拟实现需要先确定请求队列,模拟磁盘的物理结构,并选择合适的磁盘调度算法。

通过计算磁盘访问的各项性能指标,可以评估不同算法在不同应用场景下的优劣。

(模板)实验3:磁盘调度算法的实现

(模板)实验3:磁盘调度算法的实现

实验报告学院<系)名称:计算机与通信工程学院【实验过程记录<源程序、测试用例、测试结果及心得体会等)】实验思想:Sort函数实现对数组的排序功能;随机函数Rand<)实现随机产生要进行寻道的磁道号序列;FCFS算法,根据进程请求访问磁盘的先后次序进行调度;SSTF算法,每次访问的磁道与当前磁头所在的磁道距离最近;SCAN算法,磁头自里向外移动,下一个访问的对象在磁道之外,又满足距离最近直至更外的磁盘需要访问时,将磁鼻换为自外向里移动;CSCAN算法同上,磁头单向移动;NStepSCAN算法,将请求队列分成若干个长度为N的子队列,磁盘调度将按FCFS 算法依次处理这些子队列。

而每处理一个队列时有时按SCAN算法,对一个队列处理完后,再处理其他队列。

为磁道访问的平均时间再分配一个数列,从中选取效率最高和最低的算法;实验代码:# include <stdio.h># include <stdlib.h># include <math.h># define Start 10# define End 100# define N 2int a[10]。

void init(>{int i。

for (i=0。

i<10。

i++>{a[i]=rand(>%End。

printf("随机产生要进行寻道的磁道号序列号为:%d\n",a[i]>。

}printf("------------------------------------------------------------------------------\n\n\n">。

}void sort(>{int i,j,temp。

for(i=0。

i<10。

i++>for(int j=0。

j<9-i。

j++>if(a[j]>a[j+1]>{temp=a[j]。

磁盘调度算法的实现

磁盘调度算法的实现

实验五、磁盘调度算法的实现一、实验目的实验程序模拟先来先服务FCFS,最短寻道时间优先SSTF,SCAN和循环SCAN 算法的工作过程。

假设有n个磁道号所组成的磁道访问序列,给定开始磁道号m 和磁头移动的方向(正向或者反向),分别利用不同的磁盘调度算法访问磁道序列,给出每一次访问的磁头移动距离,计算每种算法的平均寻道长度,本程序采用随机数来产生磁道数。

二、实验要求算法所需的各种参数由输入产生(手工输入或者随机数产生)。

最后的结果要求是在运行四种算法的程序后,能够输出调度过程、平均寻道长度的正确结果。

三、实验说明(1) 先来先服务.(FCFS):这是一种简单的磁盘调度算法。

它根据进程请求访问磁盘的先后次序进行调度。

此算法的优点是公平、简单,且每个进程的请求都能依次得到处理,不会出现某一进程的请求长期得不到满足的情况。

但此算法由于未对寻道进行优化,致使平均寻道时间可能较长。

(2) 最短寻道时间优先(SSTF):该算法选择这样的进程,其要求访问的磁道与当前磁头所在的磁道距离最近,以使每次的寻道时间最短,但这种调度算法却不能保证平均寻道时间最短。

(3) 扫描算法(SCAN):SCAN算法不仅考虑到欲访问的磁道与当前磁道的距离,更优先考虑的是磁头的当前移动方向。

例如,当磁头正在自里向外移动时,SCAN算法所选择的下一个访问对象应是其欲访问的磁道既在当前磁道之外,又是距离最近的。

这样自里向外地访问,直到再无更外的磁道需要访问才将磁臂换向,自外向里移动。

这时,同样也是每次选择这样的进程来调度,即其要访问的磁道,在当前磁道之内,从而避免了饥饿现象的出现。

由于这种算法中磁头移动的规律颇似电梯的运行,故又称为电梯调度算法。

(4)循环扫描算法(CSCAN)CSCAN算法是对扫描算法的改进。

如果对磁道的访问请求是均匀分布的,当磁头到达磁盘的一端,并反向运动时落在磁头之后的访问请求相对较少。

这是由于这些磁道刚被处理,而磁盘另一端的请求密度相当高,且这些访问请求等待的时间较长,为了解决这种情况,循环扫描算法规定磁头单向移动。

磁盘调度算法实验报告

磁盘调度算法实验报告

磁盘调度算法实验报告磁盘调度算法实验报告引言:磁盘调度算法是操作系统中的重要组成部分,它负责决定磁盘上数据的访问顺序,以提高磁盘的访问效率。

在本次实验中,我们对比了三种常见的磁盘调度算法:先来先服务(FCFS)、最短寻道时间优先(SSTF)和扫描(SCAN)算法。

通过对比实验结果,我们将分析不同算法的优缺点,并对其适用场景进行探讨。

实验过程:为了模拟磁盘调度算法在实际应用中的情况,我们使用了一个包含100个磁道的磁盘模型。

我们随机生成了一组磁道请求序列,并以此作为实验数据。

首先,我们使用FCFS算法对数据进行访问,记录下访问每个磁道所需的时间。

然后,我们分别使用SSTF和SCAN算法进行同样的操作,并记录下相应的访问时间。

实验结果:经过实验,我们得到了不同调度算法的访问时间数据。

在FCFS算法中,由于它按照请求的先后顺序进行访问,所以磁头需要频繁地在磁道之间移动,导致访问时间较长。

SSTF算法则根据当前磁头位置选择最近的磁道进行访问,因此其访问时间相对较短。

而SCAN算法则将磁头从一端移动到另一端,期间访问所有请求的磁道,这样可以减少磁头的移动次数,从而提高访问效率。

讨论与分析:从实验结果可以看出,不同的磁盘调度算法在不同的场景下有着不同的优势。

FCFS算法适用于请求较少、请求之间没有明显关联的情况。

因为它简单易实现,不需要额外的计算和判断,但在高负载情况下容易导致磁头抖动,降低整体性能。

SSTF算法适用于请求之间有明显关联的情况,因为它能够选择最近的磁道进行访问,减少了磁头的移动次数。

但是,当请求分布不均匀时,SSTF算法可能会导致某些磁道长时间得不到访问。

SCAN算法则适用于对整个磁盘进行扫描的场景,因为它能够在一个方向上连续访问多个磁道,减少了磁头的移动次数。

但是,SCAN算法可能会导致某些磁道长时间得不到访问,因此在请求分布不均匀的情况下,其性能可能会受到影响。

结论:通过本次实验,我们对比了三种常见的磁盘调度算法,并分析了它们的优缺点及适用场景。

磁盘调度scan算法

磁盘调度scan算法

磁盘调度scan算法
磁盘调度算法是操作系统中用于确定磁盘读写请求执行顺序的一种算法。

SCAN (也称为Elevator)算法是磁盘调度算法中的一种,它模拟了电梯的上下运行过程。

SCAN算法的基本思想是,磁头在磁盘上沿着一个方向移动,直到到达磁盘的边界,然后返回到起始位置,继续移动。

在移动的过程中,磁头会按照请求队列中的请求顺序进行读写操作。

具体实现过程如下:
1. 确定磁头初始位置并指定一个移动方向。

2. 按照确定的移动方向,扫描磁盘,并将请求队列中需要访问的块分为两部分:在磁头当前位置同一方向上的块和在磁头当前位置反方向上的块。

3. 按照确定的移动方向,依次访问同一方向上的块,直到到达边界。

4. 到达边界后,改变移动方向并继续扫描,访问反方向上的块。

5. 重复步骤3和步骤4,直到所有的块都被访问完毕。

SCAN算法的优点是能够避免出现某些块长时间得不到访问的情况,同时也能够提供较高的磁盘访问速度。

然而,对于某些场景下的请求序列,SCAN算法可能会导致一些块的访问延迟较高。

为了解决这个问题,SCAN算法的改进版本如
C-SCAN(Circular SCAN)算法和LOOK算法被提出。

实验七 磁盘调度算法的实现

实验七 磁盘调度算法的实现

实验七磁盘调度算法的实现
1、实验目的
(1)通过编写和调试磁盘调度算法的模拟程序以加深对磁盘调度算法的理解;
(2)熟悉FCFS磁盘调度算法的原理;
(3)了解磁盘中存取数据过程。

2、实验要求
编写并调试一个磁盘调度模拟程序,采用FCFS算法。

已知进程号及进程先后要访问的磁道数、磁头当前位置,要求使用FCFS算法输出磁头移动的磁道数和平均寻道数。

3、算法描述
先来先服务(FCFS,First Come First Served),这是一种最简单的磁盘调度算法。

它根据进程请求访问磁盘的先后次序进行调度。

此算法的优点是公平、简单,且每个进程的请求都能依次地得到处理,不会出现某一进程的请求长期得不到满足的情况。

下图示出了有9个进程先后提出磁盘I/O请求时,当前磁道为100,按FCFS算法进行调度的情况。

(FCFS算法平均寻道距离较大,故FCFS算法仅适用于请求磁盘I/O的进程数目较少的场合。


4、源程序代码(同学们自己给出)
附加:课间或课后完成内容
(1)其它调度算法如SSTF的实现;(2)画出磁头的移动轨迹图。

模拟实现磁盘调度算法

模拟实现磁盘调度算法

模拟实现磁盘调度算法磁盘调度算法是操作系统中用于确定磁盘驱动器上的读写操作顺序的一种方法。

磁盘调度算法的目标是尽量提高磁盘的利用率和性能,减少磁盘的寻道时间和旋转延迟。

在实现磁盘调度算法之前,让我们先了解一些与磁盘调度相关的概念。

1.磁盘寻道时间:磁盘读/写头从当前磁道移动到目标磁道所需的时间。

寻道时间越短,磁盘访问速度越快。

2.磁盘旋转延迟:磁盘读/写头等待目标扇区旋转到读/写位置所需的时间。

旋转延迟取决于磁盘转速,常用转速为7200转/分钟或更高。

3.请求队列:保存待执行的读/写请求的队列。

4.当前磁道位置:磁盘读/写头当前所在的磁道。

5.下一个请求:即将被执行的读/写请求。

下面我们将模拟实现三种常见的磁盘调度算法:先来先服务(FCFS)、最短寻道时间优先(SSTF)和电梯(LOOK)算法。

1.先来先服务(FCFS)算法:FCFS算法按照请求的先后顺序进行磁盘访问,即先到先服务。

当程序提交读/写请求时,请求按照提交的顺序加入到请求队列中,然后按照队列中的顺序依次执行。

这种算法简单直接,但可能导致磁盘寻道时间较长。

缺点:容易产生“响应时间过长”和“饥饿”现象。

2.最短寻道时间优先(SSTF)算法:SSTF算法每次选择与当前磁头位置最近的磁道进行磁盘访问。

算法会根据当前磁头位置和请求队列中的请求位置计算寻道时间,选择寻道时间最短的请求作为下一个请求。

这种算法可以找到离当前磁头位置最近的请求,有效减少寻道时间。

但可能会导致一些请求一直等待。

3.电梯(LOOK)算法:LOOK算法模拟了电梯的运行方式。

它按照一个方向来执行读/写请求,直到请求队列中没有该方向上的请求,然后改变运行方向,继续执行另一方向上的请求。

LOOK算法是一种比较公平的磁盘调度算法,可以减少寻道时间和旋转延迟。

在实际的磁盘调度算法实现中,我们通常需要实现请求队列的管理、寻道时间计算、磁头位置更新等功能。

可以使用队列来管理请求队列,使用寻道算法计算寻道时间,使用函数来模拟磁头位置的更新。

磁盘调度算法实验要求及算法

磁盘调度算法实验要求及算法

磁盘调度算法编程序实现下述磁盘调度算法,并求出每种算法的平均寻道长度。

设计要求:(1)能够输入程序要访问的磁道序列和磁头当前所在的磁道数。

(2)可以选择某磁盘调度算法(先来先服务算法、最短寻道时间优先算法、扫描算法和循环扫描算法)。

(3)能够以下图形式显示磁盘调度顺序和平均寻道长度。

/*FCFS 先来先服务:根据进程请求访问磁盘的先后次序进行调度;SSTF 最短寻道时间优先:其要求访问的磁头与当前磁头所在的磁道距离最近,以使每次的寻道时间最短;SCAN 扫描算法:CSCAN 循环扫描算法:*/#include<iostream>using namespace std;#include<math.h>#define maxsize 1000int *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;float ave; //平均寻道长度cout<<"磁盘请求序列为:";for( i=0;i<m;i++) //按先来先服务的策略输出磁盘请求序列{cout<<cidao[i]<<" ";}cout<<endl;cout<<"请输入当前的磁道号:";cin>>now ;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) //磁道号数组,个数为m{int k=1;int now,l,r;int i,j,sum=0;float ave;cidao=bubble(cidao,m); //调用冒泡排序算法排序从小到大cout<<"请输入当前的磁道号:";cin>>now;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) //确定当前磁道在已排的序列中的位置,后面的算法都用到了,可以直接复制后少量修改,节省时间。

C语言磁盘调度算法

C语言磁盘调度算法

C语言磁盘调度算法1.FCFS(先来先服务)算法:FCFS算法按照磁盘请求的顺序进行调度,即按照先来先服务的原则,先处理先到达磁盘的请求。

它的实现非常简单,只需要按照请求的顺序进行访问即可。

C代码示例:```c#include <stdio.h>#include <stdlib.h>int fcfs(int start, int *requests, int n)int i;int total = abs(start - requests[0]);for (i = 1; i < n; i++)total += abs(requests[i] - requests[i - 1]);}return total;int maiint start = 50;int requests[] = { 82,170, 43, 140, 24, 16, 190};int n = sizeof(requests) / sizeof(requests[0]);int total = fcfs(start, requests, n);printf("Total head movement: %d\n", total);return 0;```2.SSTF(最短寻道时间优先)算法:SSTF算法每次都选择离当前磁道最近的请求进行处理,以减少寻道时间。

具体实现时,需要计算每个请求到当前磁道的距离,并选择最小的距离进行处理。

C代码示例:```c#include <stdio.h>#include <stdlib.h>int sstf(int start, int *requests, int n)int i, j;int total = 0;int visited[n];for (i = 0; i < n; i++)visited[i] = 0;}int cur = start;for (i = 0; i < n; i++)int minDist = __INT_MAX__;int index = -1;for (j = 0; j < n; j++)if (!visited[j])int dist = abs(cur - requests[j]); if (dist < minDist)minDist = dist;index = j;}}}total += minDist;visited[index] = 1;cur = requests[index];}return total;int maiint start = 50;int requests[] = { 82,170, 43, 140, 24, 16, 190};int n = sizeof(requests) / sizeof(requests[0]);int total = sstf(start, requests, n);printf("Total head movement: %d\n", total);return 0;```3.SCAN(电梯算法)算法:SCAN算法模拟电梯的运行方式,先向一个方向扫描直到末尾,然后再改变方向向另一个方向扫描,以此往复。

操作系统实验磁盘调度算法实验报告

操作系统实验磁盘调度算法实验报告

操作系统实验磁盘调度算法实验报告一.实验目的本实验旨在通过磁盘调度算法的模拟,探究不同调度算法对磁盘访问性能的影响,了解各种算法的特点和适用场景。

二.实验方法本实验通过编写磁盘调度模拟程序,实现了三种常见的磁盘调度算法:FCFS(先来先服务)、SSTF(最短寻找时间优先)和SCAN(扫描算法)。

实验中使用C语言编程语言,并通过随机生成的队列模拟磁盘访问请求序列。

三.实验过程1.FCFS(先来先服务)算法FCFS算法是一种非常简单的调度算法,它按照请求到达的顺序进行调度。

在实验中,我们按照生成的请求队列顺序进行磁盘调度,记录每次磁头移动的距离。

2.SSTF(最短寻找时间优先)算法SSTF算法是一种动态选择离当前磁头位置最近的磁道进行调度的算法。

在实验中,我们根据当前磁头位置和请求队列中的磁道位置,选择距离最近的磁道进行调度。

然后将该磁道从请求队列中移除,并记录磁头移动的距离。

3.SCAN(扫描算法)算法SCAN算法是一种按照一个方向进行扫描的算法,它在每个方向上按照磁道号的顺序进行调度,直到扫描到最边缘磁道再折返。

在实验中,我们模拟磁头从一个端点开始,按照磁道号从小到大的顺序进行调度,然后再折返。

记录磁头移动的距离。

四.实验结果与分析我们通过生成不同数量的请求队列进行实验,记录每种算法的磁头移动距离,并进行比较。

实验结果显示,当请求队列长度较小时,FCFS算法的磁头移动距离较短,因为它按照请求到达的顺序进行调度,无需寻找最短的磁道。

然而,当请求队列长度较大时,FCFS算法的磁头移动距离会显著增加,因为它不能根据距离进行调度。

SSTF算法相对于FCFS算法在磁头移动距离上有了明显改进。

SSTF算法通过选择最短的寻找时间来决定下一个访问的磁道,因此可以减少磁头的移动距离。

然而,在请求队列中存在少量分散的请求时,SSTF算法可能会产生扇区的服务死锁现象,导致一些磁道无法及时访问。

SCAN算法通过扫描整个磁盘来进行调度,有效解决了FCFS算法有可能导致的服务死锁问题。

磁盘调度算法的实现

磁盘调度算法的实现

一、实验目的:通过模拟设计磁盘驱动调度程序,观察驱动调度程序的动态运行过程,理解和掌握磁盘驱动调度的职能,并比较各种算法的调度结果。

二、实验容:要求设计主界面能灵活选择某算法,且以下算法都要实现。

(1)先来先服务算法(FCFS)(2)最短寻道时间优先算法(SSTF)(3)扫描算法(SCAN)(4)循环扫描算法(CSCAN)三、实验步骤(1)需求分析:本设计中可在运行时随机产生一个请求序列,先把序列排序,以方便找到下一个要寻找的磁道。

要求用户选择磁头移动方向,向里和向外移动用1和0表示,若输入值不为0或1,则报错。

选择某种调度算法后,要求显示调度顺序和移动的总磁道数。

(2)详细设计:void FCFS(int a[],int n);//先来先服务算法void SSTF(int a[],int n);//最短寻道时间算法void SCAN(int a[],int n);//扫描算法void CSCAN(int a[],int n);//循环扫描算法int main(){int n;//磁道的个数int s;//功能号cout<<"请输入磁道的个数:"<<endl;cin>>n;int *a=new int[n];cout<<"生成随机磁道号..."<<endl;srand((unsigned)time(NULL));for(int i=0;i<n;i++){a[i]=(rand()%100)+1;cout<<a[i]<<" ";}cout<<endl;while(1){ cout<<endl;cout<<"1、先来先服务算法(FCFS)"<<endl;cout<<"2、最短寻道时间算法(SSTF)"<<endl;cout<<"3、扫描算法(SCAN)"<<endl;cout<<"4、循环扫描算法(CSCAN)"<<endl;cout<<"0、退出"<<endl;cout<<endl;cout<<"请选择功能号:";cin>>s;if(s>4){cout<<"输入有误!"<<endl;}else{switch(s){ case 0: exit(0);break ;case 1:FCFS(a,n); break;case 2:SSTF(a, n);break;case 3:SCAN(a, n);break;case 4:CSCAN(a,n);break;}}}return 0;}实验源代码#include<iostream>#include<ctime>using namespace std;void FCFS(int a[],int n);void SSTF(int a[],int n);void SCAN(int a[],int n);void CSCAN(int a[],int n);int main(){int n;//磁道的个数int s;//功能号cout<<"请输入磁道的个数:"<<endl;cin>>n;int *a=new int[n];cout<<"生成随机磁道号..."<<endl;srand((unsigned)time(NULL));for(int i=0;i<n;i++){a[i]=(rand()%100)+1;cout<<a[i]<<" ";}cout<<endl;while(1){ cout<<endl;cout<<"1、先来先服务算法(FCFS)"<<endl; cout<<"2、最短寻道时间算法(SSTF)"<<endl; cout<<"3、扫描算法(SCAN)"<<endl;cout<<"4、循环扫描算法(CSCAN)"<<endl;cout<<"0、退出"<<endl;cout<<endl;cout<<"请选择功能号:";cin>>s;if(s>4){cout<<"输入有误!"<<endl;}else{switch(s){ case 0: exit(0);break ; case 1:FCFS(a,n); break;case 2:SSTF(a, n);break;case 3:SCAN(a, n);break;case 4:CSCAN(a,n);break;}}}return 0;}//先来先服务调度算法(FCFS)void FCFS(int a[],int n){int sum=0,j,i,first=0,now;cout<<"请输入当前磁道号:";cin>>now;//确定当前磁头所在位置cout<<"磁盘调度顺序为:"<<endl;for( i=0;i<n;i++)//按访问顺序输出磁道号{cout<<a[i]<<" ";}//计算sumfor(i=0,j=1;j<n;i++,j++){first+=abs(a[j]-a[i]);//外围磁道与最里面磁道的距离}sum+=first+abs(now-a[0]);cout<<endl;cout<<"移动的总磁道数: "<<sum<<endl;}//最短寻道时间算法(SSTF)void SSTF(int a[],int n){int temp;int k=1;int now,l,r;int i,j,sum=0;//将磁道号按递增排序for(i=0;i<n;i++)for(j=i+1;j<n;j++){if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}cout<<"按递增顺序排好的磁道:"<<endl;for( i=0;i<n;i++){cout<<a[i]<<" ";//输出排好的磁道顺序}cout<<endl;cout<<"请输入当前的磁道号:";cin>>now;//确定当前磁头所在位置cout<<"磁盘调度顺序为:"<<endl;if(a[n-1]<=now)//当前磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--)cout<<a[i]<<" ";sum=now-a[0];}elseif(a[0]>=now)//当前磁头位置小于最里欲访问磁道{for(i=0;i<n;i++)cout<<a[i]<<" ";sum=a[n-1]-now;}else{while(a[k]<now)//确定当前磁道在已排的序列中的位置{k++;}l=k-1;//在磁头位置的前一个欲访问磁道r=k;//磁头欲访问磁道while((l>=0)&&(r<n)){if((now-a[l])<=(a[r]-now))//选择离磁头近的磁道 {cout<<a[l]<<" ";sum+=now-a[l];now=a[l];l=l-1;}else{cout<<a[r]<<" ";sum+=a[r]-now;now=a[r];r=r+1;}}if(l=-1)//磁头位置里侧的磁道已访问完{for(j=r;j<n;j++)//访问磁头位置外侧的磁道{cout<<a[j]<<" ";}sum+=a[n-1]-a[0];}if(r==n)//磁头位置外侧的磁道已访问完{for(j=k-1;j>-1;j--) //访问磁头位置里侧的磁道{cout<<a[j]<<" ";}sum+=a[n-1]-a[0];}}cout<<endl;cout<<"移动的总道数:"<<sum<<endl;}//扫描算法(SCAN)void SCAN(int a[],int n){int temp;int k=1;int now,l,r;int i,j,sum=0;for(i=0;i<n;i++)//对访问磁道按由小到大顺序排列输出 for(j=i+1;j<n;j++){if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}cout<<"按递增顺序排好的磁道:"<<endl;for( i=0;i<n;i++){cout<<a[i]<<" ";}cout<<endl;cout<<"请输入当前的磁道号:";cin>>now;//以下算法确定磁道访问顺序if(a[n-1]<=now) //磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--)cout<<a[i]<<" ";sum=now-a[0];}elseif(a[0]>=now) //磁头位置小于最里欲访问磁道{for(i=0;i<n;i++)cout<<a[i]<<" ";sum=a[n-1]-now;}else //磁头位置在最里侧磁道与最外侧磁道之间{ int d;while(a[k]<now){ //确定当前磁道在已排的序列中的位置k++;}l=k-1;//在磁头位置的前一个欲访问磁道r=k; //磁头欲访问磁道cout<<"请输入当前磁头移动的方向 (0 表示向,1表示向外) : "; cin>>d; //确定磁头访问的方向cout<<"磁盘调度顺序为:";if(d==0||d==1){if(d==0) //磁头向{for(j=l;j>=0;j--){cout<<a[j]<<" ";}for(j=r;j<n;j++){cout<<a[j]<<" ";}sum=now-2*a[0]+a[n-1];}if(d==1) //磁头向外{for(j=r;j<n;j++){cout<<a[j]<<" ";}for(j=l;j>=0;j--){cout<<a[j]<<" ";}sum=2*a[n-1]-now-a[0];}}elsecout<<"请输入0或1!"<<endl;}cout<<endl;cout<<"移动的总道数: "<<sum<<endl;}//循环扫描算法(CSCAN)void CSCAN(int a[],int n){int temp;int now,l,r;int i,j,sum=0;int k=1;for(i=0;i<n;i++)//对访问磁道按由小到大顺序排列输出for(j=i+1;j<n;j++){if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}cout<<"按递增顺序排好的磁道:"<<endl;for( i=0;i<n;i++){cout<<a[i]<<" ";}cout<<endl;cout<<"请输入当前的磁道号:";cin>>now;//确定当前磁道号if(a[n-1]<=now)//磁头位置大于最外围欲访问磁道{for(i=0;i<n;i++)cout<<a[i]<<" ";sum=now-2*a[0]+a[n-1];}elseif(a[0]>=now)//磁头位置小于最里欲访问磁道{for(i=0;i<n;i++)cout<<a[i]<<" ";sum=a[n-1]-now;}else //磁头位置在最里侧磁道与最外侧磁道之间{ int d;while(a[k]<now){k++;}l=k-1;//在磁头位置的前一个欲访问磁道r=k; //磁头欲访问磁道cout<<"请输入当前磁头移动的方向 (0 表示向,1表示向外) : "; cin>>d; //确定磁头访问的方向cout<<"磁盘调度顺序为:";if(d==0||d==1){if(d==1) //磁头向外侧访问{for(j=r;j<n;j++)//先访问外侧磁道再转向最里欲访问磁道{cout<<a[j]<<" ";}for(j=0;j<r;j++){cout<<a[j]<<" ";}sum=2*a[n-1]-now-2*a[0]+a[l];}if(d==0) //磁头向侧访问 {for(j=r-1;j>=0;j--){cout<<a[j]<<" ";}for(j=n-1;j>=r;j--)//{cout<<a[j]<<" ";}sum=2*a[n-1]-2*a[0]+now-a[r];}}elsecout<<"请输入0或1!";}cout<<endl;cout<<"移动的总道数: "<<sum<<endl;}(3)测试结果:1.先来先服务算法(FCFS)测试结果2.最短寻道时间算法(SSTF)测试结果3.循环扫描算法(SCAN)测试结果4.循环扫描算法(CSCAN)测试结果四、设计总结:此次设计基本完成了本实验所规定的功能,但是还不够完善,很多东西做的不够好,程序不够完善和严谨。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

《操作系统--磁盘调度算法》实验报告姓名:范学升学号:1001050903班级:电科10-1班专业:电子信息科学与技术一、实验目的:通过模拟设计磁盘驱动调度程序,观察驱动调度程序的动态运行过程,理解和掌握磁盘驱动调度的职能,并比较各种算法的调度结果。

二、实验内容:要求设计主界面能灵活选择某算法,且实现以下算法:(1)先来先服务算法(FCFS)(2)最短寻道时间优先算法(SSTF)(3)扫描算法(SCAN)(4)循环扫描算法(CSCAN)三、实验步骤详细设计:源代码#include<iostream>#include<ctime>using namespace std;void FCFS(int a[],int n);void SSTF(int a[],int n);void SCAN(int a[],int n);void CSCAN(int a[],int n);int main(){int n;//磁道的个数int s;//功能号cout<<"请输入磁道的个数:"<<endl;cin>>n;int *a=new int[n];cout<<"生成随机磁道号..."<<endl;srand((unsigned)time(NULL));for(int i=0;i<n;i++){a[i]=(rand()%100)+1;cout<<a[i]<<" ";}cout<<endl;while(1){ cout<<endl;cout<<"1、先来先服务算法(FCFS)"<<endl; cout<<"2、最短寻道时间算法(SSTF)"<<endl; cout<<"3、扫描算法(SCAN)"<<endl;cout<<"4、循环扫描算法(CSCAN)"<<endl;cout<<"0、退出"<<endl;cout<<endl;cout<<"请选择功能号:";cin>>s;if(s>4){cout<<"输入有误!"<<endl;}else{switch(s){ case 0: exit(0);break ; case 1:FCFS(a,n); break;case 2:SSTF(a, n);break;case 3:SCAN(a, n);break;case 4:CSCAN(a,n);break;}}}return 0;}//先来先服务调度算法(FCFS)void FCFS(int a[],int n){int sum=0,j,i,first=0,now;cout<<"请输入当前磁道号:";cin>>now;//确定当前磁头所在位置cout<<"磁盘调度顺序为:"<<endl;for( i=0;i<n;i++)//按访问顺序输出磁道号{cout<<a[i]<<" ";}//计算sumfor(i=0,j=1;j<n;i++,j++){first+=abs(a[j]-a[i]);//外围磁道与最里面磁道的距离}sum+=first+abs(now-a[0]);cout<<endl;cout<<"移动的总磁道数: "<<sum<<endl;}最短寻道时间算法(SSTF)void SSTF(int a[],int n){int temp;int k=1;int now,l,r;int i,j,sum=0;//将磁道号按递增排序for(i=0;i<n;i++)for(j=i+1;j<n;j++){if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}cout<<"按递增顺序排好的磁道:"<<endl;for( i=0;i<n;i++){cout<<a[i]<<" ";//输出排好的磁道顺序}cout<<endl;cout<<"请输入当前的磁道号:";cin>>now;//确定当前磁头所在位置cout<<"磁盘调度顺序为:"<<endl;if(a[n-1]<=now)//当前磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--)cout<<a[i]<<" ";sum=now-a[0];}elseif(a[0]>=now)//当前磁头位置小于最里欲访问磁道{for(i=0;i<n;i++)cout<<a[i]<<" ";sum=a[n-1]-now;}else{while(a[k]<now)//确定当前磁道在已排的序列中的位置{k++;}l=k-1;//在磁头位置的前一个欲访问磁道r=k;//磁头欲访问磁道while((l>=0)&&(r<n)){if((now-a[l])<=(a[r]-now))//选择离磁头近的磁道 {cout<<a[l]<<" ";sum+=now-a[l];now=a[l];l=l-1;}else{cout<<a[r]<<" ";sum+=a[r]-now;now=a[r];r=r+1;}}if(l=-1)//磁头位置里侧的磁道已访问完{for(j=r;j<n;j++)//访问磁头位置外侧的磁道{cout<<a[j]<<" ";}sum+=a[n-1]-a[0];}if(r==n)//磁头位置外侧的磁道已访问完{for(j=k-1;j>-1;j--) //访问磁头位置里侧的磁道{cout<<a[j]<<" ";}sum+=a[n-1]-a[0];}}cout<<endl;cout<<"移动的总道数:"<<sum<<endl;}扫描算法(SCAN)void SCAN(int a[],int n){int temp;int k=1;int now,l,r;int i,j,sum=0;for(i=0;i<n;i++)//对访问磁道按由小到大顺序排列输出 for(j=i+1;j<n;j++){if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}cout<<"按递增顺序排好的磁道:"<<endl;for( i=0;i<n;i++){cout<<a[i]<<" ";}cout<<endl;cout<<"请输入当前的磁道号:";cin>>now;//以下算法确定磁道访问顺序if(a[n-1]<=now) //磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--)cout<<a[i]<<" ";sum=now-a[0];}elseif(a[0]>=now) //磁头位置小于最里欲访问磁道{for(i=0;i<n;i++)cout<<a[i]<<" ";sum=a[n-1]-now;}else //磁头位置在最里侧磁道与最外侧磁道之间{ int d;while(a[k]<now){ //确定当前磁道在已排的序列中的位置k++;}l=k-1;//在磁头位置的前一个欲访问磁道r=k; //磁头欲访问磁道cout<<"请输入当前磁头移动的方向 (0 表示向内,1表示向外) : "; cin>>d; //确定磁头访问的方向cout<<"磁盘调度顺序为:";if(d==0||d==1){if(d==0) //磁头向内{for(j=l;j>=0;j--){cout<<a[j]<<" ";}for(j=r;j<n;j++){cout<<a[j]<<" ";}sum=now-2*a[0]+a[n-1];}if(d==1) //磁头向外{for(j=r;j<n;j++){cout<<a[j]<<" ";}for(j=l;j>=0;j--){cout<<a[j]<<" ";}sum=2*a[n-1]-now-a[0];}}elsecout<<"请输入0或1!"<<endl;}cout<<endl;cout<<"移动的总道数: "<<sum<<endl;}循环扫描算法(CSCAN)void CSCAN(int a[],int n){int temp;int now,l,r;int i,j,sum=0;int k=1;for(i=0;i<n;i++)//对访问磁道按由小到大顺序排列输出 for(j=i+1;j<n;j++){if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}cout<<"按递增顺序排好的磁道:"<<endl;for( i=0;i<n;i++){cout<<a[i]<<" ";}cout<<endl;cout<<"请输入当前的磁道号:";cin>>now;//确定当前磁道号if(a[n-1]<=now)//磁头位置大于最外围欲访问磁道{for(i=0;i<n;i++)cout<<a[i]<<" ";sum=now-2*a[0]+a[n-1];}elseif(a[0]>=now)//磁头位置小于最里欲访问磁道{for(i=0;i<n;i++)cout<<a[i]<<" ";sum=a[n-1]-now;}else //磁头位置在最里侧磁道与最外侧磁道之间{ int d;while(a[k]<now){k++;}l=k-1;//在磁头位置的前一个欲访问磁道r=k; //磁头欲访问磁道cout<<"请输入当前磁头移动的方向 (0 表示向内,1表示向外) : "; cin>>d; //确定磁头访问的方向cout<<"磁盘调度顺序为:";if(d==0||d==1){if(d==1) //磁头向外侧访问{for(j=r;j<n;j++)//先访问外侧磁道再转向最里欲访问磁道{cout<<a[j]<<" ";}for(j=0;j<r;j++){cout<<a[j]<<" ";}sum=2*a[n-1]-now-2*a[0]+a[l];}if(d==0) //磁头向内侧访问{for(j=r-1;j>=0;j--){cout<<a[j]<<" ";}for(j=n-1;j>=r;j--)//{cout<<a[j]<<" ";}sum=2*a[n-1]-2*a[0]+now-a[r];}}elsecout<<"请输入0或1!";}cout<<endl;cout<<"移动的总道数: "<<sum<<endl;}(3)测试结果:1.先来先服务算法(FCFS)测试结果2.最短寻道时间算法(SSTF)测试结果3.循环扫描算法(SCAN)测试结果104.循环扫描算法(CSCAN )测试结果。

相关文档
最新文档