磁盘调度算法的模拟实现及对比

合集下载

磁盘调度算法的模拟实现

磁盘调度算法的模拟实现

磁盘调度算法的模拟实现学院专业学号学生姓名指导教师姓名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) 最短寻道时间优先算法SSTF 2.2流程图2.3具体内容1)先来先服务算法FCFS这是一种比较简单的磁盘调度算法。

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

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

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

磁盘调度算法的模拟实现

磁盘调度算法的模拟实现

磁盘调度算法的模拟实现学院专业学号学生姓名指导教师姓名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) 最短寻道时间优先算法SSTF 2.2流程图2.3具体内容1)先来先服务算法FCFS这是一种比较简单的磁盘调度算法。

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

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

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

磁盘调度算法的模拟实现

磁盘调度算法的模拟实现

磁盘调度算法的模拟实现磁盘调度算法是指操作系统中负责管理物理磁盘的一种算法,其主要目的是优化磁盘访问,提高磁盘效率。

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

下面我将分别介绍这几种算法的模拟实现。

1.FCFS(先来先服务)算法模拟实现:首先,我们需要定义一个队列,用于存储用户请求的磁道号。

然后,将用户请求的磁道号加入队列中,按照先来先服务的原则进行服务,即按照队列中的请求顺序依次访问磁盘。

计算总体访问时间等信息,并输出结果。

2.SSTF(最短寻道时间优先)算法模拟实现:首先,我们需要定义一个队列,用于存储用户请求的磁道号。

然后,从当前磁头位置开始,找到与当前位置距离最近的请求磁道号,计算距离最小的请求所在的队列位置,并将该请求从队列中取出访问磁盘。

重复上述过程,直至队列为空。

计算总体访问时间等信息,并输出结果。

3.SCAN(扫描)算法模拟实现:首先,我们需要定义一个队列,用于存储用户请求的磁道号。

然后,将用户请求的磁道号加入队列中,并将队列按磁道号从小到大排序。

假设当前磁头位置为start,将磁头移动到队列中第一个比start大的磁道号,然后按照顺时针方向继续移动,直至访问队列中最大的磁道号。

然后,改变移动方向,回到队列中最小的磁道号为止。

计算总体访问时间等信息,并输出结果。

4.C-SCAN(循环扫描)算法模拟实现:首先,我们需要定义一个队列,用于存储用户请求的磁道号。

然后,将用户请求的磁道号加入队列中,并将队列按磁道号从小到大排序。

假设当前磁头位置为start,将磁头移动到队列中第一个比start大的磁道号,然后按照顺时针方向继续移动,直至访问队列中最大的磁道号,并将磁头移动到队列中最小的磁道号。

计算总体访问时间等信息,并输出结果。

以上是对于不同磁盘调度算法的简要模拟实现。

在实际应用中,还需要考虑更多的细节,如怎样处理新到的请求、队列的管理等。

实验二 模拟实现磁盘调度算法

实验二  模拟实现磁盘调度算法

实验二模拟实现磁盘调度算法姓名:班级:软件工程二班学号:日期:2020年12月13日实验目的:a、观察、体会操作系统的磁盘调度方法,并通过一个简单的磁盘调度模拟程序的实现,加深对磁盘调度的理解。

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

实验内容:a、模拟实现磁盘调度算法:FCFS,最短寻道优先,电梯算法(参照给定的算法实现最短寻道优先算法,电梯算法(磁头向外))。

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

基本思想、原理和算法描述:(1)电梯算法磁头初始向外:思想和原理:用户输入一个初始磁道号,规定向外和向内,向外即先逐渐减小,当向外遍历完后,就掉头向里,向里则是逐渐增大。

设置一个变量了定义进程是否已经执行,每执行完一个就给它赋值,下次就不遍历。

算法描述:首先调用重置访问标志、磁头当前位置、总移动磁道数的函数,然后进入循环,在循环刚开始时候,定义一个非常大的容器用来存储移动磁道数。

比较移动磁道数的大小,把小的那个磁道的下标给iNEXT,并把移动磁道数改为当前磁道的磁道移动数,用于下一次比较。

然后累加总移动磁道数,移动磁头当前位置为当前访问磁道号,并设置磁道是否已经访问标志为1:已访问。

(2)最短寻道优先调度算法:思想和原理:要求访问的磁道与当前磁头所在的磁道距离最近,即要求移动的磁道数最小的后一个磁道先执行。

主要是比较下一个磁道与当前磁道的差,取差最小的那个磁道,后面以此类推。

算法描述:源程序和电梯算法相似,本算法只比较移动磁道数的大小。

循环比较,直到所有的磁道都遍历完。

