Changed Preemptive Logic

Author: WonSteps

src/jvmMain/kotlin/policy/Common.kt

@@ -5,7 +5,7 @@ import utils.ProgramData
 import utils.Task
 import java.util.*
 
-internal fun calculateTasks(tasks: List<Task>, compare: (Task, Task) -> Int, isNonPreemptive: Boolean): ProgramData {
+internal fun calculateTasks(tasks: List<Task>, compare: (Task, Task) -> Int, isPreemptive: Boolean): ProgramData {
     val info: MutableList<ChartInfo> = mutableListOf(ChartInfo(-1, tasks[0].arrivalTime, ranTime = 0))
 
     var currentRunTime = tasks[0].arrivalTime
@@ -16,12 +16,18 @@ internal fun calculateTasks(tasks: List<Task>, compare: (Task, Task) -> Int, isN
     while (idx < tasks.size) {
         while (idx < tasks.size && currentRunTime == tasks[idx].arrivalTime) { // 동일한 시간에 들어오는 경우 처리를 위해 if 가 아닌 while
 
-            if (currentRunTask === null) { currentRunTask = tasks[idx] }
-            else if (compare(currentRunTask, tasks[idx]) <= 0 || isNonPreemptive) { // 기존 Task 의 우선순위가 더 크면, 변화 X, current 계속 실행
+            if (currentRunTask === null) {
+                currentRunTask = tasks[idx]
+            } else if (compare(currentRunTask, tasks[idx]) <= 0 || !isPreemptive) {
+                // If It's not preemptive, simply add it to the ready pool without comparing it to other tasks.
+                // Or if It's preemptive, then compare the priority of 2 tasks.
+                // 기존 Task 의 우선순위가 더 크면, 변화 X, current 계속 실행
                 readyPool.add(tasks[idx])
             } else { // If the priority of the new task is more urgent. 새로 비교할 Task 의 우선순위가 더 크면
                 val ranTime = currentRunTime - info.last().timestamp
-                if (ranTime != 0)  info += ChartInfo(currentRunTask.pid, currentRunTime, ranTime) // To ignore if ranTime is zero
+                if (ranTime != 0) {
+                    info += ChartInfo(currentRunTask.pid, currentRunTime, ranTime)
+                } // To ignore if ranTime is zero
 
                 tasks[idx].responseTime = currentRunTime // 새로 들어온 Task 의 첫 응답 시간 설정
                 readyPool.add(currentRunTask)
@@ -56,7 +62,9 @@ internal fun calculateTasks(tasks: List<Task>, compare: (Task, Task) -> Int, isN
         val newRun = readyPool.remove()
 
         info += ChartInfo(newRun.pid, currentRunTime + newRun.remainedTime, newRun.remainedTime)
-        if (newRun.responseTime == -1) { newRun.responseTime = currentRunTime }
+        if (newRun.responseTime == -1) {
+            newRun.responseTime = currentRunTime
+        }
         currentRunTime += newRun.remainedTime
         newRun.remainedTime = 0
         newRun.waitedTime = currentRunTime - newRun.arrivalTime - newRun.executionTime

src/jvmMain/kotlin/policy/MyPriorityRoundRobin.kt

@@ -1,14 +1,42 @@
-//package policy
+package policy
+
 //
-//import utils.ProgramData
-//import utils.Task
+////private fun score(task: Task) = task.remainedTime +
+//private fun runTaskRoundRobin(tasks : List<Task>, quantum: Int): ProgramData {
+//    val info: MutableList<ChartInfo> = mutableListOf(ChartInfo(-1, tasks[0].arrivalTime, 0)) // 처음에 0 표시
 //
+//    var currentRunTime = tasks[0].arrivalTime
+//    val readyPool = CircularQueue<Task>(tasks.size + 1)
+//    readyPool.add(tasks[0])
+//    tasks[0].responseTime = 0
+//    var nextIdx = 1
 //
-//private fun score(task: Task) = task.remainedTime +
-//internal fun comparePRR(a: Task, b: Task): Int = compareValuesBy(a, b,
-//    { it.remainedTime
-//    }, { it.arrivalTime })
+//    while (readyPool.isNotEmpty()) {
+//        val performed: Task = readyPool.poll()
+//        val performedTime = if (performed.remainedTime >= quantum) quantum else performed.remainedTime % quantum
+//        if (performed.responseTime == -1) performed.responseTime = currentRunTime
 //
-//fun executeIO(tasks: List<Task>): ProgramData {
-//    return runTaskPreemptive(tasks, ::comparePRR)//.let(::printResult)
+//        currentRunTime += performedTime
+//        performed.remainedTime -= performedTime
+//
+//        info += ChartInfo(performed.pid, currentRunTime, performedTime) // ran at $currentRunTime
+//
+//        while (nextIdx < tasks.size && currentRunTime >= tasks[nextIdx].arrivalTime) {
+//            readyPool.add(tasks[nextIdx])
+//            ++nextIdx
+//        }
+//
+//        if (performed.remainedTime == 0) { // Job finished
+//            performed.waitedTime = currentRunTime - performed.arrivalTime - performed.executionTime
+//            //println("${performed.pid}: finished,, at $currentRunTime")
+//        } else {
+//            readyPool.add(performed)
+//        }
+//    }
+////    println("Total Executed time : $currentRunTime")
+////    println("Context Switched : ${info.size - 2}")
+//    return ProgramData(tasks, info)
+//}
+//fun executePRR(tasks: List<Task>): ProgramData {
+//    return calculateTasks(tasks, ::comparePRR, isPreemptive = false)//.let(::printResult)
 //}

src/jvmMain/kotlin/policy/Priority.kt

@@ -7,9 +7,9 @@ import utils.Task
 private fun comparePriority(a: Task, b: Task): Int = compareValuesBy(a, b, { it.priority }, { it.arrivalTime })
 
 fun executePriorityNonPreemptive(tasks: List<Task>): ProgramData {
-    return calculateTasks(tasks, ::comparePriority, isNonPreemptive = true)//.let(::printResult)
+    return calculateTasks(tasks, ::comparePriority, isPreemptive = false)//.let(::printResult)
 }
 
 fun executePriority(tasks: List<Task>): ProgramData {
-    return calculateTasks(tasks, ::comparePriority, isNonPreemptive = false)//.let(::printResult)
+    return calculateTasks(tasks, ::comparePriority, isPreemptive = true)//.let(::printResult)
 }

src/jvmMain/kotlin/policy/RoundRobin.kt

@@ -1,11 +1,11 @@
 package policy
 
-import utils.CircularQueue
 import utils.ChartInfo
+import utils.CircularQueue
 import utils.ProgramData
 import utils.Task
 
-private fun runTaskRoundRobin(tasks : List<Task>, quantum: Int): ProgramData {
+private fun calculateRoundRobin(tasks : List<Task>, quantum: Int): ProgramData {
     val info: MutableList<ChartInfo> = mutableListOf(ChartInfo(-1, tasks[0].arrivalTime, 0)) // 처음에 0 표시
 
     var currentRunTime = tasks[0].arrivalTime
@@ -42,5 +42,5 @@ private fun runTaskRoundRobin(tasks : List<Task>, quantum: Int): ProgramData {
 }
 
 fun executeRoundRobin(tasks: List<Task>, quantum: Int): ProgramData {
-    return runTaskRoundRobin(tasks, quantum)//.let(::printResult)
+    return calculateRoundRobin(tasks, quantum)//.let(::printResult)
 }

src/jvmMain/kotlin/policy/SJF.kt

@@ -6,9 +6,9 @@ import utils.Task
 private fun compareSJF(a: Task, b: Task): Int = compareValuesBy(a, b, { it.remainedTime }, { it.arrivalTime })
 
 fun executeSJF(tasks: List<Task>): ProgramData {
-    return calculateTasks(tasks, ::compareSJF, isNonPreemptive = true)
+    return calculateTasks(tasks, ::compareSJF, isPreemptive = false)
 }
 
 fun executeSRTF(tasks: List<Task>): ProgramData {
-    return calculateTasks(tasks, ::compareSJF, isNonPreemptive = false)//.let(::printResult)
+    return calculateTasks(tasks, ::compareSJF, isPreemptive = true)//.let(::printResult)
 }