simulator: Add CPUFreq subsystem

This pull request adds a CPUFreq subsystem to the simulator module. This subsystem allows a simulated machine to perform frequency scaling, which in turn should reduce energy consumption.

29 files changed, 768 insertions, 279 deletions

diff --git a/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/SimHost.kt b/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/SimHost.kt
index 6d81aa7d..8e1aab44 100644
--- a/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/SimHost.kt
+++ b/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/SimHost.kt
@@ -31,11 +31,13 @@ import org.opendc.compute.api.Server
 import org.opendc.compute.api.ServerState
 import org.opendc.compute.service.driver.*
 import org.opendc.simulator.compute.*
+import org.opendc.simulator.compute.cpufreq.PerformanceScalingGovernor
+import org.opendc.simulator.compute.cpufreq.SimpleScalingDriver
 import org.opendc.simulator.compute.interference.IMAGE_PERF_INTERFERENCE_MODEL
 import org.opendc.simulator.compute.interference.PerformanceInterferenceModel
 import org.opendc.simulator.compute.model.MemoryUnit
 import org.opendc.simulator.compute.power.ConstantPowerModel
-import org.opendc.simulator.compute.power.MachinePowerModel
+import org.opendc.simulator.compute.power.PowerModel
 import org.opendc.simulator.failures.FailureDomain
 import java.time.Clock
 import java.util.*
@@ -54,7 +56,7 @@ public class SimHost(
     clock: Clock,
     meter: Meter,
     hypervisor: SimHypervisorProvider,
-    powerModel: MachinePowerModel = ConstantPowerModel(0.0),
+    powerModel: PowerModel = ConstantPowerModel(0.0),
     private val mapper: SimWorkloadMapper = SimMetaWorkloadMapper(),
 ) : Host, FailureDomain, AutoCloseable {
     /**
@@ -80,7 +82,7 @@ public class SimHost(
     /**
      * The machine to run on.
      */
-    public val machine: SimBareMetalMachine = SimBareMetalMachine(context, clock, model, powerModel)
+    public val machine: SimBareMetalMachine = SimBareMetalMachine(context, clock, model, PerformanceScalingGovernor(), SimpleScalingDriver(powerModel))
 
     /**
      * The hypervisor to run multiple workloads.
diff --git a/simulator/opendc-experiments/opendc-experiments-capelin/src/main/kotlin/org/opendc/experiments/capelin/trace/Sc20RawParquetTraceReader.kt b/simulator/opendc-experiments/opendc-experiments-capelin/src/main/kotlin/org/opendc/experiments/capelin/trace/Sc20RawParquetTraceReader.kt
index 7ea5efe5..ffbf46d4 100644
--- a/simulator/opendc-experiments/opendc-experiments-capelin/src/main/kotlin/org/opendc/experiments/capelin/trace/Sc20RawParquetTraceReader.kt
+++ b/simulator/opendc-experiments/opendc-experiments-capelin/src/main/kotlin/org/opendc/experiments/capelin/trace/Sc20RawParquetTraceReader.kt
@@ -145,4 +145,13 @@ public class Sc20RawParquetTraceReader(private val path: File) {
      * Read the entries in the trace.
      */
     public fun read(): List<TraceEntry<SimWorkload>> = entries
+
+    /**
+     * Create a [TraceReader] instance.
+     */
+    public fun createReader(): TraceReader<SimWorkload> {
+        return object : TraceReader<SimWorkload>, Iterator<TraceEntry<SimWorkload>> by entries.iterator() {
+            override fun close() {}
+        }
+    }
 }
diff --git a/simulator/opendc-format/src/main/kotlin/org/opendc/format/environment/MachineDef.kt b/simulator/opendc-format/src/main/kotlin/org/opendc/format/environment/MachineDef.kt
index c7f7c4dc..9b799cc2 100644
--- a/simulator/opendc-format/src/main/kotlin/org/opendc/format/environment/MachineDef.kt
+++ b/simulator/opendc-format/src/main/kotlin/org/opendc/format/environment/MachineDef.kt
@@ -23,7 +23,7 @@
 package org.opendc.format.environment
 
 import org.opendc.simulator.compute.SimMachineModel
