Program for Round Robin Scheduling for the same Arrival time

Last Updated : 06 Dec, 2023

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.Â

• 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 a fair share of CPU.
• One of the most commonly used techniques in CPU scheduling is 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 an equal share of the CPU.
• The newly created process is added to the end of the 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

Process Burst Time Arrival Time
Â P1 Â  Â 5 ms 0 ms
Â P2 Â 4 ms 1 ms
Â P3 Â 2 ms 2 ms
Â P4 Â 1 ms 4 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 Instance Process Arrival Time Ready Queue Running Queue Execution Time Initial Burst Time Remaining BurstÂ
Time
0-2ms P1 0ms P2, P3 P1 2ms 5ms 3ms

At time = 2,

• The processes P1 and P3 arrives in the ready queue and P2 starts executing for TQ period
Time Instance Process Arrival Time Ready Queue Running Queue Execution Time Initial Burst Time Remaining BurstÂ
Time
2-4ms P1 0ms P3, P1 P2 0ms 3ms 3ms
P2 1ms 2ms 4ms 2ms

At time = 4,

• The process P4 arrives in the ready queue,Â
• Then P3 executes for TQ period.
Time Instance Process Arrival Time Ready Queue Running Queue Execution Time Initial Burst Time Remaining BurstÂ
Time
4-6ms P1 0ms P1, P4, P2 P3 0ms 3ms 3ms
P2 1ms 0ms 2ms 2ms
P3 2ms 2ms 2ms 0ms

At time = 6,

• Process P3 completes its execution
• Process P1 starts executing for TQ period as it is next in the b.
Time Instance Process Arrival Time Ready Queue Running Queue Execution Time Initial Burst Time Remaining BurstÂ
Time
6-8ms P1 0ms P4, P2 P1 2ms 3ms 1ms
P2 1ms 0ms 2ms 2ms

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 Instance Process Arrival Time Ready Queue Running Queue Execution Time Initial Burst Time Remaining BurstÂ
Time
8-9ms P1 0ms P2, P1 P4 0ms 3ms 1ms
P2 1ms 0ms 2ms 2ms
P4 4ms 1ms 1ms 0ms

At time = 9,

• Process P4 completes its execution
• Process P2 starts executing for TQ period as it is next in the ready queue
Time Instance Process Arrival Time Ready Queue Running Queue Execution Time Initial Burst Time Remaining BurstÂ
Time
9-11ms P1 0ms P1 P2 0ms 3ms 1ms
P2 1ms 2ms 2ms 0ms

At time = 11,

• Process P2 completes its execution.
• Process P1 starts executing, it will execute for 1ms only
Time Instance Process Arrival Time Ready Queue Running Queue Execution Time Initial Burst Time Remaining BurstÂ
Time
11-12ms P1 0ms Â  P1 1ms 1ms 0ms

At time = 12,

• Process P1 completes its execution.
• The overall execution of the processes will be as shown below:
Time Instance Process Arrival Time Ready Queue Running Queue Execution Time Initial Burst Time Remaining BurstÂ
Time
0-2ms P1 0ms P2, P3 P1 2ms 5ms 3ms
2-4ms P1 0ms P3, P1 P2 0ms 3ms 3ms
P2 1ms 2ms 4ms 2ms
4-6ms P1 0ms P1, P4, P2 P3 0ms 3ms 3ms
P2 1ms 0ms 2ms 2ms
P3 2ms 2ms 2ms 0ms
6-8ms P1 0ms P4, P2 P1 2ms 3ms 1ms
P2 1ms 0ms 2ms 2ms
8-9ms P1 0ms P2, P1 P4 0ms 3ms 1ms
P2 1ms 0ms 2ms 2ms
P4 4ms 1ms 1ms 0ms
9-11ms P1 0ms P1 P2 0ms 3ms 1ms
P2 1ms 2ms 2ms 0ms
11-12ms P1 0ms Â  P1 1ms 1ms 0ms

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:

Processes AT BT CT TAT WT
P1 0 5 12 12-0 = 12 12-5 = 7
P2 1 4 11 11-1 = 10 10-4 = 6
P3 2 2 6 6-2 = 4 4-2 = 2
P4 4 1 9 9-4 = 5 5-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

