Related Articles
Round Robin Scheduling with different arrival times
• Difficulty Level : Medium
• Last Updated : 07 Apr, 2021

Prerequisite: Round Robin Scheduling with arrival time as 0

Round-robin scheduling algorithm is used to schedule process fairly each job a time slot or quantum and the interrupting the job if it is not completed by then the job come after the other job which is arrived in the quantum time that makes these scheduling fairly.

Note:

• Round-robin is cyclic in nature, so starvation doesn’t occur
• Round-robin is a variant of first come, first served scheduling
• No priority, special importance given to any process or task
• RR scheduling is also known as Time slicing scheduling

• Each process is served by CPU for a fixed time, so priority is the same for each one
• Starvation does not occur because of its cyclic nature.

• Throughput depends on quantum time.
• If we want to give some process priority, we cannot.

Quantum time is 2 this means each process is only executing for 2 units of time at a time.
How to compute these process requests:-

1. Take the process which occurs first and start executing the process(for quantum time only).
2. Check if any other process request has arrived. If a process request arrives during the quantum time in which another process is executing, then add the new process to the Ready queue
3. After the quantum time has passed, check for any processes in the Ready queue. If the ready queue is empty then continue the current process. If the queue not empty and the current process is not complete, then add the current process to the end of the ready queue.
4. Take the first process from the Ready queue and start executing it (same rules)
5. Repeat all steps above from 2-5
6. If the process is complete and the ready queue is empty then the task is complete

After all these we get the three times which are:

1. Completion Time: the time taken for a process to complete.
2. Turn Around Time: total time the process exists in the system. (completion time – arrival time).
3. Waiting Time: total time waiting for their complete execution. (turn around time – burst time ).

How to implement in a programming language

```1. Declare arrival[], burst[], wait[], turn[] arrays and initialize them. Also declare a timer
variable and initialize it to zero. To sustain the original burst array create another
array (temp_burst[]) and copy all the values of burst array in it.

2. To keep a check we create another array of bool type which keeps the record of whether a
process is completed or not. we also need to maintain a queue array which contains the process
indicies (initially the array is filled with 0).

3. Now we increment the timer variable until the first process arrives and when it does, we add the
process index to the queue array

4. Now we execute the first process until the time quanta and during that time quanta, we check
whether any other process has arrived or not and if it has then we add the index in the queue
(by calling the fxn. queueUpdation()).

5. Now, after doing the above steps if a process has finished, we store its exit time and
execute the next process in the queue array. Else, we move the currently executed process at
the end of the queue (by calling another fxn. queueMaintainence()) when the time slice expires.

6. The above steps are then repeated until all the processes have been completely executed. If a
scenario arises where there are some processes left but they have not arrived yet, then we
shall wait and the CPU will remain idle during this interval.```

Below is the implementation of the above approach:

(For the sake of simplicity, we assume that the arrival times are entered in a sorted way)

