Question

scheduling program in C, please help

1 Objectives This programming project is to simulate a few CPU scheduling policies discussed in the class. You will write a C program to implement a simulator with different scheduling algorithms. The simulator selects a task to run from ready queue based on the scheduling algorithm. Since the project intends to simulate a CPU scheduler, so it does not require any actual process creation or execution. When a task is scheduled, the simulator will simply print out what task is selected to run at a time. It outputs the way similar to Gantt chart style. 2 Description The selected scheduling algorithms to implement in this project are 1) First Come First Serve (FCFS), 2) Round Robin (RR), and 3) Shortest Remaining Time First (SRTF). The detailed algorithms are already described in class slides and textbook Chapter 5. 2.1 Task Information The task information will be read from an input file. The format is pid arrival.time burst time All of fields are integer type where pid is a unique numeric process ID arrival time is the time when the task arrives in the unit of milliseconds burst time the is the CPU time requested by a task, in the unit of milliseconds The time unit for arrival time, burst time and interval is millisecond. 2.2 Command-line Usage and Examples Usage: proj2 input file [FCFS IRR SRTF] [time.quantum) where input file is the file name with task information. FCFS, RR, and SRTF are names of scheduling algorithms. The time quantum only applies to RR. FCFS is non-preemptive, while RR and SRTF are both preemptive. The last argument is needed only for RR. (See following table for more examples)

Answer 1

Code implemented in C programming

Note: Comments are written for code explanation

Filename: program.c

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

//To implement first come first serve scheduling
void fcfs(int, int[], int[], int[]);  
//To implement round robin scheduling
void rr(int, int[], int[], int[], int);
//To implement shortest runtime first
void srtf(int, int[], int[], int[]);
//To calculate turn around time
void turn_around(int, int [], int []);
//To calculate the CPU usage
void cpu_usage(int, int[], int);
//For duplicating arrays
void copy_array(int, int[], int[]);

int main(int argc, char *argv[])
{
   //Size of the array
   int size = 0;
   //Time quantum of the scheduling
   int quantum;
   //Information read from the read file
   int pid[20], arrival_time[20], burst_time[20];
   //Variable for the read file
   FILE *file;
   //Sets the file to read
   file = fopen(argv[1], "r");
  
   if ((argc < 3) || (argc > 4))
   {
       printf("Usage: proj2 input_file FCFS|RR|SRJF [quantum]\n");
   }
   else
   {
       if (file)
       {
           while (!feof(file))
           {
               fscanf(file, "%d %d %d", &pid[size], &arrival_time[size], &burst_time[size]);
               size += 1;
           }
       }
  
       //No process in the queue, queue is empty
       if(size == 0)
       {
           goto empty_queue;
       }

       printf("Schdeuling Algorithm: ");
       //First-Come-First-Serve
       if (!strcmp(argv[2], "FCFS"))
       {
           printf("FCFS\n");
           fcfs(size, pid, burst_time, arrival_time);  
       }
       else if (!strcmp(argv[2], "RR"))
       {
           if (argc == 4)
           {
               printf("RR\n");
               quantum = atoi(argv[3]);
               rr(size, pid, burst_time, arrival_time, quantum);
           }
           else
           {
               printf("...\n Invalid Entry\n");
           }
       }
       else if (!strcmp(argv[2], "SRTF"))
       {
           printf("SRTF\n");
           srtf(size, pid, burst_time, arrival_time);
       }
       else
       {
           printf("USAGE: FCFS, RR, SRTF\n");
       }
   }
   /* end of run */
   return 0;

   empty_queue: printf("\nProcess queue is empty. End of run.\n");
}