Process Burst Time Arrival Time
Â P1 Â  Â 10 ms 0 ms
Â P2 Â 5 ms 0 ms
Â P3 Â 8 ms 0 ms

Similarly, Gantt chart for this example:

Gantt chart for example 2

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

Processes AT BT CT TAT WT
P1 0 10 23 23-0 = 23 23-10 = 13
P2 0 5 15 15-0 = 15 15-5 = 10
P3 0 8 21 21-0 = 21 21-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 ` `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

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

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

```

C++

 `#include ` `#include ` `using` `namespace` `std;`   `struct` `Process {` `    ``int` `AT, BT, ST[20], WT, FT, TAT, pos;` `};`   `int` `quant;`   `int` `main() {` `    ``int` `n, i, j;`   `    ``// Taking Input` `    ``cout << ``"Enter the no. of processes: "``;` `    ``cin >> n;` `    ``Process p[n];`   `    ``cout << ``"Enter the quantum: "` `<< endl;` `    ``cin >> quant;`   `    ``cout << ``"Enter the process numbers: "` `<< endl;` `    ``for` `(i = 0; i < n; i++)` `        ``cin >> p[i].pos;`   `    ``cout << ``"Enter the Arrival time of processes: "` `<< endl;` `    ``for` `(i = 0; i < n; i++)` `        ``cin >> p[i].AT;`   `    ``cout << ``"Enter the Burst time of processes: "` `<< endl;` `    ``for` `(i = 0; i < n; i++)` `        ``cin >> p[i].BT;`   `    ``// Declaring variables` `    ``int` `c = n, s[n][20];` `    ``float` `time` `= 0, mini = INT_MAX, b[n], a[n];`   `    ``// Initializing burst and arrival time arrays` `    ``int` `index = -1;` `    ``for` `(i = 0; i < n; i++) {` `        ``b[i] = p[i].BT;` `        ``a[i] = p[i].AT;` `        ``for` `(j = 0; j < 20; j++) {` `            ``s[i][j] = -1;` `        ``}` `    ``}`   `    ``int` `tot_wt, tot_tat;` `    ``tot_wt = 0;` `    ``tot_tat = 0;` `    ``bool` `flag = ``false``;`   `    ``while` `(c != 0) {` `        ``mini = INT_MAX;` `        ``flag = ``false``;`   `        ``for` `(i = 0; i < n; i++) {` `            ``float` `p = ``time` `+ 0.1;` `            ``if` `(a[i] <= p && mini > a[i] && b[i] > 0) {` `                ``index = i;` `                ``mini = a[i];` `                ``flag = ``true``;` `            ``}` `        ``}`   `        ``// if at =1 then loop gets out hence set flag to false` `        ``if` `(!flag) {` `            ``time``++;` `            ``continue``;` `        ``}`   `        ``// calculating start time` `        ``j = 0;`   `        ``while` `(s[index][j] != -1) {` `            ``j++;` `        ``}`   `        ``if` `(s[index][j] == -1) {` `            ``s[index][j] = ``time``;` `            ``p[index].ST[j] = ``time``;` `        ``}`   `        ``if` `(b[index] <= quant) {` `            ``time` `+= b[index];` `            ``b[index] = 0;` `        ``} ``else` `{` `            ``time` `+= quant;` `            ``b[index] -= quant;` `        ``}`   `        ``if` `(b[index] > 0) {` `            ``a[index] = ``time` `+ 0.1;` `        ``}`   `        ``// calculating arrival, burst, final times` `        ``if` `(b[index] == 0) {` `            ``c--;` `            ``p[index].FT = ``time``;` `            ``p[index].WT = p[index].FT - p[index].AT - p[index].BT;` `            ``tot_wt += p[index].WT;` `            ``p[index].TAT = p[index].BT + p[index].WT;` `            ``tot_tat += p[index].TAT;` `        ``}` `    ``} ``// end of while loop`   `    ``// Printing output` `    ``cout << ``"Process number "``;` `    ``cout << ``"Arrival time "``;` `    ``cout << ``"Burst time "``;` `    ``cout << ``"\tStart time"``;` `    ``j = 0;` `    ``while` `(j != 10) {` `        ``j += 1;` `        ``cout << ``" "``;` `    ``}` `    ``cout << ``"\t\tFinal time"``;` `    ``cout << ``"\tWait Time "``;` `    ``cout << ``"\tTurnAround Time"` `<< endl;`   `    ``for` `(i = 0; i < n; i++) {` `        ``cout << p[i].pos << ``"\t\t"``;` `        ``cout << p[i].AT << ``"\t\t"``;` `        ``cout << p[i].BT << ``"\t"``;` `        ``j = 0;` `        ``int` `v = 0;` `        ``while` `(s[i][j] != -1) {` `            ``cout << p[i].ST[j] << ``" "``;` `            ``j++;` `            ``v += 3;` `        ``}` `        ``while` `(v != 40) {` `            ``cout << ``" "``;` `            ``v += 1;` `        ``}` `        ``cout << p[i].FT << ``"\t\t"``;` `        ``cout << p[i].WT << ``"\t\t"``;` `        ``cout << p[i].TAT << endl;` `    ``}`   `    ``// Calculating average wait time and turnaround time` `    ``double` `avg_wt, avg_tat;` `    ``avg_wt = tot_wt / ``static_cast``<``double``>(n);` `    ``avg_tat = tot_tat / ``static_cast``<``double``>(n);`   `    ``// Printing average wait time and turnaround time` `    ``cout << ``"The average wait time is: "` `<< avg_wt << endl;` `    ``cout << ``"The average TurnAround time is: "` `<< avg_tat << endl;`   `    ``return` `0;` `}`