源程序:(1)电梯算法磁头初始向外:case 2://磁头初始向外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++)//寻找当前方向上寻道距离最短的未访问磁道号在数组队列queue中的下标{if((queue[j].iBeVisited==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].iBeVisited==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].iBeVisited=1;//设置磁道是否已经访问标志为1:已访问} //if(iNext!=-1)else//掉头向外{for(j=0;j<iReqNum;j++)//寻找当前方向上寻道距离最短的未访问磁道号在数组队列queue中的下标{if((queue[j].iBeVisited==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].iBeVisited=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)}运行结果:(2)最短寻道优先调度算法:void SSTF() //最短寻道优先调度算法{Reset();//重置访问标志、磁头当前位置、总移动磁道数cout << endl << "---------------------------------------------" << endl;cout << "最短寻道优先调度算法的调度结果: " << endl << endl;cout << "初始磁道号: " << iStart << endl;cout << "序号下一磁道号移动的磁道数" << endl;int numberend = 0;//已经运行的磁道的数目int size = 0;//当前磁道与某磁道的距离int NewiNow = 0;//记录与当前磁头距离最短的磁道的下标,初始化为0while (numberend != iReqNum)//已经运行的磁道的数目超出最大数目时退出循环{for (int i = 0; i < iReqNum; i++){if (!queue[i].iBeVisited){size = abs(iNow - queue[i].iGo);//初始化当前距离NewiNow = i;//跟新下标break;}}for (int i = 0; i < iReqNum; i++)//循环遍历,在为输出的磁道中寻找与当前磁道最近的磁道{if (!queue[i].iBeVisited&&size > abs(iNow - queue[i].iGo))//如果该磁道没有被访问,且距离小于当前距离{size = abs(iNow - queue[i].iGo);//更新磁道距离NewiNow = i;//跟新下标}}queue[NewiNow].iBeVisited = 1;//标记该磁道已访问iNow = queue[NewiNow].iGo;//移动磁头当前位置为当前访问磁道号iSum += size;//累加总移动磁道数++numberend;//更新已经访问磁道数目//输出信息摸拟访问请求的磁道cout << " " << numberend << " " << iNow << " " << size << endl;}cout << endl << "总调度次数: " << iReqNum << endl;cout << endl << "总移动磁道数: " << iSum << endl;printf("\n平均移动磁道数: %.2f\n\n", (float)iSum / (float)iReqNum);}运行结果分析:(2)最短寻道优先调度算法:实验总结:深刻理解FCFS,最短寻道优先,电梯算法。

磁盘调度算法的模拟实现及对比

磁盘调度算法的模拟实现及对比

磁盘调度算法的模拟实现及对比磁盘调度算法是操作系统中的重要组成部分,它负责有效地管理磁盘的数据读取和写入。

在实际中,磁盘调度算法的选择对系统的性能有着重要影响。

为了更好地理解磁盘调度算法的运作原理以及它们之间的差异,我们可以进行模拟实现并对比它们的性能。

1.先来先服务算法(FCFS)FCFS算法简单直接,按照请求的顺序依次进行磁盘访问。

实现思路很简单,我们可以创建一个请求队列来存储待访问的磁盘请求。

当有新的请求到来时,将其加入到队列的末尾。

然后按照队列的顺序进行磁盘访问即可。

2.最短寻道时间优先算法(SSTF)SSTF算法选择距离当前磁头位置最近的磁道进行访问,以减少寻道时间。

实现思路是将磁盘请求按照与当前磁头位置的距离进行排序,然后按照排序后的顺序进行访问。

3.扫描算法(SCAN)SCAN算法按照同一方向扫描,当到达磁盘的边界时,改变扫描方向。

实现思路是维护两个队列,一个存储向磁头当前方向的磁道请求,另一个存储向磁头反方向的磁道请求。

先按照当前方向的队列进行访问,直到访问完毕;然后改变扫描方向,并访问反方向的队列中的请求。

以下是对三种算法进行模拟实现并对比它们性能的步骤:1.首先,我们需要模拟磁盘的读取和写入操作。

可以使用一个整型数组来模拟磁盘的扇区,数组中每个元素代表一个扇区的内容。

2.创建一个请求队列,用于存储待访问的磁道号。

可以随机生成一些待访问的磁道号,并根据算法的不同进行排序。

3.根据算法的要求,对请求队列进行排序。

4.模拟磁盘调度算法的运行过程。

对于每个磁道号,计算当前磁头位置与该磁道的距离,并记录总的移动距离。

5.统计总的移动距离,并计算平均移动距离。

6.对比不同算法的平均移动距离,分析它们的性能差异。

通过以上步骤,我们可以进行磁盘调度算法的模拟实现并对比它们的性能。

根据实际情况,我们可以调整磁道数、磁头位置、磁道位置等参数,以观察不同条件下算法的运行情况。

总的来说,磁盘调度算法的模拟实现及对比可以使我们更好地理解各种算法的运行原理,对于选择和优化磁盘调度算法具有重要意义。

磁盘调度算法的模拟

磁盘调度算法的模拟

磁盘调度算法的模拟实验要求:⏹ 请分别用SCAN 和SSTF 模拟磁盘调度,并打印出磁盘磁道的调度顺序。

⏹磁头的方向可以动态的规定 ⏹磁道请求个数及序列可以动态地写入 ⏹ 总结收获体会及对该题解的改进意见和见解先将请求的磁道序列排序,以当前磁道号将该序列分界,根据当前磁道移动方向决定 先读左边的还是先读右边的SSTF算法:先将请求的磁道序列排序,以当前磁道号将该序列分界,然后当前磁道号分别与左边、右边磁道作差比较,选作差最小的,也即最短的。

并修改当前磁道号及其访问位(1为已访问完,0为未访问)。

