磁盘调度算法文档

合集下载

磁盘调度算法

磁盘调度算法

实验六磁盘调度算法【实验目的】通过这次实验,加深对磁盘调度算法的理解,进一步掌握先来先服务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、缺点:效率不⾼,相邻两次请求可能会造成最内到最外的柱⾯寻道,使磁头反复移动,增加了服务时间,对机械也不利。

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

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

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

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

常见的磁盘调度算法有:FCFS(先来先服务)、SSTF (最短寻道时间)、SCAN(扫描)、C-SCAN(循环扫描)等。

三、实验过程1.编写代码实现磁盘调度算法首先,我们需要定义一个磁盘请求队列,其中存放所有的IO请求。

然后,根据所选的磁盘调度算法,实现对磁盘请求队列的处理和IO请求的调度。

最后,展示运行结果。

以FCFS算法为例,伪代码如下所示:```diskQueue = new DiskQueue(; // 创建磁盘请求队列while (!diskQueue.isEmpty()request = diskQueue.dequeue(; // 取出队列头的IO请求//处理IO请求displayResult(; // 展示运行结果```2.运行实验并记录数据为了验证各种磁盘调度算法的性能差异,我们可以模拟不同的场景,例如,随机生成一批磁盘IO请求,并使用不同的磁盘调度算法进行处理。

记录每种算法的平均响应时间、平均等待时间等指标。

3.撰写实验报告根据实验数据和结果,撰写实验报告。

实验报告通常包括以下内容:引言、实验目的、实验原理、实验步骤、实验结果、实验分析、结论等。

四、实验结果与分析使用不同的磁盘调度算法对磁盘IO请求进行处理,得到不同的实验结果。

通过对比这些结果,我们可以看出不同算法对磁盘IO性能的影响。

例如,FCFS算法对于请求队列中的请求没有排序,可能会导致一些请求等待时间过长。

而SSTF算法通过选择离当前磁道最近的请求进行处理,能够减少平均寻道时间,提高磁盘性能。

五、实验总结通过本次实验,我们学习了操作系统中磁盘调度算法的原理和实现过程。

不同的磁盘调度算法具有不同的优缺点,我们需要根据实际情况选择合适的算法。

C语言 磁盘调度算法 (FCFS SSTF SCAN CSCAN)

