实验七磁盘调度算法的实现

合集下载

磁盘调度实验报告

操作系统实验报告课程名称：计算机操作系统实验项目名称：磁盘调度实验时间：班级：姓名：学号：实验目的：对操作系统的磁盘调度基础理论和重要算法的理解，加强动手能力。

实验环境：PC机 win7 Visual C++实验内容：编程序实现下述磁盘调度算法,并求出每种算法的平均寻道长度，要求设计主界面以灵活选择某算法，且以下算法都要实现：1、先来先服务算法（FCFS）2、最短寻道时间优先算法（SSTF）3、扫描算法（SCAN）4、循环扫描算法（CSCAN）实验过程：1.依次输入8个磁道数：123 45 31 67 20 19 38，并以0 结束2.选择调度算法：(1)先来先服务算法（FCFS）(2)最短寻道时间优先算法（SSTF）成绩：指导教师（签名）：(3)扫描算法（SCAN）(4)循环扫描算法（CSCAN）实验心得：通过本次实验，学习了解磁盘调度的工作原理及四种调度方法的工作原理，并且在当中发现了自己的不足，对以前所学过的知识理解得不够深刻，掌握得不够牢固，看到了自己的实践经验还是比较缺乏，理论联系实际的能力还急需提高。

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

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

目录一、课程设计目的 (3)二、课程设计要求 (3)三、课程设计原理 (3)四、程序代码 (5)五、流程图设计 (11)六、运行结果 (14)七、调试分析 (16)八、心得体会 (16)一、课程设计目的操作系统是最重要的计算机系统软件，同时也是最活跃的学科之一，发展极为迅速。

我们在本课程的实验过程中，要了解实际操作系统的工作过程，加深对操作系统基础理论和重要算法的理解，在实践过程中加深对操作系统原理的理解。

通过设计一个磁盘调度模拟系统，以加深对先来先服务、最短寻道时间、电梯算法以及循环扫描算法等磁盘调度算法的理解。

让我们更好地掌握操作系统中磁盘调度的原理及实现方法,增强动手能力。

本实验通过对磁盘调度算法的实现，加深对算法的理解，同时通过用C++语言编写程序实现这些算法，并在windows平台上实现，也再一次提高了自己编程的能力，提高了综合运用专业课知识的能力。

二、课程设计要求本设计的具体要求如下：1.模拟一个磁盘调度算法2.要求能够模拟FCFS、最短寻道时间、电梯算法等磁盘调度算法3.输入为一组作业的磁道请求4.输出为按选择的算法执行时的磁头移动轨迹三、课程设计原理1.各个算法分析（1）先来先服务算法（FCFS）这是一种最简单的磁盘调度算法。

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

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

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

当有进程先后提出磁盘I/O请求时，先按他们发出请求的先后次序排队。

然后依次给予服务。

其平均寻道距离较大，故先来先服务算法仅适用于请求磁盘I/O进程数目较少的场合。

（2）最短寻道时间优先算法（SSTF）该算法选择这样的进程：其要求访问的磁道与当前磁头所在的磁道距离最近，以使每次寻道时间最短。

但这种算法不能保证平均寻道时间最短。

有可能导致某个进程出现“饥饿”现象，因为只要不断有新进程请求到达，且其所要访问的磁道与磁头当前所在的磁道的距离较近，这种新进程的I/O请求必然优先满足。

磁盘调度算法的模拟实现课程设计报告

淮北师范大学操作系统课程设计磁盘调度算法的模拟实现学院计算机科学与技术专业计算机科学与技术（师范）学号学生姓名指导教师姓名2015年7月1日目录一、引言 (2)二、总体设计............................................... 错误！未定义书签。

1. 功能实现.................................................. 错误！未定义书签。

2. 流程图...................................................... 错误！未定义书签。

3. 具体内容 (3)三、实验验证 (5)1. 结果截图 (7)2. 代码分析 (6)四、源代码 (9)五、总结 (13)六、参考资料 (13)一、引言1、课程设计的目的：操作系统课程设计是计算机专业重要的教学环节，它为学生提供了一个既动手又动脑，将课本上的理论知识和实际有机的结合起来，独立分析和解决实际问题的机会。

●进一步巩固和复习操作系统的基础知识。

●培养学生结构化程序、模块化程序设计的方法和能力。

●提高学生调试程序的技巧和软件设计的能力。

●提高学生分析问题、解决问题以及综合利用C 语言进行程序设计的能力。

2、设计内容：设计并实现一个本别利用下列磁盘调度算法进行磁盘调度的模拟程序。

1FCFS2、SSTF3、设计要求：1.磁头初始磁道号，序列长度，磁道号序列等数据可从键盘输入，也可从文件读入。