//SRTF: To implement shortest run-time first
void srtf(int size, int pid[], int burst_time[], int arrival_time[])
{
   int i, j, n, k, time, result;
   int temp_burst[size], waiting[size], response_time[size];
   int turnaround_time[size], wait_time[size];
   float float_result;
   bool done, processed[size];
   //Duplicates burst_time array
   copy_array(size, burst_time, temp_burst);
  
   printf("Total of %d tasks are read. Press 'enter' to start...", size);
   getchar();
   printf("==================================================================\n");
  
   //Initializes all processed to false
   for (i = 0; i < size; ++i)
   {
       processed[i] = false;
   }
   //Initializes the response time
   for (i = 0; i < size; ++i)
   {
       response_time[i] = -1;
   }
   //Initializes the wait time
   for (i = 0; i < size; ++i)
   {
       wait_time[i] = 0;
   }
  
   //Shortest Runtime First
   done = false;
   time = 0;
   while (!done)
   {
       n = 1000000;
       k = -1;
       for (i = 0; i < size; ++i)
       {
           if ((temp_burst[i] != 0) && (arrival_time[i] <= time))
           {
               if (temp_burst[i] < n)
               {
                   n = temp_burst[i];
                   k = i;
               }
           }
           else if ((temp_burst[i] == 0) && (processed[i] != true))
           {
               printf("<System Time\t%d> Process: %d\t...is finished;\n", time, pid[i]);
               processed[i] = true;
               turnaround_time[i] = time - arrival_time[i];
           }
       }
       if (k != -1)
       {
           printf("<System Time\t%d> Process: %d\t...is running;\n", time, pid[k]);
           temp_burst[k] -= 1;
           if (response_time[k] == -1)
           {
               response_time[k] = time - arrival_time[k];
           }
       }
       for (i = 0; i < size; ++i)
       {
           if ((temp_burst[i] != 0) && (arrival_time[i] <= time))
           {
               if (k != i)
               {
                   wait_time[i] += 1;
               }
           }
       }
       done = true;
       for (i = 0; i < size; ++i)
       {
           if ( processed[i] != true)
           {
               done = false;
               time += 1;
               break;
           }
       }
   }
   printf("<System Time\t%d> ...All processes finished;\n", time);
   printf("==================================================================\n");
  
   //CPU Usage
   cpu_usage(size, burst_time, time);
  
   //Average Wait Time
   result = 0;
   for (i = 0; i < size; ++i)
   {
       result += wait_time[i];
   }
   float_result = 1.0 * ((float)result/(float)size);
   printf("Average Wait Time\t: %.2f\n", float_result);
  
   //Average Response Time
   result = 0;
   for (i = 0; i < size; ++i)
   {
       result += response_time[i];
   }
   float_result = 1.0 * ((float)result/(float)size);
   printf("Average Response Time\t: %.2f\n", float_result);
  
   //Average Turn Around Time
   result = 0;
   for (i = 0; i < size; ++i)
   {
       result += turnaround_time[i];
   }
   float_result = 1.0 * ((float)result/(float)size);
   printf("Average Turn Around Time: %.2f\n", float_result);
}

