feat(simulator): Expose CPU time counters directly on hypervisor

This change adds a new interface to the SimHypervisor interface that
exposes the CPU time counters directly. These are derived from the flow
counters and will be used by SimHost to expose them via telemetry.

2 files changed, 20 insertions, 66 deletions

diff --git a/opendc-simulator/opendc-simulator-compute/src/test/kotlin/org/opendc/simulator/compute/kernel/SimHypervisorTest.kt b/opendc-simulator/opendc-simulator-compute/src/test/kotlin/org/opendc/simulator/compute/kernel/SimFairShareHypervisorTest.kt
index 058d5d28..9db2e6ec 100644
--- a/opendc-simulator/opendc-simulator-compute/src/test/kotlin/org/opendc/simulator/compute/kernel/SimHypervisorTest.kt
+++ b/opendc-simulator/opendc-simulator-compute/src/test/kotlin/org/opendc/simulator/compute/kernel/SimFairShareHypervisorTest.kt
@@ -46,7 +46,7 @@ import org.opendc.simulator.flow.FlowEngine
  * Test suite for the [SimHypervisor] class.
  */
 @OptIn(ExperimentalCoroutinesApi::class)
-internal class SimHypervisorTest {
+internal class SimFairShareHypervisorTest {
     private lateinit var model: MachineModel
 
     @BeforeEach
@@ -63,26 +63,6 @@ internal class SimHypervisorTest {
      */
     @Test
     fun testOvercommittedSingle() = runBlockingSimulation {
-        val listener = object : SimHypervisor.Listener {
-            var totalRequestedWork = 0.0
-            var totalGrantedWork = 0.0
-            var totalOvercommittedWork = 0.0
-
-            override fun onSliceFinish(
-                hypervisor: SimHypervisor,
-                totalWork: Double,
-                grantedWork: Double,
-                overcommittedWork: Double,
-                interferedWork: Double,
-                cpuUsage: Double,
-                cpuDemand: Double
-            ) {
-                totalRequestedWork += totalWork
-                totalGrantedWork += grantedWork
-                totalOvercommittedWork += overcommittedWork
-            }
-        }
-
         val duration = 5 * 60L
         val workloadA =
             SimTraceWorkload(
@@ -96,7 +76,7 @@ internal class SimHypervisorTest {
 
         val platform = FlowEngine(coroutineContext, clock)
         val machine = SimBareMetalMachine(platform, model, SimplePowerDriver(ConstantPowerModel(0.0)))
-        val hypervisor = SimFairShareHypervisor(platform, scalingGovernor = PerformanceScalingGovernor(), listener = listener)
+        val hypervisor = SimFairShareHypervisor(platform, null, PerformanceScalingGovernor(), null)
 
         launch {
             machine.run(hypervisor)
@@ -111,9 +91,9 @@ internal class SimHypervisorTest {
         machine.close()
 
         assertAll(
-            { assertEquals(1113300.0, listener.totalRequestedWork, "Requested Burst does not match") },
-            { assertEquals(1023300.0, listener.totalGrantedWork, "Granted Burst does not match") },
-            { assertEquals(90000.0, listener.totalOvercommittedWork, "Overcommissioned Burst does not match") },
+            { assertEquals(319781, hypervisor.counters.cpuActiveTime, "Active time does not match") },
+            { assertEquals(880219, hypervisor.counters.cpuIdleTime, "Idle time does not match") },
+            { assertEquals(28125, hypervisor.counters.cpuStealTime, "Steal time does not match") },
             { assertEquals(1200000, clock.millis()) { "Current time is correct" } }
         )
     }
@@ -123,26 +103,6 @@ internal class SimHypervisorTest {
      */
     @Test
     fun testOvercommittedDual() = runBlockingSimulation {
-        val listener = object : SimHypervisor.Listener {
-            var totalRequestedWork = 0.0
-            var totalGrantedWork = 0.0
-            var totalOvercommittedWork = 0.0
-
-            override fun onSliceFinish(
-                hypervisor: SimHypervisor,
-                totalWork: Double,
-                grantedWork: Double,
-                overcommittedWork: Double,
-                interferedWork: Double,
-                cpuUsage: Double,
-                cpuDemand: Double
-            ) {
-                totalRequestedWork += totalWork
-                totalGrantedWork += grantedWork
-                totalOvercommittedWork += overcommittedWork
-            }
-        }
-
         val duration = 5 * 60L
         val workloadA =
             SimTraceWorkload(
@@ -167,7 +127,7 @@ internal class SimHypervisorTest {
         val machine = SimBareMetalMachine(
             platform, model, SimplePowerDriver(ConstantPowerModel(0.0))
         )
-        val hypervisor = SimFairShareHypervisor(platform, listener = listener)
+        val hypervisor = SimFairShareHypervisor(platform, null, null, null)
 
         launch {
             machine.run(hypervisor)
@@ -189,9 +149,9 @@ internal class SimHypervisorTest {
         yield()
 
         assertAll(
-            { assertEquals(2073600.0, listener.totalRequestedWork, "Requested Burst does not match") },
-            { assertEquals(1053600.0, listener.totalGrantedWork, "Granted Burst does not match") },
-            { assertEquals(1020000.0, listener.totalOvercommittedWork, "Overcommissioned Burst does not match") },
+            { assertEquals(329250, hypervisor.counters.cpuActiveTime, "Active time does not match") },
+            { assertEquals(870750, hypervisor.counters.cpuIdleTime, "Idle time does not match") },
+            { assertEquals(318750, hypervisor.counters.cpuStealTime, "Steal time does not match") },
             { assertEquals(1200000, clock.millis()) }
         )
     }
@@ -205,10 +165,8 @@ internal class SimHypervisorTest {
         )
 
         val platform = FlowEngine(coroutineContext, clock)
-        val machine = SimBareMetalMachine(
-            platform, model, SimplePowerDriver(ConstantPowerModel(0.0))
-        )
-        val hypervisor = SimFairShareHypervisor(platform)
+        val machine = SimBareMetalMachine(platform, model, SimplePowerDriver(ConstantPowerModel(0.0)))
+        val hypervisor = SimFairShareHypervisor(platform, null, null, null)
 
         assertDoesNotThrow {
             launch {
@@ -238,7 +196,7 @@ internal class SimHypervisorTest {
         val machine = SimBareMetalMachine(
             platform, model, SimplePowerDriver(ConstantPowerModel(0.0))
         )
-        val hypervisor = SimFairShareHypervisor(platform, interferenceDomain = interferenceModel.newDomain())
+        val hypervisor = SimFairShareHypervisor(platform, null, null, interferenceModel.newDomain())
 
         val duration = 5 * 60L
         val workloadA =
diff --git a/opendc-simulator/opendc-simulator-compute/src/test/kotlin/org/opendc/simulator/compute/kernel/SimSpaceSharedHypervisorTest.kt b/opendc-simulator/opendc-simulator-compute/src/test/kotlin/org/opendc/simulator/compute/kernel/SimSpaceSharedHypervisorTest.kt
index 95fb6679..b05ffd22 100644
--- a/opendc-simulator/opendc-simulator-compute/src/test/kotlin/org/opendc/simulator/compute/kernel/SimSpaceSharedHypervisorTest.kt
+++ b/opendc-simulator/opendc-simulator-compute/src/test/kotlin/org/opendc/simulator/compute/kernel/SimSpaceSharedHypervisorTest.kt
@@ -75,10 +75,8 @@ internal class SimSpaceSharedHypervisorTest {
             )
 
         val engine = FlowEngine(coroutineContext, clock)
-        val machine = SimBareMetalMachine(
-            FlowEngine(coroutineContext, clock), machineModel, SimplePowerDriver(ConstantPowerModel(0.0))
-        )
-        val hypervisor = SimSpaceSharedHypervisor(engine)
+        val machine = SimBareMetalMachine(engine, machineModel, SimplePowerDriver(ConstantPowerModel(0.0)))
+        val hypervisor = SimSpaceSharedHypervisor(engine, null, null)
 
         launch { machine.run(hypervisor) }
         val vm = hypervisor.createMachine(machineModel)
@@ -99,10 +97,8 @@ internal class SimSpaceSharedHypervisorTest {
         val duration = 5 * 60L * 1000
         val workload = SimRuntimeWorkload(duration)
         val engine = FlowEngine(coroutineContext, clock)
-        val machine = SimBareMetalMachine(
-            engine, machineModel, SimplePowerDriver(ConstantPowerModel(0.0))
-        )
-        val hypervisor = SimSpaceSharedHypervisor(engine)
+        val machine = SimBareMetalMachine(engine, machineModel, SimplePowerDriver(ConstantPowerModel(0.0)))
+        val hypervisor = SimSpaceSharedHypervisor(engine, null, null)
 
         launch { machine.run(hypervisor) }
         yield()
@@ -125,7 +121,7 @@ internal class SimSpaceSharedHypervisorTest {
         val machine = SimBareMetalMachine(
             engine, machineModel, SimplePowerDriver(ConstantPowerModel(0.0))
         )
-        val hypervisor = SimSpaceSharedHypervisor(engine)
+        val hypervisor = SimSpaceSharedHypervisor(engine, null, null)
 
         launch { machine.run(hypervisor) }
         yield()
@@ -146,7 +142,7 @@ internal class SimSpaceSharedHypervisorTest {
         val machine = SimBareMetalMachine(
             engine, machineModel, SimplePowerDriver(ConstantPowerModel(0.0))
         )
-        val hypervisor = SimSpaceSharedHypervisor(engine)
+        val hypervisor = SimSpaceSharedHypervisor(engine, null, null)
 
         launch { machine.run(hypervisor) }
         yield()
@@ -172,7 +168,7 @@ internal class SimSpaceSharedHypervisorTest {
     fun testConcurrentWorkloadFails() = runBlockingSimulation {
         val engine = FlowEngine(coroutineContext, clock)
         val machine = SimBareMetalMachine(engine, machineModel, SimplePowerDriver(ConstantPowerModel(0.0)))
-        val hypervisor = SimSpaceSharedHypervisor(engine)
+        val hypervisor = SimSpaceSharedHypervisor(engine, null, null)
 
         launch { machine.run(hypervisor) }
         yield()
@@ -196,7 +192,7 @@ internal class SimSpaceSharedHypervisorTest {
         val machine = SimBareMetalMachine(
             interpreter, machineModel, SimplePowerDriver(ConstantPowerModel(0.0))
         )
-        val hypervisor = SimSpaceSharedHypervisor(interpreter)
+        val hypervisor = SimSpaceSharedHypervisor(interpreter, null, null)
 
         launch { machine.run(hypervisor) }
         yield()