compute: Improvements to cloud compute model (v2)

This is the second in the series of pull requests to improve the existing cloud compute model (see #86). This pull request removes the dependency on the bare-metal provisioning code which simplifies experiment setup tremendously:

- Remove bare-metal provisioning code (opendc-metal)
- Remove opendc-core which was a relic of the previous codebase and was only used sparingly.
- Move ownership of Server, Image and Flavor to the compute service. Users are expected to create instances via the compute service.

6 files changed, 162 insertions, 316 deletions

diff --git a/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/SimBareMetalDriver.kt b/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/SimBareMetalDriver.kt
deleted file mode 100644
index 2405a8f9..00000000
--- a/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/SimBareMetalDriver.kt
+++ /dev/null
@@ -1,188 +0,0 @@
-/*
- * Copyright (c) 2020 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.compute.simulator
-
-import kotlinx.coroutines.*
-import kotlinx.coroutines.flow.Flow
-import org.opendc.compute.api.Flavor
-import org.opendc.compute.api.Image
-import org.opendc.compute.simulator.power.api.CpuPowerModel
-import org.opendc.compute.simulator.power.api.Powerable
-import org.opendc.compute.simulator.power.models.ConstantPowerModel
-import org.opendc.metal.Node
-import org.opendc.metal.NodeEvent
-import org.opendc.metal.NodeState
-import org.opendc.metal.driver.BareMetalDriver
-import org.opendc.simulator.compute.SimBareMetalMachine
-import org.opendc.simulator.compute.SimMachineModel
-import org.opendc.simulator.compute.workload.SimWorkload
-import org.opendc.simulator.failures.FailureDomain
-import org.opendc.utils.flow.EventFlow
-import org.opendc.utils.flow.StateFlow
-import java.time.Clock
-import java.util.UUID
-
-/**
- * A basic implementation of the [BareMetalDriver] that simulates an [Image] running on a bare-metal machine.
- *
- * @param coroutineScope The [CoroutineScope] the driver runs in.
- * @param clock The virtual clock to keep track of time.
- * @param uid The unique identifier of the machine.
- * @param name An optional name of the machine.
- * @param metadata The initial metadata of the node.
- * @param machine The machine model to simulate.
- * @param cpuPowerModel The CPU power model of this machine.
- */
-@OptIn(ExperimentalCoroutinesApi::class)
-public class SimBareMetalDriver(
-    private val coroutineScope: CoroutineScope,
-    private val clock: Clock,
-    uid: UUID,
-    name: String,
-    metadata: Map<String, Any>,
-    machine: SimMachineModel,
-    cpuPowerModel: CpuPowerModel = ConstantPowerModel(0.0),
-) : BareMetalDriver, FailureDomain, Powerable {
-    /**
-     * The flavor that corresponds to this machine.
-     */
-    private val flavor = Flavor(
-        machine.cpus.size,
-        machine.memory.map { it.size }.sum()
-    )
-
-    /**
-     * The events of the machine.
-     */
-    private val events = EventFlow<NodeEvent>()
-
-    /**
-     * The machine state.
-     */
-    private val nodeState =
-        StateFlow(Node(uid, name, metadata + ("driver" to this), NodeState.SHUTOFF, flavor, Image.EMPTY, events))
-
-    /**
-     * The [SimBareMetalMachine] we use to run the workload.
-     */
-    private val machine = SimBareMetalMachine(coroutineScope, clock, machine)
-
-    override val node: Flow<Node> = nodeState
-
-    override val usage: Flow<Double>
-        get() = this.machine.usage
-
-    override val powerDraw: Flow<Double> = cpuPowerModel.getPowerDraw(this)
-
-    /**
-     * The [Job] that runs the simulated workload.
-     */
-    private var job: Job? = null
-
-    override suspend fun init(): Node {
-        return nodeState.value
-    }
-
-    override suspend fun start(): Node {
-        val node = nodeState.value
-        if (node.state != NodeState.SHUTOFF) {
-            return node
-        }
-
-        val workload = node.image.tags["workload"] as SimWorkload
-
-        job = coroutineScope.launch {
-            delay(1) // TODO Introduce boot time
-            initMachine()
-            try {
-                machine.run(workload, mapOf("driver" to this@SimBareMetalDriver, "node" to node))
-                exitMachine(null)
-            } catch (_: CancellationException) {
-                // Ignored
-            } catch (cause: Throwable) {
-                exitMachine(cause)
-            }
-        }
-
-        setNode(node.copy(state = NodeState.BOOT))
-        return nodeState.value
-    }
-
-    private fun initMachine() {
-        setNode(nodeState.value.copy(state = NodeState.ACTIVE))
-    }
-
-    private fun exitMachine(cause: Throwable?) {
-        val newNodeState =
-            if (cause == null)
-                NodeState.SHUTOFF
-            else
-                NodeState.ERROR
-        setNode(nodeState.value.copy(state = newNodeState))
-    }
-
-    override suspend fun stop(): Node {
-        val node = nodeState.value
-        if (node.state == NodeState.SHUTOFF) {
-            return node
-        }
-
-        job?.cancelAndJoin()
-        setNode(node.copy(state = NodeState.SHUTOFF))
-        return node
-    }
-
-    override suspend fun reboot(): Node {
-        stop()
-        return start()
-    }
-
-    override suspend fun setImage(image: Image): Node {
-        setNode(nodeState.value.copy(image = image))
-        return nodeState.value
-    }
-
-    override suspend fun refresh(): Node = nodeState.value
-
-    private fun setNode(value: Node) {
-        val field = nodeState.value
-        if (field.state != value.state) {
-            events.emit(NodeEvent.StateChanged(value, field.state))
-        }
-
-        nodeState.value = value
-    }
-
-    override val scope: CoroutineScope
-        get() = coroutineScope
-
-    override suspend fun fail() {
-        setNode(nodeState.value.copy(state = NodeState.ERROR))
-    }
-
-    override suspend fun recover() {
-        setNode(nodeState.value.copy(state = NodeState.ACTIVE))
-    }
-
-    override fun toString(): String = "SimBareMetalDriver(node = ${nodeState.value.uid})"
-}
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 fd547d3d..19fa3e97 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
@@ -29,34 +29,43 @@ import org.opendc.compute.api.Flavor
 import org.opendc.compute.api.Server
 import org.opendc.compute.api.ServerState
 import org.opendc.compute.service.driver.*
-import org.opendc.metal.Node
+import org.opendc.compute.simulator.power.api.CpuPowerModel
+import org.opendc.compute.simulator.power.api.Powerable
+import org.opendc.compute.simulator.power.models.ConstantPowerModel
 import org.opendc.simulator.compute.*
 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.workload.SimResourceCommand
-import org.opendc.simulator.compute.workload.SimWorkload
+import org.opendc.simulator.failures.FailureDomain
 import org.opendc.utils.flow.EventFlow
+import java.time.Clock
 import java.util.*
+import kotlin.coroutines.CoroutineContext
 import kotlin.coroutines.resume
 
 /**
  * A [Host] that is simulates virtual machines on a physical machine using [SimHypervisor].
  */
 public class SimHost(
-    public val node: Node,
-    private val coroutineScope: CoroutineScope,
-    hypervisor: SimHypervisorProvider
-) : Host, SimWorkload {
+    override val uid: UUID,
+    override val name: String,
+    model: SimMachineModel,
+    override val meta: Map<String, Any>,
+    context: CoroutineContext,
+    clock: Clock,
+    hypervisor: SimHypervisorProvider,
+    cpuPowerModel: CpuPowerModel = ConstantPowerModel(0.0),
+    private val mapper: SimWorkloadMapper = SimMetaWorkloadMapper()
+) : Host, FailureDomain, Powerable, AutoCloseable {
     /**
-     * The logger instance of this server.
+     * The [CoroutineScope] of the host bounded by the lifecycle of the host.
      */
-    private val logger = KotlinLogging.logger {}
+    override val scope: CoroutineScope = CoroutineScope(context)
 
     /**
-     * The execution context in which the [Host] runs.
+     * The logger instance of this server.
      */
-    private lateinit var ctx: SimExecutionContext
+    private val logger = KotlinLogging.logger {}
 
     override val events: Flow<HostEvent>
         get() = _events
@@ -70,12 +79,17 @@ public class SimHost(
     /**
      * Current total memory use of the images on this hypervisor.
      */
-    private var availableMemory: Long = 0
+    private var availableMemory: Long = model.memory.map { it.size }.sum()
+
+    /**
+     * The machine to run on.
+     */
+    public val machine: SimBareMetalMachine = SimBareMetalMachine(scope, clock, model)
 
     /**
      * The hypervisor to run multiple workloads.
      */
-    private val hypervisor = hypervisor.create(
+    public val hypervisor: SimHypervisor = hypervisor.create(
         object : SimHypervisor.Listener {
             override fun onSliceFinish(
                 hypervisor: SimHypervisor,
@@ -107,26 +121,40 @@ public class SimHost(
      */
     private val guests = HashMap<Server, Guest>()
 
-    override val uid: UUID
-        get() = node.uid
-
-    override val name: String
-        get() = node.name
-
-    override val model: HostModel
-        get() = HostModel(node.flavor.cpuCount, node.flavor.memorySize)
-
     override val state: HostState
         get() = _state
-    private var _state: HostState = HostState.UP
+    private var _state: HostState = HostState.DOWN
         set(value) {
-            listeners.forEach { it.onStateChanged(this, value) }
+            if (value != field) {
+                listeners.forEach { it.onStateChanged(this, value) }
+            }
             field = value
         }
 
+    override val model: HostModel = HostModel(model.cpus.size, model.memory.map { it.size }.sum())
+
+    override val powerDraw: Flow<Double> = cpuPowerModel.getPowerDraw(this)
+
+    init {
+        // Launch hypervisor onto machine
+        scope.launch {
+            try {
+                _state = HostState.UP
+                machine.run(this@SimHost.hypervisor, emptyMap())
+            } catch (_: CancellationException) {
+                // Ignored
+            } catch (cause: Throwable) {
+                logger.error(cause) { "Host failed" }
+                throw cause
+            } finally {
+                _state = HostState.DOWN
+            }
+        }
+    }
+
     override fun canFit(server: Server): Boolean {
         val sufficientMemory = availableMemory > server.flavor.memorySize
-        val enoughCpus = ctx.machine.cpus.size >= server.flavor.cpuCount
+        val enoughCpus = machine.model.cpus.size >= server.flavor.cpuCount
         val canFit = hypervisor.canFit(server.flavor.toMachineModel())
 
         return sufficientMemory && enoughCpus && canFit
@@ -146,7 +174,7 @@ public class SimHost(
             guest.start()
         }
 
-        _events.emit(HostEvent.VmsUpdated(this, guests.count { it.value.state == ServerState.ACTIVE }, availableMemory))
+        _events.emit(HostEvent.VmsUpdated(this, guests.count { it.value.state == ServerState.RUNNING }, availableMemory))
     }
 
     override fun contains(server: Server): Boolean {
@@ -163,7 +191,7 @@ public class SimHost(
         guest.stop()
     }
 
-    override suspend fun terminate(server: Server) {
+    override suspend fun delete(server: Server) {
         val guest = guests.remove(server) ?: return
         guest.terminate()
     }
@@ -176,11 +204,16 @@ public class SimHost(
         listeners.remove(listener)
     }
 
+    override fun close() {
+        scope.cancel()
+        _state = HostState.DOWN
+    }
+
     /**
      * Convert flavor to machine model.
      */
     private fun Flavor.toMachineModel(): SimMachineModel {
-        val originalCpu = ctx.machine.cpus[0]
+        val originalCpu = machine.model.cpus[0]
         val processingNode = originalCpu.node.copy(coreCount = cpuCount)
         val processingUnits = (0 until cpuCount).map { originalCpu.copy(id = it, node = processingNode) }
         val memoryUnits = listOf(MemoryUnit("Generic", "Generic", 3200.0, memorySize))
@@ -190,7 +223,7 @@ public class SimHost(
 
     private fun onGuestStart(vm: Guest) {
         guests.forEach { _, guest ->
-            if (guest.state == ServerState.ACTIVE) {
+            if (guest.state == ServerState.RUNNING) {
                 vm.performanceInterferenceModel?.onStart(vm.server.image.name)
             }
         }
@@ -200,58 +233,71 @@ public class SimHost(
 
     private fun onGuestStop(vm: Guest) {
         guests.forEach { _, guest ->
-            if (guest.state == ServerState.ACTIVE) {
+            if (guest.state == ServerState.RUNNING) {
                 vm.performanceInterferenceModel?.onStop(vm.server.image.name)
             }
         }
 
         listeners.forEach { it.onStateChanged(this, vm.server, vm.state) }
 
-        _events.emit(HostEvent.VmsUpdated(this@SimHost, guests.count { it.value.state == ServerState.ACTIVE }, availableMemory))
+        _events.emit(HostEvent.VmsUpdated(this@SimHost, guests.count { it.value.state == ServerState.RUNNING }, availableMemory))
+    }
+
+    override suspend fun fail() {
+        _state = HostState.DOWN
+    }
+
+    override suspend fun recover() {
+        _state = HostState.UP
     }
 
     /**
      * A virtual machine instance that the driver manages.
      */
     private inner class Guest(val server: Server, val machine: SimMachine) {
-        val performanceInterferenceModel: PerformanceInterferenceModel? = server.image.tags[IMAGE_PERF_INTERFERENCE_MODEL] as? PerformanceInterferenceModel?
+        val performanceInterferenceModel: PerformanceInterferenceModel? = server.meta[IMAGE_PERF_INTERFERENCE_MODEL] as? PerformanceInterferenceModel?
 
-        var state: ServerState = ServerState.SHUTOFF
+        var state: ServerState = ServerState.TERMINATED
 
         suspend fun start() {
             when (state) {
-                ServerState.SHUTOFF -> {
+                ServerState.TERMINATED -> {
                     logger.info { "User requested to start server ${server.uid}" }
                     launch()
                 }
-                ServerState.ACTIVE -> return
+                ServerState.RUNNING -> return
+                ServerState.DELETED -> {
+                    logger.warn { "User tried to start terminated server" }
+                    throw IllegalArgumentException("Server is terminated")
+                }
                 else -> assert(false) { "Invalid state transition" }
             }
         }
 
         suspend fun stop() {
             when (state) {
-                ServerState.ACTIVE, ServerState.ERROR -> {
+                ServerState.RUNNING, ServerState.ERROR -> {
                     val job = job ?: throw IllegalStateException("Server should be active")
                     job.cancel()
                     job.join()
                 }
-                ServerState.SHUTOFF -> return
+                ServerState.TERMINATED, ServerState.DELETED -> return
                 else -> assert(false) { "Invalid state transition" }
             }
         }
 
         suspend fun terminate() {
             stop()
+            state = ServerState.DELETED
         }
 
         private var job: Job? = null
 
         private suspend fun launch() = suspendCancellableCoroutine<Unit> { cont ->
             assert(job == null) { "Concurrent job running" }
-            val workload = server.image.tags["workload"] as SimWorkload
+            val workload = mapper.createWorkload(server)
 
-            val job = coroutineScope.launch {
+            val job = scope.launch {
                 delay(1) // TODO Introduce boot time
                 init()
                 cont.resume(Unit)
@@ -271,14 +317,14 @@ public class SimHost(
         }
 
         private fun init() {
-            state = ServerState.ACTIVE
+            state = ServerState.RUNNING
             onGuestStart(this)
         }
 
         private fun exit(cause: Throwable?) {
             state =
                 if (cause == null)
-                    ServerState.SHUTOFF
+                    ServerState.TERMINATED
                 else
                     ServerState.ERROR
 
@@ -286,18 +332,4 @@ public class SimHost(
             onGuestStop(this)
         }
     }
-
-    override fun onStart(ctx: SimExecutionContext) {
-        this.ctx = ctx
-        this.availableMemory = ctx.machine.memory.map { it.size }.sum()
-        this.hypervisor.onStart(ctx)
-    }
-
-    override fun onStart(ctx: SimExecutionContext, cpu: Int): SimResourceCommand {
-        return hypervisor.onStart(ctx, cpu)
-    }
-
-    override fun onNext(ctx: SimExecutionContext, cpu: Int, remainingWork: Double): SimResourceCommand {
-        return hypervisor.onNext(ctx, cpu, remainingWork)
-    }
 }
diff --git a/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/SimHostProvisioner.kt b/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/SimHostProvisioner.kt
deleted file mode 100644
index bb03777b..00000000
--- a/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/SimHostProvisioner.kt
+++ /dev/null
@@ -1,69 +0,0 @@
-/*
- * Copyright (c) 2021 AtLarge Research
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-package org.opendc.compute.simulator
-
-import kotlinx.coroutines.*
-import org.opendc.compute.api.Image
-import org.opendc.compute.service.driver.Host
-import org.opendc.metal.Node
-import org.opendc.metal.service.ProvisioningService
-import org.opendc.simulator.compute.SimHypervisorProvider
-import kotlin.coroutines.CoroutineContext
-
-/**
- * A helper class to provision [SimHost]s on top of bare-metal machines using the [ProvisioningService].
- *
- * @param context The [CoroutineContext] to use.
- * @param metal The [ProvisioningService] to use.
- * @param hypervisor The type of hypervisor to use.
- */
-public class SimHostProvisioner(
-    private val context: CoroutineContext,
-    private val metal: ProvisioningService,
-    private val hypervisor: SimHypervisorProvider
-) : AutoCloseable {
-    /**
-     * The [CoroutineScope] of the service bounded by the lifecycle of the service.
-     */
-    private val scope = CoroutineScope(context)
-
-    /**
-     * Provision all machines with a host.
-     */
-    public suspend fun provisionAll(): List<Host> = coroutineScope {
-        metal.nodes().map { node -> async { provision(node) } }.awaitAll()
-    }
-
-    /**
-     * Provision the specified [Node].
-     */
-    public suspend fun provision(node: Node): Host = coroutineScope {
-        val host = SimHost(node, scope, hypervisor)
-        metal.deploy(node, Image(node.uid, node.name, mapOf("workload" to host)))
-        host
-    }
-
-    override fun close() {
-        scope.cancel()
-    }
-}
diff --git a/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/SimMetaWorkloadMapper.kt b/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/SimMetaWorkloadMapper.kt
new file mode 100644
index 00000000..c05f1a2c
--- /dev/null
+++ b/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/SimMetaWorkloadMapper.kt
@@ -0,0 +1,35 @@
+/*
+ * 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.compute.simulator
+
+import org.opendc.compute.api.Server
+import org.opendc.simulator.compute.workload.SimWorkload
+
+/**
+ * A [SimWorkloadMapper] that maps a [Server] to a workload via the meta-data.
+ */
+public class SimMetaWorkloadMapper(private val key: String = "workload") : SimWorkloadMapper {
+    override fun createWorkload(server: Server): SimWorkload {
+        return requireNotNull(server.meta[key] ?: server.image.meta[key]) as SimWorkload
+    }
+}
diff --git a/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/SimWorkloadMapper.kt b/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/SimWorkloadMapper.kt
new file mode 100644
index 00000000..7082c5cf
--- /dev/null
+++ b/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/SimWorkloadMapper.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.compute.simulator
+
+import org.opendc.compute.api.Server
+import org.opendc.simulator.compute.workload.SimWorkload
+
+/**
+ * A [SimWorkloadMapper] is responsible for mapping a [Server] and [Image] to a [SimWorkload] that can be simulated.
+ */
+public fun interface SimWorkloadMapper {
+    /**
+     * Map the specified [server] to a [SimWorkload] that can be simulated.
+     */
+    public fun createWorkload(server: Server): SimWorkload
+}
diff --git a/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/power/api/CpuPowerModel.kt b/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/power/api/CpuPowerModel.kt
index 0141bc8c..604b69c0 100644
--- a/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/power/api/CpuPowerModel.kt
+++ b/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/power/api/CpuPowerModel.kt
@@ -2,7 +2,7 @@ package org.opendc.compute.simulator.power.api
 
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.map
-import org.opendc.metal.driver.BareMetalDriver
+import org.opendc.compute.simulator.SimHost
 
 public interface CpuPowerModel {
     /**
@@ -18,14 +18,14 @@ public interface CpuPowerModel {
     /**
      * Emits the values of power consumption for servers.
      *
-     * @param driver A [BareMetalDriver] that offers host CPU utilization.
+     * @param host A [SimHost] that offers host CPU utilization.
      * @param withoutIdle A [Boolean] flag indicates whether (false) add a constant
      *                  power consumption value when the server is idle or (true) not
      *                  with a default value being false.
      * @return A [Flow] of values representing the server power draw.
      */
-    public fun getPowerDraw(driver: BareMetalDriver, withoutIdle: Boolean = false): Flow<Double> =
-        driver.usage.map {
+    public fun getPowerDraw(host: SimHost, withoutIdle: Boolean = false): Flow<Double> =
+        host.machine.usage.map {
             computeCpuPower(it)
         }
 }