-import org.opendc.simulator.compute.power.MachinePowerModel
+import org.opendc.simulator.compute.power.PowerModel
 import java.util.*
 
 public data class MachineDef(
@@ -31,5 +31,5 @@ public data class MachineDef(
     val name: String,
     val meta: Map<String, Any>,
     val model: SimMachineModel,
-    val powerModel: MachinePowerModel
+    val powerModel: PowerModel
 )
diff --git a/simulator/opendc-serverless/opendc-serverless-simulator/src/main/kotlin/org/opendc/serverless/simulator/SimFunctionDeployer.kt b/simulator/opendc-serverless/opendc-serverless-simulator/src/main/kotlin/org/opendc/serverless/simulator/SimFunctionDeployer.kt
index 7a48609c..f28a926b 100644
--- a/simulator/opendc-serverless/opendc-serverless-simulator/src/main/kotlin/org/opendc/serverless/simulator/SimFunctionDeployer.kt
+++ b/simulator/opendc-serverless/opendc-serverless-simulator/src/main/kotlin/org/opendc/serverless/simulator/SimFunctionDeployer.kt
@@ -32,6 +32,9 @@ import org.opendc.serverless.simulator.workload.SimServerlessWorkloadMapper
 import org.opendc.simulator.compute.SimBareMetalMachine
 import org.opendc.simulator.compute.SimMachine
 import org.opendc.simulator.compute.SimMachineModel
+import org.opendc.simulator.compute.cpufreq.PerformanceScalingGovernor
+import org.opendc.simulator.compute.cpufreq.SimpleScalingDriver
+import org.opendc.simulator.compute.power.ConstantPowerModel
 import java.time.Clock
 import java.util.ArrayDeque
 import kotlin.coroutines.Continuation
@@ -66,7 +69,7 @@ public class SimFunctionDeployer(
         /**
          * The machine that will execute the workloads.
          */
-        public val machine: SimMachine = SimBareMetalMachine(scope.coroutineContext, clock, model)
+        public val machine: SimMachine = SimBareMetalMachine(scope.coroutineContext, clock, model, PerformanceScalingGovernor(), SimpleScalingDriver(ConstantPowerModel(0.0)))
 
         /**
          * The job associated with the lifecycle of the instance.
diff --git a/simulator/opendc-simulator/opendc-simulator-compute/src/jmh/kotlin/org/opendc/simulator/compute/SimMachineBenchmarks.kt b/simulator/opendc-simulator/opendc-simulator-compute/src/jmh/kotlin/org/opendc/simulator/compute/SimMachineBenchmarks.kt
index eb22c855..c2a29f5b 100644
--- a/simulator/opendc-simulator/opendc-simulator-compute/src/jmh/kotlin/org/opendc/simulator/compute/SimMachineBenchmarks.kt
+++ b/simulator/opendc-simulator/opendc-simulator-compute/src/jmh/kotlin/org/opendc/simulator/compute/SimMachineBenchmarks.kt
@@ -27,9 +27,12 @@ import kotlinx.coroutines.coroutineScope
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.test.TestCoroutineScope
 import kotlinx.coroutines.test.runBlockingTest
+import org.opendc.simulator.compute.cpufreq.PerformanceScalingGovernor
+import org.opendc.simulator.compute.cpufreq.SimpleScalingDriver
 import org.opendc.simulator.compute.model.MemoryUnit
 import org.opendc.simulator.compute.model.ProcessingNode
 import org.opendc.simulator.compute.model.ProcessingUnit
+import org.opendc.simulator.compute.power.ConstantPowerModel
 import org.opendc.simulator.compute.workload.SimWorkload
 import org.opendc.simulator.utils.DelayControllerClockAdapter
 import org.opendc.utils.TimerScheduler
@@ -75,7 +78,10 @@ class SimMachineBenchmarks {
     @Benchmark
     fun benchmarkBareMetal(state: Workload) {
         return scope.runBlockingTest {
-            val machine = SimBareMetalMachine(scope.coroutineContext, clock, machineModel)
+            val machine = SimBareMetalMachine(
+                coroutineContext, clock, machineModel, PerformanceScalingGovernor(),
+                SimpleScalingDriver(ConstantPowerModel(0.0))
+            )
             return@runBlockingTest machine.run(state.workloads[0])
         }
     }
@@ -83,7 +89,10 @@ class SimMachineBenchmarks {
     @Benchmark
     fun benchmarkSpaceSharedHypervisor(state: Workload) {
         return scope.runBlockingTest {
-            val machine = SimBareMetalMachine(coroutineContext, clock, machineModel)
+            val machine = SimBareMetalMachine(
+                coroutineContext, clock, machineModel, PerformanceScalingGovernor(),
+                SimpleScalingDriver(ConstantPowerModel(0.0))
+            )
             val hypervisor = SimSpaceSharedHypervisor()
 
             launch { machine.run(hypervisor) }
@@ -102,7 +111,10 @@ class SimMachineBenchmarks {
     @Benchmark
     fun benchmarkFairShareHypervisorSingle(state: Workload) {
         return scope.runBlockingTest {
-            val machine = SimBareMetalMachine(coroutineContext, clock, machineModel)
+            val machine = SimBareMetalMachine(
+                coroutineContext, clock, machineModel, PerformanceScalingGovernor(),
+                SimpleScalingDriver(ConstantPowerModel(0.0))
+            )
             val hypervisor = SimFairShareHypervisor()
 
             launch { machine.run(hypervisor) }
@@ -121,7 +133,10 @@ class SimMachineBenchmarks {
     @Benchmark
     fun benchmarkFairShareHypervisorDouble(state: Workload) {
         return scope.runBlockingTest {
-            val machine = SimBareMetalMachine(coroutineContext, clock, machineModel)
+            val machine = SimBareMetalMachine(
+                coroutineContext, clock, machineModel, PerformanceScalingGovernor(),
+                SimpleScalingDriver(ConstantPowerModel(0.0))
+            )
             val hypervisor = SimFairShareHypervisor()
 
             launch { machine.run(hypervisor) }
diff --git a/simulator/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/SimBareMetalMachine.kt b/simulator/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/SimBareMetalMachine.kt
index 830ff70e..51b807d2 100644
--- a/simulator/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/SimBareMetalMachine.kt
+++ b/simulator/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/SimBareMetalMachine.kt
@@ -24,9 +24,9 @@ package org.opendc.simulator.compute
 
 import kotlinx.coroutines.*
 import kotlinx.coroutines.flow.*
+import org.opendc.simulator.compute.cpufreq.ScalingDriver
+import org.opendc.simulator.compute.cpufreq.ScalingGovernor
 import org.opendc.simulator.compute.model.ProcessingUnit
-import org.opendc.simulator.compute.power.ConstantPowerModel
-import org.opendc.simulator.compute.power.MachinePowerModel
 import org.opendc.simulator.resources.*
 import org.opendc.utils.TimerScheduler
 import java.time.Clock
@@ -47,18 +47,14 @@ public class SimBareMetalMachine(
     context: CoroutineContext,
     private val clock: Clock,
     override val model: SimMachineModel,
-    private val powerModel: MachinePowerModel = ConstantPowerModel(0.0)
+    scalingGovernor: ScalingGovernor,
+    scalingDriver: ScalingDriver
 ) : SimAbstractMachine(clock) {
     /**
      * The [Job] associated with this machine.
      */
     private val scope = CoroutineScope(context + Job())
 
-    /**
-     * The power draw of the machine.
-     */
-    public val powerDraw: StateFlow<Double> = usage.map { powerModel.computeCpuPower(it) }.stateIn(scope, SharingStarted.Eagerly, 0.0)
-
     override val context: CoroutineContext = scope.coroutineContext
 
     /**
@@ -69,6 +65,32 @@ public class SimBareMetalMachine(
     override val resources: Map<ProcessingUnit, SimResourceSource> =
         model.cpus.associateWith { SimResourceSource(it.frequency, clock, scheduler) }
 
+    /**
+     * Construct the [ScalingDriver.Logic] for this machine.
+     */
+    private val scalingDriver = scalingDriver.createLogic(this)
+
+    /**
+     * The scaling contexts associated with each CPU.
+     */
+    private val scalingGovernors = resources.map { (cpu, resource) ->
+        scalingGovernor.createLogic(this.scalingDriver.createContext(cpu, resource))
+    }
+
+    init {
+        scalingGovernors.forEach { it.onStart() }
+    }
+
+    /**
+     * The power draw of the machine.
+     */
+    public val powerDraw: StateFlow<Double> = usage
+        .map {
+            this.scalingGovernors.forEach { it.onLimit() }
+            this.scalingDriver.computePower()
+        }
+        .stateIn(scope, SharingStarted.Eagerly, 0.0)
+
     override fun close() {
         super.close()
 
diff --git a/simulator/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/cpufreq/DemandScalingGovernor.kt b/simulator/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/cpufreq/DemandScalingGovernor.kt
new file mode 100644
index 00000000..b4bbf9fb
--- /dev/null
+++ b/simulator/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/cpufreq/DemandScalingGovernor.kt
@@ -0,0 +1,36 @@
+/*
+ * 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.compute.cpufreq
+
+/**
+ * A CPUFreq [ScalingGovernor] that requests the frequency based on the utilization of the machine.
+ */
+public class DemandScalingGovernor : ScalingGovernor {
+    override fun createLogic(ctx: ScalingContext): ScalingGovernor.Logic = object : ScalingGovernor.Logic {
+        override fun onLimit() {
+            ctx.setTarget(ctx.resource.speed.value)
+        }
+
+        override fun toString(): String = "DemandScalingGovernor.Logic"
+    }
+}
diff --git a/simulator/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/cpufreq/PStateScalingDriver.kt b/simulator/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/cpufreq/PStateScalingDriver.kt
new file mode 100644
index 00000000..d109e4d8
--- /dev/null
+++ b/simulator/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/cpufreq/PStateScalingDriver.kt
@@ -0,0 +1,88 @@
+/*
+ * 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.compute.cpufreq
+
+import org.opendc.simulator.compute.SimMachine
+import org.opendc.simulator.compute.model.ProcessingUnit
+import org.opendc.simulator.compute.power.PowerModel
+import org.opendc.simulator.resources.SimResourceSource
+import java.util.*
+import kotlin.math.max
+import kotlin.math.min
+
+/**
+ * A [ScalingDriver] that scales the frequency of the processor based on a discrete set of frequencies.
+ *
+ * @param states A map describing the states of the driver.
+ */
+public class PStateScalingDriver(states: Map<Double, PowerModel>) : ScalingDriver {
+    /**
+     * The P-States defined by the user and ordered by key.
+     */
+    private val states = TreeMap(states)
+
+    override fun createLogic(machine: SimMachine): ScalingDriver.Logic = object : ScalingDriver.Logic {
+        /**
+         * The scaling contexts.
+         */
+        private val contexts = mutableListOf<ScalingContextImpl>()
+
+        override fun createContext(cpu: ProcessingUnit, resource: SimResourceSource): ScalingContext {
+            val ctx = ScalingContextImpl(machine, cpu, resource)
+            contexts.add(ctx)
+            return ctx
+        }
+
+        override fun computePower(): Double {
+            var targetFreq = 0.0
+            var totalSpeed = 0.0
+
+            for (ctx in contexts) {
+                targetFreq = max(ctx.target, targetFreq)
+                totalSpeed += ctx.resource.speed.value
+            }
+
+            val maxFreq = states.lastKey()
+            val (actualFreq, model) = states.ceilingEntry(min(maxFreq, targetFreq))
+            val utilization = totalSpeed / (actualFreq * contexts.size)
+            return model.computePower(utilization)
+        }
+
+        override fun toString(): String = "PStateScalingDriver.Logic"
+    }
+
+    private class ScalingContextImpl(
+        override val machine: SimMachine,
+        override val cpu: ProcessingUnit,
+        override val resource: SimResourceSource
+    ) : ScalingContext {
+        var target = cpu.frequency
+            private set
+
+        override fun setTarget(freq: Double) {
+            target = freq
+        }
+
+        override fun toString(): String = "PStateScalingDriver.Context"
+    }
+}
diff --git a/simulator/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/cpufreq/PerformanceScalingGovernor.kt b/simulator/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/cpufreq/PerformanceScalingGovernor.kt
new file mode 100644
index 00000000..c574d5d1
--- /dev/null
+++ b/simulator/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/cpufreq/PerformanceScalingGovernor.kt
@@ -0,0 +1,36 @@
+/*
+ * 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.compute.cpufreq
+
+/**
+ * A CPUFreq [ScalingGovernor] that causes the highest possible frequency to be requested from the resource.
+ */
+public class PerformanceScalingGovernor : ScalingGovernor {
+    override fun createLogic(ctx: ScalingContext): ScalingGovernor.Logic = object : ScalingGovernor.Logic {
+        override fun onLimit() {
+            ctx.setTarget(ctx.resource.capacity)
+        }
+
+        override fun toString(): String = "PerformanceScalingGovernor.Logic"
+    }
+}
diff --git a/simulator/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/cpufreq/ScalingContext.kt b/simulator/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/cpufreq/ScalingContext.kt
new file mode 100644
index 00000000..44cd0168
--- /dev/null
+++ b/simulator/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/cpufreq/ScalingContext.kt
@@ -0,0 +1,52 @@
+/*
+ * 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.compute.cpufreq
+
+import org.opendc.simulator.compute.SimMachine
+import org.opendc.simulator.compute.model.ProcessingUnit
+import org.opendc.simulator.resources.SimResourceSource
+
+/**
+ * A [ScalingContext] is used to communicate frequency scaling changes between the [ScalingGovernor] and driver.
+ */
+public interface ScalingContext {
+    /**
+     * The machine the processing unit belongs to.
+     */
+    public val machine: SimMachine
+
+    /**
+     * The processing unit associated with this context.
+     */
+    public val cpu: ProcessingUnit
+
+    /**
+     * The resource associated with this context.
+     */
+    public val resource: SimResourceSource
+
+    /**
+     * Target the processor to run at the specified target [frequency][freq].
+     */
+    public fun setTarget(freq: Double)
+}
diff --git a/simulator/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/cpufreq/ScalingDriver.kt b/simulator/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/cpufreq/ScalingDriver.kt
new file mode 100644
index 00000000..2414eabb
--- /dev/null
+++ b/simulator/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/cpufreq/ScalingDriver.kt
@@ -0,0 +1,54 @@
+/*
+ * 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.compute.cpufreq
+
+import org.opendc.simulator.compute.SimMachine
+import org.opendc.simulator.compute.model.ProcessingUnit
+import org.opendc.simulator.resources.SimResourceSource
+
+/**
+ * A [ScalingDriver] is responsible for switching the processor to the correct frequency.
+ */
+public interface ScalingDriver {
+    /**
+     * Create the scaling logic for the specified [machine]
+     */
+    public fun createLogic(machine: SimMachine): Logic
+
+    /**
+     * The logic of the scaling driver.
+     */
+    public interface Logic {
+        /**
+         * Create the [ScalingContext] for the specified [cpu] and [resource] instance.
+         */
+        public fun createContext(cpu: ProcessingUnit, resource: SimResourceSource): ScalingContext
+
+        /**
+         * Compute the power consumption of the processor.
+         *
+         * @return The power consumption of the processor in W.
+         */
+        public fun computePower(): Double
+    }
+}
diff --git a/simulator/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/cpufreq/ScalingGovernor.kt b/simulator/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/cpufreq/ScalingGovernor.kt
new file mode 100644
index 00000000..c9aea580
--- /dev/null
+++ b/simulator/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/cpufreq/ScalingGovernor.kt
@@ -0,0 +1,54 @@
+/*
+ * 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.compute.cpufreq
+
+/**
+ * A [ScalingGovernor] in the CPUFreq subsystem of OpenDC is responsible for scaling the frequency of simulated CPUs
+ * independent of the particular implementation of the CPU.
+ *
+ * Each of the scaling governors implements a single, possibly parametrized, performance scaling algorithm.
+ *
+ * For more information, see the documentation of the Linux CPUFreq subsystem:
+ * https://www.kernel.org/doc/html/latest/admin-guide/pm/cpufreq.html
+ */
+public interface ScalingGovernor {
+    /**
+     * Create the scaling logic for the specified [context]
+     */
+    public fun createLogic(ctx: ScalingContext): Logic
+
+    /**
+     * The logic of the scaling governor.
+     */
+    public interface Logic {
+        /**
+         * This method is invoked when the governor is started.
+         */
+        public fun onStart() {}
+
+        /**
+         * This method is invoked when the governor should re-decide the frequency limits.
+         */
+        public fun onLimit() {}
+    }
+}
diff --git a/simulator/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/cpufreq/SimpleScalingDriver.kt b/simulator/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/cpufreq/SimpleScalingDriver.kt
new file mode 100644
index 00000000..b4b564ce
--- /dev/null
+++ b/simulator/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/cpufreq/SimpleScalingDriver.kt
@@ -0,0 +1,52 @@
+/*
+ * 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.compute.cpufreq
+
+import org.opendc.simulator.compute.SimMachine
+import org.opendc.simulator.compute.model.ProcessingUnit
+import org.opendc.simulator.compute.power.PowerModel
+import org.opendc.simulator.resources.SimResourceSource
+
+/**
+ * A [ScalingDriver] that ignores the instructions of the [ScalingGovernor] and directly computes the power consumption
+ * based on the specified [power model][model].
+ */
+public class SimpleScalingDriver(private val model: PowerModel) : ScalingDriver {
+    override fun createLogic(machine: SimMachine): ScalingDriver.Logic = object : ScalingDriver.Logic {
+        override fun createContext(cpu: ProcessingUnit, resource: SimResourceSource): ScalingContext {
+            return object : ScalingContext {
+                override val machine: SimMachine = machine
+
+                override val cpu: ProcessingUnit = cpu
+
+                override val resource: SimResourceSource = resource
+
+                override fun setTarget(freq: Double) {}
+            }
+        }
+
+        override fun computePower(): Double = model.computePower(machine.usage.value)
+
+        override fun toString(): String = "SimpleScalingDriver.Logic"
+    }
+}
diff --git a/simulator/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/power/ConstantPowerModel.kt b/simulator/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/power/ConstantPowerModel.kt
index 5d7ae8ad..b8cb8412 100644
--- a/simulator/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/power/ConstantPowerModel.kt
+++ b/simulator/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/power/ConstantPowerModel.kt
@@ -1,8 +1,10 @@
 package org.opendc.simulator.compute.power
 
 /**
- * A power model which produces a constant value [constant].
+ * A power model which produces a constant value [power].
  */
-public class ConstantPowerModel(private val constant: Double) : MachinePowerModel {
-    public override fun computeCpuPower(cpuUtil: Double): Double = constant
+public class ConstantPowerModel(private val power: Double) : PowerModel {
+    public override fun computePower(utilization: Double): Double = power
+
+    override fun toString(): String = "ConstantPowerModel[power=$power]"
 }
diff --git a/simulator/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/power/CubicPowerModel.kt b/simulator/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/power/CubicPowerModel.kt
index 8e47f571..48edace6 100644
--- a/simulator/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/power/CubicPowerModel.kt
+++ b/simulator/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/power/CubicPowerModel.kt
@@ -5,21 +5,15 @@ import kotlin.math.pow
 /**
  * The cubic power model partially adapted from CloudSim.
  *
- * @param maxPower The maximum power draw in Watts of the server.
- * @param staticPowerPercent The static power percentage.
- * @property staticPower The static power consumption that is not dependent on resource usage.
- *                      It is the amount of energy consumed even when the host is idle.
- * @property constPower The constant power consumption for each fraction of resource used.
+ * @param maxPower The maximum power draw of the server in W.
+ * @param idlePower The power draw of the server in idle state in W.
  */
-public class CubicPowerModel(
-    private var maxPower: Double,
-    staticPowerPercent: Double
-) : MachinePowerModel {
-    private var staticPower: Double = staticPowerPercent * maxPower
-    private var constPower: Double = (maxPower - staticPower) / 100.0.pow(3)
+public class CubicPowerModel(private val maxPower: Double, private val idlePower: Double) : PowerModel {
+    private val factor: Double = (maxPower - idlePower) / 100.0.pow(3)
 
-    public override fun computeCpuPower(cpuUtil: Double): Double {
-        require(cpuUtil in 0.0..1.0) { "CPU utilization must be in [0, 1]" }
-        return staticPower + constPower * (cpuUtil * 100).pow(3)
+    public override fun computePower(utilization: Double): Double {
+        return idlePower + factor * (utilization * 100).pow(3)
     }
+
+    override fun toString(): String = "CubicPowerModel[max=$maxPower,idle=$idlePower]"
 }
diff --git a/simulator/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/power/InterpolationPowerModel.kt b/simulator/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/power/InterpolationPowerModel.kt
index 69fc0514..85613a57 100644
--- a/simulator/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/power/InterpolationPowerModel.kt
+++ b/simulator/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/power/InterpolationPowerModel.kt
@@ -3,6 +3,8 @@ package org.opendc.simulator.compute.power
 import org.yaml.snakeyaml.Yaml
 import kotlin.math.ceil
 import kotlin.math.floor
+import kotlin.math.max
+import kotlin.math.min
 
 /**
  * The linear interpolation power model partially adapted from CloudSim.
@@ -10,30 +12,30 @@ import kotlin.math.floor
  *
  * @param hardwareName The name of the hardware vendor.
  * @see <a href="http://www.spec.org/power_ssj2008/results/res2011q1/">Machines used in the SPEC benchmark</a>
- * @property averagePowerValues A [List] of average active power measured by the power analyzer(s)
- *                          and accumulated by the PTDaemon (Power and Temperature Daemon) for this
- *                          measurement interval, displayed as watts (W).
  */
-public class InterpolationPowerModel(
-    hardwareName: String,
-) : MachinePowerModel {
+public class InterpolationPowerModel(hardwareName: String) : PowerModel {
+    /**
+     * A [List] of average active power measured by the power analyzer(s) and accumulated by the
+     * PTDaemon (Power and Temperature Daemon) for this measurement interval, displayed as watts (W).
+     */
     private val averagePowerValues: List<Double> = loadAveragePowerValue(hardwareName)
 
-    public override fun computeCpuPower(cpuUtil: Double): Double {
-        require(cpuUtil in 0.0..1.0) { "CPU utilization must be in [0, 1]" }
-
-        val cpuUtilFlr = floor(cpuUtil * 10).toInt()
-        val cpuUtilCil = ceil(cpuUtil * 10).toInt()
-        val powerFlr: Double = getAveragePowerValue(cpuUtilFlr)
-        val powerCil: Double = getAveragePowerValue(cpuUtilCil)
+    public override fun computePower(utilization: Double): Double {
+        val clampedUtilization = min(1.0, max(0.0, utilization))
+        val utilizationFlr = floor(clampedUtilization * 10).toInt()
+        val utilizationCil = ceil(clampedUtilization * 10).toInt()
+        val powerFlr: Double = getAveragePowerValue(utilizationFlr)
+        val powerCil: Double = getAveragePowerValue(utilizationCil)
         val delta = (powerCil - powerFlr) / 10
 
-        return if (cpuUtil % 0.1 == 0.0)
-            getAveragePowerValue((cpuUtil * 10).toInt())
+        return if (utilization % 0.1 == 0.0)
+            getAveragePowerValue((clampedUtilization * 10).toInt())
         else
-            powerFlr + delta * (cpuUtil - cpuUtilFlr.toDouble() / 10) * 100
+            powerFlr + delta * (clampedUtilization - utilizationFlr.toDouble() / 10) * 100
     }
 
+    override fun toString(): String = "InterpolationPowerModel[entries=${averagePowerValues.size}]"
+
     /**
      * Gets the power consumption for a given utilization percentage.
      *
diff --git a/simulator/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/power/LinearPowerModel.kt b/simulator/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/power/LinearPowerModel.kt
index 14443aff..1a0cc07b 100644
--- a/simulator/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/power/LinearPowerModel.kt
+++ b/simulator/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/power/LinearPowerModel.kt
@@ -3,21 +3,18 @@ package org.opendc.simulator.compute.power
 /**
  * The linear power model partially adapted from CloudSim.
  *
- * @param maxPower The maximum power draw in Watts of the server.
- * @param staticPowerPercent The static power percentage.
- * @property staticPower The static power consumption that is not dependent on resource usage.
- *                      It is the amount of energy consumed even when the host is idle.
- * @property constPower The constant power consumption for each fraction of resource used.
+ * @param maxPower The maximum power draw of the server in W.
+ * @param idlePower The power draw of the server in idle state in W.
  */
-public class LinearPowerModel(
-    private var maxPower: Double,
-    staticPowerPercent: Double
-) : MachinePowerModel {
-    private var staticPower: Double = staticPowerPercent * maxPower
-    private var constPower: Double = (maxPower - staticPower) / 100
+public class LinearPowerModel(private val maxPower: Double, private val idlePower: Double) : PowerModel {
+    /**
+     * The linear interpolation factor of the model.
+     */
+    private val factor: Double = (maxPower - idlePower) / 100
 
-    public override fun computeCpuPower(cpuUtil: Double): Double {
-        require(cpuUtil in 0.0..1.0) { "CPU utilization must be in [0, 1]" }
-        return staticPower + constPower * cpuUtil * 100
+    public override fun computePower(utilization: Double): Double {
+        return idlePower + factor * utilization * 100
     }
+
+    override fun toString(): String = "LinearPowerModel[max=$maxPower,idle=$idlePower]"
 }
diff --git a/simulator/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/power/PStatePowerModel.kt b/simulator/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/power/PStatePowerModel.kt
deleted file mode 100644
index 722f478d..00000000
--- a/simulator/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/power/PStatePowerModel.kt
+++ /dev/null
@@ -1,96 +0,0 @@
-package org.opendc.simulator.compute.power
-
-import org.opendc.simulator.compute.SimBareMetalMachine
-import java.time.Clock
-import java.util.*
-
-/**
- * The CPU power model derived from the iCanCloud simulator.
- *
- * @param machine The [SimBareMetalMachine] that the model is measuring.
- * @param clock The virtual [Clock] to track the time spent at each p-state.
- * @property cpuPowerMeter A [MutableMap] that contains CPU frequencies ([Double]) in GHz
- *                      as keys and the time ([Long]) spent in that frequency range in seconds.
- * @property pStatesToPower A [TreeMap] that contains the frequency ([Double]) of corresponding p-state in GHz
- *                      as keys and the energy ([Double]) consumption of that state in Watts.
- * @property pStatesRange A [Pair] in which the fist and second elements are the lower and upper bounds of the
- *                      consumption values of the p-states respectively.
- * @property lastMeasureTime The last update time of the [cpuPowerMeter].
- * @property currPState The p-state that the model is currently in.
- */
-public class PStatePowerModel(
-    private val machine: SimBareMetalMachine,
-    private val clock: Clock,
-) {
-    // TODO: Extract the power meter out of the model.
-    private val cpuPowerMeter = mutableMapOf<Double, Long>()
-    private val pStatesToPower = TreeMap<Double, Double>()
-    private val pStatesRange: Pair<Double, Double>
-    private var lastMeasureTime: Long
-    private var currPState: Double
-
-    init {
-        loadPStates(this)
-        pStatesRange = Pair(pStatesToPower.keys.first(), pStatesToPower.keys.last())
-        pStatesToPower.keys.forEach { cpuPowerMeter[it] = 0L }
-        currPState = pStatesRange.first
-        lastMeasureTime = getClockInstant()
-        updateCpuPowerMeter()
-    }
-
-    /** Recorde the elapsed time to the corresponding p-state. */
-    public fun updateCpuPowerMeter() {
-        val newMeasureTime = getClockInstant()
-        val newMaxFreq: Double = getMaxCpuSpeedInGHz()
-        assert(newMaxFreq in pStatesRange.first..pStatesRange.second) {
-            "The maximum frequency $newMaxFreq is not in the range of the P-state frequency " +
-                "from ${pStatesRange.first} to ${pStatesRange.second}."
-        }
-
-        // Update the current p-state level on which the CPU is running.
-        val newPState = pStatesToPower.ceilingKey(newMaxFreq)
-
-        // Add the time elapsed to the previous state.
-        cpuPowerMeter.merge(currPState, newMeasureTime - lastMeasureTime, Long::plus)
-
-        // Update the current states.
-        currPState = newPState
-        lastMeasureTime = newMeasureTime
-    }
-
-    /** Get the power value of the energy consumption level at which the CPU is working. */
-    public fun getInstantCpuPower(): Double =
-        pStatesToPower.getOrDefault(currPState, 0.0)
-
-    /** Get the accumulated power consumption up until now. */
-    public fun getAccumulatedCpuPower(): Double =
-        pStatesToPower.keys
-            .map {
-                pStatesToPower.getOrDefault(it, 0.0) *
-                    cpuPowerMeter.getOrDefault(it, 0.0).toDouble()
-            }.sum()
-
-    private fun getClockInstant() = clock.millis() / 1000
-
-    /** Get the maximum frequency of the CPUs in GHz as that of the package.
-     * @see <a href="https://www.intel.vn/content/dam/www/public/us/en/documents/datasheets/10th-gen-core-families-datasheet-vol-1-datasheet.pdf">
-     *     on page 34.
-     */
-    private fun getMaxCpuSpeedInGHz() = (machine.speed.maxOrNull() ?: 0.0) / 1000
-
-    public companion object PStatesLoader {
-        private fun loadPStates(pStatePowerModel: PStatePowerModel) {
-            // TODO: Dynamically load configuration.
-            // See P4 of https://www.intel.com/content/dam/support/us/en/documents/motherboards/server/sb/power_management_of_intel_architecture_servers.pdf
-            pStatePowerModel.pStatesToPower.putAll(
-                sortedMapOf(
-                    3.6 to 103.0,
-                    3.4 to 94.0,
-                    3.2 to 85.0,
-                    3.0 to 76.0,
-                    2.8 to 8.0,
-                )
-            )
-        }
-    }
-}
diff --git a/simulator/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/power/MachinePowerModel.kt b/simulator/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/power/PowerModel.kt
index 9bf03b87..1387e65a 100644
--- a/simulator/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/power/MachinePowerModel.kt
+++ b/simulator/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/power/PowerModel.kt
@@ -5,14 +5,12 @@ import org.opendc.simulator.compute.SimMachine
 /**
  * A model for estimating the power usage of a [SimMachine].
  */
-public interface MachinePowerModel {
+public interface PowerModel {
     /**
      * Computes CPU power consumption for each host.
      *
-     * @param cpuUtil The CPU utilization percentage.
+     * @param utilization The CPU utilization percentage.
      * @return A [Double] value of CPU power consumption.
-     * @throws IllegalArgumentException Will throw an error if [cpuUtil] is out of range.
      */
-    @Throws(IllegalArgumentException::class)
-    public fun computeCpuPower(cpuUtil: Double): Double
+    public fun computePower(utilization: Double): Double
 }
diff --git a/simulator/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/power/SqrtPowerModel.kt b/simulator/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/power/SqrtPowerModel.kt
index bf177aff..da40ca85 100644
--- a/simulator/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/power/SqrtPowerModel.kt
+++ b/simulator/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/power/SqrtPowerModel.kt
@@ -5,21 +5,15 @@ import kotlin.math.sqrt
 /**
  * The square root power model partially adapted from CloudSim.
  *
- * @param maxPower The maximum power draw in Watts of the server.
- * @param staticPowerPercent The static power percentage.
- * @property staticPower The static power consumption that is not dependent on resource usage.
- *                      It is the amount of energy consumed even when the host is idle.
- * @property constPower The constant power consumption for each fraction of resource used.
+ * @param maxPower The maximum power draw of the server in W.
+ * @param idlePower The power draw of the server in idle state in W.
  */
-public class SqrtPowerModel(
-    private var maxPower: Double,
-    staticPowerPercent: Double
-) : MachinePowerModel {
-    private var staticPower: Double = staticPowerPercent * maxPower
-    private var constPower: Double = (maxPower - staticPower) / sqrt(100.0)
+public class SqrtPowerModel(private val maxPower: Double, private val idlePower: Double) : PowerModel {
+    private val factor: Double = (maxPower - idlePower) / sqrt(100.0)
 
-    override fun computeCpuPower(cpuUtil: Double): Double {
-        require(cpuUtil in 0.0..1.0) { "CPU utilization must be in [0, 1]" }
-        return staticPower + constPower * sqrt(cpuUtil * 100)
+    override fun computePower(utilization: Double): Double {
+        return idlePower + factor * sqrt(utilization * 100)
     }
+
+    override fun toString(): String = "SqrtPowerModel[max=$maxPower,idle=$idlePower]"
 }
diff --git a/simulator/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/power/SquarePowerModel.kt b/simulator/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/power/SquarePowerModel.kt
index cbfad530..4f914ddf 100644
--- a/simulator/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/power/SquarePowerModel.kt
+++ b/simulator/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/power/SquarePowerModel.kt
@@ -5,21 +5,15 @@ import kotlin.math.pow
 /**
  * The square power model partially adapted from CloudSim.
  *
- * @param maxPower The maximum power draw in Watts of the server.
- * @param staticPowerPercent The static power percentage.
- * @property staticPower The static power consumption that is not dependent on resource usage.
- *                      It is the amount of energy consumed even when the host is idle.
- * @property constPower The constant power consumption for each fraction of resource used.
+ * @param maxPower The maximum power draw of the server in W.
+ * @param idlePower The power draw of the server in idle state in W.
  */
-public class SquarePowerModel(
-    private var maxPower: Double,
-    staticPowerPercent: Double
-) : MachinePowerModel {
-    private var staticPower: Double = staticPowerPercent * maxPower
-    private var constPower: Double = (maxPower - staticPower) / 100.0.pow(2)
+public class SquarePowerModel(private val maxPower: Double, private val idlePower: Double) : PowerModel {
+    private val factor: Double = (maxPower - idlePower) / 100.0.pow(2)
 
-    override fun computeCpuPower(cpuUtil: Double): Double {
-        require(cpuUtil in 0.0..1.0) { "CPU utilization must be in [0, 1]" }
-        return staticPower + constPower * (cpuUtil * 100).pow(2)
+    override fun computePower(utilization: Double): Double {
+        return idlePower + factor * (utilization * 100).pow(2)
     }
+
+    override fun toString(): String = "SquarePowerModel[max=$maxPower,idle=$idlePower]"
 }
diff --git a/simulator/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/power/ZeroIdlePowerDecorator.kt b/simulator/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/power/ZeroIdlePowerDecorator.kt
index 01deac5b..19dfcadd 100644
--- a/simulator/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/power/ZeroIdlePowerDecorator.kt
+++ b/simulator/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/power/ZeroIdlePowerDecorator.kt
@@ -3,10 +3,15 @@ package org.opendc.simulator.compute.power
 /**
  * A decorator for ignoring the idle power when computing energy consumption of components.
  *
- * @param delegate The [MachinePowerModel] to delegate to.
+ * @param delegate The [PowerModel] to delegate to.
  */
-public class ZeroIdlePowerDecorator(private val delegate: MachinePowerModel) : MachinePowerModel {
-    override fun computeCpuPower(cpuUtil: Double): Double {
-        return if (cpuUtil == 0.0) 0.0 else delegate.computeCpuPower(cpuUtil)
+public class ZeroIdlePowerDecorator(private val delegate: PowerModel) : PowerModel {
+    override fun computePower(utilization: Double): Double {
+        return if (utilization == 0.0)
+            0.0
+        else
+            delegate.computePower(utilization)
     }
+
+    override fun toString(): String = "ZeroIdlePowerDecorator[delegate=$delegate]"
 }
diff --git a/simulator/opendc-simulator/opendc-simulator-compute/src/test/kotlin/org/opendc/simulator/compute/SimHypervisorTest.kt b/simulator/opendc-simulator/opendc-simulator-compute/src/test/kotlin/org/opendc/simulator/compute/SimHypervisorTest.kt
index 5773b325..67295dfd 100644
--- a/simulator/opendc-simulator/opendc-simulator-compute/src/test/kotlin/org/opendc/simulator/compute/SimHypervisorTest.kt
+++ b/simulator/opendc-simulator/opendc-simulator-compute/src/test/kotlin/org/opendc/simulator/compute/SimHypervisorTest.kt
@@ -32,9 +32,12 @@ import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.BeforeEach
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.assertAll
+import org.opendc.simulator.compute.cpufreq.PerformanceScalingGovernor
+import org.opendc.simulator.compute.cpufreq.SimpleScalingDriver
 import org.opendc.simulator.compute.model.MemoryUnit
 import org.opendc.simulator.compute.model.ProcessingNode
 import org.opendc.simulator.compute.model.ProcessingUnit
+import org.opendc.simulator.compute.power.ConstantPowerModel
 import org.opendc.simulator.compute.workload.SimTraceWorkload
 import org.opendc.simulator.utils.DelayControllerClockAdapter
 
@@ -91,7 +94,7 @@ internal class SimHypervisorTest {
                 ),
             )
 
-        val machine = SimBareMetalMachine(coroutineContext, clock, model)
+        val machine = SimBareMetalMachine(coroutineContext, clock, model, PerformanceScalingGovernor(), SimpleScalingDriver(ConstantPowerModel(0.0)))
         val hypervisor = SimFairShareHypervisor(listener)
 
         launch {
@@ -163,7 +166,10 @@ internal class SimHypervisorTest {
                 )
             )
 
-        val machine = SimBareMetalMachine(coroutineContext, clock, model)
+        val machine = SimBareMetalMachine(
+            coroutineContext, clock, model, PerformanceScalingGovernor(),
+            SimpleScalingDriver(ConstantPowerModel(0.0))
+        )
         val hypervisor = SimFairShareHypervisor(listener)
 
         launch {
diff --git a/simulator/opendc-simulator/opendc-simulator-compute/src/test/kotlin/org/opendc/simulator/compute/SimMachineTest.kt b/simulator/opendc-simulator/opendc-simulator-compute/src/test/kotlin/org/opendc/simulator/compute/SimMachineTest.kt
index 071bdf77..d947b9cb 100644
--- a/simulator/opendc-simulator/opendc-simulator-compute/src/test/kotlin/org/opendc/simulator/compute/SimMachineTest.kt
+++ b/simulator/opendc-simulator/opendc-simulator-compute/src/test/kotlin/org/opendc/simulator/compute/SimMachineTest.kt
@@ -28,9 +28,14 @@ import kotlinx.coroutines.test.runBlockingTest
 import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.BeforeEach
 import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.assertDoesNotThrow
+import org.junit.jupiter.api.assertThrows
+import org.opendc.simulator.compute.cpufreq.PerformanceScalingGovernor
+import org.opendc.simulator.compute.cpufreq.SimpleScalingDriver
 import org.opendc.simulator.compute.model.MemoryUnit
 import org.opendc.simulator.compute.model.ProcessingNode
 import org.opendc.simulator.compute.model.ProcessingUnit
+import org.opendc.simulator.compute.power.ConstantPowerModel
 import org.opendc.simulator.compute.workload.SimFlopsWorkload
 import org.opendc.simulator.utils.DelayControllerClockAdapter
 
@@ -54,7 +59,7 @@ class SimMachineTest {
     @Test
     fun testFlopsWorkload() = runBlockingTest {
         val clock = DelayControllerClockAdapter(this)
-        val machine = SimBareMetalMachine(coroutineContext, clock, machineModel)
+        val machine = SimBareMetalMachine(coroutineContext, clock, machineModel, PerformanceScalingGovernor(), SimpleScalingDriver(ConstantPowerModel(0.0)))
 
         try {
             machine.run(SimFlopsWorkload(2_000, utilization = 1.0))
@@ -69,7 +74,7 @@ class SimMachineTest {
     @Test
     fun testUsage() = runBlockingTest {
         val clock = DelayControllerClockAdapter(this)
-        val machine = SimBareMetalMachine(coroutineContext, clock, machineModel)
+        val machine = SimBareMetalMachine(coroutineContext, clock, machineModel, PerformanceScalingGovernor(), SimpleScalingDriver(ConstantPowerModel(0.0)))
 
         val res = mutableListOf<Double>()
         val job = launch { machine.usage.toList(res) }
@@ -83,4 +88,14 @@ class SimMachineTest {
             machine.close()
         }
     }
+
+    @Test
+    fun testClose() = runBlockingTest {
+        val clock = DelayControllerClockAdapter(this)
+        val machine = SimBareMetalMachine(coroutineContext, clock, machineModel, PerformanceScalingGovernor(), SimpleScalingDriver(ConstantPowerModel(0.0)))
+
+        machine.close()
+        assertDoesNotThrow { machine.close() }
+        assertThrows<IllegalStateException> { machine.run(SimFlopsWorkload(2_000, utilization = 1.0)) }
+    }
 }
diff --git a/simulator/opendc-simulator/opendc-simulator-compute/src/test/kotlin/org/opendc/simulator/compute/SimSpaceSharedHypervisorTest.kt b/simulator/opendc-simulator/opendc-simulator-compute/src/test/kotlin/org/opendc/simulator/compute/SimSpaceSharedHypervisorTest.kt
index fb0523af..51e4305a 100644
--- a/simulator/opendc-simulator/opendc-simulator-compute/src/test/kotlin/org/opendc/simulator/compute/SimSpaceSharedHypervisorTest.kt
+++ b/simulator/opendc-simulator/opendc-simulator-compute/src/test/kotlin/org/opendc/simulator/compute/SimSpaceSharedHypervisorTest.kt
@@ -31,9 +31,12 @@ import org.junit.jupiter.api.Assertions.*
 import org.junit.jupiter.api.BeforeEach
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.assertThrows
+import org.opendc.simulator.compute.cpufreq.PerformanceScalingGovernor
+import org.opendc.simulator.compute.cpufreq.SimpleScalingDriver
 import org.opendc.simulator.compute.model.MemoryUnit
 import org.opendc.simulator.compute.model.ProcessingNode
 import org.opendc.simulator.compute.model.ProcessingUnit
+import org.opendc.simulator.compute.power.ConstantPowerModel
 import org.opendc.simulator.compute.workload.SimFlopsWorkload
 import org.opendc.simulator.compute.workload.SimRuntimeWorkload
 import org.opendc.simulator.compute.workload.SimTraceWorkload
@@ -75,7 +78,10 @@ internal class SimSpaceSharedHypervisorTest {
                 ),
             )
 
-        val machine = SimBareMetalMachine(coroutineContext, clock, machineModel)
+        val machine = SimBareMetalMachine(
+            coroutineContext, clock, machineModel, PerformanceScalingGovernor(),
+            SimpleScalingDriver(ConstantPowerModel(0.0))
+        )
         val hypervisor = SimSpaceSharedHypervisor()
 
         val colA = launch { machine.usage.toList(usagePm) }
@@ -109,7 +115,10 @@ internal class SimSpaceSharedHypervisorTest {
         val clock = DelayControllerClockAdapter(this)
         val duration = 5 * 60L * 1000
         val workload = SimRuntimeWorkload(duration)
-        val machine = SimBareMetalMachine(coroutineContext, clock, machineModel)
+        val machine = SimBareMetalMachine(
+            coroutineContext, clock, machineModel, PerformanceScalingGovernor(),
+            SimpleScalingDriver(ConstantPowerModel(0.0))
+        )
         val hypervisor = SimSpaceSharedHypervisor()
 
         launch { machine.run(hypervisor) }
@@ -131,7 +140,10 @@ internal class SimSpaceSharedHypervisorTest {
 
         val duration = 5 * 60L * 1000
         val workload = SimFlopsWorkload((duration * 3.2).toLong(), 1.0)
-        val machine = SimBareMetalMachine(coroutineContext, clock, machineModel)
+        val machine = SimBareMetalMachine(
+            coroutineContext, clock, machineModel, PerformanceScalingGovernor(),
+            SimpleScalingDriver(ConstantPowerModel(0.0))
+        )
         val hypervisor = SimSpaceSharedHypervisor()
 
         launch { machine.run(hypervisor) }
@@ -150,7 +162,10 @@ internal class SimSpaceSharedHypervisorTest {
     fun testTwoWorkloads() = runBlockingTest {
         val clock = DelayControllerClockAdapter(this)
         val duration = 5 * 60L * 1000
-        val machine = SimBareMetalMachine(coroutineContext, clock, machineModel)
+        val machine = SimBareMetalMachine(
+            coroutineContext, clock, machineModel, PerformanceScalingGovernor(),
+            SimpleScalingDriver(ConstantPowerModel(0.0))
+        )
         val hypervisor = SimSpaceSharedHypervisor()
 
         launch { machine.run(hypervisor) }
@@ -174,8 +189,10 @@ internal class SimSpaceSharedHypervisorTest {
     @Test
     fun testConcurrentWorkloadFails() = runBlockingTest {
         val clock = DelayControllerClockAdapter(this)
-
-        val machine = SimBareMetalMachine(coroutineContext, clock, machineModel)
+        val machine = SimBareMetalMachine(
+            coroutineContext, clock, machineModel, PerformanceScalingGovernor(),
+            SimpleScalingDriver(ConstantPowerModel(0.0))
+        )
         val hypervisor = SimSpaceSharedHypervisor()
 
         launch { machine.run(hypervisor) }
@@ -197,7 +214,10 @@ internal class SimSpaceSharedHypervisorTest {
     @Test
     fun testConcurrentWorkloadSucceeds() = runBlockingTest {
         val clock = DelayControllerClockAdapter(this)
-        val machine = SimBareMetalMachine(coroutineContext, clock, machineModel)
+        val machine = SimBareMetalMachine(
+            coroutineContext, clock, machineModel, PerformanceScalingGovernor(),
+            SimpleScalingDriver(ConstantPowerModel(0.0))
+        )
         val hypervisor = SimSpaceSharedHypervisor()
 
         launch { machine.run(hypervisor) }
diff --git a/simulator/opendc-simulator/opendc-simulator-compute/src/test/kotlin/org/opendc/simulator/compute/cpufreq/DemandScalingGovernorTest.kt b/simulator/opendc-simulator/opendc-simulator-compute/src/test/kotlin/org/opendc/simulator/compute/cpufreq/DemandScalingGovernorTest.kt
new file mode 100644
index 00000000..19c06126
--- /dev/null
+++ b/simulator/opendc-simulator/opendc-simulator-compute/src/test/kotlin/org/opendc/simulator/compute/cpufreq/DemandScalingGovernorTest.kt
@@ -0,0 +1,48 @@
+/*
+ * 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.compute.cpufreq
+
+import io.mockk.every
+import io.mockk.mockk
+import io.mockk.verify
+import org.junit.jupiter.api.Test
+
+/**
+ * Test suite for the [DemandScalingGovernor]
+ */
+internal class DemandScalingGovernorTest {
+    @Test
+    fun testSetDemandLimit() {
+        val ctx = mockk<ScalingContext>(relaxUnitFun = true)
+
+        every { ctx.resource.speed.value } returns 2100.0
+
+        val logic = DemandScalingGovernor().createLogic(ctx)
+
+        logic.onStart()
+        verify(exactly = 0) { ctx.setTarget(any()) }
+
+        logic.onLimit()
+        verify(exactly = 1) { ctx.setTarget(2100.0) }
+    }
+}
diff --git a/simulator/opendc-simulator/opendc-simulator-compute/src/test/kotlin/org/opendc/simulator/compute/cpufreq/PStateScalingDriverTest.kt b/simulator/opendc-simulator/opendc-simulator-compute/src/test/kotlin/org/opendc/simulator/compute/cpufreq/PStateScalingDriverTest.kt
new file mode 100644
index 00000000..5c30bc1f
--- /dev/null
+++ b/simulator/opendc-simulator/opendc-simulator-compute/src/test/kotlin/org/opendc/simulator/compute/cpufreq/PStateScalingDriverTest.kt
@@ -0,0 +1,136 @@
+/*
+ * 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.compute.cpufreq
+
+import io.mockk.every
+import io.mockk.mockk
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Test
+import org.opendc.simulator.compute.SimBareMetalMachine
+import org.opendc.simulator.compute.model.ProcessingUnit
+import org.opendc.simulator.compute.power.ConstantPowerModel
+import org.opendc.simulator.compute.power.LinearPowerModel
+import org.opendc.simulator.resources.SimResourceSource
+
+/**
+ * Test suite for [PStateScalingDriver].
+ */
+internal class PStateScalingDriverTest {
+    @Test
+    fun testPowerWithoutGovernor() {
+        val machine = mockk<SimBareMetalMachine>()
+
+        val driver = PStateScalingDriver(
+            sortedMapOf(
+                2800.0 to ConstantPowerModel(200.0),
+                3300.0 to ConstantPowerModel(300.0),
+                3600.0 to ConstantPowerModel(350.0),
+            )
+        )
+
+        val logic = driver.createLogic(machine)
+        assertEquals(200.0, logic.computePower())
+    }
+
+    @Test
+    fun testPowerWithSingleGovernor() {
+        val machine = mockk<SimBareMetalMachine>()
+        val cpu = mockk<ProcessingUnit>()
+        val resource = mockk<SimResourceSource>()
+
+        every { cpu.frequency } returns 4100.0
+        every { resource.speed.value } returns 1200.0
+
+        val driver = PStateScalingDriver(
+            sortedMapOf(
+                2800.0 to ConstantPowerModel(200.0),
+                3300.0 to ConstantPowerModel(300.0),
+                3600.0 to ConstantPowerModel(350.0),
+            )
+        )
+
+        val logic = driver.createLogic(machine)
+
+        val scalingContext = logic.createContext(cpu, resource)
+        scalingContext.setTarget(3200.0)
+
+        assertEquals(300.0, logic.computePower())
+    }
+
+    @Test
+    fun testPowerWithMultipleGovernors() {
+        val machine = mockk<SimBareMetalMachine>()
+        val cpu = mockk<ProcessingUnit>()
+        val resource = mockk<SimResourceSource>()
+
+        every { cpu.frequency } returns 4100.0
+        every { resource.speed.value } returns 1200.0
+
+        val driver = PStateScalingDriver(
+            sortedMapOf(
+                2800.0 to ConstantPowerModel(200.0),
+                3300.0 to ConstantPowerModel(300.0),
+                3600.0 to ConstantPowerModel(350.0),
+            )
+        )
+
+        val logic = driver.createLogic(machine)
+
+        val scalingContextA = logic.createContext(cpu, resource)
+        scalingContextA.setTarget(1000.0)
+
+        val scalingContextB = logic.createContext(cpu, resource)
+        scalingContextB.setTarget(3400.0)
+
+        assertEquals(350.0, logic.computePower())
+    }
+
+    @Test
+    fun testPowerBasedOnUtilization() {
+        val machine = mockk<SimBareMetalMachine>()
+        val cpu = mockk<ProcessingUnit>()
+        val resource = mockk<SimResourceSource>()
+
+        every { cpu.frequency } returns 4200.0
+
+        val driver = PStateScalingDriver(
+            sortedMapOf(
+                2800.0 to LinearPowerModel(200.0, 100.0),
+                3300.0 to LinearPowerModel(250.0, 150.0),
+                4000.0 to LinearPowerModel(300.0, 200.0),
+            )
+        )
+
+        val logic = driver.createLogic(machine)
+
+        val scalingContext = logic.createContext(cpu, resource)
+
+        every { resource.speed.value } returns 1400.0
+        scalingContext.setTarget(1400.0)
+        assertEquals(150.0, logic.computePower())
+
+        every { resource.speed.value } returns 1400.0
+        scalingContext.setTarget(4000.0)
+        assertEquals(235.0, logic.computePower())
+    }
+}
diff --git a/simulator/opendc-simulator/opendc-simulator-compute/src/test/kotlin/org/opendc/simulator/compute/power/PStatePowerModelTest.kt b/simulator/opendc-simulator/opendc-simulator-compute/src/test/kotlin/org/opendc/simulator/compute/power/PStatePowerModelTest.kt
deleted file mode 100644
index 9116f928..00000000
--- a/simulator/opendc-simulator/opendc-simulator-compute/src/test/kotlin/org/opendc/simulator/compute/power/PStatePowerModelTest.kt
+++ /dev/null
@@ -1,44 +0,0 @@
-package org.opendc.simulator.compute.power
-
-import io.mockk.*
-import org.junit.jupiter.api.Assertions.assertEquals
-import org.junit.jupiter.api.Test
-import org.opendc.simulator.compute.SimBareMetalMachine
-import java.time.Clock
-
-internal class PStatePowerModelTest {
-    @Test
-    fun `update CPU power meter with P-states`() {
-        val p0Power = 8.0
-        val p3Power = 94.0
-        val p4Power = 103.0
-        val expectedP0Power = 8.0 * 10
-        val expectedP0P4Power = expectedP0Power + 103.0 * 10
-
-        val clock = mockkClass(Clock::class)
-        val machine = mockkClass(SimBareMetalMachine::class)
-        every { clock.millis() } returnsMany listOf(0L, 0L, 10_000L, 20_000L)
-        every { machine.speed } returns
-            listOf(2.8, 2.8, 2.8, 2.8).map { it * 1000 } andThen // Max. 2.8MHz covered by P0
-            listOf(1.5, 3.1, 3.3, 3.6).map { it * 1000 } andThen // Max. 3.6MHz covered by P4
-            listOf(1.5, 3.1, 3.1, 3.3).map { it * 1000 } // Max. 3.3MHz covered by P3
-
-        // Power meter initialization.
-        val pStatePowerModel = PStatePowerModel(machine, clock)
-        verify(exactly = 2) { clock.millis() }
-        verify(exactly = 1) { machine.speed }
-        assertEquals(p0Power, pStatePowerModel.getInstantCpuPower())
-
-        // The first measure.
-        pStatePowerModel.updateCpuPowerMeter()
-        assertEquals(p4Power, pStatePowerModel.getInstantCpuPower())
-        assertEquals(expectedP0Power, pStatePowerModel.getAccumulatedCpuPower())
-
-        // The second measure.
-        pStatePowerModel.updateCpuPowerMeter()
-        assertEquals(p3Power, pStatePowerModel.getInstantCpuPower())
-        assertEquals(expectedP0P4Power, pStatePowerModel.getAccumulatedCpuPower())
-
-        verify(exactly = 4) { clock.millis() }
-    }
-}
diff --git a/simulator/opendc-simulator/opendc-simulator-compute/src/test/kotlin/org/opendc/simulator/compute/power/MachinePowerModelTest.kt b/simulator/opendc-simulator/opendc-simulator-compute/src/test/kotlin/org/opendc/simulator/compute/power/PowerModelTest.kt
index 13bb3668..439be274 100644
--- a/simulator/opendc-simulator/opendc-simulator-compute/src/test/kotlin/org/opendc/simulator/compute/power/MachinePowerModelTest.kt
+++ b/simulator/opendc-simulator/opendc-simulator-compute/src/test/kotlin/org/opendc/simulator/compute/power/PowerModelTest.kt
@@ -1,40 +1,40 @@
 package org.opendc.simulator.compute.power
 
-import kotlinx.coroutines.ExperimentalCoroutinesApi
 import org.junit.jupiter.api.Assertions.assertAll
 import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.Test
-import org.junit.jupiter.api.assertThrows
 import org.junit.jupiter.params.ParameterizedTest
 import org.junit.jupiter.params.provider.Arguments
 import org.junit.jupiter.params.provider.MethodSource
 import java.util.stream.Stream
 import kotlin.math.pow
 
-@OptIn(ExperimentalCoroutinesApi::class)
-internal class MachinePowerModelTest {
+internal class PowerModelTest {
     private val epsilon = 10.0.pow(-3)
     private val cpuUtil = 0.9
 
     @ParameterizedTest
     @MethodSource("MachinePowerModelArgs")
     fun `compute power consumption given CPU loads`(
-        powerModel: MachinePowerModel,
+        powerModel: PowerModel,
         expectedPowerConsumption: Double
     ) {
-        val computedPowerConsumption = powerModel.computeCpuPower(cpuUtil)
+        val computedPowerConsumption = powerModel.computePower(cpuUtil)
         assertEquals(expectedPowerConsumption, computedPowerConsumption, epsilon)
     }
 
     @ParameterizedTest
     @MethodSource("MachinePowerModelArgs")
     fun `ignore idle power when computing power consumptions`(
-        powerModel: MachinePowerModel,
+        powerModel: PowerModel,
         expectedPowerConsumption: Double
     ) {
         val zeroPowerModel = ZeroIdlePowerDecorator(powerModel)
-        val computedPowerConsumption = zeroPowerModel.computeCpuPower(0.0)
-        assertEquals(0.0, computedPowerConsumption)
+
+        assertAll(
+            { assertEquals(expectedPowerConsumption, zeroPowerModel.computePower(cpuUtil), epsilon) },
+            { assertEquals(0.0, zeroPowerModel.computePower(0.0)) }
+        )
     }
 
     @Test
@@ -42,19 +42,14 @@ internal class MachinePowerModelTest {
         val powerModel = InterpolationPowerModel("IBMx3550M3_XeonX5675")
 
         assertAll(
-            { assertThrows<IllegalArgumentException> { powerModel.computeCpuPower(-1.3) } },
-            { assertThrows<IllegalArgumentException> { powerModel.computeCpuPower(1.3) } },
-        )
-
-        assertAll(
-            { assertEquals(58.4, powerModel.computeCpuPower(0.0)) },
-            { assertEquals(58.4 + (98 - 58.4) / 5, powerModel.computeCpuPower(0.02)) },
-            { assertEquals(98.0, powerModel.computeCpuPower(0.1)) },
-            { assertEquals(140.0, powerModel.computeCpuPower(0.5)) },
-            { assertEquals(189.0, powerModel.computeCpuPower(0.8)) },
-            { assertEquals(189.0 + 0.7 * 10 * (205 - 189) / 10, powerModel.computeCpuPower(0.87)) },
-            { assertEquals(205.0, powerModel.computeCpuPower(0.9)) },
-            { assertEquals(222.0, powerModel.computeCpuPower(1.0)) },
+            { assertEquals(58.4, powerModel.computePower(0.0)) },
+            { assertEquals(58.4 + (98 - 58.4) / 5, powerModel.computePower(0.02)) },
+            { assertEquals(98.0, powerModel.computePower(0.1)) },
+            { assertEquals(140.0, powerModel.computePower(0.5)) },
+            { assertEquals(189.0, powerModel.computePower(0.8)) },
+            { assertEquals(189.0 + 0.7 * 10 * (205 - 189) / 10, powerModel.computePower(0.87)) },
+            { assertEquals(205.0, powerModel.computePower(0.9)) },
+            { assertEquals(222.0, powerModel.computePower(1.0)) },
         )
     }
 
@@ -63,10 +58,10 @@ internal class MachinePowerModelTest {
         @JvmStatic
         fun MachinePowerModelArgs(): Stream<Arguments> = Stream.of(
             Arguments.of(ConstantPowerModel(0.0), 0.0),
-            Arguments.of(LinearPowerModel(350.0, 200 / 350.0), 335.0),
-            Arguments.of(SquarePowerModel(350.0, 200 / 350.0), 321.5),
-            Arguments.of(CubicPowerModel(350.0, 200 / 350.0), 309.35),
-            Arguments.of(SqrtPowerModel(350.0, 200 / 350.0), 342.302),
+            Arguments.of(LinearPowerModel(350.0, 200.0), 335.0),
+            Arguments.of(SquarePowerModel(350.0, 200.0), 321.5),
+            Arguments.of(CubicPowerModel(350.0, 200.0), 309.35),
+            Arguments.of(SqrtPowerModel(350.0, 200.0), 342.302),
         )
     }
 }