磁盘调度流程图
昆明理工大学理学院
信息与计算科学专业操作性实验报告
年级： 09级姓名：学号：指导教师：
实验课程名称：操作系统原理开课实验室：理学院机房
实验内容：
1．实验/作业题目: 磁盘调度
2．实验/作业课时：2学时
3．实验过程(包括实验环境、实验内容的描述、完成实验要求的知识或技能)：
4．程序结构(程序中的函数调用关系图)
主控流程图：
Spooling输出服务程序由请求输出的两个用户进程调用,程序流程图:
Spooling输出进程流程图：
5．算法描述、流程图或操作步骤：
6．实验数据和实验结果（用屏幕图形表示，可另加附页）：
7．改进建议：
输入相应的符号来实现相应的运算。
评分标准学风--报告格式规范，文字清晰观察能力--正确描述和理解需要操作的问题
操作能力--正确输入程序，熟悉编程环境调试能力--熟练使用调试功能解决程序错误。
操作系统 实验 进程调度 银行家算法 多线程编程 存储管理 磁盘调度
实验一进程调度实验学时：2学时实验类型：设计实验要求：必修一、实验目的多道程序设计中，经常是若干个进程同时处于就绪状态，必须依照某种策略来决定那个进程优先占有处理机。
因而引起进程调度。
本实验模拟在单处理机情况下的处理机调度问题，加深对进程调度的理解。
二、实验内容1．优先权法、轮转法简化假设1）进程为计算型的（无I/O）2）进程状态：ready、running、finish3）进程需要的CPU时间以时间片为单位确定2．算法描述1）优先权法——动态优先权当前运行进程用完时间片后，其优先权减去一个常数。
2）轮转法三、流程图四、实验程序代码package进程调度;/***@author**/public class CPCB {private String name;private int time;private int count;public int getCount() {return count;}public void setCount(int count) { this.count = count;}public String getName() {return name;}public void setName(String name) { = name;}public int getTime() {return time;}public void setTime(int time) {this.time = time;}}package进程调度;/***@author**/class PCB{private String name;private int time ;private int priority ;public int getTime(){return time;}public void setTime(int time){this.time = time;}public int getPriority(){return priority;}public void setPriority(int priority){ this.priority = priority;}public String getName() {return name;}public void setName(String name) { = name;}}package进程调度;import java.util.LinkedList;/***@author**/class process{private final static int nap_time = 500;private LinkedList<PCB> queue = new LinkedList<PCB>();private LinkedList<CPCB> cqueue = new LinkedList<CPCB>();//优先权算法public void go(int p_Num) throws Exception{for(int i = 0;i<p_Num;i++){PCB pcb = new PCB();int time = (int)(Math.random()*20+1);int pri = (int)(Math.random()*20+4);pcb.setName("进程"+i);pcb.setTime(time);pcb.setPriority(pri);queue.add(pcb);}queue = this.sort(queue);int i=0;while(queue.size()!=0){PCB pcb = (PCB)queue.getFirst();System.out.println(i+"\t\t"+pcb.getName()+"运行\t"+"优先级:"+pcb.getPriority()+"---所需时间:"+pcb.getTime());// Thread.sleep(nap_time);int pre = pcb.getPriority() - 3;int time = pcb.getTime() - 1;if(time<=0){System.out.println(pcb.getName()+"\t\t进程运行结束");PCB p = (PCB)queue.removeFirst();System.out.println("移除队列的进程是\t\t"+p.getName()+"\n队列中还有"+queue.size()+"个进程\n");}else{queue.remove();pcb.setPriority(pre);pcb.setTime(time);// System.out.println("运行后:"+i+"----"+pcb.getName()+"---优先级:"+pcb.getPriority()+"---所需时间:"+pcb.getTime());queue.add(pcb);queue = this.sort(queue);}i++;}}//时间片轮转调度算法public void cycle(int p_Num) throws Exception{final int time = 3; //定义轮转时间片数for(int i = 0;i<p_Num;i++){CPCB cpcb = new CPCB();cpcb.setTime((int)(Math.random()*20)+1);cpcb.setName("进程"+i);cpcb.setCount(0);cqueue.add(cpcb);}while(cqueue.size()!=0){CPCB cpcb = (CPCB)cqueue.getFirst();while(cpcb.getCount()!=time){// Thread.sleep(nap_time);cpcb.setTime(cpcb.getTime() - 1);cpcb.setCount(cpcb.getCount()+1);for(int i=0;i<cqueue.size();i++)//输出进程运行情况{CPCB cpcb1 = (CPCB)cqueue.get(i);System.out.println(cpcb1.getName()+"\t\t所需时间片数"+cpcb1.getTime()+"\t\t已占用CPU时间片数"+cpcb1.getCount());}if(cpcb.getTime()==0){System.out.println(cpcb.getName()+"运行结束\n"+"-------------移除队列的是"+cpcb.getName()+"-------------");cqueue.removeFirst();System.out.println("-------------队列中还有"+cqueue.size()+"个进程--------------");break;}if(cpcb.getCount()==time){// cqueue.remove();System.out.println("----因为"+cpcb.getName()+"占用CPU时间片数"+cpcb.getCount()+"="+time);System.out.println(cpcb.getName()+"时间片运行结束"+cpcb.getCount()+cpcb.getTime());CPCB p = (CPCB)cqueue.removeFirst();cqueue.add(p);cpcb.setCount(0);break;}}}}public LinkedList<PCB> sort(LinkedList<PCB> processes){for(int i=0;i<processes.size();i++){PCB thread = new PCB();thread = processes.get(i);for(int j=i+1;j<processes.size();j++){if(thread.getPriority() < processes.get(j).getPriority()){PCB mythread = new PCB();mythread = thread;//thread = processes.get(j);processes.set(i, processes.get(j));processes.set(j, mythread);}}}return processes;}}package 进程调度;import java.io.BufferedReader;import java.io.InputStreamReader;/**** @author 邱福文**/public class MainFun{public void FPF(){}public static void main (String[] args) throws Exception{Integer n2;do{System.out.print("请输入进程数:");BufferedReader sin = new BufferedReader(new InputStreamReader(System.in));String str = sin.readLine();Integer n = Integer.parseInt(str);System.out.print("请输入调度算法:\n"+"1为优先权\n"+"2为轮转法\n"+"0 退出\n");BufferedReader sin2 = new BufferedReader(new InputStreamReader(System.in));String str2 = sin2.readLine();process p = new process();// do{n2 = Integer.parseInt(str2);switch(n2){case 0:break;case 1:p.go(n);break;case 2:p.cycle(n);break;default:System.out.print("输入有误请重新输入");break;}}while(n2!=0);}}五、实验结果请输入进程数:3请输入调度算法:1为优先权2为轮转法0 退出10 进程0运行优先级:19---所需时间:181 进程1运行优先级:19---所需时间:152 进程0运行优先级:16---所需时间:173 进程1运行优先级:16---所需时间:144 进程0运行优先级:13---所需时间:165 进程1运行优先级:13---所需时间:136 进程2运行优先级:10---所需时间:87 进程0运行优先级:10---所需时间:158 进程1运行优先级:10---所需时间:129 进程2运行优先级:7---所需时间:710 进程0运行优先级:7---所需时间:1411 进程1运行优先级:7---所需时间:1112 进程2运行优先级:4---所需时间:613 进程0运行优先级:4---所需时间:1314 进程1运行优先级:4---所需时间:1015 进程2运行优先级:1---所需时间:516 进程0运行优先级:1---所需时间:1217 进程1运行优先级:1---所需时间:918 进程2运行优先级:-2---所需时间:419 进程0运行优先级:-2---所需时间:1120 进程1运行优先级:-2---所需时间:821 进程2运行优先级:-5---所需时间:322 进程0运行优先级:-5---所需时间:1023 进程1运行优先级:-5---所需时间:724 进程2运行优先级:-8---所需时间:225 进程0运行优先级:-8---所需时间:926 进程1运行优先级:-8---所需时间:627 进程2运行优先级:-11---所需时间:1 进程2 进程运行结束移除队列的进程是进程2队列中还有2个进程28 进程0运行优先级:-11---所需时间:829 进程1运行优先级:-11---所需时间:530 进程0运行优先级:-14---所需时间:731 进程1运行优先级:-14---所需时间:432 进程0运行优先级:-17---所需时间:633 进程1运行优先级:-17---所需时间:334 进程0运行优先级:-20---所需时间:535 进程1运行优先级:-20---所需时间:236 进程0运行优先级:-23---所需时间:437 进程1运行优先级:-23---所需时间:1 进程1 进程运行结束移除队列的进程是进程1队列中还有1个进程38 进程0运行优先级:-26---所需时间:339 进程0运行优先级:-29---所需时间:240 进程0运行优先级:-32---所需时间:1进程0 进程运行结束移除队列的进程是进程0队列中还有0个进程请输入进程数:3请输入调度算法:1为优先权2为轮转法0 退出2进程0 所需时间片数8 已占用CPU时间片数1 进程1 所需时间片数6 已占用CPU时间片数0 进程2 所需时间片数13 已占用CPU时间片数0 进程0 所需时间片数7 已占用CPU时间片数2 进程1 所需时间片数6 已占用CPU时间片数0 进程2 所需时间片数13 已占用CPU时间片数0 进程0 所需时间片数6 已占用CPU时间片数3 进程1 所需时间片数6 已占用CPU时间片数0 进程2 所需时间片数13 已占用CPU时间片数0 ----因为进程0占用CPU时间片数3=3进程0时间片运行结束36进程1 所需时间片数5 已占用CPU时间片数1 进程2 所需时间片数13 已占用CPU时间片数0 进程0 所需时间片数6 已占用CPU时间片数0 进程1 所需时间片数4 已占用CPU时间片数2 进程2 所需时间片数13 已占用CPU时间片数0 进程0 所需时间片数6 已占用CPU时间片数0 进程1 所需时间片数3 已占用CPU时间片数3 进程2 所需时间片数13 已占用CPU时间片数0 进程0 所需时间片数6 已占用CPU时间片数0 ----因为进程1占用CPU时间片数3=3进程1时间片运行结束33进程2 所需时间片数12 已占用CPU时间片数1 进程0 所需时间片数6 已占用CPU时间片数0 进程1 所需时间片数3 已占用CPU时间片数0 进程2 所需时间片数11 已占用CPU时间片数2 进程0 所需时间片数6 已占用CPU时间片数0 进程1 所需时间片数3 已占用CPU时间片数0 进程2 所需时间片数10 已占用CPU时间片数3 进程0 所需时间片数6 已占用CPU时间片数0----因为进程2占用CPU时间片数3=3进程2时间片运行结束310进程0 所需时间片数5 已占用CPU时间片数1 进程1 所需时间片数3 已占用CPU时间片数0 进程2 所需时间片数10 已占用CPU时间片数0 进程0 所需时间片数4 已占用CPU时间片数2 进程1 所需时间片数3 已占用CPU时间片数0 进程2 所需时间片数10 已占用CPU时间片数0 进程0 所需时间片数3 已占用CPU时间片数3 进程1 所需时间片数3 已占用CPU时间片数0 进程2 所需时间片数10 已占用CPU时间片数0 ----因为进程0占用CPU时间片数3=3进程0时间片运行结束33进程1 所需时间片数2 已占用CPU时间片数1 进程2 所需时间片数10 已占用CPU时间片数0 进程0 所需时间片数3 已占用CPU时间片数0 进程1 所需时间片数1 已占用CPU时间片数2 进程2 所需时间片数10 已占用CPU时间片数0 进程0 所需时间片数3 已占用CPU时间片数0 进程1 所需时间片数0 已占用CPU时间片数3 进程2 所需时间片数10 已占用CPU时间片数0 进程0 所需时间片数3 已占用CPU时间片数0 进程1运行结束-------------移除队列的是进程1--------------------------队列中还有2个进程--------------进程2 所需时间片数9 已占用CPU时间片数1 进程0 所需时间片数3 已占用CPU时间片数0 进程2 所需时间片数8 已占用CPU时间片数2 进程0 所需时间片数3 已占用CPU时间片数0 进程2 所需时间片数7 已占用CPU时间片数3 进程0 所需时间片数3 已占用CPU时间片数0 ----因为进程2占用CPU时间片数3=3进程2时间片运行结束37进程0 所需时间片数2 已占用CPU时间片数1 进程2 所需时间片数7 已占用CPU时间片数0 进程0 所需时间片数1 已占用CPU时间片数2 进程2 所需时间片数7 已占用CPU时间片数0 进程0 所需时间片数0 已占用CPU时间片数3 进程2 所需时间片数7 已占用CPU时间片数0 进程0运行结束-------------移除队列的是进程0--------------------------队列中还有1个进程--------------进程2 所需时间片数6 已占用CPU时间片数1进程2 所需时间片数4 已占用CPU时间片数3----因为进程2占用CPU时间片数3=3进程2时间片运行结束34进程2 所需时间片数3 已占用CPU时间片数1进程2 所需时间片数2 已占用CPU时间片数2进程2 所需时间片数1 已占用CPU时间片数3----因为进程2占用CPU时间片数3=3进程2时间片运行结束31进程2 所需时间片数0 已占用CPU时间片数1进程2运行结束-------------移除队列的是进程2--------------------------队列中还有0个进程--------------请输入进程数:实验二银行家算法一、实验目的死锁会引起计算机工作僵死，因此操作系统中必须防止。
磁盘调度算法实验报告
操作系统实验报告哈尔滨工程大学计算机科学与技术学院磁盘调度算法一．实验概述：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 和访问的磁道号）。
实验七 磁盘调度管理实现
计算机操作系统综合设计实验七实验名称：磁盘调度管理实现学号：学生姓名：班级：指导教师：实验地点：实验日期：评分：一、实验目的1)理解磁盘调度相关理论；2)掌握多种磁盘调度算法；3)彻底掌握SCAN磁盘调度算法。
二、实验平台windows 10Visual C++ 6.0三、实验步骤1、实验内容1)设计磁盘调度请求队列（请求数≥10）；2)设定单位寻道时间；3)可动态修改磁盘请求时间和磁道；4)实现SCAN磁盘调度算法；5)实现动态调度并输出调度序列。
2、实验步骤1）编写并输入代码A、打开Visual C++ 6.0；B、新建c++文件，创建scan.cp。
2）进行功能测试并得出正确结果A、编译、运行scan.cpp：B、输入当前磁道号：C、输入队列：D、显示移动过程，以及平均寻道长度：E、改变队列长度，增加一个磁道号。
F、不改变长度，修改序列号为2的磁道号：G、修改磁头号的位置：四、实验总结整个设计中最麻烦的就是整个程序模块的划分和各模块之间接口设计，编程中经常犯想当然的错误，编程中出现了不少奇怪的错误。
再调试中尝试使用了分割法,对错误模块进行定位,再进行排查.通过这次的课程设计使我认识到要将操作系统这门计算机专业的课学好不仅仅是要把书上的基本知识学好而且还要不断进行实践，将所学的跟实践操作结合起来才能更好地巩固所学，才能提高自己实践能力.通过这次的设计使我认识到只停留在表面理解问题是很难使问题得到很好的解决的，实践能力与理论知识同样重要。
可以说此课程设计的理论难度并不大，但是若要深入发掘其中的东西，并且实际去编程实现，就遇到了相当大的难度。
因为与之涉及的很多方面并没有学过，需要自己去自学和实践检验。
，通过模拟磁盘调度及进程排队算法来加深对操作系统中各个磁臂调度算法概念的理解。
模拟磁盘调度算法(FCFS,SSTF,SCAN,CSCAN)，实现各种不同调度算法的过程，并计算各算法的平均寻道长度，以便于我们判断各种算法的优劣以及各种算法使用的场合。
N-Step-SCAN 磁盘调度 操作系统课程设计
哈尔滨理工大学课程设计（操作系统）题目：N-Step-SCAN 磁盘调度班级：计算机科学与技术学院计算机系10-8班姓名：唐楷航1004010825指导教师：高雪瑶系主任：林克正2013年03月01日目录1N-Step-SCAN 磁盘调度课程设计1.1 题目分析 (1)1.2 数据结构 (1)1.3 流程图 (1)1.4 实现技术 (17)1.5 设计结论和心得 (18)2 Linux代码分析 (20)2.1 功能说明 (18)2.2 接口说明 (18)2.3 局部数据结构....... (20)2.4 流程图............................................................................................................... .. (21)2.5 以实例说明运行过程 (22)- II-1N-Step-SCAN磁盘调度课程设计1.1题目分析当有一个或者几个进程对某一磁道有较高的访问频率，即这些进程反复请求对某一磁道的I/O操作，从而垄断整个磁盘设备。
在高密度的磁盘上容易出现此情况。
N步SCAN 算法是将磁道请求队列若干个长度为N的子队列。
而每处理一个队列时又是按SCAN算法，对一个队列处理完后，再处理其他队列。
1.2数据结构N-Step-SCAN磁盘调度中涉及的数据结构包括N个队列、队列缓冲区、表示空缓冲区的信号量、表示满缓冲区的信号量…等。
用伪代码表示如下：#include"stdio.h"#include"stdlib.h"//#include"iostream.h"#define maxsize 100 //定义最大数组域int now,s;void SSTF(int array[],int m){int temp;int k=1;int now,l,r; //当前磁道号now；找出的当前磁道左侧的磁道l，右侧的磁道rint i,j,sum=0;int avg;- 1-哈尔滨理工大学课程设计报告for(i=0;i<m;i++){for(j=i+1;j<m;j++)//对磁道号进行从小到大排列{if(array[i]>array[j])//两磁道号之间比较{temp=array[i];array[i]=array[j];array[j]=temp;}}}for( i=0;i<m;i++)//输出排序后的磁道号数组{printf("%d ",array[i]);}printf("\n 请输入当前的磁道号：");scanf("%d",&now);printf("\n SSTF调度结果: ");if(array[m-1]<=now)//判断整个数组里的数是否都小于当前磁道号{for(i=m-1;i>=0;i--)//将数组磁道号从大到小输出- 2-哈尔滨理工大学课程设计报告printf("%d ",array[i]);sum=now-array[0];//计算移动距离}else if(array[0]>=now)//判断整个数组里的数是否都大于当前磁道号{for(i=0;i<m;i++)//将磁道号从小到大输出printf("%d ",array[i]);sum=array[m-1]-now;//计算移动距离}else{while(array[k]<now)//逐一比较以确定K值{k++;}l=k-1;r=k;//确定当前磁道在已排的序列中的位置while((l>=0)&&(r<m)){if((now-array[l])<=(array[r]-now))//判断最短距离{- 3-哈尔滨理工大学课程设计报告printf("%d ",array[l]);sum+=now-array[l];//计算移动距离now=array[l];l=l-1;}else{printf("%d ",array[r]);sum+=array[r]-now;//计算移动距离now=array[r];r=r+1;}}if(l==-1){for(j=r;j<m;j++){printf("%d ",array[j]);}sum+=array[m-1]-array[0];//计算移动距离}else- 4-哈尔滨理工大学课程设计报告{for(j=l;j>=0;j--){printf("%d ",array[j]);}sum+=array[m-1]-array[0];//计算移动距离}}avg=sum/m;printf("\n 移动的总道数： %d \n",sum);printf(" 平均寻道长度： %d \n",avg);}void SCAN(int array[],int m,int d)//先要给出当前磁道号和移动臂的移动方向{int k=1;int l,r;int i,j,sum=0;int avg;int temp; //用于排序的临时参数int q;for(i=0;i<m;i++)- 5-哈尔滨理工大学课程设计报告{for(j=i+1;j<m;j++){if(array[i]>array[j])//对磁道号进行从小到大排列{temp=array[i];array[i]=array[j];array[j]=temp;}}}if(array[m-1]<=now)//判断整个数组里的数是否都小于当前磁道号{printf("\n SCAN调度结果: ");for(i=m-1;i>=0;i--){printf("%d ",array[i]);//将数组磁道号从大到小输出 q=array[i];}sum=now-q;//计算移动距离s=s+sum;now=q;- 6-哈尔滨理工大学课程设计报告}else if(array[0]>=now)//判断整个数组里的数是否都大于当前磁道号{printf("\n SCAN调度结果: ");for(i=0;i<m;i++){printf("%d ",array[i]);//将磁道号从小到大输出q=array[i];}sum=array[m-1]-now;//计算移动距离s=s+sum;now=q;}else{while(array[k]<now)//逐一比较以确定K值{k++;}l=k-1;r=k;printf("\n SCAN调度结果: ");- 7-哈尔滨理工大学课程设计报告if(d==0){for(j=l;j>=0;j--){printf("%d ",array[j]);q=array[j];}for(j=r;j<m;j++){printf("%d ",array[j]);q=array[j];}sum=now-2*array[0]+array[m-1];//计算移动距离s=s+sum;now=q;}//磁道号减小方向else{for(j=r;j<m;j++){printf("%d ",array[j]);q=array[j];- 8-哈尔滨理工大学课程设计报告}for(j=l;j>=0;j--){printf("%d ",array[j]);q=array[j];}sum=-now-array[0]+2*array[m-1];//计算移动距离s=s+sum;now=q;}//磁道号增加方向}avg=sum/m;printf("\n 该子队列移动的总道数： %d \n",sum);printf(" 该子队列平均寻道长度： %d \n",avg);}void NStepSCAN(int array[],int m){int sn,N,d; //sn标记每一子队列的长度，N记录子队列个数，now标记当前磁道号int b[100],c[100]; //b[100]储存前几个子队列，c[100]储存最后一个子队列- 9-哈尔滨理工大学课程设计报告int i=0,j=0,k=0,n=1;int ave;printf("请输入当前磁道号：\n");scanf("%d",&now);printf("请输入子队列的个数：\n");scanf("%d",&N);while(N<1||N>m){printf("超出范围，文件中的磁道数不够分组，请重新输入：\n");scanf("%d",&N);}printf("请输入当前移动臂的移动的方向 (1 磁道号增加方向，0磁道号减小方向) : ");scanf("%d",&d);sn=m/N;while(N!=1) //当不是最后一个子队列时，循环进行SCAN调度{j=0;for(i=k;i<sn*n;i=k,j++){b[j]=array[i];k=k+1;}- 10-哈尔滨理工大学课程设计报告printf("\n第%d个队列的排序结果为：\n",n);SCAN(b,sn,d);N=N-1;n=n+1;}if(N==1) //最后一个子队列时进行SCAN调度{for(i=k,j=0;i<m;i++,j++){c[j]=array[i];}printf("\n最后一个队列的调度结果为：\n");SCAN(c,m-k,d);}ave=s/m;printf("\n该调度总的结果为：\n");printf("\n 移动的总道数： %d \n",s);printf(" 平均寻道长度： %d \n",ave);}int main(){- 11-哈尔滨理工大学课程设计报告int c;int C=1;FILE *fp;//定义指针文件int cidao[maxsize];//定义磁道号数组int i=0,count;fp=fopen("cidao.txt","r+");//读取cidao.txt文件if(fp==NULL)//判断文件是否存在{printf("\n 请先设置磁道! \n");exit(0);}while(!feof(fp))//如果磁道文件存在{fscanf(fp,"%d",&cidao[i]);//调入磁道号i++;}count=i;printf("\n --------------------------------------------------\n");printf(" 磁盘调度算法模拟");printf("\n --------------------------------------------------\n"); printf("\n 磁道读取结果：\n");for(i=0;i<count;i++)- 12-哈尔滨理工大学课程设计报告{printf("%5d",cidao[i]);//输出读取的磁道的磁道号}printf("\n ");while(C==1){printf(" ║操作系统课程设计║ \n"); printf(" ╭═════┤磁盘调度算法├═════╮ \n "); printf(" ║ 1.返回║ \n"); printf(" ║ 2.N步扫描算法(NStepScan) ║ \n"); printf(" ╰═┤请输入你的选择的算法(输入0离开) ├═╯ \n"); scanf("%d",&c);if(c==0) exit(0);printf(" ");while(c!=1&&c!=2){printf("输入数据超出范围，请重新输入您想进行的调度算法：\n");scanf("%d",&c);}switch(c){- 13-哈尔滨理工大学课程设计报告case 1:SSTF(cidao,count);//最短寻道时间优先算法printf("\n");break;case 2:i=0;fp=fopen("cidao.txt","r+");//读取cidao.txt文件 if(fp==NULL)//判断文件是否存在{printf("\n 请先设置磁道! \n");exit(0);}while(!feof(fp))//如果磁道文件存在{fscanf(fp,"%d",&cidao[i]);//调入磁道号i++;}count=i;printf("\n 磁道读取结果：\n");for(i=0;i<count;i++){printf("%5d",cidao[i]);//输出读取的磁道的磁道号- 14-哈尔滨理工大学课程设计报告}printf("\n ");NStepSCAN(cidao,count);//N步扫描算法printf("\n");break;}printf(" 是否继续(按0结束,按1继续)?");scanf("%5d",&C);}return(0);1.3流程图- 15-哈尔滨理工大学课程设计报告- 16-将磁道号从小到大排序array[m-1]<=now磁头移动总距离sum=now-array[i]输出磁盘调度序列array[j]i>=0(array[0]>=now输出磁盘调度序列array[j]i<m磁头移动总距离sum=array[i]-now确定当前磁道在已排的序列中的位置switch(d)case 0:移动臂向磁道号减小方向访问case 1:移动臂向磁道号增加方向访问输出磁盘调度序列输出磁盘调度序列输出子队列寻道总道数sum输出子队列平均寻道长度avg=sum/(m)流程图哈尔滨理工大学课程设计报告- 17-1.4 实现技术为实现上述设计，采用C++语言，VS2008开发环境。
计算机操作系统第七章--磁盘调度
7.1.1磁盘性能简述
2.移动头磁盘 每个盘面配一个磁头，装入磁臂 中，为能访问该盘面上的所有磁道，该 磁头必须移动进行寻道。移动头磁盘只 能进行串行读/写，I/O速度较慢，但结 构简单，广泛地用于中、小型磁盘设备 中。在微机上配置的温盘(温彻斯特)和 软盘，都采用移动磁头结构，故本节主 要针对这类磁盘的I/O进行讨论。
7.1.3 各种扫描算法
N步SCAN算法是将磁盘请求队 列分成若干个长度为N的子队列，磁 盘调度将按FCFS算法依次处理这些 子队列。每处理一个队列时，又是 按SCAN算法，对一个队列处理完后 又处理其它队列，这样就可避免出 现粘着现象。
7.1.3 各种扫描算法
当N值取得很大时，会使N步扫描 算法的性能，接近于SCAN算法的性 能，当N=1时，N步SCAN算法退化 为FCFS算法。
58
55 39
32
3 16
38
18
1
20
平均寻道长度：27.8
7.1.3 各种扫描算法
二、循环扫描CSCAN(Circular SCAN)单 向扫描 SCAN算法既能获得较好的性能， 又能访止进程饥饿，广泛用于大、中、 小型 机和网络中的磁盘调度。
7.1.3 各种扫描算法
问题：当磁头刚从里向外移动过 某一磁道时，恰有一进程请求访问 此磁道，这时该进程必须等待，待 磁头从里向外，然后再从外向里扫 描完所有要访问的磁道后，才处理 该进程的请求，致使该进程的请求 被严重地推迟。
7.1.3 各种扫描算法
被访问的下 一个磁道号 150 160 184 18 38 39 55 58 90 移动距离 (磁道数) 50 10 24 166 20 1 16 3 32
平均寻道长度：27.5
操作系统课程设计-模拟电梯调度算法 实现对磁盘的驱动调度
衡阳师范学院操作系统课程设计报告设计题目：驱动调度系别：计算机科学系专业：计算机科学与技术（师范）班级：1001班姓名：XXX学号：XXX指导教师：XXX2012年11月26日目录一、程序设计内容原理及目的·······························1、设计内容················································`2、设计原理·················································3、设计目的·················································二、程序设计过程·········································1、驱动调度中的数据结构设计·································2、程序算法设计··············································三、用户手册··············································1、运行坏境··················································2、执行文件··················································四、程序实现及运行结果····································1、源代码····················································2、代码······················································3、运行结果·················································五、心得总结···············································六、参考文献···············································二、程序设计内容原理及目的1、设计内容模拟电梯调度算法，实现对磁盘的驱动调度。
操作系统磁盘调度算法例题讲解
操作系统磁盘调度算法例题讲解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算法从一个方向开始处理请求，直到到达磁盘的边界。
磁盘调度实验报告_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为所需访问的磁道号所需移动的磁道数。
SCAN磁盘调度算法
SCAN磁盘调度算法哈尔滨理工大学(操作系统)题目: SCAN磁盘调度算法学院: 计算机科学与技术学院班级: 计算机系 10-8班姓名: 曾现坤 1004010828指导教师: 高雪瑶系主任: 林克正2013年03月01日目录1.SCAN磁盘调度算法课程设计 ..................................................................... . (1)1.1 题目分析 ..................................................................... ......................................... 1 1.2 数据结构 ..................................................................... ......................................... 1 1.3 流程图 ..................................................................... ............................................. 3 1.4 实现技术 ..................................................................... ......................................... 3 1.5 设计结论和心得 ..................................................................... .. (3)1.6 源代码...................................................................... .........................................3 2 Linux代码分析 ..................................................................... (12)2.1 功能说明 ..................................................................... (14)2.2 接口说明 ..................................................................... . (114)2.3 局部数据结构 ..................................................................... .. (114)2.4 流程图 ..................................................................... . (15)2.5 以实例说明运行过程 ..................................................................... . (16)- II-1.SCAN磁盘调度算法课程设计1.1 题目分析本课程设计的目的是通过设计一个磁盘调度模拟系统，从而使磁盘调度算法更加形象化，容易使人理解，使磁盘调度的特点更简单明了，能使使用者加深对先来先服务算法、最短寻道时间优先算法、扫描算法以及循环扫描算法等磁盘调度算法的理解。
磁盘IO读写流程图
磁盘IO读写流程图对于read系统调⽤在内核的处理，如上图所述，经过了VFS、具体⽂件系统，如ext2、页⾼速缓冲存层、通⽤块层、IO调度层、设备驱动层、和设备层。
其中，VFS主要是⽤来屏蔽下层具体⽂件系统操作的差异，对上提供⼀个统⼀接⼝，正是因为有了这个层次，所以可以把设备抽象成⽂件。
具体⽂件系统，则定义了⾃⼰的块⼤⼩、操作集合等。
引⼊cache层的⽬的，是为了提⾼IO效率。
它缓存了磁盘上的部分数据，当请求到达时，如果在cache 中存在该数据且是最新的，则直接将其传递给⽤户程序，免除了对底层磁盘的操作。
通⽤块层的主要⼯作是，接收上层发出的磁盘请求，并最终发出IO 请求（BIO）。
IO调度层则试图根据设置好的调度算法对通⽤块层的bio请求合并和排序，回调驱动层提供的请求处理函数，以处理具体的IO请求。
驱动层的驱动程序对应具体的物理设备，它从上层取出IO请求，并根据该IO请求中指定的信息，通过向具体块设备的设备控制器发送命令的⽅式，来操纵设备传输数据。
设备层都是具体的物理设备。
VFS层：内核函数sys_read是read系统调⽤在该层的⼊⼝点。
它根据⽂件fd指定的索引，从当前进程描述符中取出相应的file对象，并调⽤vfs_read执⾏⽂件读取操作。
vfs_read会调⽤与具体⽂件相关的read函数执⾏读取操作，file->f_op.read。
然后，VFS将控制权交给了ext2⽂件系统。
（ext2在此作为⽰例，进⾏解析）Ext2⽂件系统层的处理通过ext2_file_operations结构知道，上述函数最终会调⽤到do_sync_read函数，它是系统通⽤的读取函数。
所以说，do_sync_read才是ext2层的真实⼊⼝。
该层⼊⼝函数 do_sync_read 调⽤函数 generic_file_aio_read ，后者判断本次读请求的访问⽅式，如果是直接 io （filp->f_flags 被设置了 O_DIRECT 标志，即不经过 cache）的⽅式，则调⽤ generic_file_direct_IO 函数；如果是 page cache 的⽅式，则调⽤ do_generic_file_read 函数。