Внедрение Round Robin в Scala

Question

Я реализовал алгоритм Round Robin с фиксированным квантом времени в Scala.Код работает нормально с желаемым выводом, но в конкретном случае код не дает желаемых результатов.

Пусть у меня есть пять процессов p0, p1, p2, p3, p4 со временем прибытия 3,0,1,9,6 и время всплеска 1,2,6,7,9 соответственно и установите (квантовое время) q = 3 .В первой итерации цикла do-while мой код выполнит p1, p2 .Во второй итерации цикла теперь будут выполняться все процессы.но исполнение таким способом нежелательно.

Я хочу исполнения таким образом.На первой итерации цикла do-while, когда код запускается, он сначала проверяет время поступления p0, которое не равно 0 (не меньше или равно переменной tracker, как начальное значение tracker = 0).Теперь код будет выполнять p1, поскольку его время прибытия равно 0. Когда p1 завершит свое выполнение, будет получено p2, поэтому будет выполнено p2.после выполнения p2 наступает p0 (так как трекер = 5 в этой точке и время поступления p0 = 4), поэтому теперь код должен выполнять p0, а затем выполнять другие процессы.Среднее выполнение должно быть в этой последовательности p1, p2, p0, p4, p3 в первой итерации цикла do-while и затем перейти ко второй итерации в зависимости от заданного условия.

Примечание : сортировка по времени прибытия не является решением в соответствии с моими потребностями.Процессы сортируются по времени их посылки.Мой код

def RoundRobin(n: Int, data: Array[Array[Double]]): Unit = {
 var arr = data.map(_.map(identity))  // first column of arr holds arrival time and second column holds Burst time.
 val q = 3.0
 val wt = new Array[Double](n) // wt is waiting time
 val a = new Array[Double](n)  

 var sum = 0.0
 for (i <- 0 to n - 1) {
  a(i) = arr(i)(1)
 }
 for (i <- 0 to n - 1) {
  wt(i) = 0
 }
 var tracker = 0.0  // Used for arrival time comparision
 do {
  arr = arr.sortBy(x => x(1))   //sort based on Burst time 
  for (i <- 0 to arr.size - 1) {
    if (tracker >= arr(i)(0))  // check if tracker is greater is greater than or equal to Arrival Time of process i
    {
      if (arr(i)(1) > q) {    //if Burst time > quantum time
        arr(i)(1) -= q        // decrement burst time of process i by q (quantum time) unit of time
        tracker = tracker + q // increment value of tracker by q unit of time
        for (j <- 0 to arr.size - 1) {
          if ((j != i) && (arr(j)(1) != 0))
            wt(j) += q        // increment waiting time of process j by q (quantum time)
        }
      }
      else {
        for (j <- 0 to arr.size - 1) {
          if ((j != i) && (arr(j)(1) != 0)) {
            wt(j) += arr(i)(1)    // increment waiting time of process j by rem aining burst time of i
          }
        }
        tracker = tracker + arr(i)(1) // increment value of tracker by burst time of process
        arr(i)(1) = 0  // set burst time of process i = 0 as process completed execution
      }
    }
    else {

      if (i == arr.length - 1) { // if all processes have been traversed that is value of i == length of list than increment tracker by 1
        tracker = tracker + 1
      }

    }
  }
  sum = 0.0
  for (i <- 0 to arr.length - 1)
    sum = sum + arr(i)(1)
 } while (sum != 0)
 var avg_wt = 0.0  //wt is waiting time
 var avg_tat = 0.0 // tat is Turn around time
 for (j <- 0 to n - 1) {
  wt(j) = wt(j) - arr(j)(0)
  if(wt(j) < 0){
    wt(j)=0.0
  }
 }
 for (j <- 0 to n - 1) {
  avg_wt = avg_wt + wt(j);
  avg_tat = avg_tat + wt(j) + a(j) // TaT = WT + BT
 }
 println(" total waiting time= " + avg_wt  + " Total turn around time= " + avg_tat )
 println(" average waiting time= " + (avg_wt / n) + " Average turn around time= " + (avg_tat / n))
}

def main(args: Array[String]): Unit = {
 println("Enter number of process:");
 val n = scala.io.StdIn.readInt();  //  n is number of processes
 var array: Array[Array[Double]] = Array.ofDim(n, 2)

//arrival time
 array(0)(0) = 3
 array(1)(0) = 0
 array(2)(0) = 1
 array(3)(0) = 9
 array(4)(0) = 6

//Burst time
 array(0)(1) = 1
 array(1)(1) = 2
 array(2)(1) = 6
 array(3)(1) = 7
 array(4)(1) = 9

 RoundRobin(n,array)
 }