2.最好能实现磁道号序列中磁道号的动态增加。

3.磁道访问序列以链表的形式存储4. 给出各磁盘调度算法的调度顺序和平均寻道长度二、总体设计1、算法实现1.先来先服务算法（FCFS）先来先服务（FCFS）调度:按先来后到次序服务，未作优化。

最简单的移臂调度算法是“先来先服务”调度算法，这个算法实际上不考虑访问者要求访问的物理位置，而只是考虑访问者提出访问请求的先后次序。

磁盘的调度算法

实验七磁盘的调度算法一.实验要求设计五个算法,分别是先来先服务算法,最短寻道时间优先算法,扫描(SCAN)算法,循环扫描(CSCAN)算法,NStepSCAN算法.由人工输入当前的磁道数,由系统随即生成要访问的磁道.二、开发环境操作系统:Rad Hat Linux ,开发环境:C语言.三、分析设计（一）实验原理.磁盘是可被多个进程共享的设备。

当有多个进程都请求访问磁盘时，应采用一种适当的调度算法，以使各进程对磁盘的平均访问(主要是寻道)时间最小。

由于在访问磁盘的时间中，主要是寻道时间，因此，磁盘调度的目标应是使磁盘的平均寻道时间最少。

(1) 先来先服务．(First-Come，First-Served，FCFS):这是一种简单的磁盘调度算法。

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

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

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

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

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

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

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

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

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

(4) 循环扫描(CSCAN)算法:处理该进程的请求，致使该进程的请求被严重地推迟。

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

操作系统磁盘调度实验报告一、实验目的：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。

实验七磁盘调度

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

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

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

由于磁盘访问时间主要受寻道时间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分别按照下列调度算法安排磁头服务序列，并计算寻道距离。

磁盘调度算法

命令行接口实验实验目的：了解命令行接口的使用实验内容：本课程设计的目的是通过磁盘调度算法设计一个磁盘调度模拟系统，从而使磁盘调度算法更加形象化，容易使人理解，使磁盘调度的特点更简单明了，能使使用者加深对先来先服务算法、最短寻道时间优先算法、扫描算法以及循环扫描算法等磁盘调度算法的理解运行程序截图：源程序：#include<stdio.h>#include<stdlib.h>#include<iostream>#include<math.h>#define maxsize 1000using namespace std;/*********************判断输入数据是否有效**************************/ 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、实验目的
（1）通过编写和调试磁盘调度算法的模拟程序以加深对磁盘调度算法的理解；
（2）熟悉FCFS磁盘调度算法的原理；
（3）了解磁盘中存取数据过程。

2、实验要求
编写并调试一个磁盘调度模拟程序，采用FCFS算法。

已知进程号及进程先后要访问的磁道数、磁头当前位置，要求使用FCFS算法输出磁头移动的磁道数和平均寻道数。

3、算法描述
先来先服务(FCFS，First Come First Served)，这是一种最简单的磁盘调度算法。

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

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

下图示出了有9个进程先后提出磁盘I/O请求时，当前磁道为100，按FCFS算法进行调度的情况。

（FCFS算法平均寻道距离较大，故FCFS算法仅适用于请求磁盘I/O的进程数目较少的场合。

）
4、源程序代码（同学们自己给出）
附加：课间或课后完成内容
（1）其它调度算法如SSTF的实现；（2）画出磁头的移动轨迹图。

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

磁盘调度算法的设计实验报告一、实验背景磁盘调度算法是操作系统中的重要内容之一，它的主要作用是优化磁盘的读写效率，提高系统的性能。

本次实验旨在通过设计不同的磁盘调度算法，比较它们在不同情况下的性能表现。

二、实验环境本次实验使用了Linux操作系统和C语言编程语言。

硬件环境为Intel Core i5处理器、4GB内存和500GB硬盘。

三、实验过程1. 先来看看什么是磁盘调度算法。

磁盘调度算法是指操作系统中用于管理磁盘I/O请求队列的算法。

常见的磁盘调度算法有FCFS(先来先服务)、SSTF(最短寻道时间优先)、SCAN(扫描)、LOOK(往返扫描)等。

2. 接下来我们分别对这些算法进行设计和实现，并进行性能测试。

3. 首先是FCFS算法。

FCFS算法就是按照请求到达时间的顺序进行服务，即先来先服务。

我们通过模拟生成一组随机数作为请求队列，然后计算出每个请求需要移动的距离，并计算出平均寻道长度。

4. 然后是SSTF算法。

SSTF算法是指选择距离当前磁头位置最近的请求进行服务。

我们同样使用模拟生成一组随机数作为请求队列，然后计算出每个请求与当前磁头位置的距离，并按照距离从小到大进行排序，然后依次服务每个请求，并计算出平均寻道长度。

