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

Office Address

Social List

How to Determine the Number of Active Hosts and Active VMs Along with Their Average CPU Utilization in a ContainerCloudSim Simulation?

Host-Level Power Consumption Using Planetlab

Condition for Determine the Number of Active Hosts and Active VMs Along with Their Average CPU Utilization in a ContainerCloudSim Simulation

  • Description:
    It simulates a cloud computing environment using ContainerCloudSim, an extension of CloudSim tailored for container-based cloud data centers. The simulation initializes a data center with multiple hosts, each running multiple virtual machines (VMs), which in turn host containers executing cloudlets (tasks). The program employs energy-aware VM allocation and container scheduling policies to optimize resource utilization and minimize power consumption.

    Key metrics such as the number of active hosts, active VMs, average CPU utilization, makespan, total energy consumption, and SLA violations are collected and printed. The simulation workflow involves creating a broker, generating hosts, VMs, containers, and cloudlets, submitting them to the broker, and executing the simulation for a predefined period. After the simulation, the program prints detailed cloudlet execution results and computes resource utilization statistics, highlighting the efficiency and activity of hosts and VMs in the system.
Sample Code
  • package containercloudsim;

    import org.cloudbus.cloudsim.*;
    import org.cloudbus.cloudsim.container.containerProvisioners.*;
    import org.cloudbus.cloudsim.container.containerVmProvisioners.*;
    import org.cloudbus.cloudsim.container.core.*;
    import org.cloudbus.cloudsim.container.hostSelectionPolicies.*;
    import org.cloudbus.cloudsim.container.resourceAllocators.*;
    import org.cloudbus.cloudsim.container.resourceAllocatorMigrationEnabled
    .PowerContainerVmAllocationPolicyMigrationAbstractHostSelection;
    import org.cloudbus.cloudsim.container.schedulers.*;
    import org.cloudbus.cloudsim.container.utils.IDs;
    import org.cloudbus.cloudsim.container.vmSelectionPolicies.*;
    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.*;

    public class ActiveHostActiveVm {

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

    // Metrics collection
    private static double totalCost = 0.0;
    private static double totalEnergy = 0.0;
    private static double makespan = 0.0;
    private static double totalResponseTime = 0.0;
    private static double totalLatency = 0.0;
    private static double totalBandwidth = 0.0;
    private static int slaViolations = 0;
    private static int completedCloudlets = 0;

    public static void main(String[] args) {
    Log.printLine("Starting ContainerCloudSim Exercise...");

    try {
    // First step: Initialize the CloudSim package
    int numUsers = 1;
    Calendar calendar = Calendar.getInstance();
    boolean traceFlag = false;

    CloudSim.init(numUsers, calendar, traceFlag);

    // Second step: Create Datacenter
    ContainerAllocationPolicy containerAllocationPolicy = new PowerContainerAllocationPolicySimple();
    PowerContainerVmSelectionPolicy vmSelectionPolicy = new PowerContainerVmSelectionPolicyMaximumUsage();
    HostSelectionPolicy hostSelectionPolicy = new HostSelectionPolicyFirstFit();
    double overUtilizationThreshold = 0.80;
    double underUtilizationThreshold = 0.70;

    // Create host list
    hostList = createHostList(5); // 5 hosts

    // Create VM allocation policy
    ContainerVmAllocationPolicy vmAllocationPolicy = new PowerContainerVmAllocationPolicyMigrationAbstractHostSelection(
    hostList, vmSelectionPolicy, hostSelectionPolicy,
    overUtilizationThreshold, underUtilizationThreshold);

    // Third step: Create Broker with overbooking factor
    int overBookingFactor = 80;
    broker = createBroker(overBookingFactor);
    int brokerId = broker.getId();

    // Fourth step: Create VMs, Containers and Cloudlets
    vmList = createVmList(brokerId, 10); // 10 VMs
    containerList = createContainerList(brokerId, 20); // 20 containers
    cloudletList = createContainerCloudletList(brokerId, 20); // 20 cloudlets

    // Create datacenter
    String experimentName = getExperimentName("ContainerCloudSimExercise", String.valueOf(overBookingFactor));
    String logAddress = "~/Results";

    datacenter = (PowerContainerDatacenter) createDatacenter(
    "Datacenter_1", PowerContainerDatacenterCM.class,
    hostList, vmAllocationPolicy, containerAllocationPolicy,
    experimentName, ConstantsExamples.SCHEDULING_INTERVAL,
    logAddress, ConstantsExamples.VM_STARTTUP_DELAY,
    ConstantsExamples.CONTAINER_STARTTUP_DELAY);

    // Submit VMs, containers and cloudlets to the broker
    broker.submitVmList(vmList);
    broker.submitContainerList(containerList);
    broker.submitCloudletList(cloudletList);

    // Fifth step: Starts the simulation
    CloudSim.terminateSimulation(86400.00); // 24 hours simulation
    CloudSim.startSimulation();

    // Final step: Print results when simulation is over
    List newList = broker.getCloudletReceivedList();
    CloudSim.stopSimulation();

    // Print comprehensive results
    printCloudletList(newList);
    printResourceUtilization();

    Log.printLine("ContainerCloudSim Exercise finished!");
    } catch (Exception e) {
    e.printStackTrace();
    Log.printLine("The simulation has been terminated due to an unexpected error");
    }
    }

    private static void printResourceUtilization() {
    DecimalFormat df = new DecimalFormat("###.##");

    Log.printLine("\n--- Resource Utilization ---");
    double totalHostUtilization = 0.0;
    int activeHosts = 0;

    for (ContainerHost host : hostList) {
    if (host.getMaxAvailableMips() > 0) {
    totalHostUtilization += host.getMaxAvailableMips();
    activeHosts++;
    }
    }

    double avgHostUtilization = activeHosts > 0 ? totalHostUtilization / activeHosts : 0;
    Log.printLine("Average Host CPU Utilization: " + df.format(avgHostUtilization * 100) + "%");
    Log.printLine("Active Hosts: " + activeHosts + "/" + hostList.size());

    // VM utilization
    double totalVmUtilization = 0.0;
    int activeVms = 0;
    for (ContainerVm vm : vmList) {
    if (vm.getHost() != null) {
    totalVmUtilization += vm.getTotalUtilizationOfCpu(0);
    activeVms++;
    }
    }

    double avgVmUtilization = activeVms > 0 ? totalVmUtilization / activeVms : 0;
    Log.printLine("Average VM CPU Utilization: " + df.format(avgVmUtilization * 100) + "%");
    Log.printLine("Active VMs: " + activeVms + "/" + vmList.size());
    }

    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) {
    ContainerDatacenterBroker broker = null;
    try {
    broker = new ContainerDatacenterBroker("Broker", overBookingFactor);
    } catch (Exception e) {
    e.printStackTrace();
    return null;
    }
    return broker;
    }

    private static List createHostList(int hostsNumber) {
    ArrayList hostList = new ArrayList();
    for (int i = 0; i < hostsNumber; ++i) {
    int hostType = i % 3; // Distribute host types evenly
    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.0;
    double cost = 3.0;
    double costPerMem = 0.05;
    double costPerStorage = 0.001;
    double costPerBw = 0.0;

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

    ContainerDatacenter datacenter = new PowerContainerDatacenterCM(
    name, characteristics, vmAllocationPolicy,
    containerAllocationPolicy, new LinkedList(),
    schedulingInterval, experimentName, logAddress,
    VMStartupDelay, ContainerStartupDelay);

    return datacenter;
    }

    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 % 4; // Distribute VM types evenly

    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;
    }

    private static List createContainerList(int brokerId, int containersNumber) {
    ArrayList containers = new ArrayList();

    for (int i = 0; i < containersNumber; ++i) {
    int containerType = i % 3; // Distribute container types evenly

    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;
    }

    private 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) {
    java.io.File inputFolder = new java.io.File(aFiles1.toString());
    java.io.File[] files = inputFolder.listFiles();

    for (int i = 0; i < files.length; ++i) {
    if (createdCloudlets < numberOfCloudlets) {
    ContainerCloudlet cloudlet = null;

    try {
    cloudlet = new ContainerCloudlet(
    IDs.pollId(ContainerCloudlet.class),
    ConstantsExamples.CLOUDLET_LENGTH, 1,
    fileSize, outputSize,
    new UtilizationModelPlanetLabInMemoryExtended(
    files[i].getAbsolutePath(), 300.0D),
    utilizationModelNull, utilizationModelNull);
    } catch (Exception e) {
    e.printStackTrace();
    System.exit(0);
    }

    cloudlet.setUserId(brokerId);
    cloudletList.add(cloudlet);
    createdCloudlets += 1;
    } else {
    return cloudletList;
    }
    }
    }
    return cloudletList;
    }

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

    String indent = " ";
    Log.printLine();
    Log.printLine("========== CLOUDLET EXECUTION DETAILS ==========");
    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("###.##");
    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");

    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()));
    }
    }
    }

    }
Screenshots
  • 32
  • 33

List