Skip to content
Related Articles

Related Articles

Program for Round Robin Scheduling for the same Arrival time

Improve Article
Save Article
  • Difficulty Level : Medium
  • Last Updated : 28 Nov, 2022
Improve Article
Save Article
 

Round Robin is a CPU scheduling algorithm where each process is assigned a fixed time slot in a cyclic way. It is basically the preemptive version of First come First Serve CPU Scheduling algorithm

  • Round Robin CPU Algorithm generally focuses on Time Sharing technique. 
  • The period of time for which a process or job is allowed to run in a pre-emptive method is called time quantum
  • Each process or job present in the ready queue is assigned the CPU for that time quantum, if the execution of the process is completed during that time then the process will end else the process will go back to the waiting table and wait for its next turn to complete the execution.
     

Characteristics of Round Robin CPU Scheduling Algorithm:

  • It is simple, easy to implement, and starvation-free as all processes get fair share of CPU.
  • One of the most commonly used technique in CPU scheduling as a core.
  • It is preemptive as processes are assigned CPU only for a fixed slice of time at most.
  • The disadvantage of it is more overhead of context switching.

Advantages of Round Robin CPU Scheduling Algorithm:

  • There is fairness since every process gets equal share of CPU.
  • The newly created process is added to end of ready queue.
  • A round-robin scheduler generally employs time-sharing, giving each job a time slot or quantum. 
  • While performing a round-robin scheduling, a particular time quantum is allotted to different jobs. 
  • Each process get a chance to reschedule after a particular quantum time in this scheduling. 

Disadvantages of Round Robin CPU Scheduling Algorithm:

  • There is Larger waiting time and Response time.
  • There is Low throughput.
  • There is Context Switches.
  • Gantt chart seems to come too big (if quantum time is less for scheduling. For Example:1 ms for big scheduling.)
  • Time consuming scheduling for small quantum.
 

Examples to show working of Round Robin Scheduling Algorithm:

Example-1: Consider the following table of arrival time and burst time for four processes P1, P2, P3, and P4 and given Time Quantum = 2

ProcessBurst TimeArrival Time
 P1   5 ms0 ms
 P2 4 ms1 ms
 P3 2 ms2 ms
 P4 1 ms4 ms

The Round Robin CPU Scheduling Algorithm will work on the basis of steps as mentioned below:

At time = 0,

  • The execution begins with process P1, which has burst time 5. 
  • Here, every process executes for 2 milliseconds (Time Quantum Period). P2 and P3 are still in the waiting queue.
Time InstanceProcessArrival TimeReady QueueRunning QueueExecution TimeInitial Burst TimeRemaining Burst 
Time
0-2msP10msP2, P3P12ms5ms3ms

At time = 2,

  • The processes P2 and P3 arrives in the ready queue and P2 starts executing for TQ period
Time InstanceProcessArrival TimeReady QueueRunning QueueExecution TimeInitial Burst TimeRemaining Burst 
Time
2-4msP10msP3, P1P20ms5ms3ms
P21ms2ms4ms2ms

At time = 4,

  • The process P4 arrives in the ready queue
  • Then P3 executes for TQ period.
Time InstanceProcessArrival TimeReady QueueRunning QueueExecution TimeInitial Burst TimeRemaining Burst 
Time
4-6msP10msP1, P4, P2P30ms5ms3ms
P21ms0ms4ms2ms
P32ms2ms2ms0ms

At time = 6,

  • Process P3 completes its execution
  • Process P1 starts executing for TQ period as it is next in the b.
Time InstanceProcessArrival TimeReady QueueRunning QueueExecution TimeInitial Burst TimeRemaining Burst 
Time
6-8msP10msP4, P2P12ms3ms1ms
P21ms0ms4ms2ms

At time = 8,

  • Process P4 starts executing, it will not execute for Time Quantum period as it has burst time = 1
  • Hence, it will execute for only 1ms. 
Time InstanceProcessArrival TimeReady QueueRunning QueueExecution TimeInitial Burst TimeRemaining Burst 
Time
8-9msP10msP2, P1P40ms3ms1ms
P21ms0ms4ms2ms
P44ms1ms1ms0ms

At time = 9,

  • Process P4 completes its execution
  • Process P2 starts executing for TQ period as it is next in the ready queue
