最高响应比调度算法代码
时间片轮转、最高响应比优先调度算法剖析
题 目 时间片轮转、最高响应比优先调学 号: 课 程 设 计度算法学 院 计算机科学与技术专 业班 级姓 名指导教师 吴利军2013 年 1 月 14 日课程设计任务书学生姓名:指导教师:吴利军工作单位:计算机科学与技术学院题目:进程调度模拟设计——时间片轮转、最高响应比优先调度算法初始条件:1.预备内容:阅读操作系统的处理机管理章节内容,对进程调度的功能以及进程调度算法有深入的理解。
2.实践准备:掌握一种计算机高级语言的使用。
要求完成的主要任务:(包括课程设计工作量及其技术要求,以及说明书撰写等具体要求)1.模拟进程调度,能够处理以下的情形:⑴能够选择不同的调度算法(要求中给出的调度算法);⑵能够输入进程的基本信息,如进程名、到达时间和运行时间等;⑶根据选择的调度算法显示进程调度队列;⑷根据选择的调度算法计算平均周转时间和平均带权周转时间。
2.设计报告内容应说明:⑴需求分析;⑵功能设计(数据结构及模块说明);⑶开发平台及源程序的主要部分;⑷测试用例,运行结果与运行情况分析;⑸我评价自与总结:i)你认为你完成的设计哪些地方做得比较好或比较出色;ii)什么地方做得不太好,以后如何改正;iii)从本设计得到的收获(在编写,调试,执行过程中的经验和教训);iv)完成本题是否有其他方法(如果有,简要说明该方法);v)对实验题的评价和改进意见,请你推荐设计题目。
时间安排:设计安排一周:周1、周2:完成程序分析及设计。
周2、周3:完成程序调试及测试。
周4、周5:验收、撰写课程设计报告。
(注意事项:严禁抄袭,一旦发现,一律按0分记)指导教师签名:年月日系主任(或责任教师)签名:年月日1.需求分析1.1.模拟进程调度,能够处理以下的情形:⑴能够选择不同的调度算法(要求中给出的调度算法);⑵能够输入进程的基本信息,如进程名、到达时间和运行时间等;⑶根据选择的调度算法显示进程调度队列;⑷根据选择的调度算法计算平均周转时间和平均带权周转时间。
高响应比优先调度算法
高响应比优先调度算法
高响应比优先调度算法(HRRN)是一种多任务调度策略,它将任务按照它们的响应比(Response Ratio)来进行排序,响应比由当前时间(Current Time)和上次服务时间(Last Service Time)组成,它体现了任务等待时间以及服务时间的比值。
HRRN算法通过比较任务的响应比,将等待时间长的任务放在队列的前面,从而提高系统的响应时间。
HRRN算法的优势在于它能够更好地满足多任务的需求,它能够有效地减少等待时间,提高系统的效率,使系统能够更好地满足客户的需求。
HRRN算法的实现步骤如下:
1. 计算每个任务的响应比(R),R=(当前时间-上次服务时间)/服务时间;
2. 将任务按照响应比从高到低进行排序;
3. 从队列中取出响应比最高的任务,分配给处理器进行处理;
4. 如果任务还没有完成,就将它重新放回队列,等待下次调度;
5. 当任务完成后,更新每个任务的响应比,重新排序,重复以上步骤。
总之,HRRN算法是一种高效的多任务调度策略,它能够有效地提高系统的响应时间,满足客户的需求,实现良好的任务调度效果。
先来先服务,短作业优先,高响应比进程调度算法的实现
先来先服务,短作业优先,⾼响应⽐进程调度算法的实现⼀、实验内容编程实现先来先服务算法、短作业优先算法、⾼响应⽐算法,并求出每个作业的完成时间、周转时间、带权周转时间,及平均周转时间、平均带权周转时间。
⼆、实验要求1.任选⼀种⾼级语⾔实现;2.选择FCFS、SJF、HRRN调度算法;3.能够输⼊进程的基本信息,如进程名、提交时间、预估运⾏时间等;4.根据选择的调度算法显⽰进程调度顺序;5.显⽰完成调度后每个进程的开始时间、完成时间呢、周转时间,带权周转时间;6.计算平均周转时间和平均带权周转时间;三、实验过程1、设计思想FCFS算法对提交时间进⾏排序,按提交时间从⼩到⼤的顺序调度,SJF算法从第⼆个进程开始计算找出当前处在就绪等待队列的进程,并找出其中运⾏时间最短的作为下次调度的进程,HRRN算法从第⼆个进程开始计算找出当前处在就绪等待队列的进程,并找出其中响应⽐最⼩的作为下次调度的进程2.运⾏结果四、实验代码#include<iostream>#include<Windows.h>#include<stdio.h>#include<stdlib.h>#include <time.h>#define N 5using namespace std;struct Mystruct{float arrivetime;float runtime;float starttime;float waittime;float endtime;float turnaroundtime;float rightturnaroundtime;}Thread[N];void sort(struct Mystruct Thread[]) {//按进程到达时间排序for (int i = 0; i < N; i++) {for (int j = 0; j < N - 1; j++) {if (Thread[j].arrivetime > Thread[j + 1].arrivetime) {float t1 = Thread[j + 1].arrivetime;Thread[j + 1].arrivetime = Thread[j].arrivetime;Thread[j].arrivetime = t1;float t2 = Thread[j + 1].runtime;Thread[j + 1].runtime = Thread[j].runtime;Thread[j].runtime = t2;}}}}float JRR(float i, float j, float k) {//计算响应⽐float s = (i - j + k) / k;//cout << i << " " << j << " " << k << "响应⽐" << s << endl;return s;}void RRsort(int i) {//找出最⼩响应⽐进程的下标与下次要运⾏的进程交换次序,使处在就绪状态响应⽐最⼩的进程下次运⾏int next = 0;float min = 30;for (int j = i + 1; j < N; j++){if (Thread[j].arrivetime <= Thread[i].endtime) {float RR;// cout << Thread[i].endtime << endl;if (i != 4)RR = JRR(Thread[i].endtime, Thread[j].arrivetime, Thread[j].runtime);if (RR < min)//找出最⼩响应⽐{min = RR;next = j;}}}Mystruct temp;temp = Thread[i + 1];Thread[i + 1] = Thread[next];Thread[next] = temp;}void FCFS() {int count = 0;cout << "==========================先来先服务算法调度==========================" << endl;sort(Thread);float avewaittime = 0,aveturnaroundtime=0,averightturnaroundtime=0;cout << "作业号" << "\t" << "提交时间" << "\t" << "运⾏时间" << "\t" << "开始时间" << "\t" << "等待时间" << "\t" << "完成时间"<<"\t" << "周转时间" << " \t" << "带权周转时间" << endl;for (int i = 0; i < N; i++){count++;if (count == 1)Thread[i].starttime = Thread[i].arrivetime; else Thread[i].starttime=Thread[i-1].starttime+Thread[i-1].runtime;if (Thread[i].starttime<Thread[i].arrivetime){Thread[i].starttime = Thread[i].arrivetime;}Thread[i].endtime = Thread[i].starttime + Thread[i].runtime;Thread[i].waittime = Thread[i].starttime - Thread[i].arrivetime;Thread[i].turnaroundtime = Thread[i].endtime - Thread[i].arrivetime;Thread[i].rightturnaroundtime = Thread[i].turnaroundtime / Thread[i].runtime;avewaittime += Thread[i].waittime; aveturnaroundtime += Thread[i].turnaroundtime; averightturnaroundtime += Thread[i].rightturnaroundtime;cout <<count<<"\t" <<Thread[i].arrivetime << "\t\t" << Thread[i].runtime << "\t\t" << Thread[i].starttime << "\t\t" << Thread[i].waittime << "\t\t" << Thr ead[i].endtime << "\t\t" << Thread[i].turnaroundtime << "\t\t" << Thread[i].rightturnaroundtime << endl;}cout << "平均等待时间:" << avewaittime / N << "\t" << "平均周转时间:" << aveturnaroundtime/N << "\t" << "平均带权周转时间:" << averightturna roundtime / N << endl;}void SJF(struct Mystruct Thread[]){float avewaittime = 0, aveturnaroundtime = 0, averightturnaroundtime = 0;for (int m = 0; m < N - 1; m++){if (m == 0)Thread[m].endtime = Thread[m].arrivetime + Thread[m].runtime;else{if (Thread[m - 1].endtime >= Thread[m].arrivetime){Thread[m].starttime = Thread[m - 1].endtime;}else{Thread[m].starttime = Thread[m].arrivetime;}Thread[m].endtime = Thread[m].starttime + Thread[m].runtime;}int i = 0;for (int n = m + 1; n <= N - 1; n++){if (Thread[n].arrivetime <= Thread[m].endtime)i++;}//按运⾏时间排序float min = Thread[m + 1].runtime;int next = m + 1;//m+1=nfor (int k = m + 1; k < m + i; k++){if (Thread[k + 1].runtime < min){min = Thread[k + 1].runtime;next = k + 1;}}// cout << min << endl;Mystruct temp;temp = Thread[m + 1];Thread[m + 1] = Thread[next];Thread[next] = temp;}int count = 0;cout << "==========================短作业优先算法调度==========================" << endl;cout << "作业号" << "\t" << "提交时间" << "\t" << "运⾏时间" << "\t" << "开始时间" << "\t" << "等待时间" << "\t" << "完成时间" << "\t" << "周转时间" << " \t" << "带权周转时间" << endl;for (int i = 0; i < N; i++){count++;if (count == 1){Thread[i].starttime = Thread[i].arrivetime;Thread[i].endtime = Thread[i].starttime + Thread[i].runtime;Thread[i].waittime = Thread[i].starttime - Thread[i].arrivetime;Thread[i].turnaroundtime = Thread[i].endtime - Thread[i].arrivetime;Thread[i].rightturnaroundtime = Thread[i].turnaroundtime / Thread[i].runtime;cout << count << "\t" << Thread[i].arrivetime << "\t\t" << Thread[i].runtime << "\t\t" << Thread[i].starttime << "\t\t" << Thread[i].waittime << "\t\t" << Thread[i].endtime << "\t\t" << Thread[i].turnaroundtime << "\t\t" << Thread[i].rightturnaroundtime << endl;}else{Thread[i].starttime = Thread[i - 1].starttime + Thread[i - 1].runtime;if (Thread[i].starttime < Thread[i].arrivetime){Thread[i].starttime = Thread[i].arrivetime;}Thread[i].endtime = Thread[i].starttime + Thread[i].runtime;Thread[i].waittime = Thread[i].starttime - Thread[i].arrivetime;Thread[i].turnaroundtime = Thread[i].endtime - Thread[i].arrivetime;Thread[i].rightturnaroundtime = Thread[i].turnaroundtime / Thread[i].runtime;avewaittime += Thread[i].waittime; aveturnaroundtime += Thread[i].turnaroundtime; averightturnaroundtime += Thread[i].rightturnaroundtime;cout << count << "\t" << Thread[i].arrivetime << "\t\t" << Thread[i].runtime << "\t\t" << Thread[i].starttime << "\t\t" << Thread[i].waittime << "\t\t" << Thread[i].endtime << "\t\t" << Thread[i].turnaroundtime << "\t\t" << Thread[i].rightturnaroundtime << endl;}}cout << "平均等待时间:" << avewaittime / N << "\t" << "平均周转时间:" << aveturnaroundtime / N << "\t" << "平均带权周转时间:" << averightturn aroundtime / N << endl;}void HRRN(struct Mystruct Thread[]){int count = 0;float avewaittime = 0, aveturnaroundtime = 0, averightturnaroundtime = 0;cout << "==========================⾼响应⽐算法调度==========================" << endl;cout << "作业号" << "\t" << "提交时间" << "\t" << "运⾏时间" << "\t" << "开始时间" << "\t" << "等待时间" << "\t" << "完成时间" << "\t" << "周转时间" << "\t" << "带权周转时间" << endl;for (int i = 0; i < N; i++){count++;if (count == 1)Thread[i].starttime = Thread[i].arrivetime; else Thread[i].starttime = Thread[i - 1].starttime + Thread[i - 1].runtime;if (Thread[i].starttime < Thread[i].arrivetime){Thread[i].starttime = Thread[i].arrivetime;}Thread[i].endtime = Thread[i].starttime + Thread[i].runtime;RRsort(i);//找出处在等待的最⼩响应⽐的进程下次运⾏Thread[i].waittime = Thread[i].starttime - Thread[i].arrivetime;Thread[i].turnaroundtime = Thread[i].endtime - Thread[i].arrivetime;Thread[i].rightturnaroundtime = Thread[i].turnaroundtime / Thread[i].runtime;avewaittime += Thread[i].waittime; aveturnaroundtime += Thread[i].turnaroundtime; averightturnaroundtime += Thread[i].rightturnaroundtime;cout << count << "\t" << Thread[i].arrivetime << "\t\t" << Thread[i].runtime << "\t\t" << Thread[i].starttime << "\t\t" << Thread[i].waittime << "\t\t" << T hread[i].endtime << "\t\t" << Thread[i].turnaroundtime << "\t\t" << Thread[i].rightturnaroundtime << endl;}cout << "平均等待时间:" << avewaittime / N << "\t" << "平均周转时间:" << aveturnaroundtime / N << "\t" << "平均带权周转时间:" << averightturn aroundtime / N << endl;}int main() {srand((int)time(0));for (int i = 0; i < N; i++) {Thread[i].arrivetime = rand() % 20;Thread[i].runtime = rand() % 20 + 1;}FCFS();SJF(Thread);HRRN(Thread);return 0;}五、实验总结通过本次实验我更加了解了先来先服务算法、短作业优先算法、⾼响应⽐算法,通过带权周转时间的计算知道了FCFS算法对长作业有利,对短作业不利,SJF算法对短作业有利,对长作业不利,在所有进程同时可运⾏是采⽤SJF算法的平均等待时间、平均周转时间最少。
高响应比调度算法(c语言程序实现)
ame,&p[i].arrivetime,&p[i].servicetime);}}void Print(struct zgxyb *p,float arrivetime,float servicetime,float starttime,float finishtime,float zztime,float dqzztime,int N){int k;printf("run order:");printf("%s",p[0].name);for(k=1;k<N;k++){printf("-->%s",p[k].name);}printf("\nthe process's information:\n");printf("\nname\tarrive\tservice\tstart\tfinish\tzz\tdqzz\n");for(k=0;k<=N-1;k++){ printf("%s\t%\t%\t%\t%\t%\t%\t\n",p[k].name,p[k].arrivetime,p[k].servicetime,p[k].starttime,p[ k].finishtime,p[k].zztime,p[k].dqzztime);}}rrivetime<p[j].arrivetime){struct zgxyb temp;temp=p[i];p[i]=p[j];p[j]=temp;}}tarttime=p[k].arrivetime;p[k].finishtime=p[k].arrivetime+p[k].servicetime;}else{p[k].starttime=p[k-1].finishtime;p[k].finishtime=p[k-1].finishtime+p[k].servicetime;}}for(k=0;k<=N-1;k++){p[k].zztime=p[k].finishtime-p[k].arrivetime;p[k].dqzztime=p[k].zztime/p[k].servicetime;}}void ZGXYB(struct zgxyb *p,int N){float arrivetime=0,servicetime=0,starttime=0,finishtime=0,zztime=0,dqzztime=0; int m,i,n,follow,k;float max;struct zgxyb temp;sort(p,N);for(m=0;m<N-1;m++){if(m==0)p[m].finishtime=p[m].arrivetime+p[m].servicetime;elsep[m].finishtime=p[m-1].finishtime+p[m].servicetime;i=0;for(n=m+1;n<=N-1;n++){if(p[n].arrivetime<=p[m].finishtime)i++;}max=(p[m].finishtime-p[m+1].arrivetime)/p[m+1].servicetime;follow=m+1;for(k=m+1;k<m+i;k++)inishtime-p[k+1].arrivetime)/p[k+1].servicetime){max=(p[m].finishtime-p[k+1].arrivetime)/p[k+1].servicetime;follow=k+1;}}temp=p[m+1];p[m+1]=p[follow];p[follow]=temp;}deal(p,arrivetime,servicetime,starttime,finishtime,zztime,dqzztime,N);Print(p,arrivetime,servicetime,starttime,finishtime,zztime,dqzztime,N);}void main(){ int N;struct zgxyb *c;printf("------高响应比调度算法------\n");printf("input the process's number:\n");scanf("%d",&N);input(a,N);c=a; ZGXYB(c,N); }。
最高优先数优先”调度算法
#include "stdio.h"
#define getpcb(type)(type*)malloc(sizeof(type))
#define NULL 0
struct pcb
{
char name[10];
char state;
int super;
int ntime;
int rtime;
while(pr!=NULL)
{
disp(pr);
pr=pr->link;
}
}
disp(pr)
PCB *pr;
{
printf("\nqname\tstate\tsuper\tdtime\truntime\n");
printf("%s\t",pr->name);
printf("%c\t",pr->state);
struct pcb*link;
} *ready=NULL,*p;
typedef struct pcb PCB;
main()
{
int len,h=0;
char c;
input();
len=space();
while( (len!=0)&&(ready!=NULL) )
{
c=getchar();
h++;
优先级调度算法短作业优先调度算法线性优先级调度算法进程调度算法时间片轮转调度算法调度算法磁盘调度算法作业调度算法cpu调度算法表调度算法
实验要求:编写并调试一个模拟的进程调度程序,采用“最高优先数优先”调度算法对五个进程进行调度
设计思想:
高响应比调度算法
高响应比调度算法1.计算响应比:每个进程的响应比定义为(等待时间+服务时间)/服务时间。
等待时间是指进程已经等待的时间,服务时间是指进程已经运行的时间。
2.选择响应比最高的进程:从就绪队列中选择响应比最高的进程,即响应比最大的进程。
3.执行进程:执行选择的进程,直至进程完成或者被阻塞。
4.更新等待时间:当进程进入等待状态时,更新等待时间。
5.重复执行以上步骤直至所有进程完成。
```c#include <stdio.h>//进程结构体typedef structint process_id; // 进程号int response_ratio; // 响应比} Process;//计算第一个进程的等待时间for (int i = 1; i < n; i++)//计算进程的等待时间//计算总的等待时间//更新响应比}void high_response_ratio_scheduling(Process *processes, int n)Process selected_process;while (1)int max_response_ratio = 0;int selected_process_index = -1;//选择响应比最高的进程for (int i = 0; i < n; i++)max_response_ratio = processes[i].response_ratio;selected_process_index = i;}}//如果没有进程可以选择,跳出循环if (selected_process_index == -1)break;}selected_process = processes[selected_process_index];//执行进程printf("正在执行进程 %d\n", selected_process.process_id); //更新状态}int mai//进程数int n = 3;//进程数组Process processes[n];//初始化进程信息processes[0].process_id = 1;processes[1].process_id = 2;processes[2].process_id = 3;//计算等待时间和响应比//高响应比调度high_response_ratio_scheduling(processes, n);return 0;```总结:高响应比调度算法是一种有效的实时调度算法,能够提高系统的响应速度和效率。
高响应比优先调度算法HRRN
作业号
到达时刻服务时间(分钟)1
8:001202
8:50503
9:00104
9:5020⾼响应⽐优先调度算法HRRN
计算在单CPU 环境下,采⽤⾼响应⽐优先调度算法时的平均周转时间和平均带权周转时间,并指出它们的调度顺序。
⾼响应⽐优先调度算法:
等待时间=上⼀个的完成时间-该作业到达的时刻
响应⽐=(等待时间+服务时间)/服务时间=等待时间/服务时间+1
第⼀轮(作业1的完成时间10:00)
作业2 等待时间:10:00-8:50=70(分钟) 响应⽐ :(70+50)/50=2.4
作业3 等待时间:10:00-9:00=60(分钟) 响应⽐ :(60+10)/10=7
作业4 等待时间:10:00-9:50=10(分钟) 响应⽐ :(10+20)/20=1.5
所以最先执⾏3
第⼆轮(作业3的完成时间10:10)
作业2 等待时间:10:10-8:50=80(分钟) 响应⽐:(80+50)/50=2.6
作业4 等待时间: 10:10-9:50=20(分钟) 响应⽐ :(20+20)/20=2
所以先执⾏2
作业号到达时刻服务时间
(分钟)
开始时间完成时间周转时间(分钟)带权周转时间(分钟)
1
8:001208:0010:0012012
8:505010;1011:00130 2.63
9:001010:0010:1070749:502011:0010:2090 4.5
平均周转时间: (120+130+70+90)/4=102.5(分钟)
平均带权周转时间: (1+2.6+7+4.5)/4=3.775(分钟)
调度顺序: 1 、 3 、2 、 4。
hrn调度算法
hrn调度算法
HRN (Highest Response Ratio Next) 调度算法是一种用于作业调度的优先级算法。
它基于作业的响应比来确定下一个要执行的作业,响应比越高的作业具有更高的优先级。
HRN 调度算法的核心思想是综合考虑作业的等待时间和作业的服务时间。
HRN 调度算法的计算公式如下:
响应比 = (等待时间 + 服务时间) / 服务时间
具体步骤如下:
初始化作业队列,将所有待执行的作业加入队列。
遍历作业队列,对每个作业计算其响应比。
计算公式为:响应比 = (等待时间 + 服务时间) / 服务时间,其中等待时间为当前时间减去作业的到达时间。
选择具有最高响应比的作业作为下一个要执行的作业。
执行选定的作业,更新等待时间和服务时间。
重复步骤2至步骤4,直到所有作业执行完毕。
HRN 调度算法的优点是能够兼顾短作业和长作业的服务时间,以及作业的等待时间。
相对于其他调度算法,它能够更好地避免长作业的饥饿现象。
然而,HRN 调度算法也有一些限制,例如可能存在计算和比较响应比的开销,以及可能对于执行时间较长的作业产生不公平性。
需要注意的是,HRN 调度算法是一种静态优先级算法,即在调度前作业的优先级就已经确定。
在实际应用中,可以根据具体的需求和系统性能进行调整和改进。
响应比最高者优先算法
响应比最高者优先算法响应比最高者优先算法(Response Ratio Highest First, RRHF)是一种常用的调度算法,它根据任务的相应时间和执行时间来确定任务的优先级,以此来决定任务的执行顺序。
这种算法能够充分利用系统资源,提高系统的效率和响应性。
简单来说,响应比是指任务等待时间与执行时间的比值。
任务的等待时间是指任务开始执行前所等待的时间,执行时间是指任务需要执行的时间。
响应比越高,表示任务的等待时间相对较长,需要优先处理。
1.计算每个任务的等待时间和执行时间,得到每个任务的响应比。
响应比(Respose Ratio)=(等待时间 + 执行时间)/ 执行时间。
2.选择响应比最高的任务作为当前要执行的任务。
在初始时,会选择一个任务作为初始任务。
3.执行选中的任务,直至完成。
4.更新剩余任务的等待时间,即等待时间=等待时间+执行时间。
5.计算更新后的任务的响应比。
6.重复步骤2至5,直至所有任务被执行完毕。
以一个具体的例子来说明这个算法:假设有三个任务,它们的执行时间分别为5秒、10秒和20秒。
初始任务为任务11.计算每个任务的响应比:任务1:(0+5)/5=1任务2:(0+10)/10=1任务3:(0+20)/20=12.选择响应比最高的任务,即任务13.执行任务14.更新剩余任务的等待时间:任务2:等待时间=0+5=5任务3:等待时间=0+5=55.计算更新后的任务的响应比:任务2:(5+10)/10=1.5任务3:(5+20)/20=1.256.选择响应比最高的任务,即任务27.执行任务28.更新剩余任务的等待时间:任务3:等待时间=0+10=109.计算更新后的任务的响应比:任务3:(10+20)/20=1.510.选择响应比最高的任务,即任务311.执行任务312.所有任务执行完毕。
然而,该算法也存在一些缺点。
首先,它可能会导致任务的饥饿问题,即一些长任务可能永远得不到执行。
源程序-进程调度模拟设计-优先级法、最高响应比优先调度算法
#include<iostream>#include<stdio.h>#include<math.h>using namespace std;struct prigle{float prii; //记录进程优先级或者响应比int num; //作用一:定位进程,作用二,标记进程是否运行};struct elment{char name[10]; //进程的名称prigle pri;int hour; //进程提交的时间(小时)int min; //进程提交(分钟)int time; //进程运行需要的时间int time1; //记录进程开始运行的时间int test; // 进程是否在等待的判断位};elment e[10];int all=0;int a[10];int a1[10];int or;void input() //输入进程信息{while(1){int d=0;cout<<"请输入第"<<all+1<<"个进程的名称,";if(or==1)cout<<"优先级,";cout<<"到达时间,运行时间"<<endl;scanf("%s",e[all].name);if(or==1)cin>>e[all].pri.prii;else e[all].pri.prii=0.0;fflush(stdin);char t[5];scanf("%s",&t);d=(t[0]-48)*10+(t[1]-48);if(d>24||d<0){cout<<"输入有误,请重新输入"<<endl;continue;}e[all].pri.num=all;e[all].hour=d;d=(t[3]-48)*10+(t[4]-48);e[all].min=d;e[all].test=0;cin>>e[all].time;e[all].time1=e[all].hour*60+e[all].min;all++;int test1;cout<<endl;cout<<"是否继续输入,继续输入请按1,否则按其他键"<<endl;cin>>test1;if(test1!=1)break;}}void Getpriorder() //按优先级从大小排列进程{elment e0[10];for(int j=0;j<all;j++)e0[j]=e[j];for(int k=0;k<all;k++){elment temp;temp.pri.prii=0;for(int h=0;h<all;h++)if(e0[h].pri.prii>temp.pri.prii)temp=e0[h];a[k]=temp.pri.num;e0[a[k]].pri.prii=-1;}}void HRN() //最高响应比算法{int n=0;while(1){elment temp;for(int ii=0;ii<all;ii++)if(e[ii].pri.num!=-1){temp=e[ii];break;}for(int i=0;i<all;i++){if(e[i].pri.num==-1)continue;if(temp.time1>e[i].time1)temp=e[i];}a1[n]=temp.pri.num;temp.pri.num=-1;e[a1[n++]].pri.num=-1;for(int j=0;j<all;j++){for(int k=0;k<all;k++){if(e[k].pri.num==-1)continue;if(e[k].time1<(temp.time1+temp.time)){e[k].time1=temp.time1+temp.time;e[k].test=1;}}for(int kk=0;kk<all;kk++){if(e[kk].pri.num==-1)continue;else if(e[kk].test==0)continue;else{temp=e[kk];break;}}if(temp.pri.num==-1)break;for(int t=0;t<all;t++){if(e[t].pri.num==-1)continue;e[t].pri.prii=float((e[t].time1-e[t].hour*60-e[t].min))/float(e[t].time);}for(int h=0;h<all;h++){if(e[h].pri.num==-1)continue;if(temp.pri.prii<e[h].pri.prii)temp=e[h];}a1[n]=temp.pri.num;temp.pri.num=-1;e[a1[n++]].pri.num=-1;}if(n==all)break;}}void Getorder() //与void Getpriorder() 连用,完成优先级算法{int n=0;while(1){elment temp;for(int jj=0;jj<all;jj++)if(e[jj].pri.num!=-1)temp=e[jj];for(int i=0;i<all;i++)if(e[i].pri.num!=-1)if(temp.time1>e[i].time1)temp=e[i];a1[n]=temp.pri.num;e[a1[n++]].pri.num=-1;for(int k=0;k<all;k++){if(e[k].pri.num==-1)continue;if(e[k].time1<(e[a1[0]].time1+e[a1[0]].time)){e[k].test=1;e[k].time1=e[a1[0]].time1+e[a1[0]].time;}}for(int h=0;h<all-1;h++){for(int count=0;count<all;count++)if(e[count].pri.num!=-1)if((e[count].hour*60+e[count].min)<(temp.time1+temp.time))e[count].test=1;for(int t=0;t<all;t++){if(e[a[t]].pri.num==-1)continue;if(e[a[t]].test==1){temp=e[a[t]];a1[n++]=temp.pri.num;e[a[t]].pri.num=-1;break;}}for(int r=0;r<all;r++){if(e[r].pri.num==-1)continue;if(e[r].time1<(temp.time1+temp.time))e[r].time1=temp.time1+temp.time;}}if(n==all)break;}}void output(){cout<<"*********************************"<<endl;cout<<"进程调度详情如下所示"<<endl;cout<<"进程名称";if(or==1)cout<<"优先级";cout<<"到达时间"<<"开始时间"<<"结束时间"<<"运行时间"<<"周转时间"<<"带周转时间"<<endl;float etime=0.0;float etime1=0.0;for(int i=0;i<all;i++){cout<<" "<<e[a1[i]].name<<'\t'<<" ";if(or==1) cout<<e[a1[i]].pri.prii<<'\t'<<" ";/* if(e[a1[i]].hour<10)cout<<"0"<<e[a1[i]].hour<<":";if(e[a1[i]].min<10)cout<<"0"<<e[a1[i]].min<<" ";else cout<<e[a1[i]].min<<" ";*/if(e[a1[i]].hour<10)cout<<"0"<<e[a1[i]].hour<<":";else cout<<e[a1[i]].hour<<":";if(e[a1[i]].min<10)cout<<"0"<<e[a1[i]].min<<" ";else cout<<e[a1[i]].min<<" ";if(e[a1[i]].time1/60<10)cout<<"0"<<e[a1[i]].time1/60<<":";else cout<<e[a1[i]].time1/60<<":";if(e[a1[i]].time1%60<10)cout<<"0"<<e[a1[i]].time1%60<<'\t';else cout<<e[a1[i]].time1%60<<'\t';if((e[a1[i]].time1/60+e[a1[i]].time)<10)cout<<"0"<<(e[a1[i]].time1+e[a1[i]].time)/60<<":";else cout<<(e[a1[i]].time1+e[a1[i]].time)/60<<":";if((e[a1[i]].time1+e[a1[i]].time)%60<10)cout<<"0"<<(e[a1[i]].time1+e[a1[i]].time)%60<<'\t' <<" ";else cout<<(e[a1[i]].time1+e[a1[i]].time)%60<<'\t'<<" ";cout<<e[a1[i]].time<<'\t'<<" ";int zhou=e[a1[i]].time1-e[a1[i]].hour*60-e[a1[i]].min+e[a1[i]].time;cout<<zhou<<" "<<'\t'<<" ";float zhou1=float(zhou)/float(e[a1[i]].time);etime1+=zhou1;cout<<zhou1<<endl;etime+=float(e[a1[i]].time1-e[a1[i]].hour*60-e[a1[i]].min+e[a1[i]].time);}cout<<"平均周转时间:"<<etime/all<<"(minute)"<<endl;cout<<"平均带权周转时间:"<<etime1/all<<"(minute)"<<endl;cout<<"*********************************"<<endl;}int main(){while(1){all=0;while(1){cout<<"选择调度方法:"<<endl<<"1,优先级法"<<endl;cout<<"2,最高响应比!"<<endl;cin>>or;if(or==1){cout<<"您选择的是:优先级法"<<endl;break;}else if(or==2){cout<<"您选择的是:最高响应比法"<<endl;break;}}input();if(or==1){Getpriorder();Getorder();}else HRN();output();int yesorno;cout<<"继续请按1,否则请按其它数字"<<endl;cin>>yesorno;if(yesorno!=1)break;}return 0;}。
操作系统各种调度算法
操作系统各种调度算法⼀、批处理作业调度算法1.先来先服务调度算法First Come,First Served.(FCFS):就是按照各个作业进⼊系统的⾃然次序来调度作业。
这种调度算法的优点是实现简单,公平。
其缺点是没有考虑到系统中各种资源的综合使⽤情况,往往使短作业的⽤户不满意,因为短作业等待处理的时间可能⽐实际运⾏时间长得多。
2.短作业优先调度算法shortest job first(SPF): 就是优先调度并处理短作业,所谓短是指作业的运⾏时间短。
⽽在作业未投⼊运⾏时,并不能知道它实际的运⾏时间的长短,因此需要⽤户在提交作业时同时提交作业运⾏时间的估计值。
3.最⾼响应⽐优先算法Hightest response-radio next(HRN):FCFS可能造成短作业⽤户不满,SPF可能使得长作业⽤户不满,于是提出HRN,选择响应⽐最⾼的作业运⾏。
响应⽐=1+作业等待时间/作业处理时间。
4. 基于优先数调度算法Highest Possible Frequency(HPF):每⼀个作业规定⼀个表⽰该作业优先级别的整数,当需要将新的作业由输⼊井调⼊内存处理时,优先选择优先数最⾼的作业。
5.均衡调度算法,即多级队列调度算法基本概念:作业周转时间(Ti)=完成时间(Tei)-提交时间(Tsi)作业平均周转时间(T)=周转时间/作业个数作业带权周转时间(Wi)=周转时间/运⾏时间响应⽐=(等待时间+运⾏时间)/运⾏时间⼆、进程调度算法1.先进先出算法(FIFO):按照进程进⼊就绪队列的先后次序来选择。
即每当进⼊进程调度,总是把就绪队列的队⾸进程投⼊运⾏。
2. 时间⽚轮转算法Round Robin(RR):分时系统的⼀种调度算法。
轮转的基本思想是,将CPU的处理时间划分成⼀个个的时间⽚,就绪队列中的进程轮流运⾏⼀个时间⽚。
当时间⽚结束时,就强迫进程让出CPU,该进程进⼊就绪队列,等待下⼀次调度,同时,进程调度⼜去选择就绪队列中的⼀个进程,分配给它⼀个时间⽚,以投⼊运⾏。
进程调度算法--最高响应比调度算法
#include "stdio.h"struct zgxyb{char name[10];float arrivetime;float servicetime;float starttime;float finishtime;float zztime;float dqzztime;};zgxyb a[100];void input(zgxyb *p,int N){ int i;printf("intput the process's name & arrivetime & servicetime:\nfor exmple: a 0 100\n");for(i=0;i<=N-1;i++){printf("input the %dth process's information:\n",i+1);scanf("%s%f%f",&p[i].name,&p[i].arrivetime,&p[i].servicetime);}}void Print(zgxyb *p,float arrivetime,float servicetime,float starttime,float finishtime,float zztime,float dqzztime,int N){int k;printf("run order:");printf("%s",p[0].name);for(k=1;k<N;k++){printf("-->%s",p[k].name);}printf("\nthe process's information:\n");printf("\nname\tarrive\tservice\tstart\tfinish\tzz\tdqzz\n");for(k=0;k<=N-1;k++){ printf("%s\t%-.2f\t%-.2f\t%-.2f\t%-.2f\t%-.2f\t%-.2f\t\n",p[k].name,p[k] .arrivetime,p[k].servicetime,p[k].starttime,p[k].finishtime,p[k].zztime,p[k].dq zztime);}}//按到达时间排序void sort(zgxyb *p,int N){for(int i=0;i<=N-1;i++)for(int j=0;j<=i;j++)if(p[i].arrivetime<p[j].arrivetime){zgxyb temp;temp=p[i];p[i]=p[j];p[j]=temp;}}//yun xing jieduanvoid deal(zgxyb *p,float arrivetime,float servicetime,float starttime,float finishtime,float &zztime,float &dqzztime,int N){ int k;for(k=0;k<=N-1;k++){if(k==0){p[k].starttime=p[k].arrivetime;p[k].finishtime=p[k].arrivetime+p[k].servicetime;}else{p[k].starttime=p[k-1].finishtime;p[k].finishtime=p[k-1].finishtime+p[k].servicetime;}}for(k=0;k<=N-1;k++){p[k].zztime=p[k].finishtime-p[k].arrivetime;p[k].dqzztime=p[k].zztime/p[k].servicetime;}}void ZGXYB(zgxyb *p,int N){floatarrivetime=0,servicetime=0,starttime=0,finishtime=0,zztime=0,dqzztime=0; sort(p,N);for(int m=0;m<N-1;m++){if(m==0)p[m].finishtime=p[m].arrivetime+p[m].servicetime;elsep[m].finishtime=p[m-1].finishtime+p[m].servicetime;int i=0,n;for(n=m+1;n<=N-1;n++){if(p[n].arrivetime<=p[m].finishtime)i++;}float max=(p[m].finishtime-p[m+1].arrivetime)/p[m+1].servicetime;//第m+1个的响应比int follow=m+1;for(int k=m+1;k<m+i;k++){if(max<=(p[m].finishtime-p[k+1].arrivetime)/p[k+1].servicetime) {max=(p[m].finishtime-p[k+1].arrivetime)/p[k+1].servicetime;follow=k+1;}}zgxyb temp;temp=p[m+1];p[m+1]=p[follow];p[follow]=temp;}deal(p,arrivetime,servicetime,starttime,finishtime,zztime,dqzztime,N); Print(p,arrivetime,servicetime,starttime,finishtime,zztime,dqzztime,N); }void main(){ int N;printf("------高响应比调度算法------\n");printf("input the process's number:\n");scanf("%d",&N);input(a,N);zgxyb *c=a;ZGXYB(c,N);}。
高响应比调度算法
高响应比调度算法一、概述高响应比调度算法是一种基于进程响应时间的优先级调度算法,其目的是尽可能地减少平均等待时间和最大响应时间。
在该算法中,系统会根据进程的等待时间和需要运行的时间来计算出每个进程的响应比,然后按照响应比从高到低的顺序进行调度。
二、计算公式在高响应比调度算法中,每个进程的优先级(即响应比)都是根据以下公式计算出来的:R = (W + S) / S其中,R表示进程的响应比,W表示进程已经等待了多久,S表示进程需要运行的总时间。
三、实现过程1. 将所有就绪队列中等待时间超过一个时钟周期的进程加入到一个新队列中。
2. 计算新队列中每个进程的响应比,并按照从高到低的顺序排序。
3. 选择具有最高优先级(即最高响应比)的进程进行执行。
4. 如果当前正在执行的进程仍然需要继续执行,则将其放回就绪队列,并回到第1步;否则,将其从系统中删除。
四、优缺点分析1. 优点:(1)能够尽可能地减少平均等待时间和最大响应时间,提高系统的响应速度和吞吐量。
(2)能够避免饥饿现象,即长时间等待的进程不会被无限期地推迟执行。
(3)能够适应不同类型的进程,包括短作业和长作业。
2. 缺点:(1)计算响应比需要消耗一定的计算资源,可能会影响系统的性能。
(2)如果一个进程需要运行的时间很长,那么其响应比将会非常低,导致该进程被无限期地推迟执行。
五、适用场景高响应比调度算法适用于需要快速响应用户请求的系统,例如Web服务器、数据库服务器等。
在这些系统中,用户需要尽快得到反馈,并且对于每个请求来说,执行时间也相对较短。
此外,该算法还适用于多种类型的作业混合在一起的情况下。
但是,在长作业占主导地位的情况下,该算法可能不太适用。
六、总结高响应比调度算法是一种基于进程响应时间的优先级调度算法,在提高系统响应速度和吞吐量方面具有显著优势。
虽然该算法计算响应比需要消耗一定的计算资源,但是在适用场景下,其优点明显,能够提高系统的性能和用户体验。
高响应比调度算法(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 zgxyb a[100];void input(struct zgxyb *p,int N){ int i;printf("intput the process's name & arrivetime & servicetime:\nfor exmple: a 0 100\n");for(i=0;i<=N-1;i++){printf("input the %dth process's information:\n",i+1);scanf("%s%f%f",&p[i].name,&p[i].arrivetime,&p[i].servicetime);}}void Print(struct zgxyb *p,float arrivetime,float servicetime,float starttime,float finishtime,float zztime,float dqzztime,int N){int k;printf("run order:");printf("%s",p[0].name);for(k=1;k<N;k++){printf("-->%s",p[k].name);}printf("\nthe process's information:\n");printf("\nname\tarrive\tservice\tstart\tfinish\tzz\tdqzz\n");for(k=0;k<=N-1;k++){ printf("%s\t%-.2f\t%-.2f\t%-.2f\t%-.2f\t%-.2f\t%-.2f\t\n",p[k].name,p[k].arrivetime,p[k].serv icetime,p[k].starttime,p[k].finishtime,p[k].zztime,p[k].dqzztime);}}//按到达时间排序void sort(struct zgxyb *p,int N){int i,j;for(i=0;i<=N-1;i++)for(j=0;j<=i;j++)if(p[i].arrivetime<p[j].arrivetime){struct zgxyb temp;temp=p[i];p[i]=p[j];p[j]=temp;}}//yun xing jieduanvoid deal(struct zgxyb *p,float arrivetime,float servicetime,float starttime,float finishtime,float zztime,float dqzztime,int N){ int k;for(k=0;k<=N-1;k++){if(k==0){p[k].starttime=p[k].arrivetime;p[k].finishtime=p[k].arrivetime+p[k].servicetime;}else{p[k].starttime=p[k-1].finishtime;p[k].finishtime=p[k-1].finishtime+p[k].servicetime;}}for(k=0;k<=N-1;k++){p[k].zztime=p[k].finishtime-p[k].arrivetime;p[k].dqzztime=p[k].zztime/p[k].servicetime;}}void ZGXYB(struct zgxyb *p,int N){float arrivetime=0,servicetime=0,starttime=0,finishtime=0,zztime=0,dqzztime=0;int m,i,n,follow,k;float max;struct zgxyb temp;sort(p,N);for(m=0;m<N-1;m++){if(m==0)p[m].finishtime=p[m].arrivetime+p[m].servicetime;elsep[m].finishtime=p[m-1].finishtime+p[m].servicetime;i=0;for(n=m+1;n<=N-1;n++){if(p[n].arrivetime<=p[m].finishtime)i++;}max=(p[m].finishtime-p[m+1].arrivetime)/p[m+1].servicetime;follow=m+1;for(k=m+1;k<m+i;k++)//从第二个开始排序{if(max<=(p[m].finishtime-p[k+1].arrivetime)/p[k+1].servicetime) {max=(p[m].finishtime-p[k+1].arrivetime)/p[k+1].servicetime;follow=k+1;}}temp=p[m+1];p[m+1]=p[follow];p[follow]=temp;}deal(p,arrivetime,servicetime,starttime,finishtime,zztime,dqzztime,N);Print(p,arrivetime,servicetime,starttime,finishtime,zztime,dqzztime,N); }void main(){ int N;struct zgxyb *c;printf("------高响应比调度算法------\n");printf("input the process's number:\n");scanf("%d",&N);input(a,N);c=a;ZGXYB(c,N);}。
操作系统高响应比优先模拟算法
操作系统⾼响应⽐优先模拟算法 这学期刚开始学习操作系统,收到⼀个作业,百度关于⾼响应⽐优先(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()的⼀些情况:1int main(int argc, char** argv){ ////argc为参数个数, argv为接下来传的参数2 ...3return0;4 }⽐如在命令⾏中调⽤该函数,***.exe 100,此时有两个参数,⼀个为"***.exe",另⼀个就是"100"了,分别在argv[0]和argv[1]中。
操作系统HRRN高响应比优先级调度算法(C++实现)
操作系统HRRN⾼响应⽐优先级调度算法(C++实现)1. 算法性质 HRRN算法既考虑了作业的等待时间,⼜考虑作业的运⾏时间,因此既照顾了短作业,⼜不致使长作业的等待时间过长,从⽽改善了处理机调度的性能。
2. 实现⽅法 我们为每个作业引⼊⼀个动态优先级,即优先级会随着时间的增加⽽动态增加,这样使得长作业的优先级在等待期间不断地增加,等到⾜够时间后,必然有机会获得处理机。
优先级算法描述为:优先权(Rp) = (等待时间 + 要求服务时间)/ 要求服务时间周转时间:周转时间(WT) = 作业完成时间 - 作业到达时间带权周转时间:带权周转时间(WWT) = 周转时间 / 服务时间平均周转时间:平均周转时间(AWT) = 作业周转总时间 / 作业个数平均带权周转时间:平均带权周转时间(AWWT) = 带权周转总时间 / 作业个数3. 算法优点如果作业的等待时间相同,则要求服务的时间越短,其优先级越⾼,因⽽类似于SJF算法,有利于短作业。
当要求服务的时间相同时,作业的优先权⼜决定于其等待时间,因⽽有类似于FCFS算法。
对于长作业的优先级,可以随等待时间增加⽽提⾼,当其等待时间⾜够长时,也可以获得处理机。
4. 实现代码 4.1 HRRN实现函数1//HRRN⾼相应⽐优先级调度算法2void HRRN( vector<int> T, vector<double> S, vector<int> &FT, vector<int> &WT3 , vector<double> &WWT){4int CurTime = 0, temp = 0, length = T.size();5 vector<bool> Finished(length, 1);6 vector<double> Rp(length, 0); //优先级7for(int i = 0; i < length; i ++){8//迭代计算未进⾏进程的全部优先级9for( int i = 0; i < length; i ++){10if( Finished[i] ){11 Rp[i] = ( abs(T[i] - CurTime) + S[i] ) / S[i];12if(Rp[i] > Rp[temp])13 temp = i; //寻找最⾼优先级14 }15 }16//输出当前时间进程状态17while( CurTime < T[temp] ){18 printf( "Time %d : No Program is Running.\n", CurTime );19 CurTime ++;20 }21for(int t = 1; t <= S[temp]; t ++){22 CurTime += 1;23 printf( "Time %d : Program %d is Running.\n",CurTime,temp );24 }25 printf( "Time %d : Program %d is already done.\n",CurTime + 1,temp );26 FT[temp] = CurTime; WT[temp] = CurTime - T[temp]; WWT[temp] = WT[temp] / S[temp];27//完成该进程后使其初始化。
最高响应比——精选推荐
最⾼响应⽐#include<stdio.h>#include<stdlib.h>#define N 100typedef struct process {int num;int time;int start;int end;int begin;int freetime;int arrivetime;int finish;int turn;double reaction;double average;}P;P a[N],b; int wordtime=0;void hrrn(int i,int j,int t,int n){a[0].finish=a[0].arrivetime+a[0].freetime;wordtime=a[0].finish;a[0].turn=a[0].time;a[0].average=(float)a[0].turn/a[0].time;for(i=1;i<n;i++) {for(j=i+1;j<n;j++) {if(a[j].arrivetime<=a[i-1].finish) {for(t=i;t<=j;t++) {a[t].reaction=(float)(a[t-1].finish-a[t].arrivetime+a[t].time)/a[t].time;if(a[t].reaction<a[j].reaction) {b=a[j];a[j]=a[t];a[t]=b;}}}} if(a[i].arrivetime<a[i-1].finish) {a[i].finish=a[i-1].finish+a[i].freetime;a[i].turn=a[i].finish-a[i].arrivetime;else {a[i].finish=a[i].arrivetime+a[i].freetime; a[i].turn=a[i].time;}a[i].average=(float)a[i].turn/a[i].time;wordtime=a[i].finish;}}void main() {int n=5,i,t,sum=0,num=2,j,x;double average=0,turn=0;printf("输⼊进程个数");scanf("%d",&n);for(i=0;i<n;i++){printf("\n");printf("输⼊第%d个进程到达时间:",i+1); scanf("%d",&a[i].arrivetime);printf("输⼊第%d个进程需要时间:",i+1); scanf("%d",&a[i].time);printf("\n");a[i].start=a[i].arrivetime;a[i].freetime=a[i].time;a[i].num=i+1;a[i].start=a[i].end=0; }for(i=0;i<n;i++) {for(t=i+1;t<n;t++) {if(a[t].arrivetime<a[i].arrivetime) {b=a[i];a[i]=a[t];a[t]=b;}elseif(a[t].arrivetime==a[i].arrivetime) {if(a[i].time>a[t].time) {b=a[i];a[i]=a[t];a[t]=b;}}}hrrn(i,j,t,n);printf("进程号\t完成时间\t周转时间\t带权周转时间\n");for(i=0;i<n;i++)printf("%d\t%d\t\t%d\t\t%.2f\n",a[i].num,a[i].finish,a[i].turn,a[i].average); for(i=0;i<n;i++) {turn=turn+(float)a[i].turn;average=average+(float)a[i].turn/a[i].time;} turn=turn/n;average=average/n;printf("平均周转时间\t平均带权周转时间\n");printf("%.2f\t\t%.2f\n",turn,average);}。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
实验四模拟处理机HRRN调度算法
一、实验目的:用c++设计HRRN调度算法程序。
二、实验内容:本实验随机输入的进程个数、进程名称、进程提交到系统的时间、进程运行所需时间。
通过模拟程序。
显示以下信息:
1)处理机对进程的调度过程。
2)计算这N个进程的平均周转时间。
三、HRRN(最高响应比调度算法)原理
最高响应比调度:在每次调度作业时,先计算后备队中每个作业的响应比,然后挑选响应比高者投入运行。
响应比R定义:
R=(w+S)/S
(R:响应比,W=等待时间,S=运行时间)
响应比R= 周转时间/ 运行时间
=(运行时间+ 等待时间)/ 运行时间
= 1 +(等待时间/ 运行时间)
四、示例
如:输入
进程个数:5
进程名称到达系统时间所需服务时间
A 0 3
B 2 6
C 4 4
D 6 5
E 8 2
显示运行结果:
进程名称到达系统时间所需服务时间开始时间结束时间
A 0 3 0 3
B 2 6 3 9
C 4 4 9 13
E 8 2 13 15
D 6 5 15 20 5个进程的平均周转时间:(3+7+9+7+14)/5=8
五、运行结果
六、代码
#include <stdio.h> #include <stdlib.h>
typedef struct Node {
char name[10];
int into;
int runtime;
int start;
int finish;
int status;
int hrrn;
int sum;
}Node;
int select(Node node[],int n) {
int i,flag=0;
for(i=0;i<n;i++)
{
if(0==node[i].status)
{
flag=1;
break;
}
}
if(1==flag)
return i;
else
return -1;
}
int compute(Node node,int t)
{
return (node.runtime+t-node.into)/node.runtime;
}
int main()
{
int n,i,j,max,t=0;
Node node[100];
printf("输入处理进程的个数:\n");
scanf("%d",&n);
getchar();
printf("进程名称到达系统时间所需服务时间\n");
for(i=0;i<n;i++)
{
scanf("%s",node[i].name);
scanf("%d",&node[i].into);
scanf("%d",&node[i].runtime);
getchar();
node[i].status=0;
if(0==i)
node[i].hrrn=0;
}
while(1)
{
int index;
index=select(node,n);
int flag=0;
if(index==-1)
break;
max=0;
for(i=0;i<n;i++)
{
if(node[i].into<=t&&0==node[i].status)
{
node[i].hrrn=compute(node[i],t);
if(0==i)
node[i].hrrn=0;
if(node[i].hrrn>node[max].hrrn)
max=i;
flag=1;
}
}
if(1==flag)
{
node[max].start=t;
t+=node[max].runtime;
node[max].status=1;
node[max].finish=t;
node[max].sum=node[max].finish-node[max].into;
}
else
{
t++;
}
}
for(i=0;i<n-1;i++)
{
for(j=i;j<n-1;j++)
{
if(node[j].finish>node[j+1].finish)
{
Node temp=node[j];
node[j]=node[j+1];
node[j+1]=temp;
}
}
}
printf("进程名称到达系统时间所需服务时间开始时间结束时间\n");
double sum=0;
for(i=0;i<n;i++)
{
printf("%s%12d%16d%12d%12d\n",node[i].name,node[i ].into,node[i].runtime,node[i].start,node[i].finish);
sum+=node[i].sum;
}
printf("平均周转时间:%.2lf\n",sum/n);
return 0;
}。