Extract simulation-related code from OpenDC Compute (core)

This change splits the opendc-compute module into two modules:

  1. opendc-compute-core
     The interfaces and APIs that represent a IaaS platform.
  2. opendc-compute-simulator
     The implementation of these interfaces using simulation components
     from opendc-simulator-compute.

20 files changed, 1750 insertions, 0 deletions

diff --git a/simulator/opendc-compute/opendc-compute-simulator/build.gradle.kts b/simulator/opendc-compute/opendc-compute-simulator/build.gradle.kts
new file mode 100644
index 00000000..e1ec6421
--- /dev/null
+++ b/simulator/opendc-compute/opendc-compute-simulator/build.gradle.kts
@@ -0,0 +1,41 @@
+/*
+ * 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.
+ */
+
+description = "Simulator for OpenDC Compute"
+
+/* Build configuration */
+plugins {
+    `kotlin-library-convention`
+}
+
+dependencies {
+    api(project(":opendc-compute:opendc-compute-core"))
+    implementation(project(":opendc-utils"))
+    implementation("io.github.microutils:kotlin-logging:1.7.9")
+    implementation(project(":opendc-simulator:opendc-simulator-compute"))
+
+    testImplementation(project(":opendc-simulator:opendc-simulator-core"))
+    testRuntimeOnly("org.slf4j:slf4j-simple:${Library.SLF4J}")
+    testImplementation("org.junit.jupiter:junit-jupiter-api:${Library.JUNIT_JUPITER}")
+    testRuntimeOnly("org.junit.jupiter:junit-jupiter-engine:${Library.JUNIT_JUPITER}")
+    testImplementation("org.junit.platform:junit-platform-launcher:${Library.JUNIT_PLATFORM}")
+}
diff --git a/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/ComputeSimExecutionContext.kt b/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/ComputeSimExecutionContext.kt
new file mode 100644
index 00000000..153a86b3
--- /dev/null
+++ b/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/ComputeSimExecutionContext.kt
@@ -0,0 +1,36 @@
+/*
+ * 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 org.opendc.compute.core.Server
+import org.opendc.simulator.compute.SimExecutionContext
+
+/**
+ * Extended [SimExecutionContext] in which workloads within the OpenDC Compute module run.
+ */
+public interface ComputeSimExecutionContext : SimExecutionContext {
+    /**
+     * The server on which the image runs.
+     */
+    public val server: Server
+}
diff --git a/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/HypervisorView.kt b/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/HypervisorView.kt
new file mode 100644
index 00000000..1a79523e
--- /dev/null
+++ b/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/HypervisorView.kt
@@ -0,0 +1,37 @@
+/*
+ * 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 org.opendc.compute.core.Server
+import org.opendc.compute.core.virt.driver.VirtDriver
+import java.util.UUID
+
+public class HypervisorView(
+    public val uid: UUID,
+    public var server: Server,
+    public var numberOfActiveServers: Int,
+    public var availableMemory: Long,
+    public var provisionedCores: Int
+) {
+    public lateinit var driver: VirtDriver
+}
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
new file mode 100644
index 00000000..08bb7e79
--- /dev/null
+++ b/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/SimBareMetalDriver.kt
@@ -0,0 +1,244 @@
+/*
+ * 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.core.Flavor
+import org.opendc.compute.core.Server
+import org.opendc.compute.core.ServerEvent
+import org.opendc.compute.core.ServerState
+import org.opendc.compute.core.image.EmptyImage
+import org.opendc.compute.core.image.Image
+import org.opendc.compute.core.metal.Node
+import org.opendc.compute.core.metal.NodeEvent
+import org.opendc.compute.core.metal.NodeState
+import org.opendc.compute.core.metal.driver.BareMetalDriver
+import org.opendc.compute.simulator.power.ConstantPowerModel
+import org.opendc.core.power.PowerModel
+import org.opendc.core.services.ServiceRegistry
+import org.opendc.simulator.compute.SimBareMetalMachine
+import org.opendc.simulator.compute.SimExecutionContext
+import org.opendc.simulator.compute.SimMachineModel
+import org.opendc.simulator.compute.workload.SimWorkload
+import org.opendc.utils.flow.EventFlow
+import org.opendc.utils.flow.StateFlow
+import java.time.Clock
+import java.util.UUID
+import kotlin.random.Random
+
+/**
+ * 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 powerModel The 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,
+    powerModel: PowerModel<SimBareMetalDriver> = ConstantPowerModel(0.0)
+) : BareMetalDriver {
+    /**
+     * 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, EmptyImage, null, 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> = powerModel(this)
+
+    /**
+     * The internal random instance.
+     */
+    private val random = Random(uid.leastSignificantBits xor uid.mostSignificantBits)
+
+    /**
+     * The [Job] that runs the simulated workload.
+     */
+    private var job: Job? = null
+
+    /**
+     * The event stream to publish to for the server.
+     */
+    private var serverEvents: EventFlow<ServerEvent>? = 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 events = EventFlow<ServerEvent>()
+        serverEvents = events
+        val server = Server(
+            UUID(random.nextLong(), random.nextLong()),
+            node.name,
+            emptyMap(),
+            flavor,
+            node.image,
+            ServerState.BUILD,
+            ServiceRegistry().put(BareMetalDriver, this@SimBareMetalDriver),
+            events
+        )
+
+        // Wrap the workload to pass in a ComputeSimExecutionContext
+        val workload = object : SimWorkload {
+            override suspend fun run(ctx: SimExecutionContext) {
+                val wrappedCtx = object : ComputeSimExecutionContext, SimExecutionContext by ctx {
+                    override val server: Server
+                        get() = nodeState.value.server!!
+                }
+                (node.image as SimWorkloadImage).workload.run(wrappedCtx)
+            }
+        }
+
+        job = coroutineScope.launch {
+            delay(1) // TODO Introduce boot time
+            initMachine()
+            try {
+                machine.run(workload)
+                exitMachine(null)
+            } catch (_: CancellationException) {
+                // Ignored
+            } catch (cause: Throwable) {
+                exitMachine(cause)
+            }
+        }
+
+        setNode(node.copy(state = NodeState.BOOT, server = server))
+        return nodeState.value
+    }
+
+    private fun initMachine() {
+        val server = nodeState.value.server?.copy(state = ServerState.ACTIVE)
+        setNode(nodeState.value.copy(state = NodeState.ACTIVE, server = server))
+    }
+
+    private fun exitMachine(cause: Throwable?) {
+        val newServerState =
+            if (cause == null)
+                ServerState.SHUTOFF
+            else
+                ServerState.ERROR
+        val newNodeState =
+            if (cause == null)
+                nodeState.value.state
+            else
+                NodeState.ERROR
+        val server = nodeState.value.server?.copy(state = newServerState)
+        setNode(nodeState.value.copy(state = newNodeState, server = server))
+
+        serverEvents?.close()
+        serverEvents = null
+    }
+
+    override suspend fun stop(): Node {
+        val node = nodeState.value
+        if (node.state == NodeState.SHUTOFF) {
+            return node
+        }
+
+        job?.cancelAndJoin()
+        setNode(node.copy(state = NodeState.SHUTOFF, server = null))
+        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))
+        }
+
+        val oldServer = field.server
+        val newServer = value.server
+
+        if (oldServer != null && newServer != null && oldServer.state != newServer.state) {
+            serverEvents?.emit(ServerEvent.StateChanged(newServer, oldServer.state))
+        }
+
+        nodeState.value = value
+    }
+
+    override val scope: CoroutineScope
+        get() = coroutineScope
+
+    override suspend fun fail() {
+        val server = nodeState.value.server?.copy(state = ServerState.ERROR)
+        setNode(nodeState.value.copy(state = NodeState.ERROR, server = server))
+    }
+
+    override suspend fun recover() {
+        val server = nodeState.value.server?.copy(state = ServerState.ACTIVE)
+        setNode(nodeState.value.copy(state = NodeState.ACTIVE, server = server))
+    }
+
+    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/SimVirtDriver.kt b/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/SimVirtDriver.kt
new file mode 100644
index 00000000..09eec1ef
--- /dev/null
+++ b/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/SimVirtDriver.kt
@@ -0,0 +1,206 @@
+/*
+ * 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.CoroutineScope
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.launch
+import org.opendc.compute.core.*
+import org.opendc.compute.core.image.Image
+import org.opendc.compute.core.virt.HypervisorEvent
+import org.opendc.compute.core.virt.driver.InsufficientMemoryOnServerException
+import org.opendc.compute.core.virt.driver.VirtDriver
+import org.opendc.core.services.ServiceRegistry
+import org.opendc.simulator.compute.SimExecutionContext
+import org.opendc.simulator.compute.SimHypervisor
+import org.opendc.simulator.compute.SimMachine
+import org.opendc.simulator.compute.interference.IMAGE_PERF_INTERFERENCE_MODEL
+import org.opendc.simulator.compute.interference.PerformanceInterferenceModel
+import org.opendc.simulator.compute.workload.SimWorkload
+import org.opendc.utils.flow.EventFlow
+import java.time.Clock
+import java.util.*
+
+/**
+ * A [VirtDriver] that is simulates virtual machines on a physical machine using [SimHypervisor].
+ */
+public class SimVirtDriver(
+    private val coroutineScope: CoroutineScope,
+    clock: Clock,
+    private val ctx: SimExecutionContext
+) : VirtDriver {
+
+    /**
+     * The server hosting this hypervisor.
+     */
+    public val server: Server
+        get() = (ctx as ComputeSimExecutionContext).server
+
+    /**
+     * The [EventFlow] to emit the events.
+     */
+    internal val eventFlow = EventFlow<HypervisorEvent>()
+
+    override val events: Flow<HypervisorEvent> = eventFlow
+
+    /**
+     * Current total memory use of the images on this hypervisor.
+     */
+    private var availableMemory: Long = ctx.machine.memory.map { it.size }.sum()
+
+    /**
+     * The hypervisor to run multiple workloads.
+     */
+    private val hypervisor = SimHypervisor(
+        coroutineScope,
+        clock,
+        object : SimHypervisor.Listener {
+            override fun onSliceFinish(
+                hypervisor: SimHypervisor,
+                requestedBurst: Long,
+                grantedBurst: Long,
+                overcommissionedBurst: Long,
+                interferedBurst: Long,
+                cpuUsage: Double,
+                cpuDemand: Double
+            ) {
+                eventFlow.emit(
+                    HypervisorEvent.SliceFinished(
+                        this@SimVirtDriver,
+                        requestedBurst,
+                        grantedBurst,
+                        overcommissionedBurst,
+                        interferedBurst,
+                        cpuUsage,
+                        cpuDemand,
+                        vms.size,
+                        (ctx as ComputeSimExecutionContext).server
+                    )
+                )
+            }
+        }
+    )
+
+    /**
+     * The virtual machines running on the hypervisor.
+     */
+    private val vms = HashSet<VirtualMachine>()
+
+    override suspend fun spawn(name: String, image: Image, flavor: Flavor): Server {
+        val requiredMemory = flavor.memorySize
+        if (availableMemory - requiredMemory < 0) {
+            throw InsufficientMemoryOnServerException()
+        }
+        require(flavor.cpuCount <= ctx.machine.cpus.size) { "Machine does not fit" }
+
+        val events = EventFlow<ServerEvent>()
+        val server = Server(
+            UUID.randomUUID(),
+            name,
+            emptyMap(),
+            flavor,
+            image,
+            ServerState.BUILD,
+            ServiceRegistry(),
+            events
+        )
+        availableMemory -= requiredMemory
+        val vm = VirtualMachine(server, events, hypervisor.createMachine(ctx.machine))
+        vms.add(vm)
+        vmStarted(vm)
+        eventFlow.emit(HypervisorEvent.VmsUpdated(this, vms.size, availableMemory))
+        return server
+    }
+
+    private fun vmStarted(vm: VirtualMachine) {
+        vms.forEach { it ->
+            vm.performanceInterferenceModel?.onStart(it.server.image.name)
+        }
+    }
+
+    private fun vmStopped(vm: VirtualMachine) {
+        vms.forEach { it ->
+            vm.performanceInterferenceModel?.onStop(it.server.image.name)
+        }
+    }
+
+    /**
+     * A virtual machine instance that the driver manages.
+     */
+    private inner class VirtualMachine(server: Server, val events: EventFlow<ServerEvent>, machine: SimMachine) {
+        val performanceInterferenceModel: PerformanceInterferenceModel? = server.image.tags[IMAGE_PERF_INTERFERENCE_MODEL] as? PerformanceInterferenceModel?
+
+        val job = coroutineScope.launch {
+            val workload = object : SimWorkload {
+                override suspend fun run(ctx: SimExecutionContext) {
+                    val wrappedCtx = object : ComputeSimExecutionContext, SimExecutionContext by ctx {
+                        override val server: Server
+                            get() = this@VirtualMachine.server
+                    }
+                    (server.image as SimWorkloadImage).workload.run(wrappedCtx)
+                }
+            }
+
+            delay(1) // TODO Introduce boot time
+            init()
+            try {
+                machine.run(workload)
+                exit(null)
+            } catch (cause: Throwable) {
+                exit(cause)
+            }
+        }
+
+        var server: Server = server
+            set(value) {
+                if (field.state != value.state) {
+                    events.emit(ServerEvent.StateChanged(value, field.state))
+                }
+
+                field = value
+            }
+
+        private fun init() {
+            server = server.copy(state = ServerState.ACTIVE)
+        }
+
+        private fun exit(cause: Throwable?) {
+            val serverState =
+                if (cause == null)
+                    ServerState.SHUTOFF
+                else
+                    ServerState.ERROR
+            server = server.copy(state = serverState)
+            availableMemory += server.flavor.memorySize
+            vms.remove(this)
+            vmStopped(this)
+            eventFlow.emit(HypervisorEvent.VmsUpdated(this@SimVirtDriver, vms.size, availableMemory))
+            events.close()
+        }
+    }
+
+    public suspend fun run() {
+        hypervisor.run(ctx)
+    }
+}
diff --git a/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/SimVirtDriverWorkload.kt b/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/SimVirtDriverWorkload.kt
new file mode 100644
index 00000000..58b9408a
--- /dev/null
+++ b/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/SimVirtDriverWorkload.kt
@@ -0,0 +1,38 @@
+/*
+ * 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.coroutineScope
+import org.opendc.simulator.compute.SimExecutionContext
+import org.opendc.simulator.compute.workload.SimWorkload
+
+public class SimVirtDriverWorkload : SimWorkload {
+    public lateinit var driver: SimVirtDriver
+
+    override suspend fun run(ctx: SimExecutionContext) {
+        coroutineScope {
+            driver = SimVirtDriver(this, ctx.clock, ctx)
+            driver.run()
+        }
+    }
+}
diff --git a/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/SimVirtProvisioningService.kt b/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/SimVirtProvisioningService.kt
new file mode 100644
index 00000000..e83370d7
--- /dev/null
+++ b/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/SimVirtProvisioningService.kt
@@ -0,0 +1,393 @@
+/*
+ * 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 kotlinx.coroutines.flow.launchIn
+import kotlinx.coroutines.flow.onEach
+import mu.KotlinLogging
+import org.opendc.compute.core.Flavor
+import org.opendc.compute.core.Server
+import org.opendc.compute.core.ServerEvent
+import org.opendc.compute.core.ServerState
+import org.opendc.compute.core.image.Image
+import org.opendc.compute.core.metal.service.ProvisioningService
+import org.opendc.compute.core.virt.HypervisorEvent
+import org.opendc.compute.core.virt.driver.InsufficientMemoryOnServerException
+import org.opendc.compute.core.virt.driver.VirtDriver
+import org.opendc.compute.core.virt.service.VirtProvisioningEvent
+import org.opendc.compute.core.virt.service.VirtProvisioningService
+import org.opendc.compute.simulator.allocation.AllocationPolicy
+import org.opendc.utils.flow.EventFlow
+import java.time.Clock
+import java.util.*
+import kotlin.coroutines.Continuation
+import kotlin.coroutines.resume
+import kotlin.math.max
+
+@OptIn(ExperimentalCoroutinesApi::class)
+public class SimVirtProvisioningService(
+    private val coroutineScope: CoroutineScope,
+    private val clock: Clock,
+    private val provisioningService: ProvisioningService,
+    public val allocationPolicy: AllocationPolicy
+) : VirtProvisioningService {
+    /**
+     * The logger instance to use.
+     */
+    private val logger = KotlinLogging.logger {}
+
+    /**
+     * The hypervisors that have been launched by the service.
+     */
+    private val hypervisors: MutableMap<Server, HypervisorView> = mutableMapOf()
+
+    /**
+     * The available hypervisors.
+     */
+    private val availableHypervisors: MutableSet<HypervisorView> = mutableSetOf()
+
+    /**
+     * The incoming images to be processed by the provisioner.
+     */
+    private val incomingImages: MutableSet<ImageView> = mutableSetOf()
+
+    /**
+     * The active images in the system.
+     */
+    private val activeImages: MutableSet<ImageView> = mutableSetOf()
+
+    public var submittedVms: Int = 0
+    public var queuedVms: Int = 0
+    public var runningVms: Int = 0
+    public var finishedVms: Int = 0
+    public var unscheduledVms: Int = 0
+
+    private var maxCores = 0
+    private var maxMemory = 0L
+
+    /**
+     * The allocation logic to use.
+     */
+    private val allocationLogic = allocationPolicy()
+
+    /**
+     * The [EventFlow] to emit the events.
+     */
+    internal val eventFlow = EventFlow<VirtProvisioningEvent>()
+
+    override val events: Flow<VirtProvisioningEvent> = eventFlow
+
+    init {
+        coroutineScope.launch {
+            val provisionedNodes = provisioningService.nodes()
+            provisionedNodes.forEach { node ->
+                val workload = SimVirtDriverWorkload()
+                val hypervisorImage = SimWorkloadImage(UUID.randomUUID(), "vmm", emptyMap(), workload)
+                launch {
+                    var init = false
+                    val deployedNode = provisioningService.deploy(node, hypervisorImage)
+                    val server = deployedNode.server!!
+                    server.events.onEach { event ->
+                        when (event) {
+                            is ServerEvent.StateChanged -> {
+                                if (!init) {
+                                    init = true
+                                }
+                                stateChanged(event.server)
+                            }
+                        }
+                    }.launchIn(this)
+
+                    delay(1)
+                    onHypervisorAvailable(server, workload.driver)
+                }
+            }
+        }
+    }
+
+    override suspend fun drivers(): Set<VirtDriver> {
+        return availableHypervisors.map { it.driver }.toSet()
+    }
+
+    override suspend fun deploy(
+        name: String,
+        image: Image,
+        flavor: Flavor
+    ): Server {
+        eventFlow.emit(
+            VirtProvisioningEvent.MetricsAvailable(
+                this@SimVirtProvisioningService,
+                hypervisors.size,
+                availableHypervisors.size,
+                ++submittedVms,
+                runningVms,
+                finishedVms,
+                ++queuedVms,
+                unscheduledVms
+            )
+        )
+
+        return suspendCancellableCoroutine<Server> { cont ->
+            val vmInstance = ImageView(name, image, flavor, cont)
+            incomingImages += vmInstance
+            requestCycle()
+        }
+    }
+
+    override suspend fun terminate() {
+        val provisionedNodes = provisioningService.nodes()
+        provisionedNodes.forEach { node -> provisioningService.stop(node) }
+    }
+
+    private var call: Job? = null
+
+    private fun requestCycle() {
+        if (call != null) {
+            return
+        }
+
+        val quantum = 300000 // 5 minutes in milliseconds
+        // We assume that the provisioner runs at a fixed slot every time quantum (e.g t=0, t=60, t=120).
+        // This is important because the slices of the VMs need to be aligned.
+        // We calculate here the delay until the next scheduling slot.
+        val delay = quantum - (clock.millis() % quantum)
+
+        val call = coroutineScope.launch {
+            delay(delay)
+            this@SimVirtProvisioningService.call = null
+            schedule()
+        }
+        this.call = call
+    }
+
+    private suspend fun schedule() {
+        val imagesToBeScheduled = incomingImages.toSet()
+
+        for (imageInstance in imagesToBeScheduled) {
+            val requiredMemory = imageInstance.image.tags["required-memory"] as Long
+            val selectedHv = allocationLogic.select(availableHypervisors, imageInstance)
+
+            if (selectedHv == null) {
+                if (requiredMemory > maxMemory || imageInstance.flavor.cpuCount > maxCores) {
+                    eventFlow.emit(
+                        VirtProvisioningEvent.MetricsAvailable(
+                            this@SimVirtProvisioningService,
+                            hypervisors.size,
+                            availableHypervisors.size,
+                            submittedVms,
+                            runningVms,
+                            finishedVms,
+                            queuedVms,
+                            ++unscheduledVms
+                        )
+                    )
+
+                    incomingImages -= imageInstance
+
+                    logger.warn("Failed to spawn ${imageInstance.image}: does not fit [${clock.millis()}]")
+                    continue
+                } else {
+                    break
+                }
+            }
+
+            try {
+                logger.info { "[${clock.millis()}] Spawning ${imageInstance.image} on ${selectedHv.server.uid} ${selectedHv.server.name} ${selectedHv.server.flavor}" }
+                incomingImages -= imageInstance
+
+                // Speculatively update the hypervisor view information to prevent other images in the queue from
+                // deciding on stale values.
+                selectedHv.numberOfActiveServers++
+                selectedHv.provisionedCores += imageInstance.flavor.cpuCount
+                selectedHv.availableMemory -= requiredMemory // XXX Temporary hack
+
+                val server = selectedHv.driver.spawn(
+                    imageInstance.name,
+                    imageInstance.image,
+                    imageInstance.flavor
+                )
+                imageInstance.server = server
+                imageInstance.continuation.resume(server)
+
+                eventFlow.emit(
+                    VirtProvisioningEvent.MetricsAvailable(
+                        this@SimVirtProvisioningService,
+                        hypervisors.size,
+                        availableHypervisors.size,
+                        submittedVms,
+                        ++runningVms,
+                        finishedVms,
+                        --queuedVms,
+                        unscheduledVms
+                    )
+                )
+                activeImages += imageInstance
+
+                server.events
+                    .onEach { event ->
+                        when (event) {
+                            is ServerEvent.StateChanged -> {
+                                if (event.server.state == ServerState.SHUTOFF) {
+                                    logger.info { "[${clock.millis()}] Server ${event.server.uid} ${event.server.name} ${event.server.flavor} finished." }
+
+                                    eventFlow.emit(
+                                        VirtProvisioningEvent.MetricsAvailable(
+                                            this@SimVirtProvisioningService,
+                                            hypervisors.size,
+                                            availableHypervisors.size,
+                                            submittedVms,
+                                            --runningVms,
+                                            ++finishedVms,
+                                            queuedVms,
+                                            unscheduledVms
+                                        )
+                                    )
+
+                                    activeImages -= imageInstance
+                                    selectedHv.provisionedCores -= server.flavor.cpuCount
+
+                                    // Try to reschedule if needed
+                                    if (incomingImages.isNotEmpty()) {
+                                        requestCycle()
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    .launchIn(coroutineScope)
+            } catch (e: InsufficientMemoryOnServerException) {
+                logger.error("Failed to deploy VM", e)
+
+                selectedHv.numberOfActiveServers--
+                selectedHv.provisionedCores -= imageInstance.flavor.cpuCount
+                selectedHv.availableMemory += requiredMemory
+            } catch (e: Throwable) {
+                logger.error("Failed to deploy VM", e)
+            }
+        }
+    }
+
+    private fun stateChanged(server: Server) {
+        when (server.state) {
+            ServerState.ACTIVE -> {
+                logger.debug { "[${clock.millis()}] Server ${server.uid} available: ${server.state}" }
+
+                if (server in hypervisors) {
+                    // Corner case for when the hypervisor already exists
+                    availableHypervisors += hypervisors.getValue(server)
+                } else {
+                    val hv = HypervisorView(
+                        server.uid,
+                        server,
+                        0,
+                        server.flavor.memorySize,
+                        0
+                    )
+                    maxCores = max(maxCores, server.flavor.cpuCount)
+                    maxMemory = max(maxMemory, server.flavor.memorySize)
+                    hypervisors[server] = hv
+                }
+
+                eventFlow.emit(
+                    VirtProvisioningEvent.MetricsAvailable(
+                        this@SimVirtProvisioningService,
+                        hypervisors.size,
+                        availableHypervisors.size,
+                        submittedVms,
+                        runningVms,
+                        finishedVms,
+                        queuedVms,
+                        unscheduledVms
+                    )
+                )
+
+                // Re-schedule on the new machine
+                if (incomingImages.isNotEmpty()) {
+                    requestCycle()
+                }
+            }
+            ServerState.SHUTOFF, ServerState.ERROR -> {
+                logger.debug { "[${clock.millis()}] Server ${server.uid} unavailable: ${server.state}" }
+                val hv = hypervisors[server] ?: return
+                availableHypervisors -= hv
+
+                eventFlow.emit(
+                    VirtProvisioningEvent.MetricsAvailable(
+                        this@SimVirtProvisioningService,
+                        hypervisors.size,
+                        availableHypervisors.size,
+                        submittedVms,
+                        runningVms,
+                        finishedVms,
+                        queuedVms,
+                        unscheduledVms
+                    )
+                )
+
+                if (incomingImages.isNotEmpty()) {
+                    requestCycle()
+                }
+            }
+            else -> throw IllegalStateException()
+        }
+    }
+
+    private fun onHypervisorAvailable(server: Server, hypervisor: SimVirtDriver) {
+        val hv = hypervisors[server] ?: return
+        hv.driver = hypervisor
+        availableHypervisors += hv
+
+        eventFlow.emit(
+            VirtProvisioningEvent.MetricsAvailable(
+                this@SimVirtProvisioningService,
+                hypervisors.size,
+                availableHypervisors.size,
+                submittedVms,
+                runningVms,
+                finishedVms,
+                queuedVms,
+                unscheduledVms
+            )
+        )
+
+        hv.driver.events
+            .onEach { event ->
+                if (event is HypervisorEvent.VmsUpdated) {
+                    hv.numberOfActiveServers = event.numberOfActiveServers
+                    hv.availableMemory = event.availableMemory
+                }
+            }.launchIn(coroutineScope)
+
+        requestCycle()
+    }
+
+    public data class ImageView(
+        public val name: String,
+        public val image: Image,
+        public val flavor: Flavor,
+        public val continuation: Continuation<Server>,
+        public var server: Server? = null
+    )
+}
diff --git a/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/SimWorkloadImage.kt b/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/SimWorkloadImage.kt
new file mode 100644
index 00000000..b48de1d5
--- /dev/null
+++ b/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/SimWorkloadImage.kt
@@ -0,0 +1,43 @@
+/*
+ * 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 org.opendc.compute.core.image.Image
+import org.opendc.core.resource.TagContainer
+import org.opendc.simulator.compute.workload.SimWorkload
+import java.util.*
+
+/**
+ * An application [Image] that runs a [SimWorkload].
+ *
+ * @property uid The unique identifier of this image.
+ * @property name The name of this image.
+ * @property tags The tags attached to the image.
+ * @property workload The workload to run for this image.
+ */
+public data class SimWorkloadImage(
+    public override val uid: UUID,
+    public override val name: String,
+    public override val tags: TagContainer,
+    public val workload: SimWorkload
+) : Image
diff --git a/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/allocation/AllocationPolicy.kt b/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/allocation/AllocationPolicy.kt
new file mode 100644
index 00000000..2018b9f2
--- /dev/null
+++ b/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/allocation/AllocationPolicy.kt
@@ -0,0 +1,50 @@
+/*
+ * 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.allocation
+
+import org.opendc.compute.core.metal.Node
+import org.opendc.compute.simulator.HypervisorView
+import org.opendc.compute.simulator.SimVirtProvisioningService
+
+/**
+ * A policy for selecting the [Node] an image should be deployed to,
+ */
+public interface AllocationPolicy {
+    /**
+     * The logic of the allocation policy.
+     */
+    public interface Logic {
+        /**
+         * Select the node on which the server should be scheduled.
+         */
+        public fun select(
+            hypervisors: Set<HypervisorView>,
+            image: SimVirtProvisioningService.ImageView
+        ): HypervisorView?
+    }
+
+    /**
+     * Builds the logic of the policy.
+     */
+    public operator fun invoke(): Logic
+}
diff --git a/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/allocation/AvailableCoreMemoryAllocationPolicy.kt b/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/allocation/AvailableCoreMemoryAllocationPolicy.kt
new file mode 100644
index 00000000..38a07b2b
--- /dev/null
+++ b/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/allocation/AvailableCoreMemoryAllocationPolicy.kt
@@ -0,0 +1,38 @@
+/*
+ * 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.allocation
+
+import org.opendc.compute.simulator.HypervisorView
+
+/**
+ * An [AllocationPolicy] that selects the machine with the highest/lowest amount of memory per core.
+ *
+ * @param reversed An option to reverse the order of the machines (lower amount of memory scores better).
+ */
+public class AvailableCoreMemoryAllocationPolicy(private val reversed: Boolean = false) : AllocationPolicy {
+    override fun invoke(): AllocationPolicy.Logic = object : ComparableAllocationPolicyLogic {
+        override val comparator: Comparator<HypervisorView> =
+            compareBy<HypervisorView> { -it.availableMemory / it.server.flavor.cpuCount }
+                .run { if (reversed) reversed() else this }
+    }
+}
diff --git a/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/allocation/AvailableMemoryAllocationPolicy.kt b/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/allocation/AvailableMemoryAllocationPolicy.kt
new file mode 100644
index 00000000..e87abd7b
--- /dev/null
+++ b/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/allocation/AvailableMemoryAllocationPolicy.kt
@@ -0,0 +1,37 @@
+/*
+ * 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.allocation
+
+import org.opendc.compute.simulator.HypervisorView
+
+/**
+ * Allocation policy that selects the node with the most available memory.
+ *
+ * @param reversed A flag to reverse the order (least amount of memory scores the best).
+ */
+public class AvailableMemoryAllocationPolicy(public val reversed: Boolean = false) : AllocationPolicy {
+    override fun invoke(): AllocationPolicy.Logic = object : ComparableAllocationPolicyLogic {
+        override val comparator: Comparator<HypervisorView> = compareBy<HypervisorView> { -it.availableMemory }
+            .run { if (reversed) reversed() else this }
+    }
+}
diff --git a/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/allocation/ComparableAllocationPolicyLogic.kt b/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/allocation/ComparableAllocationPolicyLogic.kt
new file mode 100644
index 00000000..6aff2bab
--- /dev/null
+++ b/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/allocation/ComparableAllocationPolicyLogic.kt
@@ -0,0 +1,49 @@
+/*
+ * 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.allocation
+
+import org.opendc.compute.simulator.HypervisorView
+import org.opendc.compute.simulator.SimVirtProvisioningService
+
+/**
+ * The logic for an [AllocationPolicy] that uses a [Comparator] to select the appropriate node.
+ */
+public interface ComparableAllocationPolicyLogic : AllocationPolicy.Logic {
+    /**
+     * The comparator to use.
+     */
+    public val comparator: Comparator<HypervisorView>
+
+    override fun select(
+        hypervisors: Set<HypervisorView>,
+        image: SimVirtProvisioningService.ImageView
+    ): HypervisorView? {
+        return hypervisors.asSequence()
+            .filter { hv ->
+                val fitsMemory = hv.availableMemory >= (image.image.tags["required-memory"] as Long)
+                val fitsCpu = hv.server.flavor.cpuCount >= image.flavor.cpuCount
+                fitsMemory && fitsCpu
+            }
+            .minWith(comparator.thenBy { it.server.uid })
+    }
+}
diff --git a/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/allocation/NumberOfActiveServersAllocationPolicy.kt b/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/allocation/NumberOfActiveServersAllocationPolicy.kt
new file mode 100644
index 00000000..5e2b895c
--- /dev/null
+++ b/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/allocation/NumberOfActiveServersAllocationPolicy.kt
@@ -0,0 +1,37 @@
+/*
+ * 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.allocation
+
+import org.opendc.compute.simulator.HypervisorView
+
+/**
+ * Allocation policy that selects the node with the least amount of active servers.
+ *
+ * @param reversed A flag to reverse the order, such that the node with the most active servers is selected.
+ */
+public class NumberOfActiveServersAllocationPolicy(public val reversed: Boolean = false) : AllocationPolicy {
+    override fun invoke(): AllocationPolicy.Logic = object : ComparableAllocationPolicyLogic {
+        override val comparator: Comparator<HypervisorView> = compareBy<HypervisorView> { it.numberOfActiveServers }
+            .run { if (reversed) reversed() else this }
+    }
+}
diff --git a/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/allocation/ProvisionedCoresAllocationPolicy.kt b/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/allocation/ProvisionedCoresAllocationPolicy.kt
new file mode 100644
index 00000000..4344d979
--- /dev/null
+++ b/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/allocation/ProvisionedCoresAllocationPolicy.kt
@@ -0,0 +1,40 @@
+/*
+ * 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.allocation
+
+import org.opendc.compute.simulator.HypervisorView
+
+/**
+ * An [AllocationPolicy] that takes into account the number of vCPUs that have been provisioned on this machine
+ * relative to its core count.
+ *
+ * @param reversed A flag to reverse the order of the policy, such that the machine with the most provisioned cores
+ * is selected.
+ */
+public class ProvisionedCoresAllocationPolicy(private val reversed: Boolean = false) : AllocationPolicy {
+    override fun invoke(): AllocationPolicy.Logic = object : ComparableAllocationPolicyLogic {
+        override val comparator: Comparator<HypervisorView> =
+            compareBy<HypervisorView> { it.provisionedCores / it.server.flavor.cpuCount }
+                .run { if (reversed) reversed() else this }
+    }
+}
diff --git a/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/allocation/RandomAllocationPolicy.kt b/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/allocation/RandomAllocationPolicy.kt
new file mode 100644
index 00000000..ac34f410
--- /dev/null
+++ b/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/allocation/RandomAllocationPolicy.kt
@@ -0,0 +1,48 @@
+/*
+ * 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.allocation
+
+import org.opendc.compute.simulator.HypervisorView
+import org.opendc.compute.simulator.SimVirtProvisioningService
+import kotlin.random.Random
+
+/**
+ * An [AllocationPolicy] that select a random node on which the server fits.
+ */
+public class RandomAllocationPolicy(private val random: Random = Random(0)) : AllocationPolicy {
+    @OptIn(ExperimentalStdlibApi::class)
+    override fun invoke(): AllocationPolicy.Logic = object : AllocationPolicy.Logic {
+        override fun select(
+            hypervisors: Set<HypervisorView>,
+            image: SimVirtProvisioningService.ImageView
+        ): HypervisorView? {
+            return hypervisors.asIterable()
+                .filter { hv ->
+                    val fitsMemory = hv.availableMemory >= (image.image.tags["required-memory"] as Long)
+                    val fitsCpu = hv.server.flavor.cpuCount >= image.flavor.cpuCount
+                    fitsMemory && fitsCpu
+                }
+                .randomOrNull(random)
+        }
+    }
+}
diff --git a/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/allocation/ReplayAllocationPolicy.kt b/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/allocation/ReplayAllocationPolicy.kt
new file mode 100644
index 00000000..fda863bb
--- /dev/null
+++ b/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/allocation/ReplayAllocationPolicy.kt
@@ -0,0 +1,56 @@
+/*
+ * 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.allocation
+
+import mu.KotlinLogging
+import org.opendc.compute.simulator.HypervisorView
+import org.opendc.compute.simulator.SimVirtProvisioningService
+
+private val logger = KotlinLogging.logger {}
+
+/**
+ * Policy replaying VM-cluster assignment.
+ *
+ * Within each cluster, the active servers on each node determine which node gets
+ * assigned the VM image.
+ */
+public class ReplayAllocationPolicy(private val vmPlacements: Map<String, String>) : AllocationPolicy {
+    override fun invoke(): AllocationPolicy.Logic = object : AllocationPolicy.Logic {
+        override fun select(
+            hypervisors: Set<HypervisorView>,
+            image: SimVirtProvisioningService.ImageView
+        ): HypervisorView? {
+            val clusterName = vmPlacements[image.name]
+                ?: throw IllegalStateException("Could not find placement data in VM placement file for VM ${image.name}")
+            val machinesInCluster = hypervisors.filter { it.server.name.contains(clusterName) }
+
+            if (machinesInCluster.isEmpty()) {
+                logger.info { "Could not find any machines belonging to cluster $clusterName for image ${image.name}, assigning randomly." }
+                return hypervisors.maxBy { it.availableMemory }
+            }
+
+            return machinesInCluster.maxBy { it.availableMemory }
+                ?: throw IllegalStateException("Cloud not find any machine and could not randomly assign")
+        }
+    }
+}
diff --git a/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/power/PowerModels.kt b/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/power/PowerModels.kt
new file mode 100644
index 00000000..09651720
--- /dev/null
+++ b/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/power/PowerModels.kt
@@ -0,0 +1,43 @@
+/*
+ * 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.power
+
+import kotlinx.coroutines.flow.flowOf
+import kotlinx.coroutines.flow.map
+import org.opendc.compute.core.metal.driver.BareMetalDriver
+import org.opendc.core.power.PowerModel
+
+/**
+ * A power model which emits a single value.
+ */
+public fun ConstantPowerModel(value: Double): PowerModel<BareMetalDriver> = { _ -> flowOf(value) }
+
+/**
+ * A power model that assumes a naive linear relation between power usage and host CPU utilization.
+ *
+ * @param idle The power draw in Watts on idle.
+ * @param max The maximum power draw in Watts of the server.
+ */
+public fun LinearLoadPowerModel(idle: Double, max: Double): PowerModel<BareMetalDriver> = { driver ->
+    driver.usage.map { load -> (max - idle) * load + idle }
+}
diff --git a/simulator/opendc-compute/opendc-compute-simulator/src/test/kotlin/org/opendc/compute/simulator/SimBareMetalDriverTest.kt b/simulator/opendc-compute/opendc-compute-simulator/src/test/kotlin/org/opendc/compute/simulator/SimBareMetalDriverTest.kt
new file mode 100644
index 00000000..0f1bd444
--- /dev/null
+++ b/simulator/opendc-compute/opendc-compute-simulator/src/test/kotlin/org/opendc/compute/simulator/SimBareMetalDriverTest.kt
@@ -0,0 +1,89 @@
+/*
+ * 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.ExperimentalCoroutinesApi
+import kotlinx.coroutines.flow.collect
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.test.TestCoroutineScope
+import kotlinx.coroutines.withContext
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.BeforeEach
+import org.junit.jupiter.api.Test
+import org.opendc.compute.core.ServerEvent
+import org.opendc.compute.core.ServerState
+import org.opendc.simulator.compute.SimMachineModel
+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.workload.SimFlopsWorkload
+import org.opendc.simulator.utils.DelayControllerClockAdapter
+import java.util.UUID
+
+@OptIn(ExperimentalCoroutinesApi::class)
+internal class SimBareMetalDriverTest {
+    private lateinit var machineModel: SimMachineModel
+
+    @BeforeEach
+    fun setUp() {
+        val cpuNode = ProcessingNode("Intel", "Xeon", "amd64", 4)
+
+        machineModel = SimMachineModel(
+            cpus = List(cpuNode.coreCount) { ProcessingUnit(cpuNode, it, 2000.0) },
+            memory = List(4) { MemoryUnit("Crucial", "MTA18ASF4G72AZ-3G2B1", 3200.0, 32_000) }
+        )
+    }
+
+    @Test
+    fun testFlopsWorkload() {
+        val testScope = TestCoroutineScope()
+        val clock = DelayControllerClockAdapter(testScope)
+
+        var finalState: ServerState = ServerState.BUILD
+        var finalTime = 0L
+
+        testScope.launch {
+            val driver = SimBareMetalDriver(this, clock, UUID.randomUUID(), "test", emptyMap(), machineModel)
+            val image = SimWorkloadImage(UUID.randomUUID(), "<unnamed>", emptyMap(), SimFlopsWorkload(4_000, 2, utilization = 1.0))
+
+            // Batch driver commands
+            withContext(coroutineContext) {
+                driver.init()
+                driver.setImage(image)
+                val server = driver.start().server!!
+                server.events.collect { event ->
+                    when (event) {
+                        is ServerEvent.StateChanged -> {
+                            finalState = event.server.state
+                            finalTime = clock.millis()
+                        }
+                    }
+                }
+            }
+        }
+
+        testScope.advanceUntilIdle()
+        assertEquals(ServerState.SHUTOFF, finalState)
+        assertEquals(1001, finalTime)
+    }
+}
diff --git a/simulator/opendc-compute/opendc-compute-simulator/src/test/kotlin/org/opendc/compute/simulator/SimProvisioningServiceTest.kt b/simulator/opendc-compute/opendc-compute-simulator/src/test/kotlin/org/opendc/compute/simulator/SimProvisioningServiceTest.kt
new file mode 100644
index 00000000..def78ce7
--- /dev/null
+++ b/simulator/opendc-compute/opendc-compute-simulator/src/test/kotlin/org/opendc/compute/simulator/SimProvisioningServiceTest.kt
@@ -0,0 +1,80 @@
+/*
+ * 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.ExperimentalCoroutinesApi
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.collect
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.test.TestCoroutineScope
+import org.junit.jupiter.api.BeforeEach
+import org.junit.jupiter.api.Test
+import org.opendc.compute.core.metal.service.SimpleProvisioningService
+import org.opendc.simulator.compute.SimMachineModel
+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.workload.SimFlopsWorkload
+import org.opendc.simulator.utils.DelayControllerClockAdapter
+import java.util.UUID
+
+/**
+ * Test suite for the [SimpleProvisioningService].
+ */
+@OptIn(ExperimentalCoroutinesApi::class)
+internal class SimProvisioningServiceTest {
+    private lateinit var machineModel: SimMachineModel
+
+    @BeforeEach
+    fun setUp() {
+        val cpuNode = ProcessingNode("Intel", "Xeon", "amd64", 4)
+
+        machineModel = SimMachineModel(
+            cpus = List(cpuNode.coreCount) { ProcessingUnit(cpuNode, it, 2000.0) },
+            memory = List(4) { MemoryUnit("Crucial", "MTA18ASF4G72AZ-3G2B1", 3200.0, 32_000) }
+        )
+    }
+
+    /**
+     * A basic smoke test.
+     */
+    @Test
+    fun testSmoke() {
+        val testScope = TestCoroutineScope()
+        val clock = DelayControllerClockAdapter(testScope)
+
+        testScope.launch {
+            val image = SimWorkloadImage(UUID.randomUUID(), "<unnamed>", emptyMap(), SimFlopsWorkload(1000, 2))
+            val driver = SimBareMetalDriver(this, clock, UUID.randomUUID(), "test", emptyMap(), machineModel)
+
+            val provisioner = SimpleProvisioningService()
+            provisioner.create(driver)
+            delay(5)
+            val nodes = provisioner.nodes()
+            val node = provisioner.deploy(nodes.first(), image)
+            node.server!!.events.collect { println(it) }
+        }
+
+        testScope.advanceUntilIdle()
+    }
+}
diff --git a/simulator/opendc-compute/opendc-compute-simulator/src/test/kotlin/org/opendc/compute/simulator/SimVirtDriverTest.kt b/simulator/opendc-compute/opendc-compute-simulator/src/test/kotlin/org/opendc/compute/simulator/SimVirtDriverTest.kt
new file mode 100644
index 00000000..a0c61f29
--- /dev/null
+++ b/simulator/opendc-compute/opendc-compute-simulator/src/test/kotlin/org/opendc/compute/simulator/SimVirtDriverTest.kt
@@ -0,0 +1,145 @@
+/*
+ * 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.ExperimentalCoroutinesApi
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.launchIn
+import kotlinx.coroutines.flow.onEach
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.test.TestCoroutineScope
+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.compute.core.Flavor
+import org.opendc.compute.core.virt.HypervisorEvent
+import org.opendc.simulator.compute.SimMachineModel
+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.workload.SimTraceWorkload
+import org.opendc.simulator.utils.DelayControllerClockAdapter
+import java.time.Clock
+import java.util.UUID
+
+/**
+ * Basic test-suite for the hypervisor.
+ */
+@OptIn(ExperimentalCoroutinesApi::class)
+internal class SimVirtDriverTest {
+    private lateinit var scope: TestCoroutineScope
+    private lateinit var clock: Clock
+    private lateinit var machineModel: SimMachineModel
+
+    @BeforeEach
+    fun setUp() {
+        scope = TestCoroutineScope()
+        clock = DelayControllerClockAdapter(scope)
+
+        val cpuNode = ProcessingNode("Intel", "Xeon", "amd64", 2)
+
+        machineModel = SimMachineModel(
+            cpus = List(cpuNode.coreCount) { ProcessingUnit(cpuNode, it, 3200.0) },
+            memory = List(4) { MemoryUnit("Crucial", "MTA18ASF4G72AZ-3G2B1", 3200.0, 32_000) }
+        )
+    }
+
+    /**
+     * Test overcommissioning of a hypervisor.
+     */
+    @Test
+    fun overcommission() {
+        var requestedBurst = 0L
+        var grantedBurst = 0L
+        var overcommissionedBurst = 0L
+
+        scope.launch {
+            val virtDriverWorkload = SimVirtDriverWorkload()
+            val vmm = SimWorkloadImage(UUID.randomUUID(), "vmm", emptyMap(), virtDriverWorkload)
+            val duration = 5 * 60L
+            val vmImageA = SimWorkloadImage(
+                UUID.randomUUID(),
+                "<unnamed>",
+                emptyMap(),
+                SimTraceWorkload(
+                    sequenceOf(
+                        SimTraceWorkload.Fragment(0, 28L * duration, duration * 1000, 28.0, 2),
+                        SimTraceWorkload.Fragment(0, 3500L * duration, duration * 1000, 3500.0, 2),
+                        SimTraceWorkload.Fragment(0, 0, duration * 1000, 0.0, 2),
+                        SimTraceWorkload.Fragment(0, 183L * duration, duration * 1000, 183.0, 2)
+                    ),
+                )
+            )
+            val vmImageB = SimWorkloadImage(
+                UUID.randomUUID(),
+                "<unnamed>",
+                emptyMap(),
+                SimTraceWorkload(
+                    sequenceOf(
+                        SimTraceWorkload.Fragment(0, 28L * duration, duration * 1000, 28.0, 2),
+                        SimTraceWorkload.Fragment(0, 3100L * duration, duration * 1000, 3100.0, 2),
+                        SimTraceWorkload.Fragment(0, 0, duration * 1000, 0.0, 2),
+                        SimTraceWorkload.Fragment(0, 73L * duration, duration * 1000, 73.0, 2)
+                    )
+                ),
+            )
+
+            val metalDriver =
+                SimBareMetalDriver(this, clock, UUID.randomUUID(), "test", emptyMap(), machineModel)
+
+            metalDriver.init()
+            metalDriver.setImage(vmm)
+            metalDriver.start()
+
+            delay(5)
+
+            val flavor = Flavor(2, 0)
+            val vmDriver = virtDriverWorkload.driver
+            vmDriver.events
+                .onEach { event ->
+                    when (event) {
+                        is HypervisorEvent.SliceFinished -> {
+                            requestedBurst += event.requestedBurst
+                            grantedBurst += event.grantedBurst
+                            overcommissionedBurst += event.overcommissionedBurst
+                        }
+                    }
+                }
+                .launchIn(this)
+
+            vmDriver.spawn("a", vmImageA, flavor)
+            vmDriver.spawn("b", vmImageB, flavor)
+        }
+
+        scope.advanceUntilIdle()
+
+        assertAll(
+            { assertEquals(emptyList<Throwable>(), scope.uncaughtExceptions, "No errors") },
+            { assertEquals(2073600, requestedBurst, "Requested Burst does not match") },
+            { assertEquals(2013600, grantedBurst, "Granted Burst does not match") },
+            { assertEquals(60000, overcommissionedBurst, "Overcommissioned Burst does not match") },
+            { assertEquals(1200007, scope.currentTime) }
+        )
+    }
+}