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);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228