精华内容
下载资源
问答
  • 这学期刚开始学习操作系统,收到一个作业,百度关于高响应比优先(HRRN,HighestResponseRatioNext)CPU进程调度模拟算法,基本思想:短作业优先调度算法 + 动态优先权机制;既考虑作业执行时间也考虑作业等待...

    这学期刚开始学习操作系统,收到一个作业,百度关于高响应比优先(HRRN,Highest Response Ratio Next)的CPU进程调度模拟算法,基本思想:短作业优先调度算法 + 动态优先权机制;既考虑作业的执行时间也考虑作业的等待时间,综合了先来先服务(FCFS,First Come First Served)和最短作业优先(SJF,Shortest Job First)两种算法的特点。

    之后经过多番揣摩... ...决定界面用命令行算了,反正啥也不会...

    关于响应比:

    RR =  (预计运行时间 + 等待时间) / 预计运行时间 = 1 + 等待时间/预计运行时间;

    响应比高者优先进行调度;

    关于要求中的周转时间、带权周转时间、平均周转时间和平均带权周转时间:

    周转时间 =(作业完成的时间 - 作业提交时间);

    带权周转时间 = 作业周转时间 / 作业运行时间;

    平均周转时间 = (周转时间1+周转时间2+...+周转时间n)/ n;

    平均带权周转时间 = (带权周转时间1+带权周转时间2+...+带权周转时间n)/ n;

    开始,用vector存储提交的作业结构体指针,自己设置一个系统时间,毕竟模拟不可能时间流速一毛一样,接下来就是毫无技术含量的选择了,关于测试数据,想了想好难输,还得自己编,于是用随机函数产生数据;再在主函数参数中提供一个传递生成数据数量的参数。

    说到这里得说一下,关于java老师(没错,java老师)说的关于main()的一些情况:

    1 int main(int argc, char** argv){ argc为参数个数, argv为接下来传的参数

    2 ...3 return 0;4 }

    比如在命令行中调用该函数,***.exe 100,此时有两个参数,一个为"***.exe", 另一个就是"100"了,分别在argv[0]和argv[1]中。

    首先是数据生成,用为要求格式,所以要小处理一下,感觉这种方法可以在刷ACM题被题目玄学时使用,一个为标准代码,一个为自己的代码,目前未试过:

    1 #include "bits/stdc++.h"

    2 using namespacestd;3

    4 int ch_to_int(char*s){5 int ans = 0, len =strlen(s);6 for(int i = 0; i < len; i++) ans = ans*10 + s[i]-'0';7 returnans;8 }9 int main(int argc, char**argv){10 int k, N, tj/*0~23*/, ys/*0~59*/, tmp;11 freopen("test.txt", "w", stdout);12 srand(time(NULL)); //以系统时间为种子生成真正的随机数

    13 N = k = ch_to_int(argv[1]);14 while(k--){15 tmp = (rand() + 24)%24 * 100 + (rand() + 6)%6*10 + (rand() + 10)%10;16 printf("%04d %d\n", tmp, (rand() + N)%N + 1);17 }18 return 0;19 }

    调度算法:

    1 #include "bits/stdc++.h"

    2 #include "windows.h"

    3 using namespacestd;4 typedef long longll;5

    6 //(所有时间以分钟为单位存储,需要时转化)

    7

    8 ll systemTime; //自定义系统当前时间

    9

    10 structTask{11 int Tij; //提交时间

    12 int Ysi; //预计运行时间

    13 ll waitingTime; //等待时间

    14 int id; //作业号

    15

    16 ll prior(){17 return 1 + waitingTime*1.0/Ysi;18 }19

    20 Task(int T, intY){21 Tij =T;22 Ysi =Y;23 waitingTime = 0;24 }25 ll aroundTime(){26 return systemTime - Tij +Ysi;27 }28

    29 doublepriorTime(){30 return aroundTime()*1.0/Ysi;31 }32 void disp(intord){33 printf("--调度次序: %d --作业号: %04d --调度时间:%02d%02d --周转时间: %d min(s) --带权周转时间%.2f ...\n",34 ord, id, (systemTime/100 + systemTime/60)%24, systemTime%60, aroundTime(), priorTime());35 }36 };37

    38 int cmp1(const Task* a, const Task*b){39 return (a->Tij) < (b->Tij);40 }41

    42 intmain(){43 vector taskArr; ///以不定长数组存储作业队列

    44

    45 intTij, Ysi, order;46 ll ave_aroundTime = 0;47 double ave_prior_aroundTime = 0;48

    49 freopen("test.txt", "r", stdin);50 system(".\\生成测试数据.exe 1024"); //调用测试数据生成程序

    51

    52 while(cin>>Tij>>Ysi) taskArr.push_back(new Task(Tij%100 + Tij/100*60, Ysi));53

    54 按提交时间进行排序并编号

    55 sort(taskArr.begin(), taskArr.end(), cmp1);56 std::vector::iterator pos;57 for(pos = taskArr.begin(); pos != taskArr.end(); pos++){58 (*pos)->id = pos -taskArr.begin();59 }60

    61 std::vector::iterator willRun; //指向即将运行程序

    62 systemTime = (*taskArr.begin())->Tij; ///将系统当前时间设置为最早提交的作业时间

    63 order = -1;64 while(!taskArr.empty()){65 bool flag = false; ///判定是否有新的程序提交

    66 willRun =taskArr.begin();67 for(pos = taskArr.begin(); pos != taskArr.end(); pos++){68 if((*pos)->Tij > systemTime) break;69 willRun = (*willRun)->prior() < (*pos)->prior() ?pos : willRun;70 flag = true;71 }72 if(!flag){73 willRun =taskArr.begin();74 systemTime = (*willRun)->Tij;75 }76

    77 (*willRun)->disp(++order);78

    79 ave_aroundTime += (*willRun)->aroundTime(); //总周转

    80 ave_prior_aroundTime += (*willRun)->priorTime(); //总带权周转

    81

    82 for(pos = taskArr.begin(); pos != taskArr.end(); pos++){ //更新等待时间

    83 if((*pos)->Tij waitingTime += (*willRun)->Ysi;85 }86 }87

    88 systemTime += (*willRun)->Ysi; //系统时间增加

    89

    90 taskArr.erase(willRun); //结束则删除91

    92 //Sleep(10);

    93 }94 cout<

    97 return 0;98 }

    加油( ̄▽ ̄)"

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

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

    千次阅读 2018-11-22 12:13:13
    高响应比优先调度算法(Highest Response Ratio Next)是一种对CPU中央控制器响应比分配一种算法。HRRN是介于FCFS(先来先服务算法)与SJF(短作业优先算法)之间折中算法,既考虑作业等待时间又考虑作业运行...

             高响应比优先调度算法(Highest Response Ratio Next)是一种对CPU中央控制器响应比的分配的一种算法。HRRN是介于FCFS(先来先服务算法)与SJF(短作业优先算法)之间的折中算法,既考虑作业等待时间又考虑作业运行时间,既照顾短作业又不使长作业等待时间过长,改进了调度性能。

     

    #include<cstdio>
    #include<cstdlib>
    #include<ctime>
    #include<iostream>
    #include<queue>
    #include<list>
    #include<thread>
    #include<mutex>
    #include<Windows.h>
    using namespace std;
    #define MAX_TIME 99999
    int g_time = 0;
    mutex g_mutex_time;
    
    
    
    struct process_node
    {
    	int prcess_id;  //进程编号
    	int _start;  //进入时间
    	void(*main_doing)(int args, char *ptr_argv[]);//本进程完成的任务
    	int begin;   //开始时间
    	int finish;  //完成时间
    	int _function; //需要运行时间
    	int function; //已经运行的时间
    	int wait;
    	bool complete;	 //是否完成   true 完成
    };
    
    list<process_node*>q_list;//进程队列
    
    
    void showlist()
    {
    
    	for (auto ib = q_list.begin(); ib != q_list.end(); ib++)
    	{
    		cout << (*ib)->prcess_id << "    "<<(*ib)->wait<<"    ||";
    	}
    	cout << "\n";
    
    }
    void main_doing(int args, char *ptr_argv[])
    {
    	cout << args << "这是一个运行的实例" << endl;
    	Sleep(200);
    }
    
    void Come_Init_Prcess(void(*main_doing)(int args, char *ptr_argv[]), int _function) //模拟进程到来并且初始化
    {
    	static int id = 0;
    	process_node *p = new process_node;
    	p->prcess_id = ++id;
    	p->_start = g_time;
    	p->main_doing = main_doing;
    	p->_function = _function;
    	p->begin = MAX_TIME;
    	p->wait = 0;
    	p->finish = MAX_TIME;
    	p->function = 0;
    	p->complete = false;
    	q_list.push_back(p);
    }
    void Time_End_Work(process_node & current_process)//时间片结束的前的工作
    {
    	if (current_process.function >= current_process._function)//判断是否完成
    	{
    		current_process.complete = true;
    		current_process.finish = g_time;
    		cout << "进程" << current_process.prcess_id << "完成任务" << endl;
    		int wait = current_process.finish - current_process.begin;
    		q_list.remove(&current_process);
    		for (auto ib = q_list.begin(); ib != q_list.end(); ib++)
    		{
    			(*ib)->wait += wait;
    		}
    	}
    }
    void One_End_Process(process_node & current_process)
    {
    	int current_point = g_time;
    	cout << "当前时间" << current_point << endl;
    	while (current_point + current_process._function >= g_time)
    	{
    		current_process.main_doing(current_process.prcess_id, NULL);
    	}
    	current_process.function += g_time - current_point;
    	Time_End_Work(current_process);
    }
    process_node& Obtain_Obtain()//获取优先者
    {
    	float temp = 0.0;
    	process_node *p_temp = nullptr;
    	while (q_list.size() == 0);
    	for (auto ib = q_list.begin(); ib != q_list.end(); ib++)
    	{
    		if ((float)(((*ib)->_function + (*ib)->wait)/ (*ib)->_function) > temp)
    		{
    			temp = (float)(((*ib)->_function + (*ib)->wait) / (*ib)->_function);
    			p_temp = (*ib);
    		}
    	}
    
    	cout << "优先的是程序" << p_temp->prcess_id << endl;
    	p_temp->begin = g_time;
    	return *p_temp;
    }
    void Run_begin()
    {
    
    	while (1)
    	{
    		process_node &p_temp = Obtain_Obtain();
    		showlist();
    		One_End_Process(p_temp);
    	}
    }
    //时间实例到达
    void pthread_model()
    {
    	time_t ts;
    	srand((unsigned int)time(&ts));
    	while (1)
    	{
    		int x_temp = 0;
    		lock_guard<mutex>ldg(g_mutex_time);
    		cout << "时间:[" << g_time << "]" << endl;
    		if (g_time % 2 == 0)
    		{
    			while (1)
    			{
    				x_temp = rand() % 5;
    				if (x_temp > 0)
    				{
    					break;
    				}
    			}
    			Come_Init_Prcess(main_doing, x_temp);
    			cout << "实例到达" << endl;
    		}
    		Sleep(1000);
    		g_time++;
    	}
    
    }
    
    int main()
    {
    	thread th_model(pthread_model);
    	thread th_main(Run_begin);
    	th_model.join();
    	th_main.join();
    
    	cin.get();
    
    }
    
    
    

     

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

    2019-06-02 12:28:27
    现有四个作业,给出到达系统时间和所需CPU时间,设计最高响应比优先的算法,来实现四个作业的周转时间、带权周转时间、平均作业周转时间和平均带权作业周转时间。(里面也有一个最短作业优先算法,看自己需要吧,...
  • 高响应比优先算法

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    展开全文
  • 动态优先权是指在创建进程时所赋予优先权,是可以随进程推进或随其等待时间增加而改变,以便获得更好调度性能。引入动态优先权,并使作业优先权随其等待时间增长,...本实验模拟了高响应比优先调度算法。
  • 例题:最高响应比优先调度算法

    千次阅读 2020-11-05 18:43:38
    高响应比优先HRRN 高响应比优先调度算法主要用于作业调度,该算法是对FCFS调度算法和SJF调度算法一种综合平衡,同时考虑每个作业等待时间和估计运行时间。在每次进行作业调度时,先计算后备作业队列中每个作业...
  • 高响应比优先调度算法,通过C语言实现,数据结构用是链表。操作系统课程作业,模拟HRN,算法清楚明白,容易看懂,谢谢大家。
  • 以c#为工具,以高响应比优先为原则,实现进程调度顺序查看功能。下面附验证数据及结果: 进程 到达时间 要求服务时间 A 0 4 B 1 3 C 2 5 D 3 2 E 4 4 调度结果:ADBCE 注:若要扩展,将代码中T稍作改动即可
  • 具体的要求是这样的:编写程序完成批处理系统中的作业调度,要求采用响应比高者优先的作业调度算法。实验具体包括:首先确定作业控制块的内容,作业控制块的组成方式;然后完成作业调度;最后编写主函数对所作工作...
  • 高响应比优先调度算法(HRRN)例题详解

    万次阅读 多人点赞 2020-03-25 15:43:33
    高响应比优先调度算法(Highest Response Ratio Next)是一种对CPU中央控制器响应比分配一种算法。HRRN是介于FCFS(先来先服务算法)与SJF(短作业优先算法)之间折中算法,既考虑作业等待时间又考虑作业运行...
  • C语言编写的高响应优先调度算法,非抢占,需要从txt文件中读取作业
  • 这是用C语言写3个作业调度算法,包括先来先服务,短作业优先,最高响应比优先。这是用C语言写3个作业调度算法,包括先来先服务,短作业优先,最高响应比优先
  • 自己做的操作系统的实验,批处理系统的作业调度,采用高响应比优先的算法,请仔细查看程序,不排除有错误哦
  • 高响应比优先例子VC源代码,操作系统方面
  • 高响应比优先调度算法(HighestResponseRatioNext)是一种对CPU中央控制器响应比分配一种算法。HRRN是介于FCFS(先来先服务算法)与SJF(短作业优先算法)之间折中算法,既考虑作业等待时间又考虑作业运行时间...
  • 高响应比优先算法,我们为每一个作业引入一个动态优先级,定义如下: 优先权=(等待时间+要求服务时间)/要求服务时间 而等待时间与服务时间之和是系统对该作业的响应时间,所以优先级又相当于响应比Rp,所以 Rp=...
  • 高响应比优先调度算法则是既考虑了作业等待时间,又考虑了作业运行时间调度算法,因此既照顾了短作业,又不致使长作业等待时间过长,从而改善了处理机调度能力。 算法实现 优先权变化规律: 优先权= (等.....
  • 动态优先权是指在创建进程时所赋予优先权,是可以随进程推进或随其等待时间增加而改变,以便获得更好调度...本实验模拟了高响应比优先调度算法。 假如系统中现有3个作业,分别为A、B、C,它们作业大小...
  • 这学期刚开始学习操作系统,收到一个作业,百度关于高响应比优先(HRRN,HighestResponseRatioNext)CPU进程调度模拟算法,基本思想:短作业优先调度算法 + 动态优先权机制;既考虑作业执行时间也考虑作业等待...
  • 使用响应比高者优先算法 程序采用键盘输入,输入格式为: K TJ1 YS1 …… TJK YSK 其中K是作业数(>0),TJi提交时间,YSi (i=1~K)是作业预计运行时间(以分钟计)TJ输入格式是XXYY,其中XX是时,...
  • 高优先权调度算法(FPF) 为照顾紧迫性作业,使之在进入系统后便获得优先处理,引入了最高优先优先(FPF)调度算法。此算法常被用于批处理系统中,作为作业调度算法,也作为多种操作系统中进程调度算法,还可...
  • 采用轮转法进程调度算法、高响应比优先(HRRN)进行调度(调度过程中,假设处于执行状态进程不会阻塞),且每过t个时间片系统释放资源,唤醒处于阻塞队列队首进程。《操作系统》课程实验教学大纲《操作系、 程序...
  • 时间片轮转、最高响应比优先调度算法,操作系统课程设计
  • 高响应比优先调度算法: 该算法实际上是一种动态优先调度算法,它以相应比作为作业或进程动态优先权,其目的是既照顾短作业,又考虑到作业等待时间,使长作业不会长期等待;但每次调度前,都要进行响应比计算,...

空空如也

空空如也

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

高响应比优先的响应比