# Round Robin Scheduling with different arrival times

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 are arrived in the quantum time that make these scheduling fairly

Note:

• Round robin is cyclic in nature so starvation doesn’t occur
• Round robin is 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 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.
Process Arrival Time Burst Time
P1 0 10
P2 1 4
P3 2 5
P4 3 3

Quantum time is 3 this means each process is only executing for 3 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 quantum time has passed, check for any processes in Ready queue. If ready queue is empty continue current process. If queue not empty and current process is not complete, then add 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 process is complete and the ready queue is empty then 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 system.(completion time – arrival time).
3. Waiting Time: total time the waiting for there complete execution.(turn around time – burst time ).

How to implement in programming language

```1. Create two arrays of burst time res_b[] and of
arrival time res_a[] and copy the value of
the b[] and a[] array for calculate the
remaining time.(b[] is burst time, a[] arrival time).
2. Create an another array for wt[] to store waiting time.
3. Initialize Time : t=0;
4. Keep traversing the all process while all
process are not done.
Do following for i'th process if it is not done yet.
a- if res_a[i]<= q   (quantum time :- q)
1. if res_b[i]>q
a. t=t+q
b. res_b[i]-=q;
c. a[i]+=q;
2. else res_b[i]<=q(for last to execute)
a. t=t+b[i];
b. wt[i]=t-b[i]-a[i];
c.res_b[i]=0;
b- else res_a[i]<q
1. Initialize j=0 to number of process
if a[j]<a[i] (compare is there any
other process come before these process)
1. if res_b[j]>q
a. t=t+q
b. res_b[j]-=q;
c. a[j]+=q;
2. else res_b[j]<=q
a. t=t+b[j];
b. wt[j]=t-b[j]-a[j];
c.res_b[j]=0;
2. now we executing the i'th process
1. if res_b[i]>q
a. t=t+q
b. res_b[i]-=q;
c. a[i]+=q;
2. else res_b[i]<=q
a. t=t+b[i];
b. wt[i]=t-b[i]-a[i];
c.res_b[i]=0;
```

Below is the implementation of the above approach:

 `// Java program to implement Round Robin ` `// Scheduling with different arrival time ` `class` `roundrobin { ` `    ``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 = ``new` `String(); ` ` `  `        ``// 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``; ` `            ``} ` `        ``} ` ` `  `        ``System.out.println(``"name  ctime  wtime"``); ` `        ``for` `(``int` `i = ``0``; i < p.length; i++) { ` `            ``System.out.println(``" "` `+ p[i] + ``"    "` `+ comp[i] ` `                               ``+ ``"    "` `+ w[i]); ` ` `  `            ``res = res + w[i]; ` `            ``resc = resc + comp[i]; ` `        ``} ` ` `  `        ``System.out.println(``"Average waiting time is "` `                           ``+ (``float``)res / p.length); ` `        ``System.out.println(``"Average compilation  time is "` `                           ``+ (``float``)resc / p.length); ` `        ``System.out.println(``"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); ` `    ``} ` `} `

Output:

```name  ctime  wtime
p1    22    12
p2    15    11
p3    16    11
p4    9    6
Average waiting time is 10.0
Average compilation  time is 15.5
Sequence is like that ->p1->p2->p3->p4->p1->p2->p3->p1->p1
```