5. 接下来是SCAN算法。

SCAN算法是指磁头从一端开始移动，直到到达另一端，然后返回原点继续移动。

我们同样使用模拟生成一组随机数作为请求队列，并将其按照磁头当前位置的左右分成两部分，分别从左往右和从右往左进行服务，并计算出平均寻道长度。

6. 最后是LOOK算法。

LOOK算法和SCAN类似，不同之处在于当服务完最远的请求时不会返回原点，而是直接返回最近的请求。

四、实验结果通过对以上四种磁盘调度算法进行测试，得到以下结果：1. FCFS平均寻道长度：1622. SSTF平均寻道长度：783. SCAN平均寻道长度：984. LOOK平均寻道长度：87五、实验结论从实验结果可以看出，SSTF算法的性能最优，平均寻道长度最短。

模拟实现磁盘调度算法

《操作系统》课程实验实验课题：模拟实现磁盘调度算法姓名：****学号：*****年级班级：08级信息与计算科学教学班级：操作系统专业方向：08信本软件方向指导教师：实验时间：2010-12-9一、实验名称:模拟实现磁盘调度算法1 实验目的：a、观察、体会操作系统的磁盘调度方法，并通过一个简单的磁盘调度模拟程序的实现，加深对磁盘调度的理解。

b、提高实际动手编程能力，为日后从事软件开发工作打下坚实基础。

2 实验要求：a、使用模块化设计思想来设计。

b、给出主函数和各个算法函数的流程图。

c、学生可按照自身条件，随意选择采用的算法。

二、实验算法分析总流程图三、实验内容及实验步骤1 实验内容a、模拟实现磁盘调度算法：FCFS，最短寻道优先，电梯算法（实现其中之一种以上）。

b、磁道请求服务顺序由用户输入（可通过从指定的文本文件（TXT文件）中取出）。

2 实验步骤1) 打开microsoft vasual C++ 6.0“开始”菜单—所有程序—单击“microsoft vasual C++ 6.0”，进入创建页面。

2）单击标题栏“文件”选择“新建”进入界面如下：选择‘工程，win32 console application’编辑工程名称‘zhuxuemin4’存储在d盘，创建‘创建新工作区’确定。

3）创建文件：单击标题栏“文件”选择“新建”进入界面类似于上面的界面。

4）在建好的文件中加入附件中的源程序，并进行编译。

