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 a cyclic nature starvation doesn’t occur
  • Round robin is variant of first come, first scheduling
  • No priority, special importance given to any process or task
  • RR scheduling is also know as Time slicing scheduling

Advantages:

  • Each process is served by Cpu for a fixed time so priority is same for each one
  • Starvation is not occur because of cyclic nataure.

Disadvantages:

  • The quantum time make the throughput depend on it.
  • if we want to give some process take first than other we can’t do these.
Process Arrival Time Burst Time
P1 0 10
P2 1 4
P3 2 5
P4 3 3

Quantum time is 3 that mean each process is only executing for only 3 unit at a time.



How to compute these process request:-

  1. Take the process which occur first and start executing the process.(only for quantum time only)
  2. Check that is any other process is come. if the process come in between quantum time in which process is executing then add it to the Ready queue
  3. After quantum time check is any process in Ready queue if ready queue is empty continue process if not empty then and if current process is not complete then add it to the ready queue at last.
  4. Take the first process from ready queue and executing it (same rules)
  5. Repeat all above step form 2-5
  6. If the process is complete and the ready queue is empty then task is complete

After all these we get the three time which are:

  1. Completion Time: the time at which process is complete.
  2. Turn Around Time: total time the process exist 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


My Personal Notes arrow_drop_up

My name is Abhishek i am currenty persuing the BE from Cgc LangranMohalli

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.