精华内容
下载资源
问答
  • 动态优先权是指在创建进程时所赋予的优先权,是可以随进程的推进或随其等待时间的增加而改变的,以便获得更好的调度性能。引入动态优先权,并使作业的优先权随其等待时间的增长,...本实验模拟了高响应比优先调度算法。
  • 以c#为工具,以高响应比优先为原则,实现进程调度顺序查看功能。下面附验证数据及结果: 进程 到达时间 要求服务时间 A 0 4 B 1 3 C 2 5 D 3 2 E 4 4 调度结果:ADBCE 注:若要扩展,将代码中的T稍作改动即可
  • 最高响应比优先算法

    2017-12-16 16:26:26
    本文件是对操作系统作业调度算法中的最高响应比优先算法的设计与实现,代码和报告都放在了压缩文件中,代码使用的文件输入输出。
  • java平台运行高响应比优先调度算法,如果响应比相同则短作业优先。输出进程工作顺序、调度时间、周转时间、带权周转时间、平均周转时间和平均带权周转时间。压缩带有测试案例
  • 这是用C语言写的3个作业调度算法,包括先来先服务,短作业优先,最高响应比优先。这是用C语言写的3个作业调度算法,包括先来先服务,短作业优先,最高响应比优先
  • 高响应比优先调度算法,通过C语言实现,数据结构用的是链表。操作系统的课程作业,模拟HRN,算法清楚明白,容易看懂,谢谢大家。
  • 高响应比优先调度算法从文件中读取数据,操作系统实验
  • 高响应比优先

    2014-05-12 14:33:22
    高响应比优先分配算法,有源代码有exe程序
  • 《操作系统》第四版,最高响应比算法实现作业调度,作业信息可以自行输入,输出作业号,到达时间,运行时间,完成时间,等等,输出平均周转时间,带权周转时间,调度顺序,
  • 编写并调试一个模拟的进程调度程序,分别采用“短进程优先”、“时间片轮转”、“高响应比优先”调度算法对随机产生的五个进程进行调度,并比较算法的平均周转时间。以加深对进程的概念及进程调度算法的理解。
  • 操作系统实验之模拟进程调度,是本人自己用MFC做的,语言用的是C++。包括时间片轮转法 高响应比优先法和动态优先级法。大学实验课的成品,仅供大家参考和学习
  • Java模拟最短作业优先、时间片轮转、最高响应比和先来先服务进程调度算法 rar中有四种算法和俩个对进程用时和周转时间制图的java源代码,另外有jcommon-1.0.23.jar和jfreechart-1.0.19.jar俩个制图包
  • 高响应比优先算法-记录

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

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

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

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

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

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

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

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

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

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

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

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

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

    展开全文
  • 模拟实现短作业优先高响应比优先算法。可能会有些bug
  • 使用响应比高者优先算法 程序采用键盘输入,输入格式为: K TJ1 YS1 …… TJK YSK 其中K是作业数(>0),TJi提交时间,YSi (i=1~K)是作业预计的运行时间(以分钟计)TJ的输入格式是XXYY,其中XX是时,...
  • 用java实现高响应比优先算法,考虑了空转的情况(即:在前面的进程做完之前后面的进程没有进入)。
  • 操作系统 高响应比优先算法 c++语言版 操作系统 高响应比优先算法 c++语言版
  • //高响应比调度算法 #include<stdio.h> #include<stdlib.h> struct zgxyb{ char name[10]; float arrivetime; float servicetime; float starttime; float finishtime; float zztime; float dqzztime; }; struct ...
  • #include #include #include #include #define MAX 10//釬珛講 struct PCB { char name[15]; int sTime;//督昢奀潔 int rTime;//羲宎堍俴奀潔 int fTime; int wTime; int tTime;//笚蛌奀潔 int cTime;...
  • 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) { //排除...
    #include<iostream>
    #include"string"
    using namespace std;
    struct JOB {
        string name;   //作业名字
        int length;    //作业长度,可以用来判断作业是否合法(小于0时,为非法进程)
        int printer;   //执行作业需要的打印机数目
        int tape;      //执行作业需要的磁带机的数目
        int runtime;   //作业要求服务时间
        int waittime;  //作业在系统中等待时间
        //int next;      //指向下一个作业控制块的指针,先不用。
        float xyb;     //自己加上的一个响应比,判断优先执行哪个作业
        int sfzx;      //标志位,用来标志该作业块是否执行过,0表示未执行,1表示已执行。
    };
    //1、其实这个结构体没有考虑到到达时间的问题,统一认为处理时刻所有作业都已经到达。
    //2、模拟多处理机的时候,不太了解怎么实现异步的操作。
    const int max = 5;  //允许的就绪队列最大作业数
    const int printer = 2; //打印机数量
    const int tape = 4;   //磁带机数量
    const int memory = 64;  //主存容量。
    //这些常量被用作判断输入的数据是否合法。
    string search_name(JOB job_small[], int count) {  //里面的count值为就绪队列中作业的个数。
        //search_name里面的标志位都是直接用的job_small里面的,而不是job_hrrn里面的。
        string name;
        JOB job_hrrn[max];     //如果不使用job_hrrn这个中间结构体的话,名称和数据结构里面的数据不会统一。
        for (int i = 0; i < count; i++) {
            if (job_small[i].sfzx == 0) {  //筛除已经工作完成的作业
                job_hrrn[i].name = job_small[i].name;
                job_hrrn[i].runtime = job_small[i].runtime;
                job_hrrn[i].waittime = job_small[i].waittime;    //之所以取出这两个信息就是为了下面的计算优先权。
                job_hrrn[i].xyb = (job_hrrn[i].runtime + job_hrrn[i].waittime) / (float)job_hrrn[i].runtime;  //计算响应比(优先权),需要考虑到小数的情况。
            }
        }
        for (int i = 0; i < count; i++) {  //将作业按照优先权,从大到小形成新的队列。
            for (int j = i + 1; j < count; j++) {
                if (job_small[i].sfzx == 0) {   //排除已经访问过的作业块
                    if (job_hrrn[i].xyb < job_hrrn[j].xyb) {   //这里的j写成i了,犯了致命错误。
                        string temp;
                        float tmp;
                        temp = job_hrrn[i].name;
                        job_hrrn[i].name = job_hrrn[j].name;
                        job_hrrn[j].name = temp;
                        tmp = job_hrrn[i].xyb;
                        job_hrrn[i].xyb = job_hrrn[j].xyb;
                        job_hrrn[j].xyb = tmp;
                    } //end if
                }//end if
            }  //end for
        }  //end for
        for (int i = 0; i < count; i++) {   
            //实现每调用一次search_name(),就能够把响应比最高的作业的名称返回。
            if (job_small[i].sfzx == 0) {
                name = job_hrrn[i].name;
                break;
            }
        }
        return name;
    }
    
    
    void input() {
        JOB job_small[max]; //副结构体,负责作为search_name里的形参。
        int count = 0;   //计数器,记录就绪队列中一共有多少个作业。
        int job_memory = 0;
        for (int i = 0; i < max; i++) {   //给job_small赋值
                printf("请输入作业名称、作业长度、需要打印机数目、需要磁带机数目、要求服务时间、等待时间(输入作业名称为0时,结束作业输入):\n");
                //计算优先权的工作放在方法search_name里面操作。
                cin >> job_small[i].name >> job_small[i].length >> job_small[i].printer >> job_small[i].tape >> job_small[i].runtime >> job_small[i].waittime;
                job_memory = job_memory + job_small[i].length;
                while (job_small[i].length < 0 || job_memory > 64 || job_small[i].printer > 2 || job_small[i].tape > 4) {  
                    //作业长度非法或者是作业总内存过载的情况。
                    if(job_small[i].length < 0)
                      printf("错误:此作业长度有误,请重新输入!\n");
                    if (job_memory > 64) {
                        printf("错误:内存超载,请重新输入!\n");
                        job_memory = job_memory - job_small[i].length;
                    }
                    if (job_small[i].printer > 2)
                        printf("错误:打印机数量不足,请重新输入!\n");
                    if (job_small[i].tape > 4)
                        printf("错误:磁带机数量不足,请重新输入!\n");
                    printf("请输入作业名称、作业长度、需要打印机数目、需要磁带机数目、要求服务时间、等待时间:\n");
                    cin >> job_small[i].name >> job_small[i].length >> job_small[i].printer >> job_small[i].tape >> job_small[i].runtime >> job_small[i].waittime;
                    job_memory = job_memory + job_small[i].length;
                    if (job_small[i].length > 0 && job_memory <= 64 && job_small[i].printer <= 2 && job_small[i].tape <= 4)
                        break;
                }
                printf("\n");
                if (job_small[i].name == "0")
                    break;
                count++;
                job_small[i].sfzx = 0;  //将标志位记为0,既未访问过。
        }
        JOB job[max];   //主结构体,负责作业的全部字段,也是最后负责输出的结构体
        for (int i = 0; i < count; i++) {
            //在后面代码再给结构体加上信息
            job[i].sfzx = 0;
        }
        //核心算法
        int index = 0;    //做嵌套内循环的下标使用,千万不能放在第一个循环里面,不然使得下标一直是0;
        for (int m = 0; m < count; m++) {
                string name = search_name(job_small, count);
                for (int i = 0; i < count; i++) {
                        if (job_small[i].name == name) {
                            job[index].name = job_small[i].name;
                            job[index].length = job_small[i].length;
                            job[index].printer = job_small[i].printer;
                            job[index].tape = job_small[i].tape;
                            job[index].waittime = job_small[i].waittime;
                            job[index].runtime = job_small[i].runtime;
                            job_small[i].sfzx = 1; //将标志位置1;
                            index++;
                            break;  //跳出内层for循环。
                        } //end if
                }//end for
        }//end for
        printf("\n\n\n作业名称\t作业长度\t需要打印机数目\t需要磁带机数目\t服务时间\t等待时间\n");
        for (int i = 0; i < count; i++) {
            cout << "   " << job[i].name << "\t\t" << "   " << job[i].length << "\t\t" << "     " << job[i].printer
                << "\t\t" << "     " << job[i].tape << "\t\t" << "   " << job[i].runtime << "\t\t" << "   " << job[i].waittime << endl;
            //printf("%s%10d%10d\n",job[i].name, job[i].runtime, job[i].waittime);
        }
    }//end input
    void main() {
        input();
    }

     

    展开全文
  • C++最高响应比优先.rar

    2019-06-02 12:28:27
    概要:最高响应比优先算法则是兼顾作业等待时间和作业处理时间,使响应比最高的作业进入系统先进行工作。 现有四个作业,给出到达系统时间和所需CPU时间,设计最高响应比优先的算法,来实现四个作业的周转时间、带权...
  • //高响应比调度算法 #include<stdio.h> #include<stdlib.h> struct zgxyb{ char name[10]; float arrivetime; float servicetime; float starttime; float finishtime; float zztime; float dqzztime; }; struct ...
  • 本次试验是使用程序来模拟操作系统中进程调度的三种不同的调度策略,分别为最短作业有限、时间片轮转、最高响应比。 模拟的情况下,进程数为8,进程所需执行时间为随机产生的整数,单位为1S,默认进程同时到达。 ...
  • 实验四 模拟处理机 HRRN 调度算法 一实验目的用 ...N 个进程的平均周转时间 三HRRN最高响应比调度算法原理 最高响应比调度在每次调度作业时先计算后备队 中每个作业的响应比然后挑选响应比高者投入运行 响应比 R 定义
  • 操作系统_高响应比优先算法_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;
    }
    

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

    展开全文

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 150,469
精华内容 60,187
关键字:

高响应比优先的响应比