Migrate OpenDC SC20 experiments to experiment harness

This change refactors the SC20 experiments in OpenDC to use the
standalone experiment harness as opposed to its built-in ad-hoc
experiment framework.

25 files changed, 534 insertions, 1306 deletions

diff --git a/simulator/opendc-experiments/opendc-experiments-sc20/build.gradle.kts b/simulator/opendc-experiments/opendc-experiments-sc20/build.gradle.kts
index 3b682668..b94207ba 100644
--- a/simulator/opendc-experiments/opendc-experiments-sc20/build.gradle.kts
+++ b/simulator/opendc-experiments/opendc-experiments-sc20/build.gradle.kts
@@ -29,21 +29,22 @@ plugins {
 }
 
 application {
-    mainClassName = "org.opendc.experiments.sc20.MainKt"
+    mainClass.set("org.opendc.harness.runner.console.ConsoleRunnerKt")
     applicationDefaultJvmArgs = listOf("-Xms2500M")
 }
 
 dependencies {
     api(project(":opendc-core"))
+    api(project(":opendc-harness"))
     implementation(project(":opendc-format"))
     implementation(project(":opendc-simulator:opendc-simulator-core"))
     implementation(project(":opendc-simulator:opendc-simulator-compute"))
     implementation(project(":opendc-simulator:opendc-simulator-failures"))
     implementation(project(":opendc-compute:opendc-compute-simulator"))
 
-    implementation("com.github.ajalt:clikt:2.6.0")
-    implementation("me.tongfei:progressbar:0.8.1")
-    implementation("io.github.microutils:kotlin-logging:1.7.9")
+    implementation("io.github.microutils:kotlin-logging:2.0.4")
+    implementation("me.tongfei:progressbar:0.9.0")
+    implementation("com.github.ajalt.clikt:clikt:3.1.0")
 
     implementation("org.apache.parquet:parquet-avro:1.11.0")
     implementation("org.apache.hadoop:hadoop-client:3.2.1") {
@@ -51,8 +52,6 @@ dependencies {
         exclude(group = "log4j")
     }
 
-    runtimeOnly("org.apache.logging.log4j:log4j-slf4j-impl:2.13.1")
-
     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-experiments/opendc-experiments-sc20/src/main/kotlin/org/opendc/experiments/sc20/Main.kt b/simulator/opendc-experiments/opendc-experiments-sc20/src/main/kotlin/org/opendc/experiments/sc20/Main.kt
deleted file mode 100644
index 8916261b..00000000
--- a/simulator/opendc-experiments/opendc-experiments-sc20/src/main/kotlin/org/opendc/experiments/sc20/Main.kt
+++ /dev/null
@@ -1,159 +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.experiments.sc20
-
-import com.github.ajalt.clikt.core.CliktCommand
-import com.github.ajalt.clikt.parameters.options.convert
-import com.github.ajalt.clikt.parameters.options.default
-import com.github.ajalt.clikt.parameters.options.defaultLazy
-import com.github.ajalt.clikt.parameters.options.multiple
-import com.github.ajalt.clikt.parameters.options.option
-import com.github.ajalt.clikt.parameters.options.required
-import com.github.ajalt.clikt.parameters.types.choice
-import com.github.ajalt.clikt.parameters.types.file
-import com.github.ajalt.clikt.parameters.types.int
-import mu.KotlinLogging
-import org.opendc.experiments.sc20.experiment.*
-import org.opendc.experiments.sc20.reporter.ConsoleExperimentReporter
-import org.opendc.experiments.sc20.runner.ExperimentDescriptor
-import org.opendc.experiments.sc20.runner.execution.ThreadPoolExperimentScheduler
-import org.opendc.experiments.sc20.runner.internal.DefaultExperimentRunner
-import org.opendc.format.trace.sc20.Sc20PerformanceInterferenceReader
-import org.opendc.format.trace.sc20.Sc20VmPlacementReader
-import java.io.File
-
-/**
- * The logger for this experiment.
- */
-private val logger = KotlinLogging.logger {}
-
-/**
- * Represents the command for running the experiment.
- */
-public class ExperimentCli : CliktCommand(name = "sc20-experiment") {
-    /**
-     * The path to the directory where the topology descriptions are located.
-     */
-    private val environmentPath by option("--environment-path", help = "path to the environment directory")
-        .file(canBeFile = false)
-        .required()
-
-    /**
-     * The path to the directory where the traces are located.
-     */
-    private val tracePath by option("--trace-path", help = "path to the traces directory")
-        .file(canBeFile = false)
-        .required()
-
-    /**
-     * The path to the performance interference model.
-     */
-    private val performanceInterferenceStream by option(
-        "--performance-interference-model",
-        help = "path to the performance interference file"
-    )
-        .file(canBeDir = false)
-        .convert { it.inputStream() }
-
-    /**
-     * The path to the original VM placements file.
-     */
-    private val vmPlacements by option("--vm-placements-file", help = "path to the VM placement file")
-        .file(canBeDir = false)
-        .convert {
-            Sc20VmPlacementReader(it.inputStream().buffered()).construct()
-        }
-        .default(emptyMap())
-
-    /**
-     * The selected portfolios to run.
-     */
-    private val portfolios by option("--portfolio", help = "portfolio of scenarios to explore")
-        .choice(
-            "hor-ver" to { experiment: Experiment, i: Int -> HorVerPortfolio(experiment, i) }
-                as (Experiment, Int) -> Portfolio,
-            "more-velocity" to { experiment, i -> MoreVelocityPortfolio(experiment, i) },
-            "composite-workload" to { experiment, i -> CompositeWorkloadPortfolio(experiment, i) },
-            "operational-phenomena" to { experiment, i -> OperationalPhenomenaPortfolio(experiment, i) },
-            "replay" to { experiment, i -> ReplayPortfolio(experiment, i) },
-            "test" to { experiment, i -> TestPortfolio(experiment, i) },
-            "more-hpc" to { experiment, i -> MoreHpcPortfolio(experiment, i) },
-            ignoreCase = true
-        )
-        .multiple(required = true)
-
-    /**
-     * The maximum number of worker threads to use.
-     */
-    private val parallelism by option("--parallelism", help = "maximum number of concurrent simulation runs")
-        .int()
-        .default(Runtime.getRuntime().availableProcessors())
-
-    /**
-     * The buffer size for writing results.
-     */
-    private val bufferSize by option("--buffer-size")
-        .int()
-        .default(4096)
-
-    /**
-     * The path to the output directory.
-     */
-    private val output by option("-O", "--output", help = "path to the output directory")
-        .file(canBeFile = false)
-        .defaultLazy { File("data") }
-
-    override fun run() {
-        logger.info { "Constructing performance interference model" }
-
-        val performanceInterferenceModel =
-            performanceInterferenceStream?.let { Sc20PerformanceInterferenceReader(it) }
-
-        logger.info { "Creating experiment descriptor" }
-        val descriptor = object :
-            Experiment(environmentPath, tracePath, output, performanceInterferenceModel, vmPlacements, bufferSize) {
-            private val descriptor = this
-            override val children: Sequence<ExperimentDescriptor> = sequence {
-                for ((i, producer) in portfolios.withIndex()) {
-                    yield(producer(descriptor, i))
-                }
-            }
-        }
-
-        logger.info { "Starting experiment runner [parallelism=$parallelism]" }
-        val scheduler = ThreadPoolExperimentScheduler(parallelism)
-        val runner = DefaultExperimentRunner(scheduler)
-        val reporter = ConsoleExperimentReporter()
-        try {
-            runner.execute(descriptor, reporter)
-        } finally {
-            scheduler.close()
-            reporter.close()
-        }
-    }
-}
-
-/**
- * Main entry point of the experiment.
- */
-public fun main(args: Array<String>): Unit = ExperimentCli().main(args)
diff --git a/simulator/opendc-experiments/opendc-experiments-sc20/src/main/kotlin/org/opendc/experiments/sc20/experiment/CompositeWorkloadPortfolio.kt b/simulator/opendc-experiments/opendc-experiments-sc20/src/main/kotlin/org/opendc/experiments/sc20/experiment/CompositeWorkloadPortfolio.kt
new file mode 100644
index 00000000..f4242456
--- /dev/null
+++ b/simulator/opendc-experiments/opendc-experiments-sc20/src/main/kotlin/org/opendc/experiments/sc20/experiment/CompositeWorkloadPortfolio.kt
@@ -0,0 +1,79 @@
+/*
+ * 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.sc20.experiment
+
+import org.opendc.experiments.sc20.experiment.model.CompositeWorkload
+import org.opendc.experiments.sc20.experiment.model.OperationalPhenomena
+import org.opendc.experiments.sc20.experiment.model.Topology
+import org.opendc.experiments.sc20.experiment.model.Workload
+import org.opendc.harness.dsl.anyOf
+
+/**
+ * A [Portfolio] that explores the effect of a composite workload.
+ */
+public class CompositeWorkloadPortfolio : Portfolio("composite-workload") {
+    private val totalSampleLoad = 1.3301733005049648E12
+
+    override val topology: Topology by anyOf(
+        Topology("base"),
+        Topology("exp-vol-hor-hom"),
+        Topology("exp-vol-ver-hom"),
+        Topology("exp-vel-ver-hom")
+    )
+
+    override val workload: Workload by anyOf(
+        CompositeWorkload(
+            "all-azure",
+            listOf(Workload("solvinity-short", 0.0), Workload("azure", 1.0)),
+            totalSampleLoad
+        ),
+        CompositeWorkload(
+            "solvinity-25-azure-75",
+            listOf(Workload("solvinity-short", 0.25), Workload("azure", 0.75)),
+            totalSampleLoad
+        ),
+        CompositeWorkload(
+            "solvinity-50-azure-50",
+            listOf(Workload("solvinity-short", 0.5), Workload("azure", 0.5)),
+            totalSampleLoad
+        ),
+        CompositeWorkload(
+            "solvinity-75-azure-25",
+            listOf(Workload("solvinity-short", 0.75), Workload("azure", 0.25)),
+            totalSampleLoad
+        ),
+        CompositeWorkload(
+            "all-solvinity",
+            listOf(Workload("solvinity-short", 1.0), Workload("azure", 0.0)),
+            totalSampleLoad
+        )
+    )
+
+    override val operationalPhenomena: OperationalPhenomena by anyOf(
+        OperationalPhenomena(failureFrequency = 24.0 * 7, hasInterference = false)
+    )
+
+    override val allocationPolicy: String by anyOf(
+        "active-servers"
+    )
+}
diff --git a/simulator/opendc-experiments/opendc-experiments-sc20/src/main/kotlin/org/opendc/experiments/sc20/experiment/Experiment.kt b/simulator/opendc-experiments/opendc-experiments-sc20/src/main/kotlin/org/opendc/experiments/sc20/experiment/Experiment.kt
deleted file mode 100644
index 34d7301b..00000000
--- a/simulator/opendc-experiments/opendc-experiments-sc20/src/main/kotlin/org/opendc/experiments/sc20/experiment/Experiment.kt
+++ /dev/null
@@ -1,76 +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.experiments.sc20.experiment
-
-import org.opendc.experiments.sc20.runner.ContainerExperimentDescriptor
-import org.opendc.experiments.sc20.runner.ExperimentDescriptor
-import org.opendc.experiments.sc20.runner.execution.ExperimentExecutionContext
-import org.opendc.experiments.sc20.runner.execution.ExperimentExecutionListener
-import org.opendc.experiments.sc20.telemetry.RunEvent
-import org.opendc.experiments.sc20.telemetry.parquet.ParquetRunEventWriter
-import org.opendc.format.trace.PerformanceInterferenceModelReader
-import java.io.File
-
-/**
- * The global configuration of the experiment.
- *
- * @param environments The path to the topologies directory.
- * @param traces The path to the traces directory.
- * @param output The output directory.
- * @param performanceInterferenceModel The optional performance interference model that has been specified.
- * @param vmPlacements Original VM placement in the trace.
- * @param bufferSize The buffer size of the event reporters.
- */
-public abstract class Experiment(
-    public val environments: File,
-    public val traces: File,
-    public val output: File,
-    public val performanceInterferenceModel: PerformanceInterferenceModelReader?,
-    public val vmPlacements: Map<String, String>,
-    public val bufferSize: Int
-) : ContainerExperimentDescriptor() {
-    override val parent: ExperimentDescriptor? = null
-
-    override suspend fun invoke(context: ExperimentExecutionContext) {
-        val writer = ParquetRunEventWriter(File(output, "experiments.parquet"), bufferSize)
-        try {
-            val listener = object : ExperimentExecutionListener by context.listener {
-                override fun descriptorRegistered(descriptor: ExperimentDescriptor) {
-                    if (descriptor is Run) {
-                        writer.write(RunEvent(descriptor, System.currentTimeMillis()))
-                    }
-
-                    context.listener.descriptorRegistered(descriptor)
-                }
-            }
-
-            val newContext = object : ExperimentExecutionContext by context {
-                override val listener: ExperimentExecutionListener = listener
-            }
-
-            super.invoke(newContext)
-        } finally {
-            writer.close()
-        }
-    }
-}
diff --git a/simulator/opendc-experiments/opendc-experiments-sc20/src/main/kotlin/org/opendc/experiments/sc20/experiment/HorVerPortfolio.kt b/simulator/opendc-experiments/opendc-experiments-sc20/src/main/kotlin/org/opendc/experiments/sc20/experiment/HorVerPortfolio.kt
new file mode 100644
index 00000000..aa97b808
--- /dev/null
+++ b/simulator/opendc-experiments/opendc-experiments-sc20/src/main/kotlin/org/opendc/experiments/sc20/experiment/HorVerPortfolio.kt
@@ -0,0 +1,60 @@
+/*
+ * 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.sc20.experiment
+
+import org.opendc.experiments.sc20.experiment.model.OperationalPhenomena
+import org.opendc.experiments.sc20.experiment.model.Topology
+import org.opendc.experiments.sc20.experiment.model.Workload
+import org.opendc.harness.dsl.anyOf
+
+/**
+ * A [Portfolio] that explores the difference between horizontal and vertical scaling.
+ */
+public class HorVerPortfolio : Portfolio("horizontal_vs_vertical") {
+    override val topology: Topology by anyOf(
+        Topology("base"),
+        Topology("rep-vol-hor-hom"),
+        Topology("rep-vol-hor-het"),
+        Topology("rep-vol-ver-hom"),
+        Topology("rep-vol-ver-het"),
+        Topology("exp-vol-hor-hom"),
+        Topology("exp-vol-hor-het"),
+        Topology("exp-vol-ver-hom"),
+        Topology("exp-vol-ver-het")
+    )
+
+    override val workload: Workload by anyOf(
+        Workload("solvinity", 0.1),
+        Workload("solvinity", 0.25),
+        Workload("solvinity", 0.5),
+        Workload("solvinity", 1.0)
+    )
+
+    override val operationalPhenomena: OperationalPhenomena by anyOf(
+        OperationalPhenomena(failureFrequency = 24.0 * 7, hasInterference = true)
+    )
+
+    override val allocationPolicy: String by anyOf(
+        "active-servers"
+    )
+}
diff --git a/simulator/opendc-experiments/opendc-experiments-sc20/src/main/kotlin/org/opendc/experiments/sc20/experiment/MoreHpcPortfolio.kt b/simulator/opendc-experiments/opendc-experiments-sc20/src/main/kotlin/org/opendc/experiments/sc20/experiment/MoreHpcPortfolio.kt
new file mode 100644
index 00000000..bdb33f59
--- /dev/null
+++ b/simulator/opendc-experiments/opendc-experiments-sc20/src/main/kotlin/org/opendc/experiments/sc20/experiment/MoreHpcPortfolio.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.experiments.sc20.experiment
+
+import org.opendc.experiments.sc20.experiment.model.*
+import org.opendc.harness.dsl.anyOf
+
+/**
+ * A [Portfolio] to explore the effect of HPC workloads.
+ */
+public class MoreHpcPortfolio : Portfolio("more_hpc") {
+    override val topology: Topology by anyOf(
+        Topology("base"),
+        Topology("exp-vol-hor-hom"),
+        Topology("exp-vol-ver-hom"),
+        Topology("exp-vel-ver-hom")
+    )
+
+    override val workload: Workload by anyOf(
+        Workload("solvinity", 0.0, samplingStrategy = SamplingStrategy.HPC),
+        Workload("solvinity", 0.25, samplingStrategy = SamplingStrategy.HPC),
+        Workload("solvinity", 0.5, samplingStrategy = SamplingStrategy.HPC),
+        Workload("solvinity", 1.0, samplingStrategy = SamplingStrategy.HPC),
+        Workload("solvinity", 0.25, samplingStrategy = SamplingStrategy.HPC_LOAD),
+        Workload("solvinity", 0.5, samplingStrategy = SamplingStrategy.HPC_LOAD),
+        Workload("solvinity", 1.0, samplingStrategy = SamplingStrategy.HPC_LOAD)
+    )
+
+    override val operationalPhenomena: OperationalPhenomena by anyOf(
+        OperationalPhenomena(failureFrequency = 24.0 * 7, hasInterference = true)
+    )
+
+    override val allocationPolicy: String by anyOf(
+        "active-servers"
+    )
+}
diff --git a/simulator/opendc-experiments/opendc-experiments-sc20/src/main/kotlin/org/opendc/experiments/sc20/experiment/MoreVelocityPortfolio.kt b/simulator/opendc-experiments/opendc-experiments-sc20/src/main/kotlin/org/opendc/experiments/sc20/experiment/MoreVelocityPortfolio.kt
new file mode 100644
index 00000000..733dabf6
--- /dev/null
+++ b/simulator/opendc-experiments/opendc-experiments-sc20/src/main/kotlin/org/opendc/experiments/sc20/experiment/MoreVelocityPortfolio.kt
@@ -0,0 +1,56 @@
+/*
+ * 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.sc20.experiment
+
+import org.opendc.experiments.sc20.experiment.model.OperationalPhenomena
+import org.opendc.experiments.sc20.experiment.model.Topology
+import org.opendc.experiments.sc20.experiment.model.Workload
+import org.opendc.harness.dsl.anyOf
+
+/**
+ * A [Portfolio] that explores the effect of adding more velocity to a cluster (e.g., faster machines).
+ */
+public class MoreVelocityPortfolio : Portfolio("more_velocity") {
+    override val topology: Topology by anyOf(
+        Topology("base"),
+        Topology("rep-vel-ver-hom"),
+        Topology("rep-vel-ver-het"),
+        Topology("exp-vel-ver-hom"),
+        Topology("exp-vel-ver-het")
+    )
+
+    override val workload: Workload by anyOf(
+        Workload("solvinity", 0.1),
+        Workload("solvinity", 0.25),
+        Workload("solvinity", 0.5),
+        Workload("solvinity", 1.0)
+    )
+
+    override val operationalPhenomena: OperationalPhenomena by anyOf(
+        OperationalPhenomena(failureFrequency = 24.0 * 7, hasInterference = true)
+    )
+
+    override val allocationPolicy: String by anyOf(
+        "active-servers"
+    )
+}
diff --git a/simulator/opendc-experiments/opendc-experiments-sc20/src/main/kotlin/org/opendc/experiments/sc20/experiment/OperationalPhenomenaPortfolio.kt b/simulator/opendc-experiments/opendc-experiments-sc20/src/main/kotlin/org/opendc/experiments/sc20/experiment/OperationalPhenomenaPortfolio.kt
new file mode 100644
index 00000000..66b94faf
--- /dev/null
+++ b/simulator/opendc-experiments/opendc-experiments-sc20/src/main/kotlin/org/opendc/experiments/sc20/experiment/OperationalPhenomenaPortfolio.kt
@@ -0,0 +1,61 @@
+/*
+ * 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.sc20.experiment
+
+import org.opendc.experiments.sc20.experiment.model.OperationalPhenomena
+import org.opendc.experiments.sc20.experiment.model.Topology
+import org.opendc.experiments.sc20.experiment.model.Workload
+import org.opendc.harness.dsl.anyOf
+
+/**
+ * A [Portfolio] that explores the effect of operational phenomena on metrics.
+ */
+public class OperationalPhenomenaPortfolio : Portfolio("operational_phenomena") {
+    override val topology: Topology by anyOf(
+        Topology("base")
+    )
+
+    override val workload: Workload by anyOf(
+        Workload("solvinity", 0.1),
+        Workload("solvinity", 0.25),
+        Workload("solvinity", 0.5),
+        Workload("solvinity", 1.0)
+    )
+
+    override val operationalPhenomena: OperationalPhenomena by anyOf(
+        OperationalPhenomena(failureFrequency = 24.0 * 7, hasInterference = true),
+        OperationalPhenomena(failureFrequency = 0.0, hasInterference = true),
+        OperationalPhenomena(failureFrequency = 24.0 * 7, hasInterference = false),
+        OperationalPhenomena(failureFrequency = 0.0, hasInterference = false)
+    )
+
+    override val allocationPolicy: String by anyOf(
+        "mem",
+        "mem-inv",
+        "core-mem",
+        "core-mem-inv",
+        "active-servers",
+        "active-servers-inv",
+        "random"
+    )
+}
diff --git a/simulator/opendc-experiments/opendc-experiments-sc20/src/main/kotlin/org/opendc/experiments/sc20/experiment/Portfolio.kt b/simulator/opendc-experiments/opendc-experiments-sc20/src/main/kotlin/org/opendc/experiments/sc20/experiment/Portfolio.kt
index 37cf2880..4a82ad56 100644
--- a/simulator/opendc-experiments/opendc-experiments-sc20/src/main/kotlin/org/opendc/experiments/sc20/experiment/Portfolio.kt
+++ b/simulator/opendc-experiments/opendc-experiments-sc20/src/main/kotlin/org/opendc/experiments/sc20/experiment/Portfolio.kt
@@ -22,67 +22,196 @@
 
 package org.opendc.experiments.sc20.experiment
 
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.channels.Channel
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.test.TestCoroutineScope
+import mu.KotlinLogging
+import org.opendc.compute.simulator.allocation.*
+import org.opendc.experiments.sc20.experiment.model.CompositeWorkload
 import org.opendc.experiments.sc20.experiment.model.OperationalPhenomena
 import org.opendc.experiments.sc20.experiment.model.Topology
 import org.opendc.experiments.sc20.experiment.model.Workload
-import org.opendc.experiments.sc20.runner.ContainerExperimentDescriptor
+import org.opendc.experiments.sc20.experiment.monitor.ParquetExperimentMonitor
+import org.opendc.experiments.sc20.trace.Sc20ParquetTraceReader
+import org.opendc.experiments.sc20.trace.Sc20RawParquetTraceReader
+import org.opendc.format.environment.sc20.Sc20ClusterEnvironmentReader
+import org.opendc.format.trace.PerformanceInterferenceModelReader
+import org.opendc.harness.dsl.Experiment
+import org.opendc.harness.dsl.anyOf
+import org.opendc.simulator.utils.DelayControllerClockAdapter
+import org.opendc.trace.core.EventTracer
+import java.io.File
+import java.util.concurrent.ConcurrentHashMap
+import kotlin.random.Random
 
 /**
- * A portfolio represents a collection of scenarios are tested.
+ * A portfolio represents a collection of scenarios are tested for the work.
+ *
+ * @param name The name of the portfolio.
  */
-public abstract class Portfolio(
-    override val parent: Experiment,
-    public val id: Int,
-    public val name: String
-) : ContainerExperimentDescriptor() {
+public abstract class Portfolio(name: String) : Experiment(name) {
+    /**
+     * The logger for this portfolio instance.
+     */
+    private val logger = KotlinLogging.logger {}
+
+    /**
+     * The path to where the environments are located.
+     */
+    private val environmentPath by anyOf(File("environments/"))
+
+    /**
+     * The path to where the traces are located.
+     */
+    private val tracePath by anyOf(File("traces/"))
+
     /**
-     * The topologies to consider.
+     * The path to where the output results should be written.
      */
-    protected abstract val topologies: List<Topology>
+    private val outputPath by anyOf(File("results/"))
 
     /**
-     * The workloads to consider.
+     * The path to the original VM placements file.
      */
-    protected abstract val workloads: List<Workload>
+    private val vmPlacements by anyOf(emptyMap<String, String>())
+
+    /**
+     * The path to the performance interference model.
+     */
+    private val performanceInterferenceModel by anyOf<PerformanceInterferenceModelReader?>(null)
+
+    /**
+     * The topology to test.
+     */
+    public abstract val topology: Topology
+
+    /**
+     * The workload to test.
+     */
+    public abstract val workload: Workload
 
     /**
      * The operational phenomenas to consider.
      */
-    protected abstract val operationalPhenomenas: List<OperationalPhenomena>
+    public abstract val operationalPhenomena: OperationalPhenomena
 
     /**
      * The allocation policies to consider.
      */
-    protected abstract val allocationPolicies: List<String>
+    public abstract val allocationPolicy: String
 
     /**
-     * The number of repetitions to perform.
+     * A map of trace readers.
      */
-    public open val repetitions: Int = 32
+    private val traceReaders = ConcurrentHashMap<String, Sc20RawParquetTraceReader>()
 
     /**
-     * Resolve the children of this container.
+     * Perform a single trial for this portfolio.
      */
-    override val children: Sequence<Scenario> = sequence {
-        var id = 0
-        for (topology in topologies) {
-            for (workload in workloads) {
-                for (operationalPhenomena in operationalPhenomenas) {
-                    for (allocationPolicy in allocationPolicies) {
-                        yield(
-                            Scenario(
-                                this@Portfolio,
-                                id++,
-                                repetitions,
-                                topology,
-                                workload,
-                                allocationPolicy,
-                                operationalPhenomena
-                            )
-                        )
-                    }
-                }
+    @OptIn(ExperimentalCoroutinesApi::class)
+    override fun doRun(repeat: Int) {
+        val testScope = TestCoroutineScope()
+        val clock = DelayControllerClockAdapter(testScope)
+        val tracer = EventTracer(clock)
+        val seeder = Random(repeat)
+        val environment = Sc20ClusterEnvironmentReader(File(environmentPath, "${topology.name}.txt"))
+
+        val chan = Channel<Unit>(Channel.CONFLATED)
+        val allocationPolicy = createAllocationPolicy(seeder)
+
+        val workload = workload
+        val workloadNames = if (workload is CompositeWorkload) {
+            workload.workloads.map { it.name }
+        } else {
+            listOf(workload.name)
+        }
+
+        val rawReaders = workloadNames.map { workloadName ->
+            traceReaders.computeIfAbsent(workloadName) {
+                logger.info { "Loading trace $workloadName" }
+                Sc20RawParquetTraceReader(File(tracePath, workloadName))
+            }
+        }
+
+        val performanceInterferenceModel = performanceInterferenceModel
+            ?.takeIf { operationalPhenomena.hasInterference }
+            ?.construct(seeder) ?: emptyMap()
+        val trace = Sc20ParquetTraceReader(rawReaders, performanceInterferenceModel, workload, seeder.nextInt())
+
+        val monitor = ParquetExperimentMonitor(
+            outputPath,
+            "portfolio_id=$name/scenario_id=$id/run_id=$repeat",
+            4096
+        )
+
+        testScope.launch {
+            val (bareMetalProvisioner, scheduler) = createProvisioner(
+                this,
+                clock,
+                environment,
+                allocationPolicy,
+                tracer
+            )
+
+            val failureDomain = if (operationalPhenomena.failureFrequency > 0) {
+                logger.debug("ENABLING failures")
+                createFailureDomain(
+                    this,
+                    clock,
+                    seeder.nextInt(),
+                    operationalPhenomena.failureFrequency,
+                    bareMetalProvisioner,
+                    chan
+                )
+            } else {
+                null
             }
+
+            attachMonitor(this, clock, scheduler, monitor)
+            processTrace(
+                this,
+                clock,
+                trace,
+                scheduler,
+                chan,
+                monitor
+            )
+
+            logger.debug("SUBMIT=${scheduler.submittedVms}")
+            logger.debug("FAIL=${scheduler.unscheduledVms}")
+            logger.debug("QUEUED=${scheduler.queuedVms}")
+            logger.debug("RUNNING=${scheduler.runningVms}")
+            logger.debug("FINISHED=${scheduler.finishedVms}")
+
+            failureDomain?.cancel()
+            scheduler.terminate()
+        }
+
+        try {
+            testScope.advanceUntilIdle()
+        } finally {
+            monitor.close()
+        }
+    }
+
+    /**
+     * Create the [AllocationPolicy] instance to use for the trial.
+     */
+    private fun createAllocationPolicy(seeder: Random): AllocationPolicy {
+        return when (allocationPolicy) {
+            "mem" -> AvailableMemoryAllocationPolicy()
+            "mem-inv" -> AvailableMemoryAllocationPolicy(true)
+            "core-mem" -> AvailableCoreMemoryAllocationPolicy()
+            "core-mem-inv" -> AvailableCoreMemoryAllocationPolicy(true)
+            "active-servers" -> NumberOfActiveServersAllocationPolicy()
+            "active-servers-inv" -> NumberOfActiveServersAllocationPolicy(true)
+            "provisioned-cores" -> ProvisionedCoresAllocationPolicy()
+            "provisioned-cores-inv" -> ProvisionedCoresAllocationPolicy(true)
+            "random" -> RandomAllocationPolicy(Random(seeder.nextInt()))
+            "replay" -> ReplayAllocationPolicy(vmPlacements)
+            else -> throw IllegalArgumentException("Unknown policy $allocationPolicy")
         }
     }
 }
diff --git a/simulator/opendc-experiments/opendc-experiments-sc20/src/main/kotlin/org/opendc/experiments/sc20/experiment/Portfolios.kt b/simulator/opendc-experiments/opendc-experiments-sc20/src/main/kotlin/org/opendc/experiments/sc20/experiment/Portfolios.kt
deleted file mode 100644
index 249a63b9..00000000
--- a/simulator/opendc-experiments/opendc-experiments-sc20/src/main/kotlin/org/opendc/experiments/sc20/experiment/Portfolios.kt
+++ /dev/null
@@ -1,221 +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.experiments.sc20.experiment
-
-import org.opendc.experiments.sc20.experiment.model.*
-
-public class HorVerPortfolio(parent: Experiment, id: Int) : Portfolio(parent, id, "horizontal_vs_vertical") {
-    override val topologies: List<Topology> = listOf(
-        Topology("base"),
-        Topology("rep-vol-hor-hom"),
-        Topology("rep-vol-hor-het"),
-        Topology("rep-vol-ver-hom"),
-        Topology("rep-vol-ver-het"),
-        Topology("exp-vol-hor-hom"),
-        Topology("exp-vol-hor-het"),
-        Topology("exp-vol-ver-hom"),
-        Topology("exp-vol-ver-het")
-    )
-
-    override val workloads: List<Workload> = listOf(
-        Workload("solvinity", 0.1),
-        Workload("solvinity", 0.25),
-        Workload("solvinity", 0.5),
-        Workload("solvinity", 1.0)
-    )
-
-    override val operationalPhenomenas: List<OperationalPhenomena> = listOf(
-        OperationalPhenomena(failureFrequency = 24.0 * 7, hasInterference = true)
-    )
-
-    override val allocationPolicies: List<String> = listOf(
-        "active-servers"
-    )
-}
-
-public class MoreVelocityPortfolio(parent: Experiment, id: Int) : Portfolio(parent, id, "more_velocity") {
-    override val topologies: List<Topology> = listOf(
-        Topology("base"),
-        Topology("rep-vel-ver-hom"),
-        Topology("rep-vel-ver-het"),
-        Topology("exp-vel-ver-hom"),
-        Topology("exp-vel-ver-het")
-    )
-
-    override val workloads: List<Workload> = listOf(
-        Workload("solvinity", 0.1),
-        Workload("solvinity", 0.25),
-        Workload("solvinity", 0.5),
-        Workload("solvinity", 1.0)
-    )
-
-    override val operationalPhenomenas: List<OperationalPhenomena> = listOf(
-        OperationalPhenomena(failureFrequency = 24.0 * 7, hasInterference = true)
-    )
-
-    override val allocationPolicies: List<String> = listOf(
-        "active-servers"
-    )
-}
-
-public class CompositeWorkloadPortfolio(parent: Experiment, id: Int) : Portfolio(parent, id, "composite-workload") {
-    private val totalSampleLoad = 1.3301733005049648E12
-
-    override val topologies: List<Topology> = listOf(
-        Topology("base"),
-        Topology("exp-vol-hor-hom"),
-        Topology("exp-vol-ver-hom"),
-        Topology("exp-vel-ver-hom")
-    )
-
-    override val workloads: List<Workload> = listOf(
-        CompositeWorkload(
-            "all-azure",
-            listOf(Workload("solvinity-short", 0.0), Workload("azure", 1.0)),
-            totalSampleLoad
-        ),
-        CompositeWorkload(
-            "solvinity-25-azure-75",
-            listOf(Workload("solvinity-short", 0.25), Workload("azure", 0.75)),
-            totalSampleLoad
-        ),
-        CompositeWorkload(
-            "solvinity-50-azure-50",
-            listOf(Workload("solvinity-short", 0.5), Workload("azure", 0.5)),
-            totalSampleLoad
-        ),
-        CompositeWorkload(
-            "solvinity-75-azure-25",
-            listOf(Workload("solvinity-short", 0.75), Workload("azure", 0.25)),
-            totalSampleLoad
-        ),
-        CompositeWorkload(
-            "all-solvinity",
-            listOf(Workload("solvinity-short", 1.0), Workload("azure", 0.0)),
-            totalSampleLoad
-        )
-    )
-
-    override val operationalPhenomenas: List<OperationalPhenomena> = listOf(
-        OperationalPhenomena(failureFrequency = 24.0 * 7, hasInterference = false)
-    )
-
-    override val allocationPolicies: List<String> = listOf(
-        "active-servers"
-    )
-}
-
-public class OperationalPhenomenaPortfolio(parent: Experiment, id: Int) :
-    Portfolio(parent, id, "operational_phenomena") {
-    override val topologies: List<Topology> = listOf(
-        Topology("base")
-    )
-
-    override val workloads: List<Workload> = listOf(
-        Workload("solvinity", 0.1),
-        Workload("solvinity", 0.25),
-        Workload("solvinity", 0.5),
-        Workload("solvinity", 1.0)
-    )
-
-    override val operationalPhenomenas: List<OperationalPhenomena> = listOf(
-        OperationalPhenomena(failureFrequency = 24.0 * 7, hasInterference = true),
-        OperationalPhenomena(failureFrequency = 0.0, hasInterference = true),
-        OperationalPhenomena(failureFrequency = 24.0 * 7, hasInterference = false),
-        OperationalPhenomena(failureFrequency = 0.0, hasInterference = false)
-    )
-
-    override val allocationPolicies: List<String> = listOf(
-        "mem",
-        "mem-inv",
-        "core-mem",
-        "core-mem-inv",
-        "active-servers",
-        "active-servers-inv",
-        "random"
-    )
-}
-
-public class ReplayPortfolio(parent: Experiment, id: Int) : Portfolio(parent, id, "replay") {
-    override val topologies: List<Topology> = listOf(
-        Topology("base")
-    )
-
-    override val workloads: List<Workload> = listOf(
-        Workload("solvinity", 1.0)
-    )
-
-    override val operationalPhenomenas: List<OperationalPhenomena> = listOf(
-        OperationalPhenomena(failureFrequency = 0.0, hasInterference = false)
-    )
-
-    override val allocationPolicies: List<String> = listOf(
-        "replay",
-        "active-servers"
-    )
-}
-
-public class TestPortfolio(parent: Experiment, id: Int) : Portfolio(parent, id, "test") {
-    override val repetitions: Int = 1
-
-    override val topologies: List<Topology> = listOf(
-        Topology("base")
-    )
-
-    override val workloads: List<Workload> = listOf(
-        Workload("solvinity", 1.0)
-    )
-
-    override val operationalPhenomenas: List<OperationalPhenomena> = listOf(
-        OperationalPhenomena(failureFrequency = 24.0 * 7, hasInterference = true)
-    )
-
-    override val allocationPolicies: List<String> = listOf("active-servers")
-}
-
-public class MoreHpcPortfolio(parent: Experiment, id: Int) : Portfolio(parent, id, "more_hpc") {
-    override val topologies: List<Topology> = listOf(
-        Topology("base"),
-        Topology("exp-vol-hor-hom"),
-        Topology("exp-vol-ver-hom"),
-        Topology("exp-vel-ver-hom")
-    )
-
-    override val workloads: List<Workload> = listOf(
-        Workload("solvinity", 0.0, samplingStrategy = SamplingStrategy.HPC),
-        Workload("solvinity", 0.25, samplingStrategy = SamplingStrategy.HPC),
-        Workload("solvinity", 0.5, samplingStrategy = SamplingStrategy.HPC),
-        Workload("solvinity", 1.0, samplingStrategy = SamplingStrategy.HPC),
-        Workload("solvinity", 0.25, samplingStrategy = SamplingStrategy.HPC_LOAD),
-        Workload("solvinity", 0.5, samplingStrategy = SamplingStrategy.HPC_LOAD),
-        Workload("solvinity", 1.0, samplingStrategy = SamplingStrategy.HPC_LOAD)
-    )
-
-    override val operationalPhenomenas: List<OperationalPhenomena> = listOf(
-        OperationalPhenomena(failureFrequency = 24.0 * 7, hasInterference = true)
-    )
-
-    override val allocationPolicies: List<String> = listOf(
-        "active-servers"
-    )
-}
diff --git a/simulator/opendc-experiments/opendc-experiments-sc20/src/main/kotlin/org/opendc/experiments/sc20/experiment/Scenario.kt b/simulator/opendc-experiments/opendc-experiments-sc20/src/main/kotlin/org/opendc/experiments/sc20/experiment/ReplayPortfolio.kt
index d092ddd5..8a42a3b4 100644
--- a/simulator/opendc-experiments/opendc-experiments-sc20/src/main/kotlin/org/opendc/experiments/sc20/experiment/Scenario.kt
+++ b/simulator/opendc-experiments/opendc-experiments-sc20/src/main/kotlin/org/opendc/experiments/sc20/experiment/ReplayPortfolio.kt
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020 AtLarge Research
+ * 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
@@ -25,22 +25,26 @@ package org.opendc.experiments.sc20.experiment
 import org.opendc.experiments.sc20.experiment.model.OperationalPhenomena
 import org.opendc.experiments.sc20.experiment.model.Topology
 import org.opendc.experiments.sc20.experiment.model.Workload
-import org.opendc.experiments.sc20.runner.ContainerExperimentDescriptor
-import org.opendc.experiments.sc20.runner.ExperimentDescriptor
+import org.opendc.harness.dsl.anyOf
 
 /**
- * A scenario represents a single point in the design space (a unique combination of parameters).
+ * A [Portfolio] that compares the original VM placements against our policies.
  */
-public class Scenario(
-    override val parent: Portfolio,
-    public val id: Int,
-    public val repetitions: Int,
-    public val topology: Topology,
-    public val workload: Workload,
-    public val allocationPolicy: String,
-    public val operationalPhenomena: OperationalPhenomena
-) : ContainerExperimentDescriptor() {
-    override val children: Sequence<ExperimentDescriptor> = sequence {
-        repeat(repetitions) { i -> yield(Run(this@Scenario, i, i)) }
-    }
+public class ReplayPortfolio : Portfolio("replay") {
+    override val topology: Topology by anyOf(
+        Topology("base")
+    )
+
+    override val workload: Workload by anyOf(
+        Workload("solvinity", 1.0)
+    )
+
+    override val operationalPhenomena: OperationalPhenomena by anyOf(
+        OperationalPhenomena(failureFrequency = 0.0, hasInterference = false)
+    )
+
+    override val allocationPolicy: String by anyOf(
+        "replay",
+        "active-servers"
+    )
 }
diff --git a/simulator/opendc-experiments/opendc-experiments-sc20/src/main/kotlin/org/opendc/experiments/sc20/experiment/Run.kt b/simulator/opendc-experiments/opendc-experiments-sc20/src/main/kotlin/org/opendc/experiments/sc20/experiment/Run.kt
deleted file mode 100644
index 8d8d608d..00000000
--- a/simulator/opendc-experiments/opendc-experiments-sc20/src/main/kotlin/org/opendc/experiments/sc20/experiment/Run.kt
+++ /dev/null
@@ -1,157 +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.experiments.sc20.experiment
-
-import kotlinx.coroutines.ExperimentalCoroutinesApi
-import kotlinx.coroutines.cancel
-import kotlinx.coroutines.channels.Channel
-import kotlinx.coroutines.launch
-import kotlinx.coroutines.test.TestCoroutineScope
-import mu.KotlinLogging
-import org.opendc.compute.simulator.allocation.*
-import org.opendc.experiments.sc20.experiment.model.CompositeWorkload
-import org.opendc.experiments.sc20.experiment.monitor.ParquetExperimentMonitor
-import org.opendc.experiments.sc20.runner.TrialExperimentDescriptor
-import org.opendc.experiments.sc20.runner.execution.ExperimentExecutionContext
-import org.opendc.experiments.sc20.trace.Sc20ParquetTraceReader
-import org.opendc.experiments.sc20.trace.Sc20RawParquetTraceReader
-import org.opendc.format.environment.sc20.Sc20ClusterEnvironmentReader
-import org.opendc.simulator.utils.DelayControllerClockAdapter
-import org.opendc.trace.core.EventTracer
-import java.io.File
-import kotlin.random.Random
-
-/**
- * The logger for the experiment scenario.
- */
-private val logger = KotlinLogging.logger {}
-
-/**
- * An experiment run represent a single invocation of a trial and is used to distinguish between repetitions of the
- * same set of parameters.
- */
-@OptIn(ExperimentalCoroutinesApi::class)
-public data class Run(override val parent: Scenario, val id: Int, val seed: Int) : TrialExperimentDescriptor() {
-    override suspend fun invoke(context: ExperimentExecutionContext) {
-        val experiment = parent.parent.parent
-        val testScope = TestCoroutineScope()
-        val clock = DelayControllerClockAdapter(testScope)
-        val seeder = Random(seed)
-        val environment = Sc20ClusterEnvironmentReader(File(experiment.environments, "${parent.topology.name}.txt"))
-
-        val chan = Channel<Unit>(Channel.CONFLATED)
-        val allocationPolicy = when (parent.allocationPolicy) {
-            "mem" -> AvailableMemoryAllocationPolicy()
-            "mem-inv" -> AvailableMemoryAllocationPolicy(true)
-            "core-mem" -> AvailableCoreMemoryAllocationPolicy()
-            "core-mem-inv" -> AvailableCoreMemoryAllocationPolicy(true)
-            "active-servers" -> NumberOfActiveServersAllocationPolicy()
-            "active-servers-inv" -> NumberOfActiveServersAllocationPolicy(true)
-            "provisioned-cores" -> ProvisionedCoresAllocationPolicy()
-            "provisioned-cores-inv" -> ProvisionedCoresAllocationPolicy(true)
-            "random" -> RandomAllocationPolicy(Random(seeder.nextInt()))
-            "replay" -> ReplayAllocationPolicy(experiment.vmPlacements)
-            else -> throw IllegalArgumentException("Unknown policy ${parent.allocationPolicy}")
-        }
-
-        @Suppress("UNCHECKED_CAST")
-        val rawTraceReaders =
-            context.cache.computeIfAbsent("raw-trace-readers") { mutableMapOf<String, Sc20RawParquetTraceReader>() } as MutableMap<String, Sc20RawParquetTraceReader>
-        val rawReaders = synchronized(rawTraceReaders) {
-            val workloadNames = if (parent.workload is CompositeWorkload) {
-                parent.workload.workloads.map { it.name }
-            } else {
-                listOf(parent.workload.name)
-            }
-
-            workloadNames.map { workloadName ->
-                rawTraceReaders.computeIfAbsent(workloadName) {
-                    logger.info { "Loading trace $workloadName" }
-                    Sc20RawParquetTraceReader(File(experiment.traces, workloadName))
-                }
-            }
-        }
-
-        val performanceInterferenceModel = experiment.performanceInterferenceModel
-            ?.takeIf { parent.operationalPhenomena.hasInterference }
-            ?.construct(seeder) ?: emptyMap()
-        val trace = Sc20ParquetTraceReader(rawReaders, performanceInterferenceModel, parent.workload, seed)
-
-        val monitor = ParquetExperimentMonitor(
-            parent.parent.parent.output,
-            "portfolio_id=${parent.parent.id}/scenario_id=${parent.id}/run_id=$id",
-            parent.parent.parent.bufferSize
-        )
-
-        val tracer = EventTracer(clock)
-
-        testScope.launch {
-            val (bareMetalProvisioner, scheduler) = createProvisioner(
-                this,
-                clock,
-                environment,
-                allocationPolicy,
-                tracer
-            )
-
-            val failureDomain = if (parent.operationalPhenomena.failureFrequency > 0) {
-                logger.debug("ENABLING failures")
-                createFailureDomain(
-                    this,
-                    clock,
-                    seeder.nextInt(),
-                    parent.operationalPhenomena.failureFrequency,
-                    bareMetalProvisioner,
-                    chan
-                )
-            } else {
-                null
-            }
-
-            attachMonitor(this, clock, scheduler, monitor)
-            processTrace(
-                this,
-                clock,
-                trace,
-                scheduler,
-                chan,
-                monitor
-            )
-
-            logger.debug("SUBMIT=${scheduler.submittedVms}")
-            logger.debug("FAIL=${scheduler.unscheduledVms}")
-            logger.debug("QUEUED=${scheduler.queuedVms}")
-            logger.debug("RUNNING=${scheduler.runningVms}")
-            logger.debug("FINISHED=${scheduler.finishedVms}")
-
-            failureDomain?.cancel()
-            scheduler.terminate()
-        }
-
-        try {
-            testScope.advanceUntilIdle()
-        } finally {
-            monitor.close()
-        }
-    }
-}
diff --git a/simulator/opendc-experiments/opendc-experiments-sc20/src/main/kotlin/org/opendc/experiments/sc20/runner/ExperimentRunner.kt b/simulator/opendc-experiments/opendc-experiments-sc20/src/main/kotlin/org/opendc/experiments/sc20/experiment/TestPortfolio.kt
index a59481c0..2210fc97 100644
--- a/simulator/opendc-experiments/opendc-experiments-sc20/src/main/kotlin/org/opendc/experiments/sc20/runner/ExperimentRunner.kt
+++ b/simulator/opendc-experiments/opendc-experiments-sc20/src/main/kotlin/org/opendc/experiments/sc20/experiment/TestPortfolio.kt
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020 AtLarge Research
+ * 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
@@ -20,30 +20,28 @@
  * SOFTWARE.
  */
 
-package org.opendc.experiments.sc20.runner
+package org.opendc.experiments.sc20.experiment
 
-import org.opendc.experiments.sc20.runner.execution.ExperimentExecutionListener
+import org.opendc.experiments.sc20.experiment.model.OperationalPhenomena
+import org.opendc.experiments.sc20.experiment.model.Topology
+import org.opendc.experiments.sc20.experiment.model.Workload
+import org.opendc.harness.dsl.anyOf
 
 /**
- * An [ExperimentRunner] facilitates discovery and execution of experiments.
+ * A [Portfolio] to perform a simple test run.
  */
-public interface ExperimentRunner {
-    /**
-     * The unique identifier of this runner.
-     */
-    public val id: String
+public class TestPortfolio : Portfolio("test") {
+    override val topology: Topology by anyOf(
+        Topology("base")
+    )
 
-    /**
-     * The version of this runner.
-     */
-    public val version: String?
-        get() = null
+    override val workload: Workload by anyOf(
+        Workload("solvinity", 1.0)
+    )
 
-    /**
-     * Execute the specified experiment represented as [ExperimentDescriptor].
-     *
-     * @param root The experiment to execute.
-     * @param listener The listener to report events to.
-     */
-    public fun execute(root: ExperimentDescriptor, listener: ExperimentExecutionListener)
+    override val operationalPhenomena: OperationalPhenomena by anyOf(
+        OperationalPhenomena(failureFrequency = 24.0 * 7, hasInterference = true)
+    )
+
+    override val allocationPolicy: String by anyOf("active-servers")
 }
diff --git a/simulator/opendc-experiments/opendc-experiments-sc20/src/main/kotlin/org/opendc/experiments/sc20/reporter/ConsoleExperimentReporter.kt b/simulator/opendc-experiments/opendc-experiments-sc20/src/main/kotlin/org/opendc/experiments/sc20/reporter/ConsoleExperimentReporter.kt
deleted file mode 100644
index af61622a..00000000
--- a/simulator/opendc-experiments/opendc-experiments-sc20/src/main/kotlin/org/opendc/experiments/sc20/reporter/ConsoleExperimentReporter.kt
+++ /dev/null
@@ -1,87 +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.experiments.sc20.reporter
-
-import me.tongfei.progressbar.ProgressBar
-import me.tongfei.progressbar.ProgressBarBuilder
-import mu.KotlinLogging
-import org.opendc.experiments.sc20.experiment.Run
-import org.opendc.experiments.sc20.runner.ExperimentDescriptor
-import org.opendc.experiments.sc20.runner.execution.ExperimentExecutionListener
-import org.opendc.experiments.sc20.runner.execution.ExperimentExecutionResult
-
-/**
- * A reporter that reports the experiment progress to the console.
- */
-public class ConsoleExperimentReporter : ExperimentExecutionListener, AutoCloseable {
-    /**
-     * The active [Run]s.
-     */
-    private val runs: MutableSet<Run> = mutableSetOf()
-
-    /**
-     * The total number of runs.
-     */
-    private var total = 0
-
-    /**
-     * The logger for this reporter.
-     */
-    private val logger = KotlinLogging.logger {}
-
-    /**
-     * The progress bar to keep track of the progress.
-     */
-    private val pb: ProgressBar = ProgressBarBuilder()
-        .setTaskName("")
-        .setInitialMax(1)
-        .build()
-
-    override fun descriptorRegistered(descriptor: ExperimentDescriptor) {
-        if (descriptor is Run) {
-            runs += descriptor
-            pb.maxHint((++total).toLong())
-        }
-    }
-
-    override fun executionFinished(descriptor: ExperimentDescriptor, result: ExperimentExecutionResult) {
-        if (descriptor is Run) {
-            runs -= descriptor
-
-            pb.stepTo(total - runs.size.toLong())
-            if (runs.isEmpty()) {
-                pb.close()
-            }
-        }
-
-        if (result is ExperimentExecutionResult.Failed) {
-            logger.warn(result.throwable) { "Descriptor $descriptor failed" }
-        }
-    }
-
-    override fun executionStarted(descriptor: ExperimentDescriptor) {}
-
-    override fun close() {
-        pb.close()
-    }
-}
diff --git a/simulator/opendc-experiments/opendc-experiments-sc20/src/main/kotlin/org/opendc/experiments/sc20/runner/ContainerExperimentDescriptor.kt b/simulator/opendc-experiments/opendc-experiments-sc20/src/main/kotlin/org/opendc/experiments/sc20/runner/ContainerExperimentDescriptor.kt
deleted file mode 100644
index d70e8c9a..00000000
--- a/simulator/opendc-experiments/opendc-experiments-sc20/src/main/kotlin/org/opendc/experiments/sc20/runner/ContainerExperimentDescriptor.kt
+++ /dev/null
@@ -1,66 +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.experiments.sc20.runner
-
-import kotlinx.coroutines.launch
-import kotlinx.coroutines.supervisorScope
-import org.opendc.experiments.sc20.runner.execution.ExperimentExecutionContext
-import org.opendc.experiments.sc20.runner.execution.ExperimentExecutionResult
-
-/**
- * An abstract [ExperimentDescriptor] specifically for containers.
- */
-public abstract class ContainerExperimentDescriptor : ExperimentDescriptor() {
-    /**
-     * The child descriptors of this container.
-     */
-    public abstract val children: Sequence<ExperimentDescriptor>
-
-    override val type: Type = Type.CONTAINER
-
-    override suspend fun invoke(context: ExperimentExecutionContext) {
-        val materializedChildren = children.toList()
-        for (child in materializedChildren) {
-            context.listener.descriptorRegistered(child)
-        }
-
-        supervisorScope {
-            for (child in materializedChildren) {
-                if (child.isTrial) {
-                    launch {
-                        val worker = context.scheduler.allocate()
-                        context.listener.executionStarted(child)
-                        try {
-                            worker(child, context)
-                            context.listener.executionFinished(child, ExperimentExecutionResult.Success)
-                        } catch (e: Throwable) {
-                            context.listener.executionFinished(child, ExperimentExecutionResult.Failed(e))
-                        }
-                    }
-                } else {
-                    launch { child(context) }
-                }
-            }
-        }
-    }
-}
diff --git a/simulator/opendc-experiments/opendc-experiments-sc20/src/main/kotlin/org/opendc/experiments/sc20/runner/ExperimentDescriptor.kt b/simulator/opendc-experiments/opendc-experiments-sc20/src/main/kotlin/org/opendc/experiments/sc20/runner/ExperimentDescriptor.kt
deleted file mode 100644
index 1e67c086..00000000
--- a/simulator/opendc-experiments/opendc-experiments-sc20/src/main/kotlin/org/opendc/experiments/sc20/runner/ExperimentDescriptor.kt
+++ /dev/null
@@ -1,79 +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.experiments.sc20.runner
-
-import org.opendc.experiments.sc20.runner.execution.ExperimentExecutionContext
-import java.io.Serializable
-
-/**
- * An immutable description of an experiment in the **odcsim* simulation framework, which may be a single atomic trial
- * or a composition of multiple trials.
- *
- * This class represents a dynamic tree-like structure where the children of the nodes are not known at instantiation
- * since they might be generated dynamically.
- */
-public abstract class ExperimentDescriptor : Serializable {
-    /**
-     * The parent of this descriptor, or `null` if it has no parent.
-     */
-    public abstract val parent: ExperimentDescriptor?
-
-    /**
-     * The type of descriptor.
-     */
-    public abstract val type: Type
-
-    /**
-     * A flag to indicate that this descriptor is a root descriptor.
-     */
-    public open val isRoot: Boolean
-        get() = parent == null
-
-    /**
-     * A flag to indicate that this descriptor describes an experiment trial.
-     */
-    public val isTrial: Boolean
-        get() = type == Type.TRIAL
-
-    /**
-     * Execute this [ExperimentDescriptor].
-     *
-     * @param context The context to execute the descriptor in.
-     */
-    public abstract suspend operator fun invoke(context: ExperimentExecutionContext)
-
-    /**
-     * The types of experiment descriptors.
-     */
-    public enum class Type {
-        /**
-         * A composition of multiple experiment descriptions whose invocation happens on a single thread.
-         */
-        CONTAINER,
-
-        /**
-         * An invocation of a single scenario of an experiment whose invocation may happen on different threads.
-         */
-        TRIAL
-    }
-}
diff --git a/simulator/opendc-experiments/opendc-experiments-sc20/src/main/kotlin/org/opendc/experiments/sc20/runner/TrialExperimentDescriptor.kt b/simulator/opendc-experiments/opendc-experiments-sc20/src/main/kotlin/org/opendc/experiments/sc20/runner/TrialExperimentDescriptor.kt
deleted file mode 100644
index abc52997..00000000
--- a/simulator/opendc-experiments/opendc-experiments-sc20/src/main/kotlin/org/opendc/experiments/sc20/runner/TrialExperimentDescriptor.kt
+++ /dev/null
@@ -1,32 +0,0 @@
-/*
- * MIT License
- *
- * 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.experiments.sc20.runner
-
-/**
- * An abstract [ExperimentDescriptor] specifically for trials.
- */
-public abstract class TrialExperimentDescriptor : ExperimentDescriptor() {
-    override val type: Type = Type.TRIAL
-}
diff --git a/simulator/opendc-experiments/opendc-experiments-sc20/src/main/kotlin/org/opendc/experiments/sc20/runner/execution/ExperimentExecutionContext.kt b/simulator/opendc-experiments/opendc-experiments-sc20/src/main/kotlin/org/opendc/experiments/sc20/runner/execution/ExperimentExecutionContext.kt
deleted file mode 100644
index 942eb891..00000000
--- a/simulator/opendc-experiments/opendc-experiments-sc20/src/main/kotlin/org/opendc/experiments/sc20/runner/execution/ExperimentExecutionContext.kt
+++ /dev/null
@@ -1,45 +0,0 @@
-/*
- * MIT License
- *
- * 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.experiments.sc20.runner.execution
-
-/**
- * The execution context of an experiment.
- */
-public interface ExperimentExecutionContext {
-    /**
-     * The execution listener to use.
-     */
-    public val listener: ExperimentExecutionListener
-
-    /**
-     * The experiment scheduler to use.
-     */
-    public val scheduler: ExperimentScheduler
-
-    /**
-     * A cache for objects within a single runner.
-     */
-    public val cache: MutableMap<Any?, Any?>
-}
diff --git a/simulator/opendc-experiments/opendc-experiments-sc20/src/main/kotlin/org/opendc/experiments/sc20/runner/execution/ExperimentExecutionListener.kt b/simulator/opendc-experiments/opendc-experiments-sc20/src/main/kotlin/org/opendc/experiments/sc20/runner/execution/ExperimentExecutionListener.kt
deleted file mode 100644
index 42fef164..00000000
--- a/simulator/opendc-experiments/opendc-experiments-sc20/src/main/kotlin/org/opendc/experiments/sc20/runner/execution/ExperimentExecutionListener.kt
+++ /dev/null
@@ -1,46 +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.experiments.sc20.runner.execution
-
-import org.opendc.experiments.sc20.runner.ExperimentDescriptor
-
-/**
- * Listener to be notified of experiment execution events by experiment runners.
- */
-public interface ExperimentExecutionListener {
-    /**
-     * A method that is invoked when a new [ExperimentDescriptor] is registered.
-     */
-    public fun descriptorRegistered(descriptor: ExperimentDescriptor)
-
-    /**
-     * A method that is invoked when when the execution of a leaf or subtree of the experiment tree has finished,
-     * regardless of the outcome.
-     */
-    public fun executionFinished(descriptor: ExperimentDescriptor, result: ExperimentExecutionResult)
-
-    /**
-     * A method that is invoked when the execution of a leaf or subtree of the experiment tree is about to be started.
-     */
-    public fun executionStarted(descriptor: ExperimentDescriptor)
-}
diff --git a/simulator/opendc-experiments/opendc-experiments-sc20/src/main/kotlin/org/opendc/experiments/sc20/runner/execution/ExperimentExecutionResult.kt b/simulator/opendc-experiments/opendc-experiments-sc20/src/main/kotlin/org/opendc/experiments/sc20/runner/execution/ExperimentExecutionResult.kt
deleted file mode 100644
index a765c264..00000000
--- a/simulator/opendc-experiments/opendc-experiments-sc20/src/main/kotlin/org/opendc/experiments/sc20/runner/execution/ExperimentExecutionResult.kt
+++ /dev/null
@@ -1,42 +0,0 @@
-/*
- * MIT License
- *
- * 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.experiments.sc20.runner.execution
-
-import java.io.Serializable
-
-/**
- * The result of executing an experiment.
- */
-public sealed class ExperimentExecutionResult : Serializable {
-    /**
-     * The experiment executed successfully
-     */
-    public object Success : ExperimentExecutionResult()
-
-    /**
-     * The experiment failed during execution.
-     */
-    public data class Failed(val throwable: Throwable) : ExperimentExecutionResult()
-}
diff --git a/simulator/opendc-experiments/opendc-experiments-sc20/src/main/kotlin/org/opendc/experiments/sc20/runner/execution/ExperimentScheduler.kt b/simulator/opendc-experiments/opendc-experiments-sc20/src/main/kotlin/org/opendc/experiments/sc20/runner/execution/ExperimentScheduler.kt
deleted file mode 100644
index 70095ccd..00000000
--- a/simulator/opendc-experiments/opendc-experiments-sc20/src/main/kotlin/org/opendc/experiments/sc20/runner/execution/ExperimentScheduler.kt
+++ /dev/null
@@ -1,56 +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.experiments.sc20.runner.execution
-
-import org.opendc.experiments.sc20.runner.ExperimentDescriptor
-import java.io.Closeable
-
-/**
- * A interface for scheduling the execution of experiment trials over compute resources (threads/containers/vms)
- */
-public interface ExperimentScheduler : Closeable {
-    /**
-     * Allocate a [Worker] for executing an experiment trial. This method may suspend in case no resources are directly
-     * available at the moment.
-     *
-     * @return The available worker.
-     */
-    public suspend fun allocate(): ExperimentScheduler.Worker
-
-    /**
-     * An isolated worker of an [ExperimentScheduler] that is responsible for executing a single experiment trial.
-     */
-    public interface Worker {
-        /**
-         * Dispatch the specified [ExperimentDescriptor] to execute some time in the future and return the results of
-         * the trial.
-         *
-         * @param descriptor The descriptor to execute.
-         * @param context The context to execute the descriptor in.
-         */
-        public suspend operator fun invoke(
-            descriptor: ExperimentDescriptor,
-            context: ExperimentExecutionContext
-        )
-    }
-}
diff --git a/simulator/opendc-experiments/opendc-experiments-sc20/src/main/kotlin/org/opendc/experiments/sc20/runner/execution/ThreadPoolExperimentScheduler.kt b/simulator/opendc-experiments/opendc-experiments-sc20/src/main/kotlin/org/opendc/experiments/sc20/runner/execution/ThreadPoolExperimentScheduler.kt
deleted file mode 100644
index 942faed1..00000000
--- a/simulator/opendc-experiments/opendc-experiments-sc20/src/main/kotlin/org/opendc/experiments/sc20/runner/execution/ThreadPoolExperimentScheduler.kt
+++ /dev/null
@@ -1,83 +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.experiments.sc20.runner.execution
-
-import kotlinx.coroutines.asCoroutineDispatcher
-import kotlinx.coroutines.launch
-import kotlinx.coroutines.supervisorScope
-import kotlinx.coroutines.sync.Semaphore
-import kotlinx.coroutines.withContext
-import org.opendc.experiments.sc20.runner.ExperimentDescriptor
-import java.util.concurrent.Executors
-
-/**
- * An [ExperimentScheduler] that runs experiments using a local thread pool.
- *
- * @param parallelism The maximum amount of parallel workers (default is the number of available processors).
- */
-public class ThreadPoolExperimentScheduler(parallelism: Int = Runtime.getRuntime().availableProcessors() + 1) : ExperimentScheduler {
-    private val dispatcher = Executors.newCachedThreadPool().asCoroutineDispatcher()
-    private val tickets = Semaphore(parallelism)
-
-    override suspend fun allocate(): ExperimentScheduler.Worker {
-        tickets.acquire()
-        return object : ExperimentScheduler.Worker {
-            override suspend fun invoke(
-                descriptor: ExperimentDescriptor,
-                context: ExperimentExecutionContext
-            ) = supervisorScope {
-                val listener =
-                    object : ExperimentExecutionListener {
-                        override fun descriptorRegistered(descriptor: ExperimentDescriptor) {
-                            launch { context.listener.descriptorRegistered(descriptor) }
-                        }
-
-                        override fun executionFinished(
-                            descriptor: ExperimentDescriptor,
-                            result: ExperimentExecutionResult
-                        ) {
-                            launch { context.listener.executionFinished(descriptor, result) }
-                        }
-
-                        override fun executionStarted(descriptor: ExperimentDescriptor) {
-                            launch { context.listener.executionStarted(descriptor) }
-                        }
-                    }
-
-                val newContext = object : ExperimentExecutionContext by context {
-                    override val listener: ExperimentExecutionListener = listener
-                }
-
-                try {
-                    withContext(dispatcher) {
-                        descriptor(newContext)
-                    }
-                } finally {
-                    tickets.release()
-                }
-            }
-        }
-    }
-
-    override fun close(): Unit = dispatcher.close()
-}
diff --git a/simulator/opendc-experiments/opendc-experiments-sc20/src/main/kotlin/org/opendc/experiments/sc20/runner/internal/DefaultExperimentRunner.kt b/simulator/opendc-experiments/opendc-experiments-sc20/src/main/kotlin/org/opendc/experiments/sc20/runner/internal/DefaultExperimentRunner.kt
deleted file mode 100644
index 26e4df89..00000000
--- a/simulator/opendc-experiments/opendc-experiments-sc20/src/main/kotlin/org/opendc/experiments/sc20/runner/internal/DefaultExperimentRunner.kt
+++ /dev/null
@@ -1,60 +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.experiments.sc20.runner.internal
-
-import kotlinx.coroutines.runBlocking
-import org.opendc.experiments.sc20.runner.ExperimentDescriptor
-import org.opendc.experiments.sc20.runner.ExperimentRunner
-import org.opendc.experiments.sc20.runner.execution.ExperimentExecutionContext
-import org.opendc.experiments.sc20.runner.execution.ExperimentExecutionListener
-import org.opendc.experiments.sc20.runner.execution.ExperimentExecutionResult
-import org.opendc.experiments.sc20.runner.execution.ExperimentScheduler
-import java.util.concurrent.ConcurrentHashMap
-
-/**
- * The default implementation of the [ExperimentRunner] interface.
- *
- * @param scheduler The scheduler to use.
- */
-public class DefaultExperimentRunner(private val scheduler: ExperimentScheduler) : ExperimentRunner {
-    override val id: String = "default"
-
-    override val version: String? = "1.0"
-
-    override fun execute(root: ExperimentDescriptor, listener: ExperimentExecutionListener): Unit = runBlocking {
-        val context = object : ExperimentExecutionContext {
-            override val listener: ExperimentExecutionListener = listener
-            override val scheduler: ExperimentScheduler = this@DefaultExperimentRunner.scheduler
-            override val cache: MutableMap<Any?, Any?> = ConcurrentHashMap()
-        }
-
-        listener.descriptorRegistered(root)
-        context.listener.executionStarted(root)
-        try {
-            root(context)
-            context.listener.executionFinished(root, ExperimentExecutionResult.Success)
-        } catch (e: Throwable) {
-            context.listener.executionFinished(root, ExperimentExecutionResult.Failed(e))
-        }
-    }
-}
diff --git a/simulator/opendc-experiments/opendc-experiments-sc20/src/main/kotlin/org/opendc/experiments/sc20/telemetry/RunEvent.kt b/simulator/opendc-experiments/opendc-experiments-sc20/src/main/kotlin/org/opendc/experiments/sc20/telemetry/RunEvent.kt
index 3bcd10a1..4f4706f0 100644
--- a/simulator/opendc-experiments/opendc-experiments-sc20/src/main/kotlin/org/opendc/experiments/sc20/telemetry/RunEvent.kt
+++ b/simulator/opendc-experiments/opendc-experiments-sc20/src/main/kotlin/org/opendc/experiments/sc20/telemetry/RunEvent.kt
@@ -22,12 +22,13 @@
 
 package org.opendc.experiments.sc20.telemetry
 
-import org.opendc.experiments.sc20.experiment.Run
+import org.opendc.experiments.sc20.experiment.Portfolio
 
 /**
  * A periodic report of the host machine metrics.
  */
 public data class RunEvent(
-    public val run: Run,
+    val portfolio: Portfolio,
+    val repeat: Int,
     override val timestamp: Long
 ) : Event("run")
diff --git a/simulator/opendc-experiments/opendc-experiments-sc20/src/main/kotlin/org/opendc/experiments/sc20/telemetry/parquet/ParquetRunEventWriter.kt b/simulator/opendc-experiments/opendc-experiments-sc20/src/main/kotlin/org/opendc/experiments/sc20/telemetry/parquet/ParquetRunEventWriter.kt
index 74efb660..b50a698c 100644
--- a/simulator/opendc-experiments/opendc-experiments-sc20/src/main/kotlin/org/opendc/experiments/sc20/telemetry/parquet/ParquetRunEventWriter.kt
+++ b/simulator/opendc-experiments/opendc-experiments-sc20/src/main/kotlin/org/opendc/experiments/sc20/telemetry/parquet/ParquetRunEventWriter.kt
@@ -38,33 +38,27 @@ public class ParquetRunEventWriter(path: File, bufferSize: Int) :
 
     public companion object {
         private val convert: (RunEvent, GenericData.Record) -> Unit = { event, record ->
-            val run = event.run
-            val scenario = run.parent
-            val portfolio = scenario.parent
-            record.put("portfolio_id", portfolio.id)
+            val portfolio = event.portfolio
             record.put("portfolio_name", portfolio.name)
-            record.put("scenario_id", scenario.id)
-            record.put("run_id", run.id)
-            record.put("repetitions", scenario.repetitions)
-            record.put("topology", scenario.topology.name)
-            record.put("workload_name", scenario.workload.name)
-            record.put("workload_fraction", scenario.workload.fraction)
-            record.put("workload_sampler", scenario.workload.samplingStrategy)
-            record.put("allocation_policy", scenario.allocationPolicy)
-            record.put("failure_frequency", scenario.operationalPhenomena.failureFrequency)
-            record.put("interference", scenario.operationalPhenomena.hasInterference)
-            record.put("seed", run.seed)
+            record.put("scenario_id", portfolio.id)
+            record.put("run_id", event.repeat)
+            record.put("topology", portfolio.topology.name)
+            record.put("workload_name", portfolio.workload.name)
+            record.put("workload_fraction", portfolio.workload.fraction)
+            record.put("workload_sampler", portfolio.workload.samplingStrategy)
+            record.put("allocation_policy", portfolio.allocationPolicy)
+            record.put("failure_frequency", portfolio.operationalPhenomena.failureFrequency)
+            record.put("interference", portfolio.operationalPhenomena.hasInterference)
+            record.put("seed", event.repeat)
         }
 
         private val schema: Schema = SchemaBuilder
             .record("runs")
             .namespace("org.opendc.experiments.sc20")
             .fields()
-            .name("portfolio_id").type().intType().noDefault()
             .name("portfolio_name").type().stringType().noDefault()
             .name("scenario_id").type().intType().noDefault()
             .name("run_id").type().intType().noDefault()
-            .name("repetitions").type().intType().noDefault()
             .name("topology").type().stringType().noDefault()
             .name("workload_name").type().stringType().noDefault()
             .name("workload_fraction").type().doubleType().noDefault()