List of Topics:
Location Research Breakthrough Possible @S-Logix pro@slogix.in

Office Address

Social List

How to Demonstrate the Effect of Host Underutilization on Energy Consumption and Resource Efficiency in ContainerCloudSim?

Host-Level Power Consumption Using Planetlab

Condition for Demonstrate the Effect of Host Underutilization on Energy Consumption and Resource Efficiency in ContainerCloudSim

  • Description:
    To demonstrate the underloaded scenario using ContainerCloudSim, where the infrastructure consists of 15 physical hosts, but only 8 virtual machines and 10 containers are deployed. This imbalance intentionally creates low workload density, simulating real-world cases such as night-time traffic drops or over-provisioned deployments. During execution, resource monitoring and utilization analysis reveal multiple idle or underutilized hosts, highlighting significant power wastage. To mitigate this inefficiency, we further evaluate consolidation strategies based on host selection and VM migration policies, aiming to determine the optimal number of active hosts required to maintain workload performance while minimizing energy usage. This experiment provides insights into when and how cloud providers should consolidate workloads to achieve eco-efficient containerized data centers.
Sample Code
  • package containercloudsim;

    import org.cloudbus.cloudsim.Log;
    import org.cloudbus.cloudsim.Storage;
    import org.cloudbus.cloudsim.UtilizationModelNull;
    import org.cloudbus.cloudsim.container.containerProvisioners.*;
    import org.cloudbus.cloudsim.container.containerVmProvisioners.*;
    import org.cloudbus.cloudsim.container.core.*;
    import org.cloudbus.cloudsim.container.hostSelectionPolicies.HostSelectionPolicy;
    import org.cloudbus.cloudsim.container.hostSelectionPolicies.HostSelectionPolicyFirstFit;
    import org.cloudbus.cloudsim.container.resourceAllocatorMigrationEnabled
    .PowerContainerVmAllocationPolicyMigrationAbstractHostSelection;
    import org.cloudbus.cloudsim.container.resourceAllocators.ContainerAllocationPolicy;
    import org.cloudbus.cloudsim.container.resourceAllocators.ContainerVmAllocationPolicy;
    import org.cloudbus.cloudsim.container.resourceAllocators
    .PowerContainerAllocationPolicySimple;
    import org.cloudbus.cloudsim.container.schedulers.*;
    import org.cloudbus.cloudsim.container.utils.IDs;
    import org.cloudbus.cloudsim.container.vmSelectionPolicies.PowerContainerVmSelectionPolicy;
    import org.cloudbus.cloudsim.container.vmSelectionPolicies
    .PowerContainerVmSelectionPolicyMaximumUsage;
    import org.cloudbus.cloudsim.core.CloudSim;
    import org.cloudbus.cloudsim.examples.container.ConstantsExamples;
    import org.cloudbus.cloudsim.examples.container.UtilizationModelPlanetLabInMemoryExtended;

    import java.io.FileNotFoundException;
    import java.text.DecimalFormat;
    import java.util.ArrayList;
    import java.util.Calendar;
    import java.util.LinkedList;
    import java.util.List;

    /**
    * Underloaded Scenario: Too few containers for too many hosts
    * Demonstrates resource wastage and consolidation strategies
    */
    public class ContainerCloudsimUnderloaded {

    private static List cloudletList;
    private static List vmList;
    private static List containerList;
    private static List hostList;
    private static ContainerDatacenterBroker broker;

    // Custom constants for underloaded scenario
    private static class UnderloadConstants {
    // Creating severe underload: Many hosts, few containers
    public static final int NUMBER_HOSTS = 15; // Many hosts
    public static final int NUMBER_VMS = 8; // Fewer VMs than hosts
    public static final int NUMBER_CONTAINERS = 10; // Very few containers
    public static final int NUMBER_CLOUDLETS = 10;
    }

    public static void main(String[] args) {
    Log.printLine(" Starting Underloaded ContainerCloudSim Scenario...");
    Log.printLine(" Configuration: " + UnderloadConstants.NUMBER_HOSTS + " hosts, " +
    UnderloadConstants.NUMBER_VMS + " VMs, " +
    UnderloadConstants.NUMBER_CONTAINERS + " containers");
    Log.printLine(" Expected: Resource wastage and consolidation opportunities");

    try {
    int num_user = 1;
    Calendar calendar = Calendar.getInstance();
    boolean trace_flag = false;

    CloudSim.init(num_user, calendar, trace_flag);

    // Policies optimized for underloaded scenario
    ContainerAllocationPolicy containerAllocationPolicy = new PowerContainerAllocationPolicySimple();
    PowerContainerVmSelectionPolicy vmSelectionPolicy = new PowerContainerVmSelectionPolicyMaximumUsage();
    HostSelectionPolicy hostSelectionPolicy = new HostSelectionPolicyFirstFit();

    // Higher underutilization threshold to detect underload faster
    double overUtilizationThreshold = 0.85;
    double underUtilizationThreshold = 0.25;

    hostList = createHostList(UnderloadConstants.NUMBER_HOSTS);
    cloudletList = new ArrayList();
    vmList = new ArrayList();

    ContainerVmAllocationPolicy vmAllocationPolicy =
    new PowerContainerVmAllocationPolicyMigrationAbstractHostSelection(
    hostList, vmSelectionPolicy, hostSelectionPolicy,
    overUtilizationThreshold, underUtilizationThreshold);

    int overBookingFactor = 95; // Higher overbooking since we have plenty of resources
    broker = createBroker(overBookingFactor);
    int brokerId = broker.getId();

    cloudletList = createContainerCloudletList(brokerId, UnderloadConstants.NUMBER_CLOUDLETS);
    containerList = createContainerList(brokerId, UnderloadConstants.NUMBER_CONTAINERS);
    vmList = createVmList(brokerId, UnderloadConstants.NUMBER_VMS);

    String logAddress = "~/Results/Underloaded";

    PowerContainerDatacenter datacenter = (PowerContainerDatacenter) createDatacenter("UnderloadedDatacenter",
    PowerContainerDatacenterCM.class, hostList, vmAllocationPolicy, containerAllocationPolicy,
    getExperimentName("UnderloadedScenario", String.valueOf(overBookingFactor)),
    ConstantsExamples.SCHEDULING_INTERVAL, logAddress,
    ConstantsExamples.VM_STARTTUP_DELAY, ConstantsExamples.CONTAINER_STARTTUP_DELAY);

    // Add resource monitoring for consolidation
    addResourceMonitoring();

    broker.submitCloudletList(cloudletList.subList(0, containerList.size()));
    broker.submitContainerList(containerList);
    broker.submitVmList(vmList);

    CloudSim.terminateSimulation(86400.00);
    CloudSim.startSimulation();
    CloudSim.stopSimulation();

    List newList = broker.getCloudletReceivedList();
    printCloudletList(newList);
    printResourceUtilization();
    printConsolidationRecommendations();

    Log.printLine(" Underloaded Scenario finished!");

    } catch (Exception e) {
    e.printStackTrace();
    Log.printLine(" Unwanted errors occurred");
    }
    }

    /**
    * Monitor resource utilization for underloaded scenario
    */
    private static void addResourceMonitoring() {
    Log.printLine(" Resource monitoring enabled - tracking underutilization");

    new Thread(() -> {
    try {
    // Simulate periodic monitoring
    for (int i = 0; i < 3; i++) {
    Thread.sleep(3000);
    analyzeResourceUtilization();
    }
    } catch (InterruptedException e) {
    e.printStackTrace();
    }
    }).start();
    }

    /**
    * Analyze resource utilization and suggest consolidation
    */
    private static void analyzeResourceUtilization() {
    Log.printLine("\n ANALYZING RESOURCE UTILIZATION...");

    int underutilizedHosts = 0;
    int idleHosts = 0;
    double totalUtilization = 0;

    for (ContainerHost host : hostList) {
    double utilization = calculateHostUtilization(host);
    totalUtilization += utilization;

    if (utilization < 0.20) {
    underutilizedHosts++;
    Log.printLine(" Host " + host.getId() + " utilization: " +
    String.format("%.2f", utilization * 100) + "% -> UNDERUTILIZED");
    }
    if (utilization < 0.05) {
    idleHosts++;
    }
    }

    double avgUtilization = totalUtilization / hostList.size();

    Log.printLine(" Average Host Utilization: " + String.format("%.2f", avgUtilization * 100) + "%");
    Log.printLine(" Underutilized Hosts (<20%): " + underutilizedHosts + "/" + hostList.size());
    Log.printLine(" Idle Hosts (<5%): " + idleHosts + "/" + hostList.size());

    if (avgUtilization < 0.30) {
    Log.printLine(" LOW UTILIZATION DETECTED - Significant consolidation opportunity!");
    } else if (avgUtilization < 0.50) {
    Log.printLine(" MEDIUM UTILIZATION - Some consolidation possible");
    }
    }

    /**
    * Calculate host utilization (simplified simulation)
    */
    private static double calculateHostUtilization(ContainerHost host) {
    // Simulate low utilization for underloaded scenario
    // In real implementation, this would use actual metrics from the host
    return 0.1 + (Math.random() * 0.3); // Between 10% and 40% utilization
    }

    /**
    * Print resource utilization summary
    */
    private static void printResourceUtilization() {
    Log.printLine("\n========== RESOURCE UTILIZATION SUMMARY ==========");

    double totalHostMips = 0;
    double totalVmMips = 0;
    double totalContainerMips = 0;

    for (ContainerHost host : hostList) {
    totalHostMips += host.getTotalMips();
    }

    for (ContainerVm vm : vmList) {
    totalVmMips += vm.getMips();
    }

    for (Container container : containerList) {
    totalContainerMips += container.getMips();
    }

    double hostUtilization = totalVmMips / totalHostMips * 100;
    double vmUtilization = totalContainerMips / totalVmMips * 100;
    double overallEfficiency = totalContainerMips / totalHostMips * 100;

    Log.printLine("Total Host MIPS: " + String.format("%.2f", totalHostMips));
    Log.printLine("Total VM MIPS: " + String.format("%.2f", totalVmMips));
    Log.printLine("Total Container MIPS: " + String.format("%.2f", totalContainerMips));
    Log.printLine("Host Utilization: " + String.format("%.2f", hostUtilization) + "%");
    Log.printLine("VM Utilization: " + String.format("%.2f", vmUtilization) + "%");
    Log.printLine("Overall Efficiency: " + String.format("%.2f", overallEfficiency) + "%");

    // Efficiency analysis
    if (overallEfficiency < 30) {
    Log.printLine(" CRITICAL INEFFICIENCY - Severe resource wastage!");
    } else if (overallEfficiency < 50) {
    Log.printLine(" HIGH INEFFICIENCY - Significant resource wastage");
    } else if (overallEfficiency < 70) {
    Log.printLine(" MEDIUM INEFFICIENCY - Some resource wastage");
    } else {
    Log.printLine(" GOOD EFFICIENCY - Resources well utilized");
    }

    calculateCostSavings();
    }

    /**
    * Calculate potential cost savings from consolidation
    */
    private static void calculateCostSavings() {
    int recommendedHosts = (int) Math.ceil(UnderloadConstants.NUMBER_VMS / 2.0);
    int currentHosts = UnderloadConstants.NUMBER_HOSTS;

    if (recommendedHosts < currentHosts) {
    double savingsPercentage = (currentHosts - recommendedHosts) * 100.0 / currentHosts;
    double estimatedCostReduction = savingsPercentage * 0.7; // Assume 70% cost correlates with host count

    Log.printLine("\n COST SAVINGS ANALYSIS:");
    Log.printLine("Current hosts: " + currentHosts);
    Log.printLine("Recommended hosts: " + recommendedHosts);
    Log.printLine("Potential resource reduction: " + String.format("%.1f", savingsPercentage) + "%");
    Log.printLine("Estimated cost reduction: " + String.format("%.1f", estimatedCostReduction) + "%");
    }
    }

    /**
    * Print consolidation recommendations
    */
    private static void printConsolidationRecommendations() {
    Log.printLine("\n CONSOLIDATION RECOMMENDATIONS:");

    int recommendedHosts = Math.max(2, UnderloadConstants.NUMBER_VMS / 2);
    Log.printLine("1. Reduce host count from " + UnderloadConstants.NUMBER_HOSTS + " to " + recommendedHosts);
    Log.printLine("2. Implement VM live migration to consolidate workloads");
    Log.printLine("3. Use power-saving modes for idle hosts");
    Log.printLine("4. Deploy container density optimization");
    Log.printLine("5. Consider dynamic right-sizing based on workload patterns");
    Log.printLine("6. Implement auto-scaling to shut down unused hosts during low demand");

    if (UnderloadConstants.NUMBER_HOSTS > UnderloadConstants.NUMBER_VMS) {
    Log.printLine("7. Match host count to VM count (" + UnderloadConstants.NUMBER_VMS + " hosts)");
    }
    }

    // Modified existing methods for underload scenario
    private static String getExperimentName(String... args) {
    StringBuilder experimentName = new StringBuilder();
    for (int i = 0; i < args.length; ++i) {
    if (!args[i].isEmpty()) {
    if (i != 0) experimentName.append("_");
    experimentName.append(args[i]);
    }
    }
    return experimentName.toString();
    }

    private static ContainerDatacenterBroker createBroker(int overBookingFactor) {
    try {
    return new ContainerDatacenterBroker("UnderloadBroker", overBookingFactor);
    } catch (Exception e) {
    e.printStackTrace();
    System.exit(0);
    return null;
    }
    }

    private static void printCloudletList(List list) {
    int size = list.size();
    ContainerCloudlet cloudlet;
    String indent = " ";

    Log.printLine();
    Log.printLine("========== OUTPUT ==========");
    Log.printLine("Cloudlet ID" + indent + "Container ID" + indent + "STATUS" + indent
    + "Data center ID" + indent + "VM ID" + indent + "Time" + indent
    + "Start Time" + indent + "Finish Time");

    DecimalFormat dft = new DecimalFormat("###.##");
    int successCount = 0;

    for (int i = 0; i < size; i++) {
    cloudlet = list.get(i);
    Log.print(indent + cloudlet.getCloudletId() + indent);
    Log.print(cloudlet.getContainerId() + indent);

    if (cloudlet.getCloudletStatusString().equals("Success")) {
    Log.print("SUCCESS");
    successCount++;
    Log.printLine(indent + indent + cloudlet.getResourceId()
    + indent + indent + indent + cloudlet.getVmId()
    + indent + indent + dft.format(cloudlet.getActualCPUTime()) + indent
    + indent + dft.format(cloudlet.getExecStartTime())
    + indent + indent + dft.format(cloudlet.getFinishTime()));
    } else {
    Log.printLine("FAILED");
    }
    }

    Log.printLine("\n Successfully completed: " + successCount + "/" + size + " cloudlets");
    }

    private static ArrayList createVmList(int brokerId, int containerVmsNumber) {
    ArrayList containerVms = new ArrayList();
    for (int i = 0; i < containerVmsNumber; ++i) {
    ArrayList peList = new ArrayList();
    int vmType = i % 2;

    for (int j = 0; j < ConstantsExamples.VM_PES[vmType]; ++j) {
    peList.add(new ContainerPe(j,
    new ContainerPeProvisionerSimple((double) ConstantsExamples.VM_MIPS[vmType])));
    }

    containerVms.add(new PowerContainerVm(IDs.pollId(ContainerVm.class), brokerId,
    (double) ConstantsExamples.VM_MIPS[vmType], (float) ConstantsExamples.VM_RAM[vmType],
    ConstantsExamples.VM_BW, ConstantsExamples.VM_SIZE, "Xen",
    new ContainerSchedulerTimeSharedOverSubscription(peList),
    new ContainerRamProvisionerSimple(ConstantsExamples.VM_RAM[vmType]),
    new ContainerBwProvisionerSimple(ConstantsExamples.VM_BW),
    peList, ConstantsExamples.SCHEDULING_INTERVAL));
    }
    return containerVms;
    }

    public static List createHostList(int hostsNumber) {
    ArrayList hostList = new ArrayList();
    for (int i = 0; i < hostsNumber; ++i) {
    int hostType = i % 3;
    ArrayList peList = new ArrayList();

    for (int j = 0; j < ConstantsExamples.HOST_PES[hostType]; ++j) {
    peList.add(new ContainerVmPe(j,
    new ContainerVmPeProvisionerSimple((double) ConstantsExamples.HOST_MIPS[hostType])));
    }

    hostList.add(new PowerContainerHostUtilizationHistory(IDs.pollId(ContainerHost.class),
    new ContainerVmRamProvisionerSimple(ConstantsExamples.HOST_RAM[hostType]),
    new ContainerVmBwProvisionerSimple(1000000L), 1000000L, peList,
    new ContainerVmSchedulerTimeSharedOverSubscription(peList),
    ConstantsExamples.HOST_POWER[hostType]));
    }
    return hostList;
    }

    public static ContainerDatacenter createDatacenter(String name, Class< extends ContainerDatacenter> datacenterClass,
    List hostList, ContainerVmAllocationPolicy vmAllocationPolicy,
    ContainerAllocationPolicy containerAllocationPolicy, String experimentName,
    double schedulingInterval, String logAddress, double VMStartupDelay, double ContainerStartupDelay) throws Exception {

    String arch = "x86";
    String os = "Linux";
    String vmm = "Xen";
    double time_zone = 10.0D;
    double cost = 3.0D;
    double costPerMem = 0.05D;
    double costPerStorage = 0.001D;
    double costPerBw = 0.0D;

    ContainerDatacenterCharacteristics characteristics = new ContainerDatacenterCharacteristics(
    arch, os, vmm, hostList, time_zone, cost, costPerMem, costPerStorage, costPerBw);

    return new PowerContainerDatacenterCM(name, characteristics, vmAllocationPolicy,
    containerAllocationPolicy, new LinkedList(), schedulingInterval,
    experimentName, logAddress, VMStartupDelay, ContainerStartupDelay);
    }

    public static List createContainerList(int brokerId, int containersNumber) {
    ArrayList containers = new ArrayList();
    for (int i = 0; i < containersNumber; ++i) {
    int containerType = i % 3;

    containers.add(new PowerContainer(IDs.pollId(Container.class), brokerId,
    (double) ConstantsExamples.CONTAINER_MIPS[containerType],
    ConstantsExamples.CONTAINER_PES[containerType],
    ConstantsExamples.CONTAINER_RAM[containerType],
    ConstantsExamples.CONTAINER_BW, 0L, "Xen",
    new ContainerCloudletSchedulerDynamicWorkload(
    ConstantsExamples.CONTAINER_MIPS[containerType],
    ConstantsExamples.CONTAINER_PES[containerType]),
    ConstantsExamples.SCHEDULING_INTERVAL));
    }
    return containers;
    }

    public static List createContainerCloudletList(int brokerId, int numberOfCloudlets)
    throws FileNotFoundException {
    String inputFolderName = "/home/soft13/soft13/Project 2019/Cloudsim-4.0-examples/src/workload/planetlab";
    ArrayList cloudletList = new ArrayList();
    long fileSize = 300L;
    long outputSize = 300L;
    UtilizationModelNull utilizationModelNull = new UtilizationModelNull();

    java.io.File inputFolder1 = new java.io.File(inputFolderName);
    java.io.File[] files1 = inputFolder1.listFiles();
    int createdCloudlets = 0;

    for (java.io.File aFiles1 : files1) {
    if (aFiles1.isDirectory()) {
    java.io.File inputFolder = new java.io.File(aFiles1.toString());
    java.io.File[] files = inputFolder.listFiles();

    if (files != null) {
    for (int i = 0; i < files.length; ++i) {
    if (createdCloudlets < numberOfCloudlets) {
    try {
    ContainerCloudlet cloudlet = new ContainerCloudlet(
    IDs.pollId(ContainerCloudlet.class),
    ConstantsExamples.CLOUDLET_LENGTH, 1,
    fileSize, outputSize,
    new UtilizationModelPlanetLabInMemoryExtended(files[i].getAbsolutePath(), 300.0D),
    utilizationModelNull, utilizationModelNull);

    cloudlet.setUserId(brokerId);
    cloudletList.add(cloudlet);
    createdCloudlets += 1;
    } catch (Exception e) {
    e.printStackTrace();
    // Continue with next file
    }
    } else {
    return cloudletList;
    }
    }
    }
    }
    }
    return cloudletList;
    }
    }
Screenshots
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41

List