操作系统实验四-磁盘调度算法
磁盘调度算法实验报告
操作系统实验报告哈尔滨工程大学计算机科学与技术学院磁盘调度算法一．实验概述：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 和访问的磁道号）。
操作系统磁盘调度算法实验报告
《操作系统原理》课程设计报告书题目：磁盘调度专业：网络工程学号：学生姓名：指导教师：完成日期：目录第一章课程设计目的...................... 错误!未定义书签。
编写目的.............................. 错误!未定义书签。
第二章课程设计内容...................... 错误!未定义书签。
设计内容.............................. 错误!未定义书签。
、先来先服务算法（FCFS）........... 错误!未定义书签。
、最短寻道时间优先算法（SSTF）..... 错误!未定义书签。
、扫描算法（SCAN）................. 错误!未定义书签。
、循环扫描算法（CSCAN）............ 错误!未定义书签。
第三章系统概要设计...................... 错误!未定义书签。
模块调度关系图........................ 错误!未定义书签。
模块程序流程图........................ 错误!未定义书签。
FCFS算法......................... 错误!未定义书签。
SSTF算法......................... 错误!未定义书签。
SCAN算法......................... 错误!未定义书签。
CSCAN算法........................ 错误!未定义书签。
第四章程序实现.......................... 错误!未定义书签。
主函数的代码实现..................... 错误!未定义书签。
算法的代码实现........................ 错误!未定义书签。
SSTF算法的代码实现 .................. 错误!未定义书签。
SCAN算法的代码实现 .................. 错误!未定义书签。
操作系统-磁盘调度算法
cout<<" ";
for(i=1;i<num;i++)
{
sum+=abs(FCFSQueue[i]-FCFSQueue[i-1]);
cout<<abs(FCFSQueue[i]-FCFSQueue[i-1])<<" ";
}
ave=(float)sum/(num-1);
for(i=count,j=0;i<num,j<num-count;i++,j++)
a[j]=SCANQueue[i];
for(i=count-1,j=num-count;i>=0,j<num;i--,j++)
a[j]=SCANQueue[i];
cout<<endl<<endl;
cout<<"输出访问磁道的顺序："<<endl;
结
果
总
结
程序主要利用了数组，运算的效率比较的高。用户可以输入或者随机产生所需要的数据，完全可以满足用户的需求。程序最后给出了柱面的调用顺序并且计算了寻道的时间。完成了设计的任务和要求。
附
录
#include<iostream>
#include<algorithm>//排序sort(beg,end)
#include<cmath>//求绝对值abs
}
int start=CSCANQueue[0];
sort(CSCANQueue,CSCANQueue+num);
操作系统实验报告—磁盘调度算法
操作系统实验报告—磁盘调度算法操作系统实验报告实验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语言模拟电梯调度算法，实现对磁盘的驱动调度，这个相比前两个实验实现起来相对简单，理解了算法实现起来尤为简单，程序敲出来之后没有错误，可直接运行，结果验证也无误。
磁盘调度的实验报告(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算法在请求序列较长时性能更稳定，且磁头移动次数更少。
磁盘调度实验报告总结(3篇)
第1篇一、实验背景随着计算机技术的发展，磁盘作为计算机系统中重要的存储设备，其性能对系统整体性能的影响日益显著。
磁盘调度算法是操作系统设计中的重要组成部分，其目的是优化磁盘I/O操作，提高系统性能。
本次实验通过对几种常见的磁盘调度算法进行模拟和分析，旨在加深对磁盘调度原理的理解，并提高算法分析能力。
二、实验目的1. 了解磁盘调度算法的基本原理和常用算法；2. 比较分析不同磁盘调度算法的性能；3. 培养编程能力和算法分析能力。
三、实验内容本次实验主要涉及以下几种磁盘调度算法：1. 先来先服务（FCFS）算法；2. 最短寻道时间优先（SSTF）算法；3. 扫描算法（SCAN）；4. 循环扫描算法（C-SCAN）。
实验过程中，我们首先准备一组模拟的磁盘请求序列，然后使用提供的代码实现上述四种磁盘调度算法，并计算各种情况下的寻道时间。
为了进行比较，我们尝试了不同的初始磁头位置和磁盘请求序列，观察寻道时间的变化。
四、实验步骤1. 准备磁盘请求序列：手动生成或编写程序生成一组磁盘请求序列；2. 创建实验主体：使用代码实现四种磁盘调度算法，并计算各种情况下的寻道时间；3. 改变参数进行比较：尝试不同的初始磁头位置和不同的磁盘请求序列，观察寻道时间的变化；4. 性能比较和分析：比较不同算法的寻道时间，分析它们在不同情况下的表现，找出它们的优缺点。
五、实验结果与分析1. FCFS算法：FCFS算法是最简单的磁盘调度算法，其优点是公平、算法简单，但缺点是没有对寻道算法进行优化，平均寻道时间可能比较长。
2. SSTF算法：SSTF算法选择距离磁头最近的请求先执行，从而减少了寻道时间。
但SSTF算法不能保证平均寻道时间最短。
3. SCAN算法：SCAN算法优先考虑磁头当前的移动方向，然后是访问的磁道和当前磁道的距离。
SCAN算法在磁头移动过程中，对磁道进行扫描，直到磁头到达一个方向上的最后一个请求，然后改变方向继续扫描。
操作系统磁盘调度实验报告
操作系统磁盘调度实验报告一、实验目的：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。
磁盘调度的算法
磁盘调度的算法
磁盘调度是计算机操作系统中的一个重要功能，用于决定磁盘驱动器上的磁盘访问请求的顺序。
磁盘调度算法的目标是尽可能地减少磁盘的寻道时间和旋转延迟，以提高磁盘的访问效率。
常见的磁盘调度算法包括以下几种：
1. 先来先服务（FCFS）：磁盘访问请求按照它们的到达顺序进行处理。
这种算法简单且公平，但是可能导致磁盘的平均寻道时间较长。
2. 最短寻道时间优先（SSTF）：选择距离当前磁头位置最近的磁道作为下一个要访问的磁道。
这种算法能够减少磁头的寻道时间，但是可能会导致某些磁道被连续访问，从而降低了磁盘的整体吞吐量。
3. 扫描算法（SCAN）：磁头按照一个方向移动，处理磁盘上的请求，直到到达磁盘的边界，然后改变方向继续移动。
这种算法可以减少磁盘的平均寻道时间，并且确保所有的磁道都被访问到，但是可能导致某些磁道的访问延迟较长。
4. 循环扫描算法（C-SCAN）：类似于扫描算法，但是在到达磁盘边界后，直接返回到起始位置，而不是改变方向。
这种算法可以进一步降低磁头的寻道时间，并且在某些情况下可以提高磁盘的整体性能。
5. 最佳扫描算法（LOOK）：类似于扫描算法，但是在到达磁盘边界后，只改变方向，而不是反向移动。
这种算法可以根据实际的磁盘访问请求动态调整磁头的移动方向，以减少磁头的寻道时间。
需要注意的是，每种磁盘调度算法都有其适用的场景和优缺点，选择
合适的算法取决于具体的应用需求和性能要求。
操作系统磁盘调度算法实验研究报告
目录目录11．课程设计目地0b5E2R。
1.1编写目地0p1Ean。
2．课程设计内容0DXDiT。
2.1设计内容0RTCrp。
3.1模块调用关系图25PCzV。
4．测试数据和结果6jLBHr。
5．参考文献9xHAQX。
6．总结9LDAYt。
1．课程设计目地1.1编写目地本课程设计地目地是通过磁盘调度算法设计一个磁盘调度模拟系统，从而使磁盘调度算法更加形象化，容易使人理解，使磁盘调度地特点更简单明了，能使使用者加深对先来先服务算法、最短寻道时间优先算法、扫描算法以及循环扫描算法等磁盘调度算法地理解.Zzz6Z。
2．课程设计内容2.1设计内容系统主界面可以灵活选择某种算法，算法包括：先来先服务算法（FCFS）、最短寻道时间优先算法（SSTF）、扫描算法（SCAN）、循环扫描算法（CSCAN）.dvzfv。
1、先来先服务算法（FCFS）这是一种比较简单地磁盘调度算法.它根据进程请求访问磁盘地先后次序进行调度.此算法地优点是公平、简单，且每个进程地请求都能依次得到处理，不会出现某一进程地请求长期得不到满足地情况.此算法由于未对寻道进行优化，在对磁盘地访问请求比较多地情况下，此算法将降低设备服务地吞吐量，致使平均寻道时间可能较长，但各进程得到服务地响应时间地变化幅度较小.rqyn1。
2、最短寻道时间优先算法（SSTF）该算法选择这样地进程，其要求访问地磁道与当前磁头所在地磁道距离最近，以使每次地寻道时间最短，该算法可以得到比较好地吞吐量，但却不能保证平均寻道时间最短.其缺点是对用户地服务请求地响应机会不是均等地，因而导致响应时间地变化幅度很大.在服务请求很多地情况下，对内外边缘磁道地请求将会无限期地被延迟，有些请求地响应时间将不可预期.Emxvx。
3、扫描算法（SCAN）扫描算法不仅考虑到欲访问地磁道与当前磁道地距离，更优先考虑地是磁头地当前移动方向.例如，当磁头正在自里向外移动时，扫描算法所选择地下一个访问对象应是其欲访问地磁道既在当前磁道之外，又是距离最近地.这样自里向外地访问，直到再无更外地磁道需要访问才将磁臂换向，自外向里移动.这时，同样也是每次选择这样地进程来调度，即其要访问地磁道，在当前磁道之内，从而避免了饥饿现象地出现.由于这种算法中磁头移动地规律颇似电梯地运行，故又称为电梯调度算法.此算法基本上克服了最短寻道时间优先算法地服务集中于中间磁道和响应时间变化比较大地缺点，而具有最短寻道时间优先算法地优点即吞吐量较大，平均响应时间较小，但由于是摆动式地扫描方法，两侧磁道被访问地频率仍低于中间磁道. SixE2。
操作系统-磁盘调度算法
操作系统-磁盘调度算法1 一次磁盘读/写操作需要的时间寻找时间（寻道时间）T s：在读/写数据前，需要将磁头移动到指定磁道所花费的时间。
寻道时间分两步：(1) 启动磁头臂消耗的时间：s。
(2) 移动磁头消耗的时间：假设磁头匀速移动，每跨越一个磁道消耗时间为m，共跨越n条磁道。
则寻道时间T s= s + m * n。
磁头移动到指定的磁道，但是不一定正好在所需要读/写的扇区，所以需要通过磁盘旋转使磁头定位到目标扇区。
延迟时间T R：通过旋转磁盘，使磁头定位到目标扇区所需要的时间。
设磁盘转速为r（单位：转/秒，或转/分），则平均所需延迟时间T R=(1/2)*(1/r) = 1/2r。
1/r就是转一圈所需的时间。
找到目标扇区平均需要转半圈，因此再乘以1/2。
传输时间T R：从磁盘读出或向磁盘中写入数据所经历的时间，假设磁盘转速为r，此次读/写的字节数为b，每个磁道上的字节数为N，则传输时间T R= (b/N) * (1/r) = b/(rN)。
每个磁道可存N字节数据，因此b字节数据需要b/N个磁道才能存储。
而读/写一个磁道所需的时间刚好是转一圈的时间1/r。
总的平均时间T a= T s+ 1/2r + b/(rN)，由于延迟时间和传输时间都是与磁盘转速有关的，且是线性相关。
而转速又是磁盘的固有属性，因此无法通过操作系统优化延迟时间和传输时间。
所以只能优化寻找时间。
2 磁盘调度算法2.1 先来先服务算法（FCFS）算法思想：根据进程请求访问磁盘的先后顺序进行调度。
假设磁头的初始位置是100号磁道，有多个进程先后陆续地请求访问55、58、39、18、90、160、150、38、184号磁道。
按照先来先服务算法规则，按照请求到达的顺序，磁头需要一次移动到55、58、39、18、90、160、150、38、184号磁道。
磁头共移动了 45 + 3 + 19 + 21 + 72 + 70 + 10 + 112 + 146 = 498个磁道。
磁盘调度 操作系统实验报告
实验一磁盘调度算法实现一、实验目的本课程设计的目的是通过磁盘调度算法设计一个磁盘调度模拟系统，从而使磁盘调度算法更加形象化，容易使人理解，使磁盘调度的特点更简单明了，能使使用者加深对先来先服务算法、最短寻道时间优先算法、扫描算法以及循环扫描算法等磁盘调度算法的理解。
二、实验内容系统主界面可以灵活选择某种算法，算法包括：先来先服务算法（FCFS）、最短寻道时间优先算法（SSTF）、扫描算法（SCAN）、循环扫描算法（CSCAN）。
2.1先来先服务算法（ FCFS ）这是一种比较简单的磁盘调度算法。
它根据进程请求访问磁盘的先后次序进行调度。
此算法的优点是公平、简单，且每个进程的请求都能依次得到处理，不会出现某一进程的请求长期得不到满足的情况。
此算法由于未对寻道进行优化，在对磁盘的访问请求比较多的情况下，此算法将降低设备服务的吞吐量，致使平均寻道时间可能较长，但各进程得到服务的响应时间的变化幅度较小。
2.2 最短寻道时间优先算法（ SSTF ）该算法选择这样的进程，其要求访问的磁道与当前磁头所在的磁道距离最近，以使每次的寻道时间最短，该算法可以得到比较好的吞吐量，但却不能保证平均寻道时间最短。
其缺点是对用户的服务请求的响应机会不是均等的，因而导致响应时间的变化幅度很大。
在服务请求很多的情况下，对内外边缘磁道的请求将会无限期的被延迟，有些请求的响应时间将不可预期。
2.3 扫描算法（ SCAN ）扫描算法不仅考虑到欲访问的磁道与当前磁道的距离，更优先考虑的是磁头的当前移动方向。
例如，当磁头正在自里向外移动时，扫描算法所选择的下一个访问对象应是其欲访问的磁道既在当前磁道之外，又是距离最近的。
这样自里向外地访问，直到再无更外的磁道需要访问才将磁臂换向，自外向里移动。
这时，同样也是每次选择这样的进程来调度，即其要访问的磁道，在当前磁道之内，从而避免了饥饿现象的出现。
由于这种算法中磁头移动的规律颇似电梯的运行，故又称为电梯调度算法。
操作系统实验报告四磁盘调度算法
操作系统实验报告四[实验题目]磁盘调度算法SSTF、SCAN、C-SCAN[实验目的]通过设计一个磁盘调度模拟系统，从而使磁盘调度算法更加形象化，容易理解，使磁盘调度的特点更简单明了，能使使用者加深对最短寻道时间优先算法、扫描算法以及循环扫描算法的理解。
[实验内容]编程实现如下内容：1. 最短寻道时间优先算法（SSTF）；2. 扫描算法（SCAN）（又叫电梯调度算法）；3. 循环扫描算法（CSCAN）代码如下：#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;}}}//========SSTF,最短寻道法============================= 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、先来先服务算法（FCFS） 2、最短寻道时间优先算法（SSTF） 3、扫描算法（SCAN） 4、循环扫描算法（CSCAN）。
启动磁盘执行输入输出操作时，要把移动臂移动到指定的柱面，再等待指定扇区的旋转到磁头位置下，然后让指定的磁头进行读写，完成信息传送；因此，执行一次输入输出所花的时间有：寻找时间——磁头在移动臂带动下移动到指定柱面所花的时间。
延迟时间——指定扇区旋转到磁头下所需的时间。
传送时间——由磁头进程读写完成信息传送的时间，寻道时间——指计算机在发出一个寻址命令，到相应目标数据被找到所需时间；其中传送信息所花的时间，是在硬件设计时固定的，而寻找时间和延迟时间是与信息在磁盘上的位置有关；然后设计出磁盘调度的设计方式，包括算法思路、步骤，以及要用到的主要数据结构、函数模块及其之间的调用关系等，并给出详细的算法设计，对编码进行了测试与分析。
最后进行个人总结与设计体会。
关键词：最短寻道时间优先算法、扫描算法、总寻道长度.3.2 实现过程中用到的数据结构1.最短寻道时间优先（SSTF）图a SSTF调度算法示例图ciidao[]={55,58,39,18,90,160,150,38,184}（可随机生成多个）用冒泡法对磁道数组进行排序用户输入当前磁道号now，比较当前返回内侧（外侧）扫描将当前磁道号与剩余没有图b SSTF算法流程示例图原磁道号随机组成的数组：cidao[]={55,58,39,18,90,160,150,38,184}；排序后的数组={18,38,39,5,58,90,150,160,184}；输入当前磁道号：now=100；3839 39 55 55 55 58 58 58 58 90 90 90 90 90 now值:100 90 58 55 39 184160 160150 150 15018 18 18 1838 38 38 3839 39 39 3955 55 55 5558 58 58 5890 90 90 90now值：18 150 160 184图c SSTF算法队列示意图(按磁道访问顺序)2.扫描（SCAN）算法图d SCAN算法示例图原磁道号随机组成的数组：cidao[]={55,58,39,18,90,160,150,38,184}；排序后的数组={18,38,39,5,58,90,150,160,184}；输入当前磁道号：now=100；选择磁道移动方向；以磁道号增加的方向移动为例：55 58 58 90 90 90 184 184 184 184 160 160 160 160 160 150 150 150 150 150 150 now值：100 150 160 184 90 58 1838 3839 39 3955 55 5558 58 5890 90 90184 184 184160 160 160150 150 150now值:55 39 38图e SCAN算法队列示意图（按磁道访问顺序）3.3 实现过程中用到的系统调用系统模块调用关系图4. 程序设计与实现4.1 最短寻道时间优先算法（SSTF ）模块4.1.1程序流程图磁盘调度算法最短寻道扫描算法退出4.1.2 程序说明算法分析①优点：相较于先来先服务算法（FCFS）有更好的寻道性能，使每次的寻道时间最短。
操作系统实验磁盘调度算法实验报告
操作系统实验磁盘调度算法实验报告一.实验目的本实验旨在通过磁盘调度算法的模拟，探究不同调度算法对磁盘访问性能的影响，了解各种算法的特点和适用场景。
二.实验方法本实验通过编写磁盘调度模拟程序，实现了三种常见的磁盘调度算法：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、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验四磁盘调度一、实验目的：本实验要求学生模拟设计一个磁盘调度程序，观察调度程序的动态运行过程。
通过实验让学生理解和掌握磁盘调度的职能。
二、实验内容：对磁盘进行移臂操作，模拟磁盘调度算法并计算平均寻道时间三、实验准备：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) //确定当前磁道在已排的序列中的位置，后面的算法都用到了，可以直接复制后少量修改，节省时间。
{k++;}l=k-1;r=k;while((l>=0)&&(r<m)) //当前磁道在请求序列范围内{if((now-cidao[l])<=(cidao[r]-now)) //选择与当前磁道最近的请求给予服务{cout<<cidao[l]<<" ";sum+=now-cidao[l];now=cidao[l];l=l-1;}else{cout<<cidao[r]<<" ";sum+=cidao[r]-now;now=cidao[r];r=r+1;}}if(l==-1) //磁头移动到序列的最小号，返回外侧扫描仍未扫描的磁道{for(j=r;j<m;j++){cout<<cidao[j]<<" ";}sum+=cidao[m-1]-cidao[0];}else //磁头移动到序列的最大号，返回内侧扫描仍未扫描的磁道{for(j=l;j>=0;j--){cout<<cidao[j]<<" ";}sum+=cidao[m-1]-cidao[0];}}ave=(float)(sum)/(float)(m);cout<<endl;cout<<"平均寻道长度："<<ave<<endl;}/*************************扫描调度算法*************************/void SCAN(int cidao[],int m) //先要给出当前磁道号和移动臂的移动方向{int k=1;int now,l,r,d;int i,j,sum=0;int a;char str[100];float ave;cidao=bubble(cidao,m); //调用冒泡排序算法排序cout<<"请输入当前的磁道号：";D: cin>>str; //对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入！"<<endl;goto D;}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]) //若当前磁道号大于请求序列中最小者且小于最大者{while(cidao[k]<now){k++;}l=k-1;r=k;cout<<"请输入当前移动臂的移动的方向(1 表示向外，0表示向内) : ";cin>>d;if(d==0) //选择移动臂方向向内，则先向内扫描{cout<<"磁盘扫描序列为：";for(j=l;j>=0;j--){cout<<cidao[j]<<" "; //输出向内扫描的序列}for(j=r;j<m;j++) //磁头移动到最小号，则改变方向向外扫描未扫描的磁道{cout<<cidao[j]<<" "; //输出向外扫描的序列}sum=now-2*cidao[0]+cidao[m-1];}else //选择移动臂方向向外，则先向外扫描{cout<<"磁盘扫描序列为：";for(j=r;j<m;j++){cout<<cidao[j]<<" "; //输出向外扫描的序列}for(j=l;j>=0;j--) //磁头移动到最大号，则改变方向向内扫描未扫描的磁道{cout<<cidao[j]<<" ";}sum=-now-cidao[0]+2*cidao[m-1];}}ave=(float)(sum)/(float)(m);cout<<endl;cout<<"平均寻道长度："<<ave<<endl;}/************************循环扫描调度算法*****************************/void CSCAN(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<<"请输入当前的磁道号：";E: cin>>str; //对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入！"<<endl;goto E;}elsenow=trans(str,a); //输入当前磁道号if(cidao[m-1]<=now) //若当前磁道号大于请求序列中最大者，则直接将移动臂移动到最小号磁道依次向外给予各请求服务{cout<<"磁盘扫描序列为：";for(i=0;i<m;i++)cout<<cidao[i]<<" ";sum=now-2*cidao[0]+cidao[m-1];}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) //单向反复地从内向外扫描{k++;}l=k-1;r=k;for(j=r;j<m;j++){cout<<cidao[j]<<" "; //输出从当前磁道向外扫描的序列}for(j=0;j<r;j++) //当扫描完最大号磁道，磁头直接移动到最小号磁道，再向外扫描未扫描的磁道{cout<<cidao[j]<<" ";}sum=2*cidao[m-1]+cidao[l]-now-2*cidao[0];}ave=(float)(sum)/(float)(m);cout<<endl;cout<<"平均寻道长度："<<ave<<endl;}void main(){int a;int c; //菜单项int cidao[maxsize];int i=0,count;char str[100];cout<<"请输入磁道序列（0结束）："<<endl;A:cin>>str; //对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入！"<<endl;goto A;//输入错误，跳转到A，重新输入}elsecidao[i]=trans(str,a);i++;while(cidao[i-1]!=0){cin>>str; //对输入数据进行有效性判断a=decide(str);if(a==0)cout<<"输入数据的类型错误,请重新输入！"<<endl;else{cidao[i]=trans(str,a);i++;}}count=i-1; //要访问的磁道数cout<<"你输入的磁道序列为：";for(i=0;i<count;i++){cout<<cidao[i]<<" "; //输出磁道序列}cout<<endl;while(1){cout<<endl;cout<<"**********************************************"<<endl;cout<<" 系统菜单"<<endl;cout<<"*** ***"<<endl;cout<<"** 1. 先来先服务**"<<endl;cout<<"** **"<<endl;cout<<"** 2. 最短寻道时间优先**"<<endl;cout<<"** **"<<endl;cout<<"** 3. 扫描调度**"<<endl;cout<<"** **"<<endl;cout<<"** 4. 循环扫描**"<<endl;cout<<"** **"<<endl;cout<<"** 5. 退出**"<<endl;cout<<"*** ***"<<endl;cout<<"**********************************************"<<endl;cout<<"**********************************************"<<endl;G:cout<<"请选择算法：";F:cin>>str; //对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入！"<<endl;goto F;//输入错误，跳转到F，重新输入}elsec=trans(str,a);if(c==5)break;if(c>5){cout<<"数据输入错误！请重新输入"<<endl;goto G;}switch(c){case 1: //使用FCFS算法FCFS(cidao,count);break;case 2: //使用SSTF算法SSTF(cidao,count);break;case 3: //使用SCAN算法SCAN(cidao,count);break;case 4: //使用CSCAN算法CSCAN(cidao,count);break;}}}3. 运行界面：五、实验心得：通过本次实验，学习了解磁盘调度的工作原理及四种调度方法的工作原理，并且在当中发现了自己的不足，对以前所学过的知识理解得不够深刻，掌握得不够牢固，看到了自己的实践经验还是比较缺乏，理论联系实际的能力还急需提高。