simulator: Support perf interference in uniform resource model

This pull request re-implements the performance interference model to integrate 
with the uniform resource model in OpenDC. This forms the basis for other forms 
of resource interference (e.g., network or disk).

* Add interface for resource interference in uniform resource 
   model (`opendc-simulator-resources`)
* Remove dependency on performance interference model from trace readers
* Re-implement the performance interference model on top of the interface 
   in the uniform resource model.


**Breaking API Changes**

* The original performance interference model classes are removed
* The SC20 trace and environment related readers have moved to the Capelin experiments module.
* Changes to the interfaces in `opendc-format`.

Implements #103

1 files changed, 18 insertions, 17 deletions

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 09f7de35..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
@@ -47,14 +47,16 @@ import org.opendc.compute.service.scheduler.filters.ComputeFilter
 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.Sc20ParquetTraceReader
-import org.opendc.experiments.capelin.trace.Sc20RawParquetTraceReader
+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.format.trace.sc20.Sc20PerformanceInterferenceReader
+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 {}
 
@@ -62,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,8 +169,8 @@ public class RunnerCli : CliktCommand(name = "runner") {
             tracePath,
             scenario.getEmbedded(listOf("trace", "traceId"), String::class.java)
         )
-        val traceReader = Sc20RawParquetTraceReader(traceDir)
-        val performanceInterferenceReader = let {
+        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")
@@ -177,17 +179,18 @@ public class RunnerCli : CliktCommand(name = "runner") {
                 return@let null
             }
 
-            path.inputStream().use { Sc20PerformanceInterferenceReader(it) }
+            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, performanceInterferenceReader)
+                val interferenceModel = interferenceGroups?.let { VmInterferenceModel(it, Random(repeat.toLong()).asJavaRandom()) }
+                runRepeat(scenario, repeat, environment, traceReader, interferenceModel)
             }
         }
 
@@ -203,8 +206,8 @@ public class RunnerCli : CliktCommand(name = "runner") {
         scenario: Document,
         repeat: Int,
         environment: EnvironmentReader,
-        traceReader: Sc20RawParquetTraceReader,
-        performanceInterferenceReader: Sc20PerformanceInterferenceReader?
+        traceReader: RawParquetTraceReader,
+        interferenceModel: VmInterferenceModel?
     ): WebExperimentMonitor.Result {
         val monitor = WebExperimentMonitor()
 
@@ -267,16 +270,14 @@ public class RunnerCli : CliktCommand(name = "runner") {
                         else -> throw IllegalArgumentException("Unknown policy $policyName")
                     }
 
-                val performanceInterferenceModel = performanceInterferenceReader?.construct(seeder) ?: emptyMap()
-                val trace = Sc20ParquetTraceReader(
+                val trace = ParquetTraceReader(
                     listOf(traceReader),
-                    performanceInterferenceModel,
                     Workload(workloadName, workloadFraction),
                     seed
                 )
                 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(
@@ -377,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)