四、实验原始记录及结果分析1 先来先服务调度算法2 最短寻道优先调度算法3电梯调度算法五、参考代码#include<stdio.h>#include<iostream.h>#include<string.h>#include<math.h>const int MAXQUEUE=200; //定义请求队列最大长度//磁道号请求结构体定义typedef struct TRACK_Node{ int iGo; //要访问的磁道号int iVisited; //磁道是否已经访问标志（1：已访问；0：末访问）}TRACK;TRACK queue[MAXQUEUE]; //磁道号请求队列数组int iReqNum=0; //磁道访问请求数int iStart=0; //磁头初始位置int iNow=0; //磁头当前位置int iSum=0; //总移动磁道数int iInput; //用户当前输入的整数char sFileName[20]; //文件名void Init() //初始化函数{int i;for(i=0;i<MAXQUEUE;i++){ queue[i].iGo=-1; //设置要访问的磁道号为不可能的数-1，以区别正常请求磁道号queue[i].iVisited=0; //设置磁道是否已经访问标志为0：末访问} } //void Init()void Reset() //重置访问标志、磁头当前位置、总移动磁道数{ int i;for(i=0;i<iReqNum;i++){ queue[i].iVisited=0; //设置磁道是否已经访问标志为0：末访问} printf( "\n 请输入磁头的初始磁道号（整数）: ");scanf("%d",&iStart); //从标准输入获取用户当前输入的磁头初始位置iNow=iStart; //磁头当前位置iSum=0; //总移动磁道数} //void Reset()int ReadTrackFile() //读入磁道号流文件{ FILE *fp;int iTemp;cout<<" \n 请输入磁道号流（文本）文件名（注意：包括后缀名）: ";cin>>sFileName; //从标准输入获取用户当前输入的文件名if((fp=fopen(sFileName,"r"))==NULL){ cout<<endl<<" 错误：磁道号流文件"<<sFileName<<" 打不开，请检查文件名和路径!!"<<endl; return -1; } else{ while(!feof(fp)) //将文件中输入的磁道号依次存入磁道号请求队列数组{ fscanf(fp,"%d ",&iTemp);queue[iReqNum].iGo=iTemp;iReqNum++; //磁道访问请求数} } //if((fp=fopen(sFileName,"r"))==NULL) return 0;} //void ReadTrackFile()void FCFS() //先来先服务调度算法{int i;Reset(); //重置访问标志、磁头当前位置、总移动磁道数cout<<endl<<"---------------------------------------------"<<endl;cout<<" 先来先服务调度算法的调度结果: "<<endl<<endl;cout<<" 初始磁道号: "<<iStart<<endl;cout<<" 序号下一磁道号移动的磁道数"<<endl;for(i=0;i<iReqNum;i++){ cout<<" "<<i+1<<" "<<queue[i].iGo<<" "<<abs(queue[i].iGo-iNow)<<endl;iSum+=abs(queue[i].iGo-iNow); //累加总移动磁道数iNow=queue[i].iGo; //设置磁头当前位置为当前访问磁道号} cout<<endl<<" 总调度次数: "<<iReqNum<<endl;cout<<endl<<" 总移动磁道数: "<<iSum<<endl;printf("\n 平均移动磁道数: %.2f\n\n",(float)iSum / (float)iReqNum);} //void FCFS()void SSTF() //最短寻道优先调度算法{ int i,j;int iNext; //下一磁道号Reset(); //重置访问标志、磁头当前位置、总移动磁道数cout<<endl<<"---------------------------------------------"<<endl;cout<<endl<<"---------------------------------------------"<<endl;cout<<" 最短寻道优先调度算法的调度结果: "<<endl<<endl;cout<<" 初始磁道号: "<<iStart<<endl;cout<<" 序号下一磁道号移动的磁道数"<<endl;for(i=0;i<iReqNum;i++){ iNext=0;while(queue[iNext].iVisited!=0) //跳过已访问的磁道号{ iNext++; } //whilefor(j=iNext;j<iReqNum;j++){ //寻找下一个寻道距离最短的末访问磁道号if((queue[j].iVisited==0)&&(abs(iNow-queue[iNext].iGo)>abs(iNow-queue[j].iGo))){ iNext=j; } } //for(j=iNext;j<iReqNum;j++)cout<<" "<<i+1<<" "<<queue[iNext].iGo<<" "<<abs(queue[iNext].iGo-iNow)<<endl;iSum+=abs(queue[iNext].iGo-iNow); //累加总移动磁道数queue[iNext].iVisited=1; //设置磁道是否已经访问标志为1：已访问iNow=queue[iNext].iGo; //设置磁头当前位置为当前访问磁道号} //for(i=0;i<iReqNum;i++)cout<<endl<<" 总调度次数: "<<iReqNum<<endl;cout<<endl<<" 总移动磁道数: "<<iSum<<endl;printf("\n 平均移动磁道数: %.2f\n\n",(float)iSum / (float)iReqNum);} //void SSTF()void SCAN() //电梯调度算法{ int i,j;int iNext; //下一磁道号int iMinMove; //当前方向上最短寻道距离cout<<endl<<"---------------------------------------------"<<endl;cout<<endl<<" 请选择磁头初始方向（ 1 OR 2）："<<endl<<endl;cout<<" 1 磁头初始向内"<<endl<<endl<<" 2 磁头初始向外"<<endl<<endl<<" "; cin>>iInput; //从标准输入获取用户当前输入的整数switch(iInput) //用户当前输入的整数{case 1: //磁头初始向内Reset(); //重置访问标志、磁头当前位置、总移动磁道数cout<<endl<<"---------------------------------------------"<<endl;cout<<" 电梯调度算法--磁头初始向内的调度结果: "<<endl<<endl;cout<<" 初始磁道号: "<<iStart<<endl;cout<<" 序号下一磁道号移动的磁道数"<<endl;for(i=0;i<iReqNum;i++){iMinMove=9999;iNext=-1;for(j=0;j<iReqNum;j++) //寻找当前方向上寻道距离最短的末访问磁道号{ if((queue[j].iVisited==0)&&(queue[j].iGo>=iNow)){ if(abs(queue[j].iGo-iNow)<iMinMove){ iNext=j;iMinMove=abs(queue[j].iGo-iNow);} //if(abs(queue[j].iGo-iNow)<iMinMove)} //if((queue[j].iVisited==0)&&(queue[j].iGo>=iNow))} //for(j=0;j<iReqNum;j++)if(iNext!=-1){ cout<<" "<<i+1<<" "<<queue[iNext].iGo<<" "<<abs(queue[iNext].iGo-iNow)<<endl;iSum+=abs(queue[iNext].iGo-iNow); //累加总移动磁道数iNow=queue[iNext].iGo; //设置磁头当前位置为当前访问磁道号queue[iNext].iVisited=1; //设置磁道是否已经访问标志为1：已访问} //if(iNext!=-1) else //掉头向外{ for(j=0;j<iReqNum;j++) //寻找当前方向上寻道距离最短的末访问磁道号{ if((queue[j].iVisited==0)&&(queue[j].iGo<iNow)){ if(abs(queue[j].iGo-iNow)<iMinMove){ iNext=j;iMinMove=abs(queue[j].iGo-iNow);} } } //for(j=0;j<iReqNum;j++)cout<<" "<<i+1<<" "<<queue[iNext].iGo<<" "<<abs(queue[iNext].iGo-iNow)<<endl;iSum+=abs(queue[iNext].iGo-iNow); //累加总移动磁道数iNow=queue[iNext].iGo; //设置磁头当前位置为当前访问磁道号queue[iNext].iVisited=1; //设置磁道是否已经访问标志为1：已访问} //if(iNext!=-1) } //for(i=0;i<iReqNum;i++)cout<<endl<<" 总调度次数: "<<iReqNum<<endl;cout<<endl<<" 总移动磁道数: "<<iSum<<endl;printf("\n 平均移动磁道数: %.2f\n\n",(float)iSum / (float)iReqNum);break;case 2: //磁头初始向外Reset(); //重置访问标志、磁头当前位置、总移动磁道数cout<<endl<<"---------------------------------------------"<<endl;cout<<endl<<endl<<" 电梯调度算法--磁头初始向外的调度结果: "<<endl<<endl;cout<<" 初始磁道号: "<<iStart<<endl;cout<<" 序号下一磁道号移动的磁道数"<<endl;for(i=0;i<iReqNum;i++){ iMinMove=9999;iNext=-1;for(j=0;j<iReqNum;j++) //寻找当前方向上寻道距离最短的末访问磁道号{ if((queue[j].iVisited==0)&&(queue[j].iGo<=iNow)){ if(abs(queue[j].iGo-iNow)<iMinMove){ iNext=j;iMinMove=abs(queue[j].iGo-iNow);} //if(abs(queue[j].iGo-iNow)<iMinMove)} //if((queue[j].iVisited==0)&&(queue[j].iGo<=iNow))} //for(j=0;j<iReqNum;j++)if(iNext!=-1){ cout<<" "<<i+1<<" "<<queue[iNext].iGo<<" "<<abs(queue[iNext].iGo-iNow)<<endl;iSum+=abs(queue[iNext].iGo-iNow); //累加总移动磁道数iNow=queue[iNext].iGo; //设置磁头当前位置为当前访问磁道号queue[iNext].iVisited=1; //设置磁道是否已经访问标志为1：已访问} else //掉头向内{ for(j=0;j<iReqNum;j++) //寻找当前方向上寻道距离最短的末访问磁道号{ if((queue[j].iVisited==0)&&(queue[j].iGo>iNow)){ if(abs(queue[j].iGo-iNow)<iMinMove){ iNext=j;iMinMove=abs(queue[j].iGo-iNow); } //if(abs(queue[j].iGo-iNow)<iMinMove)} //if((queue[j].iVisited==0)&&(queue[j].iGo>iNow))} //for(j=0;j<iReqNum;j++) cout<<" "<<i+1<<" "<<queue[iNext].iGo<<" "<<abs(queue[iNext].iGo-iNow)<<endl;iSum+=abs(queue[iNext].iGo-iNow); //累加总移动磁道数iNow=queue[iNext].iGo; //设置磁头当前位置为当前访问磁道号queue[iNext].iVisited=1; //设置磁道是否已经访问标志为1：已访问} //if(iNext!=-1)} //for(i=0;i<iReqNum;i++)cout<<endl<<" 总调度次数: "<<iReqNum<<endl;cout<<endl<<" 总移动磁道数: "<<iSum<<endl;printf("\n 平均移动磁道数: %.2f\n\n",(float)iSum / (float)iReqNum);break;default:printf("\n 输入错误!!\n\n");return;} //switch(iInput)} //void SCAN()void Version() //显示版权信息函数{ cout<<endl<<endl;cout<<" ┏━━━━━━━━━━━━━━━━━━━━━━━┓"<<endl;cout<<" ┃磁盘调度算法模拟系统┃"<<endl;cout<<" ┠───────────────────────┨"<<endl;cout<<" ┃(c)All Right Reserved ┃"<<endl;cout<<" ┃程坤┃"<<endl;cout<<" ┃Version 2010 build 2.0 ┃"<<endl;cout<<" ┗━━━━━━━━━━━━━━━━━━━━━━━┛"<<endl;cout<<endl<<endl; }// void Version()void main(){ int i;bool bGoOn; //是否继续磁盘调度算法模拟的标志char sGoOn[1]; //用户输入是否继续磁盘调度算法模拟的字母：y、Y、N、nVersion();//显示版权信息函数Init(); //初始化函数if(ReadTrackFile()==-1) //读入磁道号流文件{printf(" 读入磁道号流文件失败!!\n\n"); }else{bGoOn= true;while (bGoOn){cout<<endl<<"---------------------------------------------"<<endl;cout<<" 从磁道号流文件"<<sFileName<<" 所读入的磁道号流如下:"<<endl<<endl<<" ";for(i=0;i<iReqNum;i++){ cout<<queue[i].iGo<<" "; }cout<<endl<<endl<<" 请求数为: "<<iReqNum<<endl<<endl;iInput=-1; //用户输入的整数以选择算法cout<<endl<<" 请输入算法编号（ 1 OR 2 OR 3）选择调度算法："<<endl<<endl; cout<<"1 先来先服务调度算法"<<endl<<endl<<"2 最短寻道优先调度算法"<<endl<<endl<<"3 电梯调度算法"<<endl<<endl<<" ";cin>>iInput; //从标准输入获取用户当前输入的整数switch(iInput) //用户输入的整数以选择算法{case 1: FCFS(); //先来先服务调度算法break;case 2: SSTF(); //最短寻道优先调度算法break;case 3:SCAN(); //电梯调度算法break;default:printf("\n 输入的算法编号错误!!\n\n");return; } //switch(iInput)bGoOn= false;strcpy(sGoOn," ");cout<<" 要继续进行磁盘调度算法模拟吗?(Y/N) "<<endl<<" ";cin>>sGoOn;bGoOn=(sGoOn[0]=='y'||sGoOn[0]=='Y');} //while bGoOn } //if(ReadTrackFile()==-1) }【下载本文档，可以自由复制内容或自由编辑修改内容，更多精彩文章，期待你的好评和关注，我将一如既往为您服务】精品文档交流。

