simulator: Add generic framework for resource consumption modeling

This change adds a generic framework for modeling resource consumptions and
adapts opendc-simulator-compute to model machines and VMs on top of
this framework.

This framework anticipates the addition of additional resource types
such as memory, disk and network to the OpenDC codebase.

3 files changed, 69 insertions, 92 deletions

diff --git a/simulator/opendc-simulator/opendc-simulator-compute/src/test/kotlin/org/opendc/simulator/compute/SimHypervisorTest.kt b/simulator/opendc-simulator/opendc-simulator-compute/src/test/kotlin/org/opendc/simulator/compute/SimHypervisorTest.kt
index b8eee4f0..4b4d7eca 100644
--- a/simulator/opendc-simulator/opendc-simulator-compute/src/test/kotlin/org/opendc/simulator/compute/SimHypervisorTest.kt
+++ b/simulator/opendc-simulator/opendc-simulator-compute/src/test/kotlin/org/opendc/simulator/compute/SimHypervisorTest.kt
@@ -30,9 +30,9 @@ import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.BeforeEach
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.assertAll
-import org.opendc.simulator.compute.model.MemoryUnit
-import org.opendc.simulator.compute.model.ProcessingNode
-import org.opendc.simulator.compute.model.ProcessingUnit
+import org.opendc.simulator.compute.model.SimMemoryUnit
+import org.opendc.simulator.compute.model.SimProcessingNode
+import org.opendc.simulator.compute.model.SimProcessingUnit
 import org.opendc.simulator.compute.workload.SimTraceWorkload
 import org.opendc.simulator.utils.DelayControllerClockAdapter
 import java.time.Clock
@@ -51,10 +51,10 @@ internal class SimHypervisorTest {
         scope = TestCoroutineScope()
         clock = DelayControllerClockAdapter(scope)
 
-        val cpuNode = ProcessingNode("Intel", "Xeon", "amd64", 1)
+        val cpuNode = SimProcessingNode("Intel", "Xeon", "amd64", 1)
         machineModel = SimMachineModel(
-            cpus = List(cpuNode.coreCount) { ProcessingUnit(cpuNode, it, 3200.0) },
-            memory = List(4) { MemoryUnit("Crucial", "MTA18ASF4G72AZ-3G2B1", 3200.0, 32_000) }
+            cpus = List(cpuNode.coreCount) { SimProcessingUnit(cpuNode, it, 3200.0) },
+            memory = List(4) { SimMemoryUnit("Crucial", "MTA18ASF4G72AZ-3G2B1", 3200.0, 32_000) }
         )
     }
 
diff --git a/simulator/opendc-simulator/opendc-simulator-compute/src/test/kotlin/org/opendc/simulator/compute/SimMachineTest.kt b/simulator/opendc-simulator/opendc-simulator-compute/src/test/kotlin/org/opendc/simulator/compute/SimMachineTest.kt
index 1036f1ac..00efba53 100644
--- a/simulator/opendc-simulator/opendc-simulator-compute/src/test/kotlin/org/opendc/simulator/compute/SimMachineTest.kt
+++ b/simulator/opendc-simulator/opendc-simulator-compute/src/test/kotlin/org/opendc/simulator/compute/SimMachineTest.kt
@@ -29,14 +29,10 @@ import kotlinx.coroutines.test.runBlockingTest
 import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.BeforeEach
 import org.junit.jupiter.api.Test
-import org.junit.jupiter.api.assertDoesNotThrow
-import org.junit.jupiter.api.assertThrows
-import org.opendc.simulator.compute.model.MemoryUnit
-import org.opendc.simulator.compute.model.ProcessingNode
-import org.opendc.simulator.compute.model.ProcessingUnit
+import org.opendc.simulator.compute.model.SimMemoryUnit
+import org.opendc.simulator.compute.model.SimProcessingNode
+import org.opendc.simulator.compute.model.SimProcessingUnit
 import org.opendc.simulator.compute.workload.SimFlopsWorkload
