# Find the Order of Execution of given N Processes in Round Robin Scheduling

In this article, you will learn about how to find the order of execution for the given N processes in the Round Robin Scheduling algorithm. But before starting with the code, let’s understand a bit about how this algorithm works.

Round Robin Scheduling is a popular CPU scheduling algorithm used in operating systems to allocate CPU time to multiple processes in a fair and efficient manner. In this blog, we will explore how round−robin scheduling works, its advantages and disadvantages, and provide an example to help you understand the concept better.

## What is Round Robin Scheduling?

Round Robin Scheduling is a preemptive scheduling algorithm where each process is given a fixed time slice or quantum to execute. The CPU scheduler allocates the CPU time to the processes in a circular order, hence the name 'round robin.' Once a process has used up its time slice, it is preempted and added to the end of the ready queue. The next process in the queue is then allocated the CPU for its time slice.

The time slice or quantum for each process is generally small, typically between 10 to 100 milliseconds. The advantage of a small time slice is that each process gets a fair amount of CPU time, and the CPU is utilized efficiently by switching between processes frequently.

### Scenario

To understand how Round Robin Scheduling works, let's consider an example. Suppose we have four processes that need to be executed:

• Process 1: Requires 6 units of CPU time

• Process 2: Requires 4 units of CPU time

• Process 3: Requires 2 units of CPU time

• Process 4: Requires 8 units of CPU time

We'll assume that the time quantum for the Round Robin Scheduling algorithm is set to 3 units of time. At the start of the scheduling process, all four processes are added to the ready queue in the order they arrived:

Ready queue: [Process 1, Process 2, Process 3, Process 4]


The scheduling algorithm then begins executing the processes in a cyclic manner, giving each process a time quantum of 3 units:

• Time 0: Process 1 starts executing (requires 3 units of CPU time)

• Time 3: Process 2 starts executing (requires 3 units of CPU time)

• Time 6: Process 3 starts executing (requires 2 units of CPU time)

• Time 8: Process 1 resumes execution (requires 3 units of CPU time)

• Time 11: Process 4 starts executing (requires 3 units of CPU time)

• Time 14: Process 2 resumes execution (requires 1 unit of CPU time)

• Time 15: Process 1 finishes executing

• Time 15: Process 3 resumes execution (requires 1 unit of CPU time)

• Time 16: Process 2 finishes executing

• Time 16: Process 4 resumes execution (requires 3 units of CPU time)

• Time 19: Process 3 finishes executing

• Time 19: Process 4 resumes execution (requires 2 units of CPU time)

• Time 21: Process 4 finishes executing

Process Queue: P1 P2 P3 P1 P4 P2 P1 P3 P2 P4 P3 P4 P4


As you can see from the example, each process is given a time quantum of 3 units, regardless of how much CPU time it requires to complete. Once a process has completed its time quantum, it is pre−empted and moved to the end of the ready queue, where it waits until it is its turn to execute again.

### Pseudocode

Let’s have a look into the pseudocode for implementing round−robin scheduling. Here we have created a function named round_robin() and variables like "waiting_time," "turnaround_time," "remaining," "current," "order_of_execution," and "ready_queue" are initialized by the function. Once all of the operations have been carried out, a loop is then started.

• The function adds all of the processes that have arrived as of the current time to the ready queue throughout each iteration of the loop. The first process in the ready queue is then executed for the time quantum or until it is complete, whichever comes first.

• If the process does not finish within the time quantum, it is added back to the ready queue. If it finishes, its waiting time and turnaround time are calculated.

• After all the processes have been executed, the function calculates the average waiting time and turnaround time and returns the order of execution as an array.

function round_robin(processes, quantum):
//Initialize variables
n = length of processes
waiting_time = an array of n elements, initialized to 0
turnaround_time = an array of n elements, initialized to 0
remaining_time = an array of n elements, initialized to the CPU burst time of each process
current_time = 0
order_of_execution = an empty array
index = 0
//Loop until all processes are executed
while true:
//Add all processes that have arrived at the current time to the ready queue
for i from index to n-1:
if processes[i].arrival_time <= current_time:
increment index

//Break the loop if all processes have been executed
if the ready_queue is empty and the sum of remaining_time is 0:
break

// Execute the first process in the ready queue
if the ready_queue is not empty:
process_index = the first element in ready_queue
remove the first element from ready_queue
if remaining_time[process_index] > quantum:
increment current_time by quantum
decrement remaining_time[process_index] by quantum
else:
increment current_time by remaining_time[process_index]
set waiting_time[process_index] to current_time - processes[process_index].burst_time
set remaining_time[process_index] to 0
set turnaround_time[process_index] to current_time - processes[process_index].arrival_time
else:
increment current_time by 1

// Calculate average waiting time and turnaround time
avg_waiting_time = sum of waiting_time divided by n
avg_turnaround_time = sum of turnaround_time divided by n

// Return the order of execution and average waiting/turnaround time
return order_of_execution, avg_waiting_time, avg_turnaround_time


## Implementation

Here you can find the implementation of the above pseudocode in Python and Java

### Python Example

def round_robin(processes, quantum):
# Initialize variables
n = len(processes)
waiting_time = [0] * n
turnaround_time = [0] * n
remaining_time = [processes[i][1] for i in range(n)]
current_time = 0
order_of_execution = []
index = 0

