磁盘调度算法实验报告

合集下载

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

操作系统磁盘调度算法实验报告及代码一、实验目的通过实验掌握磁盘调度算法的实现过程，了解各种不同磁盘调度算法的特点和优缺点，并比较它们的性能差异。

二、实验原理磁盘调度是操作系统中的重要内容，其主要目的是提高磁盘的利用率和系统的响应速度。

常见的磁盘调度算法有：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算法通过选择离当前磁道最近的请求进行处理，能够减少平均寻道时间，提高磁盘性能。

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

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

操作系统课程设计磁盘调度报告

题目：磁盘调度一．设计目的本课程设计是学习完《计算机操作系统》课程后，进行的一次全面的综合训练，通过课程设计，我们更好地掌握操作系统的原理及实现方法,加深对操作系统基础理论和重要算法的理解，加强了动手能力。

二．课程设计内容和要求编程序实现下述磁盘调度算法,并求出每种算法的平均寻道长度，要求设计主界面以灵活选择某算法，且以下算法都要实现：1、先来先服务算法（FCFS）2、最短寻道时间优先算法（SSTF）3、扫描算法（SCAN）4、循环扫描算法（CSCAN）三．算法及数据结构3.1算法的总体思想设备的动态分配算法与进程调度相似，也是基于一定的分配策略的。

常用的分配策略有先请求先分配、优先级高者先分配等策略。

在多道程序系统中，低效率通常是由于磁盘类旋转设备使用不当造成的。

操作系统中，对磁盘的访问要求来自多方面，常常需要排队。

这时，对众多的访问要求按一定的次序响应，会直接影响磁盘的工作效率，进而影响系统的性能。

访问磁盘的时间因子由3部分构成，它们是查找（查找磁道）时间、等待（旋转等待扇区）时间和数据传输时间，其中查找时间是决定因素。

因此，磁盘调度算法先考虑优化查找策略，需要时再优化旋转等待策略。

平均寻道长度（L）为所有磁道所需移动距离之和除以总的所需访问的磁道数（N），即：L=（M1+M2+……+Mi+……+MN）/N其中Mi为所需访问的磁道号所需移动的磁道数。

启动磁盘执行输入输出操作时，要把移动臂移动到指定的柱面，再等待指定扇区的旋转到磁头位置下，然后让指定的磁头进行读写，完成信息传送。

因此，执行一次输入输出所花的时间有：寻找时间——磁头在移动臂带动下移动到指定柱面所花的时间。

延迟时间——指定扇区旋转到磁头下所需的时间。

传送时间——由磁头进程读写完成信息传送的时间。

其中传送信息所花的时间，是在硬件设计就固定的。

而寻找时间和延迟时间是与信息在磁盘上的位置有关。

为了减少移动臂进行移动花费的时间，每个文件的信息不是按盘面上的磁道顺序存放满一个盘面后，再放到下一个盘面上。

实验报告六磁盘调度算法

实验报告六磁盘调度算法班级：软技2班学号：201467003084 姓名：刘道林一．实验内容：熟悉磁盘的结构以及磁盘的驱动调度算法的模拟，编程实现简单常用的磁盘驱动调度算法先来先服务（FIFO）、电梯调度算法、最短寻找时间优先算法、扫描（双向扫描）算法、单向扫描（循环扫描）算法等。

编程只需实现两个算法。

题目可以选取教材或习题中的相关编程实例。

编程语言建议采用c/c++或Java。

模拟程序鼓励采用随机数技术、动态空间分配技术，有条件的最好能用图形界面展现甚至用动画模拟。

实验性质：验证型。

二．实验目的和要求1）掌握使用一门语言进行磁盘驱动调度算法的模拟；2）编写程序将磁盘驱动调度算法的过程和结果能以较简明直观的方式展现出来。

三．实验原理、方法和步骤1. 实验原理磁盘驱动调度对磁盘的效率有重要影响。

磁盘驱动调度算法的好坏直接影响辅助存储器的效率，从而影响计算机系统的整体效率。

常用的磁盘驱动调度算法有：最简单的磁盘驱动调度算法是先入先出（FIFO）法。

这种算法的实质是，总是严格按时间顺序对磁盘请求予以处理。

算法实现简单、易于理解并且相对公平，不会发生进程饿死现象。