(注:还要考虑左边或右边没有磁道的情况,如何确定所要与之比较的磁道)利用数组相关知识(图SSTF1. 当前磁道号在已排序的磁道请求序列中间的运行结果)(图SSTF2 当前磁道号在已排序的磁道请求序列最右边的运行结果)(图SSTF2 当前磁道号在已排序的磁道请求序列最左边的运行结果)SCAN源代码:#include<stdio.h>void main(){int m=0,n,Seek[100],SCurrent,t,i=0,j,k,option;printf("请输入当前的磁道号:");scanf("%d",&SCurrent);printf("\n----1.向磁道号增加的方向访问\t2.向磁道号减少的方向访问----\n");printf("---请选择的当前磁头移动方向(1/2):");scanf("%d",&option);printf("\n请输入磁道请求序列(以-999结束):\n");scanf("%d",&n);while(n!=-999){Seek[i]=n;m++;i++;scanf("%d",&n);}/* 冒泡排序使磁道请求序列从小到大排序 */for(j=0;j<m-1;j++){for(i=0;i<m-1-j;i++)if(Seek[i]>Seek[i+1]){t=Seek[i];Seek[i]=Seek[i+1];Seek[i+1]=t;}}/* 找到当前磁道号在磁道请求序列中的排序位置 */k=0;for(i=0;i<m;i++){if(Seek[i]<SCurrent)k++;elsebreak;}printf("\n--------------扫描(SCAN)算法后的磁盘调度序列----------\n");/* 第一种: 当前磁道号先向外再向里读 */if(option==1){for(i=k;i<m;i++)printf("%5d",Seek[i]);for(i=k-1;i>=0;i--)printf("%5d",Seek[i]);}/* 第二种: 当前磁道号先向里再向外读 */if(option==2){for(i=k-1;i>=0;i--)printf("%d ",Seek[i]);for(i=k;i<m;i++)printf("%5d",Seek[i]);}printf("\n");}SSTF源代码:#include<stdio.h>void main(){int m=0,n,Seek[100],Flag[100],SCurrent,t,i=0,j,k,i0,j0;printf("请输入当前的磁道号:");scanf("%d",&SCurrent);printf("\n请输入磁道请求序列(以-999结束):\n");scanf("%d",&n);while(n!=-999){Seek[i]=n;m++;i++;scanf("%d",&n);}/* 初始化置对应的磁道访问位为零 */for(i=0;i<m;i++)Flag[i]=0;/* 冒泡排序使磁道请求序列从小到大排序 */for(j=0;j<m-1;j++){for(i=0;i<m-1-j;i++)if(Seek[i]>Seek[i+1]){t=Seek[i];Seek[i]=Seek[i+1];Seek[i+1]=t;}}printf("\n--------------最短寻道时间优先(SSTF)算法后的磁盘调度序列----------\n");/* 找到当前磁道号在磁道请求序列中的排序位置 */k=0;for(i=0;i<m;i++){if(Seek[i]<SCurrent)k++;elsebreak;}//a. 已排序的磁道请求序列均在当前磁道号的右边//if(k==0){for(i=0;i<m;i++)printf("%5d",Seek[i]);k=-1;}//b. 已排序的磁道请求序列均在当前磁道号的左边//if(k==m){for(i=m-1;i>=0;i--)printf("%5d",Seek[i]);k=-1;}// c. 当前磁道号在已排序的请求序列的中间//if(k>0&&k<m){// 前后数与当前磁道号作差比较,选最近(差值最小)的if(Seek[k]-SCurrent>SCurrent-Seek[k-1])k--;printf("%5d",Seek[k]);SCurrent=Seek[k];Flag[k]=1;}while(k!=-1){i0=k-1;j0=k+1; //i0为当前磁道的靠左边的磁道号,j0为靠右边while(Flag[i0]==1&&i0>=0)i0--;while(Flag[j0]==1&&j0<m)j0++;// 1. 当前磁道号在已排序的磁道序列的最左边 //if(i0<0&&j0<m){for(i=j0;i<m;i++)printf("%5d",Seek[i]);k=-1;}// 2.当前磁道号在已排序的磁道序列的最右边 //if(i0>=0&&j0>=m){for(i=i0;i>=0;i--)printf("%5d",Seek[i]);k=-1;}// 3.当前磁道号在已排序的磁道序列的中间 //if(i0>=0&&j0<m){if(SCurrent-Seek[i0]<Seek[j0]-SCurrent){printf("%5d",Seek[i0]);Flag[i0]=1;SCurrent=Seek[i0];k=i0;}else{printf("%5d",Seek[j0]);Flag[j0]=1;SCurrent=Seek[j0];k=j0;}}}printf("\n");}。

磁盘调度的实验报告(3篇)

磁盘调度的实验报告(3篇)

第1篇一、实验目的1. 理解磁盘调度算法的基本原理和重要性。

2. 掌握几种常见的磁盘调度算法,包括先来先服务(FCFS)、最短寻道时间优先(SSTF)、扫描(SCAN)和循环扫描(C-SCAN)算法。

3. 通过模拟实验,分析不同磁盘调度算法的性能差异。

4. 优化磁盘调度策略,提高磁盘访问效率。

二、实验环境1. 操作系统:Windows 102. 编程语言:Python3.83. 磁盘调度算法模拟库:PyDiskScheduling三、实验内容1. FCFS算法:模拟实现先来先服务算法,按照请求顺序访问磁盘。

2. SSTF算法:模拟实现最短寻道时间优先算法,优先访问距离当前磁头最近的请求。

3. SCAN算法:模拟实现扫描算法,磁头从0号磁道开始向0号磁道移动,访问所有请求,然后返回到0号磁道。

4. C-SCAN算法:模拟实现循环扫描算法,与SCAN算法类似,但磁头在到达末尾磁道后返回到0号磁道。

四、实验步骤1. 导入PyDiskScheduling库。

2. 创建一个磁盘调度对象,指定磁头初始位置、请求序列和调度算法。

3. 运行调度算法,获取磁头移动轨迹和访问时间。

4. 分析算法性能,包括磁头移动次数、平均访问时间和响应时间等。

五、实验结果与分析1. FCFS算法:在请求序列较短时,FCFS算法表现较好。

但随着请求序列长度增加,磁头移动次数和访问时间明显增加。

2. SSTF算法:SSTF算法在请求序列较短时表现最佳,平均访问时间和响应时间较低。

但当请求序列较长时,算法性能下降,磁头移动次数增加。

3. SCAN算法:SCAN算法在请求序列较短时性能较好,但随着请求序列长度增加,磁头移动次数和访问时间逐渐增加。

与SSTF算法相比,SCAN算法在请求序列较长时性能更稳定。

4. C-SCAN算法:C-SCAN算法在请求序列较短时表现较好,但随着请求序列长度增加,磁头移动次数和访问时间逐渐增加。

