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`.

1 files changed, 16 insertions, 16 deletions

diff --git a/opendc-simulator/opendc-simulator-compute/src/jmh/kotlin/org/opendc/simulator/compute/SimMachineBenchmarks.kt b/opendc-simulator/opendc-simulator-compute/src/jmh/kotlin/org/opendc/simulator/compute/SimMachineBenchmarks.kt
index cb52d24f..91e91f9d 100644
--- a/opendc-simulator/opendc-simulator-compute/src/jmh/kotlin/org/opendc/simulator/compute/SimMachineBenchmarks.kt
+++ b/opendc-simulator/opendc-simulator-compute/src/jmh/kotlin/org/opendc/simulator/compute/SimMachineBenchmarks.kt
@@ -76,7 +76,7 @@ class SimMachineBenchmarks {
             val machine = SimBareMetalMachine(
                 engine, machineModel, SimplePowerDriver(ConstantPowerModel(0.0))
             )
-            return@runBlockingSimulation machine.run(SimTraceWorkload(trace))
+            return@runBlockingSimulation machine.runWorkload(SimTraceWorkload(trace))
         }
     }
 
@@ -89,15 +89,15 @@ class SimMachineBenchmarks {
             )
             val hypervisor = SimSpaceSharedHypervisor(engine, null, null)
 
-            launch { machine.run(hypervisor) }
+            launch { machine.runWorkload(hypervisor) }
 
-            val vm = hypervisor.createMachine(machineModel)
+            val vm = hypervisor.newMachine(machineModel)
 
             try {
-                return@runBlockingSimulation vm.run(SimTraceWorkload(trace))
+                return@runBlockingSimulation vm.runWorkload(SimTraceWorkload(trace))
             } finally {
-                vm.close()
-                machine.close()
+                vm.cancel()
+                machine.cancel()
             }
         }
     }
@@ -111,15 +111,15 @@ class SimMachineBenchmarks {
             )
             val hypervisor = SimFairShareHypervisor(engine, null, null, null)
 
-            launch { machine.run(hypervisor) }
+            launch { machine.runWorkload(hypervisor) }
 
-            val vm = hypervisor.createMachine(machineModel)
+            val vm = hypervisor.newMachine(machineModel)
 
             try {
-                return@runBlockingSimulation vm.run(SimTraceWorkload(trace))
+                return@runBlockingSimulation vm.runWorkload(SimTraceWorkload(trace))
             } finally {
-                vm.close()
-                machine.close()
+                vm.cancel()
+                machine.cancel()
             }
         }
     }
@@ -133,22 +133,22 @@ class SimMachineBenchmarks {
             )
             val hypervisor = SimFairShareHypervisor(engine, null, null, null)
 
-            launch { machine.run(hypervisor) }
+            launch { machine.runWorkload(hypervisor) }
 
             coroutineScope {
                 repeat(2) {
-                    val vm = hypervisor.createMachine(machineModel)
+                    val vm = hypervisor.newMachine(machineModel)
 
                     launch {
                         try {
-                            vm.run(SimTraceWorkload(trace))
+                            vm.runWorkload(SimTraceWorkload(trace))
                         } finally {
-                            machine.close()
+                            machine.cancel()
                         }
                     }
                 }
             }
-            machine.close()
+            machine.cancel()
         }
     }
 }