但该算法可能会移动的柱面数较多并且会经常更换移动方向，效率有待提高。

最短寻找时间优先算法：总是优先处理最靠近的请求。

该算法移动的柱面距离较小，但可能会经常改变移动方向，并且可能会发生进程饥饿现象。

电梯调度：总是将一个方向上的请求全部处理完后，才改变方向继续处理其他请求。

扫描（双向扫描）：总是从最外向最里进行扫描，然后在从最里向最外扫描。

该算法与电梯调度算法的区别是电梯调度在没有最外或最里的请求时不会移动到最外或最里柱面，二扫描算法总是移到最外、最里柱面。

两端的请求有优先服被务的迹象。

循环扫描（单向扫描）：从最外向最里进行柱面请求处理，到最里柱面后，直接跳到最外柱面然后继续向里进行处理。

该算法与扫描算法的区别是，回来过程不处理请求，基于这样的事实，因为里端刚被处理。

磁盘调度算法实验设计报告

实验五磁盘调度算法班级： 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) //确定当前磁道在已排的序列中的位置，后面的算法都用到了，可以直接复制后少量修改，节省时间。

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

磁盘调度实验报告

操作系统实验报告磁盘调度实验六：磁盘调度算法一．实验目的复习模拟实现一种磁盘调度算法，进一步加深对磁盘调度效率的理解。

二．实验属性该实验为设计性实验。

三．实验仪器设备及器材普通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。

磁盘调度算法实验小结

磁盘调度算法实验小结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算法在局部请求密集的情况下表现较好，适用于需要快速响应局部请求的情况。

实验七磁盘调度

实验七磁盘调度一、实验目的：磁盘是高速、大容量、旋转型、可直接存取的存储设备。

它作为计算机系统的辅助存储器，担负着繁重的输入输出工作，在现代计算机系统中往往同时会有若干个要求访问磁盘的输入输出要求。

系统可采用一种策略，尽可能按最佳次序执行访问磁盘的请求。

由于磁盘访问时间主要受寻道时间T的影响，为此需要采用合适的寻道算法，以降低寻道时间。

本实验要求模拟设计一个磁盘调度程序，观察调度程序的动态运行过程。

通过实验来理解和掌握磁盘调度的职能。

二、实验内容：分别模拟如下电梯调度算法，对磁盘进行移臂操作：●先来先服务算法●最短寻道优先算法●电梯算法三、实验要求：1、假设磁盘只有一个盘面，并且磁盘是可移动头磁盘。

2、磁盘是可供多个进程共享的存储设备，但一个磁盘每个时刻只能为一个进程服务。

当有进程在访问某个磁盘时，其它想访问该磁盘的进程必须等待，直到磁盘一次工作结束。

当有多个进程提出输入输出请求而处于等待状态时，可用磁盘调度算法从若干个等待访问者中选择一个进程，让它访问磁盘。

为此设置“驱动调度”进程。

3、由于磁盘与处理器是并行工作的，所以当磁盘在为一个进程服务时，占有处理器的其它进程可以提出使用磁盘（这里我们只要求访问磁道），即动态申请访问磁道，为此设置“接受请求”进程。

4、为了模拟以上两个进程的执行，可以考虑使用随机数来确定二者的允许顺序，参考程序流程图。

5、“接受请求”进程建立一张“进程请求I/O”表，指出等待访问磁盘的进程要求访问的磁道，表的格式如下：6、磁盘调度的功能是查“请求I/O”表，当有等待访问的进程时，按磁盘调度算法从中选择一个等待访问的进程，按其指定的要求访问磁道。

流程图中的“初始化”工作包括：初始化“请求I/O”表，设置当前移臂方向；当前磁道号。

并且假设程序运行前“请求I/O”表中已有若干进程（4～8个）申请访问相应磁道。