## C++

 `//C++ Program for implementing``//Round Robin Algorithm``//code by sparsh_cbs``#include ` `using` `namespace` `std;` `void` `queueUpdation(``int` `queue[],``int` `timer,``int` `arrival[],``int` `n, ``int` `maxProccessIndex){``    ``int` `zeroIndex;``    ``for``(``int` `i = 0; i < n; i++){``        ``if``(queue[i] == 0){``            ``zeroIndex = i;``            ``break``;``        ``}``    ``}  ``    ``queue[zeroIndex] = maxProccessIndex + 1;``}` `void` `queueMaintainence(``int` `queue[], ``int` `n){``    ``for``(``int` `i = 0; (i < n-1) && (queue[i+1] != 0) ; i++){``        ``int` `temp = queue[i];``        ``queue[i] = queue[i+1];``        ``queue[i+1] = temp;``    ``}``}` `void` `checkNewArrival(``int` `timer, ``int` `arrival[], ``int` `n, ``int` `maxProccessIndex,``int` `queue[]){``    ``if``(timer <= arrival[n-1]){``       ``bool` `newArrival = ``false``;``       ``for``(``int` `j = (maxProccessIndex+1); j < n; j++){``             ``if``(arrival[j] <= timer){``              ``if``(maxProccessIndex < j){``                 ``maxProccessIndex = j;``                 ``newArrival = ``true``;``              ``}``           ``}``       ``}``       ``//adds the incoming process to the ready queue``       ``//(if any arrives)``       ``if``(newArrival)``          ``queueUpdation(queue,timer,arrival,n, maxProccessIndex);``    ``}``}` `//Driver Code``int` `main(){``    ``int` `n,tq, timer = 0, maxProccessIndex = 0;``    ``float` `avgWait = 0, avgTT = 0;``    ``cout << ``"\nEnter the time quanta : "``;``    ``cin>>tq;``    ``cout << ``"\nEnter the number of processess : "``;``    ``cin>>n;``    ``int` `arrival[n], burst[n], wait[n], turn[n], queue[n], temp_burst[n];``    ``bool` `complete[n];` `    ``cout << ``"\nEnter the arrival time of the processess : "``;``    ``for``(``int` `i = 0; i < n; i++)``        ``cin>>arrival[i];` `    ``cout << ``"\nEnter the burst time of the processess : "``;``    ``for``(``int` `i = 0; i < n; i++){``        ``cin>>burst[i];``        ``temp_burst[i] = burst[i];``    ``}` `    ``for``(``int` `i = 0; i < n; i++){    ``//Initializing the queue and complete array``        ``complete[i] = ``false``;``        ``queue[i] = 0;``    ``}``    ``while``(timer < arrival)    ``//Incrementing Timer until the first process arrives``        ``timer++;``    ``queue = 1;``    ` `    ``while``(``true``){``        ``bool` `flag = ``true``;``        ``for``(``int` `i = 0; i < n; i++){``            ``if``(temp_burst[i] != 0){``                ``flag = ``false``;``                ``break``;``            ``}``        ``}``        ``if``(flag)``            ``break``;` `        ``for``(``int` `i = 0; (i < n) && (queue[i] != 0); i++){``            ``int` `ctr = 0;``            ``while``((ctr < tq) && (temp_burst[queue-1] > 0)){``                ``temp_burst[queue-1] -= 1;``                ``timer += 1;``                ``ctr++;` `                ``//Checking and Updating the ready queue untill all the processes arrive``                ``checkNewArrival(timer, arrival, n, maxProccessIndex, queue);``            ``}``            ``//If a process is completed then store its exit time``            ``//and mark it as completed``            ``if``((temp_burst[queue-1] == 0) && (complete[queue-1] == ``false``)){``                ``//turn array currently stores the completion time``                ``turn[queue-1] = timer;       ``                ``complete[queue-1] = ``true``;``            ``}``            ` `              ``//checks whether or not CPU is idle``            ``bool` `idle = ``true``;``            ``if``(queue[n-1] == 0){``                ``for``(``int` `i = 0; i < n && queue[i] != 0; i++){``                    ``if``(complete[queue[i]-1] == ``false``){``                        ``idle = ``false``;``                    ``}``                ``}``            ``}``            ``else``                ``idle = ``false``;` `            ``if``(idle){``                ``timer++;``                ``checkNewArrival(timer, arrival, n, maxProccessIndex, queue);``            ``}``      ` `            ``//Maintaining the entires of processes``            ``//after each premption in the ready Queue``            ``queueMaintainence(queue,n);``        ``}``    ``}` `    ``for``(``int` `i = 0; i < n; i++){``        ``turn[i] = turn[i] - arrival[i];``        ``wait[i] = turn[i] - burst[i];``    ``}` `    ``cout << ``"\nProgram No.\tArrival Time\tBurst Time\tWait Time\tTurnAround Time"``         ``<< endl;``    ``for``(``int` `i = 0; i < n; i++){``        ``cout<

## C#

 `// C# program to implement Round Robin``// Scheduling with different arrival time``using` `System;` `class` `GFG {``    ``public` `static` `void` `roundRobin(String[] p, ``int``[] a,``                                  ``int``[] b, ``int` `n)``    ``{``        ``// result of average times``        ``int` `res = 0;``        ``int` `resc = 0;` `        ``// for sequence storage``        ``String seq = ``""``;` `        ``// copy the burst array and arrival array``        ``// for not effecting the actual array``        ``int``[] res_b = ``new` `int``[b.Length];``        ``int``[] res_a = ``new` `int``[a.Length];` `        ``for` `(``int` `i = 0; i < res_b.Length; i++) {``            ``res_b[i] = b[i];``            ``res_a[i] = a[i];``        ``}` `        ``// critical time of system``        ``int` `t = 0;` `        ``// for store the waiting time``        ``int``[] w = ``new` `int``[p.Length];` `        ``// for store the Completion time``        ``int``[] comp = ``new` `int``[p.Length];` `        ``while` `(``true``) {``            ``Boolean flag = ``true``;``            ``for` `(``int` `i = 0; i < p.Length; i++) {` `                ``// these condition for if``                ``// arrival is not on zero` `                ``// check that if there come before qtime``                ``if` `(res_a[i] <= t) {``                    ``if` `(res_a[i] <= n) {``                        ``if` `(res_b[i] > 0) {``                            ``flag = ``false``;``                            ``if` `(res_b[i] > n) {` `                                ``// make decrease the b time``                                ``t = t + n;``                                ``res_b[i] = res_b[i] - n;``                                ``res_a[i] = res_a[i] + n;``                                ``seq += ``"->"` `+ p[i];``                            ``}``                            ``else` `{` `                                ``// for last time``                                ``t = t + res_b[i];` `                                ``// store comp time``                                ``comp[i] = t - a[i];` `                                ``// store wait time``                                ``w[i] = t - b[i] - a[i];``                                ``res_b[i] = 0;` `                                ``// add sequence``                                ``seq += ``"->"` `+ p[i];``                            ``}``                        ``}``                    ``}``                    ``else` `if` `(res_a[i] > n) {` `                        ``// is any have less arrival time``                        ``// the coming process then execute``                        ``// them``                        ``for` `(``int` `j = 0; j < p.Length; j++) {` `                            ``// compare``                            ``if` `(res_a[j] < res_a[i]) {``                                ``if` `(res_b[j] > 0) {``                                    ``flag = ``false``;``                                    ``if` `(res_b[j] > n) {``                                        ``t = t + n;``                                        ``res_b[j]``                                            ``= res_b[j] - n;``                                        ``res_a[j]``                                            ``= res_a[j] + n;``                                        ``seq += ``"->"` `+ p[j];``                                    ``}``                                    ``else` `{``                                        ``t = t + res_b[j];``                                        ``comp[j] = t - a[j];``                                        ``w[j] = t - b[j]``                                               ``- a[j];``                                        ``res_b[j] = 0;``                                        ``seq += ``"->"` `+ p[j];``                                    ``}``                                ``}``                            ``}``                        ``}` `                        ``// now the previous porcess``                        ``// according to ith is process``                        ``if` `(res_b[i] > 0) {``                            ``flag = ``false``;` `                            ``// Check for greaters``                            ``if` `(res_b[i] > n) {``                                ``t = t + n;``                                ``res_b[i] = res_b[i] - n;``                                ``res_a[i] = res_a[i] + n;``                                ``seq += ``"->"` `+ p[i];``                            ``}``                            ``else` `{``                                ``t = t + res_b[i];``                                ``comp[i] = t - a[i];``                                ``w[i] = t - b[i] - a[i];``                                ``res_b[i] = 0;``                                ``seq += ``"->"` `+ p[i];``                            ``}``                        ``}``                    ``}``                ``}` `                ``// if no process is come on thse critical``                ``else` `if` `(res_a[i] > t) {``                    ``t++;``                    ``i--;``                ``}``            ``}` `            ``// for exit the while loop``            ``if` `(flag) {``                ``break``;``            ``}``        ``}` `        ``Console.WriteLine(``"name   ctime   wtime"``);``        ``for` `(``int` `i = 0; i < p.Length; i++) {``            ``Console.WriteLine(``" "` `+ p[i] + ``"\t"` `+ comp[i]``                              ``+ ``"\t"` `+ w[i]);` `            ``res = res + w[i];``            ``resc = resc + comp[i];``        ``}` `        ``Console.WriteLine(``"Average waiting time is "``                          ``+ (``float``)res / p.Length);``        ``Console.WriteLine(``"Average compilation time is "``                          ``+ (``float``)resc / p.Length);``        ``Console.WriteLine(``"Sequence is like that "` `+ seq);``    ``}` `    ``// Driver Code``    ``public` `static` `void` `Main(String[] args)``    ``{``        ``// name of the process``        ``String[] name = { ``"p1"``, ``"p2"``, ``"p3"``, ``"p4"` `};` `        ``// arrival for every process``        ``int``[] arrivaltime = { 0, 1, 2, 3 };` `        ``// burst time for every process``        ``int``[] bursttime = { 10, 4, 5, 3 };` `        ``// quantum time of each process``        ``int` `q = 3;` `        ``// cal the function for output``        ``roundRobin(name, arrivaltime, bursttime, q);``    ``}``}` `// This code is contributed by Rajput-Ji`

