高响应比优先调度算法和短作业优先调度算法

简介: 高响应比优先调度算法和短作业优先调度算法

动态优先权是指在创建进程时所赋予的优先权,是可以随进程的推进或随其等待时间的增加而改变的,以便获得更好的调度性能。引入动态优先权,并使作业的优先权随其等待时间的增长,其优先权以速率a提高。优先权的变化规律可描述为:


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


本实验模拟了高响应比优先调度算法。

假如系统中现有3个作业,分别为A、B、C,它们的作业大小、需要磁带机数、需要打印机数,在外存上等待的时间以及估计需要执行时间分别是:

A 5 2 1 3 10

B 3 3 2 4 6

C 7 1 2 2 14

按高响应比优先算法,假如要选一个作业,你认为选择哪个作业进行调度? B


1.打开“Microsoft Visual C++ 6.0”,输入相关代码后,对程序行进编译运行后,将前述的三个作业A、B、C的相关数据依次输入,得到运行结果:

image.png


2.将程序改为短作业优先算法,给出程序修改位置以及所改代码:

修改位置

if(jobtable[p].length<=memory&&jobtable[p].tape<=tape&&jobtable[p].printer<=printer){
    xk=(float)(jobtable[p].waittime+jobtable[p].runtime)/jobtable[p].runtime;
    if(q==0||xk>k) {  
      k=xk;
      q=p;
      t=s;
    }
    }


所改代码

if(jobtable[p].length<=memory&&jobtable[p].tape<=tape&&jobtable[p].printer<=printer){
    xk=(float)(jobtable[p].runtime);
    if(q==0||xk<jobtable[p+1].runtime) {  
      k=xk;
      q=p;
      t=s;
    }
    }


3.短作业优先算法中输入相同的三个作业A、B、C的相关数据,得到运行结果:


——————————————————————————————————————————————————————————————————————————————————————

附上高响应比优先调度算法:


#include"string.h"
#define n 10
typedef struct jcb {
  char name[4];  
  int length;  
  int printer;  
  int tape;  
  int runtime;  
  int waittime;  
  int next;  
}JCB;
int head;
int tape,printer;
long memory;
JCB jobtable[n]; 
int jobcount=0;  
shedule(){
  float xk,k;
  int p,q,s,t;
  do{
  p=head;
  q=s=-1;
  k=0;
  while(p!=-1){
    if(jobtable[p].length<=memory&&jobtable[p].tape<=tape&&jobtable[p].printer<=printer){
    xk=(float)(jobtable[p].waittime+jobtable[p].runtime)/jobtable[p].runtime;
    if(q==0||xk>k) {  
      k=xk;
      q=p;
      t=s;
    }
    }
    s=p;
    p=jobtable[p].next; 
  } 
  if(q!=-1){
    if(t==-1)  
    head=jobtable[head].next;
  else
    jobtable[t].next=jobtable[q].next;   
  memory=memory-jobtable[q].length;
  tape=tape-jobtable[q].tape;  
  printer=printer-jobtable[q].printer;  
  printf("选中的作业的作业名: %s\n",jobtable[q].name);
  }
  } while(q!=-1);
}
void main(){
  char name[4];
  int size,tcount,pcount,wtime,rtime; 
  int p;
  memory=65536; 
  tape=4;
  printer=2;
  head=-1;
  printf("请输入作业相关数据(以作业大小为负数停止输入):\n");
  printf("输入作业名 作业大小 磁带机数 打印机数 等待时间 估计运行时间\n");
  scanf("%s %d %d %d %d %d",name,&size,&tcount,&pcount,&wtime,&rtime);
  while(size!=-1)
  {
  if(jobcount<n)
    p=jobcount;
  else
  {
    printf("无法在创建作业\n");
    break;
  }
   jobcount++;
   strcpy(jobtable[p].name,name);
   jobtable[p].length=size;
   jobtable[p].printer=pcount;
   jobtable[p].tape=tcount;
   jobtable[p].runtime=rtime;
   jobtable[p].waittime=wtime;
   jobtable[p].next=head;  
   head=p;   
   printf("输入作业名 作业大小 磁带机数 打印机数 等待时间 估计运行时间\n");
   scanf("%s %d %d %d %d %d",name,&size,&tcount,&pcount,&wtime,&rtime);
  }
  shedule(); 
  return;
}

附上短作业优先调度算法:


#include"string.h"
#define n 10
typedef struct jcb {
  char name[4];  
  int length;  
  int printer;  
  int tape;  
  int runtime;  
  int waittime;  
  int next;  
}JCB;
int head;
int tape,printer;
long memory;
JCB jobtable[n]; 
int jobcount=0;  
shedule(){
  float xk,k;
  int p,q,s,t;
  do{
  p=head;
  q=s=-1;
  k=0;
  while(p!=-1){
    if(jobtable[p].length<=memory&&jobtable[p].tape<=tape&&jobtable[p].printer<=printer){
    xk=(float)(jobtable[p].runtime);
    if(q==0||xk<jobtable[p+1].runtime) {  
      k=xk;
      q=p;
      t=s;
    }
    }
    s=p;
    p=jobtable[p].next; 
  } 
  if(q!=-1){
    if(t==-1)  
    head=jobtable[head].next;
  else
    jobtable[t].next=jobtable[q].next;   
  memory=memory-jobtable[q].length;
  tape=tape-jobtable[q].tape;  
  printer=printer-jobtable[q].printer;  
  printf("选中的作业的作业名: %s\n",jobtable[q].name);
  }
  } while(q!=-1);
}
void main(){
  char name[4];
  int size,tcount,pcount,wtime,rtime; 
  int p;
  memory=65536; 
  tape=4;
  printer=2;
  head=-1;
  printf("请输入作业相关数据(以作业大小为负数停止输入):\n");
  printf("输入作业名 作业大小 磁带机数 打印机数 等待时间 估计运行时间\n");
  scanf("%s %d %d %d %d %d",name,&size,&tcount,&pcount,&wtime,&rtime);
  while(size!=-1)
  {
  if(jobcount<n)
    p=jobcount;
  else
  {
    printf("无法在创建作业\n");
    break;
  }
   jobcount++;
   strcpy(jobtable[p].name,name);
   jobtable[p].length=size;
   jobtable[p].printer=pcount;
   jobtable[p].tape=tcount;
   jobtable[p].runtime=rtime;
   jobtable[p].waittime=wtime;
   jobtable[p].next=head;  
   head=p;   
   printf("输入作业名 作业大小 磁带机数 打印机数 等待时间 估计运行时间\n");
   scanf("%s %d %d %d %d %d",name,&size,&tcount,&pcount,&wtime,&rtime);
  }
  shedule(); 
  return;
}


目录
相关文章
|
8月前
|
监控 算法 机器人
软件体系结构 - 调度算法(2) 最低松弛度优先
【4月更文挑战第19天】软件体系结构 - 调度算法(2) 最低松弛度优先
260 0
|
8月前
|
存储 人工智能 算法
图与树的遍历:探索广度优先、深度优先及其他遍历算法的原理与实现
图与树的遍历:探索广度优先、深度优先及其他遍历算法的原理与实现
502 0
|
8月前
|
监控 算法 自动驾驶
软件体系结构 - 调度算法(1) 最早截至时间优先
【4月更文挑战第19天】软件体系结构 - 调度算法(1) 最早截至时间优先
420 0
|
7月前
|
算法 Python
深度优先算法
深度优先算法
|
4月前
|
算法 调度
作业调度算法_先来先服务算法_短作业优先算法_高响应比优先算法
本文介绍了作业调度算法,包括先来先服务(FCFS)、短进程优先(SJF)和高响应比优先(HRRN)算法。通过分析进程的到达时间和所需CPU服务时间,计算进程的开始时间、完成时间、平均周转时间和平均带权周转时间,以评估不同算法的性能。FCFS适合长作业,SJF适合短作业,而HRRN则综合了两者的优点。
202 12
|
6月前
|
算法 JavaScript
JS 【详解】树的遍历(含深度优先遍历和广度优先遍历的算法实现)
JS 【详解】树的遍历(含深度优先遍历和广度优先遍历的算法实现)
92 0
JS 【详解】树的遍历(含深度优先遍历和广度优先遍历的算法实现)
|
7月前
|
算法 Python
广度优先算法
广度优先算法
|
7月前
|
算法
【经典LeetCode算法题目专栏分类】【第4期】BFS广度优先算法:单词接龙、最小基因变化、二进制矩阵中的最短路径
【经典LeetCode算法题目专栏分类】【第4期】BFS广度优先算法:单词接龙、最小基因变化、二进制矩阵中的最短路径
|
算法 Go C++
【LeetCode 算法专题突破】二叉树的深度优先遍历(⭐)
【LeetCode 算法专题突破】二叉树的深度优先遍历(⭐)
81 0