四、程序流程图：五．参考程序代码：#include <stdlib.h>#include<iostream.h>#include<cmath>typedef struct node{int data;struct node *next;}Node;void main(){void fcfs(Node *,int,int);//声明先来先服务函数FCFSvoid sstf(Node *,int,int);//声明最短寻道时间优先函数SSTFvoid scan(Node *,int,int);//声明扫描函数SCANvoid print(Node *); //输出链表函数Node *head,*p,*q; //建立一个链表int it,c=0,f,s; //c为链表长度,f是开始的磁道号,s是选择哪个算法head=(Node *)malloc(sizeof(Node));head->next=NULL;q=head;cout<<" /**************磁盘调度算法***************/"<<endl;cout<<endl;cout<<"新建一个单链表,以0作为结束标志:";cin>>it;while(it!=0){p=(Node *)malloc(sizeof(Node));p->next=NULL;p->data=it;q->next=p;q=p;cin>>it;c++;}cout<<"从几号磁道开始:";cin>>f; //f为磁道号print(head);cout<<"链表长度为:"<<c<<endl;cout<<"1、先来先服务算法FCFS"<<endl;cout<<"2、最短寻道时间优先算法SSTF"<<endl;cout<<"3、电梯调度算法(扫描算法SCAN)"<<endl;cout<<"0、退出"<<endl;cout<<"请选择:";cin>>s;while(s!=0){switch(s){case 1:cout<<"你选择了:先来先服务算法FCFS"<<endl;fcfs( head,c,f);break;case 2:cout<<"你选择了:最短寻道时间优先算法SSTF"<<endl;sstf( head,c,f);break;case 3:cout<<"你选择了:电梯调度算法(扫描算法SCAN)"<<endl;scan( head,c,f);break;}cout<<"退出请选0,继续请选1,2,3:";cin>>s;}}/***********************************************************/ void fcfs(Node *head,int c,int f)//先来先服务算法{void print(Node *);Node *l;//*m,*n;float num=0; //num为平均寻道长度l=head->next;for(int i=0;i<c;i++){num+=abs(l->data-f);f=l->data;l=l->next;}num=num/c;cout<<"先来先服务的寻道顺序是:"<<endl;print(head);cout<<"平均寻道长度:"<<num<<endl;}/*****************************************************************/ void sstf(Node *head,int c,int f)//最短寻道时间优先算法{void print(Node *);Node *p,*q,*r,*s,*l,*m;l=(Node *)malloc(sizeof(Node));l->next=NULL;m=l;q=head;p=head->next;s=head;r=head->next;float num=0;for(int i=0;i<c;i++){int min=abs(f-r->data);for(int j=0;j<c-i-1;j++){p=p->next;q=q->next;if(abs(f-p->data)<min){min=abs(f-p->data);r=p;s=q;}}num+=abs(f-r->data);f=r->data;s->next=r->next;r->next=NULL;m->next=r;m=r;q=head;p=head->next;s=head;r=head->next;}num=num/c;cout<<"最短寻道时间优先顺序是:"<<endl;print(l);cout<<"平均寻道长度:"<<num<<endl;}/***************************************************************/ void scan(Node *head,int c,int f)//扫描算法（电梯调度算法）{void print(Node *);int min,max,i=0,j=0;float num=0;Node *p,*q,*r,*s,*m,*n,*x,*y;r=(Node *)malloc(sizeof(Node));//存放比开始磁道小的磁道r->next=NULL;s=r;m=(Node *)malloc(sizeof(Node));//存放比开始磁道大的磁道m->next=NULL;n=m;x=(Node *)malloc(sizeof(Node));x->next=NULL;y=x;q=head;p=head->next;while(p->next!=NULL){if(p->data-f>0){q->next=p->next;p->next=NULL;n->next=p;n=p;p=q->next;i++;}else{q->next=p->next;p->next=NULL;s->next=p;s=p;p=q->next;j++;}}if(p->data>=f){n->next=p;n=p;i++;}else{s->next=p;s=p;j++;}q=r; //对比开始磁道小的磁道排序p=r->next;while(q->next->next!=NULL){q=q->next;p=q->next;max=q->data;while(p->next!=NULL){if(p->data>max){max=p->data;p->data=q->data;q->data=max;max=q->data;}p=p->next;}if(p->data>max){max=p->data;p->data=q->data;q->data=max;max=q->data;}}//print(r);q=m;p=m->next;while(q->next->next!=NULL){q=q->next;p=q->next;min=q->data;while(p->next!=NULL){if(p->data<min){min=p->data;p->data=q->data;q->data=min;min=q->data;}p=p->next;}if(p->data<min){min=p->data;p->data=q->data;q->data=min;min=q->data;}}//print(m);x=m;p->next=r->next;y=x->next;while(y->next!=NULL){num+=abs(f-y->data);f=y->data;y=y->next;}num+=abs(f-y->data);num=num/c;cout<<"扫描算法的顺序是:"<<endl;print(x);cout<<"平均寻道长度为:"<<num<<endl;}/*****************************************************/void print(Node *head) //输出链表{Node *p;p=head->next;cout<<"单链表显示:";if(p==NULL){cout<<"单链表为空:";}else if(p->next==NULL){cout<<p->data;}else{while(p->next!=NULL){cout<<p->data<<"->";p=p->next;}cout<<p->data<<endl;}}六．实验结果分析1. 假设磁盘访问序列： 89，138， 73，122，41，142，56，76，读写头起始位置：95分别按照下列调度算法安排磁头服务序列，并计算寻道距离。