-import org.opendc.simulator.compute.workload.SimResourceCommand
-import org.opendc.simulator.compute.workload.SimWorkload
 import org.opendc.simulator.utils.DelayControllerClockAdapter
 
 /**
@@ -48,11 +44,11 @@ class SimMachineTest {
 
     @BeforeEach
     fun setUp() {
-        val cpuNode = ProcessingNode("Intel", "Xeon", "amd64", 2)
+        val cpuNode = SimProcessingNode("Intel", "Xeon", "amd64", 2)
 
         machineModel = SimMachineModel(
-            cpus = List(cpuNode.coreCount) { ProcessingUnit(cpuNode, it, 1000.0) },
-            memory = List(4) { MemoryUnit("Crucial", "MTA18ASF4G72AZ-3G2B1", 3200.0, 32_000) }
+            cpus = List(cpuNode.coreCount) { SimProcessingUnit(cpuNode, it, 1000.0) },
+            memory = List(4) { SimMemoryUnit("Crucial", "MTA18ASF4G72AZ-3G2B1", 3200.0, 32_000) }
         )
     }
 
@@ -86,74 +82,4 @@ class SimMachineTest {
             assertEquals(listOf(0.0, 0.5, 1.0, 0.5, 0.0), res) { "Machine is fully utilized" }
         }
     }
-
-    @Test
-    fun testInterrupt() {
-        val testScope = TestCoroutineScope()
-        val clock = DelayControllerClockAdapter(testScope)
-        val machine = SimBareMetalMachine(testScope, clock, machineModel)
-
-        val workload = object : SimWorkload {
-            override fun onStart(ctx: SimExecutionContext) {}
-
-            override fun onStart(ctx: SimExecutionContext, cpu: Int): SimResourceCommand {
-                ctx.interrupt(cpu)
-                return SimResourceCommand.Exit
-            }
-
-            override fun onNext(ctx: SimExecutionContext, cpu: Int, remainingWork: Double): SimResourceCommand {
-                throw IllegalStateException()
-            }
-        }
-
-        assertDoesNotThrow {
-            testScope.runBlockingTest { machine.run(workload) }
-        }
-    }
-
-    @Test
-    fun testExceptionPropagationOnStart() {
-        val testScope = TestCoroutineScope()
-        val clock = DelayControllerClockAdapter(testScope)
-        val machine = SimBareMetalMachine(testScope, clock, machineModel)
-
-        val workload = object : SimWorkload {
-            override fun onStart(ctx: SimExecutionContext) {}
-
-            override fun onStart(ctx: SimExecutionContext, cpu: Int): SimResourceCommand {
-                throw IllegalStateException()
-            }
-
-            override fun onNext(ctx: SimExecutionContext, cpu: Int, remainingWork: Double): SimResourceCommand {
-                throw IllegalStateException()
-            }
-        }
-
-        assertThrows<IllegalStateException> {
-            testScope.runBlockingTest { machine.run(workload) }
-        }
-    }
-
-    @Test
-    fun testExceptionPropagationOnNext() {
-        val testScope = TestCoroutineScope()
-        val clock = DelayControllerClockAdapter(testScope)
-        val machine = SimBareMetalMachine(testScope, clock, machineModel)
-
-        val workload = object : SimWorkload {
-            override fun onStart(ctx: SimExecutionContext) {}
-
-            override fun onStart(ctx: SimExecutionContext, cpu: Int): SimResourceCommand {
-                return SimResourceCommand.Consume(1.0, 1.0)
-            }
-
-            override fun onNext(ctx: SimExecutionContext, cpu: Int, remainingWork: Double): SimResourceCommand {
-                throw IllegalStateException()
-            }
-        }
-
-        assertThrows<IllegalStateException> {
-            testScope.runBlockingTest { machine.run(workload) }
-        }
-    }
 }
diff --git a/simulator/opendc-simulator/opendc-simulator-compute/src/test/kotlin/org/opendc/simulator/compute/SimSpaceSharedHypervisorTest.kt b/simulator/opendc-simulator/opendc-simulator-compute/src/test/kotlin/org/opendc/simulator/compute/SimSpaceSharedHypervisorTest.kt
index 1a9faf11..583d989c 100644
--- a/simulator/opendc-simulator/opendc-simulator-compute/src/test/kotlin/org/opendc/simulator/compute/SimSpaceSharedHypervisorTest.kt
+++ b/simulator/opendc-simulator/opendc-simulator-compute/src/test/kotlin/org/opendc/simulator/compute/SimSpaceSharedHypervisorTest.kt
@@ -31,9 +31,10 @@ import org.junit.jupiter.api.Assertions.*
 import org.junit.jupiter.api.BeforeEach
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.assertThrows
-import org.opendc.simulator.compute.model.MemoryUnit
-import org.opendc.simulator.compute.model.ProcessingNode
-import org.opendc.simulator.compute.model.ProcessingUnit
+import org.opendc.simulator.compute.model.SimMemoryUnit
+import org.opendc.simulator.compute.model.SimProcessingNode
+import org.opendc.simulator.compute.model.SimProcessingUnit
+import org.opendc.simulator.compute.workload.SimFlopsWorkload
 import org.opendc.simulator.compute.workload.SimRuntimeWorkload
 import org.opendc.simulator.compute.workload.SimTraceWorkload
 import org.opendc.simulator.utils.DelayControllerClockAdapter
@@ -53,10 +54,10 @@ internal class SimSpaceSharedHypervisorTest {
         scope = TestCoroutineScope()
         clock = DelayControllerClockAdapter(scope)
 
-        val cpuNode = ProcessingNode("Intel", "Xeon", "amd64", 1)
+        val cpuNode = SimProcessingNode("Intel", "Xeon", "amd64", 1)
         machineModel = SimMachineModel(
-            cpus = List(cpuNode.coreCount) { ProcessingUnit(cpuNode, it, 3200.0) },
-            memory = List(4) { MemoryUnit("Crucial", "MTA18ASF4G72AZ-3G2B1", 3200.0, 32_000) }
+            cpus = List(cpuNode.coreCount) { SimProcessingUnit(cpuNode, it, 3200.0) },
+            memory = List(4) { SimMemoryUnit("Crucial", "MTA18ASF4G72AZ-3G2B1", 3200.0, 32_000) }
         )
     }
 
@@ -126,6 +127,56 @@ internal class SimSpaceSharedHypervisorTest {
     }
 
     /**
+     * Test FLOPs workload on hypervisor.
+     */
+    @Test
+    fun testFlopsWorkload() {
+        val duration = 5 * 60L * 1000
+        val workload = SimFlopsWorkload((duration * 3.2).toLong(), 1.0)
+        val machine = SimBareMetalMachine(scope, clock, machineModel)
+        val hypervisor = SimSpaceSharedHypervisor()
+
+        scope.launch {
+            launch { machine.run(hypervisor) }
+
+            yield()
+            launch { hypervisor.createMachine(machineModel).run(workload) }
+        }
+
+        scope.advanceUntilIdle()
+
+        assertEquals(duration, scope.currentTime) { "Took enough time" }
+    }
+
+    /**
+     * Test two workloads running sequentially.
+     */
+    @Test
+    fun testTwoWorkloads() {
+        val duration = 5 * 60L * 1000
+        val machine = SimBareMetalMachine(scope, clock, machineModel)
+        val hypervisor = SimSpaceSharedHypervisor()
+
+        scope.launch {
+            launch { machine.run(hypervisor) }
+
+            yield()
+            launch {
+                val vm = hypervisor.createMachine(machineModel)
+                vm.run(SimRuntimeWorkload(duration))
+                vm.close()
+
+                val vm2 = hypervisor.createMachine(machineModel)
+                vm2.run(SimRuntimeWorkload(duration))
+            }
+        }
+
+        scope.advanceUntilIdle()
+
+        assertEquals(duration * 2, scope.currentTime) { "Took enough time" }
+    }
+
+    /**
      * Test concurrent workloads on the machine.
      */
     @Test