Implements Virtualization overhead modelling (#357)

20 files changed, 871 insertions, 15 deletions

diff --git a/opendc-compute/opendc-compute-topology/src/main/kotlin/org/opendc/compute/topology/TopologyFactories.kt b/opendc-compute/opendc-compute-topology/src/main/kotlin/org/opendc/compute/topology/TopologyFactories.kt
index c1617304..fd66ca11 100644
--- a/opendc-compute/opendc-compute-topology/src/main/kotlin/org/opendc/compute/topology/TopologyFactories.kt
+++ b/opendc-compute/opendc-compute-topology/src/main/kotlin/org/opendc/compute/topology/TopologyFactories.kt
@@ -32,6 +32,7 @@ import org.opendc.compute.topology.specs.HostSpec
 import org.opendc.compute.topology.specs.PowerSourceSpec
 import org.opendc.compute.topology.specs.TopologySpec
 import org.opendc.compute.topology.specs.toDistributionPolicy
+import org.opendc.compute.topology.specs.toVirtualizationOverheadModel
 import org.opendc.simulator.compute.models.CpuModel
 import org.opendc.simulator.compute.models.GpuModel
 import org.opendc.simulator.compute.models.MachineModel
@@ -171,6 +172,7 @@ private fun HostJSONSpec.toHostSpec(clusterName: String): HostSpec {
     val unknownMemoryUnit = MemoryUnit(memory.vendor, memory.modelName, memory.memorySpeed.toMHz(), memory.memorySize.toMiB().toLong())
     val gpuUnits =
         List(gpu?.count ?: 0) {
+            val virtualizationOverheadModel = gpu?.virtualizationOverHeadModel?.toVirtualizationOverheadModel()
             GpuModel(
                 globalGpuId++,
                 gpu!!.coreCount,
@@ -180,6 +182,7 @@ private fun HostJSONSpec.toHostSpec(clusterName: String): HostSpec {
                 gpu.vendor,
                 gpu.modelName,
                 gpu.architecture,
+                virtualizationOverheadModel,
             )
         }
 
diff --git a/opendc-compute/opendc-compute-topology/src/main/kotlin/org/opendc/compute/topology/specs/TopologySpecs.kt b/opendc-compute/opendc-compute-topology/src/main/kotlin/org/opendc/compute/topology/specs/TopologySpecs.kt
index f5c8ab31..667e9cbd 100644
--- a/opendc-compute/opendc-compute-topology/src/main/kotlin/org/opendc/compute/topology/specs/TopologySpecs.kt
+++ b/opendc-compute/opendc-compute-topology/src/main/kotlin/org/opendc/compute/topology/specs/TopologySpecs.kt
@@ -35,6 +35,7 @@ import org.opendc.simulator.compute.power.batteries.policy.DoubleThresholdBatter
 import org.opendc.simulator.compute.power.batteries.policy.RunningMeanBatteryPolicy
 import org.opendc.simulator.compute.power.batteries.policy.RunningMeanPlusBatteryPolicy
 import org.opendc.simulator.compute.power.batteries.policy.SingleThresholdBatteryPolicy
+import org.opendc.simulator.compute.virtualization.VirtualizationOverheadModelFactory.VirtualizationOverheadModelEnum
 import org.opendc.simulator.engine.engine.FlowEngine
 import org.opendc.simulator.engine.graph.distributionPolicies.FlowDistributorFactory.DistributionPolicy
 
@@ -69,8 +70,12 @@ public data class ClusterJSONSpec(
  * @param name The name of the host.
  * @param cpu The CPU available in this cluster
  * @param memory The amount of RAM memory available in Byte
- * @param powerModel The power model used to determine the power draw of a host
  * @param count The power model used to determine the power draw of a host
+ * @param gpu The GPU available in this cluster (optional)
+ * @param cpuPowerModel The power model used to determine the power draw of the CPU
+ * @param gpuPowerModel The power model used to determine the power draw of the GPU
+ * @param cpuDistributionPolicy The distribution policy used to distribute CPU resources
+ * @param gpuDistributionPolicy The distribution policy used to distribute GPU resources
  */
 @Serializable
 public data class HostJSONSpec(
@@ -133,6 +138,7 @@ public data class GPUJSONSpec(
     val vendor: String = "unknown",
     val modelName: String = "unknown",
     val architecture: String = "unknown",
+    val virtualizationOverHeadModel: VirtualizationOverheadModelSpec = NoVirtualizationOverheadModelSpec(),
 )
 
 @Serializable
@@ -216,6 +222,48 @@ public data class MaxMinFairnessDistributionPolicySpec(
     override val type: DistributionPolicy = DistributionPolicy.MAX_MIN_FAIRNESS,
 ) : DistributionPolicySpec
 
+@Serializable
+public sealed interface VirtualizationOverheadModelSpec {
+    public val type: VirtualizationOverheadModelEnum
+}
+
+@Serializable
+@SerialName("NONE")
+public data class NoVirtualizationOverheadModelSpec(
+    override val type: VirtualizationOverheadModelEnum =
+        VirtualizationOverheadModelEnum.NONE,
+) : VirtualizationOverheadModelSpec
+
+@Serializable
+@SerialName("CONSTANT")
+public data class ConstantVirtualizationOverheadModelSpec(
+    override val type: VirtualizationOverheadModelEnum = VirtualizationOverheadModelEnum.CONSTANT,
+    val percentageOverhead: Double? = -1.0,
+) : VirtualizationOverheadModelSpec
+
+@Serializable
+@SerialName("SHARE_BASED")
+public data class ShareBasedVirtualizationOverheadModelSpec(
+    override val type: VirtualizationOverheadModelEnum = VirtualizationOverheadModelEnum.SHARE_BASED,
+) : VirtualizationOverheadModelSpec
+
+public fun VirtualizationOverheadModelSpec.toVirtualizationOverheadModel(): VirtualizationOverheadModelEnum {
+    return when (this) {
+        is NoVirtualizationOverheadModelSpec -> VirtualizationOverheadModelEnum.NONE
+        is ConstantVirtualizationOverheadModelSpec ->
+            VirtualizationOverheadModelEnum.CONSTANT.apply {
+                if (percentageOverhead != null) {
+                    // -1.0 is used to indicate that no percentage overhead is specified
+                    if (percentageOverhead != -1.0 && (percentageOverhead < 0.0 || percentageOverhead > 1.0)) {
+                        throw IllegalArgumentException("Percentage overhead must be between 0.0 and 1.0")
+                    }
+                    setProperty("percentageOverhead", percentageOverhead)
+                }
+            }
+        is ShareBasedVirtualizationOverheadModelSpec -> VirtualizationOverheadModelEnum.SHARE_BASED
+    }
+}
+
 /**
  * Definition of a power source used for JSON input.
  *
diff --git a/opendc-experiments/opendc-experiments-base/src/test/kotlin/org/opendc/experiments/base/VirtualizationOverheadTests.kt b/opendc-experiments/opendc-experiments-base/src/test/kotlin/org/opendc/experiments/base/VirtualizationOverheadTests.kt
new file mode 100644
index 00000000..18936a15
--- /dev/null
+++ b/opendc-experiments/opendc-experiments-base/src/test/kotlin/org/opendc/experiments/base/VirtualizationOverheadTests.kt
@@ -0,0 +1,275 @@
+/*
+ * Copyright (c) 2024 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.base
+
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Assertions.assertInstanceOf
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.assertAll
+import org.opendc.compute.workload.Task
+import org.opendc.simulator.compute.virtualization.OverheadModels.ConstantVirtualizationOverhead
+import org.opendc.simulator.compute.virtualization.OverheadModels.NoVirtualizationOverHead
+import org.opendc.simulator.compute.virtualization.OverheadModels.ShareBasedVirtualizationOverhead
+import org.opendc.simulator.compute.workload.trace.TraceFragment
+import java.util.ArrayList
+
+class VirtualizationOverheadTests {
+    /**
+     * Test that the different virtualization overhead models are loaded correctly from a topology file.
+     */
+    @Test
+    fun loadsVirtualizationOverheadModelCorrectly() {
+        val noModelTopology = createTopology("virtualizationOverhead/single_gpu_no_model.json")
+        val noOverHeadTopology = createTopology("virtualizationOverhead/single_gpu_no_overhead.json")
+        val constantOverHeadTopology = createTopology("virtualizationOverhead/single_gpu_constant_overhead.json")
+        val customConstantOverHeadTopology = createTopology("virtualizationOverhead/single_gpu_custom_constant_overhead.json")
+        val shareBasedOverheadTopology = createTopology("virtualizationOverhead/single_gpu_share_based_overhead.json")
+
+        assertAll(
+            {
+                assertInstanceOf(
+                    NoVirtualizationOverHead::class.java,
+                    noModelTopology[0].hostSpecs[0].model.gpuModels[0].virtualizationOverheadModel,
+                    "Did not load default model correctly, when no model was given.",
+                )
+            },
+            // no overhead
+            {
+                assertInstanceOf(
+                    NoVirtualizationOverHead::class.java,
+                    noOverHeadTopology[0].hostSpecs[0].model.gpuModels[0].virtualizationOverheadModel,
+                    "Did not load no overhead model correctly.",
+                )
+            },
+            // default constant overhead
+            {
+                assertInstanceOf(
+                    ConstantVirtualizationOverhead::class.java,
+                    constantOverHeadTopology[0].hostSpecs[0].model.gpuModels[0].virtualizationOverheadModel,
+                    "Did not load constant overhead model correctly.",
+                )
+            },
+            {
+                assertEquals(
+                    0.05,
+                    (
+                        constantOverHeadTopology[0].hostSpecs[0].model.gpuModels[0].virtualizationOverheadModel
+                            as ConstantVirtualizationOverhead
+                    ).percentageOverhead,
+                    "Constant overhead should have 5% overhead",
+                )
+            },
+            // custom constant overhead
+            {
+                assertInstanceOf(
+                    ConstantVirtualizationOverhead::class.java,
+                    customConstantOverHeadTopology[0].hostSpecs[0].model.gpuModels[0].virtualizationOverheadModel,
+                    "Did not load constant overhead model correctly, when overhead factor was given.",
+                )
+            },
+            {
+                assertEquals(
+                    0.25,
+                    (
+                        customConstantOverHeadTopology[0].hostSpecs[0].model.gpuModels[0].virtualizationOverheadModel
+                            as ConstantVirtualizationOverhead
+                    ).percentageOverhead,
+                    "Custom constant overhead should have 25% overhead",
+                )
+            },
+            // share-based overhead
+            {
+                assertInstanceOf(
+                    ShareBasedVirtualizationOverhead::class.java,
+                    shareBasedOverheadTopology[0].hostSpecs[0].model.gpuModels[0].virtualizationOverheadModel,
+                    "Did not load shared based overhead model correctly",
+                )
+            },
+        )
+    }
+
+    /**
+     * Test that the NoVirtualizationOverhead model does not apply any overhead.
+     */
+    @Test
+    fun noVirtualizationOverheadModelTest() {
+        val topology = createTopology("virtualizationOverhead/single_gpu_no_overhead.json")
+        val workload: ArrayList<Task> =
+            arrayListOf(
+                createTestTask(
+                    name = "0",
+                    fragments =
+                        arrayListOf(
+                            TraceFragment(10 * 60 * 1000, 1000.0, 1, 1000.0, 1),
+                        ),
+                ),
+            )
+
+        val monitor = runTest(topology, workload)
+        assertEquals(1000.0, monitor.taskGpuDemands["0"]?.get(1), "Task 0 should have gpu demand 1000.0")
+        assertEquals(1000.0, monitor.taskGpuSupplied["0"]?.get(1), "Task 0 should have gpu supplied 1000.0 ")
+        assertEquals(1000.0, monitor.hostGpuDemands["H01"]?.get(1)?.get(0), "Host H01 should have gpu demand 1000.0")
+        assertEquals(1000.0, monitor.hostGpuSupplied["H01"]?.get(1)?.get(0), "Host H01 should have gpu supply 1000.0")
+    }
+
+    /**
+     * Test that the constant overhead model does apply the correct amount of overhead.
+     */
+    @Test
+    fun constantVirtualizationOverheadModelTest() {
+        val topology = createTopology("virtualizationOverhead/single_gpu_constant_overhead.json")
+        val workload: ArrayList<Task> =
+            arrayListOf(
+                createTestTask(
+                    name = "0",
+                    fragments =
+                        arrayListOf(
+                            TraceFragment(10 * 60 * 1000, 1000.0, 1, 1000.0, 1),
+                        ),
+                ),
+            )
+
+        val monitor = runTest(topology, workload)
+        assertAll(
+            { assertEquals(1000.0, monitor.taskGpuDemands["0"]?.get(1), "Task 0 should have gpu demand 1000.0") },
+            { assertEquals(0.95 * 1000.0, monitor.taskGpuSupplied["0"]?.get(1), "Task 0 should have gpu supplied 950.0 ") },
+            { assertEquals(1000.0, monitor.hostGpuDemands["H01"]?.get(1)?.get(0), "Host H01 should have gpu demand 1000.0") },
+            { assertEquals(0.95 * 1000.0, monitor.hostGpuSupplied["H01"]?.get(1)?.get(0), "Host H01 should have gpu supply 950.0") },
+        )
+    }
+
+    /**
+     * Test that the custom constant overhead model does not apply the correct amount of overhead.
+     */
+    @Test
+    fun customConstantVirtualizationOverheadModelTest() {
+        val topology = createTopology("virtualizationOverhead/single_gpu_custom_constant_overhead.json")
+        val workload: ArrayList<Task> =
+            arrayListOf(
+                createTestTask(
+                    name = "0",
+                    fragments =
+                        arrayListOf(
+                            TraceFragment(10 * 60 * 1000, 1000.0, 1, 1000.0, 1),
+                        ),
+                ),
+            )
+
+        val monitor = runTest(topology, workload)
+        assertAll(
+            { assertEquals(1000.0, monitor.taskGpuDemands["0"]?.get(1), "Task 0 should have gpu demand 1000.0") },
+            { assertEquals(0.75 * 1000.0, monitor.taskGpuSupplied["0"]?.get(1), "Task 0 should have gpu supplied 750.0 ") },
+            { assertEquals(1000.0, monitor.hostGpuDemands["H01"]?.get(1)?.get(0), "Host H01 should have gpu demand 1000.0") },
+            { assertEquals(0.75 * 1000.0, monitor.hostGpuSupplied["H01"]?.get(1)?.get(0), "Host H01 should have gpu supply 750.0") },
+        )
+    }
+
+    /**
+     * Test that the share-based overhead model does not applies the correct amount of overhead, depending on the number of VMs.
+     */
+    @Test
+    fun shareBasedVirtualizationOverheadModelTest() {
+        val topology = createTopology("virtualizationOverhead/single_gpu_share_based_overhead.json")
+        val workload1: ArrayList<Task> =
+            arrayListOf(
+                createTestTask(
+                    name = "0",
+                    fragments =
+                        arrayListOf(
+                            TraceFragment(10 * 60 * 1000, 1000.0, 1, 1000.0, 1),
+                        ),
+                ),
+            )
+
+        val workload2: ArrayList<Task> =
+            arrayListOf(
+                createTestTask(
+                    name = "0",
+                    fragments =
+                        arrayListOf(
+                            TraceFragment(10 * 60 * 1000, 0.0, 0, 1000.0, 1),
+                        ),
+                ),
+                createTestTask(
+                    name = "1",
+                    fragments =
+                        arrayListOf(
+                            TraceFragment(10 * 60 * 1000, 0.0, 0, 1000.0, 1),
+                        ),
+                ),
+            )
+
+        val workload3: ArrayList<Task> =
+            arrayListOf(
+                createTestTask(
+                    name = "0",
+                    fragments =
+                        arrayListOf(
+                            TraceFragment(10 * 60 * 1000, 0.0, 0, 1000.0, 1),
+                        ),
+                ),
+                createTestTask(
+                    name = "1",
+                    fragments =
+                        arrayListOf(
+                            TraceFragment(10 * 60 * 1000, 0.0, 0, 1000.0, 1),
+                        ),
+                ),
+                createTestTask(
+                    name = "2",
+                    fragments =
+                        arrayListOf(
+                            TraceFragment(10 * 60 * 1000, 0.0, 0, 1000.0, 1),
+                        ),
+                ),
+            )
+
+        val monitor1 = runTest(topology, workload1)
+        val monitor2 = runTest(topology, workload2)
+        val monitor3 = runTest(topology, workload3)
+
+        assertAll(
+            // Test with one VM
+            { assertEquals(1000.0, monitor1.taskGpuDemands["0"]?.get(1), "Task 0 should have gpu demand 1000.0") },
+            { assertEquals(1000.0, monitor1.taskGpuSupplied["0"]?.get(1), "Task 0 should have gpu supplied 1000.0 ") },
+            { assertEquals(1000.0, monitor1.hostGpuDemands["H01"]?.get(1)?.get(0), "Host H01 should have gpu demand 1000.0") },
+            { assertEquals(1000.0, monitor1.hostGpuSupplied["H01"]?.get(1)?.get(0), "Host H01 should have gpu supply 1000.0") },
+            // Test with two VMs
+            { assertEquals(1000.0, monitor2.taskGpuDemands["0"]?.get(1), "Task 0 should have gpu demand 1000.0") },
+            { assertEquals(500.0, monitor2.taskGpuSupplied["0"]?.get(1), "Task 0 should have gpu supplied 500.0") },
+            { assertEquals(1000.0, monitor2.taskGpuDemands["1"]?.get(1), "Task 0 should have gpu demand 1000.0") },
+            { assertEquals(500.0, monitor2.taskGpuSupplied["1"]?.get(1), "Task 0 should have gpu supplied 500.0") },
+            { assertEquals(2000.0, monitor2.hostGpuDemands["H01"]?.get(1)?.get(0), "Host H01 should have gpu demand 2000.0") },
+            { assertEquals(1000.0, monitor2.hostGpuSupplied["H01"]?.get(1)?.get(0), "Host H01 should have gpu supply 1000.0") },
+            // Test with three VMs
+            { assertEquals(1000.0, monitor3.taskGpuDemands["0"]?.get(1), "Task 0 should have gpu demand 1000.0") },
+            { assertEquals(333.3, monitor3.taskGpuSupplied["0"]?.get(1) ?: 0.0, 0.05, "Task 0 should have gpu supplied 333.3 ") },
+            { assertEquals(1000.0, monitor3.taskGpuDemands["1"]?.get(1), "Task 0 should have gpu demand 1000.0") },
+            { assertEquals(333.3, monitor3.taskGpuSupplied["1"]?.get(1) ?: 0.0, 0.05, "Task 0 should have gpu supplied 333.3 ") },
+            { assertEquals(1000.0, monitor3.taskGpuDemands["2"]?.get(1), "Task 0 should have gpu demand 1000.0") },
+            { assertEquals(333.3, monitor3.taskGpuSupplied["2"]?.get(1) ?: 0.0, 0.05, "Task 0 should have gpu supplied 333.3 ") },
+            { assertEquals(3000.0, monitor3.hostGpuDemands["H01"]?.get(1)?.get(0), "Host H01 should have gpu demand 3000.0") },
+            { assertEquals(1000.0, monitor3.hostGpuSupplied["H01"]?.get(1)?.get(0), "Host H01 should have gpu supply 700.0") },
+        )
+    }
+}
diff --git a/opendc-experiments/opendc-experiments-base/src/test/resources/topologies/Gpus/single_gpu_full.json b/opendc-experiments/opendc-experiments-base/src/test/resources/topologies/Gpus/single_gpu_full.json
index 8e4c3546..d3e897bd 100644
--- a/opendc-experiments/opendc-experiments-base/src/test/resources/topologies/Gpus/single_gpu_full.json
+++ b/opendc-experiments/opendc-experiments-base/src/test/resources/topologies/Gpus/single_gpu_full.json
@@ -29,7 +29,10 @@
                         "memoryBandwidth": "900 GBps",
                         "vendor": "NVIDIA",
                         "modelName": "Tesla V100",
-                        "architecture": "Volta"
+                        "architecture": "Volta",
+                        "virtualizationOverHeadModel": {
+                            "type": "CONSTANT"
+                        }
                     },
                     "gpuPowerModel": {
                         "modelType": "linear",
diff --git a/opendc-experiments/opendc-experiments-base/src/test/resources/topologies/virtualizationOverhead/single_gpu_constant_overhead.json b/opendc-experiments/opendc-experiments-base/src/test/resources/topologies/virtualizationOverhead/single_gpu_constant_overhead.json
new file mode 100644
index 00000000..d3651cba
--- /dev/null
+++ b/opendc-experiments/opendc-experiments-base/src/test/resources/topologies/virtualizationOverhead/single_gpu_constant_overhead.json
@@ -0,0 +1,42 @@
+{
+    "clusters":
+    [
+        {
+            "name": "C01",
+            "hosts" :
+            [
+                {
+                    "name": "H01",
+                    "cpu":
+                    {
+                        "coreCount": 1,
+                        "coreSpeed": 2000
+                    },
+                    "memory": {
+                        "memorySize": 140457600000
+                    },
+                    "cpuPowerModel": {
+                        "modelType": "linear",
+                        "power": 400.0,
+                        "idlePower": 100.0,
+                        "maxPower": 200.0
+                    },
+                    "gpu":
+                    {
+                        "coreCount": 3,
+                        "coreSpeed": 2000,
+                        "virtualizationOverHeadModel": {
+                            "type": "CONSTANT"
+                        }
+                    },
+                    "gpuPowerModel": {
+                        "modelType": "linear",
+                        "power": 800.0,
+                        "idlePower": 300.0,
+                        "maxPower": 600.0
+                    }
+                }
+            ]
+        }
+    ]
+}
diff --git a/opendc-experiments/opendc-experiments-base/src/test/resources/topologies/virtualizationOverhead/single_gpu_custom_constant_overhead.json b/opendc-experiments/opendc-experiments-base/src/test/resources/topologies/virtualizationOverhead/single_gpu_custom_constant_overhead.json
new file mode 100644
index 00000000..db30608e
--- /dev/null
+++ b/opendc-experiments/opendc-experiments-base/src/test/resources/topologies/virtualizationOverhead/single_gpu_custom_constant_overhead.json
@@ -0,0 +1,43 @@
+{
+    "clusters":
+    [
+        {
+            "name": "C01",
+            "hosts" :
+            [
+                {
+                    "name": "H01",
+                    "cpu":
+                    {
+                        "coreCount": 1,
+                        "coreSpeed": 2000
+                    },
+                    "memory": {
+                        "memorySize": 140457600000
+                    },
+                    "cpuPowerModel": {
+                        "modelType": "linear",
+                        "power": 400.0,
+                        "idlePower": 100.0,
+                        "maxPower": 200.0
+                    },
+                    "gpu":
+                    {
+                        "coreCount": 3,
+                        "coreSpeed": 2000,
+                        "virtualizationOverHeadModel": {
+                            "type": "CONSTANT",
+                            "percentageOverhead": 0.25
+                        }
+                    },
+                    "gpuPowerModel": {
+                        "modelType": "linear",
+                        "power": 800.0,
+                        "idlePower": 300.0,
+                        "maxPower": 600.0
+                    }
+                }
+            ]
+        }
+    ]
+}
diff --git a/opendc-experiments/opendc-experiments-base/src/test/resources/topologies/virtualizationOverhead/single_gpu_no_model.json b/opendc-experiments/opendc-experiments-base/src/test/resources/topologies/virtualizationOverhead/single_gpu_no_model.json
new file mode 100644
index 00000000..e272e924
--- /dev/null
+++ b/opendc-experiments/opendc-experiments-base/src/test/resources/topologies/virtualizationOverhead/single_gpu_no_model.json
@@ -0,0 +1,39 @@
+{
+    "clusters":
+    [
+        {
+            "name": "C01",
+            "hosts" :
+            [
+                {
+                    "name": "H01",
+                    "cpu":
+                    {
+                        "coreCount": 1,
+                        "coreSpeed": 2000
+                    },
+                    "memory": {
+                        "memorySize": 140457600000
+                    },
+                    "cpuPowerModel": {
+                        "modelType": "linear",
+                        "power": 400.0,
+                        "idlePower": 100.0,
+                        "maxPower": 200.0
+                    },
+                    "gpu":
+                    {
+                        "coreCount": 3,
+                        "coreSpeed": 2000
+                    },
+                    "gpuPowerModel": {
+                        "modelType": "linear",
+                        "power": 800.0,
+                        "idlePower": 300.0,
+                        "maxPower": 600.0
+                    }
+                }
+            ]
+        }
+    ]
+}
diff --git a/opendc-experiments/opendc-experiments-base/src/test/resources/topologies/virtualizationOverhead/single_gpu_no_overhead.json b/opendc-experiments/opendc-experiments-base/src/test/resources/topologies/virtualizationOverhead/single_gpu_no_overhead.json
new file mode 100644
index 00000000..f4cc893d
--- /dev/null
+++ b/opendc-experiments/opendc-experiments-base/src/test/resources/topologies/virtualizationOverhead/single_gpu_no_overhead.json
@@ -0,0 +1,42 @@
+{
+    "clusters":
+    [
+        {
+            "name": "C01",
+            "hosts" :
+            [
+                {
+                    "name": "H01",
+                    "cpu":
+                    {
+                        "coreCount": 1,
+                        "coreSpeed": 2000
+                    },
+                    "memory": {
+                        "memorySize": 140457600000
+                    },
+                    "cpuPowerModel": {
+                        "modelType": "linear",
+                        "power": 400.0,
+                        "idlePower": 100.0,
+                        "maxPower": 200.0
+                    },
+                    "gpu":
+                    {
+                        "coreCount": 3,
+                        "coreSpeed": 2000,
+                        "virtualizationOverHeadModel": {
+                            "type": "NONE"
+                        }
+                    },
+                    "gpuPowerModel": {
+                        "modelType": "linear",
+                        "power": 800.0,
+                        "idlePower": 300.0,
+                        "maxPower": 600.0
+                    }
+                }
+            ]
+        }
+    ]
+}
diff --git a/opendc-experiments/opendc-experiments-base/src/test/resources/topologies/virtualizationOverhead/single_gpu_share_based_overhead.json b/opendc-experiments/opendc-experiments-base/src/test/resources/topologies/virtualizationOverhead/single_gpu_share_based_overhead.json
new file mode 100644
index 00000000..00fb665f
--- /dev/null
+++ b/opendc-experiments/opendc-experiments-base/src/test/resources/topologies/virtualizationOverhead/single_gpu_share_based_overhead.json
@@ -0,0 +1,42 @@
+{
+    "clusters":
+    [
+        {
+            "name": "C01",
+            "hosts" :
+            [
+                {
+                    "name": "H01",
+                    "cpu":
+                    {
+                        "coreCount": 1,
+                        "coreSpeed": 2000
+                    },
+                    "memory": {
+                        "memorySize": 140457600000
+                    },
+                    "cpuPowerModel": {
+                        "modelType": "linear",
+                        "power": 400.0,
+                        "idlePower": 100.0,
+                        "maxPower": 200.0
+                    },
+                    "gpu":
+                    {
+                        "coreCount": 3,
+                        "coreSpeed": 1000,
+                        "virtualizationOverHeadModel": {
+                            "type": "SHARE_BASED"
+                        }
+                    },
+                    "gpuPowerModel": {
+                        "modelType": "linear",
+                        "power": 800.0,
+                        "idlePower": 300.0,
+                        "maxPower": 600.0
+                    }
+                }
+            ]
+        }
+    ]
+}
diff --git a/opendc-simulator/opendc-simulator-compute/src/main/java/org/opendc/simulator/compute/gpu/SimGpu.java b/opendc-simulator/opendc-simulator-compute/src/main/java/org/opendc/simulator/compute/gpu/SimGpu.java
index c5778dc0..99317a08 100644
--- a/opendc-simulator/opendc-simulator-compute/src/main/java/org/opendc/simulator/compute/gpu/SimGpu.java
+++ b/opendc-simulator/opendc-simulator-compute/src/main/java/org/opendc/simulator/compute/gpu/SimGpu.java
@@ -29,6 +29,7 @@ import org.opendc.simulator.compute.ComputeResource;
 import org.opendc.simulator.compute.machine.PerformanceCounters;
 import org.opendc.simulator.compute.models.GpuModel;
 import org.opendc.simulator.compute.power.PowerModel;
+import org.opendc.simulator.compute.virtualization.VirtualizationOverheadModel;
 import org.opendc.simulator.engine.engine.FlowEngine;
 import org.opendc.simulator.engine.graph.FlowConsumer;
 import org.opendc.simulator.engine.graph.FlowEdge;
@@ -47,12 +48,12 @@ public final class SimGpu extends FlowNode implements FlowSupplier, FlowConsumer
 
     private final PowerModel gpuPowerModel;
 
-    private double currentGpuDemand = 0.0f; // cpu capacity demanded by the mux
+    private double currentGpuDemand = 0.0f; // gpu capacity demanded by the mux
     private double currentGpuUtilization = 0.0f;
-    private double currentGpuSupplied = 0.0f; // cpu capacity supplied to the mux
+    private double currentGpuSupplied = 0.0f; // gpu capacity supplied to the mux
 
     private double currentPowerDemand; // power demanded of the psu
-    private double currentPowerSupplied = 0.0f; // cpu capacity supplied by the psu
+    private double currentPowerSupplied = 0.0f; // gpu capacity supplied by the psu
 
     private double maxCapacity;
 
@@ -60,6 +61,9 @@ public final class SimGpu extends FlowNode implements FlowSupplier, FlowConsumer
     private long lastCounterUpdate;
     private final double gpuFrequencyInv;
 
+    private final VirtualizationOverheadModel virtualizationOverheadModel;
+    private int consumerCount = 0; // Number of consumers connected to this GPU
+
     private FlowEdge distributorEdge;
     private FlowEdge psuEdge;
 
@@ -110,7 +114,12 @@ public final class SimGpu extends FlowNode implements FlowSupplier, FlowConsumer
     // Constructors
     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-    public SimGpu(FlowEngine engine, GpuModel gpuModel, PowerModel powerModel, int id) {
+    public SimGpu(
+            FlowEngine engine,
+            GpuModel gpuModel,
+            PowerModel powerModel,
+            int id,
+            VirtualizationOverheadModel overheadModel) {
         super(engine);
         this.id = id;
         this.gpuModel = gpuModel;
@@ -123,6 +132,7 @@ public final class SimGpu extends FlowNode implements FlowSupplier, FlowConsumer
         this.gpuFrequencyInv = 1 / this.maxCapacity;
 
         this.currentPowerDemand = this.gpuPowerModel.computePower(this.currentGpuUtilization);
+        this.virtualizationOverheadModel = overheadModel;
     }
 
     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -139,8 +149,8 @@ public final class SimGpu extends FlowNode implements FlowSupplier, FlowConsumer
 
             return Long.MAX_VALUE;
         }
-
-        this.currentGpuSupplied = Math.min(this.currentGpuDemand, this.maxCapacity);
+        this.currentGpuSupplied = virtualizationOverheadModel.getSupply(
+                Math.min(this.currentGpuDemand, this.maxCapacity), this.consumerCount);
         this.pushOutgoingSupply(this.distributorEdge, this.currentGpuSupplied);
 
         return Long.MAX_VALUE;
@@ -213,13 +223,31 @@ public final class SimGpu extends FlowNode implements FlowSupplier, FlowConsumer
         this.distributorEdge.pushSupply(newGpuSupply, true, resourceType);
     }
 
+    @Override
+    public void handleIncomingDemand(FlowEdge consumerEdge, double newGpuDemand) {
+        updateCounters();
+        this.currentGpuDemand = newGpuDemand;
+
+        this.currentGpuUtilization = Math.min(this.currentGpuDemand / this.maxCapacity, 1.0);
+
+        // Calculate Power Demand and send to PSU
+        this.currentPowerDemand = this.gpuPowerModel.computePower(this.currentGpuUtilization);
+
+        this.invalidate();
+    }
+
     /**
      * Handle new demand coming in from the mux
      */
     @Override
-    public void handleIncomingDemand(FlowEdge consumerEdge, double newGpuDemand) {
+    public void handleIncomingDemand(
+            FlowEdge consumerEdge, double newGpuDemand, ResourceType resourceType, int consumerCount) {
+        if (resourceType != ResourceType.GPU) {
+            throw new IllegalArgumentException("Resource type must be GPU");
+        }
         updateCounters();
         this.currentGpuDemand = newGpuDemand;
+        this.consumerCount = consumerCount;
 
         this.currentGpuUtilization = Math.min(this.currentGpuDemand / this.maxCapacity, 1.0);
 
diff --git a/opendc-simulator/opendc-simulator-compute/src/main/java/org/opendc/simulator/compute/machine/SimMachine.java b/opendc-simulator/opendc-simulator-compute/src/main/java/org/opendc/simulator/compute/machine/SimMachine.java
index 5f4a4fcd..7158356a 100644
--- a/opendc-simulator/opendc-simulator-compute/src/main/java/org/opendc/simulator/compute/machine/SimMachine.java
+++ b/opendc-simulator/opendc-simulator-compute/src/main/java/org/opendc/simulator/compute/machine/SimMachine.java
@@ -242,7 +242,8 @@ public class SimMachine {
 
             for (GpuModel gpuModel : machineModel.getGpuModels()) {
                 // create a new GPU
-                SimGpu gpu = new SimGpu(engine, gpuModel, gpuPowerModel, gpuModel.getId());
+                SimGpu gpu = new SimGpu(
+                        engine, gpuModel, gpuPowerModel, gpuModel.getId(), gpuModel.getVirtualizationOverheadModel());
                 gpus.add(gpu);
                 // Connect the GPU to the distributor
                 new FlowEdge(
diff --git a/opendc-simulator/opendc-simulator-compute/src/main/java/org/opendc/simulator/compute/models/GpuModel.java b/opendc-simulator/opendc-simulator-compute/src/main/java/org/opendc/simulator/compute/models/GpuModel.java
index b804b061..e62c93da 100644
--- a/opendc-simulator/opendc-simulator-compute/src/main/java/org/opendc/simulator/compute/models/GpuModel.java
+++ b/opendc-simulator/opendc-simulator-compute/src/main/java/org/opendc/simulator/compute/models/GpuModel.java
@@ -23,6 +23,9 @@
 package org.opendc.simulator.compute.models;
 
 import java.util.Objects;
+import org.opendc.simulator.compute.virtualization.VirtualizationOverheadModel;
+import org.opendc.simulator.compute.virtualization.VirtualizationOverheadModelFactory;
+import org.opendc.simulator.compute.virtualization.VirtualizationOverheadModelFactory.VirtualizationOverheadModelEnum;
 
 /**
  * A single logical compute unit of processor node, either virtual or physical.
@@ -37,6 +40,7 @@ public final class GpuModel {
     private final String vendor;
     private final String modelName;
     private final String arch;
+    private VirtualizationOverheadModel virtualizationOverheadModel;
 
     /**
      * Construct a {@link GpuModel} instance.
@@ -49,6 +53,7 @@ public final class GpuModel {
      * @param vendor The vendor of the GPU
      * @param modelName The name of the GPU
      * @param arch The architecture of the GPU
+     * @param virtualizationOverheadModel The virtualization overhead model of this GPU.
      */
     public GpuModel(
             int id,
@@ -58,7 +63,8 @@ public final class GpuModel {
             long memorySize,
             String vendor,
             String modelName,
-            String arch) {
+            String arch,
+            VirtualizationOverheadModelEnum virtualizationOverheadModel) {
         this.id = id;
         this.coreCount = coreCount;
         this.coreSpeed = coreSpeed;
@@ -68,6 +74,8 @@ public final class GpuModel {
         this.vendor = vendor;
         this.modelName = modelName;
         this.arch = arch;
+        this.virtualizationOverheadModel =
+                VirtualizationOverheadModelFactory.getVirtualizationOverheadModel(virtualizationOverheadModel);
     }
 
     /**
@@ -78,11 +86,20 @@ public final class GpuModel {
      * @param coreSpeed The speed of a single core
      */
     public GpuModel(int id, int coreCount, double coreSpeed) {
-        this(id, coreCount, coreSpeed, 0, 0, "unkown", "unkown", "unkown");
+        this(id, coreCount, coreSpeed, 0, 0, "unkown", "unkown", "unkown", VirtualizationOverheadModelEnum.NONE);
     }
 
     public GpuModel(int id, int coreCount, double coreSpeed, double memoryBandwidth, long memorySize) {
-        this(id, coreCount, coreSpeed, memoryBandwidth, memorySize, "unkown", "unkown", "unkown");
+        this(
+                id,
+                coreCount,
+                coreSpeed,
+                memoryBandwidth,
+                memorySize,
+                "unkown",
+                "unkown",
+                "unkown",
+                VirtualizationOverheadModelEnum.NONE);
     }
 
     /**
@@ -148,6 +165,14 @@ public final class GpuModel {
         return arch;
     }
 
+    /**
+     * Return the virtualization overhead model of this GPU.
+     * @return The virtualization overhead model of this GPU.
+     */
+    public VirtualizationOverheadModel getVirtualizationOverheadModel() {
+        return this.virtualizationOverheadModel;
+    }
+
     @Override
     public boolean equals(Object o) {
         if (this == o) return true;
diff --git a/opendc-simulator/opendc-simulator-compute/src/main/java/org/opendc/simulator/compute/virtualization/OverheadModels/ConstantVirtualizationOverhead.java b/opendc-simulator/opendc-simulator-compute/src/main/java/org/opendc/simulator/compute/virtualization/OverheadModels/ConstantVirtualizationOverhead.java
new file mode 100644
index 00000000..e30133a5
--- /dev/null
+++ b/opendc-simulator/opendc-simulator-compute/src/main/java/org/opendc/simulator/compute/virtualization/OverheadModels/ConstantVirtualizationOverhead.java
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) 2025 AtLarge Research
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package org.opendc.simulator.compute.virtualization.OverheadModels;
+
+import org.opendc.simulator.compute.virtualization.VirtualizationOverheadModel;
+
+/**
+ * A VirtualizationOverheadModel that applies a constant percentage overhead to the current GPU demand.
+ * This model is useful for scenarios where a fixed overhead is expected regardless of the number of consumers.
+ */
+public class ConstantVirtualizationOverhead implements VirtualizationOverheadModel {
+
+    private double percentageOverhead = 0.0;
+
+    public double getPercentageOverhead() {
+        return percentageOverhead;
+    }
+
+    /**
+     * Creates a new instance of ConstantVirtualizationOverhead with the specified percentage overhead.
+     *
+     * @param percentageOverhead The percentage overhead to apply to the current GPU demand.
+     *                           If set to -1.0, a default value of 0.05 (5%) is used.
+     */
+    public ConstantVirtualizationOverhead(double percentageOverhead) {
+
+        this.percentageOverhead = (percentageOverhead == -1.0) ? 0.05 : percentageOverhead;
+    }
+
+    @Override
+    public double getSupply(double currentGpuDemand, int consumerCount) {
+        return currentGpuDemand * (1 - percentageOverhead);
+    }
+}
diff --git a/opendc-simulator/opendc-simulator-compute/src/main/java/org/opendc/simulator/compute/virtualization/OverheadModels/NoVirtualizationOverHead.java b/opendc-simulator/opendc-simulator-compute/src/main/java/org/opendc/simulator/compute/virtualization/OverheadModels/NoVirtualizationOverHead.java
new file mode 100644
index 00000000..114962ef
--- /dev/null
+++ b/opendc-simulator/opendc-simulator-compute/src/main/java/org/opendc/simulator/compute/virtualization/OverheadModels/NoVirtualizationOverHead.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2025 AtLarge Research
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package org.opendc.simulator.compute.virtualization.OverheadModels;
+
+import org.opendc.simulator.compute.virtualization.VirtualizationOverheadModel;
+
+/**
+ * A VirtualizationOverheadModel that does not introduce any overhead.
+ * It simply returns the current GPU demand as the supply.
+ */
+public class NoVirtualizationOverHead implements VirtualizationOverheadModel {
+    @Override
+    public double getSupply(double currentGpuDemand, int consumerCount) {
+        return currentGpuDemand; // No overhead, so supply is equal to demand
+    }
+}
diff --git a/opendc-simulator/opendc-simulator-compute/src/main/java/org/opendc/simulator/compute/virtualization/OverheadModels/ShareBasedVirtualizationOverhead.java b/opendc-simulator/opendc-simulator-compute/src/main/java/org/opendc/simulator/compute/virtualization/OverheadModels/ShareBasedVirtualizationOverhead.java
new file mode 100644
index 00000000..e1562c38
--- /dev/null
+++ b/opendc-simulator/opendc-simulator-compute/src/main/java/org/opendc/simulator/compute/virtualization/OverheadModels/ShareBasedVirtualizationOverhead.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2025 AtLarge Research
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package org.opendc.simulator.compute.virtualization.OverheadModels;
+
+import org.opendc.simulator.compute.virtualization.VirtualizationOverheadModel;
+
+/**
+ * A VirtualizationOverheadModel that divides the current GPU demand by the number of consumers.
+ * This model assumes that the supply is shared among all consumers, effectively reducing the
+ * supply available to each consumer based on the number of consumers.
+ */
+public class ShareBasedVirtualizationOverhead implements VirtualizationOverheadModel {
+    @Override
+    public double getSupply(double currentGpuDemand, int consumerCount) {
+        // Supply is divided by the number of consumers to account for sharing
+        return currentGpuDemand / (consumerCount == 0 ? 1 : consumerCount);
+    }
+}
diff --git a/opendc-simulator/opendc-simulator-compute/src/main/java/org/opendc/simulator/compute/virtualization/VirtualizationOverheadModel.java b/opendc-simulator/opendc-simulator-compute/src/main/java/org/opendc/simulator/compute/virtualization/VirtualizationOverheadModel.java
new file mode 100644
index 00000000..149780f8
--- /dev/null
+++ b/opendc-simulator/opendc-simulator-compute/src/main/java/org/opendc/simulator/compute/virtualization/VirtualizationOverheadModel.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2025 AtLarge Research
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package org.opendc.simulator.compute.virtualization;
+
+/**
+ * An interface for modeling the overhead introduced by virtualization in a compute environment.
+ * This model is used to determine the effective supply of resources available to consumers based
+ * on the current demand and the number of consumers.
+ */
+public interface VirtualizationOverheadModel {
+
+    public double getSupply(double currentGpuDemand, int consumerCount);
+}
diff --git a/opendc-simulator/opendc-simulator-compute/src/main/java/org/opendc/simulator/compute/virtualization/VirtualizationOverheadModelFactory.java b/opendc-simulator/opendc-simulator-compute/src/main/java/org/opendc/simulator/compute/virtualization/VirtualizationOverheadModelFactory.java
new file mode 100644
index 00000000..8eee2b01
--- /dev/null
+++ b/opendc-simulator/opendc-simulator-compute/src/main/java/org/opendc/simulator/compute/virtualization/VirtualizationOverheadModelFactory.java
@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) 2025 AtLarge Research
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package org.opendc.simulator.compute.virtualization;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+import org.opendc.simulator.compute.virtualization.OverheadModels.ConstantVirtualizationOverhead;
+import org.opendc.simulator.compute.virtualization.OverheadModels.NoVirtualizationOverHead;
+import org.opendc.simulator.compute.virtualization.OverheadModels.ShareBasedVirtualizationOverhead;
+
+/**
+ * A factory class for creating instances of VirtualizationOverheadModel based on the specified type.
+ * This factory supports different virtualization overhead models, including no overhead, constant overhead,
+ * and share-based overhead.
+ */
+public class VirtualizationOverheadModelFactory {
+
+    public enum VirtualizationOverheadModelEnum {
+        NONE,
+        // General virtualization models -> Passthrough vs Full/Para virtualization
+        CONSTANT,
+        // Hardware assisted virtualization models
+        SHARE_BASED;
+
+        private final Map<String, Object> properties = new HashMap<>();
+
+        public void setProperty(String key, Object value) {
+            properties.put(key, value);
+        }
+
+        public Object getProperty(String key) {
+            return properties.get(key);
+        }
+
+        public <T> T getProperty(String key, Class<T> type) {
+            return type.cast(properties.get(key));
+        }
+
+        public Set<String> getPropertyNames() {
+            return properties.keySet();
+        }
+    }
+
+    /**
+     * Factory method to create a VirtualizationOverheadModel based on the specified type.
+     *
+     * @param virtualizationOverheadModelType The type of virtualization overhead model to create.
+     * @return An instance of the specified VirtualizationOverheadModel.
+     */
+    public static VirtualizationOverheadModel getVirtualizationOverheadModel(
+            VirtualizationOverheadModelEnum virtualizationOverheadModelType) {
+        return switch (virtualizationOverheadModelType) {
+            case NONE -> new NoVirtualizationOverHead();
+            case CONSTANT -> {
+                double percentageOverhead = -1.0; // Default value if not set
+                if (virtualizationOverheadModelType.getPropertyNames().contains("percentageOverhead")) {
+                    percentageOverhead =
+                            virtualizationOverheadModelType.getProperty("percentageOverhead", Double.class);
+                }
+                yield new ConstantVirtualizationOverhead(percentageOverhead);
+            }
+            case SHARE_BASED -> new ShareBasedVirtualizationOverhead();
+            default -> throw new IllegalArgumentException(
+                    "Unknown virtualization overhead model type: " + virtualizationOverheadModelType);
+        };
+    }
+}
diff --git a/opendc-simulator/opendc-simulator-flow/src/main/java/org/opendc/simulator/engine/graph/FlowDistributor.java b/opendc-simulator/opendc-simulator-flow/src/main/java/org/opendc/simulator/engine/graph/FlowDistributor.java
index cae3e8a1..c388293b 100644
--- a/opendc-simulator/opendc-simulator-flow/src/main/java/org/opendc/simulator/engine/graph/FlowDistributor.java
+++ b/opendc-simulator/opendc-simulator-flow/src/main/java/org/opendc/simulator/engine/graph/FlowDistributor.java
@@ -102,7 +102,6 @@ public abstract class FlowDistributor extends FlowNode implements FlowSupplier,
 
     protected abstract void updateOutgoingDemand();
 
-    // TODO: This should probably be moved to the distribution strategy
     protected abstract void updateOutgoingSupplies();
 
     public abstract double[] distributeSupply(
@@ -120,6 +119,7 @@ public abstract class FlowDistributor extends FlowNode implements FlowSupplier,
         this.incomingDemands.add(0.0);
         this.outgoingSupplies.add(0.0);
         this.consumerResourceType = consumerEdge.getConsumerResourceType();
+        this.outgoingDemandUpdateNeeded = true;
     }
 
     @Override
@@ -233,7 +233,7 @@ public abstract class FlowDistributor extends FlowNode implements FlowSupplier,
 
     @Override
     public void pushOutgoingDemand(FlowEdge supplierEdge, double newDemand) {
-        supplierEdge.pushDemand(newDemand, false, this.getSupplierResourceType());
+        supplierEdge.pushDemand(newDemand, false, this.getSupplierResourceType(), this.consumerEdges.size());
     }
 
     @Override
diff --git a/opendc-simulator/opendc-simulator-flow/src/main/java/org/opendc/simulator/engine/graph/FlowEdge.java b/opendc-simulator/opendc-simulator-flow/src/main/java/org/opendc/simulator/engine/graph/FlowEdge.java
index db2a2944..1e65998b 100644
--- a/opendc-simulator/opendc-simulator-flow/src/main/java/org/opendc/simulator/engine/graph/FlowEdge.java
+++ b/opendc-simulator/opendc-simulator-flow/src/main/java/org/opendc/simulator/engine/graph/FlowEdge.java
@@ -177,6 +177,16 @@ public class FlowEdge {
         this.supplierIndex = supplierIndex;
     }
 
+    public void pushDemand(double newDemand, boolean forceThrough, ResourceType resourceType, int consumerCount) {
+        // or store last resource type in the edge
+        if ((newDemand == this.demand) && !forceThrough) {
+            return;
+        }
+
+        this.demand = newDemand;
+        this.supplier.handleIncomingDemand(this, newDemand, resourceType, consumerCount);
+    }
+
     public void pushDemand(double newDemand, boolean forceThrough, ResourceType resourceType) {
         // or store last resource type in the edge
         if ((newDemand == this.demand) && !forceThrough) {
diff --git a/opendc-simulator/opendc-simulator-flow/src/main/java/org/opendc/simulator/engine/graph/FlowSupplier.java b/opendc-simulator/opendc-simulator-flow/src/main/java/org/opendc/simulator/engine/graph/FlowSupplier.java
index eb665b8c..2f5f80ef 100644
--- a/opendc-simulator/opendc-simulator-flow/src/main/java/org/opendc/simulator/engine/graph/FlowSupplier.java
+++ b/opendc-simulator/opendc-simulator-flow/src/main/java/org/opendc/simulator/engine/graph/FlowSupplier.java
@@ -32,6 +32,12 @@ public interface FlowSupplier {
         handleIncomingDemand(consumerEdge, newDemand);
     }
 
+    default void handleIncomingDemand(
+            FlowEdge consumerEdge, double newDemand, ResourceType resourceType, int consumerCount) {
+        handleIncomingDemand(consumerEdge, newDemand);
+    }
+    ;
+
     void pushOutgoingSupply(FlowEdge consumerEdge, double newSupply);
 
     default void pushOutgoingSupply(FlowEdge consumerEdge, double newSupply, ResourceType resourceType) {