Program for Round Robin Scheduling for the Same Arrival Time (original) (raw)

Last Updated : 23 Jul, 2025

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

This article focuses on **implementing a Round Robin Scheduling Program where all processes have the same arrival time. In this scenario, all processes arrive at the same time which makes scheduling easier. You can focus on the main logic of dividing CPU time equally and managing the process queue.

Characteristics of Round Robin CPU Scheduling Algorithm with Same Arrival Time

Below are the key characteristics of the Round Robin Scheduling Algorithm when all processes share the same arrival time:

1. **Equal Time Allocation: Each process gets an equal and fixed time slice (time quantum) to execute, ensuring fairness.
2. **Cyclic Execution: Processes are scheduled in a circular order, and the CPU moves to the next process in the queue after completing the time quantum.
3. **No Process Starvation: All processes are guaranteed CPU time at regular intervals, preventing any process from being neglected.
4. **Same Start Time: Since all processes arrive at the same time, there is no need to consider arrival time while scheduling, simplifying the process.
5. **Context Switching: Frequent context switching occurs as the CPU moves between processes after each time quantum, which can slightly impact performance.

**Example of Round Robin Scheduling Algorithm for the Same Arrival Time

**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

**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 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);
}

}

Python

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] * n

# 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 ``

``

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

**Next Article to Read: **Program for Round Robin Scheduling with Different Arrival Times for all Processes

Conclusion

In conclusion, Round Robin CPU scheduling is a fair and preemptive algorithm that allocates a fixed time quantum to each process, ensuring equal CPU access. It is simple to implement but can lead to higher context-switching overhead. While it promotes fairness and prevents starvation, it may result in longer waiting times and reduced throughput, depending on the time quantum. Effective program implementation allows for the calculation of key metrics like completion time, turnaround time, and waiting time, aiding in performance evaluation and optimization.