与SCAN算法相比,C-SCAN算法在请求序列较长时性能更稳定,且磁头移动次数更少。

磁盘调度算法的模拟实现及对比

磁盘调度算法的模拟实现及对比

磁盘调度算法的模拟实现及对比磁盘调度算法是计算机操作系统中的重要概念,用于管理磁盘上的数据读写请求,使得磁盘的读写操作更加高效和优化。

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

磁盘调度算法的模拟实现需要先确定请求队列,即需要访问的磁盘扇区的序列。

在实现过程中,需要模拟磁盘的物理结构,包括磁盘的扇区数量、扇区大小等。

具体的模拟实现过程如下:1. 创建请求队列,包括需要访问的磁盘扇区序列;2. 模拟磁盘的物理结构,并将请求队列中的扇区按照物理位置排序;3. 选择一个磁盘调度算法,如FCFS、SSTF、SCAN等;4. 按照选择的算法依次处理请求队列中的磁盘访问请求,模拟磁盘的读写操作;5. 计算并输出磁盘访问的平均寻道时间、平均旋转延迟时间、平均传输时间等性能指标。

下面以FCFS算法为例,介绍磁盘调度算法的模拟实现过程。

FCFS算法是一种简单的磁盘调度算法,按照请求队列中请求的先后顺序进行磁盘访问,即先来先服务。

模拟实现过程如下:1. 创建请求队列,包括需要访问的磁盘扇区序列;2. 模拟磁盘的物理结构,并将请求队列中的扇区按照物理位置排序;3. 按照请求队列中的请求顺序,依次访问磁盘扇区,并记录磁盘访问的时间戳;4. 计算并输出磁盘访问的平均寻道时间、平均旋转延迟时间、平均传输时间等性能指标。

除了FCFS算法,还有SSTF、SCAN等磁盘调度算法。

它们的实现方法和性能指标计算方式略有不同,但实现过程的基本框架和步骤相似。

总之,磁盘调度算法的模拟实现需要先确定请求队列,模拟磁盘的物理结构,并选择合适的磁盘调度算法。

通过计算磁盘访问的各项性能指标,可以评估不同算法在不同应用场景下的优劣。

磁盘调度算法的实现

磁盘调度算法的实现

实验五、磁盘调度算法的实现一、实验目的实验程序模拟先来先服务FCFS,最短寻道时间优先SSTF,SCAN和循环SCAN 算法的工作过程。

假设有n个磁道号所组成的磁道访问序列,给定开始磁道号m 和磁头移动的方向(正向或者反向),分别利用不同的磁盘调度算法访问磁道序列,给出每一次访问的磁头移动距离,计算每种算法的平均寻道长度,本程序采用随机数来产生磁道数。

二、实验要求算法所需的各种参数由输入产生(手工输入或者随机数产生)。

最后的结果要求是在运行四种算法的程序后,能够输出调度过程、平均寻道长度的正确结果。

三、实验说明(1) 先来先服务.(FCFS):这是一种简单的磁盘调度算法。

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

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

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

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

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

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

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

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

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

(4)循环扫描算法(CSCAN)CSCAN算法是对扫描算法的改进。

如果对磁道的访问请求是均匀分布的,当磁头到达磁盘的一端,并反向运动时落在磁头之后的访问请求相对较少。

这是由于这些磁道刚被处理,而磁盘另一端的请求密度相当高,且这些访问请求等待的时间较长,为了解决这种情况,循环扫描算法规定磁头单向移动。

磁盘驱动调度算法

磁盘驱动调度算法

操作系统课程设计题目:磁盘驱动调度算法模拟班级:姓名:学号:指导教师:成绩:6 月磁盘驱动调度算法模拟菜单显示FCFS算法SCAN算法SSTF算法CSCAN算法沿磁道增加方向沿磁道减小方向沿磁道增加方向沿磁道减小方向一、课程设计目的1.进一步加深对磁盘驱动调度算法的理解。

2.编程实现“先来先服务”、“最短寻道时间优先”、“电梯调度”、“循环扫描”算法。

二、课题内容1.假设一种磁盘含有4 个盘片,每个盘片有100 个磁道,每道有8 个扇区,模拟格式化时对柱面和扇区进行编号的过程。

2.设计若干磁道访问请求,规定顾客输入线性块号,系统能将其转换为对应的磁道号(柱面号),并计算出分别采用“先来先服务”、“最短寻道时间优先”、“电梯调度”、“循环扫描”算法的寻道总长度。

3.提供可视化且简洁清晰的顾客界面,能直观且动态地描述磁头移动。

三、设计思路(一)系统概要设计1.整体模块设计图2.有关知识磁盘调度:当有多个进程都请求访问磁盘时,采用一种合适的驱动调度算法,使各进程对磁盘的平均访问(重要是寻道)时间最小。

现在惯用的磁盘调度算法有:1)先来先服务2)最短寻道时间优先3)扫描算法4)循环扫描算法等3.算法思想介绍(1)先来先服务算法(FCFS)即先来的请求先被响应。

FCFS 方略看起来似乎是相称"公平"的,但是当请求的频率过高的时候FCFS 方略的响应时间就会大大延长。

FCFS 方略为我们建立起一种随机访问机制的模型,但是如果用这个方略重复响应从里到外的请求,那么将会消耗大量的时间。

为了尽量减少寻道时间,看来我们需要对等待着的请求进行合适的排序,而不是简朴的使用FCFS 方略。

这个过程就叫做磁盘调度管理。

有时候FCFS 也被看作是最简朴的磁盘调度算法。

(2)最短寻道时间优先算法(SSTF)最短时间优先算法选择这样的进程。

规定访问的磁道,与现在磁头所在的磁道距离近来,以使每次的寻道时间最短。

磁盘调度算法的实现

磁盘调度算法的实现

