merge: Improve the OpenDC compute model (#37)

This pull request contains various improvements to the OpenDC compute simulation model.

- Support filtering hosts based on CPU capacity
- Do not allocate lambda in fast-path
- Redesign VM interference algorithm
- Report provisioning time of virtual machines
- Prevent allocations during collection cycle 
- Use correct flow input capacity for counters
- Support running workloads without coroutines

**Breaking API Changes**

- `VirtualMachine` now requires `cpuCapacity` parameter.
- `VmInterferenceModel` needs to be constructed using `VmInterferenceModel.Builder` and can't be passed a list of groups anymore.
- Scheduling latency is not collected anymore. Instead, use the boot time and provisioning time to derive the scheduling latency.
- Telemetry data is recorded using `*TableReader` interfaces as opposed to the `*Data` classes. These classes are re-used per row and should not be shared with other threads, since the underlying data may change.
- `SimMachine` does not implement `AutoCloseable` anymore. Machines can be removed from a `SimHypervisor` using the `removeMachine` method.
- `SimMachine.run` is moved to an extension method called `runWorkload`. Users can now also choose to run a workload using the asynchronous `SimMachine.startWorkload`.

2 files changed, 23 insertions, 24 deletions

diff --git a/opendc-web/opendc-web-runner/src/main/kotlin/org/opendc/web/runner/Main.kt b/opendc-web/opendc-web-runner/src/main/kotlin/org/opendc/web/runner/Main.kt
index 59308e11..a1bc869e 100644
--- a/opendc-web/opendc-web-runner/src/main/kotlin/org/opendc/web/runner/Main.kt
+++ b/opendc-web/opendc-web-runner/src/main/kotlin/org/opendc/web/runner/Main.kt
@@ -32,7 +32,7 @@ import org.opendc.compute.workload.*
 import org.opendc.compute.workload.topology.HostSpec
 import org.opendc.compute.workload.topology.Topology
 import org.opendc.compute.workload.topology.apply
-import org.opendc.compute.workload.util.PerformanceInterferenceReader
+import org.opendc.compute.workload.util.VmInterferenceModelReader
 import org.opendc.simulator.compute.kernel.interference.VmInterferenceModel
 import org.opendc.simulator.compute.model.MachineModel
 import org.opendc.simulator.compute.model.MemoryUnit
@@ -131,7 +131,7 @@ class RunnerCli : CliktCommand(name = "runner") {
         logger.info { "Constructing performance interference model" }
 
         val workloadLoader = ComputeWorkloadLoader(tracePath)
-        val interferenceGroups = let {
+        val interferenceModel = let {
             val path = tracePath.resolve(scenario.trace.traceId).resolve("performance-interference-model.json")
             val operational = scenario.operationalPhenomena
             val enabled = operational.performanceInterferenceEnabled
@@ -140,15 +140,14 @@ class RunnerCli : CliktCommand(name = "runner") {
                 return@let null
             }
 
-            PerformanceInterferenceReader().read(path.inputStream())
+            VmInterferenceModelReader().read(path.inputStream())
         }
 
         val targets = portfolio.targets
         val results = (0 until targets.repeatsPerScenario).map { repeat ->
             logger.info { "Starting repeat $repeat" }
             withTimeout(runTimeout * 1000) {
-                val interferenceModel = interferenceGroups?.let { VmInterferenceModel(it, Random(repeat.toLong())) }
-                runRepeat(scenario, repeat, topology, workloadLoader, interferenceModel)
+                runRepeat(scenario, repeat, topology, workloadLoader, interferenceModel?.withSeed(repeat.toLong()))
             }
         }
 
diff --git a/opendc-web/opendc-web-runner/src/main/kotlin/org/opendc/web/runner/WebComputeMetricExporter.kt b/opendc-web/opendc-web-runner/src/main/kotlin/org/opendc/web/runner/WebComputeMetricExporter.kt
index 7913660d..d39a0c74 100644
--- a/opendc-web/opendc-web-runner/src/main/kotlin/org/opendc/web/runner/WebComputeMetricExporter.kt
+++ b/opendc-web/opendc-web-runner/src/main/kotlin/org/opendc/web/runner/WebComputeMetricExporter.kt
@@ -24,8 +24,8 @@ package org.opendc.web.runner
 
 import org.opendc.telemetry.compute.ComputeMetricExporter
 import org.opendc.telemetry.compute.ComputeMonitor
-import org.opendc.telemetry.compute.table.HostData
-import org.opendc.telemetry.compute.table.ServiceData
+import org.opendc.telemetry.compute.table.HostTableReader
+import org.opendc.telemetry.compute.table.ServiceTableReader
 import kotlin.math.max
 import kotlin.math.roundToLong
 
@@ -33,24 +33,24 @@ import kotlin.math.roundToLong
  * A [ComputeMonitor] that tracks the aggregate metrics for each repeat.
  */
 class WebComputeMetricExporter : ComputeMetricExporter() {
-    override fun record(data: HostData) {
-        val slices = data.downtime / SLICE_LENGTH
+    override fun record(reader: HostTableReader) {
+        val slices = reader.downtime / SLICE_LENGTH
 
         hostAggregateMetrics = AggregateHostMetrics(
-            hostAggregateMetrics.totalActiveTime + data.cpuActiveTime,
-            hostAggregateMetrics.totalIdleTime + data.cpuIdleTime,
-            hostAggregateMetrics.totalStealTime + data.cpuStealTime,
-            hostAggregateMetrics.totalLostTime + data.cpuLostTime,
-            hostAggregateMetrics.totalPowerDraw + data.powerTotal,
+            hostAggregateMetrics.totalActiveTime + reader.cpuActiveTime,
+            hostAggregateMetrics.totalIdleTime + reader.cpuIdleTime,
+            hostAggregateMetrics.totalStealTime + reader.cpuStealTime,
+            hostAggregateMetrics.totalLostTime + reader.cpuLostTime,
+            hostAggregateMetrics.totalPowerDraw + reader.powerTotal,
             hostAggregateMetrics.totalFailureSlices + slices,
-            hostAggregateMetrics.totalFailureVmSlices + data.guestsRunning * slices
+            hostAggregateMetrics.totalFailureVmSlices + reader.guestsRunning * slices
         )
 
-        hostMetrics.compute(data.host.id) { _, prev ->
+        hostMetrics.compute(reader.host.id) { _, prev ->
             HostMetrics(
-                data.cpuUsage + (prev?.cpuUsage ?: 0.0),
-                data.cpuDemand + (prev?.cpuDemand ?: 0.0),
-                data.guestsRunning + (prev?.instanceCount ?: 0),
+                reader.cpuUsage + (prev?.cpuUsage ?: 0.0),
+                reader.cpuDemand + (prev?.cpuDemand ?: 0.0),
+                reader.guestsRunning + (prev?.instanceCount ?: 0),
                 1 + (prev?.count ?: 0)
             )
         }
@@ -79,13 +79,13 @@ class WebComputeMetricExporter : ComputeMetricExporter() {
 
     private var serviceMetrics: AggregateServiceMetrics = AggregateServiceMetrics()
 
-    override fun record(data: ServiceData) {
+    override fun record(reader: ServiceTableReader) {
         serviceMetrics = AggregateServiceMetrics(
-            max(data.attemptsSuccess, serviceMetrics.vmTotalCount),
-            max(data.serversPending, serviceMetrics.vmWaitingCount),
-            max(data.serversActive, serviceMetrics.vmActiveCount),
+            max(reader.attemptsSuccess, serviceMetrics.vmTotalCount),
+            max(reader.serversPending, serviceMetrics.vmWaitingCount),
+            max(reader.serversActive, serviceMetrics.vmActiveCount),
             max(0, serviceMetrics.vmInactiveCount),
-            max(data.attemptsFailure, serviceMetrics.vmFailedCount),
+            max(reader.attemptsFailure, serviceMetrics.vmFailedCount),
         )
     }