Add round_robin scheduling algorithm

scheduling/round_robin_scheduling_algorithm.py

@@ -0,0 +1,102 @@
+"""
+Round Robin is a CPU scheduling algorithm.
+In Round Robin each process is assigned a fixed time slot in a cyclic way.
+https://en.wikipedia.org/wiki/Round-robin_scheduling
+"""
+
+
+def calculate_waiting_time(processes, n, burst_time, waiting_time, quantum):
+    """
+    This function calculates the waiting time of some processes that have a
+    specified duration time.
+        Return: The waiting time for each process.
+    >>> calculate_waiting_times([5, 10, 15])
+    [0, 5, 15]
+    >>> calculate_waiting_times([1, 2, 3, 4, 5])
+    [0, 1, 3, 6, 10]
+    >>> calculate_waiting_times([10, 3])
+    [0, 10]
+    """
+    rem_burst_time = [0] * n
+    for i in range(n):
+        rem_burst_time[i] = burst_time[i]
+    t = 0
+    while 1:
+        done = True
+        for i in range(n):
+            if rem_burst_time[i] > 0:
+                done = False
+                if rem_burst_time[i] > quantum:
+                    t += quantum
+                    rem_burst_time[i] -= quantum
+                else:
+                    t = t + rem_burst_time[i]
+                    waiting_time[i] = t - burst_time[i]
+                    rem_burst_time[i] = 0
+        if done is True:
+            break
+
+
+def calculate_turn_around_time(
+    processes, n, burst_time, waiting_time, turn_around_time
+):
+
+    """
+    This function calculates the turnaround time of some processes.
+        Return: The time difference between the completion time and the
+                arrival time.
+                Practically waiting_time + duration_time
+    >>> calculate_turnaround_times([5, 10, 15], [0, 5, 15])
+    [5, 15, 30]
+    >>> calculate_turnaround_times([1, 2, 3, 4, 5], [0, 1, 3, 6, 10])
+    [1, 3, 6, 10, 15]
+    >>> calculate_turnaround_times([10, 3], [0, 10])
+    [10, 13]
+    """
+
+    for i in range(n):
+        turn_around_time[i] = burst_time[i] + waiting_time[i]
+
+
+def calculate_avg_time(processes, n, burst_time, quantum):
+    """
+    This function calculates the average of the waiting times
+        Return: The average of the waiting times.
+    >>> calculate_average_waiting_time([0, 5, 16])
+    7.0
+    >>> calculate_average_waiting_time([1, 5, 8, 12])
+    6.5
+    >>> calculate_average_waiting_time([10, 24])
+    17.0
+    """
+    waiting_time = [0] * n
+    turn_around_time = [0] * n
+    calculate_waiting_time(processes, n, burst_time, waiting_time, quantum)
+    calculate_turn_around_time(processes, n, burst_time, waiting_time, turn_around_time)
+    print("Processes    Burst Time     Waiting Time    Turn-Around Time")
+    total_waiting_time = 0
+    total_turn_around_time = 0
+    for i in range(n):
+        total_waiting_time = total_waiting_time + waiting_time[i]
+        total_turn_around_time = total_turn_around_time + turn_around_time[i]
+        print(
+            " ",
+            i + 1,
+            "\t\t",
+            burst_time[i],
+            "\t\t",
+            waiting_time[i],
+            "\t\t",
+            turn_around_time[i],
+        )
+    print("\nAverage waiting time = %.5f " % (total_waiting_time / n))
+    print("Average turn around time = %.5f " % (total_turn_around_time / n))
+
+
+if __name__ == "__main__":
+    # Process id
+    processes = [1, 2, 3]
+    n = 3
+    burst_time = [10, 5, 8]
+    quantum = 2
+    calculate_avg_time(processes, n, burst_time, quantum)