simulator: Re-implement performance interference model

This change updates reimplements the performance interference model to
work on top of the universal resource model in
`opendc-simulator-resources`. This enables us to model interference and
performance variability of other resources such as disk or network in
the future.

27 files changed, 575 insertions, 244 deletions

diff --git a/buildSrc/src/main/kotlin/kotlin-conventions.gradle.kts b/buildSrc/src/main/kotlin/kotlin-conventions.gradle.kts
index 7fda64a2..6e4cab89 100644
--- a/buildSrc/src/main/kotlin/kotlin-conventions.gradle.kts
+++ b/buildSrc/src/main/kotlin/kotlin-conventions.gradle.kts
@@ -40,4 +40,5 @@ java {
 tasks.withType<KotlinCompile>().configureEach {
     kotlinOptions.jvmTarget = Libs.jvmTarget.toString()
     kotlinOptions.freeCompilerArgs += "-Xopt-in=kotlin.RequiresOptIn"
+    kotlinOptions.freeCompilerArgs += "-Xjvm-default=all"
 }
diff --git a/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/SimHost.kt b/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/SimHost.kt
index be7bc667..5ea577f3 100644
--- a/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/SimHost.kt
+++ b/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/SimHost.kt
@@ -31,17 +31,15 @@ import org.opendc.compute.api.Server
 import org.opendc.compute.api.ServerState
 import org.opendc.compute.service.driver.*
 import org.opendc.simulator.compute.*
-import org.opendc.simulator.compute.interference.IMAGE_PERF_INTERFERENCE_MODEL
-import org.opendc.simulator.compute.interference.PerformanceInterferenceModel
 import org.opendc.simulator.compute.kernel.SimHypervisor
 import org.opendc.simulator.compute.kernel.SimHypervisorProvider
 import org.opendc.simulator.compute.kernel.cpufreq.PerformanceScalingGovernor
 import org.opendc.simulator.compute.kernel.cpufreq.ScalingGovernor
+import org.opendc.simulator.compute.kernel.interference.VmInterferenceDomain
 import org.opendc.simulator.compute.model.MachineModel
 import org.opendc.simulator.compute.model.MemoryUnit
 import org.opendc.simulator.compute.power.ConstantPowerModel
 import org.opendc.simulator.compute.power.PowerDriver
-import org.opendc.simulator.compute.power.PowerModel
 import org.opendc.simulator.compute.power.SimplePowerDriver
 import org.opendc.simulator.failures.FailureDomain
 import org.opendc.simulator.resources.SimResourceInterpreter
@@ -61,24 +59,11 @@ public class SimHost(
     interpreter: SimResourceInterpreter,
     meter: Meter,
     hypervisor: SimHypervisorProvider,
-    scalingGovernor: ScalingGovernor,
-    scalingDriver: PowerDriver,
+    scalingGovernor: ScalingGovernor = PerformanceScalingGovernor(),
+    powerDriver: PowerDriver = SimplePowerDriver(ConstantPowerModel(0.0)),
     private val mapper: SimWorkloadMapper = SimMetaWorkloadMapper(),
+    interferenceDomain: VmInterferenceDomain? = null
 ) : Host, FailureDomain, AutoCloseable {
-
-    public constructor(
-        uid: UUID,
-        name: String,
-        model: MachineModel,
-        meta: Map<String, Any>,
-        context: CoroutineContext,
-        interpreter: SimResourceInterpreter,
-        meter: Meter,
-        hypervisor: SimHypervisorProvider,
-        powerModel: PowerModel = ConstantPowerModel(0.0),
-        mapper: SimWorkloadMapper = SimMetaWorkloadMapper(),
-    ) : this(uid, name, model, meta, context, interpreter, meter, hypervisor, PerformanceScalingGovernor(), SimplePowerDriver(powerModel), mapper)
-
     /**
      * The [CoroutineScope] of the host bounded by the lifecycle of the host.
      */
@@ -102,13 +87,15 @@ public class SimHost(
     /**
      * The machine to run on.
      */
-    public val machine: SimBareMetalMachine = SimBareMetalMachine(interpreter, model, scalingDriver)
+    public val machine: SimBareMetalMachine = SimBareMetalMachine(interpreter, model, powerDriver)
 
     /**
      * The hypervisor to run multiple workloads.
      */
     public val hypervisor: SimHypervisor = hypervisor.create(
         interpreter,
+        scalingGovernor = scalingGovernor,
+        interferenceDomain = interferenceDomain,
         listener = object : SimHypervisor.Listener {
             override fun onSliceFinish(
                 hypervisor: SimHypervisor,
@@ -260,7 +247,7 @@ public class SimHost(
         }
 
         require(canFit(server)) { "Server does not fit" }
-        val guest = Guest(server, hypervisor.createMachine(server.flavor.toMachineModel()))
+        val guest = Guest(server, hypervisor.createMachine(server.flavor.toMachineModel(), server.name))
         guests[server] = guest
         _guests.add(1)
 
@@ -317,23 +304,11 @@ public class SimHost(
     }
 
     private fun onGuestStart(vm: Guest) {
-        guests.forEach { (_, guest) ->
-            if (guest.state == ServerState.RUNNING) {
-                vm.performanceInterferenceModel?.onStart(vm.server.image.name)
-            }
-        }
-
         _activeGuests.add(1)
         listeners.forEach { it.onStateChanged(this, vm.server, vm.state) }
     }
 
     private fun onGuestStop(vm: Guest) {
-        guests.forEach { (_, guest) ->
-            if (guest.state == ServerState.RUNNING) {
-                vm.performanceInterferenceModel?.onStop(vm.server.image.name)
-            }
-        }
-
         _activeGuests.add(-1)
         listeners.forEach { it.onStateChanged(this, vm.server, vm.state) }
     }
@@ -350,8 +325,6 @@ public class SimHost(
      * A virtual machine instance that the driver manages.
      */
     private inner class Guest(val server: Server, val machine: SimMachine) {
-        val performanceInterferenceModel: PerformanceInterferenceModel? = server.meta[IMAGE_PERF_INTERFERENCE_MODEL] as? PerformanceInterferenceModel?
-
         var state: ServerState = ServerState.TERMINATED
 
         suspend fun start() {
diff --git a/opendc-compute/opendc-compute-simulator/src/test/kotlin/org/opendc/compute/simulator/SimHostTest.kt b/opendc-compute/opendc-compute-simulator/src/test/kotlin/org/opendc/compute/simulator/SimHostTest.kt
index 5414d042..5a6fb03d 100644
--- a/opendc-compute/opendc-compute-simulator/src/test/kotlin/org/opendc/compute/simulator/SimHostTest.kt
+++ b/opendc-compute/opendc-compute-simulator/src/test/kotlin/org/opendc/compute/simulator/SimHostTest.kt
@@ -33,11 +33,7 @@ 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.api.Flavor
-import org.opendc.compute.api.Image
-import org.opendc.compute.api.Server
-import org.opendc.compute.api.ServerState
-import org.opendc.compute.api.ServerWatcher
+import org.opendc.compute.api.*
 import org.opendc.compute.service.driver.Host
 import org.opendc.compute.service.driver.HostListener
 import org.opendc.simulator.compute.kernel.SimFairShareHypervisorProvider
@@ -50,7 +46,7 @@ import org.opendc.simulator.core.runBlockingSimulation
 import org.opendc.simulator.resources.SimResourceInterpreter
 import org.opendc.telemetry.sdk.metrics.export.CoroutineMetricReader
 import org.opendc.telemetry.sdk.toOtelClock
-import java.util.UUID
+import java.util.*
 import kotlin.coroutines.resume
 
 /**
@@ -85,7 +81,16 @@ internal class SimHostTest {
             .build()
 
         val interpreter = SimResourceInterpreter(coroutineContext, clock)
-        val virtDriver = SimHost(UUID.randomUUID(), "test", machineModel, emptyMap(), coroutineContext, interpreter, meterProvider.get("opendc-compute-simulator"), SimFairShareHypervisorProvider())
+        val virtDriver = SimHost(
+            uid = UUID.randomUUID(),
+            name = "test",
+            model = machineModel,
+            meta = emptyMap(),
+            coroutineContext,
+            interpreter,
+            meterProvider.get("opendc-compute-simulator"),
+            SimFairShareHypervisorProvider()
+        )
         val duration = 5 * 60L
         val vmImageA = MockImage(
             UUID.randomUUID(),
diff --git a/opendc-experiments/opendc-experiments-capelin/src/main/kotlin/org/opendc/experiments/capelin/ExperimentHelpers.kt b/opendc-experiments/opendc-experiments-capelin/src/main/kotlin/org/opendc/experiments/capelin/ExperimentHelpers.kt
index 06251dd3..9548253d 100644
--- a/opendc-experiments/opendc-experiments-capelin/src/main/kotlin/org/opendc/experiments/capelin/ExperimentHelpers.kt
+++ b/opendc-experiments/opendc-experiments-capelin/src/main/kotlin/org/opendc/experiments/capelin/ExperimentHelpers.kt
@@ -44,6 +44,8 @@ import org.opendc.experiments.capelin.monitor.ExperimentMonitor
 import org.opendc.format.environment.EnvironmentReader
 import org.opendc.format.trace.TraceReader
 import org.opendc.simulator.compute.kernel.SimFairShareHypervisorProvider
+import org.opendc.simulator.compute.kernel.interference.VmInterferenceModel
+import org.opendc.simulator.compute.power.SimplePowerDriver
 import org.opendc.simulator.compute.workload.SimTraceWorkload
 import org.opendc.simulator.compute.workload.SimWorkload
 import org.opendc.simulator.failures.CorrelatedFaultInjector
@@ -123,6 +125,7 @@ suspend fun withComputeService(
     meterProvider: MeterProvider,
     environmentReader: EnvironmentReader,
     scheduler: ComputeScheduler,
+    interferenceModel: VmInterferenceModel? = null,
     block: suspend CoroutineScope.(ComputeService) -> Unit
 ): Unit = coroutineScope {
     val interpreter = SimResourceInterpreter(coroutineContext, clock)
@@ -138,7 +141,8 @@ suspend fun withComputeService(
                 interpreter,
                 meterProvider.get("opendc-compute-simulator"),
                 SimFairShareHypervisorProvider(),
-                def.powerModel
+                powerDriver = SimplePowerDriver(def.powerModel),
+                interferenceDomain = interferenceModel?.newDomain()
             )
         }
 
@@ -161,7 +165,6 @@ suspend fun withComputeService(
 /**
  * Attach the specified monitor to the VM provisioner.
  */
-@OptIn(ExperimentalCoroutinesApi::class)
 suspend fun withMonitor(
     monitor: ExperimentMonitor,
     clock: Clock,
diff --git a/opendc-experiments/opendc-experiments-capelin/src/main/kotlin/org/opendc/experiments/capelin/Portfolio.kt b/opendc-experiments/opendc-experiments-capelin/src/main/kotlin/org/opendc/experiments/capelin/Portfolio.kt
index 460da303..cbb5bfd9 100644
--- a/opendc-experiments/opendc-experiments-capelin/src/main/kotlin/org/opendc/experiments/capelin/Portfolio.kt
+++ b/opendc-experiments/opendc-experiments-capelin/src/main/kotlin/org/opendc/experiments/capelin/Portfolio.kt
@@ -39,11 +39,14 @@ import org.opendc.experiments.capelin.model.Topology
 import org.opendc.experiments.capelin.model.Workload
 import org.opendc.experiments.capelin.monitor.ParquetExperimentMonitor
 import org.opendc.experiments.capelin.trace.ParquetTraceReader
+import org.opendc.experiments.capelin.trace.PerformanceInterferenceReader
 import org.opendc.experiments.capelin.trace.RawParquetTraceReader
 import org.opendc.harness.dsl.Experiment
 import org.opendc.harness.dsl.anyOf
+import org.opendc.simulator.compute.kernel.interference.VmInterferenceModel
 import org.opendc.simulator.core.runBlockingSimulation
 import java.io.File
+import java.io.FileInputStream
 import java.util.*
 import java.util.concurrent.ConcurrentHashMap
 
@@ -119,6 +122,12 @@ abstract class Portfolio(name: String) : Experiment(name) {
             }
         }
 
+        val performanceInterferenceModel = if (operationalPhenomena.hasInterference)
+            PerformanceInterferenceReader(FileInputStream(config.getString("interference-model")))
+                .use { VmInterferenceModel(it.read(), Random(seeder.nextLong())) }
+        else
+            null
+
         val trace = ParquetTraceReader(rawReaders, workload, seeder.nextInt())
 
         val monitor = ParquetExperimentMonitor(
@@ -127,7 +136,7 @@ abstract class Portfolio(name: String) : Experiment(name) {
             4096
         )
 
-        withComputeService(clock, meterProvider, environment, allocationPolicy) { scheduler ->
+        withComputeService(clock, meterProvider, environment, allocationPolicy, performanceInterferenceModel) { scheduler ->
             val failureDomain = if (operationalPhenomena.failureFrequency > 0) {
                 logger.debug("ENABLING failures")
                 createFailureDomain(
diff --git a/opendc-experiments/opendc-experiments-capelin/src/main/kotlin/org/opendc/experiments/capelin/trace/ParquetTraceReader.kt b/opendc-experiments/opendc-experiments-capelin/src/main/kotlin/org/opendc/experiments/capelin/trace/ParquetTraceReader.kt
index 2ebe65ea..5ad75565 100644
--- a/opendc-experiments/opendc-experiments-capelin/src/main/kotlin/org/opendc/experiments/capelin/trace/ParquetTraceReader.kt
+++ b/opendc-experiments/opendc-experiments-capelin/src/main/kotlin/org/opendc/experiments/capelin/trace/ParquetTraceReader.kt
@@ -31,11 +31,11 @@ import org.opendc.simulator.compute.workload.SimWorkload
 /**
  * A [TraceReader] for the internal VM workload trace format.
  *
- * @param rawReaders The raw trace readers to use..
- * @param workload The workload to use.
- * @param seed The seed to use for workload sampling.
+ * @param rawReaders The internal raw trace readers to use.
+ * @param workload The workload to read.
+ * @param seed The seed to use for sampling.
  */
-class ParquetTraceReader(
+public class ParquetTraceReader(
     rawReaders: List<RawParquetTraceReader>,
     workload: Workload,
     seed: Int
diff --git a/opendc-experiments/opendc-experiments-capelin/src/main/kotlin/org/opendc/experiments/capelin/trace/PerformanceInterferenceReader.kt b/opendc-experiments/opendc-experiments-capelin/src/main/kotlin/org/opendc/experiments/capelin/trace/PerformanceInterferenceReader.kt
new file mode 100644
index 00000000..a19f5699
--- /dev/null
+++ b/opendc-experiments/opendc-experiments-capelin/src/main/kotlin/org/opendc/experiments/capelin/trace/PerformanceInterferenceReader.kt
@@ -0,0 +1,65 @@
+/*
+ * 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.experiments.capelin.trace
+
+import com.fasterxml.jackson.annotation.JsonProperty
+import com.fasterxml.jackson.databind.ObjectMapper
+import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper
+import com.fasterxml.jackson.module.kotlin.readValue
+import org.opendc.simulator.compute.kernel.interference.VmInterferenceGroup
+import java.io.InputStream
+
+/**
+ * A parser for the JSON performance interference setup files used for the TPDS article on Capelin.
+ *
+ * @param input The input stream to read from.
+ * @param mapper The Jackson object mapper to use.
+ */
+class PerformanceInterferenceReader(
+    private val input: InputStream,
+    private val mapper: ObjectMapper = jacksonObjectMapper()
+) : AutoCloseable {
+    init {
+        mapper.addMixIn(VmInterferenceGroup::class.java, GroupMixin::class.java)
+    }
+
+    /**
+     * Read the performance interface model from the input.
+     */
+    fun read(): List<VmInterferenceGroup> {
+        return mapper.readValue(input)
+    }
+
+    override fun close() {
+        input.close()
+    }
+
+    private data class GroupMixin(
+        @JsonProperty("minServerLoad")
+        val targetLoad: Double,
+        @JsonProperty("performanceScore")
+        val score: Double,
+        @JsonProperty("vms")
+        val members: Set<String>,
+    )
+}
diff --git a/opendc-experiments/opendc-experiments-capelin/src/main/kotlin/org/opendc/experiments/capelin/trace/VmPlacementReader.kt b/opendc-experiments/opendc-experiments-capelin/src/main/kotlin/org/opendc/experiments/capelin/trace/VmPlacementReader.kt
index fb641f1b..7a1683f0 100644
--- a/opendc-experiments/opendc-experiments-capelin/src/main/kotlin/org/opendc/experiments/capelin/trace/VmPlacementReader.kt
+++ b/opendc-experiments/opendc-experiments-capelin/src/main/kotlin/org/opendc/experiments/capelin/trace/VmPlacementReader.kt
@@ -28,7 +28,7 @@ import com.fasterxml.jackson.module.kotlin.readValue
 import java.io.InputStream
 
 /**
- * A parser for the JSON VM placement data files used for the SC20 paper.
+ * A parser for the JSON VM placement data files used for the TPDS article on Capelin.
  *
  * @param input The input stream to read from.
  * @param mapper The Jackson object mapper to use.
@@ -38,9 +38,9 @@ public class VmPlacementReader(
     private val mapper: ObjectMapper = jacksonObjectMapper()
 ) : AutoCloseable {
     /**
-     * Read the VM placements.
+     * Read the VM placements from the input.
      */
-    fun read(): Map<String, String> {
+    public fun read(): Map<String, String> {
         return mapper.readValue<Map<String, String>>(input)
             .mapKeys { "vm__workload__${it.key}.txt" }
             .mapValues { it.value.split("/")[1] } // Clusters have format XX0 / X00
diff --git a/opendc-experiments/opendc-experiments-capelin/src/test/kotlin/org/opendc/experiments/capelin/CapelinIntegrationTest.kt b/opendc-experiments/opendc-experiments-capelin/src/test/kotlin/org/opendc/experiments/capelin/CapelinIntegrationTest.kt
index beaa798f..08e04ddf 100644
--- a/opendc-experiments/opendc-experiments-capelin/src/test/kotlin/org/opendc/experiments/capelin/CapelinIntegrationTest.kt
+++ b/opendc-experiments/opendc-experiments-capelin/src/test/kotlin/org/opendc/experiments/capelin/CapelinIntegrationTest.kt
@@ -172,7 +172,7 @@ class CapelinIntegrationTest {
      * Obtain the environment reader for the test.
      */
     private fun createTestEnvironmentReader(name: String = "topology"): EnvironmentReader {
-        val stream = object {}.javaClass.getResourceAsStream("/env/$name.txt")
+        val stream = checkNotNull(object {}.javaClass.getResourceAsStream("/env/$name.txt"))
         return ClusterEnvironmentReader(stream)
     }
 
diff --git a/opendc-experiments/opendc-experiments-capelin/src/test/kotlin/org/opendc/experiments/capelin/trace/PerformanceInterferenceReaderTest.kt b/opendc-experiments/opendc-experiments-capelin/src/test/kotlin/org/opendc/experiments/capelin/trace/PerformanceInterferenceReaderTest.kt
new file mode 100644
index 00000000..9b1513dc
--- /dev/null
+++ b/opendc-experiments/opendc-experiments-capelin/src/test/kotlin/org/opendc/experiments/capelin/trace/PerformanceInterferenceReaderTest.kt
@@ -0,0 +1,47 @@
+/*
+ * 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.experiments.capelin.trace
+
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.assertAll
+
+/**
+ * Test suite for the [PerformanceInterferenceReader] class.
+ */
+class PerformanceInterferenceReaderTest {
+    @Test
+    fun testSmoke() {
+        val input = checkNotNull(PerformanceInterferenceReader::class.java.getResourceAsStream("/perf-interference.json"))
+        val reader = PerformanceInterferenceReader(input)
+
+        val result = reader.use { reader.read() }
+
+        assertAll(
+            { assertEquals(2, result.size) },
+            { assertEquals(setOf("vm_a", "vm_c", "vm_x", "vm_y"), result[0].members) },
+            { assertEquals(0.0, result[0].targetLoad, 0.001) },
+            { assertEquals(0.8830158730158756, result[0].score, 0.001) }
+        )
+    }
+}
diff --git a/opendc-experiments/opendc-experiments-capelin/src/test/resources/perf-interference.json b/opendc-experiments/opendc-experiments-capelin/src/test/resources/perf-interference.json
new file mode 100644
index 00000000..1be5852b
--- /dev/null
+++ b/opendc-experiments/opendc-experiments-capelin/src/test/resources/perf-interference.json
@@ -0,0 +1,22 @@
+[
+    {
+        "vms": [
+            "vm_a",
+            "vm_c",
+            "vm_x",
+            "vm_y"
+        ],
+        "minServerLoad": 0.0,
+        "performanceScore": 0.8830158730158756
+    },
+    {
+        "vms": [
+            "vm_a",
+            "vm_b",
+            "vm_c",
+            "vm_d"
+        ],
+        "minServerLoad": 0.0,
+        "performanceScore": 0.7133055555552751
+    }
+]
diff --git a/opendc-format/src/main/kotlin/org/opendc/format/trace/bitbrains/BitbrainsTraceReader.kt b/opendc-format/src/main/kotlin/org/opendc/format/trace/bitbrains/BitbrainsTraceReader.kt
index 769b2b13..aaf8a240 100644
--- a/opendc-format/src/main/kotlin/org/opendc/format/trace/bitbrains/BitbrainsTraceReader.kt
+++ b/opendc-format/src/main/kotlin/org/opendc/format/trace/bitbrains/BitbrainsTraceReader.kt
@@ -24,8 +24,6 @@ package org.opendc.format.trace.bitbrains
 
 import org.opendc.format.trace.TraceEntry
 import org.opendc.format.trace.TraceReader
-import org.opendc.simulator.compute.interference.IMAGE_PERF_INTERFERENCE_MODEL
-import org.opendc.simulator.compute.interference.PerformanceInterferenceModel
 import org.opendc.simulator.compute.workload.SimTraceWorkload
 import org.opendc.simulator.compute.workload.SimWorkload
 import java.io.BufferedReader
@@ -38,12 +36,8 @@ import kotlin.math.min
  * A [TraceReader] for the public VM workload trace format.
  *
  * @param traceDirectory The directory of the traces.
- * @param performanceInterferenceModel The performance model covering the workload in the VM trace.
  */
-public class BitbrainsTraceReader(
-    traceDirectory: File,
-    performanceInterferenceModel: PerformanceInterferenceModel
-) : TraceReader<SimWorkload> {
+public class BitbrainsTraceReader(traceDirectory: File) : TraceReader<SimWorkload> {
     /**
      * The internal iterator to use for this reader.
      */
@@ -123,12 +117,6 @@ public class BitbrainsTraceReader(
 
                 val uuid = UUID(0L, vmId)
 
-                val relevantPerformanceInterferenceModelItems =
-                    PerformanceInterferenceModel(
-                        performanceInterferenceModel.items.filter { it.workloadNames.contains(vmId.toString()) }
-                            .toSortedSet()
-                    )
-
                 val workload = SimTraceWorkload(flopsHistory.asSequence())
                 entries[vmId] = TraceEntry(
                     uuid,
@@ -136,7 +124,6 @@ public class BitbrainsTraceReader(
                     startTime,
                     workload,
                     mapOf(
-                        IMAGE_PERF_INTERFERENCE_MODEL to relevantPerformanceInterferenceModelItems,
                         "cores" to cores,
                         "required-memory" to requiredMemory,
                         "workload" to workload
diff --git a/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/interference/PerformanceInterferenceModel.kt b/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/interference/PerformanceInterferenceModel.kt
deleted file mode 100644
index 4c409887..00000000
--- a/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/interference/PerformanceInterferenceModel.kt
+++ /dev/null
@@ -1,134 +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.simulator.compute.interference
-
-import java.util.*
-import kotlin.random.Random
-
-/**
- * Meta-data key for the [PerformanceInterferenceModel] of an image.
- */
-public const val IMAGE_PERF_INTERFERENCE_MODEL: String = "image:performance-interference"
-
-/**
- * Performance Interference Model describing the variability incurred by different sets of workloads if colocated.
- *
- * @param items The [PerformanceInterferenceModel.Item]s that make up this model.
- */
-public class PerformanceInterferenceModel(
-    public val items: SortedSet<Item>,
-    private val random: Random = Random(0)
-) {
-    private var intersectingItems: List<Item> = emptyList()
-    private val colocatedWorkloads = TreeMap<String, Int>()
-
-    /**
-     * Indicate that a VM has started.
-     */
-    public fun onStart(name: String) {
-        colocatedWorkloads.merge(name, 1, Int::plus)
-        intersectingItems = items.filter { item -> doesMatch(item) }
-    }
-
-    /**
-     * Indicate that a VM has stopped.
-     */
-    public fun onStop(name: String) {
-        colocatedWorkloads.computeIfPresent(name) { _, v -> (v - 1).takeUnless { it == 0 } }
-        intersectingItems = items.filter { item -> doesMatch(item) }
-    }
-
-    /**
-     * Compute the performance interference based on the current server load.
-     */
-    public fun apply(currentServerLoad: Double): Double {
-        if (intersectingItems.isEmpty()) {
-            return 1.0
-        }
-        val score = intersectingItems
-            .firstOrNull { it.minServerLoad <= currentServerLoad }
-
-        // Apply performance penalty to (on average) only one of the VMs
-        return if (score != null && random.nextInt(score.workloadNames.size) == 0) {
-            score.performanceScore
-        } else {
-            1.0
-        }
-    }
-
-    private fun doesMatch(item: Item): Boolean {
-        var count = 0
-        for (
-            name in item.workloadNames.subSet(
-                colocatedWorkloads.firstKey(),
-                colocatedWorkloads.lastKey() + "\u0000"
-            )
-        ) {
-            count += colocatedWorkloads.getOrDefault(name, 0)
-            if (count > 1)
-                return true
-        }
-        return false
-    }
-
-    /**
-     * Model describing how a specific set of workloads causes performance variability for each workload.
-     *
-     * @param workloadNames The names of the workloads that together cause performance variability for each workload in the set.
-     * @param minServerLoad The minimum total server load at which this interference is activated and noticeable.
-     * @param performanceScore The performance score that should be applied to each workload's performance. 1 means no
-     * influence, <1 means that performance degrades, and >1 means that performance improves.
-     */
-    public data class Item(
-        public val workloadNames: SortedSet<String>,
-        public val minServerLoad: Double,
-        public val performanceScore: Double
-    ) : Comparable<Item> {
-        override fun equals(other: Any?): Boolean {
-            if (this === other) return true
-            if (javaClass != other?.javaClass) return false
-
-            other as Item
-
-            if (workloadNames != other.workloadNames) return false
-
-            return true
-        }
-
-        override fun hashCode(): Int = workloadNames.hashCode()
-
-        override fun compareTo(other: Item): Int {
-            var cmp = performanceScore.compareTo(other.performanceScore)
-            if (cmp != 0) {
-                return cmp
-            }
-
-            cmp = minServerLoad.compareTo(other.minServerLoad)
-            if (cmp != 0) {
-                return cmp
-            }
-
-            return hashCode().compareTo(other.hashCode())
-        }
-    }
-}
diff --git a/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/kernel/SimAbstractHypervisor.kt b/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/kernel/SimAbstractHypervisor.kt
index fb46dab4..d287312f 100644
--- a/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/kernel/SimAbstractHypervisor.kt
+++ b/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/kernel/SimAbstractHypervisor.kt
@@ -23,9 +23,9 @@
 package org.opendc.simulator.compute.kernel
 
 import org.opendc.simulator.compute.*
-import org.opendc.simulator.compute.interference.PerformanceInterferenceModel
 import org.opendc.simulator.compute.kernel.cpufreq.ScalingGovernor
 import org.opendc.simulator.compute.kernel.cpufreq.ScalingPolicy
+import org.opendc.simulator.compute.kernel.interference.VmInterferenceDomain
 import org.opendc.simulator.compute.model.MachineModel
 import org.opendc.simulator.compute.model.ProcessingUnit
 import org.opendc.simulator.resources.*
@@ -39,7 +39,8 @@ import org.opendc.simulator.resources.SimResourceSwitch
  */
 public abstract class SimAbstractHypervisor(
     private val interpreter: SimResourceInterpreter,
-    private val scalingGovernor: ScalingGovernor?
+    private val scalingGovernor: ScalingGovernor? = null,
+    protected val interferenceDomain: VmInterferenceDomain? = null
 ) : SimHypervisor {
     /**
      * The machine on which the hypervisor runs.
@@ -87,12 +88,9 @@ public abstract class SimAbstractHypervisor(
         return canFit(model, switch)
     }
 
-    override fun createMachine(
-        model: MachineModel,
-        performanceInterferenceModel: PerformanceInterferenceModel?
-    ): SimMachine {
+    override fun createMachine(model: MachineModel, interferenceId: String?): SimMachine {
         require(canFit(model)) { "Machine does not fit" }
-        val vm = VirtualMachine(model, performanceInterferenceModel)
+        val vm = VirtualMachine(model, interferenceId)
         _vms.add(vm)
         return vm
     }
@@ -116,17 +114,18 @@ public abstract class SimAbstractHypervisor(
     /**
      * A virtual machine running on the hypervisor.
      *
-     * @property model The machine model of the virtual machine.
-     * @property performanceInterferenceModel The performance interference model to utilize.
+     * @param model The machine model of the virtual machine.
      */
-    private inner class VirtualMachine(
-        model: MachineModel,
-        val performanceInterferenceModel: PerformanceInterferenceModel? = null,
-    ) : SimAbstractMachine(interpreter, parent = null, model) {
+    private inner class VirtualMachine(model: MachineModel, interferenceId: String? = null) : SimAbstractMachine(interpreter, parent = null, model) {
+        /**
+         * The interference key of this virtual machine.
+         */
+        private val interferenceKey = interferenceId?.let { interferenceDomain?.join(interferenceId) }
+
         /**
          * The vCPUs of the machine.
          */
-        override val cpus = model.cpus.map { VCpu(switch.newOutput(), it) }
+        override val cpus = model.cpus.map { VCpu(switch.newOutput(interferenceKey), it) }
 
         override fun close() {
             super.close()
@@ -136,6 +135,9 @@ public abstract class SimAbstractHypervisor(
             }
 
             _vms.remove(this)
+            if (interferenceKey != null) {
+                interferenceDomain?.leave(interferenceKey)
+            }
         }
     }
 
diff --git a/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/kernel/SimFairShareHypervisor.kt b/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/kernel/SimFairShareHypervisor.kt
index 2ce51ea6..17130d34 100644
--- a/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/kernel/SimFairShareHypervisor.kt
+++ b/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/kernel/SimFairShareHypervisor.kt
@@ -22,8 +22,10 @@
 
 package org.opendc.simulator.compute.kernel
 
+import org.opendc.simulator.compute.SimMachine
 import org.opendc.simulator.compute.SimMachineContext
 import org.opendc.simulator.compute.kernel.cpufreq.ScalingGovernor
+import org.opendc.simulator.compute.kernel.interference.VmInterferenceDomain
 import org.opendc.simulator.compute.model.MachineModel
 import org.opendc.simulator.compute.workload.SimWorkload
 import org.opendc.simulator.resources.SimResourceInterpreter
@@ -32,20 +34,22 @@ import org.opendc.simulator.resources.SimResourceSwitchMaxMin
 import org.opendc.simulator.resources.SimResourceSystem
 
 /**
- * A [SimHypervisor] that distributes the computing requirements of multiple [SimWorkload] on a single
- * [SimBareMetalMachine] concurrently using weighted fair sharing.
+ * A [SimHypervisor] that distributes the computing requirements of multiple [SimWorkload]s on a single [SimMachine]
+ * concurrently using weighted fair sharing.
  *
  * @param interpreter The interpreter to manage the machine's resources.
  * @param parent The parent simulation system.
  * @param scalingGovernor The CPU frequency scaling governor to use for the hypervisor.
+ * @param interferenceDomain The resource interference domain to which the hypervisor belongs.
  * @param listener The hypervisor listener to use.
  */
 public class SimFairShareHypervisor(
     private val interpreter: SimResourceInterpreter,
     private val parent: SimResourceSystem? = null,
     scalingGovernor: ScalingGovernor? = null,
+    interferenceDomain: VmInterferenceDomain? = null,
     private val listener: SimHypervisor.Listener? = null
-) : SimAbstractHypervisor(interpreter, scalingGovernor) {
+) : SimAbstractHypervisor(interpreter, scalingGovernor, interferenceDomain) {
 
     override fun canFit(model: MachineModel, switch: SimResourceSwitch): Boolean = true
 
@@ -54,7 +58,7 @@ public class SimFairShareHypervisor(
     }
 
     private inner class SwitchSystem(private val ctx: SimMachineContext) : SimResourceSystem {
-        val switch = SimResourceSwitchMaxMin(interpreter, this)
+        val switch = SimResourceSwitchMaxMin(interpreter, this, interferenceDomain)
 
         override val parent: SimResourceSystem? = this@SimFairShareHypervisor.parent
 
diff --git a/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/kernel/SimFairShareHypervisorProvider.kt b/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/kernel/SimFairShareHypervisorProvider.kt
index 542cd0d2..8d0592ec 100644
--- a/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/kernel/SimFairShareHypervisorProvider.kt
+++ b/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/kernel/SimFairShareHypervisorProvider.kt
@@ -22,6 +22,8 @@
 
 package org.opendc.simulator.compute.kernel
 
+import org.opendc.simulator.compute.kernel.cpufreq.ScalingGovernor
+import org.opendc.simulator.compute.kernel.interference.VmInterferenceDomain
 import org.opendc.simulator.resources.SimResourceInterpreter
 import org.opendc.simulator.resources.SimResourceSystem
 
@@ -34,6 +36,14 @@ public class SimFairShareHypervisorProvider : SimHypervisorProvider {
     override fun create(
         interpreter: SimResourceInterpreter,
         parent: SimResourceSystem?,
+        scalingGovernor: ScalingGovernor?,
+        interferenceDomain: VmInterferenceDomain?,
         listener: SimHypervisor.Listener?
-    ): SimHypervisor = SimFairShareHypervisor(interpreter, parent, listener = listener)
+    ): SimHypervisor = SimFairShareHypervisor(
+        interpreter,
+        parent,
+        scalingGovernor = scalingGovernor,
+        interferenceDomain = interferenceDomain,
+        listener = listener
+    )
 }
diff --git a/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/kernel/SimHypervisor.kt b/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/kernel/SimHypervisor.kt
index 40402f5c..e398ab36 100644
--- a/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/kernel/SimHypervisor.kt
+++ b/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/kernel/SimHypervisor.kt
@@ -23,13 +23,12 @@
 package org.opendc.simulator.compute.kernel
 
 import org.opendc.simulator.compute.SimMachine
-import org.opendc.simulator.compute.interference.PerformanceInterferenceModel
 import org.opendc.simulator.compute.model.MachineModel
 import org.opendc.simulator.compute.workload.SimWorkload
 
 /**
  * A SimHypervisor facilitates the execution of multiple concurrent [SimWorkload]s, while acting as a single workload
- * to a [SimBareMetalMachine].
+ * to another [SimMachine].
  */
 public interface SimHypervisor : SimWorkload {
     /**
@@ -46,12 +45,9 @@ public interface SimHypervisor : SimWorkload {
      * Create a [SimMachine] instance on which users may run a [SimWorkload].
      *
      * @param model The machine to create.
-     * @param performanceInterferenceModel The performance interference model to use.
+     * @param interferenceId An identifier for the interference model.
      */
-    public fun createMachine(
-        model: MachineModel,
-        performanceInterferenceModel: PerformanceInterferenceModel? = null
-    ): SimMachine
+    public fun createMachine(model: MachineModel, interferenceId: String? = null): SimMachine
 
     /**
      * Event listener for hypervisor events.
diff --git a/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/kernel/SimHypervisorProvider.kt b/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/kernel/SimHypervisorProvider.kt
index cafd1ffc..b307a34d 100644
--- a/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/kernel/SimHypervisorProvider.kt
+++ b/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/kernel/SimHypervisorProvider.kt
@@ -22,6 +22,8 @@
 
 package org.opendc.simulator.compute.kernel
 
+import org.opendc.simulator.compute.kernel.cpufreq.ScalingGovernor
+import org.opendc.simulator.compute.kernel.interference.VmInterferenceDomain
 import org.opendc.simulator.resources.SimResourceInterpreter
 import org.opendc.simulator.resources.SimResourceSystem
 
@@ -43,6 +45,8 @@ public interface SimHypervisorProvider {
     public fun create(
         interpreter: SimResourceInterpreter,
         parent: SimResourceSystem? = null,
+        scalingGovernor: ScalingGovernor? = null,
+        interferenceDomain: VmInterferenceDomain? = null,
         listener: SimHypervisor.Listener? = null
     ): SimHypervisor
 }
diff --git a/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/kernel/SimSpaceSharedHypervisor.kt b/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/kernel/SimSpaceSharedHypervisor.kt
index 3ceebb9a..ac1c0250 100644
--- a/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/kernel/SimSpaceSharedHypervisor.kt
+++ b/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/kernel/SimSpaceSharedHypervisor.kt
@@ -31,7 +31,7 @@ import org.opendc.simulator.resources.SimResourceSwitchExclusive
 /**
  * A [SimHypervisor] that allocates its sub-resources exclusively for the virtual machine that it hosts.
  */
-public class SimSpaceSharedHypervisor(interpreter: SimResourceInterpreter) : SimAbstractHypervisor(interpreter, null) {
+public class SimSpaceSharedHypervisor(interpreter: SimResourceInterpreter) : SimAbstractHypervisor(interpreter) {
     override fun canFit(model: MachineModel, switch: SimResourceSwitch): Boolean {
         return switch.inputs.size - switch.outputs.size >= model.cpus.size
     }
diff --git a/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/kernel/SimSpaceSharedHypervisorProvider.kt b/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/kernel/SimSpaceSharedHypervisorProvider.kt
index fb47d9e5..3906cb9a 100644
--- a/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/kernel/SimSpaceSharedHypervisorProvider.kt
+++ b/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/kernel/SimSpaceSharedHypervisorProvider.kt
@@ -22,6 +22,8 @@
 
 package org.opendc.simulator.compute.kernel
 
+import org.opendc.simulator.compute.kernel.cpufreq.ScalingGovernor
+import org.opendc.simulator.compute.kernel.interference.VmInterferenceDomain
 import org.opendc.simulator.resources.SimResourceInterpreter
 import org.opendc.simulator.resources.SimResourceSystem
 
@@ -34,6 +36,8 @@ public class SimSpaceSharedHypervisorProvider : SimHypervisorProvider {
     override fun create(
         interpreter: SimResourceInterpreter,
         parent: SimResourceSystem?,
+        scalingGovernor: ScalingGovernor?,
+        interferenceDomain: VmInterferenceDomain?,
         listener: SimHypervisor.Listener?
     ): SimHypervisor = SimSpaceSharedHypervisor(interpreter)
 }
diff --git a/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/kernel/interference/VmInterferenceDomain.kt b/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/kernel/interference/VmInterferenceDomain.kt
new file mode 100644
index 00000000..1801fcd0
--- /dev/null
+++ b/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/kernel/interference/VmInterferenceDomain.kt
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2021 AtLarge Research
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package org.opendc.simulator.compute.kernel.interference
+
+import org.opendc.simulator.resources.interference.InterferenceDomain
+import org.opendc.simulator.resources.interference.InterferenceKey
+
+/**
+ * The interference domain of a hypervisor.
+ */
+public interface VmInterferenceDomain : InterferenceDomain {
+    /**
+     * Join this interference domain.
+     *
+     * @param id The identifier of the virtual machine.
+     */
+    public fun join(id: String): InterferenceKey
+
+    /**
+     * Leave this interference domain.
+     */
+    public fun leave(key: InterferenceKey)
+}
diff --git a/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/kernel/interference/VmInterferenceGroup.kt b/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/kernel/interference/VmInterferenceGroup.kt
new file mode 100644
index 00000000..708ddede
--- /dev/null
+++ b/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/kernel/interference/VmInterferenceGroup.kt
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) 2021 AtLarge Research
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package org.opendc.simulator.compute.kernel.interference
+
+/**
+ * A group of virtual machines that together can interfere when operating on the same resources, causing performance
+ * variability.
+ */
+public data class VmInterferenceGroup(
+    /**
+     * The minimum load of the host before the interference occurs.
+     */
+    public val targetLoad: Double,
+
+    /**
+     * A score in [0, 1] representing the performance variability as a result of resource interference.
+     */
+    public val score: Double,
+
+    /**
+     * The members of this interference group.
+     */
+    public val members: Set<String>
+)
diff --git a/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/kernel/interference/VmInterferenceModel.kt b/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/kernel/interference/VmInterferenceModel.kt
new file mode 100644
index 00000000..c2e00c8e
--- /dev/null
+++ b/opendc-simulator/opendc-simulator-compute/src/main/kotlin/org/opendc/simulator/compute/kernel/interference/VmInterferenceModel.kt
@@ -0,0 +1,170 @@
+/*
+ * Copyright (c) 2021 AtLarge Research
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package org.opendc.simulator.compute.kernel.interference
+
+import org.opendc.simulator.resources.interference.InterferenceKey
+import java.util.*
+
+/**
+ * An interference model that models the resource interference between virtual machines on a host.
+ *
+ * @param groups The groups of virtual machines that interfere with each other.
+ * @param random The [Random] instance to select the affected virtual machines.
+ */
+public class VmInterferenceModel(
+    private val groups: List<VmInterferenceGroup>,
+    private val random: Random = Random(0)
+) {
+    /**
+     * Construct a new [VmInterferenceDomain].
+     */
+    public fun newDomain(): VmInterferenceDomain = object : VmInterferenceDomain {
+        /**
+         * The stateful groups of this domain.
+         */
+        private val groups = this@VmInterferenceModel.groups.map { GroupContext(it) }
+
+        /**
+         * The set of keys active in this domain.
+         */
+        private val keys = mutableSetOf<InterferenceKeyImpl>()
+
+        override fun join(id: String): InterferenceKey {
+            val key = InterferenceKeyImpl(id, groups.filter { id in it }.sortedBy { it.group.targetLoad })
+            keys += key
+            return key
+        }
+
+        override fun leave(key: InterferenceKey) {
+            if (key is InterferenceKeyImpl) {
+                keys -= key
+                key.leave()
+            }
+        }
+
+        override fun apply(key: InterferenceKey?, load: Double): Double {
+            if (key == null || key !is InterferenceKeyImpl) {
+                return 1.0
+            }
+
+            val ctx = key.findGroup(load)
+            val group = ctx?.group
+
+            // Apply performance penalty to (on average) only one of the VMs
+            return if (group != null && random.nextInt(group.members.size) == 0) {
+                group.score
+            } else {
+                1.0
+            }
+        }
+
+        override fun toString(): String = "VmInterferenceDomain"
+    }
+
+    /**
+     * An interference key.
+     *
+     * @param id The identifier of the member.
+     * @param groups The groups to which the key belongs.
+     */
+    private inner class InterferenceKeyImpl(val id: String, private val groups: List<GroupContext>) : InterferenceKey {
+        init {
+            for (group in groups) {
+                group.join(this)
+            }
+        }
+
+        /**
+         * Find the active group that applies for the interference member.
+         */
+        fun findGroup(load: Double): GroupContext? {
+            // Find the first active group whose target load is lower than the current load
+            val index = groups.binarySearchBy(load) { it.group.targetLoad }
+            val target = if (index >= 0) index else -(index + 1)
+
+            // Check whether there are active groups ahead of the index
+            for (i in target until groups.size) {
+                val group = groups[i]
+                if (group.group.targetLoad > load) {
+                    break
+                } else if (group.isActive) {
+                    return group
+                }
+            }
+
+            // Check whether there are active groups before the index
+            for (i in (target - 1) downTo 0) {
+                val group = groups[i]
+                if (group.isActive) {
+                    return group
+                }
+            }
+
+            return null
+        }
+
+        /**
+         * Leave all the groups.
+         */
+        fun leave() {
+            for (group in groups) {
+                group.leave(this)
+            }
+        }
+    }
+
+    /**
+     * A group context is used to track the active keys per interference group.
+     */
+    private inner class GroupContext(val group: VmInterferenceGroup) {
+        /**
+         * The active keys that are part of this group.
+         */
+        private val keys = mutableSetOf<InterferenceKeyImpl>()
+
+        /**
+         * A flag to indicate that the group is active.
+         */
+        val isActive
+            get() = keys.size > 1
+
+        /**
+         * Determine whether the specified [id] is part of this group.
+         */
+        operator fun contains(id: String): Boolean = id in group.members
+
+        /**
+         * Join this group with the specified [key].
+         */
+        fun join(key: InterferenceKeyImpl) {
+            keys += key
+        }
+
+        /**
+         * Leave this group with the specified [key].
+         */
+        fun leave(key: InterferenceKeyImpl) {
+            keys -= key
+        }
+    }
+}
diff --git a/opendc-simulator/opendc-simulator-compute/src/test/kotlin/org/opendc/simulator/compute/SimMachineTest.kt b/opendc-simulator/opendc-simulator-compute/src/test/kotlin/org/opendc/simulator/compute/SimMachineTest.kt
index 892d5223..a6d955ca 100644
--- a/opendc-simulator/opendc-simulator-compute/src/test/kotlin/org/opendc/simulator/compute/SimMachineTest.kt
+++ b/opendc-simulator/opendc-simulator-compute/src/test/kotlin/org/opendc/simulator/compute/SimMachineTest.kt
@@ -24,12 +24,9 @@ package org.opendc.simulator.compute
 
 import kotlinx.coroutines.*
 import kotlinx.coroutines.flow.toList
+import org.junit.jupiter.api.*
 import org.junit.jupiter.api.Assertions.assertArrayEquals
 import org.junit.jupiter.api.Assertions.assertEquals
-import org.junit.jupiter.api.BeforeEach
-import org.junit.jupiter.api.Test
-import org.junit.jupiter.api.assertDoesNotThrow
-import org.junit.jupiter.api.assertThrows
 import org.opendc.simulator.compute.device.SimNetworkAdapter
 import org.opendc.simulator.compute.model.*
 import org.opendc.simulator.compute.power.ConstantPowerModel
@@ -157,8 +154,10 @@ class SimMachineTest {
         try {
             coroutineScope {
                 launch { machine.run(SimFlopsWorkload(2_000, utilization = 1.0)) }
-                assertEquals(100.0, machine.psu.powerDraw)
-                assertEquals(100.0, source.powerDraw)
+                assertAll(
+                    { assertEquals(100.0, machine.psu.powerDraw) },
+                    { assertEquals(100.0, source.powerDraw) }
+                )
             }
         } finally {
             machine.close()
@@ -284,6 +283,7 @@ class SimMachineTest {
         }
     }
 
+    @Test
     fun testDiskWriteUsage() = runBlockingSimulation {
         val interpreter = SimResourceInterpreter(coroutineContext, clock)
         val machine = SimBareMetalMachine(
diff --git a/opendc-simulator/opendc-simulator-compute/src/test/kotlin/org/opendc/simulator/compute/kernel/SimHypervisorTest.kt b/opendc-simulator/opendc-simulator-compute/src/test/kotlin/org/opendc/simulator/compute/kernel/SimHypervisorTest.kt
index 71d48a31..a61cba8d 100644
--- a/opendc-simulator/opendc-simulator-compute/src/test/kotlin/org/opendc/simulator/compute/kernel/SimHypervisorTest.kt
+++ b/opendc-simulator/opendc-simulator-compute/src/test/kotlin/org/opendc/simulator/compute/kernel/SimHypervisorTest.kt
@@ -34,6 +34,8 @@ import org.junit.jupiter.api.assertAll
 import org.junit.jupiter.api.assertDoesNotThrow
 import org.opendc.simulator.compute.SimBareMetalMachine
 import org.opendc.simulator.compute.kernel.cpufreq.PerformanceScalingGovernor
+import org.opendc.simulator.compute.kernel.interference.VmInterferenceGroup
+import org.opendc.simulator.compute.kernel.interference.VmInterferenceModel
 import org.opendc.simulator.compute.model.MachineModel
 import org.opendc.simulator.compute.model.MemoryUnit
 import org.opendc.simulator.compute.model.ProcessingNode
@@ -223,4 +225,63 @@ internal class SimHypervisorTest {
 
         machine.close()
     }
+
+    @Test
+    fun testInterference() = runBlockingSimulation {
+        val cpuNode = ProcessingNode("Intel", "Xeon", "amd64", 2)
+        val model = MachineModel(
+            cpus = List(cpuNode.coreCount) { ProcessingUnit(cpuNode, it, 3200.0) },
+            memory = List(4) { MemoryUnit("Crucial", "MTA18ASF4G72AZ-3G2B1", 3200.0, 32_000) }
+        )
+
+        val groups = listOf(
+            VmInterferenceGroup(targetLoad = 0.0, score = 0.9, members = setOf("a", "b")),
+            VmInterferenceGroup(targetLoad = 0.0, score = 0.6, members = setOf("a", "c")),
+            VmInterferenceGroup(targetLoad = 0.1, score = 0.8, members = setOf("a", "n"))
+        )
+        val interferenceModel = VmInterferenceModel(groups)
+
+        val platform = SimResourceInterpreter(coroutineContext, clock)
+        val machine = SimBareMetalMachine(
+            platform, model, SimplePowerDriver(ConstantPowerModel(0.0))
+        )
+        val hypervisor = SimFairShareHypervisor(platform, interferenceDomain = interferenceModel.newDomain())
+
+        val duration = 5 * 60L
+        val workloadA =
+            SimTraceWorkload(
+                sequenceOf(
+                    SimTraceWorkload.Fragment(duration * 1000, 0.0, 1),
+                    SimTraceWorkload.Fragment(duration * 1000, 28.0, 1),
+                    SimTraceWorkload.Fragment(duration * 1000, 3500.0, 1),
+                    SimTraceWorkload.Fragment(duration * 1000, 183.0, 1)
+                ),
+            )
+        val workloadB =
+            SimTraceWorkload(
+                sequenceOf(
+                    SimTraceWorkload.Fragment(duration * 1000, 0.0, 1),
+                    SimTraceWorkload.Fragment(duration * 1000, 28.0, 1),
+                    SimTraceWorkload.Fragment(duration * 1000, 3100.0, 1),
+                    SimTraceWorkload.Fragment(duration * 1000, 73.0, 1)
+                )
+            )
+
+        launch {
+            machine.run(hypervisor)
+        }
+
+        coroutineScope {
+            launch {
+                val vm = hypervisor.createMachine(model, "a")
+                vm.run(workloadA)
+                vm.close()
+            }
+            val vm = hypervisor.createMachine(model, "b")
+            vm.run(workloadB)
+            vm.close()
+        }
+
+        machine.close()
+    }
 }
diff --git a/opendc-web/opendc-web-runner/src/main/kotlin/org/opendc/runner/web/Main.kt b/opendc-web/opendc-web-runner/src/main/kotlin/org/opendc/runner/web/Main.kt
index f5d0b65e..d0b97d90 100644
--- a/opendc-web/opendc-web-runner/src/main/kotlin/org/opendc/runner/web/Main.kt
+++ b/opendc-web/opendc-web-runner/src/main/kotlin/org/opendc/runner/web/Main.kt
@@ -48,12 +48,15 @@ import org.opendc.compute.service.scheduler.weights.*
 import org.opendc.experiments.capelin.*
 import org.opendc.experiments.capelin.model.Workload
 import org.opendc.experiments.capelin.trace.ParquetTraceReader
+import org.opendc.experiments.capelin.trace.PerformanceInterferenceReader
 import org.opendc.experiments.capelin.trace.RawParquetTraceReader
 import org.opendc.format.environment.EnvironmentReader
+import org.opendc.simulator.compute.kernel.interference.VmInterferenceModel
 import org.opendc.simulator.core.runBlockingSimulation
 import org.opendc.telemetry.sdk.toOtelClock
 import java.io.File
 import kotlin.random.Random
+import kotlin.random.asJavaRandom
 
 private val logger = KotlinLogging.logger {}
 
@@ -61,7 +64,7 @@ private val logger = KotlinLogging.logger {}
  * Represents the CLI command for starting the OpenDC web runner.
  */
 @OptIn(ExperimentalCoroutinesApi::class)
-public class RunnerCli : CliktCommand(name = "runner") {
+class RunnerCli : CliktCommand(name = "runner") {
     /**
      * The name of the database to use.
      */
@@ -167,14 +170,27 @@ public class RunnerCli : CliktCommand(name = "runner") {
             scenario.getEmbedded(listOf("trace", "traceId"), String::class.java)
         )
         val traceReader = RawParquetTraceReader(traceDir)
+        val interferenceGroups = let {
+            val path = File(traceDir, "performance-interference-model.json")
+            val operational = scenario.get("operational", Document::class.java)
+            val enabled = operational.getBoolean("performanceInterferenceEnabled")
+
+            if (!enabled || !path.exists()) {
+                return@let null
+            }
+
+            PerformanceInterferenceReader(path.inputStream()).use { reader -> reader.read() }
+        }
+
         val targets = portfolio.get("targets", Document::class.java)
         val topologyId = scenario.getEmbedded(listOf("topology", "topologyId"), ObjectId::class.java)
         val environment = topologyParser.read(topologyId)
 
-        val results = (0 until targets.getInteger("repeatsPerScenario")).map {
-            logger.info { "Starting repeat $it" }
+        val results = (0 until targets.getInteger("repeatsPerScenario")).map { repeat ->
+            logger.info { "Starting repeat $repeat" }
             withTimeout(runTimeout * 1000) {
-                runRepeat(scenario, it, environment, traceReader)
+                val interferenceModel = interferenceGroups?.let { VmInterferenceModel(it, Random(repeat.toLong()).asJavaRandom()) }
+                runRepeat(scenario, repeat, environment, traceReader, interferenceModel)
             }
         }
 
@@ -191,6 +207,7 @@ public class RunnerCli : CliktCommand(name = "runner") {
         repeat: Int,
         environment: EnvironmentReader,
         traceReader: RawParquetTraceReader,
+        interferenceModel: VmInterferenceModel?
     ): WebExperimentMonitor.Result {
         val monitor = WebExperimentMonitor()
 
@@ -260,7 +277,7 @@ public class RunnerCli : CliktCommand(name = "runner") {
                 )
                 val failureFrequency = if (operational.getBoolean("failuresEnabled", false)) 24.0 * 7 else 0.0
 
-                withComputeService(clock, meterProvider, environment, allocationPolicy) { scheduler ->
+                withComputeService(clock, meterProvider, environment, allocationPolicy, interferenceModel) { scheduler ->
                     val failureDomain = if (failureFrequency > 0) {
                         logger.debug { "ENABLING failures" }
                         createFailureDomain(
@@ -361,4 +378,4 @@ public class RunnerCli : CliktCommand(name = "runner") {
 /**
  * Main entry point of the runner.
  */
-public fun main(args: Array<String>): Unit = RunnerCli().main(args)
+fun main(args: Array<String>): Unit = RunnerCli().main(args)
diff --git a/opendc-workflow/opendc-workflow-service/src/test/kotlin/org/opendc/workflow/service/WorkflowServiceIntegrationTest.kt b/opendc-workflow/opendc-workflow-service/src/test/kotlin/org/opendc/workflow/service/WorkflowServiceIntegrationTest.kt
index 413112af..38c774a9 100644
--- a/opendc-workflow/opendc-workflow-service/src/test/kotlin/org/opendc/workflow/service/WorkflowServiceIntegrationTest.kt
+++ b/opendc-workflow/opendc-workflow-service/src/test/kotlin/org/opendc/workflow/service/WorkflowServiceIntegrationTest.kt
@@ -25,7 +25,6 @@ package org.opendc.workflow.service
 import io.opentelemetry.api.metrics.MeterProvider
 import io.opentelemetry.sdk.metrics.SdkMeterProvider
 import io.opentelemetry.sdk.metrics.export.MetricProducer
-import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.coroutineScope
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.launch
@@ -57,7 +56,6 @@ import kotlin.math.max
  * Integration test suite for the [WorkflowServiceImpl].
  */
 @DisplayName("WorkflowServiceImpl")
-@OptIn(ExperimentalCoroutinesApi::class)
 internal class WorkflowServiceIntegrationTest {
     /**
      * A large integration test where we check whether all tasks in some trace are executed correctly.
@@ -70,7 +68,7 @@ internal class WorkflowServiceIntegrationTest {
             .build()
 
         val interpreter = SimResourceInterpreter(coroutineContext, clock)
-        val hosts = Sc18EnvironmentReader(object {}.javaClass.getResourceAsStream("/environment.json"))
+        val hosts = Sc18EnvironmentReader(checkNotNull(object {}.javaClass.getResourceAsStream("/environment.json")))
             .use { it.read() }
             .map { def ->
                 SimHost(
@@ -106,7 +104,7 @@ internal class WorkflowServiceIntegrationTest {
             taskOrderPolicy = SubmissionTimeTaskOrderPolicy(),
         )
 
-        val reader = GwfTraceReader(object {}.javaClass.getResourceAsStream("/trace.gwf"))
+        val reader = GwfTraceReader(checkNotNull(object {}.javaClass.getResourceAsStream("/trace.gwf")))
         var offset = Long.MIN_VALUE
 
         coroutineScope {