Question

(C++)
Given an array with Job_id, Arrival_Time & Duration:

Array[5][3]
0 0 100
1 20 80
2 30 60
3 40 50
4 50 40
Use simple array manipulation in C++ to implement "Shortest Job First" to show arrival start time, finish time and response time for each job.

Answer 1

#include<stdio.h>

// main function definition
int main()
{
// Matrix contains first column process ID, second column arrival time third column duration
int Array[5][3] = {{0, 0, 100}, {1, 20, 80}, {2, 30, 60}, {3, 40, 50}, {4, 50, 40}};

// Declares array to store process process ID, burst time arrival time
// waiting time and turn around time
int processID[5], burstTime[5], arrivalTime[5], waitingTime[5], turnAroundTime[5];
// Variables to store total and average waiting time and turn around time
float avgWaitingTime = 0, avgTurnAroundTime = 0, turnAroundTotal = 0, waitingTotal = 0;
// Temporary variables
int temp, minimum, k = 1, executionTime = 0, turnAround = 0, total = 0;

printf(" ******* SJF Scheduling (Non Preemptive Scheduling) ******** \n");
int numberOfProcess = 5;

// Loops till number of process
for(int r = 0; r < numberOfProcess; r++)
{
// Extracts matrix current row position and 0 column index position data
// and stores it in process ID array
processID[r] = Array[r][0];
// Extracts matrix current row position and 1 column index position data
// and stores it in array time array
arrivalTime[r] = Array[r][1];
// Extracts matrix current row position and 2 column index position data
// and stores it in burst time array
burstTime[r] = Array[r][2];
}// End of for loop

// Sorting process ID, arrival time and burst time According to Arrival Time
// Loops till number of process
for(int r = 0; r < numberOfProcess; r++)
{
// Loops till number of process
for(int c = 0; c < numberOfProcess; c++)
{
// Checks if r index position arrival time is less than
// c index position arrival time
if(arrivalTime[r] < arrivalTime[c])
{
// Swapping process for process ID
temp = processID[c];
processID[c] = processID[r];
processID[r] = temp;

// Swapping process for arrival time
temp = arrivalTime[c];
arrivalTime[c] = arrivalTime[r];
arrivalTime[r] = temp;

// Swapping process for burst time
temp = burstTime[c];
burstTime[c] = burstTime[r];
burstTime[r] = temp;
}// End of if condition
}// End of inner for loop
}// End of outer for loop

// Arranging the table according to Burst time, Execution time and Arrival Time
// Where arrival time <= execution time

// Loops till number of process
for(int c = 0; c < numberOfProcess; c++)
{
// Calculates execution time
executionTime = executionTime + burstTime[c];
// Stores the first burst time as minimum
minimum = burstTime[k];

// Loops till number of process
for(int r = k; r < numberOfProcess; r++)
{
// Checks if the execution time is greater than or equals to
// r index position process arrival time
// and r index position burst time is less than the minimum
if (executionTime >= arrivalTime[r] && burstTime[r] < minimum)
{
// Swapping process for process ID
temp = processID[k];
processID[k] = processID[r];
processID[r] = temp;

// Swapping process for arrival time
temp = arrivalTime[k];
arrivalTime[k] = arrivalTime[r];
arrivalTime[r] = temp;

// Swapping process for burst time
temp = burstTime[k];
burstTime[k] = burstTime[r];
burstTime[r] = temp;
}// End of if condition
}// End of inner for loop
// Increase the counter by one
k++;
}// End of outer for loop

// Initialize waiting time to 0
waitingTime[0] = 0;

// Calculates total waiting time

// Loops till number of process
for(int r = 1; r < numberOfProcess; r++)
{
total = total + burstTime[r - 1];
waitingTime[r] = total - arrivalTime[r];
waitingTotal = waitingTotal + waitingTime[r];
}// End of for loop

// Calculates average waiting time
avgWaitingTime = (waitingTotal / numberOfProcess);

// Calculates total turn around time

// Loops till number of process
for(int r = 0; r < numberOfProcess; r++)
{
turnAround = turnAround + burstTime[r];
turnAroundTime[r] = turnAround - arrivalTime[r];
waitingTotal = waitingTotal + turnAroundTime[r];
}// End of for loop

// Calculates average turn around time
avgTurnAroundTime = (waitingTotal / numberOfProcess);

// Displays heading
printf("\nProcess\t Burst\t Arrival\t Waiting\t Turn-around" );

// Loops till number of process
for(int r = 0; r < numberOfProcess; r++)
// Displays process ID, burst time, arrival time, waiting time, and turn around time
printf("\n p%d\t %d\t %d\t\t %d\t\t %d",
processID[r], burstTime[r], arrivalTime[r], waitingTime[r], turnAroundTime[r]);

// Displays averages
printf("\n\n AVERAGE WAITING TIME : %f", avgWaitingTime);
printf("\n AVERAGE TURN AROUND TIME : %f",avgTurnAroundTime);
return 0;
}// End of main function

Sample Output:

******* SJF Scheduling (Non Preemptive Scheduling) ********

Process Burst Arrival Waiting Turn-around
p0 100 0 0 100
p4 40 50 50 90
p3 50 40 100 150
p2 60 30 160 220
p1 80 20 230 310

AVERAGE WAITING TIME : 108.000000
AVERAGE TURN AROUND TIME : 282.000000