精华内容
下载资源
问答
  • 磁盘调度算法代码
    千次阅读
    2020-08-09 21:13:56

    一、实验目的及要求

        通过模拟磁盘调度算法加深对磁盘调度的理解,熟悉磁盘管理系统的设计方法;加深对磁盘访问过程的理解。

    二、实验内容

         编程实现下述磁盘调度算法,并求出每种算法的平均寻道长度,并给出调度顺序;要求在主界面中灵活选择调度算法,要求实现以下磁盘调度算法:

        1.先来先服务FCFS  

        2.最短寻道时间优先SSTF   

        3.扫描算法SCAN   

       4.循环扫描算法CSCAN

    三、程序结构及流程图 

    程序包含一个主函数以及四种调度算法对应的子函数。

    更多相关内容
  • 武汉理工大学计算机科学与技术学院操作系统磁盘调度算法
  • 操作系统上机实验,要求使用C语言实现FCFS/SSTF/SCAN/CSCAN四种磁盘调度算法 本程序界面清晰,运行结果与教材一致,可以修改最大磁道号和初始磁道号(SSTF,SCAN,CSCAN算法中从哪个磁道号开始搜索),交互性较好 欢迎...
  • 如何使用代码: ... 磁盘调度算法 磁盘调度是由操作系统完成的,以调度到达磁盘的I / O请求。 磁盘调度也称为I / O调度。 磁盘调度很重要,因为: Multiple I/O requests may arrive by different processe
  • FIFO:先进先出的调度策略,这个策略具有公平的优点,因为每个请求都会得到处理,并且是按照接收到的顺序进行处理 ...  磁盘调度算法的数据比较  磁盘调度算法的描述  磁盘调度算法的直观比较
  • 基于c++开发的操作系统磁盘调度算法,下载在vc/vs环境中可以直接运行,有较为详细的备注
  • (1) 实现的磁盘调度算法有FCFS,SSTF,SCAN,CSCAN和 NStepSCAN算法。 (2) 设定开始磁道号寻道范围,依据起始扫描磁道号和最大磁道号数,随机产生要进行寻道的磁道号序列。 (3) 选择磁盘调度算法,显示该算法的磁道...
  • 操作系统——磁盘调度算法代码实现

    千次阅读 多人点赞 2019-12-18 09:20:50
    磁盘调度算法 先来先服务算法(FCFS): 先来先服务算法根据访问磁盘的先后顺序进行,由当前磁头位置移动到首先到达缓存区的磁盘。优点:公平/简单,该算法的平均寻道时间相对较长。 void FCFS() { int sum=0; ...

    磁盘调度算法

    先来先服务算法(FCFS):

    先来先服务算法根据访问磁盘的先后顺序进行,由当前磁头位置移动到首先到达缓存区的磁盘。优点:公平/简单,该算法的平均寻道时间相对较长。

    void FCFS()
    {
        int sum=0;
        int start;
        int Find[11];
        cout<<"请输入当前磁头位置:";
        cin>>start;
        cout<<"请输入10个需要遍历的磁盘号:"<<endl;;
        for(int i=1; i<=10; i++)
        {
            cout<<"i="<<i<<":";
            cin>>Find[i];
        }
        cout<<"当前算法的遍历路径为:\n"<<endl;
        cout<<start<<"-->";
    
        for(int i=1; i<=10; i++)
        {
            if(i==1)
                sum+=abs(start-Find[i]);
            else
                sum+=abs(Find[i-1]-Find[i]);
            if(i==10)
                cout<<Find[i]<<endl;
            else
                cout<<Find[i]<<"-->";
        }
        cout<<"\n当前算法的磁头移动总量为:"<<sum<<"\n"<<endl;
        system("pause");
    }

     

    最短寻道时间优先算法(SSTF):

    首先确定磁头当前位置,根据所有到达缓存区的磁盘位置,找到距离最短的磁盘位置,首先进行访问,利用贪心思想,每次都选取当前最优解实现访问

    void SSTF()
    {
        struct P
        {
            int location;
            int flag;
        } Find[11];
        int sum=0;
        int start;
        int now;
        int Short=0;
        cout<<"请输入当前磁头位置:";
        cin>>start;
        cout<<"请输入10个需要遍历的磁盘号:"<<endl;;
        for(int i=1; i<=10; i++)
        {
            cout<<"i="<<i<<":";
            cin>>Find[i].location;
            Find[i].flag=0;
        }
        now = start;
        cout<<"当前算法的遍历路径为:\n"<<endl;
        cout<<start<<"-->";
    
        for(int k=1; k<=10; k++)
        {
            int min_size = 1000000;
            int min_num = -999;
            for(int i=1; i<=10; i++)
            {
                Short=abs(now-Find[i].location);
                if(Find[i].flag!=1)
                {
                    if(min_size>Short)
                    {
                        min_size = Short;
                        min_num = i;
                    }
                }
            }
            now = Find[min_num].location;
            Find[min_num].flag=1;
            sum+=min_size;
            if(k==10)
                cout<<Find[min_num].location<<endl;
            else
                cout<<Find[min_num].location<<"-->";
        }
        cout<<"\n当前算法的磁头移动总量为:"<<sum<<"\n"<<endl;
        system("pause");
    }

     

    扫描算法(SCAN): 

    其运行方式类似于电梯,从当前位置只能一次性向同一方向(磁盘号增大或磁盘号减小)遍历所有磁盘。考虑因素:方向一致,距离最短。接下来的实现过程只简单模拟一下。判断距离最短并没有实现(其实实现也很方便)大家手动尝试一下就好。

    bool cmp_high(int a,int b)
    {
        return a<b;
    }
    bool cmp_low(int a,int b)
    {
        return a>b;
    }
    void SCAN()
    {
        int sum=0,now;
        int start;
        int high[11];
        int high_i=1;
        int low[11];
        int low_i=1;
        cout<<"请输入当前磁头位置:";
        cin>>start;
        cout<<"请输入10个需要遍历的磁盘号:"<<endl;;
        for(int i=1; i<=10; i++)
        {
            cin>>now;
            if(now>=start)
            {
                high[high_i++]=now;
            }
            else
            {
                low[low_i++]=now;
            }
        }
        sort(high+1,high+high_i,cmp_high);
        sort(low+1,low+low_i,cmp_low);
    
        cout<<"当前算法的遍历路径为:\n"<<endl;
        cout<<start<<"-->";
    
        for(int i=1; i<high_i; i++)
        {
            cout<<high[i]<<"-->";
            sum+=abs(start-high[i]);
            start=high[i];
        }
        for(int i=1; i<low_i; i++)
        {
            if(i==low_i-1)
                cout<<low[i];
            else
                cout<<low[i]<<"-->";
            sum+=abs(start-low[i]);
            start=low[i];
        }
        cout<<""<<endl;
        cout<<"\n当前算法的磁头移动总量为:"<<sum<<"\n"<<endl;
        system("pause");
    }

     

    完整代码:

    #include <stdlib.h>
    #include <iostream>
    #include <stdio.h>
    #include <string.h>
    #include <algorithm>
    #include <math.h>
    using namespace std;
    bool cmp_high(int a,int b)
    {
        return a<b;
    }
    bool cmp_low(int a,int b)
    {
        return a>b;
    }
    void Choice()
    {
    
        cout<<"欢迎使用磁盘调度算法演示过程"<<endl;
        cout<<"****************************"<<endl;
        cout<<"*1.先来先服务算法          *"<<endl;
        cout<<"*2.最短寻道算法            *"<<endl;
        cout<<"*3.扫描算法                *"<<endl;
        cout<<"*4.退出                    *"<<endl;
        cout<<"****************************"<<endl;
    }
    void FCFS()
    {
        int sum=0;
        int start;
        int Find[11];
        cout<<"请输入当前磁头位置:";
        cin>>start;
        cout<<"请输入10个需要遍历的磁盘号:"<<endl;;
        for(int i=1; i<=10; i++)
        {
            cout<<"i="<<i<<":";
            cin>>Find[i];
        }
        cout<<"当前算法的遍历路径为:\n"<<endl;
        cout<<start<<"-->";
    
        for(int i=1; i<=10; i++)
        {
            if(i==1)
                sum+=abs(start-Find[i]);
            else
                sum+=abs(Find[i-1]-Find[i]);
            if(i==10)
                cout<<Find[i]<<endl;
            else
                cout<<Find[i]<<"-->";
        }
        cout<<"\n当前算法的磁头移动总量为:"<<sum<<"\n"<<endl;
        system("pause");
    }
    void SSTF()
    {
        struct P
        {
            int location;
            int flag;
        } Find[11];
        int sum=0;
        int start;
        int now;
        int Short=0;
        cout<<"请输入当前磁头位置:";
        cin>>start;
        cout<<"请输入10个需要遍历的磁盘号:"<<endl;;
        for(int i=1; i<=10; i++)
        {
            cout<<"i="<<i<<":";
            cin>>Find[i].location;
            Find[i].flag=0;
        }
        now = start;
        cout<<"当前算法的遍历路径为:\n"<<endl;
        cout<<start<<"-->";
    
        for(int k=1; k<=10; k++)
        {
            int min_size = 1000000;
            int min_num = -999;
            for(int i=1; i<=10; i++)
            {
                Short=abs(now-Find[i].location);
                if(Find[i].flag!=1)
                {
                    if(min_size>Short)
                    {
                        min_size = Short;
                        min_num = i;
                    }
                }
            }
            now = Find[min_num].location;
            Find[min_num].flag=1;
            sum+=min_size;
            if(k==10)
                cout<<Find[min_num].location<<endl;
            else
                cout<<Find[min_num].location<<"-->";
        }
        cout<<"\n当前算法的磁头移动总量为:"<<sum<<"\n"<<endl;
        system("pause");
    }
    void SCAN()
    {
        int sum=0,now;
        int start;
        int high[11];
        int high_i=1;
        int low[11];
        int low_i=1;
        cout<<"请输入当前磁头位置:";
        cin>>start;
        cout<<"请输入10个需要遍历的磁盘号:"<<endl;;
        for(int i=1; i<=10; i++)
        {
            cin>>now;
            if(now>=start)
            {
                high[high_i++]=now;
            }
            else
            {
                low[low_i++]=now;
            }
        }
        sort(high+1,high+high_i,cmp_high);
        sort(low+1,low+low_i,cmp_low);
    
        cout<<"当前算法的遍历路径为:\n"<<endl;
        cout<<start<<"-->";
    
        for(int i=1; i<high_i; i++)
        {
            cout<<high[i]<<"-->";
            sum+=abs(start-high[i]);
            start=high[i];
        }
        for(int i=1; i<low_i; i++)
        {
            if(i==low_i-1)
                cout<<low[i];
            else
                cout<<low[i]<<"-->";
            sum+=abs(start-low[i]);
            start=low[i];
        }
        cout<<""<<endl;
        cout<<"\n当前算法的磁头移动总量为:"<<sum<<"\n"<<endl;
        system("pause");
    }
    /*
    23
    376
    205
    132
    19
    61
    190
    398
    29
    4
    
    */
    int main()
    {
        int choice;
        while(1)
        {
            bool flag = 0;
            Choice();
            cout<<"请输入选项:";
            cin>>choice;
            switch(choice)
            {
            case 1:
                FCFS();
                system("CLS");
                break;
            case 2:
                SSTF();
                system("CLS");
                break;
            case 3:
                SCAN();
                system("CLS");
                break;
            case 4:
                flag = 1;
                system("CLS");
                break;
            default:
                system("CLS");
                break;
            }
            if(flag==1)
            {
                cout<<"拜拜了您嘞!"<<endl;
                break;
            }
    
        }
        return 0;
    }
    

     

    展开全文
  • 磁盘调度算法 c语言

    2014-12-11 17:24:39
    先来先服务算法(FCFS) 最短寻道时间优先算法(SSTF) 扫描算法(SCAN) 循环扫描算法(CSCAN) N步扫描算法(NStepScan)
  • 磁盘调度算法java实现

    热门讨论 2013-05-30 20:54:38
    随机生成磁盘序列 用java实现了FIFO、SSTF、SCAN和C-SCAN算法模拟磁盘调度 有用户界面,有序列结果记录,有计算移动磁道数
  • 1.了解UNIX的命令及使用格式,熟悉UNIX/LINUX...2.设计一个磁盘工作区,并使用先来先服务算法(FCFS)、最短寻道时间优先算法(SSTF)、扫描算法(SCAN)和循环扫描算法(C-SCAN)计算磁头移动的总磁道数。 平均磁道数
  • 2.最短寻找时间优先调度算法 3.单向扫描调度算法 4.双向扫描调度算法 5.电梯调度算法 代码如下: //测试例子 98 183 37 122 14 124 65 67 -1 //测试例子 98 183 37 122 14 124 65 67 -1 //测试例子 98 183 37 122...

    本代码包含了

    1.先来先服务算法
    2.最短寻找时间优先调度算法
    3.单向扫描调度算法
    4.双向扫描调度算法
    5.电梯调度算法

    代码如下:

    //测试例子 98 183 37 122 14 124 65 67 -1
    //测试例子 98 183 37 122 14 124 65 67 -1
    //测试例子 98 183 37 122 14 124 65 67 -1
    //测试例子 98 183 37 122 14 124 65 67 -1
    import java.util.*;
    public class ArmShiftSchedulingAlgorithm {
    	private int arm;//模拟移动臂
    	private int distance = 0;//保存移动臂移动距离
    	private int surfaceNum = 0;//保存柱面数
    	//生成队列保存输入序列
    	LinkedList<Integer> intputQueue(){
    		Scanner in = new Scanner(System.in);
    		LinkedList<Integer> inputQueue = new LinkedList<Integer>();
    		int temp = -1;
    		temp = in.nextInt();
    		while(temp != -1) {
    			inputQueue.offer(temp);
    			temp = in.nextInt();
    		}
    		return inputQueue;
    	}
    	//模拟移动臂移动
    	void move(int address) {
    		for(int i = 0;i < Math.abs(address - arm);i++) {
    			try {
    				Thread.sleep(10);
    			} catch (InterruptedException e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}
    			
    		}
    		System.out.print("到达柱面" + address + " >> ");
    		distance += Math.abs(address - arm);
    		arm = address;
    	}
    	//输出访问序列
    	void showOutputQueue(LinkedList<Integer> outputQueue) {
    		System.out.print("柱面响应序列为:");
    		while(!outputQueue.isEmpty()) {
    			System.out.print(outputQueue.poll() + " ");
    		}
    		System.out.println();
    		System.out.println("总移动柱面个数:" + distance + "\n");
    		System.out.println(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n");
    	}
    	//生成选择菜单
    	@SuppressWarnings("resource")
    	 void menu() {
    		System.out.print("请你输入请求访问的柱面序列(以-1作为结束标志):");
    		LinkedList<Integer> intputQueue = intputQueue();
    		System.out.print("请输入移动臂的初始位置:");
    		arm = (new Scanner(System.in)).nextInt();
    		System.out.print("请输入最里的柱面号:");
    		surfaceNum = (new Scanner(System.in)).nextInt();
    		System.out.println("\n请你选择算法");
    		System.out.println("1.先来先服务算法");
    		System.out.println("2.最短寻找时间优先调度算法");
    		System.out.println("3.单向扫描调度算法");
    		System.out.println("4.双向扫描调度算法");
    		System.out.println("5.电梯调度算法");
    		System.out.println("0.退出");
    		System.out.println("");
    		System.out.print("请选择:");
    		int selectFunction = (new Scanner(System.in)).nextInt();
    		while(selectFunction != 0) {
    			switch(selectFunction) {
    				case 1:
    					 System.out.println("\n>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");
    					 System.out.println("\n\t\t先来先服务算法\n");
    					 execFiFOArithmetic(intputQueue);
    					 break;
    				case 2:
    					 System.out.println("\n>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");
    					 System.out.println("\n\t\t最短寻找时间优先调度算法\n");
    					 execSSTFArithmetic(intputQueue);
    					 break;
    				case 3:
    					 System.out.println("\n>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");
    					 System.out.println("\n\t\t单向扫描调度算法\n");
    					 execOneWayScanArithmetic(intputQueue);
    					 break;
    				case 4:
    					 System.out.println("\n>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");
    					 System.out.println("\n\t\t双向扫描调度算法\n");
    					 execDoubleWayScanArithmetic(intputQueue);
    					 break;
    				case 5:
    					 System.out.println("\n>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");
    					 System.out.println("\n\t\t电梯调度算法\n");
    					 execElevatorSchedulingArithmetic(intputQueue);
    					 break;
    				default:
    					System.out.println("\n你的输入不正确!");
    					break;	
    			}
    			System.out.print("请你输入请求访问的柱面序列(以-1作为结束标志):");
    			intputQueue = intputQueue();
    			System.out.print("请输入移动臂的初始位置:");
    			arm = (new Scanner(System.in)).nextInt();
    			System.out.print("请输入最里的柱面号:");
    			surfaceNum = (new Scanner(System.in)).nextInt();
    			System.out.println("\n请你选择算法");
    			System.out.println("1.先来先服务算法");
    			System.out.println("2.最短寻找时间优先调度算法");
    			System.out.println("3.单向扫描调度算法");
    			System.out.println("4.双向扫描调度算法");
    			System.out.println("5.电梯调度算法");
    			System.out.println("0.退出");
    			System.out.println("");
    			System.out.print("请选择:");
    			selectFunction = (new Scanner(System.in)).nextInt();
    			distance = 0;
    		}
    	}
    	//FIFO算法
    	LinkedList<Integer> FIFOArithmetic(LinkedList<Integer> queue1){
    		LinkedList<Integer> outputQueue = new LinkedList<Integer>();
    		while(!queue1.isEmpty()) {
    			int popNum = queue1.poll();
    			outputQueue.offer(popNum);
    			move(popNum);
    		}
    		System.out.println("");
    		return outputQueue;
    	}
    	void execFiFOArithmetic(LinkedList<Integer> InputQueue) {
    		showOutputQueue( FIFOArithmetic(InputQueue));
    	}
    	//SSTF算法
    	//1.先创建一个临时队列
    	//2.再把队列的值和当前arm的值相减
    	//3.从队列中找出最小的值
    	//4.将该值加上当前arm的值后进入一个新的队列
    	//5,将新进入的值从旧的队列中删除
    	//6.重复1直到队列为空
    	LinkedList<Integer> SSTFArithmetic(LinkedList<Integer> queue1){
    		LinkedList<Integer> outputQueue = new LinkedList<Integer>();
    		while(!queue1.isEmpty()) {
    			findMin2AddOutputQueue(queue1,outputQueue);
    		}
    		return outputQueue;
    	}
    	//把队列中的最小值添加到输出对列
    	void findMin2AddOutputQueue(LinkedList<Integer> InputQueue,LinkedList<Integer> outputQueue) {
    		int min = -999999;
    		int temp = 0;
    		LinkedList<Integer> tempQueue = new LinkedList<Integer>(InputQueue);
    		Iterator<Integer> it = tempQueue.iterator();
    		int i = 1;
    		int minNum = 1;
    		if(it.hasNext())
    			min = it.next()- arm;
    		while(it.hasNext()) {
    			temp = it.next() - arm;
    			i++;
    			if(Math.abs(temp) < Math.abs(min)) {
    				min = temp;
    				minNum = i;
    			}
    		}
    		outputQueue.offer(min + arm);
    		InputQueue.remove(minNum - 1);
    		move(min + arm);
    	}
    	void execSSTFArithmetic(LinkedList<Integer> InputQueue) {
    		LinkedList<Integer> outputQueue = SSTFArithmetic(InputQueue);
    		System.out.println("");
    		showOutputQueue(outputQueue);
    	}
    	//单向扫描算法
    	//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
    	void OneWayScanArithmetic(LinkedList<Integer> queue1,LinkedList<Integer> outputQueueL,LinkedList<Integer> outputQueueR){
    		int[] array = changeQueueToOrderIntArray(queue1);
    		boolean firstAdd = true;
    		int firstAddr = 0;
    		for(int i = 0;i < array.length;i++) {
    			if(array[i] >= arm) {
    				if(firstAdd == true) {
    					firstAdd = false;
    					firstAddr = i;
    				}
    				outputQueueL.offer(array[i]);
    				move(array[i]);
    			}
    		}
    		move(surfaceNum);
    		move(0);
    		for(int i = 0;i < firstAddr;i++) {
    			outputQueueL.offer(array[i]);
    			move(array[i]);
    		}
    		System.out.println();
    		showOutputQueue(outputQueueL);
    	}
    	//把输入队列转换成有序数组
    	int[] changeQueueToOrderIntArray(LinkedList<Integer> InputQueue) {
    		int[] array = new int[InputQueue.size()];
    		Iterator<Integer> it = InputQueue.iterator();
    		for(int i = 0;i < array.length;i++) {
    			array[i] = it.next();
    		}
    		return insertArithmetic(array);
    	}
    	//插入排序算法
    	int[] insertArithmetic(int[] array) {
    		int len = array.length;
    		int temp;
    		for(int i = 1;i < len;i++) {
    			temp = array[i];
    			int j;
    			for(j = i - 1;j >= 0;j--) {
    				if(temp < array[j]) {
    					array[j+1] = array[j];
    				}
    				else
    					break;
    			}
    			array[j + 1] = temp;
    		}
    		return array;
    	}
    	void execOneWayScanArithmetic(LinkedList<Integer> InputQueue) {
    		distance = 0;
    		LinkedList<Integer> OutputLeftQueue = new LinkedList<Integer>();
    		LinkedList<Integer> OutputRightQueue = new LinkedList<Integer>();
    		OneWayScanArithmetic(InputQueue,OutputLeftQueue,OutputRightQueue);
    	}
    	//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
    	//双向扫描算法
    	void DoubleWayScanArithmetic(LinkedList<Integer> queue1,LinkedList<Integer> outputQueueL,LinkedList<Integer> outputQueueR){
    		int[] array = changeQueueToOrderIntArray(queue1);
    		boolean firstAdd = true;
    		int firstAddr = 0;
    		for(int i = 0;i < array.length;i++) {
    			if(array[i] >= arm) {
    				if(firstAdd == true) {
    					firstAdd = false;
    					firstAddr = i;
    				}
    				outputQueueL.offer(array[i]);
    				move(array[i]);
    			}
    		}
    		move(surfaceNum);
    		for(int i = firstAddr - 1;i >= 0;i--) {
    			outputQueueL.offer(array[i]);
    			move(array[i]);
    		}
    		System.out.println();
    		showOutputQueue(outputQueueL);
    	}
    	void execDoubleWayScanArithmetic(LinkedList<Integer> InputQueue) {
    		distance = 0;
    		LinkedList<Integer> OutputLeftQueue = new LinkedList<Integer>();
    		LinkedList<Integer> OutputRightQueue = new LinkedList<Integer>();
    		DoubleWayScanArithmetic(InputQueue,OutputLeftQueue,OutputRightQueue);
    	}
    	//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
    	//电梯调度算法
    	void ElevatorSchedulingArithmetic(LinkedList<Integer> queue1,LinkedList<Integer> outputQueueL,LinkedList<Integer> outputQueueR){
    		int tempArm1 = arm;
    		//从右向左扫描
    		System.out.println("移动臂由外向里移动:");
    		int[] array = changeQueueToOrderIntArray(queue1);
    		boolean firstAdd = true;
    		int firstAddr = 0;
    		for(int i = 0;i < array.length;i++) {
    			if(array[i] >= arm) {
    				if(firstAdd == true) {
    					firstAdd = false;
    					firstAddr = i;
    				}
    				outputQueueL.offer(array[i]);
    				move(array[i]);
    			}
    		}
    		for(int i = firstAddr - 1;i >= 0;i--) {
    			outputQueueL.offer(array[i]);
    			move(array[i]);
    		}
    		System.out.println("");
    		showOutputQueue(outputQueueL);
    		System.out.println("");
    		//从左向右扫描
    		System.out.println("移动臂由里向外移动:");
    		distance = 0;
    		arm = tempArm1;
    		firstAdd = true;
    		firstAddr = 0;
    		for(int i = array.length - 1;i >= 0;i--) {
    			if(array[i] <= arm) {
    				if(firstAdd == true) {
    					firstAdd = false;
    					firstAddr = i;
    				}
    				outputQueueR.offer(array[i]);
    				move(array[i]);
    			}
    		}
    		for(int i = firstAddr + 1;i < array.length;i++) {
    			outputQueueR.offer(array[i]);
    			move(array[i]);
    		}
    		System.out.println("");
    		showOutputQueue(outputQueueR);
    	}
    	void execElevatorSchedulingArithmetic(LinkedList<Integer> InputQueue) {
    		distance = 0;
    		LinkedList<Integer> OutputLeftQueue = new LinkedList<Integer>();
    		LinkedList<Integer> OutputRightQueue = new LinkedList<Integer>();
    		ElevatorSchedulingArithmetic(InputQueue,OutputLeftQueue,OutputRightQueue);
    	}
    		
    }
    
    
    

    测试类Java文件:

    public class runTest {
    	public static void main(String args[]) {
    		(new ArmShiftSchedulingAlgorithm()).menu();
    	}
    }
    

    运行结果如下:

     

     

     

     

     

    展开全文
  • 1.先来先服务算法(FCFS) 2.最短寻道时间优先算法(SSTF) 3. 扫描算法(SCAN)
  • 假设有 n 个磁道号所组成 的磁道访问序列,给定开始磁道号 m 和磁头移动的方向,正向 或者反向,分别利用不同的磁盘调度算法访问磁道序列,给出 每一次访问的磁头移动距离,计算每种算法的平均寻道长度
  • 操作系统实 验 报 告课程名称操作系统实验实验项目名称磁盘调度算法学号班级姓名专业计算机科学与技术学生所在学院计算机科学与技术学院指导教师初妍实验室名称地点21#428哈尔滨工程大学计算机科学与技术学院第六讲 ...

    操作系统

    实 验 报 告

    课程名称操作系统实验实验项目名称磁盘调度算法学号班级姓名专业计算机科学与技术学生所在学院计算机科学

    与技术学院指导教师初妍实验室名称地点21#428

    哈尔滨工程大学

    计算机科学与技术学院

    第六讲 磁盘调度算法

    一、实验概述

    1. 实验名称

    磁盘调度算法

    2. 实验目的

    (1)通过学习EOS 实现磁盘调度算法的机制,掌握磁盘调度算法执行的条件和时机;

    (2)观察 EOS 实现的FCFS、SSTF和 SCAN磁盘调度算法,了解常用的磁盘调度算法;

    (3)编写 CSCAN和 N-Step-SCAN磁盘调度算法,加深对各种扫描算法的理解。

    3. 实验类型

    验证性+设计性实验

    4. 实验内容

    (1)验证先来先服务(FCFS)磁盘调度算法;

    (2)验证最短寻道时间优先(SSTF)磁盘调度算法;

    (3)验证SSTF算法造成的线程“饥饿”现象;

    (4)验证扫描(SCAN)磁盘调度算法;

    (5)改写SCAN算法。

    二、实验环境

    在OS Lab实验环境的基础上,利用EOS操作系统,由汇编语言及C语言编写代码,对需要的项目进行生成、调试、查看和修改,并通过EOS应用程序使内核从源代码变为可以在虚拟机上使用。

    三、实验过程

    1. 设计思路和流程图

    (1)改写SCAN算法

    在已有 SCAN 算法源代码的基础上进行改写,要求不再使用双重循环,而是只遍历一次请求队列中的请求,就可以选中下一个要处理的请求。算法流程图如下图所示。

    图 3.1.1 SCAN算法IopDiskSchedule函数流程图

    编写循环扫描(CSCAN)磁盘调度算法

    在已经完成的SCAN算法源代码的基础上进行改写,不再使用全局变量ScanInside确定磁头移动的方向,而是规定磁头只能从外向内移动。当磁头移动到最内的被访问磁道时,磁头立即移动到最外的被访问磁道,即将最大磁道号紧接着最小磁道号构成循环,进行扫描。算法流程图如下图所示。

    图 3.1.2 CSCAN算法IopDiskSchedule函数流程图

    编写N-Step-SCAN磁盘调度算法

    在已经完成的 SCAN 算法源代码的基础上进行改写,将请求队列分成若干个长度为 N 的子队列,调度程序按照 FCFS原则依次处理这些子队列,而每处理一个子队列时,又是按照SCAN算法。算法流程图如下图所示。

    图 3.1.3 N-Step-SCAN算法IopDiskSchedule函数流程图

    算法实现

    (1)改写SCAN算法

    在一次遍历中,不再关心当前磁头移动的方向,而是同时找到两个方向上移动距离最短的线程所对应的请求,这样就不再需要遍历两次。 在计算出线程要访问的磁道与当前磁头所在磁道的偏移后,可以将偏移分为三种类型:偏移为0,

    表示线程要访问的磁道与当前磁头所在磁道相同,此情况应该优先被调度,可立即返回该线程对应的请求的指针;偏移大于 0,记录向内移动距离最短的线程对应的请求;偏移小于 0,记录向外移动距离最短的线程对应的请求。循环结束后,根据当前磁头移动的方向选择同方向移动距离最短的线程,如果在同方向上没有线程,就变换方向,选择反方向移动距离最短的线程。

    编写循环扫描(CSCAN)磁盘调度算法

    由于规定了磁头只能从外向内移动,所以在每次遍历中,总是同时找到向内移动距离最短的线程和向外移动距离最长的线程。注意,与 SCAN 算法查找向外移动距离最短线程不同,这里查找向外移动距离最长的线程。在开始遍历前,可以将用来记录向外移动最长距离的变量赋值为0。在计算出线程要访问的磁道与当前磁头所在磁道的偏移后,同样可以将偏移分为三种类型:偏移为 0,表示线程要访问的磁道与当前磁头所在磁道相同,此情况应优先被调度,可立即返回该线程对应的请求的指针;偏移大于 0,记录向内移动距离最短的线程对应的请求;偏移小于 0,记录向外移动距离最长的线程对应的请求。循环结束后,选择向内移动距离最短的线程,如果没有向内移动的线程,就选择向外移动距离最长的线程。

    (3)编写N-Step-SCAN磁盘调度算法

    在 block.c 文件中的第360 行定义了一个宏 SUB_QUEUE_LENGTH,表示子队列的长度(即N 值 )。目前这个宏定义的值为6。在第 367行定义了一个全局变量SubQueueRemainLength,表示第一个子队列剩余的长度,并初始化其值为SUB_QUEUE_LENGTH。在执行 N-Step-SCAN算法时,要以第一个子队列剩余的长度做为计数器,确保只遍历第一个子队列剩余的项。所以,结束遍历的条件就既包括第一个子队列结束

    展开全文
  • 磁盘调度算法课程设计(附源代码

    千次阅读 多人点赞 2020-03-26 19:46:43
    磁盘驱动器,满足这一要求一位着要有较快的访问速度和较宽的磁盘宽带。磁盘宽带是指所传递的总字节数除以从服务请求开始到最后传递结束时的总时间。访问时间有寻道时间和旋转延迟两个主要部分。寻道时间是磁臂将...
  • java实现磁盘调度算法(操作系统)
  • import java.util.Scanner; public class DiskSchedulingAlgorithm { ... System.out.println("请输入磁盘柱头起始位置:"); int start = in.nextInt(); System.out.println("输入请求队列...
  • 通过磁盘调度算法的模拟设计,了解磁盘调度的特点,同时加深对FCFS、SSTF电梯、C-SCAN算法等磁盘调度算法的理解。更好地掌握操作系统磁盘调度的原理及实现方法,加深对操作系统基础理论和重要算法的理解。模拟实现...
  • Python-磁盘调度算法

    2019-12-17 17:14:54
    import math def avg_seek_length(list = []): sum = 0 for i in range(0, len(list) - 1): sum += int(abs(list[i] - list[i + 1])) print(sum / len(list)) def handle_data(list= []): ...
  • 本文档是计算机操作系统实验,用FSFC算法和SCAN算法实现了磁盘调度算法
  • 磁盘调度算法Java版(FCFS,SSTF,SCAN)
  • 操作系统调度算法代码 操作系统磁盘调度算法java版.doc
  • 磁盘调度算法C语言

    千次阅读 2019-12-31 23:23:27
    磁盘调度算法 磁盘调度主要应用于多道批处理系统中,以满足多个进程对磁盘读/写的请求。常用的磁盘调度算法有以下四种: 1. 先来先服务FCFS 此算法的优点是公平、简单,且每个进程 的请求都能依次得到处理,不会出现...
  • 操作系统实验六 磁盘调度算法(内含源代码和详细实验报告),详细介绍:http://blog.csdn.net/xunciy/article/details/79239096
  • 完整的本科课程设计文档及源代码,无需修改,可直接使用。
  • Python 磁盘调度算法实现

    千次阅读 2019-12-25 17:49:59
    print("|电梯调度算法(SCAN)平均寻道长度:%.1f |" % (l / n)) print("|--------------------------------------|") def findnext2(now, data): # CSCAN biggerList = [] smallerList = [] for d in data: ...
  • 磁盘调度算法的实现

    2015-12-25 12:09:34
    天津理工大学操作系统实验三磁盘调度算法的实现

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 47,390
精华内容 18,956
关键字:

磁盘调度算法代码

友情链接: RussiaCube.zip