refactored opendc-experiment-compute (#190)

* removed experiment-compute and integrated all components into opendc-compute

* updated workflow gradle file

* removed unneeded code

10 files changed, 799 insertions, 0 deletions

diff --git a/opendc-compute/opendc-compute-workload/build.gradle.kts b/opendc-compute/opendc-compute-workload/build.gradle.kts
new file mode 100644
index 00000000..905f905c
--- /dev/null
+++ b/opendc-compute/opendc-compute-workload/build.gradle.kts
@@ -0,0 +1,37 @@
+/*
+ * 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.
+ */
+
+description = "OpenDC Compute Service implementation"
+
+/* Build configuration */
+plugins {
+    `kotlin-library-conventions`
+}
+
+dependencies {
+    api(projects.opendcCompute.opendcComputeApi)
+    implementation(projects.opendcCommon)
+    implementation(project(mapOf("path" to ":opendc-trace:opendc-trace-api")))
+    implementation(project(mapOf("path" to ":opendc-simulator:opendc-simulator-compute")))
+
+    implementation(libs.kotlin.logging)
+}
diff --git a/opendc-compute/opendc-compute-workload/src/main/kotlin/org/opendc/compute/workload/ComputeWorkload.kt b/opendc-compute/opendc-compute-workload/src/main/kotlin/org/opendc/compute/workload/ComputeWorkload.kt
new file mode 100644
index 00000000..a802afdb
--- /dev/null
+++ b/opendc-compute/opendc-compute-workload/src/main/kotlin/org/opendc/compute/workload/ComputeWorkload.kt
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2021 AtLarge Research
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package org.opendc.compute.workload
+
+import java.util.random.RandomGenerator
+
+/**
+ * An interface that describes how a workload is resolved.
+ */
+public interface ComputeWorkload {
+    /**
+     * Resolve the workload into a list of [VirtualMachine]s to simulate.
+     */
+    public fun resolve(loader: ComputeWorkloadLoader, random: RandomGenerator): List<VirtualMachine>
+}
diff --git a/opendc-compute/opendc-compute-workload/src/main/kotlin/org/opendc/compute/workload/ComputeWorkloadLoader.kt b/opendc-compute/opendc-compute-workload/src/main/kotlin/org/opendc/compute/workload/ComputeWorkloadLoader.kt
new file mode 100644
index 00000000..c5fb3e56
--- /dev/null
+++ b/opendc-compute/opendc-compute-workload/src/main/kotlin/org/opendc/compute/workload/ComputeWorkloadLoader.kt
@@ -0,0 +1,266 @@
+/*
+ * Copyright (c) 2021 AtLarge Research
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package org.opendc.compute.workload
+
+import mu.KotlinLogging
+import org.opendc.simulator.compute.kernel.interference.VmInterferenceModel
+import org.opendc.simulator.compute.workload.SimTrace
+import org.opendc.trace.Trace
+import org.opendc.trace.conv.INTERFERENCE_GROUP_MEMBERS
+import org.opendc.trace.conv.INTERFERENCE_GROUP_SCORE
+import org.opendc.trace.conv.INTERFERENCE_GROUP_TARGET
+import org.opendc.trace.conv.RESOURCE_CPU_CAPACITY
+import org.opendc.trace.conv.RESOURCE_CPU_COUNT
+import org.opendc.trace.conv.RESOURCE_ID
+import org.opendc.trace.conv.RESOURCE_MEM_CAPACITY
+import org.opendc.trace.conv.RESOURCE_START_TIME
+import org.opendc.trace.conv.RESOURCE_STATE_CPU_USAGE
+import org.opendc.trace.conv.RESOURCE_STATE_DURATION
+import org.opendc.trace.conv.RESOURCE_STATE_TIMESTAMP
+import org.opendc.trace.conv.RESOURCE_STOP_TIME
+import org.opendc.trace.conv.TABLE_INTERFERENCE_GROUPS
+import org.opendc.trace.conv.TABLE_RESOURCES
+import org.opendc.trace.conv.TABLE_RESOURCE_STATES
+import java.io.File
+import java.lang.ref.SoftReference
+import java.time.Duration
+import java.time.Instant
+import java.util.UUID
+import java.util.concurrent.ConcurrentHashMap
+import kotlin.math.roundToLong
+
+/**
+ * A helper class for loading compute workload traces into memory.
+ *
+ * @param baseDir The directory containing the traces.
+ */
+public class ComputeWorkloadLoader(private val baseDir: File) {
+    /**
+     * The logger for this instance.
+     */
+    private val logger = KotlinLogging.logger {}
+
+    /**
+     * The cache of workloads.
+     */
+    private val cache = ConcurrentHashMap<String, SoftReference<List<VirtualMachine>>>()
+
+    /**
+     * Read the fragments into memory.
+     */
+    private fun parseFragments(trace: Trace): Map<String, Builder> {
+        val reader = checkNotNull(trace.getTable(TABLE_RESOURCE_STATES)).newReader()
+
+        val idCol = reader.resolve(RESOURCE_ID)
+        val timestampCol = reader.resolve(RESOURCE_STATE_TIMESTAMP)
+        val durationCol = reader.resolve(RESOURCE_STATE_DURATION)
+        val coresCol = reader.resolve(RESOURCE_CPU_COUNT)
+        val usageCol = reader.resolve(RESOURCE_STATE_CPU_USAGE)
+
+        val fragments = mutableMapOf<String, Builder>()
+
+        return try {
+            while (reader.nextRow()) {
+                val id = reader.getString(idCol)!!
+                val time = reader.getInstant(timestampCol)!!
+                val durationMs = reader.getDuration(durationCol)!!
+                val cores = reader.getInt(coresCol)
+                val cpuUsage = reader.getDouble(usageCol)
+
+                val builder = fragments.computeIfAbsent(id) { Builder() }
+                builder.add(time, durationMs, cpuUsage, cores)
+            }
+
+            fragments
+        } finally {
+            reader.close()
+        }
+    }
+
+    /**
+     * Read the metadata into a workload.
+     */
+    private fun parseMeta(trace: Trace, fragments: Map<String, Builder>, interferenceModel: VmInterferenceModel): List<VirtualMachine> {
+        val reader = checkNotNull(trace.getTable(TABLE_RESOURCES)).newReader()
+
+        val idCol = reader.resolve(RESOURCE_ID)
+        val startTimeCol = reader.resolve(RESOURCE_START_TIME)
+        val stopTimeCol = reader.resolve(RESOURCE_STOP_TIME)
+        val cpuCountCol = reader.resolve(RESOURCE_CPU_COUNT)
+        val cpuCapacityCol = reader.resolve(RESOURCE_CPU_CAPACITY)
+        val memCol = reader.resolve(RESOURCE_MEM_CAPACITY)
+
+        var counter = 0
+        val entries = mutableListOf<VirtualMachine>()
+
+        return try {
+            while (reader.nextRow()) {
+                val id = reader.getString(idCol)!!
+                if (!fragments.containsKey(id)) {
+                    continue
+                }
+
+                val submissionTime = reader.getInstant(startTimeCol)!!
+                val endTime = reader.getInstant(stopTimeCol)!!
+                val cpuCount = reader.getInt(cpuCountCol)
+                val cpuCapacity = reader.getDouble(cpuCapacityCol)
+                val memCapacity = reader.getDouble(memCol) / 1000.0 // Convert from KB to MB
+                val uid = UUID.nameUUIDFromBytes("$id-${counter++}".toByteArray())
+
+                val builder = fragments.getValue(id)
+                val totalLoad = builder.totalLoad
+
+                entries.add(
+                    VirtualMachine(
+                        uid,
+                        id,
+                        cpuCount,
+                        cpuCapacity,
+                        memCapacity.roundToLong(),
+                        totalLoad,
+                        submissionTime,
+                        endTime,
+                        builder.build(),
+                        interferenceModel.getProfile(id)
+                    )
+                )
+            }
+
+            // Make sure the virtual machines are ordered by start time
+            entries.sortBy { it.startTime }
+
+            entries
+        } catch (e: Exception) {
+            e.printStackTrace()
+            throw e
+        } finally {
+            reader.close()
+        }
+    }
+
+    /**
+     * Read the interference model associated with the specified [trace].
+     */
+    private fun parseInterferenceModel(trace: Trace): VmInterferenceModel {
+        val reader = checkNotNull(trace.getTable(TABLE_INTERFERENCE_GROUPS)).newReader()
+
+        return try {
+            val membersCol = reader.resolve(INTERFERENCE_GROUP_MEMBERS)
+            val targetCol = reader.resolve(INTERFERENCE_GROUP_TARGET)
+            val scoreCol = reader.resolve(INTERFERENCE_GROUP_SCORE)
+
+            val modelBuilder = VmInterferenceModel.builder()
+
+            while (reader.nextRow()) {
+                val members = reader.getSet(membersCol, String::class.java)!!
+                val target = reader.getDouble(targetCol)
+                val score = reader.getDouble(scoreCol)
+
+                modelBuilder
+                    .addGroup(members, target, score)
+            }
+
+            modelBuilder.build()
+        } finally {
+            reader.close()
+        }
+    }
+
+    /**
+     * Load the trace with the specified [name] and [format].
+     */
+    public fun get(name: String, format: String): List<VirtualMachine> {
+        val ref = cache.compute(name) { key, oldVal ->
+            val inst = oldVal?.get()
+            if (inst == null) {
+                val path = baseDir.resolve(key)
+
+                logger.info { "Loading trace $key at $path" }
+
+                val trace = Trace.open(path, format)
+                val fragments = parseFragments(trace)
+                val interferenceModel = parseInterferenceModel(trace)
+                val vms = parseMeta(trace, fragments, interferenceModel)
+
+                SoftReference(vms)
+            } else {
+                oldVal
+            }
+        }
+
+        return checkNotNull(ref?.get()) { "Memory pressure" }
+    }
+
+    /**
+     * Clear the workload cache.
+     */
+    public fun reset() {
+        cache.clear()
+    }
+
+    /**
+     * A builder for a VM trace.
+     */
+    private class Builder {
+        /**
+         * The total load of the trace.
+         */
+        @JvmField var totalLoad: Double = 0.0
+
+        /**
+         * The internal builder for the trace.
+         */
+        private val builder = SimTrace.builder()
+
+        /**
+         * The deadline of the previous fragment.
+         */
+        private var previousDeadline = Long.MIN_VALUE
+
+        /**
+         * Add a fragment to the trace.
+         *
+         * @param timestamp Timestamp at which the fragment starts (in epoch millis).
+         * @param deadline Timestamp at which the fragment ends (in epoch millis).
+         * @param usage CPU usage of this fragment.
+         * @param cores Number of cores used.
+         */
+        fun add(deadline: Instant, duration: Duration, usage: Double, cores: Int) {
+            val startTimeMs = (deadline - duration).toEpochMilli()
+            totalLoad += (usage * duration.toMillis()) / 1000.0 // avg MHz * duration = MFLOPs
+
+            if ((startTimeMs != previousDeadline) && (previousDeadline != Long.MIN_VALUE)) {
+                // There is a gap between the previous and current fragment; fill the gap
+                builder.add(startTimeMs, 0.0, cores)
+            }
+
+            builder.add(deadline.toEpochMilli(), usage, cores)
+            previousDeadline = deadline.toEpochMilli()
+        }
+
+        /**
+         * Build the trace.
+         */
+        fun build(): SimTrace = builder.build()
+    }
+}
diff --git a/opendc-compute/opendc-compute-workload/src/main/kotlin/org/opendc/compute/workload/ComputeWorkloads.kt b/opendc-compute/opendc-compute-workload/src/main/kotlin/org/opendc/compute/workload/ComputeWorkloads.kt
new file mode 100644
index 00000000..61a6e3a0
--- /dev/null
+++ b/opendc-compute/opendc-compute-workload/src/main/kotlin/org/opendc/compute/workload/ComputeWorkloads.kt
@@ -0,0 +1,63 @@
+/*
+ * 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.
+ */
+
+@file:JvmName("ComputeWorkloads")
+
+package org.opendc.compute.workload
+
+import org.opendc.compute.workload.internal.CompositeComputeWorkload
+import org.opendc.compute.workload.internal.HpcSampledComputeWorkload
+import org.opendc.compute.workload.internal.LoadSampledComputeWorkload
+import org.opendc.compute.workload.internal.TraceComputeWorkload
+
+/**
+ * Construct a workload from a trace.
+ */
+public fun trace(name: String, format: String = "opendc-vm"): ComputeWorkload = TraceComputeWorkload(name, format)
+
+/**
+ * Construct a composite workload with the specified fractions.
+ */
+public fun composite(vararg pairs: Pair<ComputeWorkload, Double>): ComputeWorkload {
+    return CompositeComputeWorkload(pairs.toMap())
+}
+
+/**
+ * Sample a workload by a [fraction] of the total load.
+ */
+public fun ComputeWorkload.sampleByLoad(fraction: Double): ComputeWorkload {
+    return LoadSampledComputeWorkload(this, fraction)
+}
+
+/**
+ * Sample a workload by a [fraction] of the HPC VMs (count)
+ */
+public fun ComputeWorkload.sampleByHpc(fraction: Double): ComputeWorkload {
+    return HpcSampledComputeWorkload(this, fraction)
+}
+
+/**
+ * Sample a workload by a [fraction] of the HPC load
+ */
+public fun ComputeWorkload.sampleByHpcLoad(fraction: Double): ComputeWorkload {
+    return HpcSampledComputeWorkload(this, fraction, sampleLoad = true)
+}
diff --git a/opendc-compute/opendc-compute-workload/src/main/kotlin/org/opendc/compute/workload/VirtualMachine.kt b/opendc-compute/opendc-compute-workload/src/main/kotlin/org/opendc/compute/workload/VirtualMachine.kt
new file mode 100644
index 00000000..622b3c55
--- /dev/null
+++ b/opendc-compute/opendc-compute-workload/src/main/kotlin/org/opendc/compute/workload/VirtualMachine.kt
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) 2021 AtLarge Research
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package org.opendc.compute.workload
+
+import org.opendc.simulator.compute.kernel.interference.VmInterferenceProfile
+import org.opendc.simulator.compute.workload.SimTrace
+import java.time.Instant
+import java.util.UUID
+
+/**
+ * A virtual machine workload.
+ *
+ * @param uid The unique identifier of the virtual machine.
+ * @param name The name of the virtual machine.
+ * @param cpuCapacity The required CPU capacity for the VM in MHz.
+ * @param cpuCount The number of vCPUs in the VM.
+ * @param memCapacity The provisioned memory for the VM in MB.
+ * @param startTime The start time of the VM.
+ * @param stopTime The stop time of the VM.
+ * @param trace The trace that belong to this VM.
+ * @param interferenceProfile The interference profile of this virtual machine.
+ */
+public data class VirtualMachine(
+    val uid: UUID,
+    val name: String,
+    val cpuCount: Int,
+    val cpuCapacity: Double,
+    val memCapacity: Long,
+    val totalLoad: Double,
+    val startTime: Instant,
+    val stopTime: Instant,
+    val trace: SimTrace,
+    val interferenceProfile: VmInterferenceProfile?
+)
diff --git a/opendc-compute/opendc-compute-workload/src/main/kotlin/org/opendc/compute/workload/internal/CompositeComputeWorkload.kt b/opendc-compute/opendc-compute-workload/src/main/kotlin/org/opendc/compute/workload/internal/CompositeComputeWorkload.kt
new file mode 100644
index 00000000..1ac5f4ad
--- /dev/null
+++ b/opendc-compute/opendc-compute-workload/src/main/kotlin/org/opendc/compute/workload/internal/CompositeComputeWorkload.kt
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) 2021 AtLarge Research
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package org.opendc.compute.workload.internal
+
+import mu.KotlinLogging
+import org.opendc.compute.workload.ComputeWorkload
+import org.opendc.compute.workload.ComputeWorkloadLoader
+import org.opendc.compute.workload.VirtualMachine
+import java.util.random.RandomGenerator
+
+/**
+ * A [ComputeWorkload] that samples multiple workloads based on the total load of all workloads.
+ */
+internal class CompositeComputeWorkload(val sources: Map<ComputeWorkload, Double>) : ComputeWorkload {
+    /**
+     * The logging instance of this class.
+     */
+    private val logger = KotlinLogging.logger {}
+
+    override fun resolve(loader: ComputeWorkloadLoader, random: RandomGenerator): List<VirtualMachine> {
+        val traces = sources.map { (source, fraction) -> fraction to source.resolve(loader, random) }
+
+        val totalLoad = traces.sumOf { (_, vms) -> vms.sumOf { it.totalLoad } }
+
+        val res = mutableListOf<VirtualMachine>()
+
+        for ((fraction, vms) in traces) {
+            var currentLoad = 0.0
+
+            for (entry in vms) {
+                val entryLoad = entry.totalLoad
+                if ((currentLoad + entryLoad) / totalLoad > fraction) {
+                    break
+                }
+
+                currentLoad += entryLoad
+                res += entry
+            }
+        }
+
+        val vmCount = traces.sumOf { (_, vms) -> vms.size }
+        logger.info { "Sampled $vmCount VMs into subset of ${res.size} VMs" }
+
+        return res
+    }
+}
diff --git a/opendc-compute/opendc-compute-workload/src/main/kotlin/org/opendc/compute/workload/internal/HpcSampledComputeWorkload.kt b/opendc-compute/opendc-compute-workload/src/main/kotlin/org/opendc/compute/workload/internal/HpcSampledComputeWorkload.kt
new file mode 100644
index 00000000..fdb599c1
--- /dev/null
+++ b/opendc-compute/opendc-compute-workload/src/main/kotlin/org/opendc/compute/workload/internal/HpcSampledComputeWorkload.kt
@@ -0,0 +1,142 @@
+/*
+ * Copyright (c) 2021 AtLarge Research
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package org.opendc.compute.workload.internal
+
+import mu.KotlinLogging
+import org.opendc.compute.workload.ComputeWorkload
+import org.opendc.compute.workload.ComputeWorkloadLoader
+import org.opendc.compute.workload.VirtualMachine
+import java.util.UUID
+import java.util.random.RandomGenerator
+
+/**
+ * A [ComputeWorkload] that samples HPC VMs in the workload.
+ *
+ * @param fraction The fraction of load/virtual machines to sample
+ * @param sampleLoad A flag to indicate that the sampling should be based on the total load or on the number of VMs.
+ */
+internal class HpcSampledComputeWorkload(val source: ComputeWorkload, val fraction: Double, val sampleLoad: Boolean = false) : ComputeWorkload {
+    /**
+     * The logging instance of this class.
+     */
+    private val logger = KotlinLogging.logger {}
+
+    /**
+     * The pattern to match compute nodes in the workload.
+     */
+    private val pattern = Regex("^(ComputeNode|cn).*")
+
+    override fun resolve(loader: ComputeWorkloadLoader, random: RandomGenerator): List<VirtualMachine> {
+        val vms = source.resolve(loader, random)
+
+        val (hpc, nonHpc) = vms.partition { entry ->
+            val name = entry.name
+            name.matches(pattern)
+        }
+
+        val hpcSequence = generateSequence(0) { it + 1 }
+            .map { index ->
+                val res = mutableListOf<VirtualMachine>()
+                hpc.mapTo(res) { sample(it, index) }
+                res
+            }
+            .flatten()
+
+        val nonHpcSequence = generateSequence(0) { it + 1 }
+            .map { index ->
+                val res = mutableListOf<VirtualMachine>()
+                nonHpc.mapTo(res) { sample(it, index) }
+                res
+            }
+            .flatten()
+
+        logger.debug { "Found ${hpc.size} HPC workloads and ${nonHpc.size} non-HPC workloads" }
+
+        val totalLoad = vms.sumOf { it.totalLoad }
+
+        logger.debug { "Total trace load: $totalLoad" }
+        var hpcCount = 0
+        var hpcLoad = 0.0
+        var nonHpcCount = 0
+        var nonHpcLoad = 0.0
+
+        val res = mutableListOf<VirtualMachine>()
+
+        if (sampleLoad) {
+            var currentLoad = 0.0
+            for (entry in hpcSequence) {
+                val entryLoad = entry.totalLoad
+                if ((currentLoad + entryLoad) / totalLoad > fraction) {
+                    break
+                }
+
+                hpcLoad += entryLoad
+                hpcCount += 1
+                currentLoad += entryLoad
+                res += entry
+            }
+
+            for (entry in nonHpcSequence) {
+                val entryLoad = entry.totalLoad
+                if ((currentLoad + entryLoad) / totalLoad > 1) {
+                    break
+                }
+
+                nonHpcLoad += entryLoad
+                nonHpcCount += 1
+                currentLoad += entryLoad
+                res += entry
+            }
+        } else {
+            hpcSequence
+                .take((fraction * vms.size).toInt())
+                .forEach { entry ->
+                    hpcLoad += entry.totalLoad
+                    hpcCount += 1
+                    res.add(entry)
+                }
+
+            nonHpcSequence
+                .take(((1 - fraction) * vms.size).toInt())
+                .forEach { entry ->
+                    nonHpcLoad += entry.totalLoad
+                    nonHpcCount += 1
+                    res.add(entry)
+                }
+        }
+
+        logger.debug { "HPC $hpcCount (load $hpcLoad) and non-HPC $nonHpcCount (load $nonHpcLoad)" }
+        logger.debug { "Total sampled load: ${hpcLoad + nonHpcLoad}" }
+        logger.info { "Sampled ${vms.size} VMs (fraction $fraction) into subset of ${res.size} VMs" }
+
+        return res
+    }
+
+    /**
+     * Sample a random trace entry.
+     */
+    private fun sample(entry: VirtualMachine, i: Int): VirtualMachine {
+        val uid = UUID.nameUUIDFromBytes("${entry.uid}-$i".toByteArray())
+        return entry.copy(uid = uid)
+    }
+}
diff --git a/opendc-compute/opendc-compute-workload/src/main/kotlin/org/opendc/compute/workload/internal/LoadSampledComputeWorkload.kt b/opendc-compute/opendc-compute-workload/src/main/kotlin/org/opendc/compute/workload/internal/LoadSampledComputeWorkload.kt
new file mode 100644
index 00000000..6014f37a
--- /dev/null
+++ b/opendc-compute/opendc-compute-workload/src/main/kotlin/org/opendc/compute/workload/internal/LoadSampledComputeWorkload.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.compute.workload.internal
+
+import mu.KotlinLogging
+import org.opendc.compute.workload.ComputeWorkload
+import org.opendc.compute.workload.ComputeWorkloadLoader
+import org.opendc.compute.workload.VirtualMachine
+import java.util.random.RandomGenerator
+
+/**
+ * A [ComputeWorkload] that is sampled based on total load.
+ */
+internal class LoadSampledComputeWorkload(val source: ComputeWorkload, val fraction: Double) : ComputeWorkload {
+    /**
+     * The logging instance of this class.
+     */
+    private val logger = KotlinLogging.logger {}
+
+    override fun resolve(loader: ComputeWorkloadLoader, random: RandomGenerator): List<VirtualMachine> {
+        val vms = source.resolve(loader, random)
+        val res = mutableListOf<VirtualMachine>()
+
+        val totalLoad = vms.sumOf { it.totalLoad }
+        var currentLoad = 0.0
+
+        for (entry in vms) {
+            val entryLoad = entry.totalLoad
+            if ((currentLoad + entryLoad) / totalLoad > fraction) {
+                break
+            }
+
+            currentLoad += entryLoad
+            res += entry
+        }
+
+        logger.info { "Sampled ${vms.size} VMs (fraction $fraction) into subset of ${res.size} VMs" }
+
+        return res
+    }
+}
diff --git a/opendc-compute/opendc-compute-workload/src/main/kotlin/org/opendc/compute/workload/internal/TraceComputeWorkload.kt b/opendc-compute/opendc-compute-workload/src/main/kotlin/org/opendc/compute/workload/internal/TraceComputeWorkload.kt
new file mode 100644
index 00000000..ff88fa3e
--- /dev/null
+++ b/opendc-compute/opendc-compute-workload/src/main/kotlin/org/opendc/compute/workload/internal/TraceComputeWorkload.kt
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2021 AtLarge Research
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package org.opendc.compute.workload.internal
+
+import org.opendc.compute.workload.ComputeWorkload
+import org.opendc.compute.workload.ComputeWorkloadLoader
+import org.opendc.compute.workload.VirtualMachine
+import java.util.random.RandomGenerator
+
+/**
+ * A [ComputeWorkload] from a trace.
+ */
+internal class TraceComputeWorkload(val name: String, val format: String) : ComputeWorkload {
+    override fun resolve(loader: ComputeWorkloadLoader, random: RandomGenerator): List<VirtualMachine> {
+        return loader.get(name, format)
+    }
+}
diff --git a/opendc-compute/opendc-compute-workload/src/test/resources/log4j2.xml b/opendc-compute/opendc-compute-workload/src/test/resources/log4j2.xml
new file mode 100644
index 00000000..0dfb75f2
--- /dev/null
+++ b/opendc-compute/opendc-compute-workload/src/test/resources/log4j2.xml
@@ -0,0 +1,38 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+  ~ 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.
+  -->
+
+<Configuration status="WARN" packages="org.apache.logging.log4j.core">
+    <Appenders>
+        <Console name="Console" target="SYSTEM_OUT">
+            <PatternLayout pattern="%d{HH:mm:ss.SSS} [%highlight{%-5level}] %logger{36} - %msg%n" disableAnsi="false"/>
+        </Console>
+    </Appenders>
+    <Loggers>
+        <Logger name="org.opendc" level="trace" additivity="false">
+            <AppenderRef ref="Console"/>
+        </Logger>
+        <Root level="info">
+            <AppenderRef ref="Console"/>
+        </Root>
+    </Loggers>
+</Configuration>