Time InstanceProcessArrival TimeReady QueueRunning QueueExecution TimeInitial Burst TimeRemaining Burst 
Time
9-11msP10msP1P20ms3ms1ms
P21ms2ms2ms0ms

At time = 11,

  • Process P2 completes its execution.
  • Process P1 starts executing, it will execute for 1ms only
Time InstanceProcessArrival TimeReady QueueRunning QueueExecution TimeInitial Burst TimeRemaining Burst 
Time
11-12msP10ms P11ms1ms0ms

At time = 12,

  • Process P1 completes its execution.
  • The overall execution of the processes will be as shown below:
Time InstanceProcessArrival TimeReady QueueRunning QueueExecution TimeInitial Burst TimeRemaining Burst 
Time
0-2msP10msP2, P3P12ms5ms3ms
2-4msP10msP3, P1P20ms5ms3ms
P21ms2ms4ms2ms
4-6msP10msP1, P4, P2P30ms5ms3ms
P21ms0ms4ms2ms
P32ms2ms2ms0ms
6-8msP10msP4, P2P12ms3ms1ms
P21ms0ms4ms2ms
8-9msP10msP2, P1P40ms3ms1ms
P21ms0ms4ms2ms
P44ms1ms1ms0ms
9-11msP10msP1P20ms3ms1ms
P21ms2ms2ms0ms
11-12msP10ms P11ms1ms0ms

Gantt chart will be as following below: 

Gantt chart for Round Robin Scheduling Algorithm

How to compute below times in Round Robin using a program? 

  • Completion Time: Time at which process completes its execution.
  • Turn Around Time: Time Difference between completion time and arrival time. Turn Around Time = Completion Time – Arrival Time
  • Waiting Time(W.T): Time Difference between turn around time and burst time. 
    Waiting Time = Turn Around Time – Burst Time

Now, lets calculate average waiting time and turn around time:

ProcessesATBTCTTATWT
P1051212-0 = 1212-5 = 7
P2141111-1 = 1010-4 = 6
P32266-2 = 44-2 = 2
P44199-4 = 55-1 = 4

Now, 

  • Average Turn around time = (12 + 10 + 4 + 5)/4 = 31/4 = 7.7
  • Average waiting time = (7 + 6 + 2 + 4)/4 = 19/4 = 4.7

Example 2: Consider the following table of arrival time and burst time for three processes P1, P2 and P3 and given Time Quantum = 2

ProcessBurst TimeArrival Time
 P1   10 ms0 ms
 P2 5 ms0 ms
 P3 8 ms0 ms

Similarly, Gantt chart for this example:

Gantt chart for example 2

Now, lets calculate average waiting time and turn around time:

ProcessesATBTCTTATWT
P10102323-0 = 2323-10 = 13
P2051515-0 = 1515-5 = 10
P3082121-0 = 2121-8 = 13

Total Turn Around Time = 59 ms
So, Average Turn Around Time = 59/3 = 19.667 ms

And, Total Waiting Time = 36 ms
So, Average Waiting Time = 36/3 = 12.00 ms 

Program for Round Robin Scheduling with arrival time as 0 for all processes:

Steps to find waiting times of all processes: 

  • Create an array rem_bt[] to keep track of remaining burst time of processes. This array is initially a copy of bt[] (burst times array)
  • Create another array wt[] to store waiting times of processes. Initialize this array as 0.
  • Initialize time : t = 0
  • Keep traversing all the processes while they are not done. Do following for i’th process if it is not done yet.
    • If rem_bt[i] > quantum
      • t = t + quantum
      • rem_bt[i] -= quantum;
    • Else // Last cycle for this process
      • t = t + rem_bt[i];
      • wt[i] = t – bt[i]
      • rem_bt[i] = 0; // This process is over

Once we have waiting times, we can compute turn around time tat[i] of a process as sum of waiting and burst times, i.e., wt[i] + bt[i]

Below is implementation of above steps. 

C++




// C++ program for implementation of RR scheduling 
#include<iostream> 
using namespace std; 
  
