Renamed input files and internally server is changed to task (#246)

* Updated SimTrace to use a single ArrayDeque instead of three separate lists for deadline, cpuUsage, and coreCount

* Renamed input files to tasks.parquet and fragments.parquet. Renamed server to task. OpenDC nows exports tasks.parquet instead of server.parquet

5 files changed, 75 insertions, 75 deletions

diff --git a/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/SimHost.kt b/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/SimHost.kt
index 624a612f..ac0a8043 100644
--- a/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/SimHost.kt
+++ b/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/SimHost.kt
@@ -23,8 +23,8 @@
 package org.opendc.compute.simulator
 
 import org.opendc.compute.api.Flavor
-import org.opendc.compute.api.Server
-import org.opendc.compute.api.ServerState
+import org.opendc.compute.api.Task
+import org.opendc.compute.api.TaskState
 import org.opendc.compute.service.driver.Host
 import org.opendc.compute.service.driver.HostListener
 import org.opendc.compute.service.driver.HostModel
@@ -60,7 +60,7 @@ import java.util.function.Supplier
  * @param clock The (virtual) clock used to track time.
  * @param machine The [SimBareMetalMachine] on which the host runs.
  * @param hypervisor The [SimHypervisor] to run on top of the machine.
- * @param mapper A [SimWorkloadMapper] to map a [Server] to a [SimWorkload].
+ * @param mapper A [SimWorkloadMapper] to map a [Task] to a [SimWorkload].
  * @param bootModel A [Supplier] providing the [SimWorkload] to execute during the boot procedure of the hypervisor.
  * @param optimize A flag to indicate to optimize the machine models of the virtual machines.
  */
@@ -83,7 +83,7 @@ public class SimHost(
     /**
      * The virtual machines running on the hypervisor.
      */
-    private val guests = HashMap<Server, Guest>()
+    private val guests = HashMap<Task, Guest>()
     private val localGuests = mutableListOf<Guest>()
 
     private var localState: HostState = HostState.DOWN
@@ -108,11 +108,11 @@ public class SimHost(
     private val guestListener =
         object : GuestListener {
             override fun onStart(guest: Guest) {
-                listeners.forEach { it.onStateChanged(this@SimHost, guest.server, guest.state) }
+                listeners.forEach { it.onStateChanged(this@SimHost, guest.task, guest.state) }
             }
 
             override fun onStop(guest: Guest) {
-                listeners.forEach { it.onStateChanged(this@SimHost, guest.server, guest.state) }
+                listeners.forEach { it.onStateChanged(this@SimHost, guest.task, guest.state) }
             }
         }
 
@@ -140,21 +140,21 @@ public class SimHost(
         return localState
     }
 
-    override fun getInstances(): Set<Server> {
+    override fun getInstances(): Set<Task> {
         return guests.keys
     }
 
-    override fun canFit(server: Server): Boolean {
-        val sufficientMemory = model.memoryCapacity >= server.flavor.memorySize
-        val enoughCpus = model.coreCount >= server.flavor.coreCount
-        val canFit = hypervisor.canFit(server.flavor.toMachineModel())
+    override fun canFit(task: Task): Boolean {
+        val sufficientMemory = model.memoryCapacity >= task.flavor.memorySize
+        val enoughCpus = model.coreCount >= task.flavor.coreCount
+        val canFit = hypervisor.canFit(task.flavor.toMachineModel())
 
         return sufficientMemory && enoughCpus && canFit
     }
 
-    override fun spawn(server: Server) {
-        guests.computeIfAbsent(server) { key ->
-            require(canFit(key)) { "Server does not fit" }
+    override fun spawn(task: Task) {
+        guests.computeIfAbsent(task) { key ->
+            require(canFit(key)) { "Task does not fit" }
 
             val machine = hypervisor.newMachine(key.flavor.toMachineModel())
             val newGuest =
@@ -164,7 +164,7 @@ public class SimHost(
                     hypervisor,
                     mapper,
                     guestListener,
-                    server,
+                    task,
                     machine,
                 )
 
@@ -173,25 +173,25 @@ public class SimHost(
         }
     }
 
-    override fun contains(server: Server): Boolean {
-        return server in guests
+    override fun contains(task: Task): Boolean {
+        return task in guests
     }
 
-    override fun start(server: Server) {
-        val guest = requireNotNull(guests[server]) { "Unknown server ${server.uid} at host $uid" }
+    override fun start(task: Task) {
+        val guest = requireNotNull(guests[task]) { "Unknown task ${task.uid} at host $uid" }
         guest.start()
     }
 
-    override fun stop(server: Server) {
-        val guest = requireNotNull(guests[server]) { "Unknown server ${server.uid} at host $uid" }
+    override fun stop(task: Task) {
+        val guest = requireNotNull(guests[task]) { "Unknown task ${task.uid} at host $uid" }
         guest.stop()
     }
 
-    override fun delete(server: Server) {
-        val guest = guests[server] ?: return
+    override fun delete(task: Task) {
+        val guest = guests[task] ?: return
         guest.delete()
 
-        guests.remove(server)
+        guests.remove(task)
         localGuests.remove(guest)
     }
 
@@ -219,12 +219,12 @@ public class SimHost(
         val guests = localGuests.listIterator()
         for (guest in guests) {
             when (guest.state) {
-                ServerState.TERMINATED -> terminated++
-                ServerState.RUNNING -> running++
-                ServerState.ERROR -> error++
-                ServerState.DELETED -> {
+                TaskState.TERMINATED -> terminated++
+                TaskState.RUNNING -> running++
+                TaskState.ERROR -> error++
+                TaskState.DELETED -> {
                     // Remove guests that have been deleted
-                    this.guests.remove(guest.server)
+                    this.guests.remove(guest.task)
                     guests.remove()
                 }
                 else -> invalid++
@@ -244,8 +244,8 @@ public class SimHost(
         )
     }
 
-    override fun getSystemStats(server: Server): GuestSystemStats {
-        val guest = requireNotNull(guests[server]) { "Unknown server ${server.uid} at host $uid" }
+    override fun getSystemStats(task: Task): GuestSystemStats {
+        val guest = requireNotNull(guests[task]) { "Unknown task ${task.uid} at host $uid" }
         return guest.getSystemStats()
     }
 
@@ -265,8 +265,8 @@ public class SimHost(
         )
     }
 
-    override fun getCpuStats(server: Server): GuestCpuStats {
-        val guest = requireNotNull(guests[server]) { "Unknown server ${server.uid} at host $uid" }
+    override fun getCpuStats(task: Task): GuestCpuStats {
+        val guest = requireNotNull(guests[task]) { "Unknown task ${task.uid} at host $uid" }
         return guest.getCpuStats()
     }
 
diff --git a/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/SimMetaWorkloadMapper.kt b/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/SimMetaWorkloadMapper.kt
index c05f1a2c..907f6acd 100644
--- a/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/SimMetaWorkloadMapper.kt
+++ b/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/SimMetaWorkloadMapper.kt
@@ -22,14 +22,14 @@
 
 package org.opendc.compute.simulator
 
-import org.opendc.compute.api.Server
+import org.opendc.compute.api.Task
 import org.opendc.simulator.compute.workload.SimWorkload
 
 /**
- * A [SimWorkloadMapper] that maps a [Server] to a workload via the meta-data.
+ * A [SimWorkloadMapper] that maps a [Task] to a workload via the meta-data.
  */
 public class SimMetaWorkloadMapper(private val key: String = "workload") : SimWorkloadMapper {
-    override fun createWorkload(server: Server): SimWorkload {
-        return requireNotNull(server.meta[key] ?: server.image.meta[key]) as SimWorkload
+    override fun createWorkload(task: Task): SimWorkload {
+        return requireNotNull(task.meta[key] ?: task.image.meta[key]) as SimWorkload
     }
 }
diff --git a/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/SimWorkloadMapper.kt b/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/SimWorkloadMapper.kt
index 83baa61a..a85091a0 100644
--- a/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/SimWorkloadMapper.kt
+++ b/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/SimWorkloadMapper.kt
@@ -23,15 +23,15 @@
 package org.opendc.compute.simulator
 
 import org.opendc.compute.api.Image
-import org.opendc.compute.api.Server
+import org.opendc.compute.api.Task
 import org.opendc.simulator.compute.workload.SimWorkload
 
 /**
- * A [SimWorkloadMapper] is responsible for mapping a [Server] and [Image] to a [SimWorkload] that can be simulated.
+ * A [SimWorkloadMapper] is responsible for mapping a [Task] and [Image] to a [SimWorkload] that can be simulated.
  */
 public fun interface SimWorkloadMapper {
     /**
-     * Map the specified [server] to a [SimWorkload] that can be simulated.
+     * Map the specified [task] to a [SimWorkload] that can be simulated.
      */
-    public fun createWorkload(server: Server): SimWorkload
+    public fun createWorkload(task: Task): SimWorkload
 }
diff --git a/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/internal/DefaultWorkloadMapper.kt b/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/internal/DefaultWorkloadMapper.kt
index 7d4b7302..24c382dd 100644
--- a/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/internal/DefaultWorkloadMapper.kt
+++ b/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/internal/DefaultWorkloadMapper.kt
@@ -22,7 +22,7 @@
 
 package org.opendc.compute.simulator.internal
 
-import org.opendc.compute.api.Server
+import org.opendc.compute.api.Task
 import org.opendc.compute.simulator.SimMetaWorkloadMapper
 import org.opendc.compute.simulator.SimWorkloadMapper
 import org.opendc.simulator.compute.workload.SimWorkload
@@ -36,8 +36,8 @@ import java.time.Duration
 internal object DefaultWorkloadMapper : SimWorkloadMapper {
     private val delegate = SimMetaWorkloadMapper()
 
-    override fun createWorkload(server: Server): SimWorkload {
-        val workload = delegate.createWorkload(server)
+    override fun createWorkload(task: Task): SimWorkload {
+        val workload = delegate.createWorkload(task)
         // FIXME: look at connecting this to frontend. Probably not needed since the duration is so small
         val bootWorkload = SimWorkloads.runtime(Duration.ofMillis(1), 0.8, 0L, 0L)
         return SimWorkloads.chain(bootWorkload, workload)
diff --git a/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/internal/Guest.kt b/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/internal/Guest.kt
index cbdda0cb..1925233f 100644
--- a/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/internal/Guest.kt
+++ b/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/internal/Guest.kt
@@ -23,8 +23,8 @@
 package org.opendc.compute.simulator.internal
 
 import mu.KotlinLogging
-import org.opendc.compute.api.Server
-import org.opendc.compute.api.ServerState
+import org.opendc.compute.api.Task
+import org.opendc.compute.api.TaskState
 import org.opendc.compute.service.driver.telemetry.GuestCpuStats
 import org.opendc.compute.service.driver.telemetry.GuestSystemStats
 import org.opendc.compute.simulator.SimHost
@@ -46,16 +46,16 @@ internal class Guest(
     private val hypervisor: SimHypervisor,
     private val mapper: SimWorkloadMapper,
     private val listener: GuestListener,
-    val server: Server,
+    val task: Task,
     val machine: SimVirtualMachine,
 ) {
     /**
      * The state of the [Guest].
      *
-     * [ServerState.PROVISIONING] is an invalid value for a guest, since it applies before the host is selected for
-     * a server.
+     * [TaskState.PROVISIONING] is an invalid value for a guest, since it applies before the host is selected for
+     * a task.
      */
-    var state: ServerState = ServerState.TERMINATED
+    var state: TaskState = TaskState.TERMINATED
         private set
 
     /**
@@ -63,14 +63,14 @@ internal class Guest(
      */
     fun start() {
         when (state) {
-            ServerState.TERMINATED, ServerState.ERROR -> {
-                LOGGER.info { "User requested to start server ${server.uid}" }
+            TaskState.TERMINATED, TaskState.ERROR -> {
+                LOGGER.info { "User requested to start task ${task.uid}" }
                 doStart()
             }
-            ServerState.RUNNING -> return
-            ServerState.DELETED -> {
-                LOGGER.warn { "User tried to start deleted server" }
-                throw IllegalArgumentException("Server is deleted")
+            TaskState.RUNNING -> return
+            TaskState.DELETED -> {
+                LOGGER.warn { "User tried to start deleted task" }
+                throw IllegalArgumentException("Task is deleted")
             }
             else -> assert(false) { "Invalid state transition" }
         }
@@ -81,9 +81,9 @@ internal class Guest(
      */
     fun stop() {
         when (state) {
-            ServerState.RUNNING -> doStop(ServerState.TERMINATED)
-            ServerState.ERROR -> doRecover()
-            ServerState.TERMINATED, ServerState.DELETED -> return
+            TaskState.RUNNING -> doStop(TaskState.TERMINATED)
+            TaskState.ERROR -> doRecover()
+            TaskState.TERMINATED, TaskState.DELETED -> return
             else -> assert(false) { "Invalid state transition" }
         }
     }
@@ -97,28 +97,28 @@ internal class Guest(
     fun delete() {
         stop()
 
-        state = ServerState.DELETED
+        state = TaskState.DELETED
         hypervisor.removeMachine(machine)
     }
 
     /**
      * Fail the guest if it is active.
      *
-     * This operation forcibly stops the guest and puts the server into an error state.
+     * This operation forcibly stops the guest and puts the task into an error state.
      */
     fun fail() {
-        if (state != ServerState.RUNNING) {
+        if (state != TaskState.RUNNING) {
             return
         }
 
-        doStop(ServerState.ERROR)
+        doStop(TaskState.ERROR)
     }
 
     /**
      * Recover the guest if it is in an error state.
      */
     fun recover() {
-        if (state != ServerState.ERROR) {
+        if (state != TaskState.ERROR) {
             return
         }
 
@@ -170,23 +170,23 @@ internal class Guest(
 
         onStart()
 
-        val workload: SimWorkload = mapper.createWorkload(server)
+        val workload: SimWorkload = mapper.createWorkload(task)
         workload.setOffset(clock.millis())
-        val meta = mapOf("driver" to host, "server" to server) + server.meta
+        val meta = mapOf("driver" to host, "task" to task) + task.meta
         ctx =
             machine.startWorkload(workload, meta) { cause ->
-                onStop(if (cause != null) ServerState.ERROR else ServerState.TERMINATED)
+                onStop(if (cause != null) TaskState.ERROR else TaskState.TERMINATED)
                 ctx = null
             }
     }
 
     /**
-     * Attempt to stop the server and put it into [target] state.
+     * Attempt to stop the task and put it into [target] state.
      */
-    private fun doStop(target: ServerState) {
+    private fun doStop(target: TaskState) {
         assert(ctx != null) { "Invalid job state" }
         val ctx = ctx ?: return
-        if (target == ServerState.ERROR) {
+        if (target == TaskState.ERROR) {
             ctx.shutdown(Exception("Stopped because of ERROR"))
         } else {
             ctx.shutdown()
@@ -199,7 +199,7 @@ internal class Guest(
      * Attempt to recover from an error state.
      */
     private fun doRecover() {
-        state = ServerState.TERMINATED
+        state = TaskState.TERMINATED
     }
 
     /**
@@ -207,14 +207,14 @@ internal class Guest(
      */
     private fun onStart() {
         localBootTime = clock.instant()
-        state = ServerState.RUNNING
+        state = TaskState.RUNNING
         listener.onStart(this)
     }
 
     /**
      * This method is invoked when the guest stopped.
      */
-    private fun onStop(target: ServerState) {
+    private fun onStop(target: TaskState) {
         updateUptime()
 
         state = target
@@ -235,9 +235,9 @@ internal class Guest(
         val duration = now - localLastReport
         localLastReport = now
 
-        if (state == ServerState.RUNNING) {
+        if (state == TaskState.RUNNING) {
             localUptime += duration
-        } else if (state == ServerState.ERROR) {
+        } else if (state == TaskState.ERROR) {
             localDowntime += duration
         }
     }