实验五、磁盘调度算法的实现一、实验目的实验程序模拟先来先服务FCFS,最短寻道时间优先SSTF,SCAN和循环SCAN 算法的工作过程。

假设有n个磁道号所组成的磁道访问序列,给定开始磁道号m 和磁头移动的方向(正向或者反向),分别利用不同的磁盘调度算法访问磁道序列,给出每一次访问的磁头移动距离,计算每种算法的平均寻道长度,本程序采用随机数来产生磁道数。

二、实验要求算法所需的各种参数由输入产生(手工输入或者随机数产生)。

最后的结果要求是在运行四种算法的程序后,能够输出调度过程、平均寻道长度的正确结果。

三、实验说明(1) 先来先服务.(FCFS):这是一种简单的磁盘调度算法。

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

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

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

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

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

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

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

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

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

(4)循环扫描算法(CSCAN)CSCAN算法是对扫描算法的改进。

如果对磁道的访问请求是均匀分布的,当磁头到达磁盘的一端,并反向运动时落在磁头之后的访问请求相对较少。

这是由于这些磁道刚被处理,而磁盘另一端的请求密度相当高,且这些访问请求等待的时间较长,为了解决这种情况,循环扫描算法规定磁头单向移动。

磁盘调度算法及模拟

磁盘调度算法及模拟

磁盘调度算法及模拟磁盘调度算法是操作系统中用于管理磁盘访问请求的一种机制,其目的是优化磁盘的访问速度和效率。

磁盘调度算法主要考虑如何按照一定的规则来调度磁盘上的读写请求,以尽可能减少磁头的移动距离和等待时间,提高磁盘的访问性能。

常见的磁盘调度算法包括先来先服务(FCFS)、最短寻道时间优先(SSTF)、电梯调度算法(SCAN)、循环扫描算法(C-SCAN)和最短期望时间优先(C-LOOK)等。

1.先来先服务(FCFS)算法:按照请求的顺序处理磁盘访问请求,效率较低。

2.最短寻道时间优先(SSTF)算法:始终选择离当前磁头位置最近的请求进行处理,减少磁头的移动距离。

但容易造成一些请求长时间等待。

3.电梯调度算法(SCAN):磁头按照其中一方向(例如柱面号增大)移动,直到到达磁道的最边缘,然后改变方向继续移动。

这样可以使得距离较远的磁头请求较少等待时间,但在磁头改变方向时可能造成一些请求需要等待。

4.循环扫描算法(C-SCAN):与SCAN类似,但在到达磁道最边缘后,直接返回到最开始的磁道继续扫描。

这样可以减少等待时间,但请求之间可能存在不公平的情况。

5.最短期望时间优先(C-LOOK)算法:磁头按照其中一方向移动,直到扫描完所有请求,然后返回最开始的磁道重新扫描。

这种方式减少了等待时间,并且使请求公平地被处理。

下面对磁盘调度算法进行模拟:假设磁盘上有一系列的读写请求,我们可以随机生成一些磁道号来模拟这些请求。

假设磁头的初始位置在1号磁道,我们可以使用Python编程语言实现一个简单的模拟算法。

```pythonimport random#初始化请求队列request_queue = []for _ in range(10):request_queue.append(random.randint(1, 100))#初始化磁头位置和移动方向head = 1direction = 1#使用SCAN算法进行模拟total_distance = 0while request_queue:#寻找离当前磁头位置最近的请求nearest_request = min(request_queue, key=lambda x: abs(x - head))#计算磁头移动距离,并更新磁头位置distance = abs(nearest_request - head)head = nearest_request#累计移动距离total_distance += distance#处理请求request_queue.remove(nearest_request)#打印相关信息print('磁头移动到磁道{},移动距离为{}'.format(nearest_request, distance))print('总移动距离为:', total_distance)```以上为一个简单的模拟算法,随机生成10个磁道号作为请求,模拟使用SCAN算法进行调度。

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

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

实验七磁盘调度算法的实现
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)画出磁头的移动轨迹图。

模拟实现磁盘调度算法

模拟实现磁盘调度算法

模拟实现磁盘调度算法磁盘调度算法是操作系统中用于确定磁盘驱动器上的读写操作顺序的一种方法。

磁盘调度算法的目标是尽量提高磁盘的利用率和性能,减少磁盘的寻道时间和旋转延迟。

在实现磁盘调度算法之前,让我们先了解一些与磁盘调度相关的概念。

1.磁盘寻道时间:磁盘读/写头从当前磁道移动到目标磁道所需的时间。

寻道时间越短,磁盘访问速度越快。

2.磁盘旋转延迟:磁盘读/写头等待目标扇区旋转到读/写位置所需的时间。

旋转延迟取决于磁盘转速,常用转速为7200转/分钟或更高。

3.请求队列:保存待执行的读/写请求的队列。

4.当前磁道位置:磁盘读/写头当前所在的磁道。

5.下一个请求:即将被执行的读/写请求。

下面我们将模拟实现三种常见的磁盘调度算法:先来先服务(FCFS)、最短寻道时间优先(SSTF)和电梯(LOOK)算法。

1.先来先服务(FCFS)算法:FCFS算法按照请求的先后顺序进行磁盘访问,即先到先服务。

当程序提交读/写请求时,请求按照提交的顺序加入到请求队列中,然后按照队列中的顺序依次执行。

这种算法简单直接,但可能导致磁盘寻道时间较长。

缺点:容易产生“响应时间过长”和“饥饿”现象。

2.最短寻道时间优先(SSTF)算法:SSTF算法每次选择与当前磁头位置最近的磁道进行磁盘访问。

算法会根据当前磁头位置和请求队列中的请求位置计算寻道时间,选择寻道时间最短的请求作为下一个请求。