磁盘调度算法

磁盘调度算法实验报告六-磁盘调度算法操作系统实验报告六--磁盘调度算法08网络工程实验目的通过这次实验，加深对磁盘调度算法的理解，进一步掌握先来先服务FCFS、最短寻道时间优先SSTF、SCAN和循环SCAN算法的实现方法。

二、实验内容问题描述:设计程序模拟先来先服务FCFS、最短寻道时间优先SSTF、SCAN和循环SCAN算法的工作过程。

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

程序要求:1)利用先来先服务FCFS、最短寻道时间优先SSTF、SCAN和循环SCAN算法模拟磁道访问过程。

2)模拟四种算法的磁道访问过程，给出每个磁道访问的磁头移动距离。

3)输入:磁道个数n和磁道访问序列，开始磁道号m和磁头移动方向(对-FCFS，2-SSTF，3-SCAN，4-循环SCAN和循环SCAN算法有效)，算法选择1 SCAN。

4)输出:每种算法的平均寻道长度。

三、实验要求:1)上机前认真复习磁盘调度算法，熟悉FCFS、SSTF、SCAN和循环SCAN算法的过程;2)上机时独立编程、调试程序;3)根据具体实验要求，完成好实验报告四、实验设计流程图实验报告六-磁盘调度算法输入要访问的磁道总数、要访问的每个磁道、当前所在磁道先来先服务最短寻道时间优扫描算法循环算法FCFS 先SSTF SCAN1(由CSCAN 内向外)、SCAN2(由外向内)结束五、用户使用说明实验报告六-磁盘调度算法先输入要访问的磁道数目、各个磁道的所在号数、当前所在的磁道。

然后选择用户所需的算法。

如果选1.先来先服务(FCFS)和2.最短寻道时间优先(SSTF)或者4.循环算法(CSCAN)，那么会直接输出所得结果，如果选了3.扫描算法(SCAN) ，那还有选择磁盘的旋转方向，即向内或者向外，或者是要返回上一级菜单。

磁盘调度算法实验报告

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

磁盘调度算法

磁盘调度算法现代操作系统中，磁盘利用外层磁道容量较内层磁道大的特点，将盘面划分成若干条环带，使得同一环带内的所有磁道具有相同的扇区数。

磁头在各磁道上移动，当进程请求时根据当前磁头位置和待访问位置决定访问次序。

本实验是模拟操作系统的磁盘寻道方式，运用磁盘访问顺序的不同来设计磁盘的调度算法。

设定开始磁道号寻道范围，依据起始扫描磁道号和最大磁道号数，随机产生要进行寻道的磁道号序列。

磁道访问序列不小于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";}。

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

实验一磁盘调度算法实现一、实验目的本课程设计的目的是通过磁盘调度算法设计一个磁盘调度模拟系统,从而使磁盘调度算法更加形象化,容易使人理解,使磁盘调度的特点更简单明了,能使使用者加深对先来先服务算法、最短寻道时间优先算法、扫描算法以及循环扫描算法等磁盘调度算法的理解;二、实验内容系统主界面可以灵活选择某种算法,算法包括：先来先服务算法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 循环扫描算法运行结果图六、总结通过本次实验,学习了解磁盘调度四种调度算法先来先服务算法；最短寻道时间优先算法；扫描算法；循环扫描算法的工作原理以及四种调度算法之间的差异和共性,并且在当中发现了自己的不足,对以前所学过的知识理解得不够深刻,掌握得不够牢固,看到了自己的实践经验还是比较缺乏,实践能力还需要提高;。

