All simulation are now run with a single CPU and single MemoryUnit. multi CPUs are combined into one. This is for performance and explainability. (#255)

6 files changed, 59 insertions, 51 deletions

diff --git a/opendc-experiments/opendc-experiments-base/src/test/kotlin/org/opendc/experiments/base/ScenarioIntegrationTest.kt b/opendc-experiments/opendc-experiments-base/src/test/kotlin/org/opendc/experiments/base/ScenarioIntegrationTest.kt
index c6ae5180..08eddca0 100644
--- a/opendc-experiments/opendc-experiments-base/src/test/kotlin/org/opendc/experiments/base/ScenarioIntegrationTest.kt
+++ b/opendc-experiments/opendc-experiments-base/src/test/kotlin/org/opendc/experiments/base/ScenarioIntegrationTest.kt
@@ -120,12 +120,12 @@ class ScenarioIntegrationTest {
                 { assertEquals(0, monitor.tasksActive, "All VMs should finish after a run") },
                 { assertEquals(0, monitor.attemptsFailure, "No VM should be unscheduled") },
                 { assertEquals(0, monitor.tasksPending, "No VM should not be in the queue") },
-                { assertEquals(43101695530, monitor.idleTime) { "Incorrect idle time" } },
-                { assertEquals(3489503997, monitor.activeTime) { "Incorrect active time" } },
-                { assertEquals(142, monitor.stealTime) { "Incorrect steal time" } },
+                { assertEquals(43101769345, monitor.idleTime) { "Incorrect idle time" } },
+                { assertEquals(3489430672, monitor.activeTime) { "Incorrect active time" } },
+                { assertEquals(0, monitor.stealTime) { "Incorrect steal time" } },
                 { assertEquals(0, monitor.lostTime) { "Incorrect lost time" } },
                 { assertEquals(3.3388920269258898E7, monitor.powerDraw, 1E4) { "Incorrect power draw" } },
-                { assertEquals(1.0016142948422823E10, monitor.energyUsage, 1E4) { "Incorrect energy usage" } },
+                { assertEquals(1.0016127451211525E10, monitor.energyUsage, 1E4) { "Incorrect energy usage" } },
             )
         }
 
