diff --git a/README.md b/README.md index fecffa7..add4881 100755 --- a/README.md +++ b/README.md @@ -89,3 +89,21 @@ Each configuration is compared with the usual case before #603: a new `CoreCapac | **Shared instances, after** | **7,114.6 KB** | **815.7 KB (10.3%)** | **209 B** | Of the 209 bytes saved per VM, 175 come from sharing the `BootModel` and its two `UtilizationModel`s, which #603 makes safe, and 34 come from #603 itself (shared before → shared after), since a VM's MIPS share is no longer a new `CoreCapacity`. + +## Results of `MigrationCheckBenchmark` (cloudsimplus#94) + +`MigrationCheckBenchmark` measures one VM migration check: a call to `VmPlacementPolicyMigrationAbstract.getOptimizedPlacementMap()`, which finds the VMs to migrate from overloaded and underloaded Hosts and their target Hosts. It's the baseline for [cloudsimplus#94](https://github.com/cloudsimplus/cloudsimplus/issues/94), where the check creates and destroys VMs to compute the migration map, and for [cloudsimplus#648](https://github.com/cloudsimplus/cloudsimplus/issues/648), the quadratic costs of the placement algorithm itself. + +Scenario: Hosts with 8 cores. In each group of 10 Hosts, 1 is overloaded (4 VMs using 100% of the CPU), 1 is underloaded (a VM with 1 core) and 8 use half of their CPU (2 VMs with 2 cores), so there are 2.1 VMs per Host. A `VmPlacementPolicyMigrationStaticThreshold` (thresholds 0.8 and 0.2) with `VmSelectionPolicyMinimumUtilization` performs the check. + +- **Before #94:** CloudSim Plus `master` at `4a160b4bb`. +- JDK 25.0.4, JMH 1.35, default GC, 1 fork, 5 warmup and 10 measurement iterations of 2 seconds, `-prof gc`. + +| Hosts | VMs | Time per check (ms) | Allocated per check (MB) | +| ----: | ----: | ------------------: | -----------------------: | +| 100 | 210 | 4.07 ± 0.07 | 18.3 | +| 500 | 1,050 | 102.75 ± 2.35 | 454.9 | +| 1,000 | 2,100 | 428.46 ± 14.58 | 1,818.2 | +| 2,000 | 4,200 | 1,802.05 ± 31.41 | 7,268.5 | + +Both the time and the memory allocated by a check grow quadratically: doubling the number of Hosts makes a check about 4 times slower and allocate about 4 times more memory. A simulation runs one check at each scheduling interval while some Host is under or overloaded. diff --git a/src/main/java/org/cloudsimplus/placementpolicies/migration/MigrationCheckBenchmark.java b/src/main/java/org/cloudsimplus/placementpolicies/migration/MigrationCheckBenchmark.java new file mode 100644 index 0000000..1f51dc5 --- /dev/null +++ b/src/main/java/org/cloudsimplus/placementpolicies/migration/MigrationCheckBenchmark.java @@ -0,0 +1,216 @@ +/* + * CloudSim Plus: A modern, highly-extensible and easier-to-use Framework for + * Modeling and Simulation of Cloud Computing Infrastructures and Services. + * http://cloudsimplus.org + * + * Copyright (C) 2015-2021 Universidade da Beira Interior (UBI, Portugal) and + * the Instituto Federal de Educação Ciência e Tecnologia do Tocantins (IFTO, Brazil). + * + * This file is part of CloudSim Plus. + * + * CloudSim Plus is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * CloudSim Plus is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with CloudSim Plus. If not, see . + */ +package org.cloudsimplus.placementpolicies.migration; + +import org.cloudsimplus.brokers.DatacenterBrokerSimple; +import org.cloudsimplus.cloudlets.Cloudlet; +import org.cloudsimplus.cloudlets.CloudletSimple; +import org.cloudsimplus.core.CloudSimPlus; +import org.cloudsimplus.datacenters.DatacenterSimple; +import org.cloudsimplus.hosts.Host; +import org.cloudsimplus.hosts.HostSimple; +import org.cloudsimplus.placementpolicies.VmPlacementPolicy; +import org.cloudsimplus.power.models.PowerModelHostSimple; +import org.cloudsimplus.resources.CoreCapacity; +import org.cloudsimplus.schedulers.cloudlet.CloudletSchedulerTimeShared; +import org.cloudsimplus.schedulers.vm.VmSchedulerTimeShared; +import org.cloudsimplus.selectionpolicies.VmSelectionPolicyMinimumUtilization; +import org.cloudsimplus.util.Log; +import org.cloudsimplus.utilizationmodels.UtilizationModelDynamic; +import org.cloudsimplus.utilizationmodels.UtilizationModelFull; +import org.cloudsimplus.vms.Vm; +import org.cloudsimplus.vms.VmSimple; +import org.openjdk.jmh.annotations.*; + +import java.util.ArrayList; +import java.util.List; +import java.util.Map; +import java.util.Optional; +import java.util.concurrent.TimeUnit; +import java.util.function.BiFunction; + +/// Measures one VM migration check: a call to +/// [VmPlacementPolicyMigrationAbstract#getOptimizedPlacementMap(List)], +/// which finds the VMs to migrate from overloaded and underloaded Hosts and their target Hosts. +/// +/// It's the baseline for [cloudsimplus#94](https://github.com/cloudsimplus/cloudsimplus/issues/94), +/// where the check creates and destroys VMs in their Hosts to compute the migration map +/// and then restores the previous placement, +/// and for [cloudsimplus#648](https://github.com/cloudsimplus/cloudsimplus/issues/648), +/// the quadratic costs of the placement algorithm itself. +/// +/// The Datacenter has [#hosts] Hosts with [#HOST_CORES] cores each: +/// - 1 in [#HOST_TYPES] is overloaded: its VMs use 100% of its CPU; +/// - 1 in [#HOST_TYPES] is underloaded: a single VM requests 1 core; +/// - the others use half of their CPU, so they can receive VMs. +/// +/// Migrations are disabled in the Datacenter, so no migration is ever started. +/// While cloudsimplus#94 isn't fixed, the first check changes the placement: +/// VMs planned to leave underloaded Hosts are left in their target Hosts too, +/// and some VMs are removed from the broker's list of running VMs. +/// The state stops changing after the first check, so the warmup iterations +/// make every measured check start from the same placement. +/// +/// Run it with the GC profiler to also get the memory allocated by each check: +/// +/// ```bash +/// ./mvnw clean package +/// java -jar target/cloudsimplus-benchmarks-*-uber.jar MigrationCheckBenchmark -prof gc +/// ``` +/// +/// @author Manoel Campos da Silva Filho +@BenchmarkMode(Mode.AverageTime) +@OutputTimeUnit(TimeUnit.MILLISECONDS) +@State(Scope.Thread) +@Fork(1) +@Warmup(iterations = 5, time = 2) +@Measurement(iterations = 10, time = 2) +public class MigrationCheckBenchmark { + /// Hosts are created in groups of this size: one overloaded, one underloaded and the others half used. + private static final int HOST_TYPES = 10; + private static final int HOST_CORES = 8; + private static final int MIPS = 1000; + private static final long HOST_RAM = 100_000; + private static final long HOST_BW = 100_000; + private static final long HOST_STORAGE = 1_000_000; + private static final double HOST_MAX_POWER = 200; + private static final double HOST_STATIC_POWER = 100; + + /// Cores of each VM in overloaded and half used Hosts. + private static final int VM_CORES = 2; + private static final long VM_RAM = 1000; + private static final long VM_BW = 1000; + private static final long VM_SIZE = 1000; + + private static final double OVER_UTILIZATION_THRESHOLD = 0.8; + private static final double UNDER_UTILIZATION_THRESHOLD = 0.2; + + /// Cloudlets are long enough to keep running while the check is measured. + private static final long CLOUDLET_LENGTH = 1_000_000_000L; + + /// Simulation time to run before measuring, so that VMs are created and Cloudlets are running. + private static final double STARTUP_TIME = 10; + + /// The Host index, the number of cores and the Cloudlet CPU utilization of a VM. + private record VmSpec(int hostIndex, int cores, double cpuUtilization) { } + + @Param({"100", "500", "1000", "2000"}) + private int hosts; + + private VmPlacementPolicyMigrationAbstract policy; + private List vms; + + @Setup(Level.Trial) + public void setup() { + Log.setLevel(ch.qos.logback.classic.Level.OFF); + final var simulation = new CloudSimPlus(); + final var vmSpecs = new ArrayList(); + final var hostList = new ArrayList(hosts); + for (int i = 0; i < hosts; i++) { + hostList.add(createHost()); + addVmSpecs(i, vmSpecs); + } + + policy = new VmPlacementPolicyMigrationStaticThreshold(new VmSelectionPolicyMinimumUtilization(), OVER_UTILIZATION_THRESHOLD); + policy.setUnderUtilizationThreshold(UNDER_UTILIZATION_THRESHOLD); + policy.setFindHostForVmFunction(initialPlacement(vmSpecs)); + DatacenterSimple.of(simulation, hostList, policy).disableMigrations(); + + final var broker = new DatacenterBrokerSimple(simulation); + vms = vmSpecs.stream().map(MigrationCheckBenchmark::createVm).toList(); + broker.submitVmList(vms); + broker.submitCloudletList(createCloudlets(broker, vms, vmSpecs)); + + simulation.startSync(); + // Each call processes the events of a single time + while (simulation.clock() < STARTUP_TIME) { + simulation.runFor(STARTUP_TIME - simulation.clock()); + } + + policy.setFindHostForVmFunction(null); + final int createdVms = broker.getVmCreatedList().size(); + if (createdVms != vms.size()) { + throw new IllegalStateException("Not all VMs were placed: %d of %d".formatted(createdVms, vms.size())); + } + } + + /// {@return the migration map, so that the JIT compiler doesn't remove the check} + @Benchmark + public Map migrationCheck() { + return policy.getOptimizedPlacementMap(vms); + } + + /// Adds the specs of the VMs for the Host with a given index. + /// VMs in underloaded Hosts have a single core, so the Host requests less than the under utilization threshold. + private static void addVmSpecs(final int hostIndex, final List vmSpecs) { + switch (hostIndex % HOST_TYPES) { + case 0 -> addVmSpecs(vmSpecs, HOST_CORES / VM_CORES, new VmSpec(hostIndex, VM_CORES, 1.0)); + case 1 -> addVmSpecs(vmSpecs, 1, new VmSpec(hostIndex, 1, 0.5)); + default -> addVmSpecs(vmSpecs, HOST_CORES / VM_CORES / 2, new VmSpec(hostIndex, VM_CORES, 1.0)); + } + } + + private static void addVmSpecs(final List vmSpecs, final int count, final VmSpec spec) { + for (int i = 0; i < count; i++) { + vmSpecs.add(spec); + } + } + + /// {@return a function that places each VM into the Host index given for it} + /// The broker gives VMs sequential ids from 0, in the order they are submitted. + private static BiFunction> initialPlacement(final List vmSpecs) { + return (placementPolicy, vm) -> Optional.of(placementPolicy.getHostList().get(vmSpecs.get((int) vm.getId()).hostIndex())); + } + + private static Host createHost() { + final var host = HostSimple.of(HOST_RAM, HOST_BW, HOST_STORAGE, new CoreCapacity(HOST_CORES, MIPS)); + host.setVmScheduler(new VmSchedulerTimeShared()); + host.setPowerModel(new PowerModelHostSimple(HOST_MAX_POWER, HOST_STATIC_POWER)); + return host; + } + + private static Vm createVm(final VmSpec spec) { + final var vm = VmSimple.of(new CoreCapacity(spec.cores(), MIPS)); + vm.setRam(VM_RAM).setBw(VM_BW).setSize(VM_SIZE).setCloudletScheduler(new CloudletSchedulerTimeShared()); + return vm; + } + + private static List createCloudlets( + final DatacenterBrokerSimple broker, final List vms, final List vmSpecs) + { + final var list = new ArrayList(vms.size()); + for (int i = 0; i < vms.size(); i++) { + final var vm = vms.get(i); + final var spec = vmSpecs.get(i); + final var cloudlet = CloudletSimple.of(CLOUDLET_LENGTH, spec.cores()) + .setUtilizationModelCpu(new UtilizationModelDynamic(spec.cpuUtilization())) + .setUtilizationModelRam(new UtilizationModelFull()) + .setUtilizationModelBw(new UtilizationModelFull()); + broker.bindCloudletToVm(cloudlet, vm); + list.add(cloudlet); + } + + return list; + } +}