这种算法可以找到离当前磁头位置最近的请求,有效减少寻道时间。

但可能会导致一些请求一直等待。

3.电梯(LOOK)算法:LOOK算法模拟了电梯的运行方式。

它按照一个方向来执行读/写请求,直到请求队列中没有该方向上的请求,然后改变运行方向,继续执行另一方向上的请求。

LOOK算法是一种比较公平的磁盘调度算法,可以减少寻道时间和旋转延迟。

在实际的磁盘调度算法实现中,我们通常需要实现请求队列的管理、寻道时间计算、磁头位置更新等功能。

可以使用队列来管理请求队列,使用寻道算法计算寻道时间,使用函数来模拟磁头位置的更新。

模拟实现磁盘调度算法

模拟实现磁盘调度算法

《操作系统》课程实验实验课题:模拟实现磁盘调度算法姓名:****学号:*****年级班级: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该算法选择这样的进程,其要求访问的磁道与当前磁头所在的磁道距离最近,以使每次的寻道时间最短,该算法可以得到比较好的吞吐量,但却不能保证平均寻道时间最短。

模拟实现磁盘调度算法

模拟实现磁盘调度算法

《操作系统》课程实验实验课题:模拟实现磁盘调度算法姓名:****学号:*****年级班级: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:末访问} } //voidInit()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].iG o))){ 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) }. . .。

磁盘调度算法的实现

磁盘调度算法的实现

一、实验目的:通过模拟设计磁盘驱动调度程序,观察驱动调度程序的动态运行过程,理解和掌握磁盘驱动调度的职能,并比较各种算法的调度结果。

二、实验容:要求设计主界面能灵活选择某算法,且以下算法都要实现。

(1)先来先服务算法(FCFS)(2)最短寻道时间优先算法(SSTF)(3)扫描算法(SCAN)(4)循环扫描算法(CSCAN)三、实验步骤(1)需求分析:本设计中可在运行时随机产生一个请求序列,先把序列排序,以方便找到下一个要寻找的磁道。

要求用户选择磁头移动方向,向里和向外移动用1和0表示,若输入值不为0或1,则报错。

选择某种调度算法后,要求显示调度顺序和移动的总磁道数。

