refactor(simulator): Migrate to flow-based simulation

This change renames the `opendc-simulator-resources` module into the
`opendc-simulator-flow` module to indicate that the core simulation
model of OpenDC is based around modelling and simulating flows.

Previously, the distinction between resource consumer and provider, and
input and output caused some confusion. By switching to a flow-based
model, this distinction is now clear (as in, the water flows from source
to consumer/sink).

31 files changed, 219 insertions, 220 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 88ad7286..c57919c1 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
@@ -36,7 +36,7 @@ import org.opendc.simulator.compute.power.SimplePowerDriver
 import org.opendc.simulator.compute.workload.SimTraceWorkload
 import org.opendc.simulator.core.SimulationCoroutineScope
 import org.opendc.simulator.core.runBlockingSimulation
-import org.opendc.simulator.resources.SimResourceInterpreter
+import org.opendc.simulator.flow.FlowEngine
 import org.openjdk.jmh.annotations.*
 import java.util.concurrent.ThreadLocalRandom
 import java.util.concurrent.TimeUnit
@@ -48,13 +48,13 @@ import java.util.concurrent.TimeUnit
 @OptIn(ExperimentalCoroutinesApi::class)
 class SimMachineBenchmarks {
     private lateinit var scope: SimulationCoroutineScope
-    private lateinit var interpreter: SimResourceInterpreter
+    private lateinit var engine: FlowEngine
     private lateinit var machineModel: MachineModel
 
     @Setup
     fun setUp() {
         scope = SimulationCoroutineScope()
-        interpreter = SimResourceInterpreter(scope.coroutineContext, scope.clock)
+        engine = FlowEngine(scope.coroutineContext, scope.clock)
 
         val cpuNode = ProcessingNode("Intel", "Xeon", "amd64", 2)
 
@@ -80,7 +80,7 @@ class SimMachineBenchmarks {
     fun benchmarkBareMetal(state: Workload) {
         return scope.runBlockingSimulation {
             val machine = SimBareMetalMachine(
-                interpreter, machineModel, SimplePowerDriver(ConstantPowerModel(0.0))
+                engine, machineModel, SimplePowerDriver(ConstantPowerModel(0.0))
             )
             return@runBlockingSimulation machine.run(SimTraceWorkload(state.trace))
         }
@@ -90,9 +90,9 @@ class SimMachineBenchmarks {
     fun benchmarkSpaceSharedHypervisor(state: Workload) {
         return scope.runBlockingSimulation {
             val machine = SimBareMetalMachine(
-                interpreter, machineModel, SimplePowerDriver(ConstantPowerModel(0.0))
+                engine, machineModel, SimplePowerDriver(ConstantPowerModel(0.0))
             )
-            val hypervisor = SimSpaceSharedHypervisor(interpreter)
+            val hypervisor = SimSpaceSharedHypervisor(engine)
 
             launch { machine.run(hypervisor) }
 
@@ -111,9 +111,9 @@ class SimMachineBenchmarks {
     fun benchmarkFairShareHypervisorSingle(state: Workload) {
         return scope.runBlockingSimulation {
             val machine = SimBareMetalMachine(
-                interpreter, machineModel, SimplePowerDriver(ConstantPowerModel(0.0))
+                engine, machineModel, SimplePowerDriver(ConstantPowerModel(0.0))
             )
-            val hypervisor = SimFairShareHypervisor(interpreter)
+            val hypervisor = SimFairShareHypervisor(engine)
 
             launch { machine.run(hypervisor) }
 
@@ -132,9 +132,9 @@ class SimMachineBenchmarks {
     fun benchmarkFairShareHypervisorDouble(state: Workload) {
         return scope.runBlockingSimulation {
             val machine = SimBareMetalMachine(
-                interpreter, machineModel, SimplePowerDriver(ConstantPowerModel(0.0))
+                engine, machineModel, SimplePowerDriver(ConstantPowerModel(0.0))
             )
-            val hypervisor = SimFairShareHypervisor(interpreter)
+            val hypervisor = SimFairShareHypervisor(engine)
 
             launch { machine.run(hypervisor) }
 
diff --git a/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/SimAbstractMachine.kt b/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/SimAbstractMachine.kt
index f9db048d..6a62d8a5 100644
--- a/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/SimAbstractMachine.kt
+++ b/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/SimAbstractMachine.kt
@@ -30,22 +30,22 @@ import org.opendc.simulator.compute.model.MemoryUnit
 import org.opendc.simulator.compute.model.NetworkAdapter
 import org.opendc.simulator.compute.model.StorageDevice
 import org.opendc.simulator.compute.workload.SimWorkload
-import org.opendc.simulator.resources.*
+import org.opendc.simulator.flow.*
 import kotlin.coroutines.Continuation
 import kotlin.coroutines.resume
 
 /**
  * Abstract implementation of the [SimMachine] interface.
  *
- * @param interpreter The interpreter to manage the machine's resources.
+ * @param engine The engine to manage the machine's resources.
  * @param parent The parent simulation system.
  * @param model The model of the machine.
  */
 public abstract class SimAbstractMachine(
-    protected val interpreter: SimResourceInterpreter,
-    final override val parent: SimResourceSystem?,
+    protected val engine: FlowEngine,
+    final override val parent: FlowSystem?,
     final override val model: MachineModel
-) : SimMachine, SimResourceSystem {
+) : SimMachine, FlowSystem {
     /**
      * The resources allocated for this machine.
      */
@@ -54,17 +54,17 @@ public abstract class SimAbstractMachine(
     /**
      * The memory interface of the machine.
      */
-    public val memory: SimMemory = Memory(SimResourceSource(model.memory.sumOf { it.size }.toDouble(), interpreter), model.memory)
+    public val memory: SimMemory = Memory(FlowSink(engine, model.memory.sumOf { it.size }.toDouble()), model.memory)
 
     /**
      * The network interfaces available to the machine.
      */
-    public val net: List<SimNetworkInterface> = model.net.mapIndexed { i, adapter -> NetworkAdapterImpl(adapter, i) }
+    public val net: List<SimNetworkInterface> = model.net.mapIndexed { i, adapter -> NetworkAdapterImpl(engine, adapter, i) }
 
     /**
      * The network interfaces available to the machine.
      */
-    public val storage: List<SimStorageInterface> = model.storage.mapIndexed { i, device -> StorageDeviceImpl(interpreter, device, i) }
+    public val storage: List<SimStorageInterface> = model.storage.mapIndexed { i, device -> StorageDeviceImpl(engine, device, i) }
 
     /**
      * The peripherals of the machine.
@@ -82,7 +82,7 @@ public abstract class SimAbstractMachine(
     private var cont: Continuation<Unit>? = null
 
     /**
-     * Run the specified [SimWorkload] on this machine and suspend execution util the workload has finished.
+     * Converge the specified [SimWorkload] on this machine and suspend execution util the workload has finished.
      */
     override suspend fun run(workload: SimWorkload, meta: Map<String, Any>) {
         check(!isTerminated) { "Machine is terminated" }
@@ -96,14 +96,14 @@ public abstract class SimAbstractMachine(
             // Cancel all cpus on cancellation
             cont.invokeOnCancellation {
                 this.cont = null
-                interpreter.batch {
+                engine.batch {
                     for (cpu in cpus) {
                         cpu.cancel()
                     }
                 }
             }
 
-            interpreter.batch { workload.onStart(ctx) }
+            engine.batch { workload.onStart(ctx) }
         }
     }
 
@@ -120,7 +120,7 @@ public abstract class SimAbstractMachine(
      * Cancel the workload that is currently running on the machine.
      */
     private fun cancel() {
-        interpreter.batch {
+        engine.batch {
             for (cpu in cpus) {
                 cpu.cancel()
             }
@@ -137,8 +137,8 @@ public abstract class SimAbstractMachine(
      * The execution context in which the workload runs.
      */
     private inner class Context(override val meta: Map<String, Any>) : SimMachineContext {
-        override val interpreter: SimResourceInterpreter
-            get() = this@SimAbstractMachine.interpreter
+        override val engine: FlowEngine
+            get() = this@SimAbstractMachine.engine
 
         override val cpus: List<SimProcessingUnit> = this@SimAbstractMachine.cpus
 
@@ -154,7 +154,7 @@ public abstract class SimAbstractMachine(
     /**
      * The [SimMemory] implementation for a machine.
      */
-    private class Memory(source: SimResourceSource, override val models: List<MemoryUnit>) : SimMemory, SimResourceProvider by source {
+    private class Memory(source: FlowSink, override val models: List<MemoryUnit>) : SimMemory, FlowConsumer by source {
         override fun toString(): String = "SimAbstractMachine.Memory"
     }
 
@@ -162,6 +162,7 @@ public abstract class SimAbstractMachine(
      * The [SimNetworkAdapter] implementation for a machine.
      */
     private class NetworkAdapterImpl(
+        private val engine: FlowEngine,
         model: NetworkAdapter,
         index: Int
     ) : SimNetworkAdapter(), SimNetworkInterface {
@@ -169,18 +170,18 @@ public abstract class SimAbstractMachine(
 
         override val bandwidth: Double = model.bandwidth
 
-        override val provider: SimResourceProvider
+        override val provider: FlowConsumer
             get() = _rx
 
-        override fun createConsumer(): SimResourceConsumer = _tx
+        override fun createConsumer(): FlowSource = _tx
 
-        override val tx: SimResourceProvider
+        override val tx: FlowConsumer
             get() = _tx
-        private val _tx = SimResourceForwarder()
+        private val _tx = FlowForwarder(engine)
 
-        override val rx: SimResourceConsumer
+        override val rx: FlowSource
             get() = _rx
-        private val _rx = SimResourceForwarder()
+        private val _rx = FlowForwarder(engine)
 
         override fun toString(): String = "SimAbstractMachine.NetworkAdapterImpl[name=$name,bandwidth=$bandwidth]"
     }
@@ -189,7 +190,7 @@ public abstract class SimAbstractMachine(
      * The [SimStorageInterface] implementation for a machine.
      */
     private class StorageDeviceImpl(
-        interpreter: SimResourceInterpreter,
+        engine: FlowEngine,
         model: StorageDevice,
         index: Int
     ) : SimStorageInterface {
@@ -197,9 +198,9 @@ public abstract class SimAbstractMachine(
 
         override val capacity: Double = model.capacity
 
-        override val read: SimResourceProvider = SimResourceSource(model.readBandwidth, interpreter)
+        override val read: FlowConsumer = FlowSink(engine, model.readBandwidth)
 
-        override val write: SimResourceProvider = SimResourceSource(model.writeBandwidth, interpreter)
+        override val write: FlowConsumer = FlowSink(engine, model.writeBandwidth)
 
         override fun toString(): String = "SimAbstractMachine.StorageDeviceImpl[name=$name,capacity=$capacity]"
     }
diff --git a/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/SimBareMetalMachine.kt b/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/SimBareMetalMachine.kt
index 639ca450..37cf282b 100644
--- a/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/SimBareMetalMachine.kt
+++ b/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/SimBareMetalMachine.kt
@@ -26,8 +26,8 @@ import org.opendc.simulator.compute.device.SimPsu
 import org.opendc.simulator.compute.model.MachineModel
 import org.opendc.simulator.compute.model.ProcessingUnit
 import org.opendc.simulator.compute.power.PowerDriver
-import org.opendc.simulator.resources.*
-import org.opendc.simulator.resources.SimResourceInterpreter
+import org.opendc.simulator.flow.*
+import org.opendc.simulator.flow.FlowEngine
 
 /**
  * A simulated bare-metal machine that is able to run a single workload.
@@ -35,19 +35,19 @@ import org.opendc.simulator.resources.SimResourceInterpreter
  * A [SimBareMetalMachine] is a stateful object, and you should be careful when operating this object concurrently. For
  * example, the class expects only a single concurrent call to [run].
  *
- * @param interpreter The [SimResourceInterpreter] to drive the simulation.
+ * @param engine The [FlowEngine] to drive the simulation.
  * @param model The machine model to simulate.
  * @param powerDriver The power driver to use.
  * @param psu The power supply of the machine.
  * @param parent The parent simulation system.
  */
 public class SimBareMetalMachine(
-    interpreter: SimResourceInterpreter,
+    engine: FlowEngine,
     model: MachineModel,
     powerDriver: PowerDriver,
     public val psu: SimPsu = SimPsu(500.0, mapOf(1.0 to 1.0)),
-    parent: SimResourceSystem? = null,
-) : SimAbstractMachine(interpreter, parent, model) {
+    parent: FlowSystem? = null,
+) : SimAbstractMachine(engine, parent, model) {
     /**
      * The power draw of the machine onto the PSU.
      */
@@ -58,7 +58,7 @@ public class SimBareMetalMachine(
      * The processing units of the machine.
      */
     override val cpus: List<SimProcessingUnit> = model.cpus.map { cpu ->
-        Cpu(SimResourceSource(cpu.frequency, interpreter, this@SimBareMetalMachine), cpu)
+        Cpu(FlowSink(engine, cpu.frequency, this@SimBareMetalMachine), cpu)
     }
 
     /**
@@ -78,9 +78,9 @@ public class SimBareMetalMachine(
      * A [SimProcessingUnit] of a bare-metal machine.
      */
     private class Cpu(
-        private val source: SimResourceSource,
+        private val source: FlowSink,
         override val model: ProcessingUnit
-    ) : SimProcessingUnit, SimResourceProvider by source {
+    ) : SimProcessingUnit, FlowConsumer by source {
         override var capacity: Double
             get() = source.capacity
             set(value) {
diff --git a/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/SimMachine.kt b/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/SimMachine.kt
index d8dd8205..ab0b56ae 100644
--- a/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/SimMachine.kt
+++ b/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/SimMachine.kt
@@ -41,7 +41,7 @@ public interface SimMachine : AutoCloseable {
     public val peripherals: List<SimPeripheral>
 
     /**
-     * Run the specified [SimWorkload] on this machine and suspend execution util the workload has finished.
+     * Converge the specified [SimWorkload] on this machine and suspend execution util the workload has finished.
      */
     public suspend fun run(workload: SimWorkload, meta: Map<String, Any> = emptyMap())
 
diff --git a/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/SimMachineContext.kt b/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/SimMachineContext.kt
index 6996a30d..1317f728 100644
--- a/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/SimMachineContext.kt
+++ b/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/SimMachineContext.kt
@@ -22,7 +22,7 @@
 
 package org.opendc.simulator.compute
 
-import org.opendc.simulator.resources.SimResourceInterpreter
+import org.opendc.simulator.flow.FlowEngine
 
 /**
  * A simulated execution context in which a bootable image runs. This interface represents the
@@ -31,9 +31,9 @@ import org.opendc.simulator.resources.SimResourceInterpreter
  */
 public interface SimMachineContext : AutoCloseable {
     /**
-     * The resource interpreter that simulates the machine.
+     * The [FlowEngine] that simulates the machine.
      */
-    public val interpreter: SimResourceInterpreter
+    public val engine: FlowEngine
 
     /**
      * The metadata associated with the context.
diff --git a/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/SimMemory.kt b/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/SimMemory.kt
index 6623df23..b1aef495 100644
--- a/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/SimMemory.kt
+++ b/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/SimMemory.kt
@@ -23,12 +23,12 @@
 package org.opendc.simulator.compute
 
 import org.opendc.simulator.compute.model.MemoryUnit
-import org.opendc.simulator.resources.SimResourceProvider
+import org.opendc.simulator.flow.FlowConsumer
 
 /**
  * An interface to control the memory usage of simulated workloads.
  */
-public interface SimMemory : SimResourceProvider {
+public interface SimMemory : FlowConsumer {
     /**
      * The models representing the static information of the memory units supporting this interface.
      */
diff --git a/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/SimNetworkInterface.kt b/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/SimNetworkInterface.kt
index 1ac126ae..660b2871 100644
--- a/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/SimNetworkInterface.kt
+++ b/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/SimNetworkInterface.kt
@@ -22,8 +22,8 @@
 
 package org.opendc.simulator.compute
 
-import org.opendc.simulator.resources.SimResourceConsumer
-import org.opendc.simulator.resources.SimResourceProvider
+import org.opendc.simulator.flow.FlowConsumer
+import org.opendc.simulator.flow.FlowSource
 
 /**
  * A firmware interface to a network adapter.
@@ -42,10 +42,10 @@ public interface SimNetworkInterface {
     /**
      * The resource provider for the transmit channel of the network interface.
      */
-    public val tx: SimResourceProvider
+    public val tx: FlowConsumer
 
     /**
      * The resource consumer for the receive channel of the network interface.
      */
-    public val rx: SimResourceConsumer
+    public val rx: FlowSource
 }
diff --git a/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/SimProcessingUnit.kt b/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/SimProcessingUnit.kt
index 93c9ddfa..c9f36ece 100644
--- a/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/SimProcessingUnit.kt
+++ b/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/SimProcessingUnit.kt
@@ -23,12 +23,12 @@
 package org.opendc.simulator.compute
 
 import org.opendc.simulator.compute.model.ProcessingUnit
-import org.opendc.simulator.resources.SimResourceProvider
+import org.opendc.simulator.flow.FlowConsumer
 
 /**
  * A simulated processing unit.
  */
-public interface SimProcessingUnit : SimResourceProvider {
+public interface SimProcessingUnit : FlowConsumer {
     /**
      * The capacity of the processing unit, which can be adjusted by the workload if supported by the machine.
      */
diff --git a/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/SimStorageInterface.kt b/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/SimStorageInterface.kt
index 21a801f1..3d648671 100644
--- a/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/SimStorageInterface.kt
+++ b/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/SimStorageInterface.kt
@@ -22,7 +22,7 @@
 
 package org.opendc.simulator.compute
 
-import org.opendc.simulator.resources.SimResourceProvider
+import org.opendc.simulator.flow.FlowConsumer
 
 /**
  * A firmware interface to a storage device.
@@ -41,10 +41,10 @@ public interface SimStorageInterface {
     /**
      * The resource provider for the read operations of the storage device.
      */
-    public val read: SimResourceProvider
+    public val read: FlowConsumer
 
     /**
      * The resource consumer for the write operation of the storage device.
      */
-    public val write: SimResourceProvider
+    public val write: FlowConsumer
 }
diff --git a/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/device/SimPsu.kt b/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/device/SimPsu.kt
index 6e6e590f..b05d8ad9 100644
--- a/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/device/SimPsu.kt
+++ b/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/device/SimPsu.kt
@@ -23,10 +23,10 @@
 package org.opendc.simulator.compute.device
 
 import org.opendc.simulator.compute.power.PowerDriver
+import org.opendc.simulator.flow.FlowConnection
+import org.opendc.simulator.flow.FlowEvent
+import org.opendc.simulator.flow.FlowSource
 import org.opendc.simulator.power.SimPowerInlet
-import org.opendc.simulator.resources.SimResourceConsumer
-import org.opendc.simulator.resources.SimResourceContext
-import org.opendc.simulator.resources.SimResourceEvent
 import java.util.*
 
 /**
@@ -54,7 +54,7 @@ public class SimPsu(
     /**
      * The consumer context.
      */
-    private var _ctx: SimResourceContext? = null
+    private var _ctx: FlowConnection? = null
 
     /**
      * The driver that is connected to the PSU.
@@ -69,7 +69,7 @@ public class SimPsu(
      * Update the power draw of the PSU.
      */
     public fun update() {
-        _ctx?.interrupt()
+        _ctx?.pull()
     }
 
     /**
@@ -81,18 +81,18 @@ public class SimPsu(
         update()
     }
 
-    override fun createConsumer(): SimResourceConsumer = object : SimResourceConsumer {
-        override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
+    override fun createConsumer(): FlowSource = object : FlowSource {
+        override fun onPull(conn: FlowConnection, now: Long, delta: Long): Long {
             val powerDraw = computePowerDraw(_driver?.computePower() ?: 0.0)
-            ctx.push(powerDraw)
+            conn.push(powerDraw)
             return Long.MAX_VALUE
         }
 
-        override fun onEvent(ctx: SimResourceContext, event: SimResourceEvent) {
+        override fun onEvent(conn: FlowConnection, now: Long, event: FlowEvent) {
             when (event) {
-                SimResourceEvent.Start -> _ctx = ctx
-                SimResourceEvent.Run -> _powerDraw = ctx.speed
-                SimResourceEvent.Exit -> _ctx = null
+                FlowEvent.Start -> _ctx = conn
+                FlowEvent.Converge -> _powerDraw = conn.rate
+                FlowEvent.Exit -> _ctx = null
                 else -> {}
             }
         }
diff --git a/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/kernel/SimAbstractHypervisor.kt b/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/kernel/SimAbstractHypervisor.kt
index cf9e3230..b145eefc 100644
--- a/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/kernel/SimAbstractHypervisor.kt
+++ b/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/kernel/SimAbstractHypervisor.kt
@@ -28,17 +28,17 @@ import org.opendc.simulator.compute.kernel.cpufreq.ScalingPolicy
 import org.opendc.simulator.compute.kernel.interference.VmInterferenceDomain
 import org.opendc.simulator.compute.model.MachineModel
 import org.opendc.simulator.compute.model.ProcessingUnit
-import org.opendc.simulator.resources.*
-import org.opendc.simulator.resources.SimResourceSwitch
+import org.opendc.simulator.flow.*
+import org.opendc.simulator.flow.mux.FlowMultiplexer
 
 /**
  * Abstract implementation of the [SimHypervisor] interface.
  *
- * @param interpreter The resource interpreter to use.
+ * @param engine The [FlowEngine] to drive the simulation.
  * @param scalingGovernor The scaling governor to use for scaling the CPU frequency of the underlying hardware.
  */
 public abstract class SimAbstractHypervisor(
-    private val interpreter: SimResourceInterpreter,
+    protected val engine: FlowEngine,
     private val scalingGovernor: ScalingGovernor? = null,
     protected val interferenceDomain: VmInterferenceDomain? = null
 ) : SimHypervisor {
@@ -50,7 +50,7 @@ public abstract class SimAbstractHypervisor(
     /**
      * The resource switch to use.
      */
-    private lateinit var switch: SimResourceSwitch
+    private lateinit var mux: FlowMultiplexer
 
     /**
      * The virtual machines running on this hypervisor.
@@ -62,8 +62,8 @@ public abstract class SimAbstractHypervisor(
     /**
      * The resource counters associated with the hypervisor.
      */
-    public override val counters: SimResourceCounters
-        get() = switch.counters
+    public override val counters: FlowCounters
+        get() = mux.counters
 
     /**
      * The scaling governors attached to the physical CPUs backing this hypervisor.
@@ -71,14 +71,14 @@ public abstract class SimAbstractHypervisor(
     private val governors = mutableListOf<ScalingGovernor.Logic>()
 
     /**
-     * Construct the [SimResourceSwitch] implementation that performs the actual scheduling of the CPUs.
+     * Construct the [FlowMultiplexer] implementation that performs the actual scheduling of the CPUs.
      */
-    public abstract fun createSwitch(ctx: SimMachineContext): SimResourceSwitch
+    public abstract fun createMultiplexer(ctx: SimMachineContext): FlowMultiplexer
 
     /**
      * Check whether the specified machine model fits on this hypervisor.
      */
-    public abstract fun canFit(model: MachineModel, switch: SimResourceSwitch): Boolean
+    public abstract fun canFit(model: MachineModel, switch: FlowMultiplexer): Boolean
 
     /**
      * Trigger the governors to recompute the scaling limits.
@@ -91,7 +91,7 @@ public abstract class SimAbstractHypervisor(
 
     /* SimHypervisor */
     override fun canFit(model: MachineModel): Boolean {
-        return canFit(model, switch)
+        return canFit(model, mux)
     }
 
     override fun createMachine(model: MachineModel, interferenceId: String?): SimMachine {
@@ -104,7 +104,7 @@ public abstract class SimAbstractHypervisor(
     /* SimWorkload */
     override fun onStart(ctx: SimMachineContext) {
         context = ctx
-        switch = createSwitch(ctx)
+        mux = createMultiplexer(ctx)
 
         for (cpu in ctx.cpus) {
             val governor = scalingGovernor?.createLogic(ScalingPolicyImpl(cpu))
@@ -113,7 +113,7 @@ public abstract class SimAbstractHypervisor(
                 governor.onStart()
             }
 
-            switch.addInput(cpu)
+            mux.addOutput(cpu)
         }
     }
 
@@ -122,7 +122,7 @@ public abstract class SimAbstractHypervisor(
      *
      * @param model The machine model of the virtual machine.
      */
-    private inner class VirtualMachine(model: MachineModel, interferenceId: String? = null) : SimAbstractMachine(interpreter, parent = null, model) {
+    private inner class VirtualMachine(model: MachineModel, interferenceId: String? = null) : SimAbstractMachine(engine, parent = null, model) {
         /**
          * The interference key of this virtual machine.
          */
@@ -131,7 +131,7 @@ public abstract class SimAbstractHypervisor(
         /**
          * The vCPUs of the machine.
          */
-        override val cpus = model.cpus.map { VCpu(switch, switch.newOutput(interferenceKey), it) }
+        override val cpus = model.cpus.map { VCpu(mux, mux.newInput(interferenceKey), it) }
 
         override fun close() {
             super.close()
@@ -153,10 +153,10 @@ public abstract class SimAbstractHypervisor(
      * A [SimProcessingUnit] of a virtual machine.
      */
     private class VCpu(
-        private val switch: SimResourceSwitch,
-        private val source: SimResourceProvider,
+        private val switch: FlowMultiplexer,
+        private val source: FlowConsumer,
         override val model: ProcessingUnit
-    ) : SimProcessingUnit, SimResourceProvider by source {
+    ) : SimProcessingUnit, FlowConsumer by source {
         override var capacity: Double
             get() = source.capacity
             set(_) {
@@ -169,7 +169,7 @@ public abstract class SimAbstractHypervisor(
          * Close the CPU
          */
         fun close() {
-            switch.removeOutput(source)
+            switch.removeInput(source)
         }
     }
 
diff --git a/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/kernel/SimFairShareHypervisor.kt b/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/kernel/SimFairShareHypervisor.kt
index 3b44292d..36ab7c1c 100644
--- a/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/kernel/SimFairShareHypervisor.kt
+++ b/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/kernel/SimFairShareHypervisor.kt
@@ -28,39 +28,39 @@ import org.opendc.simulator.compute.kernel.cpufreq.ScalingGovernor
 import org.opendc.simulator.compute.kernel.interference.VmInterferenceDomain
 import org.opendc.simulator.compute.model.MachineModel
 import org.opendc.simulator.compute.workload.SimWorkload
-import org.opendc.simulator.resources.SimResourceInterpreter
-import org.opendc.simulator.resources.SimResourceSwitch
-import org.opendc.simulator.resources.SimResourceSwitchMaxMin
-import org.opendc.simulator.resources.SimResourceSystem
+import org.opendc.simulator.flow.FlowEngine
+import org.opendc.simulator.flow.FlowSystem
+import org.opendc.simulator.flow.mux.FlowMultiplexer
+import org.opendc.simulator.flow.mux.MaxMinFlowMultiplexer
 
 /**
  * A [SimHypervisor] that distributes the computing requirements of multiple [SimWorkload]s on a single [SimMachine]
  * concurrently using weighted fair sharing.
  *
- * @param interpreter The interpreter to manage the machine's resources.
+ * @param engine The [FlowEngine] to manage the machine's resources.
  * @param parent The parent simulation system.
  * @param scalingGovernor The CPU frequency scaling governor to use for the hypervisor.
  * @param interferenceDomain The resource interference domain to which the hypervisor belongs.
  * @param listener The hypervisor listener to use.
  */
 public class SimFairShareHypervisor(
-    private val interpreter: SimResourceInterpreter,
-    private val parent: SimResourceSystem? = null,
+    engine: FlowEngine,
+    private val parent: FlowSystem? = null,
     scalingGovernor: ScalingGovernor? = null,
     interferenceDomain: VmInterferenceDomain? = null,
     private val listener: SimHypervisor.Listener? = null
-) : SimAbstractHypervisor(interpreter, scalingGovernor, interferenceDomain) {
+) : SimAbstractHypervisor(engine, scalingGovernor, interferenceDomain) {
 
-    override fun canFit(model: MachineModel, switch: SimResourceSwitch): Boolean = true
+    override fun canFit(model: MachineModel, switch: FlowMultiplexer): Boolean = true
 
-    override fun createSwitch(ctx: SimMachineContext): SimResourceSwitch {
+    override fun createMultiplexer(ctx: SimMachineContext): FlowMultiplexer {
         return SwitchSystem(ctx).switch
     }
 
-    private inner class SwitchSystem(private val ctx: SimMachineContext) : SimResourceSystem {
-        val switch = SimResourceSwitchMaxMin(interpreter, this, interferenceDomain)
+    private inner class SwitchSystem(private val ctx: SimMachineContext) : FlowSystem {
+        val switch = MaxMinFlowMultiplexer(engine, this, interferenceDomain)
 
-        override val parent: SimResourceSystem? = this@SimFairShareHypervisor.parent
+        override val parent: FlowSystem? = this@SimFairShareHypervisor.parent
 
         private var lastCpuUsage = 0.0
         private var lastCpuDemand = 0.0
@@ -87,8 +87,8 @@ public class SimFairShareHypervisor(
             }
             lastReport = timestamp
 
-            lastCpuDemand = switch.inputs.sumOf { it.demand }
-            lastCpuUsage = switch.inputs.sumOf { it.speed }
+            lastCpuDemand = switch.outputs.sumOf { it.demand }
+            lastCpuUsage = switch.outputs.sumOf { it.rate }
             lastDemand = counters.demand
             lastActual = counters.actual
             lastOvercommit = counters.overcommit
diff --git a/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/kernel/SimFairShareHypervisorProvider.kt b/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/kernel/SimFairShareHypervisorProvider.kt
index 8d0592ec..bfa099fb 100644
--- a/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/kernel/SimFairShareHypervisorProvider.kt
+++ b/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/kernel/SimFairShareHypervisorProvider.kt
@@ -24,8 +24,8 @@ package org.opendc.simulator.compute.kernel
 
 import org.opendc.simulator.compute.kernel.cpufreq.ScalingGovernor
 import org.opendc.simulator.compute.kernel.interference.VmInterferenceDomain
-import org.opendc.simulator.resources.SimResourceInterpreter
-import org.opendc.simulator.resources.SimResourceSystem
+import org.opendc.simulator.flow.FlowEngine
+import org.opendc.simulator.flow.FlowSystem
 
 /**
  * A [SimHypervisorProvider] for the [SimFairShareHypervisor] implementation.
@@ -34,13 +34,13 @@ public class SimFairShareHypervisorProvider : SimHypervisorProvider {
     override val id: String = "fair-share"
 
     override fun create(
-        interpreter: SimResourceInterpreter,
-        parent: SimResourceSystem?,
+        engine: FlowEngine,
+        parent: FlowSystem?,
         scalingGovernor: ScalingGovernor?,
         interferenceDomain: VmInterferenceDomain?,
         listener: SimHypervisor.Listener?
     ): SimHypervisor = SimFairShareHypervisor(
-        interpreter,
+        engine,
         parent,
         scalingGovernor = scalingGovernor,
         interferenceDomain = interferenceDomain,
diff --git a/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/kernel/SimHypervisor.kt b/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/kernel/SimHypervisor.kt
index 3b49d515..1b11ca6b 100644
--- a/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/kernel/SimHypervisor.kt
+++ b/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/kernel/SimHypervisor.kt
@@ -25,7 +25,7 @@ package org.opendc.simulator.compute.kernel
 import org.opendc.simulator.compute.SimMachine
 import org.opendc.simulator.compute.model.MachineModel
 import org.opendc.simulator.compute.workload.SimWorkload
-import org.opendc.simulator.resources.SimResourceCounters
+import org.opendc.simulator.flow.FlowCounters
 
 /**
  * A SimHypervisor facilitates the execution of multiple concurrent [SimWorkload]s, while acting as a single workload
@@ -40,7 +40,7 @@ public interface SimHypervisor : SimWorkload {
     /**
      * The resource counters associated with the hypervisor.
      */
-    public val counters: SimResourceCounters
+    public val counters: FlowCounters
 
     /**
      * Determine whether the specified machine characterized by [model] can fit on this hypervisor at this moment.
diff --git a/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/kernel/SimHypervisorProvider.kt b/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/kernel/SimHypervisorProvider.kt
index b307a34d..97f07097 100644
--- a/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/kernel/SimHypervisorProvider.kt
+++ b/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/kernel/SimHypervisorProvider.kt
@@ -24,8 +24,8 @@ package org.opendc.simulator.compute.kernel
 
 import org.opendc.simulator.compute.kernel.cpufreq.ScalingGovernor
 import org.opendc.simulator.compute.kernel.interference.VmInterferenceDomain
-import org.opendc.simulator.resources.SimResourceInterpreter
-import org.opendc.simulator.resources.SimResourceSystem
+import org.opendc.simulator.flow.FlowEngine
+import org.opendc.simulator.flow.FlowSystem
 
 /**
  * A service provider interface for constructing a [SimHypervisor].
@@ -43,8 +43,8 @@ public interface SimHypervisorProvider {
      * Create a [SimHypervisor] instance with the specified [listener].
      */
     public fun create(
-        interpreter: SimResourceInterpreter,
-        parent: SimResourceSystem? = null,
+        engine: FlowEngine,
+        parent: FlowSystem? = null,
         scalingGovernor: ScalingGovernor? = null,
         interferenceDomain: VmInterferenceDomain? = null,
         listener: SimHypervisor.Listener? = null
diff --git a/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/kernel/SimSpaceSharedHypervisor.kt b/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/kernel/SimSpaceSharedHypervisor.kt
index ac1c0250..883e0d82 100644
--- a/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/kernel/SimSpaceSharedHypervisor.kt
+++ b/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/kernel/SimSpaceSharedHypervisor.kt
@@ -24,19 +24,19 @@ package org.opendc.simulator.compute.kernel
 
 import org.opendc.simulator.compute.SimMachineContext
 import org.opendc.simulator.compute.model.MachineModel
-import org.opendc.simulator.resources.SimResourceInterpreter
-import org.opendc.simulator.resources.SimResourceSwitch
-import org.opendc.simulator.resources.SimResourceSwitchExclusive
+import org.opendc.simulator.flow.FlowEngine
+import org.opendc.simulator.flow.mux.FlowMultiplexer
+import org.opendc.simulator.flow.mux.ForwardingFlowMultiplexer
 
 /**
  * A [SimHypervisor] that allocates its sub-resources exclusively for the virtual machine that it hosts.
  */
-public class SimSpaceSharedHypervisor(interpreter: SimResourceInterpreter) : SimAbstractHypervisor(interpreter) {
-    override fun canFit(model: MachineModel, switch: SimResourceSwitch): Boolean {
-        return switch.inputs.size - switch.outputs.size >= model.cpus.size
+public class SimSpaceSharedHypervisor(engine: FlowEngine) : SimAbstractHypervisor(engine) {
+    override fun canFit(model: MachineModel, switch: FlowMultiplexer): Boolean {
+        return switch.outputs.size - switch.inputs.size >= model.cpus.size
     }
 
-    override fun createSwitch(ctx: SimMachineContext): SimResourceSwitch {
-        return SimResourceSwitchExclusive()
+    override fun createMultiplexer(ctx: SimMachineContext): FlowMultiplexer {
+        return ForwardingFlowMultiplexer(engine)
     }
 }
diff --git a/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/kernel/SimSpaceSharedHypervisorProvider.kt b/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/kernel/SimSpaceSharedHypervisorProvider.kt
index 3906cb9a..7869d72d 100644
--- a/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/kernel/SimSpaceSharedHypervisorProvider.kt
+++ b/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/kernel/SimSpaceSharedHypervisorProvider.kt
@@ -24,8 +24,8 @@ package org.opendc.simulator.compute.kernel
 
 import org.opendc.simulator.compute.kernel.cpufreq.ScalingGovernor
 import org.opendc.simulator.compute.kernel.interference.VmInterferenceDomain
-import org.opendc.simulator.resources.SimResourceInterpreter
-import org.opendc.simulator.resources.SimResourceSystem
+import org.opendc.simulator.flow.FlowEngine
+import org.opendc.simulator.flow.FlowSystem
 
 /**
  * A [SimHypervisorProvider] for the [SimSpaceSharedHypervisor] implementation.
@@ -34,10 +34,10 @@ public class SimSpaceSharedHypervisorProvider : SimHypervisorProvider {
     override val id: String = "space-shared"
 
     override fun create(
-        interpreter: SimResourceInterpreter,
-        parent: SimResourceSystem?,
+        engine: FlowEngine,
+        parent: FlowSystem?,
         scalingGovernor: ScalingGovernor?,
         interferenceDomain: VmInterferenceDomain?,
         listener: SimHypervisor.Listener?
-    ): SimHypervisor = SimSpaceSharedHypervisor(interpreter)
+    ): SimHypervisor = SimSpaceSharedHypervisor(engine)
 }
diff --git a/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/kernel/interference/VmInterferenceDomain.kt b/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/kernel/interference/VmInterferenceDomain.kt
index 1801fcd0..b737d61a 100644
--- a/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/kernel/interference/VmInterferenceDomain.kt
+++ b/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/kernel/interference/VmInterferenceDomain.kt
@@ -22,8 +22,8 @@
 
 package org.opendc.simulator.compute.kernel.interference
 
-import org.opendc.simulator.resources.interference.InterferenceDomain
-import org.opendc.simulator.resources.interference.InterferenceKey
+import org.opendc.simulator.flow.interference.InterferenceDomain
+import org.opendc.simulator.flow.interference.InterferenceKey
 
 /**
  * The interference domain of a hypervisor.
diff --git a/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/kernel/interference/VmInterferenceModel.kt b/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/kernel/interference/VmInterferenceModel.kt
index c2e00c8e..b3d72507 100644
--- a/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/kernel/interference/VmInterferenceModel.kt
+++ b/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/kernel/interference/VmInterferenceModel.kt
@@ -22,7 +22,7 @@
 
 package org.opendc.simulator.compute.kernel.interference
 
-import org.opendc.simulator.resources.interference.InterferenceKey
+import org.opendc.simulator.flow.interference.InterferenceKey
 import java.util.*
 
 /**
diff --git a/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/power/PStatePowerDriver.kt b/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/power/PStatePowerDriver.kt
index 6577fbfc..f71446f8 100644
--- a/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/power/PStatePowerDriver.kt
+++ b/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/power/PStatePowerDriver.kt
@@ -46,7 +46,7 @@ public class PStatePowerDriver(states: Map<Double, PowerModel>) : PowerDriver {
 
             for (cpu in cpus) {
                 targetFreq = max(cpu.capacity, targetFreq)
-                totalSpeed += cpu.speed
+                totalSpeed += cpu.rate
             }
 
             val maxFreq = states.lastKey()
diff --git a/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/power/SimplePowerDriver.kt b/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/power/SimplePowerDriver.kt
index bf7aeff1..34e91c35 100644
--- a/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/power/SimplePowerDriver.kt
+++ b/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/power/SimplePowerDriver.kt
@@ -37,7 +37,7 @@ public class SimplePowerDriver(private val model: PowerModel) : PowerDriver {
 
             for (cpu in cpus) {
                 targetFreq += cpu.capacity
-                totalSpeed += cpu.speed
+                totalSpeed += cpu.rate
             }
 
             return model.computePower(totalSpeed / targetFreq)
diff --git a/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/workload/SimFlopsWorkload.kt b/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/workload/SimFlopsWorkload.kt
index a01fa20c..99f4a1e1 100644
--- a/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/workload/SimFlopsWorkload.kt
+++ b/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/workload/SimFlopsWorkload.kt
@@ -23,7 +23,7 @@
 package org.opendc.simulator.compute.workload
 
 import org.opendc.simulator.compute.SimMachineContext
-import org.opendc.simulator.resources.consumer.SimWorkConsumer
+import org.opendc.simulator.flow.source.FixedFlowSource
 
 /**
  * A [SimWorkload] that models applications as a static number of floating point operations ([flops]) executed on
@@ -44,7 +44,7 @@ public class SimFlopsWorkload(
     override fun onStart(ctx: SimMachineContext) {
         val lifecycle = SimWorkloadLifecycle(ctx)
         for (cpu in ctx.cpus) {
-            cpu.startConsumer(lifecycle.waitFor(SimWorkConsumer(flops.toDouble() / ctx.cpus.size, utilization)))
+            cpu.startConsumer(lifecycle.waitFor(FixedFlowSource(flops.toDouble() / ctx.cpus.size, utilization)))
         }
     }
 
diff --git a/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/workload/SimRuntimeWorkload.kt b/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/workload/SimRuntimeWorkload.kt
index 4ee56689..2ef3bc43 100644
--- a/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/workload/SimRuntimeWorkload.kt
+++ b/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/workload/SimRuntimeWorkload.kt
@@ -23,7 +23,7 @@
 package org.opendc.simulator.compute.workload
 
 import org.opendc.simulator.compute.SimMachineContext
-import org.opendc.simulator.resources.consumer.SimWorkConsumer
+import org.opendc.simulator.flow.source.FixedFlowSource
 
 /**
  * A [SimWorkload] that models application execution as a single duration.
@@ -44,7 +44,7 @@ public class SimRuntimeWorkload(
         val lifecycle = SimWorkloadLifecycle(ctx)
         for (cpu in ctx.cpus) {
             val limit = cpu.capacity * utilization
-            cpu.startConsumer(lifecycle.waitFor(SimWorkConsumer((limit / 1000) * duration, utilization)))
+            cpu.startConsumer(lifecycle.waitFor(FixedFlowSource((limit / 1000) * duration, utilization)))
         }
     }
 
diff --git a/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/workload/SimTraceWorkload.kt b/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/workload/SimTraceWorkload.kt
index dd582bb2..a877dac1 100644
--- a/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/workload/SimTraceWorkload.kt
+++ b/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/workload/SimTraceWorkload.kt
@@ -24,8 +24,8 @@ package org.opendc.simulator.compute.workload
 
 import org.opendc.simulator.compute.SimMachineContext
 import org.opendc.simulator.compute.model.ProcessingUnit
-import org.opendc.simulator.resources.SimResourceConsumer
-import org.opendc.simulator.resources.SimResourceContext
+import org.opendc.simulator.flow.FlowConnection
+import org.opendc.simulator.flow.FlowSource
 import kotlin.math.min
 
 /**
@@ -78,12 +78,12 @@ public class SimTraceWorkload(public val trace: Sequence<Fragment>, private val
         return now >= timestamp + duration
     }
 
-    private inner class Consumer(val cpu: ProcessingUnit) : SimResourceConsumer {
-        override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
+    private inner class Consumer(val cpu: ProcessingUnit) : FlowSource {
+        override fun onPull(conn: FlowConnection, now: Long, delta: Long): Long {
             val fragment = pullFragment(now)
 
             if (fragment == null) {
-                ctx.close()
+                conn.close()
                 return Long.MAX_VALUE
             }
 
@@ -91,7 +91,7 @@ public class SimTraceWorkload(public val trace: Sequence<Fragment>, private val
 
             // Fragment is in the future
             if (timestamp > now) {
-                ctx.push(0.0)
+                conn.push(0.0)
                 return timestamp - now
             }
 
@@ -103,7 +103,7 @@ public class SimTraceWorkload(public val trace: Sequence<Fragment>, private val
             val deadline = timestamp + fragment.duration
             val duration = deadline - now
 
-            ctx.push(if (cpu.id < cores && usage > 0.0) usage else 0.0)
+            conn.push(if (cpu.id < cores && usage > 0.0) usage else 0.0)
 
             return duration
         }
diff --git a/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/workload/SimWorkloadLifecycle.kt b/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/workload/SimWorkloadLifecycle.kt
index 5dd18271..dabe60e0 100644
--- a/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/workload/SimWorkloadLifecycle.kt
+++ b/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/workload/SimWorkloadLifecycle.kt
@@ -23,9 +23,9 @@
 package org.opendc.simulator.compute.workload
 
 import org.opendc.simulator.compute.SimMachineContext
-import org.opendc.simulator.resources.SimResourceConsumer
-import org.opendc.simulator.resources.SimResourceContext
-import org.opendc.simulator.resources.SimResourceEvent
+import org.opendc.simulator.flow.FlowConnection
+import org.opendc.simulator.flow.FlowEvent
+import org.opendc.simulator.flow.FlowSource
 
 /**
  * A helper class to manage the lifecycle of a [SimWorkload]
@@ -34,27 +34,27 @@ public class SimWorkloadLifecycle(private val ctx: SimMachineContext) {
     /**
      * The resource consumers which represent the lifecycle of the workload.
      */
-    private val waiting = mutableSetOf<SimResourceConsumer>()
+    private val waiting = mutableSetOf<FlowSource>()
 
     /**
      * Wait for the specified [consumer] to complete before ending the lifecycle of the workload.
      */
-    public fun waitFor(consumer: SimResourceConsumer): SimResourceConsumer {
+    public fun waitFor(consumer: FlowSource): FlowSource {
         waiting.add(consumer)
-        return object : SimResourceConsumer by consumer {
-            override fun onEvent(ctx: SimResourceContext, event: SimResourceEvent) {
+        return object : FlowSource by consumer {
+            override fun onEvent(conn: FlowConnection, now: Long, event: FlowEvent) {
                 try {
-                    consumer.onEvent(ctx, event)
+                    consumer.onEvent(conn, now, event)
                 } finally {
-                    if (event == SimResourceEvent.Exit) {
+                    if (event == FlowEvent.Exit) {
                         complete(consumer)
                     }
                 }
             }
 
-            override fun onFailure(ctx: SimResourceContext, cause: Throwable) {
+            override fun onFailure(conn: FlowConnection, cause: Throwable) {
                 try {
-                    consumer.onFailure(ctx, cause)
+                    consumer.onFailure(conn, cause)
                 } finally {
                     complete(consumer)
                 }
@@ -65,9 +65,9 @@ public class SimWorkloadLifecycle(private val ctx: SimMachineContext) {
     }
 
     /**
-     * Complete the specified [SimResourceConsumer].
+     * Complete the specified [FlowSource].
      */
-    private fun complete(consumer: SimResourceConsumer) {
+    private fun complete(consumer: FlowSource) {
         if (waiting.remove(consumer) && waiting.isEmpty()) {
             ctx.close()
         }
diff --git a/opendc-simulator/opendc-simulator-compute/src/test/kotlin/org/opendc/simulator/compute/SimMachineTest.kt b/opendc-simulator/opendc-simulator-compute/src/test/kotlin/org/opendc/simulator/compute/SimMachineTest.kt
index 81268879..0bb24ed8 100644
--- a/opendc-simulator/opendc-simulator-compute/src/test/kotlin/org/opendc/simulator/compute/SimMachineTest.kt
+++ b/opendc-simulator/opendc-simulator-compute/src/test/kotlin/org/opendc/simulator/compute/SimMachineTest.kt
@@ -34,10 +34,10 @@ import org.opendc.simulator.compute.workload.SimFlopsWorkload
 import org.opendc.simulator.compute.workload.SimWorkload
 import org.opendc.simulator.compute.workload.SimWorkloadLifecycle
 import org.opendc.simulator.core.runBlockingSimulation
+import org.opendc.simulator.flow.FlowEngine
+import org.opendc.simulator.flow.source.FixedFlowSource
 import org.opendc.simulator.network.SimNetworkSink
 import org.opendc.simulator.power.SimPowerSource
-import org.opendc.simulator.resources.SimResourceInterpreter
-import org.opendc.simulator.resources.consumer.SimWorkConsumer
 
 /**
  * Test suite for the [SimBareMetalMachine] class.
@@ -60,7 +60,7 @@ class SimMachineTest {
     @Test
     fun testFlopsWorkload() = runBlockingSimulation {
         val machine = SimBareMetalMachine(
-            SimResourceInterpreter(coroutineContext, clock),
+            FlowEngine(coroutineContext, clock),
             machineModel,
             SimplePowerDriver(ConstantPowerModel(0.0))
         )
@@ -83,7 +83,7 @@ class SimMachineTest {
             memory = List(4) { MemoryUnit("Crucial", "MTA18ASF4G72AZ-3G2B1", 3200.0, 32_000) }
         )
         val machine = SimBareMetalMachine(
-            SimResourceInterpreter(coroutineContext, clock),
+            FlowEngine(coroutineContext, clock),
             machineModel,
             SimplePowerDriver(ConstantPowerModel(0.0))
         )
@@ -100,13 +100,13 @@ class SimMachineTest {
 
     @Test
     fun testPower() = runBlockingSimulation {
-        val interpreter = SimResourceInterpreter(coroutineContext, clock)
+        val engine = FlowEngine(coroutineContext, clock)
         val machine = SimBareMetalMachine(
-            interpreter,
+            engine,
             machineModel,
             SimplePowerDriver(LinearPowerModel(100.0, 50.0))
         )
-        val source = SimPowerSource(interpreter, capacity = 1000.0)
+        val source = SimPowerSource(engine, capacity = 1000.0)
         source.connect(machine.psu)
 
         try {
@@ -125,7 +125,7 @@ class SimMachineTest {
     @Test
     fun testCapacityClamp() = runBlockingSimulation {
         val machine = SimBareMetalMachine(
-            SimResourceInterpreter(coroutineContext, clock),
+            FlowEngine(coroutineContext, clock),
             machineModel,
             SimplePowerDriver(ConstantPowerModel(0.0))
         )
@@ -151,7 +151,7 @@ class SimMachineTest {
     @Test
     fun testMemory() = runBlockingSimulation {
         val machine = SimBareMetalMachine(
-            SimResourceInterpreter(coroutineContext, clock),
+            FlowEngine(coroutineContext, clock),
             machineModel,
             SimplePowerDriver(ConstantPowerModel(0.0))
         )
@@ -171,7 +171,7 @@ class SimMachineTest {
     @Test
     fun testMemoryUsage() = runBlockingSimulation {
         val machine = SimBareMetalMachine(
-            SimResourceInterpreter(coroutineContext, clock),
+            FlowEngine(coroutineContext, clock),
             machineModel,
             SimplePowerDriver(ConstantPowerModel(0.0))
         )
@@ -180,7 +180,7 @@ class SimMachineTest {
             machine.run(object : SimWorkload {
                 override fun onStart(ctx: SimMachineContext) {
                     val lifecycle = SimWorkloadLifecycle(ctx)
-                    ctx.memory.startConsumer(lifecycle.waitFor(SimWorkConsumer(ctx.memory.capacity, utilization = 0.8)))
+                    ctx.memory.startConsumer(lifecycle.waitFor(FixedFlowSource(ctx.memory.capacity, utilization = 0.8)))
                 }
             })
 
@@ -192,22 +192,22 @@ class SimMachineTest {
 
     @Test
     fun testNetUsage() = runBlockingSimulation {
-        val interpreter = SimResourceInterpreter(coroutineContext, clock)
+        val engine = FlowEngine(coroutineContext, clock)
         val machine = SimBareMetalMachine(
-            interpreter,
+            engine,
             machineModel,
             SimplePowerDriver(ConstantPowerModel(0.0))
         )
 
         val adapter = (machine.peripherals[0] as SimNetworkAdapter)
-        adapter.connect(SimNetworkSink(interpreter, adapter.bandwidth))
+        adapter.connect(SimNetworkSink(engine, adapter.bandwidth))
 
         try {
             machine.run(object : SimWorkload {
                 override fun onStart(ctx: SimMachineContext) {
                     val lifecycle = SimWorkloadLifecycle(ctx)
                     val iface = ctx.net[0]
-                    iface.tx.startConsumer(lifecycle.waitFor(SimWorkConsumer(iface.bandwidth, utilization = 0.8)))
+                    iface.tx.startConsumer(lifecycle.waitFor(FixedFlowSource(iface.bandwidth, utilization = 0.8)))
                 }
             })
 
@@ -219,9 +219,9 @@ class SimMachineTest {
 
     @Test
     fun testDiskReadUsage() = runBlockingSimulation {
-        val interpreter = SimResourceInterpreter(coroutineContext, clock)
+        val engine = FlowEngine(coroutineContext, clock)
         val machine = SimBareMetalMachine(
-            interpreter,
+            engine,
             machineModel,
             SimplePowerDriver(ConstantPowerModel(0.0))
         )
@@ -231,7 +231,7 @@ class SimMachineTest {
                 override fun onStart(ctx: SimMachineContext) {
                     val lifecycle = SimWorkloadLifecycle(ctx)
                     val disk = ctx.storage[0]
-                    disk.read.startConsumer(lifecycle.waitFor(SimWorkConsumer(disk.read.capacity, utilization = 0.8)))
+                    disk.read.startConsumer(lifecycle.waitFor(FixedFlowSource(disk.read.capacity, utilization = 0.8)))
                 }
             })
 
@@ -243,9 +243,9 @@ class SimMachineTest {
 
     @Test
     fun testDiskWriteUsage() = runBlockingSimulation {
-        val interpreter = SimResourceInterpreter(coroutineContext, clock)
+        val engine = FlowEngine(coroutineContext, clock)
         val machine = SimBareMetalMachine(
-            interpreter,
+            engine,
             machineModel,
             SimplePowerDriver(ConstantPowerModel(0.0))
         )
@@ -255,7 +255,7 @@ class SimMachineTest {
                 override fun onStart(ctx: SimMachineContext) {
                     val lifecycle = SimWorkloadLifecycle(ctx)
                     val disk = ctx.storage[0]
-                    disk.write.startConsumer(lifecycle.waitFor(SimWorkConsumer(disk.write.capacity, utilization = 0.8)))
+                    disk.write.startConsumer(lifecycle.waitFor(FixedFlowSource(disk.write.capacity, utilization = 0.8)))
                 }
             })
 
@@ -268,7 +268,7 @@ class SimMachineTest {
     @Test
     fun testCancellation() = runBlockingSimulation {
         val machine = SimBareMetalMachine(
-            SimResourceInterpreter(coroutineContext, clock),
+            FlowEngine(coroutineContext, clock),
             machineModel,
             SimplePowerDriver(ConstantPowerModel(0.0))
         )
@@ -290,7 +290,7 @@ class SimMachineTest {
     @Test
     fun testConcurrentRuns() = runBlockingSimulation {
         val machine = SimBareMetalMachine(
-            SimResourceInterpreter(coroutineContext, clock),
+            FlowEngine(coroutineContext, clock),
             machineModel,
             SimplePowerDriver(ConstantPowerModel(0.0))
         )
@@ -313,7 +313,7 @@ class SimMachineTest {
     @Test
     fun testClose() = runBlockingSimulation {
         val machine = SimBareMetalMachine(
-            SimResourceInterpreter(coroutineContext, clock),
+            FlowEngine(coroutineContext, clock),
             machineModel,
             SimplePowerDriver(ConstantPowerModel(0.0))
         )
diff --git a/opendc-simulator/opendc-simulator-compute/src/test/kotlin/org/opendc/simulator/compute/device/SimPsuTest.kt b/opendc-simulator/opendc-simulator-compute/src/test/kotlin/org/opendc/simulator/compute/device/SimPsuTest.kt
index 6c9ec7bd..e5b509f0 100644
--- a/opendc-simulator/opendc-simulator-compute/src/test/kotlin/org/opendc/simulator/compute/device/SimPsuTest.kt
+++ b/opendc-simulator/opendc-simulator-compute/src/test/kotlin/org/opendc/simulator/compute/device/SimPsuTest.kt
@@ -29,8 +29,8 @@ import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.assertThrows
 import org.opendc.simulator.compute.power.PowerDriver
 import org.opendc.simulator.core.runBlockingSimulation
+import org.opendc.simulator.flow.FlowEngine
 import org.opendc.simulator.power.SimPowerSource
-import org.opendc.simulator.resources.SimResourceInterpreter
 
 /**
  * Test suite for [SimPsu]
@@ -55,8 +55,8 @@ internal class SimPsuTest {
         val ratedOutputPower = 240.0
         val energyEfficiency = mapOf(0.0 to 1.0)
 
-        val interpreter = SimResourceInterpreter(coroutineContext, clock)
-        val source = SimPowerSource(interpreter, capacity = ratedOutputPower)
+        val engine = FlowEngine(coroutineContext, clock)
+        val source = SimPowerSource(engine, capacity = ratedOutputPower)
 
         val cpuLogic = mockk<PowerDriver.Logic>()
         every { cpuLogic.computePower() } returns 0.0
@@ -78,8 +78,8 @@ internal class SimPsuTest {
             1.0 to 0.94,
         )
 
-        val interpreter = SimResourceInterpreter(coroutineContext, clock)
-        val source = SimPowerSource(interpreter, capacity = ratedOutputPower)
+        val engine = FlowEngine(coroutineContext, clock)
+        val source = SimPowerSource(engine, capacity = ratedOutputPower)
 
         val cpuLogic = mockk<PowerDriver.Logic>()
         every { cpuLogic.computePower() } returnsMany listOf(50.0, 100.0, 150.0, 200.0)
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/SimHypervisorTest.kt
index 8cd535ad..058d5d28 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/SimHypervisorTest.kt
@@ -40,7 +40,7 @@ import org.opendc.simulator.compute.power.ConstantPowerModel
 import org.opendc.simulator.compute.power.SimplePowerDriver
 import org.opendc.simulator.compute.workload.SimTraceWorkload
 import org.opendc.simulator.core.runBlockingSimulation
-import org.opendc.simulator.resources.SimResourceInterpreter
+import org.opendc.simulator.flow.FlowEngine
 
 /**
  * Test suite for the [SimHypervisor] class.
@@ -94,7 +94,7 @@ internal class SimHypervisorTest {
                 ),
             )
 
-        val platform = SimResourceInterpreter(coroutineContext, clock)
+        val platform = FlowEngine(coroutineContext, clock)
         val machine = SimBareMetalMachine(platform, model, SimplePowerDriver(ConstantPowerModel(0.0)))
         val hypervisor = SimFairShareHypervisor(platform, scalingGovernor = PerformanceScalingGovernor(), listener = listener)
 
@@ -163,7 +163,7 @@ internal class SimHypervisorTest {
                 )
             )
 
-        val platform = SimResourceInterpreter(coroutineContext, clock)
+        val platform = FlowEngine(coroutineContext, clock)
         val machine = SimBareMetalMachine(
             platform, model, SimplePowerDriver(ConstantPowerModel(0.0))
         )
@@ -204,7 +204,7 @@ internal class SimHypervisorTest {
             memory = List(4) { MemoryUnit("Crucial", "MTA18ASF4G72AZ-3G2B1", 3200.0, 32_000) }
         )
 
-        val platform = SimResourceInterpreter(coroutineContext, clock)
+        val platform = FlowEngine(coroutineContext, clock)
         val machine = SimBareMetalMachine(
             platform, model, SimplePowerDriver(ConstantPowerModel(0.0))
         )
@@ -234,7 +234,7 @@ internal class SimHypervisorTest {
         )
         val interferenceModel = VmInterferenceModel(groups)
 
-        val platform = SimResourceInterpreter(coroutineContext, clock)
+        val platform = FlowEngine(coroutineContext, clock)
         val machine = SimBareMetalMachine(
             platform, model, SimplePowerDriver(ConstantPowerModel(0.0))
         )
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 55d6d7c4..95fb6679 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
@@ -40,7 +40,7 @@ import org.opendc.simulator.compute.workload.SimFlopsWorkload
 import org.opendc.simulator.compute.workload.SimRuntimeWorkload
 import org.opendc.simulator.compute.workload.SimTraceWorkload
 import org.opendc.simulator.core.runBlockingSimulation
-import org.opendc.simulator.resources.SimResourceInterpreter
+import org.opendc.simulator.flow.FlowEngine
 
 /**
  * A test suite for the [SimSpaceSharedHypervisor].
@@ -74,11 +74,11 @@ internal class SimSpaceSharedHypervisorTest {
                 ),
             )
 
-        val interpreter = SimResourceInterpreter(coroutineContext, clock)
+        val engine = FlowEngine(coroutineContext, clock)
         val machine = SimBareMetalMachine(
-            SimResourceInterpreter(coroutineContext, clock), machineModel, SimplePowerDriver(ConstantPowerModel(0.0))
+            FlowEngine(coroutineContext, clock), machineModel, SimplePowerDriver(ConstantPowerModel(0.0))
         )
-        val hypervisor = SimSpaceSharedHypervisor(interpreter)
+        val hypervisor = SimSpaceSharedHypervisor(engine)
 
         launch { machine.run(hypervisor) }
         val vm = hypervisor.createMachine(machineModel)
@@ -98,11 +98,11 @@ internal class SimSpaceSharedHypervisorTest {
     fun testRuntimeWorkload() = runBlockingSimulation {
         val duration = 5 * 60L * 1000
         val workload = SimRuntimeWorkload(duration)
-        val interpreter = SimResourceInterpreter(coroutineContext, clock)
+        val engine = FlowEngine(coroutineContext, clock)
         val machine = SimBareMetalMachine(
-            interpreter, machineModel, SimplePowerDriver(ConstantPowerModel(0.0))
+            engine, machineModel, SimplePowerDriver(ConstantPowerModel(0.0))
         )
-        val hypervisor = SimSpaceSharedHypervisor(interpreter)
+        val hypervisor = SimSpaceSharedHypervisor(engine)
 
         launch { machine.run(hypervisor) }
         yield()
@@ -121,11 +121,11 @@ internal class SimSpaceSharedHypervisorTest {
     fun testFlopsWorkload() = runBlockingSimulation {
         val duration = 5 * 60L * 1000
         val workload = SimFlopsWorkload((duration * 3.2).toLong(), 1.0)
-        val interpreter = SimResourceInterpreter(coroutineContext, clock)
+        val engine = FlowEngine(coroutineContext, clock)
         val machine = SimBareMetalMachine(
-            interpreter, machineModel, SimplePowerDriver(ConstantPowerModel(0.0))
+            engine, machineModel, SimplePowerDriver(ConstantPowerModel(0.0))
         )
-        val hypervisor = SimSpaceSharedHypervisor(interpreter)
+        val hypervisor = SimSpaceSharedHypervisor(engine)
 
         launch { machine.run(hypervisor) }
         yield()
@@ -142,11 +142,11 @@ internal class SimSpaceSharedHypervisorTest {
     @Test
     fun testTwoWorkloads() = runBlockingSimulation {
         val duration = 5 * 60L * 1000
-        val interpreter = SimResourceInterpreter(coroutineContext, clock)
+        val engine = FlowEngine(coroutineContext, clock)
         val machine = SimBareMetalMachine(
-            interpreter, machineModel, SimplePowerDriver(ConstantPowerModel(0.0))
+            engine, machineModel, SimplePowerDriver(ConstantPowerModel(0.0))
         )
-        val hypervisor = SimSpaceSharedHypervisor(interpreter)
+        val hypervisor = SimSpaceSharedHypervisor(engine)
 
         launch { machine.run(hypervisor) }
         yield()
@@ -170,11 +170,9 @@ internal class SimSpaceSharedHypervisorTest {
      */
     @Test
     fun testConcurrentWorkloadFails() = runBlockingSimulation {
-        val interpreter = SimResourceInterpreter(coroutineContext, clock)
-        val machine = SimBareMetalMachine(
-            interpreter, machineModel, SimplePowerDriver(ConstantPowerModel(0.0))
-        )
-        val hypervisor = SimSpaceSharedHypervisor(interpreter)
+        val engine = FlowEngine(coroutineContext, clock)
+        val machine = SimBareMetalMachine(engine, machineModel, SimplePowerDriver(ConstantPowerModel(0.0)))
+        val hypervisor = SimSpaceSharedHypervisor(engine)
 
         launch { machine.run(hypervisor) }
         yield()
@@ -194,7 +192,7 @@ internal class SimSpaceSharedHypervisorTest {
      */
     @Test
     fun testConcurrentWorkloadSucceeds() = runBlockingSimulation {
-        val interpreter = SimResourceInterpreter(coroutineContext, clock)
+        val interpreter = FlowEngine(coroutineContext, clock)
         val machine = SimBareMetalMachine(
             interpreter, machineModel, SimplePowerDriver(ConstantPowerModel(0.0))
         )
diff --git a/opendc-simulator/opendc-simulator-compute/src/test/kotlin/org/opendc/simulator/compute/power/PStatePowerDriverTest.kt b/opendc-simulator/opendc-simulator-compute/src/test/kotlin/org/opendc/simulator/compute/power/PStatePowerDriverTest.kt
index c39859bf..f557c8d3 100644
--- a/opendc-simulator/opendc-simulator-compute/src/test/kotlin/org/opendc/simulator/compute/power/PStatePowerDriverTest.kt
+++ b/opendc-simulator/opendc-simulator-compute/src/test/kotlin/org/opendc/simulator/compute/power/PStatePowerDriverTest.kt
@@ -55,7 +55,7 @@ internal class PStatePowerDriverTest {
         val cpu = mockk<SimProcessingUnit>(relaxUnitFun = true)
 
         every { cpu.capacity } returns 3200.0
-        every { cpu.speed } returns 1200.0
+        every { cpu.rate } returns 1200.0
 
         val driver = PStatePowerDriver(
             sortedMapOf(
@@ -77,10 +77,10 @@ internal class PStatePowerDriverTest {
         val cpus = listOf(cpu, cpu)
 
         every { cpus[0].capacity } returns 1000.0
-        every { cpus[0].speed } returns 1200.0
+        every { cpus[0].rate } returns 1200.0
 
         every { cpus[1].capacity } returns 3500.0
-        every { cpus[1].speed } returns 1200.0
+        every { cpus[1].rate } returns 1200.0
 
         val driver = PStatePowerDriver(
             sortedMapOf(
@@ -112,11 +112,11 @@ internal class PStatePowerDriverTest {
 
         val logic = driver.createLogic(machine, listOf(cpu))
 
-        every { cpu.speed } returns 1400.0
+        every { cpu.rate } returns 1400.0
         every { cpu.capacity } returns 1400.0
         assertEquals(150.0, logic.computePower())
 
-        every { cpu.speed } returns 1400.0
+        every { cpu.rate } returns 1400.0
         every { cpu.capacity } returns 4000.0
         assertEquals(235.0, logic.computePower())
     }
diff --git a/opendc-simulator/opendc-simulator-compute/src/test/kotlin/org/opendc/simulator/compute/workload/SimTraceWorkloadTest.kt b/opendc-simulator/opendc-simulator-compute/src/test/kotlin/org/opendc/simulator/compute/workload/SimTraceWorkloadTest.kt
index 78019c2e..cdbffe4b 100644
--- a/opendc-simulator/opendc-simulator-compute/src/test/kotlin/org/opendc/simulator/compute/workload/SimTraceWorkloadTest.kt
+++ b/opendc-simulator/opendc-simulator-compute/src/test/kotlin/org/opendc/simulator/compute/workload/SimTraceWorkloadTest.kt
@@ -31,7 +31,7 @@ import org.opendc.simulator.compute.model.*
 import org.opendc.simulator.compute.power.ConstantPowerModel
 import org.opendc.simulator.compute.power.SimplePowerDriver
 import org.opendc.simulator.core.runBlockingSimulation
-import org.opendc.simulator.resources.SimResourceInterpreter
+import org.opendc.simulator.flow.FlowEngine
 
 /**
  * Test suite for the [SimTraceWorkloadTest] class.
@@ -52,7 +52,7 @@ class SimTraceWorkloadTest {
     @Test
     fun testSmoke() = runBlockingSimulation {
         val machine = SimBareMetalMachine(
-            SimResourceInterpreter(coroutineContext, clock),
+            FlowEngine(coroutineContext, clock),
             machineModel,
             SimplePowerDriver(ConstantPowerModel(0.0))
         )
@@ -79,7 +79,7 @@ class SimTraceWorkloadTest {
     @Test
     fun testOffset() = runBlockingSimulation {
         val machine = SimBareMetalMachine(
-            SimResourceInterpreter(coroutineContext, clock),
+            FlowEngine(coroutineContext, clock),
             machineModel,
             SimplePowerDriver(ConstantPowerModel(0.0))
         )
@@ -106,7 +106,7 @@ class SimTraceWorkloadTest {
     @Test
     fun testSkipFragment() = runBlockingSimulation {
         val machine = SimBareMetalMachine(
-            SimResourceInterpreter(coroutineContext, clock),
+            FlowEngine(coroutineContext, clock),
             machineModel,
             SimplePowerDriver(ConstantPowerModel(0.0))
         )
@@ -134,7 +134,7 @@ class SimTraceWorkloadTest {
     @Test
     fun testZeroCores() = runBlockingSimulation {
         val machine = SimBareMetalMachine(
-            SimResourceInterpreter(coroutineContext, clock),
+            FlowEngine(coroutineContext, clock),
             machineModel,
             SimplePowerDriver(ConstantPowerModel(0.0))
         )