精华内容
下载资源
问答
  • 操作系统磁盘调度算法
    千次阅读
    2019-10-18 15:17:57

    C(C++)操作系统磁盘调度算法

    1.种类:
    在操作系统中基本的调度算法包括以下4类:
    (1)先来先服务算法(FCFS)
    FCFS顾名思义就是:按照作业提交或进程变为就绪状态的先后次序,分派CPU; 当前作业或进程占用CPU,直到执行完或阻塞,才出让CPU(非抢占方式),这是最简单的磁盘调度算法。总结成一句话就是:先来的先执行。
    特点:比较有利于长作业,而不利于短作业。 有利于CPU繁忙的作业,而不利于I/O繁忙的作业。
    (2)最短查找(寻道)时间优先算法(SSTF)
    SSTF:考虑I/O请求之间的区别,总是先执行查找时间最短的请求,与FCFS算法相比有较好的寻道功能。简单来说就是每次总是寻找离当前磁头相差最小的执行。
    特点:改善了磁盘平均服务时间,但造成某些访问请求长期等待得不到服务。
    (3)电梯调度算法/扫描算法(SCAN)
    SCAN:移动臂每次沿一个方向移动,扫过所有柱面,遇到最近的I/O请求便进行处理,直至到达最后一个柱面后再向相反的方向移动回来。
    电梯调度算法/扫描算法
    特点:克服了最短寻道优先的缺点,既考虑了距离,同时又考虑了方向。
    (4)循环扫描算法(CSCAN)
    CSCAN:他的思想是,访问完最里边一个要求服务的序列之后,从最外层的序号楷书往里走,即始终保持一个方向。
    2.代码实现:
    在这里四个算法都使用Print()函数输出,SSTF、SCAN、SCAN都依赖于FCFS算法。即对上述三个算法做相应的变换使其利用FCFS的方式输出。

    • 输出函数Print()
      此函数有三个参数,第一个数组arr[]中存储着所有等待的柱面号,trackNumber代表当前磁头所在的位置,m是等待着的柱面号的个数。依次遍历将移动的距离累加在sum中。
    void Print(int arr[maxsize],int trackNumber,int m){
        int i,j,sum=0;
    
         cout<<"移动次序\t"<<"当前柱面号\t"<<"下一个柱面号\t"<<"移动距离\t"<<"已移动距离"<<endl;
         for(i=0;i<m;i++){
            if(i==0){
                    sum+=abs(arr[i]-trackNumber);
                cout<<i+1<<"  \t\t"<<trackNumber<<"  \t\t"<<arr[i]<<"  \t\t"<<abs(arr[i]-trackNumber)<<"  \t\t"<<sum<<endl;
    
            }
    
            else{ sum+=abs(arr[i]-arr[i-1]);
                cout<<i+1<<"  \t\t"<<arr[i-1]<<"  \t\t"<<arr[i]<<"  \t\t"<<abs(arr[i]-arr[i-1])<<"  \t\t"<<sum<<endl;
    
            }
    
         }
    
         cout<<"移动总柱面数为:"<<sum<<endl;
    }
    
    • 先来先服务算法(FCFS)
      基本思想: 因为FCFS本就是按照作业的提交次序执行的所以只需调用Print()函数即可:
      代码
     void FCFS(int arr[maxsize],int trackNumber,int m)
    {
    	 Print(arr,trackNumber,m);
    }
    
    • 最短查找(寻道)时间优先算法(SSTF)
      基本思想:SSTF即考虑I/O请求之间的区别,总是先执行查找时间最短的请求。第一个数组a[]中存储着所有等待的柱面号,now代表当前磁头所在的位置,n是等待着的柱面号的个数。依次对数组a进行遍历,每次将与当前磁头距离最近的存在数组next[]中,此时的next中就是SSTF的执行次序,然后调用Print()函数依次输出。
      代码
    void SSTF(int a[],int n,int now){
    	int i,min,k=0,first=now;
    	int flag;//最短路径的下标
    	int t=n;
    	int next[maxsize],length[maxsize];
    	int visit[maxsize]={0};//访问数组,已经访问过的为1
    	//寻道n次
    	while(t--){
    		min=999999;
    		//找没有访问过的中最近的
    		for(i=0;i<n;i++){
    			if(visit[i])
    				continue;
    			if(abs(a[i]-now)<min){
    				flag=i;
    				min=abs(a[i]-now);
    			}
    		}
    		length[k]=min;//移动的距离
    		next[k++]=a[flag];//下一个被访问的磁道号
    		visit[flag]=1;//访问过的置1
    		now=a[flag];//磁道移动到当前位置
    	}
    	Print(next,first,n);
    
    }
    
    • 电梯调度算法/扫描算法(SCAN)
      基本思想:此算法中的参数与上边相同,但有一点不同的是电梯调度算法区分方向。此算法的原理是先选择是往大(小)的方向移动,之后将arr[]数组中的磁道分为两部分即以现在的磁头为准则将大于它的存在一个数组中,将小于它的存在一个数组中,并用函数 BubbleSort1和 BubbleSort2对其排序。如果选择往大(小)的方向移动即比现在磁头所在柱面大的那个数组按从小到大(从大到小)的顺序排列,比它小的按从大到小(从小到大)的顺序排列。则它的执行次序就是:比它他大的那个数组+比它小的那个数组(比它他小的那个数组+比它大的那个数组)。然后调用Print()函数输出即可。
      代码
    void BubbleSort1(int *arr,int sz){
        int i = 0;
        int j = 0;
    
        for(i=0;i<sz-1;i++){
            for(j=0;j<sz-i-1;j++){
                if(arr[j]>arr[j+1]){
                    int tmp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = tmp;
                }
            }
        }
    }
    
    
    
    void BubbleSort2(int *arr,int sz){
        int i = 0;
        int j = 0;
    
        for(i=0;i<sz-1;i++){
            for(j=0;j<sz-i-1;j++){
                if(arr[j]<arr[j+1]){
                    int tmp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = tmp;
                }
            }
        }
    }
    
    void SCAN(int arr[],int number,int n){/*电梯调度算法(扫描算法)*/
        int count=0;
        int sum1=0,sum2=0;
        for(int i=0;i<n;i++){
            if(arr[i]>number)
                count++;
        }
        int arr1[count],arr2[n-count];
        int i1=0,i2=0;
        for(int i=0;i<n;i++){
            if(arr[i]>number){
                arr1[i1]=arr[i];
                i1++;
            }
            else{
                arr2[i2]=arr[i];
                i2++;
            }
        }
    
        cout<<"请选择1:往大的方向移动"<<endl;
        cout<<"请选择2:往小的方向移动"<<endl;
        int p;
        cin>>p;
        if(p==1){
                 BubbleSort1(arr1,count);
            BubbleSort2(arr2,n-count);
            int ele_arr1[n];
            for(int i=0;i<n;i++){
                if(i<count)
                    ele_arr1[i]=arr1[i];
                else
                    ele_arr1[i]=arr2[i-count];
            }
            Print(ele_arr1,number,n);
        }
            else if(p==2){
                     BubbleSort1(arr1,count);
                BubbleSort2(arr2,n-count);
                int ele_arr2[n];
            for(int i=0;i<n;i++){
                if(i<n-count)
                    ele_arr2[i]=arr2[i];
                else
                    ele_arr2[i]=arr1[i-(n-count)];
            }
            Print(ele_arr2,number,n);
            }
            else
                cout<<"输入错误!"<<endl;
    }
    
    • 循环扫描算法(CSCAN)
      基本思想:CSCAN的具体思想和SCAN类似,只是它执行时必须到“头”,即多了一个最大柱面号。

    代码

    void CSCAN(int arr[],int number,int n,int maxnumber){/*循环扫描算法*/
        int count=0;
        int sum=1;
        for(int i=0;i<n;i++){
            if(arr[i]>number)
                count++;
        }
        int arr1[count],arr2[n-count];
        int i1=0,i2=0;
        for(int i=0;i<n;i++){
            if(arr[i]>number){
                arr1[i1]=arr[i];
                i1++;
            }
            else{
                arr2[i2]=arr[i];
                i2++;
            }
        }
        int sum1=0,sum2=0;
          cout<<"请选择1:往大的方向移动"<<endl;
        cout<<"请选择2:往小的方向移动"<<endl;
        int p;
        cin>>p;
        if(p==1){
                 BubbleSort1(arr1,count);
            BubbleSort1(arr2,n-count);
            int scf_arr1[n+1];
            for(int i=0;i<n+1;i++){
                if(i<count)
                    scf_arr1[i]=arr1[i];
                else if(i==count)
                    scf_arr1[i]=maxnumber;
                else
                    scf_arr1[i]=arr2[i-count-1];
            }
            Print(scf_arr1,number,n+1);
    
        }
        else if(p==2){
             BubbleSort2(arr1,count);
        BubbleSort2(arr2,n-count);
         int scf_arr2[n+1];
            for(int i=0;i<=n;i++){
                if(i<n-count)
                    scf_arr2[i]=arr2[i];
                else if(i==n-count)
                    scf_arr2[i]=maxnumber;
                else
                    scf_arr2[i]=arr1[i-(n-count)-1];
            }
            Print(scf_arr2,number,n+1);
        }
        else
            cout<<"错误!"<<endl;
    
    }
    

    整体代码如下:

    #include <iostream>
    #include<bits/stdc++.h>
    #include<malloc.h>
    #include<stdio.h>
    #include<cstdlib>
    #define maxsize 200
    using namespace std;
    
    void Print(int arr[maxsize],int trackNumber,int m){
        int i,j,sum=0;
    
         cout<<"移动次序\t"<<"当前柱面号\t"<<"下一个柱面号\t"<<"移动距离\t"<<"已移动距离"<<endl;
         for(i=0;i<m;i++){
            if(i==0){
                    sum+=abs(arr[i]-trackNumber);
                cout<<i+1<<"  \t\t"<<trackNumber<<"  \t\t"<<arr[i]<<"  \t\t"<<abs(arr[i]-trackNumber)<<"  \t\t"<<sum<<endl;
    
            }
    
            else{ sum+=abs(arr[i]-arr[i-1]);
                cout<<i+1<<"  \t\t"<<arr[i-1]<<"  \t\t"<<arr[i]<<"  \t\t"<<abs(arr[i]-arr[i-1])<<"  \t\t"<<sum<<endl;
    
            }
    
         }
    
         cout<<"移动总柱面数为:"<<sum<<endl;
    }
    /*先来先服务*/
    void FCFS(int arr[maxsize],int trackNumber,int m)
    {Print(arr,trackNumber,m);}
    
    
    //最短寻道时间优先算法
    void SSTF(int a[],int n,int now){
    	int i,min,k=0,first=now;
    	int flag;//最短路径的下标
    	int t=n;
    	int next[maxsize],length[maxsize];
    	int visit[maxsize]={0};//访问数组,已经访问过的为1
    	//寻道n次
    	while(t--){
    		min=999999;
    		//找没有访问过的中最近的
    		for(i=0;i<n;i++){
    			if(visit[i])
    				continue;
    			if(abs(a[i]-now)<min){
    				flag=i;
    				min=abs(a[i]-now);
    			}
    		}
    		length[k]=min;//移动的距离
    		next[k++]=a[flag];//下一个被访问的磁道号
    		visit[flag]=1;//访问过的置1
    		now=a[flag];//磁道移动到当前位置
    	}
    	Print(next,first,n);
    
    }
    
    void BubbleSort1(int *arr,int sz){
        int i = 0;
        int j = 0;
    
        for(i=0;i<sz-1;i++){
            for(j=0;j<sz-i-1;j++){
                if(arr[j]>arr[j+1]){
                    int tmp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = tmp;
                }
            }
        }
    }
    void BubbleSort2(int *arr,int sz){
        int i = 0;
        int j = 0;
    
        for(i=0;i<sz-1;i++){
            for(j=0;j<sz-i-1;j++){
                if(arr[j]<arr[j+1]){
                    int tmp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = tmp;
                }
            }
        }
    }
    void SCAN(int arr[],int number,int n){/*电梯调度算法(扫描算法)*/
        int count=0;
        int sum1=0,sum2=0;
        for(int i=0;i<n;i++){
            if(arr[i]>number)
                count++;
        }
        int arr1[count],arr2[n-count];
        int i1=0,i2=0;
        for(int i=0;i<n;i++){
            if(arr[i]>number){
                arr1[i1]=arr[i];
                i1++;
            }
            else{
                arr2[i2]=arr[i];
                i2++;
            }
        }
    
        cout<<"请选择1:往大的方向移动"<<endl;
        cout<<"请选择2:往小的方向移动"<<endl;
        int p;
        cin>>p;
        if(p==1){
                 BubbleSort1(arr1,count);
            BubbleSort2(arr2,n-count);
            int ele_arr1[n];
            for(int i=0;i<n;i++){
                if(i<count)
                    ele_arr1[i]=arr1[i];
                else
                    ele_arr1[i]=arr2[i-count];
            }
            Print(ele_arr1,number,n);
        }
            else if(p==2){
                     BubbleSort1(arr1,count);
                BubbleSort2(arr2,n-count);
                int ele_arr2[n];
            for(int i=0;i<n;i++){
                if(i<n-count)
                    ele_arr2[i]=arr2[i];
                else
                    ele_arr2[i]=arr1[i-(n-count)];
            }
            Print(ele_arr2,number,n);
            }
            else
                cout<<"输入错误!"<<endl;
    }
    
    void CSCAN(int arr[],int number,int n,int maxnumber){/*循环扫描算法*/
        int count=0;
        int sum=1;
        for(int i=0;i<n;i++){
            if(arr[i]>number)
                count++;
        }
        int arr1[count],arr2[n-count];
        int i1=0,i2=0;
        for(int i=0;i<n;i++){
            if(arr[i]>number){
                arr1[i1]=arr[i];
                i1++;
            }
            else{
                arr2[i2]=arr[i];
                i2++;
            }
        }
        int sum1=0,sum2=0;
          cout<<"请选择1:往大的方向移动"<<endl;
        cout<<"请选择2:往小的方向移动"<<endl;
        int p;
        cin>>p;
        if(p==1){
                 BubbleSort1(arr1,count);
            BubbleSort1(arr2,n-count);
            int scf_arr1[n+1];
            for(int i=0;i<n+1;i++){
                if(i<count)
                    scf_arr1[i]=arr1[i];
                else if(i==count)
                    scf_arr1[i]=maxnumber;
                else
                    scf_arr1[i]=arr2[i-count-1];
            }
            Print(scf_arr1,number,n+1);
    
        }
        else if(p==2){
             BubbleSort2(arr1,count);
        BubbleSort2(arr2,n-count);
         int scf_arr2[n+1];
            for(int i=0;i<=n;i++){
                if(i<n-count)
                    scf_arr2[i]=arr2[i];
                else if(i==n-count)
                    scf_arr2[i]=maxnumber;
                else
                    scf_arr2[i]=arr1[i-(n-count)-1];
            }
            Print(scf_arr2,number,n+1);
        }
        else
            cout<<"错误!"<<endl;
    
    }
    int main()
    {
        int n,number,choice,maxnumber,i;
        int brr[maxsize];
        cout<<"请输入等待访问的磁道的个数:"<<endl;
        cin>>n;
        int a[n];
        cout<<"请依次输入等待的"<<n<<"个柱面号:"<<endl;
        for(int i=0;i<n;i++)
        cin>>a[i];
        cout<<"请输入当前磁头位置:"<<endl;
        cin>>number;
        cout<<"***********************菜单***********************"<<endl;
         cout<<"*"<<"\t\t\t\t\t\t "<<"*"<<endl;
          cout<<"*"<<"\t\t\t\t\t\t "<<"*"<<endl;
          cout<<"*"<<"\t\t"<<"1.先来先服务算法"<<"\t\t "<<"*"<<endl;
          cout<<"*"<<"\t\t"<<"2.最短作业优先算法"<<"\t\t "<<"*"<<endl;
        cout<<"*"<<"\t\t"<<"3.电梯调度算法"<<"\t\t\t "<<"*"<<endl;
        cout<<"*"<<"\t\t"<<"4.循环扫描算法"<<"\t\t\t "<<"*"<<endl;
         cout<<"*"<<"\t\t"<<"5.退出"<<"\t\t\t\t "<<"*"<<endl;
        cout<<"*"<<"\t\t\t\t\t\t "<<"*"<<endl;
         cout<<"*"<<"\t\t\t\t\t\t "<<"*"<<endl;
          cout<<"*"<<"************************************************"<<"*"<<endl;
          while(true){
          cout<<"请选择要执行的算法"<<endl;
          cin>>choice;
          switch(choice){
            case 1:FCFS(a,number,n);break;
            case 2:SSTF(a,n,number);
                    break;
            case 3:SCAN(a,number,n);break;
            case 4:cout<<"请输入最大磁头号:"<<endl;
                    cin>>maxnumber;
                    CSCAN(a,number,n,maxnumber);break;
            case 5:exit(0);
          }
          }
        return 0;
    }
    
    
    更多相关内容
  • 操作系统磁盘调度算法实验报告
  • 假设有 n 个磁道号所组成 的磁道访问序列,给定开始磁道号 m 和磁头移动的方向,正向 或者反向,分别利用不同的磁盘调度算法访问磁道序列,给出 每一次访问的磁头移动距离,计算每种算法的平均寻道长度
  • 操作系统上机实验,要求使用C语言实现FCFS/SSTF/SCAN/CSCAN四种磁盘调度算法 本程序界面清晰,运行结果与教材一致,可以修改最大磁道号和初始磁道号(SSTF,SCAN,CSCAN算法中从哪个磁道号开始搜索),交互性较好 欢迎...
  • 武汉理工大学计算机科学与技术学院操作系统磁盘调度算法
  • 目录 目录 1 1课程设计目的 2 1.1 编写目的 2 2课程设计内容 2 2.1 设计内容 2 3课程设计方案 3 3.1 模块划分 3 3.2 模块调用关系图 6 3.3 子模块程序流程图 6 4测试数据和结果 10 4.1 测试数据 10 4.2 测试结果 11 ...
  • 基于c++开发的操作系统磁盘调度算法,下载在vc/vs环境中可以直接运行,有较为详细的备注
  • 本文档是计算机操作系统实验,用FSFC算法和SCAN算法实现了磁盘调度算法
  • (1) 实现的磁盘调度算法有FCFS,SSTF,SCAN,CSCAN和 NStepSCAN算法。 (2) 设定开始磁道号寻道范围,依据起始扫描磁道号和最大磁道号数,随机产生要进行寻道的磁道号序列。 (3) 选择磁盘调度算法,显示该算法的磁道...
  • 磁盘调度算法 FCFS 将需要分配的先来先分配。算法实现,直接计算每两个之间磁盘移动的距离。取一个绝对值。 void FCFS(){ cout<<"FCFS: \n"; int pre=100; cout<<"\n从100号磁道开始\n\n"; cout<...

    磁盘调度算法

    FCFS

    将需要分配的先来先分配。算法实现,直接计算每两个之间磁盘移动的距离。取一个绝对值。

    void FCFS(){
    	cout<<"FCFS: \n";
    	int pre=100;
    	cout<<"\n从100号磁道开始\n\n";
    	cout<<"下一个磁道号 移动距离\n"<<endl;
    	int sum=0;
    	for(int i=1;i<len;i++){
    		cout<<"     "<<q[i]<<"      "<<abs(q[i]-q[i-1])<<endl;
    		sum+=abs(q[i]-q[i-1]);
    	}
    
    	cout<<"总移动长度  "<<sum<<endl;
    	cout<<"平均寻道长度  "<<(double)(sum*1.0/(len-1))<<endl;
    }
    

    SSTF

    FCFS的平均寻到距离较大。SSTF算法会选择要求访问的磁道与当前磁头所在的磁道距离最近的。

    算法实现:用循环暴力去未分配磁盘的作业序列里找和当前最近的。

    void SSTF(){
    	cout<<"SSTF: \n";
    	int pre=100,cnt=0,sum=0;
    	bool vis[1010];
    	for(int i=0;i<len;i++) vis[i]=false;
    	cout<<"下一个磁道号 移动距离\n"<<endl;
    	vis[0]=true;
    	while(cnt<len-1){
    		int pos=0,mi=1e9;
    		for(int i=1;i<len;i++){
    			if(abs(q[i]-pre)<mi&&!vis[i]){
    				pos=i;
    				mi=abs(q[i]-pre);
    			}
    		}
    		cout<<q[pos]<<"        "<<mi<<endl;
    		pre=q[pos];
    		vis[pos]=true;
    		sum+=mi;
    		cnt++;
    	}
    	cout<<"总移动长度  "<<sum<<endl;
    	cout<<"平均寻道长度  "<<(double)(sum*1.0/(len-1))<<endl;
    }
    

    电梯磁盘调度算法 SCAN

    固定一个方向,扫描到边界,到边界之后在回到另一边。

    算法实现:将序列排好序,找到起始位置,固定开始方向向右,循环向右,然后再循环向左。

    void SCAN(){
    	cout<<"SCAN:"<<endl;
    	sort(q,q+len);
    	int start=-1;
    	bool vis[1001];
    	for(int i=0;i<len;i++) vis[i]=false;
    	//假设起始点是100,找到排序后100的位置,采用优先向右走
    	for(int i=0;i<len;i++){
    		if(q[i]==100) {
    			start=i;
    			vis[i]=true;
    			break;
    		}
    	}
    
    	cout<<"下一个磁道号 移动距离\n"<<endl;
    	int sum=0;
    	for(int i=start+1;i<len;i++){
    		cout<<q[i]<<"     "<<q[i]-q[i-1]<<endl;
    		sum+=q[i]-q[i-1];
    	}
    
    	cout<<q[start-1]<<"     "<<q[len-1]-q[start-1]<<endl;
    	sum+=q[len-1]-q[start-1];
    
    	for(int i=start-2;i>=0;i--){
    		cout<<q[i]<<"     "<<q[i+1]-q[i]<<endl;
    		sum+=q[i+1]-q[i];
    	}
    
    	cout<<"总移动长度  "<<sum<<endl;
    	cout<<"平均寻道长度  "<<(double)(sum*1.0/(len-1))<<endl;
    
    }
    

    实验九 磁盘调度算法的模拟

    使用C语言完成磁盘调度算法中的最短寻道时间优先调度算法和电梯调度算法!假设进程请求的访问磁盘的磁道序列号为:100 55 58 39 18 90 160 150 38 184请输出采用不同算法时访问的磁道号,并计算平均寻道长度。请提交源代码和运行结果截图!

    代码:

    #include<bits/stdc++.h>
    using namespace std;
    const int N=1010;
    int len=0,x;//len表示序列的长度
    int q[N];//存储作业序列
    /*
    作业序列,以下作业起点均假设为100,和书上P242一致
    100 55 58 39 18 90 160 150 38 184 -1 
    */
    void FCFS(){
    	cout<<"FCFS: \n";
    	int pre=100;
    	cout<<"\n从100号磁道开始\n\n";
    	cout<<"下一个磁道号 移动距离\n"<<endl;
    	int sum=0;
    	for(int i=1;i<len;i++){ //循环遍历一遍即可
    		cout<<"     "<<q[i]<<"      "<<abs(q[i]-q[i-1])<<endl;
    		sum+=abs(q[i]-q[i-1]);
    	}
    
    	cout<<"总移动长度  "<<sum<<endl;
    	cout<<"平均寻道长度  "<<(double)(sum*1.0/(len-1))<<endl;//序列长度为len,寻道len-1次。
    }
    
    void SSTF(){
    	cout<<"SSTF: \n";
    	int pre=100,cnt=0,sum=0;
    	bool vis[1010];
    	for(int i=0;i<len;i++) vis[i]=false;
    	cout<<"下一个磁道号 移动距离\n"<<endl;
    	vis[0]=true;
    	while(cnt<len-1){
    		int pos=0,mi=1e9;
    		for(int i=1;i<len;i++){//两重循环,每一次都循环找和当前最近的,这里其实可以二分的,但是这种作业没必要。
    			if(abs(q[i]-pre)<mi&&!vis[i]){
    				pos=i;
    				mi=abs(q[i]-pre);
    			}
    		}
    		cout<<q[pos]<<"        "<<mi<<endl;
    		pre=q[pos];
    		vis[pos]=true;
    		sum+=mi;
    		cnt++;
    	}
    	cout<<"总移动长度  "<<sum<<endl;
    	cout<<"平均寻道长度  "<<(double)(sum*1.0/(len-1))<<endl;//序列长度为len,寻道len-1次。
    }
    
    void SCAN(){
    	cout<<"SCAN:"<<endl;
    	sort(q,q+len);
    	int start=-1;
    	bool vis[1001];
    	for(int i=0;i<len;i++) vis[i]=false;
    	//假设起始点是100,找到排序后100的位置,采用优先向右走
    	for(int i=0;i<len;i++){
    		if(q[i]==100) {
    			start=i;
    			vis[i]=true;
    			break;
    		}
    	}
    
    	cout<<"下一个磁道号 移动距离\n"<<endl;
    	int sum=0;
    	for(int i=start+1;i<len;i++){//向右扫描
    		cout<<q[i]<<"     "<<q[i]-q[i-1]<<endl;
    		sum+=q[i]-q[i-1];
    	}
    
    	cout<<q[start-1]<<"     "<<q[len-1]-q[start-1]<<endl;
    	sum+=q[len-1]-q[start-1];//回到左边最近需要分配的作业
    
    	for(int i=start-2;i>=0;i--){//循环向左扫描
    		cout<<q[i]<<"     "<<q[i+1]-q[i]<<endl;
    		sum+=q[i+1]-q[i];
    	}
    
    	cout<<"总移动长度  "<<sum<<endl;
    	cout<<"平均寻道长度  "<<(double)(sum*1.0/(len-1))<<endl;//序列长度为len,寻道len-1次。
    
    }
    
    
    int main(){
    	printf("请输入进程请求的访问磁盘的磁道序列号(输入-1结束)\n");
    	while(cin>>x){
    		if(x==-1) break;
    		q[len++]=x;
    	}
    	FCFS();
    	cout<<"\n<---------------------------->\n"<<endl;
    	SSTF();
    	cout<<"\n<---------------------------->\n"<<endl;
    	SCAN();
    }
    

    实现截图:

    image-20220526183259723

    image-20220526183319546

    image-20220526183333641

    总结:实现的比较简单,有很多小细节没有具体去细化。

    展开全文
  • FIFO:先进先出的调度策略,这个策略具有公平的优点,因为每个请求都会得到处理,并且是按照接收到的顺序进行处理 ...  磁盘调度算法的数据比较  磁盘调度算法的描述  磁盘调度算法的直观比较
  • #include<stdio.h> #include<math.h> #define M 100 void FCFS(int b[],int n,int first) //先来先服务 { int i,f,sum=0; int a[M]; f=first;... printf"FCFS算法调度次序; printf%d,f; for(i=0;i;
  • 操作系统调度算法代码 操作系统磁盘调度算法java版.doc
  • 操作系统实验六 磁盘调度算法(内含源代码和详细实验报告),详细介绍:http://blog.csdn.net/xunciy/article/details/79239096
  • 操作系统课程设计任务书 题 目: 磁盘调度算法 院 系: 专 业: 班 级: 姓 名: 学 号: 指导教师: 设计时间: 2018.1.1-2018.1.5 指 导 教 师 评 语 " " " " " " " " " " " " " " " " " " " " " " " " " " ...
  • 用java解决操作系统中的磁盘调度算法,包括了先来先服务法,最短寻到优先法以及电梯算法
  • 实用标准文案 操作系统课程设计任务书 题 目 磁盘调度算法 院 系 专 业 班 级 姓 名 学 号 指导教师 设计时间 2018.1.1-2018.1.5 精彩文档 实用标准文案 指 导 教 师 评 语 精彩文档 实用标准文案 成绩评定 指导教师...
  • 实用标准文案 目录 目录 1 1 课程设计目的 1 1.1 编写目的 1 2 课程设计内容 1 2.1 设计...1.1 编写目的 本课程设计的目的是通过磁盘调度算法设计一个磁盘调度模拟系统 从而使磁盘调度算法更加形象化容易使人理解使磁
  • 实验六 磁盘调度算法 1 实验目的 通过这次实验加深对磁盘调度算法的理解进一步掌握先来先 服务 FCFS最 短寻道时间优先 SSTFSCAN和循环 SCAN算法 的实现方法 2 试验内容 问题描述 设计程序模拟先来先服务 FCFS最短...
  • 操作系统磁盘调度算法课程设计.doc
  • 操作系统 磁盘调度算法课程设计.doc
  • NULL 博文链接:https://bosshida.iteye.com/blog/620814
  • 操作系统

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 65,931
精华内容 26,372
关键字:

操作系统磁盘调度算法