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

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

    万次阅读 2016-08-30 20:54:20
    优先权 = (等待时间 + 要求服务时间) / 要求服务时间又因为等待时间 + 要求服务时间 = 响应时间优先权 = 响应时间 / 要求服务时间故而称之为,高响应比优先算法。那么,这个计算公式,怎么就能体现上面三个综合...

    这个算法很好玩,综合了短作业优先,先来先服务,以及长作业也能得到服务的特性,因此,是一种综合的调度算法。

    计算公式:
    优先权 = (等待时间 + 要求服务时间) / 要求服务时间

    又因为等待时间 + 要求服务时间 = 响应时间

    优先权 = 响应时间 / 要求服务时间

    故而称之为,高响应比优先算法。

    那么,这个计算公式,怎么就能体现上面三个综合特性呢?

    首先,短作业优先。
    短作业优先是因为,要求服务时间在分子,如果要求服务时间很短,且等待时机我们认为相等,那么短作业就有更高的优先权。

    其次,先来先服务。
    假设要求服务时间相同,那么先来的作业等待时间肯定较长,所以先来的优先级更高。

    最后,长作业也不会沦落到没法调度的尴尬局面。因为一个长作业,等啊等,越等自己自己资历越老,优先级是在不断增长的,所以总会有机会熬出头的!

    因此,高响应比优先算法,实在很妙。
    但是,不得不承认,计算这个优先级是要付出代价的,关键是这个代价是不是可以忽略。

    展开全文
  • 高响应比优先算法-记录

    万次阅读 2019-08-29 21:37:02
    这里记录一下高响应比优先算法的思想,它结合了短作业优先+先来先服务+不冷落长作业等特点,成为一种综合的动态调度算法,常用在操作系统的任务进程调度中。 它的计算公式如下: 优先权 = (等待时间 + 要求服务...

    这里记录一下高响应比优先算法的思想,它结合了短作业优先+先来先服务+不冷落长作业等特点,成为一种综合的动态调度算法,常用在操作系统的任务进程调度中。

    它的计算公式如下: 
    优先权 = (等待时间 + 要求服务时间) / 要求服务时间

    又因为等待时间 + 要求服务时间 = 响应时间

    优先权 = 响应时间 / 要求服务时间

    故而称之为,高响应比优先算法。

    那么,这个计算公式,怎么就能体现上面三个综合特性呢?

    首先,短作业优先。 
    短作业优先是因为,要求服务时间在分子,如果要求服务时间很短,且等待时机我们认为相等,那么短作业就有更高的优先权。

    其次,先来先服务。 
    假设要求服务时间相同,那么先来的作业等待时间肯定较长,所以先来的优先级更高。

    最后,长作业也不会沦落到没法调度的尴尬局面。因为一个长作业,等啊等,越等自己自己资历越老,优先级是在不断增长的,所以总会有机会熬出头的!

    以上都是优点,但是它也有缺点的

    缺点:响应比计算系统开销,增加系统开销

    适用场合有:批处理系统、主要用于作业调度

    展开全文
  • 操作系统 高响应比优先算法 c++语言版 操作系统 高响应比优先算法 c++语言版
  • 模拟实现短作业优先和高响应比优先算法。可能会有些bug
  • 高响应比优先算法,我们为每一个作业引入一个动态优先级,定义如下: 优先权=(等待时间+要求服务时间)/要求服务时间 而等待时间与服务时间之和是系统对该作业的响应时间,所以优先级又相当于响应比Rp,所以 Rp=...

    高响应比优先算法,我们为每一个作业引入一个动态优先级,定义如下:

    • 优先权=(等待时间+要求服务时间)/要求服务时间

    而等待时间与服务时间之和是系统对该作业的响应时间,所以优先级又相当于响应比Rp,所以

    • Rp=(等待时间+要求服务时间)/要求服务时间=响应时间/要求服务时间
    #include<bits/stdc++.h>
    using namespace std;
    #define maxsize 10
    struct proc
    {
        double seq;
        double com_Time;
        double ser_Time;
        double wait_Time;
        double res_Rate;
    }p[maxsize + 5];
    
    bool cmp(proc x, proc y) {
        return x.res_Rate > y.res_Rate;
    }
    
    void sortBy_res_Rate(double time, int flag, int n) {
        for (; flag <n; flag++) {
            p[flag].wait_Time = time - p[flag].com_Time;
            p[flag].res_Rate =(p[flag].wait_Time + p[flag].ser_Time) / p[flag].ser_Time;
        }
    }
    
    int main() {
        int n;
        cout << "请输入进程个数:(max<=10)" << endl;
        cin >> n;
        for (int i = 0; i < n; ++i) {
            cout << "请按顺序输入第"<<i+1<<"个进程的作业号,到达时刻,服务时间:" << endl;
            scanf("%lf %lf %lf",&p[i].seq,&p[i].com_Time,&p[i].ser_Time);
        }
        p[0].res_Rate = INT_MAX;
        double time = p[0].com_Time;
        time += p[0].ser_Time;
        cout << "调度顺序:" << endl;
        cout<<p[0].seq<<" ";
        for (int flag = 1; flag < n; ++flag) {
            sortBy_res_Rate(time, flag, n);
            sort(p + flag, p + n, cmp);
            time+=p[flag].ser_Time;
            cout << p[flag].seq << " ";
        }
        cout << endl;
    
        return 0;
    }
    
    

    在这里插入图片描述

    展开全文
  • #include #include #include #include #define MAX 10//釬珛講 struct PCB { char name[15]; int sTime;//督昢奀潔 int rTime;//羲宎堍俴奀潔 int fTime; int wTime; int tTime;//笚蛌奀潔 int cTime;...
  • 使用响应比高者优先算法 程序采用键盘输入,输入格式为: K TJ1 YS1 …… TJK YSK 其中K是作业数(>0),TJi提交时间,YSi (i=1~K)是作业预计的运行时间(以分钟计)TJ的输入格式是XXYY,其中XX是时,...
  • 操作系统_高响应比优先算法_c语言实现

    千次阅读 多人点赞 2021-04-08 20:53:24
    主函数 int main() { int n; //进程数量 scanf_s("%d", &n); ...核心算法 高响应比优先 void hrrf(struct pcb* p, int n) { int finishedcount = 0; //记录已经完成的进程数 int unfini.

    在这里插入图片描述
    注:在PTA上面提交时务必把scanf_s改成scanf,(编译器用的是vs2019).

    主函数

    int main()
    {
    	int n;              //进程数量
    	scanf_s("%d", &n);
    	struct pcb p[333];
    	input(p, n);
    	sort(p, n);
    	hrrf(p, n);
    	output(p, n);
    	return 0;
    }
    

    核心算法 高响应比优先

    void hrrf(struct pcb* p, int n) {
    	int finishedcount = 0;		  //记录已经完成的进程数
    	int unfinishedposition = 0;		//记录未完成进程的位置
    	double nowtime = 0;		     //现在时间
    	for (int i = 0; i < n; i++) {		
    		p[i].state = 0;
    	}
    	while (finishedcount < n) {
    
    		double max_rp = 0;			//中间变量比较响应比
    		int next = 0;		       //记录下一个要运行的位置下标
    	
    		//扫描找出有max响应比的进程下标
    		for (int i = unfinishedposition; (i < n && p[i].atime <= nowtime&&i!=0); i++) {
    			if (p[i].state == 1) {	 
    				continue;
    			}
    			if (p[i].rp > max_rp) {			//扫描对比rp
    				max_rp = p[i].rp;
    				next = i;					//记录下一个要执行进程下标
    			}
    		}
    
    		if (nowtime < p[unfinishedposition].atime * 1.0)	 //考虑到达的进程都运行完了, 有些进程还没到达的情况
    		{
    			nowtime = p[unfinishedposition].atime * 1.0;
    			next = unfinishedposition;
    		}
    
    		//运行阶段
    		{
    			nowtime = nowtime + p[next].rtime;		//更新现在时间
    			p[next].state = 1;						 //记录运行状态
    			p[next].ftime = nowtime;	     		 //完成时间=现在时间
    			p[next].ttime = nowtime - p[next].atime;			//周转=现在时间-到达
    			p[next].wtime = 1.0 * p[next].ttime / p[next].rtime;		//带权周转=周转/运行
    			
    			for (int i = unfinishedposition; i < n; i++) {		//指向下一个未运行的进程
    				if (p[i].state == 0) {
    					unfinishedposition = i;
    					break;
    				}
    			}
    			finishedcount++;		//运行完成的个数
    		}
    
    		//循环计算rp,响应比=(现在时间+运行时间-到达时间)/运行时间
    		for (int i = 0; i < n && (p[i].atime <= nowtime); i++) {
    			if (p[i].state == 1) {		//已经完成的就不要算响应比了
    				continue;
    			}
    			else {
    
    				p[i].rp = (nowtime + p[i].rtime-p[i].atime) / p[i].rtime;
    			}
    		}
    	}
    }
    
    

    源程序代码

    #include<stdio.h>
    #include<stdlib.h>
    //每运行完一次就要计算一次等待时间和响应比=(等待+服务)/服务
    //进程结构体
    struct pcb
    {
    	char name[10];   //进程名
    	int  atime;      //到达时间
    	int  rtime;    //运行时间
    	int  stime;		//开始时间
    	int  ftime;      //完成时间
    	int  ttime;      //周转时间
    	double wtime;    //带权周转时间
    	double rp;		//响应比
    	int state;		//执行状态  1表示已经执行
    };
    
    //输入模块
    void input(struct pcb* p, int n)
    {
    	for (int i = 0; i < n; i++) {
    		scanf_s("%s", p[i].name, sizeof(p[i]));
    	}
    	for (int i = 0; i < n; i++) {
    		scanf_s("%d", &p[i].atime);
    	}
    	for (int i = 0; i < n; i++) {
    		scanf_s("%d", &p[i].rtime);
    	}
    }
    
    //输出模块
    void output(struct pcb* p, int n)
    {
    
    	printf("作 业 名:");
    	for (int i = 0; i < n; i++) {
    		if (i == n - 1) {
    			printf("%s", p[n - 1].name);
    			printf("\n");
    		}
    		else {
    			printf("%s ", p[i].name);
    		}
    	}
    	printf("到达时间:");
    	for (int i = 0; i < n; i++) {
    		if (i == n - 1) {
    			printf("%d", p[n - 1].atime);
    			printf("\n");
    		}
    		else {
    			printf("%d ", p[i].atime);
    		}
    	}
    
    	printf("服务时间:");
    	for (int i = 0; i < n; i++) {
    		if (i == n - 1) {				//最后一行要加回车 这样做其实不方便
    			printf("%d", p[n - 1].rtime);
    			printf("\n");
    		}
    		else {
    			printf("%d ", p[i].rtime);
    		}
    	}
    	printf("完成时间:");
    	for (int i = 0; i < n; i++) {
    		if (i == n - 1) {
    			printf("%d", p[n - 1].ftime);
    			printf("\n");
    		}
    		else {
    			printf("%d ", p[i].ftime);
    		}
    	}
    	printf("周转时间:");
    	for (int i = 0; i < n; i++) {
    		if (i == n - 1) {
    			printf("%d", p[n - 1].ttime);
    			printf("\n");
    		}
    		else {
    			printf("%d ", p[i].ttime);
    		}
    	}
    	printf("带权周转时间:");
    	for (int i = 0; i < n; i++) {
    		if (i == n - 1) {
    			printf("%.2f", p[n - 1].wtime);
    			printf("\n");
    		}
    		else {
    			printf("%.2f ", p[i].wtime);
    		}
    	}
    
    }
    
    //atime升序
    void sort(struct pcb* p, int n)
    {
    
    	for (int i = 0; i < n - 1; i++)
    	{
    		struct pcb temp;
    		for (int j = 0; j < n - i - 1; j++)
    		{
    			if (p[j].atime > p[j + 1].atime)
    			{
    				temp = p[j];
    				p[j] = p[j + 1];
    				p[j + 1] = temp;
    			}
    		}
    	}
    }
    
    
    
    void hrrf(struct pcb* p, int n) {
    	int finishedcount = 0;		  //记录已经完成的进程数
    	int unfinishedposition = 0;		//记录未完成进程的位置
    	double nowtime = 0;		     //现在时间
    	for (int i = 0; i < n; i++) {		
    		p[i].state = 0;
    	}
    	while (finishedcount < n) {
    
    		double max_rp = 0;			//中间变量比较响应比
    		int next = 0;		       //记录下一个要运行的位置下标
    	
    		//扫描找出有max响应比的进程下标
    		for (int i = unfinishedposition; (i < n && p[i].atime <= nowtime&&i!=0); i++) {
    			if (p[i].state == 1) {	 
    				continue;
    			}
    			if (p[i].rp > max_rp) {			//扫描对比rp
    				max_rp = p[i].rp;
    				next = i;					//记录下一个要执行进程下标
    			}
    		}
    
    		if (nowtime < p[unfinishedposition].atime * 1.0)	 //考虑到达的进程都运行完了, 有些进程还没到达的情况
    		{
    			nowtime = p[unfinishedposition].atime * 1.0;
    			next = unfinishedposition;
    		}
    
    		//运行阶段
    		{
    			nowtime = nowtime + p[next].rtime;		//更新现在时间
    			p[next].state = 1;						 //记录运行状态
    			p[next].ftime = nowtime;	     		 //完成时间=现在时间
    			p[next].ttime = nowtime - p[next].atime;			//周转=现在时间-到达
    			p[next].wtime = 1.0 * p[next].ttime / p[next].rtime;		//带权周转=周转/运行
    			
    			for (int i = unfinishedposition; i < n; i++) {		//指向下一个未运行的进程
    				if (p[i].state == 0) {
    					unfinishedposition = i;
    					break;
    				}
    			}
    			finishedcount++;		//运行完成的个数
    		}
    
    		//循环计算rp,响应比=(现在时间+运行时间-到达时间)/运行时间
    		for (int i = 0; i < n && (p[i].atime <= nowtime); i++) {
    			if (p[i].state == 1) {		//已经完成的就不要算响应比了
    				continue;
    			}
    			else {
    
    				p[i].rp = (nowtime + p[i].rtime-p[i].atime) / p[i].rtime;
    			}
    		}
    	}
    }
    
    
    int main()
    {
    	int n;              //进程数量
    	scanf_s("%d", &n);
    	struct pcb p[333];
    	input(p, n);
    	sort(p, n);
    	hrrf(p, n);
    	output(p, n);
    	return 0;
    }
    

    测试截图
    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • C++、高响应比优先算法

    千次阅读 2018-12-06 20:55:38
    //计算响应比优先权),需要考虑到小数的情况。  }  }  for (int i = 0; i ; i++) { //将作业按照优先权,从大到小形成新的队列。  for (int j = i + 1; j ; j++) {  if (job_small[i].sfzx == 0) { //排除...
  • 自己做的操作系统的实验,批处理系统的作业调度,采用高响应比优先算法,请仔细查看程序,不排除有错误哦
  • Java 操作系统 最高响应比优先算法

    千次阅读 2018-05-19 22:08:55
    在进程管理中,进程调度是核心,因为在采用多道程序设计的系统中,往往有若干个进程同时处于就绪状态,当就绪进程个数大于处理器数目时,就必须依照某种策略决定哪些进程优先占用处理器。本设计模拟在单处理器情况下...
  • 二、设计题目 题目1 进程调度模拟程序 目的: 熟悉进程调度算法及其实现 内容: 编写一个程序完成多道程序的调度 要求: 只考虑1个CPU的资源,其他资源不考虑 使用响应比高者优先算法 程序采用键盘输入,输入格式为...
  • 操作系统|高响应比优先算法(HRRN)

    千次阅读 2019-12-02 22:13:44
    首先,根据时间线的时间判断进程时间是否到达,如果进程时间到达,将进程存入缓冲池中,在每次执行前先计算出缓冲池中的进程响应比,得到响应比最高的进程信息,单步执行该进程 单步执行进程信息 //单步执行进程 ...
  • 包括 先来先服务 短作业优先 高响应比优先 这三种算法 计算 非常详细
  • 设计要求(多道、单处理机): 1) 每一个进程有一个PCB,其内容可以根据具体情况设定。 2) 可以在界面设定的互斥资源(包括两种:输入设备与输出设备)的数目 3) 进程数、进入内存时间、要求服务时间可以在界面上...
  • 二、最短作业优先算法(SJF非抢占式):Shortest Job First 三、最短剩余时间优先算法SRTN(等价于抢占式SJF):Shortest Remaining Time Next 注意几个小细节: 如果题目中未特别说明,所提到的“短作业/进程...
  • 高响应比优先调度算法从文件中读取数据,操作系统实验
  • 高响应比优先调度算法(HRRN)例题详解

    万次阅读 多人点赞 2020-03-25 15:43:33
    高响应比优先调度算法 (HRRN) 高响应比优先调度算法(Highest Response Ratio Next)是一种对CPU中央控制器响应比的分配的一种算法。HRRN是介于FCFS(先来先服务算法)与SJF(短作业优先算法)之间的折中算法,既...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 601
精华内容 240
关键字:

高响应比优先算法