refactor: Replace use of CoroutineContext by Dispatcher

This change replaces the use of `CoroutineContext` for passing the
`SimulationDispatcher` across the different modules of OpenDC by the
lightweight `Dispatcher` interface of the OpenDC common module.

16 files changed, 42 insertions, 81 deletions

diff --git a/opendc-experiments/opendc-experiments-base/src/main/kotlin/org/opendc/experiments/provisioner/Provisioner.kt b/opendc-experiments/opendc-experiments-base/src/main/kotlin/org/opendc/experiments/provisioner/Provisioner.kt
index 66fcca22..eae5806e 100644
--- a/opendc-experiments/opendc-experiments-base/src/main/kotlin/org/opendc/experiments/provisioner/Provisioner.kt
+++ b/opendc-experiments/opendc-experiments-base/src/main/kotlin/org/opendc/experiments/provisioner/Provisioner.kt
@@ -22,13 +22,12 @@
 
 package org.opendc.experiments.provisioner
 
+import org.opendc.common.Dispatcher
 import org.opendc.experiments.MutableServiceRegistry
 import org.opendc.experiments.ServiceRegistry
 import org.opendc.experiments.internal.ServiceRegistryImpl
-import java.time.InstantSource
 import java.util.ArrayDeque
 import java.util.SplittableRandom
-import kotlin.coroutines.CoroutineContext
 
 /**
  * A helper class to set up the experimental environment in a reproducible manner.
@@ -37,17 +36,15 @@ import kotlin.coroutines.CoroutineContext
  * [ProvisioningStep]s are executed sequentially and ensure that the necessary infrastructure is configured and teared
  * down after the simulation completes.
  *
- * @param coroutineContext The [CoroutineContext] in which the environment is set up.
- * @param clock The simulation clock represented as [InstantSource].
+ * @param dispatcher The [Dispatcher] implementation for scheduling future tasks.
  * @param seed A seed for initializing the randomness of the environment.
  */