磁盘调度算法的模拟实现

磁盘调度算法的模拟实现学院专业学号学生姓名指导教师姓名2014年3月19日目录一、课设简介 (2)1.1 课程设计题目 (2)1.2 课程设计目的 (2)1.3 课程设计要求 (2)二、设计内容 (3)2.1功能实现 (3)2.2流程图 (3)2.3具体内容 (3)三、测试数据 (4)3.3 测试用例及运行结果 (4)四、源代码 (5)五、总结 (12)5.1 总结............................................一、课设简介1.1课程设计题目磁盘调度算法的模拟实现11.2程序设计目的操作系统课程设计是计算机专业重要的教学环节，它为学生提供了一个既动手又动脑，将课本上的理论知识和实际有机的结合起来，独立分析和解决实际问题的机会。

1）进一步巩固和复习操作系统的基础知识。

2）培养学生结构化程序、模块化程序设计的方法和能力。

3）提高学生调试程序的技巧和软件设计的能力。

4）提高学生分析问题、解决问题以及综合利用C语言进行程序设计的能力。

1.3 设计要求1）磁头初始磁道号，序列长度，磁道号序列等数据可从键盘输入，也可从文件读入。

2）最好能实现磁道号序列中磁道号的动态增加。

3）磁道访问序列以链表的形式存储4）给出各磁盘调度算法的调度顺序和平均寻道长度二、设计内容2.1 功能实现设计并实现一个本别利用下列磁盘调度算法进行磁盘调度的模拟程序。

