操作系统实验 第五讲 磁盘调度算法

磁盘调度算法一、实验目的1、对磁盘调度的相关知识作进一步的了解，明确磁盘调度的原理。

2、加深理解磁盘调度的主要任务。

3、通过编程，掌握磁盘调度的主要算法。

二、实验内容和要求1、对于如下给定的一组磁盘访问进行调度：3、要求给出每种算法中磁盘访问的顺序，计算出平均移动道数。

4、假定当前读写头在90号，向磁道号增加的方向移动。

三、实验报告1、程序中使用的数据结构及符号说明。

2、给出主要算法的流程图。

3、给出程序清单并附上注释。

4、给出测试数据和运行结果。

#include<iostream>#include<iomanip>#include<math.h>using namespace std;const int MaxNumber=100;int TrackOrder[MaxNumber];int MoveDistance[MaxNumber]; //----移动距离;int FindOrder[MaxNumber]; //-----寻好序列。

double AverageDistance; //-----平均寻道长度bool direction; //-----方向 true时为向外，false为向里int BeginNum; //----开始磁道号。

int M; //----磁道数。

int N; //-----提出磁盘I/O申请的进程数int SortOrder[MaxNumber]; //----排序后的序列bool Finished[MaxNumber];void Inith(){cout<<"请输入磁道数（最大磁盘数目）：";cin>>M;cout<<"请输入提出磁盘I/O申请的进程数:";cin>>N;cout<<"请依次输入要访问的磁道号：";for(int i=0;i<N;i++)cin>>TrackOrder[i];for(int j=0;j<N;j++)MoveDistance[j]=0;cout<<"请输入开始磁道号：";cin>>BeginNum;for(int k=0;k<N;k++)Finished[k]=false;for(int l=0;l<N;l++)SortOrder[l]=TrackOrder[l];}//=====================排序函数，将各进程申请的磁道按从小到大排列=================void Sort(){ //------冒泡排序int temp;for(int i=N-1;i>=0;i--)for(int j=0;j<i;j++){if(SortOrder[j]>SortOrder[j+1]){temp=SortOrder[j];SortOrder[j]=SortOrder[j+1];SortOrder[j+1]=temp;}}}//============先来先服务=================================void FCFS(){int temp;temp=BeginNum; //--------将BeginNum赋给temp作为寻道时的当前所在磁道号for(int i=0;i<N;i++){MoveDistance[i]=abs(TrackOrder[i]-temp); //-------计算移动磁道数temp=TrackOrder[i]; //-------寻到后，将此道作为当前所在磁道号，赋给tempFindOrder[i]=TrackOrder[i]; //-----寻好的赋给寻好序列}}//========最短寻道法=============================void SSTF(){int temp,n;int A=M;temp=BeginNum; //--------将BeginNum赋给temp作为寻道时的当前所在磁道号for(int i=0;i<N;i++){for(int j=0;j<N;j++) //-------寻找最短的寻道长度{if(abs(TrackOrder[j]-temp)<A&&Finished[j]==false){A=abs(TrackOrder[j]-temp);n=j;}else continue;}Finished[n]=true; //-------将已经寻找到的Finished赋值为trueMoveDistance[i]=A; //-------寻道长度temp=TrackOrder[n]; //-------当前寻道号。

磁盘调度算法⼀次磁盘读写操作的时间由寻找(寻道)时间、延迟时间和传输时间决定:1) 寻找时间Ts:活动头磁盘在读写信息前，将磁头移动到指定磁道所需要的时间。

这个时间除跨越n条磁道的时间外，还包括启动磁臂的时间s，即:Ts = m * n + s。

式中，m是与磁盘驱动器速度有关的常数，约为0.2ms，磁臂的启动时间约为2ms。

2)延迟时间Tr:磁头定位到某⼀磁道的扇区(块号)所需要的时间，设磁盘的旋转速度为r，则:Tr = 1 / (2 * r)。

对于硬盘，典型的旋转速度为5400r/m，相当于⼀周11.1ms，则Tr为5.55ms;对于软盘，其旋转速度在300~600r/m之间，则Tr为50~100ms。

3) 传输时间Tt:从磁盘读出或向磁盘写⼊数据所经历的时间，这个时间取决于每次所读/写的字节数b和磁盘的旋转速度:Tt = b / (r * N)。

式中，r为磁盘每秒钟的转数;N为⼀个磁道上的字节数。

在磁盘存取时间的计算中，寻道时间与磁盘调度算法相关，下⾯将会介绍分析⼏种算法，⽽延迟时间和传输时间都与磁盘旋转速度相关，且为线性相关，所以在硬件上，转速是磁盘性能的⼀个⾮常重要的参数。

总平均存取时间Ta可以表⽰为:Ta = Ts + Tr + Tt。

（1）先来先服务（FCFS）按请求者的先后次序启动磁盘驱动器，⽽不考虑它们要访问的物理位置。

FCFS算法根据进程请求访问磁盘的先后顺序进⾏调度，这是⼀种最简单的调度算法。

该算法的优点是具有公平性。