//RR: To implement round robin scheduling
void rr(int size, int pid[], int burst_time[], int arrival_time[], int quantum)
{
   int i, j, n, remain, count, front, rear, time, result;
   int ready_queue[size], temp_burst[size], waiting[size], response_time[size];
   int turnaround[size], waittime[size];
   int flag = 0;
   float float_result;
   bool done, processed[size], waiting_queue[size];
   //Copies the real array into duplicate for modification
   copy_array(size, burst_time, temp_burst);
  
   printf("Total of %d tasks are read. Press 'enter' to start...", size);
   getchar();
   printf("==================================================================\n");
  
   //Determines if the index has been processed
   for (i = 0; i < size; ++i)
   {
       processed[i] = false;
   }
   for (i = 0; i < size; ++i)
   {
       response_time[i] = -1;
   }
   //Initializes the ready queue
   for (i = 0; i < size; ++i)
   {
       ready_queue[i] = -1;
   }
   //Initializes the waiting queue to false
   for (i = 0; i < size; ++i)
   {
       waiting_queue[i] = false;
   }
   //Initializes something
   for (i = 0; i < size; ++i)
   {
       waittime[i] = 0;
   }
  
   //Round Robin
   done = false;
   n = 0;
   time = 0;
   front = 0;
   rear = -1;
   while (!done)
   {
       check_queue: for (i = 0; i < size; ++i)
       {
           if ((arrival_time[i] <= time) && (temp_burst != 0) && (processed[i] != true))
           {
               waiting_queue[i] = false;
               for (j = 0; j < size; ++j)
               {
                   if (ready_queue[j] == i)
                   {
                       waiting_queue[i] = false;
                       break;
                   }
                   else
                   {
                       waiting_queue[i] = true;
                   }
               }
           }
           if (waiting_queue[i] == true)
           {
               rear = (rear + 1) % size;
               ready_queue[rear] = i;
           }
       }
       if (temp_burst[ready_queue[front]] == 0)
       {
           printf("<System Time\t%d> Process: %d\t...is finished;\n", time, pid[ready_queue[front]]);
           processed[ready_queue[front]] = true;
           turnaround[ready_queue[front]] = time - arrival_time[ready_queue[front]];
       }
       if ((n >= quantum) || (processed[ready_queue[front]] == true))
       {
           ready_queue[front] = -1;
           front = (front + 1) % size;
           if (n == quantum)
           {
               n = 0;
               goto check_queue;
           }
           n = 0;
       }
       if (ready_queue[front] != -1)
       {
           n += 1;
           temp_burst[ready_queue[front]] -= 1;
           if (response_time[ready_queue[front]] == -1)
           {
               response_time[ready_queue[front]] = time - arrival_time[ready_queue[front]];
           }
       }
       if (ready_queue[front] != -1)
       {
           printf("<System Time\t%d> Process: %d\t...is running;\n", time, pid[ready_queue[front]]);
       }
       done = true;
       for (i = 0; i < size; ++i)
       {
           if ((temp_burst[i] != 0) && (arrival_time[i] <= time))
           {
               if (ready_queue[front] != i)
               {
                   waittime[i] += 1;
               }
           }
       }
       for (i = 0; i < size; ++i)
       {
           if (processed[i] != true)
           {
               done = false;
               time += 1;
               break;
           }
       }
   }
   printf("<System Time\t%d> ...All processes finished;\n", time);
   printf("==================================================================\n");
  
   //Resets processed to false
   for (i = 0; i < size; ++i)
   {
       processed[i] = false;
   }
  
   //CPU Usage
   cpu_usage(size, burst_time, time);
  
   //Resets the temporary array
   copy_array(size, burst_time, temp_burst);
  
   //Average Wait Time
   result = 0;
   for (i = 0; i < size; ++i)
   {
       result += waittime[i];
   }
   float_result = 1.0 * ((float)result/(float)size);
   printf("Average Waiting Time\t: %.2f\n", float_result);
  
   //Average Response Time
   result = 0;
   for (i = 0; i < size; ++i)
   {
       result += response_time[i];
   }
   float_result = ((float)result/(float)size);
   printf("Average Response Time\t: %.2f\n", float_result);
  
   //Average Turn Around Time
   result = 0;
   for (i = 0; i < size; ++i)
   {
       result += turnaround[i];
   }
   float_result = 1.0 * ((float)result/(float)size);
   printf("Average Turn Around Time: %.2f\n", float_result);
}

//FCFS : To implement first come first serve scheduling
void fcfs(int size, int pid[], int burst_time[], int arrival_time[])
{
   int i, j, k, n, time, result;
   int temp_burst[size], first_response[size];
   int wait_time[size], turnaround_time[size];
   float float_result;
   bool done, processed[size];
   //Copies the real arrays into duplicates for modification
   copy_array(size, burst_time, temp_burst);
  
   printf("Total of %d tasks are read. Press 'enter' to start...", size);
   getchar();
   printf("==================================================================\n");
  
   //Determines if the index has been processed
   for (i = 0; i < size; ++i)
   {
       processed[i] = false;
   }
   //Initializes all of the first responses to -1
   for (i = 0; i < size; ++i)
   {
       first_response[i] = -1;
   }
   //Initializes you get the idea
   for (i = 0; i < size; ++i)
   {
       wait_time[i] = 0;
   }
  
   //First Come First Serve
   done = false;
   time = 0;
   while (!done)
   {
       n = 1000000;
       k = -1;
       for (i = 0; i < size; ++i)
       {
           if ((temp_burst[i]) != 0 && (arrival_time[i] <= time))
           {
               if ((arrival_time[i] < n))
               {
                   n = arrival_time[i];
                   k = i;
               }
           }
           else if ((temp_burst[i] == 0) && (processed[i] != true))
           {
               printf("<System Time\t%d> Process: %d\t...is finished;\n", time, pid[i]);
               processed[i] = true;
               turnaround_time[i] = time - arrival_time[i];
           }
       }
       if (k != -1)
       {
           printf("<System Time\t%d> Process: %d\t...is running;\n", time, pid[k]);
           temp_burst[k] -= 1;
           if (first_response[k] == -1)
           {
               first_response[k] = time - arrival_time[k];
           }
       }
       for (i = 0; i < size; ++i)
       {
           if ((temp_burst[i] != 0) && (arrival_time[i] <= time))
           {
               if (k != i)
               {
                   wait_time[i] += 1;
               }
           }
       }
       done = true;
       for (i = 0; i < size; ++i)
       {
           if (processed[i] != true)
           {
               done = false;
               time += 1;
               break;
           }
       }
   }
   printf("<System Time\t%d> ...All processes finished;\n", time);
   printf("==================================================================\n");
  
   //Determines if the index has been processed
   for (i = 0; i < size; ++i)
   {
       processed[i] = false;
   }
  
   //CPU Utilization
   cpu_usage(size, burst_time, time);
  
   //Average Waiting Time
   result = 0;
   for (i = 0; i < size; ++i)  
   {
       result += wait_time[i];
   }
   float_result = ((float)result/(float)size);
   printf("Average Waiting Time\t: %.2f\n", float_result);
  
   //Average Response Time
   result = 0;
   for (i = 0; i < size; ++i)
   {
       result += first_response[i];
   }
   float_result = ((float)result/(float)size);
   printf("Average Response Time\t: %.2f\n", float_result);

   //Turnaround Time
   turn_around(size, burst_time, wait_time);
}

