Question

我已经在Scala中实现了具有固定时间量子的Round Robin算法。代码可以正常运行并具有所需的输出，但是在特定情况下，代码无法提供理想的结果。

让我有五个进程 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（不小于等于跟踪器的初始值= 0的变量跟踪器）。现在，代码将在到达时间为0时执行p1。当p1完成执行时，p2将到达，因此将执行p2。在执行p2之后，到达p0（此时跟踪器= 5，到达时间p0 = 4），所以现在代码应该执行p0，然后执行其他进程。平均执行应在do-while循环的第一次迭代中按此顺序 p1，p2，p0，p4，p3 进行，然后根据给定条件进行第二次迭代。

注意：根据我的需要，基于到达时间的排序过程不是解决方案。进程根据其爆发时间进行排序。我的代码是

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)
 }

在Scala中实施Round Robin

0 个答案: