C语言模拟实现先来先服务(FCFS)和短作业优先调度算法(SJF)

说明

该并非实现真正的处理机调度，只是通过算法模拟这两种调度算法的过程。
运行过程如下：

1. 输入进程个数
2. 输入各个进程的到达事件
3. 输入各个进程的要求服务事件
4. 选择一种调度算法
5. 程序给出调度结果：各进程的完成时间、周转时间、带权周转时间。

运行截图

• FCFS
  
• SJF
  

代码如下

#include <stdio.h>
#include <stdlib.h>

#define MAX_DURANCE 1e6

/*
author: Qin Guoqing;

date:2020年11月17日 17点37分;

description: 模拟实现短作业优先和先来先服务两种调度算法。

*/

int count_process;            //进程数
int *coming_times;            //达到时间
int *serve_times;             //服务时间
int *finished_times;          //完成时间
int *turnover_times;          //周转时间
int *waiting_times;           //等待时间
float *turnover_times_weight; //带权周转时间
int method_choosen;           //所选调度算法

void input_process_count(); //输入进程个数
void input_coming_time();   //输入进程到达时间
void input_serve_time();    //输入进程服务时间
void print_inputInfo();     //打印输入信息
void choose_method();       //选择调度算法
void inatialize();          //数据初始化
void SJF();                 //短作业优先
void FCFS();                //先来先服务
void print_schedulInfo();   //打印调度信息
int main()
{
  input_process_count();
  input_coming_time();
  input_serve_time();
  print_inputInfo();
  choose_method();
  inatialize();
  switch (method_choosen)
  {
  case 1:
    FCFS();
    break;

  default:
    SJF();
    break;
  }
  print_schedulInfo();
  system("pause");
  return 0;
}

void input_process_count()
{
  puts("please input the amount of process:");
  scanf("%d", &count_process);
}

void input_coming_time()
{
  coming_times = (int *)malloc(sizeof(int) * count_process);
  puts("please input the coming_time of the processes:");
  for (size_t i = 0; i < count_process; i++)
  {
    scanf("%d", &coming_times[i]);
  }
}

void input_serve_time()
{
  serve_times = (int *)malloc(sizeof(int) * count_process);
  puts("please input the serve_time of the processes:");
  for (size_t i = 0; i < count_process; i++)
  {
    scanf("%d", &serve_times[i]);
  }
}
void print_inputInfo()
{
  puts("###################################################");
  printf("the amount of processes inputed by the user:n = %d\n", count_process);
  puts("here are the coming_times of those processes:");
  for (int i = 0; i < count_process; i++)
  {
    printf("%d ", coming_times[i]);
  }
  printf("\n");
  puts("here are the serve_time of those processes:");
  for (int i = 0; i < count_process; i++)
  {
    printf("%d ", serve_times[i]);
  }
  printf("\n");
}

void choose_method()
{
  puts("please choose a schedul method: 1-FCFS,2-SJF:");
  scanf("%d", &method_choosen);
}

void FCFS()
{
  int current = 0;
  int co_coming_times[count_process];
  for (size_t i = 0; i < count_process; i++)
  {
    co_coming_times[i] = coming_times[i];
  }
  for (size_t j = 0; j < count_process; j++)
  {
    int earliest = 0, min = co_coming_times[0];
    int i;
    //先找到当前最先到达的进程，需要使用到达时间的副本来找
    for (i = 1; i < count_process; i++)
    {
      if (co_coming_times[i] < min)
      {
        min = co_coming_times[i];
        earliest = i;
      }
    }
    co_coming_times[earliest] = MAX_DURANCE;
    //上一个进程执行完时有可能下个进程还没到达
    if (coming_times[earliest] > current)
    {
      current = coming_times[earliest];
    }
    //更新其完成时间
    finished_times[earliest] = current + serve_times[earliest];
    //等待时间
    waiting_times[earliest] = current - coming_times[earliest];
    //更新当前时间
    current += serve_times[earliest];
    //更新周转时间
    turnover_times[earliest] = serve_times[earliest] + waiting_times[earliest];
    //更新带权周转时间
    turnover_times_weight[earliest] = (float)turnover_times[earliest] / (float)serve_times[earliest];
  }
}

void SJF()
{
  int current = 0;
  int co_serve_times[count_process], co_coming_times[count_process];
  //服务时间的副本
  for (size_t i = 0; i < count_process; i++)
  {
    co_serve_times[i] = serve_times[i];
  }
  //到达时间的副本
  for (size_t i = 0; i < count_process; i++)
  {
    co_coming_times[i] = coming_times[i];
  }
  int flag = 0; //标识当前时间下有无已经到达的进程
  for (size_t i = 0; i < count_process; i++)
  {
    int min_p = 0, min = co_serve_times[0], early = co_coming_times[0];
    //min_p: 当前调度进程的xiabiao
    //min: 当前调度进程的服务时间
    //early:当前调度进程的到达时间
    for (size_t j = 1; j < count_process; j++)
    {
      if (co_coming_times[j] <= current && co_serve_times[j] < min)
      {
        flag = 1;
        min = co_serve_times[j];
        min_p = j;
      }
    }
    //若当前时间无进程到达，则选择即将最早到达的那个进程
    if (flag == 0)
    {
      for (size_t m = 1; m < count_process; m++)
      {
        if (co_coming_times[m] < early)
        {
          early = co_coming_times[m];
          min_p = m;
          current = early;
        }
      }
    }
    co_coming_times[min_p] = MAX_DURANCE;
    co_serve_times[min_p] = MAX_DURANCE;
    finished_times[min_p] = current + serve_times[min_p];
    waiting_times[min_p] = current - coming_times[min_p];
    current = finished_times[min_p];

    turnover_times[min_p] = waiting_times[min_p] + serve_times[min_p];
    turnover_times_weight[min_p] = (float)turnover_times[min_p] / (float)serve_times[min_p];
  }
}

void print_schedulInfo()
{
  puts("####################################################################################################");
  puts("here is the information of the schedul:");
  puts("P_name(ID)    arrived_time    served_time    finished_time    turnover_time    turnover_time_weight");
  for (size_t i = 0; i < count_process; i++)
  {
    printf("%10d    %12d    %11d    %14d    %13d    %20f\n", i, coming_times[i], serve_times[i], finished_times[i], turnover_times[i], turnover_times_weight[i]);
  }
  float average_turnover_time, sum_turnover_time = 0;               //平均周转时间和总周转时间
  float average_turnover_time_weight, sum_turnover_time_weight = 0; //平均带权周转时间和总带权周转时间
  for (size_t i = 0; i < count_process; i++)
  {
    sum_turnover_time += turnover_times[i];
    sum_turnover_time_weight += turnover_times_weight[i];
  }
  average_turnover_time = sum_turnover_time / count_process;
  average_turnover_time_weight = sum_turnover_time_weight / count_process;
  printf("the average time of turnover time is: %.2f\n", average_turnover_time);
  printf("the average time of turnover time with weight is: %.2f\n", average_turnover_time_weight);
  puts("####################################################################################################");
}

void inatialize()
{
  finished_times = (int *)malloc(sizeof(int) * count_process);
  turnover_times = (int *)malloc(sizeof(int) * count_process);
  turnover_times_weight = (float *)malloc(sizeof(float) * count_process);
  waiting_times = (int *)malloc(sizeof(int) * count_process);
}