C语言 磁盘调度算法 (FCFS SSTF SCAN CSCAN)
0.退出
1.FCFS算法实现
2.SSTF算法实现
3.SCAN算法实现
4.CSCAN算法
5.显示对比表
=================================
【实验要求】可选编程语言:C/C++/Java/C#/Python;
实现在同一个程序文件中(C/C++);
请适当注释;
报告正文(运行屏幕截图及源代码)
{
sum += abs(track[i] - adress);
adress = track[i];
}
return sum;
}
int Get_SSTF_index(int t, int *flag)
{
int i, f = 0, min = 10000, juli = 0, l;
for(i = 0; i < 9; i++)
{
juli = abs(track[i] - t);
if(juli > 0 && juli < min && flag[i] ==0)
{
min = juli;
f = i;
}
}
return f;
}
bool IsEmpty(int *flag)
{
int i = 0;
for(i = 0; i < 9; i++)
一.截屏。
2.附录。
#include<stdio.h>
#include<Math.h>
static int track[9] = {55, 58, 39, 18, 90, 160, 150, 38, 184};

磁盘调度算法-电脑资料.

磁盘调度算法-电脑资料.

磁盘调度算法 -电脑资料2019-01-01磁盘优点容量很大每位的价格非常低当关掉电源后存储信息不丢失物理特性磁盘表面覆盖着磁性物质,信息记录在磁表面上,。

固定头磁盘的每个磁道单独有一个磁头,这样就能使得计算机可以很快地从一个磁道转换到另一个磁道。

但是这需要大量的头,设备成本很高。

更通用的方式是每个盘面只有一个头,让它从一道移向另一道。

这种动头设备需要硬件设备移动头。

磁盘一般用于文件存储,设计原则是:成本低、容量大、速度高。

扩大存储容量:a.增加每英寸磁道数目; b. 双面记录。

存取盘块中的信息一般要有三部分时间:系统首先要把磁头移到相应的道上或柱面上,这个时间叫做寻道时间;一旦磁头到达指定磁道,必须等待所需要的扇区转到读/写头下,这个延迟时间叫做旋转延迟时间;最后,信息实际在磁盘和内存之间进行传送也要花费时间,这部分时间叫做传送时间。

一次磁盘服务的总时间就是这三者之和。

要使磁盘服务尽可能地快,操作系统要提供合适的调度算法,改善磁盘服务的平均时间。

进程需要和磁盘交换信息时必须要操作系统发出系统调用,对磁盘的请求一般要有下述几部分内容:1. 输入和输出;2. 磁盘地址(驱动器、柱面、面号、扇区);3. 内存地址;4. 传送长度。

磁盘调度算法1、先来先服务调度(FCFS)FCFS 算法是优先为最先到达的请求服务。

例如,有如下请求磁盘服务队列,要访问的磁道数分别是:98,183,37,122,14,124,65,67排在前面的是先到达的请求,假设磁头目前停留在53磁道上,按照先来先服务的算法,接下来磁头的移动顺序依次是:53—>98—>183—>37—>122—>14—>124—>65—>67这个过程总共移动了(98-53)+(183-98)+(183-37)+(122-37)+(122-14)+(124-14)+(124-65)+(67-65)=640个磁道这种调度法产生的磁头移动服务太大,磁头频繁的大幅度移动,容易产生机械振动和误差,对使用寿命有损害。

操作系统磁盘调度算法

操作系统磁盘调度算法

#include<stdio.h>#include<math.h>#include<stdlib.h>#define N 20typedef struct{int num;//磁道int flag;//1个标记量}V,*v;//********************************************************************* void Initial(v *a,int n){//初始化磁道请求printf("请输入请求顺序(磁道范围是0 - 199):\n");for(int i = 1;i <= n;i++){a[i] = (v)malloc(sizeof(V));if(!a[i]) exit(-1);scanf("%d",&a[i]->num);a[i]->flag = 0;}}//*********************************************************************** void FCFS(v *a,int start,int n){//先到先服务算法int temp = start;float s = 0;printf("---------------------------FCFS调度算法----------------------------\n");for(int i = 1;i <= n; i++){temp = abs(a[i]->num - temp);s += temp;a[i]->flag = i;temp = a[i]->num;}int temp2;for(i = n;i >= 1;i--){//冒泡排序,按照磁道访问的先后顺序重新排列数组a,用于输出调度顺序for(int j = 1;j < i;j ++){if(a[j]->flag> a[j+1]->flag){temp = a[j]->flag;temp2 = a[j]->num;a[j]->flag = a[j+1]->flag;a[j]->num = a[j+1]->num;a[j+1]->flag = temp;a[j+1]->num = temp2;}}}printf("调度序列为:\n");printf("%d—>",start);for(i = 1;i <= n; i++){printf("%d —> ",a[i]->num);}printf("\n");printf("寻道长度是%f",s);printf("\n");printf("平均寻道长度是%f",s/n);printf("\n");printf("---------------------------FCFS调度算法----------------------------\n");}//************************************************************************ int Find(v *a,int n,int start){//找到离开始磁道最近的一项,返回下标int p;for(int i = 1;i < n;i++){if((a[i]->num <= start) && (start <=a[i+1]->num )){if(abs(a[i]->num - start) < abs(a[i+1]->num - start)){p = i;}else{p= i+1;}}}return p;}void SSTF(v *a,int start,int n){//最短寻道时间调度算法int temp;int pr,pl;//分别标记离磁头最近的那个磁道在数组中的下标的前一个和后一个float s = 0; //用来计算寻道长度temp = start;printf("---------------------------SSTF调度算法----------------------------\n");for(int i = n;i >= 1;i--){//冒泡排序,把磁道按由小到大的顺序排列for(int j = 1;j < i;j ++){if(a[j]->num > a[j+1]->num){temp = a[j]->num;a[j]->num = a[j+1]->num;a[j+1]->num = temp;}}}printf("排序后\n");for(int j=1;j<=n;j++)printf("%d ",a[j]->num);printf("\n");int p,x;p = Find(a,n,start);x = p;pr = p + 1;pl = p - 1;if(start <= a[1]->num){//磁头在最左边s =(float)(a[1]->num-start);printf("调度序列为:\n");printf("%d—>",start);for(i = 1;i <= n; i++){if(i!=1){s+=a[i]->num-a[i-1]->num;}printf("%d —> ",a[i]->num);}printf("\n");printf("寻道长度为%f",s);printf("\n");printf("平均寻道长度是%f",s/n);printf("\n");}else if(start >= a[n]->num){//磁头在最右边s =(float)(start-a[n]->num);printf("调度序列为:\n");printf("%d—>",start);for(i = n; i >= 1; i--){if(i!=1){s += a[i]->num-a[i-1]->num;}printf("%d —> ",a[i]->num);}printf("\n");printf("寻道长度为%f",s);printf("平均寻道长度是%f",s/n);printf("\n");}else{//磁头在中间printf("调度序列为:\n");printf("%d—>",start);printf("%d —> ",a[p]->num);s = (float)(a[p]->num - start);while(1){if(abs(a[pl]->num - a[p]->num) <= abs(a[p]->num - a[pr]->num)){s += a[p]->num-a[pl]->num;p = pl;printf("%d —> ",a[p]->num);pl--;if(pl==0){s += a[pr]->num-a[1]->num;s += a[n]->num-a[pr]->num;for(int i=pr;i<=n;i++){printf(" %d—>",a[i]->num);}break;}}else{s += a[pr]->num-a[p]->num;p = pr;printf("%d —> ",a[p]->num);pr++;if(pr==n+1){s += a[n]->num-a[pl]->num;s += a[pl]->num-a[1]->num;for(int i=pl;i>=1;i--){printf("%d —> ",a[i]->num);}break;}}}printf("\n");printf("寻道长度为%f",s);printf("\n");printf("平均寻道长度是%f",s/n);printf("\n");}printf("---------------------------SSTF调度算法----------------------------\n");}//********************************************************************** void SCAN(v *a,int start,int n){//电梯算法int l = 0 ;//用于设置访问磁道的flagint temp,temp2;for(int i = n;i >= 1;i--){//冒泡排序,把磁道按由小到大的顺序排列for(int j = 1;j < i;j ++){if(a[j]->num > a[j+1]->num){temp = a[j]->num;a[j]->num = a[j+1]->num;a[j+1]->num = temp;}}}int p,x;p = Find(a,n,start);x = p;float s = 0;int toleft,toright;printf("---------------------------SCAN调度算法----------------------------\n"); if(abs(start - a[1]->num) < abs(a[n]->num - start))toleft = 1;//磁头离最左端的磁道近elsetoright = 1;//磁头离最右端的磁道近temp = start;if(toleft == 1){//先向0磁道方向访问while(p != 0){temp = abs(a[p]->num - temp);s += temp;l += 1;temp = a[p]->num;a[p]->flag = l;p--;}s += a[1]->num - 0;temp = 0;x = x + 1;while(x != n){temp = abs(a[x]->num - temp);s += temp;l += 1;temp = a[x]->num;a[x]->flag =l;x++;}for(i = n;i >= 1;i--){//冒泡排序,按照访问的顺序将数组重新排列for(int j = 1;j < i;j ++){if(a[j]->flag> a[j+1]->flag){temp = a[j]->flag;temp2 = a[j]->num;a[j]->flag = a[j+1]->flag;a[j]->num = a[j+1]->num;a[j+1]->flag = temp;a[j+1]->num = temp2;}}}printf("调度序列为:\n");printf("%d—>",start);for(i = 1;i <= n; i++){printf("%d —> ",a[i]->num);}printf("\n");printf("寻道长度是%f",s);printf("\n");printf("平均寻道长度是%f",s/n);printf("\n");}if(toright == 1){//先向199磁道方向访问while(p != n+1){temp = abs(a[p]->num - temp);s += temp;l += 1;temp = a[p]->num;a[p]->flag = l;p++;}s += abs(199 - a[n]->num);temp = 199;x = x - 1;while(x != 0){temp = abs(a[x]->num - temp);s += temp;l += 1;temp = a[x]->num;a[x]->flag =l;x--;}for(i = n;i >= 1;i--){//冒泡排序,按照访问的顺序将数组重新排列for(int j = 1;j < i;j ++){if(a[j]->flag> a[j+1]->flag){temp = a[j]->flag;temp2 = a[j]->num;a[j]->flag = a[j+1]->flag;a[j]->num = a[j+1]->num;a[j+1]->flag = temp;a[j+1]->num = temp;}}}printf("调度序列为:\n");printf("%d—>",start);for(i = 1;i <= n; i++){printf("%d —> ",a[i]->num);}printf("\n");printf("寻道长度是%f",s);printf("\n");printf("平均寻道长度是%f",s/n);printf("\n");}printf("---------------------------SCAN调度算法----------------------------\n");}//*************************************************************************void CSCAN(v *a,int start,int n){//int temp,temp2;int l = 0;for(int i = n;i >= 1;i--){//冒泡排序for(int j = 1;j < i;j ++){if(a[j]->num > a[j+1]->num){temp = a[j]->num;a[j]->num = a[j+1]->num;a[j+1]->num = temp;}}}int p,x;p = Find(a,n,start);x = p;float s = 0;temp = start;printf("---------------------------CSCAN调度算法----------------------------\n"); if((n - p) >= p ){//右边的磁道数比左边的磁道数多while(p != n+1){temp = abs(a[p]->num - temp);s += temp;l += 1;temp = a[p]->num;a[p]->flag = l;p++;}s += abs(199 - a[n]->num);temp = 0;x = x + 1;i = 1;while(i != x){temp = abs(a[i]->num - temp);s += temp;l += 1;temp = a[i]->num;a[i]->flag = l;i++;}for(i = n;i >= 1;i--){//冒泡排序,按照访问的顺序将数组重新排列for(int j = 1;j < i;j ++){if(a[j]->flag> a[j+1]->flag){temp = a[j]->flag;temp2 = a[j]->num;a[j]->flag = a[j+1]->flag;a[j]->num = a[j+1]->num;a[j+1]->flag = temp;a[j+1]->num = temp2;}}}printf("调度序列为:\n");printf("%d—>",start);for(i = 1;i <= n; i++){printf("%d —> ",a[i]->num);}printf("\n");printf("寻道长度是%f",s);printf("\n");printf("平均寻道长度是%f",s/n);printf("\n");}else{//左边的磁道数比右边的磁道数多while(p != 0){temp = abs(a[p]->num - temp);s += temp;l += 1;temp = a[p]->num;a[p]->flag = l;p--;}s += a[1]->num - 0;temp = 199;i = n;while(i != x){temp = abs(a[i]->num - temp);s += temp;temp = a[i]->num;l += 1;a[i]->flag =l;i--;}for(i = n;i >= 1;i--){//冒泡排序,按照访问的顺序将数组重新排列for(int j = 1;j < i;j ++){if(a[j]->flag> a[j+1]->flag){temp = a[j]->flag;temp2 = a[j]->num;a[j]->flag = a[j+1]->flag;a[j]->num = a[j+1]->num;a[j+1]->flag = temp;a[j+1]->num = temp2;}}}printf("调度序列为:\n");printf("%d—>",start);for(i = 1;i <= n; i++){printf("%d —> ",a[i]->num);}printf("\n");printf("寻道长度是%f",s);printf("\n");printf("平均寻道长度是%f",s/n);printf("\n");}printf("---------------------------CSCAN调度算法----------------------------\n");}//************************************************************************** void main(){int n;//v a[N];int start;//磁头开始的位置int choice;//用于标记操作的序号printf("******************************磁盘调度算法****************************\n");printf(" ");printf("1.FCFS调度算法\n");printf(" ");printf("2.SSTF调度算法\n");printf(" ");printf("3.SCAN调度算法\n");printf(" ");printf("4.CSCAN调度算法\n");printf(" ");printf("5.退出\n");printf("******************************磁盘调度算法****************************\n");printf("请输入请求的柱面数:");scanf("%d",&n);printf("请输入磁头开始的位置:");scanf("%d",&start);Initial(a,n);while(1){printf("请选择你要的操作序号\n");scanf("%d",&choice);switch(choice){case 1:FCFS(a,start,n);break;case 2:SSTF(a,start,n);break;case 3:SCAN(a,start,n);break;case 4:CSCAN(a,start,n);break;case 5:exit(-1);default:printf("你输入的操作序号有误!");}printf("\n");}}。

操作系统-磁盘调度算法

操作系统-磁盘调度算法

操作系统-磁盘调度算法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个磁道。

磁盘调度算法

磁盘调度算法

磁盘调度算法现代操作系统中,磁盘利用外层磁道容量较内层磁道大的特点,将盘面划分成若干条环带,使得同一环带内的所有磁道具有相同的扇区数。

磁头在各磁道上移动,当进程请求时根据当前磁头位置和待访问位置决定访问次序。

本实验是模拟操作系统的磁盘寻道方式,运用磁盘访问顺序的不同来设计磁盘的调度算法。

设定开始磁道号寻道范围,依据起始扫描磁道号和最大磁道号数,随机产生要进行寻道的磁道号序列。

磁道访问序列不小于6。

选择磁盘调度算法,显示该算法的磁道访问顺序,计算出移动的磁道总数和平均寻道总数。

可选的实现磁盘调度算法有FCFS,SSTF,SCAN,CSCAN和NStepSCAN算法。

选择比较的算法,不小于3。

按算法的寻道效率进行排序,并对各算法的性能进行分析比较。

先来先服务FCFS根据进程请求访问磁盘的先后次序进行调度。

当一个新的磁盘访问请求发生时,不考虑其他因素,仅仅凭借作业的到达次序,作为调度的依据。

程序设定访问磁道的起止道号,如100-500,随机产生不小于6个磁道访问的序列,并明确次序。

按照FCFS方法,依磁道访问序列,确定每个作业的移动磁道数,并输出计算平均寻道长度详细描述实验设计思想、程序结构及各模块设计思路;详细描述程序所用数据结构及算法;明确给出测试用例和实验结果;为增加程序可读性,在程序中进行适当注释说明;认真进行实验总结,包括:设计中遇到的问题、解决方法与收获等;#include<iostream>#include<cmath>using namespace std;#define size 10void FCFS(int input[],int num);void SSTF(int input[],int num);void SCAN(int input[],int num);void CSCAN(int input[],int num);void sort(int input[],int num); //排序函数void main(){int track[200]; //磁道的范围为0~199int PCB[size]; //输入的磁道号int i=0;while(i<200){ //磁道初始化track[i]=i;i++;}cout<<"\n请输入"<<size<<"个待寻磁道号(0~199)"<<endl;for(int j=0;j<size; j++){cin>>PCB[j];}int suanfa; //算法选择while(1){cout<<"选择算法:"<<endl;cout<<" 1、FCFS算法\n";cout<<" 2、SSTF算法\n";cout<<" 3、SCAN算法\n";cout<<" 4、CSCAN算法\n";cout<<" 5、退出!\n";scanf("%d",&suanfa);if(suanfa==1) FCFS(PCB,size);else if(suanfa==2) SSTF(PCB,size);else if(suanfa==3) SCAN(PCB,size);else if(suanfa==4) CSCAN(PCB,size);else if(suanfa!=1 || suanfa!=2 || suanfa!=3 || suanfa!=4 )break;}cout<<" 欢迎使用!\n\n\n";}void sort(int input[],int num){ //排序函数int t;for(int j=0;j<num-1;j++)for(int i=0;i<num-1-j;i++)if(input[i]>input[i+1]){t=input[i];input[i]=input[i+1];input[i+1]=t;}}void FCFS(int input[],int num){cout<<"输入当前所在磁道号\n";int dangqian;float sum=0; //记录总访问磁道数float ave; //平均访问磁道数cin>>dangqian;cout<<"访问磁道顺序为:";for(int i=0;i<num;i++){cout<<input[i]<<" ";sum=sum+abs(input[i]-dangqian);dangqian=input[i];}ave=sum/num;cout<<"\n移动的磁道总数:"<<sum;cout<<"\n平均访问磁道数为:"<<ave<<endl;cout<<"\n";}void SSTF(int input[],int num){sort(input,size); //对输入的磁道号排序cout<<"输入当前所在磁道号\n";int dangqian;float sum=0; //记录总访问磁道数float ave; //平均访问磁道数cin>>dangqian;cout<<"访问磁道顺序为:";if(dangqian>=input[num-1]){ //如果当前大于最大的磁道号for(int i=num-1;i>=0;i--){cout<<input[i]<<" ";sum=sum+abs(input[i]-dangqian);dangqian=input[i];}}else if(dangqian<=input[0]){ //如果当前小于最大的磁道号for(int i=0;i<num;i++){cout<<input[i]<<" ";sum=sum+abs(input[i]-dangqian);dangqian=input[i];}}else { //如果在最大和最小之间int k=0;int low,high;while(dangqian>input[k]) k++;low=k;high=k+1;while(low>=0 || high <num){if(abs(dangqian-input[low])<=abs(dangqian-input[high])) //如果前一个较近取前一个{cout<<input[low]<<" ";sum=sum+abs(input[low]-dangqian);dangqian=input[low];low--;}else{cout<<input[high]<<" ";sum=sum+abs(input[high]-dangqian);dangqian=input[high];high++;}}}ave=sum/num;cout<<"\n移动的磁道总数:"<<sum;cout<<"\n平均访问磁道数为:"<<ave<<endl;cout<<"\n";}void SCAN(int input[],int num){sort(input,size);cout<<"输入当前所在磁道号\n";int dangqian;float sum=0; //记录总访问磁道数float ave; //平均访问磁道数cin>>dangqian;cout<<"选择扫描方向:\n";cout<<" 0、从里向外\n";cout<<" 1、从外向里\n";int k; //记录中间位置cin>>k;int x=0;while(dangqian>input[x]) x++;int temp=x;cout<<"访问磁道顺序为:";if(k==0){ //从里向外while(x<size){cout<<input[x]<<" ";sum=sum+abs(input[x]-dangqian);dangqian=input[x];x++;}int wo=temp;while(wo>0){cout<<input[wo-1]<<" ";sum=sum+abs(input[wo-1]-dangqian);dangqian=input[wo-1];wo--;}}else if(k==1){ //从外向里while(x>0){cout<<input[x-1]<<" ";sum=sum+abs(input[x-1]-dangqian);dangqian=input[x-1];x--;}int wow=temp;while(wow<size){cout<<input[wow]<<" ";sum=sum+abs(input[wow]-dangqian);dangqian=input[wow];wow++;}}else { cout<<"输入错误!\n"; exit(0);}ave=sum/num;cout<<"\n移动的磁道总数:"<<sum;cout<<"\n平均访问磁道数为:"<<ave<<endl;cout<<"\n";}void CSCAN(int input[],int num){sort(input,size);cout<<"输入当前所在磁道号\n";int dangqian;float sum=0; //记录总访问磁道数float ave; //平均访问磁道数cin>>dangqian;cout<<"选择扫描方向:\n";cout<<" 0、从里向外\n";cout<<" 1、从外向里\n";int k; //记录中间位置cin>>k;int x=0;while(dangqian>input[x]) x++;int temp=x;cout<<"访问磁道顺序为:";if(k==0){ //从里向外while(x<size){cout<<input[x]<<" ";sum=sum+abs(input[x]-dangqian);dangqian=input[x];x++;}int wo=0;while(wo<temp){cout<<input[wo]<<" ";sum=sum+abs(input[wo]-dangqian);dangqian=input[wo];wo++;}}else if(k==1){ //从外向里while(x>0){cout<<input[x-1]<<" ";sum=sum+abs(input[x-1]-dangqian);dangqian=input[x-1];x--;}int wow=size-1;while(wow>=temp){cout<<input[wow]<<" ";sum=sum+abs(input[wow]-dangqian);dangqian=input[wow];wow--;}}else { cout<<"输入错误!\n"; exit(0);}ave=sum/num;cout<<"\n移动的磁道总数:"<<sum;cout<<"\n平均访问磁道数为:"<<ave<<endl;cout<<"\n";}。

磁盘调度算法文库

磁盘调度算法文库

#include"stdio.h"#include"stdlib.h"#include"iostream.h"#define maxsize 100/***************************************************************** *************//* ÏÈÀ´ÏÈ·þÎñµ÷¶ÈËã·¨/***************************************************************** *************/void FCFS(int array[],int m){int sum=0,j,i;for( i=0;i<m;i++){cout<<array[i]<<" ";}for(i=0,j=1;j<m;i++,j++){sum+=abs(array[j]-array[i]);}cout<<"Òƶ¯µÄ×ܵÀÊý£º "<<sum<<endl;}/***************************************************************** *************//* ×î¶ÌÑ°µÀʱ¼äÓÅÏȵ÷¶ÈËã·¨/***************************************************************** *************/void ShortPath(int array[],int m){int temp;int k=1;int now,l,r;int i,j,sum=0;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++){cout<<array[i]<<" ";}/*ÅÅÐò*/cout<<"ÇëÊäÈ뵱ǰµÄ´ÅµÀºÅ£º";cin>>now;if(array[m-1]<=now){for(i=m-1;i>=0;i--)cout<<array[i]<<" ";sum=now-array[0];}elseif(array[0]>=now){for(i=0;i<m;i++)cout<<array[i]<<" ";sum=array[m-1]-now;}else{while(array[k]<now){k++;}l=k-1;r=k;/*È·¶¨µ±Ç°´ÅµÀÔÚÒÑÅŵÄÐòÁÐÖеÄλÖ㬺óÃæµÄËã·¨¶¼Óõ½ÁË£¬¿ÉÒÔÖ±½Ó¸´ÔÓºóÉÙÁ¿Ð޸ģ¬½Úʡʱ¼ä¡£*/while((l>=0)&&(r<m)){if((now-array[l])<=(array[r]-now)){cout<<array[l]<<" ";sum+=now-array[l];now=array[l];l=l-1;}else{cout<<array[r]<<" ";sum+=array[r]-now;now=array[r];r=r+1;}}if(l=-1){for(j=r;j<m;j++){cout<<array[j]<<" ";}sum+=array[m-1]-array[0];}else{for(j=l;j>=0;j--){cout<<array[j]<<" ";}sum+=array[m-1]-array[0];}}cout<<"Òƶ¯µÄ×ܵÀÊý£º "<<sum<<endl;}</P><P> </P><P>/***************************************************************** *************//* µçÌݵ÷¶ÈËã·¨/***************************************************************** *************/void Elevator(int array[],int m) <a>file://ÏÈ</A>Òª¸ø³öµ±Ç°´ÅµÀºÅºÍÒƶ¯±ÛµÄÒƶ¯·½Ïò{int temp;int k=1;int now,l,r,d;int i,j,sum=0;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++){cout<<array[i]<<" ";}cout<<"ÇëÊäÈ뵱ǰµÄ´ÅµÀºÅ£º";cin>>now;if(array[m-1]<=now){for(i=m-1;i>=0;i--)cout<<array[i]<<" ";sum=now-array[0];}elseif(array[0]>=now){for(i=0;i<m;i++)cout<<array[i]<<" ";sum=array[m-1]-now;}else{while(array[k]<now){k++;}l=k-1;r=k;cout<<"ÇëÊäÈ뵱ǰÒƶ¯±ÛµÄÒƶ¯µÄ·½Ïò (1 ±íʾÏòÄÚ £¬0±íʾÏòÍâ) : "; cin>>d;if(d==0){for(j=l;j>=0;j--){cout<<array[j]<<" ";}for(j=r;j<m;j++){cout<<array[j]<<" ";}sum=now-2*array[0]+array[m-1];}else{for(j=r;j<m;j++){cout<<array[j]<<" ";}for(j=l;j>=0;j--){cout<<array[j]<<" ";}sum=-now-array[0]+2*array[m-1];}}cout<<"Òƶ¯µÄ×ܵÀÊý£º "<<sum<<endl;}</P><P>/***************************************************************** *************//* µ¥ÏòɨÃèµ÷¶ÈËã·¨/***************************************************************** *************/void SCAN(int array[],int m){int temp;int k=1;int now,l,r;int i,j,sum=0;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++){cout<<array[i]<<" ";}cout<<"ÇëÊäÈ뵱ǰµÄ´ÅµÀºÅ£º";cin>>now;if(array[m-1]<=now){for(i=0;i<m;i++)cout<<array[i]<<" ";sum=now-array[0]+array[m-1];}elseif(array[0]>=now){for(i=0;i<m;i++)cout<<array[i]<<" ";sum=array[m-1]-now;}else{while(array[k]<now){k++;}l=k-1;r=k;for(j=r;j<m;j++){cout<<array[j]<<" ";}for(j=0;j<r;j++){cout<<array[j]<<" ";}sum=2*array[m-1]-now;}cout<<"Òƶ¯µÄ×ܵÀÊý£º "<<sum<<endl; }void main(){int c;FILE *fp;int cidao[maxsize];int i=0,count;fp=fopen("cidao.txt","r+");if(fp==NULL){cout<<"can not find file!"<<endl;exit(0);}while(!feof(fp)){fscanf(fp,"%d",&cidao[i]);i++;}count=i-1;for(i=0;i<count;i++){printf("%5d",cidao[i]);}cout<<endl;while(1){cout<<endl<<"ϵͳµÄ²Ëµ¥ÈçÏ£º"<<endl;printf("1. ÏÈÀ´ÏÈ·þÎñ 2. ×î¶ÌÑ°µÀʱ¼äÓÅÏÈ 3. µçÌݵ÷¶È"); cout<<endl;printf("4. µ¥ÏòɨÃè 5. Í˳ö");cout<<endl;cout<<"ÇëÑ¡Ôñ£º";cin>>c;if(c>4)break;switch(c){case 1:FCFS(cidao,count);break;case 2:ShortPath(cidao,count);break;case 3:Elevator(cidao,count);break;case 4:SCAN(cidao,count);break;}}}。

操作系统磁盘调度算法

操作系统磁盘调度算法

操作系统磁盘调度算法1:引言1.1 目的1.2 范围1.3 定义2:磁盘调度算法概述2.1 概念2.2 目标3:先来先服务(FCFS)算法3.1 原理3.2 步骤3.3 优点3.4 缺点4:最短寻道时间优先(SSTF)算法4.1 原理4.2 步骤4.3 优点4.4 缺点5:扫描(SCAN)算法5.1 原理5.2 步骤5.3 优点5.4 缺点6:循环扫描(C-SCAN)算法 6.1 原理6.2 步骤6.3 优点6.4 缺点7:电梯(C-LOOK)算法7.1 原理7.2 步骤7.3 优点7.4 缺点8:其他磁盘调度算法8.1 双队列(两级)调度算法8.2 基于预测的调度算法8.3 基于平滑滑动窗口的调度算法9:磁盘调度算法的选择与评估9.1 根据系统特点选择适当算法9.2 评估磁盘调度算法性能10:结论附件:1:示例代码2:测试数据法律名词及注释:1:操作系统:计算机系统中负责管理和控制硬件资源,并为用户提供软件接口的核心程序。

2:磁盘调度算法:在操作系统中,用于决定磁盘上数据访问请求的处理顺序的算法。

3:先来先服务(FCFS)算法:一种磁盘调度算法,按照请求的到达顺序进行处理。

4:最短寻道时间优先(SSTF)算法:一种磁盘调度算法,选择离当前磁头位置最近的请求进行处理。

5:扫描(SCAN)算法:一种磁盘调度算法,磁头按一个方向来回扫描磁道,处理请求。

6:循环扫描(C-SCAN)算法:一种磁盘调度算法,磁头按一个方向循环扫描磁道,处理请求。

7:电梯(C-LOOK)算法:一种磁盘调度算法,类似于循环扫描算法,但不需回到磁道的起点。

sstf磁盘调度算法lru算法

sstf磁盘调度算法lru算法

sstf磁盘调度算法lru算法
SSTF(最短寻道时间优先)和LRU(最近最久未使用)是两种常用的磁盘调度算法。

SSTF算法根据进程请求访问磁盘的先后顺序进行调度,优先满足当前磁头所在磁道距离最近的请求。

然而,这种算法可能导致优先级低的进程发生“饥饿”现象,因为新进程请求到达,且其所要访问的磁道与磁头当前所在的磁道距离较近,必先优先满足。

LRU算法则是在置换时淘汰最近一段时间最久没有使用的页面,即选择上次使用距当前最远的页面淘汰。

这种算法相对更符合用户的行为习惯,因为用户通常会继续使用最近使用的页面。

以上内容仅供参考,如需更多信息,建议查阅计算机科学相关书籍或咨询专业人士。

磁盘调度算法

磁盘调度算法
优点: 消除了对两端磁道请求的不公平。
举例: 若磁头的当前位置为 72 磁道,磁头正向磁 道增加方向移动。现有一磁盘读写请求队列 98 , 220,37,122,14,124,65,82,试计算出采 用下列不同算法的平均寻道长度各为多少? (1)FCFS算法 (2)SSTF算法 (3)SCAN算法 (4)CSCAN算法
解:(1)FCFS算法 从72磁道开始
下一磁道 98 220 37 122 14 124 65 82 移动磁道数 26 122 183 85 108 110 59 17
平均寻道长度=710/8=89.75
解:(2)SSTF算法 从72磁道开始
下一磁道 65 82 98 122 124 37 14 220 移动磁道数 7 17 16 24 2 87 23 206
3.扫描算法(SCAN)
在磁头移动方向上选择与当前磁头所在的磁 道距离最近的请求作为下一次服务的对象。 优点:
(1)具有较好的寻道性能;
(2)避免了饥饿现象
缺点: 不利于远离磁头一端的访问请求。
Hale Waihona Puke 4.循环扫描算法(CSCAN)
是对扫描算法(SCAN)的改良,它规定磁头 单向移动,例如自内向外移动,当磁头移动到 最外磁道时立即又返回到最内磁道,如此循环 进行扫描。
磁盘调度算法 磁盘调度算法有若干种,但着眼点都放在 寻道优化上,即寻道时间尽量短,吞吐量尽量 大。目前广泛使用的寻道策略有下列几种:
1.先来先服务寻道算法(FCFS):
按进程请求访问磁盘的先后次序进行调度。
特点:合理、简单、但未对寻道进行优化。
2 .最短寻道时间优先算法(SSFT , ShortestSeek-Time-First) 选择与当前磁头所在的磁道距离最近的请求 作为下一次服务的对象。 缺点: (1)不能保证平均寻道时间最短; ( 2 )可能会使某些请求总得不到服务(又 称饥饿)。

磁盘调度算法

磁盘调度算法

命令行接口实验实验目的:了解命令行接口的使用实验内容:本课程设计的目的是通过磁盘调度算法设计一个磁盘调度模拟系统,从而使磁盘调度算法更加形象化,容易使人理解,使磁盘调度的特点更简单明了,能使使用者加深对先来先服务算法、最短寻道时间优先算法、扫描算法以及循环扫描算法等磁盘调度算法的理解运行程序截图:源程序:#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. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

1、课程设计的目的本课程设计是学生学习完《操作系统原理及应用》课程后,进行的一次全面的综合训练,通过课程设计,让学生更好地掌握操作系统的原理及实现方法,加深对操作系统基础理论和重要算法的理解,加强学生的动手能力。

2、课程设计的内容及要求编程序实现下述磁盘调度算法,并求出每种算法的平均寻道长度:要求设计主界面以灵活选择某算法,且以下算法都要实现1、先来先服务算法(FCFS)2、最短寻道时间优先算法(SSTF)3、扫描算法(SCAN)4、循环扫描算法(CSCAN)3、实现原理磁盘是可供多个进程共享的设备,当有多个进程都要求访问磁盘时,应采用一种最佳调度算法,以使各进程对磁盘的平均访问时间最小。

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

目前常用的磁盘调度算法有先来先服务、最短寻道时间优先、扫描和循环扫描等算法。

其中,平均寻道长度(L)为所有磁道所需移动距离之和除以总的所需访问的磁道数(N),即:L=(M1+M2+……+Mi+……+MN)/N其中Mi为磁头从上一各磁道到这个磁道所需移动的距离。

4、算法1.先来先服务算法(FCFS)这是一种最简单的磁盘调度算法。

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

此算法只考虑访问者提出访问请求的先后次序,按照先后次序依次访问磁道号。

移动距离等于上一个被访问的磁道号减去当前访问的磁道号的绝对值,平均寻道长度等于所有移动距离之和除以磁道被访问的次数。

2.短寻道时间优先算法(SSTF)该算法选择这样的进程,其要求访问的磁道与当前磁头所在的磁道距离最近,以使每次的寻道时间最短,而不管访问者到来的先后次序。

实现时可以先对磁道号进行从小到大排序保存在数组里,然后与当前磁道号比较,选择离自己最近的访问,每比较一次,当前磁道号也跟着变化,移动距离等于上一个被访问的磁道号减去当前访问的磁道号的绝对值。

但当数组里的最大值小于当前磁道号时,就逆序访问,此时移动距离的和就等于当前磁道号减去数组中最小数;当数组中最小的数大于当前磁道号时,就正序访问,此时移动距离的和等于数组中最大值减当前磁道号,平均寻道长度等于所有移动距离之和除以磁道被访问的次数。

3.扫描算法(SCAN)SCAN 算法又称电梯调度算法。

该算法先考虑磁头的移动方向,再考虑距离近的访问。

所以可以对即将访问的磁道号进行从小到大排序保存在数组里,然后与当前磁道号比较,当磁头移动方向向磁道号增加的方向移动时,就先依次访问比当前磁道号大的数,再逆向访问比自己小的数;当磁头移动方向是向磁道号减小的方向时就先访问比自己的小的,然后逆向访问比自己大的,移动距离等于上一个被访问的磁道号减去当前访问的磁道号的绝对值。

但当数组里的最大值小于当前磁道号时,两种方向都是逆序对磁道号访问,此时移动距离的和就等于当前磁道号减去数组中最小数;当数组中最小的数大于当前磁道号时,两种方向都是正序对磁道号访问,此时移动距离的和等于数组中最大值减当前磁道号,平均寻道长度等于所有移动距离之和除以磁道被访问的次数。

4.循环扫描算法(CSCAN)CSCAN算法是在SCAN算法的基础上规定磁头单向移动,即扫描时要么向磁道号增加的方向的访问,要么向磁道号减小的方向访问。

所以可以对即将访问的磁道号进行从小到大排序保存在数组里,然后与当前磁道号比较,当磁头移动方向向磁道号增加的方向移动时,就先依次访问比当前磁道号大的数,再返回磁道最里面朝增加的方向访问比自己小的数;当磁头移动方向是向磁道号减小的方向时就先访问比自己的小的,然后返回到磁道最外层访问比自己大的,移动距离等于上一个被访问的磁道号减去当前访问的磁道号的绝对值。

但当向磁道号增加的方向时,数组里的最大值小于当前磁道号或数组中最小的数大于当前磁道号时,都是正序访问;而当向磁道号减小的方向时,数组里的最大值小于当前磁道号或数组中最小的数大于当前磁道号时,都是逆序访问;此时移动距离的和等于数组中最大值减当前磁道号,平均寻道长度等于所有移动距离之和除以磁道被访问的次数。

5、程序中使用的数据结构及使用的变量说明和作用int[] cidao = new int[1000];//将被访问的磁道号存入cidao数组int sum = 0;//求移动距离之和double avg = 0;//求平均寻道时间string[] str = txtnum.Text.Split(',');//从txtnum里面获取访问的磁道号int now = Convert.ToInt32(txtnow.Text);//获取当前的磁道号for (int i = 0; i < str.Length; i++){//将获取的磁道号存入磁道号数组cidao[i] = Convert.ToInt32(str[i]);}private void btnFCFS_Click(object sender, EventArgs e)先来先服务FCFS算法private void btnSSTF_Click(object sender, EventArgs e)最短寻道时间优先SSTF private void btnSCANhigh_Click(object sender, EventArgs e)从里向外扫描private void btnSCANlow_Click(object sender, EventArgs e)从外向里扫描private void btnCSCANhigh_Click(object sender, EventArgs e)从里向外循环扫描private void btnCSCANlow_Click(object sender, EventArgs e)从外向里循环扫描private void btnexit_Click(object sender, EventArgs e)退出窗体private void txtnum_KeyDown(object sender, KeyEventArgs e)快捷键Tab选择输入框6、关键算法实现流程图先来先服务FCFS算法:最短寻道时间算法:扫描算法:向磁道号增加的方向:从磁道号减小的方向:循环扫描算法:从磁道号增加的方向:从磁道号减小的方向:7、实现代码///<summary>///先来先服务FCFS///</summary>///<param name="sender"></param>///<param name="e"></param>private void btnFCFS_Click(object sender, EventArgs e){txtresult.Clear();//清除显示int[] cidao = new int[1000];//被访问的磁道号数组int sum = 0;//移动距离之和double avg = 0;//平均寻道时间string[] str = txtnum.Text.Split(',');//从txtnum里面获取访问的磁道号int now = Convert.ToInt32(txtnow.Text);//当前的磁道号for (int i = 0; i < str.Length; i++){//将获取的磁道号存入磁道号数组cidao[i] = Convert.ToInt32(str[i]);}sum += Math.Abs(now - cidao[0]);//当前的磁道号减去磁道号数组中的第一个值取绝对值for (int i = 0; i < str.Length; i++){//输出FCFS磁盘调度结果txtresult.Text = txtresult.Text + cidao[i] + ','; }for (int i = 0, j = 1; j < str.Length; i++, j++){//累计总的移动距离sum += Math.Abs(cidao[j] - cidao[i]);}avg = (double)sum / str.Length;//平均寻道长度lblsum.Text = "总移动距离:" + sum.ToString();//在Label中显示总移动距离lblavg.Text = "平均寻道长度:" + avg.ToString("0.00");//在Label中显示平均寻道时间}///<summary>///最短寻道时间优先SSTF///</summary>///<param name="sender"></param>///<param name="e"></param>private void btnSSTF_Click(object sender, EventArgs e){txtresult.Clear();//清除显示int[] cidao = new int[1000];//被访问的磁道号数组int sum = 0;//移动距离之和double avg = 0;//平均寻道时间int temp;//中间变量int k = 1;int m, n;string[] str = txtnum.Text.Split(',');//从txtnum里面获取访问的磁道号int now = Convert.ToInt32(txtnow.Text);//当前的磁道号for (int i = 0; i < str.Length; i++){//将获取的磁道号存入磁道号数组cidao[i] = Convert.ToInt32(str[i]);}//对磁道号进行从小到大排列for (int i = 0; i < str.Length; i++){for (int j = i + 1; j < str.Length; j++){if (cidao[i] > cidao[j]){temp = cidao[i];cidao[i] = cidao[j];cidao[j] = temp;}}}//数组的最后一个小于当前磁道号,则数组逆序输出,此时的移动距离之和等于当前磁道号减去最小的磁道号if (cidao[str.Length - 1] <= now){for (int i = str.Length - 1; i >= 0; i--)txtresult.Text = txtresult.Text + cidao[i] + ','; sum = now - cidao[0];//移动距离之和}//数组的第一个数大于当前磁道号,正序输出,此时的移动距离之和等于最大的磁道号减去当前磁道号else if (cidao[0] >= now){for (int i = 0; i < str.Length; i++)txtresult.Text = txtresult.Text + cidao[i] + ','; sum = cidao[str.Length - 1] - now;//移动距离之和}//当前磁道号的大小介于数组的最大值与最小值之间{//k的初始值为,从数组的第二个数开始逐一与当前磁道号比较while (cidao[k] < now){k++;}//k+1比当前磁道号大的时候m = k - 1;n = k;//确定当前磁道在已排的序列中的位置while ((m >= 0) && (n < str.Length)){//当前位置的前一个磁道号离当前磁道号近if ((now - cidao[m]) <= (cidao[n] - now)){txtresult.Text = txtresult.Text + cidao[m] + ',';//输出sum += now - cidao[m];//移动距离之和now = cidao[m];//当前磁道号改变m = m - 1;//与数组的前半部分比较}//当前位置的后一个磁道号离当前磁道号近else{txtresult.Text = txtresult.Text + cidao[n] + ','; ;//输出sum += cidao[n] - now;//移动距离之和now = cidao[n];//当前磁道号改变n = n + 1;//与数组的后半部分比较}}//数组的第一个数比当前磁道号大if (m == -1){for (int j = n; j < str.Length; j++)//输出{txtresult.Text = txtresult.Text + cidao[j] + ',';}//移动距离之和sum += cidao[str.Length - 1] - cidao[0];//数组的最后一个数比当前磁道号小else{for (int j = m; j >= 0; j--)//输出{txtresult.Text = txtresult.Text + cidao[j] + ',';}sum += cidao[str.Length - 1] - cidao[0];//移动距离之和}}avg = (double)sum / str.Length;//平均寻道长度lblsum.Text = "总移动距离:" + sum.ToString();//在Label中显示总移动距离lblavg.Text = "平均寻道长度:" + avg.ToString("0.00");//在Label中显示平均寻道时间}///<summary>///磁道号增加的方向扫描///</summary>///<param name="sender"></param>///<param name="e"></param>private void btnSCANhigh_Click(object sender, EventArgs e){txtresult.Clear();//清除显示int[] cidao = new int[1000];//被访问的磁道号数组int sum = 0;//移动距离之和double avg = 0;//平均寻道时间int temp;//中间变量int k = 1;int m, n;string[] str = txtnum.Text.Split(',');//从txtnum里面获取访问的磁道号int now = Convert.ToInt32(txtnow.Text);//当前的磁道号for (int i = 0; i < str.Length; i++){//将获取的磁道号存入磁道号数组cidao[i] = Convert.ToInt32(str[i]);}//对磁道号进行从小到大排列for (int i = 0; i < str.Length; i++){for (int j = i + 1; j < str.Length; j++){if (cidao[i] > cidao[j]){temp = cidao[i];cidao[i] = cidao[j];cidao[j] = temp;}}}//数组的最后一个小于当前磁道号,则数组逆序输出,此时的移动距离之和等于当前磁道号减去最小的磁道号if (cidao[str.Length - 1] <= now){for (int i = str.Length - 1; i >= 0; i--)txtresult.Text = txtresult.Text + cidao[i] + ',';//移动距离之和sum = now - cidao[0];}//数组的第一个数大于当前磁道号,正序输出,此时的移动距离之和等于最大的磁道号减去当前磁道号else if (cidao[0] >= now){for (int i = 0; i < str.Length; i++)txtresult.Text = txtresult.Text + cidao[i] + ',';sum = cidao[str.Length - 1] - now;//移动距离之和}//当前磁道号的大小介于数组的最大值与最小值之间else{//k的初始值为,从数组的第二个数开始逐一与当前磁道号比较while (cidao[k] < now){k++;}//k+1比当前磁道号大的时候m = k - 1;n = k;for (int j = n; j < str.Length; j++)//输出{txtresult.Text = txtresult.Text + cidao[j] + ','; }//sum = cidao[str.Length - 1] - now;for (int j = m; j >= 0; j--){txtresult.Text = txtresult.Text + cidao[j] + ','; }//sum = cidao[str.Length - 1] - cidao[0];sum =2 * cidao[str.Length - 1] - now - cidao[0];}avg = (double)sum / str.Length;//平均寻道长度lblsum.Text = "总移动距离:" + sum.ToString();//在Label中显示总移动距离lblavg.Text = "平均寻道长度:" + avg.ToString("0.00");//在Label中显示平均寻道时间}///<summary>///磁道号减小的方向扫描///</summary>///<param name="sender"></param>///<param name="e"></param>private void btnSCANlow_Click(object sender, EventArgs e){txtresult.Clear();//清除显示int[] cidao = new int[1000];//被访问的磁道号数组int sum = 0;//移动距离之和double avg = 0;//平均寻道时间int temp;//中间变量int k = 1;int m, n;string[] str = txtnum.Text.Split(',');//从txtnum里面获取访问的磁道号int now = Convert.ToInt32(txtnow.Text);//当前的磁道号for (int i = 0; i < str.Length; i++){//将获取的磁道号存入磁道号数组cidao[i] = Convert.ToInt32(str[i]);}//对磁道号进行从小到大排列for (int i = 0; i < str.Length; i++){for (int j = i + 1; j < str.Length; j++){if (cidao[i] > cidao[j]){temp = cidao[i];cidao[i] = cidao[j];cidao[j] = temp;}}}//数组的最后一个小于当前磁道号,则数组逆序输出,此时的移动距离之和等于当前磁道号减去最小的磁道号if (cidao[str.Length - 1] <= now){for (int i = str.Length - 1; i >= 0; i--)txtresult.Text = txtresult.Text + cidao[i] + ','; sum = now - cidao[0];//移动距离之和}//数组的第一个数大于当前磁道号,正序输出,此时的移动距离之和等于最大的磁道号减去当前磁道号else if (cidao[0] >= now){for (int i = 0; i < str.Length; i++)txtresult.Text = txtresult.Text + cidao[i] + ',';sum = cidao[str.Length - 1] - now;//移动距离之和}//当前磁道号的大小介于数组的最大值与最小值之间else{//k的初始值为,从数组的第二个数开始逐一与当前磁道号比较while (cidao[k] < now){k++;}//k+1比当前磁道号大的时候m = k - 1;n = k;for (int j = m; j >= 0; j--)//比当前磁道号小的磁道数组的左边输出{txtresult.Text = txtresult.Text + cidao[j] + ','; }//sum = now - cidao[0];for (int j = n; j < str.Length; j++)//比当前磁道号大的磁道数组的右边输出{txtresult.Text = txtresult.Text + cidao[j] + ',';}//sum = cidao[str.Length - 1] - cidao[0];sum = now - cidao[0] + cidao[str.Length - 1] - cidao[0]; }avg = (double)sum / str.Length;//平均寻道长度lblsum.Text = "总移动距离:" + sum.ToString();//在Label中显示总移动距离lblavg.Text = "平均寻道长度:" + avg.ToString("0.00");//在Label中显示平均寻道时间}///<summary>///磁道号增加的方向循环扫描///</summary>///<param name="sender"></param>///<param name="e"></param>private void btnCSCANhigh_Click(object sender, EventArgs e) {txtresult.Clear();//清除显示int[] cidao = new int[1000];//被访问的磁道号数组int sum = 0;//移动距离之和double avg = 0;//平均寻道时间int temp;//中间变量int k = 1;int m, n;string[] str = txtnum.Text.Split(',');//从txtnum里面获取访问的磁道号int now = Convert.ToInt32(txtnow.Text);//当前的磁道号for (int i = 0; i < str.Length; i++){//将获取的磁道号存入磁道号数组cidao[i] = Convert.ToInt32(str[i]);}//对磁道号进行从小到大排列for (int i = 0; i < str.Length; i++){for (int j = i + 1; j < str.Length; j++){if (cidao[i] > cidao[j]){temp = cidao[i];cidao[i] = cidao[j];cidao[j] = temp;}}//数组的最后一个小于当前磁道号,则数组正序输出,此时的移动距离之和等于最大的磁道号减去当前磁道号if (cidao[str.Length - 1] <= now){for (int i = 0; i < str.Length; i++)txtresult.Text = txtresult.Text + cidao[i] + ','; sum = now - cidao[0];//移动距离之和}//数组的第一个数大于当前磁道号,正序输出,此时的移动距离之和等于最大的磁道号减去当前磁道号else if (cidao[0] >= now){for (int i = 0; i < str.Length; i++)txtresult.Text = txtresult.Text + cidao[i] + ',';sum = cidao[str.Length - 1] - now;//移动距离之和}//当前磁道号的大小介于数组的最大值与最小值之间else{//k的初始值为,从数组的第二个数开始逐一与当前磁道号比较while (cidao[k] < now){k++;}//k+1比当前磁道号大的时候m = k - 1;n = k;for (int j = n; j < str.Length; j++)//输出{txtresult.Text = txtresult.Text + cidao[j] + ','; }//sum = cidao[str.Length - 1] - now;cidao[str.Length - 1] - cidao[0] + cidao[n] - cidao[0];for (int j = 0; j <n; j++){txtresult.Text = txtresult.Text + cidao[j] + ','; }//sum = cidao[str.Length - 1] - cidao[0] + cidao[n-1] - cidao[0];sum = cidao[n-1] + 2 * (cidao[str.Length - 1] - cidao[0]) - now;avg = (double)sum / str.Length;//平均寻道长度lblsum.Text = "总移动距离:" + sum.ToString();//在Label中显示总移动距离lblavg.Text = "平均寻道长度:" + avg.ToString("0.00");//在Label中显示平均寻道时间}///<summary>///磁道号减小的方向循环扫描///</summary>///<param name="sender"></param>///<param name="e"></param>private void btnCSCANlow_Click(object sender, EventArgs e) {txtresult.Clear();//清除显示int[] cidao = new int[1000];//被访问的磁道号数组int sum = 0;//移动距离之和double avg = 0;//平均寻道时间int temp;//中间变量int k = 1;int m, n;string[] str = txtnum.Text.Split(',');//从txtnum里面获取访问的磁道号int now = Convert.ToInt32(txtnow.Text);//当前的磁道号for (int i = 0; i < str.Length; i++){//将获取的磁道号存入磁道号数组cidao[i] = Convert.ToInt32(str[i]);}//对磁道号进行从小到大排列for (int i = 0; i < str.Length; i++){for (int j = i + 1; j < str.Length; j++){if (cidao[i] > cidao[j]){temp = cidao[i];cidao[i] = cidao[j];cidao[j] = temp;}}}//数组的最后一个小于当前磁道号,则数组逆序输出,此时的移动距离之和等于当前磁道号减去最小的磁道号if (cidao[str.Length - 1] <= now){for (int i = str.Length - 1; i >= 0; i--)txtresult.Text = txtresult.Text + cidao[i] + ','; sum = now - cidao[0];//移动距离之和}//数组的第一个数大于当前磁道号,逆序输出,此时的移动距离之和等于当前磁道号减去最小的磁道号else if (cidao[0] >= now){for (int i = str.Length - 1; i >= 0; i--)txtresult.Text = txtresult.Text + cidao[i] + ','; sum = cidao[str.Length - 1] - now;//移动距离之和}//当前磁道号的大小介于数组的最大值与最小值之间else{//k的初始值为,从数组的第二个数开始逐一与当前磁道号比较while (cidao[k] < now){k++;}//k+1比当前磁道号大的时候m = k - 1;n = k;for (int j = m; j >= 0; j--)//输出{txtresult.Text = txtresult.Text + cidao[j] + ','; }for (int j = str.Length-1; j >= n; j--){txtresult.Text = txtresult.Text + cidao[j] + ','; }sum = now - cidao[n] + 2 * (cidao[str.Length - 1] - cidao[0]);}avg = (double)sum / str.Length;//平均寻道长度lblsum.Text = "总移动距离:" + sum.ToString();//在Label中显示总移动距离lblavg.Text = "平均寻道长度:" + avg.ToString("0.00");//在Label中显示平均寻道时间}///<summary>///退出///</summary>///<param name="sender"></param>///<param name="e"></param>private void btnexit_Click(object sender, EventArgs e){Application.Exit();}///<summary>///快捷键Tab选择输入框///</summary>///<param name="sender"></param>///<param name="e"></param>private void txtnum_KeyDown(object sender, KeyEventArgs e) {if (e.KeyCode == Keys.Return)this.txtnum.Focus();}8、软件运行环境及限制Microsoft Visual Studio 2005 C# Windows应用程序9、结果输出及分析编译并运行程序,弹出来磁盘调度算法窗体,输入当前磁道号和写一个被访问的磁道号(磁道号间用逗号隔开),然后可以根据提供的空间选择不同的算法实现对输入的磁道号的访问;1、按照教材196页的例题输入相应的数据;2、点击先来先服务(FCFS)按钮实现算法,显示结果如下:此算法按照请求访问的先后顺序访问磁道号,所以输出结果和输入结果的顺序一致,平均寻道长度为访问的磁道号之间的移动距离之和除以被访问的磁道数。

相关文档
最新文档