From 83e6c19681a5cae4b80773f95a66b6753b0bcd7e Mon Sep 17 00:00:00 2001
From: Fabian Mastenbroek <mail.fabianm@gmail.com>
Date: Thu, 30 Sep 2021 10:28:46 +0200
Subject: build: Migrate from kotlinx-benchmark to jmh-gradle

This change updates the project to use jmh-gradle for benchmarking as
opposed to kotlinx-benchmark. Both plugins use JMH under the hood, but
jmh-gradle offers more options for profiling and seems to be beter
maintained.
---
 opendc-simulator/opendc-simulator-resources/build.gradle.kts | 1 -
 1 file changed, 1 deletion(-)

(limited to 'opendc-simulator/opendc-simulator-resources')

diff --git a/opendc-simulator/opendc-simulator-resources/build.gradle.kts b/opendc-simulator/opendc-simulator-resources/build.gradle.kts
index e4ffc3ff..68047d5c 100644
--- a/opendc-simulator/opendc-simulator-resources/build.gradle.kts
+++ b/opendc-simulator/opendc-simulator-resources/build.gradle.kts
@@ -34,6 +34,5 @@ dependencies {
     api(libs.kotlinx.coroutines)
     implementation(projects.opendcUtils)
 
-    jmhImplementation(projects.opendcSimulator.opendcSimulatorCore)
     testImplementation(projects.opendcSimulator.opendcSimulatorCore)
 }
-- 
cgit v1.2.3


From 0ffd93933228e87a205c9839d1bf04cd0e178e8c Mon Sep 17 00:00:00 2001
From: Fabian Mastenbroek <mail.fabianm@gmail.com>
Date: Thu, 30 Sep 2021 12:14:42 +0200
Subject: test(simulator): Use longer traces for benchmarks

This change updates the JMH benchmarks to use longer traces in order to
measure the overhead of running the flow simulation as opposed to
setting up the benchmark.
---
 .../opendc/simulator/resources/SimResourceBenchmarks.kt    | 14 ++++----------
 1 file changed, 4 insertions(+), 10 deletions(-)

(limited to 'opendc-simulator/opendc-simulator-resources')

diff --git a/opendc-simulator/opendc-simulator-resources/src/jmh/kotlin/org/opendc/simulator/resources/SimResourceBenchmarks.kt b/opendc-simulator/opendc-simulator-resources/src/jmh/kotlin/org/opendc/simulator/resources/SimResourceBenchmarks.kt
index b45b2a2f..fbc3f319 100644
--- a/opendc-simulator/opendc-simulator-resources/src/jmh/kotlin/org/opendc/simulator/resources/SimResourceBenchmarks.kt
+++ b/opendc-simulator/opendc-simulator-resources/src/jmh/kotlin/org/opendc/simulator/resources/SimResourceBenchmarks.kt
@@ -28,6 +28,7 @@ import org.opendc.simulator.core.SimulationCoroutineScope
 import org.opendc.simulator.core.runBlockingSimulation
 import org.opendc.simulator.resources.consumer.SimTraceConsumer
 import org.openjdk.jmh.annotations.*
+import java.util.concurrent.ThreadLocalRandom
 import java.util.concurrent.TimeUnit
 
 @State(Scope.Thread)
@@ -51,16 +52,9 @@ class SimResourceBenchmarks {
 
         @Setup
         fun setUp() {
-            trace = sequenceOf(
-                SimTraceConsumer.Fragment(1000, 28.0),
-                SimTraceConsumer.Fragment(1000, 3500.0),
-                SimTraceConsumer.Fragment(1000, 0.0),
-                SimTraceConsumer.Fragment(1000, 183.0),
-                SimTraceConsumer.Fragment(1000, 400.0),
-                SimTraceConsumer.Fragment(1000, 100.0),
-                SimTraceConsumer.Fragment(1000, 3000.0),
-                SimTraceConsumer.Fragment(1000, 4500.0),
-            )
+            val random = ThreadLocalRandom.current()
+            val entries = List(10000) { SimTraceConsumer.Fragment(1000, random.nextDouble(0.0, 4500.0)) }
+            trace = entries.asSequence()
         }
     }
 
-- 
cgit v1.2.3


From a4a611c45dfd5f9e379434f1dc459128cb437338 Mon Sep 17 00:00:00 2001
From: Fabian Mastenbroek <mail.fabianm@gmail.com>
Date: Thu, 23 Sep 2021 14:45:56 +0200
Subject: perf(simulator): Use direct field access for perf-sensitive code

This change updates the SimResourceDistributorMaxMin implementation to
use direct field accesses in the perf-sensitive code.
---
 .../resources/SimResourceDistributorMaxMin.kt      | 22 ++++++++++++----------
 1 file changed, 12 insertions(+), 10 deletions(-)

(limited to 'opendc-simulator/opendc-simulator-resources')

diff --git a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceDistributorMaxMin.kt b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceDistributorMaxMin.kt
index 6c1e134b..63cfbdac 100644
--- a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceDistributorMaxMin.kt
+++ b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceDistributorMaxMin.kt
@@ -162,6 +162,8 @@ public class SimResourceDistributorMaxMin(
             return SimResourceCommand.Idle()
         }
 
+        val now = interpreter.clock.millis()
+
         val capacity = ctx.capacity
         var duration: Double = Double.MAX_VALUE
         var deadline: Long = Long.MAX_VALUE
@@ -171,7 +173,7 @@ public class SimResourceDistributorMaxMin(
         // Pull in the work of the outputs
         val outputIterator = activeOutputs.listIterator()
         for (output in outputIterator) {
-            output.pull()
+            output.pull(now)
 
             // Remove outputs that have finished
             if (!output.isActive) {
@@ -206,7 +208,7 @@ public class SimResourceDistributorMaxMin(
             duration = min(duration, output.work / grantedSpeed)
         }
 
-        val targetDuration = min(duration, (deadline - interpreter.clock.millis()) / 1000.0)
+        val targetDuration = min(duration, (deadline - now) / 1000.0)
         var totalRequestedWork = 0.0
         var totalAllocatedWork = 0.0
         for (output in activeOutputs) {
@@ -219,7 +221,7 @@ public class SimResourceDistributorMaxMin(
             }
         }
 
-        assert(deadline >= interpreter.clock.millis()) { "Deadline already passed" }
+        assert(deadline >= now) { "Deadline already passed" }
 
         this.totalRequestedSpeed = totalRequestedSpeed
         this.totalAllocatedWork = totalAllocatedWork
@@ -254,27 +256,27 @@ public class SimResourceDistributorMaxMin(
         /**
          * The current requested work.
          */
-        var work: Double = 0.0
+        @JvmField var work: Double = 0.0
 
         /**
          * The requested limit.
          */
-        var limit: Double = 0.0
+        @JvmField var limit: Double = 0.0
 
         /**
          * The current deadline.
          */
-        var deadline: Long = Long.MAX_VALUE
+        @JvmField var deadline: Long = Long.MAX_VALUE
 
         /**
          * The processing speed that is allowed by the model constraints.
          */
-        var allowedSpeed: Double = 0.0
+        @JvmField var allowedSpeed: Double = 0.0
 
         /**
          * The actual processing speed.
          */
-        var actualSpeed: Double = 0.0
+        @JvmField var actualSpeed: Double = 0.0
 
         /**
          * The timestamp at which we received the last command.
@@ -363,9 +365,9 @@ public class SimResourceDistributorMaxMin(
         /**
          * Pull the next command if necessary.
          */
-        fun pull() {
+        fun pull(now: Long) {
             val ctx = ctx
-            if (ctx != null && lastCommandTimestamp < ctx.clock.millis()) {
+            if (ctx != null && lastCommandTimestamp < now) {
                 ctx.flush()
             }
         }
-- 
cgit v1.2.3


From d575bed5418be222e1d3ad39af862e2390596d61 Mon Sep 17 00:00:00 2001
From: Fabian Mastenbroek <mail.fabianm@gmail.com>
Date: Sun, 26 Sep 2021 13:11:10 +0200
Subject: refactor(simulator): Combine work and deadline to duration

This change removes the work and deadline properties from the
SimResourceCommand.Consume class and introduces a new property duration.
This property is now used in conjunction with the limit to compute the amount
of work processed by a resource provider.

Previously, we used both work and deadline to compute the duration and
the amount of remaining work at the end of a consumption. However, with
this change, we ensure that a resource consumption always runs at the
same speed once establishing, drastically simplifying the computation
for the amount of work processed during the consumption.
---
 .../resources/SimAbstractResourceAggregator.kt     |  40 +++----
 .../resources/SimAbstractResourceProvider.kt       |  22 +++-
 .../resources/SimResourceAggregatorMaxMin.kt       |  15 +--
 .../simulator/resources/SimResourceCommand.kt      |  16 +--
 .../simulator/resources/SimResourceConsumer.kt     |   4 +-
 .../simulator/resources/SimResourceContext.kt      |   5 -
 .../resources/SimResourceDistributorMaxMin.kt      | 129 +++++++--------------
 .../resources/SimResourceProviderLogic.kt          |  48 +++-----
 .../simulator/resources/SimResourceSource.kt       |  31 ++---
 .../simulator/resources/SimResourceTransformer.kt  |  28 ++---
 .../resources/consumer/SimSpeedConsumerAdapter.kt  |   4 +-
 .../resources/consumer/SimTraceConsumer.kt         |  13 +--
 .../resources/consumer/SimWorkConsumer.kt          |  22 ++--
 .../resources/impl/SimResourceContextImpl.kt       |  83 +++----------
 .../resources/SimResourceAggregatorMaxMinTest.kt   |  19 ++-
 .../simulator/resources/SimResourceCommandTest.kt  |  31 +----
 .../simulator/resources/SimResourceContextTest.kt  |  50 +++-----
 .../simulator/resources/SimResourceSourceTest.kt   |  54 +++------
 .../resources/SimResourceSwitchExclusiveTest.kt    |  11 +-
 .../resources/SimResourceSwitchMaxMinTest.kt       |   4 +-
 .../resources/SimResourceTransformerTest.kt        |  19 ++-
 .../simulator/resources/SimWorkConsumerTest.kt     |   2 -
 22 files changed, 212 insertions(+), 438 deletions(-)

(limited to 'opendc-simulator/opendc-simulator-resources')

diff --git a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimAbstractResourceAggregator.kt b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimAbstractResourceAggregator.kt
index 00648876..da5c3257 100644
--- a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimAbstractResourceAggregator.kt
+++ b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimAbstractResourceAggregator.kt
@@ -32,12 +32,7 @@ public abstract class SimAbstractResourceAggregator(
     /**
      * This method is invoked when the resource consumer consumes resources.
      */
-    protected abstract fun doConsume(work: Double, limit: Double, deadline: Long)
-
-    /**
-     * This method is invoked when the resource consumer enters an idle state.
-     */
-    protected abstract fun doIdle(deadline: Long)
+    protected abstract fun doConsume(limit: Double, duration: Long)
 
     /**
      * This method is invoked when the resource consumer finishes processing.
@@ -98,26 +93,23 @@ public abstract class SimAbstractResourceAggregator(
     private val _output = object : SimAbstractResourceProvider(interpreter, parent, initialCapacity = 0.0) {
         override fun createLogic(): SimResourceProviderLogic {
             return object : SimResourceProviderLogic {
-                override fun onIdle(ctx: SimResourceControllableContext, deadline: Long): Long {
-                    doIdle(deadline)
-                    return Long.MAX_VALUE
-                }
 
-                override fun onConsume(ctx: SimResourceControllableContext, work: Double, limit: Double, deadline: Long): Long {
-                    doConsume(work, limit, deadline)
-                    return Long.MAX_VALUE
+                override fun onConsume(ctx: SimResourceControllableContext, now: Long, limit: Double, duration: Long): Long {
+                    doConsume(limit, duration)
+                    return super.onConsume(ctx, now, limit, duration)
                 }
 
                 override fun onFinish(ctx: SimResourceControllableContext) {
                     doFinish()
                 }
 
-                override fun onUpdate(ctx: SimResourceControllableContext, work: Double, willOvercommit: Boolean) {
-                    updateCounters(ctx, work, willOvercommit)
-                }
-
-                override fun getConsumedWork(ctx: SimResourceControllableContext, work: Double, speed: Double, duration: Long): Double {
-                    return work - _inputConsumers.sumOf { it.remainingWork }
+                override fun onUpdate(
+                    ctx: SimResourceControllableContext,
+                    delta: Long,
+                    limit: Double,
+                    willOvercommit: Boolean
+                ) {
+                    updateCounters(ctx, delta, limit, willOvercommit)
                 }
             }
         }
@@ -156,12 +148,6 @@ public abstract class SimAbstractResourceAggregator(
             get() = _ctx!!
         private var _ctx: SimResourceContext? = null
 
-        /**
-         * The remaining work of the consumer.
-         */
-        val remainingWork: Double
-            get() = _ctx?.remainingWork ?: 0.0
-
         /**
          * The resource command to run next.
          */
@@ -179,7 +165,7 @@ public abstract class SimAbstractResourceAggregator(
         }
 
         /* SimResourceConsumer */
-        override fun onNext(ctx: SimResourceContext): SimResourceCommand {
+        override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): SimResourceCommand {
             var next = command
 
             return if (next != null) {
@@ -190,7 +176,7 @@ public abstract class SimAbstractResourceAggregator(
 
                 next = command
                 this.command = null
-                next ?: SimResourceCommand.Idle()
+                next ?: SimResourceCommand.Consume(0.0)
             }
         }
 
diff --git a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimAbstractResourceProvider.kt b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimAbstractResourceProvider.kt
index 4e8e803a..548bc228 100644
--- a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimAbstractResourceProvider.kt
+++ b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimAbstractResourceProvider.kt
@@ -87,21 +87,35 @@ public abstract class SimAbstractResourceProvider(
     /**
      * Update the counters of the resource provider.
      */
-    protected fun updateCounters(ctx: SimResourceContext, work: Double, willOvercommit: Boolean) {
-        if (work <= 0.0) {
+    protected fun updateCounters(ctx: SimResourceContext, delta: Long, limit: Double, willOvercommit: Boolean) {
+        if (delta <= 0.0) {
             return
         }
 
         val counters = _counters
-        val remainingWork = ctx.remainingWork
+        val deltaS = delta / 1000.0
+        val work = limit * deltaS
+        val actualWork = ctx.speed * deltaS
+        val remainingWork = work - actualWork
+
         counters.demand += work
-        counters.actual += work - remainingWork
+        counters.actual += actualWork
 
         if (willOvercommit && remainingWork > 0.0) {
             counters.overcommit += remainingWork
         }
     }
 
+    /**
+     * Update the counters of the resource provider.
+     */
+    protected fun updateCounters(demand: Double, actual: Double, overcommit: Double) {
+        val counters = _counters
+        counters.demand += demand
+        counters.actual += actual
+        counters.overcommit += overcommit
+    }
+
     final override fun startConsumer(consumer: SimResourceConsumer) {
         check(ctx == null) { "Resource is in invalid state" }
         val ctx = interpreter.newContext(consumer, createLogic(), parent)
diff --git a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceAggregatorMaxMin.kt b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceAggregatorMaxMin.kt
index 991cda7a..537be1b5 100644
--- a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceAggregatorMaxMin.kt
+++ b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceAggregatorMaxMin.kt
@@ -31,7 +31,7 @@ public class SimResourceAggregatorMaxMin(
 ) : SimAbstractResourceAggregator(interpreter, parent) {
     private val consumers = mutableListOf<Input>()
 
-    override fun doConsume(work: Double, limit: Double, deadline: Long) {
+    override fun doConsume(limit: Double, duration: Long) {
         // Sort all consumers by their capacity
         consumers.sortWith(compareBy { it.ctx.capacity })
 
@@ -40,22 +40,15 @@ public class SimResourceAggregatorMaxMin(
             val inputCapacity = input.ctx.capacity
             val fraction = inputCapacity / capacity
             val grantedSpeed = limit * fraction
-            val grantedWork = fraction * work
 
-            val command = if (grantedWork > 0.0 && grantedSpeed > 0.0)
-                SimResourceCommand.Consume(grantedWork, grantedSpeed, deadline)
+            val command = if (grantedSpeed > 0.0)
+                SimResourceCommand.Consume(grantedSpeed, duration)
             else
-                SimResourceCommand.Idle()
+                SimResourceCommand.Consume(0.0, duration)
             input.push(command)
         }
     }
 
-    override fun doIdle(deadline: Long) {
-        for (input in consumers) {
-            input.push(SimResourceCommand.Idle(deadline))
-        }
-    }
-
     override fun doFinish() {
         val iterator = consumers.iterator()
         for (input in iterator) {
diff --git a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceCommand.kt b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceCommand.kt
index f7f3fa4d..4a980071 100644
--- a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceCommand.kt
+++ b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceCommand.kt
@@ -27,24 +27,18 @@ package org.opendc.simulator.resources
  */
 public sealed class SimResourceCommand {
     /**
-     * A request to the resource to perform the specified amount of work before the given [deadline].
+     * A request to the resource to perform work for the specified [duration].
      *
-     * @param work The amount of work to process.
      * @param limit The maximum amount of work to be processed per second.
-     * @param deadline The instant at which the work needs to be fulfilled.
+     * @param duration The duration of the resource consumption in milliseconds.
      */
-    public data class Consume(val work: Double, val limit: Double, val deadline: Long = Long.MAX_VALUE) : SimResourceCommand() {
+    public data class Consume(val limit: Double, val duration: Long = Long.MAX_VALUE) : SimResourceCommand() {
         init {
-            require(work > 0) { "Amount of work must be positive" }
-            require(limit > 0) { "Limit must be positive" }
+            require(limit >= 0.0) { "Negative limit is not allowed" }
+            require(duration >= 0) { "Duration must be positive" }
         }
     }
 
-    /**
-     * An indication to the resource that the consumer will idle until the specified [deadline] or if it is interrupted.
-     */
-    public data class Idle(val deadline: Long = Long.MAX_VALUE) : SimResourceCommand()
-
     /**
      * An indication to the resource that the consumer has finished.
      */
diff --git a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceConsumer.kt b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceConsumer.kt
index 4d937514..4d1d2c32 100644
--- a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceConsumer.kt
+++ b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceConsumer.kt
@@ -34,9 +34,11 @@ public interface SimResourceConsumer {
      * the resource finished processing, reached its deadline or was interrupted.
      *
      * @param ctx The execution context in which the consumer runs.
+     * @param now The virtual timestamp in milliseconds at which the update is occurring.
+     * @param delta The virtual duration between this call and the last call in milliseconds.
      * @return The next command that the resource should execute.
      */
-    public fun onNext(ctx: SimResourceContext): SimResourceCommand
+    public fun onNext(ctx: SimResourceContext, now: Long, delta: Long): SimResourceCommand
 
     /**
      * This method is invoked when an event has occurred.
diff --git a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceContext.kt b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceContext.kt
index 0d9a6106..f28b43d0 100644
--- a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceContext.kt
+++ b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceContext.kt
@@ -49,11 +49,6 @@ public interface SimResourceContext {
      */
     public val demand: Double
 
-    /**
-     * The amount of work still remaining at this instant.
-     */
-    public val remainingWork: Double
-
     /**
      * Ask the resource provider to interrupt its resource.
      */
diff --git a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceDistributorMaxMin.kt b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceDistributorMaxMin.kt
index 63cfbdac..d23c7dbb 100644
--- a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceDistributorMaxMin.kt
+++ b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceDistributorMaxMin.kt
@@ -97,8 +97,8 @@ public class SimResourceDistributorMaxMin(
     }
 
     /* SimResourceConsumer */
-    override fun onNext(ctx: SimResourceContext): SimResourceCommand {
-        return doNext(ctx)
+    override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): SimResourceCommand {
+        return doNext(ctx, now)
     }
 
     override fun onEvent(ctx: SimResourceContext, event: SimResourceEvent) {
@@ -134,39 +134,17 @@ public class SimResourceDistributorMaxMin(
         public val interference: Double
     }
 
-    /**
-     * Update the counters of the distributor.
-     */
-    private fun updateCounters(ctx: SimResourceControllableContext, work: Double, willOvercommit: Boolean) {
-        if (work <= 0.0) {
-            return
-        }
-
-        val counters = _counters
-        val remainingWork = ctx.remainingWork
-
-        counters.demand += work
-        counters.actual += work - remainingWork
-
-        if (willOvercommit && remainingWork > 0.0) {
-            counters.overcommit += remainingWork
-        }
-    }
-
     /**
      * Schedule the work of the outputs.
      */
-    private fun doNext(ctx: SimResourceContext): SimResourceCommand {
+    private fun doNext(ctx: SimResourceContext, now: Long): SimResourceCommand {
         // If there is no work yet, mark the input as idle.
         if (activeOutputs.isEmpty()) {
-            return SimResourceCommand.Idle()
+            return SimResourceCommand.Consume(0.0)
         }
 
-        val now = interpreter.clock.millis()
-
         val capacity = ctx.capacity
-        var duration: Double = Double.MAX_VALUE
-        var deadline: Long = Long.MAX_VALUE
+        var duration: Long = Long.MAX_VALUE
         var availableSpeed = capacity
         var totalRequestedSpeed = 0.0
 
@@ -191,10 +169,10 @@ public class SimResourceDistributorMaxMin(
             val availableShare = availableSpeed / remaining--
             val grantedSpeed = min(output.allowedSpeed, availableShare)
 
-            deadline = min(deadline, output.deadline)
+            duration = min(duration, output.duration)
 
             // Ignore idle computation
-            if (grantedSpeed <= 0.0 || output.work <= 0.0) {
+            if (grantedSpeed <= 0.0) {
                 output.actualSpeed = 0.0
                 continue
             }
@@ -203,35 +181,29 @@ public class SimResourceDistributorMaxMin(
 
             output.actualSpeed = grantedSpeed
             availableSpeed -= grantedSpeed
-
-            // The duration that we want to run is that of the shortest request of an output
-            duration = min(duration, output.work / grantedSpeed)
         }
 
-        val targetDuration = min(duration, (deadline - now) / 1000.0)
+        val durationS = duration / 1000.0
         var totalRequestedWork = 0.0
         var totalAllocatedWork = 0.0
         for (output in activeOutputs) {
-            val work = output.work
+            val limit = output.limit
             val speed = output.actualSpeed
             if (speed > 0.0) {
-                val outputDuration = work / speed
-                totalRequestedWork += work * (duration / outputDuration)
-                totalAllocatedWork += work * (targetDuration / outputDuration)
+                totalRequestedWork += limit * durationS
+                totalAllocatedWork += speed * durationS
             }
         }
 
-        assert(deadline >= now) { "Deadline already passed" }
-
         this.totalRequestedSpeed = totalRequestedSpeed
         this.totalAllocatedWork = totalAllocatedWork
         val totalAllocatedSpeed = capacity - availableSpeed
         this.totalAllocatedSpeed = totalAllocatedSpeed
 
         return if (totalAllocatedWork > 0.0 && totalAllocatedSpeed > 0.0)
-            SimResourceCommand.Consume(totalAllocatedWork, totalAllocatedSpeed, deadline)
+            SimResourceCommand.Consume(totalAllocatedSpeed, duration)
         else
-            SimResourceCommand.Idle(deadline)
+            SimResourceCommand.Consume(0.0, duration)
     }
 
     private fun updateCapacity(ctx: SimResourceContext) {
@@ -243,7 +215,7 @@ public class SimResourceDistributorMaxMin(
     /**
      * An internal [SimResourceProvider] implementation for switch outputs.
      */
-    private inner class Output(capacity: Double, private val key: InterferenceKey?) :
+    private inner class Output(capacity: Double, val key: InterferenceKey?) :
         SimAbstractResourceProvider(interpreter, parent, capacity),
         SimResourceCloseableProvider,
         SimResourceProviderLogic,
@@ -253,11 +225,6 @@ public class SimResourceDistributorMaxMin(
          */
         private var isClosed: Boolean = false
 
-        /**
-         * The current requested work.
-         */
-        @JvmField var work: Double = 0.0
-
         /**
          * The requested limit.
          */
@@ -266,7 +233,7 @@ public class SimResourceDistributorMaxMin(
         /**
          * The current deadline.
          */
-        @JvmField var deadline: Long = Long.MAX_VALUE
+        @JvmField var duration: Long = Long.MAX_VALUE
 
         /**
          * The processing speed that is allowed by the model constraints.
@@ -304,44 +271,19 @@ public class SimResourceDistributorMaxMin(
         }
 
         /* SimResourceProviderLogic */
-        override fun onIdle(ctx: SimResourceControllableContext, deadline: Long): Long {
-            allowedSpeed = 0.0
-            this.deadline = deadline
-            work = 0.0
-            limit = 0.0
-            lastCommandTimestamp = ctx.clock.millis()
-
-            return Long.MAX_VALUE
-        }
-
-        override fun onConsume(ctx: SimResourceControllableContext, work: Double, limit: Double, deadline: Long): Long {
+        override fun onConsume(ctx: SimResourceControllableContext, now: Long, limit: Double, duration: Long): Long {
             allowedSpeed = min(ctx.capacity, limit)
-            this.work = work
             this.limit = limit
-            this.deadline = deadline
-            lastCommandTimestamp = ctx.clock.millis()
-
-            return Long.MAX_VALUE
-        }
-
-        override fun onUpdate(ctx: SimResourceControllableContext, work: Double, willOvercommit: Boolean) {
-            updateCounters(ctx, work, willOvercommit)
+            this.duration = duration
+            lastCommandTimestamp = now
 
-            this@SimResourceDistributorMaxMin.updateCounters(ctx, work, willOvercommit)
-        }
-
-        override fun onFinish(ctx: SimResourceControllableContext) {
-            work = 0.0
-            limit = 0.0
-            deadline = Long.MAX_VALUE
-            lastCommandTimestamp = ctx.clock.millis()
+            return super.onConsume(ctx, now, limit, duration)
         }
 
-        override fun getConsumedWork(ctx: SimResourceControllableContext, work: Double, speed: Double, duration: Long): Double {
-            val totalRemainingWork = this@SimResourceDistributorMaxMin.ctx?.remainingWork ?: 0.0
-
-            // Compute the fraction of compute time allocated to the output
-            val fraction = actualSpeed / totalAllocatedSpeed
+        override fun onUpdate(ctx: SimResourceControllableContext, delta: Long, limit: Double, willOvercommit: Boolean) {
+            if (delta <= 0.0) {
+                return
+            }
 
             // Compute the performance penalty due to resource interference
             val perfScore = if (interferenceDomain != null) {
@@ -351,12 +293,29 @@ public class SimResourceDistributorMaxMin(
                 1.0
             }
 
-            // Compute the work that was actually granted to the output.
-            val potentialConsumedWork = (totalAllocatedWork - totalRemainingWork) * fraction
+            val deltaS = delta / 1000.0
+            val work = limit * deltaS
+            val actualWork = actualSpeed * deltaS
+            val remainingWork = work - actualWork
+            val overcommit = if (willOvercommit && remainingWork > 0.0) {
+                remainingWork
+            } else {
+                0.0
+            }
 
-            _counters.interference += potentialConsumedWork * max(0.0, 1 - perfScore)
+            updateCounters(work, actualWork, overcommit)
 
-            return potentialConsumedWork
+            val distCounters = _counters
+            distCounters.demand += work
+            distCounters.actual += actualWork
+            distCounters.overcommit += overcommit
+            distCounters.interference += actualWork * max(0.0, 1 - perfScore)
+        }
+
+        override fun onFinish(ctx: SimResourceControllableContext) {
+            limit = 0.0
+            duration = Long.MAX_VALUE
+            lastCommandTimestamp = ctx.clock.millis()
         }
 
         /* Comparable */
diff --git a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceProviderLogic.kt b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceProviderLogic.kt
index 2fe1b00f..d8ff87f9 100644
--- a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceProviderLogic.kt
+++ b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceProviderLogic.kt
@@ -27,53 +27,33 @@ package org.opendc.simulator.resources
  */
 public interface SimResourceProviderLogic {
     /**
-     * This method is invoked when the resource is reported to idle until the specified [deadline].
+     * This method is invoked when the consumer ask to consume the resource for the specified [duration].
      *
      * @param ctx The context in which the provider runs.
-     * @param deadline The deadline that was requested by the resource consumer.
-     * @return The instant at which to resume the consumer.
-     */
-    public fun onIdle(ctx: SimResourceControllableContext, deadline: Long): Long
-
-    /**
-     * This method is invoked when the resource will be consumed until the specified amount of [work] was processed
-     * or [deadline] is reached.
-     *
-     * @param ctx The context in which the provider runs.
-     * @param work The amount of work that was requested by the resource consumer.
+     * @param now The virtual timestamp in milliseconds at which the update is occurring.
      * @param limit The limit on the work rate of the resource consumer.
-     * @param deadline The deadline that was requested by the resource consumer.
-     * @return The instant at which to resume the consumer.
+     * @param duration The duration of the consumption in milliseconds.
+     * @return The deadline of the resource consumption.
      */
-    public fun onConsume(ctx: SimResourceControllableContext, work: Double, limit: Double, deadline: Long): Long
+    public fun onConsume(ctx: SimResourceControllableContext, now: Long, limit: Double, duration: Long): Long {
+        return if (duration == Long.MAX_VALUE) {
+            return Long.MAX_VALUE
+        } else {
+            now + duration
+        }
+    }
 
     /**
      * This method is invoked when the progress of the resource consumer is materialized.
      *
      * @param ctx The context in which the provider runs.
-     * @param work The amount of work that was requested by the resource consumer.
+     * @param limit The limit on the work rate of the resource consumer.
      * @param willOvercommit A flag to indicate that the remaining work is overcommitted.
      */
-    public fun onUpdate(ctx: SimResourceControllableContext, work: Double, willOvercommit: Boolean) {}
+    public fun onUpdate(ctx: SimResourceControllableContext, delta: Long, limit: Double, willOvercommit: Boolean) {}
 
     /**
      * This method is invoked when the resource consumer has finished.
      */
-    public fun onFinish(ctx: SimResourceControllableContext)
-
-    /**
-     * Compute the amount of work that was consumed over the specified [duration].
-     *
-     * @param work The total size of the resource consumption.
-     * @param speed The speed of the resource provider.
-     * @param duration The duration from the start of the consumption until now.
-     * @return The amount of work that was consumed by the resource provider.
-     */
-    public fun getConsumedWork(ctx: SimResourceControllableContext, work: Double, speed: Double, duration: Long): Double {
-        return if (duration > 0L) {
-            return (duration / 1000.0) * speed
-        } else {
-            work
-        }
-    }
+    public fun onFinish(ctx: SimResourceControllableContext) {}
 }
diff --git a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceSource.kt b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceSource.kt
index 2d53198a..10213f26 100644
--- a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceSource.kt
+++ b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceSource.kt
@@ -22,9 +22,6 @@
 
 package org.opendc.simulator.resources
 
-import kotlin.math.ceil
-import kotlin.math.min
-
 /**
  * A [SimResourceSource] represents a source for some resource that provides bounded processing capacity.
  *
@@ -39,20 +36,13 @@ public class SimResourceSource(
 ) : SimAbstractResourceProvider(interpreter, parent, initialCapacity) {
     override fun createLogic(): SimResourceProviderLogic {
         return object : SimResourceProviderLogic {
-            override fun onIdle(ctx: SimResourceControllableContext, deadline: Long): Long {
-                return deadline
-            }
-
-            override fun onConsume(ctx: SimResourceControllableContext, work: Double, limit: Double, deadline: Long): Long {
-                return if (work.isInfinite()) {
-                    Long.MAX_VALUE
-                } else {
-                    min(deadline, ctx.clock.millis() + getDuration(work, speed))
-                }
-            }
-
-            override fun onUpdate(ctx: SimResourceControllableContext, work: Double, willOvercommit: Boolean) {
-                updateCounters(ctx, work, willOvercommit)
+            override fun onUpdate(
+                ctx: SimResourceControllableContext,
+                delta: Long,
+                limit: Double,
+                willOvercommit: Boolean
+            ) {
+                updateCounters(ctx, delta, limit, willOvercommit)
             }
 
             override fun onFinish(ctx: SimResourceControllableContext) {
@@ -62,11 +52,4 @@ public class SimResourceSource(
     }
 
     override fun toString(): String = "SimResourceSource[capacity=$capacity]"
-
-    /**
-     * Compute the duration that a resource consumption will take with the specified [speed].
-     */
-    private fun getDuration(work: Double, speed: Double): Long {
-        return ceil(work / speed * 1000).toLong()
-    }
 }
diff --git a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceTransformer.kt b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceTransformer.kt
index cec27e1c..68bedbd9 100644
--- a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceTransformer.kt
+++ b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceTransformer.kt
@@ -100,19 +100,19 @@ public class SimResourceTransformer(
         }
     }
 
-    override fun onNext(ctx: SimResourceContext): SimResourceCommand {
+    override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): SimResourceCommand {
         val delegate = delegate
 
         if (!hasDelegateStarted) {
             start()
         }
 
-        updateCounters(ctx)
+        updateCounters(ctx, delta)
 
         return if (delegate != null) {
-            val command = transform(ctx, delegate.onNext(ctx))
+            val command = transform(ctx, delegate.onNext(ctx, now, delta))
 
-            _work = if (command is SimResourceCommand.Consume) command.work else 0.0
+            _limit = if (command is SimResourceCommand.Consume) command.limit else 0.0
 
             if (command == SimResourceCommand.Exit) {
                 // Warning: resumption of the continuation might change the entire state of the forwarder. Make sure we
@@ -124,12 +124,12 @@ public class SimResourceTransformer(
                 if (isCoupled)
                     SimResourceCommand.Exit
                 else
-                    onNext(ctx)
+                    onNext(ctx, now, delta)
             } else {
                 command
             }
         } else {
-            SimResourceCommand.Idle()
+            SimResourceCommand.Consume(0.0)
         }
     }
 
@@ -180,19 +180,21 @@ public class SimResourceTransformer(
     }
 
     /**
-     * Counter to track the current submitted work.
+     * The requested speed.
      */
-    private var _work = 0.0
+    private var _limit: Double = 0.0
 
     /**
      * Update the resource counters for the transformer.
      */
-    private fun updateCounters(ctx: SimResourceContext) {
+    private fun updateCounters(ctx: SimResourceContext, delta: Long) {
         val counters = _counters
-        val remainingWork = ctx.remainingWork
-        counters.demand += _work
-        counters.actual += _work - remainingWork
-        counters.overcommit += remainingWork
+        val deltaS = delta / 1000.0
+        val work = _limit * deltaS
+        val actualWork = ctx.speed * deltaS
+        counters.demand += work
+        counters.actual += actualWork
+        counters.overcommit += (work - actualWork)
     }
 }
 
diff --git a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/consumer/SimSpeedConsumerAdapter.kt b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/consumer/SimSpeedConsumerAdapter.kt
index 4f4ebb14..1f8434b7 100644
--- a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/consumer/SimSpeedConsumerAdapter.kt
+++ b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/consumer/SimSpeedConsumerAdapter.kt
@@ -50,8 +50,8 @@ public class SimSpeedConsumerAdapter(
         callback(0.0)
     }
 
-    override fun onNext(ctx: SimResourceContext): SimResourceCommand {
-        return delegate.onNext(ctx)
+    override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): SimResourceCommand {
+        return delegate.onNext(ctx, now, delta)
     }
 
     override fun onEvent(ctx: SimResourceContext, event: SimResourceEvent) {
diff --git a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/consumer/SimTraceConsumer.kt b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/consumer/SimTraceConsumer.kt
index 2e94e1c1..e5173e5f 100644
--- a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/consumer/SimTraceConsumer.kt
+++ b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/consumer/SimTraceConsumer.kt
@@ -34,20 +34,11 @@ import org.opendc.simulator.resources.SimResourceEvent
 public class SimTraceConsumer(private val trace: Sequence<Fragment>) : SimResourceConsumer {
     private var iterator: Iterator<Fragment>? = null
 
-    override fun onNext(ctx: SimResourceContext): SimResourceCommand {
+    override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): SimResourceCommand {
         val iterator = checkNotNull(iterator)
         return if (iterator.hasNext()) {
-            val now = ctx.clock.millis()
             val fragment = iterator.next()
-            val work = (fragment.duration / 1000) * fragment.usage
-            val deadline = now + fragment.duration
-
-            assert(deadline >= now) { "Deadline already passed" }
-
-            if (work > 0.0)
-                SimResourceCommand.Consume(work, fragment.usage, deadline)
-            else
-                SimResourceCommand.Idle(deadline)
+            SimResourceCommand.Consume(fragment.usage, fragment.duration)
         } else {
             SimResourceCommand.Exit
         }
diff --git a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/consumer/SimWorkConsumer.kt b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/consumer/SimWorkConsumer.kt
index faa693c4..ae837043 100644
--- a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/consumer/SimWorkConsumer.kt
+++ b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/consumer/SimWorkConsumer.kt
@@ -25,6 +25,7 @@ package org.opendc.simulator.resources.consumer
 import org.opendc.simulator.resources.SimResourceCommand
 import org.opendc.simulator.resources.SimResourceConsumer
 import org.opendc.simulator.resources.SimResourceContext
+import kotlin.math.roundToLong
 
 /**
  * A [SimResourceConsumer] that consumes the specified amount of work at the specified utilization.
@@ -39,18 +40,19 @@ public class SimWorkConsumer(
         require(utilization > 0.0 && utilization <= 1.0) { "Utilization must be in (0, 1]" }
     }
 
-    private var isFirst = true
+    private var remainingWork = work
 
-    override fun onNext(ctx: SimResourceContext): SimResourceCommand {
+    override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): SimResourceCommand {
+        val actualWork = ctx.speed * delta / 1000.0
         val limit = ctx.capacity * utilization
-        val work = if (isFirst) {
-            isFirst = false
-            work
-        } else {
-            ctx.remainingWork
-        }
-        return if (work > 0.0) {
-            SimResourceCommand.Consume(work, limit)
+
+        remainingWork -= actualWork
+
+        val remainingWork = remainingWork
+        val duration = (remainingWork / limit * 1000).roundToLong()
+
+        return if (duration > 0) {
+            SimResourceCommand.Consume(limit, duration)
         } else {
             SimResourceCommand.Exit
         }
diff --git a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/impl/SimResourceContextImpl.kt b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/impl/SimResourceContextImpl.kt
index b79998a3..a9507e52 100644
--- a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/impl/SimResourceContextImpl.kt
+++ b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/impl/SimResourceContextImpl.kt
@@ -57,12 +57,6 @@ internal class SimResourceContextImpl(
             }
         }
 
-    /**
-     * The amount of work still remaining at this instant.
-     */
-    override val remainingWork: Double
-        get() = getRemainingWork(_clock.millis())
-
     /**
      * A flag to indicate the state of the context.
      */
@@ -87,8 +81,8 @@ internal class SimResourceContextImpl(
      * The current state of the resource context.
      */
     private var _timestamp: Long = Long.MIN_VALUE
-    private var _work: Double = 0.0
     private var _limit: Double = 0.0
+    private var _duration: Long = Long.MAX_VALUE
     private var _deadline: Long = Long.MAX_VALUE
 
     /**
@@ -178,7 +172,6 @@ internal class SimResourceContextImpl(
         } catch (cause: Throwable) {
             doFail(cause)
         } finally {
-            _remainingWorkFlush = Long.MIN_VALUE
             _timestamp = timestamp
         }
     }
@@ -200,29 +193,25 @@ internal class SimResourceContextImpl(
             SimResourceState.Pending, SimResourceState.Stopped -> state
             SimResourceState.Active -> {
                 val isInterrupted = _flag and FLAG_INTERRUPT != 0
-                val remainingWork = getRemainingWork(timestamp)
-                val isConsume = _limit > 0.0
                 val reachedDeadline = _deadline <= timestamp
+                val delta = max(0, timestamp - _timestamp)
 
                 // Update the resource counters only if there is some progress
                 if (timestamp > _timestamp) {
-                    logic.onUpdate(this, _work, reachedDeadline)
+                    logic.onUpdate(this, delta, _limit, reachedDeadline)
                 }
 
                 // We should only continue processing the next command if:
                 // 1. The resource consumption was finished.
                 // 2. The resource capacity cannot satisfy the demand.
                 // 3. The resource consumer should be interrupted (e.g., someone called .interrupt())
-                if ((isConsume && remainingWork == 0.0) || reachedDeadline || isInterrupted) {
-                    when (val command = consumer.onNext(this)) {
-                        is SimResourceCommand.Idle -> interpretIdle(timestamp, command.deadline)
-                        is SimResourceCommand.Consume -> interpretConsume(timestamp, command.work, command.limit, command.deadline)
+                if (reachedDeadline || isInterrupted) {
+                    when (val command = consumer.onNext(this, timestamp, delta)) {
+                        is SimResourceCommand.Consume -> interpretConsume(timestamp, command.limit, command.duration)
                         is SimResourceCommand.Exit -> interpretExit()
                     }
-                } else if (isConsume) {
-                    interpretConsume(timestamp, remainingWork, _limit, _deadline)
                 } else {
-                    interpretIdle(timestamp, _deadline)
+                    interpretConsume(timestamp, _limit, _duration - delta)
                 }
             }
         }
@@ -257,32 +246,15 @@ internal class SimResourceContextImpl(
     /**
      * Interpret the [SimResourceCommand.Consume] command.
      */
-    private fun interpretConsume(now: Long, work: Double, limit: Double, deadline: Long): SimResourceState {
-        require(deadline >= now) { "Deadline already passed" }
-
+    private fun interpretConsume(now: Long, limit: Double, duration: Long): SimResourceState {
         _speed = min(capacity, limit)
-        _work = work
         _limit = limit
-        _deadline = deadline
+        _duration = duration
 
-        val timestamp = logic.onConsume(this, work, limit, deadline)
-        scheduleUpdate(timestamp)
+        val timestamp = logic.onConsume(this, now, limit, duration)
 
-        return SimResourceState.Active
-    }
-
-    /**
-     * Interpret the [SimResourceCommand.Idle] command.
-     */
-    private fun interpretIdle(now: Long, deadline: Long): SimResourceState {
-        require(deadline >= now) { "Deadline already passed" }
-
-        _speed = 0.0
-        _work = 0.0
-        _limit = 0.0
-        _deadline = deadline
+        _deadline = timestamp
 
-        val timestamp = logic.onIdle(this, deadline)
         scheduleUpdate(timestamp)
 
         return SimResourceState.Active
@@ -293,37 +265,13 @@ internal class SimResourceContextImpl(
      */
     private fun interpretExit(): SimResourceState {
         _speed = 0.0
-        _work = 0.0
         _limit = 0.0
+        _duration = Long.MAX_VALUE
         _deadline = Long.MAX_VALUE
 
         return SimResourceState.Stopped
     }
 
-    private var _remainingWork: Double = 0.0
-    private var _remainingWorkFlush: Long = Long.MIN_VALUE
-
-    /**
-     * Obtain the remaining work at the given timestamp.
-     */
-    private fun getRemainingWork(now: Long): Double {
-        return if (_remainingWorkFlush < now) {
-            _remainingWorkFlush = now
-            computeRemainingWork(now).also { _remainingWork = it }
-        } else {
-            _remainingWork
-        }
-    }
-
-    /**
-     * Compute the remaining work based on the current state.
-     */
-    private fun computeRemainingWork(now: Long): Double {
-        return if (_work > 0.0)
-            max(0.0, _work - logic.getConsumedWork(this, _work, speed, now - _timestamp))
-        else 0.0
-    }
-
     /**
      * Indicate that the capacity of the resource has changed.
      */
@@ -333,16 +281,11 @@ internal class SimResourceContextImpl(
             return
         }
 
-        val isThrottled = speed > capacity
-
         interpreter.batch {
             // Inform the consumer of the capacity change. This might already trigger an interrupt.
             consumer.onEvent(this, SimResourceEvent.Capacity)
 
-            // Optimization: only invalidate context if the new capacity cannot satisfy the active resource command.
-            if (isThrottled) {
-                invalidate()
-            }
+            interrupt()
         }
     }
 
diff --git a/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceAggregatorMaxMinTest.kt b/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceAggregatorMaxMinTest.kt
index 2f01a8c4..a9390553 100644
--- a/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceAggregatorMaxMinTest.kt
+++ b/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceAggregatorMaxMinTest.kt
@@ -38,7 +38,6 @@ import org.opendc.simulator.resources.impl.SimResourceInterpreterImpl
 /**
  * Test suite for the [SimResourceAggregatorMaxMin] class.
  */
-@OptIn(ExperimentalCoroutinesApi::class)
 internal class SimResourceAggregatorMaxMinTest {
     @Test
     fun testSingleCapacity() = runBlockingSimulation {
@@ -102,15 +101,15 @@ internal class SimResourceAggregatorMaxMinTest {
         sources.forEach(aggregator::addInput)
 
         val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
-        every { consumer.onNext(any()) }
-            .returns(SimResourceCommand.Consume(4.0, 4.0, 1000))
+        every { consumer.onNext(any(), any(), any()) }
+            .returns(SimResourceCommand.Consume(4.0, 1000))
             .andThen(SimResourceCommand.Exit)
 
         aggregator.consume(consumer)
         yield()
         assertEquals(1000, clock.millis())
 
-        verify(exactly = 2) { consumer.onNext(any()) }
+        verify(exactly = 2) { consumer.onNext(any(), any(), any()) }
     }
 
     @Test
@@ -125,8 +124,8 @@ internal class SimResourceAggregatorMaxMinTest {
         sources.forEach(aggregator::addInput)
 
         val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
-        every { consumer.onNext(any()) }
-            .returns(SimResourceCommand.Consume(1.0, 1.0))
+        every { consumer.onNext(any(), any(), any()) }
+            .returns(SimResourceCommand.Consume(1.0, duration = 1000))
             .andThenThrows(IllegalStateException("Test Exception"))
 
         assertThrows<IllegalStateException> { aggregator.consume(consumer) }
@@ -152,7 +151,7 @@ internal class SimResourceAggregatorMaxMinTest {
             sources[0].capacity = 0.5
         }
         yield()
-        assertEquals(2334, clock.millis())
+        assertEquals(2333, clock.millis())
     }
 
     @Test
@@ -173,7 +172,7 @@ internal class SimResourceAggregatorMaxMinTest {
             sources[0].capacity = 0.5
         }
         yield()
-        assertEquals(1000, clock.millis())
+        assertEquals(1167, clock.millis())
     }
 
     @Test
@@ -188,8 +187,8 @@ internal class SimResourceAggregatorMaxMinTest {
         sources.forEach(aggregator::addInput)
 
         val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
-        every { consumer.onNext(any()) }
-            .returns(SimResourceCommand.Consume(4.0, 4.0, 1000))
+        every { consumer.onNext(any(), any(), any()) }
+            .returns(SimResourceCommand.Consume(4.0, 1000))
             .andThen(SimResourceCommand.Exit)
 
         aggregator.consume(consumer)
diff --git a/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceCommandTest.kt b/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceCommandTest.kt
index 02d456ff..9a52dc63 100644
--- a/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceCommandTest.kt
+++ b/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceCommandTest.kt
@@ -31,44 +31,23 @@ import org.junit.jupiter.api.assertThrows
  */
 class SimResourceCommandTest {
     @Test
-    fun testZeroWork() {
-        assertThrows<IllegalArgumentException> {
-            SimResourceCommand.Consume(0.0, 1.0)
-        }
-    }
-
-    @Test
-    fun testNegativeWork() {
-        assertThrows<IllegalArgumentException> {
-            SimResourceCommand.Consume(-1.0, 1.0)
-        }
-    }
-
-    @Test
-    fun testZeroLimit() {
+    fun testNegativeLimit() {
         assertThrows<IllegalArgumentException> {
-            SimResourceCommand.Consume(1.0, 0.0)
+            SimResourceCommand.Consume(-1.0, 1)
         }
     }
 
     @Test
-    fun testNegativeLimit() {
+    fun testNegativeDuration() {
         assertThrows<IllegalArgumentException> {
-            SimResourceCommand.Consume(1.0, -1.0, 1)
+            SimResourceCommand.Consume(1.0, -1)
         }
     }
 
     @Test
     fun testConsumeCorrect() {
         assertDoesNotThrow {
-            SimResourceCommand.Consume(1.0, 1.0)
-        }
-    }
-
-    @Test
-    fun testIdleCorrect() {
-        assertDoesNotThrow {
-            SimResourceCommand.Idle(1)
+            SimResourceCommand.Consume(1.0)
         }
     }
 }
diff --git a/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceContextTest.kt b/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceContextTest.kt
index 6cb507ce..0cb95abb 100644
--- a/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceContextTest.kt
+++ b/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceContextTest.kt
@@ -32,19 +32,14 @@ import org.opendc.simulator.resources.impl.SimResourceInterpreterImpl
 /**
  * A test suite for the [SimResourceContextImpl] class.
  */
-@OptIn(ExperimentalCoroutinesApi::class)
 class SimResourceContextTest {
     @Test
     fun testFlushWithoutCommand() = runBlockingSimulation {
         val interpreter = SimResourceInterpreterImpl(coroutineContext, clock)
         val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
-        every { consumer.onNext(any()) } returns SimResourceCommand.Consume(10.0, 1.0) andThen SimResourceCommand.Exit
+        every { consumer.onNext(any(), any(), any()) } returns SimResourceCommand.Consume(1.0) andThen SimResourceCommand.Exit
 
-        val logic = object : SimResourceProviderLogic {
-            override fun onIdle(ctx: SimResourceControllableContext, deadline: Long): Long = deadline
-            override fun onConsume(ctx: SimResourceControllableContext, work: Double, limit: Double, deadline: Long): Long = deadline
-            override fun onFinish(ctx: SimResourceControllableContext) {}
-        }
+        val logic = object : SimResourceProviderLogic {}
         val context = SimResourceContextImpl(null, interpreter, consumer, logic)
 
         context.doUpdate(interpreter.clock.millis())
@@ -54,12 +49,11 @@ class SimResourceContextTest {
     fun testIntermediateFlush() = runBlockingSimulation {
         val interpreter = SimResourceInterpreterImpl(coroutineContext, clock)
         val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
-        every { consumer.onNext(any()) } returns SimResourceCommand.Consume(10.0, 1.0) andThen SimResourceCommand.Exit
+        every { consumer.onNext(any(), any(), any()) } returns SimResourceCommand.Consume(1.0) andThen SimResourceCommand.Exit
 
         val logic = spyk(object : SimResourceProviderLogic {
-            override fun onIdle(ctx: SimResourceControllableContext, deadline: Long): Long = deadline
             override fun onFinish(ctx: SimResourceControllableContext) {}
-            override fun onConsume(ctx: SimResourceControllableContext, work: Double, limit: Double, deadline: Long): Long = deadline
+            override fun onConsume(ctx: SimResourceControllableContext, now: Long, limit: Double, duration: Long): Long = duration
         })
         val context = spyk(SimResourceContextImpl(null, interpreter, consumer, logic))
 
@@ -74,13 +68,9 @@ class SimResourceContextTest {
     fun testIntermediateFlushIdle() = runBlockingSimulation {
         val interpreter = SimResourceInterpreterImpl(coroutineContext, clock)
         val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
-        every { consumer.onNext(any()) } returns SimResourceCommand.Idle(10) andThen SimResourceCommand.Exit
+        every { consumer.onNext(any(), any(), any()) } returns SimResourceCommand.Consume(0.0, 10) andThen SimResourceCommand.Exit
 
-        val logic = spyk(object : SimResourceProviderLogic {
-            override fun onIdle(ctx: SimResourceControllableContext, deadline: Long): Long = deadline
-            override fun onFinish(ctx: SimResourceControllableContext) {}
-            override fun onConsume(ctx: SimResourceControllableContext, work: Double, limit: Double, deadline: Long): Long = deadline
-        })
+        val logic = spyk(object : SimResourceProviderLogic {})
         val context = spyk(SimResourceContextImpl(null, interpreter, consumer, logic))
 
         context.start()
@@ -90,7 +80,7 @@ class SimResourceContextTest {
         context.invalidate()
 
         assertAll(
-            { verify(exactly = 2) { logic.onIdle(any(), any()) } },
+            { verify(exactly = 2) { logic.onConsume(any(), any(), 0.0, any()) } },
             { verify(exactly = 1) { logic.onFinish(any()) } }
         )
     }
@@ -99,13 +89,9 @@ class SimResourceContextTest {
     fun testDoubleStart() = runBlockingSimulation {
         val interpreter = SimResourceInterpreterImpl(coroutineContext, clock)
         val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
-        every { consumer.onNext(any()) } returns SimResourceCommand.Idle(10) andThen SimResourceCommand.Exit
+        every { consumer.onNext(any(), any(), any()) } returns SimResourceCommand.Consume(0.0, 10) andThen SimResourceCommand.Exit
 
-        val logic = object : SimResourceProviderLogic {
-            override fun onIdle(ctx: SimResourceControllableContext, deadline: Long): Long = deadline
-            override fun onFinish(ctx: SimResourceControllableContext) {}
-            override fun onConsume(ctx: SimResourceControllableContext, work: Double, limit: Double, deadline: Long): Long = deadline
-        }
+        val logic = object : SimResourceProviderLogic {}
         val context = SimResourceContextImpl(null, interpreter, consumer, logic)
 
         context.start()
@@ -116,16 +102,12 @@ class SimResourceContextTest {
     }
 
     @Test
-    fun testIdempodentCapacityChange() = runBlockingSimulation {
+    fun testIdempotentCapacityChange() = runBlockingSimulation {
         val interpreter = SimResourceInterpreterImpl(coroutineContext, clock)
         val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
-        every { consumer.onNext(any()) } returns SimResourceCommand.Consume(10.0, 1.0) andThen SimResourceCommand.Exit
+        every { consumer.onNext(any(), any(), any()) } returns SimResourceCommand.Consume(1.0) andThen SimResourceCommand.Exit
 
-        val logic = object : SimResourceProviderLogic {
-            override fun onIdle(ctx: SimResourceControllableContext, deadline: Long): Long = deadline
-            override fun onFinish(ctx: SimResourceControllableContext) {}
-            override fun onConsume(ctx: SimResourceControllableContext, work: Double, limit: Double, deadline: Long): Long = deadline
-        }
+        val logic = object : SimResourceProviderLogic {}
 
         val context = SimResourceContextImpl(null, interpreter, consumer, logic)
         context.capacity = 4200.0
@@ -139,15 +121,11 @@ class SimResourceContextTest {
     fun testFailureNoInfiniteLoop() = runBlockingSimulation {
         val interpreter = SimResourceInterpreterImpl(coroutineContext, clock)
         val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
-        every { consumer.onNext(any()) } returns SimResourceCommand.Exit
+        every { consumer.onNext(any(), any(), any()) } returns SimResourceCommand.Exit
         every { consumer.onEvent(any(), SimResourceEvent.Exit) } throws IllegalStateException("onEvent")
         every { consumer.onFailure(any(), any()) } throws IllegalStateException("onFailure")
 
-        val logic = spyk(object : SimResourceProviderLogic {
-            override fun onIdle(ctx: SimResourceControllableContext, deadline: Long): Long = deadline
-            override fun onFinish(ctx: SimResourceControllableContext) {}
-            override fun onConsume(ctx: SimResourceControllableContext, work: Double, limit: Double, deadline: Long): Long = deadline
-        })
+        val logic = spyk(object : SimResourceProviderLogic {})
 
         val context = SimResourceContextImpl(null, interpreter, consumer, logic)
 
diff --git a/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceSourceTest.kt b/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceSourceTest.kt
index 4895544d..c310fad6 100644
--- a/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceSourceTest.kt
+++ b/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceSourceTest.kt
@@ -37,8 +37,7 @@ import org.opendc.simulator.resources.impl.SimResourceInterpreterImpl
 /**
  * A test suite for the [SimResourceSource] class.
  */
-@OptIn(ExperimentalCoroutinesApi::class)
-class SimResourceSourceTest {
+internal class SimResourceSourceTest {
     @Test
     fun testSpeed() = runBlockingSimulation {
         val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
@@ -46,8 +45,8 @@ class SimResourceSourceTest {
         val provider = SimResourceSource(capacity, scheduler)
 
         val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
-        every { consumer.onNext(any()) }
-            .returns(SimResourceCommand.Consume(1000 * capacity, capacity))
+        every { consumer.onNext(any(), any(), any()) }
+            .returns(SimResourceCommand.Consume(capacity, duration = 1000))
             .andThen(SimResourceCommand.Exit)
 
         val res = mutableListOf<Double>()
@@ -81,8 +80,8 @@ class SimResourceSourceTest {
         val provider = SimResourceSource(capacity, scheduler)
 
         val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
-        every { consumer.onNext(any()) }
-            .returns(SimResourceCommand.Consume(1000 * capacity, 2 * capacity))
+        every { consumer.onNext(any(), any(), any()) }
+            .returns(SimResourceCommand.Consume(2 * capacity, duration = 1000))
             .andThen(SimResourceCommand.Exit)
 
         val res = mutableListOf<Double>()
@@ -104,7 +103,7 @@ class SimResourceSourceTest {
         val provider = SimResourceSource(capacity, scheduler)
 
         val consumer = object : SimResourceConsumer {
-            override fun onNext(ctx: SimResourceContext): SimResourceCommand {
+            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): SimResourceCommand {
                 return SimResourceCommand.Exit
             }
 
@@ -133,11 +132,10 @@ class SimResourceSourceTest {
                 }
             }
 
-            override fun onNext(ctx: SimResourceContext): SimResourceCommand {
-                assertEquals(0.0, ctx.remainingWork)
+            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): SimResourceCommand {
                 return if (isFirst) {
                     isFirst = false
-                    SimResourceCommand.Consume(4.0, 1.0)
+                    SimResourceCommand.Consume(1.0, duration = 4000)
                 } else {
                     SimResourceCommand.Exit
                 }
@@ -175,8 +173,8 @@ class SimResourceSourceTest {
         val provider = SimResourceSource(capacity, scheduler)
 
         val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
-        every { consumer.onNext(any()) }
-            .returns(SimResourceCommand.Consume(1.0, 1.0))
+        every { consumer.onNext(any(), any(), any()) }
+            .returns(SimResourceCommand.Consume(1.0, duration = 1000))
             .andThenThrows(IllegalStateException())
 
         assertThrows<IllegalStateException> {
@@ -191,8 +189,8 @@ class SimResourceSourceTest {
         val provider = SimResourceSource(capacity, scheduler)
 
         val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
-        every { consumer.onNext(any()) }
-            .returns(SimResourceCommand.Consume(1.0, 1.0))
+        every { consumer.onNext(any(), any(), any()) }
+            .returns(SimResourceCommand.Consume(1.0))
             .andThenThrows(IllegalStateException())
 
         assertThrows<IllegalStateException> {
@@ -210,8 +208,8 @@ class SimResourceSourceTest {
         val provider = SimResourceSource(capacity, scheduler)
 
         val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
-        every { consumer.onNext(any()) }
-            .returns(SimResourceCommand.Consume(1.0, 1.0))
+        every { consumer.onNext(any(), any(), any()) }
+            .returns(SimResourceCommand.Consume(1.0))
             .andThenThrows(IllegalStateException())
 
         launch { provider.consume(consumer) }
@@ -228,8 +226,8 @@ class SimResourceSourceTest {
         val provider = SimResourceSource(capacity, scheduler)
 
         val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
-        every { consumer.onNext(any()) }
-            .returns(SimResourceCommand.Idle(clock.millis() + 500))
+        every { consumer.onNext(any(), any(), any()) }
+            .returns(SimResourceCommand.Consume(0.0, 500))
             .andThen(SimResourceCommand.Exit)
 
         provider.consume(consumer)
@@ -246,28 +244,12 @@ class SimResourceSourceTest {
                 val provider = SimResourceSource(capacity, scheduler)
 
                 val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
-                every { consumer.onNext(any()) }
-                    .returns(SimResourceCommand.Idle())
+                every { consumer.onNext(any(), any(), any()) }
+                    .returns(SimResourceCommand.Consume(0.0))
                     .andThenThrows(IllegalStateException())
 
                 provider.consume(consumer)
             }
         }
     }
-
-    @Test
-    fun testIncorrectDeadline() = runBlockingSimulation {
-        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
-        val capacity = 4200.0
-        val provider = SimResourceSource(capacity, scheduler)
-
-        val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
-        every { consumer.onNext(any()) }
-            .returns(SimResourceCommand.Idle(2))
-            .andThen(SimResourceCommand.Exit)
-
-        delay(10)
-
-        assertThrows<IllegalArgumentException> { provider.consume(consumer) }
-    }
 }
diff --git a/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceSwitchExclusiveTest.kt b/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceSwitchExclusiveTest.kt
index ad8d82e3..ad3b0f9f 100644
--- a/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceSwitchExclusiveTest.kt
+++ b/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceSwitchExclusiveTest.kt
@@ -24,7 +24,6 @@ package org.opendc.simulator.resources
 
 import io.mockk.every
 import io.mockk.mockk
-import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.yield
 import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.Test
@@ -38,7 +37,6 @@ import org.opendc.simulator.resources.impl.SimResourceInterpreterImpl
 /**
  * Test suite for the [SimResourceSwitchExclusive] class.
  */
-@OptIn(ExperimentalCoroutinesApi::class)
 internal class SimResourceSwitchExclusiveTest {
     /**
      * Test a trace workload.
@@ -91,7 +89,7 @@ internal class SimResourceSwitchExclusiveTest {
 
         val duration = 5 * 60L * 1000
         val workload = mockk<SimResourceConsumer>(relaxUnitFun = true)
-        every { workload.onNext(any()) } returns SimResourceCommand.Consume(duration / 1000.0, 1.0) andThen SimResourceCommand.Exit
+        every { workload.onNext(any(), any(), any()) } returns SimResourceCommand.Consume(1.0, duration = duration) andThen SimResourceCommand.Exit
 
         val switch = SimResourceSwitchExclusive()
         val source = SimResourceSource(3200.0, scheduler)
@@ -127,10 +125,10 @@ internal class SimResourceSwitchExclusiveTest {
                 }
             }
 
-            override fun onNext(ctx: SimResourceContext): SimResourceCommand {
+            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): SimResourceCommand {
                 return if (isFirst) {
                     isFirst = false
-                    SimResourceCommand.Consume(duration / 1000.0, 1.0)
+                    SimResourceCommand.Consume(1.0, duration = duration)
                 } else {
                     SimResourceCommand.Exit
                 }
@@ -161,9 +159,8 @@ internal class SimResourceSwitchExclusiveTest {
     fun testConcurrentWorkloadFails() = runBlockingSimulation {
         val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
 
-        val duration = 5 * 60L * 1000
         val workload = mockk<SimResourceConsumer>(relaxUnitFun = true)
-        every { workload.onNext(any()) } returns SimResourceCommand.Consume(duration / 1000.0, 1.0) andThen SimResourceCommand.Exit
+        every { workload.onNext(any(), any(), any()) } returns SimResourceCommand.Consume(1.0) andThen SimResourceCommand.Exit
 
         val switch = SimResourceSwitchExclusive()
         val source = SimResourceSource(3200.0, scheduler)
diff --git a/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceSwitchMaxMinTest.kt b/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceSwitchMaxMinTest.kt
index e4292ec0..d8f18e65 100644
--- a/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceSwitchMaxMinTest.kt
+++ b/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceSwitchMaxMinTest.kt
@@ -24,7 +24,6 @@ package org.opendc.simulator.resources
 
 import io.mockk.every
 import io.mockk.mockk
-import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.coroutineScope
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.yield
@@ -37,7 +36,6 @@ import org.opendc.simulator.resources.impl.SimResourceInterpreterImpl
 /**
  * Test suite for the [SimResourceSwitch] implementations
  */
-@OptIn(ExperimentalCoroutinesApi::class)
 internal class SimResourceSwitchMaxMinTest {
     @Test
     fun testSmoke() = runBlockingSimulation {
@@ -50,7 +48,7 @@ internal class SimResourceSwitchMaxMinTest {
         val provider = switch.newOutput()
 
         val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
-        every { consumer.onNext(any()) } returns SimResourceCommand.Consume(1.0, 1.0) andThen SimResourceCommand.Exit
+        every { consumer.onNext(any(), any(), any()) } returns SimResourceCommand.Consume(1.0, duration = 1000) andThen SimResourceCommand.Exit
 
         try {
             provider.consume(consumer)
diff --git a/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceTransformerTest.kt b/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceTransformerTest.kt
index cf69b7b5..3780fd60 100644
--- a/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceTransformerTest.kt
+++ b/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceTransformerTest.kt
@@ -37,7 +37,6 @@ import org.opendc.simulator.resources.impl.SimResourceInterpreterImpl
 /**
  * A test suite for the [SimResourceTransformer] class.
  */
-@OptIn(ExperimentalCoroutinesApi::class)
 internal class SimResourceTransformerTest {
     @Test
     fun testCancelImmediately() = runBlockingSimulation {
@@ -48,7 +47,7 @@ internal class SimResourceTransformerTest {
         launch { source.consume(forwarder) }
 
         forwarder.consume(object : SimResourceConsumer {
-            override fun onNext(ctx: SimResourceContext): SimResourceCommand {
+            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): SimResourceCommand {
                 return SimResourceCommand.Exit
             }
         })
@@ -68,10 +67,10 @@ internal class SimResourceTransformerTest {
         forwarder.consume(object : SimResourceConsumer {
             var isFirst = true
 
-            override fun onNext(ctx: SimResourceContext): SimResourceCommand {
+            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): SimResourceCommand {
                 return if (isFirst) {
                     isFirst = false
-                    SimResourceCommand.Consume(10.0, 1.0)
+                    SimResourceCommand.Consume(1.0, duration = 10 * 1000L)
                 } else {
                     SimResourceCommand.Exit
                 }
@@ -86,7 +85,7 @@ internal class SimResourceTransformerTest {
     fun testState() = runBlockingSimulation {
         val forwarder = SimResourceForwarder()
         val consumer = object : SimResourceConsumer {
-            override fun onNext(ctx: SimResourceContext): SimResourceCommand = SimResourceCommand.Exit
+            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): SimResourceCommand = SimResourceCommand.Exit
         }
 
         assertFalse(forwarder.isActive)
@@ -108,7 +107,7 @@ internal class SimResourceTransformerTest {
         val forwarder = SimResourceForwarder()
 
         val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
-        every { consumer.onNext(any()) } returns SimResourceCommand.Exit
+        every { consumer.onNext(any(), any(), any()) } returns SimResourceCommand.Exit
 
         forwarder.startConsumer(consumer)
         forwarder.cancel()
@@ -123,7 +122,7 @@ internal class SimResourceTransformerTest {
         val source = SimResourceSource(2000.0, scheduler)
 
         val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
-        every { consumer.onNext(any()) } returns SimResourceCommand.Idle(10)
+        every { consumer.onNext(any(), any(), any()) } returns SimResourceCommand.Consume(0.0, 10)
 
         source.startConsumer(forwarder)
         yield()
@@ -142,7 +141,7 @@ internal class SimResourceTransformerTest {
         val source = SimResourceSource(2000.0, scheduler)
 
         val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
-        every { consumer.onNext(any()) } returns SimResourceCommand.Idle(10)
+        every { consumer.onNext(any(), any(), any()) } returns SimResourceCommand.Consume(0.0, 10)
 
         source.startConsumer(forwarder)
         yield()
@@ -161,7 +160,7 @@ internal class SimResourceTransformerTest {
         val source = SimResourceSource(2000.0, scheduler)
 
         val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
-        every { consumer.onNext(any()) } returns SimResourceCommand.Exit
+        every { consumer.onNext(any(), any(), any()) } returns SimResourceCommand.Exit
 
         source.startConsumer(forwarder)
         forwarder.consume(consumer)
@@ -200,7 +199,7 @@ internal class SimResourceTransformerTest {
         forwarder.consume(consumer)
 
         assertEquals(0, clock.millis())
-        verify(exactly = 1) { consumer.onNext(any()) }
+        verify(exactly = 1) { consumer.onNext(any(), any(), any()) }
     }
 
     @Test
diff --git a/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimWorkConsumerTest.kt b/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimWorkConsumerTest.kt
index 42648cf1..830f16d3 100644
--- a/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimWorkConsumerTest.kt
+++ b/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimWorkConsumerTest.kt
@@ -22,7 +22,6 @@
 
 package org.opendc.simulator.resources
 
-import kotlinx.coroutines.ExperimentalCoroutinesApi
 import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.Test
 import org.opendc.simulator.core.runBlockingSimulation
@@ -32,7 +31,6 @@ import org.opendc.simulator.resources.impl.SimResourceInterpreterImpl
 /**
  * A test suite for the [SimWorkConsumer] class.
  */
-@OptIn(ExperimentalCoroutinesApi::class)
 internal class SimWorkConsumerTest {
     @Test
     fun testSmoke() = runBlockingSimulation {
-- 
cgit v1.2.3


From 02fa44c0b116ff51c4cbe2876d8b2a225ed68553 Mon Sep 17 00:00:00 2001
From: Fabian Mastenbroek <mail.fabianm@gmail.com>
Date: Tue, 28 Sep 2021 11:58:19 +0200
Subject: refactor(simulator): Add support for pushing flow from context

This change adds a new method to `SimResourceContext` called `push`
which allows users to change the requested flow rate directly without
having to interrupt the consumer.
---
 .../resources/SimAbstractResourceAggregator.kt     |  53 ++++++---
 .../resources/SimResourceAggregatorMaxMin.kt       |   8 +-
 .../simulator/resources/SimResourceCommand.kt      |  46 --------
 .../simulator/resources/SimResourceConsumer.kt     |   7 +-
 .../simulator/resources/SimResourceContext.kt      |  14 ++-
 .../resources/SimResourceControllableContext.kt    |   7 +-
 .../resources/SimResourceDistributorMaxMin.kt      |  18 +--
 .../simulator/resources/SimResourceTransformer.kt  | 109 +++++++++++-------
 .../resources/consumer/SimSpeedConsumerAdapter.kt  |   3 +-
 .../resources/consumer/SimTraceConsumer.kt         |   9 +-
 .../resources/consumer/SimWorkConsumer.kt          |  11 +-
 .../resources/impl/SimResourceContextImpl.kt       | 123 +++++++++------------
 .../resources/SimResourceAggregatorMaxMinTest.kt   |  55 ++++-----
 .../simulator/resources/SimResourceCommandTest.kt  |  53 ---------
 .../simulator/resources/SimResourceContextTest.kt  |  90 ++++++++++++---
 .../simulator/resources/SimResourceSourceTest.kt   |  73 +++++-------
 .../resources/SimResourceSwitchExclusiveTest.kt    |  17 ++-
 .../resources/SimResourceSwitchMaxMinTest.kt       |   7 +-
 .../resources/SimResourceTransformerTest.kt        |  44 +++++---
 19 files changed, 356 insertions(+), 391 deletions(-)
 delete mode 100644 opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceCommand.kt
 delete mode 100644 opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceCommandTest.kt

(limited to 'opendc-simulator/opendc-simulator-resources')

diff --git a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimAbstractResourceAggregator.kt b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimAbstractResourceAggregator.kt
index da5c3257..8e0eb5f8 100644
--- a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimAbstractResourceAggregator.kt
+++ b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimAbstractResourceAggregator.kt
@@ -125,16 +125,21 @@ public abstract class SimAbstractResourceAggregator(
     /**
      * An input for the resource aggregator.
      */
-    public interface Input {
+    public interface Input : AutoCloseable {
         /**
          * The [SimResourceContext] associated with the input.
          */
         public val ctx: SimResourceContext
 
         /**
-         * Push the specified [SimResourceCommand] to the input.
+         * Push to this input with the specified [limit] and [duration].
          */
-        public fun push(command: SimResourceCommand)
+        public fun push(limit: Double, duration: Long)
+
+        /**
+         * Close the input for further input.
+         */
+        public override fun close()
     }
 
     /**
@@ -151,7 +156,12 @@ public abstract class SimAbstractResourceAggregator(
         /**
          * The resource command to run next.
          */
-        private var command: SimResourceCommand? = null
+        private var _duration: Long = Long.MAX_VALUE
+
+        /**
+         * A flag to indicate that the consumer should flush.
+         */
+        private var _isPushed = false
 
         private fun updateCapacity() {
             // Adjust capacity of output resource
@@ -159,25 +169,34 @@ public abstract class SimAbstractResourceAggregator(
         }
 
         /* Input */
-        override fun push(command: SimResourceCommand) {
-            this.command = command
-            _ctx?.interrupt()
+        override fun push(limit: Double, duration: Long) {
+            _duration = duration
+            val ctx = _ctx
+            if (ctx != null) {
+                ctx.push(limit)
+                ctx.interrupt()
+            }
+            _isPushed = true
+        }
+
+        override fun close() {
+            _duration = Long.MAX_VALUE
+            _isPushed = true
+            _ctx?.close()
         }
 
         /* SimResourceConsumer */
-        override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): SimResourceCommand {
-            var next = command
+        override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
+            var next = _duration
 
-            return if (next != null) {
-                this.command = null
-                next
-            } else {
+            if (!_isPushed) {
                 _output.flush()
-
-                next = command
-                this.command = null
-                next ?: SimResourceCommand.Consume(0.0)
+                next = _duration
             }
+
+            _isPushed = false
+            _duration = Long.MAX_VALUE
+            return next
         }
 
         override fun onEvent(ctx: SimResourceContext, event: SimResourceEvent) {
diff --git a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceAggregatorMaxMin.kt b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceAggregatorMaxMin.kt
index 537be1b5..b258a368 100644
--- a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceAggregatorMaxMin.kt
+++ b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceAggregatorMaxMin.kt
@@ -41,11 +41,7 @@ public class SimResourceAggregatorMaxMin(
             val fraction = inputCapacity / capacity
             val grantedSpeed = limit * fraction
 
-            val command = if (grantedSpeed > 0.0)
-                SimResourceCommand.Consume(grantedSpeed, duration)
-            else
-                SimResourceCommand.Consume(0.0, duration)
-            input.push(command)
+            input.push(grantedSpeed, duration)
         }
     }
 
@@ -53,7 +49,7 @@ public class SimResourceAggregatorMaxMin(
         val iterator = consumers.iterator()
         for (input in iterator) {
             iterator.remove()
-            input.push(SimResourceCommand.Exit)
+            input.close()
         }
     }
 
diff --git a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceCommand.kt b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceCommand.kt
deleted file mode 100644
index 4a980071..00000000
--- a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceCommand.kt
+++ /dev/null
@@ -1,46 +0,0 @@
-/*
- * Copyright (c) 2021 AtLarge Research
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-package org.opendc.simulator.resources
-
-/**
- * A SimResourceCommand communicates to a resource how it is consumed by a [SimResourceConsumer].
- */
-public sealed class SimResourceCommand {
-    /**
-     * A request to the resource to perform work for the specified [duration].
-     *
-     * @param limit The maximum amount of work to be processed per second.
-     * @param duration The duration of the resource consumption in milliseconds.
-     */
-    public data class Consume(val limit: Double, val duration: Long = Long.MAX_VALUE) : SimResourceCommand() {
-        init {
-            require(limit >= 0.0) { "Negative limit is not allowed" }
-            require(duration >= 0) { "Duration must be positive" }
-        }
-    }
-
-    /**
-     * An indication to the resource that the consumer has finished.
-     */
-    public object Exit : SimResourceCommand()
-}
diff --git a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceConsumer.kt b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceConsumer.kt
index 4d1d2c32..0b25358a 100644
--- a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceConsumer.kt
+++ b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceConsumer.kt
@@ -30,15 +30,14 @@ package org.opendc.simulator.resources
  */
 public interface SimResourceConsumer {
     /**
-     * This method is invoked when a resource asks for the next [command][SimResourceCommand] to process, either because
-     * the resource finished processing, reached its deadline or was interrupted.
+     * This method is invoked when the resource provider is pulling this resource consumer.
      *
      * @param ctx The execution context in which the consumer runs.
      * @param now The virtual timestamp in milliseconds at which the update is occurring.
      * @param delta The virtual duration between this call and the last call in milliseconds.
-     * @return The next command that the resource should execute.
+     * @return The duration after which the resource consumer should be pulled again.
      */
-    public fun onNext(ctx: SimResourceContext, now: Long, delta: Long): SimResourceCommand
+    public fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long
 
     /**
      * This method is invoked when an event has occurred.
diff --git a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceContext.kt b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceContext.kt
index f28b43d0..225cae0b 100644
--- a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceContext.kt
+++ b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceContext.kt
@@ -28,7 +28,7 @@ import java.time.Clock
  * The execution context in which a [SimResourceConsumer] runs. It facilitates the communication and control between a
  * resource and a resource consumer.
  */
-public interface SimResourceContext {
+public interface SimResourceContext : AutoCloseable {
     /**
      * The virtual clock tracking simulation time.
      */
@@ -53,4 +53,16 @@ public interface SimResourceContext {
      * Ask the resource provider to interrupt its resource.
      */
     public fun interrupt()
+
+    /**
+     * Push the given flow to this context.
+     *
+     * @param rate The rate of the flow to push.
+     */
+    public fun push(rate: Double)
+
+    /**
+     * Stop the resource context.
+     */
+    public override fun close()
 }
diff --git a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceControllableContext.kt b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceControllableContext.kt
index ceaca39a..ba52b597 100644
--- a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceControllableContext.kt
+++ b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceControllableContext.kt
@@ -27,7 +27,7 @@ package org.opendc.simulator.resources
  *
  * This interface is used by resource providers to control the resource context.
  */
-public interface SimResourceControllableContext : SimResourceContext, AutoCloseable {
+public interface SimResourceControllableContext : SimResourceContext {
     /**
      * The state of the resource context.
      */
@@ -43,11 +43,6 @@ public interface SimResourceControllableContext : SimResourceContext, AutoClosea
      */
     public fun start()
 
-    /**
-     * Stop the resource context.
-     */
-    public override fun close()
-
     /**
      * Invalidate the resource context's state.
      *
diff --git a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceDistributorMaxMin.kt b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceDistributorMaxMin.kt
index d23c7dbb..eac58410 100644
--- a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceDistributorMaxMin.kt
+++ b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceDistributorMaxMin.kt
@@ -53,11 +53,6 @@ public class SimResourceDistributorMaxMin(
      */
     private val activeOutputs: MutableList<Output> = mutableListOf()
 
-    /**
-     * The total amount of work allocated to be executed.
-     */
-    private var totalAllocatedWork = 0.0
-
     /**
      * The total allocated speed for the output resources.
      */
@@ -97,7 +92,7 @@ public class SimResourceDistributorMaxMin(
     }
 
     /* SimResourceConsumer */
-    override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): SimResourceCommand {
+    override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
         return doNext(ctx, now)
     }
 
@@ -137,10 +132,10 @@ public class SimResourceDistributorMaxMin(
     /**
      * Schedule the work of the outputs.
      */
-    private fun doNext(ctx: SimResourceContext, now: Long): SimResourceCommand {
+    private fun doNext(ctx: SimResourceContext, now: Long): Long {
         // If there is no work yet, mark the input as idle.
         if (activeOutputs.isEmpty()) {
-            return SimResourceCommand.Consume(0.0)
+            return Long.MAX_VALUE
         }
 
         val capacity = ctx.capacity
@@ -196,14 +191,11 @@ public class SimResourceDistributorMaxMin(
         }
 
         this.totalRequestedSpeed = totalRequestedSpeed
-        this.totalAllocatedWork = totalAllocatedWork
         val totalAllocatedSpeed = capacity - availableSpeed
         this.totalAllocatedSpeed = totalAllocatedSpeed
 
-        return if (totalAllocatedWork > 0.0 && totalAllocatedSpeed > 0.0)
-            SimResourceCommand.Consume(totalAllocatedSpeed, duration)
-        else
-            SimResourceCommand.Consume(0.0, duration)
+        ctx.push(totalAllocatedSpeed)
+        return duration
     }
 
     private fun updateCapacity(ctx: SimResourceContext) {
diff --git a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceTransformer.kt b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceTransformer.kt
index 68bedbd9..f12ef9f1 100644
--- a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceTransformer.kt
+++ b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceTransformer.kt
@@ -23,6 +23,7 @@
 package org.opendc.simulator.resources
 
 import org.opendc.simulator.resources.impl.SimResourceCountersImpl
+import java.time.Clock
 
 /**
  * A [SimResourceFlow] that transforms the resource commands emitted by the resource commands to the resource provider.
@@ -32,13 +33,8 @@ import org.opendc.simulator.resources.impl.SimResourceCountersImpl
  */
 public class SimResourceTransformer(
     private val isCoupled: Boolean = false,
-    private val transform: (SimResourceContext, SimResourceCommand) -> SimResourceCommand
+    private val transform: (SimResourceContext, Long) -> Long
 ) : SimResourceFlow, AutoCloseable {
-    /**
-     * The [SimResourceContext] in which the forwarder runs.
-     */
-    private var ctx: SimResourceContext? = null
-
     /**
      * The delegate [SimResourceConsumer].
      */
@@ -49,17 +45,63 @@ public class SimResourceTransformer(
      */
     private var hasDelegateStarted: Boolean = false
 
+    /**
+     * The exposed [SimResourceContext].
+     */
+    private val ctx = object : SimResourceContext {
+        override val clock: Clock
+            get() = _ctx!!.clock
+
+        override val capacity: Double
+            get() = _ctx?.capacity ?: 0.0
+
+        override val demand: Double
+            get() = _ctx?.demand ?: 0.0
+
+        override val speed: Double
+            get() = _ctx?.speed ?: 0.0
+
+        override fun interrupt() {
+            _ctx?.interrupt()
+        }
+
+        override fun push(rate: Double) {
+            _ctx?.push(rate)
+            _limit = rate
+        }
+
+        override fun close() {
+            val delegate = checkNotNull(delegate) { "Delegate not active" }
+
+            // Warning: resumption of the continuation might change the entire state of the forwarder. Make sure we
+            // reset beforehand the existing state and check whether it has been updated afterwards
+            reset()
+
+            delegate.onEvent(this, SimResourceEvent.Exit)
+
+            if (isCoupled)
+                _ctx?.close()
+            else
+                _ctx?.push(0.0)
+        }
+    }
+
+    /**
+     * The [SimResourceContext] in which the forwarder runs.
+     */
+    private var _ctx: SimResourceContext? = null
+
     override val isActive: Boolean
         get() = delegate != null
 
     override val capacity: Double
-        get() = ctx?.capacity ?: 0.0
+        get() = ctx.capacity
 
     override val speed: Double
-        get() = ctx?.speed ?: 0.0
+        get() = ctx.speed
 
     override val demand: Double
-        get() = ctx?.demand ?: 0.0
+        get() = ctx.demand
 
     override val counters: SimResourceCounters
         get() = _counters
@@ -75,32 +117,32 @@ public class SimResourceTransformer(
     }
 
     override fun interrupt() {
-        ctx?.interrupt()
+        ctx.interrupt()
     }
 
     override fun cancel() {
         val delegate = delegate
-        val ctx = ctx
+        val ctx = _ctx
 
         if (delegate != null) {
             this.delegate = null
 
             if (ctx != null) {
-                delegate.onEvent(ctx, SimResourceEvent.Exit)
+                delegate.onEvent(this.ctx, SimResourceEvent.Exit)
             }
         }
     }
 
     override fun close() {
-        val ctx = ctx
+        val ctx = _ctx
 
         if (ctx != null) {
-            this.ctx = null
+            this._ctx = null
             ctx.interrupt()
         }
     }
 
-    override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): SimResourceCommand {
+    override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
         val delegate = delegate
 
         if (!hasDelegateStarted) {
@@ -110,54 +152,39 @@ public class SimResourceTransformer(
         updateCounters(ctx, delta)
 
         return if (delegate != null) {
-            val command = transform(ctx, delegate.onNext(ctx, now, delta))
-
-            _limit = if (command is SimResourceCommand.Consume) command.limit else 0.0
-
-            if (command == SimResourceCommand.Exit) {
-                // Warning: resumption of the continuation might change the entire state of the forwarder. Make sure we
-                // reset beforehand the existing state and check whether it has been updated afterwards
-                reset()
-
-                delegate.onEvent(ctx, SimResourceEvent.Exit)
-
-                if (isCoupled)
-                    SimResourceCommand.Exit
-                else
-                    onNext(ctx, now, delta)
-            } else {
-                command
-            }
+            val duration = transform(ctx, delegate.onNext(this.ctx, now, delta))
+            _limit = ctx.demand
+            duration
         } else {
-            SimResourceCommand.Consume(0.0)
+            Long.MAX_VALUE
         }
     }
 
     override fun onEvent(ctx: SimResourceContext, event: SimResourceEvent) {
         when (event) {
             SimResourceEvent.Start -> {
-                this.ctx = ctx
+                _ctx = ctx
             }
             SimResourceEvent.Exit -> {
-                this.ctx = null
+                _ctx = null
 
                 val delegate = delegate
                 if (delegate != null) {
                     reset()
-                    delegate.onEvent(ctx, SimResourceEvent.Exit)
+                    delegate.onEvent(this.ctx, SimResourceEvent.Exit)
                 }
             }
-            else -> delegate?.onEvent(ctx, event)
+            else -> delegate?.onEvent(this.ctx, event)
         }
     }
 
     override fun onFailure(ctx: SimResourceContext, cause: Throwable) {
-        this.ctx = null
+        _ctx = null
 
         val delegate = delegate
         if (delegate != null) {
             reset()
-            delegate.onFailure(ctx, cause)
+            delegate.onFailure(this.ctx, cause)
         }
     }
 
@@ -166,7 +193,7 @@ public class SimResourceTransformer(
      */
     private fun start() {
         val delegate = delegate ?: return
-        delegate.onEvent(checkNotNull(ctx), SimResourceEvent.Start)
+        delegate.onEvent(checkNotNull(_ctx), SimResourceEvent.Start)
 
         hasDelegateStarted = true
     }
diff --git a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/consumer/SimSpeedConsumerAdapter.kt b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/consumer/SimSpeedConsumerAdapter.kt
index 1f8434b7..46885640 100644
--- a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/consumer/SimSpeedConsumerAdapter.kt
+++ b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/consumer/SimSpeedConsumerAdapter.kt
@@ -22,7 +22,6 @@
 
 package org.opendc.simulator.resources.consumer
 
-import org.opendc.simulator.resources.SimResourceCommand
 import org.opendc.simulator.resources.SimResourceConsumer
 import org.opendc.simulator.resources.SimResourceContext
 import org.opendc.simulator.resources.SimResourceEvent
@@ -50,7 +49,7 @@ public class SimSpeedConsumerAdapter(
         callback(0.0)
     }
 
-    override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): SimResourceCommand {
+    override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
         return delegate.onNext(ctx, now, delta)
     }
 
diff --git a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/consumer/SimTraceConsumer.kt b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/consumer/SimTraceConsumer.kt
index e5173e5f..ad6b0108 100644
--- a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/consumer/SimTraceConsumer.kt
+++ b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/consumer/SimTraceConsumer.kt
@@ -22,7 +22,6 @@
 
 package org.opendc.simulator.resources.consumer
 
-import org.opendc.simulator.resources.SimResourceCommand
 import org.opendc.simulator.resources.SimResourceConsumer
 import org.opendc.simulator.resources.SimResourceContext
 import org.opendc.simulator.resources.SimResourceEvent
@@ -34,13 +33,15 @@ import org.opendc.simulator.resources.SimResourceEvent
 public class SimTraceConsumer(private val trace: Sequence<Fragment>) : SimResourceConsumer {
     private var iterator: Iterator<Fragment>? = null
 
-    override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): SimResourceCommand {
+    override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
         val iterator = checkNotNull(iterator)
         return if (iterator.hasNext()) {
             val fragment = iterator.next()
-            SimResourceCommand.Consume(fragment.usage, fragment.duration)
+            ctx.push(fragment.usage)
+            fragment.duration
         } else {
-            SimResourceCommand.Exit
+            ctx.close()
+            Long.MAX_VALUE
         }
     }
 
diff --git a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/consumer/SimWorkConsumer.kt b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/consumer/SimWorkConsumer.kt
index ae837043..bf76711f 100644
--- a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/consumer/SimWorkConsumer.kt
+++ b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/consumer/SimWorkConsumer.kt
@@ -22,7 +22,6 @@
 
 package org.opendc.simulator.resources.consumer
 
-import org.opendc.simulator.resources.SimResourceCommand
 import org.opendc.simulator.resources.SimResourceConsumer
 import org.opendc.simulator.resources.SimResourceContext
 import kotlin.math.roundToLong
@@ -37,12 +36,12 @@ public class SimWorkConsumer(
 
     init {
         require(work >= 0.0) { "Work must be positive" }
-        require(utilization > 0.0 && utilization <= 1.0) { "Utilization must be in (0, 1]" }
+        require(utilization > 0.0) { "Utilization must be positive" }
     }
 
     private var remainingWork = work
 
-    override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): SimResourceCommand {
+    override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
         val actualWork = ctx.speed * delta / 1000.0
         val limit = ctx.capacity * utilization
 
@@ -52,9 +51,11 @@ public class SimWorkConsumer(
         val duration = (remainingWork / limit * 1000).roundToLong()
 
         return if (duration > 0) {
-            SimResourceCommand.Consume(limit, duration)
+            ctx.push(limit)
+            duration
         } else {
-            SimResourceCommand.Exit
+            ctx.close()
+            Long.MAX_VALUE
         }
     }
 }
diff --git a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/impl/SimResourceContextImpl.kt b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/impl/SimResourceContextImpl.kt
index a9507e52..d7ea0043 100644
--- a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/impl/SimResourceContextImpl.kt
+++ b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/impl/SimResourceContextImpl.kt
@@ -85,6 +85,11 @@ internal class SimResourceContextImpl(
     private var _duration: Long = Long.MAX_VALUE
     private var _deadline: Long = Long.MAX_VALUE
 
+    /**
+     * A flag to indicate that an update is active.
+     */
+    private var _updateActive = false
+
     /**
      * The update flag indicating why the update was triggered.
      */
@@ -108,7 +113,9 @@ internal class SimResourceContextImpl(
         if (_state != SimResourceState.Stopped) {
             interpreter.batch {
                 _state = SimResourceState.Stopped
-                doStop()
+                if (!_updateActive) {
+                    doStop()
+                }
             }
         }
     }
@@ -139,6 +146,11 @@ internal class SimResourceContextImpl(
         interpreter.scheduleSync(this)
     }
 
+    override fun push(rate: Double) {
+        _speed = min(capacity, rate)
+        _limit = rate
+    }
+
     /**
      * Determine whether the state of the resource context should be updated.
      */
@@ -151,14 +163,49 @@ internal class SimResourceContextImpl(
      * Update the state of the resource context.
      */
     fun doUpdate(timestamp: Long) {
+        val oldState = _state
+        if (oldState != SimResourceState.Active) {
+            return
+        }
+
+        _updateActive = true
+
+        val flag = _flag
+        val isInterrupted = flag and FLAG_INTERRUPT != 0
+        val reachedDeadline = _deadline <= timestamp
+        val delta = max(0, timestamp - _timestamp)
+
         try {
-            val oldState = _state
-            val newState = doUpdate(timestamp, oldState)
 
-            _state = newState
+            // Update the resource counters only if there is some progress
+            if (timestamp > _timestamp) {
+                logic.onUpdate(this, delta, _limit, reachedDeadline)
+            }
+
+            // We should only continue processing the next command if:
+            // 1. The resource consumption was finished.
+            // 2. The resource consumer should be interrupted (e.g., someone called .interrupt())
+            val duration = if (reachedDeadline || isInterrupted) {
+                consumer.onNext(this, timestamp, delta)
+            } else {
+                _deadline - timestamp
+            }
+
+            // Reset update flags
             _flag = 0
 
-            when (newState) {
+            when (_state) {
+                SimResourceState.Active -> {
+                    val limit = _limit
+                    push(limit)
+                    _duration = duration
+
+                    val target = logic.onConsume(this, timestamp, limit, duration)
+
+                    _deadline = target
+
+                    scheduleUpdate(target)
+                }
                 SimResourceState.Pending ->
                     if (oldState != SimResourceState.Pending) {
                         throw IllegalStateException("Illegal transition to pending state")
@@ -167,12 +214,12 @@ internal class SimResourceContextImpl(
                     if (oldState != SimResourceState.Stopped) {
                         doStop()
                     }
-                else -> {}
             }
         } catch (cause: Throwable) {
             doFail(cause)
         } finally {
             _timestamp = timestamp
+            _updateActive = false
         }
     }
 
@@ -184,39 +231,6 @@ internal class SimResourceContextImpl(
 
     override fun toString(): String = "SimResourceContextImpl[capacity=$capacity]"
 
-    /**
-     * Update the state of the resource context.
-     */
-    private fun doUpdate(timestamp: Long, state: SimResourceState): SimResourceState {
-        return when (state) {
-            // Resource context is not active, so its state will not update
-            SimResourceState.Pending, SimResourceState.Stopped -> state
-            SimResourceState.Active -> {
-                val isInterrupted = _flag and FLAG_INTERRUPT != 0
-                val reachedDeadline = _deadline <= timestamp
-                val delta = max(0, timestamp - _timestamp)
-
-                // Update the resource counters only if there is some progress
-                if (timestamp > _timestamp) {
-                    logic.onUpdate(this, delta, _limit, reachedDeadline)
-                }
-
-                // We should only continue processing the next command if:
-                // 1. The resource consumption was finished.
-                // 2. The resource capacity cannot satisfy the demand.
-                // 3. The resource consumer should be interrupted (e.g., someone called .interrupt())
-                if (reachedDeadline || isInterrupted) {
-                    when (val command = consumer.onNext(this, timestamp, delta)) {
-                        is SimResourceCommand.Consume -> interpretConsume(timestamp, command.limit, command.duration)
-                        is SimResourceCommand.Exit -> interpretExit()
-                    }
-                } else {
-                    interpretConsume(timestamp, _limit, _duration - delta)
-                }
-            }
-        }
-    }
-
     /**
      * Stop the resource context.
      */
@@ -226,6 +240,8 @@ internal class SimResourceContextImpl(
             logic.onFinish(this)
         } catch (cause: Throwable) {
             doFail(cause)
+        } finally {
+            _deadline = Long.MAX_VALUE
         }
     }
 
@@ -243,35 +259,6 @@ internal class SimResourceContextImpl(
         logic.onFinish(this)
     }
 
-    /**
-     * Interpret the [SimResourceCommand.Consume] command.
-     */
-    private fun interpretConsume(now: Long, limit: Double, duration: Long): SimResourceState {
-        _speed = min(capacity, limit)
-        _limit = limit
-        _duration = duration
-
-        val timestamp = logic.onConsume(this, now, limit, duration)
-
-        _deadline = timestamp
-
-        scheduleUpdate(timestamp)
-
-        return SimResourceState.Active
-    }
-
-    /**
-     * Interpret the [SimResourceCommand.Exit] command.
-     */
-    private fun interpretExit(): SimResourceState {
-        _speed = 0.0
-        _limit = 0.0
-        _duration = Long.MAX_VALUE
-        _deadline = Long.MAX_VALUE
-
-        return SimResourceState.Stopped
-    }
-
     /**
      * Indicate that the capacity of the resource has changed.
      */
diff --git a/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceAggregatorMaxMinTest.kt b/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceAggregatorMaxMinTest.kt
index a9390553..f4ea5fe8 100644
--- a/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceAggregatorMaxMinTest.kt
+++ b/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceAggregatorMaxMinTest.kt
@@ -22,14 +22,12 @@
 
 package org.opendc.simulator.resources
 
-import io.mockk.every
-import io.mockk.mockk
+import io.mockk.spyk
 import io.mockk.verify
 import kotlinx.coroutines.*
 import org.junit.jupiter.api.Assertions.*
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.assertAll
-import org.junit.jupiter.api.assertThrows
 import org.opendc.simulator.core.runBlockingSimulation
 import org.opendc.simulator.resources.consumer.SimSpeedConsumerAdapter
 import org.opendc.simulator.resources.consumer.SimWorkConsumer
@@ -100,10 +98,17 @@ internal class SimResourceAggregatorMaxMinTest {
         )
         sources.forEach(aggregator::addInput)
 
-        val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
-        every { consumer.onNext(any(), any(), any()) }
-            .returns(SimResourceCommand.Consume(4.0, 1000))
-            .andThen(SimResourceCommand.Exit)
+        val consumer = spyk(object : SimResourceConsumer {
+            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
+                return if (now == 0L) {
+                    ctx.push(4.0)
+                    1000
+                } else {
+                    ctx.close()
+                    Long.MAX_VALUE
+                }
+            }
+        })
 
         aggregator.consume(consumer)
         yield()
@@ -112,27 +117,6 @@ internal class SimResourceAggregatorMaxMinTest {
         verify(exactly = 2) { consumer.onNext(any(), any(), any()) }
     }
 
-    @Test
-    fun testException() = runBlockingSimulation {
-        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
-
-        val aggregator = SimResourceAggregatorMaxMin(scheduler)
-        val sources = listOf(
-            SimResourceSource(1.0, scheduler),
-            SimResourceSource(1.0, scheduler)
-        )
-        sources.forEach(aggregator::addInput)
-
-        val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
-        every { consumer.onNext(any(), any(), any()) }
-            .returns(SimResourceCommand.Consume(1.0, duration = 1000))
-            .andThenThrows(IllegalStateException("Test Exception"))
-
-        assertThrows<IllegalStateException> { aggregator.consume(consumer) }
-        yield()
-        assertFalse(sources[0].isActive)
-    }
-
     @Test
     fun testAdjustCapacity() = runBlockingSimulation {
         val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
@@ -186,10 +170,17 @@ internal class SimResourceAggregatorMaxMinTest {
         )
         sources.forEach(aggregator::addInput)
 
-        val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
-        every { consumer.onNext(any(), any(), any()) }
-            .returns(SimResourceCommand.Consume(4.0, 1000))
-            .andThen(SimResourceCommand.Exit)
+        val consumer = object : SimResourceConsumer {
+            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
+                return if (now == 0L) {
+                    ctx.push(4.0)
+                    1000
+                } else {
+                    ctx.close()
+                    Long.MAX_VALUE
+                }
+            }
+        }
 
         aggregator.consume(consumer)
         yield()
diff --git a/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceCommandTest.kt b/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceCommandTest.kt
deleted file mode 100644
index 9a52dc63..00000000
--- a/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceCommandTest.kt
+++ /dev/null
@@ -1,53 +0,0 @@
-/*
- * Copyright (c) 2021 AtLarge Research
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-package org.opendc.simulator.resources
-
-import org.junit.jupiter.api.Test
-import org.junit.jupiter.api.assertDoesNotThrow
-import org.junit.jupiter.api.assertThrows
-
-/**
- * Test suite for [SimResourceCommand].
- */
-class SimResourceCommandTest {
-    @Test
-    fun testNegativeLimit() {
-        assertThrows<IllegalArgumentException> {
-            SimResourceCommand.Consume(-1.0, 1)
-        }
-    }
-
-    @Test
-    fun testNegativeDuration() {
-        assertThrows<IllegalArgumentException> {
-            SimResourceCommand.Consume(1.0, -1)
-        }
-    }
-
-    @Test
-    fun testConsumeCorrect() {
-        assertDoesNotThrow {
-            SimResourceCommand.Consume(1.0)
-        }
-    }
-}
diff --git a/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceContextTest.kt b/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceContextTest.kt
index 0cb95abb..4e57f598 100644
--- a/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceContextTest.kt
+++ b/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceContextTest.kt
@@ -36,8 +36,17 @@ class SimResourceContextTest {
     @Test
     fun testFlushWithoutCommand() = runBlockingSimulation {
         val interpreter = SimResourceInterpreterImpl(coroutineContext, clock)
-        val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
-        every { consumer.onNext(any(), any(), any()) } returns SimResourceCommand.Consume(1.0) andThen SimResourceCommand.Exit
+        val consumer = object : SimResourceConsumer {
+            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
+                return if (now == 0L) {
+                    ctx.push(1.0)
+                    1000
+                } else {
+                    ctx.close()
+                    Long.MAX_VALUE
+                }
+            }
+        }
 
         val logic = object : SimResourceProviderLogic {}
         val context = SimResourceContextImpl(null, interpreter, consumer, logic)
@@ -48,14 +57,23 @@ class SimResourceContextTest {
     @Test
     fun testIntermediateFlush() = runBlockingSimulation {
         val interpreter = SimResourceInterpreterImpl(coroutineContext, clock)
-        val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
-        every { consumer.onNext(any(), any(), any()) } returns SimResourceCommand.Consume(1.0) andThen SimResourceCommand.Exit
+        val consumer = object : SimResourceConsumer {
+            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
+                return if (now == 0L) {
+                    ctx.push(4.0)
+                    1000
+                } else {
+                    ctx.close()
+                    Long.MAX_VALUE
+                }
+            }
+        }
 
         val logic = spyk(object : SimResourceProviderLogic {
             override fun onFinish(ctx: SimResourceControllableContext) {}
             override fun onConsume(ctx: SimResourceControllableContext, now: Long, limit: Double, duration: Long): Long = duration
         })
-        val context = spyk(SimResourceContextImpl(null, interpreter, consumer, logic))
+        val context = SimResourceContextImpl(null, interpreter, consumer, logic)
 
         context.start()
         delay(1) // Delay 1 ms to prevent hitting the fast path
@@ -67,11 +85,20 @@ class SimResourceContextTest {
     @Test
     fun testIntermediateFlushIdle() = runBlockingSimulation {
         val interpreter = SimResourceInterpreterImpl(coroutineContext, clock)
-        val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
-        every { consumer.onNext(any(), any(), any()) } returns SimResourceCommand.Consume(0.0, 10) andThen SimResourceCommand.Exit
+        val consumer = object : SimResourceConsumer {
+            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
+                return if (now == 0L) {
+                    ctx.push(0.0)
+                    10
+                } else {
+                    ctx.close()
+                    Long.MAX_VALUE
+                }
+            }
+        }
 
         val logic = spyk(object : SimResourceProviderLogic {})
-        val context = spyk(SimResourceContextImpl(null, interpreter, consumer, logic))
+        val context = SimResourceContextImpl(null, interpreter, consumer, logic)
 
         context.start()
         delay(5)
@@ -88,8 +115,17 @@ class SimResourceContextTest {
     @Test
     fun testDoubleStart() = runBlockingSimulation {
         val interpreter = SimResourceInterpreterImpl(coroutineContext, clock)
-        val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
-        every { consumer.onNext(any(), any(), any()) } returns SimResourceCommand.Consume(0.0, 10) andThen SimResourceCommand.Exit
+        val consumer = object : SimResourceConsumer {
+            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
+                return if (now == 0L) {
+                    ctx.push(0.0)
+                    1000
+                } else {
+                    ctx.close()
+                    Long.MAX_VALUE
+                }
+            }
+        }
 
         val logic = object : SimResourceProviderLogic {}
         val context = SimResourceContextImpl(null, interpreter, consumer, logic)
@@ -104,8 +140,17 @@ class SimResourceContextTest {
     @Test
     fun testIdempotentCapacityChange() = runBlockingSimulation {
         val interpreter = SimResourceInterpreterImpl(coroutineContext, clock)
-        val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
-        every { consumer.onNext(any(), any(), any()) } returns SimResourceCommand.Consume(1.0) andThen SimResourceCommand.Exit
+        val consumer = spyk(object : SimResourceConsumer {
+            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
+                return if (now == 0L) {
+                    ctx.push(1.0)
+                    1000
+                } else {
+                    ctx.close()
+                    Long.MAX_VALUE
+                }
+            }
+        })
 
         val logic = object : SimResourceProviderLogic {}
 
@@ -120,12 +165,23 @@ class SimResourceContextTest {
     @Test
     fun testFailureNoInfiniteLoop() = runBlockingSimulation {
         val interpreter = SimResourceInterpreterImpl(coroutineContext, clock)
-        val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
-        every { consumer.onNext(any(), any(), any()) } returns SimResourceCommand.Exit
-        every { consumer.onEvent(any(), SimResourceEvent.Exit) } throws IllegalStateException("onEvent")
-        every { consumer.onFailure(any(), any()) } throws IllegalStateException("onFailure")
 
-        val logic = spyk(object : SimResourceProviderLogic {})
+        val consumer = spyk(object : SimResourceConsumer {
+            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
+                ctx.close()
+                return Long.MAX_VALUE
+            }
+
+            override fun onEvent(ctx: SimResourceContext, event: SimResourceEvent) {
+                if (event == SimResourceEvent.Exit) throw IllegalStateException("onEvent")
+            }
+
+            override fun onFailure(ctx: SimResourceContext, cause: Throwable) {
+                throw IllegalStateException("onFailure")
+            }
+        })
+
+        val logic = object : SimResourceProviderLogic {}
 
         val context = SimResourceContextImpl(null, interpreter, consumer, logic)
 
diff --git a/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceSourceTest.kt b/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceSourceTest.kt
index c310fad6..e055daf7 100644
--- a/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceSourceTest.kt
+++ b/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceSourceTest.kt
@@ -44,10 +44,7 @@ internal class SimResourceSourceTest {
         val capacity = 4200.0
         val provider = SimResourceSource(capacity, scheduler)
 
-        val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
-        every { consumer.onNext(any(), any(), any()) }
-            .returns(SimResourceCommand.Consume(capacity, duration = 1000))
-            .andThen(SimResourceCommand.Exit)
+        val consumer = SimWorkConsumer(4200.0, 1.0)
 
         val res = mutableListOf<Double>()
         val adapter = SimSpeedConsumerAdapter(consumer, res::add)
@@ -79,10 +76,7 @@ internal class SimResourceSourceTest {
         val capacity = 4200.0
         val provider = SimResourceSource(capacity, scheduler)
 
-        val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
-        every { consumer.onNext(any(), any(), any()) }
-            .returns(SimResourceCommand.Consume(2 * capacity, duration = 1000))
-            .andThen(SimResourceCommand.Exit)
+        val consumer = SimWorkConsumer(capacity, 2.0)
 
         val res = mutableListOf<Double>()
         val adapter = SimSpeedConsumerAdapter(consumer, res::add)
@@ -103,8 +97,9 @@ internal class SimResourceSourceTest {
         val provider = SimResourceSource(capacity, scheduler)
 
         val consumer = object : SimResourceConsumer {
-            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): SimResourceCommand {
-                return SimResourceCommand.Exit
+            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
+                ctx.close()
+                return Long.MAX_VALUE
             }
 
             override fun onEvent(ctx: SimResourceContext, event: SimResourceEvent) {
@@ -132,12 +127,14 @@ internal class SimResourceSourceTest {
                 }
             }
 
-            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): SimResourceCommand {
+            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
                 return if (isFirst) {
                     isFirst = false
-                    SimResourceCommand.Consume(1.0, duration = 4000)
+                    ctx.push(1.0)
+                    4000
                 } else {
-                    SimResourceCommand.Exit
+                    ctx.close()
+                    Long.MAX_VALUE
                 }
             }
         }
@@ -172,10 +169,19 @@ internal class SimResourceSourceTest {
         val capacity = 4200.0
         val provider = SimResourceSource(capacity, scheduler)
 
-        val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
-        every { consumer.onNext(any(), any(), any()) }
-            .returns(SimResourceCommand.Consume(1.0, duration = 1000))
-            .andThenThrows(IllegalStateException())
+        val consumer = object : SimResourceConsumer {
+            var isFirst = true
+
+            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
+                return if (isFirst) {
+                    isFirst = false
+                    ctx.push(1.0)
+                    1000
+                } else {
+                    throw IllegalStateException()
+                }
+            }
+        }
 
         assertThrows<IllegalStateException> {
             provider.consume(consumer)
@@ -188,10 +194,7 @@ internal class SimResourceSourceTest {
         val capacity = 4200.0
         val provider = SimResourceSource(capacity, scheduler)
 
-        val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
-        every { consumer.onNext(any(), any(), any()) }
-            .returns(SimResourceCommand.Consume(1.0))
-            .andThenThrows(IllegalStateException())
+        val consumer = SimWorkConsumer(capacity, 1.0)
 
         assertThrows<IllegalStateException> {
             coroutineScope {
@@ -207,30 +210,13 @@ internal class SimResourceSourceTest {
         val capacity = 4200.0
         val provider = SimResourceSource(capacity, scheduler)
 
-        val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
-        every { consumer.onNext(any(), any(), any()) }
-            .returns(SimResourceCommand.Consume(1.0))
-            .andThenThrows(IllegalStateException())
+        val consumer = SimWorkConsumer(capacity, 1.0)
 
         launch { provider.consume(consumer) }
         delay(500)
         provider.cancel()
 
-        assertEquals(500, clock.millis())
-    }
-
-    @Test
-    fun testIdle() = runBlockingSimulation {
-        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
-        val capacity = 4200.0
-        val provider = SimResourceSource(capacity, scheduler)
-
-        val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
-        every { consumer.onNext(any(), any(), any()) }
-            .returns(SimResourceCommand.Consume(0.0, 500))
-            .andThen(SimResourceCommand.Exit)
-
-        provider.consume(consumer)
+        yield()
 
         assertEquals(500, clock.millis())
     }
@@ -243,10 +229,9 @@ internal class SimResourceSourceTest {
                 val capacity = 4200.0
                 val provider = SimResourceSource(capacity, scheduler)
 
-                val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
-                every { consumer.onNext(any(), any(), any()) }
-                    .returns(SimResourceCommand.Consume(0.0))
-                    .andThenThrows(IllegalStateException())
+                val consumer = object : SimResourceConsumer {
+                    override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long = Long.MAX_VALUE
+                }
 
                 provider.consume(consumer)
             }
diff --git a/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceSwitchExclusiveTest.kt b/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceSwitchExclusiveTest.kt
index ad3b0f9f..9f86dc0d 100644
--- a/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceSwitchExclusiveTest.kt
+++ b/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceSwitchExclusiveTest.kt
@@ -22,8 +22,6 @@
 
 package org.opendc.simulator.resources
 
-import io.mockk.every
-import io.mockk.mockk
 import kotlinx.coroutines.yield
 import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.Test
@@ -32,6 +30,7 @@ import org.junit.jupiter.api.assertThrows
 import org.opendc.simulator.core.runBlockingSimulation
 import org.opendc.simulator.resources.consumer.SimSpeedConsumerAdapter
 import org.opendc.simulator.resources.consumer.SimTraceConsumer
+import org.opendc.simulator.resources.consumer.SimWorkConsumer
 import org.opendc.simulator.resources.impl.SimResourceInterpreterImpl
 
 /**
@@ -88,8 +87,7 @@ internal class SimResourceSwitchExclusiveTest {
         val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
 
         val duration = 5 * 60L * 1000
-        val workload = mockk<SimResourceConsumer>(relaxUnitFun = true)
-        every { workload.onNext(any(), any(), any()) } returns SimResourceCommand.Consume(1.0, duration = duration) andThen SimResourceCommand.Exit
+        val workload = SimWorkConsumer(duration * 3.2, 1.0)
 
         val switch = SimResourceSwitchExclusive()
         val source = SimResourceSource(3200.0, scheduler)
@@ -125,12 +123,14 @@ internal class SimResourceSwitchExclusiveTest {
                 }
             }
 
-            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): SimResourceCommand {
+            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
                 return if (isFirst) {
                     isFirst = false
-                    SimResourceCommand.Consume(1.0, duration = duration)
+                    ctx.push(1.0)
+                    duration
                 } else {
-                    SimResourceCommand.Exit
+                    ctx.close()
+                    Long.MAX_VALUE
                 }
             }
         }
@@ -159,9 +159,6 @@ internal class SimResourceSwitchExclusiveTest {
     fun testConcurrentWorkloadFails() = runBlockingSimulation {
         val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
 
-        val workload = mockk<SimResourceConsumer>(relaxUnitFun = true)
-        every { workload.onNext(any(), any(), any()) } returns SimResourceCommand.Consume(1.0) andThen SimResourceCommand.Exit
-
         val switch = SimResourceSwitchExclusive()
         val source = SimResourceSource(3200.0, scheduler)
 
diff --git a/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceSwitchMaxMinTest.kt b/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceSwitchMaxMinTest.kt
index d8f18e65..ba0d66ff 100644
--- a/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceSwitchMaxMinTest.kt
+++ b/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceSwitchMaxMinTest.kt
@@ -22,8 +22,6 @@
 
 package org.opendc.simulator.resources
 
-import io.mockk.every
-import io.mockk.mockk
 import kotlinx.coroutines.coroutineScope
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.yield
@@ -31,6 +29,7 @@ import org.junit.jupiter.api.*
 import org.junit.jupiter.api.Assertions.assertEquals
 import org.opendc.simulator.core.runBlockingSimulation
 import org.opendc.simulator.resources.consumer.SimTraceConsumer
+import org.opendc.simulator.resources.consumer.SimWorkConsumer
 import org.opendc.simulator.resources.impl.SimResourceInterpreterImpl
 
 /**
@@ -46,9 +45,7 @@ internal class SimResourceSwitchMaxMinTest {
         sources.forEach { switch.addInput(it) }
 
         val provider = switch.newOutput()
-
-        val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
-        every { consumer.onNext(any(), any(), any()) } returns SimResourceCommand.Consume(1.0, duration = 1000) andThen SimResourceCommand.Exit
+        val consumer = SimWorkConsumer(2000.0, 1.0)
 
         try {
             provider.consume(consumer)
diff --git a/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceTransformerTest.kt b/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceTransformerTest.kt
index 3780fd60..fc43c3da 100644
--- a/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceTransformerTest.kt
+++ b/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceTransformerTest.kt
@@ -22,8 +22,6 @@
 
 package org.opendc.simulator.resources
 
-import io.mockk.every
-import io.mockk.mockk
 import io.mockk.spyk
 import io.mockk.verify
 import kotlinx.coroutines.*
@@ -47,8 +45,9 @@ internal class SimResourceTransformerTest {
         launch { source.consume(forwarder) }
 
         forwarder.consume(object : SimResourceConsumer {
-            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): SimResourceCommand {
-                return SimResourceCommand.Exit
+            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
+                ctx.close()
+                return Long.MAX_VALUE
             }
         })
 
@@ -67,12 +66,14 @@ internal class SimResourceTransformerTest {
         forwarder.consume(object : SimResourceConsumer {
             var isFirst = true
 
-            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): SimResourceCommand {
+            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
                 return if (isFirst) {
                     isFirst = false
-                    SimResourceCommand.Consume(1.0, duration = 10 * 1000L)
+                    ctx.push(1.0)
+                    10 * 1000
                 } else {
-                    SimResourceCommand.Exit
+                    ctx.close()
+                    Long.MAX_VALUE
                 }
             }
         })
@@ -85,7 +86,10 @@ internal class SimResourceTransformerTest {
     fun testState() = runBlockingSimulation {
         val forwarder = SimResourceForwarder()
         val consumer = object : SimResourceConsumer {
-            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): SimResourceCommand = SimResourceCommand.Exit
+            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
+                ctx.close()
+                return Long.MAX_VALUE
+            }
         }
 
         assertFalse(forwarder.isActive)
@@ -106,8 +110,12 @@ internal class SimResourceTransformerTest {
     fun testCancelPendingDelegate() = runBlockingSimulation {
         val forwarder = SimResourceForwarder()
 
-        val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
-        every { consumer.onNext(any(), any(), any()) } returns SimResourceCommand.Exit
+        val consumer = spyk(object : SimResourceConsumer {
+            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
+                ctx.close()
+                return Long.MAX_VALUE
+            }
+        })
 
         forwarder.startConsumer(consumer)
         forwarder.cancel()
@@ -121,8 +129,7 @@ internal class SimResourceTransformerTest {
         val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
         val source = SimResourceSource(2000.0, scheduler)
 
-        val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
-        every { consumer.onNext(any(), any(), any()) } returns SimResourceCommand.Consume(0.0, 10)
+        val consumer = spyk(SimWorkConsumer(2000.0, 1.0))
 
         source.startConsumer(forwarder)
         yield()
@@ -140,8 +147,7 @@ internal class SimResourceTransformerTest {
         val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
         val source = SimResourceSource(2000.0, scheduler)
 
-        val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
-        every { consumer.onNext(any(), any(), any()) } returns SimResourceCommand.Consume(0.0, 10)
+        val consumer = spyk(SimWorkConsumer(2000.0, 1.0))
 
         source.startConsumer(forwarder)
         yield()
@@ -159,8 +165,12 @@ internal class SimResourceTransformerTest {
         val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
         val source = SimResourceSource(2000.0, scheduler)
 
-        val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
-        every { consumer.onNext(any(), any(), any()) } returns SimResourceCommand.Exit
+        val consumer = object : SimResourceConsumer {
+            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
+                ctx.close()
+                return Long.MAX_VALUE
+            }
+        }
 
         source.startConsumer(forwarder)
         forwarder.consume(consumer)
@@ -190,7 +200,7 @@ internal class SimResourceTransformerTest {
 
     @Test
     fun testTransformExit() = runBlockingSimulation {
-        val forwarder = SimResourceTransformer { _, _ -> SimResourceCommand.Exit }
+        val forwarder = SimResourceTransformer { ctx, _ -> ctx.close(); Long.MAX_VALUE }
         val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
         val source = SimResourceSource(1.0, scheduler)
 
-- 
cgit v1.2.3


From 657deac134f7b9ee30ed7e2b7667e30f3b17f79f Mon Sep 17 00:00:00 2001
From: Fabian Mastenbroek <mail.fabianm@gmail.com>
Date: Wed, 29 Sep 2021 16:52:30 +0200
Subject: perf(simulator): Reduce memory allocations in SimResourceInterpreter

This change removes unnecessary allocations in the SimResourceInterpreter
caused by the way timers were allocated for the resource context.
---
 .../resources/impl/SimResourceContextImpl.kt       |  71 ++++----
 .../resources/impl/SimResourceInterpreterImpl.kt   | 199 +++++++++------------
 .../simulator/resources/SimResourceContextTest.kt  |   4 +-
 3 files changed, 126 insertions(+), 148 deletions(-)

(limited to 'opendc-simulator/opendc-simulator-resources')

diff --git a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/impl/SimResourceContextImpl.kt b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/impl/SimResourceContextImpl.kt
index d7ea0043..9cbf849d 100644
--- a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/impl/SimResourceContextImpl.kt
+++ b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/impl/SimResourceContextImpl.kt
@@ -24,6 +24,7 @@ package org.opendc.simulator.resources.impl
 
 import org.opendc.simulator.resources.*
 import java.time.Clock
+import java.util.ArrayDeque
 import kotlin.math.max
 import kotlin.math.min
 
@@ -96,9 +97,9 @@ internal class SimResourceContextImpl(
     private var _flag: Int = 0
 
     /**
-     * The current pending update.
+     * The timers at which the context is scheduled to be interrupted.
      */
-    private var _pendingUpdate: SimResourceInterpreterImpl.Update? = null
+    private val _timers: ArrayDeque<SimResourceInterpreterImpl.Timer> = ArrayDeque()
 
     override fun start() {
         check(_state == SimResourceState.Pending) { "Consumer is already started" }
@@ -126,7 +127,7 @@ internal class SimResourceContextImpl(
         }
 
         _flag = _flag or FLAG_INTERRUPT
-        scheduleUpdate()
+        scheduleUpdate(clock.millis())
     }
 
     override fun invalidate() {
@@ -135,7 +136,7 @@ internal class SimResourceContextImpl(
         }
 
         _flag = _flag or FLAG_INVALIDATE
-        scheduleUpdate()
+        scheduleUpdate(clock.millis())
     }
 
     override fun flush() {
@@ -143,7 +144,7 @@ internal class SimResourceContextImpl(
             return
         }
 
-        interpreter.scheduleSync(this)
+        interpreter.scheduleSync(clock.millis(), this)
     }
 
     override fun push(rate: Double) {
@@ -154,9 +155,9 @@ internal class SimResourceContextImpl(
     /**
      * Determine whether the state of the resource context should be updated.
      */
-    fun requiresUpdate(timestamp: Long): Boolean {
+    fun shouldUpdate(timestamp: Long): Boolean {
         // Either the resource context is flagged or there is a pending update at this timestamp
-        return _flag != 0 || _pendingUpdate?.timestamp == timestamp
+        return _flag != 0 || _deadline == timestamp
     }
 
     /**
@@ -204,7 +205,7 @@ internal class SimResourceContextImpl(
 
                     _deadline = target
 
-                    scheduleUpdate(target)
+                    scheduleUpdate(timestamp, target)
                 }
                 SimResourceState.Pending ->
                     if (oldState != SimResourceState.Pending) {
@@ -229,6 +230,30 @@ internal class SimResourceContextImpl(
         }
     }
 
+    /**
+     * Prune the elapsed timers from this context.
+     */
+    fun pruneTimers(now: Long) {
+        val timers = _timers
+        while (true) {
+            val head = timers.peek()
+            if (head == null || head.target > now) {
+                break
+            }
+            timers.poll()
+        }
+    }
+
+    /**
+     * Try to re-schedule the resource context in case it was skipped.
+     */
+    fun tryReschedule(now: Long) {
+        val deadline = _deadline
+        if (deadline > now && deadline != Long.MAX_VALUE) {
+            scheduleUpdate(now, deadline)
+        }
+    }
+
     override fun toString(): String = "SimResourceContextImpl[capacity=$capacity]"
 
     /**
@@ -279,35 +304,17 @@ internal class SimResourceContextImpl(
     /**
      * Schedule an update for this resource context.
      */
-    private fun scheduleUpdate() {
-        // Cancel the pending update
-        val pendingUpdate = _pendingUpdate
-        if (pendingUpdate != null) {
-            _pendingUpdate = null
-            pendingUpdate.cancel()
-        }
-
-        interpreter.scheduleImmediate(this)
+    private fun scheduleUpdate(now: Long) {
+        interpreter.scheduleImmediate(now, this)
     }
 
     /**
      * Schedule a delayed update for this resource context.
      */
-    private fun scheduleUpdate(timestamp: Long) {
-        val pendingUpdate = _pendingUpdate
-        if (pendingUpdate != null) {
-            if (pendingUpdate.timestamp == timestamp) {
-                // Fast-path: A pending update for the same timestamp already exists
-                return
-            } else {
-                // Cancel the old pending update
-                _pendingUpdate = null
-                pendingUpdate.cancel()
-            }
-        }
-
-        if (timestamp != Long.MAX_VALUE) {
-            _pendingUpdate = interpreter.scheduleDelayed(this, timestamp)
+    private fun scheduleUpdate(now: Long, target: Long) {
+        val timers = _timers
+        if (target != Long.MAX_VALUE && (timers.isEmpty() || target < timers.peek().target)) {
+            timers.addFirst(interpreter.scheduleDelayed(now, this, target))
         }
     }
 
diff --git a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/impl/SimResourceInterpreterImpl.kt b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/impl/SimResourceInterpreterImpl.kt
index c3dcebd0..2b6ec2ba 100644
--- a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/impl/SimResourceInterpreterImpl.kt
+++ b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/impl/SimResourceInterpreterImpl.kt
@@ -53,7 +53,7 @@ internal class SimResourceInterpreterImpl(private val context: CoroutineContext,
     /**
      * A priority queue containing the resource updates to be scheduled in the future.
      */
-    private val futureQueue = PriorityQueue<Update>(compareBy { it.timestamp })
+    private val futureQueue = PriorityQueue<Timer>()
 
     /**
      * The stack of interpreter invocations to occur in the future.
@@ -77,13 +77,14 @@ internal class SimResourceInterpreterImpl(private val context: CoroutineContext,
         get() = batchIndex > 0
 
     /**
-     * Enqueue the specified [ctx] to be updated immediately during the active interpreter cycle.
-     *
-     * This method should be used when the state of a resource context is invalidated/interrupted and needs to be
-     * re-computed. In case no interpreter is currently active, the interpreter will be started.
+     * Update the specified [ctx] synchronously.
      */
-    fun scheduleImmediate(ctx: SimResourceContextImpl) {
-        queue.add(ctx)
+    fun scheduleSync(now: Long, ctx: SimResourceContextImpl) {
+        ctx.doUpdate(now)
+
+        if (visited.add(ctx)) {
+            collectAncestors(ctx, visited)
+        }
 
         // In-case the interpreter is already running in the call-stack, return immediately. The changes will be picked
         // up by the active interpreter.
@@ -93,21 +94,20 @@ internal class SimResourceInterpreterImpl(private val context: CoroutineContext,
 
         try {
             batchIndex++
-            runInterpreter()
+            runInterpreter(now)
         } finally {
             batchIndex--
         }
     }
 
     /**
-     * Update the specified [ctx] synchronously.
+     * Enqueue the specified [ctx] to be updated immediately during the active interpreter cycle.
+     *
+     * This method should be used when the state of a resource context is invalidated/interrupted and needs to be
+     * re-computed. In case no interpreter is currently active, the interpreter will be started.
      */
-    fun scheduleSync(ctx: SimResourceContextImpl) {
-        ctx.doUpdate(clock.millis())
-
-        if (visited.add(ctx)) {
-            collectAncestors(ctx, visited)
-        }
+    fun scheduleImmediate(now: Long, ctx: SimResourceContextImpl) {
+        queue.add(ctx)
 
         // In-case the interpreter is already running in the call-stack, return immediately. The changes will be picked
         // up by the active interpreter.
@@ -117,35 +117,30 @@ internal class SimResourceInterpreterImpl(private val context: CoroutineContext,
 
         try {
             batchIndex++
-            runInterpreter()
+            runInterpreter(now)
         } finally {
             batchIndex--
         }
     }
 
     /**
-     * Schedule the interpreter to run at [timestamp] to update the resource contexts.
+     * Schedule the interpreter to run at [target] to update the resource contexts.
      *
      * This method will override earlier calls to this method for the same [ctx].
      *
+     * @param now The current virtual timestamp.
      * @param ctx The resource context to which the event applies.
-     * @param timestamp The timestamp when the interrupt should happen.
+     * @param target The timestamp when the interrupt should happen.
      */
-    fun scheduleDelayed(ctx: SimResourceContextImpl, timestamp: Long): Update {
-        val now = clock.millis()
+    fun scheduleDelayed(now: Long, ctx: SimResourceContextImpl, target: Long): Timer {
         val futureQueue = futureQueue
 
-        require(timestamp >= now) { "Timestamp must be in the future" }
+        require(target >= now) { "Timestamp must be in the future" }
 
-        val update = allocUpdate(ctx, timestamp)
-        futureQueue.add(update)
+        val timer = Timer(ctx, target)
+        futureQueue.add(timer)
 
-        // Optimization: Check if we need to push the interruption forward. Note that we check by timer reference.
-        if (futureQueue.peek() === update) {
-            trySchedule(futureQueue, futureInvocations)
-        }
-
-        return update
+        return timer
     }
 
     override fun newContext(
@@ -162,7 +157,7 @@ internal class SimResourceInterpreterImpl(private val context: CoroutineContext,
         try {
             // Flush the work if the platform is not already running
             if (batchIndex == 1 && queue.isNotEmpty()) {
-                runInterpreter()
+                runInterpreter(clock.millis())
             }
         } finally {
             batchIndex--
@@ -172,37 +167,46 @@ internal class SimResourceInterpreterImpl(private val context: CoroutineContext,
     /**
      * Interpret all actions that are scheduled for the current timestamp.
      */
-    private fun runInterpreter() {
-        val now = clock.millis()
+    private fun runInterpreter(now: Long) {
         val queue = queue
         val futureQueue = futureQueue
         val futureInvocations = futureInvocations
         val visited = visited
 
+        // Remove any entries in the `futureInvocations` queue from the past
+        while (true) {
+            val head = futureInvocations.peek()
+            if (head == null || head.timestamp > now) {
+                break
+            }
+            futureInvocations.poll()
+        }
+
         // Execute all scheduled updates at current timestamp
         while (true) {
-            val update = futureQueue.peek() ?: break
+            val timer = futureQueue.peek() ?: break
+            val ctx = timer.ctx
+            val target = timer.target
 
-            assert(update.timestamp >= now) { "Internal inconsistency: found update of the past" }
+            assert(target >= now) { "Internal inconsistency: found update of the past" }
 
-            if (update.timestamp > now && !update.isCancelled) {
-                // Schedule a task for the next event to occur.
-                trySchedule(futureQueue, futureInvocations)
+            if (target > now) {
                 break
             }
 
             futureQueue.poll()
 
-            val shouldExecute = !update.isCancelled && update.ctx.requiresUpdate(now)
-            if (shouldExecute) {
-                update.ctx.doUpdate(now)
+            ctx.pruneTimers(now)
 
-                if (visited.add(update.ctx)) {
-                    collectAncestors(update.ctx, visited)
+            if (ctx.shouldUpdate(now)) {
+                ctx.doUpdate(now)
+
+                if (visited.add(ctx)) {
+                    collectAncestors(ctx, visited)
                 }
+            } else {
+                ctx.tryReschedule(now)
             }
-
-            updatePool.add(update)
         }
 
         // Repeat execution of all immediate updates until the system has converged to a steady-state
@@ -211,9 +215,8 @@ internal class SimResourceInterpreterImpl(private val context: CoroutineContext,
             // Execute all immediate updates
             while (true) {
                 val ctx = queue.poll() ?: break
-                val shouldExecute = ctx.requiresUpdate(now)
 
-                if (shouldExecute) {
+                if (ctx.shouldUpdate(now)) {
                     ctx.doUpdate(now)
 
                     if (visited.add(ctx)) {
@@ -228,88 +231,65 @@ internal class SimResourceInterpreterImpl(private val context: CoroutineContext,
 
             visited.clear()
         } while (queue.isNotEmpty())
+
+        // Schedule an interpreter invocation for the next update to occur.
+        val headTimer = futureQueue.peek()
+        if (headTimer != null) {
+            trySchedule(now, futureInvocations, headTimer.target)
+        }
     }
 
     /**
-     * Try to schedule the next interpreter event.
+     * Collect all the ancestors of the specified [system].
      */
-    private fun trySchedule(queue: PriorityQueue<Update>, scheduled: ArrayDeque<Invocation>) {
-        val nextTimer = queue.peek()
-        val now = clock.millis()
-
-        // Check whether we need to update our schedule:
-        if (nextTimer == null) {
-            // Case 1: all timers are cancelled
-            for (invocation in scheduled) {
-                invocation.cancel()
-            }
-            scheduled.clear()
-            return
+    private tailrec fun collectAncestors(system: SimResourceSystem, systems: MutableSet<SimResourceSystem>) {
+        val parent = system.parent
+        if (parent != null) {
+            systems.add(parent)
+            collectAncestors(parent, systems)
         }
+    }
 
+    /**
+     * Try to schedule an interpreter invocation at the specified [target].
+     *
+     * @param now The current virtual timestamp.
+     * @param target The virtual timestamp at which the interpreter invocation should happen.
+     * @param scheduled The queue of scheduled invocations.
+     */
+    private fun trySchedule(now: Long, scheduled: ArrayDeque<Invocation>, target: Long) {
         while (true) {
             val invocation = scheduled.peekFirst()
-            if (invocation == null || invocation.timestamp > nextTimer.timestamp) {
+            if (invocation == null || invocation.timestamp > target) {
                 // Case 2: A new timer was registered ahead of the other timers.
                 // Solution: Schedule a new scheduler invocation
-                val nextTimestamp = nextTimer.timestamp
                 @OptIn(InternalCoroutinesApi::class)
                 val handle = delay.invokeOnTimeout(
-                    nextTimestamp - now,
+                    target - now,
                     {
                         try {
                             batchIndex++
-                            runInterpreter()
+                            runInterpreter(target)
                         } finally {
                             batchIndex--
                         }
                     },
                     context
                 )
-                scheduled.addFirst(Invocation(nextTimestamp, handle))
+                scheduled.addFirst(Invocation(target, handle))
                 break
-            } else if (invocation.timestamp < nextTimer.timestamp) {
+            } else if (invocation.timestamp < target) {
                 // Case 2: A timer was cancelled and the head of the timer queue is now later than excepted
                 // Solution: Cancel the next scheduler invocation
-                invocation.cancel()
                 scheduled.pollFirst()
+
+                invocation.cancel()
             } else {
                 break
             }
         }
     }
 
-    /**
-     * Collect all the ancestors of the specified [system].
-     */
-    private tailrec fun collectAncestors(system: SimResourceSystem, systems: MutableSet<SimResourceSystem>) {
-        val parent = system.parent
-        if (parent != null) {
-            systems.add(parent)
-            collectAncestors(parent, systems)
-        }
-    }
-
-    /**
-     * The pool of existing updates.
-     */
-    private val updatePool = ArrayDeque<Update>()
-
-    /**
-     * Allocate an [Update] object.
-     */
-    private fun allocUpdate(ctx: SimResourceContextImpl, timestamp: Long): Update {
-        val update = updatePool.poll()
-        return if (update != null) {
-            update.ctx = ctx
-            update.timestamp = timestamp
-            update.isCancelled = false
-            update
-        } else {
-            Update(ctx, timestamp)
-        }
-    }
-
     /**
      * A future interpreter invocation.
      *
@@ -318,34 +298,25 @@ internal class SimResourceInterpreterImpl(private val context: CoroutineContext,
      */
     private data class Invocation(
         @JvmField val timestamp: Long,
-        private val disposableHandle: DisposableHandle
+        @JvmField val handle: DisposableHandle
     ) {
         /**
          * Cancel the interpreter invocation.
          */
-        fun cancel() = disposableHandle.dispose()
+        fun cancel() = handle.dispose()
     }
 
     /**
-     * An update call for [ctx] that is scheduled for [timestamp].
+     * An update call for [ctx] that is scheduled for [target].
      *
-     * This class represents an update in the future at [timestamp] requested by [ctx]. A deferred update might be
+     * This class represents an update in the future at [target] requested by [ctx]. A deferred update might be
      * cancelled if the resource context was invalidated in the meantime.
      */
-    class Update(@JvmField var ctx: SimResourceContextImpl, @JvmField var timestamp: Long) {
-        /**
-         * A flag to indicate that the task has been cancelled.
-         */
-        @JvmField
-        var isCancelled: Boolean = false
-
-        /**
-         * Cancel the update.
-         */
-        fun cancel() {
-            isCancelled = true
+    class Timer(@JvmField val ctx: SimResourceContextImpl, @JvmField val target: Long) : Comparable<Timer> {
+        override fun compareTo(other: Timer): Int {
+            return target.compareTo(other.target)
         }
 
-        override fun toString(): String = "Update[ctx=$ctx,timestamp=$timestamp]"
+        override fun toString(): String = "Timer[ctx=$ctx,timestamp=$target]"
     }
 }
diff --git a/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceContextTest.kt b/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceContextTest.kt
index 4e57f598..e95e9e42 100644
--- a/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceContextTest.kt
+++ b/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceContextTest.kt
@@ -51,7 +51,7 @@ class SimResourceContextTest {
         val logic = object : SimResourceProviderLogic {}
         val context = SimResourceContextImpl(null, interpreter, consumer, logic)
 
-        context.doUpdate(interpreter.clock.millis())
+        interpreter.scheduleSync(interpreter.clock.millis(), context)
     }
 
     @Test
@@ -77,7 +77,7 @@ class SimResourceContextTest {
 
         context.start()
         delay(1) // Delay 1 ms to prevent hitting the fast path
-        context.doUpdate(interpreter.clock.millis())
+        interpreter.scheduleSync(interpreter.clock.millis(), context)
 
         verify(exactly = 2) { logic.onConsume(any(), any(), any(), any()) }
     }
-- 
cgit v1.2.3


From d3b0b551362eb677c12047cba82a6279ea4608b4 Mon Sep 17 00:00:00 2001
From: Fabian Mastenbroek <mail.fabianm@gmail.com>
Date: Wed, 29 Sep 2021 17:06:45 +0200
Subject: refactor(simulator): Simplify max-min aggregator implementation

This change simplifies the implementation of the
SimResourceAggregatorMaxMin class by utilizing the new push method.
This approach should offer better performance than the previous version,
since we can directly push changes to the source.
---
 .../resources/SimAbstractResourceAggregator.kt     | 81 +++-------------------
 .../resources/SimResourceAggregatorMaxMin.kt       | 15 ++--
 2 files changed, 16 insertions(+), 80 deletions(-)

(limited to 'opendc-simulator/opendc-simulator-resources')

diff --git a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimAbstractResourceAggregator.kt b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimAbstractResourceAggregator.kt
index 8e0eb5f8..d064d7fa 100644
--- a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimAbstractResourceAggregator.kt
+++ b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimAbstractResourceAggregator.kt
@@ -32,7 +32,7 @@ public abstract class SimAbstractResourceAggregator(
     /**
      * This method is invoked when the resource consumer consumes resources.
      */
-    protected abstract fun doConsume(limit: Double, duration: Long)
+    protected abstract fun doConsume(limit: Double)
 
     /**
      * This method is invoked when the resource consumer finishes processing.
@@ -42,12 +42,12 @@ public abstract class SimAbstractResourceAggregator(
     /**
      * This method is invoked when an input context is started.
      */
-    protected abstract fun onInputStarted(input: Input)
+    protected abstract fun onInputStarted(input: SimResourceContext)
 
     /**
      * This method is invoked when an input is stopped.
      */
-    protected abstract fun onInputFinished(input: Input)
+    protected abstract fun onInputFinished(input: SimResourceContext)
 
     /* SimResourceAggregator */
     override fun addInput(input: SimResourceProvider) {
@@ -95,7 +95,7 @@ public abstract class SimAbstractResourceAggregator(
             return object : SimResourceProviderLogic {
 
                 override fun onConsume(ctx: SimResourceControllableContext, now: Long, limit: Double, duration: Long): Long {
-                    doConsume(limit, duration)
+                    doConsume(limit)
                     return super.onConsume(ctx, now, limit, duration)
                 }
 
@@ -113,90 +113,25 @@ public abstract class SimAbstractResourceAggregator(
                 }
             }
         }
-
-        /**
-         * Flush the progress of the output if possible.
-         */
-        fun flush() {
-            ctx?.flush()
-        }
-    }
-
-    /**
-     * An input for the resource aggregator.
-     */
-    public interface Input : AutoCloseable {
-        /**
-         * The [SimResourceContext] associated with the input.
-         */
-        public val ctx: SimResourceContext
-
-        /**
-         * Push to this input with the specified [limit] and [duration].
-         */
-        public fun push(limit: Double, duration: Long)
-
-        /**
-         * Close the input for further input.
-         */
-        public override fun close()
     }
 
     /**
      * An internal [SimResourceConsumer] implementation for aggregator inputs.
      */
-    private inner class Consumer : Input, SimResourceConsumer {
+    private inner class Consumer : SimResourceConsumer {
         /**
          * The resource context associated with the input.
          */
-        override val ctx: SimResourceContext
-            get() = _ctx!!
         private var _ctx: SimResourceContext? = null
 
-        /**
-         * The resource command to run next.
-         */
-        private var _duration: Long = Long.MAX_VALUE
-
-        /**
-         * A flag to indicate that the consumer should flush.
-         */
-        private var _isPushed = false
-
         private fun updateCapacity() {
             // Adjust capacity of output resource
             _output.capacity = _inputConsumers.sumOf { it._ctx?.capacity ?: 0.0 }
         }
 
-        /* Input */
-        override fun push(limit: Double, duration: Long) {
-            _duration = duration
-            val ctx = _ctx
-            if (ctx != null) {
-                ctx.push(limit)
-                ctx.interrupt()
-            }
-            _isPushed = true
-        }
-
-        override fun close() {
-            _duration = Long.MAX_VALUE
-            _isPushed = true
-            _ctx?.close()
-        }
-
         /* SimResourceConsumer */
         override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
-            var next = _duration
-
-            if (!_isPushed) {
-                _output.flush()
-                next = _duration
-            }
-
-            _isPushed = false
-            _duration = Long.MAX_VALUE
-            return next
+            return Long.MAX_VALUE
         }
 
         override fun onEvent(ctx: SimResourceContext, event: SimResourceEvent) {
@@ -205,10 +140,10 @@ public abstract class SimAbstractResourceAggregator(
                     _ctx = ctx
                     updateCapacity()
 
-                    onInputStarted(this)
+                    onInputStarted(ctx)
                 }
                 SimResourceEvent.Capacity -> updateCapacity()
-                SimResourceEvent.Exit -> onInputFinished(this)
+                SimResourceEvent.Exit -> onInputFinished(ctx)
                 else -> {}
             }
         }
diff --git a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceAggregatorMaxMin.kt b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceAggregatorMaxMin.kt
index b258a368..f131ac6c 100644
--- a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceAggregatorMaxMin.kt
+++ b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceAggregatorMaxMin.kt
@@ -29,19 +29,20 @@ public class SimResourceAggregatorMaxMin(
     interpreter: SimResourceInterpreter,
     parent: SimResourceSystem? = null
 ) : SimAbstractResourceAggregator(interpreter, parent) {
-    private val consumers = mutableListOf<Input>()
+    private val consumers = mutableListOf<SimResourceContext>()
 
-    override fun doConsume(limit: Double, duration: Long) {
+    override fun doConsume(limit: Double) {
         // Sort all consumers by their capacity
-        consumers.sortWith(compareBy { it.ctx.capacity })
+        consumers.sortWith(compareBy { it.capacity })
 
         // Divide the requests over the available capacity of the input resources fairly
         for (input in consumers) {
-            val inputCapacity = input.ctx.capacity
+            val inputCapacity = input.capacity
             val fraction = inputCapacity / capacity
             val grantedSpeed = limit * fraction
 
-            input.push(grantedSpeed, duration)
+            input.push(grantedSpeed)
+            input.interrupt()
         }
     }
 
@@ -53,11 +54,11 @@ public class SimResourceAggregatorMaxMin(
         }
     }
 
-    override fun onInputStarted(input: Input) {
+    override fun onInputStarted(input: SimResourceContext) {
         consumers.add(input)
     }
 
-    override fun onInputFinished(input: Input) {
+    override fun onInputFinished(input: SimResourceContext) {
         consumers.remove(input)
     }
 }
-- 
cgit v1.2.3


From d031a70f8bea02a86df7840c5ce731185df86883 Mon Sep 17 00:00:00 2001
From: Fabian Mastenbroek <mail.fabianm@gmail.com>
Date: Tue, 28 Sep 2021 22:10:12 +0200
Subject: refactor(simulator): Invoke consumer callback on every invalidation

This change updates the simulator implementation to always invoke the
`SimResourceConsumer.onNext` callback when the resource context is
invalidated. This allows users to update the resource counter or do some
other work if the context has changed.
---
 .../resources/consumer/SimTraceConsumer.kt         | 18 ++++++++---
 .../resources/impl/SimResourceContextImpl.kt       | 36 +++++++++-------------
 .../simulator/resources/SimResourceContextTest.kt  | 33 +++++---------------
 3 files changed, 35 insertions(+), 52 deletions(-)

(limited to 'opendc-simulator/opendc-simulator-resources')

diff --git a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/consumer/SimTraceConsumer.kt b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/consumer/SimTraceConsumer.kt
index ad6b0108..4c0e075c 100644
--- a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/consumer/SimTraceConsumer.kt
+++ b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/consumer/SimTraceConsumer.kt
@@ -31,12 +31,20 @@ import org.opendc.simulator.resources.SimResourceEvent
  * consumption for some period of time.
  */
 public class SimTraceConsumer(private val trace: Sequence<Fragment>) : SimResourceConsumer {
-    private var iterator: Iterator<Fragment>? = null
+    private var _iterator: Iterator<Fragment>? = null
+    private var _nextTarget = Long.MIN_VALUE
 
     override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
-        val iterator = checkNotNull(iterator)
+        // Check whether the trace fragment was fully consumed, otherwise wait until we have done so
+        val nextTarget = _nextTarget
+        if (nextTarget > now) {
+            return now - nextTarget
+        }
+
+        val iterator = checkNotNull(_iterator)
         return if (iterator.hasNext()) {
             val fragment = iterator.next()
+            _nextTarget = now + fragment.duration
             ctx.push(fragment.usage)
             fragment.duration
         } else {
@@ -48,11 +56,11 @@ public class SimTraceConsumer(private val trace: Sequence<Fragment>) : SimResour
     override fun onEvent(ctx: SimResourceContext, event: SimResourceEvent) {
         when (event) {
             SimResourceEvent.Start -> {
-                check(iterator == null) { "Consumer already running" }
-                iterator = trace.iterator()
+                check(_iterator == null) { "Consumer already running" }
+                _iterator = trace.iterator()
             }
             SimResourceEvent.Exit -> {
-                iterator = null
+                _iterator = null
             }
             else -> {}
         }
diff --git a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/impl/SimResourceContextImpl.kt b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/impl/SimResourceContextImpl.kt
index 9cbf849d..1ac38946 100644
--- a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/impl/SimResourceContextImpl.kt
+++ b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/impl/SimResourceContextImpl.kt
@@ -148,6 +148,10 @@ internal class SimResourceContextImpl(
     }
 
     override fun push(rate: Double) {
+        if (_limit == rate) {
+            return
+        }
+
         _speed = min(capacity, rate)
         _limit = rate
     }
@@ -163,7 +167,7 @@ internal class SimResourceContextImpl(
     /**
      * Update the state of the resource context.
      */
-    fun doUpdate(timestamp: Long) {
+    fun doUpdate(now: Long) {
         val oldState = _state
         if (oldState != SimResourceState.Active) {
             return
@@ -171,41 +175,29 @@ internal class SimResourceContextImpl(
 
         _updateActive = true
 
-        val flag = _flag
-        val isInterrupted = flag and FLAG_INTERRUPT != 0
-        val reachedDeadline = _deadline <= timestamp
-        val delta = max(0, timestamp - _timestamp)
+        val reachedDeadline = _deadline <= now
+        val delta = max(0, now - _timestamp)
 
         try {
-
             // Update the resource counters only if there is some progress
-            if (timestamp > _timestamp) {
+            if (now > _timestamp) {
                 logic.onUpdate(this, delta, _limit, reachedDeadline)
             }
 
-            // We should only continue processing the next command if:
-            // 1. The resource consumption was finished.
-            // 2. The resource consumer should be interrupted (e.g., someone called .interrupt())
-            val duration = if (reachedDeadline || isInterrupted) {
-                consumer.onNext(this, timestamp, delta)
-            } else {
-                _deadline - timestamp
-            }
+            val duration = consumer.onNext(this, now, delta)
 
             // Reset update flags
             _flag = 0
 
             when (_state) {
                 SimResourceState.Active -> {
-                    val limit = _limit
-                    push(limit)
-                    _duration = duration
-
-                    val target = logic.onConsume(this, timestamp, limit, duration)
+                    val target = logic.onConsume(this, now, _limit, duration)
 
+                    _speed = min(capacity, _limit)
+                    _duration = duration
                     _deadline = target
 
-                    scheduleUpdate(timestamp, target)
+                    scheduleUpdate(now, target)
                 }
                 SimResourceState.Pending ->
                     if (oldState != SimResourceState.Pending) {
@@ -219,7 +211,7 @@ internal class SimResourceContextImpl(
         } catch (cause: Throwable) {
             doFail(cause)
         } finally {
-            _timestamp = timestamp
+            _timestamp = now
             _updateActive = false
         }
     }
diff --git a/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceContextTest.kt b/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceContextTest.kt
index e95e9e42..c7230a0e 100644
--- a/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceContextTest.kt
+++ b/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceContextTest.kt
@@ -26,6 +26,7 @@ import io.mockk.*
 import kotlinx.coroutines.*
 import org.junit.jupiter.api.*
 import org.opendc.simulator.core.runBlockingSimulation
+import org.opendc.simulator.resources.consumer.SimWorkConsumer
 import org.opendc.simulator.resources.impl.SimResourceContextImpl
 import org.opendc.simulator.resources.impl.SimResourceInterpreterImpl
 
@@ -57,23 +58,14 @@ class SimResourceContextTest {
     @Test
     fun testIntermediateFlush() = runBlockingSimulation {
         val interpreter = SimResourceInterpreterImpl(coroutineContext, clock)
-        val consumer = object : SimResourceConsumer {
-            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
-                return if (now == 0L) {
-                    ctx.push(4.0)
-                    1000
-                } else {
-                    ctx.close()
-                    Long.MAX_VALUE
-                }
-            }
-        }
+        val consumer = SimWorkConsumer(1.0, 1.0)
 
         val logic = spyk(object : SimResourceProviderLogic {
             override fun onFinish(ctx: SimResourceControllableContext) {}
             override fun onConsume(ctx: SimResourceControllableContext, now: Long, limit: Double, duration: Long): Long = duration
         })
         val context = SimResourceContextImpl(null, interpreter, consumer, logic)
+        context.capacity = 1.0
 
         context.start()
         delay(1) // Delay 1 ms to prevent hitting the fast path
@@ -85,29 +77,20 @@ class SimResourceContextTest {
     @Test
     fun testIntermediateFlushIdle() = runBlockingSimulation {
         val interpreter = SimResourceInterpreterImpl(coroutineContext, clock)
-        val consumer = object : SimResourceConsumer {
-            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
-                return if (now == 0L) {
-                    ctx.push(0.0)
-                    10
-                } else {
-                    ctx.close()
-                    Long.MAX_VALUE
-                }
-            }
-        }
+        val consumer = SimWorkConsumer(1.0, 1.0)
 
         val logic = spyk(object : SimResourceProviderLogic {})
         val context = SimResourceContextImpl(null, interpreter, consumer, logic)
+        context.capacity = 1.0
 
         context.start()
-        delay(5)
+        delay(500)
         context.invalidate()
-        delay(5)
+        delay(500)
         context.invalidate()
 
         assertAll(
-            { verify(exactly = 2) { logic.onConsume(any(), any(), 0.0, any()) } },
+            { verify(exactly = 2) { logic.onConsume(any(), any(), any(), any()) } },
             { verify(exactly = 1) { logic.onFinish(any()) } }
         )
     }
-- 
cgit v1.2.3


From 15899c88d29c039149f701e7f0d538a49a436599 Mon Sep 17 00:00:00 2001
From: Fabian Mastenbroek <mail.fabianm@gmail.com>
Date: Wed, 29 Sep 2021 10:33:36 +0200
Subject: refactor(simulator): Lazily push changes to resource context

This change updates the SimResourceContextImpl to lazily push changes to
the resource context instead of applying them directly. The change is
picked up after the resource is updated again.
---
 .../simulator/resources/SimResourceTransformer.kt  |  4 +-
 .../resources/impl/SimResourceContextImpl.kt       | 58 ++++++++++++----------
 2 files changed, 34 insertions(+), 28 deletions(-)

(limited to 'opendc-simulator/opendc-simulator-resources')

diff --git a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceTransformer.kt b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceTransformer.kt
index f12ef9f1..a317f832 100644
--- a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceTransformer.kt
+++ b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceTransformer.kt
@@ -152,9 +152,7 @@ public class SimResourceTransformer(
         updateCounters(ctx, delta)
 
         return if (delegate != null) {
-            val duration = transform(ctx, delegate.onNext(this.ctx, now, delta))
-            _limit = ctx.demand
-            duration
+            transform(ctx, delegate.onNext(this.ctx, now, delta))
         } else {
             Long.MAX_VALUE
         }
diff --git a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/impl/SimResourceContextImpl.kt b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/impl/SimResourceContextImpl.kt
index 1ac38946..78d79434 100644
--- a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/impl/SimResourceContextImpl.kt
+++ b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/impl/SimResourceContextImpl.kt
@@ -69,8 +69,8 @@ internal class SimResourceContextImpl(
      * The current processing speed of the resource.
      */
     override val speed: Double
-        get() = _speed
-    private var _speed = 0.0
+        get() = _rate
+    private var _rate = 0.0
 
     /**
      * The current resource processing demand.
@@ -81,10 +81,10 @@ internal class SimResourceContextImpl(
     /**
      * The current state of the resource context.
      */
-    private var _timestamp: Long = Long.MIN_VALUE
     private var _limit: Double = 0.0
-    private var _duration: Long = Long.MAX_VALUE
-    private var _deadline: Long = Long.MAX_VALUE
+    private var _activeLimit: Double = 0.0
+    private var _deadline: Long = Long.MIN_VALUE
+    private var _lastUpdate: Long = Long.MIN_VALUE
 
     /**
      * A flag to indicate that an update is active.
@@ -152,8 +152,13 @@ internal class SimResourceContextImpl(
             return
         }
 
-        _speed = min(capacity, rate)
         _limit = rate
+
+        // Invalidate only if the active limit is change and no update is active
+        // If an update is active, it will already get picked up at the end of the update
+        if (_activeLimit != rate && !_updateActive) {
+            invalidate()
+        }
     }
 
     /**
@@ -173,45 +178,47 @@ internal class SimResourceContextImpl(
             return
         }
 
+        val lastUpdate = _lastUpdate
+        _lastUpdate = now
         _updateActive = true
 
         val reachedDeadline = _deadline <= now
-        val delta = max(0, now - _timestamp)
+        val delta = max(0, now - lastUpdate)
 
         try {
             // Update the resource counters only if there is some progress
-            if (now > _timestamp) {
-                logic.onUpdate(this, delta, _limit, reachedDeadline)
+            if (now > lastUpdate) {
+                logic.onUpdate(this, delta, _activeLimit, reachedDeadline)
             }
 
             val duration = consumer.onNext(this, now, delta)
+            val newDeadline = if (duration != Long.MAX_VALUE) now + duration else duration
 
             // Reset update flags
             _flag = 0
 
+            // Check whether the state has changed after [consumer.onNext]
             when (_state) {
                 SimResourceState.Active -> {
-                    val target = logic.onConsume(this, now, _limit, duration)
-
-                    _speed = min(capacity, _limit)
-                    _duration = duration
-                    _deadline = target
+                    logic.onConsume(this, now, _limit, duration)
 
-                    scheduleUpdate(now, target)
+                    // Schedule an update at the new deadline
+                    scheduleUpdate(now, newDeadline)
                 }
-                SimResourceState.Pending ->
-                    if (oldState != SimResourceState.Pending) {
-                        throw IllegalStateException("Illegal transition to pending state")
-                    }
-                SimResourceState.Stopped ->
-                    if (oldState != SimResourceState.Stopped) {
-                        doStop()
-                    }
+                SimResourceState.Stopped -> doStop()
+                SimResourceState.Pending -> throw IllegalStateException("Illegal transition to pending state")
             }
+
+            // Note: pending limit might be changed by [logic.onConsume], so re-fetch the value
+            val newLimit = _limit
+
+            // Flush the changes to the flow
+            _activeLimit = newLimit
+            _deadline = newDeadline
+            _rate = min(capacity, newLimit)
         } catch (cause: Throwable) {
             doFail(cause)
         } finally {
-            _timestamp = now
             _updateActive = false
         }
     }
@@ -246,7 +253,7 @@ internal class SimResourceContextImpl(
         }
     }
 
-    override fun toString(): String = "SimResourceContextImpl[capacity=$capacity]"
+    override fun toString(): String = "SimResourceContextImpl[capacity=$capacity,rate=$_rate]"
 
     /**
      * Stop the resource context.
@@ -259,6 +266,7 @@ internal class SimResourceContextImpl(
             doFail(cause)
         } finally {
             _deadline = Long.MAX_VALUE
+            _limit = 0.0
         }
     }
 
-- 
cgit v1.2.3


From e07a5357013b92377a840b4d0d394d0ef6605b26 Mon Sep 17 00:00:00 2001
From: Fabian Mastenbroek <mail.fabianm@gmail.com>
Date: Mon, 27 Sep 2021 14:22:02 +0200
Subject: refactor(simulator): Remove onUpdate callback

This change removes the `onUpdate` callback from the
`SimResourceProviderLogic` interface. Instead, users should now update
counters using either `onConsume` or `onConverge`.
---
 .../resources/SimAbstractResourceAggregator.kt     |  18 +--
 .../resources/SimAbstractResourceProvider.kt       |  22 +--
 .../resources/SimResourceDistributorMaxMin.kt      | 148 +++++++++++----------
 .../simulator/resources/SimResourceInterpreter.kt  |   7 +-
 .../resources/SimResourceProviderLogic.kt          |  25 ++--
 .../simulator/resources/SimResourceSource.kt       |  16 ++-
 .../simulator/resources/SimResourceTransformer.kt  |  14 +-
 .../resources/impl/SimResourceContextImpl.kt       |  79 ++++++-----
 .../resources/impl/SimResourceInterpreterImpl.kt   |  34 +----
 .../simulator/resources/SimResourceContextTest.kt  |  24 ++--
 .../resources/SimResourceTransformerTest.kt        |   3 +
 11 files changed, 197 insertions(+), 193 deletions(-)

(limited to 'opendc-simulator/opendc-simulator-resources')

diff --git a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimAbstractResourceAggregator.kt b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimAbstractResourceAggregator.kt
index d064d7fa..621ea6e7 100644
--- a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimAbstractResourceAggregator.kt
+++ b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimAbstractResourceAggregator.kt
@@ -90,26 +90,22 @@ public abstract class SimAbstractResourceAggregator(
         _output.interrupt()
     }
 
-    private val _output = object : SimAbstractResourceProvider(interpreter, parent, initialCapacity = 0.0) {
+    private val _output = object : SimAbstractResourceProvider(interpreter, initialCapacity = 0.0) {
         override fun createLogic(): SimResourceProviderLogic {
             return object : SimResourceProviderLogic {
 
-                override fun onConsume(ctx: SimResourceControllableContext, now: Long, limit: Double, duration: Long): Long {
+                override fun onConsume(ctx: SimResourceControllableContext, now: Long, delta: Long, limit: Double, duration: Long) {
+                    updateCounters(ctx, delta)
                     doConsume(limit)
-                    return super.onConsume(ctx, now, limit, duration)
                 }
 
-                override fun onFinish(ctx: SimResourceControllableContext) {
+                override fun onFinish(ctx: SimResourceControllableContext, now: Long, delta: Long) {
+                    updateCounters(ctx, delta)
                     doFinish()
                 }
 
-                override fun onUpdate(
-                    ctx: SimResourceControllableContext,
-                    delta: Long,
-                    limit: Double,
-                    willOvercommit: Boolean
-                ) {
-                    updateCounters(ctx, delta, limit, willOvercommit)
+                override fun onConverge(ctx: SimResourceControllableContext, now: Long, delta: Long) {
+                    parent?.onConverge(now)
                 }
             }
         }
diff --git a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimAbstractResourceProvider.kt b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimAbstractResourceProvider.kt
index 548bc228..085cba63 100644
--- a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimAbstractResourceProvider.kt
+++ b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimAbstractResourceProvider.kt
@@ -29,7 +29,6 @@ import org.opendc.simulator.resources.impl.SimResourceCountersImpl
  */
 public abstract class SimAbstractResourceProvider(
     private val interpreter: SimResourceInterpreter,
-    private val parent: SimResourceSystem?,
     initialCapacity: Double
 ) : SimResourceProvider {
     /**
@@ -84,26 +83,31 @@ public abstract class SimAbstractResourceProvider(
         ctx.start()
     }
 
+    /**
+     * The previous demand for the resource.
+     */
+    private var previousDemand = 0.0
+
     /**
      * Update the counters of the resource provider.
      */
-    protected fun updateCounters(ctx: SimResourceContext, delta: Long, limit: Double, willOvercommit: Boolean) {
-        if (delta <= 0.0) {
+    protected fun updateCounters(ctx: SimResourceContext, delta: Long) {
+        val demand = previousDemand
+        previousDemand = ctx.demand
+
+        if (delta <= 0) {
             return
         }
 
         val counters = _counters
         val deltaS = delta / 1000.0
-        val work = limit * deltaS
+        val work = demand * deltaS
         val actualWork = ctx.speed * deltaS
         val remainingWork = work - actualWork
 
         counters.demand += work
         counters.actual += actualWork
-
-        if (willOvercommit && remainingWork > 0.0) {
-            counters.overcommit += remainingWork
-        }
+        counters.overcommit += remainingWork
     }
 
     /**
@@ -118,7 +122,7 @@ public abstract class SimAbstractResourceProvider(
 
     final override fun startConsumer(consumer: SimResourceConsumer) {
         check(ctx == null) { "Resource is in invalid state" }
-        val ctx = interpreter.newContext(consumer, createLogic(), parent)
+        val ctx = interpreter.newContext(consumer, createLogic())
 
         ctx.capacity = capacity
         this.ctx = ctx
diff --git a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceDistributorMaxMin.kt b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceDistributorMaxMin.kt
index eac58410..7df940ad 100644
--- a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceDistributorMaxMin.kt
+++ b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceDistributorMaxMin.kt
@@ -93,46 +93,6 @@ public class SimResourceDistributorMaxMin(
 
     /* SimResourceConsumer */
     override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
-        return doNext(ctx, now)
-    }
-
-    override fun onEvent(ctx: SimResourceContext, event: SimResourceEvent) {
-        when (event) {
-            SimResourceEvent.Start -> {
-                this.ctx = ctx
-                updateCapacity(ctx)
-            }
-            SimResourceEvent.Exit -> {
-                val iterator = _outputs.iterator()
-                while (iterator.hasNext()) {
-                    val output = iterator.next()
-
-                    // Remove the output from the outputs to prevent ConcurrentModificationException when removing it
-                    // during the call to output.close()
-                    iterator.remove()
-
-                    output.close()
-                }
-            }
-            SimResourceEvent.Capacity -> updateCapacity(ctx)
-            else -> {}
-        }
-    }
-
-    /**
-     * Extended [SimResourceCounters] interface for the distributor.
-     */
-    public interface Counters : SimResourceCounters {
-        /**
-         * The amount of work lost due to interference.
-         */
-        public val interference: Double
-    }
-
-    /**
-     * Schedule the work of the outputs.
-     */
-    private fun doNext(ctx: SimResourceContext, now: Long): Long {
         // If there is no work yet, mark the input as idle.
         if (activeOutputs.isEmpty()) {
             return Long.MAX_VALUE
@@ -198,6 +158,39 @@ public class SimResourceDistributorMaxMin(
         return duration
     }
 
+    override fun onEvent(ctx: SimResourceContext, event: SimResourceEvent) {
+        when (event) {
+            SimResourceEvent.Start -> {
+                this.ctx = ctx
+                updateCapacity(ctx)
+            }
+            SimResourceEvent.Exit -> {
+                val iterator = _outputs.iterator()
+                while (iterator.hasNext()) {
+                    val output = iterator.next()
+
+                    // Remove the output from the outputs to prevent ConcurrentModificationException when removing it
+                    // during the call to output.close()
+                    iterator.remove()
+
+                    output.close()
+                }
+            }
+            SimResourceEvent.Capacity -> updateCapacity(ctx)
+            else -> {}
+        }
+    }
+
+    /**
+     * Extended [SimResourceCounters] interface for the distributor.
+     */
+    public interface Counters : SimResourceCounters {
+        /**
+         * The amount of work lost due to interference.
+         */
+        public val interference: Double
+    }
+
     private fun updateCapacity(ctx: SimResourceContext) {
         for (output in _outputs) {
             output.capacity = ctx.capacity
@@ -208,7 +201,7 @@ public class SimResourceDistributorMaxMin(
      * An internal [SimResourceProvider] implementation for switch outputs.
      */
     private inner class Output(capacity: Double, val key: InterferenceKey?) :
-        SimAbstractResourceProvider(interpreter, parent, capacity),
+        SimAbstractResourceProvider(interpreter, capacity),
         SimResourceCloseableProvider,
         SimResourceProviderLogic,
         Comparable<Output> {
@@ -263,17 +256,54 @@ public class SimResourceDistributorMaxMin(
         }
 
         /* SimResourceProviderLogic */
-        override fun onConsume(ctx: SimResourceControllableContext, now: Long, limit: Double, duration: Long): Long {
+        override fun onConsume(
+            ctx: SimResourceControllableContext,
+            now: Long,
+            delta: Long,
+            limit: Double,
+            duration: Long
+        ) {
+            doUpdateCounters(delta)
+
             allowedSpeed = min(ctx.capacity, limit)
+            actualSpeed = 0.0
             this.limit = limit
             this.duration = duration
             lastCommandTimestamp = now
+        }
+
+        override fun onConverge(ctx: SimResourceControllableContext, now: Long, delta: Long) {
+            parent?.onConverge(now)
+        }
+
+        override fun onFinish(ctx: SimResourceControllableContext, now: Long, delta: Long) {
+            doUpdateCounters(delta)
+
+            limit = 0.0
+            duration = Long.MAX_VALUE
+            actualSpeed = 0.0
+            allowedSpeed = 0.0
+            lastCommandTimestamp = now
+        }
 
-            return super.onConsume(ctx, now, limit, duration)
+        /* Comparable */
+        override fun compareTo(other: Output): Int = allowedSpeed.compareTo(other.allowedSpeed)
+
+        /**
+         * Pull the next command if necessary.
+         */
+        fun pull(now: Long) {
+            val ctx = ctx
+            if (ctx != null && lastCommandTimestamp < now) {
+                ctx.flush()
+            }
         }
 
-        override fun onUpdate(ctx: SimResourceControllableContext, delta: Long, limit: Double, willOvercommit: Boolean) {
-            if (delta <= 0.0) {
+        /**
+         * Helper method to update the resource counters of the distributor.
+         */
+        private fun doUpdateCounters(delta: Long) {
+            if (delta <= 0L) {
                 return
             }
 
@@ -289,38 +319,14 @@ public class SimResourceDistributorMaxMin(
             val work = limit * deltaS
             val actualWork = actualSpeed * deltaS
             val remainingWork = work - actualWork
-            val overcommit = if (willOvercommit && remainingWork > 0.0) {
-                remainingWork
-            } else {
-                0.0
-            }
 
-            updateCounters(work, actualWork, overcommit)
+            updateCounters(work, actualWork, remainingWork)
 
             val distCounters = _counters
             distCounters.demand += work
             distCounters.actual += actualWork
-            distCounters.overcommit += overcommit
+            distCounters.overcommit += remainingWork
             distCounters.interference += actualWork * max(0.0, 1 - perfScore)
         }
-
-        override fun onFinish(ctx: SimResourceControllableContext) {
-            limit = 0.0
-            duration = Long.MAX_VALUE
-            lastCommandTimestamp = ctx.clock.millis()
-        }
-
-        /* Comparable */
-        override fun compareTo(other: Output): Int = allowedSpeed.compareTo(other.allowedSpeed)
-
-        /**
-         * Pull the next command if necessary.
-         */
-        fun pull(now: Long) {
-            val ctx = ctx
-            if (ctx != null && lastCommandTimestamp < now) {
-                ctx.flush()
-            }
-        }
     }
 }
diff --git a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceInterpreter.kt b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceInterpreter.kt
index 82631377..4bfeaf20 100644
--- a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceInterpreter.kt
+++ b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceInterpreter.kt
@@ -43,13 +43,8 @@ public interface SimResourceInterpreter {
      *
      * @param consumer The consumer logic.
      * @param provider The logic of the resource provider.
-     * @param parent The system to which the resource context belongs.
      */
-    public fun newContext(
-        consumer: SimResourceConsumer,
-        provider: SimResourceProviderLogic,
-        parent: SimResourceSystem? = null
-    ): SimResourceControllableContext
+    public fun newContext(consumer: SimResourceConsumer, provider: SimResourceProviderLogic): SimResourceControllableContext
 
     /**
      * Start batching the execution of resource updates until [popBatch] is called.
diff --git a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceProviderLogic.kt b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceProviderLogic.kt
index d8ff87f9..cc718165 100644
--- a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceProviderLogic.kt
+++ b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceProviderLogic.kt
@@ -23,7 +23,7 @@
 package org.opendc.simulator.resources
 
 /**
- * The logic of a resource provider.
+ * A collection of callbacks associated with a flow stage.
  */
 public interface SimResourceProviderLogic {
     /**
@@ -31,29 +31,28 @@ public interface SimResourceProviderLogic {
      *
      * @param ctx The context in which the provider runs.
      * @param now The virtual timestamp in milliseconds at which the update is occurring.
+     * @param delta The virtual duration between this call and the last call to [onConsume] in milliseconds.
      * @param limit The limit on the work rate of the resource consumer.
      * @param duration The duration of the consumption in milliseconds.
      * @return The deadline of the resource consumption.
      */
-    public fun onConsume(ctx: SimResourceControllableContext, now: Long, limit: Double, duration: Long): Long {
-        return if (duration == Long.MAX_VALUE) {
-            return Long.MAX_VALUE
-        } else {
-            now + duration
-        }
-    }
+    public fun onConsume(ctx: SimResourceControllableContext, now: Long, delta: Long, limit: Double, duration: Long) {}
 
     /**
-     * This method is invoked when the progress of the resource consumer is materialized.
+     * This method is invoked when the flow graph has converged into a steady-state system.
      *
      * @param ctx The context in which the provider runs.
-     * @param limit The limit on the work rate of the resource consumer.
-     * @param willOvercommit A flag to indicate that the remaining work is overcommitted.
+     * @param now The virtual timestamp in milliseconds at which the system converged.
+     * @param delta The virtual duration between this call and the last call to [onConverge] in milliseconds.
      */
-    public fun onUpdate(ctx: SimResourceControllableContext, delta: Long, limit: Double, willOvercommit: Boolean) {}
+    public fun onConverge(ctx: SimResourceControllableContext, now: Long, delta: Long) {}
 
     /**
      * This method is invoked when the resource consumer has finished.
+     *
+     * @param ctx The context in which the provider runs.
+     * @param now The virtual timestamp in milliseconds at which the provider finished.
+     * @param delta The virtual duration between this call and the last call to [onConsume] in milliseconds.
      */
-    public fun onFinish(ctx: SimResourceControllableContext) {}
+    public fun onFinish(ctx: SimResourceControllableContext, now: Long, delta: Long) {}
 }
diff --git a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceSource.kt b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceSource.kt
index 10213f26..c8d4cf0d 100644
--- a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceSource.kt
+++ b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceSource.kt
@@ -33,21 +33,27 @@ public class SimResourceSource(
     initialCapacity: Double,
     private val interpreter: SimResourceInterpreter,
     private val parent: SimResourceSystem? = null
-) : SimAbstractResourceProvider(interpreter, parent, initialCapacity) {
+) : SimAbstractResourceProvider(interpreter, initialCapacity) {
     override fun createLogic(): SimResourceProviderLogic {
         return object : SimResourceProviderLogic {
-            override fun onUpdate(
+            override fun onConsume(
                 ctx: SimResourceControllableContext,
+                now: Long,
                 delta: Long,
                 limit: Double,
-                willOvercommit: Boolean
+                duration: Long
             ) {
-                updateCounters(ctx, delta, limit, willOvercommit)
+                updateCounters(ctx, delta)
             }
 
-            override fun onFinish(ctx: SimResourceControllableContext) {
+            override fun onFinish(ctx: SimResourceControllableContext, now: Long, delta: Long) {
+                updateCounters(ctx, delta)
                 cancel()
             }
+
+            override fun onConverge(ctx: SimResourceControllableContext, now: Long, delta: Long) {
+                parent?.onConverge(now)
+            }
         }
     }
 
diff --git a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceTransformer.kt b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceTransformer.kt
index a317f832..397463e0 100644
--- a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceTransformer.kt
+++ b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceTransformer.kt
@@ -73,16 +73,16 @@ public class SimResourceTransformer(
         override fun close() {
             val delegate = checkNotNull(delegate) { "Delegate not active" }
 
+            if (isCoupled)
+                _ctx?.close()
+            else
+                _ctx?.push(0.0)
+
             // Warning: resumption of the continuation might change the entire state of the forwarder. Make sure we
             // reset beforehand the existing state and check whether it has been updated afterwards
             reset()
 
             delegate.onEvent(this, SimResourceEvent.Exit)
-
-            if (isCoupled)
-                _ctx?.close()
-            else
-                _ctx?.push(0.0)
         }
     }
 
@@ -213,6 +213,10 @@ public class SimResourceTransformer(
      * Update the resource counters for the transformer.
      */
     private fun updateCounters(ctx: SimResourceContext, delta: Long) {
+        if (delta <= 0) {
+            return
+        }
+
         val counters = _counters
         val deltaS = delta / 1000.0
         val work = _limit * deltaS
diff --git a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/impl/SimResourceContextImpl.kt b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/impl/SimResourceContextImpl.kt
index 78d79434..5a9ffe2d 100644
--- a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/impl/SimResourceContextImpl.kt
+++ b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/impl/SimResourceContextImpl.kt
@@ -32,11 +32,10 @@ import kotlin.math.min
  * Implementation of a [SimResourceContext] managing the communication between resources and resource consumers.
  */
 internal class SimResourceContextImpl(
-    override val parent: SimResourceSystem?,
     private val interpreter: SimResourceInterpreterImpl,
     private val consumer: SimResourceConsumer,
     private val logic: SimResourceProviderLogic
-) : SimResourceControllableContext, SimResourceSystem {
+) : SimResourceControllableContext {
     /**
      * The clock of the context.
      */
@@ -84,7 +83,6 @@ internal class SimResourceContextImpl(
     private var _limit: Double = 0.0
     private var _activeLimit: Double = 0.0
     private var _deadline: Long = Long.MIN_VALUE
-    private var _lastUpdate: Long = Long.MIN_VALUE
 
     /**
      * A flag to indicate that an update is active.
@@ -96,6 +94,12 @@ internal class SimResourceContextImpl(
      */
     private var _flag: Int = 0
 
+    /**
+     * The timestamp of calls to the callbacks.
+     */
+    private var _lastUpdate: Long = Long.MIN_VALUE
+    private var _lastConvergence: Long = Long.MAX_VALUE
+
     /**
      * The timers at which the context is scheduled to be interrupted.
      */
@@ -111,12 +115,20 @@ internal class SimResourceContextImpl(
     }
 
     override fun close() {
-        if (_state != SimResourceState.Stopped) {
-            interpreter.batch {
-                _state = SimResourceState.Stopped
-                if (!_updateActive) {
-                    doStop()
-                }
+        if (_state == SimResourceState.Stopped) {
+            return
+        }
+
+        interpreter.batch {
+            _state = SimResourceState.Stopped
+            if (!_updateActive) {
+                val now = clock.millis()
+                val delta = max(0, now - _lastUpdate)
+                doStop(now, delta)
+
+                // FIX: Make sure the context converges
+                _flag = _flag or FLAG_INVALIDATE
+                scheduleUpdate(clock.millis())
             }
         }
     }
@@ -166,7 +178,7 @@ internal class SimResourceContextImpl(
      */
     fun shouldUpdate(timestamp: Long): Boolean {
         // Either the resource context is flagged or there is a pending update at this timestamp
-        return _flag != 0 || _deadline == timestamp
+        return _flag != 0 || _limit != _activeLimit || _deadline == timestamp
     }
 
     /**
@@ -179,18 +191,13 @@ internal class SimResourceContextImpl(
         }
 
         val lastUpdate = _lastUpdate
+
         _lastUpdate = now
         _updateActive = true
 
-        val reachedDeadline = _deadline <= now
         val delta = max(0, now - lastUpdate)
 
         try {
-            // Update the resource counters only if there is some progress
-            if (now > lastUpdate) {
-                logic.onUpdate(this, delta, _activeLimit, reachedDeadline)
-            }
-
             val duration = consumer.onNext(this, now, delta)
             val newDeadline = if (duration != Long.MAX_VALUE) now + duration else duration
 
@@ -200,12 +207,12 @@ internal class SimResourceContextImpl(
             // Check whether the state has changed after [consumer.onNext]
             when (_state) {
                 SimResourceState.Active -> {
-                    logic.onConsume(this, now, _limit, duration)
+                    logic.onConsume(this, now, delta, _limit, duration)
 
                     // Schedule an update at the new deadline
                     scheduleUpdate(now, newDeadline)
                 }
-                SimResourceState.Stopped -> doStop()
+                SimResourceState.Stopped -> doStop(now, delta)
                 SimResourceState.Pending -> throw IllegalStateException("Illegal transition to pending state")
             }
 
@@ -217,18 +224,12 @@ internal class SimResourceContextImpl(
             _deadline = newDeadline
             _rate = min(capacity, newLimit)
         } catch (cause: Throwable) {
-            doFail(cause)
+            doFail(now, delta, cause)
         } finally {
             _updateActive = false
         }
     }
 
-    override fun onConverge(timestamp: Long) {
-        if (_state == SimResourceState.Active) {
-            consumer.onEvent(this, SimResourceEvent.Run)
-        }
-    }
-
     /**
      * Prune the elapsed timers from this context.
      */
@@ -253,17 +254,35 @@ internal class SimResourceContextImpl(
         }
     }
 
+    /**
+     * This method is invoked when the system converges into a steady state.
+     */
+    fun onConverge(timestamp: Long) {
+        val delta = max(0, timestamp - _lastConvergence)
+        _lastConvergence = timestamp
+
+        try {
+            if (_state == SimResourceState.Active) {
+                consumer.onEvent(this, SimResourceEvent.Run)
+            }
+
+            logic.onConverge(this, timestamp, delta)
+        } catch (cause: Throwable) {
+            doFail(timestamp, max(0, timestamp - _lastUpdate), cause)
+        }
+    }
+
     override fun toString(): String = "SimResourceContextImpl[capacity=$capacity,rate=$_rate]"
 
     /**
      * Stop the resource context.
      */
-    private fun doStop() {
+    private fun doStop(now: Long, delta: Long) {
         try {
             consumer.onEvent(this, SimResourceEvent.Exit)
-            logic.onFinish(this)
+            logic.onFinish(this, now, delta)
         } catch (cause: Throwable) {
-            doFail(cause)
+            doFail(now, delta, cause)
         } finally {
             _deadline = Long.MAX_VALUE
             _limit = 0.0
@@ -273,7 +292,7 @@ internal class SimResourceContextImpl(
     /**
      * Fail the resource consumer.
      */
-    private fun doFail(cause: Throwable) {
+    private fun doFail(now: Long, delta: Long, cause: Throwable) {
         try {
             consumer.onFailure(this, cause)
         } catch (e: Throwable) {
@@ -281,7 +300,7 @@ internal class SimResourceContextImpl(
             e.printStackTrace()
         }
 
-        logic.onFinish(this)
+        logic.onFinish(this, now, delta)
     }
 
     /**
diff --git a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/impl/SimResourceInterpreterImpl.kt b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/impl/SimResourceInterpreterImpl.kt
index 2b6ec2ba..2abf0749 100644
--- a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/impl/SimResourceInterpreterImpl.kt
+++ b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/impl/SimResourceInterpreterImpl.kt
@@ -63,7 +63,7 @@ internal class SimResourceInterpreterImpl(private val context: CoroutineContext,
     /**
      * The systems that have been visited during the interpreter cycle.
      */
-    private val visited = linkedSetOf<SimResourceSystem>()
+    private val visited = linkedSetOf<SimResourceContextImpl>()
 
     /**
      * The index in the batch stack.
@@ -81,10 +81,7 @@ internal class SimResourceInterpreterImpl(private val context: CoroutineContext,
      */
     fun scheduleSync(now: Long, ctx: SimResourceContextImpl) {
         ctx.doUpdate(now)
-
-        if (visited.add(ctx)) {
-            collectAncestors(ctx, visited)
-        }
+        visited.add(ctx)
 
         // In-case the interpreter is already running in the call-stack, return immediately. The changes will be picked
         // up by the active interpreter.
@@ -143,11 +140,7 @@ internal class SimResourceInterpreterImpl(private val context: CoroutineContext,
         return timer
     }
 
-    override fun newContext(
-        consumer: SimResourceConsumer,
-        provider: SimResourceProviderLogic,
-        parent: SimResourceSystem?
-    ): SimResourceControllableContext = SimResourceContextImpl(parent, this, consumer, provider)
+    override fun newContext(consumer: SimResourceConsumer, provider: SimResourceProviderLogic): SimResourceControllableContext = SimResourceContextImpl(this, consumer, provider)
 
     override fun pushBatch() {
         batchIndex++
@@ -200,10 +193,7 @@ internal class SimResourceInterpreterImpl(private val context: CoroutineContext,
 
             if (ctx.shouldUpdate(now)) {
                 ctx.doUpdate(now)
-
-                if (visited.add(ctx)) {
-                    collectAncestors(ctx, visited)
-                }
+                visited.add(ctx)
             } else {
                 ctx.tryReschedule(now)
             }
@@ -218,10 +208,7 @@ internal class SimResourceInterpreterImpl(private val context: CoroutineContext,
 
                 if (ctx.shouldUpdate(now)) {
                     ctx.doUpdate(now)
-
-                    if (visited.add(ctx)) {
-                        collectAncestors(ctx, visited)
-                    }
+                    visited.add(ctx)
                 }
             }
 
@@ -239,17 +226,6 @@ internal class SimResourceInterpreterImpl(private val context: CoroutineContext,
         }
     }
 
-    /**
-     * Collect all the ancestors of the specified [system].
-     */
-    private tailrec fun collectAncestors(system: SimResourceSystem, systems: MutableSet<SimResourceSystem>) {
-        val parent = system.parent
-        if (parent != null) {
-            systems.add(parent)
-            collectAncestors(parent, systems)
-        }
-    }
-
     /**
      * Try to schedule an interpreter invocation at the specified [target].
      *
diff --git a/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceContextTest.kt b/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceContextTest.kt
index c7230a0e..1428ce42 100644
--- a/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceContextTest.kt
+++ b/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceContextTest.kt
@@ -50,7 +50,7 @@ class SimResourceContextTest {
         }
 
         val logic = object : SimResourceProviderLogic {}
-        val context = SimResourceContextImpl(null, interpreter, consumer, logic)
+        val context = SimResourceContextImpl(interpreter, consumer, logic)
 
         interpreter.scheduleSync(interpreter.clock.millis(), context)
     }
@@ -60,18 +60,15 @@ class SimResourceContextTest {
         val interpreter = SimResourceInterpreterImpl(coroutineContext, clock)
         val consumer = SimWorkConsumer(1.0, 1.0)
 
-        val logic = spyk(object : SimResourceProviderLogic {
-            override fun onFinish(ctx: SimResourceControllableContext) {}
-            override fun onConsume(ctx: SimResourceControllableContext, now: Long, limit: Double, duration: Long): Long = duration
-        })
-        val context = SimResourceContextImpl(null, interpreter, consumer, logic)
+        val logic = spyk(object : SimResourceProviderLogic {})
+        val context = SimResourceContextImpl(interpreter, consumer, logic)
         context.capacity = 1.0
 
         context.start()
         delay(1) // Delay 1 ms to prevent hitting the fast path
         interpreter.scheduleSync(interpreter.clock.millis(), context)
 
-        verify(exactly = 2) { logic.onConsume(any(), any(), any(), any()) }
+        verify(exactly = 2) { logic.onConsume(any(), any(), any(), any(), any()) }
     }
 
     @Test
@@ -80,7 +77,7 @@ class SimResourceContextTest {
         val consumer = SimWorkConsumer(1.0, 1.0)
 
         val logic = spyk(object : SimResourceProviderLogic {})
-        val context = SimResourceContextImpl(null, interpreter, consumer, logic)
+        val context = SimResourceContextImpl(interpreter, consumer, logic)
         context.capacity = 1.0
 
         context.start()
@@ -90,8 +87,8 @@ class SimResourceContextTest {
         context.invalidate()
 
         assertAll(
-            { verify(exactly = 2) { logic.onConsume(any(), any(), any(), any()) } },
-            { verify(exactly = 1) { logic.onFinish(any()) } }
+            { verify(exactly = 2) { logic.onConsume(any(), any(), any(), any(), any()) } },
+            { verify(exactly = 1) { logic.onFinish(any(), any(), any()) } }
         )
     }
 
@@ -111,7 +108,7 @@ class SimResourceContextTest {
         }
 
         val logic = object : SimResourceProviderLogic {}
-        val context = SimResourceContextImpl(null, interpreter, consumer, logic)
+        val context = SimResourceContextImpl(interpreter, consumer, logic)
 
         context.start()
 
@@ -136,8 +133,7 @@ class SimResourceContextTest {
         })
 
         val logic = object : SimResourceProviderLogic {}
-
-        val context = SimResourceContextImpl(null, interpreter, consumer, logic)
+        val context = SimResourceContextImpl(interpreter, consumer, logic)
         context.capacity = 4200.0
         context.start()
         context.capacity = 4200.0
@@ -166,7 +162,7 @@ class SimResourceContextTest {
 
         val logic = object : SimResourceProviderLogic {}
 
-        val context = SimResourceContextImpl(null, interpreter, consumer, logic)
+        val context = SimResourceContextImpl(interpreter, consumer, logic)
 
         context.start()
 
diff --git a/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceTransformerTest.kt b/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceTransformerTest.kt
index fc43c3da..d7d0924f 100644
--- a/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceTransformerTest.kt
+++ b/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceTransformerTest.kt
@@ -223,6 +223,9 @@ internal class SimResourceTransformerTest {
 
         forwarder.consume(consumer)
 
+        yield()
+
+        assertEquals(2.0, source.counters.actual)
         assertEquals(source.counters.actual, forwarder.counters.actual) { "Actual work" }
         assertEquals(source.counters.demand, forwarder.counters.demand) { "Work demand" }
         assertEquals(source.counters.overcommit, forwarder.counters.overcommit) { "Overcommitted work" }
-- 
cgit v1.2.3


From 7703fc9fcc847208b1803a58d9eaa5938d2c77a1 Mon Sep 17 00:00:00 2001
From: Fabian Mastenbroek <mail.fabianm@gmail.com>
Date: Wed, 29 Sep 2021 15:02:38 +0200
Subject: refactor(simulator): Do not expose SimResourceState

This change hides the SimResourceState from public API since it is not
actively used outside of the `SimResourceContextImpl` class.
---
 .../resources/SimResourceControllableContext.kt    |  5 ---
 .../opendc/simulator/resources/SimResourceState.kt | 43 -------------------
 .../resources/impl/SimResourceContextImpl.kt       | 50 +++++++++++++++-------
 3 files changed, 34 insertions(+), 64 deletions(-)
 delete mode 100644 opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceState.kt

(limited to 'opendc-simulator/opendc-simulator-resources')

diff --git a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceControllableContext.kt b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceControllableContext.kt
index ba52b597..b406b896 100644
--- a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceControllableContext.kt
+++ b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceControllableContext.kt
@@ -28,11 +28,6 @@ package org.opendc.simulator.resources
  * This interface is used by resource providers to control the resource context.
  */
 public interface SimResourceControllableContext : SimResourceContext {
-    /**
-     * The state of the resource context.
-     */
-    public val state: SimResourceState
-
     /**
      * The capacity of the resource.
      */
diff --git a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceState.kt b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceState.kt
deleted file mode 100644
index c72951d0..00000000
--- a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceState.kt
+++ /dev/null
@@ -1,43 +0,0 @@
-/*
- * Copyright (c) 2021 AtLarge Research
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-package org.opendc.simulator.resources
-
-/**
- * The state of a resource provider.
- */
-public enum class SimResourceState {
-    /**
-     * The resource provider is pending and the resource is waiting to be consumed.
-     */
-    Pending,
-
-    /**
-     * The resource provider is active and the resource is currently being consumed.
-     */
-    Active,
-
-    /**
-     * The resource provider is stopped and the resource cannot be consumed anymore.
-     */
-    Stopped
-}
diff --git a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/impl/SimResourceContextImpl.kt b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/impl/SimResourceContextImpl.kt
index 5a9ffe2d..cbfa7afd 100644
--- a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/impl/SimResourceContextImpl.kt
+++ b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/impl/SimResourceContextImpl.kt
@@ -60,9 +60,7 @@ internal class SimResourceContextImpl(
     /**
      * A flag to indicate the state of the context.
      */
-    override val state: SimResourceState
-        get() = _state
-    private var _state = SimResourceState.Pending
+    private var _state = State.Pending
 
     /**
      * The current processing speed of the resource.
@@ -106,21 +104,21 @@ internal class SimResourceContextImpl(
     private val _timers: ArrayDeque<SimResourceInterpreterImpl.Timer> = ArrayDeque()
 
     override fun start() {
-        check(_state == SimResourceState.Pending) { "Consumer is already started" }
+        check(_state == State.Pending) { "Consumer is already started" }
         interpreter.batch {
             consumer.onEvent(this, SimResourceEvent.Start)
-            _state = SimResourceState.Active
+            _state = State.Active
             interrupt()
         }
     }
 
     override fun close() {
-        if (_state == SimResourceState.Stopped) {
+        if (_state == State.Stopped) {
             return
         }
 
         interpreter.batch {
-            _state = SimResourceState.Stopped
+            _state = State.Stopped
             if (!_updateActive) {
                 val now = clock.millis()
                 val delta = max(0, now - _lastUpdate)
@@ -134,7 +132,7 @@ internal class SimResourceContextImpl(
     }
 
     override fun interrupt() {
-        if (_state == SimResourceState.Stopped) {
+        if (_state == State.Stopped) {
             return
         }
 
@@ -143,7 +141,7 @@ internal class SimResourceContextImpl(
     }
 
     override fun invalidate() {
-        if (_state == SimResourceState.Stopped) {
+        if (_state == State.Stopped) {
             return
         }
 
@@ -152,7 +150,7 @@ internal class SimResourceContextImpl(
     }
 
     override fun flush() {
-        if (_state == SimResourceState.Stopped) {
+        if (_state == State.Stopped) {
             return
         }
 
@@ -186,7 +184,7 @@ internal class SimResourceContextImpl(
      */
     fun doUpdate(now: Long) {
         val oldState = _state
-        if (oldState != SimResourceState.Active) {
+        if (oldState != State.Active) {
             return
         }
 
@@ -206,14 +204,14 @@ internal class SimResourceContextImpl(
 
             // Check whether the state has changed after [consumer.onNext]
             when (_state) {
-                SimResourceState.Active -> {
+                State.Active -> {
                     logic.onConsume(this, now, delta, _limit, duration)
 
                     // Schedule an update at the new deadline
                     scheduleUpdate(now, newDeadline)
                 }
-                SimResourceState.Stopped -> doStop(now, delta)
-                SimResourceState.Pending -> throw IllegalStateException("Illegal transition to pending state")
+                State.Stopped -> doStop(now, delta)
+                State.Pending -> throw IllegalStateException("Illegal transition to pending state")
             }
 
             // Note: pending limit might be changed by [logic.onConsume], so re-fetch the value
@@ -262,7 +260,7 @@ internal class SimResourceContextImpl(
         _lastConvergence = timestamp
 
         try {
-            if (_state == SimResourceState.Active) {
+            if (_state == State.Active) {
                 consumer.onEvent(this, SimResourceEvent.Run)
             }
 
@@ -308,7 +306,7 @@ internal class SimResourceContextImpl(
      */
     private fun onCapacityChange() {
         // Do not inform the consumer if it has not been started yet
-        if (state != SimResourceState.Active) {
+        if (_state != State.Active) {
             return
         }
 
@@ -337,6 +335,26 @@ internal class SimResourceContextImpl(
         }
     }
 
+    /**
+     * The state of a resource context.
+     */
+    private enum class State {
+        /**
+         * The resource context is pending and the resource is waiting to be consumed.
+         */
+        Pending,
+
+        /**
+         * The resource context is active and the resource is currently being consumed.
+         */
+        Active,
+
+        /**
+         * The resource context is stopped and the resource cannot be consumed anymore.
+         */
+        Stopped
+    }
+
     /**
      * A flag to indicate that the context should be invalidated.
      */
-- 
cgit v1.2.3


From 0272738f3ba5faeb0b5463464ff2d961136bb317 Mon Sep 17 00:00:00 2001
From: Fabian Mastenbroek <mail.fabianm@gmail.com>
Date: Wed, 29 Sep 2021 15:04:54 +0200
Subject: refactor(simulator): Remove SimResourceFlow interface

---
 .../opendc/simulator/resources/SimResourceFlow.kt  | 29 ----------------------
 .../simulator/resources/SimResourceTransformer.kt  |  5 ++--
 2 files changed, 3 insertions(+), 31 deletions(-)
 delete mode 100644 opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceFlow.kt

(limited to 'opendc-simulator/opendc-simulator-resources')

diff --git a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceFlow.kt b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceFlow.kt
deleted file mode 100644
index bbf6ad44..00000000
--- a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceFlow.kt
+++ /dev/null
@@ -1,29 +0,0 @@
-/*
- * Copyright (c) 2021 AtLarge Research
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-package org.opendc.simulator.resources
-
-/**
- * A [SimResourceFlow] acts as both a resource consumer and resource provider at the same time, simplifying bridging
- * between different components.
- */
-public interface SimResourceFlow : SimResourceConsumer, SimResourceProvider
diff --git a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceTransformer.kt b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceTransformer.kt
index 397463e0..76a3bdd7 100644
--- a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceTransformer.kt
+++ b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceTransformer.kt
@@ -26,7 +26,8 @@ import org.opendc.simulator.resources.impl.SimResourceCountersImpl
 import java.time.Clock
 
 /**
- * A [SimResourceFlow] that transforms the resource commands emitted by the resource commands to the resource provider.
+ * A [SimResourceConsumer] and [SimResourceProvider] that transforms the resource commands emitted by the resource
+ * commands to the resource provider.
  *
  * @param isCoupled A flag to indicate that the transformer will exit when the resource consumer exits.
  * @param transform The function to transform the received resource command.
@@ -34,7 +35,7 @@ import java.time.Clock
 public class SimResourceTransformer(
     private val isCoupled: Boolean = false,
     private val transform: (SimResourceContext, Long) -> Long
-) : SimResourceFlow, AutoCloseable {
+) : SimResourceConsumer, SimResourceProvider, AutoCloseable {
     /**
      * The delegate [SimResourceConsumer].
      */
-- 
cgit v1.2.3


From d2f15fd7fd16922c11b0dcaa8807e8a321859773 Mon Sep 17 00:00:00 2001
From: Fabian Mastenbroek <mail.fabianm@gmail.com>
Date: Wed, 29 Sep 2021 22:05:03 +0200
Subject: refactor(simulator): Merge distributor and aggregator into switch

This change removes the distributor and aggregator interfaces in favour
of a single switch interface. Since the switch interface is as powerful
as both the distributor and aggregator, we don't need the latter two.
---
 .../resources/SimAbstractResourceAggregator.kt     | 147 ---------
 .../simulator/resources/SimResourceAggregator.kt   |  38 ---
 .../resources/SimResourceAggregatorMaxMin.kt       |  64 ----
 .../resources/SimResourceCloseableProvider.kt      |  37 ---
 .../simulator/resources/SimResourceCounters.kt     |   5 +
 .../simulator/resources/SimResourceDistributor.kt  |  42 ---
 .../resources/SimResourceDistributorMaxMin.kt      | 332 -------------------
 .../simulator/resources/SimResourceSwitch.kt       |  16 +-
 .../resources/SimResourceSwitchExclusive.kt        |  64 ++--
 .../simulator/resources/SimResourceSwitchMaxMin.kt | 361 +++++++++++++++++++--
 .../resources/impl/SimResourceCountersImpl.kt      |   6 +-
 .../resources/SimResourceAggregatorMaxMinTest.kt   | 190 -----------
 .../resources/SimResourceSwitchExclusiveTest.kt    |  28 +-
 .../resources/SimResourceSwitchMaxMinTest.kt       |   6 +-
 14 files changed, 405 insertions(+), 931 deletions(-)
 delete mode 100644 opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimAbstractResourceAggregator.kt
 delete mode 100644 opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceAggregator.kt
 delete mode 100644 opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceAggregatorMaxMin.kt
 delete mode 100644 opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceCloseableProvider.kt
 delete mode 100644 opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceDistributor.kt
 delete mode 100644 opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceDistributorMaxMin.kt
 delete mode 100644 opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceAggregatorMaxMinTest.kt

(limited to 'opendc-simulator/opendc-simulator-resources')

diff --git a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimAbstractResourceAggregator.kt b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimAbstractResourceAggregator.kt
deleted file mode 100644
index 621ea6e7..00000000
--- a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimAbstractResourceAggregator.kt
+++ /dev/null
@@ -1,147 +0,0 @@
-/*
- * Copyright (c) 2021 AtLarge Research
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-package org.opendc.simulator.resources
-
-/**
- * Abstract implementation of [SimResourceAggregator].
- */
-public abstract class SimAbstractResourceAggregator(
-    interpreter: SimResourceInterpreter,
-    parent: SimResourceSystem?
-) : SimResourceAggregator {
-    /**
-     * This method is invoked when the resource consumer consumes resources.
-     */
-    protected abstract fun doConsume(limit: Double)
-
-    /**
-     * This method is invoked when the resource consumer finishes processing.
-     */
-    protected abstract fun doFinish()
-
-    /**
-     * This method is invoked when an input context is started.
-     */
-    protected abstract fun onInputStarted(input: SimResourceContext)
-
-    /**
-     * This method is invoked when an input is stopped.
-     */
-    protected abstract fun onInputFinished(input: SimResourceContext)
-
-    /* SimResourceAggregator */
-    override fun addInput(input: SimResourceProvider) {
-        val consumer = Consumer()
-        _inputs.add(input)
-        _inputConsumers.add(consumer)
-        input.startConsumer(consumer)
-    }
-
-    override val inputs: Set<SimResourceProvider>
-        get() = _inputs
-    private val _inputs = mutableSetOf<SimResourceProvider>()
-    private val _inputConsumers = mutableListOf<Consumer>()
-
-    /* SimResourceProvider */
-    override val isActive: Boolean
-        get() = _output.isActive
-
-    override val capacity: Double
-        get() = _output.capacity
-
-    override val speed: Double
-        get() = _output.speed
-
-    override val demand: Double
-        get() = _output.demand
-
-    override val counters: SimResourceCounters
-        get() = _output.counters
-
-    override fun startConsumer(consumer: SimResourceConsumer) {
-        _output.startConsumer(consumer)
-    }
-
-    override fun cancel() {
-        _output.cancel()
-    }
-
-    override fun interrupt() {
-        _output.interrupt()
-    }
-
-    private val _output = object : SimAbstractResourceProvider(interpreter, initialCapacity = 0.0) {
-        override fun createLogic(): SimResourceProviderLogic {
-            return object : SimResourceProviderLogic {
-
-                override fun onConsume(ctx: SimResourceControllableContext, now: Long, delta: Long, limit: Double, duration: Long) {
-                    updateCounters(ctx, delta)
-                    doConsume(limit)
-                }
-
-                override fun onFinish(ctx: SimResourceControllableContext, now: Long, delta: Long) {
-                    updateCounters(ctx, delta)
-                    doFinish()
-                }
-
-                override fun onConverge(ctx: SimResourceControllableContext, now: Long, delta: Long) {
-                    parent?.onConverge(now)
-                }
-            }
-        }
-    }
-
-    /**
-     * An internal [SimResourceConsumer] implementation for aggregator inputs.
-     */
-    private inner class Consumer : SimResourceConsumer {
-        /**
-         * The resource context associated with the input.
-         */
-        private var _ctx: SimResourceContext? = null
-
-        private fun updateCapacity() {
-            // Adjust capacity of output resource
-            _output.capacity = _inputConsumers.sumOf { it._ctx?.capacity ?: 0.0 }
-        }
-
-        /* SimResourceConsumer */
-        override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
-            return Long.MAX_VALUE
-        }
-
-        override fun onEvent(ctx: SimResourceContext, event: SimResourceEvent) {
-            when (event) {
-                SimResourceEvent.Start -> {
-                    _ctx = ctx
-                    updateCapacity()
-
-                    onInputStarted(ctx)
-                }
-                SimResourceEvent.Capacity -> updateCapacity()
-                SimResourceEvent.Exit -> onInputFinished(ctx)
-                else -> {}
-            }
-        }
-    }
-}
diff --git a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceAggregator.kt b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceAggregator.kt
deleted file mode 100644
index 00972f43..00000000
--- a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceAggregator.kt
+++ /dev/null
@@ -1,38 +0,0 @@
-/*
- * Copyright (c) 2021 AtLarge Research
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-package org.opendc.simulator.resources
-
-/**
- * A [SimResourceAggregator] aggregates the capacity of multiple resources into a single resource.
- */
-public interface SimResourceAggregator : SimResourceProvider {
-    /**
-     * The input resources that will be switched between the output providers.
-     */
-    public val inputs: Set<SimResourceProvider>
-
-    /**
-     * Add the specified [input] to the aggregator.
-     */
-    public fun addInput(input: SimResourceProvider)
-}
diff --git a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceAggregatorMaxMin.kt b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceAggregatorMaxMin.kt
deleted file mode 100644
index f131ac6c..00000000
--- a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceAggregatorMaxMin.kt
+++ /dev/null
@@ -1,64 +0,0 @@
-/*
- * Copyright (c) 2021 AtLarge Research
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-package org.opendc.simulator.resources
-
-/**
- * A [SimResourceAggregator] that distributes the load equally across the input resources.
- */
-public class SimResourceAggregatorMaxMin(
-    interpreter: SimResourceInterpreter,
-    parent: SimResourceSystem? = null
-) : SimAbstractResourceAggregator(interpreter, parent) {
-    private val consumers = mutableListOf<SimResourceContext>()
-
-    override fun doConsume(limit: Double) {
-        // Sort all consumers by their capacity
-        consumers.sortWith(compareBy { it.capacity })
-
-        // Divide the requests over the available capacity of the input resources fairly
-        for (input in consumers) {
-            val inputCapacity = input.capacity
-            val fraction = inputCapacity / capacity
-            val grantedSpeed = limit * fraction
-
-            input.push(grantedSpeed)
-            input.interrupt()
-        }
-    }
-
-    override fun doFinish() {
-        val iterator = consumers.iterator()
-        for (input in iterator) {
-            iterator.remove()
-            input.close()
-        }
-    }
-
-    override fun onInputStarted(input: SimResourceContext) {
-        consumers.add(input)
-    }
-
-    override fun onInputFinished(input: SimResourceContext) {
-        consumers.remove(input)
-    }
-}
diff --git a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceCloseableProvider.kt b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceCloseableProvider.kt
deleted file mode 100644
index bce8274b..00000000
--- a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceCloseableProvider.kt
+++ /dev/null
@@ -1,37 +0,0 @@
-/*
- * Copyright (c) 2021 AtLarge Research
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-package org.opendc.simulator.resources
-
-/**
- * A [SimResourceProvider] that has a controllable and limited lifetime.
- *
- * This interface is used to signal that the resource provider may be closed and not reused after that point.
- */
-public interface SimResourceCloseableProvider : SimResourceProvider, AutoCloseable {
-    /**
-     * End the lifetime of the resource provider.
-     *
-     * This operation cancels the existing resource consumer and prevents the resource provider from being reused.
-     */
-    public override fun close()
-}
diff --git a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceCounters.kt b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceCounters.kt
index 725aa5bc..11924db2 100644
--- a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceCounters.kt
+++ b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceCounters.kt
@@ -41,6 +41,11 @@ public interface SimResourceCounters {
      */
     public val overcommit: Double
 
+    /**
+     * The amount of work lost due to interference.
+     */
+    public val interference: Double
+
     /**
      * Reset the resource counters.
      */
diff --git a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceDistributor.kt b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceDistributor.kt
deleted file mode 100644
index f384582f..00000000
--- a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceDistributor.kt
+++ /dev/null
@@ -1,42 +0,0 @@
-/*
- * Copyright (c) 2021 AtLarge Research
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-package org.opendc.simulator.resources
-
-import org.opendc.simulator.resources.interference.InterferenceKey
-
-/**
- * A [SimResourceDistributor] distributes the capacity of some resource over multiple resource consumers.
- */
-public interface SimResourceDistributor : SimResourceConsumer {
-    /**
-     * The output resource providers to which resource consumers can be attached.
-     */
-    public val outputs: Set<SimResourceCloseableProvider>
-
-    /**
-     * Create a new output for the distributor.
-     *
-     * @param key The key of the interference member to which the output belongs.
-     */
-    public fun newOutput(key: InterferenceKey? = null): SimResourceCloseableProvider
-}
diff --git a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceDistributorMaxMin.kt b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceDistributorMaxMin.kt
deleted file mode 100644
index 7df940ad..00000000
--- a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceDistributorMaxMin.kt
+++ /dev/null
@@ -1,332 +0,0 @@
-/*
- * Copyright (c) 2021 AtLarge Research
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-package org.opendc.simulator.resources
-
-import org.opendc.simulator.resources.interference.InterferenceDomain
-import org.opendc.simulator.resources.interference.InterferenceKey
-import kotlin.math.max
-import kotlin.math.min
-
-/**
- * A [SimResourceDistributor] that distributes the capacity of a resource over consumers using max-min fair sharing.
- *
- * @param interpreter The interpreter for managing the resource contexts.
- * @param parent The parent resource system of the distributor.
- * @param interferenceDomain The interference domain of the distributor.
- */
-public class SimResourceDistributorMaxMin(
-    private val interpreter: SimResourceInterpreter,
-    private val parent: SimResourceSystem? = null,
-    private val interferenceDomain: InterferenceDomain? = null
-) : SimResourceDistributor {
-    override val outputs: Set<SimResourceCloseableProvider>
-        get() = _outputs
-    private val _outputs = mutableSetOf<Output>()
-
-    /**
-     * The resource context of the consumer.
-     */
-    private var ctx: SimResourceContext? = null
-
-    /**
-     * The active outputs.
-     */
-    private val activeOutputs: MutableList<Output> = mutableListOf()
-
-    /**
-     * The total allocated speed for the output resources.
-     */
-    private var totalAllocatedSpeed = 0.0
-
-    /**
-     * The total requested speed for the output resources.
-     */
-    private var totalRequestedSpeed = 0.0
-
-    /**
-     * The resource counters of this distributor.
-     */
-    public val counters: Counters
-        get() = _counters
-    private val _counters = object : Counters {
-        override var demand: Double = 0.0
-        override var actual: Double = 0.0
-        override var overcommit: Double = 0.0
-        override var interference: Double = 0.0
-
-        override fun reset() {
-            demand = 0.0
-            actual = 0.0
-            overcommit = 0.0
-            interference = 0.0
-        }
-
-        override fun toString(): String = "SimResourceDistributorMaxMin.Counters[demand=$demand,actual=$actual,overcommit=$overcommit,interference=$interference]"
-    }
-
-    /* SimResourceDistributor */
-    override fun newOutput(key: InterferenceKey?): SimResourceCloseableProvider {
-        val provider = Output(ctx?.capacity ?: 0.0, key)
-        _outputs.add(provider)
-        return provider
-    }
-
-    /* SimResourceConsumer */
-    override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
-        // If there is no work yet, mark the input as idle.
-        if (activeOutputs.isEmpty()) {
-            return Long.MAX_VALUE
-        }
-
-        val capacity = ctx.capacity
-        var duration: Long = Long.MAX_VALUE
-        var availableSpeed = capacity
-        var totalRequestedSpeed = 0.0
-
-        // Pull in the work of the outputs
-        val outputIterator = activeOutputs.listIterator()
-        for (output in outputIterator) {
-            output.pull(now)
-
-            // Remove outputs that have finished
-            if (!output.isActive) {
-                outputIterator.remove()
-            }
-        }
-
-        // Sort in-place the outputs based on their requested usage.
-        // Profiling shows that it is faster than maintaining some kind of sorted set.
-        activeOutputs.sort()
-
-        // Divide the available input capacity fairly across the outputs using max-min fair sharing
-        var remaining = activeOutputs.size
-        for (output in activeOutputs) {
-            val availableShare = availableSpeed / remaining--
-            val grantedSpeed = min(output.allowedSpeed, availableShare)
-
-            duration = min(duration, output.duration)
-
-            // Ignore idle computation
-            if (grantedSpeed <= 0.0) {
-                output.actualSpeed = 0.0
-                continue
-            }
-
-            totalRequestedSpeed += output.limit
-
-            output.actualSpeed = grantedSpeed
-            availableSpeed -= grantedSpeed
-        }
-
-        val durationS = duration / 1000.0
-        var totalRequestedWork = 0.0
-        var totalAllocatedWork = 0.0
-        for (output in activeOutputs) {
-            val limit = output.limit
-            val speed = output.actualSpeed
-            if (speed > 0.0) {
-                totalRequestedWork += limit * durationS
-                totalAllocatedWork += speed * durationS
-            }
-        }
-
-        this.totalRequestedSpeed = totalRequestedSpeed
-        val totalAllocatedSpeed = capacity - availableSpeed
-        this.totalAllocatedSpeed = totalAllocatedSpeed
-
-        ctx.push(totalAllocatedSpeed)
-        return duration
-    }
-
-    override fun onEvent(ctx: SimResourceContext, event: SimResourceEvent) {
-        when (event) {
-            SimResourceEvent.Start -> {
-                this.ctx = ctx
-                updateCapacity(ctx)
-            }
-            SimResourceEvent.Exit -> {
-                val iterator = _outputs.iterator()
-                while (iterator.hasNext()) {
-                    val output = iterator.next()
-
-                    // Remove the output from the outputs to prevent ConcurrentModificationException when removing it
-                    // during the call to output.close()
-                    iterator.remove()
-
-                    output.close()
-                }
-            }
-            SimResourceEvent.Capacity -> updateCapacity(ctx)
-            else -> {}
-        }
-    }
-
-    /**
-     * Extended [SimResourceCounters] interface for the distributor.
-     */
-    public interface Counters : SimResourceCounters {
-        /**
-         * The amount of work lost due to interference.
-         */
-        public val interference: Double
-    }
-
-    private fun updateCapacity(ctx: SimResourceContext) {
-        for (output in _outputs) {
-            output.capacity = ctx.capacity
-        }
-    }
-
-    /**
-     * An internal [SimResourceProvider] implementation for switch outputs.
-     */
-    private inner class Output(capacity: Double, val key: InterferenceKey?) :
-        SimAbstractResourceProvider(interpreter, capacity),
-        SimResourceCloseableProvider,
-        SimResourceProviderLogic,
-        Comparable<Output> {
-        /**
-         * A flag to indicate that the output is closed.
-         */
-        private var isClosed: Boolean = false
-
-        /**
-         * The requested limit.
-         */
-        @JvmField var limit: Double = 0.0
-
-        /**
-         * The current deadline.
-         */
-        @JvmField var duration: Long = Long.MAX_VALUE
-
-        /**
-         * The processing speed that is allowed by the model constraints.
-         */
-        @JvmField var allowedSpeed: Double = 0.0
-
-        /**
-         * The actual processing speed.
-         */
-        @JvmField var actualSpeed: Double = 0.0
-
-        /**
-         * The timestamp at which we received the last command.
-         */
-        private var lastCommandTimestamp: Long = Long.MIN_VALUE
-
-        /* SimAbstractResourceProvider */
-        override fun createLogic(): SimResourceProviderLogic = this
-
-        override fun start(ctx: SimResourceControllableContext) {
-            check(!isClosed) { "Cannot re-use closed output" }
-
-            activeOutputs += this
-            interpreter.batch {
-                ctx.start()
-                // Interrupt the input to re-schedule the resources
-                this@SimResourceDistributorMaxMin.ctx?.interrupt()
-            }
-        }
-
-        override fun close() {
-            isClosed = true
-            cancel()
-            _outputs.remove(this)
-        }
-
-        /* SimResourceProviderLogic */
-        override fun onConsume(
-            ctx: SimResourceControllableContext,
-            now: Long,
-            delta: Long,
-            limit: Double,
-            duration: Long
-        ) {
-            doUpdateCounters(delta)
-
-            allowedSpeed = min(ctx.capacity, limit)
-            actualSpeed = 0.0
-            this.limit = limit
-            this.duration = duration
-            lastCommandTimestamp = now
-        }
-
-        override fun onConverge(ctx: SimResourceControllableContext, now: Long, delta: Long) {
-            parent?.onConverge(now)
-        }
-
-        override fun onFinish(ctx: SimResourceControllableContext, now: Long, delta: Long) {
-            doUpdateCounters(delta)
-
-            limit = 0.0
-            duration = Long.MAX_VALUE
-            actualSpeed = 0.0
-            allowedSpeed = 0.0
-            lastCommandTimestamp = now
-        }
-
-        /* Comparable */
-        override fun compareTo(other: Output): Int = allowedSpeed.compareTo(other.allowedSpeed)
-
-        /**
-         * Pull the next command if necessary.
-         */
-        fun pull(now: Long) {
-            val ctx = ctx
-            if (ctx != null && lastCommandTimestamp < now) {
-                ctx.flush()
-            }
-        }
-
-        /**
-         * Helper method to update the resource counters of the distributor.
-         */
-        private fun doUpdateCounters(delta: Long) {
-            if (delta <= 0L) {
-                return
-            }
-
-            // Compute the performance penalty due to resource interference
-            val perfScore = if (interferenceDomain != null) {
-                val load = totalAllocatedSpeed / requireNotNull(this@SimResourceDistributorMaxMin.ctx).capacity
-                interferenceDomain.apply(key, load)
-            } else {
-                1.0
-            }
-
-            val deltaS = delta / 1000.0
-            val work = limit * deltaS
-            val actualWork = actualSpeed * deltaS
-            val remainingWork = work - actualWork
-
-            updateCounters(work, actualWork, remainingWork)
-
-            val distCounters = _counters
-            distCounters.demand += work
-            distCounters.actual += actualWork
-            distCounters.overcommit += remainingWork
-            distCounters.interference += actualWork * max(0.0, 1 - perfScore)
-        }
-    }
-}
diff --git a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceSwitch.kt b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceSwitch.kt
index d2aab634..3c25b76d 100644
--- a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceSwitch.kt
+++ b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceSwitch.kt
@@ -27,11 +27,11 @@ import org.opendc.simulator.resources.interference.InterferenceKey
 /**
  * A [SimResourceSwitch] enables switching of capacity of multiple resources between multiple consumers.
  */
-public interface SimResourceSwitch : AutoCloseable {
+public interface SimResourceSwitch {
     /**
      * The output resource providers to which resource consumers can be attached.
      */
-    public val outputs: Set<SimResourceCloseableProvider>
+    public val outputs: Set<SimResourceProvider>
 
     /**
      * The input resources that will be switched between the output providers.
@@ -48,10 +48,20 @@ public interface SimResourceSwitch : AutoCloseable {
      *
      * @param key The key of the interference member to which the output belongs.
      */
-    public fun newOutput(key: InterferenceKey? = null): SimResourceCloseableProvider
+    public fun newOutput(key: InterferenceKey? = null): SimResourceProvider
+
+    /**
+     * Remove [output] from this switch.
+     */
+    public fun removeOutput(output: SimResourceProvider)
 
     /**
      * Add the specified [input] to the switch.
      */
     public fun addInput(input: SimResourceProvider)
+
+    /**
+     * Clear all inputs and outputs from the switch.
+     */
+    public fun clear()
 }
diff --git a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceSwitchExclusive.kt b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceSwitchExclusive.kt
index fbb541e5..2be8ccb0 100644
--- a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceSwitchExclusive.kt
+++ b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceSwitchExclusive.kt
@@ -27,23 +27,17 @@ import java.util.ArrayDeque
 
 /**
  * A [SimResourceSwitch] implementation that allocates outputs to the inputs of the switch exclusively. This means that
- * a single output is directly connected to an input and that the switch can only support as much outputs as inputs.
+ * a single output is directly connected to an input and that the switch can only support as many outputs as inputs.
  */
 public class SimResourceSwitchExclusive : SimResourceSwitch {
-    /**
-     * A flag to indicate that the switch is closed.
-     */
-    private var isClosed: Boolean = false
-
-    private val _outputs = mutableSetOf<Provider>()
-    override val outputs: Set<SimResourceCloseableProvider>
+    override val outputs: Set<SimResourceProvider>
         get() = _outputs
-
-    private val availableResources = ArrayDeque<SimResourceTransformer>()
+    private val _outputs = mutableSetOf<Output>()
 
     private val _inputs = mutableSetOf<SimResourceProvider>()
     override val inputs: Set<SimResourceProvider>
         get() = _inputs
+    private val _availableInputs = ArrayDeque<SimResourceTransformer>()
 
     override val counters: SimResourceCounters = object : SimResourceCounters {
         override val demand: Double
@@ -52,6 +46,8 @@ public class SimResourceSwitchExclusive : SimResourceSwitch {
             get() = _inputs.sumOf { it.counters.actual }
         override val overcommit: Double
             get() = _inputs.sumOf { it.counters.overcommit }
+        override val interference: Double
+            get() = _inputs.sumOf { it.counters.interference }
 
         override fun reset() {
             for (input in _inputs) {
@@ -65,18 +61,25 @@ public class SimResourceSwitchExclusive : SimResourceSwitch {
     /**
      * Add an output to the switch.
      */
-    override fun newOutput(key: InterferenceKey?): SimResourceCloseableProvider {
-        check(!isClosed) { "Switch has been closed" }
-        check(availableResources.isNotEmpty()) { "No capacity to serve request" }
-        val forwarder = availableResources.poll()
-        val output = Provider(forwarder)
+    override fun newOutput(key: InterferenceKey?): SimResourceProvider {
+        val forwarder = checkNotNull(_availableInputs.poll()) { "No capacity to serve request" }
+        val output = Output(forwarder)
         _outputs += output
         return output
     }
 
-    override fun addInput(input: SimResourceProvider) {
-        check(!isClosed) { "Switch has been closed" }
+    override fun removeOutput(output: SimResourceProvider) {
+        if (!_outputs.remove(output)) {
+            return
+        }
+
+        (output as Output).close()
+    }
 
+    /**
+     * Add an input to the switch.
+     */
+    override fun addInput(input: SimResourceProvider) {
         if (input in inputs) {
             return
         }
@@ -84,7 +87,7 @@ public class SimResourceSwitchExclusive : SimResourceSwitch {
         val forwarder = SimResourceForwarder()
 
         _inputs += input
-        availableResources += forwarder
+        _availableInputs += forwarder
 
         input.startConsumer(object : SimResourceConsumer by forwarder {
             override fun onEvent(ctx: SimResourceContext, event: SimResourceEvent) {
@@ -98,18 +101,29 @@ public class SimResourceSwitchExclusive : SimResourceSwitch {
         })
     }
 
-    override fun close() {
-        isClosed = true
+    override fun clear() {
+        for (input in _inputs) {
+            input.cancel()
+        }
+        _inputs.clear()
 
-        // Cancel all upstream subscriptions
-        _inputs.forEach(SimResourceProvider::cancel)
+        // Outputs are implicitly cancelled by the inputs forwarders
+        _outputs.clear()
     }
 
-    private inner class Provider(private val forwarder: SimResourceTransformer) : SimResourceCloseableProvider, SimResourceProvider by forwarder {
-        override fun close() {
+    /**
+     * An output of the resource switch.
+     */
+    private inner class Output(private val forwarder: SimResourceTransformer) : SimResourceProvider by forwarder {
+        /**
+         * Close the output.
+         */
+        fun close() {
             // We explicitly do not close the forwarder here in order to re-use it across output resources.
             _outputs -= this
-            availableResources += forwarder
+            _availableInputs += forwarder
         }
+
+        override fun toString(): String = "SimResourceSwitchExclusive.Output"
     }
 }
diff --git a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceSwitchMaxMin.kt b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceSwitchMaxMin.kt
index e368609f..574fb443 100644
--- a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceSwitchMaxMin.kt
+++ b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceSwitchMaxMin.kt
@@ -22,8 +22,11 @@
 
 package org.opendc.simulator.resources
 
+import org.opendc.simulator.resources.impl.SimResourceCountersImpl
 import org.opendc.simulator.resources.interference.InterferenceDomain
 import org.opendc.simulator.resources.interference.InterferenceKey
+import kotlin.math.max
+import kotlin.math.min
 
 /**
  * A [SimResourceSwitch] implementation that switches resource consumptions over the available resources using max-min
@@ -34,69 +37,371 @@ import org.opendc.simulator.resources.interference.InterferenceKey
  * @param interferenceDomain The interference domain of the switch.
  */
 public class SimResourceSwitchMaxMin(
-    interpreter: SimResourceInterpreter,
-    parent: SimResourceSystem? = null,
-    interferenceDomain: InterferenceDomain? = null
+    private val interpreter: SimResourceInterpreter,
+    private val parent: SimResourceSystem? = null,
+    private val interferenceDomain: InterferenceDomain? = null
 ) : SimResourceSwitch {
     /**
      * The output resource providers to which resource consumers can be attached.
      */
-    override val outputs: Set<SimResourceCloseableProvider>
-        get() = distributor.outputs
+    override val outputs: Set<SimResourceProvider>
+        get() = _outputs
+    private val _outputs = mutableSetOf<Output>()
+    private val _activeOutputs: MutableList<Output> = mutableListOf()
 
     /**
      * The input resources that will be switched between the output providers.
      */
     override val inputs: Set<SimResourceProvider>
-        get() = aggregator.inputs
+        get() = _inputs
+    private val _inputs = mutableSetOf<SimResourceProvider>()
+    private val _activeInputs = mutableListOf<Input>()
 
     /**
-     * The resource counters to track the execution metrics of all switch resources.
+     * The resource counters of this switch.
      */
-    override val counters: SimResourceDistributorMaxMin.Counters
-        get() = distributor.counters
+    public override val counters: SimResourceCounters
+        get() = _counters
+    private val _counters = SimResourceCountersImpl()
 
     /**
-     * A flag to indicate that the switch was closed.
+     * The actual processing rate of the switch.
      */
-    private var isClosed = false
+    private var _rate = 0.0
 
     /**
-     * The aggregator to aggregate the resources.
+     * The demanded processing rate of the outputs.
      */
-    private val aggregator = SimResourceAggregatorMaxMin(interpreter, parent)
+    private var _demand = 0.0
 
     /**
-     * The distributor to distribute the aggregated resources.
+     * The capacity of the switch.
      */
-    private val distributor = SimResourceDistributorMaxMin(interpreter, parent, interferenceDomain)
+    private var _capacity = 0.0
 
-    init {
-        aggregator.startConsumer(distributor)
-    }
+    /**
+     * Flag to indicate that the scheduler is active.
+     */
+    private var _schedulerActive = false
 
     /**
      * Add an output to the switch.
      */
-    override fun newOutput(key: InterferenceKey?): SimResourceCloseableProvider {
-        check(!isClosed) { "Switch has been closed" }
-
-        return distributor.newOutput(key)
+    override fun newOutput(key: InterferenceKey?): SimResourceProvider {
+        val provider = Output(_capacity, key)
+        _outputs.add(provider)
+        return provider
     }
 
     /**
      * Add the specified [input] to the switch.
      */
     override fun addInput(input: SimResourceProvider) {
-        check(!isClosed) { "Switch has been closed" }
+        val consumer = Input(input)
+        if (_inputs.add(input)) {
+            _activeInputs.add(consumer)
+            input.startConsumer(consumer)
+        }
+    }
+
+    /**
+     * Remove [output] from this switch.
+     */
+    override fun removeOutput(output: SimResourceProvider) {
+        if (!_outputs.remove(output)) {
+            return
+        }
+        // This cast should always succeed since only `Output` instances should be added to _outputs
+        (output as Output).close()
+    }
+
+    override fun clear() {
+        for (input in _activeInputs) {
+            input.cancel()
+        }
+        _activeInputs.clear()
+
+        for (output in _activeOutputs) {
+            output.cancel()
+        }
+        _activeOutputs.clear()
+    }
+
+    /**
+     * Run the scheduler of the switch.
+     */
+    private fun runScheduler(now: Long) {
+        if (_schedulerActive) {
+            return
+        }
+
+        _schedulerActive = true
+        try {
+            doSchedule(now)
+        } finally {
+            _schedulerActive = false
+        }
+    }
+
+    /**
+     * Schedule the outputs over the input.
+     */
+    private fun doSchedule(now: Long) {
+        // If there is no work yet, mark the input as idle.
+        if (_activeOutputs.isEmpty()) {
+            return
+        }
+
+        val capacity = _capacity
+        var availableCapacity = capacity
+
+        // Pull in the work of the outputs
+        val outputIterator = _activeOutputs.listIterator()
+        for (output in outputIterator) {
+            output.pull(now)
+
+            // Remove outputs that have finished
+            if (!output.isActive) {
+                outputIterator.remove()
+            }
+        }
+
+        var demand = 0.0
+
+        // Sort in-place the outputs based on their requested usage.
+        // Profiling shows that it is faster than maintaining some kind of sorted set.
+        _activeOutputs.sort()
+
+        // Divide the available input capacity fairly across the outputs using max-min fair sharing
+        var remaining = _activeOutputs.size
+        for (output in _activeOutputs) {
+            val availableShare = availableCapacity / remaining--
+            val grantedSpeed = min(output.allowedRate, availableShare)
+
+            // Ignore idle computation
+            if (grantedSpeed <= 0.0) {
+                output.actualRate = 0.0
+                continue
+            }
+
+            demand += output.limit
 
-        aggregator.addInput(input)
+            output.actualRate = grantedSpeed
+            availableCapacity -= grantedSpeed
+        }
+
+        val rate = capacity - availableCapacity
+
+        _demand = demand
+        _rate = rate
+
+        // Sort all consumers by their capacity
+        _activeInputs.sort()
+
+        // Divide the requests over the available capacity of the input resources fairly
+        for (input in _activeInputs) {
+            val inputCapacity = input.capacity
+            val fraction = inputCapacity / capacity
+            val grantedSpeed = rate * fraction
+
+            input.push(grantedSpeed)
+        }
     }
 
-    override fun close() {
-        if (!isClosed) {
-            isClosed = true
-            aggregator.cancel()
+    /**
+     * Recompute the capacity of the switch.
+     */
+    private fun updateCapacity() {
+        val newCapacity = _activeInputs.sumOf(Input::capacity)
+
+        // No-op if the capacity is unchanged
+        if (_capacity == newCapacity) {
+            return
         }
+
+        _capacity = newCapacity
+
+        for (output in _outputs) {
+            output.capacity = newCapacity
+        }
+    }
+
+    /**
+     * An internal [SimResourceProvider] implementation for switch outputs.
+     */
+    private inner class Output(capacity: Double, val key: InterferenceKey?) :
+        SimAbstractResourceProvider(interpreter, capacity),
+        SimResourceProviderLogic,
+        Comparable<Output> {
+        /**
+         * The requested limit.
+         */
+        @JvmField var limit: Double = 0.0
+
+        /**
+         * The actual processing speed.
+         */
+        @JvmField var actualRate: Double = 0.0
+
+        /**
+         * The processing speed that is allowed by the model constraints.
+         */
+        val allowedRate: Double
+            get() = min(capacity, limit)
+
+        /**
+         * A flag to indicate that the output is closed.
+         */
+        private var _isClosed: Boolean = false
+
+        /**
+         * The timestamp at which we received the last command.
+         */
+        private var _lastPull: Long = Long.MIN_VALUE
+
+        /**
+         * Close the output.
+         *
+         * This method is invoked when the user removes an output from the switch.
+         */
+        fun close() {
+            _isClosed = true
+            cancel()
+        }
+
+        /* SimAbstractResourceProvider */
+        override fun createLogic(): SimResourceProviderLogic = this
+
+        override fun start(ctx: SimResourceControllableContext) {
+            check(!_isClosed) { "Cannot re-use closed output" }
+
+            _activeOutputs += this
+            super.start(ctx)
+        }
+
+        /* SimResourceProviderLogic */
+        override fun onConsume(
+            ctx: SimResourceControllableContext,
+            now: Long,
+            delta: Long,
+            limit: Double,
+            duration: Long
+        ) {
+            doUpdateCounters(delta)
+
+            actualRate = 0.0
+            this.limit = limit
+            _lastPull = now
+
+            runScheduler(now)
+        }
+
+        override fun onConverge(ctx: SimResourceControllableContext, now: Long, delta: Long) {
+            parent?.onConverge(now)
+        }
+
+        override fun onFinish(ctx: SimResourceControllableContext, now: Long, delta: Long) {
+            doUpdateCounters(delta)
+
+            limit = 0.0
+            actualRate = 0.0
+            _lastPull = now
+        }
+
+        /* Comparable */
+        override fun compareTo(other: Output): Int = allowedRate.compareTo(other.allowedRate)
+
+        /**
+         * Pull the next command if necessary.
+         */
+        fun pull(now: Long) {
+            val ctx = ctx
+            if (ctx != null && _lastPull < now) {
+                ctx.flush()
+            }
+        }
+
+        /**
+         * Helper method to update the resource counters of the distributor.
+         */
+        private fun doUpdateCounters(delta: Long) {
+            if (delta <= 0L) {
+                return
+            }
+
+            // Compute the performance penalty due to resource interference
+            val perfScore = if (interferenceDomain != null) {
+                val load = _rate / capacity
+                interferenceDomain.apply(key, load)
+            } else {
+                1.0
+            }
+
+            val deltaS = delta / 1000.0
+            val work = limit * deltaS
+            val actualWork = actualRate * deltaS
+            val remainingWork = work - actualWork
+
+            updateCounters(work, actualWork, remainingWork)
+
+            val distCounters = _counters
+            distCounters.demand += work
+            distCounters.actual += actualWork
+            distCounters.overcommit += remainingWork
+            distCounters.interference += actualWork * max(0.0, 1 - perfScore)
+        }
+    }
+
+    /**
+     * An internal [SimResourceConsumer] implementation for switch inputs.
+     */
+    private inner class Input(private val provider: SimResourceProvider) : SimResourceConsumer, Comparable<Input> {
+        /**
+         * The active [SimResourceContext] of this consumer.
+         */
+        private var _ctx: SimResourceContext? = null
+
+        /**
+         * The capacity of this input.
+         */
+        val capacity: Double
+            get() = _ctx?.capacity ?: 0.0
+
+        /**
+         * Push the specified rate to the provider.
+         */
+        fun push(rate: Double) {
+            _ctx?.push(rate)
+        }
+
+        /**
+         * Cancel this input.
+         */
+        fun cancel() {
+            provider.cancel()
+        }
+
+        override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
+            runScheduler(now)
+            return Long.MAX_VALUE
+        }
+
+        override fun onEvent(ctx: SimResourceContext, event: SimResourceEvent) {
+            when (event) {
+                SimResourceEvent.Start -> {
+                    assert(_ctx == null) { "Consumer running concurrently" }
+                    _ctx = ctx
+                    updateCapacity()
+                }
+                SimResourceEvent.Exit -> {
+                    _ctx = null
+                    updateCapacity()
+                }
+                SimResourceEvent.Capacity -> updateCapacity()
+                else -> {}
+            }
+        }
+
+        override fun compareTo(other: Input): Int = capacity.compareTo(other.capacity)
     }
 }
diff --git a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/impl/SimResourceCountersImpl.kt b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/impl/SimResourceCountersImpl.kt
index 827019c5..01062179 100644
--- a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/impl/SimResourceCountersImpl.kt
+++ b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/impl/SimResourceCountersImpl.kt
@@ -31,12 +31,16 @@ internal class SimResourceCountersImpl : SimResourceCounters {
     override var demand: Double = 0.0
     override var actual: Double = 0.0
     override var overcommit: Double = 0.0
+    override var interference: Double = 0.0
 
     override fun reset() {
         demand = 0.0
         actual = 0.0
         overcommit = 0.0
+        interference = 0.0
     }
 
-    override fun toString(): String = "SimResourceCounters[demand=$demand,actual=$actual,overcommit=$overcommit]"
+    override fun toString(): String {
+        return "SimResourceCounters[demand=$demand,actual=$actual,overcommit=$overcommit,interference=$interference]"
+    }
 }
diff --git a/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceAggregatorMaxMinTest.kt b/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceAggregatorMaxMinTest.kt
deleted file mode 100644
index f4ea5fe8..00000000
--- a/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceAggregatorMaxMinTest.kt
+++ /dev/null
@@ -1,190 +0,0 @@
-/*
- * Copyright (c) 2021 AtLarge Research
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-package org.opendc.simulator.resources
-
-import io.mockk.spyk
-import io.mockk.verify
-import kotlinx.coroutines.*
-import org.junit.jupiter.api.Assertions.*
-import org.junit.jupiter.api.Test
-import org.junit.jupiter.api.assertAll
-import org.opendc.simulator.core.runBlockingSimulation
-import org.opendc.simulator.resources.consumer.SimSpeedConsumerAdapter
-import org.opendc.simulator.resources.consumer.SimWorkConsumer
-import org.opendc.simulator.resources.impl.SimResourceInterpreterImpl
-
-/**
- * Test suite for the [SimResourceAggregatorMaxMin] class.
- */
-internal class SimResourceAggregatorMaxMinTest {
-    @Test
-    fun testSingleCapacity() = runBlockingSimulation {
-        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
-
-        val aggregator = SimResourceAggregatorMaxMin(scheduler)
-        val forwarder = SimResourceForwarder()
-        val sources = listOf(
-            forwarder,
-            SimResourceSource(1.0, scheduler)
-        )
-        sources.forEach(aggregator::addInput)
-
-        val consumer = SimWorkConsumer(1.0, 0.5)
-        val usage = mutableListOf<Double>()
-        val source = SimResourceSource(1.0, scheduler)
-        val adapter = SimSpeedConsumerAdapter(forwarder, usage::add)
-        source.startConsumer(adapter)
-
-        aggregator.consume(consumer)
-        yield()
-
-        assertAll(
-            { assertEquals(1000, clock.millis()) },
-            { assertEquals(listOf(0.0, 0.5, 0.0), usage) }
-        )
-    }
-
-    @Test
-    fun testDoubleCapacity() = runBlockingSimulation {
-        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
-
-        val aggregator = SimResourceAggregatorMaxMin(scheduler)
-        val sources = listOf(
-            SimResourceSource(1.0, scheduler),
-            SimResourceSource(1.0, scheduler)
-        )
-        sources.forEach(aggregator::addInput)
-
-        val consumer = SimWorkConsumer(2.0, 1.0)
-        val usage = mutableListOf<Double>()
-        val adapter = SimSpeedConsumerAdapter(consumer, usage::add)
-
-        aggregator.consume(adapter)
-        yield()
-        assertAll(
-            { assertEquals(1000, clock.millis()) },
-            { assertEquals(listOf(0.0, 2.0, 0.0), usage) }
-        )
-    }
-
-    @Test
-    fun testOvercommit() = runBlockingSimulation {
-        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
-
-        val aggregator = SimResourceAggregatorMaxMin(scheduler)
-        val sources = listOf(
-            SimResourceSource(1.0, scheduler),
-            SimResourceSource(1.0, scheduler)
-        )
-        sources.forEach(aggregator::addInput)
-
-        val consumer = spyk(object : SimResourceConsumer {
-            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
-                return if (now == 0L) {
-                    ctx.push(4.0)
-                    1000
-                } else {
-                    ctx.close()
-                    Long.MAX_VALUE
-                }
-            }
-        })
-
-        aggregator.consume(consumer)
-        yield()
-        assertEquals(1000, clock.millis())
-
-        verify(exactly = 2) { consumer.onNext(any(), any(), any()) }
-    }
-
-    @Test
-    fun testAdjustCapacity() = runBlockingSimulation {
-        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
-
-        val aggregator = SimResourceAggregatorMaxMin(scheduler)
-        val sources = listOf(
-            SimResourceSource(1.0, scheduler),
-            SimResourceSource(1.0, scheduler)
-        )
-        sources.forEach(aggregator::addInput)
-
-        val consumer = SimWorkConsumer(4.0, 1.0)
-        coroutineScope {
-            launch { aggregator.consume(consumer) }
-            delay(1000)
-            sources[0].capacity = 0.5
-        }
-        yield()
-        assertEquals(2333, clock.millis())
-    }
-
-    @Test
-    fun testFailOverCapacity() = runBlockingSimulation {
-        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
-
-        val aggregator = SimResourceAggregatorMaxMin(scheduler)
-        val sources = listOf(
-            SimResourceSource(1.0, scheduler),
-            SimResourceSource(1.0, scheduler)
-        )
-        sources.forEach(aggregator::addInput)
-
-        val consumer = SimWorkConsumer(1.0, 0.5)
-        coroutineScope {
-            launch { aggregator.consume(consumer) }
-            delay(500)
-            sources[0].capacity = 0.5
-        }
-        yield()
-        assertEquals(1167, clock.millis())
-    }
-
-    @Test
-    fun testCounters() = runBlockingSimulation {
-        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
-
-        val aggregator = SimResourceAggregatorMaxMin(scheduler)
-        val sources = listOf(
-            SimResourceSource(1.0, scheduler),
-            SimResourceSource(1.0, scheduler)
-        )
-        sources.forEach(aggregator::addInput)
-
-        val consumer = object : SimResourceConsumer {
-            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
-                return if (now == 0L) {
-                    ctx.push(4.0)
-                    1000
-                } else {
-                    ctx.close()
-                    Long.MAX_VALUE
-                }
-            }
-        }
-
-        aggregator.consume(consumer)
-        yield()
-        assertEquals(1000, clock.millis())
-        assertEquals(2.0, aggregator.counters.actual) { "Actual work mismatch" }
-    }
-}
diff --git a/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceSwitchExclusiveTest.kt b/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceSwitchExclusiveTest.kt
index 9f86dc0d..49f2da5f 100644
--- a/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceSwitchExclusiveTest.kt
+++ b/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceSwitchExclusiveTest.kt
@@ -65,13 +65,8 @@ internal class SimResourceSwitchExclusiveTest {
         switch.addInput(forwarder)
 
         val provider = switch.newOutput()
-
-        try {
-            provider.consume(workload)
-            yield()
-        } finally {
-            provider.close()
-        }
+        provider.consume(workload)
+        yield()
 
         assertAll(
             { assertEquals(listOf(0.0, 28.0, 3200.0, 0.0, 183.0, 0.0), speed) { "Correct speed" } },
@@ -95,13 +90,9 @@ internal class SimResourceSwitchExclusiveTest {
         switch.addInput(source)
 
         val provider = switch.newOutput()
+        provider.consume(workload)
+        yield()
 
-        try {
-            provider.consume(workload)
-            yield()
-        } finally {
-            provider.close()
-        }
         assertEquals(duration, clock.millis()) { "Took enough time" }
     }
 
@@ -141,14 +132,9 @@ internal class SimResourceSwitchExclusiveTest {
         switch.addInput(source)
 
         val provider = switch.newOutput()
-
-        try {
-            provider.consume(workload)
-            yield()
-            provider.consume(workload)
-        } finally {
-            provider.close()
-        }
+        provider.consume(workload)
+        yield()
+        provider.consume(workload)
         assertEquals(duration * 2, clock.millis()) { "Took enough time" }
     }
 
diff --git a/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceSwitchMaxMinTest.kt b/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceSwitchMaxMinTest.kt
index ba0d66ff..03f90e21 100644
--- a/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceSwitchMaxMinTest.kt
+++ b/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceSwitchMaxMinTest.kt
@@ -51,7 +51,7 @@ internal class SimResourceSwitchMaxMinTest {
             provider.consume(consumer)
             yield()
         } finally {
-            switch.close()
+            switch.clear()
         }
     }
 
@@ -81,7 +81,7 @@ internal class SimResourceSwitchMaxMinTest {
             provider.consume(workload)
             yield()
         } finally {
-            switch.close()
+            switch.clear()
         }
 
         assertAll(
@@ -133,7 +133,7 @@ internal class SimResourceSwitchMaxMinTest {
 
             yield()
         } finally {
-            switch.close()
+            switch.clear()
         }
         assertAll(
             { assertEquals(2073600.0, switch.counters.demand, "Requested work does not match") },
-- 
cgit v1.2.3


From dd605ab1f70fef1fbbed848e8ebbd6b231622273 Mon Sep 17 00:00:00 2001
From: Fabian Mastenbroek <mail.fabianm@gmail.com>
Date: Wed, 29 Sep 2021 22:20:48 +0200
Subject: refactor(simulator): Remove transform from SimResourceForwarder

This change removes the ability to transform the duration of a pull from
the SimResourceForwarder class. This ability is not used anymore, since
pushes are now done using a method instead of a command.
---
 .../simulator/resources/SimResourceForwarder.kt    | 220 +++++++++++++++++++
 .../resources/SimResourceSwitchExclusive.kt        |   4 +-
 .../simulator/resources/SimResourceTransformer.kt  | 238 ---------------------
 .../resources/SimResourceForwarderTest.kt          | 220 +++++++++++++++++++
 .../resources/SimResourceTransformerTest.kt        | 234 --------------------
 5 files changed, 442 insertions(+), 474 deletions(-)
 create mode 100644 opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceForwarder.kt
 delete mode 100644 opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceTransformer.kt
 create mode 100644 opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceForwarderTest.kt
 delete mode 100644 opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceTransformerTest.kt

(limited to 'opendc-simulator/opendc-simulator-resources')

diff --git a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceForwarder.kt b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceForwarder.kt
new file mode 100644
index 00000000..0cd2bfc7
--- /dev/null
+++ b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceForwarder.kt
@@ -0,0 +1,220 @@
+/*
+ * Copyright (c) 2021 AtLarge Research
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package org.opendc.simulator.resources
+
+import org.opendc.simulator.resources.impl.SimResourceCountersImpl
+import java.time.Clock
+
+/**
+ * A class that acts as a [SimResourceConsumer] and [SimResourceProvider] at the same time.
+ *
+ * @param isCoupled A flag to indicate that the transformer will exit when the resource consumer exits.
+ */
+public class SimResourceForwarder(private val isCoupled: Boolean = false) : SimResourceConsumer, SimResourceProvider, AutoCloseable {
+    /**
+     * The delegate [SimResourceConsumer].
+     */
+    private var delegate: SimResourceConsumer? = null
+
+    /**
+     * A flag to indicate that the delegate was started.
+     */
+    private var hasDelegateStarted: Boolean = false
+
+    /**
+     * The exposed [SimResourceContext].
+     */
+    private val _ctx = object : SimResourceContext {
+        override val clock: Clock
+            get() = _innerCtx!!.clock
+
+        override val capacity: Double
+            get() = _innerCtx?.capacity ?: 0.0
+
+        override val demand: Double
+            get() = _innerCtx?.demand ?: 0.0
+
+        override val speed: Double
+            get() = _innerCtx?.speed ?: 0.0
+
+        override fun interrupt() {
+            _innerCtx?.interrupt()
+        }
+
+        override fun push(rate: Double) {
+            _innerCtx?.push(rate)
+            _limit = rate
+        }
+
+        override fun close() {
+            val delegate = checkNotNull(delegate) { "Delegate not active" }
+
+            if (isCoupled)
+                _innerCtx?.close()
+            else
+                _innerCtx?.push(0.0)
+
+            // Warning: resumption of the continuation might change the entire state of the forwarder. Make sure we
+            // reset beforehand the existing state and check whether it has been updated afterwards
+            reset()
+
+            delegate.onEvent(this, SimResourceEvent.Exit)
+        }
+    }
+
+    /**
+     * The [SimResourceContext] in which the forwarder runs.
+     */
+    private var _innerCtx: SimResourceContext? = null
+
+    override val isActive: Boolean
+        get() = delegate != null
+
+    override val capacity: Double
+        get() = _ctx.capacity
+
+    override val speed: Double
+        get() = _ctx.speed
+
+    override val demand: Double
+        get() = _ctx.demand
+
+    override val counters: SimResourceCounters
+        get() = _counters
+    private val _counters = SimResourceCountersImpl()
+
+    override fun startConsumer(consumer: SimResourceConsumer) {
+        check(delegate == null) { "Resource transformer already active" }
+
+        delegate = consumer
+
+        // Interrupt the provider to replace the consumer
+        interrupt()
+    }
+
+    override fun interrupt() {
+        _ctx.interrupt()
+    }
+
+    override fun cancel() {
+        val delegate = delegate
+        val ctx = _innerCtx
+
+        if (delegate != null) {
+            this.delegate = null
+
+            if (ctx != null) {
+                delegate.onEvent(this._ctx, SimResourceEvent.Exit)
+            }
+        }
+    }
+
+    override fun close() {
+        val ctx = _innerCtx
+
+        if (ctx != null) {
+            this._innerCtx = null
+            ctx.interrupt()
+        }
+    }
+
+    override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
+        val delegate = delegate
+
+        if (!hasDelegateStarted) {
+            start()
+        }
+
+        updateCounters(ctx, delta)
+
+        return delegate?.onNext(this._ctx, now, delta) ?: Long.MAX_VALUE
+    }
+
+    override fun onEvent(ctx: SimResourceContext, event: SimResourceEvent) {
+        when (event) {
+            SimResourceEvent.Start -> {
+                _innerCtx = ctx
+            }
+            SimResourceEvent.Exit -> {
+                _innerCtx = null
+
+                val delegate = delegate
+                if (delegate != null) {
+                    reset()
+                    delegate.onEvent(this._ctx, SimResourceEvent.Exit)
+                }
+            }
+            else -> delegate?.onEvent(this._ctx, event)
+        }
+    }
+
+    override fun onFailure(ctx: SimResourceContext, cause: Throwable) {
+        _innerCtx = null
+
+        val delegate = delegate
+        if (delegate != null) {
+            reset()
+            delegate.onFailure(this._ctx, cause)
+        }
+    }
+
+    /**
+     * Start the delegate.
+     */
+    private fun start() {
+        val delegate = delegate ?: return
+        delegate.onEvent(checkNotNull(_innerCtx), SimResourceEvent.Start)
+
+        hasDelegateStarted = true
+    }
+
+    /**
+     * Reset the delegate.
+     */
+    private fun reset() {
+        delegate = null
+        hasDelegateStarted = false
+    }
+
+    /**
+     * The requested speed.
+     */
+    private var _limit: Double = 0.0
+
+    /**
+     * Update the resource counters for the transformer.
+     */
+    private fun updateCounters(ctx: SimResourceContext, delta: Long) {
+        if (delta <= 0) {
+            return
+        }
+
+        val counters = _counters
+        val deltaS = delta / 1000.0
+        val work = _limit * deltaS
+        val actualWork = ctx.speed * deltaS
+        counters.demand += work
+        counters.actual += actualWork
+        counters.overcommit += (work - actualWork)
+    }
+}
diff --git a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceSwitchExclusive.kt b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceSwitchExclusive.kt
index 2be8ccb0..f1e004d2 100644
--- a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceSwitchExclusive.kt
+++ b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceSwitchExclusive.kt
@@ -37,7 +37,7 @@ public class SimResourceSwitchExclusive : SimResourceSwitch {
     private val _inputs = mutableSetOf<SimResourceProvider>()
     override val inputs: Set<SimResourceProvider>
         get() = _inputs
-    private val _availableInputs = ArrayDeque<SimResourceTransformer>()
+    private val _availableInputs = ArrayDeque<SimResourceForwarder>()
 
     override val counters: SimResourceCounters = object : SimResourceCounters {
         override val demand: Double
@@ -114,7 +114,7 @@ public class SimResourceSwitchExclusive : SimResourceSwitch {
     /**
      * An output of the resource switch.
      */
-    private inner class Output(private val forwarder: SimResourceTransformer) : SimResourceProvider by forwarder {
+    private inner class Output(private val forwarder: SimResourceForwarder) : SimResourceProvider by forwarder {
         /**
          * Close the output.
          */
diff --git a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceTransformer.kt b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceTransformer.kt
deleted file mode 100644
index 76a3bdd7..00000000
--- a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceTransformer.kt
+++ /dev/null
@@ -1,238 +0,0 @@
-/*
- * Copyright (c) 2021 AtLarge Research
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-package org.opendc.simulator.resources
-
-import org.opendc.simulator.resources.impl.SimResourceCountersImpl
-import java.time.Clock
-
-/**
- * A [SimResourceConsumer] and [SimResourceProvider] that transforms the resource commands emitted by the resource
- * commands to the resource provider.
- *
- * @param isCoupled A flag to indicate that the transformer will exit when the resource consumer exits.
- * @param transform The function to transform the received resource command.
- */
-public class SimResourceTransformer(
-    private val isCoupled: Boolean = false,
-    private val transform: (SimResourceContext, Long) -> Long
-) : SimResourceConsumer, SimResourceProvider, AutoCloseable {
-    /**
-     * The delegate [SimResourceConsumer].
-     */
-    private var delegate: SimResourceConsumer? = null
-
-    /**
-     * A flag to indicate that the delegate was started.
-     */
-    private var hasDelegateStarted: Boolean = false
-
-    /**
-     * The exposed [SimResourceContext].
-     */
-    private val ctx = object : SimResourceContext {
-        override val clock: Clock
-            get() = _ctx!!.clock
-
-        override val capacity: Double
-            get() = _ctx?.capacity ?: 0.0
-
-        override val demand: Double
-            get() = _ctx?.demand ?: 0.0
-
-        override val speed: Double
-            get() = _ctx?.speed ?: 0.0
-
-        override fun interrupt() {
-            _ctx?.interrupt()
-        }
-
-        override fun push(rate: Double) {
-            _ctx?.push(rate)
-            _limit = rate
-        }
-
-        override fun close() {
-            val delegate = checkNotNull(delegate) { "Delegate not active" }
-
-            if (isCoupled)
-                _ctx?.close()
-            else
-                _ctx?.push(0.0)
-
-            // Warning: resumption of the continuation might change the entire state of the forwarder. Make sure we
-            // reset beforehand the existing state and check whether it has been updated afterwards
-            reset()
-
-            delegate.onEvent(this, SimResourceEvent.Exit)
-        }
-    }
-
-    /**
-     * The [SimResourceContext] in which the forwarder runs.
-     */
-    private var _ctx: SimResourceContext? = null
-
-    override val isActive: Boolean
-        get() = delegate != null
-
-    override val capacity: Double
-        get() = ctx.capacity
-
-    override val speed: Double
-        get() = ctx.speed
-
-    override val demand: Double
-        get() = ctx.demand
-
-    override val counters: SimResourceCounters
-        get() = _counters
-    private val _counters = SimResourceCountersImpl()
-
-    override fun startConsumer(consumer: SimResourceConsumer) {
-        check(delegate == null) { "Resource transformer already active" }
-
-        delegate = consumer
-
-        // Interrupt the provider to replace the consumer
-        interrupt()
-    }
-
-    override fun interrupt() {
-        ctx.interrupt()
-    }
-
-    override fun cancel() {
-        val delegate = delegate
-        val ctx = _ctx
-
-        if (delegate != null) {
-            this.delegate = null
-
-            if (ctx != null) {
-                delegate.onEvent(this.ctx, SimResourceEvent.Exit)
-            }
-        }
-    }
-
-    override fun close() {
-        val ctx = _ctx
-
-        if (ctx != null) {
-            this._ctx = null
-            ctx.interrupt()
-        }
-    }
-
-    override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
-        val delegate = delegate
-
-        if (!hasDelegateStarted) {
-            start()
-        }
-
-        updateCounters(ctx, delta)
-
-        return if (delegate != null) {
-            transform(ctx, delegate.onNext(this.ctx, now, delta))
-        } else {
-            Long.MAX_VALUE
-        }
-    }
-
-    override fun onEvent(ctx: SimResourceContext, event: SimResourceEvent) {
-        when (event) {
-            SimResourceEvent.Start -> {
-                _ctx = ctx
-            }
-            SimResourceEvent.Exit -> {
-                _ctx = null
-
-                val delegate = delegate
-                if (delegate != null) {
-                    reset()
-                    delegate.onEvent(this.ctx, SimResourceEvent.Exit)
-                }
-            }
-            else -> delegate?.onEvent(this.ctx, event)
-        }
-    }
-
-    override fun onFailure(ctx: SimResourceContext, cause: Throwable) {
-        _ctx = null
-
-        val delegate = delegate
-        if (delegate != null) {
-            reset()
-            delegate.onFailure(this.ctx, cause)
-        }
-    }
-
-    /**
-     * Start the delegate.
-     */
-    private fun start() {
-        val delegate = delegate ?: return
-        delegate.onEvent(checkNotNull(_ctx), SimResourceEvent.Start)
-
-        hasDelegateStarted = true
-    }
-
-    /**
-     * Reset the delegate.
-     */
-    private fun reset() {
-        delegate = null
-        hasDelegateStarted = false
-    }
-
-    /**
-     * The requested speed.
-     */
-    private var _limit: Double = 0.0
-
-    /**
-     * Update the resource counters for the transformer.
-     */
-    private fun updateCounters(ctx: SimResourceContext, delta: Long) {
-        if (delta <= 0) {
-            return
-        }
-
-        val counters = _counters
-        val deltaS = delta / 1000.0
-        val work = _limit * deltaS
-        val actualWork = ctx.speed * deltaS
-        counters.demand += work
-        counters.actual += actualWork
-        counters.overcommit += (work - actualWork)
-    }
-}
-
-/**
- * Constructs a [SimResourceTransformer] that forwards the received resource command with an identity transform.
- *
- * @param isCoupled A flag to indicate that the transformer will exit when the resource consumer exits.
- */
-public fun SimResourceForwarder(isCoupled: Boolean = false): SimResourceTransformer {
-    return SimResourceTransformer(isCoupled) { _, command -> command }
-}
diff --git a/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceForwarderTest.kt b/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceForwarderTest.kt
new file mode 100644
index 00000000..49e60f68
--- /dev/null
+++ b/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceForwarderTest.kt
@@ -0,0 +1,220 @@
+/*
+ * Copyright (c) 2021 AtLarge Research
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package org.opendc.simulator.resources
+
+import io.mockk.spyk
+import io.mockk.verify
+import kotlinx.coroutines.*
+import org.junit.jupiter.api.Assertions.*
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.assertThrows
+import org.opendc.simulator.core.runBlockingSimulation
+import org.opendc.simulator.resources.consumer.SimWorkConsumer
+import org.opendc.simulator.resources.impl.SimResourceInterpreterImpl
+
+/**
+ * A test suite for the [SimResourceForwarder] class.
+ */
+internal class SimResourceForwarderTest {
+    @Test
+    fun testCancelImmediately() = runBlockingSimulation {
+        val forwarder = SimResourceForwarder()
+        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
+        val source = SimResourceSource(2000.0, scheduler)
+
+        launch { source.consume(forwarder) }
+
+        forwarder.consume(object : SimResourceConsumer {
+            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
+                ctx.close()
+                return Long.MAX_VALUE
+            }
+        })
+
+        forwarder.close()
+        source.cancel()
+    }
+
+    @Test
+    fun testCancel() = runBlockingSimulation {
+        val forwarder = SimResourceForwarder()
+        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
+        val source = SimResourceSource(2000.0, scheduler)
+
+        launch { source.consume(forwarder) }
+
+        forwarder.consume(object : SimResourceConsumer {
+            var isFirst = true
+
+            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
+                return if (isFirst) {
+                    isFirst = false
+                    ctx.push(1.0)
+                    10 * 1000
+                } else {
+                    ctx.close()
+                    Long.MAX_VALUE
+                }
+            }
+        })
+
+        forwarder.close()
+        source.cancel()
+    }
+
+    @Test
+    fun testState() = runBlockingSimulation {
+        val forwarder = SimResourceForwarder()
+        val consumer = object : SimResourceConsumer {
+            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
+                ctx.close()
+                return Long.MAX_VALUE
+            }
+        }
+
+        assertFalse(forwarder.isActive)
+
+        forwarder.startConsumer(consumer)
+        assertTrue(forwarder.isActive)
+
+        assertThrows<IllegalStateException> { forwarder.startConsumer(consumer) }
+
+        forwarder.cancel()
+        assertFalse(forwarder.isActive)
+
+        forwarder.close()
+        assertFalse(forwarder.isActive)
+    }
+
+    @Test
+    fun testCancelPendingDelegate() = runBlockingSimulation {
+        val forwarder = SimResourceForwarder()
+
+        val consumer = spyk(object : SimResourceConsumer {
+            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
+                ctx.close()
+                return Long.MAX_VALUE
+            }
+        })
+
+        forwarder.startConsumer(consumer)
+        forwarder.cancel()
+
+        verify(exactly = 0) { consumer.onEvent(any(), SimResourceEvent.Exit) }
+    }
+
+    @Test
+    fun testCancelStartedDelegate() = runBlockingSimulation {
+        val forwarder = SimResourceForwarder()
+        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
+        val source = SimResourceSource(2000.0, scheduler)
+
+        val consumer = spyk(SimWorkConsumer(2000.0, 1.0))
+
+        source.startConsumer(forwarder)
+        yield()
+        forwarder.startConsumer(consumer)
+        yield()
+        forwarder.cancel()
+
+        verify(exactly = 1) { consumer.onEvent(any(), SimResourceEvent.Start) }
+        verify(exactly = 1) { consumer.onEvent(any(), SimResourceEvent.Exit) }
+    }
+
+    @Test
+    fun testCancelPropagation() = runBlockingSimulation {
+        val forwarder = SimResourceForwarder()
+        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
+        val source = SimResourceSource(2000.0, scheduler)
+
+        val consumer = spyk(SimWorkConsumer(2000.0, 1.0))
+
+        source.startConsumer(forwarder)
+        yield()
+        forwarder.startConsumer(consumer)
+        yield()
+        source.cancel()
+
+        verify(exactly = 1) { consumer.onEvent(any(), SimResourceEvent.Start) }
+        verify(exactly = 1) { consumer.onEvent(any(), SimResourceEvent.Exit) }
+    }
+
+    @Test
+    fun testExitPropagation() = runBlockingSimulation {
+        val forwarder = SimResourceForwarder(isCoupled = true)
+        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
+        val source = SimResourceSource(2000.0, scheduler)
+
+        val consumer = object : SimResourceConsumer {
+            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
+                ctx.close()
+                return Long.MAX_VALUE
+            }
+        }
+
+        source.startConsumer(forwarder)
+        forwarder.consume(consumer)
+        yield()
+
+        assertFalse(forwarder.isActive)
+    }
+
+    @Test
+    fun testAdjustCapacity() = runBlockingSimulation {
+        val forwarder = SimResourceForwarder()
+        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
+        val source = SimResourceSource(1.0, scheduler)
+
+        val consumer = spyk(SimWorkConsumer(2.0, 1.0))
+        source.startConsumer(forwarder)
+
+        coroutineScope {
+            launch { forwarder.consume(consumer) }
+            delay(1000)
+            source.capacity = 0.5
+        }
+
+        assertEquals(3000, clock.millis())
+        verify(exactly = 1) { consumer.onEvent(any(), SimResourceEvent.Capacity) }
+    }
+
+    @Test
+    fun testCounters() = runBlockingSimulation {
+        val forwarder = SimResourceForwarder()
+        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
+        val source = SimResourceSource(1.0, scheduler)
+
+        val consumer = SimWorkConsumer(2.0, 1.0)
+        source.startConsumer(forwarder)
+
+        forwarder.consume(consumer)
+
+        yield()
+
+        assertEquals(2.0, source.counters.actual)
+        assertEquals(source.counters.actual, forwarder.counters.actual) { "Actual work" }
+        assertEquals(source.counters.demand, forwarder.counters.demand) { "Work demand" }
+        assertEquals(source.counters.overcommit, forwarder.counters.overcommit) { "Overcommitted work" }
+        assertEquals(2000, clock.millis())
+    }
+}
diff --git a/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceTransformerTest.kt b/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceTransformerTest.kt
deleted file mode 100644
index d7d0924f..00000000
--- a/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceTransformerTest.kt
+++ /dev/null
@@ -1,234 +0,0 @@
-/*
- * Copyright (c) 2021 AtLarge Research
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-package org.opendc.simulator.resources
-
-import io.mockk.spyk
-import io.mockk.verify
-import kotlinx.coroutines.*
-import org.junit.jupiter.api.Assertions.*
-import org.junit.jupiter.api.Test
-import org.junit.jupiter.api.assertThrows
-import org.opendc.simulator.core.runBlockingSimulation
-import org.opendc.simulator.resources.consumer.SimWorkConsumer
-import org.opendc.simulator.resources.impl.SimResourceInterpreterImpl
-
-/**
- * A test suite for the [SimResourceTransformer] class.
- */
-internal class SimResourceTransformerTest {
-    @Test
-    fun testCancelImmediately() = runBlockingSimulation {
-        val forwarder = SimResourceForwarder()
-        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
-        val source = SimResourceSource(2000.0, scheduler)
-
-        launch { source.consume(forwarder) }
-
-        forwarder.consume(object : SimResourceConsumer {
-            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
-                ctx.close()
-                return Long.MAX_VALUE
-            }
-        })
-
-        forwarder.close()
-        source.cancel()
-    }
-
-    @Test
-    fun testCancel() = runBlockingSimulation {
-        val forwarder = SimResourceForwarder()
-        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
-        val source = SimResourceSource(2000.0, scheduler)
-
-        launch { source.consume(forwarder) }
-
-        forwarder.consume(object : SimResourceConsumer {
-            var isFirst = true
-
-            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
-                return if (isFirst) {
-                    isFirst = false
-                    ctx.push(1.0)
-                    10 * 1000
-                } else {
-                    ctx.close()
-                    Long.MAX_VALUE
-                }
-            }
-        })
-
-        forwarder.close()
-        source.cancel()
-    }
-
-    @Test
-    fun testState() = runBlockingSimulation {
-        val forwarder = SimResourceForwarder()
-        val consumer = object : SimResourceConsumer {
-            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
-                ctx.close()
-                return Long.MAX_VALUE
-            }
-        }
-
-        assertFalse(forwarder.isActive)
-
-        forwarder.startConsumer(consumer)
-        assertTrue(forwarder.isActive)
-
-        assertThrows<IllegalStateException> { forwarder.startConsumer(consumer) }
-
-        forwarder.cancel()
-        assertFalse(forwarder.isActive)
-
-        forwarder.close()
-        assertFalse(forwarder.isActive)
-    }
-
-    @Test
-    fun testCancelPendingDelegate() = runBlockingSimulation {
-        val forwarder = SimResourceForwarder()
-
-        val consumer = spyk(object : SimResourceConsumer {
-            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
-                ctx.close()
-                return Long.MAX_VALUE
-            }
-        })
-
-        forwarder.startConsumer(consumer)
-        forwarder.cancel()
-
-        verify(exactly = 0) { consumer.onEvent(any(), SimResourceEvent.Exit) }
-    }
-
-    @Test
-    fun testCancelStartedDelegate() = runBlockingSimulation {
-        val forwarder = SimResourceForwarder()
-        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
-        val source = SimResourceSource(2000.0, scheduler)
-
-        val consumer = spyk(SimWorkConsumer(2000.0, 1.0))
-
-        source.startConsumer(forwarder)
-        yield()
-        forwarder.startConsumer(consumer)
-        yield()
-        forwarder.cancel()
-
-        verify(exactly = 1) { consumer.onEvent(any(), SimResourceEvent.Start) }
-        verify(exactly = 1) { consumer.onEvent(any(), SimResourceEvent.Exit) }
-    }
-
-    @Test
-    fun testCancelPropagation() = runBlockingSimulation {
-        val forwarder = SimResourceForwarder()
-        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
-        val source = SimResourceSource(2000.0, scheduler)
-
-        val consumer = spyk(SimWorkConsumer(2000.0, 1.0))
-
-        source.startConsumer(forwarder)
-        yield()
-        forwarder.startConsumer(consumer)
-        yield()
-        source.cancel()
-
-        verify(exactly = 1) { consumer.onEvent(any(), SimResourceEvent.Start) }
-        verify(exactly = 1) { consumer.onEvent(any(), SimResourceEvent.Exit) }
-    }
-
-    @Test
-    fun testExitPropagation() = runBlockingSimulation {
-        val forwarder = SimResourceForwarder(isCoupled = true)
-        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
-        val source = SimResourceSource(2000.0, scheduler)
-
-        val consumer = object : SimResourceConsumer {
-            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
-                ctx.close()
-                return Long.MAX_VALUE
-            }
-        }
-
-        source.startConsumer(forwarder)
-        forwarder.consume(consumer)
-        yield()
-
-        assertFalse(forwarder.isActive)
-    }
-
-    @Test
-    fun testAdjustCapacity() = runBlockingSimulation {
-        val forwarder = SimResourceForwarder()
-        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
-        val source = SimResourceSource(1.0, scheduler)
-
-        val consumer = spyk(SimWorkConsumer(2.0, 1.0))
-        source.startConsumer(forwarder)
-
-        coroutineScope {
-            launch { forwarder.consume(consumer) }
-            delay(1000)
-            source.capacity = 0.5
-        }
-
-        assertEquals(3000, clock.millis())
-        verify(exactly = 1) { consumer.onEvent(any(), SimResourceEvent.Capacity) }
-    }
-
-    @Test
-    fun testTransformExit() = runBlockingSimulation {
-        val forwarder = SimResourceTransformer { ctx, _ -> ctx.close(); Long.MAX_VALUE }
-        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
-        val source = SimResourceSource(1.0, scheduler)
-
-        val consumer = spyk(SimWorkConsumer(2.0, 1.0))
-        source.startConsumer(forwarder)
-        forwarder.consume(consumer)
-
-        assertEquals(0, clock.millis())
-        verify(exactly = 1) { consumer.onNext(any(), any(), any()) }
-    }
-
-    @Test
-    fun testCounters() = runBlockingSimulation {
-        val forwarder = SimResourceForwarder()
-        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
-        val source = SimResourceSource(1.0, scheduler)
-
-        val consumer = SimWorkConsumer(2.0, 1.0)
-        source.startConsumer(forwarder)
-
-        forwarder.consume(consumer)
-
-        yield()
-
-        assertEquals(2.0, source.counters.actual)
-        assertEquals(source.counters.actual, forwarder.counters.actual) { "Actual work" }
-        assertEquals(source.counters.demand, forwarder.counters.demand) { "Work demand" }
-        assertEquals(source.counters.overcommit, forwarder.counters.overcommit) { "Overcommitted work" }
-        assertEquals(2000, clock.millis())
-    }
-}
-- 
cgit v1.2.3


From 4cc1d40d421c8736f8b21b360b61d6b065158b7a Mon Sep 17 00:00:00 2001
From: Fabian Mastenbroek <mail.fabianm@gmail.com>
Date: Wed, 29 Sep 2021 23:56:16 +0200
Subject: 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).
---
 .../opendc-simulator-resources/build.gradle.kts    |  38 --
 .../simulator/resources/SimResourceBenchmarks.kt   | 138 -------
 .../resources/SimAbstractResourceProvider.kt       | 146 --------
 .../simulator/resources/SimResourceConsumer.kt     |  57 ---
 .../simulator/resources/SimResourceContext.kt      |  68 ----
 .../resources/SimResourceControllableContext.kt    |  54 ---
 .../simulator/resources/SimResourceCounters.kt     |  53 ---
 .../opendc/simulator/resources/SimResourceEvent.kt |  48 ---
 .../simulator/resources/SimResourceForwarder.kt    | 220 -----------
 .../simulator/resources/SimResourceInterpreter.kt  |  94 -----
 .../simulator/resources/SimResourceProvider.kt     | 106 ------
 .../resources/SimResourceProviderLogic.kt          |  58 ---
 .../simulator/resources/SimResourceSource.kt       |  61 ---
 .../simulator/resources/SimResourceSwitch.kt       |  67 ----
 .../resources/SimResourceSwitchExclusive.kt        | 129 -------
 .../simulator/resources/SimResourceSwitchMaxMin.kt | 407 ---------------------
 .../simulator/resources/SimResourceSystem.kt       |  43 ---
 .../resources/consumer/SimConsumerBarrier.kt       |  52 ---
 .../resources/consumer/SimSpeedConsumerAdapter.kt  |  82 -----
 .../resources/consumer/SimTraceConsumer.kt         |  73 ----
 .../resources/consumer/SimWorkConsumer.kt          |  61 ---
 .../resources/impl/SimResourceContextImpl.kt       | 367 -------------------
 .../resources/impl/SimResourceCountersImpl.kt      |  46 ---
 .../resources/impl/SimResourceInterpreterImpl.kt   | 298 ---------------
 .../resources/interference/InterferenceDomain.kt   |  19 -
 .../resources/interference/InterferenceKey.kt      |  28 --
 .../simulator/resources/SimResourceContextTest.kt  | 173 ---------
 .../resources/SimResourceForwarderTest.kt          | 220 -----------
 .../simulator/resources/SimResourceSourceTest.kt   | 240 ------------
 .../resources/SimResourceSwitchExclusiveTest.kt    | 156 --------
 .../resources/SimResourceSwitchMaxMinTest.kt       | 145 --------
 .../simulator/resources/SimWorkConsumerTest.kt     |  56 ---
 32 files changed, 3803 deletions(-)
 delete mode 100644 opendc-simulator/opendc-simulator-resources/build.gradle.kts
 delete mode 100644 opendc-simulator/opendc-simulator-resources/src/jmh/kotlin/org/opendc/simulator/resources/SimResourceBenchmarks.kt
 delete mode 100644 opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimAbstractResourceProvider.kt
 delete mode 100644 opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceConsumer.kt
 delete mode 100644 opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceContext.kt
 delete mode 100644 opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceControllableContext.kt
 delete mode 100644 opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceCounters.kt
 delete mode 100644 opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceEvent.kt
 delete mode 100644 opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceForwarder.kt
 delete mode 100644 opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceInterpreter.kt
 delete mode 100644 opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceProvider.kt
 delete mode 100644 opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceProviderLogic.kt
 delete mode 100644 opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceSource.kt
 delete mode 100644 opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceSwitch.kt
 delete mode 100644 opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceSwitchExclusive.kt
 delete mode 100644 opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceSwitchMaxMin.kt
 delete mode 100644 opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceSystem.kt
 delete mode 100644 opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/consumer/SimConsumerBarrier.kt
 delete mode 100644 opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/consumer/SimSpeedConsumerAdapter.kt
 delete mode 100644 opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/consumer/SimTraceConsumer.kt
 delete mode 100644 opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/consumer/SimWorkConsumer.kt
 delete mode 100644 opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/impl/SimResourceContextImpl.kt
 delete mode 100644 opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/impl/SimResourceCountersImpl.kt
 delete mode 100644 opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/impl/SimResourceInterpreterImpl.kt
 delete mode 100644 opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/interference/InterferenceDomain.kt
 delete mode 100644 opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/interference/InterferenceKey.kt
 delete mode 100644 opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceContextTest.kt
 delete mode 100644 opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceForwarderTest.kt
 delete mode 100644 opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceSourceTest.kt
 delete mode 100644 opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceSwitchExclusiveTest.kt
 delete mode 100644 opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceSwitchMaxMinTest.kt
 delete mode 100644 opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimWorkConsumerTest.kt

(limited to 'opendc-simulator/opendc-simulator-resources')

diff --git a/opendc-simulator/opendc-simulator-resources/build.gradle.kts b/opendc-simulator/opendc-simulator-resources/build.gradle.kts
deleted file mode 100644
index 68047d5c..00000000
--- a/opendc-simulator/opendc-simulator-resources/build.gradle.kts
+++ /dev/null
@@ -1,38 +0,0 @@
-/*
- * Copyright (c) 2021 AtLarge Research
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-description = "Uniform resource consumption simulation model"
-
-plugins {
-    `kotlin-library-conventions`
-    `testing-conventions`
-    `jacoco-conventions`
-    `benchmark-conventions`
-}
-
-dependencies {
-    api(platform(projects.opendcPlatform))
-    api(libs.kotlinx.coroutines)
-    implementation(projects.opendcUtils)
-
-    testImplementation(projects.opendcSimulator.opendcSimulatorCore)
-}
diff --git a/opendc-simulator/opendc-simulator-resources/src/jmh/kotlin/org/opendc/simulator/resources/SimResourceBenchmarks.kt b/opendc-simulator/opendc-simulator-resources/src/jmh/kotlin/org/opendc/simulator/resources/SimResourceBenchmarks.kt
deleted file mode 100644
index fbc3f319..00000000
--- a/opendc-simulator/opendc-simulator-resources/src/jmh/kotlin/org/opendc/simulator/resources/SimResourceBenchmarks.kt
+++ /dev/null
@@ -1,138 +0,0 @@
-/*
- * Copyright (c) 2021 AtLarge Research
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-package org.opendc.simulator.resources
-
-import kotlinx.coroutines.ExperimentalCoroutinesApi
-import kotlinx.coroutines.launch
-import org.opendc.simulator.core.SimulationCoroutineScope
-import org.opendc.simulator.core.runBlockingSimulation
-import org.opendc.simulator.resources.consumer.SimTraceConsumer
-import org.openjdk.jmh.annotations.*
-import java.util.concurrent.ThreadLocalRandom
-import java.util.concurrent.TimeUnit
-
-@State(Scope.Thread)
-@Fork(1)
-@Warmup(iterations = 2, time = 1, timeUnit = TimeUnit.SECONDS)
-@Measurement(iterations = 5, time = 3, timeUnit = TimeUnit.SECONDS)
-@OptIn(ExperimentalCoroutinesApi::class)
-class SimResourceBenchmarks {
-    private lateinit var scope: SimulationCoroutineScope
-    private lateinit var interpreter: SimResourceInterpreter
-
-    @Setup
-    fun setUp() {
-        scope = SimulationCoroutineScope()
-        interpreter = SimResourceInterpreter(scope.coroutineContext, scope.clock)
-    }
-
-    @State(Scope.Thread)
-    class Workload {
-        lateinit var trace: Sequence<SimTraceConsumer.Fragment>
-
-        @Setup
-        fun setUp() {
-            val random = ThreadLocalRandom.current()
-            val entries = List(10000) { SimTraceConsumer.Fragment(1000, random.nextDouble(0.0, 4500.0)) }
-            trace = entries.asSequence()
-        }
-    }
-
-    @Benchmark
-    fun benchmarkSource(state: Workload) {
-        return scope.runBlockingSimulation {
-            val provider = SimResourceSource(4200.0, interpreter)
-            return@runBlockingSimulation provider.consume(SimTraceConsumer(state.trace))
-        }
-    }
-
-    @Benchmark
-    fun benchmarkForwardOverhead(state: Workload) {
-        return scope.runBlockingSimulation {
-            val provider = SimResourceSource(4200.0, interpreter)
-            val forwarder = SimResourceForwarder()
-            provider.startConsumer(forwarder)
-            return@runBlockingSimulation forwarder.consume(SimTraceConsumer(state.trace))
-        }
-    }
-
-    @Benchmark
-    fun benchmarkSwitchMaxMinSingleConsumer(state: Workload) {
-        return scope.runBlockingSimulation {
-            val switch = SimResourceSwitchMaxMin(interpreter)
-
-            switch.addInput(SimResourceSource(3000.0, interpreter))
-            switch.addInput(SimResourceSource(3000.0, interpreter))
-
-            val provider = switch.newOutput()
-            return@runBlockingSimulation provider.consume(SimTraceConsumer(state.trace))
-        }
-    }
-
-    @Benchmark
-    fun benchmarkSwitchMaxMinTripleConsumer(state: Workload) {
-        return scope.runBlockingSimulation {
-            val switch = SimResourceSwitchMaxMin(interpreter)
-
-            switch.addInput(SimResourceSource(3000.0, interpreter))
-            switch.addInput(SimResourceSource(3000.0, interpreter))
-
-            repeat(3) {
-                launch {
-                    val provider = switch.newOutput()
-                    provider.consume(SimTraceConsumer(state.trace))
-                }
-            }
-        }
-    }
-
-    @Benchmark
-    fun benchmarkSwitchExclusiveSingleConsumer(state: Workload) {
-        return scope.runBlockingSimulation {
-            val switch = SimResourceSwitchExclusive()
-
-            switch.addInput(SimResourceSource(3000.0, interpreter))
-            switch.addInput(SimResourceSource(3000.0, interpreter))
-
-            val provider = switch.newOutput()
-            return@runBlockingSimulation provider.consume(SimTraceConsumer(state.trace))
-        }
-    }
-
-    @Benchmark
-    fun benchmarkSwitchExclusiveTripleConsumer(state: Workload) {
-        return scope.runBlockingSimulation {
-            val switch = SimResourceSwitchExclusive()
-
-            switch.addInput(SimResourceSource(3000.0, interpreter))
-            switch.addInput(SimResourceSource(3000.0, interpreter))
-
-            repeat(2) {
-                launch {
-                    val provider = switch.newOutput()
-                    provider.consume(SimTraceConsumer(state.trace))
-                }
-            }
-        }
-    }
-}
diff --git a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimAbstractResourceProvider.kt b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimAbstractResourceProvider.kt
deleted file mode 100644
index 085cba63..00000000
--- a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimAbstractResourceProvider.kt
+++ /dev/null
@@ -1,146 +0,0 @@
-/*
- * Copyright (c) 2021 AtLarge Research
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-package org.opendc.simulator.resources
-
-import org.opendc.simulator.resources.impl.SimResourceCountersImpl
-
-/**
- * Abstract implementation of the [SimResourceProvider] which can be re-used by other implementations.
- */
-public abstract class SimAbstractResourceProvider(
-    private val interpreter: SimResourceInterpreter,
-    initialCapacity: Double
-) : SimResourceProvider {
-    /**
-     * A flag to indicate that the resource provider is active.
-     */
-    public override val isActive: Boolean
-        get() = ctx != null
-
-    /**
-     * The capacity of the resource.
-     */
-    public override var capacity: Double = initialCapacity
-        set(value) {
-            field = value
-            ctx?.capacity = value
-        }
-
-    /**
-     * The current processing speed of the resource.
-     */
-    public override val speed: Double
-        get() = ctx?.speed ?: 0.0
-
-    /**
-     * The resource processing speed demand at this instant.
-     */
-    public override val demand: Double
-        get() = ctx?.demand ?: 0.0
-
-    /**
-     * The resource counters to track the execution metrics of the resource.
-     */
-    public override val counters: SimResourceCounters
-        get() = _counters
-    private val _counters = SimResourceCountersImpl()
-
-    /**
-     * The [SimResourceControllableContext] that is currently running.
-     */
-    protected var ctx: SimResourceControllableContext? = null
-        private set
-
-    /**
-     * Construct the [SimResourceProviderLogic] instance for a new consumer.
-     */
-    protected abstract fun createLogic(): SimResourceProviderLogic
-
-    /**
-     * Start the specified [SimResourceControllableContext].
-     */
-    protected open fun start(ctx: SimResourceControllableContext) {
-        ctx.start()
-    }
-
-    /**
-     * The previous demand for the resource.
-     */
-    private var previousDemand = 0.0
-
-    /**
-     * Update the counters of the resource provider.
-     */
-    protected fun updateCounters(ctx: SimResourceContext, delta: Long) {
-        val demand = previousDemand
-        previousDemand = ctx.demand
-
-        if (delta <= 0) {
-            return
-        }
-
-        val counters = _counters
-        val deltaS = delta / 1000.0
-        val work = demand * deltaS
-        val actualWork = ctx.speed * deltaS
-        val remainingWork = work - actualWork
-
-        counters.demand += work
-        counters.actual += actualWork
-        counters.overcommit += remainingWork
-    }
-
-    /**
-     * Update the counters of the resource provider.
-     */
-    protected fun updateCounters(demand: Double, actual: Double, overcommit: Double) {
-        val counters = _counters
-        counters.demand += demand
-        counters.actual += actual
-        counters.overcommit += overcommit
-    }
-
-    final override fun startConsumer(consumer: SimResourceConsumer) {
-        check(ctx == null) { "Resource is in invalid state" }
-        val ctx = interpreter.newContext(consumer, createLogic())
-
-        ctx.capacity = capacity
-        this.ctx = ctx
-
-        start(ctx)
-    }
-
-    final override fun interrupt() {
-        ctx?.interrupt()
-    }
-
-    final override fun cancel() {
-        val ctx = ctx
-        if (ctx != null) {
-            this.ctx = null
-            ctx.close()
-        }
-    }
-
-    override fun toString(): String = "SimAbstractResourceProvider[capacity=$capacity]"
-}
diff --git a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceConsumer.kt b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceConsumer.kt
deleted file mode 100644
index 0b25358a..00000000
--- a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceConsumer.kt
+++ /dev/null
@@ -1,57 +0,0 @@
-/*
- * Copyright (c) 2021 AtLarge Research
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-package org.opendc.simulator.resources
-
-/**
- * A [SimResourceConsumer] characterizes how a resource is consumed.
- *
- * Implementors of this interface should be considered stateful and must be assumed not to be re-usable (concurrently)
- * for multiple resource providers, unless explicitly said otherwise.
- */
-public interface SimResourceConsumer {
-    /**
-     * This method is invoked when the resource provider is pulling this resource consumer.
-     *
-     * @param ctx The execution context in which the consumer runs.
-     * @param now The virtual timestamp in milliseconds at which the update is occurring.
-     * @param delta The virtual duration between this call and the last call in milliseconds.
-     * @return The duration after which the resource consumer should be pulled again.
-     */
-    public fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long
-
-    /**
-     * This method is invoked when an event has occurred.
-     *
-     * @param ctx The execution context in which the consumer runs.
-     * @param event The event that has occurred.
-     */
-    public fun onEvent(ctx: SimResourceContext, event: SimResourceEvent) {}
-
-    /**
-     * This method is invoked when a resource consumer throws an exception.
-     *
-     * @param ctx The execution context in which the consumer runs.
-     * @param cause The cause of the failure.
-     */
-    public fun onFailure(ctx: SimResourceContext, cause: Throwable) {}
-}
diff --git a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceContext.kt b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceContext.kt
deleted file mode 100644
index 225cae0b..00000000
--- a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceContext.kt
+++ /dev/null
@@ -1,68 +0,0 @@
-/*
- * Copyright (c) 2021 AtLarge Research
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-package org.opendc.simulator.resources
-
-import java.time.Clock
-
-/**
- * The execution context in which a [SimResourceConsumer] runs. It facilitates the communication and control between a
- * resource and a resource consumer.
- */
-public interface SimResourceContext : AutoCloseable {
-    /**
-     * The virtual clock tracking simulation time.
-     */
-    public val clock: Clock
-
-    /**
-     * The resource capacity available at this instant.
-     */
-    public val capacity: Double
-
-    /**
-     * The resource processing speed at this instant.
-     */
-    public val speed: Double
-
-    /**
-     * The resource processing speed demand at this instant.
-     */
-    public val demand: Double
-
-    /**
-     * Ask the resource provider to interrupt its resource.
-     */
-    public fun interrupt()
-
-    /**
-     * Push the given flow to this context.
-     *
-     * @param rate The rate of the flow to push.
-     */
-    public fun push(rate: Double)
-
-    /**
-     * Stop the resource context.
-     */
-    public override fun close()
-}
diff --git a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceControllableContext.kt b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceControllableContext.kt
deleted file mode 100644
index b406b896..00000000
--- a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceControllableContext.kt
+++ /dev/null
@@ -1,54 +0,0 @@
-/*
- * Copyright (c) 2021 AtLarge Research
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-package org.opendc.simulator.resources
-
-/**
- * A controllable [SimResourceContext].
- *
- * This interface is used by resource providers to control the resource context.
- */
-public interface SimResourceControllableContext : SimResourceContext {
-    /**
-     * The capacity of the resource.
-     */
-    public override var capacity: Double
-
-    /**
-     * Start the resource context.
-     */
-    public fun start()
-
-    /**
-     * Invalidate the resource context's state.
-     *
-     * By invalidating the resource context's current state, the state is re-computed and the current progress is
-     * materialized during the next interpreter cycle. As a result, this call run asynchronously. See [flush] for the
-     * synchronous variant.
-     */
-    public fun invalidate()
-
-    /**
-     * Synchronously flush the progress of the resource context and materialize its current progress.
-     */
-    public fun flush()
-}
diff --git a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceCounters.kt b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceCounters.kt
deleted file mode 100644
index 11924db2..00000000
--- a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceCounters.kt
+++ /dev/null
@@ -1,53 +0,0 @@
-/*
- * Copyright (c) 2021 AtLarge Research
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-package org.opendc.simulator.resources
-
-/**
- * An interface that tracks cumulative counts of the work performed by a resource.
- */
-public interface SimResourceCounters {
-    /**
-     * The amount of work that resource consumers wanted the resource to perform.
-     */
-    public val demand: Double
-
-    /**
-     * The amount of work performed by the resource.
-     */
-    public val actual: Double
-
-    /**
-     * The amount of work that could not be completed due to overcommitted resources.
-     */
-    public val overcommit: Double
-
-    /**
-     * The amount of work lost due to interference.
-     */
-    public val interference: Double
-
-    /**
-     * Reset the resource counters.
-     */
-    public fun reset()
-}
diff --git a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceEvent.kt b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceEvent.kt
deleted file mode 100644
index 959427f1..00000000
--- a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceEvent.kt
+++ /dev/null
@@ -1,48 +0,0 @@
-/*
- * Copyright (c) 2021 AtLarge Research
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-package org.opendc.simulator.resources
-
-/**
- * A resource event that is communicated to the resource consumer.
- */
-public enum class SimResourceEvent {
-    /**
-     * This event is emitted to the consumer when it has started.
-     */
-    Start,
-
-    /**
-     * This event is emitted to the consumer when it has exited.
-     */
-    Exit,
-
-    /**
-     * This event is emitted to the consumer when it has started a new resource consumption or idle cycle.
-     */
-    Run,
-
-    /**
-     * This event is emitted to the consumer when the capacity of the resource has changed.
-     */
-    Capacity,
-}
diff --git a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceForwarder.kt b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceForwarder.kt
deleted file mode 100644
index 0cd2bfc7..00000000
--- a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceForwarder.kt
+++ /dev/null
@@ -1,220 +0,0 @@
-/*
- * Copyright (c) 2021 AtLarge Research
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-package org.opendc.simulator.resources
-
-import org.opendc.simulator.resources.impl.SimResourceCountersImpl
-import java.time.Clock
-
-/**
- * A class that acts as a [SimResourceConsumer] and [SimResourceProvider] at the same time.
- *
- * @param isCoupled A flag to indicate that the transformer will exit when the resource consumer exits.
- */
-public class SimResourceForwarder(private val isCoupled: Boolean = false) : SimResourceConsumer, SimResourceProvider, AutoCloseable {
-    /**
-     * The delegate [SimResourceConsumer].
-     */
-    private var delegate: SimResourceConsumer? = null
-
-    /**
-     * A flag to indicate that the delegate was started.
-     */
-    private var hasDelegateStarted: Boolean = false
-
-    /**
-     * The exposed [SimResourceContext].
-     */
-    private val _ctx = object : SimResourceContext {
-        override val clock: Clock
-            get() = _innerCtx!!.clock
-
-        override val capacity: Double
-            get() = _innerCtx?.capacity ?: 0.0
-
-        override val demand: Double
-            get() = _innerCtx?.demand ?: 0.0
-
-        override val speed: Double
-            get() = _innerCtx?.speed ?: 0.0
-
-        override fun interrupt() {
-            _innerCtx?.interrupt()
-        }
-
-        override fun push(rate: Double) {
-            _innerCtx?.push(rate)
-            _limit = rate
-        }
-
-        override fun close() {
-            val delegate = checkNotNull(delegate) { "Delegate not active" }
-
-            if (isCoupled)
-                _innerCtx?.close()
-            else
-                _innerCtx?.push(0.0)
-
-            // Warning: resumption of the continuation might change the entire state of the forwarder. Make sure we
-            // reset beforehand the existing state and check whether it has been updated afterwards
-            reset()
-
-            delegate.onEvent(this, SimResourceEvent.Exit)
-        }
-    }
-
-    /**
-     * The [SimResourceContext] in which the forwarder runs.
-     */
-    private var _innerCtx: SimResourceContext? = null
-
-    override val isActive: Boolean
-        get() = delegate != null
-
-    override val capacity: Double
-        get() = _ctx.capacity
-
-    override val speed: Double
-        get() = _ctx.speed
-
-    override val demand: Double
-        get() = _ctx.demand
-
-    override val counters: SimResourceCounters
-        get() = _counters
-    private val _counters = SimResourceCountersImpl()
-
-    override fun startConsumer(consumer: SimResourceConsumer) {
-        check(delegate == null) { "Resource transformer already active" }
-
-        delegate = consumer
-
-        // Interrupt the provider to replace the consumer
-        interrupt()
-    }
-
-    override fun interrupt() {
-        _ctx.interrupt()
-    }
-
-    override fun cancel() {
-        val delegate = delegate
-        val ctx = _innerCtx
-
-        if (delegate != null) {
-            this.delegate = null
-
-            if (ctx != null) {
-                delegate.onEvent(this._ctx, SimResourceEvent.Exit)
-            }
-        }
-    }
-
-    override fun close() {
-        val ctx = _innerCtx
-
-        if (ctx != null) {
-            this._innerCtx = null
-            ctx.interrupt()
-        }
-    }
-
-    override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
-        val delegate = delegate
-
-        if (!hasDelegateStarted) {
-            start()
-        }
-
-        updateCounters(ctx, delta)
-
-        return delegate?.onNext(this._ctx, now, delta) ?: Long.MAX_VALUE
-    }
-
-    override fun onEvent(ctx: SimResourceContext, event: SimResourceEvent) {
-        when (event) {
-            SimResourceEvent.Start -> {
-                _innerCtx = ctx
-            }
-            SimResourceEvent.Exit -> {
-                _innerCtx = null
-
-                val delegate = delegate
-                if (delegate != null) {
-                    reset()
-                    delegate.onEvent(this._ctx, SimResourceEvent.Exit)
-                }
-            }
-            else -> delegate?.onEvent(this._ctx, event)
-        }
-    }
-
-    override fun onFailure(ctx: SimResourceContext, cause: Throwable) {
-        _innerCtx = null
-
-        val delegate = delegate
-        if (delegate != null) {
-            reset()
-            delegate.onFailure(this._ctx, cause)
-        }
-    }
-
-    /**
-     * Start the delegate.
-     */
-    private fun start() {
-        val delegate = delegate ?: return
-        delegate.onEvent(checkNotNull(_innerCtx), SimResourceEvent.Start)
-
-        hasDelegateStarted = true
-    }
-
-    /**
-     * Reset the delegate.
-     */
-    private fun reset() {
-        delegate = null
-        hasDelegateStarted = false
-    }
-
-    /**
-     * The requested speed.
-     */
-    private var _limit: Double = 0.0
-
-    /**
-     * Update the resource counters for the transformer.
-     */
-    private fun updateCounters(ctx: SimResourceContext, delta: Long) {
-        if (delta <= 0) {
-            return
-        }
-
-        val counters = _counters
-        val deltaS = delta / 1000.0
-        val work = _limit * deltaS
-        val actualWork = ctx.speed * deltaS
-        counters.demand += work
-        counters.actual += actualWork
-        counters.overcommit += (work - actualWork)
-    }
-}
diff --git a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceInterpreter.kt b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceInterpreter.kt
deleted file mode 100644
index 4bfeaf20..00000000
--- a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceInterpreter.kt
+++ /dev/null
@@ -1,94 +0,0 @@
-/*
- * Copyright (c) 2021 AtLarge Research
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-package org.opendc.simulator.resources
-
-import org.opendc.simulator.resources.impl.SimResourceInterpreterImpl
-import java.time.Clock
-import kotlin.coroutines.CoroutineContext
-
-/**
- * The resource interpreter is responsible for managing the interaction between resource consumer and provider.
- *
- * The interpreter centralizes the scheduling logic of state updates of resource context, allowing update propagation
- * to happen more efficiently. and overall, reducing the work necessary to transition into a steady state.
- */
-public interface SimResourceInterpreter {
-    /**
-     * The [Clock] associated with this interpreter.
-     */
-    public val clock: Clock
-
-    /**
-     * Create a new [SimResourceControllableContext] with the given [provider].
-     *
-     * @param consumer The consumer logic.
-     * @param provider The logic of the resource provider.
-     */
-    public fun newContext(consumer: SimResourceConsumer, provider: SimResourceProviderLogic): SimResourceControllableContext
-
-    /**
-     * Start batching the execution of resource updates until [popBatch] is called.
-     *
-     * This method is useful if you want to propagate multiple resources updates (e.g., starting multiple CPUs
-     * simultaneously) in a single state update.
-     *
-     * Multiple calls to this method requires the same number of [popBatch] calls in order to properly flush the
-     * resource updates. This allows nested calls to [pushBatch], but might cause issues if [popBatch] is not called
-     * the same amount of times. To simplify batching, see [batch].
-     */
-    public fun pushBatch()
-
-    /**
-     * Stop the batching of resource updates and run the interpreter on the batch.
-     *
-     * Note that method will only flush the event once the first call to [pushBatch] has received a [popBatch] call.
-     */
-    public fun popBatch()
-
-    public companion object {
-        /**
-         * Construct a new [SimResourceInterpreter] implementation.
-         *
-         * @param context The coroutine context to use.
-         * @param clock The virtual simulation clock.
-         */
-        @JvmName("create")
-        public operator fun invoke(context: CoroutineContext, clock: Clock): SimResourceInterpreter {
-            return SimResourceInterpreterImpl(context, clock)
-        }
-    }
-}
-
-/**
- * Batch the execution of several interrupts into a single call.
- *
- * This method is useful if you want to propagate the start of multiple resources (e.g., CPUs) in a single update.
- */
-public inline fun SimResourceInterpreter.batch(block: () -> Unit) {
-    try {
-        pushBatch()
-        block()
-    } finally {
-        popBatch()
-    }
-}
diff --git a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceProvider.kt b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceProvider.kt
deleted file mode 100644
index b68b7261..00000000
--- a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceProvider.kt
+++ /dev/null
@@ -1,106 +0,0 @@
-/*
- * Copyright (c) 2021 AtLarge Research
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-package org.opendc.simulator.resources
-
-import kotlinx.coroutines.suspendCancellableCoroutine
-import kotlin.coroutines.resume
-import kotlin.coroutines.resumeWithException
-
-/**
- * A [SimResourceProvider] provides a resource that can be consumed by a [SimResourceConsumer].
- */
-public interface SimResourceProvider {
-    /**
-     * A flag to indicate that the resource provider is currently being consumed by a [SimResourceConsumer].
-     */
-    public val isActive: Boolean
-
-    /**
-     * The resource capacity available at this instant.
-     */
-    public val capacity: Double
-
-    /**
-     * The current processing speed of the resource.
-     */
-    public val speed: Double
-
-    /**
-     * The resource processing speed demand at this instant.
-     */
-    public val demand: Double
-
-    /**
-     * The resource counters to track the execution metrics of the resource.
-     */
-    public val counters: SimResourceCounters
-
-    /**
-     * Start the specified [resource consumer][consumer] in the context of this resource provider asynchronously.
-     *
-     * @throws IllegalStateException if there is already a consumer active or the resource lifetime has ended.
-     */
-    public fun startConsumer(consumer: SimResourceConsumer)
-
-    /**
-     * Interrupt the resource consumer. If there is no consumer active, this operation will be a no-op.
-     */
-    public fun interrupt()
-
-    /**
-     * Cancel the current resource consumer. If there is no consumer active, this operation will be a no-op.
-     */
-    public fun cancel()
-}
-
-/**
- * Consume the resource provided by this provider using the specified [consumer] and suspend execution until
- * the consumer has finished.
- */
-public suspend fun SimResourceProvider.consume(consumer: SimResourceConsumer) {
-    return suspendCancellableCoroutine { cont ->
-        startConsumer(object : SimResourceConsumer by consumer {
-            override fun onEvent(ctx: SimResourceContext, event: SimResourceEvent) {
-                consumer.onEvent(ctx, event)
-
-                if (event == SimResourceEvent.Exit && !cont.isCompleted) {
-                    cont.resume(Unit)
-                }
-            }
-
-            override fun onFailure(ctx: SimResourceContext, cause: Throwable) {
-                try {
-                    consumer.onFailure(ctx, cause)
-                    cont.resumeWithException(cause)
-                } catch (e: Throwable) {
-                    e.addSuppressed(cause)
-                    cont.resumeWithException(e)
-                }
-            }
-
-            override fun toString(): String = "SimSuspendingResourceConsumer"
-        })
-
-        cont.invokeOnCancellation { cancel() }
-    }
-}
diff --git a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceProviderLogic.kt b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceProviderLogic.kt
deleted file mode 100644
index cc718165..00000000
--- a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceProviderLogic.kt
+++ /dev/null
@@ -1,58 +0,0 @@
-/*
- * Copyright (c) 2021 AtLarge Research
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-package org.opendc.simulator.resources
-
-/**
- * A collection of callbacks associated with a flow stage.
- */
-public interface SimResourceProviderLogic {
-    /**
-     * This method is invoked when the consumer ask to consume the resource for the specified [duration].
-     *
-     * @param ctx The context in which the provider runs.
-     * @param now The virtual timestamp in milliseconds at which the update is occurring.
-     * @param delta The virtual duration between this call and the last call to [onConsume] in milliseconds.
-     * @param limit The limit on the work rate of the resource consumer.
-     * @param duration The duration of the consumption in milliseconds.
-     * @return The deadline of the resource consumption.
-     */
-    public fun onConsume(ctx: SimResourceControllableContext, now: Long, delta: Long, limit: Double, duration: Long) {}
-
-    /**
-     * This method is invoked when the flow graph has converged into a steady-state system.
-     *
-     * @param ctx The context in which the provider runs.
-     * @param now The virtual timestamp in milliseconds at which the system converged.
-     * @param delta The virtual duration between this call and the last call to [onConverge] in milliseconds.
-     */
-    public fun onConverge(ctx: SimResourceControllableContext, now: Long, delta: Long) {}
-
-    /**
-     * This method is invoked when the resource consumer has finished.
-     *
-     * @param ctx The context in which the provider runs.
-     * @param now The virtual timestamp in milliseconds at which the provider finished.
-     * @param delta The virtual duration between this call and the last call to [onConsume] in milliseconds.
-     */
-    public fun onFinish(ctx: SimResourceControllableContext, now: Long, delta: Long) {}
-}
diff --git a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceSource.kt b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceSource.kt
deleted file mode 100644
index c8d4cf0d..00000000
--- a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceSource.kt
+++ /dev/null
@@ -1,61 +0,0 @@
-/*
- * Copyright (c) 2021 AtLarge Research
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-package org.opendc.simulator.resources
-
-/**
- * A [SimResourceSource] represents a source for some resource that provides bounded processing capacity.
- *
- * @param initialCapacity The initial capacity of the resource.
- * @param interpreter The interpreter that is used for managing the resource contexts.
- * @param parent The parent resource system.
- */
-public class SimResourceSource(
-    initialCapacity: Double,
-    private val interpreter: SimResourceInterpreter,
-    private val parent: SimResourceSystem? = null
-) : SimAbstractResourceProvider(interpreter, initialCapacity) {
-    override fun createLogic(): SimResourceProviderLogic {
-        return object : SimResourceProviderLogic {
-            override fun onConsume(
-                ctx: SimResourceControllableContext,
-                now: Long,
-                delta: Long,
-                limit: Double,
-                duration: Long
-            ) {
-                updateCounters(ctx, delta)
-            }
-
-            override fun onFinish(ctx: SimResourceControllableContext, now: Long, delta: Long) {
-                updateCounters(ctx, delta)
-                cancel()
-            }
-
-            override fun onConverge(ctx: SimResourceControllableContext, now: Long, delta: Long) {
-                parent?.onConverge(now)
-            }
-        }
-    }
-
-    override fun toString(): String = "SimResourceSource[capacity=$capacity]"
-}
diff --git a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceSwitch.kt b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceSwitch.kt
deleted file mode 100644
index 3c25b76d..00000000
--- a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceSwitch.kt
+++ /dev/null
@@ -1,67 +0,0 @@
-/*
- * Copyright (c) 2021 AtLarge Research
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-package org.opendc.simulator.resources
-
-import org.opendc.simulator.resources.interference.InterferenceKey
-
-/**
- * A [SimResourceSwitch] enables switching of capacity of multiple resources between multiple consumers.
- */
-public interface SimResourceSwitch {
-    /**
-     * The output resource providers to which resource consumers can be attached.
-     */
-    public val outputs: Set<SimResourceProvider>
-
-    /**
-     * The input resources that will be switched between the output providers.
-     */
-    public val inputs: Set<SimResourceProvider>
-
-    /**
-     * The resource counters to track the execution metrics of all switch resources.
-     */
-    public val counters: SimResourceCounters
-
-    /**
-     * Create a new output on the switch.
-     *
-     * @param key The key of the interference member to which the output belongs.
-     */
-    public fun newOutput(key: InterferenceKey? = null): SimResourceProvider
-
-    /**
-     * Remove [output] from this switch.
-     */
-    public fun removeOutput(output: SimResourceProvider)
-
-    /**
-     * Add the specified [input] to the switch.
-     */
-    public fun addInput(input: SimResourceProvider)
-
-    /**
-     * Clear all inputs and outputs from the switch.
-     */
-    public fun clear()
-}
diff --git a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceSwitchExclusive.kt b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceSwitchExclusive.kt
deleted file mode 100644
index f1e004d2..00000000
--- a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceSwitchExclusive.kt
+++ /dev/null
@@ -1,129 +0,0 @@
-/*
- * Copyright (c) 2021 AtLarge Research
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-package org.opendc.simulator.resources
-
-import org.opendc.simulator.resources.interference.InterferenceKey
-import java.util.ArrayDeque
-
-/**
- * A [SimResourceSwitch] implementation that allocates outputs to the inputs of the switch exclusively. This means that
- * a single output is directly connected to an input and that the switch can only support as many outputs as inputs.
- */
-public class SimResourceSwitchExclusive : SimResourceSwitch {
-    override val outputs: Set<SimResourceProvider>
-        get() = _outputs
-    private val _outputs = mutableSetOf<Output>()
-
-    private val _inputs = mutableSetOf<SimResourceProvider>()
-    override val inputs: Set<SimResourceProvider>
-        get() = _inputs
-    private val _availableInputs = ArrayDeque<SimResourceForwarder>()
-
-    override val counters: SimResourceCounters = object : SimResourceCounters {
-        override val demand: Double
-            get() = _inputs.sumOf { it.counters.demand }
-        override val actual: Double
-            get() = _inputs.sumOf { it.counters.actual }
-        override val overcommit: Double
-            get() = _inputs.sumOf { it.counters.overcommit }
-        override val interference: Double
-            get() = _inputs.sumOf { it.counters.interference }
-
-        override fun reset() {
-            for (input in _inputs) {
-                input.counters.reset()
-            }
-        }
-
-        override fun toString(): String = "SimResourceCounters[demand=$demand,actual=$actual,overcommit=$overcommit]"
-    }
-
-    /**
-     * Add an output to the switch.
-     */
-    override fun newOutput(key: InterferenceKey?): SimResourceProvider {
-        val forwarder = checkNotNull(_availableInputs.poll()) { "No capacity to serve request" }
-        val output = Output(forwarder)
-        _outputs += output
-        return output
-    }
-
-    override fun removeOutput(output: SimResourceProvider) {
-        if (!_outputs.remove(output)) {
-            return
-        }
-
-        (output as Output).close()
-    }
-
-    /**
-     * Add an input to the switch.
-     */
-    override fun addInput(input: SimResourceProvider) {
-        if (input in inputs) {
-            return
-        }
-
-        val forwarder = SimResourceForwarder()
-
-        _inputs += input
-        _availableInputs += forwarder
-
-        input.startConsumer(object : SimResourceConsumer by forwarder {
-            override fun onEvent(ctx: SimResourceContext, event: SimResourceEvent) {
-                if (event == SimResourceEvent.Exit) {
-                    // De-register the input after it has finished
-                    _inputs -= input
-                }
-
-                forwarder.onEvent(ctx, event)
-            }
-        })
-    }
-
-    override fun clear() {
-        for (input in _inputs) {
-            input.cancel()
-        }
-        _inputs.clear()
-
-        // Outputs are implicitly cancelled by the inputs forwarders
-        _outputs.clear()
-    }
-
-    /**
-     * An output of the resource switch.
-     */
-    private inner class Output(private val forwarder: SimResourceForwarder) : SimResourceProvider by forwarder {
-        /**
-         * Close the output.
-         */
-        fun close() {
-            // We explicitly do not close the forwarder here in order to re-use it across output resources.
-            _outputs -= this
-            _availableInputs += forwarder
-        }
-
-        override fun toString(): String = "SimResourceSwitchExclusive.Output"
-    }
-}
diff --git a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceSwitchMaxMin.kt b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceSwitchMaxMin.kt
deleted file mode 100644
index 574fb443..00000000
--- a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceSwitchMaxMin.kt
+++ /dev/null
@@ -1,407 +0,0 @@
-/*
- * Copyright (c) 2021 AtLarge Research
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-package org.opendc.simulator.resources
-
-import org.opendc.simulator.resources.impl.SimResourceCountersImpl
-import org.opendc.simulator.resources.interference.InterferenceDomain
-import org.opendc.simulator.resources.interference.InterferenceKey
-import kotlin.math.max
-import kotlin.math.min
-
-/**
- * A [SimResourceSwitch] implementation that switches resource consumptions over the available resources using max-min
- * fair sharing.
- *
- * @param interpreter The interpreter for managing the resource contexts.
- * @param parent The parent resource system of the switch.
- * @param interferenceDomain The interference domain of the switch.
- */
-public class SimResourceSwitchMaxMin(
-    private val interpreter: SimResourceInterpreter,
-    private val parent: SimResourceSystem? = null,
-    private val interferenceDomain: InterferenceDomain? = null
-) : SimResourceSwitch {
-    /**
-     * The output resource providers to which resource consumers can be attached.
-     */
-    override val outputs: Set<SimResourceProvider>
-        get() = _outputs
-    private val _outputs = mutableSetOf<Output>()
-    private val _activeOutputs: MutableList<Output> = mutableListOf()
-
-    /**
-     * The input resources that will be switched between the output providers.
-     */
-    override val inputs: Set<SimResourceProvider>
-        get() = _inputs
-    private val _inputs = mutableSetOf<SimResourceProvider>()
-    private val _activeInputs = mutableListOf<Input>()
-
-    /**
-     * The resource counters of this switch.
-     */
-    public override val counters: SimResourceCounters
-        get() = _counters
-    private val _counters = SimResourceCountersImpl()
-
-    /**
-     * The actual processing rate of the switch.
-     */
-    private var _rate = 0.0
-
-    /**
-     * The demanded processing rate of the outputs.
-     */
-    private var _demand = 0.0
-
-    /**
-     * The capacity of the switch.
-     */
-    private var _capacity = 0.0
-
-    /**
-     * Flag to indicate that the scheduler is active.
-     */
-    private var _schedulerActive = false
-
-    /**
-     * Add an output to the switch.
-     */
-    override fun newOutput(key: InterferenceKey?): SimResourceProvider {
-        val provider = Output(_capacity, key)
-        _outputs.add(provider)
-        return provider
-    }
-
-    /**
-     * Add the specified [input] to the switch.
-     */
-    override fun addInput(input: SimResourceProvider) {
-        val consumer = Input(input)
-        if (_inputs.add(input)) {
-            _activeInputs.add(consumer)
-            input.startConsumer(consumer)
-        }
-    }
-
-    /**
-     * Remove [output] from this switch.
-     */
-    override fun removeOutput(output: SimResourceProvider) {
-        if (!_outputs.remove(output)) {
-            return
-        }
-        // This cast should always succeed since only `Output` instances should be added to _outputs
-        (output as Output).close()
-    }
-
-    override fun clear() {
-        for (input in _activeInputs) {
-            input.cancel()
-        }
-        _activeInputs.clear()
-
-        for (output in _activeOutputs) {
-            output.cancel()
-        }
-        _activeOutputs.clear()
-    }
-
-    /**
-     * Run the scheduler of the switch.
-     */
-    private fun runScheduler(now: Long) {
-        if (_schedulerActive) {
-            return
-        }
-
-        _schedulerActive = true
-        try {
-            doSchedule(now)
-        } finally {
-            _schedulerActive = false
-        }
-    }
-
-    /**
-     * Schedule the outputs over the input.
-     */
-    private fun doSchedule(now: Long) {
-        // If there is no work yet, mark the input as idle.
-        if (_activeOutputs.isEmpty()) {
-            return
-        }
-
-        val capacity = _capacity
-        var availableCapacity = capacity
-
-        // Pull in the work of the outputs
-        val outputIterator = _activeOutputs.listIterator()
-        for (output in outputIterator) {
-            output.pull(now)
-
-            // Remove outputs that have finished
-            if (!output.isActive) {
-                outputIterator.remove()
-            }
-        }
-
-        var demand = 0.0
-
-        // Sort in-place the outputs based on their requested usage.
-        // Profiling shows that it is faster than maintaining some kind of sorted set.
-        _activeOutputs.sort()
-
-        // Divide the available input capacity fairly across the outputs using max-min fair sharing
-        var remaining = _activeOutputs.size
-        for (output in _activeOutputs) {
-            val availableShare = availableCapacity / remaining--
-            val grantedSpeed = min(output.allowedRate, availableShare)
-
-            // Ignore idle computation
-            if (grantedSpeed <= 0.0) {
-                output.actualRate = 0.0
-                continue
-            }
-
-            demand += output.limit
-
-            output.actualRate = grantedSpeed
-            availableCapacity -= grantedSpeed
-        }
-
-        val rate = capacity - availableCapacity
-
-        _demand = demand
-        _rate = rate
-
-        // Sort all consumers by their capacity
-        _activeInputs.sort()
-
-        // Divide the requests over the available capacity of the input resources fairly
-        for (input in _activeInputs) {
-            val inputCapacity = input.capacity
-            val fraction = inputCapacity / capacity
-            val grantedSpeed = rate * fraction
-
-            input.push(grantedSpeed)
-        }
-    }
-
-    /**
-     * Recompute the capacity of the switch.
-     */
-    private fun updateCapacity() {
-        val newCapacity = _activeInputs.sumOf(Input::capacity)
-
-        // No-op if the capacity is unchanged
-        if (_capacity == newCapacity) {
-            return
-        }
-
-        _capacity = newCapacity
-
-        for (output in _outputs) {
-            output.capacity = newCapacity
-        }
-    }
-
-    /**
-     * An internal [SimResourceProvider] implementation for switch outputs.
-     */
-    private inner class Output(capacity: Double, val key: InterferenceKey?) :
-        SimAbstractResourceProvider(interpreter, capacity),
-        SimResourceProviderLogic,
-        Comparable<Output> {
-        /**
-         * The requested limit.
-         */
-        @JvmField var limit: Double = 0.0
-
-        /**
-         * The actual processing speed.
-         */
-        @JvmField var actualRate: Double = 0.0
-
-        /**
-         * The processing speed that is allowed by the model constraints.
-         */
-        val allowedRate: Double
-            get() = min(capacity, limit)
-
-        /**
-         * A flag to indicate that the output is closed.
-         */
-        private var _isClosed: Boolean = false
-
-        /**
-         * The timestamp at which we received the last command.
-         */
-        private var _lastPull: Long = Long.MIN_VALUE
-
-        /**
-         * Close the output.
-         *
-         * This method is invoked when the user removes an output from the switch.
-         */
-        fun close() {
-            _isClosed = true
-            cancel()
-        }
-
-        /* SimAbstractResourceProvider */
-        override fun createLogic(): SimResourceProviderLogic = this
-
-        override fun start(ctx: SimResourceControllableContext) {
-            check(!_isClosed) { "Cannot re-use closed output" }
-
-            _activeOutputs += this
-            super.start(ctx)
-        }
-
-        /* SimResourceProviderLogic */
-        override fun onConsume(
-            ctx: SimResourceControllableContext,
-            now: Long,
-            delta: Long,
-            limit: Double,
-            duration: Long
-        ) {
-            doUpdateCounters(delta)
-
-            actualRate = 0.0
-            this.limit = limit
-            _lastPull = now
-
-            runScheduler(now)
-        }
-
-        override fun onConverge(ctx: SimResourceControllableContext, now: Long, delta: Long) {
-            parent?.onConverge(now)
-        }
-
-        override fun onFinish(ctx: SimResourceControllableContext, now: Long, delta: Long) {
-            doUpdateCounters(delta)
-
-            limit = 0.0
-            actualRate = 0.0
-            _lastPull = now
-        }
-
-        /* Comparable */
-        override fun compareTo(other: Output): Int = allowedRate.compareTo(other.allowedRate)
-
-        /**
-         * Pull the next command if necessary.
-         */
-        fun pull(now: Long) {
-            val ctx = ctx
-            if (ctx != null && _lastPull < now) {
-                ctx.flush()
-            }
-        }
-
-        /**
-         * Helper method to update the resource counters of the distributor.
-         */
-        private fun doUpdateCounters(delta: Long) {
-            if (delta <= 0L) {
-                return
-            }
-
-            // Compute the performance penalty due to resource interference
-            val perfScore = if (interferenceDomain != null) {
-                val load = _rate / capacity
-                interferenceDomain.apply(key, load)
-            } else {
-                1.0
-            }
-
-            val deltaS = delta / 1000.0
-            val work = limit * deltaS
-            val actualWork = actualRate * deltaS
-            val remainingWork = work - actualWork
-
-            updateCounters(work, actualWork, remainingWork)
-
-            val distCounters = _counters
-            distCounters.demand += work
-            distCounters.actual += actualWork
-            distCounters.overcommit += remainingWork
-            distCounters.interference += actualWork * max(0.0, 1 - perfScore)
-        }
-    }
-
-    /**
-     * An internal [SimResourceConsumer] implementation for switch inputs.
-     */
-    private inner class Input(private val provider: SimResourceProvider) : SimResourceConsumer, Comparable<Input> {
-        /**
-         * The active [SimResourceContext] of this consumer.
-         */
-        private var _ctx: SimResourceContext? = null
-
-        /**
-         * The capacity of this input.
-         */
-        val capacity: Double
-            get() = _ctx?.capacity ?: 0.0
-
-        /**
-         * Push the specified rate to the provider.
-         */
-        fun push(rate: Double) {
-            _ctx?.push(rate)
-        }
-
-        /**
-         * Cancel this input.
-         */
-        fun cancel() {
-            provider.cancel()
-        }
-
-        override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
-            runScheduler(now)
-            return Long.MAX_VALUE
-        }
-
-        override fun onEvent(ctx: SimResourceContext, event: SimResourceEvent) {
-            when (event) {
-                SimResourceEvent.Start -> {
-                    assert(_ctx == null) { "Consumer running concurrently" }
-                    _ctx = ctx
-                    updateCapacity()
-                }
-                SimResourceEvent.Exit -> {
-                    _ctx = null
-                    updateCapacity()
-                }
-                SimResourceEvent.Capacity -> updateCapacity()
-                else -> {}
-            }
-        }
-
-        override fun compareTo(other: Input): Int = capacity.compareTo(other.capacity)
-    }
-}
diff --git a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceSystem.kt b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceSystem.kt
deleted file mode 100644
index 609262cb..00000000
--- a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/SimResourceSystem.kt
+++ /dev/null
@@ -1,43 +0,0 @@
-/*
- * Copyright (c) 2021 AtLarge Research
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-package org.opendc.simulator.resources
-
-/**
- * A system of possible multiple sub-resources.
- *
- * This interface is used to model hierarchies of resource providers, which can listen efficiently to changes of the
- * resource provider.
- */
-public interface SimResourceSystem {
-    /**
-     * The parent system to which this system belongs or `null` if it has no parent.
-     */
-    public val parent: SimResourceSystem?
-
-    /**
-     * This method is invoked when the system has converged to a steady-state.
-     *
-     * @param timestamp The timestamp at which the system converged.
-     */
-    public fun onConverge(timestamp: Long)
-}
diff --git a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/consumer/SimConsumerBarrier.kt b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/consumer/SimConsumerBarrier.kt
deleted file mode 100644
index 52a42241..00000000
--- a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/consumer/SimConsumerBarrier.kt
+++ /dev/null
@@ -1,52 +0,0 @@
-/*
- * Copyright (c) 2021 AtLarge Research
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-package org.opendc.simulator.resources.consumer
-
-/**
- * The [SimConsumerBarrier] is a barrier that allows consumers to wait for a select number of other consumers to
- * complete, before proceeding its operation.
- */
-public class SimConsumerBarrier(public val parties: Int) {
-    private var counter = 0
-
-    /**
-     * Enter the barrier and determine whether the caller is the last to reach the barrier.
-     *
-     * @return `true` if the caller is the last to reach the barrier, `false` otherwise.
-     */
-    public fun enter(): Boolean {
-        val last = ++counter == parties
-        if (last) {
-            counter = 0
-            return true
-        }
-        return false
-    }
-
-    /**
-     * Reset the barrier.
-     */
-    public fun reset() {
-        counter = 0
-    }
-}
diff --git a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/consumer/SimSpeedConsumerAdapter.kt b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/consumer/SimSpeedConsumerAdapter.kt
deleted file mode 100644
index 46885640..00000000
--- a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/consumer/SimSpeedConsumerAdapter.kt
+++ /dev/null
@@ -1,82 +0,0 @@
-/*
- * Copyright (c) 2021 AtLarge Research
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-package org.opendc.simulator.resources.consumer
-
-import org.opendc.simulator.resources.SimResourceConsumer
-import org.opendc.simulator.resources.SimResourceContext
-import org.opendc.simulator.resources.SimResourceEvent
-import kotlin.math.min
-
-/**
- * Helper class to expose an observable [speed] field describing the speed of the consumer.
- */
-public class SimSpeedConsumerAdapter(
-    private val delegate: SimResourceConsumer,
-    private val callback: (Double) -> Unit = {}
-) : SimResourceConsumer by delegate {
-    /**
-     * The resource processing speed at this instant.
-     */
-    public var speed: Double = 0.0
-        private set(value) {
-            if (field != value) {
-                callback(value)
-                field = value
-            }
-        }
-
-    init {
-        callback(0.0)
-    }
-
-    override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
-        return delegate.onNext(ctx, now, delta)
-    }
-
-    override fun onEvent(ctx: SimResourceContext, event: SimResourceEvent) {
-        val oldSpeed = speed
-
-        delegate.onEvent(ctx, event)
-
-        when (event) {
-            SimResourceEvent.Run -> speed = ctx.speed
-            SimResourceEvent.Capacity -> {
-                // Check if the consumer interrupted the consumer and updated the resource consumption. If not, we might
-                // need to update the current speed.
-                if (oldSpeed == speed) {
-                    speed = min(ctx.capacity, speed)
-                }
-            }
-            SimResourceEvent.Exit -> speed = 0.0
-            else -> {}
-        }
-    }
-
-    override fun onFailure(ctx: SimResourceContext, cause: Throwable) {
-        speed = 0.0
-
-        delegate.onFailure(ctx, cause)
-    }
-
-    override fun toString(): String = "SimSpeedConsumerAdapter[delegate=$delegate]"
-}
diff --git a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/consumer/SimTraceConsumer.kt b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/consumer/SimTraceConsumer.kt
deleted file mode 100644
index 4c0e075c..00000000
--- a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/consumer/SimTraceConsumer.kt
+++ /dev/null
@@ -1,73 +0,0 @@
-/*
- * Copyright (c) 2021 AtLarge Research
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-package org.opendc.simulator.resources.consumer
-
-import org.opendc.simulator.resources.SimResourceConsumer
-import org.opendc.simulator.resources.SimResourceContext
-import org.opendc.simulator.resources.SimResourceEvent
-
-/**
- * A [SimResourceConsumer] that replays a workload trace consisting of multiple fragments, each indicating the resource
- * consumption for some period of time.
- */
-public class SimTraceConsumer(private val trace: Sequence<Fragment>) : SimResourceConsumer {
-    private var _iterator: Iterator<Fragment>? = null
-    private var _nextTarget = Long.MIN_VALUE
-
-    override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
-        // Check whether the trace fragment was fully consumed, otherwise wait until we have done so
-        val nextTarget = _nextTarget
-        if (nextTarget > now) {
-            return now - nextTarget
-        }
-
-        val iterator = checkNotNull(_iterator)
-        return if (iterator.hasNext()) {
-            val fragment = iterator.next()
-            _nextTarget = now + fragment.duration
-            ctx.push(fragment.usage)
-            fragment.duration
-        } else {
-            ctx.close()
-            Long.MAX_VALUE
-        }
-    }
-
-    override fun onEvent(ctx: SimResourceContext, event: SimResourceEvent) {
-        when (event) {
-            SimResourceEvent.Start -> {
-                check(_iterator == null) { "Consumer already running" }
-                _iterator = trace.iterator()
-            }
-            SimResourceEvent.Exit -> {
-                _iterator = null
-            }
-            else -> {}
-        }
-    }
-
-    /**
-     * A fragment of the workload.
-     */
-    public data class Fragment(val duration: Long, val usage: Double)
-}
diff --git a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/consumer/SimWorkConsumer.kt b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/consumer/SimWorkConsumer.kt
deleted file mode 100644
index bf76711f..00000000
--- a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/consumer/SimWorkConsumer.kt
+++ /dev/null
@@ -1,61 +0,0 @@
-/*
- * Copyright (c) 2021 AtLarge Research
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-package org.opendc.simulator.resources.consumer
-
-import org.opendc.simulator.resources.SimResourceConsumer
-import org.opendc.simulator.resources.SimResourceContext
-import kotlin.math.roundToLong
-
-/**
- * A [SimResourceConsumer] that consumes the specified amount of work at the specified utilization.
- */
-public class SimWorkConsumer(
-    private val work: Double,
-    private val utilization: Double
-) : SimResourceConsumer {
-
-    init {
-        require(work >= 0.0) { "Work must be positive" }
-        require(utilization > 0.0) { "Utilization must be positive" }
-    }
-
-    private var remainingWork = work
-
-    override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
-        val actualWork = ctx.speed * delta / 1000.0
-        val limit = ctx.capacity * utilization
-
-        remainingWork -= actualWork
-
-        val remainingWork = remainingWork
-        val duration = (remainingWork / limit * 1000).roundToLong()
-
-        return if (duration > 0) {
-            ctx.push(limit)
-            duration
-        } else {
-            ctx.close()
-            Long.MAX_VALUE
-        }
-    }
-}
diff --git a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/impl/SimResourceContextImpl.kt b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/impl/SimResourceContextImpl.kt
deleted file mode 100644
index cbfa7afd..00000000
--- a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/impl/SimResourceContextImpl.kt
+++ /dev/null
@@ -1,367 +0,0 @@
-/*
- * Copyright (c) 2021 AtLarge Research
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-package org.opendc.simulator.resources.impl
-
-import org.opendc.simulator.resources.*
-import java.time.Clock
-import java.util.ArrayDeque
-import kotlin.math.max
-import kotlin.math.min
-
-/**
- * Implementation of a [SimResourceContext] managing the communication between resources and resource consumers.
- */
-internal class SimResourceContextImpl(
-    private val interpreter: SimResourceInterpreterImpl,
-    private val consumer: SimResourceConsumer,
-    private val logic: SimResourceProviderLogic
-) : SimResourceControllableContext {
-    /**
-     * The clock of the context.
-     */
-    override val clock: Clock
-        get() = _clock
-    private val _clock = interpreter.clock
-
-    /**
-     * The capacity of the resource.
-     */
-    override var capacity: Double = 0.0
-        set(value) {
-            val oldValue = field
-
-            // Only changes will be propagated
-            if (value != oldValue) {
-                field = value
-                onCapacityChange()
-            }
-        }
-
-    /**
-     * A flag to indicate the state of the context.
-     */
-    private var _state = State.Pending
-
-    /**
-     * The current processing speed of the resource.
-     */
-    override val speed: Double
-        get() = _rate
-    private var _rate = 0.0
-
-    /**
-     * The current resource processing demand.
-     */
-    override val demand: Double
-        get() = _limit
-
-    /**
-     * The current state of the resource context.
-     */
-    private var _limit: Double = 0.0
-    private var _activeLimit: Double = 0.0
-    private var _deadline: Long = Long.MIN_VALUE
-
-    /**
-     * A flag to indicate that an update is active.
-     */
-    private var _updateActive = false
-
-    /**
-     * The update flag indicating why the update was triggered.
-     */
-    private var _flag: Int = 0
-
-    /**
-     * The timestamp of calls to the callbacks.
-     */
-    private var _lastUpdate: Long = Long.MIN_VALUE
-    private var _lastConvergence: Long = Long.MAX_VALUE
-
-    /**
-     * The timers at which the context is scheduled to be interrupted.
-     */
-    private val _timers: ArrayDeque<SimResourceInterpreterImpl.Timer> = ArrayDeque()
-
-    override fun start() {
-        check(_state == State.Pending) { "Consumer is already started" }
-        interpreter.batch {
-            consumer.onEvent(this, SimResourceEvent.Start)
-            _state = State.Active
-            interrupt()
-        }
-    }
-
-    override fun close() {
-        if (_state == State.Stopped) {
-            return
-        }
-
-        interpreter.batch {
-            _state = State.Stopped
-            if (!_updateActive) {
-                val now = clock.millis()
-                val delta = max(0, now - _lastUpdate)
-                doStop(now, delta)
-
-                // FIX: Make sure the context converges
-                _flag = _flag or FLAG_INVALIDATE
-                scheduleUpdate(clock.millis())
-            }
-        }
-    }
-
-    override fun interrupt() {
-        if (_state == State.Stopped) {
-            return
-        }
-
-        _flag = _flag or FLAG_INTERRUPT
-        scheduleUpdate(clock.millis())
-    }
-
-    override fun invalidate() {
-        if (_state == State.Stopped) {
-            return
-        }
-
-        _flag = _flag or FLAG_INVALIDATE
-        scheduleUpdate(clock.millis())
-    }
-
-    override fun flush() {
-        if (_state == State.Stopped) {
-            return
-        }
-
-        interpreter.scheduleSync(clock.millis(), this)
-    }
-
-    override fun push(rate: Double) {
-        if (_limit == rate) {
-            return
-        }
-
-        _limit = rate
-
-        // Invalidate only if the active limit is change and no update is active
-        // If an update is active, it will already get picked up at the end of the update
-        if (_activeLimit != rate && !_updateActive) {
-            invalidate()
-        }
-    }
-
-    /**
-     * Determine whether the state of the resource context should be updated.
-     */
-    fun shouldUpdate(timestamp: Long): Boolean {
-        // Either the resource context is flagged or there is a pending update at this timestamp
-        return _flag != 0 || _limit != _activeLimit || _deadline == timestamp
-    }
-
-    /**
-     * Update the state of the resource context.
-     */
-    fun doUpdate(now: Long) {
-        val oldState = _state
-        if (oldState != State.Active) {
-            return
-        }
-
-        val lastUpdate = _lastUpdate
-
-        _lastUpdate = now
-        _updateActive = true
-
-        val delta = max(0, now - lastUpdate)
-
-        try {
-            val duration = consumer.onNext(this, now, delta)
-            val newDeadline = if (duration != Long.MAX_VALUE) now + duration else duration
-
-            // Reset update flags
-            _flag = 0
-
-            // Check whether the state has changed after [consumer.onNext]
-            when (_state) {
-                State.Active -> {
-                    logic.onConsume(this, now, delta, _limit, duration)
-
-                    // Schedule an update at the new deadline
-                    scheduleUpdate(now, newDeadline)
-                }
-                State.Stopped -> doStop(now, delta)
-                State.Pending -> throw IllegalStateException("Illegal transition to pending state")
-            }
-
-            // Note: pending limit might be changed by [logic.onConsume], so re-fetch the value
-            val newLimit = _limit
-
-            // Flush the changes to the flow
-            _activeLimit = newLimit
-            _deadline = newDeadline
-            _rate = min(capacity, newLimit)
-        } catch (cause: Throwable) {
-            doFail(now, delta, cause)
-        } finally {
-            _updateActive = false
-        }
-    }
-
-    /**
-     * Prune the elapsed timers from this context.
-     */
-    fun pruneTimers(now: Long) {
-        val timers = _timers
-        while (true) {
-            val head = timers.peek()
-            if (head == null || head.target > now) {
-                break
-            }
-            timers.poll()
-        }
-    }
-
-    /**
-     * Try to re-schedule the resource context in case it was skipped.
-     */
-    fun tryReschedule(now: Long) {
-        val deadline = _deadline
-        if (deadline > now && deadline != Long.MAX_VALUE) {
-            scheduleUpdate(now, deadline)
-        }
-    }
-
-    /**
-     * This method is invoked when the system converges into a steady state.
-     */
-    fun onConverge(timestamp: Long) {
-        val delta = max(0, timestamp - _lastConvergence)
-        _lastConvergence = timestamp
-
-        try {
-            if (_state == State.Active) {
-                consumer.onEvent(this, SimResourceEvent.Run)
-            }
-
-            logic.onConverge(this, timestamp, delta)
-        } catch (cause: Throwable) {
-            doFail(timestamp, max(0, timestamp - _lastUpdate), cause)
-        }
-    }
-
-    override fun toString(): String = "SimResourceContextImpl[capacity=$capacity,rate=$_rate]"
-
-    /**
-     * Stop the resource context.
-     */
-    private fun doStop(now: Long, delta: Long) {
-        try {
-            consumer.onEvent(this, SimResourceEvent.Exit)
-            logic.onFinish(this, now, delta)
-        } catch (cause: Throwable) {
-            doFail(now, delta, cause)
-        } finally {
-            _deadline = Long.MAX_VALUE
-            _limit = 0.0
-        }
-    }
-
-    /**
-     * Fail the resource consumer.
-     */
-    private fun doFail(now: Long, delta: Long, cause: Throwable) {
-        try {
-            consumer.onFailure(this, cause)
-        } catch (e: Throwable) {
-            e.addSuppressed(cause)
-            e.printStackTrace()
-        }
-
-        logic.onFinish(this, now, delta)
-    }
-
-    /**
-     * Indicate that the capacity of the resource has changed.
-     */
-    private fun onCapacityChange() {
-        // Do not inform the consumer if it has not been started yet
-        if (_state != State.Active) {
-            return
-        }
-
-        interpreter.batch {
-            // Inform the consumer of the capacity change. This might already trigger an interrupt.
-            consumer.onEvent(this, SimResourceEvent.Capacity)
-
-            interrupt()
-        }
-    }
-
-    /**
-     * Schedule an update for this resource context.
-     */
-    private fun scheduleUpdate(now: Long) {
-        interpreter.scheduleImmediate(now, this)
-    }
-
-    /**
-     * Schedule a delayed update for this resource context.
-     */
-    private fun scheduleUpdate(now: Long, target: Long) {
-        val timers = _timers
-        if (target != Long.MAX_VALUE && (timers.isEmpty() || target < timers.peek().target)) {
-            timers.addFirst(interpreter.scheduleDelayed(now, this, target))
-        }
-    }
-
-    /**
-     * The state of a resource context.
-     */
-    private enum class State {
-        /**
-         * The resource context is pending and the resource is waiting to be consumed.
-         */
-        Pending,
-
-        /**
-         * The resource context is active and the resource is currently being consumed.
-         */
-        Active,
-
-        /**
-         * The resource context is stopped and the resource cannot be consumed anymore.
-         */
-        Stopped
-    }
-
-    /**
-     * A flag to indicate that the context should be invalidated.
-     */
-    private val FLAG_INVALIDATE = 0b01
-
-    /**
-     * A flag to indicate that the context should be interrupted.
-     */
-    private val FLAG_INTERRUPT = 0b10
-}
diff --git a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/impl/SimResourceCountersImpl.kt b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/impl/SimResourceCountersImpl.kt
deleted file mode 100644
index 01062179..00000000
--- a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/impl/SimResourceCountersImpl.kt
+++ /dev/null
@@ -1,46 +0,0 @@
-/*
- * Copyright (c) 2021 AtLarge Research
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-package org.opendc.simulator.resources.impl
-
-import org.opendc.simulator.resources.SimResourceCounters
-
-/**
- * Mutable implementation of the [SimResourceCounters] interface.
- */
-internal class SimResourceCountersImpl : SimResourceCounters {
-    override var demand: Double = 0.0
-    override var actual: Double = 0.0
-    override var overcommit: Double = 0.0
-    override var interference: Double = 0.0
-
-    override fun reset() {
-        demand = 0.0
-        actual = 0.0
-        overcommit = 0.0
-        interference = 0.0
-    }
-
-    override fun toString(): String {
-        return "SimResourceCounters[demand=$demand,actual=$actual,overcommit=$overcommit,interference=$interference]"
-    }
-}
diff --git a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/impl/SimResourceInterpreterImpl.kt b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/impl/SimResourceInterpreterImpl.kt
deleted file mode 100644
index 2abf0749..00000000
--- a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/impl/SimResourceInterpreterImpl.kt
+++ /dev/null
@@ -1,298 +0,0 @@
-/*
- * Copyright (c) 2021 AtLarge Research
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-package org.opendc.simulator.resources.impl
-
-import kotlinx.coroutines.Delay
-import kotlinx.coroutines.DisposableHandle
-import kotlinx.coroutines.InternalCoroutinesApi
-import kotlinx.coroutines.Runnable
-import org.opendc.simulator.resources.*
-import java.time.Clock
-import java.util.*
-import kotlin.coroutines.ContinuationInterceptor
-import kotlin.coroutines.CoroutineContext
-
-/**
- * A [SimResourceInterpreter] queues all interrupts that occur during execution to be executed after.
- *
- * @param context The coroutine context to use.
- * @param clock The virtual simulation clock.
- */
-internal class SimResourceInterpreterImpl(private val context: CoroutineContext, override val clock: Clock) : SimResourceInterpreter {
-    /**
-     * The [Delay] instance that provides scheduled execution of [Runnable]s.
-     */
-    @OptIn(InternalCoroutinesApi::class)
-    private val delay = requireNotNull(context[ContinuationInterceptor] as? Delay) { "Invalid CoroutineDispatcher: no delay implementation" }
-
-    /**
-     * The queue of resource updates that are scheduled for immediate execution.
-     */
-    private val queue = ArrayDeque<SimResourceContextImpl>()
-
-    /**
-     * A priority queue containing the resource updates to be scheduled in the future.
-     */
-    private val futureQueue = PriorityQueue<Timer>()
-
-    /**
-     * The stack of interpreter invocations to occur in the future.
-     */
-    private val futureInvocations = ArrayDeque<Invocation>()
-
-    /**
-     * The systems that have been visited during the interpreter cycle.
-     */
-    private val visited = linkedSetOf<SimResourceContextImpl>()
-
-    /**
-     * The index in the batch stack.
-     */
-    private var batchIndex = 0
-
-    /**
-     * A flag to indicate that the interpreter is currently active.
-     */
-    private val isRunning: Boolean
-        get() = batchIndex > 0
-
-    /**
-     * Update the specified [ctx] synchronously.
-     */
-    fun scheduleSync(now: Long, ctx: SimResourceContextImpl) {
-        ctx.doUpdate(now)
-        visited.add(ctx)
-
-        // In-case the interpreter is already running in the call-stack, return immediately. The changes will be picked
-        // up by the active interpreter.
-        if (isRunning) {
-            return
-        }
-
-        try {
-            batchIndex++
-            runInterpreter(now)
-        } finally {
-            batchIndex--
-        }
-    }
-
-    /**
-     * Enqueue the specified [ctx] to be updated immediately during the active interpreter cycle.
-     *
-     * This method should be used when the state of a resource context is invalidated/interrupted and needs to be
-     * re-computed. In case no interpreter is currently active, the interpreter will be started.
-     */
-    fun scheduleImmediate(now: Long, ctx: SimResourceContextImpl) {
-        queue.add(ctx)
-
-        // In-case the interpreter is already running in the call-stack, return immediately. The changes will be picked
-        // up by the active interpreter.
-        if (isRunning) {
-            return
-        }
-
-        try {
-            batchIndex++
-            runInterpreter(now)
-        } finally {
-            batchIndex--
-        }
-    }
-
-    /**
-     * Schedule the interpreter to run at [target] to update the resource contexts.
-     *
-     * This method will override earlier calls to this method for the same [ctx].
-     *
-     * @param now The current virtual timestamp.
-     * @param ctx The resource context to which the event applies.
-     * @param target The timestamp when the interrupt should happen.
-     */
-    fun scheduleDelayed(now: Long, ctx: SimResourceContextImpl, target: Long): Timer {
-        val futureQueue = futureQueue
-
-        require(target >= now) { "Timestamp must be in the future" }
-
-        val timer = Timer(ctx, target)
-        futureQueue.add(timer)
-
-        return timer
-    }
-
-    override fun newContext(consumer: SimResourceConsumer, provider: SimResourceProviderLogic): SimResourceControllableContext = SimResourceContextImpl(this, consumer, provider)
-
-    override fun pushBatch() {
-        batchIndex++
-    }
-
-    override fun popBatch() {
-        try {
-            // Flush the work if the platform is not already running
-            if (batchIndex == 1 && queue.isNotEmpty()) {
-                runInterpreter(clock.millis())
-            }
-        } finally {
-            batchIndex--
-        }
-    }
-
-    /**
-     * Interpret all actions that are scheduled for the current timestamp.
-     */
-    private fun runInterpreter(now: Long) {
-        val queue = queue
-        val futureQueue = futureQueue
-        val futureInvocations = futureInvocations
-        val visited = visited
-
-        // Remove any entries in the `futureInvocations` queue from the past
-        while (true) {
-            val head = futureInvocations.peek()
-            if (head == null || head.timestamp > now) {
-                break
-            }
-            futureInvocations.poll()
-        }
-
-        // Execute all scheduled updates at current timestamp
-        while (true) {
-            val timer = futureQueue.peek() ?: break
-            val ctx = timer.ctx
-            val target = timer.target
-
-            assert(target >= now) { "Internal inconsistency: found update of the past" }
-
-            if (target > now) {
-                break
-            }
-
-            futureQueue.poll()
-
-            ctx.pruneTimers(now)
-
-            if (ctx.shouldUpdate(now)) {
-                ctx.doUpdate(now)
-                visited.add(ctx)
-            } else {
-                ctx.tryReschedule(now)
-            }
-        }
-
-        // Repeat execution of all immediate updates until the system has converged to a steady-state
-        // We have to take into account that the onConverge callback can also trigger new actions.
-        do {
-            // Execute all immediate updates
-            while (true) {
-                val ctx = queue.poll() ?: break
-
-                if (ctx.shouldUpdate(now)) {
-                    ctx.doUpdate(now)
-                    visited.add(ctx)
-                }
-            }
-
-            for (system in visited) {
-                system.onConverge(now)
-            }
-
-            visited.clear()
-        } while (queue.isNotEmpty())
-
-        // Schedule an interpreter invocation for the next update to occur.
-        val headTimer = futureQueue.peek()
-        if (headTimer != null) {
-            trySchedule(now, futureInvocations, headTimer.target)
-        }
-    }
-
-    /**
-     * Try to schedule an interpreter invocation at the specified [target].
-     *
-     * @param now The current virtual timestamp.
-     * @param target The virtual timestamp at which the interpreter invocation should happen.
-     * @param scheduled The queue of scheduled invocations.
-     */
-    private fun trySchedule(now: Long, scheduled: ArrayDeque<Invocation>, target: Long) {
-        while (true) {
-            val invocation = scheduled.peekFirst()
-            if (invocation == null || invocation.timestamp > target) {
-                // Case 2: A new timer was registered ahead of the other timers.
-                // Solution: Schedule a new scheduler invocation
-                @OptIn(InternalCoroutinesApi::class)
-                val handle = delay.invokeOnTimeout(
-                    target - now,
-                    {
-                        try {
-                            batchIndex++
-                            runInterpreter(target)
-                        } finally {
-                            batchIndex--
-                        }
-                    },
-                    context
-                )
-                scheduled.addFirst(Invocation(target, handle))
-                break
-            } else if (invocation.timestamp < target) {
-                // Case 2: A timer was cancelled and the head of the timer queue is now later than excepted
-                // Solution: Cancel the next scheduler invocation
-                scheduled.pollFirst()
-
-                invocation.cancel()
-            } else {
-                break
-            }
-        }
-    }
-
-    /**
-     * A future interpreter invocation.
-     *
-     * This class is used to keep track of the future scheduler invocations created using the [Delay] instance. In case
-     * the invocation is not needed anymore, it can be cancelled via [cancel].
-     */
-    private data class Invocation(
-        @JvmField val timestamp: Long,
-        @JvmField val handle: DisposableHandle
-    ) {
-        /**
-         * Cancel the interpreter invocation.
-         */
-        fun cancel() = handle.dispose()
-    }
-
-    /**
-     * An update call for [ctx] that is scheduled for [target].
-     *
-     * This class represents an update in the future at [target] requested by [ctx]. A deferred update might be
-     * cancelled if the resource context was invalidated in the meantime.
-     */
-    class Timer(@JvmField val ctx: SimResourceContextImpl, @JvmField val target: Long) : Comparable<Timer> {
-        override fun compareTo(other: Timer): Int {
-            return target.compareTo(other.target)
-        }
-
-        override fun toString(): String = "Timer[ctx=$ctx,timestamp=$target]"
-    }
-}
diff --git a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/interference/InterferenceDomain.kt b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/interference/InterferenceDomain.kt
deleted file mode 100644
index 1066777f..00000000
--- a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/interference/InterferenceDomain.kt
+++ /dev/null
@@ -1,19 +0,0 @@
-package org.opendc.simulator.resources.interference
-
-import org.opendc.simulator.resources.SimResourceConsumer
-
-/**
- * An interference domain represents a system of resources where [resource consumers][SimResourceConsumer] may incur
- * performance variability due to operating on the same resources and therefore causing interference.
- */
-public interface InterferenceDomain {
-    /**
-     * Compute the performance score of a participant in this interference domain.
-     *
-     * @param key The participant to obtain the score of or `null` if the participant has no key.
-     * @param load The overall load on the interference domain.
-     * @return A score representing the performance score to be applied to the resource consumer, with 1
-     * meaning no influence, <1 means that performance degrades, and >1 means that performance improves.
-     */
-    public fun apply(key: InterferenceKey?, load: Double): Double
-}
diff --git a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/interference/InterferenceKey.kt b/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/interference/InterferenceKey.kt
deleted file mode 100644
index 8b12e7b4..00000000
--- a/opendc-simulator/opendc-simulator-resources/src/main/kotlin/org/opendc/simulator/resources/interference/InterferenceKey.kt
+++ /dev/null
@@ -1,28 +0,0 @@
-/*
- * Copyright (c) 2021 AtLarge Research
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-package org.opendc.simulator.resources.interference
-
-/**
- * A key that uniquely identifies a participant of an interference domain.
- */
-public interface InterferenceKey
diff --git a/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceContextTest.kt b/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceContextTest.kt
deleted file mode 100644
index 1428ce42..00000000
--- a/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceContextTest.kt
+++ /dev/null
@@ -1,173 +0,0 @@
-/*
- * Copyright (c) 2021 AtLarge Research
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-package org.opendc.simulator.resources
-
-import io.mockk.*
-import kotlinx.coroutines.*
-import org.junit.jupiter.api.*
-import org.opendc.simulator.core.runBlockingSimulation
-import org.opendc.simulator.resources.consumer.SimWorkConsumer
-import org.opendc.simulator.resources.impl.SimResourceContextImpl
-import org.opendc.simulator.resources.impl.SimResourceInterpreterImpl
-
-/**
- * A test suite for the [SimResourceContextImpl] class.
- */
-class SimResourceContextTest {
-    @Test
-    fun testFlushWithoutCommand() = runBlockingSimulation {
-        val interpreter = SimResourceInterpreterImpl(coroutineContext, clock)
-        val consumer = object : SimResourceConsumer {
-            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
-                return if (now == 0L) {
-                    ctx.push(1.0)
-                    1000
-                } else {
-                    ctx.close()
-                    Long.MAX_VALUE
-                }
-            }
-        }
-
-        val logic = object : SimResourceProviderLogic {}
-        val context = SimResourceContextImpl(interpreter, consumer, logic)
-
-        interpreter.scheduleSync(interpreter.clock.millis(), context)
-    }
-
-    @Test
-    fun testIntermediateFlush() = runBlockingSimulation {
-        val interpreter = SimResourceInterpreterImpl(coroutineContext, clock)
-        val consumer = SimWorkConsumer(1.0, 1.0)
-
-        val logic = spyk(object : SimResourceProviderLogic {})
-        val context = SimResourceContextImpl(interpreter, consumer, logic)
-        context.capacity = 1.0
-
-        context.start()
-        delay(1) // Delay 1 ms to prevent hitting the fast path
-        interpreter.scheduleSync(interpreter.clock.millis(), context)
-
-        verify(exactly = 2) { logic.onConsume(any(), any(), any(), any(), any()) }
-    }
-
-    @Test
-    fun testIntermediateFlushIdle() = runBlockingSimulation {
-        val interpreter = SimResourceInterpreterImpl(coroutineContext, clock)
-        val consumer = SimWorkConsumer(1.0, 1.0)
-
-        val logic = spyk(object : SimResourceProviderLogic {})
-        val context = SimResourceContextImpl(interpreter, consumer, logic)
-        context.capacity = 1.0
-
-        context.start()
-        delay(500)
-        context.invalidate()
-        delay(500)
-        context.invalidate()
-
-        assertAll(
-            { verify(exactly = 2) { logic.onConsume(any(), any(), any(), any(), any()) } },
-            { verify(exactly = 1) { logic.onFinish(any(), any(), any()) } }
-        )
-    }
-
-    @Test
-    fun testDoubleStart() = runBlockingSimulation {
-        val interpreter = SimResourceInterpreterImpl(coroutineContext, clock)
-        val consumer = object : SimResourceConsumer {
-            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
-                return if (now == 0L) {
-                    ctx.push(0.0)
-                    1000
-                } else {
-                    ctx.close()
-                    Long.MAX_VALUE
-                }
-            }
-        }
-
-        val logic = object : SimResourceProviderLogic {}
-        val context = SimResourceContextImpl(interpreter, consumer, logic)
-
-        context.start()
-
-        assertThrows<IllegalStateException> {
-            context.start()
-        }
-    }
-
-    @Test
-    fun testIdempotentCapacityChange() = runBlockingSimulation {
-        val interpreter = SimResourceInterpreterImpl(coroutineContext, clock)
-        val consumer = spyk(object : SimResourceConsumer {
-            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
-                return if (now == 0L) {
-                    ctx.push(1.0)
-                    1000
-                } else {
-                    ctx.close()
-                    Long.MAX_VALUE
-                }
-            }
-        })
-
-        val logic = object : SimResourceProviderLogic {}
-        val context = SimResourceContextImpl(interpreter, consumer, logic)
-        context.capacity = 4200.0
-        context.start()
-        context.capacity = 4200.0
-
-        verify(exactly = 0) { consumer.onEvent(any(), SimResourceEvent.Capacity) }
-    }
-
-    @Test
-    fun testFailureNoInfiniteLoop() = runBlockingSimulation {
-        val interpreter = SimResourceInterpreterImpl(coroutineContext, clock)
-
-        val consumer = spyk(object : SimResourceConsumer {
-            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
-                ctx.close()
-                return Long.MAX_VALUE
-            }
-
-            override fun onEvent(ctx: SimResourceContext, event: SimResourceEvent) {
-                if (event == SimResourceEvent.Exit) throw IllegalStateException("onEvent")
-            }
-
-            override fun onFailure(ctx: SimResourceContext, cause: Throwable) {
-                throw IllegalStateException("onFailure")
-            }
-        })
-
-        val logic = object : SimResourceProviderLogic {}
-
-        val context = SimResourceContextImpl(interpreter, consumer, logic)
-
-        context.start()
-
-        delay(1)
-
-        verify(exactly = 1) { consumer.onFailure(any(), any()) }
-    }
-}
diff --git a/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceForwarderTest.kt b/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceForwarderTest.kt
deleted file mode 100644
index 49e60f68..00000000
--- a/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceForwarderTest.kt
+++ /dev/null
@@ -1,220 +0,0 @@
-/*
- * Copyright (c) 2021 AtLarge Research
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-package org.opendc.simulator.resources
-
-import io.mockk.spyk
-import io.mockk.verify
-import kotlinx.coroutines.*
-import org.junit.jupiter.api.Assertions.*
-import org.junit.jupiter.api.Test
-import org.junit.jupiter.api.assertThrows
-import org.opendc.simulator.core.runBlockingSimulation
-import org.opendc.simulator.resources.consumer.SimWorkConsumer
-import org.opendc.simulator.resources.impl.SimResourceInterpreterImpl
-
-/**
- * A test suite for the [SimResourceForwarder] class.
- */
-internal class SimResourceForwarderTest {
-    @Test
-    fun testCancelImmediately() = runBlockingSimulation {
-        val forwarder = SimResourceForwarder()
-        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
-        val source = SimResourceSource(2000.0, scheduler)
-
-        launch { source.consume(forwarder) }
-
-        forwarder.consume(object : SimResourceConsumer {
-            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
-                ctx.close()
-                return Long.MAX_VALUE
-            }
-        })
-
-        forwarder.close()
-        source.cancel()
-    }
-
-    @Test
-    fun testCancel() = runBlockingSimulation {
-        val forwarder = SimResourceForwarder()
-        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
-        val source = SimResourceSource(2000.0, scheduler)
-
-        launch { source.consume(forwarder) }
-
-        forwarder.consume(object : SimResourceConsumer {
-            var isFirst = true
-
-            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
-                return if (isFirst) {
-                    isFirst = false
-                    ctx.push(1.0)
-                    10 * 1000
-                } else {
-                    ctx.close()
-                    Long.MAX_VALUE
-                }
-            }
-        })
-
-        forwarder.close()
-        source.cancel()
-    }
-
-    @Test
-    fun testState() = runBlockingSimulation {
-        val forwarder = SimResourceForwarder()
-        val consumer = object : SimResourceConsumer {
-            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
-                ctx.close()
-                return Long.MAX_VALUE
-            }
-        }
-
-        assertFalse(forwarder.isActive)
-
-        forwarder.startConsumer(consumer)
-        assertTrue(forwarder.isActive)
-
-        assertThrows<IllegalStateException> { forwarder.startConsumer(consumer) }
-
-        forwarder.cancel()
-        assertFalse(forwarder.isActive)
-
-        forwarder.close()
-        assertFalse(forwarder.isActive)
-    }
-
-    @Test
-    fun testCancelPendingDelegate() = runBlockingSimulation {
-        val forwarder = SimResourceForwarder()
-
-        val consumer = spyk(object : SimResourceConsumer {
-            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
-                ctx.close()
-                return Long.MAX_VALUE
-            }
-        })
-
-        forwarder.startConsumer(consumer)
-        forwarder.cancel()
-
-        verify(exactly = 0) { consumer.onEvent(any(), SimResourceEvent.Exit) }
-    }
-
-    @Test
-    fun testCancelStartedDelegate() = runBlockingSimulation {
-        val forwarder = SimResourceForwarder()
-        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
-        val source = SimResourceSource(2000.0, scheduler)
-
-        val consumer = spyk(SimWorkConsumer(2000.0, 1.0))
-
-        source.startConsumer(forwarder)
-        yield()
-        forwarder.startConsumer(consumer)
-        yield()
-        forwarder.cancel()
-
-        verify(exactly = 1) { consumer.onEvent(any(), SimResourceEvent.Start) }
-        verify(exactly = 1) { consumer.onEvent(any(), SimResourceEvent.Exit) }
-    }
-
-    @Test
-    fun testCancelPropagation() = runBlockingSimulation {
-        val forwarder = SimResourceForwarder()
-        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
-        val source = SimResourceSource(2000.0, scheduler)
-
-        val consumer = spyk(SimWorkConsumer(2000.0, 1.0))
-
-        source.startConsumer(forwarder)
-        yield()
-        forwarder.startConsumer(consumer)
-        yield()
-        source.cancel()
-
-        verify(exactly = 1) { consumer.onEvent(any(), SimResourceEvent.Start) }
-        verify(exactly = 1) { consumer.onEvent(any(), SimResourceEvent.Exit) }
-    }
-
-    @Test
-    fun testExitPropagation() = runBlockingSimulation {
-        val forwarder = SimResourceForwarder(isCoupled = true)
-        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
-        val source = SimResourceSource(2000.0, scheduler)
-
-        val consumer = object : SimResourceConsumer {
-            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
-                ctx.close()
-                return Long.MAX_VALUE
-            }
-        }
-
-        source.startConsumer(forwarder)
-        forwarder.consume(consumer)
-        yield()
-
-        assertFalse(forwarder.isActive)
-    }
-
-    @Test
-    fun testAdjustCapacity() = runBlockingSimulation {
-        val forwarder = SimResourceForwarder()
-        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
-        val source = SimResourceSource(1.0, scheduler)
-
-        val consumer = spyk(SimWorkConsumer(2.0, 1.0))
-        source.startConsumer(forwarder)
-
-        coroutineScope {
-            launch { forwarder.consume(consumer) }
-            delay(1000)
-            source.capacity = 0.5
-        }
-
-        assertEquals(3000, clock.millis())
-        verify(exactly = 1) { consumer.onEvent(any(), SimResourceEvent.Capacity) }
-    }
-
-    @Test
-    fun testCounters() = runBlockingSimulation {
-        val forwarder = SimResourceForwarder()
-        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
-        val source = SimResourceSource(1.0, scheduler)
-
-        val consumer = SimWorkConsumer(2.0, 1.0)
-        source.startConsumer(forwarder)
-
-        forwarder.consume(consumer)
-
-        yield()
-
-        assertEquals(2.0, source.counters.actual)
-        assertEquals(source.counters.actual, forwarder.counters.actual) { "Actual work" }
-        assertEquals(source.counters.demand, forwarder.counters.demand) { "Work demand" }
-        assertEquals(source.counters.overcommit, forwarder.counters.overcommit) { "Overcommitted work" }
-        assertEquals(2000, clock.millis())
-    }
-}
diff --git a/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceSourceTest.kt b/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceSourceTest.kt
deleted file mode 100644
index e055daf7..00000000
--- a/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceSourceTest.kt
+++ /dev/null
@@ -1,240 +0,0 @@
-/*
- * Copyright (c) 2021 AtLarge Research
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-package org.opendc.simulator.resources
-
-import io.mockk.every
-import io.mockk.mockk
-import io.mockk.spyk
-import io.mockk.verify
-import kotlinx.coroutines.*
-import org.junit.jupiter.api.*
-import org.junit.jupiter.api.Assertions.assertEquals
-import org.opendc.simulator.core.runBlockingSimulation
-import org.opendc.simulator.resources.consumer.SimSpeedConsumerAdapter
-import org.opendc.simulator.resources.consumer.SimWorkConsumer
-import org.opendc.simulator.resources.impl.SimResourceInterpreterImpl
-
-/**
- * A test suite for the [SimResourceSource] class.
- */
-internal class SimResourceSourceTest {
-    @Test
-    fun testSpeed() = runBlockingSimulation {
-        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
-        val capacity = 4200.0
-        val provider = SimResourceSource(capacity, scheduler)
-
-        val consumer = SimWorkConsumer(4200.0, 1.0)
-
-        val res = mutableListOf<Double>()
-        val adapter = SimSpeedConsumerAdapter(consumer, res::add)
-
-        provider.consume(adapter)
-
-        assertEquals(listOf(0.0, capacity, 0.0), res) { "Speed is reported correctly" }
-    }
-
-    @Test
-    fun testAdjustCapacity() = runBlockingSimulation {
-        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
-        val provider = SimResourceSource(1.0, scheduler)
-
-        val consumer = spyk(SimWorkConsumer(2.0, 1.0))
-
-        coroutineScope {
-            launch { provider.consume(consumer) }
-            delay(1000)
-            provider.capacity = 0.5
-        }
-        assertEquals(3000, clock.millis())
-        verify(exactly = 1) { consumer.onEvent(any(), SimResourceEvent.Capacity) }
-    }
-
-    @Test
-    fun testSpeedLimit() = runBlockingSimulation {
-        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
-        val capacity = 4200.0
-        val provider = SimResourceSource(capacity, scheduler)
-
-        val consumer = SimWorkConsumer(capacity, 2.0)
-
-        val res = mutableListOf<Double>()
-        val adapter = SimSpeedConsumerAdapter(consumer, res::add)
-
-        provider.consume(adapter)
-
-        assertEquals(listOf(0.0, capacity, 0.0), res) { "Speed is reported correctly" }
-    }
-
-    /**
-     * Test to see whether no infinite recursion occurs when interrupting during [SimResourceConsumer.onStart] or
-     * [SimResourceConsumer.onNext].
-     */
-    @Test
-    fun testIntermediateInterrupt() = runBlockingSimulation {
-        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
-        val capacity = 4200.0
-        val provider = SimResourceSource(capacity, scheduler)
-
-        val consumer = object : SimResourceConsumer {
-            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
-                ctx.close()
-                return Long.MAX_VALUE
-            }
-
-            override fun onEvent(ctx: SimResourceContext, event: SimResourceEvent) {
-                ctx.interrupt()
-            }
-        }
-
-        provider.consume(consumer)
-    }
-
-    @Test
-    fun testInterrupt() = runBlockingSimulation {
-        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
-        val capacity = 4200.0
-        val provider = SimResourceSource(capacity, scheduler)
-        lateinit var resCtx: SimResourceContext
-
-        val consumer = object : SimResourceConsumer {
-            var isFirst = true
-
-            override fun onEvent(ctx: SimResourceContext, event: SimResourceEvent) {
-                when (event) {
-                    SimResourceEvent.Start -> resCtx = ctx
-                    else -> {}
-                }
-            }
-
-            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
-                return if (isFirst) {
-                    isFirst = false
-                    ctx.push(1.0)
-                    4000
-                } else {
-                    ctx.close()
-                    Long.MAX_VALUE
-                }
-            }
-        }
-
-        launch {
-            yield()
-            resCtx.interrupt()
-        }
-        provider.consume(consumer)
-
-        assertEquals(0, clock.millis())
-    }
-
-    @Test
-    fun testFailure() = runBlockingSimulation {
-        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
-        val capacity = 4200.0
-        val provider = SimResourceSource(capacity, scheduler)
-
-        val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
-        every { consumer.onEvent(any(), eq(SimResourceEvent.Start)) }
-            .throws(IllegalStateException())
-
-        assertThrows<IllegalStateException> {
-            provider.consume(consumer)
-        }
-    }
-
-    @Test
-    fun testExceptionPropagationOnNext() = runBlockingSimulation {
-        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
-        val capacity = 4200.0
-        val provider = SimResourceSource(capacity, scheduler)
-
-        val consumer = object : SimResourceConsumer {
-            var isFirst = true
-
-            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
-                return if (isFirst) {
-                    isFirst = false
-                    ctx.push(1.0)
-                    1000
-                } else {
-                    throw IllegalStateException()
-                }
-            }
-        }
-
-        assertThrows<IllegalStateException> {
-            provider.consume(consumer)
-        }
-    }
-
-    @Test
-    fun testConcurrentConsumption() = runBlockingSimulation {
-        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
-        val capacity = 4200.0
-        val provider = SimResourceSource(capacity, scheduler)
-
-        val consumer = SimWorkConsumer(capacity, 1.0)
-
-        assertThrows<IllegalStateException> {
-            coroutineScope {
-                launch { provider.consume(consumer) }
-                provider.consume(consumer)
-            }
-        }
-    }
-
-    @Test
-    fun testCancelDuringConsumption() = runBlockingSimulation {
-        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
-        val capacity = 4200.0
-        val provider = SimResourceSource(capacity, scheduler)
-
-        val consumer = SimWorkConsumer(capacity, 1.0)
-
-        launch { provider.consume(consumer) }
-        delay(500)
-        provider.cancel()
-
-        yield()
-
-        assertEquals(500, clock.millis())
-    }
-
-    @Test
-    fun testInfiniteSleep() {
-        assertThrows<IllegalStateException> {
-            runBlockingSimulation {
-                val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
-                val capacity = 4200.0
-                val provider = SimResourceSource(capacity, scheduler)
-
-                val consumer = object : SimResourceConsumer {
-                    override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long = Long.MAX_VALUE
-                }
-
-                provider.consume(consumer)
-            }
-        }
-    }
-}
diff --git a/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceSwitchExclusiveTest.kt b/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceSwitchExclusiveTest.kt
deleted file mode 100644
index 49f2da5f..00000000
--- a/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceSwitchExclusiveTest.kt
+++ /dev/null
@@ -1,156 +0,0 @@
-/*
- * Copyright (c) 2021 AtLarge Research
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-package org.opendc.simulator.resources
-
-import kotlinx.coroutines.yield
-import org.junit.jupiter.api.Assertions.assertEquals
-import org.junit.jupiter.api.Test
-import org.junit.jupiter.api.assertAll
-import org.junit.jupiter.api.assertThrows
-import org.opendc.simulator.core.runBlockingSimulation
-import org.opendc.simulator.resources.consumer.SimSpeedConsumerAdapter
-import org.opendc.simulator.resources.consumer.SimTraceConsumer
-import org.opendc.simulator.resources.consumer.SimWorkConsumer
-import org.opendc.simulator.resources.impl.SimResourceInterpreterImpl
-
-/**
- * Test suite for the [SimResourceSwitchExclusive] class.
- */
-internal class SimResourceSwitchExclusiveTest {
-    /**
-     * Test a trace workload.
-     */
-    @Test
-    fun testTrace() = runBlockingSimulation {
-        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
-
-        val speed = mutableListOf<Double>()
-
-        val duration = 5 * 60L
-        val workload =
-            SimTraceConsumer(
-                sequenceOf(
-                    SimTraceConsumer.Fragment(duration * 1000, 28.0),
-                    SimTraceConsumer.Fragment(duration * 1000, 3500.0),
-                    SimTraceConsumer.Fragment(duration * 1000, 0.0),
-                    SimTraceConsumer.Fragment(duration * 1000, 183.0)
-                ),
-            )
-
-        val switch = SimResourceSwitchExclusive()
-        val source = SimResourceSource(3200.0, scheduler)
-        val forwarder = SimResourceForwarder()
-        val adapter = SimSpeedConsumerAdapter(forwarder, speed::add)
-        source.startConsumer(adapter)
-        switch.addInput(forwarder)
-
-        val provider = switch.newOutput()
-        provider.consume(workload)
-        yield()
-
-        assertAll(
-            { assertEquals(listOf(0.0, 28.0, 3200.0, 0.0, 183.0, 0.0), speed) { "Correct speed" } },
-            { assertEquals(5 * 60L * 4000, clock.millis()) { "Took enough time" } }
-        )
-    }
-
-    /**
-     * Test runtime workload on hypervisor.
-     */
-    @Test
-    fun testRuntimeWorkload() = runBlockingSimulation {
-        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
-
-        val duration = 5 * 60L * 1000
-        val workload = SimWorkConsumer(duration * 3.2, 1.0)
-
-        val switch = SimResourceSwitchExclusive()
-        val source = SimResourceSource(3200.0, scheduler)
-
-        switch.addInput(source)
-
-        val provider = switch.newOutput()
-        provider.consume(workload)
-        yield()
-
-        assertEquals(duration, clock.millis()) { "Took enough time" }
-    }
-
-    /**
-     * Test two workloads running sequentially.
-     */
-    @Test
-    fun testTwoWorkloads() = runBlockingSimulation {
-        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
-
-        val duration = 5 * 60L * 1000
-        val workload = object : SimResourceConsumer {
-            var isFirst = true
-
-            override fun onEvent(ctx: SimResourceContext, event: SimResourceEvent) {
-                when (event) {
-                    SimResourceEvent.Start -> isFirst = true
-                    else -> {}
-                }
-            }
-
-            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
-                return if (isFirst) {
-                    isFirst = false
-                    ctx.push(1.0)
-                    duration
-                } else {
-                    ctx.close()
-                    Long.MAX_VALUE
-                }
-            }
-        }
-
-        val switch = SimResourceSwitchExclusive()
-        val source = SimResourceSource(3200.0, scheduler)
-
-        switch.addInput(source)
-
-        val provider = switch.newOutput()
-        provider.consume(workload)
-        yield()
-        provider.consume(workload)
-        assertEquals(duration * 2, clock.millis()) { "Took enough time" }
-    }
-
-    /**
-     * Test concurrent workloads on the machine.
-     */
-    @Test
-    fun testConcurrentWorkloadFails() = runBlockingSimulation {
-        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
-
-        val switch = SimResourceSwitchExclusive()
-        val source = SimResourceSource(3200.0, scheduler)
-
-        switch.addInput(source)
-
-        switch.newOutput()
-        assertThrows<IllegalStateException> { switch.newOutput() }
-    }
-}
diff --git a/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceSwitchMaxMinTest.kt b/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceSwitchMaxMinTest.kt
deleted file mode 100644
index 03f90e21..00000000
--- a/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceSwitchMaxMinTest.kt
+++ /dev/null
@@ -1,145 +0,0 @@
-/*
- * Copyright (c) 2021 AtLarge Research
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-package org.opendc.simulator.resources
-
-import kotlinx.coroutines.coroutineScope
-import kotlinx.coroutines.launch
-import kotlinx.coroutines.yield
-import org.junit.jupiter.api.*
-import org.junit.jupiter.api.Assertions.assertEquals
-import org.opendc.simulator.core.runBlockingSimulation
-import org.opendc.simulator.resources.consumer.SimTraceConsumer
-import org.opendc.simulator.resources.consumer.SimWorkConsumer
-import org.opendc.simulator.resources.impl.SimResourceInterpreterImpl
-
-/**
- * Test suite for the [SimResourceSwitch] implementations
- */
-internal class SimResourceSwitchMaxMinTest {
-    @Test
-    fun testSmoke() = runBlockingSimulation {
-        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
-        val switch = SimResourceSwitchMaxMin(scheduler)
-
-        val sources = List(2) { SimResourceSource(2000.0, scheduler) }
-        sources.forEach { switch.addInput(it) }
-
-        val provider = switch.newOutput()
-        val consumer = SimWorkConsumer(2000.0, 1.0)
-
-        try {
-            provider.consume(consumer)
-            yield()
-        } finally {
-            switch.clear()
-        }
-    }
-
-    /**
-     * Test overcommitting of resources via the hypervisor with a single VM.
-     */
-    @Test
-    fun testOvercommittedSingle() = runBlockingSimulation {
-        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
-
-        val duration = 5 * 60L
-        val workload =
-            SimTraceConsumer(
-                sequenceOf(
-                    SimTraceConsumer.Fragment(duration * 1000, 28.0),
-                    SimTraceConsumer.Fragment(duration * 1000, 3500.0),
-                    SimTraceConsumer.Fragment(duration * 1000, 0.0),
-                    SimTraceConsumer.Fragment(duration * 1000, 183.0)
-                ),
-            )
-
-        val switch = SimResourceSwitchMaxMin(scheduler)
-        val provider = switch.newOutput()
-
-        try {
-            switch.addInput(SimResourceSource(3200.0, scheduler))
-            provider.consume(workload)
-            yield()
-        } finally {
-            switch.clear()
-        }
-
-        assertAll(
-            { assertEquals(1113300.0, switch.counters.demand, "Requested work does not match") },
-            { assertEquals(1023300.0, switch.counters.actual, "Actual work does not match") },
-            { assertEquals(90000.0, switch.counters.overcommit, "Overcommitted work does not match") },
-            { assertEquals(1200000, clock.millis()) }
-        )
-    }
-
-    /**
-     * Test overcommitting of resources via the hypervisor with two VMs.
-     */
-    @Test
-    fun testOvercommittedDual() = runBlockingSimulation {
-        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
-
-        val duration = 5 * 60L
-        val workloadA =
-            SimTraceConsumer(
-                sequenceOf(
-                    SimTraceConsumer.Fragment(duration * 1000, 28.0),
-                    SimTraceConsumer.Fragment(duration * 1000, 3500.0),
-                    SimTraceConsumer.Fragment(duration * 1000, 0.0),
-                    SimTraceConsumer.Fragment(duration * 1000, 183.0)
-                ),
-            )
-        val workloadB =
-            SimTraceConsumer(
-                sequenceOf(
-                    SimTraceConsumer.Fragment(duration * 1000, 28.0),
-                    SimTraceConsumer.Fragment(duration * 1000, 3100.0),
-                    SimTraceConsumer.Fragment(duration * 1000, 0.0),
-                    SimTraceConsumer.Fragment(duration * 1000, 73.0)
-                )
-            )
-
-        val switch = SimResourceSwitchMaxMin(scheduler)
-        val providerA = switch.newOutput()
-        val providerB = switch.newOutput()
-
-        try {
-            switch.addInput(SimResourceSource(3200.0, scheduler))
-
-            coroutineScope {
-                launch { providerA.consume(workloadA) }
-                providerB.consume(workloadB)
-            }
-
-            yield()
-        } finally {
-            switch.clear()
-        }
-        assertAll(
-            { assertEquals(2073600.0, switch.counters.demand, "Requested work does not match") },
-            { assertEquals(1053600.0, switch.counters.actual, "Granted work does not match") },
-            { assertEquals(1020000.0, switch.counters.overcommit, "Overcommitted work does not match") },
-            { assertEquals(1200000, clock.millis()) }
-        )
-    }
-}
diff --git a/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimWorkConsumerTest.kt b/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimWorkConsumerTest.kt
deleted file mode 100644
index 830f16d3..00000000
--- a/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimWorkConsumerTest.kt
+++ /dev/null
@@ -1,56 +0,0 @@
-/*
- * Copyright (c) 2021 AtLarge Research
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-package org.opendc.simulator.resources
-
-import org.junit.jupiter.api.Assertions.assertEquals
-import org.junit.jupiter.api.Test
-import org.opendc.simulator.core.runBlockingSimulation
-import org.opendc.simulator.resources.consumer.SimWorkConsumer
-import org.opendc.simulator.resources.impl.SimResourceInterpreterImpl
-
-/**
- * A test suite for the [SimWorkConsumer] class.
- */
-internal class SimWorkConsumerTest {
-    @Test
-    fun testSmoke() = runBlockingSimulation {
-        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
-        val provider = SimResourceSource(1.0, scheduler)
-
-        val consumer = SimWorkConsumer(1.0, 1.0)
-
-        provider.consume(consumer)
-        assertEquals(1000, clock.millis())
-    }
-
-    @Test
-    fun testUtilization() = runBlockingSimulation {
-        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
-        val provider = SimResourceSource(1.0, scheduler)
-
-        val consumer = SimWorkConsumer(1.0, 0.5)
-
-        provider.consume(consumer)
-        assertEquals(2000, clock.millis())
-    }
-}
-- 
cgit v1.2.3