操作系统实验四磁盘调度算法
磁盘调度算法
实验六磁盘调度算法【实验目的】通过这次实验,加深对磁盘调度算法的理解,进一步掌握先来先服务FCFS、最短寻道时间优先SSTF、SCAN和循环SCAN算法的实现方法。
【实验内容】问题描述:设计程序模拟先来先服务FCFS、最短寻道时间优先SSTF、SCAN 和循环SCAN算法的工作过程。
假设有n个磁道号所组成的磁道访问序列,给定开始磁道号m和磁头移动的方向(正向或者反向),分别利用不同的磁盘调度算法访问磁道序列,给出每一次访问的磁头移动距离,计算每种算法的平均寻道长度。
程序要求:1)利用先来先服务FCFS、最短寻道时间优先SSTF、SCAN和循环SCAN算法模拟磁道访问过程。
2)模拟四种算法的磁道访问过程,给出每个磁道访问的磁头移动距离。
3)输入:磁道个数n和磁道访问序列,开始磁道号m和磁头移动方向(对SCAN和循环SCAN算法有效),算法选择1-FCFS,2-SSTF,3-SCAN,4-循环SCAN。
4)输出:每种算法的平均寻道长度。
实现提示:用C++语言实现提示:1)程序中变量定义参考(根据需要可添加)如下:const int MaxNumber=100;int TrackOrder[MaxNumber];int MoveDistance[MaxNumber];double AverageDistance;bool direction;2)页面置换的实现过程如下:变量初始化;接收用户输入磁道个数n和磁盘访问序列,选择算法1-FCFS,2-SSTF,3-SCAN,4-循环SCAN,输入开始磁盘号m和磁头移动方向;根据用户选择的算法进行磁道访问,输出磁盘调度算法的模拟过程;计算选择每次移动的磁头移动距离和算法的平均寻道长度;输出选择算法的平均寻道长度。
实验要求:1)上机前认真复习磁盘调度算法,熟悉FCFS、SSTF、SCAN 和循环SCAN算法的过程;2)上机时独立编程、调试程序;3)根据具体实验要求,完成好实验报告(包括实验的目的、内容、要求、源程序、实例运行结果截图、发现的问题以及解决方法)。
磁盘调度算法
磁盘调度算法⼀次磁盘读写操作的时间由寻找(寻道)时间、延迟时间和传输时间决定: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、缺点:效率不⾼,相邻两次请求可能会造成最内到最外的柱⾯寻道,使磁头反复移动,增加了服务时间,对机械也不利。
操作系统实验报告—磁盘调度算法
操作系统实验报告—磁盘调度算法操作系统实验报告实验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语言模拟电梯调度算法,实现对磁盘的驱动调度,这个相比前两个实验实现起来相对简单,理解了算法实现起来尤为简单,程序敲出来之后没有错误,可直接运行,结果验证也无误。
操作系统有哪些主要调度算法
操作系统有哪些主要调度算法操作系统调度算法一、磁盘调度1.先来先服务fcfs:是按请求访问者的先后次序启动磁盘驱动器,而不考虑它们要访问的物理位置2.最短一般说来时间优先sstf:使距当前磁道最近的命令访问者启动磁盘驱动器,即是使查找时间最短的那个作业先继续执行,而不考量命令访问者到来的先后次序,这样就消除了先来先服务调度算法中磁臂移动过小的问题3.扫描算法scan或电梯调度算法:总是从磁臂当前位置开始,沿磁臂的移动方向去选择离当前磁臂最近的那个柱面的访问者。
如果沿磁臂的方向无请求访问时,就改变磁臂的移动方向。
在这种调度方法下磁臂的移动类似于电梯的调度,所以它也称为电梯调度算法。
4.循环读取算法cscan:循环读取调度算法就是在读取算法的基础上改良的。
磁臂改成单项移动,由外向里。
当前边线已经开始沿磁臂的移动方向回去挑选距当前磁臂最近的哪个柱面的访问者。
如果沿磁臂的方向并无命令出访时,再返回最外,出访柱面号最轻的作业命令。
操作系统调度算法二、进程调度算法1.先进先出算法fifo:按照进程步入准备就绪队列的先后次序去挑选。
即为每当步入进程调度,总是把准备就绪队列的队首进程资金投入运转。
2.时间片轮转算法rr:分时系统的一种调度算法。
轮转的基本思想是,将cpu的处理时间划分成一个个的时间片,就绪队列中的进程轮流运行一个时间片。
当时间片结束时,就强迫进程让出cpu,该进程进入就绪队列,等待下一次调度,同时,进程调度又去选择就绪队列中的一个进程,分配给它一个时间片,以投入运行。
3.最低优先级算法hpf:进程调度每次将处理机分配给具备最低优先级的准备就绪进程。
最低优先级算法可以与相同的cpu方式融合构成可以抢占市场式最低优先级算法和不容抢占市场式最低优先级算法。
4.多级队列反馈法:几种调度算法的结合形式多级队列方式。
操作系统调度算法三、常用的批处理作业调度算法1.先来先服务调度算法fcfs:就是按照各个作业进入系统的自然次序来调度作业。
磁盘调度的实验报告(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算法在请求序列较长时性能更稳定,且磁头移动次数更少。
操作系统课程设计报告磁盘调度算法
操作系统课程设计报告磁盘调度算法华南农业⼤学数学与信息学院(软件学院)《操作系统分析与设计实习》成绩单开设时间:2015学年第⼀学期⼀、需求分析(1)输⼊的形式和输⼊值的范围:在⽂本框输⼊序列长度,输⼊值为int类型输出每种算法的平均寻道长度。
(3)程序所能达到的功能:模拟实现FCFS、SSTF、SCAN、C-SCAN 算法,并计算及⽐较磁头移动道数。
(4)测试数据:包括正确的输⼊及其输出结果和含有错误的输⼊及其输出结果:⼆、概要设计1)主程序流程图:输出随机⽣成400个磁道号序列主菜单选择算法开始FCFS SSTFSCANC-SCAN 结束(2)各程序模块之间的调⽤关系磁头初始位置输⼊及合法性检查冒泡排序算法由外向内输出磁道序列由内向外输出磁道序列由当前位置向内再向外输出磁道序列由当前位置向外再向内输出磁道序列由当前位置向内再由外向内输出磁道序列由当前位置向外再由内向外输出磁道序列就近选择主函数SCANC-SCAN三、详细设计1)各操作伪码算法(1)实现磁头初始位置的输⼊并进⾏合法性检查int printstarter()//磁头初始位置输⼊{输⼊:磁头初始位置;if输⼊⼩于0或⼤于1500{输出:"输⼊数据类型有误,请重新输⼊!"<重新输⼊}Else 返回合法的磁头初始位置}(2)冒泡排序算法int *bubble//冒泡排序算法{for 从数组的第⼀个元素开始重复{依次和后续元素表较⼤⼩;If后⾯元素⼤于当前元素交换数值;}输出排序后的数组;返回数组;}(3)int out_to_in//由磁道最外向内输出磁道序列{for 从最外磁道开始{依次输出磁道号;当前磁道号与磁头初始未⾄的绝对值求和;返回绝对值之和;}(4)int in_to_out//由磁道最内向外输出磁道序列{ for 从最内磁道开始{依次输出磁道号;当前磁道号与磁头初始未⾄的绝对值求和;磁头初始位置=当前磁道号;}返回绝对值之和;}(5)int out_to_in_to_out//先由当前位置向内再向外{找到⼩于等于磁头初始位置的磁道for由该磁道开始{向内依次输出磁道号;当前磁道号与磁头初始未⾄的绝对值求和;}for由该磁道的外侧磁道开始{向外依次输出磁道号;当前磁道号与磁头初始未⾄的绝对值求和;}返回绝对值之和;}(6)int in_to_out_to_in//先由当前位置向外再向内{找到⼤于等于磁头初始位置的磁道for由该磁道开始{向外依次输出磁道号;当前磁道号与磁头初始未⾄的绝对值求和;}for由该磁道的内侧磁道开始当前磁道号与磁头初始未⾄的绝对值求和;}返回绝对值之和;}(7)int out_to_in_twice由当前磁道向内再从最外向内{找到⼩于等于磁头初始位置的磁道;for由该磁道开始{向内依次输出磁道号;当前磁道号与磁头初始未⾄的绝对值求和;}for由最外侧磁道开始{向内依次输出磁道号直到⼩于等于初始位置的磁道的外侧⼀个磁道;当前磁道号与磁头初始未⾄的绝对值求和;}返回绝对值之和;}(8)int in_to_out_twice由当前磁道向外再从最内向外{找到⼤于等于磁头初始位置的磁道for由该磁道开始{向内依次输出磁道号;当前磁道号与磁头初始未⾄的绝对值求和;}for由最内侧磁道开始{向外依次输出磁道号直到⼩于等于初始位置的磁道的内侧⼀个磁道;当前磁道号与磁头初始未⾄的绝对值求和;}返回绝对值之和;{找到⼤于磁头初始位置的磁道;while初始位置内侧差绝对值更⼩{输出内侧磁道号;绝对值差求和;初始位置更新为当前磁道号;}while 初始位置外侧绝对值差更⼩{输出外侧磁道号;绝对值差求和;初始位置更新为当前磁道号;}}If已到达最内侧未到达最外侧{if内侧绝对值差更⼩{输出最内侧磁道号;绝对差值求和;初始位置更新;while 向外侧依次输出磁道号直到到达最外侧{绝对差值求和;更新初始位置;}}else外侧绝对值差更⼩{While向外侧依次输出磁道号直到到达最外侧{绝对差值求和;更新初始位置;绝对差值求和;更新初始位置;}}if 已到达最外侧未到达最内侧{If外侧绝对值更⼩{输出最外侧磁道号;绝对差值求和;更新初始位置;while向内依次输出磁道号{绝对差值求和;更新初始位置;}}else{while 向内依次输出磁道号{绝对差值求和;更新初始位置;}输出最外侧磁道号;绝对值差求和;更新初始位置;}}if均到达最内侧和最外侧{if 外侧差绝对值更⼩{}else{输出最内侧磁道号并绝对值差求和;输出最外侧磁道号并绝对值差求和;}}求总和并返回;}(10)void FCFS算法{输出磁盘请求序列为;按照磁盘请求序列依次输出磁盘扫描序列;当前磁道号与磁头初始未⾄的绝对值求和;求平均值;输出平均寻道长度;}(11)void SSTF算法{if序列中最⼤的磁道号⼩于磁头初始位置{调⽤out_to_in直接由外向内;}if 序列中最⼩的磁道号⼤于磁头初始位置{调⽤in_to_out直接由内向外;}If 磁头初始位置为中间值{调⽤就近选择算法;}求均值;输出平均寻道时间;}输⼊:磁臂移动⽅向(1:向外,0:向内); if 序列中最⼤的磁道号⼩于磁头初始位置{调⽤out_to_in直接由外向内;}if序列中最⼩的磁道号⼤于磁头初始位置{调⽤in_to_out直接由内向外;}if 初始磁头位置为中间值{if 磁臂⽅向向内{调⽤out_to_in_to_out;}if 磁臂⽅向向外{调⽤n_to_out_to_in;}}求均值;输出平均寻道时间;}(13)Viod C-SCAN算法{请输⼊磁臂移动⽅向(1:向外,0:向内);if 序列中最⼤磁道号⼩于等于磁头初始位置{ if磁臂⽅向向内{调⽤out_to_in;}if磁臂⽅向向外{调⽤in_to_out;if 序列中最⼤磁道号⼤于等于磁头初始位置{if磁臂⽅向向内{调⽤out_to_in;}if磁臂⽅向向外{调⽤in_to_out;}}if初始磁头位置为中间值{if (磁臂⽅向向内{调⽤out_to_in_twice;}if 磁臂⽅向向外{调⽤in_to_out_twice);}}求均值;输出平均寻道时间;}(14)主函数int main(){随机⽣成200个0~499的磁道序列并输出;随机⽣成100个500~999的磁道序列并输出;随机⽣成100个1000~1500的磁道序列并输出;输出:主菜单;输⼊:⽤户选择并进⾏合法性检查switch (⽤户选择)case 2:调⽤SSTF()case 3:调⽤SCAN()case 4:调⽤C-SCAN()case 5:退出}}2)函数的调⽤关系图四、调试分析1)调试过程中遇到的问题以及对设计与实现的讨论和分析:(1)随机⽣成400个磁道号序列:使⽤rand()函数,对于:50%位于 0~499,25%分布在 500~999,25%分布在 1000~1499,采⽤如下⽅法解决:track[i] = (rand() % 500);track[i] = (rand() % 500)+500;track[i] = (rand() % 500)+1000;(2)通过对每⼀⾏的输出设置断点判断问题出现在哪⾥,把出问题的地⽅缩⼩到⼀定范围,然后解决问题,如若解决不出则上⽹查询。
操作系统磁盘调度算法例题讲解
操作系统磁盘调度算法例题讲解1. 磁盘调度算法的背景和意义磁盘调度算法是操作系统中的重要组成部分,它的主要目的是优化磁盘访问,提高磁盘I/O操作的效率。
在计算机系统中,磁盘是一个重要的存储介质,它负责存储和读写数据。
然而,由于磁盘访问具有机械运动延迟和寻道时间等特性,使得磁盘I/O操作成为计算机系统中一个性能瓶颈。
为了解决这个问题,人们提出了各种各样的磁盘调度算法。
这些算法通过优化访问顺序、减少寻道时间、提高数据传输率等方式来提高磁盘I/O操作效率。
因此,深入了解和掌握不同类型的磁盘调度算法对于优化计算机系统性能具有重要意义。
2. 先来先服务(FCFS)调度算法先来先服务(First-Come, First-Served)是最简单、最直观的一种磁盘调度算法。
它按请求顺序处理I/O请求。
当一个请求到达时,在当前位置完成当前请求后再处理下一个请求。
然而,在实际应用中,FCFS存在一些问题。
首先,它无法充分利用磁盘的带宽,因为磁盘的读写头可能在处理当前请求时,其他请求已经到达。
其次,由于磁盘请求的随机性,FCFS可能导致某些请求等待时间过长。
3. 最短寻道时间优先(SSTF)调度算法最短寻道时间优先(Shortest Seek Time First)是一种基于当前位置选择下一个最近请求的调度算法。
在SSTF算法中,选择离当前位置最近的请求进行处理。
SSTF算法相对于FCFS算法来说,在减少寻道时间方面有一定的优势。
它能够充分利用磁盘带宽,并且能够减少某些请求等待时间过长的问题。
然而,SSTF算法也存在一些问题。
首先,在某些情况下,由于选择最近的请求进行处理,可能导致某些较远位置上的请求长期等待。
其次,在高负载情况下,由于大量随机访问导致寻道距离变大,SSTF 算法可能会导致饥饿现象。
4. 扫描(SCAN)调度算法扫描(SCAN)是一种按一个方向依次处理I/O请求,并在到达边界后改变方向的调度算法。
SCAN算法从一个方向开始处理请求,直到到达磁盘的边界。
操作系统-磁盘调度算法
操作系统-磁盘调度算法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个磁道。
操作系统课程设计报告磁盘调度算法
课程设计课程设计名称:操作系统应用课程设计专业班级:学生姓名:xxxxx学号:指导教师:课程设计时间: 2010.12.20-2010.12.26计算机科学专业课程设计任务书说明:本表由指导教师填写,由教研室主任审核后下达给选题学生,装订在设计(论文)首页一 .课程设计需求分析操作系统是计算机系统的一个重要系统软件。
我们在本课程的实验过程中,了解实际操作系统的工作过程,在实践中加深对操作系统原理的理解。
磁盘存储器不仅容量大,存取速度快,而且可以实现随机存取,是当前存放大量程序和数据的理想设备,故在现代计算机系统中,都配置了磁盘存储器,并以它为主来存放文件。
这样,对文件的操作,都将涉及到对磁盘的访问。
磁盘I/O速度的高低和磁盘系统的可靠性都将直接影响到系统性能。
因此,设法改善磁盘系统的性能,已成为现代操作系统的重要任务之一。
磁盘性能有数据的组织、磁盘的类型和访问时间等。
磁盘调度的目标是使磁盘的平均寻道时间最少。
也正因为这样,我们有必要对各算法进行模拟,进而比较、分析、了解。
本实验设计的目的是通过设计一个磁盘调度模拟系统,以加深对最短寻道时间优先(SSTF)、N步扫描算法(NStepSCAN)等磁盘调度算法的理解。
让我们更好地掌握操作系统的原理及实现方法,加深对操作系统基础理论和重要算法的理解,加强动手能力。
二.课程设计原理设备的动态分配算法与进程调度相似,也是基于一定的分配策略的。
常用的分配策略有先请求先分配、优先级高者先分配等策略。
在多道程序系统中,低效率通常是由于磁盘类旋转设备使用不当造成的。
操作系统中,对磁盘的访问要求来自多方面,常常需要排队。
这时,对众多的访问要求按一定的次序响应,会直接影响磁盘的工作效率,进而影响系统的性能。
访问磁盘的时间因子由3部分构成,它们是查找(查找磁道)时间、等待(旋转等待扇区)时间和数据传输时间,其中查找时间是决定因素。
因此,磁盘调度算法先考虑优化查找策略,需要时再优化旋转等待策略。
操作系统课程设计-磁盘调度算法
前言摘要:本课程设计的目的是通过设计一个磁盘调度模拟系统,从而使磁盘调度算法更加形象化,使磁盘调度的特点更简单明了,这里主要实现磁盘调度的四种算法,分别是:1、先来先服务算法(FCFS) 2、最短寻道时间优先算法(SSTF) 3、扫描算法(SCAN) 4、循环扫描算法(CSCAN)。
启动磁盘执行输入输出操作时,要把移动臂移动到指定的柱面,再等待指定扇区的旋转到磁头位置下,然后让指定的磁头进行读写,完成信息传送;因此,执行一次输入输出所花的时间有:寻找时间——磁头在移动臂带动下移动到指定柱面所花的时间。
延迟时间——指定扇区旋转到磁头下所需的时间。
传送时间——由磁头进程读写完成信息传送的时间,寻道时间——指计算机在发出一个寻址命令,到相应目标数据被找到所需时间;其中传送信息所花的时间,是在硬件设计时固定的,而寻找时间和延迟时间是与信息在磁盘上的位置有关;然后设计出磁盘调度的设计方式,包括算法思路、步骤,以及要用到的主要数据结构、函数模块及其之间的调用关系等,并给出详细的算法设计,对编码进行了测试与分析。
最后进行个人总结与设计体会。
关键词:最短寻道时间优先算法、扫描算法、总寻道长度.目录前言 (2)2. 课程设计任务及要求 (4)2.1 设计任务 (4)2.2 设计要求 (4)3. 算法及数据结构 (5)3.1算法的总体思想(流程) (5)3.2 实现过程中用到的数据结构 (6)3.3 实现过程中用到的系统调用 (11)4. 程序设计与实现 (11)4.1 最短寻道时间优先算法(SSTF)模块 (11)4.1.1程序流程图 (11)4.1.2 程序说明 (13)4.1.3 程序关键代码 (13)4.2扫描算法(SCAN)模块 (14)4.2.1 程序流程图 (14)4.2.2 程序说明 (16)4.2.3 程序关键代码 (16)4.3 实验结果 (17)5. 结论 (26)6. 参考文献 (26)7. 收获、体会和建议 (27)2. 课程设计任务及要求2.1 设计任务1.熟悉并掌握磁盘调度算法管理系统的设计方法,加强对所学各种调度算法及相应算法的特点了解。
操作系统课程设计-磁盘调度算法
操作系统课程设计-磁盘调度算法前言摘要:本课程设计的目的是通过设计一个磁盘调度模拟系统,从而使磁盘调度算法更加形象化,使磁盘调度的特点更简单明了,这里主要实现磁盘调度的四种算法,分别是: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)有更好的寻道性能,使每次的寻道时间最短。
操作系统磁盘调度算法实验报告
目录1.课程设计目的1.1编写目的本课程设计的目的是通过磁盘调度算法设计一个磁盘调度模拟系统,从而使磁盘调度算法更加形象化,容易使人理解,使磁盘调度的特点更简单明了,能使使用者加深对先来先服务算法、最短寻道时间优先算法、扫描算法以及循环扫描算法等磁盘调度算法的理解。
2.课程设计内容2.1设计内容系统主界面可以灵活选择某种算法,算法包括:先来先服务算法(FCFS)、最短寻道时间优先算法(SSTF)、扫描算法(SCAN)、循环扫描算法(CSCAN)。
1、先来先服务算法(FCFS)这是一种比较简单的磁盘调度算法。
它根据进程请求访问磁盘的先后次序进行调度。
此算法的优点是公平、简单,且每个进程的请求都能依次得到处理,不会出现某一进程的请求长期得不到满足的情况。
此算法由于未对寻道进行优化,在对磁盘的访问请求比较多的情况下,此算法将降低设备服务的吞吐量,致使平均寻道时间可能较长,但各进程得到服务的响应时间的变化幅度较小。
2、最短寻道时间优先算法(SSTF)该算法选择这样的进程,其要求访问的磁道与当前磁头所在的磁道距离最近,以使每次的寻道时间最短,该算法可以得到比较好的吞吐量,但却不能保证平均寻道时间最短。
其缺点是对用户的服务请求的响应机会不是均等的,因而导致响应时间的变化幅度很大。
在服务请求很多的情况下,对内外边缘磁道的请求将会无限期的被延迟,有些请求的响应时间将不可预期。
3、扫描算法(SCAN)扫描算法不仅考虑到欲访问的磁道与当前磁道的距离,更优先考虑的是磁头的当前移动方向。
例如,当磁头正在自里向外移动时,扫描算法所选择的下一个访问对象应是其欲访问的磁道既在当前磁道之外,又是距离最近的。
这样自里向外地访问,直到再无更外的磁道需要访问才将磁臂换向,自外向里移动。
这时,同样也是每次选择这样的进程来调度,即其要访问的磁道,在当前磁道之内,从而避免了饥饿现象的出现。
由于这种算法中磁头移动的规律颇似电梯的运行,故又称为电梯调度算法。
操作系统磁盘调度算法例题讲解
操作系统磁盘调度算法例题讲解磁盘调度算法是操作系统中用于确定磁盘上数据访问顺序的算法。
它的目标是提高磁盘I/O的效率,减少磁盘访问时间。
以下是一个例题,我们通过讲解来了解磁盘调度算法的工作原理。
假设一个磁盘上有以下请求序列:98, 183, 37, 122, 14, 124, 65, 67。
磁头起始位置为53,磁道编号从0到199。
假设每个磁道的大小为1。
我们现在来分别讲解几种常见的磁盘调度算法如何处理这个请求序列:1. 先来先服务算法(First Come First Serve, FCFS)FCFS算法会按照请求的顺序进行处理。
根据给定的请求序列,磁头依次移动到98,然后到达183,再到37,以此类推。
计算总共移动的磁道数,得到结果为:98-53 + 183-98 + 183-37 + 122-37 + 122-14 + 124-14 + 124-65 + 67-65 = 640。
2. 最短寻道时间优先算法(Shortest Seek Time First, SSTF) SSTF算法会选择离当前磁头位置最近的请求进行处理。
对于请求序列98, 183, 37, 122, 14, 124, 65, 67,初始磁头位置为53,我们按照离当前位置最近的请求的顺序进行处理。
首先找到最近的请求是37,磁头移动到37,然后移动到14,继续移动到65,以此类推。
计算总共移动的磁道数,得到结果为:37-53 + 14-37 + 65-14 + 67-65 + 98-67 + 122-98 + 124-122 + 183-124 = 236。
3. 扫描算法(Scan)扫描算法,也叫电梯算法,是按照一个方向上的顺序进行移动,直到到达最上方或最下方,然后改变方向继续移动。
对于给定的请求序列,我们可以选择一个方向(向上或向下),然后依次处理请求。
对于本例中的请求序列,假设选择向上移动。
磁头依次移动到65,然后67,再到98,然后122,以此类推,直到183。
磁盘调度算法的实现
一、实验目的:通过模拟设计磁盘驱动调度程序,观察驱动调度程序的动态运行过程,理解和掌握磁盘驱动调度的职能,并比较各种算法的调度结果。
二、实验容:要求设计主界面能灵活选择某算法,且以下算法都要实现。
(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)假设磁盘只有一个盘面,并且磁盘是可移动头磁盘。
(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) //确定当前磁道在已排的序列中的位置,后面的算法都用到了,可以直接复制后少量修改,节省时间。
- 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. 运行界面:五、实验心得:通过本次实验,学习了解磁盘调度的工作原理及四种调度方法的工作原理,并且在当中发现了自己的不足,对以前所学过的知识理解得不够深刻,掌握得不够牢固,看到了自己的实践经验还是比较缺乏,理论联系实际的能力还急需提高。