精华内容
下载资源
问答
  • 最高响应比优先算法

    2017-12-16 16:26:26
    本文件是对操作系统作业调度算法中的最高响应比优先算法的设计与实现,代码和报告都放在了压缩文件中,代码使用的文件输入输出。
  • Java 操作系统 最高响应比优先算法

    千次阅读 2018-05-19 22:08:55
    在进程管理中,进程调度是核心,因为在采用多道程序设计的系统中,往往有若干个进程同时处于就绪状态,当就绪进程个数大于处理器数目时,就必须依照某种策略决定哪些进程优先占用处理器。本设计模拟在单处理器情况下...

    设计目的:    

      进程管理是操作系统中的重要功能,用来创建进程、撤消进程、实现进程状态转换,它提供了在可运行的进程之间复用CPU的方法。在进程管理中,进程调度是核心,因为在采用多道程序设计的系统中,往往有若干个进程同时处于就绪状态,当就绪进程个数大于处理器数目时,就必须依照某种策略决定哪些进程优先占用处理器。本设计模拟在单处理器情况下的进程调度,目的是加深对进程调度工作的理解,掌握不同调度算法的优缺点。

    设计内容:

    设计程序模拟单处理机系统中的进程调度算法,在短作业优先调度算法、时间片轮转调度、最高优先级优先算法三种算法中选择两种实现。

    每个进程由一个进程控制块(PCB)表示。进程控制块可以包含如下信息:进程名、优先数、到达时间、需要运行时间、已用CPU时间、进程状态等。

    进程的优先数及需要的运行时间可以事先人为地指定(也可以由随机数产生)。进程的到达时间为进程输入的时间。

    进程的运行时间以时间片为单位进行计算。

    每个进程的状态可以是就绪W(Wait)、运行R(Run)或完成F(Finish)3中状态之一。

    以下是最高优先级优先算法思想:

     

    就绪进程获得CPU后都只能运行一个时间片,用已占用CPU时间加1来表示。

    如果运行一个时间片后,进程的已占用CPU时间已达到所需要的运行时间,则撤销该进程,如果运行一个时间片后进程的已占用CPU时间还未达到所需要的运行时间,也即进程还需要继续运行,此时应将进程的优先数减1(即降低一级),然后把它插入就绪队列等待CPU。

    每进行一次调度程序都打印一次运行进程、就绪队列以及各个进程的PCB,以便进行检查。

    重复以上过程,直到所有进程都完成为止。

    代码如下:

    import java.util.Scanner;
    
    import org.omg.CORBA.PUBLIC_MEMBER;
    
    
    public class PP {
    	public static void main(String[] args) {
    		int Num;
    		int i,j;
    		int t;
    		int a,b,c,d;
    		int o,p,q,r,s;
    		int NowTime;
    		int Sum = 0;
    		Scanner Shu = new Scanner(System.in);
    		System.out.print("请输入进程数:");
    		Num = Shu.nextInt();
    		PCB pcb[] = new PCB[Num];
    		System.out.println("请依次输入进程名   到达时间   需要运行时间   优先级");
    		for(i = 0;i < Num;i++){
    			a = Shu.nextInt();
    			b = Shu.nextInt();
    			c = Shu.nextInt();
    			d = Shu.nextInt();
    			pcb[i] = new PCB(a,b,c,d);
    		}
    		PCB e = new PCB();
    		e.sort1(pcb,Num);
    		System.out.println("进程名  到达时间  需要运行时间   优先级");   //输出排序后的进程
    		for(o=0;o<Num;o++){	
    			System.out.print("  "+pcb[o].Name+"     ");
    			System.out.print(pcb[o].ArrT+"      ");
    			System.out.print(pcb[o].RunT+"          ");
    			System.out.println(pcb[o].Piro);
    		}
    		NowTime = pcb[0].ArrT;
    		e.setCPUTIME(pcb,0);
    		e.setSTATE(pcb,0,'R');
    		e.setRunT(pcb, 0);
    		System.out.println("进程名     到达时间      需要运行时间      已占用CPU时间      进程状态");
    		System.out.print("  "+pcb[0].Name+"        ");
    		System.out.print(pcb[0].ArrT+"             ");
    		System.out.print(pcb[0].RunT+"             ");
    		System.out.print(pcb[0].CPUTIME+"          ");
    		System.out.println(pcb[0].State);
    		System.out.println("现在的时间为:"+NowTime);
    		while(true){
    			for(i=0;i<Num;i++){
    				if(pcb[i].State !='F')
    					break;
    			}
    			if(i==Num)
    				break;
    			e.sort2(pcb,Num);
    			e.setPiro(pcb, 0);
    			e.setCPUTIME(pcb,0);
    			e.setSTATE(pcb,0,'R');
    			e.setRunT(pcb, 0);
    			NowTime++;
    			for(p = 1;p < Num&&pcb[p].State!='F';p++){
    				e.setSTATE(pcb,p,'W');
    				}
    			for(r = 0;r < Num;r++){
    				if(pcb[r].RunT == 0){
    					e.setSTATE(pcb,r,'F');
    				    e.changepiro(pcb, r);
    				}
    			}			
    		System.out.println("进程名     到达时间      需要运行时间      已占用CPU时间      进程状态");
    		for(q = 0;q < Num;q++) {
    		System.out.print("  "+pcb[q].Name+"        ");
    		System.out.print(pcb[q].ArrT+"             ");
    		System.out.print(pcb[q].RunT+"             ");
    		System.out.print(pcb[q].CPUTIME+"          ");
    		System.out.println(pcb[q].State);
    		}
    		System.out.println("现在的时间为:"+NowTime);
    	}
    }
    }
    
    
    class PCB{
    	int Name;  //进程名
    	int ArrT;  //到达时间
    	int RunT;  //需要运行时间
    	int Piro;  //优先级
        int CPUTIME=0;  //已用CPU时间
        char State;  //进程状态
    	PCB(){};
    	PCB(int a,int b,int c,int d){
    		Name = a;
    		ArrT = b;
    		RunT = c;
    		Piro = d;
    	}
    	
    	void sort1(PCB pcb[],int n){  //排序,先到达的排在前面
    		PCB t = new PCB();
    		int i,j;
    		for(i = 0;i < n-1;i++)
    			for(j = 0;j < n-1;j++)
    				if(pcb[j].ArrT > pcb[j+1].ArrT){
    					t = pcb[j];
    					pcb[j] = pcb[j+1];
    					pcb[j+1] = t;
    				}
    	}
    	
    	void sort2(PCB pcb[],int n){   //按照优先级排序
    		PCB t = new PCB();
    		int i,j;
    		for(i = 0;i < n-1;i++)
    			for(j = 0;j < n-1;j++)
    				if(pcb[j].Piro < pcb[j+1].Piro){
    					t = pcb[j];
    					pcb[j] = pcb[j+1];
    					pcb[j+1] = t;
    				}
    	}
    	
    	int setCPUTIME(PCB pcb[],int n){
    		pcb[n].CPUTIME++;
    		return pcb[n].CPUTIME;
    	}
    	
    	int setSTATE(PCB pcb[],int t,char n){
    		pcb[t].State = n;
    		return pcb[t].State;
    	}
    	
    	int setRunT(PCB pcb[],int n){
    		pcb[n].RunT = pcb[n].RunT - 1;
    		return pcb[n].RunT;
    	}
    	
    	int setPiro(PCB pcb[],int n){
    		pcb[n].Piro--;
    		return pcb[n].Piro--;
    	}
    	int changepiro(PCB pcb[],int n){
    		pcb[n].Piro = -99;
    		return pcb[n].Piro;
    	}
    }

    测试可用。
    展开全文
  • 二、最短作业优先算法(SJF非抢占式):Shortest Job First 三、最短剩余时间优先算法SRTN(等价于抢占式SJF):Shortest Remaining Time Next 注意几个小细节: 如果题目中未特别说明,所提到的“短作业/进程...

    各种调度算法的学习思路:

    在这里插入图片描述

    调度算法的评价指标:

    在这里插入图片描述

    一、先来先服务算法(FCFS):First Come First Serve

    在这里插入图片描述
    在这里插入图片描述

    二、最短作业优先算法(SJF非抢占式):Shortest Job First

    在这里插入图片描述
    在这里插入图片描述

    三、最短剩余时间优先算法SRTN(等价于抢占式SJF):Shortest Remaining Time Next

    在这里插入图片描述
    在这里插入图片描述
    注意几个小细节:

    1. 如果题目中未特别说明,所提到的“短作业/进程优先算法”默认是非抢占式的
    2. 很多书上都会说“SJF最短作业优先调度算法的平均等待时间、平均周转时间最少”
      严格来说,这个表述是错误的,不严谨的。之前的例子表明,SRTN最短剩余时间优先算法得到的平均等待时间、平均周转时间更少!
      应该加上一个条件“在所有进程同时可运行时,采用SJF调度算法的平均等待时间、平均周转时间最少”;或者说“在所有进程都几乎同时到达时,采用SJF调度算法的平均等待时间、平均周转时间最少”;如果不加上述前提条件,则应该说“抢占式的短作业/进程优先调度算法(最短剩余时间优先,SRNT算法)的平均等待时间、平均周转时间最少”
    3. 虽然严格来说,SJF的平均等待时间、平均周转时间并不一定最少,但相比于其他算法(如FCFS),SIF依然可以获得较少的平均等待时间、平均周转时间
    4. 如果选择题中遇到“SJF算法的平均等待时间、平均周转时间最少”的选项,那最好判断其他选项是不是有很明显的错误,如果没有更合适的选项,那也应该选择该选项

    在这里插入图片描述

    四、最高响应比优先算法HRRN:Highest Response Ratio Next

    响应比 = (等待时间 + 要求服务时间)/ 要求服务时间
    注意: 这里的要求服务时间其实就是等待时间!
    在这里插入图片描述
    在这里插入图片描述

    五、对四种算法的总结:

    在这里插入图片描述

    展开全文
  • 进程调度模拟设计(非强占式短进程优先算法最高响应比优先调度算法)在此基础上增加了先来先服务算法。直接复制粘贴就能运行
  • 例题:最高响应比优先调度算法

    千次阅读 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   

    展开全文
  • 操作系统课程设计:时间片轮转、最高响应比优先调度算法
  • 进程调度模拟设计——优先级法、最高响应比优先调度算法
  • 操作系统课程设计:进程调度模拟设计 先来先服务 最高响应比优先调度算法
  • 进程调度模拟设计--优先级法、最高响应比优先调度算法
  • 进程调度模拟设计--时间片轮转、最高响应比优先调度算法
  • 进程调度模拟设计--先来先服务、最高响应比优先调度算法
  • C++最高响应比优先.rar

    2019-06-02 12:28:27
    概要:最高响应比优先算法则是兼顾作业等待时间和作业处理时间,使响应比最高的作业进入系统先进行工作。 现有四个作业,给出到达系统时间和所需CPU时间,设计最高响应比优先算法,来实现四个作业的周转时间、带权...
  • 经过调试程序 代码成功的运行 做出实验
  • 响应比最高优先调度算法(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、执行过程

     

     

     

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

    展开全文
  • (1)算法思想 主要从“公平”的角度考虑(类似于我们生活中排队买东西的例子) (2)算法规则 按照作业/进程到达的先后顺序进行服务 (3)用于作业/进程调度 用于作业调度时,考虑的是哪个作业先到达后备队列;用于...
  • 这是用C语言写的3个作业调度算法,包括先来先服务,短作业优先,最高响应比优先。这是用C语言写的3个作业调度算法,包括先来先服务,短作业优先,最高响应比优先
  • 操作系统课程设计 进程调度模拟设计 武汉理工大学 计算机学科学与上技术学院院
  • cout 高响应比优先算法" ; cout 退出程序" ; } int main() { int n; cout 请输入进程的个数:"; cin >> n; createProcess(n); int flag = 0; menu(); while(1) { cin >> flag; switch(flag) { ...
  • 操作系统--响应比最高优先算法(Python代码)响应比最高优先算法简介原理Python代码(1) 原始数据(2) 代码实现1.创建进程2.第一次排序3. 找出在作业结束前被创建的作业4.找出响应比最大的作业相对应的索引(大...
  • 操作系统|高响应比优先算法(HRRN)

    千次阅读 2019-12-02 22:13:44
    首先,根据时间线的时间判断进程时间是否到达,如果进程时间到达,将进程存入缓冲池中,在每次执行前先计算出缓冲池中的进程响应比,得到响应比最高的进程信息,单步执行该进程 单步执行进程信息 //单步执行进程 ...
  • 这里记录一下操作系统的实验,几个调度算法的原理很好理解,网上也有很多解释,这里不再解释,直接上代码。 一、JCB类 public class JCB { public int id; /** * 剩余服务时间 */ public int leftTime; /** *...
  • 优先权调度算法(FPF) 为照顾紧迫性作业,使之在进入系统后便获得优先处理,...优先权的类型有静态优先权和动态优先权,最高优先权调度算法的关键就在于:使用静态优先权、动态优先权和如何确定进程的优先权。...

空空如也

空空如也

1 2 3 4 5 ... 13
收藏数 242
精华内容 96
关键字:

最高响应比优先算法