/* turn_around : to calculate turn around time for each process */
void turn_around(int size, int burst_time[], int waiting[])
{
   int i;
   int turn_around_time[size];
   int result = 0;
   float float_result = 0.0;
  
   for(i = 0; i < size; ++i)
   {
       //Turn around time = burst time + waiting time
       turn_around_time[i] = burst_time[i] + waiting[i];
       result += turn_around_time[i];
   }
   float_result = ((float)result/(float)size);
   printf("Average Turn Around Time: %.2f\n", float_result);
}

void cpu_usage(int size, int burst_time[], int time)
{
   float float_result = 0.0;
   int result = 0;
   int i;
   for (i = 0; i < size; ++i)
   {
       result += burst_time[i];
   }
   float_result = 100.0 * ((float)result/(float)time);
   printf("Average CPU Usage\t: %%%.2f\n", float_result);
}

//Copies the content of one array into the other
void copy_array(int size, int A[], int B[])
{
   int i;
   for (i = 0; i < size; ++i)
   {
       B[i] = A[i];
   }
}

1 2 3 4 #include <stdio.h> #include <stdlib.h> #include <stdbool.h> #include <math.h> 6 // To implement first come first serve scheduling 7 void fcfs(int, int[], int[], int[]); 8 // To implement round robin scheduling 9 void rr(int, int[], int[], int[], int); 10 // To implement shortest runtime first 11 void srtf(int, int[], int[], int[]); 12 // To calculate turn around time 13 void turn around(int, int [], int []); 14 // To calculate the CPU usage 15 void cpu_usage(int, int[], int); 16 //For duplicating arrays 17 void copy_array(int, int[], int[]); 18 int main(int argc, char *argv[]) 25 //Size of the array int size = 0; //Time quantum of the scheduling int quantum; //Information read from the read file int pid[20], arrival_time [20], burst_time [20]; //Variable for the read file FILE *file; // Sets the file to read file = fopen(argv[1], "r"); N if ((argo < 3) || (argc > 4)) printf("Usage: proj2 input_file FCFS|RR|SRJF [quantum]\n"); else 38. if (file) 39 40 while (!feof(file))

41 42 fscanf(file, "%d %d %d", &pid[size], &arrival_time[size], &burst_time[size]); size += 1; 43 44 45 46 27 //No process in the queue, queue is empty if(size == 0) 48. 49 { 50 goto empty_queue; ГОЛОл ол Ул Nm printf("Schdeuling Algorithm: "); //First-come-First-Serve if (!strcmp(argv[2], "FCFS")) 55 56 { 57 printf("FCFS\n"); fcfs(size, pid, burst_time, arrival_time); 5 60 else if (!strcmp(argv[2], "RR")) 61 { 62 if (argc == 4) 63 64 65 printf("RR\n"); quantum = atoi(argv[3]); rr(size, pid, burst_time, arrival_time, quantum); else printf("... \n Invalid Entry\n"); } else if (!strcmp(argv[2], "SRTF")) 75 printf("SRTF\n"); srtf(size, pid, burst_time, arrival_time); 76 77 78. else printf("USAGE: FCFS, RR, SRTF\n");

