SHARE
TWEET

Untitled

a guest Apr 20th, 2019 92 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. // Java program to implement Round Robin
  2. // Scheduling with different arrival time
  3. class roundrobin {
  4.     public static void roundRobin(String p[], int a[], int b[], int n)
  5.     {
  6.         // result of average times
  7.         int res = 0;
  8.         int resc = 0;
  9.  
  10.         // for sequence storage
  11.         String seq = new String();
  12.  
  13.         // copy the burst array and arrival array for not effecting the actual array
  14.         int res_b[] = new int[b.length];
  15.         int res_a[] = new int[a.length];
  16.  
  17.         for (int i = 0; i < res_b.length; i++)
  18.         {
  19.             res_b[i] = b[i];
  20.             res_a[i] = a[i];
  21.         }
  22.  
  23.         // critical time of system
  24.         int t = 0;
  25.  
  26.         // for store the waiting time
  27.         int w[] = new int[p.length];
  28.  
  29.         // for store the Completion time
  30.         int comp[] = new int[p.length];
  31.  
  32.         while (true)
  33.          {
  34.             boolean flag = true;
  35.             for (int i = 0; i < p.length; i++)
  36.             {
  37.  
  38.                 // these condition for if
  39.                 // arrival is not on zero
  40.  
  41.                 // check that if there come before qtime
  42.                 if (res_a[i] <= t)
  43.                  {
  44.                     if (res_a[i] <= n)
  45.                      {
  46.                         if (res_b[i] > 0)
  47.                          {
  48.                             flag = false;
  49.                             if (res_b[i] > n)
  50.                              {
  51.  
  52.                                 // make decrease the b time
  53.                                 t = t + n;
  54.                                 res_b[i] = res_b[i] - n;
  55.                                 res_a[i] = res_a[i] + n;
  56.                                 seq += "->" + p[i];
  57.                             }
  58.                             else {
  59.  
  60.                                 // for last time
  61.                                 t = t + res_b[i];
  62.  
  63.                                 // store comp time
  64.                                 comp[i] = t - a[i];
  65.  
  66.                                 // store wait time
  67.                                 w[i] = t - b[i] - a[i];
  68.                                 res_b[i] = 0;
  69.  
  70.                                 // add sequence
  71.                                 seq += "->" + p[i];
  72.                             }
  73.                         }
  74.                     }
  75.                     else if (res_a[i] > n)
  76.                      {
  77.  
  78.                         // is any have less arrival time
  79.                         // the coming process then execute them
  80.                         for (int j = 0; j < p.length; j++) {
  81.  
  82.                             // compare
  83.                             if (res_a[j] < res_a[i])
  84.                              {
  85.                                 if (res_b[j] > 0)
  86.                                  {
  87.                                     flag = false;
  88.                                     if (res_b[j] > n)
  89.                                      {
  90.                                         t = t + n;
  91.                                         res_b[j] = res_b[j] - n;
  92.                                         res_a[j] = res_a[j] + n;
  93.                                         seq += "->" + p[j];
  94.                                     }
  95.                                     else {
  96.                                         t = t + res_b[j];
  97.                                         comp[j] = t - a[j];
  98.                                         w[j] = t - b[j] - a[j];
  99.                                         res_b[j] = 0;
  100.                                         seq += "->" + p[j];
  101.                                     }
  102.                                 }
  103.                             }
  104.                         }
  105.  
  106.                         // now the previous porcess according to ith is process
  107.                         if (res_b[i] > 0) {
  108.                             flag = false;
  109.  
  110.                             // Check for greaters
  111.                             if (res_b[i] > n) {
  112.                                 t = t + n;
  113.                                 res_b[i] = res_b[i] - n;
  114.                                 res_a[i] = res_a[i] + n;
  115.                                 seq += "->" + p[i];
  116.                             }
  117.                             else {
  118.                                 t = t + res_b[i];
  119.                                 comp[i] = t - a[i];
  120.                                 w[i] = t - b[i] - a[i];
  121.                                 res_b[i] = 0;
  122.                                 seq += "->" + p[i];
  123.                             }
  124.                         }
  125.                     }
  126.                 }
  127.  
  128.                 // if no process is come on thse critical
  129.                 else if (res_a[i] > t) {
  130.                     t++;
  131.                     i--;
  132.                 }
  133.             }
  134.             // for exit the while loop
  135.             if (flag) {
  136.                 break;
  137.             }
  138.         }
  139.  
  140.         System.out.println("Process Name   Completion Time   Waiting Time");
  141.         for (int i = 0; i < p.length; i++) {
  142.             System.out.println(" " + p[i] + "        " + comp[i] + "          " + w[i]);
  143.  
  144.             res = res + w[i];
  145.             resc = resc + comp[i];
  146.         }
  147.  
  148.         System.out.println("Average waiting time is "+ (float)res / p.length);
  149.         System.out.println("Average compilation time is "+ (float)resc / p.length);
  150.         System.out.println("Sequence is like that " + seq);
  151.     }
  152.  
  153.     // Driver Code
  154.     public static void main(String args[])
  155.     {
  156.         // name of the process
  157.         String name[] = { "p1", "p2", "p3", "p4" };
  158.  
  159.         // arrival for every process
  160.         int arrivaltime[] = { 0,5,13,26 };
  161.  
  162.         // burst time for every process
  163.         int bursttime[] = { 20,36,19,42 };
  164.  
  165.         // quantum time of each process
  166.         int q = 10;
  167.  
  168.         // cal the function for output
  169.         roundRobin(name, arrivaltime, bursttime, q);
  170.     }
  171. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top