simulator: Remove generic resource constraint from resource model

This change removes the generic resource constraint (e.g., SimResource)
and replaces it by a simple capacity property. In the future, users
should handle the resource properties on a higher level.

This change simplifies compositions of consumers and providers by not
requiring a translation from resource to capacity.

7 files changed, 274 insertions, 142 deletions

diff --git a/simulator/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceAggregatorMaxMinTest.kt b/simulator/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceAggregatorMaxMinTest.kt
new file mode 100644
index 00000000..3dffc7bf
--- /dev/null
+++ b/simulator/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceAggregatorMaxMinTest.kt
@@ -0,0 +1,158 @@
+/*
+ * 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.verify
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.flow.toList
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.test.runBlockingTest
+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.resources.consumer.SimWorkConsumer
+import org.opendc.simulator.utils.DelayControllerClockAdapter
+import org.opendc.utils.TimerScheduler
+
+/**
+ * Test suite for the [SimResourceAggregatorMaxMin] class.
+ */
+@OptIn(ExperimentalCoroutinesApi::class)
+internal class SimResourceAggregatorMaxMinTest {
+    @Test
+    fun testSingleCapacity() = runBlockingTest {
+        val clock = DelayControllerClockAdapter(this)
+        val scheduler = TimerScheduler<Any>(coroutineContext, clock)
+
+        val aggregator = SimResourceAggregatorMaxMin(clock)
+        val sources = listOf(
+            SimResourceSource(1.0, clock, scheduler),
+            SimResourceSource(1.0, clock, scheduler)
+        )
+        sources.forEach(aggregator::addInput)
+
+        val consumer = SimWorkConsumer(1.0, 0.5)
+        val usage = mutableListOf<Double>()
+        val job = launch { sources[0].speed.toList(usage) }
+
+        try {
+            aggregator.output.consume(consumer)
+            yield()
+
+            assertAll(
+                { assertEquals(1000, currentTime) },
+                { assertEquals(listOf(0.0, 0.5, 0.0), usage) }
+            )
+        } finally {
+            aggregator.output.close()
+            job.cancel()
+        }
+    }
+
+    @Test
+    fun testDoubleCapacity() = runBlockingTest {
+        val clock = DelayControllerClockAdapter(this)
+        val scheduler = TimerScheduler<Any>(coroutineContext, clock)
+
+        val aggregator = SimResourceAggregatorMaxMin(clock)
+        val sources = listOf(
+            SimResourceSource(1.0, clock, scheduler),
+            SimResourceSource(1.0, clock, scheduler)
+        )
+        sources.forEach(aggregator::addInput)
+
+        val consumer = SimWorkConsumer(2.0, 1.0)
+        val usage = mutableListOf<Double>()
+        val job = launch { sources[0].speed.toList(usage) }
+
+        try {
+            aggregator.output.consume(consumer)
+            yield()
+            assertAll(
+                { assertEquals(1000, currentTime) },
+                { assertEquals(listOf(0.0, 1.0, 0.0), usage) }
+            )
+        } finally {
+            aggregator.output.close()
+            job.cancel()
+        }
+    }
+
+    @Test
+    fun testOvercommit() = runBlockingTest {
+        val clock = DelayControllerClockAdapter(this)
+        val scheduler = TimerScheduler<Any>(coroutineContext, clock)
+
+        val aggregator = SimResourceAggregatorMaxMin(clock)
+        val sources = listOf(
+            SimResourceSource(1.0, clock, scheduler),
+            SimResourceSource(1.0, clock, scheduler)
+        )
+        sources.forEach(aggregator::addInput)
+
+        val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
+        every { consumer.onNext(any()) }
+            .returns(SimResourceCommand.Consume(4.0, 4.0, 1000))
+            .andThen(SimResourceCommand.Exit)
+
+        try {
+            aggregator.output.consume(consumer)
+            yield()
+            assertEquals(1000, currentTime)
+
+            verify(exactly = 2) { consumer.onNext(any()) }
+        } finally {
+            aggregator.output.close()
+        }
+    }
+
+    @Test
+    fun testException() = runBlockingTest {
+        val clock = DelayControllerClockAdapter(this)
+        val scheduler = TimerScheduler<Any>(coroutineContext, clock)
+
+        val aggregator = SimResourceAggregatorMaxMin(clock)
+        val sources = listOf(
+            SimResourceSource(1.0, clock, scheduler),
+            SimResourceSource(1.0, clock, scheduler)
+        )
+        sources.forEach(aggregator::addInput)
+
+        val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
+        every { consumer.onNext(any()) }
+            .returns(SimResourceCommand.Consume(1.0, 1.0))
+            .andThenThrows(IllegalStateException())
+
+        try {
+            assertThrows<IllegalStateException> { aggregator.output.consume(consumer) }
+            yield()
+            assertEquals(SimResourceState.Pending, sources[0].state)
+        } finally {
+            aggregator.output.close()
+        }
+    }
+}
diff --git a/simulator/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceContextTest.kt b/simulator/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceContextTest.kt
index 5d4eb46d..c6988ed9 100644
--- a/simulator/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceContextTest.kt
+++ b/simulator/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceContextTest.kt
@@ -33,25 +33,18 @@ import org.opendc.simulator.utils.DelayControllerClockAdapter
  */
 @OptIn(ExperimentalCoroutinesApi::class)
 class SimResourceContextTest {
-    data class SimCpu(val speed: Double) : SimResource {
-        override val capacity: Double
-            get() = speed
-    }
-
     @Test
     fun testFlushWithoutCommand() = runBlockingTest {
         val clock = DelayControllerClockAdapter(this)
 
-        val resource = SimCpu(4200.0)
-
-        val consumer = mockk<SimResourceConsumer<SimCpu>>(relaxUnitFun = true)
+        val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
         every { consumer.onNext(any()) } returns SimResourceCommand.Consume(10.0, 1.0) andThen SimResourceCommand.Exit
 
-        val context = object : SimAbstractResourceContext<SimCpu>(resource, clock, consumer) {
-            override fun onIdle(deadline: Long) {}
+        val context = object : SimAbstractResourceContext(clock, consumer) {
+            override val capacity: Double = 4200.0
 
+            override fun onIdle(deadline: Long) {}
             override fun onConsume(work: Double, limit: Double, deadline: Long) {}
-
             override fun onFinish(cause: Throwable?) {}
         }
 
@@ -61,12 +54,13 @@ class SimResourceContextTest {
     @Test
     fun testIntermediateFlush() = runBlockingTest {
         val clock = DelayControllerClockAdapter(this)
-        val resource = SimCpu(4200.0)
 
-        val consumer = mockk<SimResourceConsumer<SimCpu>>(relaxUnitFun = true)
+        val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
         every { consumer.onNext(any()) } returns SimResourceCommand.Consume(10.0, 1.0) andThen SimResourceCommand.Exit
 
-        val context = spyk(object : SimAbstractResourceContext<SimCpu>(resource, clock, consumer) {
+        val context = spyk(object : SimAbstractResourceContext(clock, consumer) {
+            override val capacity: Double = 4200.0
+
             override fun onIdle(deadline: Long) {}
             override fun onFinish(cause: Throwable?) {}
             override fun onConsume(work: Double, limit: Double, deadline: Long) {}
@@ -82,12 +76,13 @@ class SimResourceContextTest {
     @Test
     fun testIntermediateFlushIdle() = runBlockingTest {
         val clock = DelayControllerClockAdapter(this)
-        val resource = SimCpu(4200.0)
 
-        val consumer = mockk<SimResourceConsumer<SimCpu>>(relaxUnitFun = true)
+        val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
         every { consumer.onNext(any()) } returns SimResourceCommand.Idle(10) andThen SimResourceCommand.Exit
 
-        val context = spyk(object : SimAbstractResourceContext<SimCpu>(resource, clock, consumer) {
+        val context = spyk(object : SimAbstractResourceContext(clock, consumer) {
+            override val capacity: Double = 4200.0
+
             override fun onIdle(deadline: Long) {}
             override fun onFinish(cause: Throwable?) {}
             override fun onConsume(work: Double, limit: Double, deadline: Long) {}
@@ -100,7 +95,7 @@ class SimResourceContextTest {
         context.flush(isIntermediate = true)
 
         assertAll(
-            { verify(exactly = 1) { context.onIdle(any()) } },
+            { verify(exactly = 2) { context.onIdle(any()) } },
             { verify(exactly = 1) { context.onFinish(null) } }
         )
     }
@@ -108,12 +103,13 @@ class SimResourceContextTest {
     @Test
     fun testDoubleStart() = runBlockingTest {
         val clock = DelayControllerClockAdapter(this)
-        val resource = SimCpu(4200.0)
 
-        val consumer = mockk<SimResourceConsumer<SimCpu>>(relaxUnitFun = true)
+        val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
         every { consumer.onNext(any()) } returns SimResourceCommand.Idle(10) andThen SimResourceCommand.Exit
 
-        val context = object : SimAbstractResourceContext<SimCpu>(resource, clock, consumer) {
+        val context = object : SimAbstractResourceContext(clock, consumer) {
+            override val capacity: Double = 4200.0
+
             override fun onIdle(deadline: Long) {}
             override fun onFinish(cause: Throwable?) {}
             override fun onConsume(work: Double, limit: Double, deadline: Long) {}
diff --git a/simulator/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceForwarderTest.kt b/simulator/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceForwarderTest.kt
index 47794bdd..f68450ff 100644
--- a/simulator/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceForwarderTest.kt
+++ b/simulator/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceForwarderTest.kt
@@ -40,28 +40,20 @@ import org.opendc.utils.TimerScheduler
  */
 @OptIn(ExperimentalCoroutinesApi::class)
 internal class SimResourceForwarderTest {
-
-    data class SimCpu(val speed: Double) : SimResource {
-        override val capacity: Double
-            get() = speed
-    }
-
     @Test
     fun testExitImmediately() = runBlockingTest {
-        val forwarder = SimResourceForwarder(SimCpu(1000.0))
+        val forwarder = SimResourceForwarder()
         val clock = DelayControllerClockAdapter(this)
         val scheduler = TimerScheduler<Any>(coroutineContext, clock)
-        val source = SimResourceSource(SimCpu(2000.0), clock, scheduler)
+        val source = SimResourceSource(2000.0, clock, scheduler)
 
         launch {
             source.consume(forwarder)
             source.close()
         }
 
-        forwarder.consume(object : SimResourceConsumer<SimCpu> {
-            override fun onNext(
-                ctx: SimResourceContext<SimCpu>
-            ): SimResourceCommand {
+        forwarder.consume(object : SimResourceConsumer {
+            override fun onNext(ctx: SimResourceContext): SimResourceCommand {
                 return SimResourceCommand.Exit
             }
         })
@@ -72,22 +64,20 @@ internal class SimResourceForwarderTest {
 
     @Test
     fun testExit() = runBlockingTest {
-        val forwarder = SimResourceForwarder(SimCpu(1000.0))
+        val forwarder = SimResourceForwarder()
         val clock = DelayControllerClockAdapter(this)
         val scheduler = TimerScheduler<Any>(coroutineContext, clock)
-        val source = SimResourceSource(SimCpu(2000.0), clock, scheduler)
+        val source = SimResourceSource(2000.0, clock, scheduler)
 
         launch {
             source.consume(forwarder)
             source.close()
         }
 
-        forwarder.consume(object : SimResourceConsumer<SimCpu> {
+        forwarder.consume(object : SimResourceConsumer {
             var isFirst = true
 
-            override fun onNext(
-                ctx: SimResourceContext<SimCpu>
-            ): SimResourceCommand {
+            override fun onNext(ctx: SimResourceContext): SimResourceCommand {
                 return if (isFirst) {
                     isFirst = false
                     SimResourceCommand.Consume(10.0, 1.0)
@@ -102,11 +92,9 @@ internal class SimResourceForwarderTest {
 
     @Test
     fun testState() = runBlockingTest {
-        val forwarder = SimResourceForwarder(SimCpu(1000.0))
-        val consumer = object : SimResourceConsumer<SimCpu> {
-            override fun onNext(
-                ctx: SimResourceContext<SimCpu>
-            ): SimResourceCommand = SimResourceCommand.Exit
+        val forwarder = SimResourceForwarder()
+        val consumer = object : SimResourceConsumer {
+            override fun onNext(ctx: SimResourceContext): SimResourceCommand = SimResourceCommand.Exit
         }
 
         assertEquals(SimResourceState.Pending, forwarder.state)
@@ -125,9 +113,9 @@ internal class SimResourceForwarderTest {
 
     @Test
     fun testCancelPendingDelegate() = runBlockingTest {
-        val forwarder = SimResourceForwarder(SimCpu(1000.0))
+        val forwarder = SimResourceForwarder()
 
-        val consumer = mockk<SimResourceConsumer<SimCpu>>(relaxUnitFun = true)
+        val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
         every { consumer.onNext(any()) } returns SimResourceCommand.Exit
 
         forwarder.startConsumer(consumer)
@@ -138,12 +126,12 @@ internal class SimResourceForwarderTest {
 
     @Test
     fun testCancelStartedDelegate() = runBlockingTest {
-        val forwarder = SimResourceForwarder(SimCpu(1000.0))
+        val forwarder = SimResourceForwarder()
         val clock = DelayControllerClockAdapter(this)
         val scheduler = TimerScheduler<Any>(coroutineContext, clock)
-        val source = SimResourceSource(SimCpu(2000.0), clock, scheduler)
+        val source = SimResourceSource(2000.0, clock, scheduler)
 
-        val consumer = mockk<SimResourceConsumer<SimCpu>>(relaxUnitFun = true)
+        val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
         every { consumer.onNext(any()) } returns SimResourceCommand.Idle(10)
 
         source.startConsumer(forwarder)
@@ -158,12 +146,12 @@ internal class SimResourceForwarderTest {
 
     @Test
     fun testCancelPropagation() = runBlockingTest {
-        val forwarder = SimResourceForwarder(SimCpu(1000.0))
+        val forwarder = SimResourceForwarder()
         val clock = DelayControllerClockAdapter(this)
         val scheduler = TimerScheduler<Any>(coroutineContext, clock)
-        val source = SimResourceSource(SimCpu(2000.0), clock, scheduler)
+        val source = SimResourceSource(2000.0, clock, scheduler)
 
-        val consumer = mockk<SimResourceConsumer<SimCpu>>(relaxUnitFun = true)
+        val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
         every { consumer.onNext(any()) } returns SimResourceCommand.Idle(10)
 
         source.startConsumer(forwarder)
diff --git a/simulator/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceSourceTest.kt b/simulator/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceSourceTest.kt
index c0ed8c9e..1279c679 100644
--- a/simulator/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceSourceTest.kt
+++ b/simulator/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceSourceTest.kt
@@ -37,20 +37,16 @@ import org.opendc.utils.TimerScheduler
  */
 @OptIn(ExperimentalCoroutinesApi::class)
 class SimResourceSourceTest {
-    data class SimCpu(val speed: Double) : SimResource {
-        override val capacity: Double
-            get() = speed
-    }
-
     @Test
     fun testSpeed() = runBlockingTest {
         val clock = DelayControllerClockAdapter(this)
         val scheduler = TimerScheduler<Any>(coroutineContext, clock)
-        val provider = SimResourceSource(SimCpu(4200.0), clock, scheduler)
+        val capacity = 4200.0
+        val provider = SimResourceSource(capacity, clock, scheduler)
 
-        val consumer = mockk<SimResourceConsumer<SimCpu>>(relaxUnitFun = true)
+        val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
         every { consumer.onNext(any()) }
-            .returns(SimResourceCommand.Consume(1000 * provider.resource.speed, provider.resource.speed))
+            .returns(SimResourceCommand.Consume(1000 * capacity, capacity))
             .andThen(SimResourceCommand.Exit)
 
         try {
@@ -60,7 +56,7 @@ class SimResourceSourceTest {
             provider.consume(consumer)
 
             job.cancel()
-            assertEquals(listOf(0.0, provider.resource.speed, 0.0), res) { "Speed is reported correctly" }
+            assertEquals(listOf(0.0, capacity, 0.0), res) { "Speed is reported correctly" }
         } finally {
             scheduler.close()
             provider.close()
@@ -71,11 +67,12 @@ class SimResourceSourceTest {
     fun testSpeedLimit() = runBlockingTest {
         val clock = DelayControllerClockAdapter(this)
         val scheduler = TimerScheduler<Any>(coroutineContext, clock)
-        val provider = SimResourceSource(SimCpu(4200.0), clock, scheduler)
+        val capacity = 4200.0
+        val provider = SimResourceSource(capacity, clock, scheduler)
 
-        val consumer = mockk<SimResourceConsumer<SimCpu>>(relaxUnitFun = true)
+        val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
         every { consumer.onNext(any()) }
-            .returns(SimResourceCommand.Consume(1000 * provider.resource.speed, 2 * provider.resource.speed))
+            .returns(SimResourceCommand.Consume(1000 * capacity, 2 * capacity))
             .andThen(SimResourceCommand.Exit)
 
         try {
@@ -85,7 +82,7 @@ class SimResourceSourceTest {
             provider.consume(consumer)
 
             job.cancel()
-            assertEquals(listOf(0.0, provider.resource.speed, 0.0), res) { "Speed is reported correctly" }
+            assertEquals(listOf(0.0, capacity, 0.0), res) { "Speed is reported correctly" }
         } finally {
             scheduler.close()
             provider.close()
@@ -100,14 +97,15 @@ class SimResourceSourceTest {
     fun testIntermediateInterrupt() = runBlockingTest {
         val clock = DelayControllerClockAdapter(this)
         val scheduler = TimerScheduler<Any>(coroutineContext, clock)
-        val provider = SimResourceSource(SimCpu(4200.0), clock, scheduler)
+        val capacity = 4200.0
+        val provider = SimResourceSource(capacity, clock, scheduler)
 
-        val consumer = object : SimResourceConsumer<SimCpu> {
-            override fun onStart(ctx: SimResourceContext<SimCpu>) {
+        val consumer = object : SimResourceConsumer {
+            override fun onStart(ctx: SimResourceContext) {
                 ctx.interrupt()
             }
 
-            override fun onNext(ctx: SimResourceContext<SimCpu>): SimResourceCommand {
+            override fun onNext(ctx: SimResourceContext): SimResourceCommand {
                 return SimResourceCommand.Exit
             }
         }
@@ -124,16 +122,17 @@ class SimResourceSourceTest {
     fun testInterrupt() = runBlockingTest {
         val clock = DelayControllerClockAdapter(this)
         val scheduler = TimerScheduler<Any>(coroutineContext, clock)
-        val provider = SimResourceSource(SimCpu(4200.0), clock, scheduler)
-        lateinit var resCtx: SimResourceContext<SimCpu>
+        val capacity = 4200.0
+        val provider = SimResourceSource(capacity, clock, scheduler)
+        lateinit var resCtx: SimResourceContext
 
-        val consumer = object : SimResourceConsumer<SimCpu> {
+        val consumer = object : SimResourceConsumer {
             var isFirst = true
-            override fun onStart(ctx: SimResourceContext<SimCpu>) {
+            override fun onStart(ctx: SimResourceContext) {
                 resCtx = ctx
             }
 
-            override fun onNext(ctx: SimResourceContext<SimCpu>): SimResourceCommand {
+            override fun onNext(ctx: SimResourceContext): SimResourceCommand {
                 assertEquals(0.0, ctx.remainingWork)
                 return if (isFirst) {
                     isFirst = false
@@ -162,9 +161,10 @@ class SimResourceSourceTest {
     fun testFailure() = runBlockingTest {
         val clock = DelayControllerClockAdapter(this)
         val scheduler = TimerScheduler<Any>(coroutineContext, clock)
-        val provider = SimResourceSource(SimCpu(4200.0), clock, scheduler)
+        val capacity = 4200.0
+        val provider = SimResourceSource(capacity, clock, scheduler)
 
-        val consumer = mockk<SimResourceConsumer<SimCpu>>(relaxUnitFun = true)
+        val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
         every { consumer.onStart(any()) }
             .throws(IllegalStateException())
 
@@ -182,9 +182,10 @@ class SimResourceSourceTest {
     fun testExceptionPropagationOnNext() = runBlockingTest {
         val clock = DelayControllerClockAdapter(this)
         val scheduler = TimerScheduler<Any>(coroutineContext, clock)
-        val provider = SimResourceSource(SimCpu(4200.0), clock, scheduler)
+        val capacity = 4200.0
+        val provider = SimResourceSource(capacity, clock, scheduler)
 
-        val consumer = mockk<SimResourceConsumer<SimCpu>>(relaxUnitFun = true)
+        val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
         every { consumer.onNext(any()) }
             .returns(SimResourceCommand.Consume(1.0, 1.0))
             .andThenThrows(IllegalStateException())
@@ -203,9 +204,10 @@ class SimResourceSourceTest {
     fun testConcurrentConsumption() = runBlockingTest {
         val clock = DelayControllerClockAdapter(this)
         val scheduler = TimerScheduler<Any>(coroutineContext, clock)
-        val provider = SimResourceSource(SimCpu(4200.0), clock, scheduler)
+        val capacity = 4200.0
+        val provider = SimResourceSource(capacity, clock, scheduler)
 
-        val consumer = mockk<SimResourceConsumer<SimCpu>>(relaxUnitFun = true)
+        val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
         every { consumer.onNext(any()) }
             .returns(SimResourceCommand.Consume(1.0, 1.0))
             .andThenThrows(IllegalStateException())
@@ -227,9 +229,10 @@ class SimResourceSourceTest {
     fun testClosedConsumption() = runBlockingTest {
         val clock = DelayControllerClockAdapter(this)
         val scheduler = TimerScheduler<Any>(coroutineContext, clock)
-        val provider = SimResourceSource(SimCpu(4200.0), clock, scheduler)
+        val capacity = 4200.0
+        val provider = SimResourceSource(capacity, clock, scheduler)
 
-        val consumer = mockk<SimResourceConsumer<SimCpu>>(relaxUnitFun = true)
+        val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
         every { consumer.onNext(any()) }
             .returns(SimResourceCommand.Consume(1.0, 1.0))
             .andThenThrows(IllegalStateException())
@@ -249,9 +252,10 @@ class SimResourceSourceTest {
     fun testCloseDuringConsumption() = runBlockingTest {
         val clock = DelayControllerClockAdapter(this)
         val scheduler = TimerScheduler<Any>(coroutineContext, clock)
-        val provider = SimResourceSource(SimCpu(4200.0), clock, scheduler)
+        val capacity = 4200.0
+        val provider = SimResourceSource(capacity, clock, scheduler)
 
-        val consumer = mockk<SimResourceConsumer<SimCpu>>(relaxUnitFun = true)
+        val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
         every { consumer.onNext(any()) }
             .returns(SimResourceCommand.Consume(1.0, 1.0))
             .andThenThrows(IllegalStateException())
@@ -272,9 +276,10 @@ class SimResourceSourceTest {
     fun testIdle() = runBlockingTest {
         val clock = DelayControllerClockAdapter(this)
         val scheduler = TimerScheduler<Any>(coroutineContext, clock)
-        val provider = SimResourceSource(SimCpu(4200.0), clock, scheduler)
+        val capacity = 4200.0
+        val provider = SimResourceSource(capacity, clock, scheduler)
 
-        val consumer = mockk<SimResourceConsumer<SimCpu>>(relaxUnitFun = true)
+        val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
         every { consumer.onNext(any()) }
             .returns(SimResourceCommand.Idle(clock.millis() + 500))
             .andThen(SimResourceCommand.Exit)
@@ -295,9 +300,10 @@ class SimResourceSourceTest {
             runBlockingTest {
                 val clock = DelayControllerClockAdapter(this)
                 val scheduler = TimerScheduler<Any>(coroutineContext, clock)
-                val provider = SimResourceSource(SimCpu(4200.0), clock, scheduler)
+                val capacity = 4200.0
+                val provider = SimResourceSource(capacity, clock, scheduler)
 
-                val consumer = mockk<SimResourceConsumer<SimCpu>>(relaxUnitFun = true)
+                val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
                 every { consumer.onNext(any()) }
                     .returns(SimResourceCommand.Idle())
                     .andThenThrows(IllegalStateException())
@@ -316,9 +322,10 @@ class SimResourceSourceTest {
     fun testIncorrectDeadline() = runBlockingTest {
         val clock = DelayControllerClockAdapter(this)
         val scheduler = TimerScheduler<Any>(coroutineContext, clock)
-        val provider = SimResourceSource(SimCpu(4200.0), clock, scheduler)
+        val capacity = 4200.0
+        val provider = SimResourceSource(capacity, clock, scheduler)
 
-        val consumer = mockk<SimResourceConsumer<SimCpu>>(relaxUnitFun = true)
+        val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
         every { consumer.onNext(any()) }
             .returns(SimResourceCommand.Idle(2))
             .andThen(SimResourceCommand.Exit)
diff --git a/simulator/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceSwitchExclusiveTest.kt b/simulator/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceSwitchExclusiveTest.kt
index dc90a43e..edd60502 100644
--- a/simulator/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceSwitchExclusiveTest.kt
+++ b/simulator/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceSwitchExclusiveTest.kt
@@ -42,11 +42,6 @@ import org.opendc.utils.TimerScheduler
  */
 @OptIn(ExperimentalCoroutinesApi::class)
 internal class SimResourceSwitchExclusiveTest {
-    class SimCpu(val speed: Double) : SimResource {
-        override val capacity: Double
-            get() = speed
-    }
-
     /**
      * Test a trace workload.
      */
@@ -68,12 +63,12 @@ internal class SimResourceSwitchExclusiveTest {
                 ),
             )
 
-        val switch = SimResourceSwitchExclusive<SimCpu>()
-        val source = SimResourceSource(SimCpu(3200.0), clock, scheduler)
+        val switch = SimResourceSwitchExclusive()
+        val source = SimResourceSource(3200.0, clock, scheduler)
 
         switch.addInput(source)
 
-        val provider = switch.addOutput(SimCpu(3200.0))
+        val provider = switch.addOutput(3200.0)
         val job = launch { source.speed.toList(speed) }
 
         try {
@@ -99,15 +94,15 @@ internal class SimResourceSwitchExclusiveTest {
         val scheduler = TimerScheduler<Any>(coroutineContext, clock)
 
         val duration = 5 * 60L * 1000
-        val workload = mockk<SimResourceConsumer<SimCpu>>(relaxUnitFun = true)
+        val workload = mockk<SimResourceConsumer>(relaxUnitFun = true)
         every { workload.onNext(any()) } returns SimResourceCommand.Consume(duration / 1000.0, 1.0) andThen SimResourceCommand.Exit
 
-        val switch = SimResourceSwitchExclusive<SimCpu>()
-        val source = SimResourceSource(SimCpu(3200.0), clock, scheduler)
+        val switch = SimResourceSwitchExclusive()
+        val source = SimResourceSource(3200.0, clock, scheduler)
 
         switch.addInput(source)
 
-        val provider = switch.addOutput(SimCpu(3200.0))
+        val provider = switch.addOutput(3200.0)
 
         try {
             provider.consume(workload)
@@ -127,16 +122,14 @@ internal class SimResourceSwitchExclusiveTest {
         val scheduler = TimerScheduler<Any>(coroutineContext, clock)
 
         val duration = 5 * 60L * 1000
-        val workload = object : SimResourceConsumer<SimCpu> {
+        val workload = object : SimResourceConsumer {
             var isFirst = true
 
-            override fun onStart(ctx: SimResourceContext<SimCpu>) {
+            override fun onStart(ctx: SimResourceContext) {
                 isFirst = true
             }
 
-            override fun onNext(
-                ctx: SimResourceContext<SimCpu>
-            ): SimResourceCommand {
+            override fun onNext(ctx: SimResourceContext): SimResourceCommand {
                 return if (isFirst) {
                     isFirst = false
                     SimResourceCommand.Consume(duration / 1000.0, 1.0)
@@ -146,12 +139,12 @@ internal class SimResourceSwitchExclusiveTest {
             }
         }
 
-        val switch = SimResourceSwitchExclusive<SimCpu>()
-        val source = SimResourceSource(SimCpu(3200.0), clock, scheduler)
+        val switch = SimResourceSwitchExclusive()
+        val source = SimResourceSource(3200.0, clock, scheduler)
 
         switch.addInput(source)
 
-        val provider = switch.addOutput(SimCpu(3200.0))
+        val provider = switch.addOutput(3200.0)
 
         try {
             provider.consume(workload)
@@ -172,15 +165,15 @@ internal class SimResourceSwitchExclusiveTest {
         val scheduler = TimerScheduler<Any>(coroutineContext, clock)
 
         val duration = 5 * 60L * 1000
-        val workload = mockk<SimResourceConsumer<SimCpu>>(relaxUnitFun = true)
+        val workload = mockk<SimResourceConsumer>(relaxUnitFun = true)
         every { workload.onNext(any()) } returns SimResourceCommand.Consume(duration / 1000.0, 1.0) andThen SimResourceCommand.Exit
 
-        val switch = SimResourceSwitchExclusive<SimCpu>()
-        val source = SimResourceSource(SimCpu(3200.0), clock, scheduler)
+        val switch = SimResourceSwitchExclusive()
+        val source = SimResourceSource(3200.0, clock, scheduler)
 
         switch.addInput(source)
 
-        switch.addOutput(SimCpu(3200.0))
-        assertThrows<IllegalStateException> { switch.addOutput(SimCpu(3200.0)) }
+        switch.addOutput(3200.0)
+        assertThrows<IllegalStateException> { switch.addOutput(3200.0) }
     }
 }
diff --git a/simulator/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceSwitchMaxMinTest.kt b/simulator/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceSwitchMaxMinTest.kt
index 8b989334..5f4fd187 100644
--- a/simulator/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceSwitchMaxMinTest.kt
+++ b/simulator/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceSwitchMaxMinTest.kt
@@ -40,23 +40,18 @@ import org.opendc.utils.TimerScheduler
  */
 @OptIn(ExperimentalCoroutinesApi::class)
 internal class SimResourceSwitchMaxMinTest {
-    class SimCpu(val speed: Double) : SimResource {
-        override val capacity: Double
-            get() = speed
-    }
-
     @Test
     fun testSmoke() = runBlockingTest {
         val clock = DelayControllerClockAdapter(this)
         val scheduler = TimerScheduler<Any>(coroutineContext, clock)
-        val switch = SimResourceSwitchMaxMin<SimCpu>(clock)
+        val switch = SimResourceSwitchMaxMin(clock)
 
-        val sources = List(2) { SimResourceSource(SimCpu(2000.0), clock, scheduler) }
+        val sources = List(2) { SimResourceSource(2000.0, clock, scheduler) }
         sources.forEach { switch.addInput(it) }
 
-        val provider = switch.addOutput(SimCpu(1000.0))
+        val provider = switch.addOutput(1000.0)
 
-        val consumer = mockk<SimResourceConsumer<SimCpu>>(relaxUnitFun = true)
+        val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
         every { consumer.onNext(any()) } returns SimResourceCommand.Consume(1.0, 1.0) andThen SimResourceCommand.Exit
 
         try {
@@ -76,13 +71,13 @@ internal class SimResourceSwitchMaxMinTest {
         val clock = DelayControllerClockAdapter(this)
         val scheduler = TimerScheduler<Any>(coroutineContext, clock)
 
-        val listener = object : SimResourceSwitchMaxMin.Listener<SimCpu> {
+        val listener = object : SimResourceSwitchMaxMin.Listener {
             var totalRequestedWork = 0L
             var totalGrantedWork = 0L
             var totalOvercommittedWork = 0L
 
             override fun onSliceFinish(
-                switch: SimResourceSwitchMaxMin<SimCpu>,
+                switch: SimResourceSwitchMaxMin,
                 requestedWork: Long,
                 grantedWork: Long,
                 overcommittedWork: Long,
@@ -108,10 +103,10 @@ internal class SimResourceSwitchMaxMinTest {
             )
 
         val switch = SimResourceSwitchMaxMin(clock, listener)
-        val provider = switch.addOutput(SimCpu(3200.0))
+        val provider = switch.addOutput(3200.0)
 
         try {
-            switch.addInput(SimResourceSource(SimCpu(3200.0), clock, scheduler))
+            switch.addInput(SimResourceSource(3200.0, clock, scheduler))
             provider.consume(workload)
             yield()
         } finally {
@@ -135,13 +130,13 @@ internal class SimResourceSwitchMaxMinTest {
         val clock = DelayControllerClockAdapter(this)
         val scheduler = TimerScheduler<Any>(coroutineContext, clock)
 
-        val listener = object : SimResourceSwitchMaxMin.Listener<SimCpu> {
+        val listener = object : SimResourceSwitchMaxMin.Listener {
             var totalRequestedWork = 0L
             var totalGrantedWork = 0L
             var totalOvercommittedWork = 0L
 
             override fun onSliceFinish(
-                switch: SimResourceSwitchMaxMin<SimCpu>,
+                switch: SimResourceSwitchMaxMin,
                 requestedWork: Long,
                 grantedWork: Long,
                 overcommittedWork: Long,
@@ -176,11 +171,11 @@ internal class SimResourceSwitchMaxMinTest {
             )
 
         val switch = SimResourceSwitchMaxMin(clock, listener)
-        val providerA = switch.addOutput(SimCpu(3200.0))
-        val providerB = switch.addOutput(SimCpu(3200.0))
+        val providerA = switch.addOutput(3200.0)
+        val providerB = switch.addOutput(3200.0)
 
         try {
-            switch.addInput(SimResourceSource(SimCpu(3200.0), clock, scheduler))
+            switch.addInput(SimResourceSource(3200.0, clock, scheduler))
 
             coroutineScope {
                 launch { providerA.consume(workloadA) }
diff --git a/simulator/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimWorkConsumerTest.kt b/simulator/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimWorkConsumerTest.kt
index b05195f7..4d6b19ee 100644
--- a/simulator/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimWorkConsumerTest.kt
+++ b/simulator/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimWorkConsumerTest.kt
@@ -35,18 +35,13 @@ import org.opendc.utils.TimerScheduler
  */
 @OptIn(ExperimentalCoroutinesApi::class)
 internal class SimWorkConsumerTest {
-    data class SimCpu(val speed: Double) : SimResource {
-        override val capacity: Double
-            get() = speed
-    }
-
     @Test
     fun testSmoke() = runBlockingTest {
         val clock = DelayControllerClockAdapter(this)
         val scheduler = TimerScheduler<Any>(coroutineContext, clock)
-        val provider = SimResourceSource(SimCpu(1.0), clock, scheduler)
+        val provider = SimResourceSource(1.0, clock, scheduler)
 
-        val consumer = SimWorkConsumer<SimCpu>(1.0, 1.0)
+        val consumer = SimWorkConsumer(1.0, 1.0)
 
         try {
             provider.consume(consumer)
@@ -60,9 +55,9 @@ internal class SimWorkConsumerTest {
     fun testUtilization() = runBlockingTest {
         val clock = DelayControllerClockAdapter(this)
         val scheduler = TimerScheduler<Any>(coroutineContext, clock)
-        val provider = SimResourceSource(SimCpu(1.0), clock, scheduler)
+        val provider = SimResourceSource(1.0, clock, scheduler)
 
-        val consumer = SimWorkConsumer<SimCpu>(1.0, 0.5)
+        val consumer = SimWorkConsumer(1.0, 0.5)
 
         try {
             provider.consume(consumer)