1）FCFS 2）SSTF2.2流程图2.3具体内容1)先来先服务算法FCFS这是一种比较简单的磁盘调度算法。

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

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

此算法由于未对寻道进行优化，在对磁盘的访问请求比较多的情况下，此算法将降低设备服务的吞吐量，致使平均寻道时间可能较长，但各进程得到服务的响应时间的变化幅度较小。

2)最短寻道时间优先算法SSTF该算法选择这样的进程，其要求访问的磁道与当前磁头所在的磁道距离最近，以使每次的寻道时间最短，该算法可以得到比较好的吞吐量，但却不能保证平均寻道时间最短。

实验磁盘调度算法

实验七：磁盘调度算法目录一．实验目的加深对磁盘的工作原理和调度效率的理解，掌握各种磁盘调度算法，模拟实现一种磁盘调度算法<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]。

磁盘调度算法实验报告 (2)

磁盘调度算法学生姓名:学生学号:专业班级:指导老师：2013年6月20日1、实验目的：通过这次实验，加深对磁盘调度算法的理解，进一步掌握先来先服务FCFS、最短寻道时间优先SSTF、SCAN和循环SCAN算法的实现方法。

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

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

3、需求分析通过这次实验，加深对磁盘调度算法的理解，进一步掌握先来先服务FCFS、最短寻道时间优先SSTF、SCAN和循环SCAN算法的实现方法。

