Migrate from Domain to TestCoroutineScope

This change eliminates the use of Domain and simulationContext in favour
of the generic (Test)CoroutineScope and Clock classes. In this way, we
decouple the OpenDC modules and their logic from simulation-related
code.

In this way, we also simplify eventual attempt for emulating OpenDC
componments in real-time.

4 files changed, 39 insertions, 70 deletions

diff --git a/simulator/opendc/opendc-compute/src/main/kotlin/com/atlarge/opendc/compute/virt/driver/SimpleVirtDriver.kt b/simulator/opendc/opendc-compute/src/main/kotlin/com/atlarge/opendc/compute/virt/driver/SimpleVirtDriver.kt
index df45f440..bd266208 100644
--- a/simulator/opendc/opendc-compute/src/main/kotlin/com/atlarge/opendc/compute/virt/driver/SimpleVirtDriver.kt
+++ b/simulator/opendc/opendc-compute/src/main/kotlin/com/atlarge/opendc/compute/virt/driver/SimpleVirtDriver.kt
@@ -39,18 +39,10 @@ import com.atlarge.opendc.compute.core.workload.PerformanceInterferenceModel
 import com.atlarge.opendc.compute.virt.HypervisorEvent
 import com.atlarge.opendc.core.services.ServiceKey
 import com.atlarge.opendc.core.services.ServiceRegistry
-import kotlinx.coroutines.CancellationException
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.DisposableHandle
-import kotlinx.coroutines.ExperimentalCoroutinesApi
-import kotlinx.coroutines.FlowPreview
-import kotlinx.coroutines.InternalCoroutinesApi
-import kotlinx.coroutines.Job
+import kotlinx.coroutines.*
 import kotlinx.coroutines.channels.Channel
-import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.intrinsics.startCoroutineCancellable
-import kotlinx.coroutines.launch
 import kotlinx.coroutines.selects.SelectClause0
 import kotlinx.coroutines.selects.SelectInstance
 import kotlinx.coroutines.selects.select
