操作系统 FCFS,SPF,HRRN算法的实现

简介: 操作系统 FCFS,SPF,HRRN算法的实现

FCFS,SPF,HRRN算法的实现

  • 先来先服务(first-come first-served,FCFS)调度算法 
    该算法是一种最简单的调度算法,它既可用于作业调度,也可用于进程调度。在进程调度中采用 FCFS 算法时, 将选择最先进入就绪队列的进程投入执行。 FCFS 算法属于非抢占调度方式, 其特点是简单、易于实现 , 但不利于短作业和 I/0 型作业的运行。FCFS 算法很少作为进程调度的主算法,但常作为辅助调度算法。
  • 短作业(进程)优先调度算法SJ/PF
    该调度算法是从后备队列中选择一个或若干个估计运行时间最短的作业,将它们调入内存运行
    image.png
  • 高响应比优先调度算法 HRRN
    高响应比优先调度算法则是既考虑了作业的等待时间,又考虑作业运行时间的调度算法该优先权的变化规律可描述为:
    image.png
  • 代码
#include<stdio.h>
typedef struct PCB{
  int ID;    //进程ID 
  double submit;     //提交时间 
  double run;    //运行时长 
  double start;  //开始时间 
  double end;    //结束时间 
  double TAT;  //周转
  double TATW;    //带权周转
}PCB;
void FCFS(PCB pcb[], int PCBNUM){      
  //先来先服务
  PCB temp;  //方便交换 
  for(int i = 0; i < PCBNUM - 1; i++){                 
    for(int j = 0; j < PCBNUM - i - 1; j++){
      if(pcb[j].submit > pcb[j+1].submit){
        //使用冒泡排序,通过提交时间经行排序 
        temp = pcb[j];
          pcb[j] = pcb[j+1];
        pcb[j+1] = temp;
      }
      }
    }
  for(int i = 0; i < PCBNUM; i++){    
    //时间计算
    if(i == 0){
      pcb[i].start = pcb[i].submit;
    }
    else{
      pcb[i].start = pcb[i-1].end;
    }
    pcb[i].end = pcb[i].start + pcb[i].run;
    pcb[i].TAT = pcb[i].end - pcb[i].submit;
    pcb[i].TATW = pcb[i].TAT / pcb[i].run;
  }
  printf("FCFS,先来先服务算法:\n");
  printf("名称    提交    运行    开始    结束    周转    带权周转\n");
  for(int i = 0; i < PCBNUM; i++){   
      //输出
    printf("%d\t%.2f\t%.2f\t%.2f\t%.2f\t%.2f\t%.2f\n", pcb[i].ID, pcb[i].submit, pcb[i].run, pcb[i].start, pcb[i].end, pcb[i].TAT, pcb[i].TATW);
  }
  printf("\n");
}
void SPF(PCB pcb[], int PCBNUM){     
  //短进程优先 
  PCB temp;  //方便交换 
  for(int r = PCBNUM - 1; r > 0; r--){
    //选出第一行
    if(pcb[r-1].submit > pcb[r].submit){
      temp = pcb[r];
        pcb[r] = pcb[r-1];
      pcb[r-1] = temp;
    }
  }
  for(int i = 1; i < PCBNUM - 1; i++){        
    for(int j = 1; j < PCBNUM - 1; j++){
      //通过运行时间排序 
      if(pcb[j].run > pcb[j+1].run ){
        temp = pcb[j];
          pcb[j] = pcb[j+1];
        pcb[j+1] = temp;
      }
      }
  }
  for(int i = 0; i < PCBNUM; i++){     //计算
    if(i == 0){
      pcb[i].start = pcb[i].submit;
    }
    else{
      pcb[i].start = pcb[i-1].end;
    }
    pcb[i].end = pcb[i].start +pcb[i].run;
    pcb[i].TAT = pcb[i].end -pcb[i].submit;
    pcb[i].TATW = pcb[i].TAT/pcb[i].run ;    
  }
  printf("SPF,短进程优先算法:\n");
  printf("名称    提交    运行    开始    结束    周转    带权周转\n");
  for(int i = 0; i < PCBNUM; i++){   
      //输出
    printf("%d\t%.2f\t%.2f\t%.2f\t%.2f\t%.2f\t%.2f\n", pcb[i].ID, pcb[i].submit, pcb[i].run, pcb[i].start, pcb[i].end, pcb[i].TAT, pcb[i].TATW);
  }
  printf("\n");
}
void HRRN(PCB pcb[], int PCBNUM){          
  //高响应比
  PCB temp;  //方便交换
  int R[PCBNUM];  //记录相应比 
  for(int r = PCBNUM-1; r > 0; r--){    
      //选出第一行
    if(pcb[r-1].submit > pcb[r].submit){
      temp = pcb[r];
        pcb[r] = pcb[r-1];
      pcb[r-1] = temp;
    }
  }
  for(int i = 0; i < PCBNUM - 1; i++){               
    for(int j=1;j < PCBNUM - 1; j++){
      //排序,通过响应比 
      for(int o = 1; o < PCBNUM; o++){     
         //计算响应比
        R[i] = (pcb[i-1].end-pcb[i].submit) / pcb[i].run+1;
      }
      if(R[i] < R[i+1]){
        temp = pcb[j];
          pcb[j] = pcb[j+1];
        pcb[j+1] = temp;
      }
    }
  }
  for(int i = 0; i < PCBNUM; i++){     
    //计算
    if(i == 0){
      pcb[i].start = pcb[i].submit;
    }
    else{
      pcb[i].start = pcb[i-1].end;
    }
    pcb[i].end = pcb[i].start + pcb[i].run;
    pcb[i].TAT = pcb[i].end - pcb[i].submit;
    pcb[i].TATW = pcb[i].TAT / pcb[i].run;
    }
    printf("HRRN,高响应比算法:\n");
    printf("名称    提交    运行    开始    结束    周转    带权周转\n");
  for(int i = 0; i < PCBNUM; i++){   
      //输出
    printf("%d\t%.2f\t%.2f\t%.2f\t%.2f\t%.2f\t%.2f\n", pcb[i].ID, pcb[i].submit, pcb[i].run, pcb[i].start, pcb[i].end, pcb[i].TAT, pcb[i].TATW);
  }
  printf("\n");
}
int main(){
  printf("请输入进程数目:");
  int PCBNUM;
  scanf("%d", &PCBNUM);
  PCB pcb[PCBNUM];  //申请空间 
  printf("请输入每个进程的进程名,提交时间,运行时长(中间用空格分开)\n"); 
  for(int i = 0; i < PCBNUM; i++){
    scanf("%d%lf%lf", &pcb[i].ID, &pcb[i].submit, &pcb[i].run);
  }
  FCFS(pcb, PCBNUM);
  SPF(pcb, PCBNUM);
  HRRN(pcb, PCBNUM);
}
  • 效果图image.png