// Function to find the waiting time for all 
// processes 
void findWaitingTime(int processes[], int n, 
            int bt[], int wt[], int quantum) 
    // Make a copy of burst times bt[] to store remaining 
    // burst times. 
    int rem_bt[n]; 
    for (int i = 0 ; i < n ; i++) 
        rem_bt[i] = bt[i]; 
  
    int t = 0; // Current time 
  
    // Keep traversing processes in round robin manner 
    // until all of them are not done. 
    while (1) 
    
        bool done = true
  
        // Traverse all processes one by one repeatedly 
        for (int i = 0 ; i < n; i++) 
        
            // If burst time of a process is greater than 0 
            // then only need to process further 
            if (rem_bt[i] > 0) 
            
                done = false; // There is a pending process 
  
                if (rem_bt[i] > quantum) 
                
                    // Increase the value of t i.e. shows 
                    // how much time a process has been processed 
                    t += quantum; 
  
                    // Decrease the burst_time of current process 
                    // by quantum 
                    rem_bt[i] -= quantum; 
                
  
                // If burst time is smaller than or equal to 
                // quantum. Last cycle for this process 
                else
                
                    // Increase the value of t i.e. shows 
                    // how much time a process has been processed 
                    t = t + rem_bt[i]; 
  
                    // Waiting time is current time minus time 
                    // used by this process 
                    wt[i] = t - bt[i]; 
  
                    // As the process gets fully executed 
                    // make its remaining burst time = 0 
                    rem_bt[i] = 0; 
                
            
        
  
        // If all processes are done 
        if (done == true
        break
    
  
// Function to calculate turn around time 
void findTurnAroundTime(int processes[], int n, 
                        int bt[], int wt[], int tat[]) 
    // calculating turnaround time by adding 
    // bt[i] + wt[i] 
    for (int i = 0; i < n ; i++) 
        tat[i] = bt[i] + wt[i]; 
  
// Function to calculate average time 
void findavgTime(int processes[], int n, int bt[], 
                                    int quantum) 
    int wt[n], tat[n], total_wt = 0, total_tat = 0; 
  
    // Function to find waiting time of all processes 
    findWaitingTime(processes, n, bt, wt, quantum); 
  
    // Function to find turn around time for all processes 
    findTurnAroundTime(processes, n, bt, wt, tat); 
  
    // Display processes along with all details 
    cout << "PN\t "<< " \tBT "
        << "  WT " << " \tTAT\n"
  
    // Calculate total waiting time and total turn 
    // around time 
    for (int i=0; i<n; i++) 
    
        total_wt = total_wt + wt[i]; 
        total_tat = total_tat + tat[i]; 
        cout << " " << i+1 << "\t\t" << bt[i] <<"\t "
            << wt[i] <<"\t\t " << tat[i] <<endl; 
    
  
    cout << "Average waiting time = "
        << (float)total_wt / (float)n; 
    cout << "\nAverage turn around time = "
        << (float)total_tat / (float)n; 
  
// Driver code 
int main() 
    // process id's 
    int processes[] = { 1, 2, 3}; 
    int n = sizeof processes / sizeof processes[0]; 
  
    // Burst time of all processes 
    int burst_time[] = {10, 5, 8}; 
  
    // Time quantum 
    int quantum = 2; 
    findavgTime(processes, n, burst_time, quantum); 
    return 0; 

Java




// Java program for implementation of RR scheduling
  
public class GFG 
{
    // Method to find the waiting time for all
    // processes
    static void findWaitingTime(int processes[], int n,
                 int bt[], int wt[], int quantum)
    {
        // Make a copy of burst times bt[] to store remaining
        // burst times.
        int rem_bt[] = new int[n];
        for (int i = 0 ; i < n ; i++)
            rem_bt[i] =  bt[i];
       
        int t = 0; // Current time
       
        // Keep traversing processes in round robin manner
        // until all of them are not done.
        while(true)
        {
            boolean done = true;
       
            // Traverse all processes one by one repeatedly
            for (int i = 0 ; i < n; i++)
            {
                // If burst time of a process is greater than 0
                // then only need to process further
                if (rem_bt[i] > 0)
                {
                    done = false; // There is a pending process
       
                    if (rem_bt[i] > quantum)
                    {
                        // Increase the value of t i.e. shows
                        // how much time a process has been processed
                        t += quantum;
       
                        // Decrease the burst_time of current process
                        // by quantum
                        rem_bt[i] -= quantum;
                    }
       
                    // If burst time is smaller than or equal to
                    // quantum. Last cycle for this process
                    else
                    {
                        // Increase the value of t i.e. shows
                        // how much time a process has been processed
                        t = t + rem_bt[i];
       
                        // Waiting time is current time minus time
                        // used by this process
                        wt[i] = t - bt[i];
       
                        // As the process gets fully executed
                        // make its remaining burst time = 0
                        rem_bt[i] = 0;
                    }
                }
            }
       
            // If all processes are done
            if (done == true)
              break;
        }
    }
       
    // Method to calculate turn around time
    static void findTurnAroundTime(int processes[], int n,
                            int bt[], int wt[], int tat[])
    {
        // calculating turnaround time by adding
        // bt[i] + wt[i]
        for (int i = 0; i < n ; i++)
            tat[i] = bt[i] + wt[i];
    }
       
    // Method to calculate average time
    static void findavgTime(int processes[], int n, int bt[],
                                         int quantum)
    {
        int wt[] = new int[n], tat[] = new int[n];
        int total_wt = 0, total_tat = 0;
       
        // Function to find waiting time of all processes
        findWaitingTime(processes, n, bt, wt, quantum);
       
        // Function to find turn around time for all processes
        findTurnAroundTime(processes, n, bt, wt, tat);
       
        // Display processes along with all details
        System.out.println("PN " + " B " +
                      " WT " + " TAT");
       
        // Calculate total waiting time and total turn
        // around time
        for (int i=0; i<n; i++)
        {
            total_wt = total_wt + wt[i];
            total_tat = total_tat + tat[i];
            System.out.println(" " + (i+1) + "\t\t" + bt[i] +"\t " +
                              wt[i] +"\t\t " + tat[i]);
        }
       
        System.out.println("Average waiting time = " +
                          (float)total_wt / (float)n);
        System.out.println("Average turn around time = " +
                           (float)total_tat / (float)n);
    }
      
    // Driver Method
    public static void main(String[] args)
    {
        // process id's
        int processes[] = { 1, 2, 3};
        int n = processes.length;
       
        // Burst time of all processes
        int burst_time[] = {10, 5, 8};
       
        // Time quantum
        int quantum = 2;
        findavgTime(processes, n, burst_time, quantum);
    }
}

Python3




# Python3 program for implementation of 
# RR scheduling 
  
# Function to find the waiting time 
# for all processes 
def findWaitingTime(processes, n, bt, 
                         wt, quantum): 
    rem_bt = [0] * n
  
    # Copy the burst time into rt[] 
    for i in range(n): 
        rem_bt[i] = bt[i]
    t = 0 # Current time 
  
    # Keep traversing processes in round 
    # robin manner until all of them are
    # not done. 
    while(1):
        done = True
  
        # Traverse all processes one by
        # one repeatedly 
        for i in range(n):
              
            # If burst time of a process is greater 
            # than 0 then only need to process further 
            if (rem_bt[i] > 0) :
                done = False # There is a pending process
                  
                if (rem_bt[i] > quantum) :
                  
                    # Increase the value of t i.e. shows 
                    # how much time a process has been processed 
                    t += quantum 
  
                    # Decrease the burst_time of current 
                    # process by quantum 
                    rem_bt[i] -= quantum 
                  
                # If burst time is smaller than or equal  
                # to quantum. Last cycle for this process 
                else:
                  
                    # Increase the value of t i.e. shows 
                    # how much time a process has been processed 
                    t = t + rem_bt[i] 
  
                    # Waiting time is current time minus 
                    # time used by this process 
                    wt[i] = t - bt[i] 
  
                    # As the process gets fully executed 
                    # make its remaining burst time = 0 
                    rem_bt[i] = 0
                  
        # If all processes are done 
        if (done == True):
            break
              
# Function to calculate turn around time 
def findTurnAroundTime(processes, n, bt, wt, tat):
      
    # Calculating turnaround time 
    for i in range(n):
        tat[i] = bt[i] + wt[i] 
  
  
# Function to calculate average waiting 
# and turn-around times. 
def findavgTime(processes, n, bt, quantum): 
    wt = [0] * n
    tat = [0] *
  
    # Function to find waiting time
    # of all processes 
    findWaitingTime(processes, n, bt, 
                         wt, quantum) 
  
    # Function to find turn around time
    # for all processes 
    findTurnAroundTime(processes, n, bt,
                                wt, tat) 
  
    # Display processes along with all details 
    print("Processes    Burst Time     Waiting"
                     "Time    Turn-Around Time")
    total_wt = 0
    total_tat = 0
    for i in range(n):
  
        total_wt = total_wt + wt[i] 
        total_tat = total_tat + tat[i] 
        print(" ", i + 1, "\t\t", bt[i], 
              "\t\t", wt[i], "\t\t", tat[i])
  
    print("\nAverage waiting time = %.5f "%(total_wt /n) )
    print("Average turn around time = %.5f "% (total_tat / n)) 
      
# Driver code 
if __name__ =="__main__":
      
    # Process id's 
    proc = [1, 2, 3]
    n = 3
  
    # Burst time of all processes 
    burst_time = [10, 5, 8
  
    # Time quantum 
    quantum = 2
    findavgTime(proc, n, burst_time, quantum)
  
# This code is contributed by
# Shubham Singh(SHUBHAMSINGH10)

C#




// C# program for implementation of RR
// scheduling
using System;
  
public class GFG {
      
    // Method to find the waiting time
    // for all processes
    static void findWaitingTime(int []processes,
             int n, int []bt, int []wt, int quantum)
    {
          
        // Make a copy of burst times bt[] to 
        // store remaining burst times.
        int []rem_bt = new int[n];
          
        for (int i = 0 ; i < n ; i++)
            rem_bt[i] = bt[i];
      
        int t = 0; // Current time
      
        // Keep traversing processes in round
        // robin manner until all of them are
        // not done.
        while(true)
        {
            bool done = true;
      
            // Traverse all processes one by
            // one repeatedly
            for (int i = 0 ; i < n; i++)
            {
                // If burst time of a process
                // is greater than 0 then only
                // need to process further
                if (rem_bt[i] > 0)
                {
                      
                    // There is a pending process
                    done = false;
      
                    if (rem_bt[i] > quantum)
                    {
                        // Increase the value of t i.e.
                        // shows how much time a process
                        // has been processed
                        t += quantum;
      
                        // Decrease the burst_time of 
                        // current process by quantum
                        rem_bt[i] -= quantum;
                    }
      
                    // If burst time is smaller than
                    // or equal to quantum. Last cycle
                    // for this process
                    else
                    {
                          
                        // Increase the value of t i.e.
                        // shows how much time a process
                        // has been processed
                        t = t + rem_bt[i];
      
                        // Waiting time is current
                        // time minus time used by 
                        // this process
                        wt[i] = t - bt[i];
      
                        // As the process gets fully 
                        // executed make its remaining
                        // burst time = 0
                        rem_bt[i] = 0;
                    }
                }
            }
      
            // If all processes are done
            if (done == true)
            break;
        }
    }
      
    // Method to calculate turn around time
    static void findTurnAroundTime(int []processes,
               int n, int []bt, int []wt, int []tat)
    {
        // calculating turnaround time by adding
        // bt[i] + wt[i]
        for (int i = 0; i < n ; i++)
            tat[i] = bt[i] + wt[i];
    }
      
    // Method to calculate average time
    static void findavgTime(int []processes, int n,
                             int []bt, int quantum)
    {
        int []wt = new int[n];
        int []tat = new int[n];
        int total_wt = 0, total_tat = 0;
      
        // Function to find waiting time of
        // all processes
        findWaitingTime(processes, n, bt, wt, quantum);
      
        // Function to find turn around time
        // for all processes
        findTurnAroundTime(processes, n, bt, wt, tat);
      
        // Display processes along with
        // all details
        Console.WriteLine("Processes " + " Burst time " +
                    " Waiting time " + " Turn around time");
      
        // Calculate total waiting time and total turn
        // around time
        for (int i = 0; i < n; i++)
        {
            total_wt = total_wt + wt[i];
            total_tat = total_tat + tat[i];
            Console.WriteLine(" " + (i+1) + "\t\t" + bt[i] 
                         + "\t " + wt[i] +"\t\t " + tat[i]);
        }
      
        Console.WriteLine("Average waiting time = " +
                        (float)total_wt / (float)n);
        Console.Write("Average turn around time = " +
                        (float)total_tat / (float)n);
    }
      
    // Driver Method
    public static void Main()
    {
        // process id's
        int []processes = { 1, 2, 3};
        int n = processes.Length;
      
        // Burst time of all processes
        int []burst_time = {10, 5, 8};
      
        // Time quantum
        int quantum = 2;
        findavgTime(processes, n, burst_time, quantum);
    }
}
  
// This code is contributed by nitin mittal.

Javascript




<script>
    // JavaScript program for implementation of RR scheduling
  
    // Function to find the waiting time for all
    // processes
    const findWaitingTime = (processes, n, bt, wt, quantum) => {
        // Make a copy of burst times bt[] to store remaining
        // burst times.
        let rem_bt = new Array(n).fill(0);
        for (let i = 0; i < n; i++)
            rem_bt[i] = bt[i];
  
        let t = 0; // Current time
  
        // Keep traversing processes in round robin manner
        // until all of them are not done.
        while (1) {
            let done = true;
  
            // Traverse all processes one by one repeatedly
            for (let i = 0; i < n; i++) {
                // If burst time of a process is greater than 0
                // then only need to process further
                if (rem_bt[i] > 0) {
                    done = false; // There is a pending process
  
                    if (rem_bt[i] > quantum) {
                        // Increase the value of t i.e. shows
                        // how much time a process has been processed
                        t += quantum;
  
                        // Decrease the burst_time of current process
                        // by quantum
                        rem_bt[i] -= quantum;
                    }
  
                    // If burst time is smaller than or equal to
                    // quantum. Last cycle for this process
                    else {
                        // Increase the value of t i.e. shows
                        // how much time a process has been processed
                        t = t + rem_bt[i];
  
                        // Waiting time is current time minus time
                        // used by this process
                        wt[i] = t - bt[i];
  
                        // As the process gets fully executed
                        // make its remaining burst time = 0
                        rem_bt[i] = 0;
                    }
                }
            }
  
            // If all processes are done
            if (done == true)
                break;
        }
    }
  
    // Function to calculate turn around time
    const findTurnAroundTime = (processes, n, bt, wt, tat) => {
        // calculating turnaround time by adding
        // bt[i] + wt[i]
        for (let i = 0; i < n; i++)
            tat[i] = bt[i] + wt[i];
    }
  
    // Function to calculate average time
    const findavgTime = (processes, n, bt, quantum) => {
        let wt = new Array(n).fill(0), tat = new Array(n).fill(0);
        let total_wt = 0, total_tat = 0;
  
        // Function to find waiting time of all processes
        findWaitingTime(processes, n, bt, wt, quantum);
  
        // Function to find turn around time for all processes
        findTurnAroundTime(processes, n, bt, wt, tat);
  
        // Display processes along with all details
        document.write(`Processes Burst time Waiting time Turn around time<br/>`);
  
        // Calculate total waiting time and total turn
        // around time
        for (let i = 0; i < n; i++) {
            total_wt = total_wt + wt[i];
            total_tat = total_tat + tat[i];
  
            document.write(`${i + 1} ${bt[i]} ${wt[i]} ${tat[i]}<br/>`);
        }
  
        document.write(`Average waiting time = ${total_wt / n}`);
        document.write(`<br/>Average turn around time = ${total_tat / n}`);
    }
  
    // Driver code
    // process id's
    processes = [1, 2, 3];
    let n = processes.length;
  
    // Burst time of all processes
    let burst_time = [10, 5, 8];
  
    // Time quantum
    let quantum = 2;
    findavgTime(processes, n, burst_time, quantum);
  
    // This code is contributed by rakeshsahni
  
</script>

Output

PN          BT   WT      TAT
 1        10     13         23
 2        5     10         15
 3        8     13         21
Average waiting time = 12
Average turn around time = 19.6667

Program for Round Robin Scheduling with different arrival times for all processes

For detailed implementation of Preemptive Round Robin algorithm with different arrival times for all processes please refer: Program for Round Robin Scheduling with different arrival times

This article is contributed by Sahil Chhabra. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.


My Personal Notes arrow_drop_up
Related Articles

Start Your Coding Journey Now!