通过已知开始磁道数、访问磁道总数、磁道号访问序列、访问方向及访问方式得到访问序列及移动距离和平均移动距离！(1)输入的形式；int TrackOrder[MaxNumber];//被访问的磁道号序列 int direction;//寻道方向int Num;//访问的磁道号数目int start;//(2)输出的形式；int MoveDistance[MaxNumber]={0};//移动距离double AverageDistance=0;//平均寻道长度移动的序列！(3)程序所能达到的功能；模拟先来先服务FCFS、最短寻道时间优先SSTF、SCAN和循环SCAN 算法的工作过程。

(4)测试数据，包括正确的输入及其输出结果和含有错误的输入及其输出结果。

开始磁道号：100磁道号方向：内（0）和外（1）磁道号数目：9页面序列：55 58 39 18 90 160 150 38 1844、概要设计说明本程序中用到的所有抽象数据类型的定义、主程序的流程以及各程序模块之间的层次(调用)关系。

磁盘调度算法实验报告 (2)(优选.)

最新文件---------------- 仅供参考--------------------已改成-----------word文本 --------------------- 方便更改赠人玫瑰，手留余香。

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

3、需求分析通过这次实验，加深对磁盘调度算法的理解，进一步掌握先来先服务FCFS、最短寻道时间优先SSTF、SCAN和循环SCAN算法的实现方法。

通过已知开始磁道数、访问磁道总数、磁道号访问序列、访问方向及访问方式得到访问序列及移动距离和平均移动距离！(1)输入的形式；int TrackOrder[MaxNumber];//被访问的磁道号序列int direction;//寻道方向int Num;//访问的磁道号数目int start;//(2)输出的形式；int MoveDistance[MaxNumber]={0};//移动距离double AverageDistance=0;//平均寻道长度移动的序列！(3)程序所能达到的功能；模拟先来先服务FCFS、最短寻道时间优先SSTF、SCAN和循环SCAN算法的工作过程。

天津理工大学-操作系统实验3：磁盘调度算法的实现

天津理工大学-操作系统实验3：磁盘调度算法的实现实验报告学院（系）名称：计算机与通信工程学院【实验过程记录（源程序、测试用例、测试结果及心得体会等）】#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;}}}//============FCFS,先来先服务=================================void FCFS(){int temp;temp=BeginNum; //--------将BeginNum赋给temp作为寻道时的当前所在磁道号for(int i=0;i<N;i++){MoveDistance[i]=abs(TrackOrder[i]-temp);//-------计算移动磁道数temp=TrackOrder[i];//-------寻到后，将此道作为当前所在磁道号，赋给temp FindOrder[i]=TrackOrder[i];//-----寻好的赋给寻好序列}}//========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]; //-------当前寻道A=M; //-----重置A值FindOrder[i]=TrackOrder[n]; //----寻好的赋给寻好序列}}//=====================SCAN,扫描算法==========================void SCAN(){int m,n,temp;temp=BeginNum;Sort();//------排序cout<<"请选择开始方向：1--向外;0---向里"; //------选择扫描方向cin>>m;if(m==1)direction=true;else if(m==0)direction=false;cout<<"输入错误";for(int i=0;i<N;i++){if(SortOrder[i]<BeginNum)continue;else{n=i;break;}}if(direction==true) //------选择向外{for(int i=n;i<N;i++){MoveDistance[i-n]=abs(SortOrder[i]-temp);temp=SortOrder[i];FindOrder[i-n]=SortOrder[i];}for(int j=n-1;j>=0;j--){MoveDistance[N-1-j]=abs(SortOrder[j]-temp);temp=SortOrder[j];FindOrder[N-1-j]=SortOrder[j];}}else //-------选择向里{for(int i=n-1;i>=0;i--){MoveDistance[N-i-4]=abs(SortOrder[i]-temp);temp=SortOrder[i];FindOrder[N-i-4]=SortOrder[i];}for(int j=n;j<N;j++){MoveDistance[j]=abs(SortOrder[j]-temp);temp=TrackOrder[j];FindOrder[j]=SortOrder[j];}}}//=================CSCAN,循环扫描算法=======================void CSCAN(){int m,n,temp;temp=BeginNum;Sort();cout<<"请选择开始方向：1--向外;0---向里"; cin>>m;if(m==1)direction=true;else if(m==0)direction=false;elsecout<<"输入错误";for(int i=0;i<N;i++){if(SortOrder[i]<BeginNum)continue;else{n=i;break;}}if(direction==true){for(int i=n;i<N;i++){MoveDistance[i-n]=abs(SortOrder[i]-temp);temp=SortOrder[i];FindOrder[i-n]=SortOrder[i];}for(int j=0;j<n;j++){MoveDistance[N-n+j]=abs(SortOrder[j]-temp);temp=SortOrder[j];FindOrder[N-n+j]=SortOrder[j];}}else{for(int i=n-1;i>=0;i--){MoveDistance[n-1-i]=abs(SortOrder[i]-temp);temp=SortOrder[i];FindOrder[n-1-i]=SortOrder[i];}for(int j=N-1;j>=n;j--){MoveDistance[N-j+n-1]=abs(SortOrder[j]-temp);temp=SortOrder[j];FindOrder[N-j+n-1]=SortOrder[j];}}}//========计算平均寻道时间============== void Count(){int Total=0;for(int i=0;i<N;i++){Total+=MoveDistance[i];}AverageDistance=((double)Total)/((double)N);}void Show(){cout<<"================从"<<BeginNum<<"号磁道开始====================="<<endl;cout<<setw(20)<<"被访问的下一个磁道号"<<setw(20)<<"移动距离(磁道数)"<<endl;for(int i=0;i<N;i++){cout<<setw(15)<<FindOrder[i]<<setw(15)<<MoveDista nce[i]<<endl;}cout<<setw(20)<<"平均寻道长度:"<<AverageDistance<<endl;cout<<endl;}int main(){int y=1;int s;Inith();while(y){cout<<"请选择寻道方式：1--FCFS; 2--SSTF;3--SCAN;4--CSCSN;";cin>>s;switch(s){case 1:FCFS();Count();Show();break;case 2:SSTF();Count();Show();break;case 3:SCAN();Count();Show();break;case 4:CSCAN();Count();Show();break;}cout<<"是否继续选择寻道算法？1--是；2--否";int p;cin>>p;y=p;}return 0;}实验结果:FCFS方式：Sstf方式：SCAN方式：4.CSCSN。