(2)详细设计:void FCFS(int a[],int n);//先来先服务算法void SSTF(int a[],int n);//最短寻道时间算法void SCAN(int a[],int n);//扫描算法void CSCAN(int a[],int n);//循环扫描算法int main(){int n;//磁道的个数int s;//功能号cout<<"请输入磁道的个数:"<<endl;cin>>n;int *a=new int[n];cout<<"生成随机磁道号..."<<endl;srand((unsigned)time(NULL));for(int i=0;i<n;i++){a[i]=(rand()%100)+1;cout<<a[i]<<" ";}cout<<endl;while(1){ cout<<endl;cout<<"1、先来先服务算法(FCFS)"<<endl;cout<<"2、最短寻道时间算法(SSTF)"<<endl;cout<<"3、扫描算法(SCAN)"<<endl;cout<<"4、循环扫描算法(CSCAN)"<<endl;cout<<"0、退出"<<endl;cout<<endl;cout<<"请选择功能号:";cin>>s;if(s>4){cout<<"输入有误!"<<endl;}else{switch(s){ case 0: exit(0);break ;case 1:FCFS(a,n); break;case 2:SSTF(a, n);break;case 3:SCAN(a, n);break;case 4:CSCAN(a,n);break;}}}return 0;}实验源代码#include<iostream>#include<ctime>using namespace std;void FCFS(int a[],int n);void SSTF(int a[],int n);void SCAN(int a[],int n);void CSCAN(int a[],int n);int main(){int n;//磁道的个数int s;//功能号cout<<"请输入磁道的个数:"<<endl;cin>>n;int *a=new int[n];cout<<"生成随机磁道号..."<<endl;srand((unsigned)time(NULL));for(int i=0;i<n;i++){a[i]=(rand()%100)+1;cout<<a[i]<<" ";}cout<<endl;while(1){ cout<<endl;cout<<"1、先来先服务算法(FCFS)"<<endl; cout<<"2、最短寻道时间算法(SSTF)"<<endl; cout<<"3、扫描算法(SCAN)"<<endl;cout<<"4、循环扫描算法(CSCAN)"<<endl;cout<<"0、退出"<<endl;cout<<endl;cout<<"请选择功能号:";cin>>s;if(s>4){cout<<"输入有误!"<<endl;}else{switch(s){ case 0: exit(0);break ; case 1:FCFS(a,n); break;case 2:SSTF(a, n);break;case 3:SCAN(a, n);break;case 4:CSCAN(a,n);break;}}}return 0;}//先来先服务调度算法(FCFS)void FCFS(int a[],int n){int sum=0,j,i,first=0,now;cout<<"请输入当前磁道号:";cin>>now;//确定当前磁头所在位置cout<<"磁盘调度顺序为:"<<endl;for( i=0;i<n;i++)//按访问顺序输出磁道号{cout<<a[i]<<" ";}//计算sumfor(i=0,j=1;j<n;i++,j++){first+=abs(a[j]-a[i]);//外围磁道与最里面磁道的距离}sum+=first+abs(now-a[0]);cout<<endl;cout<<"移动的总磁道数: "<<sum<<endl;}//最短寻道时间算法(SSTF)void SSTF(int a[],int n){int temp;int k=1;int now,l,r;int i,j,sum=0;//将磁道号按递增排序for(i=0;i<n;i++)for(j=i+1;j<n;j++){if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}cout<<"按递增顺序排好的磁道:"<<endl;for( i=0;i<n;i++){cout<<a[i]<<" ";//输出排好的磁道顺序}cout<<endl;cout<<"请输入当前的磁道号:";cin>>now;//确定当前磁头所在位置cout<<"磁盘调度顺序为:"<<endl;if(a[n-1]<=now)//当前磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--)cout<<a[i]<<" ";sum=now-a[0];}elseif(a[0]>=now)//当前磁头位置小于最里欲访问磁道{for(i=0;i<n;i++)cout<<a[i]<<" ";sum=a[n-1]-now;}else{while(a[k]<now)//确定当前磁道在已排的序列中的位置{k++;}l=k-1;//在磁头位置的前一个欲访问磁道r=k;//磁头欲访问磁道while((l>=0)&&(r<n)){if((now-a[l])<=(a[r]-now))//选择离磁头近的磁道 {cout<<a[l]<<" ";sum+=now-a[l];now=a[l];l=l-1;}else{cout<<a[r]<<" ";sum+=a[r]-now;now=a[r];r=r+1;}}if(l=-1)//磁头位置里侧的磁道已访问完{for(j=r;j<n;j++)//访问磁头位置外侧的磁道{cout<<a[j]<<" ";}sum+=a[n-1]-a[0];}if(r==n)//磁头位置外侧的磁道已访问完{for(j=k-1;j>-1;j--) //访问磁头位置里侧的磁道{cout<<a[j]<<" ";}sum+=a[n-1]-a[0];}}cout<<endl;cout<<"移动的总道数:"<<sum<<endl;}//扫描算法(SCAN)void SCAN(int a[],int n){int temp;int k=1;int now,l,r;int i,j,sum=0;for(i=0;i<n;i++)//对访问磁道按由小到大顺序排列输出 for(j=i+1;j<n;j++){if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}cout<<"按递增顺序排好的磁道:"<<endl;for( i=0;i<n;i++){cout<<a[i]<<" ";}cout<<endl;cout<<"请输入当前的磁道号:";cin>>now;//以下算法确定磁道访问顺序if(a[n-1]<=now) //磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--)cout<<a[i]<<" ";sum=now-a[0];}elseif(a[0]>=now) //磁头位置小于最里欲访问磁道{for(i=0;i<n;i++)cout<<a[i]<<" ";sum=a[n-1]-now;}else //磁头位置在最里侧磁道与最外侧磁道之间{ int d;while(a[k]<now){ //确定当前磁道在已排的序列中的位置k++;}l=k-1;//在磁头位置的前一个欲访问磁道r=k; //磁头欲访问磁道cout<<"请输入当前磁头移动的方向 (0 表示向,1表示向外) : "; cin>>d; //确定磁头访问的方向cout<<"磁盘调度顺序为:";if(d==0||d==1){if(d==0) //磁头向{for(j=l;j>=0;j--){cout<<a[j]<<" ";}for(j=r;j<n;j++){cout<<a[j]<<" ";}sum=now-2*a[0]+a[n-1];}if(d==1) //磁头向外{for(j=r;j<n;j++){cout<<a[j]<<" ";}for(j=l;j>=0;j--){cout<<a[j]<<" ";}sum=2*a[n-1]-now-a[0];}}elsecout<<"请输入0或1!"<<endl;}cout<<endl;cout<<"移动的总道数: "<<sum<<endl;}//循环扫描算法(CSCAN)void CSCAN(int a[],int n){int temp;int now,l,r;int i,j,sum=0;int k=1;for(i=0;i<n;i++)//对访问磁道按由小到大顺序排列输出for(j=i+1;j<n;j++){if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}cout<<"按递增顺序排好的磁道:"<<endl;for( i=0;i<n;i++){cout<<a[i]<<" ";}cout<<endl;cout<<"请输入当前的磁道号:";cin>>now;//确定当前磁道号if(a[n-1]<=now)//磁头位置大于最外围欲访问磁道{for(i=0;i<n;i++)cout<<a[i]<<" ";sum=now-2*a[0]+a[n-1];}elseif(a[0]>=now)//磁头位置小于最里欲访问磁道{for(i=0;i<n;i++)cout<<a[i]<<" ";sum=a[n-1]-now;}else //磁头位置在最里侧磁道与最外侧磁道之间{ int d;while(a[k]<now){k++;}l=k-1;//在磁头位置的前一个欲访问磁道r=k; //磁头欲访问磁道cout<<"请输入当前磁头移动的方向 (0 表示向,1表示向外) : "; cin>>d; //确定磁头访问的方向cout<<"磁盘调度顺序为:";if(d==0||d==1){if(d==1) //磁头向外侧访问{for(j=r;j<n;j++)//先访问外侧磁道再转向最里欲访问磁道{cout<<a[j]<<" ";}for(j=0;j<r;j++){cout<<a[j]<<" ";}sum=2*a[n-1]-now-2*a[0]+a[l];}if(d==0) //磁头向侧访问 {for(j=r-1;j>=0;j--){cout<<a[j]<<" ";}for(j=n-1;j>=r;j--)//{cout<<a[j]<<" ";}sum=2*a[n-1]-2*a[0]+now-a[r];}}elsecout<<"请输入0或1!";}cout<<endl;cout<<"移动的总道数: "<<sum<<endl;}(3)测试结果:1.先来先服务算法(FCFS)测试结果2.最短寻道时间算法(SSTF)测试结果3.循环扫描算法(SCAN)测试结果4.循环扫描算法(CSCAN)测试结果四、设计总结:此次设计基本完成了本实验所规定的功能,但是还不够完善,很多东西做的不够好,程序不够完善和严谨。

磁盘调度算法模拟

磁盘调度算法模拟

磁盘调度算法模拟磁盘调度算法是操作系统中用于优化磁盘寻道时间的重要技术。

在磁盘读写过程中,磁头需要进行寻道和定位,而磁盘调度算法的目标就是通过合理的调度策略,最大限度地减少寻道时间,提高磁盘的读写效率。