## Java

 `//JAVA Program for implementing``//Round Robin Algorithm``// code by Sparsh_cbs``import` `java.util.*;` `public` `class` `RoundRobin{``    ``private` `static` `Scanner inp = ``new` `Scanner(System.in);``    ``//Driver Code``    ``public` `static` `void` `main(String[] args){``        ``int` `n,tq, timer = ``0``, maxProccessIndex = ``0``;``        ``float` `avgWait = ``0``, avgTT = ``0``;``        ``System.out.print(``"\nEnter the time quanta : "``);``        ``tq = inp.nextInt();``        ``System.out.print(``"\nEnter the number of processess : "``);``        ``n = inp.nextInt();``        ``int` `arrival[] = ``new` `int``[n];``        ``int` `burst[] = ``new` `int``[n];``        ``int` `wait[] = ``new` `int``[n];``        ``int` `turn[] = ``new` `int``[n];``        ``int` `queue[] = ``new` `int``[n];``        ``int` `temp_burst[] = ``new` `int``[n];``        ``boolean` `complete[] = ``new` `boolean``[n];` `        ``System.out.print(``"\nEnter the arrival time of the processess : "``);``        ``for``(``int` `i = ``0``; i < n; i++)``            ``arrival[i] = inp.nextInt();` `        ``System.out.print(``"\nEnter the burst time of the processess : "``);``        ``for``(``int` `i = ``0``; i < n; i++){``            ``burst[i] = inp.nextInt();``            ``temp_burst[i] = burst[i];``        ``}` `        ``for``(``int` `i = ``0``; i < n; i++){    ``//Initializing the queue and complete array``            ``complete[i] = ``false``;``            ``queue[i] = ``0``;``        ``}``        ``while``(timer < arrival[``0``])    ``//Incrementing Timer until the first process arrives``            ``timer++;``        ``queue[``0``] = ``1``;``        ` `        ``while``(``true``){``            ``boolean` `flag = ``true``;``            ``for``(``int` `i = ``0``; i < n; i++){``                ``if``(temp_burst[i] != ``0``){``                    ``flag = ``false``;``                    ``break``;``                ``}``            ``}``            ``if``(flag)``                ``break``;` `            ``for``(``int` `i = ``0``; (i < n) && (queue[i] != ``0``); i++){``                ``int` `ctr = ``0``;``                ``while``((ctr < tq) && (temp_burst[queue[``0``]-``1``] > ``0``)){``                    ``temp_burst[queue[``0``]-``1``] -= ``1``;``                    ``timer += ``1``;``                    ``ctr++;` `                    ``//Updating the ready queue untill all the processes arrive``                    ``checkNewArrival(timer, arrival, n, maxProccessIndex, queue);``                ``}``                ``if``((temp_burst[queue[``0``]-``1``] == ``0``) && (complete[queue[``0``]-``1``] == ``false``)){``                    ``turn[queue[``0``]-``1``] = timer;        ``//turn currently stores exit times``                    ``complete[queue[``0``]-``1``] = ``true``;``                ``}``                ` `                  ``//checks whether or not CPU is idle``                ``boolean` `idle = ``true``;``                ``if``(queue[n-``1``] == ``0``){``                    ``for``(``int` `k = ``0``; k < n && queue[k] != ``0``; k++){``                        ``if``(complete[queue[k]-``1``] == ``false``){``                            ``idle = ``false``;``                        ``}``                    ``}``                ``}``                ``else``                    ``idle = ``false``;` `                ``if``(idle){``                    ``timer++;``                    ``checkNewArrival(timer, arrival, n, maxProccessIndex, queue);``                ``}``              ` `                ``//Maintaining the entires of processes after each premption in the ready Queue``                ``queueMaintainence(queue,n);``            ``}``        ``}` `        ``for``(``int` `i = ``0``; i < n; i++){``            ``turn[i] = turn[i] - arrival[i];``            ``wait[i] = turn[i] - burst[i];``        ``}` `        ``System.out.print(``"\nProgram No.\tArrival Time\tBurst Time\tWait Time\tTurnAround Time"``                         ``+ ``"\n"``);``        ``for``(``int` `i = ``0``; i < n; i++){``            ``System.out.print(i+``1``+``"\t\t"``+arrival[i]+``"\t\t"``+burst[i]``                             ``+``"\t\t"``+wait[i]+``"\t\t"``+turn[i]+ ``"\n"``);``        ``}``        ``for``(``int` `i =``0``; i< n; i++){``            ``avgWait += wait[i];``            ``avgTT += turn[i];``        ``}``        ``System.out.print(``"\nAverage wait time : "``+(avgWait/n)``                         ``+``"\nAverage Turn Around Time : "``+(avgTT/n));``    ``}``    ``public` `static` `void` `queueUpdation(``int` `queue[],``int` `timer,``int` `arrival[],``int` `n, ``int` `maxProccessIndex){``        ``int` `zeroIndex = -``1``;``        ``for``(``int` `i = ``0``; i < n; i++){``            ``if``(queue[i] == ``0``){``                ``zeroIndex = i;``                ``break``;``            ``}``        ``}``        ``if``(zeroIndex == -``1``)``            ``return``;``        ``queue[zeroIndex] = maxProccessIndex + ``1``;``    ``}` `    ``public` `static` `void` `checkNewArrival(``int` `timer, ``int` `arrival[], ``int` `n, ``int` `maxProccessIndex,``int` `queue[]){``        ``if``(timer <= arrival[n-``1``]){``            ``boolean` `newArrival = ``false``;``            ``for``(``int` `j = (maxProccessIndex+``1``); j < n; j++){``                ``if``(arrival[j] <= timer){``                    ``if``(maxProccessIndex < j){``                        ``maxProccessIndex = j;``                        ``newArrival = ``true``;``                    ``}``                ``}``            ``}``            ``if``(newArrival)    ``//adds the index of the arriving process(if any)``                ``queueUpdation(queue,timer,arrival,n, maxProccessIndex);       ``        ``}``    ``}``  ` `    ``public` `static` `void` `queueMaintainence(``int` `queue[], ``int` `n){` `        ``for``(``int` `i = ``0``; (i < n-``1``) && (queue[i+``1``] != ``0``) ; i++){``            ``int` `temp = queue[i];``            ``queue[i] = queue[i+``1``];``            ``queue[i+``1``] = temp;``        ``}``    ``}``}`

Output:

```Enter the time quanta : 2

Enter the number of processess : 4

Enter the arrival time of the processess : 0 1 2 3

Enter the burst time of the processess : 5 4 2 1

Program No.     Arrival Time    Burst Time      Wait Time       TurnAround Time
1               0               5               7               12
2               1               4               6               10
3               2               2               2               4
4               3               1               5               6

Average wait time : 5
Average Turn Around Time : 8```

In case of any queries or a problem with the code, please write it in the comment section.

Note: A slightly optimized version of the above-implemented code could be by using Queue data structure.

My Personal Notes arrow_drop_up