实验磁盘调度算法

实验七：磁盘调度算法目录一．实验目的加深对磁盘的工作原理和调度效率的理解，掌握各种磁盘调度算法，模拟实现一种磁盘调度算法<SSTF、SCAN、CSCAN等）。

二．实验属性该实验为设计性实验。

三．实验仪器设备及器材普通PC386以上微机四．实验内容<1）先来先服务算法<FCFS）<2）最短寻道时间优先算法<SSTF）<3）扫描算法<SCAN）<4）循环扫描算法<CSCAN）五．实验步骤。

<1）先来先服务调度算法<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。

}<2）最短寻道时间算法<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]。

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

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

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

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

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

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

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

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

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

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

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

记录磁头移动的距离。

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

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

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

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

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

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

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

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

实验四磁盘调度一、实验目的：本实验要求学生模拟设计一个磁盘调度程序，观察调度程序的动态运行过程。

通过实验让学生理解和掌握磁盘调度的职能。

二、实验内容：对磁盘进行移臂操作，模拟磁盘调度算法并计算平均寻道时间三、实验准备：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) //确定当前磁道在已排的序列中的位置，后面的算法都用到了，可以直接复制后少量修改，节省时间。

磁盘调度算法

磁盘调度算法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）磁盘调度算法，要求请给出在“输出”窗口中的结果。

磁盘调度实验报告_4

磁盘调度一、实验目的:磁盘是高速、大容量、旋转型、可直接存取的存储设备。

它作为计算机系统的辅助存储器, 担负着繁重的输入输出工作, 在现代计算机系统中往往同时会有若干个要求访问磁盘的输入输出要求。

系统可采用一种策略, 尽可能按最佳次序执行访问磁盘的请求。

由于磁盘访问时间主要受寻道时间T的影响, 为此需要采用合适的寻道算法, 以降低寻道时间。

本实验要求学生模拟设计一个磁盘调度程序, 观察调度程序的动态运行过程。

通过实验让学生理解和掌握磁盘调度的职能。

二、概要设计:要求设计主界面能灵活选择某算法, 且实现以下算法：（1）先来先服务算法（FCFS）（2）最短寻道时间优先算法（SSTF）（3）扫描算法（SCAN）（4）循环扫描算法（CSCAN）本系统划分为四个模块: 先来先服务算法模块void FCFS(int array[],int m)、最短寻道时优先算法模块void SSTF(int array[],int m)、扫描算法模块void SCAN(int array[],int m)、循环扫描算法模块void SCAN(int array[],int m)设备的动态分配算法与进程调度相似, 也是基于一定的分配策略的。

常用的分配策略有先请求先分配、优先级高者先分配等策略。

在多道程序系统中, 低效率通常是由于磁盘类旋转设备使用不当造成的。

操作系统中, 对磁盘的访问要求来自多方面, 常常需要排队。

这时, 对众多的访问要求按一定的次序响应, 会直接影响磁盘的工作效率, 进而影响系统的性能访问磁盘的时间因子由3部分构成, 它们是：查找（查找磁道）时间、等待（旋转等待扇区）时间和数据传输时间, 其中查找时间是决定因素。

因此, 磁盘调度算法先考虑优化查找策略, 需要时再优化旋转等待策略。

平均寻道长度（L）为所有磁道所需移动距离之和除以总的所需访问的磁道数（N）, 即：（M1+M2+……+Mi+……+MN）/N 其中Mi为所需访问的磁道号所需移动的磁道数。

磁盘调度算法的实现

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

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

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

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

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

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

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

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

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

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

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

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

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

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

（4）循环扫描算法（CSCAN）CSCAN算法是对扫描算法的改进。

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

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

磁盘调度算法实验报告

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

操作系统课程设计磁盘调度报告

实验报告六 磁盘调度算法

磁盘调度算法实验设计报告

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

磁盘调度实验报告

磁盘调度算法实验小结

实验七 磁盘调度

磁盘调度算法

磁盘调度算法实验报告

磁盘调度算法

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

实验磁盘调度算法

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

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

磁盘调度算法

磁盘调度实验报告_4

磁盘调度算法的实现

实验报告六磁盘调度算法

实验七磁盘调度

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