C

 `#include` `#include` `#include`   `struct` `P{` `int` `AT,BT,ST[20],WT,FT,TAT,pos;` `};`   `int` `quant;` `int` `main(){` `int` `n,i,j;` `// Taking Input` `printf``(``"Enter the no. of processes :"``);` `scanf``(``"%d"``,&n);` `struct` `P p[n];` `  `  `printf``(``"Enter the quantum  \n"``);` `scanf``(``"%d"``,&quant);`   `printf``(``"Enter the process numbers \n"``);` `for``(i=0;ia[i] && b[i]>0){` `        ``index=i;` `        ``mini=a[i];` `        ``flag=``true``;` `       `  `        ``}` `}` `// if at =1 then loop gets out  hence set flag to false` `if``(!flag){` `        ``time``++;` `        ``continue``;` `}`   `//calculating start time` `j=0;`   `while``(s[index][j]!=-1){` `j++;` `}`   `if``(s[index][j]==-1){` `s[index][j]=``time``;` `p[index].ST[j]=``time``;` `}`   `if``(b[index]<=quant){` `time``+=b[index];` `b[index]=0;` `}` `else``{` `time``+=quant;` `b[index]-=quant;` `}`   `if``(b[index]>0){` `a[index]=``time``+0.1;` `}`   `// calculating arrival,burst,final times` `if``(b[index]==0){` `c--;` `p[index].FT=``time``;` `p[index].WT=p[index].FT-p[index].AT-p[index].BT;` `tot_wt+=p[index].WT;` `p[index].TAT=p[index].BT+p[index].WT;` `tot_tat+=p[index].TAT;`   `}`   `} ``// end of while loop`   `// Printing output` `printf``(``"Process number "``);` `printf``(``"Arrival time "``);` `printf``(``"Burst time "``);` `printf``(``"\tStart time"``);` `j=0;` `while``(j!=10){` `j+=1;` `printf``(``" "``);` `}` `printf``(``"\t\tFinal time"``);` `printf``(``"\tWait Time "``);` `printf``(``"\tTurnAround Time \n"``);`     `for``(i=0;i

Output:

`Enter the number of processes : 4Enter the time quanta : 2Enter the process numbers : 1 2 3 4Enter the arrival time of the processes : 0 1 2 3Enter the burst time of the processes : 5 4 2 1Program No.     Arrival Time    Burst Time      Wait Time       TurnAround Time1               0               5               7               122               1               4               6               103               2               2               2               44               3               1               5               6Average wait time : 5Average Turn Around Time : 8`

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.

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.Â