# Loop until all processes are executed
while True:
# Add all processes that have arrived at the current time to the ready queue
for i in range(index, n):
if processes[i][0] <= current_time:
index += 1

# Break the loop if all processes have been executed
if not ready_queue and sum(remaining_time) == 0:
break

# Execute the first process in the ready queue
order_of_execution.append(process_index)
if remaining_time[process_index] > quantum:
current_time += quantum
remaining_time[process_index] -= quantum
else:
current_time += remaining_time[process_index]
waiting_time[process_index] = current_time - processes[process_index][1]
remaining_time[process_index] = 0
turnaround_time[process_index] = current_time - processes[process_index][0]
else:
current_time += 1

# Calculate average waiting time and turnaround time
avg_waiting_time = sum(waiting_time) / n
avg_turnaround_time = sum(turnaround_time) / n

return order_of_execution, avg_waiting_time, avg_turnaround_time
processes = [(0, 5), (1, 3), (2, 8), (3, 6)]
time_quantum = 2
order_of_execution, avg_waiting_time, avg_turnaround_time = round_robin(processes, time_quantum)
print("Order of execution:", order_of_execution)
print("Average waiting time:", avg_waiting_time)
print("Average turnaround time:", avg_turnaround_time)


### Output

This code will output the order of execution of the processes, along with the average waiting time and average turnaround time for the Round Robin Scheduling algorithm with the given time quantum. Note that this is just an example implementation and may need to be modified for different use cases or requirements.

Order of execution: [0, 0, 1, 2, 0, 3, 1, 2, 3, 2, 3, 2]
Average waiting time: 10.25
Average turnaround time: 14.25


### Java Example

import java.util.*;
class Process {
int pid; // process ID
int arrival_time; // arrival time of process
int burst_time; // CPU burst time of process

Process(int pid, int arrival_time, int burst_time) {
this.pid = pid;
this.arrival_time = arrival_time;
this.burst_time = burst_time;
}
}
public class RoundRobinScheduling {
//Driver method
public static void main(String[] args) {
Process[] processes = new Process[] {
new Process(1, 0, 10),
new Process(2, 3, 5),
new Process(3, 5, 8),
new Process(4, 6, 3),
new Process(5, 8, 6)
};
// Time quantum
int quantum = 2;

// Run Round Robin Scheduling algorithm
int[] order_of_execution = round_robin(processes, quantum);

// Print order of execution
System.out.println("Order of Execution: " + Arrays.toString(order_of_execution));
}
//method to implement round-robin cpu scheduling
public static int[] round_robin(Process[] processes, int quantum) {
// Initialize variables
int n = processes.length;
int[] waiting_time = new int[n];
int[] turnaround_time = new int[n];
int[] remaining_time = new int[n];
for (int i = 0; i < n; i++) {
remaining_time[i] = processes[i].burst_time;
}
int current_time = 0;
List<Integer> order_of_execution = new ArrayList<Integer>();
int index = 0;

// Loop until all processes are executed
while (true) {
// Add all processes that have arrived at the current time to the ready queue
for (int i = index; i < n; i++) {
if (processes[i].arrival_time <= current_time) {
index++;
}
}

// Break the loop if all processes have been executed
if (ready_queue.isEmpty() && Arrays.stream(remaining_time).sum() == 0) {
break;
}

// Execute the first process in the ready queue
if (remaining_time[process_index] > quantum) {
current_time += quantum;
remaining_time[process_index] -= quantum;
} else {
current_time += remaining_time[process_index];
waiting_time[process_index] = current_time - processes[process_index].burst_time - processes[process_index].arrival_time;
remaining_time[process_index] = 0;
turnaround_time[process_index] = current_time - processes[process_index].arrival_time;
}
} else {
current_time++;
}
}

// Convert order of execution from list to array
int[] order_of_execution_arr = new int[order_of_execution.size()];
for (int i = 0; i < order_of_execution.size(); i++) {
order_of_execution_arr[i] = order_of_execution.get(i);
}

// Print average waiting time and turnaround time
float avg_waiting_time = Arrays.stream(waiting_time).sum() / (float) n;
float avg_turnaround_time = Arrays.stream(turnaround_time).sum() / (float) n;
System.out.println("Average Waiting Time: " + avg_waiting_time);
System.out.println("Average Turnaround Time: " + avg_turnaround_time);
// Return order of execution
return order_of_execution_arr;
}
}


### Output

Average Waiting Time: 15.0
Average Turnaround Time: 21.4
Order of Execution: [0, 0, 0, 1, 0, 2, 3, 1, 4, 0, 2, 3, 1, 4, 2, 4, 2]


## Conclusion

Round Robin Scheduling is a popular CPU scheduling algorithm used in operating systems to allocate CPU time to multiple processes in a fair and efficient manner. It is a preemptive scheduling algorithm where each process is given a fixed time slice or quantum to execute.

Round Robin Scheduling ensures that each process gets a fair share of CPU time and that the CPU is utilized efficiently by switching between processes frequently. However, Round Robin Scheduling can cause some overhead due to the frequent context switching between processes and may result in longer waiting times for some processes.

Updated on: 22-Aug-2023

185 Views