@@ -100,6 +92,8 @@ class SimpleVirtDriver(
     init {
         launch {
             try {
+                // Yield first to allow class variables to initialize
+                yield()
                 scheduler()
             } catch (e: Exception) {
                 if (e !is CancellationException) {
diff --git a/simulator/opendc/opendc-compute/src/test/kotlin/com/atlarge/opendc/compute/metal/driver/SimpleBareMetalDriverTest.kt b/simulator/opendc/opendc-compute/src/test/kotlin/com/atlarge/opendc/compute/metal/driver/SimpleBareMetalDriverTest.kt
index 80c9c547..7b57327e 100644
--- a/simulator/opendc/opendc-compute/src/test/kotlin/com/atlarge/opendc/compute/metal/driver/SimpleBareMetalDriverTest.kt
+++ b/simulator/opendc/opendc-compute/src/test/kotlin/com/atlarge/opendc/compute/metal/driver/SimpleBareMetalDriverTest.kt
@@ -24,53 +24,52 @@
 
 package com.atlarge.opendc.compute.metal.driver
 
-import com.atlarge.odcsim.SimulationEngineProvider
-import com.atlarge.odcsim.simulationContext
 import com.atlarge.opendc.compute.core.ProcessingNode
 import com.atlarge.opendc.compute.core.ProcessingUnit
 import com.atlarge.opendc.compute.core.ServerEvent
 import com.atlarge.opendc.compute.core.ServerState
 import com.atlarge.opendc.compute.core.image.FlopsApplicationImage
+import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.flow.collect
 import kotlinx.coroutines.flow.launchIn
 import kotlinx.coroutines.flow.onEach
 import kotlinx.coroutines.launch
-import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.test.TestCoroutineScope
 import kotlinx.coroutines.withContext
 import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.Test
-import java.util.ServiceLoader
+import org.opendc.simulator.utils.DelayControllerClockAdapter
 import java.util.UUID
 
+@OptIn(ExperimentalCoroutinesApi::class)
 internal class SimpleBareMetalDriverTest {
     /**
      * A smoke test for the bare-metal driver.
      */
     @Test
     fun smoke() {
+        val testScope = TestCoroutineScope()
+        val clock = DelayControllerClockAdapter(testScope)
+
         var finalState: ServerState = ServerState.BUILD
-        val provider = ServiceLoader.load(SimulationEngineProvider::class.java).first()
-        val system = provider("sim")
-        val root = system.newDomain(name = "root")
-        root.launch {
-            val dom = root.newDomain(name = "driver")
+        testScope.launch {
             val cpuNode = ProcessingNode("Intel", "Xeon", "amd64", 4)
             val cpus = List(4) { ProcessingUnit(cpuNode, it, 2400.0) }
-            val driver = SimpleBareMetalDriver(dom, simulationContext.clock, UUID.randomUUID(), "test", emptyMap(), cpus, emptyList())
+            val driver = SimpleBareMetalDriver(this, clock, UUID.randomUUID(), "test", emptyMap(), cpus, emptyList())
             val image = FlopsApplicationImage(UUID.randomUUID(), "<unnamed>", emptyMap(), 1_000, 2)
 
             // Batch driver commands
-            withContext(dom.coroutineContext) {
+            withContext(coroutineContext) {
                 driver.init()
                 driver.setImage(image)
                 val server = driver.start().server!!
                 driver.usage
-                    .onEach { println("${simulationContext.clock.millis()} $it") }
+                    .onEach { println("${clock.millis()} $it") }
                     .launchIn(this)
                 server.events.collect { event ->
                     when (event) {
                         is ServerEvent.StateChanged -> {
-                            println("${simulationContext.clock.millis()} $event")
+                            println("${clock.millis()} $event")
                             finalState = event.server.state
                         }
                     }
@@ -78,11 +77,7 @@ internal class SimpleBareMetalDriverTest {
             }
         }
 
-        runBlocking {
-            system.run()
-            system.terminate()
-        }
-
+        testScope.advanceUntilIdle()
         assertEquals(ServerState.SHUTOFF, finalState)
     }
 }
diff --git a/simulator/opendc/opendc-compute/src/test/kotlin/com/atlarge/opendc/compute/metal/service/SimpleProvisioningServiceTest.kt b/simulator/opendc/opendc-compute/src/test/kotlin/com/atlarge/opendc/compute/metal/service/SimpleProvisioningServiceTest.kt
index 37cd5898..0a85e0f9 100644
--- a/simulator/opendc/opendc-compute/src/test/kotlin/com/atlarge/opendc/compute/metal/service/SimpleProvisioningServiceTest.kt
+++ b/simulator/opendc/opendc-compute/src/test/kotlin/com/atlarge/opendc/compute/metal/service/SimpleProvisioningServiceTest.kt
@@ -24,40 +24,38 @@
 
 package com.atlarge.opendc.compute.metal.service
 
-import com.atlarge.odcsim.SimulationEngineProvider
-import com.atlarge.odcsim.simulationContext
 import com.atlarge.opendc.compute.core.ProcessingNode
 import com.atlarge.opendc.compute.core.ProcessingUnit
 import com.atlarge.opendc.compute.core.image.FlopsApplicationImage
 import com.atlarge.opendc.compute.metal.driver.SimpleBareMetalDriver
+import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.collect
 import kotlinx.coroutines.launch
-import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.test.TestCoroutineScope
 import org.junit.jupiter.api.Test
-import java.util.ServiceLoader
+import org.opendc.simulator.utils.DelayControllerClockAdapter
 import java.util.UUID
 
 /**
  * Test suite for the [SimpleProvisioningService].
  */
+@OptIn(ExperimentalCoroutinesApi::class)
 internal class SimpleProvisioningServiceTest {
     /**
      * A basic smoke test.
      */
     @Test
     fun smoke() {
-        val provider = ServiceLoader.load(SimulationEngineProvider::class.java).first()
-        val system = provider("sim")
-        val root = system.newDomain(name = "root")
-        root.launch {
-            val clock = simulationContext.clock
+        val testScope = TestCoroutineScope()
+        val clock = DelayControllerClockAdapter(testScope)
+
+        testScope.launch {
             val image = FlopsApplicationImage(UUID.randomUUID(), "<unnamed>", emptyMap(), 1000, 2)
-            val dom = root.newDomain("provisioner")
 
             val cpuNode = ProcessingNode("Intel", "Xeon", "amd64", 4)
             val cpus = List(4) { ProcessingUnit(cpuNode, it, 2400.0) }
-            val driver = SimpleBareMetalDriver(dom.newDomain(), clock, UUID.randomUUID(), "test", emptyMap(), cpus, emptyList())
+            val driver = SimpleBareMetalDriver(this, clock, UUID.randomUUID(), "test", emptyMap(), cpus, emptyList())
 
             val provisioner = SimpleProvisioningService()
             provisioner.create(driver)
@@ -67,9 +65,6 @@ internal class SimpleProvisioningServiceTest {
             node.server!!.events.collect { println(it) }
         }
 
-        runBlocking {
-            system.run()
-            system.terminate()
-        }
+        testScope.advanceUntilIdle()
     }
 }
diff --git a/simulator/opendc/opendc-compute/src/test/kotlin/com/atlarge/opendc/compute/virt/HypervisorTest.kt b/simulator/opendc/opendc-compute/src/test/kotlin/com/atlarge/opendc/compute/virt/HypervisorTest.kt
index 528434b1..dca0b292 100644
--- a/simulator/opendc/opendc-compute/src/test/kotlin/com/atlarge/opendc/compute/virt/HypervisorTest.kt
+++ b/simulator/opendc/opendc-compute/src/test/kotlin/com/atlarge/opendc/compute/virt/HypervisorTest.kt
@@ -24,8 +24,6 @@
 
 package com.atlarge.opendc.compute.virt
 
-import com.atlarge.odcsim.SimulationEngineProvider
-import com.atlarge.odcsim.simulationContext
 import com.atlarge.opendc.compute.core.Flavor
 import com.atlarge.opendc.compute.core.ProcessingNode
 import com.atlarge.opendc.compute.core.ProcessingUnit
@@ -39,17 +37,18 @@ import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.launchIn
 import kotlinx.coroutines.flow.onEach
 import kotlinx.coroutines.launch
-import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.test.TestCoroutineScope
 import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.Disabled
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.assertAll
-import java.util.ServiceLoader
+import org.opendc.simulator.utils.DelayControllerClockAdapter
 import java.util.UUID
 
 /**
  * Basic test-suite for the hypervisor.
  */
+@OptIn(ExperimentalCoroutinesApi::class)
 internal class HypervisorTest {
     /**
      * A smoke test for the bare-metal driver.
@@ -58,21 +57,17 @@ internal class HypervisorTest {
     @Test
     @Disabled
     fun smoke() {
-        val provider = ServiceLoader.load(SimulationEngineProvider::class.java).first()
-        val system = provider("test")
-        val root = system.newDomain("root")
+        val testScope = TestCoroutineScope()
+        val clock = DelayControllerClockAdapter(testScope)
 
-        root.launch {
-            val clock = simulationContext.clock
+        testScope.launch {
             val vmm = HypervisorImage
             val workloadA = FlopsApplicationImage(UUID.randomUUID(), "<unnamed>", emptyMap(), 1_000, 1)
             val workloadB = FlopsApplicationImage(UUID.randomUUID(), "<unnamed>", emptyMap(), 2_000, 1)
 
-            val driverDom = root.newDomain("driver")
-
             val cpuNode = ProcessingNode("Intel", "Xeon", "amd64", 1)
             val cpus = List(1) { ProcessingUnit(cpuNode, it, 2000.0) }
-            val metalDriver = SimpleBareMetalDriver(driverDom, clock, UUID.randomUUID(), "test", emptyMap(), cpus, emptyList())
+            val metalDriver = SimpleBareMetalDriver(this, clock, UUID.randomUUID(), "test", emptyMap(), cpus, emptyList())
 
             metalDriver.init()
             metalDriver.setImage(vmm)
@@ -90,10 +85,7 @@ internal class HypervisorTest {
             vmB.events.onEach { println(it) }.launchIn(this)
         }
 
-        runBlocking {
-            system.run()
-            system.terminate()
-        }
+        testScope.advanceUntilIdle()
     }
 
     /**
@@ -101,16 +93,14 @@ internal class HypervisorTest {
      */
     @Test
     fun overcommission() {
-        val provider = ServiceLoader.load(SimulationEngineProvider::class.java).first()
-        val system = provider("test")
-        val root = system.newDomain("root")
+        val testScope = TestCoroutineScope()
+        val clock = DelayControllerClockAdapter(testScope)
 
         var requestedBurst = 0L
         var grantedBurst = 0L
         var overcommissionedBurst = 0L
 
-        root.launch {
-            val clock = simulationContext.clock
+        testScope.launch {
             val vmm = HypervisorImage
             val duration = 5 * 60L
             val vmImageA = VmImage(
@@ -140,11 +130,9 @@ internal class HypervisorTest {
                 0
             )
 
-            val driverDom = root.newDomain("driver")
-
             val cpuNode = ProcessingNode("Intel", "Xeon", "amd64", 2)
             val cpus = List(2) { ProcessingUnit(cpuNode, it, 3200.0) }
-            val metalDriver = SimpleBareMetalDriver(driverDom, clock, UUID.randomUUID(), "test", emptyMap(), cpus, emptyList())
+            val metalDriver = SimpleBareMetalDriver(this, clock, UUID.randomUUID(), "test", emptyMap(), cpus, emptyList())
 
             metalDriver.init()
             metalDriver.setImage(vmm)
@@ -170,10 +158,7 @@ internal class HypervisorTest {
             vmDriver.spawn("b", vmImageB, flavor)
         }
 
-        runBlocking {
-            system.run()
-            system.terminate()
-        }
+        testScope.advanceUntilIdle()
 
         assertAll(
             { assertEquals(2073600, requestedBurst, "Requested Burst does not match") },