/* end of run */ return 0; empty_queue: printf("\nProcess queue is empty. End of run.\n"); 88 89 90 //SRTF: To implement shortest run-time first void srtf(int size, int pid[], int burst_time[], int arrival_time[]) int i, j, n, k, time, result; int temp_burst[size], waiting[size], response_time[size]; int turnaround_time[size], wait_time[size]; float float_result; bool done, processed[size]; //Duplicates burst_time array copy_array(size, burst_time, temp_burst); printf("Total of %d tasks are read. Press 'enter' to start...", size); getchar(); printf("==================================================================\n"); //Initializes all processed to false for (i = 0; i < size; ++i) processed[i] = false; 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 //Initializes the response time for (i = 0; i < size; ++i) ५ response_time[i] = -1; //Initializes the wait time for (i = 0; i < size; ++i) 117 wait_time[i] = 0; 118 119 120 //Shortest Runtime First

121 122 done = false; time = 0; while (!done) 123 124 125 126 127 128 129 130 131 n = 1000000; k = -1; for (i = 0; i < size; ++i) if ((temp_burst[i] != 0) && (arrival_time[i] <= time)) { if (temp_burst[i] < n) n = temp_burst[i]; 134 k = i; 135 136 137 else if ((temp_burst[i] == 0) && (processed[i] != true)) printf("<System Time\t%d> Process: %d\t...is finished; \n", time, pid[i]); processed[i] = true; turnaround_time[i] = time - arrival_time[i]; 138 139 140 141 142 143 144 145 146 147 148 149 if (k != -1) printf("<System Time\t%d> Process: %d\t...is running; \n", time, pid[k]); temp_burst[k] -= 1; if (response_time[k] == -1) 150 response_time[k] = time - arrival_time[k]; 151 152 153 for (i = 0; i < size; ++i) if ((temp_burst[i] != 0) && (arrival_time[i] <= time)) 154 155 156 157 158 159 if (k != i) wait_time[i] += 1; 160

161 162 163 164 done = true; for (i = 0; i < size; ++i) 165 { if ( processed[i] != true) { 166 167 168 169 170 171 172 173 done = false; time += 1; break; 174 printf("<System Time\t%d> ...All processes finished; \n", time); pr ================================================================ //CPU Usage cpu_usage(size, burst_time, time); 175 176 177 178 179 180 181 182 183 //Average Wait Time result = 0; for (i = 0; i < size; ++i) 184 result += wait_time[i]; 185 186 float_result = 1.0 * ((float)result/(float)size); printf("Average Wait Time\t: %.2f\n", float_result); 187 188 189 190 191 //Average Response Time result = 0; for (i = 0; i < size; ++i) 192 result += response_time[i]; 193 194 195 196 197 198 199 200 float_result = 1.0 * ((float)result/(float)size); printf("Average Response Timelt: %.2f\n", float_result); //Average Turn Around Time result = 0; for (i = 0; i < size; ++i)

202 NNNNNNNNN. 201 result += turnaround_time[i]; 203 204 float_result = 1.0 * ((float)result/(float)size); 205 printf("Average Turn Around Time: %.2f\n", float_result); 206 207 208 //RR: To implement round robin scheduling 209 void rr(int size, int pid[], int burst_time[], int arrival_time[], int quantum) 210 211 int i, j, n, remain, count, front, rear, time, result; 212 int ready_queue[size], temp_burst[size], waiting[size], response_time[size]; 213 int turnaround[size], waittime[size]; 214 int flag = 0; 215 float float_result; 216 bool done, processed[size], waiting_queue[size]; 217 //Copies the real array into duplicate for modification 218. copy_array(size, burst_time, temp_burst); 219 220 printf("Total of %d tasks are read. Press 'enter' to start...", size); 221 getchar(); 222 printf("==================================================================\n"); 223 //Determines if the index has been processed 225 for (i = 0; i < size; ++i) 226 processed[i] = false; 228 229 for (i = 0; i < size; ++i) 230 231 response_time[i] = -1; 232 //Initializes the ready queue 234 for (i = 0; i < size; ++i) 235 236 ready_queue[i] = -1; 237 //Initializes the waiting queue to false 239 for (i = 0; i < size; ++i) 240 233 238

241 waiting_queue[i] = false; 242 //Initializes something for (i = 0; i < size; ++i) waittime[i] = 0; 243 244 245 246 247 248 249 250 251 //Round Robin done = false; n = 0; time = 0; front = 0; rear = -1; while (!done) 253 254 255 256 257 check_queue: for (i = 0; i < size; ++i) 258 259 if ((arrival_time[i] <= time) && (temp_burst != 0) && (processed[i] != true)) 260 { 261 waiting_queue[i] = false; for (j = 0; j < size; ++j) 262 263 264 if (ready_queue[j] == i) 265 266 waiting_queue[i] = false; break; 267 268 269 else 270 271 272 waiting_queue[i] = true; 273 if (waiting_queue[i] == true) 274 275 276 277 278. 279 rear = (rear + 1) % size; ready_queue[rear] = i; 280

281 if (temp_burst[ready_queue[front]] == 0) 282 283 284 printf("<System Time\t%d> Process: %d\t...is finished; \n", time, pid[ready_queue[front]]); processed[ready_queue[front]] = true; turnaround[ready_queue[front]] = time - arrival_time[ready_queue[front]]; 285 286 if ((n >= quantum) || (processed[ready_queue[front]] == true)) 287 288 289 290 291 292 293 294 295 ready_queue[front] = -1; front = (front + 1) % size; if (n == quantum) n = 0; goto check_queue; 296 n = 0; if (ready_queue[front] != -1) 297 298 299 300 301 302 303 304 305 n += 1; temp_burst[ready_queue[front]] -= 1; if (response_time[ready_queue[front]] == -1) response_time[ready_queue[front]] = time - arrival_time[ready_queue[front]]; 306 if (ready_queue[front] != -1) 307 308 309 printf("<System Time\t%d> Process: %d\t...is running; \n", time, pid[ready_queue[front]]); 310 done = true; for (i = 0; i < size; ++i) if ((temp_burst[i] != 0) && (arrival_time[i] <= time)) 311 312 313 314 315 316 317 318 319 320 if (ready_queue[front] != i) waittime[i] += 1;

321 322 for (i = 0; i < size; ++i) if (processed[i] != true) 323 324 325 326 327 328 329 330 331 332 done = false; time += 1; break; printf("<System Time\t%d> ...All processes finished;\n", time); printf("==================================================================\n"); 334 335 336 //Resets processed to false for (i = 0; i < size; ++i) 337 338 processed[i] = false; 339 340 341 342 343 344 345 //CPU Usage cpu_usage(size, burst_time, time); //Resets the temporary array copy_array(size, burst_time, temp_burst); 346 347 348 349 //Average Wait Time result = 0; for (i = 0; i < size; ++i) 350 result += waittime[i]; 351 352 353 354 float_result = 1.0 * ((float)result/(float)size); printf("Average Waiting Time\t: %.2f\n", float_result); 355 356 357 358 359 360 //Average Response Time result = 0; for (i = 0; i < size; ++i) result += response_time[i];

361 362 363 float_result = ((float)result/(float)size); printf("Average Response Time\t: %.2f\n", float_result); 364 365 //Average Turn Around Time result = 0; for (i = 0; i < size; ++i) result += turnaround[i]; resu m float_result = 1.0 * ((float)result/(float)size); printf("Average Turn Around Time: %.2f\n", float_result); m m 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 } m m //FCFS : To implement first come first serve scheduling void fcfs(int size, int pid[], int burst_time[], int arrival_time[]) { int i, j, k, n, time, result; int temp_burst[size], first_response[size]; int wait_time[size], turnaround_time[size]; float float_result; bool done, processed[size]; // Copies the real arrays into duplicates for modification copy_array(size, burst_time, temp_burst); 381 382 383 384 385 386 387 388 printf("Total of %d tasks are read. Press 'enter' to start...", size); getchar(); printf("======== =============== ================================================= 389 390 391 //Determines if the index has been processed for (i = 0; i < size; ++i) 392 processed[i] = false; 393 394 395 396 397 398 399 400 //Initializes all of the first responses to - 1 for (i = 0; i < size; ++i) first_response[i] = -1; //Initializes you get the idea

for (i = 0; i < size; ++i) 401 402 403 404 405 406 wait_time[i] = 0; 407 //First Come First Serve done = false; time = 0; while (!done) 408 409 410 411 412 413 414 415 n = 1000000; k = -1; for (i = 0; i < size; ++i) if ((temp_burst[i]) != 0 && (arrival_time[i] <= time)) 416 if ((arrival_time[i] < n)) n = arrival_time[i]; k = i; } 417 418 419 420 421 422 423 424 425 426 427 428 429 else if ((temp_burst[i] == 0) && (processed[i] != true)) printf("<System Time\t%d> Process: %d\t...is finished;\n", time, pid[i]); processed[i] = true; turnaround_time[i] = time - arrival_time[i]; 430 if (k != -1) 433 printf("<System Time\t%d> Process: %d\t...is running; \n", time, pid[k]); temp_burst[k] -= 1; if (first_response[k] == -1) first_response[k] = time - arrival_time[k]; 434 435 436 437 438 439 440 for (i = 0; i < size; ++i)

if ((temp_burst[i] != 0) && (arrival_time[i] <= time)) if (k != i) wait_time[i] += 1; 441 442 443 444 445 446 447 448 449 450 451 done = true; for (i = 0; i < size; ++i) 452 if (processed[i] != true) { 454 455 456 457 458 done = false; time += 1; break; 459 printf("<System Time\t%d> ...All processes finished;\n", time); printt e r ass==================== ===================================== \n" : 460 461 462 463 464 //Determines if the index has been processed for (i = 0; i < size; ++i) processed[i] = false; //CPU Utilization cpu_usage(size, burst_time, time); 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 //Average Waiting Time result = 0; for (i = 0; i < size; ++i) result += wait_time[i]; float result = ((float)result/(float)size); printf("Average Waiting Time\t: %.2f\n", float_result);

499 481 //Average Response Time 482 result = 0; 483 for (i = 0; i < size; ++i) 484 485 result += first response[i]; 486 487 float_result = ((float)result/(float)size); 488 printf("Average Response Timelt: %.2f\n", float_result); 489 490 //Turnaround Time 491 turn_around(size, burst_time, wait_time); 492 493 494 /* turn around : to calculate turn around time for each process */ 495 void turn_around(int size, int burst_time[], int waiting[]). 496 497 int i; 498 int turn_around_time[size]; int result = 0; 500 float float_result = 0.0; 501 502 for(i = 0; i < size; ++i) 503 504 //Turn around time = burst time + waiting time 505 turn_around_time[i] = burst_time[i] + waiting[i]; 506 result += turn_around_time[i]; 507 508 float_result = ((float)result/(float)size); printf("Average Turn Around Time: %.2f\n", float_result); 510 } 511 512 void cpu_usage(int size, int burst_time[], int time) 513 514 float float result = 0.0; 515 int result = 0; 516 int i; 517 for (i = 0; i < size; ++i) 518 519 result += burst_time[i]; 520 509

float_result = 100.0 * ((float)result/(float)time); printf("Average CPU Usage\t: %%%.2f\n", float_result); } 521 522 523 524 525 526 527 528 529 530 531 532 533 // Copies the content of one array into the other void copy_array(int size, int A[], int B[]). { int i; for (i = 0; i < size; ++i) B[i] = A[i]; }

Working Code Output:

Schdeuling Algorithm: FCFS
Total of 6 tasks are read. Press 'enter' to start...
==================================================================
<System Time 0> Process: 1 ...is running;
<System Time 1> Process: 1 ...is running; <System Time 2> Process: 1 ...is running;
<System Time 3> Process: 1 ...is running;
<System Time 4> Process: 1 ...is running;
<System Time 5> Process: 1 ...is running;
<System Time 6> Process: 1 ...is running;
<System Time 7> Process: 1 ...is running;
<System Time 8> Process: 1 ...is running;
<System Time 9> Process: 1 ...is running;
<System Time 10> Process: 1 ...is finished;
<System Time 10> Process: 2 ...is running;
<System Time 11> Process: 2 ...is running;
<System Time 12> Process: 2 ...is running;
<System Time 13> Process: 2 ...is running;
<System Time 14> Process: 2 ...is running;
<System Time 15> Process: 2 ...is running;
<System Time 16> Process: 2 ...is running;
<System Time 17> Process: 2 ...is running;
<System Time 18> Process: 2 ...is running;
<System Time 19> Process: 2 ...is finished;
<System Time 19> Process: 3 ...is running;
<System Time 20> Process: 3 ...is running;
<System Time 21> Process: 3 ...is running;
<System Time 22> Process: 3 ...is running;
<System Time 23> Process: 3 ...is running;
<System Time 24> Process: 3 ...is finished;
<System Time 24> Process: 4 ...is running;
<System Time 25> Process: 4 ...is running;
<System Time 26> Process: 4 ...is running;
<System Time 27> Process: 4 ...is running;
<System Time 28> Process: 4 ...is finished;
<System Time 28> Process: 5 ...is running;
<System Time 29> Process: 5 ...is running;
<System Time 30> Process: 5 ...is running;
<System Time 31> Process: 5 ...is running;
<System Time 32> Process: 5 ...is running;
<System Time 33> Process: 5 ...is running;
<System Time 34> Process: 5 ...is finished;
<System Time 34> Process: 6 ...is running;
<System Time 35> Process: 6 ...is running;
<System Time 36> Process: 6 ...is running;
<System Time 37> Process: 6 ...is running;
<System Time 38> Process: 6 ...is running;
<System Time 39> Process: 6 ...is running;
<System Time 40> Process: 6 ...is running;
<System Time 41> Process: 6 ...is finished;
<System Time 41> ...All processes finished;
==================================================================
Average CPU Usage : %100.00
Average Waiting Time : 14.17
Average Response Time : 14.17
Average Turn Around Time: 21.00

Working Code Output Screenshot:

-->output input.1 FCFS Schdeuling Algorithm: FCFS Total of 6 tasks are read. Press 'enter' to start... ================================================================== <System Time 0> Process: 1 ...is running; <System Time 1> Process: 1 ...is running; <System Time 2> Process: 1 ...is running; <System Time 3> Process: 1 ...is running; <System Time 4> Process: 1 ...is running; <System Time 5> Process: 1 ...is running; <System Time 6> Process: 1 ...is running; <System Time 7> Process: 1 ...is running; <System Time 8> Process: 1 ...is running; <System Time 9> Process: 1 ...is running; <System Time 10> Process: 1 ...is finished; <System Time 10> Process: 2 ...is running; <System Time 11> Process: 2 ...is running; <System Time 12> Process: 2 ...is running; <System Time 13> Process: 2 ...is running; <System Time 14> Process: 2 ...is running; <System Time 15> Process: 2 ...is running; <System Time 16> Process: 2 ...is running; <System Time 17> Process: 2 ...is running; <System Time 18> Process: 2 ...is running; <System Time 19> Process: 2 ...is finished; <System Time 19> Process: 3 ...is running; <System Time 20> Process: 3 ...is running; <System Time 21> Process: 3 ...is running; <System Time 22> Process: 3 ...is running; <System Time 23> Process: 3 ...is running; <System Time 24> Process: 3 ...is finished; <System Time 24> Process: 4 ...is running; <System Time 25> Process: 4 ...is running; <System Time 26> Process: 4 ...is running; <System Time 27> Process: 4 ...is running; <System Time 28> Process: 4 ...is finished; <System Time 28> Process: 5 ...is running; <System Time 29> Process: 5 ...is running; <System Time 30> Process: 5 ...is running; <System Time 31> Process: 5 ...is running; <System Time 32> Process: 5 ...is running; <System Time 33> Process: 5 ...is running; <System Time 34> Process: 5 ...is finished; <System Time 34> Process: 6 ...is running; <System Time 35> Process: 6 ...is running; <System Time 36> Process: 6 ...is running; <System Time 37> Process: 6 ...is running; <System Time 38> Process: 6 ...is running; <System Time 39> Process: 6 ...is running; <System Time 40> Process: 6 ...is running; <System Time 41> Process: 6 ...is finished;

<System Time 28> Process: 4 ...is finished; <System Time 28> Process: 5 ...is running; <System Time 29> Process: 5 ...is running; <System Time 30> Process: 5 ...is running; <System Time 31> Process: 5 ...is running; <System Time 32> Process: 5 ...is running; <System Time 33> Process: 5 ...is running; <System Time 34> Process: 5 ...is finished; <System Time 34> Process: 6 ...is running; <System Time 35> Process: 6 ...is running; <System Time 36> Process: 6 ...is running; <System Time 37> Process: 6 ...is running; <System Time 38> Process: 6 ...is running; <System Time 39> Process: 6 ...is running; <System Time 40> Process: 6 ...is running, <System Time 41> Process: 6 ... is finished; <System Time 4 1> ...All processes finished; ================================================================== Average CPU Usage : %100.00 Average Waiting Time : 14.17 Average Response Time : 14.17 Average Turn Around Time: 21.00

If you like my answer, hit thumbs up. Thank you