@@ -162,9 +162,9 @@ class ScenarioIntegrationTest {
 
             // Note that these values have been verified beforehand
             assertAll(
-                { assertEquals(1373412033, monitor.idleTime) { "Idle time incorrect" } },
-                { assertEquals(1217675912, monitor.activeTime) { "Active time incorrect" } },
-                { assertEquals(19, monitor.stealTime) { "Steal time incorrect" } },
+                { assertEquals(1373419781, monitor.idleTime) { "Idle time incorrect" } },
+                { assertEquals(1217668222, monitor.activeTime) { "Active time incorrect" } },
+                { assertEquals(0, monitor.stealTime) { "Steal time incorrect" } },
                 { assertEquals(0, monitor.lostTime) { "Lost time incorrect" } },
                 { assertEquals(2539987.394500494, monitor.powerDraw, 1E4) { "Incorrect power draw" } },
                 { assertEquals(7.617527900379665E8, monitor.energyUsage, 1E4) { "Incorrect energy usage" } },
diff --git a/opendc-experiments/opendc-experiments-faas/src/test/kotlin/org/opendc/experiments/faas/FaaSExperiment.kt b/opendc-experiments/opendc-experiments-faas/src/test/kotlin/org/opendc/experiments/faas/FaaSExperiment.kt
index 346059a8..49d7d489 100644
--- a/opendc-experiments/opendc-experiments-faas/src/test/kotlin/org/opendc/experiments/faas/FaaSExperiment.kt
+++ b/opendc-experiments/opendc-experiments-faas/src/test/kotlin/org/opendc/experiments/faas/FaaSExperiment.kt
@@ -30,10 +30,9 @@ import org.opendc.faas.service.FaaSService
 import org.opendc.faas.service.autoscaler.FunctionTerminationPolicyFixed
 import org.opendc.faas.service.router.RandomRoutingPolicy
 import org.opendc.faas.simulator.delay.ColdStartModel
+import org.opendc.simulator.compute.model.Cpu
 import org.opendc.simulator.compute.model.MachineModel
 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.kotlin.runSimulation
 import java.io.File
 import java.time.Duration
@@ -80,13 +79,11 @@ class FaaSExperiment {
      * Construct the machine model to test with.
      */
     private fun createMachineModel(): MachineModel {
-        val cpuNode = ProcessingNode("Intel", "Xeon", "amd64", 2)
-
         return MachineModel(
             // cpus
-            List(cpuNode.coreCount) { ProcessingUnit(cpuNode, it, 1000.0) },
+            Cpu(0, 2, 1000.0, "Intel", "Xeon", "amd64"),
             // memory
-            List(4) { MemoryUnit("Crucial", "MTA18ASF4G72AZ-3G2B1", 3200.0, 32_000) },
+            MemoryUnit("Crucial", "MTA18ASF4G72AZ-3G2B1", 3200.0, 32_000 * 4),
         )
     }
 }
diff --git a/opendc-experiments/opendc-experiments-tf20/src/main/kotlin/org/opendc/experiments/tf20/core/SimTFDevice.kt b/opendc-experiments/opendc-experiments-tf20/src/main/kotlin/org/opendc/experiments/tf20/core/SimTFDevice.kt
index 1a99cedf..11e010ec 100644
--- a/opendc-experiments/opendc-experiments-tf20/src/main/kotlin/org/opendc/experiments/tf20/core/SimTFDevice.kt
+++ b/opendc-experiments/opendc-experiments-tf20/src/main/kotlin/org/opendc/experiments/tf20/core/SimTFDevice.kt
@@ -29,9 +29,9 @@ import org.opendc.simulator.compute.SimBareMetalMachine
 import org.opendc.simulator.compute.SimMachine
 import org.opendc.simulator.compute.SimMachineContext
 import org.opendc.simulator.compute.SimPsuFactories
+import org.opendc.simulator.compute.model.Cpu
 import org.opendc.simulator.compute.model.MachineModel
 import org.opendc.simulator.compute.model.MemoryUnit
-import org.opendc.simulator.compute.model.ProcessingUnit
 import org.opendc.simulator.compute.power.CpuPowerModel
 import org.opendc.simulator.compute.workload.SimWorkload
 import org.opendc.simulator.flow2.FlowEngine
@@ -52,7 +52,7 @@ public class SimTFDevice(
     override val uid: UUID,
     override val isGpu: Boolean,
     dispatcher: Dispatcher,
-    pu: ProcessingUnit,
+    pu: Cpu,
     private val memory: MemoryUnit,
     powerModel: CpuPowerModel,
 ) : TFDevice {
@@ -62,7 +62,7 @@ public class SimTFDevice(
     private val machine =
         SimBareMetalMachine.create(
             FlowEngine.create(dispatcher).newGraph(),
-            MachineModel(listOf(pu), listOf(memory)),
+            MachineModel(pu, memory),
             SimPsuFactories.simple(powerModel),
         )
 
@@ -108,7 +108,7 @@ public class SimTFDevice(
                 output = stage.getOutlet("out")
                 lastPull = ctx.graph.engine.clock.millis()
 
-                ctx.graph.connect(output, ctx.cpus[0].input)
+                ctx.graph.connect(output, ctx.cpu.input)
             }
 
             override fun onStop(ctx: SimMachineContext) {
diff --git a/opendc-experiments/opendc-experiments-tf20/src/main/kotlin/org/opendc/experiments/tf20/util/MLEnvironmentReader.kt b/opendc-experiments/opendc-experiments-tf20/src/main/kotlin/org/opendc/experiments/tf20/util/MLEnvironmentReader.kt
index 077bcc04..34b4bc7b 100644
--- a/opendc-experiments/opendc-experiments-tf20/src/main/kotlin/org/opendc/experiments/tf20/util/MLEnvironmentReader.kt
+++ b/opendc-experiments/opendc-experiments-tf20/src/main/kotlin/org/opendc/experiments/tf20/util/MLEnvironmentReader.kt
@@ -25,10 +25,9 @@ package org.opendc.experiments.tf20.util
 import com.fasterxml.jackson.databind.ObjectMapper
 import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper
 import com.fasterxml.jackson.module.kotlin.readValue
+import org.opendc.simulator.compute.model.Cpu
 import org.opendc.simulator.compute.model.MachineModel
 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.power.CpuPowerModels
 import java.io.InputStream
 import java.util.UUID
@@ -54,36 +53,50 @@ public class MLEnvironmentReader {
                             var maxPower = 350.0
                             var minPower = 200.0
                             val cores =
-                                machine.cpus.flatMap { id ->
+                                machine.cpus.map { id ->
                                     when (id) {
                                         1 -> {
                                             // ref: https://www.guru3d.com/articles-pages/nvidia-geforce-gtx-titan-x-review,8.html#:~:text=GeForce%20GTX%20Titan%20X%20%2D%20On,power%20supply%20unit%20as%20minimum.
-                                            maxPower = 334.0
-                                            minPower = 90.0
-                                            val node = ProcessingNode("NVidia", "TITAN X", "Pascal", 4992)
-                                            List(node.coreCount) { ProcessingUnit(node, it, 824.0) }
+                                            Cpu(
+                                                0,
+                                                4992,
+                                                824.0,
+                                                "NVidia",
+                                                "TITAN X",
+                                                "Pascal",
+                                            )
                                         }
                                         2 -> {
                                             // ref: https://www.microway.com/hpc-tech-tips/nvidia-tesla-p100-pci-e-16gb-gpu-accelerator-pascal-gp100-close/
-                                            maxPower = 250.0
-                                            minPower = 125.0
-                                            val node = ProcessingNode("NVIDIA", "Tesla P100", "Pascal", 3584)
-                                            List(node.coreCount) { ProcessingUnit(node, it, 1190.0) }
+                                            Cpu(
+                                                0,
+                                                3584,
+                                                1190.0,
+                                                "NVIDIA",
+                                                "Tesla P100",
+                                                "Pascal",
+                                            )
                                         }
                                         3 -> {
                                             // ref: https://www.anandtech.com/show/10923/openpower-saga-tyans-1u-power8-gt75/7
-                                            minPower = 84.0
-                                            maxPower = 135.0
-                                            val node = ProcessingNode("Intel", "E5-2690v3 Haswell24", "amd64", 24)
-                                            isGpuFlag = false
-                                            List(node.coreCount) { ProcessingUnit(node, it, 3498.0) }
+                                            Cpu(
+                                                0,
+                                                24,
+                                                3498.0,
+                                                "Intel",
+                                                "E5-2690v3 Haswell24",
+                                                "amd64",
+                                            )
                                         }
                                         4 -> {
-                                            minPower = 130.0
-                                            maxPower = 190.0
-                                            val node = ProcessingNode("IBM", "POWER8", "RISC", 10)
-                                            isGpuFlag = false
-                                            List(node.coreCount) { ProcessingUnit(node, it, 143000.0) } // 28600.0 3690
+                                            Cpu(
+                                                0,
+                                                10,
+                                                143000.0,
+                                                "IBM",
+                                                "POWER8",
+                                                "RISC",
+                                            )
                                         }
                                         else -> throw IllegalArgumentException("The cpu id $id is not recognized")
                                     }
@@ -103,7 +116,7 @@ public class MLEnvironmentReader {
                                 UUID(0, counter.toLong()),
                                 "node-${counter++}",
                                 mapOf("gpu" to isGpuFlag),
-                                MachineModel(cores, memories),
+                                MachineModel(cores, memories[0]),
                                 CpuPowerModels.linear(maxPower, minPower),
                             )
                         }
diff --git a/opendc-experiments/opendc-experiments-tf20/src/test/kotlin/org/opendc/experiments/tf20/TensorFlowTest.kt b/opendc-experiments/opendc-experiments-tf20/src/test/kotlin/org/opendc/experiments/tf20/TensorFlowTest.kt
index 28a77c2e..447827e9 100644
--- a/opendc-experiments/opendc-experiments-tf20/src/test/kotlin/org/opendc/experiments/tf20/TensorFlowTest.kt
+++ b/opendc-experiments/opendc-experiments-tf20/src/test/kotlin/org/opendc/experiments/tf20/TensorFlowTest.kt
@@ -49,8 +49,8 @@ class TensorFlowTest {
                     def.uid,
                     def.meta["gpu"] as Boolean,
                     dispatcher,
-                    def.model.cpus[0],
-                    def.model.memory[0],
+                    def.model.cpu,
+                    def.model.memory,
                     CpuPowerModels.linear(250.0, 60.0),
                 )
             val strategy = OneDeviceStrategy(device)
@@ -84,8 +84,8 @@ class TensorFlowTest {
                     def.uid,
                     def.meta["gpu"] as Boolean,
                     dispatcher,
-                    def.model.cpus[0],
-                    def.model.memory[0],
+                    def.model.cpu,
+                    def.model.memory,
                     CpuPowerModels.linear(250.0, 60.0),
                 )
             val strategy = OneDeviceStrategy(device)
@@ -119,8 +119,8 @@ class TensorFlowTest {
                     def.uid,
                     def.meta["gpu"] as Boolean,
                     dispatcher,
-                    def.model.cpus[0],
-                    def.model.memory[0],
+                    def.model.cpu,
+                    def.model.memory,
                     CpuPowerModels.linear(250.0, 60.0),
                 )
 
@@ -129,8 +129,8 @@ class TensorFlowTest {
                     UUID.randomUUID(),
                     def.meta["gpu"] as Boolean,
                     dispatcher,
-                    def.model.cpus[0],
-                    def.model.memory[0],
+                    def.model.cpu,
+                    def.model.memory,
                     CpuPowerModels.linear(250.0, 60.0),
                 )
 
diff --git a/opendc-experiments/opendc-experiments-tf20/src/test/kotlin/org/opendc/experiments/tf20/core/SimTFDeviceTest.kt b/opendc-experiments/opendc-experiments-tf20/src/test/kotlin/org/opendc/experiments/tf20/core/SimTFDeviceTest.kt
index 76473868..e0c4599a 100644
--- a/opendc-experiments/opendc-experiments-tf20/src/test/kotlin/org/opendc/experiments/tf20/core/SimTFDeviceTest.kt
+++ b/opendc-experiments/opendc-experiments-tf20/src/test/kotlin/org/opendc/experiments/tf20/core/SimTFDeviceTest.kt
@@ -27,9 +27,8 @@ import kotlinx.coroutines.launch
 import org.junit.jupiter.api.Assertions.assertAll
 import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.Test
+import org.opendc.simulator.compute.model.Cpu
 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.power.CpuPowerModels
 import org.opendc.simulator.kotlin.runSimulation
 import java.util.UUID
@@ -41,8 +40,7 @@ internal class SimTFDeviceTest {
     @Test
     fun testSmoke() =
         runSimulation {
-            val puNode = ProcessingNode("NVIDIA", "Tesla V100", "unknown", 1)
-            val pu = ProcessingUnit(puNode, 0, 960 * 1230.0)
+            val pu = Cpu(0, 1, 960 * 1230.0, "NVIDIA", "Tesla V100", "unknown")
             val memory = MemoryUnit("NVIDIA", "Tesla V100", 877.0, 32_000)
 
             val device =