Python Shortest Job First (Non-Preemptive) Algorithm with Same Arrival Time

Python Shortest Job First (Non-Preemptive) Algorithm with Same Arrival Time

SJF: Shortest Job First
The task is to find the Average Waiting Time and Average Turnaround Time of the given processes with their Burst Time using SJF Scheduling Algorithm.
SJF is a scheduling policy that selects the waiting process with the smallest execution time to execute next.
SJF is a Non Pre-emptive Algorithm, hence the process which has the least Burst Time will be served first and the next process will be served only after the previous process is executed completely.
SJF has the advantage of having a minimum average waiting time among all scheduling algorithms.
Here we are considering the arrival time of all processes to be 0.
Start Time: Time at which the execution of the process starts
Completion Time: Time at which the process completes its execution
Turnaround Time: Completion Time - Arrival Time
Waiting Time: Turnaround Time - Burst Time

class SJF:

def processData(self, no_of_processes):
process_data = []
for i in range(no_of_processes):
temporary = []
process_id = int(input("Enter Process ID: "))

burst_time = int(input(f"Enter Burst Time for Process {process_id}: "))

temporary.extend([process_id, 0, burst_time])
'0' is the arrival time of the processes
SJF.schedulingProcess(self, process_data)

def schedulingProcess(self, process_data):
process_data.sort(key=lambda x: x[2])
        Sort according to Burst Time 
        start_time = []
exit_time = []
s_time = 0
for i in range(len(process_data)):
s_time = s_time + process_data[i][2]
e_time = s_time
t_time = SJF.calculateTurnaroundTime(self, process_data)
w_time = SJF.calculateWaitingTime(self, process_data)
SJF.printData(self, process_data, t_time, w_time)

def calculateTurnaroundTime(self, process_data):
total_turnaround_time = 0
for i in range(len(process_data)):
turnaround_time = process_data[i][3] - process_data[i][1]
turnaround_time = completion_time - arrival_time
total_turnaround_time = total_turnaround_time + turnaround_time
average_turnaround_time = total_turnaround_time / len(process_data)
average_turnaround_time = total_turnaround_time / no_of_processes
return average_turnaround_time

def calculateWaitingTime(self, process_data):
total_waiting_time = 0
for i in range(len(process_data)):
waiting_time = process_data[i][4] - process_data[i][2]
waiting_time = turnaround_time - burst_time
total_waiting_time = total_waiting_time + waiting_time
average_waiting_time = total_waiting_time / len(process_data)
average_waiting_time = total_waiting_time / no_of_processes
return average_waiting_time

def printData(self, process_data, average_turnaround_time, average_waiting_time):

print("Process_ID Arrival_Time Burst_Time Completion_Time Turnaround_Time Waiting_Time")

for i in range(len(process_data)):
for j in range(len(process_data[i])):
print(process_data[i][j], end=" ")

print(f'Average Turnaround Time: {average_turnaround_time}')

print(f'Average Waiting Time: {average_waiting_time}')

if __name__ == "__main__":

no_of_processes = int(input("Enter number of processes: "))
sjf = SJF()