下面将介绍几种常见的磁盘调度算法,并进行模拟。

1.先来先服务(FCFS)算法先来先服务算法是最简单的磁盘调度算法之一,它按照进程请求的先后顺序依次进行处理,不考虑磁道位置的远近。

通过模拟一个磁盘请求队列,可以计算出FCFS算法的平均寻道长度。

以下是一个模拟FCFS算法的示例代码:```pythondef FCFS(requests, start):head = starttotal_length = 0for request in requests:total_length += abs(request - head)head = requestreturn total_length / len(requests)```2.最短寻道时间优先(SSTF)算法最短寻道时间优先算法是一种贪心算法,它每次选择离当前磁道位置最近的磁道进行访问,以降低寻道时间。

通过模拟一个磁盘请求队列,可以计算出SSTF算法的平均寻道长度。

以下是一个模拟SSTF算法的示例代码:```pythondef SSTF(requests, start):head = starttotal_length = 0while requests:min_distance = float('inf')min_index = 0for i in range(len(requests)):distance = abs(requests[i] - head)if distance < min_distance:min_distance = distancemin_index = itotal_length += min_distancehead = requests.pop(min_index)return total_length / len(requests)```3.扫描算法(SCAN)和循环扫描算法(C-SCAN)扫描算法和循环扫描算法是两种相似的磁盘调度算法,它们都是从一个磁盘边界开始,依次沿一个方向移动,直到到达磁道的最边界,然后再返回到磁道的起始位置。

相关主题
  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

磁盘调度算法的模拟实现及对比
磁盘调度算法是操作系统中的一个重要组成部分,用于优化磁盘读写操作的效率,提高系统的响应速度和运行效率。

常见的磁盘调度算法包括先来先服务(FCFS)算法、最短寻道时间优先(SSTF)算法、电梯(Elevator)算法等。

在进行磁盘调度算法的比较和模拟之前,我们首先需要了解磁盘读写操作的基本原理。

磁盘是由许多磁道和扇区组成的,当操作系统需要对磁盘进行读写操作时,读写头需要按照特定的路径移动到目标扇区,这个过程称为寻道。

而磁头在寻道的过程中所花费的时间称为寻道时间。

不同的磁盘调度算法的主要目标就是使得寻道时间尽可能地短,从而提高磁盘的读写操作效率。

首先,我们来实现一个先来先服务(FCFS)算法的模拟。

FCFS算法是最简单的磁盘调度算法,它按照磁盘请求的先后顺序进行处理。

具体实现如下:
```python
def fcfs(disk_queue, start):
head_movement = 0
curr_pos = start
for request in disk_queue:
head_movement += abs(request - curr_pos)
curr_pos = request
return head_movement
```
上述代码中,`disk_queue`表示磁盘请求队列,`start`表示起始磁道号。

算法首先将磁头移动到起始磁道号`start`,然后按照磁盘请求的先后顺序对队列中的请求进行处理,计算磁头的移动距离。

最后返回磁头的总移动距离。

接下来,我们实现一个最短寻道时间优先(SSTF)算法的模拟。

SSTF 算法会选择离当前磁道最近的请求进行处理,从而减少磁头的寻道时间。

具体实现如下:
```python
def sstf(disk_queue, start):
head_movement = 0
curr_pos = start
while disk_queue:
min_distance = float('inf')
min_index = -1
for i, request in enumerate(disk_queue):
distance = abs(request - curr_pos)
if distance < min_distance:
min_distance = distance
min_index = i
head_movement += min_distance
curr_pos = disk_queue.pop(min_index)
return head_movement
```
上述代码中,算法首先将磁头移动到起始磁道号`start`,然后不断选择离当前磁道最近的请求处理,直到所有请求处理完毕。

计算磁头的总移动距离并返回。

最后,我们实现一个电梯(Elevator)算法的模拟。

电梯算法模拟了磁头在磁盘上类似电梯运行的行为,它会按照一些方向进行寻道操作,直到该方向上没有更多的请求,然后改变方向寻找另一侧的请求。

具体实现如下:
```python
def elevator(disk_queue, start):
head_movement = 0
curr_pos = start
direction = 1 # 1: up, -1: down
while disk_queue:
min_distance = float('inf')
min_index = -1
for i, request in enumerate(disk_queue):
if (direction == 1 and request >= curr_pos) or (direction == -1 and request <= curr_pos):
distance = abs(request - curr_pos)
if distance < min_distance:
min_distance = distance
min_index = i
if min_index == -1:
direction = -direction
continue
head_movement += min_distance
curr_pos = disk_queue.pop(min_index)
return head_movement
```
上述代码中,算法首先将磁头移动到起始磁道号`start`,然后根据当前的方向选择离当前磁道最近的请求进行处理,直到所有请求处理完毕或当前方向上没有更多的请求。

如果当前方向上没有更多的请求,算法会改变方向寻找另一侧的请求。

计算磁头的总移动距离并返回。

下面进行这三个磁盘调度算法的比较。

假设有一个磁盘请求队列`[98,183,37,122,14,124,65,67]`,起始磁
道号为`53`。

使用FCFS算法处理该磁盘请求队列,磁头的总移动距离为`640`。

使用SSTF算法处理该磁盘请求队列,磁头的总移动距离为`236`。

使用Elevator算法处理该磁盘请求队列,磁头的总移动距离为`208`。

通过比较可以发现,Elevator算法相比于FCFS算法和SSTF算法,
减少了磁头的移动距离,从而提高了磁盘读写操作的效率。

综上所述,磁盘调度算法的模拟实现及对比结果显示,Elevator算
法在减少寻道时间上有较好的效果。

但需要注意的是,选择哪种调度算法
要根据具体的应用场景和系统需求进行权衡和选择。

相关文档
最新文档