-public class Provisioner(coroutineContext: CoroutineContext, clock: InstantSource, seed: Long) : AutoCloseable {
+public class Provisioner(dispatcher: Dispatcher, seed: Long) : AutoCloseable {
     /**
      * Implementation of [ProvisioningContext].
      */
     private val context = object : ProvisioningContext {
-        override val clock: InstantSource = clock
-        override val coroutineContext: CoroutineContext = coroutineContext
+        override val dispatcher: Dispatcher = dispatcher
         override val seeder: SplittableRandom = SplittableRandom(seed)
         override val registry: MutableServiceRegistry = ServiceRegistryImpl()
 
diff --git a/opendc-experiments/opendc-experiments-base/src/main/kotlin/org/opendc/experiments/provisioner/ProvisioningContext.kt b/opendc-experiments/opendc-experiments-base/src/main/kotlin/org/opendc/experiments/provisioner/ProvisioningContext.kt
index 7eec6fa4..e53044ce 100644
--- a/opendc-experiments/opendc-experiments-base/src/main/kotlin/org/opendc/experiments/provisioner/ProvisioningContext.kt
+++ b/opendc-experiments/opendc-experiments-base/src/main/kotlin/org/opendc/experiments/provisioner/ProvisioningContext.kt
@@ -22,27 +22,21 @@
 
 package org.opendc.experiments.provisioner
 
+import org.opendc.common.Dispatcher
 import org.opendc.experiments.MutableServiceRegistry
-import java.time.InstantSource
 import java.util.SplittableRandom
 import java.util.random.RandomGenerator
-import kotlin.coroutines.CoroutineContext
 
 /**
  * The [ProvisioningContext] class provides access to shared state between subsequent [ProvisioningStep]s, as well as
- * access to the simulation dispatcher (via [CoroutineContext]), the virtual clock, and a randomness seeder to allow
+ * access to the simulation dispatcher, the virtual clock, and a randomness seeder to allow
  * the provisioning steps to initialize the (simulated) resources.
  */
 public interface ProvisioningContext {
     /**
-     * The [CoroutineContext] in which the provisioner runs.
+     * The [Dispatcher] provided by the provisioner to schedule future events during the simulation.
      */
-    public val coroutineContext: CoroutineContext
-
-    /**
-     * The [InstantSource] tracking the virtual simulation time.
-     */
-    public val clock: InstantSource
+    public val dispatcher: Dispatcher
 
     /**
      * A [SplittableRandom] instance used to seed the provisioners.
diff --git a/opendc-experiments/opendc-experiments-capelin/src/jmh/kotlin/org/opendc/experiments/capelin/CapelinBenchmarks.kt b/opendc-experiments/opendc-experiments-capelin/src/jmh/kotlin/org/opendc/experiments/capelin/CapelinBenchmarks.kt
index 08bb2c32..1221f084 100644
--- a/opendc-experiments/opendc-experiments-capelin/src/jmh/kotlin/org/opendc/experiments/capelin/CapelinBenchmarks.kt
+++ b/opendc-experiments/opendc-experiments-capelin/src/jmh/kotlin/org/opendc/experiments/capelin/CapelinBenchmarks.kt
@@ -75,7 +75,7 @@ class CapelinBenchmarks {
     fun benchmarkCapelin() = runSimulation {
         val serviceDomain = "compute.opendc.org"
 
-        Provisioner(coroutineContext, timeSource, seed = 0).use { provisioner ->
+        Provisioner(dispatcher, seed = 0).use { provisioner ->
             val computeScheduler = FilterScheduler(
                 filters = listOf(ComputeFilter(), VCpuFilter(16.0), RamFilter(1.0)),
                 weighers = listOf(CoreRamWeigher(multiplier = 1.0))
diff --git a/opendc-experiments/opendc-experiments-capelin/src/main/kotlin/org/opendc/experiments/capelin/CapelinRunner.kt b/opendc-experiments/opendc-experiments-capelin/src/main/kotlin/org/opendc/experiments/capelin/CapelinRunner.kt
index 1f9f3439..2567a4d5 100644
--- a/opendc-experiments/opendc-experiments-capelin/src/main/kotlin/org/opendc/experiments/capelin/CapelinRunner.kt
+++ b/opendc-experiments/opendc-experiments-capelin/src/main/kotlin/org/opendc/experiments/capelin/CapelinRunner.kt
@@ -64,7 +64,7 @@ public class CapelinRunner(
         val serviceDomain = "compute.opendc.org"
         val topology = clusterTopology(File(envPath, "${scenario.topology.name}.txt"))
 
-        Provisioner(coroutineContext, timeSource, seed).use { provisioner ->
+        Provisioner(dispatcher, seed).use { provisioner ->
             provisioner.runSteps(
                 setupComputeService(serviceDomain, { createComputeScheduler(scenario.allocationPolicy, Random(it.seeder.nextLong())) }),
                 setupHosts(serviceDomain, topology, optimize = true)
diff --git a/opendc-experiments/opendc-experiments-capelin/src/test/kotlin/org/opendc/experiments/capelin/CapelinIntegrationTest.kt b/opendc-experiments/opendc-experiments-capelin/src/test/kotlin/org/opendc/experiments/capelin/CapelinIntegrationTest.kt
index aa7d552e..7e01bb64 100644
--- a/opendc-experiments/opendc-experiments-capelin/src/test/kotlin/org/opendc/experiments/capelin/CapelinIntegrationTest.kt
+++ b/opendc-experiments/opendc-experiments-capelin/src/test/kotlin/org/opendc/experiments/capelin/CapelinIntegrationTest.kt
@@ -94,7 +94,7 @@ class CapelinIntegrationTest {
         val topology = createTopology()
         val monitor = monitor
 
-        Provisioner(coroutineContext, timeSource, seed).use { provisioner ->
+        Provisioner(dispatcher, seed).use { provisioner ->
             provisioner.runSteps(
                 setupComputeService(serviceDomain = "compute.opendc.org", { computeScheduler }),
                 registerComputeMonitor(serviceDomain = "compute.opendc.org", monitor),
@@ -138,7 +138,7 @@ class CapelinIntegrationTest {
         val topology = createTopology("single")
         val monitor = monitor
 
-        Provisioner(coroutineContext, timeSource, seed).use { provisioner ->
+        Provisioner(dispatcher, seed).use { provisioner ->
             provisioner.runSteps(
                 setupComputeService(serviceDomain = "compute.opendc.org", { computeScheduler }),
                 registerComputeMonitor(serviceDomain = "compute.opendc.org", monitor),
@@ -177,7 +177,7 @@ class CapelinIntegrationTest {
         val workload = createTestWorkload(1.0, seed)
         val topology = createTopology("single")
 
-        Provisioner(coroutineContext, timeSource, seed).use { provisioner ->
+        Provisioner(dispatcher, seed).use { provisioner ->
             provisioner.runSteps(
                 setupComputeService(serviceDomain = "compute.opendc.org", { computeScheduler }),
                 registerComputeMonitor(serviceDomain = "compute.opendc.org", monitor),
@@ -216,7 +216,7 @@ class CapelinIntegrationTest {
         val workload = createTestWorkload(0.25, seed)
         val monitor = monitor
 
-        Provisioner(coroutineContext, timeSource, seed).use { provisioner ->
+        Provisioner(dispatcher, seed).use { provisioner ->
             provisioner.runSteps(
                 setupComputeService(serviceDomain = "compute.opendc.org", { computeScheduler }),
                 registerComputeMonitor(serviceDomain = "compute.opendc.org", monitor),
diff --git a/opendc-experiments/opendc-experiments-compute/src/main/kotlin/org/opendc/experiments/compute/ComputeServiceProvisioningStep.kt b/opendc-experiments/opendc-experiments-compute/src/main/kotlin/org/opendc/experiments/compute/ComputeServiceProvisioningStep.kt
index 38cbf2dc..d7347327 100644
--- a/opendc-experiments/opendc-experiments-compute/src/main/kotlin/org/opendc/experiments/compute/ComputeServiceProvisioningStep.kt
+++ b/opendc-experiments/opendc-experiments-compute/src/main/kotlin/org/opendc/experiments/compute/ComputeServiceProvisioningStep.kt
@@ -41,7 +41,7 @@ public class ComputeServiceProvisioningStep internal constructor(
     private val schedulingQuantum: Duration
 ) : ProvisioningStep {
     override fun apply(ctx: ProvisioningContext): AutoCloseable {
-        val service = ComputeService(ctx.coroutineContext, ctx.clock, scheduler(ctx), schedulingQuantum)
+        val service = ComputeService(ctx.dispatcher, scheduler(ctx), schedulingQuantum)
         ctx.registry.register(serviceDomain, ComputeService::class.java, service)
 
         return AutoCloseable { service.close() }
diff --git a/opendc-experiments/opendc-experiments-compute/src/main/kotlin/org/opendc/experiments/compute/HostsProvisioningStep.kt b/opendc-experiments/opendc-experiments-compute/src/main/kotlin/org/opendc/experiments/compute/HostsProvisioningStep.kt
index e224fb84..310aa54c 100644
--- a/opendc-experiments/opendc-experiments-compute/src/main/kotlin/org/opendc/experiments/compute/HostsProvisioningStep.kt
+++ b/opendc-experiments/opendc-experiments-compute/src/main/kotlin/org/opendc/experiments/compute/HostsProvisioningStep.kt
@@ -46,7 +46,7 @@ public class HostsProvisioningStep internal constructor(
 ) : ProvisioningStep {
     override fun apply(ctx: ProvisioningContext): AutoCloseable {
         val service = requireNotNull(ctx.registry.resolve(serviceDomain, ComputeService::class.java)) { "Compute service $serviceDomain does not exist" }
-        val engine = FlowEngine.create(ctx.coroutineContext, ctx.clock)
+        val engine = FlowEngine.create(ctx.dispatcher)
         val graph = engine.newGraph()
         val hosts = mutableSetOf<SimHost>()
 
@@ -58,7 +58,7 @@ public class HostsProvisioningStep internal constructor(
                 spec.uid,
                 spec.name,
                 spec.meta,
-                ctx.clock,
+                ctx.dispatcher.timeSource,
                 machine,
                 hypervisor,
                 optimize = optimize
diff --git a/opendc-experiments/opendc-experiments-compute/src/main/kotlin/org/opendc/experiments/compute/telemetry/ComputeMetricReader.kt b/opendc-experiments/opendc-experiments-compute/src/main/kotlin/org/opendc/experiments/compute/telemetry/ComputeMetricReader.kt
index f39f74bc..efd38a3c 100644
--- a/opendc-experiments/opendc-experiments-compute/src/main/kotlin/org/opendc/experiments/compute/telemetry/ComputeMetricReader.kt
+++ b/opendc-experiments/opendc-experiments-compute/src/main/kotlin/org/opendc/experiments/compute/telemetry/ComputeMetricReader.kt
@@ -27,6 +27,8 @@ import kotlinx.coroutines.delay
 import kotlinx.coroutines.isActive
 import kotlinx.coroutines.launch
 import mu.KotlinLogging
+import org.opendc.common.Dispatcher
+import org.opendc.common.asCoroutineDispatcher
 import org.opendc.compute.api.Server
 import org.opendc.compute.service.ComputeService
 import org.opendc.compute.service.driver.Host
@@ -37,26 +39,25 @@ import org.opendc.experiments.compute.telemetry.table.ServerTableReader
 import org.opendc.experiments.compute.telemetry.table.ServiceTableReader
 import java.time.Duration
 import java.time.Instant
-import java.time.InstantSource
 
 /**
  * A helper class to collect metrics from a [ComputeService] instance and automatically export the metrics every
  * export interval.
  *
- * @param scope The [CoroutineScope] to run the reader in.
- * @param clock The virtual clock.
+ * @param dispatcher A [Dispatcher] for scheduling the future events.
  * @param service The [ComputeService] to monitor.
  * @param monitor The monitor to export the metrics to.
  * @param exportInterval The export interval.
  */
 public class ComputeMetricReader(
-    scope: CoroutineScope,
-    clock: InstantSource,
+    dispatcher: Dispatcher,
     private val service: ComputeService,
     private val monitor: ComputeMonitor,
     private val exportInterval: Duration = Duration.ofMinutes(5)
 ) : AutoCloseable {
     private val logger = KotlinLogging.logger {}
+    private val scope = CoroutineScope(dispatcher.asCoroutineDispatcher())
+    private val clock = dispatcher.timeSource
 
     /**
      * Aggregator for service metrics.
diff --git a/opendc-experiments/opendc-experiments-compute/src/main/kotlin/org/opendc/experiments/compute/telemetry/ComputeMonitorProvisioningStep.kt b/opendc-experiments/opendc-experiments-compute/src/main/kotlin/org/opendc/experiments/compute/telemetry/ComputeMonitorProvisioningStep.kt
index 68ca5ae8..665611dd 100644
--- a/opendc-experiments/opendc-experiments-compute/src/main/kotlin/org/opendc/experiments/compute/telemetry/ComputeMonitorProvisioningStep.kt
+++ b/opendc-experiments/opendc-experiments-compute/src/main/kotlin/org/opendc/experiments/compute/telemetry/ComputeMonitorProvisioningStep.kt
@@ -22,9 +22,6 @@
 
 package org.opendc.experiments.compute.telemetry
 
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Job
-import kotlinx.coroutines.cancel
 import org.opendc.compute.service.ComputeService
 import org.opendc.experiments.provisioner.ProvisioningContext
 import org.opendc.experiments.provisioner.ProvisioningStep
@@ -40,13 +37,8 @@ public class ComputeMonitorProvisioningStep internal constructor(
     private val exportInterval: Duration
 ) : ProvisioningStep {
     override fun apply(ctx: ProvisioningContext): AutoCloseable {
-        val scope = CoroutineScope(ctx.coroutineContext + Job())
         val service = requireNotNull(ctx.registry.resolve(serviceDomain, ComputeService::class.java)) { "Compute service $serviceDomain does not exist" }
-        val metricReader = ComputeMetricReader(scope, ctx.clock, service, monitor, exportInterval)
-
-        return AutoCloseable {
-            metricReader.close()
-            scope.cancel()
-        }
+        val metricReader = ComputeMetricReader(ctx.dispatcher, service, monitor, exportInterval)
+        return AutoCloseable { metricReader.close() }
     }
 }
diff --git a/opendc-experiments/opendc-experiments-faas/src/main/kotlin/org/opendc/experiments/faas/FaaSServiceProvisioningStep.kt b/opendc-experiments/opendc-experiments-faas/src/main/kotlin/org/opendc/experiments/faas/FaaSServiceProvisioningStep.kt
index 3b4200c8..e5c2f86a 100644
--- a/opendc-experiments/opendc-experiments-faas/src/main/kotlin/org/opendc/experiments/faas/FaaSServiceProvisioningStep.kt
+++ b/opendc-experiments/opendc-experiments-faas/src/main/kotlin/org/opendc/experiments/faas/FaaSServiceProvisioningStep.kt
@@ -56,10 +56,9 @@ public class FaaSServiceProvisioningStep internal constructor(
         } else {
             ZeroDelayInjector
         }
-        val deployer = SimFunctionDeployer(ctx.coroutineContext, ctx.clock, machineModel, delayInjector)
+        val deployer = SimFunctionDeployer(ctx.dispatcher, machineModel, delayInjector)
         val service = FaaSService(
-            ctx.coroutineContext,
-            ctx.clock,
+            ctx.dispatcher,
             deployer,
             routingPolicy(ctx),
             terminationPolicy(ctx)
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 ff825260..4a4d9ae0 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
@@ -49,12 +49,12 @@ class FaaSExperiment {
     fun testSmoke() = runSimulation {
         val faasService = "faas.opendc.org"
 
-        Provisioner(coroutineContext, timeSource, seed = 0L).use { provisioner ->
+        Provisioner(dispatcher, seed = 0L).use { provisioner ->
             provisioner.runStep(
                 setupFaaSService(
                     faasService,
                     { RandomRoutingPolicy() },
-                    { FunctionTerminationPolicyFixed(it.coroutineContext, it.clock, timeout = Duration.ofMinutes(10)) },
+                    { FunctionTerminationPolicyFixed(it.dispatcher, timeout = Duration.ofMinutes(10)) },
                     createMachineModel(),
                     coldStartModel = ColdStartModel.GOOGLE
                 )
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 51f6e763..53bf5aa6 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
@@ -22,12 +22,9 @@
 
 package org.opendc.experiments.tf20.core
 
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Job
-import kotlinx.coroutines.cancel
 import kotlinx.coroutines.delay
-import kotlinx.coroutines.launch
 import kotlinx.coroutines.suspendCancellableCoroutine
+import org.opendc.common.Dispatcher
 import org.opendc.simulator.compute.SimBareMetalMachine
 import org.opendc.simulator.compute.SimMachine
 import org.opendc.simulator.compute.SimMachineContext
@@ -36,17 +33,14 @@ 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.runWorkload
 import org.opendc.simulator.compute.workload.SimWorkload
 import org.opendc.simulator.flow2.FlowEngine
 import org.opendc.simulator.flow2.FlowStage
 import org.opendc.simulator.flow2.FlowStageLogic
 import org.opendc.simulator.flow2.OutPort
-import java.time.InstantSource
 import java.util.ArrayDeque
 import java.util.UUID
 import kotlin.coroutines.Continuation
-import kotlin.coroutines.CoroutineContext
 import kotlin.coroutines.resume
 import kotlin.math.ceil
 import kotlin.math.roundToLong
@@ -57,22 +51,16 @@ import kotlin.math.roundToLong
 public class SimTFDevice(
     override val uid: UUID,
     override val isGpu: Boolean,
-    context: CoroutineContext,
-    clock: InstantSource,
+    dispatcher: Dispatcher,
     pu: ProcessingUnit,
     private val memory: MemoryUnit,
     powerModel: CpuPowerModel
 ) : TFDevice {
     /**
-     * The scope in which the device runs.
-     */
-    private val scope = CoroutineScope(context + Job())
-
-    /**
      * The [SimMachine] representing the device.
      */
     private val machine = SimBareMetalMachine.create(
-        FlowEngine.create(context, clock).newGraph(),
+        FlowEngine.create(dispatcher).newGraph(),
         MachineModel(listOf(pu), listOf(memory)),
         SimPsuFactories.simple(powerModel)
     )
@@ -162,9 +150,7 @@ public class SimTFDevice(
     }
 
     init {
-        scope.launch {
-            machine.runWorkload(workload)
-        }
+        machine.startWorkload(workload, emptyMap()) {}
     }
 
     override suspend fun load(dataSize: Long) {
@@ -185,7 +171,6 @@ public class SimTFDevice(
 
     override fun close() {
         machine.cancel()
-        scope.cancel()
     }
 
     private data class Work(var flops: Double, val cont: Continuation<Unit>) {
diff --git a/opendc-experiments/opendc-experiments-tf20/src/main/kotlin/org/opendc/experiments/tf20/network/NetworkController.kt b/opendc-experiments/opendc-experiments-tf20/src/main/kotlin/org/opendc/experiments/tf20/network/NetworkController.kt
index 6fcdf513..5b408fb3 100644
--- a/opendc-experiments/opendc-experiments-tf20/src/main/kotlin/org/opendc/experiments/tf20/network/NetworkController.kt
+++ b/opendc-experiments/opendc-experiments-tf20/src/main/kotlin/org/opendc/experiments/tf20/network/NetworkController.kt
@@ -23,19 +23,18 @@
 package org.opendc.experiments.tf20.network
 
 import kotlinx.coroutines.channels.Channel
+import org.opendc.common.Dispatcher
 import org.opendc.common.util.TimerScheduler
-import java.time.InstantSource
-import kotlin.coroutines.CoroutineContext
 
 /**
  * The network controller represents a simple network model between the worker and master nodes during
  * TensorFlow execution.
  */
-public class NetworkController(context: CoroutineContext, clock: InstantSource) : AutoCloseable {
+public class NetworkController(dispatcher: Dispatcher) : AutoCloseable {
     /**
      * The scheduler for the message.
      */
-    private val scheduler = TimerScheduler<Message>(context, clock)
+    private val scheduler = TimerScheduler<Message>(dispatcher)
 
     /**
      * The outbound communication channels.
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 d01a4a3c..899aafc0 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
@@ -48,8 +48,7 @@ class TensorFlowTest {
         val device = SimTFDevice(
             def.uid,
             def.meta["gpu"] as Boolean,
-            coroutineContext,
-            timeSource,
+            dispatcher,
             def.model.cpus[0],
             def.model.memory[0],
             CpuPowerModels.linear(250.0, 60.0)
@@ -83,8 +82,7 @@ class TensorFlowTest {
         val device = SimTFDevice(
             def.uid,
             def.meta["gpu"] as Boolean,
-            coroutineContext,
-            timeSource,
+            dispatcher,
             def.model.cpus[0],
             def.model.memory[0],
             CpuPowerModels.linear(250.0, 60.0)
@@ -118,8 +116,7 @@ class TensorFlowTest {
         val deviceA = SimTFDevice(
             def.uid,
             def.meta["gpu"] as Boolean,
-            coroutineContext,
-            timeSource,
+            dispatcher,
             def.model.cpus[0],
             def.model.memory[0],
             CpuPowerModels.linear(250.0, 60.0)
@@ -128,8 +125,7 @@ class TensorFlowTest {
         val deviceB = SimTFDevice(
             UUID.randomUUID(),
             def.meta["gpu"] as Boolean,
-            coroutineContext,
-            timeSource,
+            dispatcher,
             def.model.cpus[0],
             def.model.memory[0],
             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 9f15eab6..549c6f3e 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
@@ -47,8 +47,7 @@ internal class SimTFDeviceTest {
         val device = SimTFDevice(
             UUID.randomUUID(),
             isGpu = true,
-            coroutineContext,
-            timeSource,
+            dispatcher,
             pu,
             memory,
             CpuPowerModels.linear(250.0, 100.0)
diff --git a/opendc-experiments/opendc-experiments-workflow/src/main/kotlin/org/opendc/experiments/workflow/WorkflowServiceProvisioningStep.kt b/opendc-experiments/opendc-experiments-workflow/src/main/kotlin/org/opendc/experiments/workflow/WorkflowServiceProvisioningStep.kt
index 5cee9abf..fe4fde17 100644
--- a/opendc-experiments/opendc-experiments-workflow/src/main/kotlin/org/opendc/experiments/workflow/WorkflowServiceProvisioningStep.kt
+++ b/opendc-experiments/opendc-experiments-workflow/src/main/kotlin/org/opendc/experiments/workflow/WorkflowServiceProvisioningStep.kt
@@ -47,8 +47,7 @@ public class WorkflowServiceProvisioningStep internal constructor(
 
         val client = computeService.newClient()
         val service = WorkflowService(
-            ctx.coroutineContext,
-            ctx.clock,
+            ctx.dispatcher,
             client,
             scheduler.schedulingQuantum,
             jobAdmissionPolicy = scheduler.jobAdmissionPolicy,