如果只有少量进程需要访问，且⼤部分请求都是访问簇聚的⽂件扇区，则有望达到较好的性能;但如果有⼤量进程竞争使⽤磁盘，那么这种算法在性能上往往接近于随机调度。

所以，实际磁盘调度中考虑⼀些更为复杂的调度算法。

1、算法思想:按访问请求到达的先后次序服务。

2、优点:简单，公平。

3、缺点:效率不⾼，相邻两次请求可能会造成最内到最外的柱⾯寻道，使磁头反复移动，增加了服务时间，对机械也不利。

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

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

常见的磁盘调度算法有：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语言模拟电梯调度算法，实现对磁盘的驱动调度，这个相比前两个实验实现起来相对简单，理解了算法实现起来尤为简单，程序敲出来之后没有错误，可直接运行，结果验证也无误。

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

操作系统实验第五讲磁盘调度算法操作系统实验报告哈尔滨工程大学计算机科学与技术学院第六讲磁盘调度算法一、实验概述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算法。

Linux操作系统磁盘调度算法分析磁盘调度算法是指操作系统中用于处理磁盘上的请求的一套算法。

在现代计算机系统中，磁盘是一种非常重要的存储设备，因此如何高效地处理磁盘请求对于提高系统性能至关重要。

Linux操作系统作为一种广泛使用的开源操作系统，也采用了多种磁盘调度算法来提高磁盘访问效率。

本文将对Linux操作系统中常用的磁盘调度算法进行详细分析。

1. 先来先服务（FCFS）调度算法先来先服务是最基本的磁盘调度算法之一。

它按照磁盘请求的提交顺序进行处理。

当一个请求被完成后，下一个请求将按照提交的顺序进行处理。

这种算法的优点是简单易实现，但并不考虑磁盘访问位置和移动时间。

由于磁盘的读写时间和移动时间往往不同，因此FCFS算法可能会导致一些请求等待时间过长，影响系统的响应速度。

2. 最短寻道时间优先（SSTF）调度算法最短寻道时间优先算法是根据当前磁头位置选择离磁头最近的下一个请求进行处理。

该算法考虑了磁头的移动距离，因此能够减少磁头的寻道时间。

但是由于该算法总是选择最近的请求处理，可能导致一些远离磁头的请求等待时间过长，造成一些请求的饥饿现象。

3. 扫描（SCAN）调度算法扫描算法是磁盘调度算法中常用的一种。

它模拟磁头在磁盘上进行的一次扫描操作，沿着一定方向进行磁道的访问。

当磁头到达磁盘的一端时，会改变方向进行下一次扫描。

该算法比较公平，能够较均匀地处理所有磁盘请求，但是由于需要扫描整个磁道，可能导致一些请求等待时间较长。

4. 循环扫描（C-SCAN）调度算法循环扫描算法是对扫描算法的一种改进。

该算法在到达磁盘的一端后不会改变方向，而是直接返回到磁道的另一端进行下一次扫描。

这意味着所有请求都会等待直到磁头回到磁道的起始位置，这样能够减少等待时间，但是也可能导致一些请求的响应时间较长。

5. 最不常用（LFU）调度算法最不常用算法是根据请求的使用频率进行处理的一种算法。

它将优先处理那些使用频率较低的请求，这样能够提高系统的整体性能。

操作系统磁盘调度实验报告一、实验目的：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", &current);//动态分配内存给磁盘请求数组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。

磁盘调度的算法
磁盘调度是计算机操作系统中的一个重要功能，用于决定磁盘驱动器上的磁盘访问请求的顺序。

磁盘调度算法的目标是尽可能地减少磁盘的寻道时间和旋转延迟，以提高磁盘的访问效率。

常见的磁盘调度算法包括以下几种：
1. 先来先服务（FCFS）：磁盘访问请求按照它们的到达顺序进行处理。

这种算法简单且公平，但是可能导致磁盘的平均寻道时间较长。

2. 最短寻道时间优先（SSTF）：选择距离当前磁头位置最近的磁道作为下一个要访问的磁道。

这种算法能够减少磁头的寻道时间，但是可能会导致某些磁道被连续访问，从而降低了磁盘的整体吞吐量。

3. 扫描算法（SCAN）：磁头按照一个方向移动，处理磁盘上的请求，直到到达磁盘的边界，然后改变方向继续移动。

这种算法可以减少磁盘的平均寻道时间，并且确保所有的磁道都被访问到，但是可能导致某些磁道的访问延迟较长。

4. 循环扫描算法（C-SCAN）：类似于扫描算法，但是在到达磁盘边界后，直接返回到起始位置，而不是改变方向。

这种算法可以进一步降低磁头的寻道时间，并且在某些情况下可以提高磁盘的整体性能。

5. 最佳扫描算法（LOOK）：类似于扫描算法，但是在到达磁盘边界后，只改变方向，而不是反向移动。

这种算法可以根据实际的磁盘访问请求动态调整磁头的移动方向，以减少磁头的寻道时间。

需要注意的是，每种磁盘调度算法都有其适用的场景和优缺点，选择
合适的算法取决于具体的应用需求和性能要求。