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

Office Address

Social List

How to Handle Server Host Overload to Maintain Container Execution Performance and System Efficiency in ContainerCloudSim using Dynamic Scaling Strategies?

Host-Level Power Consumption Using Planetlab

Condition for Handle Server Host Overload to Maintain Container Execution Performance and System Efficiency in ContainerCloudSim

  • Description:
    In cloud data centers, resource overloading can lead to performance degradation, increased execution times, and resource contention, which negatively affect service quality and user experience. To investigate this, to design a severely overloaded scenario using ContainerCloudSim, where 3 physical hosts are allocated to 10 virtual machines and 40 containers, creating an intentional imbalance between workload demand and available resources. This setup simulates real-world situations such as peak traffic periods or insufficient provisioning. The simulation monitors system utilization, container execution times, and cloudlet completion rates, revealing performance bottlenecks, high wait times, and lower completion rates due to resource contention. To address these issues, dynamic scaling mechanisms, including adding new hosts and optimizing container placement, are applied to maintain performance under overload conditions. This experiment provides insights into how cloud providers can implement adaptive scaling and resource management policies to sustain service quality and system efficiency under heavy load scenarios.
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;

    /**
    * Overloaded Scenario: Too many containers for too few hosts Demonstrates
    * performance degradation and dynamic scaling
    */
    public class ContainerCloudsimOverloaded {

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

    // Custom constants for overloaded scenario
    private static class OverloadConstants {

    // Creating severe overload: Few hosts, many containers
    public static final int NUMBER_HOSTS = 3; // Very few hosts
    public static final int NUMBER_VMS = 10; // More VMs than hosts
    public static final int NUMBER_CONTAINERS = 40; // Many containers
    public static final int NUMBER_CLOUDLETS = 40;

    // Reduced host capacity to create overload faster
    public static final int[] HOST_PES = {2, 4, 6}; // Reduced PEs
    public static final int[] HOST_RAM = {4096, 8192, 16384}; // Reduced RAM
    public static final double[] HOST_MIPS = {1000, 1500, 2000}; // Reduced MIPS
    }

    public static void main(String[] args) {
    Log.printLine(" Starting Overloaded ContainerCloudSim Scenario...");
    Log.printLine(" Configuration: " + OverloadConstants.NUMBER_HOSTS + " hosts, "
    + OverloadConstants.NUMBER_VMS + " VMs, "
    + OverloadConstants.NUMBER_CONTAINERS + " containers");
    Log.printLine(" Expected: Performance degradation due to resource contention");

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

    CloudSim.init(num_user, calendar, trace_flag);

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

    // Lower thresholds to detect overload faster
    double overUtilizationThreshold = 0.70;
    double underUtilizationThreshold = 0.40;

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

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

    int overBookingFactor = 50; // Lower overbooking for overload scenario
    broker = createBroker(overBookingFactor);
    int brokerId = broker.getId();

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

    String logAddress = "~/Results/Overloaded";

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

    // Add simulation listener for dynamic scaling
    addDynamicScalingListener();

    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);
    printPerformanceMetrics(newList);

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

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

    /**
    * Add dynamic scaling listener to handle overload situations
    */
    private static void addDynamicScalingListener() {
    Log.printLine(" Dynamic scaling enabled - monitoring for overload conditions");

    new Thread(() -> {
    try {
    // Simulate monitoring intervals
    for (int i = 0; i < 5; i++) {
    Thread.sleep(2000);
    checkAndScaleIfNeeded();
    }
    } catch (InterruptedException e) {
    e.printStackTrace();
    }
    }).start();
    }

    /**
    * Check system load and scale if needed
    */
    private static void checkAndScaleIfNeeded() {
    double utilization = calculateSystemUtilization();
    Log.printLine("Current system utilization: " + String.format("%.2f", utilization * 100) + "%");

    if (utilization > 1.2) { // 120% utilization indicates severe overload
    Log.printLine(" SEVERE OVERLOAD DETECTED! Adding additional host...");
    addNewHostDynamically();
    } else if (utilization > 0.9) { // 90% utilization indicates moderate overload
    Log.printLine(" MODERATE OVERLOAD DETECTED - Considering scaling...");
    }
    }

    /**
    * Calculate approximate system utilization
    */
    private static double calculateSystemUtilization() {
    double totalRequestedMips = OverloadConstants.NUMBER_CONTAINERS * 800; // Approx MIPS per container
    double totalAvailableMips = 0;

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

    return totalRequestedMips / totalAvailableMips;
    }

    /**
    * Add a new host dynamically to handle overload
    */
    private static void addNewHostDynamically() {
    try {
    ContainerHost newHost = createNewHost();
    hostList.add(newHost);

    Log.printLine(" New host added dynamically! Host ID: " + newHost.getId());
    Log.printLine(" Total hosts now: " + hostList.size());
    Log.printLine(" New host capacity: " + newHost.getTotalMips() + " MIPS, "
    + newHost.getRam() + " MB RAM");

    } catch (Exception e) {
    Log.printLine(" Failed to add new host: " + e.getMessage());
    }
    }

    /**
    * Create a new host for dynamic scaling
    */
    private static ContainerHost createNewHost() {
    ArrayList peList = new ArrayList();
    int hostType = 2; // Use the most powerful host type for scaling

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

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

    /**
    * Print performance metrics to show degradation
    */
    private static void printPerformanceMetrics(List cloudlets) {
    Log.printLine("\n========== PERFORMANCE METRICS ==========");

    double totalExecutionTime = 0;
    double totalWaitTime = 0;
    int completedCloudlets = 0;
    int failedCloudlets = 0;

    for (ContainerCloudlet cloudlet : cloudlets) {
    if (cloudlet.getCloudletStatusString().equals("Success")) {
    totalExecutionTime += cloudlet.getActualCPUTime();
    totalWaitTime += (cloudlet.getExecStartTime() - 0);
    completedCloudlets++;
    } else {
    failedCloudlets++;
    }
    }

    if (completedCloudlets > 0) {
    double avgExecutionTime = totalExecutionTime / completedCloudlets;
    double avgWaitTime = totalWaitTime / completedCloudlets;
    double efficiency = completedCloudlets / (double) cloudlets.size() * 100;

    Log.printLine("Completed Cloudlets: " + completedCloudlets + "/" + cloudlets.size());
    Log.printLine("Failed Cloudlets: " + failedCloudlets + "/" + cloudlets.size());
    Log.printLine("Success Rate: " + String.format("%.2f", efficiency) + "%");
    Log.printLine("Average Execution Time: " + String.format("%.2f", avgExecutionTime) + " seconds");
    Log.printLine("Average Wait Time: " + String.format("%.2f", avgWaitTime) + " seconds");

    // Performance degradation analysis
    if (avgWaitTime > 150) {
    Log.printLine(" SEVERE PERFORMANCE DEGRADATION - High wait times!");
    } else if (avgWaitTime > 100) {
    Log.printLine(" MODERATE PERFORMANCE DEGRADATION - Elevated wait times");
    } else if (avgWaitTime > 50) {
    Log.printLine(" SLIGHT PERFORMANCE DEGRADATION - Some delays");
    }

    if (efficiency < 60) {
    Log.printLine(" LOW COMPLETION RATE - Resource starvation detected!");
    }
    }

    printScalingRecommendations();
    }

    /**
    * Print scaling recommendations based on performance
    */
    private static void printScalingRecommendations() {
    Log.printLine("\n SCALING RECOMMENDATIONS:");
    Log.printLine("1. Increase host count from " + OverloadConstants.NUMBER_HOSTS + " to "
    + (OverloadConstants.NUMBER_HOSTS + 3));
    Log.printLine("2. Use larger host types for better resource allocation");
    Log.printLine("3. Implement container density optimization");
    Log.printLine("4. Consider auto-scaling based on CPU utilization");
    Log.printLine("5. Use container resource limits to prevent starvation");
    }

    // Modified existing methods for overload 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("OverloadBroker", 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;
    int failCount = 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");
    failCount++;
    }
    }

    Log.printLine("\n Summary - Success: " + successCount + ", Failed: " + failCount + ", Total: " + size);
    }

    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; // Alternate between VM types

    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; // Use all host types
    ArrayList peList = new ArrayList();

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

    hostList.add(new PowerContainerHostUtilizationHistory(IDs.pollId(ContainerHost.class),
    new ContainerVmRamProvisionerSimple(OverloadConstants.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; // Use all container types

    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 instead of exiting
    }
    } else {
    return cloudletList;
    }
    }
    }
    }
    }
    return cloudletList;
    }
    }
Screenshots
  • 42
  • 43
  • 44
  • 45

List