精华内容
下载资源
问答
  • 进程调度模拟设计(非强占式短进程优先算法、最高响应比优先调度算法)在此基础上增加了先来先服务算法。直接复制粘贴就能运行
  • 操作系统课程设计:时间片轮转、最高响应比优先调度算法
  • 进程调度模拟设计——优先级法、最高响应比优先调度算法
  • 操作系统课程设计:进程调度模拟设计 先来先服务 最高响应比优先调度算法
  • 例题:最高响应比优先调度算法

    千次阅读 2020-11-05 18:43:38
    响应比优先调度算法主要用于作业调度,该算法是对FCFS调度算法和SJF调度算法的一种综合平衡,同时考虑每个作业的等待时间和估计的运行时间。在每次进行作业调度时,先计算后备作业队列中每个作业的响应比,从中...

    高响应比优先HRRN

    高响应比优先调度算法主要用于作业调度,该算法是对FCFS调度算法和SJF调度算法的一种综合平衡,同时考虑每个作业的等待时间和估计的运行时间。在每次进行作业调度时,先计算后备作业队列中每个作业的响应比,从中选出响应比最高的作业投入运行。

    响应比的变化规律可描述为:

    响应比=(等待时间+服务时间)/服务时间

    根据公式可知:

    当作业的等待时间相同时,则要求服务时间越短,其响应比越高,有利于短作业。

    当要求服务时间相同时,作业的响应比由其等待时间决定,等待时间越长,其响应比越高,因而它实现的是先来先服务。

    对于长作业,作业的响应比可以随等待时间的增加而提高,当其等待时间足够长时,其响应比便可升到很高,从而也可获得处理机。克服了饥饿状态,兼顾了长作业。

    参考文章:
    1、操作系统中调度算法(FCFS、RR、SPN、SRT、HRRN)
    2、高响应比优先调度算法(HRRN)例题详解

    作业提交时刻(时)运行时间(小时)开始时刻完成时刻周转时间18:002.08:00  28:500.5   39:000.1   49:500.2   

    展开全文
  • 进程调度模拟设计--优先级法、最高响应比优先调度算法
  • 进程调度模拟设计--时间片轮转、最高响应比优先调度算法
  • 进程调度模拟设计--先来先服务、最高响应比优先调度算法
  • 经过调试程序 代码成功的运行 做出实验
  • 操作系统课程设计 进程调度模拟设计 武汉理工大学 计算机学科学与上技术学院院
  • 这里记录一下操作系统的实验,几个调度算法的原理很好理解,网上也有很多解释,这里不再解释,直接上代码。 一、JCB类 public class JCB { public int id; /** * 剩余服务时间 */ public int leftTime; /** *...

    这里记录一下操作系统的实验,几个调度算法的原理很好理解,网上也有很多解释,这里不再解释,直接上代码。

    一、JCB类

    public class JCB {
        public int id;
        /**
         * 剩余服务时间
         */
        public int leftTime;
        /**
         * 要求服务时间
         */
        public int serviceTime;
        /**
         * 到达时间
         */
        public int arriveTime;
        /**
         * 开始时间
         */
        public int beginTime;
    
        /**
         * 结束时间
         */
        public int finishTime;
        /**
         * 优先权
         */
        public float priority;
    
        public JCB(int id, int serviceTime, int arriveTime,float priority) {
            this.id = id;
            this.leftTime = serviceTime;
            this.serviceTime = serviceTime;
            this.arriveTime = arriveTime;
            beginTime =0;
            this.priority=priority;
            finishTime=0;
        }
    
    
    
        @Override
        public String toString() {
            return "JCB{" +
                    "id=" + id +
                    ", serviceTime=" + serviceTime +
                    ", arriveTime=" + arriveTime +
                    ", priority=" + priority +
                    '}';
        }
    }
    
    

    二、定义所需数据结构

    /**
     * 时间片轮转算法
     *
     * @author MaoLin Wang
     * @date 2019/11/3020:03
     */
    public class SchedulingAlgorithm {
        /**
         * 就绪队列
         */
        LinkedList<JCB> readyQueue = null;
        /**
         * 结束调度队列
         */
        LinkedList<JCB> finishQueue = null;
    
        /**
         * 时间段
         */
        private int cpuTime;
    
        /**
         * 时间片大小
         */
        private int timeSize;
    
        /**
         * 作业数
         */
        private int jobNum;
    
        private String dispatchName;//调度算法名
    
        /**
         * 作业周转时间
         */
        private int[] turnoverTime;
        /**
         * 作业带权周转时间·
         */
        private float[] turnoverTimeWithWeight;
    
        /**
         * 平均带权周转时间
         */
        private float ave;
    }
    

    三、初始化

    这里将最高响应比的初始化拉了出来,因为要设置响应比

     /**
         * 初始化
         */
        public void init(int jobNum, int timeSize, String dispatchName) {
            System.out.println("开始" + dispatchName + "调度");
            readyQueue = new LinkedList<>();
            finishQueue = new LinkedList<>();
            this.turnoverTime = new int[jobNum];
            this.turnoverTimeWithWeight = new float[jobNum];
            this.cpuTime = 0;
            JCB jcb;
            for (int i = 1; i <= jobNum; i++) {
                jcb = new JCB(i, (int) (Math.random() * 10 + 1), i - 1, 0);
                readyQueue.offer(jcb);
            }
            this.timeSize = timeSize;
            this.jobNum = jobNum;
            this.dispatchName = dispatchName;
            printInitQueue();
        }
    
        /**
         * 初始化高响应比优先队列
         *
         * @param jobNum
         * @param timeSize
         * @param dispatchName
         */
        public void HRNInit(int jobNum, int timeSize, String dispatchName) {
            System.out.println("开始" + dispatchName + "调度");
            readyQueue = new LinkedList<>();
            finishQueue = new LinkedList<>();
            this.turnoverTime = new int[jobNum];
            this.turnoverTimeWithWeight = new float[jobNum];
            this.cpuTime = 0;
            JCB jcb;
            for (int i = 1; i <= jobNum; i++) {
                float v = (float) (Math.random() * 5 + 1);
                jcb = new JCB(i, (int) (Math.random() * 10 + 1), i - 1, (float) (Math.random() * 5 + 1));
                readyQueue.offer(jcb);
            }
            this.timeSize = timeSize;
            this.jobNum = jobNum;
            this.dispatchName = dispatchName;
            printInitQueue();
        }
    
    

    作业id默认为序号i,所需服务时间随机生成,到达时间默认从0开始,响应比其他调度算法为0,高响应比算法为随机生成。

    四、高响应比优先算法实现

    逻辑很简单,使用递归实现,参数初始为0,每次取出对头作业,因为这里所有的作业在初始化时数据都初始化好了,所以需判断作业到达时间是否小于cpu时间片,因为只有小于时间片,说明其实际是到达的。
    如果小于,则设置其开始时间为cpu当前时间,结束时间为开始时间+服务时间,剩余时间设为0,同时增加cpu时间,将该作业加入已完成队列中,否则,递归调用该算法,参数为index+1,一轮结束后,对作业按响应比排序,继续递归,知道就绪队列为空。

    
         /**
         * 最高响应比优先算法
         */
        public void HRNAlgorithm(int index) {
            if (readyQueue.size() == 0) {
                System.out.println("就绪队列为空,调度完毕!");
                return;
            }
            JCB head = readyQueue.get(index);
            if (head.arriveTime <= cpuTime) {
                readyQueue.poll();
                System.out.println("-----------------------------------------------------");
                System.out.println("时间片: " + cpuTime + "开始调度作业:" + head.id + ", 剩余服务时间: " + head.leftTime);
                head.beginTime = cpuTime;
                head.finishTime = head.beginTime + head.serviceTime;
                head.leftTime = 0;
                cpuTime += head.serviceTime;
                finishQueue.offer(head);
                System.out.println("时间片: " + cpuTime + "结束调度作业:" + head.id + ", 剩余服务时间: " + head.leftTime);
    
            } else {
                HRNAlgorithm(index++);
            }
            sortByPriority();
            HRNAlgorithm(0);
        }
    
        /**
         * 根据响应比排序
         */
        private void sortByPriority() {
            readyQueue.sort((o1, o2) -> o1.priority > o2.priority ? -1 : 1);
        }
    

    五、短作业优先调度算法

    同高响应比优先类似,只是按照要求服务时间排序。

     /**
         * 短作业优先调度算法
         */
        public void SJFAlgorithm(int index) {
            if (readyQueue.size() == 0) {
                System.out.println("就绪队列为空,调度完毕!");
                return;
            }
            JCB head = readyQueue.get(index);
            if (head.arriveTime <= cpuTime) {
                readyQueue.poll();
                System.out.println("-----------------------------------------------------");
                System.out.println("时间片: " + cpuTime + "开始调度作业:" + head.id + ", 剩余服务时间: " + head.leftTime);
                head.beginTime = cpuTime;
                head.finishTime = head.beginTime + head.serviceTime;
                head.leftTime = 0;
                cpuTime += head.serviceTime;
                finishQueue.offer(head);
                System.out.println("时间片: " + cpuTime + "结束调度作业:" + head.id + ", 剩余服务时间: " + head.leftTime);
    
            } else {
                sortByServiceTime();
                SJFAlgorithm(index++);
            }
    
            sortByServiceTime();
            SJFAlgorithm(0);
        }
    
    
        /**
         * 根据要求服务时间从小到大排序
         */
        private void sortByServiceTime() {
            readyQueue.sort((o1, o2) -> o1.serviceTime < o2.serviceTime ? -1 : 1);
        }
    

    六、先来先服务

    最简单的一个算法,直接按顺序取出队头作业执行。

      /**
         * 先来先服务调度算法
         */
        public void FCFSAlgorithm() {
            if (readyQueue.size() == 0) {
                System.out.println("就绪队列为空,调度完毕!");
                return;
            }
            JCB head = readyQueue.poll();
            System.out.println("-----------------------------------------------------");
            System.out.println("时间片: " + cpuTime + "开始调度作业:" + head.id + ", 剩余服务时间: " + head.leftTime);
    
            head.beginTime = cpuTime;
            head.leftTime = 0;
            head.finishTime = head.beginTime + head.serviceTime;
            cpuTime += head.serviceTime;
            finishQueue.offer(head);
            System.out.println("时间片: " + cpuTime + "结束调度作业:" + head.id + ", 剩余服务时间: " + head.leftTime);
    
            FCFSAlgorithm();
    
        }
    

    七、时间片轮转算法

    这里需要根据作业剩余需要服务的时间跟时间片大小做对比,代码很好理解。

     /**
         * 时间片轮转算法
         */
        public void RRAlgorithm() {
            if (readyQueue.size() == 0) {
                System.out.println("就绪队列为空,调度完毕!");
                return;
            }
            JCB head = readyQueue.poll();
            System.out.println("-----------------------------------------------------");
            System.out.println("时间片: " + cpuTime + "开始调度作业:" + head.id + ", 剩余服务时间: " + head.leftTime);
            head.beginTime = cpuTime;
            if (head.leftTime > timeSize) {
                //服务时间大于时间片大小
                head.leftTime -= timeSize;
                //重新加入到就绪队列尾部
                readyQueue.offer(head);
                cpuTime += timeSize;
    
            } else if (head.leftTime == timeSize) {
                //服务时间等于时间片大小
                cpuTime += timeSize;
                head.finishTime = cpuTime;
                head.leftTime = 0;
                //加入结束队列
                finishQueue.offer(head);
            } else {
                //服务时间小于时间片大小
                head.finishTime = cpuTime + head.leftTime;
                head.leftTime = 0;
                cpuTime += head.leftTime;
                finishQueue.offer(head);
            }
            System.out.println("时间片: " + cpuTime + "结束调度作业:" + head.id + ", 剩余服务时间: " + head.leftTime);
            RRAlgorithm();
        }
    

    八、计算周转时间和带权周转时间

    /**
         * 计算周转时间和带权周转时间
         * @param finishQueue
         */
        public void R_Dis(Queue<JCB> finishQueue) {
            Queue<JCB>temp=finishQueue;
            JCB tempJcb;
            float sum = 0;
            for (int i = 0; i < jobNum; i++) {
                tempJcb=temp.poll();
                turnoverTime[i] = tempJcb.finishTime - tempJcb.arriveTime;
                turnoverTimeWithWeight[i] =(float) turnoverTime[i] / tempJcb.serviceTime;
                sum += turnoverTimeWithWeight[i];
                temp.offer(tempJcb);
            }
            float ave = sum / jobNum;
    
            this.ave = ave;
        }
    

    九、打印结果

    public void printResult(boolean isHRN) {
            R_Dis(this.finishQueue);
            System.out.println("=====================" + this.dispatchName + "调度结果为=========================");
            if (isHRN) {
    
                System.out.println("进程名\t" + "到达时间\t" + "要求服务时间\t" + "响应比\t" + "开始时间\t" + "完成时间\t" + "周转时间\t" + "带权周转时间\t"+"平均带权周转时间\t");
            } else {
    
                System.out.println("进程名\t" + "到达时间\t" + "要求服务时间\t" + "开始时间\t" + "完成时间\t" + "周转时间\t" + "带权周转时间\t"+"平均带权周转时间\t");
            }
            int count = 0;
    
            for (JCB jcb : this.finishQueue) {
                if (isHRN) {
                    System.out.println("  " + jcb.id + "\t\t\t" + jcb.arriveTime + "\t\t" + jcb.serviceTime + "\t\t" + jcb.priority + "\t\t" + jcb.beginTime + "\t\t"
                            + jcb.finishTime + "\t\t" + turnoverTime[count] + "\t\t" + turnoverTimeWithWeight[count]+"\t\t"+this.ave);
                    count = count + 1;
                } else {
                    System.out.println("  " + jcb.id + "\t\t\t" + jcb.arriveTime + "\t\t" + jcb.serviceTime + "\t\t" + jcb.beginTime + "\t\t"
                            + jcb.finishTime + "\t\t" + turnoverTime[count] + "\t\t" + turnoverTimeWithWeight[count]+"\t\t"+this.ave);
                    count = count + 1;
                }
    
            }
        }
    
    
        /**
         * 打印初始化队列
         */
        private void printInitQueue() {
            System.out.println("当前就绪队列为:");
            for (JCB jcb2 : readyQueue) {
                System.out.println(jcb2);
            }
        }
    

    测试

    public class Test {
        public static void main(String[] args) {
            SchedulingAlgorithm schedulingAlgorithm = new SchedulingAlgorithm();
            schedulingAlgorithm.init(5, 2,"轮转");
            schedulingAlgorithm.RRAlgorithm();
            schedulingAlgorithm.printResult(false);
    
            schedulingAlgorithm.init(5,3,"先来先服务");
            schedulingAlgorithm.FCFSAlgorithm();
            schedulingAlgorithm.printResult(false);
    
            schedulingAlgorithm.init(5,3,"短作业优先服务");
            schedulingAlgorithm.SJFAlgorithm(0);
            schedulingAlgorithm.printResult(false);
    
            schedulingAlgorithm.HRNInit(5,3,"高响应比优先");
            schedulingAlgorithm.HRNAlgorithm(0);
            schedulingAlgorithm.printResult(true);
    
    
    
        }
    }
    

    结果:

    开始轮转调度
    当前就绪队列为:
    JCB{id=1, serviceTime=1, arriveTime=0, priority=0.0}
    JCB{id=2, serviceTime=5, arriveTime=1, priority=0.0}
    JCB{id=3, serviceTime=4, arriveTime=2, priority=0.0}
    JCB{id=4, serviceTime=6, arriveTime=3, priority=0.0}
    JCB{id=5, serviceTime=6, arriveTime=4, priority=0.0}
    -----------------------------------------------------
    时间片: 0开始调度作业:1, 剩余服务时间: 1
    时间片: 0结束调度作业:1, 剩余服务时间: 0
    -----------------------------------------------------
    时间片: 0开始调度作业:2, 剩余服务时间: 5
    时间片: 2结束调度作业:2, 剩余服务时间: 3
    -----------------------------------------------------
    时间片: 2开始调度作业:3, 剩余服务时间: 4
    时间片: 4结束调度作业:3, 剩余服务时间: 2
    -----------------------------------------------------
    时间片: 4开始调度作业:4, 剩余服务时间: 6
    时间片: 6结束调度作业:4, 剩余服务时间: 4
    -----------------------------------------------------
    时间片: 6开始调度作业:5, 剩余服务时间: 6
    时间片: 8结束调度作业:5, 剩余服务时间: 4
    -----------------------------------------------------
    时间片: 8开始调度作业:2, 剩余服务时间: 3
    时间片: 10结束调度作业:2, 剩余服务时间: 1
    -----------------------------------------------------
    时间片: 10开始调度作业:3, 剩余服务时间: 2
    时间片: 12结束调度作业:3, 剩余服务时间: 0
    -----------------------------------------------------
    时间片: 12开始调度作业:4, 剩余服务时间: 4
    时间片: 14结束调度作业:4, 剩余服务时间: 2
    -----------------------------------------------------
    时间片: 14开始调度作业:5, 剩余服务时间: 4
    时间片: 16结束调度作业:5, 剩余服务时间: 2
    -----------------------------------------------------
    时间片: 16开始调度作业:2, 剩余服务时间: 1
    时间片: 16结束调度作业:2, 剩余服务时间: 0
    -----------------------------------------------------
    时间片: 16开始调度作业:4, 剩余服务时间: 2
    时间片: 18结束调度作业:4, 剩余服务时间: 0
    -----------------------------------------------------
    时间片: 18开始调度作业:5, 剩余服务时间: 2
    时间片: 20结束调度作业:5, 剩余服务时间: 0
    就绪队列为空,调度完毕!
    =====================轮转调度结果为=========================
    进程名	到达时间	要求服务时间	开始时间	完成时间	周转时间	带权周转时间	平均带权周转时间	
      1			0		1		0		1		1		1.0		2.3733335
      3			2		4		10		12		10		2.5		2.3733335
      2			1		5		16		17		16		3.2		2.3733335
      4			3		6		16		18		15		2.5		2.3733335
      5			4		6		18		20		16		2.6666667		2.3733335
    开始先来先服务调度
    当前就绪队列为:
    JCB{id=1, serviceTime=3, arriveTime=0, priority=0.0}
    JCB{id=2, serviceTime=10, arriveTime=1, priority=0.0}
    JCB{id=3, serviceTime=7, arriveTime=2, priority=0.0}
    JCB{id=4, serviceTime=1, arriveTime=3, priority=0.0}
    JCB{id=5, serviceTime=1, arriveTime=4, priority=0.0}
    -----------------------------------------------------
    时间片: 0开始调度作业:1, 剩余服务时间: 3
    时间片: 3结束调度作业:1, 剩余服务时间: 0
    -----------------------------------------------------
    时间片: 3开始调度作业:2, 剩余服务时间: 10
    时间片: 13结束调度作业:2, 剩余服务时间: 0
    -----------------------------------------------------
    时间片: 13开始调度作业:3, 剩余服务时间: 7
    时间片: 20结束调度作业:3, 剩余服务时间: 0
    -----------------------------------------------------
    时间片: 20开始调度作业:4, 剩余服务时间: 1
    时间片: 21结束调度作业:4, 剩余服务时间: 0
    -----------------------------------------------------
    时间片: 21开始调度作业:5, 剩余服务时间: 1
    时间片: 22结束调度作业:5, 剩余服务时间: 0
    就绪队列为空,调度完毕!
    =====================先来先服务调度结果为=========================
    进程名	到达时间	要求服务时间	开始时间	完成时间	周转时间	带权周转时间	平均带权周转时间	
      1			0		3		0		3		3		1.0		8.154286
      2			1		10		3		13		12		1.2		8.154286
      3			2		7		13		20		18		2.5714285		8.154286
      4			3		1		20		21		18		18.0		8.154286
      5			4		1		21		22		18		18.0		8.154286
    开始短作业优先服务调度
    当前就绪队列为:
    JCB{id=1, serviceTime=8, arriveTime=0, priority=0.0}
    JCB{id=2, serviceTime=10, arriveTime=1, priority=0.0}
    JCB{id=3, serviceTime=1, arriveTime=2, priority=0.0}
    JCB{id=4, serviceTime=10, arriveTime=3, priority=0.0}
    JCB{id=5, serviceTime=1, arriveTime=4, priority=0.0}
    -----------------------------------------------------
    时间片: 0开始调度作业:1, 剩余服务时间: 8
    时间片: 8结束调度作业:1, 剩余服务时间: 0
    -----------------------------------------------------
    时间片: 8开始调度作业:3, 剩余服务时间: 1
    时间片: 9结束调度作业:3, 剩余服务时间: 0
    -----------------------------------------------------
    时间片: 9开始调度作业:5, 剩余服务时间: 1
    时间片: 10结束调度作业:5, 剩余服务时间: 0
    -----------------------------------------------------
    时间片: 10开始调度作业:2, 剩余服务时间: 10
    时间片: 20结束调度作业:2, 剩余服务时间: 0
    -----------------------------------------------------
    时间片: 20开始调度作业:4, 剩余服务时间: 10
    时间片: 30结束调度作业:4, 剩余服务时间: 0
    就绪队列为空,调度完毕!
    =====================短作业优先服务调度结果为=========================
    进程名	到达时间	要求服务时间	开始时间	完成时间	周转时间	带权周转时间	平均带权周转时间	
      1			0		8		0		8		8		1.0		3.72
      3			2		1		8		9		7		7.0		3.72
      5			4		1		9		10		6		6.0		3.72
      2			1		10		10		20		19		1.9		3.72
      4			3		10		20		30		27		2.7		3.72
    开始高响应比优先调度
    当前就绪队列为:
    JCB{id=1, serviceTime=1, arriveTime=0, priority=5.41018}
    JCB{id=2, serviceTime=6, arriveTime=1, priority=5.1338425}
    JCB{id=3, serviceTime=6, arriveTime=2, priority=3.1670618}
    JCB{id=4, serviceTime=6, arriveTime=3, priority=2.0463989}
    JCB{id=5, serviceTime=1, arriveTime=4, priority=4.711568}
    -----------------------------------------------------
    时间片: 0开始调度作业:1, 剩余服务时间: 1
    时间片: 1结束调度作业:1, 剩余服务时间: 0
    -----------------------------------------------------
    时间片: 1开始调度作业:2, 剩余服务时间: 6
    时间片: 7结束调度作业:2, 剩余服务时间: 0
    -----------------------------------------------------
    时间片: 7开始调度作业:5, 剩余服务时间: 1
    时间片: 8结束调度作业:5, 剩余服务时间: 0
    -----------------------------------------------------
    时间片: 8开始调度作业:3, 剩余服务时间: 6
    时间片: 14结束调度作业:3, 剩余服务时间: 0
    -----------------------------------------------------
    时间片: 14开始调度作业:4, 剩余服务时间: 6
    时间片: 20结束调度作业:4, 剩余服务时间: 0
    就绪队列为空,调度完毕!
    =====================高响应比优先调度结果为=========================
    进程名	到达时间	要求服务时间	响应比	开始时间	完成时间	周转时间	带权周转时间	平均带权周转时间	
      1			0		1		5.41018		0		1		1		1.0		2.1666665
      2			1		6		5.1338425		1		7		6		1.0		2.1666665
      5			4		1		4.711568		7		8		4		4.0		2.1666665
      3			2		6		3.1670618		8		14		12		2.0		2.1666665
      4			3		6		2.0463989		14		20		17		2.8333333		2.1666665
    
    展开全文
  • 优先调度算法(FPF) 为照顾紧迫性作业,使之在进入系统后便获得优先处理,...优先权的类型有静态优先权和动态优先权,最高优先调度算法的关键就在于:使用静态优先权、动态优先权和如何确定进程的优先权。...

    高优先权调度算法(FPF)

    为照顾紧迫性作业,使之在进入系统后便获得优先处理,引入了最高优先权优先(FPF)调度算法。此算法常被用于批处理系统中,作为作业调度算法,也作为多种操作系统中的进程调度算法,还可用于实时系统中。它分为两种:非抢占式优先权算法、抢占式优先权调度算法。

    优先权的类型有静态优先权和动态优先权,最高优先权调度算法的关键就在于:使用静态优先权、动态优先权和如何确定进程的优先权。

    静态优先权:一般用一个整数表示,在进程创建时确定,进程的整个运行期间保持不变。又称为优先数。动态优先权:在进程创建时赋予优先权,随着进程的推进或者等待时间的增加而改变。

    确定进程优先权的依据有三个方面:(1)进程类型:一般来说系统进程高于用户进程。(2)进程对资源的要求:如进程的估计时间及内存需要量的多少,对要求少的进程赋予较高优先权。(3)用户要求:由用户进程的紧迫程度及用户所付费用的多少来确定优先权的。

     

    高响应比优先调度算法

    在批处理系统中,短作业优先算法是一种比较好的算法,其主要不足是长作业的运行得不到保证。我们为每个作业引入动态优先权,并使作业的优先级随着等待时间的增加而以速率a提高,则可解决问题。

    优先权 = (等待时间 + 要求服务时间)/  要求服务时间。由于等待时间与服务时间之和就是系统的响应时间,故上式又表示为:Rp=响应时间 / 要求服务时间

    可以看出随着进程等待时间增长,优先权线性增长,等待足够长时间是一定能获得处理机的;要求服务时间短,优先权线性增长,有利于短作业。进程要求服务时间相同时,等待时间长的优先级高,所以是先来先服务

     

    展开全文
  • 响应比最高优先调度算法(HRRF)

    万次阅读 多人点赞 2018-05-10 22:32:29
    响应比最高优先算法是通过计算输入井后备队列中每个作业的响应比大小,从中选择响应比最高的作业装入主存,这样既考虑了作业的等待时间,又考虑了作业的运行时间。 二、实验要求 假设本系统仍采用单道批处理...

    一、实验目的

           作业调度算法是指依照某种原则或策略从后备作业队列中选取作业的方法。响应比最高者优先算法是通过计算输入井后备队列中每个作业的响应比大小,从中选择响应比最高的作业装入主存,这样既考虑了作业的等待时间,又考虑了作业的运行时间。

    二、实验要求

           假设本系统仍采用单道批处理系统,忽略设备工作时间和系统进行调度所花的时间。要求从键盘输入作业个数N,及每个作业的作业名、作业入井时间、估计运行时间。请编程输出采用响应比最高者优先算法得到的每个作业调度序号、作业名、作业入井时间、开始调度时间、运行时间、结束时间、周转时间,以及所有作业的平均周转时间。

    三、源代码

    #include <stdio.h>
    #define N 10
    
    typedef struct {
        int hour;
        int min;
    }time;
    typedef struct hrrf{
        char hrrf_id[20];
        double hrrf_run;  //运行时间
        time hrrf_entertime; //进入时间
        int enter;
        time hrrf_needtime;  //调度时间
        int needtime;
        time hrrf_endtime;   //结束时间
        int endtime;
        int hrrf_longtime;  //周转时间
        int hrrf_waittime;   //等待时间
        double hrrf_pjlongtime; //平均周转时间
        double hrrf_rate;       //响应比
    
        struct hrrf* next;
    }HRRF;
    //输入作业信息
    void hrrfinput(HRRF s[N],int k)
    {
        printf("\t请输入第%d个作业名:",k+1);
        scanf("%s",&s[k].hrrf_id);
        printf("\t请输入%s作业进入时间:",s[k].hrrf_id);
        scanf("%d:%d",&s[k].hrrf_entertime.hour,&s[k].hrrf_entertime.min);
        s[k].enter=s[k].hrrf_entertime.hour*60+s[k].hrrf_entertime.min;
        printf("\t请输入%s作业运行时间:",s[k].hrrf_id);
        scanf("%lf",&s[k].hrrf_run);
    }
    //计算作业的响应比
    void rate(HRRF s[N],int k,int m)
    {
        double ratenum;
        ratenum = (s[k].hrrf_run+(double)(s[m].endtime-s[k].enter))/(s[k].hrrf_run);
        s[k].hrrf_rate=ratenum;
        printf("\n\t每次算响应比:%s---%f\n",s[k].hrrf_id,s[k].hrrf_rate);
    }
    //按响应比大小对作业进行排序(降序排序)
    void ratesort(HRRF s[N],int k,int m)
    {
        int maxratenum;
        HRRF temp;
        int i,j;
        for(i=k;i<m;i++)         //简单选择排序
        {
            maxratenum=i;
            for(j=i+1;j<m;j++)
                if(s[j].hrrf_rate>s[maxratenum].hrrf_rate)
                    maxratenum=j;
            if(maxratenum!=i)
            {
                temp=s[i];
                s[i]=s[maxratenum];
                s[maxratenum]=temp;
            }
    
        }
    }
    //打印表单
    void print(HRRF s[N],int k)
    {
        printf("\t序号\t作业名\t进入时间\t调度时间\t结束时间\t运行时间\t等待时间\t周转时间\n");
        int i,j;
        for(i=0;i<k;i++)
            printf("\t%d\t%s\t%d:%d\t\t%d:%d\t\t%d:%d\t\t%.0f min\t\t%d\t\t%d min\n",i+1,s[i].hrrf_id,(s[i].enter/60),(s[i].enter%60),(s[i].needtime/60),(s[i].needtime%60),(s[i].endtime/60),(s[i].endtime%60),s[i].hrrf_run,s[i].hrrf_waittime,s[i].hrrf_longtime);
    
    }
    
    //hrrf算法
    void HRRF_run(HRRF s[N],int k)
    {
        int i,j=k,n;
        double sum;
        HRRF temp;
        //按到达时间进行排序
        while(j>1)
        {
            for(i=0;i<j-1;i++)
            {
                if(s[i+1].enter<s[i].enter)
                {
                    temp=s[i];
                    s[i]=s[i+1];
                    s[i+1]=temp;
                }
            }
            j--;
        }
        printf("\n\t--------------------------------------------初始状态------------------------------------------------\n");
        print(s,k);
        j=0;
        //执行
        do{
                if(j==0)
                {
                    s[j].needtime=s[j].enter;
                    s[j].hrrf_waittime=0;
                    s[j].endtime=s[j].enter+s[j].hrrf_waittime+(int)(s[j].hrrf_run);
                    s[j].hrrf_longtime=s[j].endtime-s[j].enter;
                }
                else
                {
                    s[j].needtime=s[j-1].endtime;
                    s[j].hrrf_waittime=s[j-1].endtime-s[j].enter;
                    s[j].endtime=s[j].needtime+(int)(s[j].hrrf_run);
                    s[j].hrrf_longtime=s[j].endtime-s[j].enter;
                }
                j++;  //到了第几个作业
                //计算响应比
                n=j-1;  //此次已经执行完的作业序号-1,因为数组从0开始
                for(i=j;i<k;i++)
                {
                    rate(s,i,n);    //计算响应比
                }
                ratesort(s,j,k);    //按响应比由大到小排序
                printf("\n\t-----------------------------------------每次响应比排序---------------------------------------------\n");
                print(s,k);
    
        }while(j<k);
    
        printf("\n\t--------------------------------------------作业调度------------------------------------------------\n");
        print(s,k);
        for(i=0;i<k;i++)
        {
            sum+=(double)(s[i].hrrf_longtime);
        }
    
        printf("\n\t平均周转时间为:%.2f\n",sum/k);
    }
    
    int main()
    {
        HRRF a[N]={0};
        int i,j;
        printf("请输入创建作业数目:");
        scanf("%d",&i);
        for(j=0;j<i;j++)  //输入作业信息
            hrrfinput(a,j);
        //HRRF算法
        HRRF_run(a,j);
    
        return 0;
    }
    

    四、实验截图

     

    1、输入

     

     

    2、执行过程

     

     

     

    有问题欢迎指正,先谢了~~~

    展开全文
  • 最高响应比优先算法

    2017-12-16 16:26:26
    本文件是对操作系统作业调度算法中的最高响应比优先算法的设计与实现,代码和报告都放在了压缩文件中,代码使用的文件输入输出。
  • 题 目: 进程调度模拟设计——优先级法、最高响应比优先调度算法 初始条件: 1.预备内容:阅读操作系统的处理机管理章节内容,对进程调度的功能以及进程调度算法有深入的理解。 2.实践准备:掌握一种计算机高级...
  • 设有四个进程,它们的到达时刻和处理时间如下所示: Process Arrival Time ... 采用最高响应比优先(HRRN)调度算法在时刻50进行调度,所选中的进程是? 再次强调一点:最高相应比算法不发生抢占 50时...
  • (1)算法思想 主要从“公平”的角度考虑(类似于我们生活中排队买东西的例子) (2)算法规则 按照作业/进程到达的先后顺序进行服务 (3)用于作业/进程调度 用于作业调度时,考虑的是哪个作业先到达后备队列;用于...
  • 进程调度算法包括先来先服务调度算法、最短作业时间优先(抢占式和非抢占式)、最高响应比调度算法4种。(每个人必须做FCFS,然后在后面的三种中任选一种,即每个人必须做2种调度算法的模拟。) [2]. 衡量算法性能的...

空空如也

空空如也

1 2 3 4 5 ... 12
收藏数 224
精华内容 89
关键字:

最高响应比优先调度算法