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

Office Address

Social List

How to Implement a Resource Utilization Monitoring Module in ContainerCloudSim to Track and Report CPU, RAM, and Bandwidth usage for Hosts and VMs During Simulation?

Cloud Data Center using ContainerCloudSim

Condition for Mapping Between Containers and Virtual Machines (Vms) in a Container-Based Cloud Data Center using ContainerCloudSim

  • Description:
    Efficient resource utilization monitoring is critical in cloud computing, particularly in container-based environments, to ensure optimal performance, avoid resource contention, and enable energy-efficient management. In this project, a monitoring module is implemented within ContainerCloudSim to track the utilization of CPU, RAM, and network bandwidth for both hosts and virtual machines.
  • Host Monitoring: Capture CPU, RAM, and bandwidth usage for each physical host.

    VM Monitoring: Track the same metrics for all virtual machines running containers.

    Simulation Integration: Monitor resource utilization during or at the end of a ContainerCloudSim simulation.

    Performance Insights: Identify over-utilized or under-utilized resources to support better container allocation, VM migration, and scheduling decisions.
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.ContainerBwProvisionerSimple;
    import org.cloudbus.cloudsim.container.containerProvisioners.ContainerPe;
    import org.cloudbus.cloudsim.container.containerProvisioners.ContainerRamProvisionerSimple;
    import org.cloudbus.cloudsim.container.containerProvisioners.ContainerPeProvisionerSimple;
    import org.cloudbus.cloudsim.container.containerVmProvisioners.ContainerVmBwProvisionerSimple;
    import org.cloudbus.cloudsim.container.containerVmProvisioners.ContainerVmPe;
    import org.cloudbus.cloudsim.container.containerVmProvisioners.ContainerVmPeProvisionerSimple;
    import org.cloudbus.cloudsim.container.containerVmProvisioners.ContainerVmRamProvisionerSimple;
    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.ContainerCloudletSchedulerDynamicWorkload;
    import org.cloudbus.cloudsim.container.schedulers.ContainerSchedulerTimeSharedOverSubscription;
    import org.cloudbus.cloudsim.container.schedulers.ContainerVmSchedulerTimeSharedOverSubscription;
    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.container.core.PowerContainer;
    import org.cloudbus.cloudsim.container.core.Container;

    import java.io.FileNotFoundException;
    import java.text.DecimalFormat;
    import java.util.ArrayList;
    import java.util.Calendar;
    import java.util.LinkedList;
    import java.util.List;
    import org.cloudbus.cloudsim.examples.container.ConstantsExamples;
    import org.cloudbus.cloudsim.examples.container.UtilizationModelPlanetLabInMemoryExtended;

    public class ResourceUtilizationMonitoring {

    private static List cloudletList;

    private static List vmList;

    private static List containerList;

    private static List hostList;

    private static final DecimalFormat df = new DecimalFormat("#.##");

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

    try {
    int num_user = 1;

    Calendar calendar = Calendar.getInstance();

    boolean trace_flag = false;

    CloudSim.init(num_user, calendar, trace_flag);

    ContainerAllocationPolicy containerAllocationPolicy = new PowerContainerAllocationPolicySimple();

    PowerContainerVmSelectionPolicy vmSelectionPolicy = new PowerContainerVmSelectionPolicyMaximumUsage();

    HostSelectionPolicy hostSelectionPolicy = new HostSelectionPolicyFirstFit();

    double overUtilizationThreshold = 0.80;
    double underUtilizationThreshold = 0.70;

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

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

    int overBookingFactor = 80;
    ContainerDatacenterBroker broker = createBroker(overBookingFactor);
    int brokerId = broker.getId();

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

    String logAddress = "~/Results";

    @SuppressWarnings("unused")
    PowerContainerDatacenter e = (PowerContainerDatacenter) createDatacenter("datacenter",
    PowerContainerDatacenterCM.class, hostList, vmAllocationPolicy, containerAllocationPolicy,
    getExperimentName("ContainerCloudSimExample-1", String.valueOf(overBookingFactor)),
    ConstantsExamples.SCHEDULING_INTERVAL, logAddress,
    ConstantsExamples.VM_STARTTUP_DELAY, ConstantsExamples.CONTAINER_STARTTUP_DELAY);

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

    printHostUtilization(hostList);
    printVmUtilization(vmList);

    Log.printLine("ContainerCloudSimExample1 finished!");
    } catch (Exception e) {
    e.printStackTrace();
    Log.printLine("Unwanted errors happen");
    }
    }

    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 var2) {
    var2.printStackTrace();
    System.exit(0);
    }

    return broker;
    }

    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("###.##");
    for (int i = 0; i < size; i++) {
    cloudlet = list.get(i);
    Log.print(indent + cloudlet.getCloudletId() + indent);

    // Print Container ID
    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()));
    }
    try {
    Thread.sleep(100); // adds movement feel
    } catch (InterruptedException e) {
    e.printStackTrace();
    }
    }
    }

    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 / (int) Math.ceil((double) containerVmsNumber / 4.0D);
    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 / (int) Math.ceil((double) hostsNumber / 3.0D);
    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);
    ContainerDatacenter datacenter = new PowerContainerDatacenterCM(name, characteristics, vmAllocationPolicy,
    containerAllocationPolicy, new LinkedList(), schedulingInterval, experimentName, logAddress,
    VMStartupDelay, ContainerStartupDelay);

    return datacenter;
    }

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

    for (int i = 0; i < containersNumber; ++i) {
    int containerType = i / (int) Math.ceil((double) containersNumber / 3.0D);

    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";
    // String inputFolderName = "/home/soft13/soft13/Project 2025/containercloudsim/ContainerCloudsim/dax/CyberShake/CyberShake_30.xml";
    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 var13) {
    var13.printStackTrace();
    System.exit(0);
    }

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

    return cloudletList;
    }
    }

    }
    return cloudletList;
    }

    public static void printHostUtilization(List hostList) {
    Log.printLine("\n========== HOST RESOURCE UTILIZATION ==========");
    for (ContainerHost host : hostList) {
    double cpuUtil = host.getTotalMips();
    double ramUsed = host.getContainerVmRamProvisioner().getUsedVmRam();
    double ramTotal = host.getContainerVmRamProvisioner().getRam();
    double bwUsed = host.getContainerVmBwProvisioner().getUsedBw();
    double bwTotal = host.getContainerVmBwProvisioner().getBw();

    Log.printLine("Host ID: " + host.getId()
    + " | CPU Utilization: " + df.format(cpuUtil * 100) + "%"
    + " | RAM: " + df.format(ramUsed) + "/" + ramTotal + " MB"
    + " | BW: " + df.format(bwUsed) + "/" + bwTotal + " MB/s"
    );
    }
    }

    /**
    * Prints CPU, RAM, and cloudlet utilization info for VMs
    */
    public static void printVmUtilization(List vmList) {
    Log.printLine("\n========== VM RESOURCE UTILIZATION ==========");
    for (ContainerVm vm : vmList) {
    double cpuUtil = vm.getTotalMips();
    double ramUsed = vm.getContainerRamProvisioner().getUsedVmRam();
    double ramTotal = vm.getContainerRamProvisioner().getRam();
    double bwUsed = vm.getContainerBwProvisioner().getUsedVmBw();
    double bwTotal = vm.getContainerBwProvisioner().getBw();

    Log.printLine("VM ID: " + vm.getId()
    + " | CPU Utilization: " + df.format(cpuUtil * 100) + "%"
    + " | RAM: " + df.format(ramUsed) + "/" + ramTotal + " MB"
    + " | BW: " + df.format(bwUsed) + "/" + bwTotal + " MB/s"
    );
    }
    }

    }
Screenshots
  • 7
  • 8
  • 9

List