目录
相关文章
|
算法 Linux 数据处理
《操作系统》—— 处理机调度算法
《操作系统》—— 处理机调度算法
|
3月前
|
算法
操作系统LRU算法(最近最少使用算法)
操作系统LRU算法(最近最少使用算法)
22 0
|
3月前
|
存储 算法
【操作系统】虚拟存储管理-页面置换算法
【操作系统】虚拟存储管理-页面置换算法
35 0
|
3月前
|
算法 安全
【操作系统】死锁处理-银行家算法
【操作系统】死锁处理-银行家算法
38 0
|
3月前
|
算法 调度
详解操作系统四大常用的作业调度算法(FCFS丨SJF丨HRRN丨RR)
详解操作系统四大常用的作业调度算法(FCFS丨SJF丨HRRN丨RR)
692 0
|
3月前
|
存储 算法 安全
操作系统:银行家算法
操作系统:银行家算法
36 0
|
3月前
|
算法
操作系统OPT算法(最佳页面替换算法)
操作系统OPT算法(最佳页面替换算法)
33 0
|
4月前
|
算法 调度 C语言
操作系统进程调度算法(c语言模拟实现)
操作系统进程调度算法(c语言模拟实现)
146 0
|
6月前
|
缓存 算法 关系型数据库
面试官:你知道MySQL和Linux操作系统是如何改进LRU算法的吗?
上周群里看到有位小伙伴面试时,被问到这两个问题: 咋一看,以为是在问操作系统的问题,其实这两个题目都是在问如何改进 LRU 算法。 因为传统的 LRU 算法存在这两个问题: 「预读失效」导致缓存命中率下降(对应第一个问题) 「缓存污染」导致缓存命中率下降(对应第二个问题) Redis 的缓存淘汰算法则是通过实现 LFU 算法来避免「缓存污染」而导致缓存命中率下降的问题(Redis 没有预读机制)。 MySQL 和 Linux 操作系统是通过改进 LRU 算法来避免「预读失效和缓存污染」而导致缓存命中率下降的问题。 这次,就重点讲讲 MySQL 和 Linux 操作系统是如何改进 L
|
8月前
|
算法
计算机操作系统学习笔记(9)——页面置换算法
计算机操作系统学习笔记(9)——页面置换算法
91 0