磁盘调度实现

实验七：磁盘调度算法一、目的理解磁盘调度原理。

二、实验内容实现SSTF算法和SCAN算法。

三、实验要求测试：设有100个磁道，访问序列如下：23，5，98，14，66，25，78，34，66，74，56，87，12，39，71，49，58当前磁头在50道，上次访问的磁道是18道。

四、实验代码#include"stdio.h"void scan(int star, int *rom, int n){int i, j;for( i=0; i<n; i++)//寻找star在rom中的位置{if(rom[i]>=star) break;}for( j = i; j<n; j++)//输出star右边的数{printf("%d ", rom[j]);}for( j=i-1; j>=0; j--)//输出star左边的数{printf("%d ", rom[j]);}printf("\n\n");}void sstf(int star, int *rom, int n){int temp, i, min, j=0, k;for( i=0; i<n; i++)//寻找star在有序rom中的位置{if(rom[i]>=star) break;}j = i-1;while(j>=0 || i<n)//寻找距star最近的磁道{if( (i<n && j>=0 &&(star - rom[j] > rom[i]-star)) || j<0 ){//star左右都有未访问的磁道且右边的距star较近，或者satr只有右边有未访问的磁道star = rom[i];printf("%d ", rom[i++]);}else{//star左右都有未访问的磁道且左边的距star较近，或者satr只有左边有未访问的磁道star = rom[j];printf("%d ", rom[j--]);}}printf("\n\n");}void sort(int *rom, int n)//选择排序{int i, j, min, k, temp;j = 1;while(j<n){min = rom[j-1], k = j-1;for( i=j; i<n; i++){if(rom[i] < min) min = rom[i], k = i;}if(k!=j-1){temp = min;rom[k] = rom[j-1];rom[j-1] = min;}j++;}}int main(){int rom[1000];int i=0, select, star;printf("请输入磁道的访问序列：(cntrl+z表示输入结束)\n");while(scanf("%d", &rom[i++])==1);i--;sort(rom, i);//选择排序while(1){printf("请选择：1.sstf算法 2.scan算法0.退出\n你的选择是：");scanf("%d", &select);if(select==0) break;printf("请输入起始位置:");scanf("%d", &star);if(select==1) sstf(star, rom, i);if(select==2) scan(star, rom, i);}return 0;}五、测试数据。

实验七 磁盘调度算法的实现

磁盘调度实验报告

磁盘调度算法

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

磁盘调度算法的模拟实现课程设计报告

磁盘的调度算法

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

实验七 磁盘调度

磁盘调度算法

实验七 磁盘调度算法的实现

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

模拟实现磁盘调度算法

磁盘调度算法的模拟实现

实验磁盘调度算法

磁盘调度算法实验报告 (2)

磁盘调度算法实验报告 (2)(优选.)

天津理工大学-操作系统实验3：磁盘调度算法的实现

磁盘调度实现

实验七磁盘调度算法的实现

实验七磁盘调度

实验七磁盘调度算法的实现