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

Office Address

Social List

How to Analyze Host-Level Power Consumption Using Planetlab-Based Workloads and Powercontainerhost Models in Containercloudsim?

Host-Level Power Consumption Using Planetlab

Condition for Analyze Host-Level Power Consumption Using Planetlab-Based Workloads and Powercontainerhost Models in Containercloudsim

  • Description:
    It simulates a container-based cloud datacenter using CloudSim with power-aware components to analyze energy and power consumption across hosts. It deploys multiple virtual machines and containers using dynamic workload traces from PlanetLab and executes container cloudlets under an overbooking-enabled broker. The simulation integrates migration-aware VM allocation policies and host selection strategies to observe how resource utilization impacts energy efficiency. After the execution, the system retrieves power usage from each host using PowerContainerHost models and computes total energy consumption. This enables evaluation of workload distribution, scheduling behavior, and the effectiveness of power-aware provisioning strategies in reducing overall datacenter energy usage.
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 PowerConsumption {

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

    printCloudletList(newList);

    calculateEnergyConsumption();
    printPowerConsumption();

    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 calculateEnergyConsumption() {
    totalEnergy = 0.0;
    for (ContainerHost host : hostList) {
    if (host instanceof PowerContainerHost) {
    PowerContainerHost powerHost = (PowerContainerHost) host;
    totalEnergy += powerHost.getPower();
    }
    }
    }

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

    private static void printPowerConsumption() {
    DecimalFormat dft = new DecimalFormat("###.##");
    Log.printLine("\n========== POWER CONSUMPTION ANALYSIS ==========");

    double totalPower = 0.0;
    for (int i = 0; i < hostList.size(); i++) {
    ContainerHost host = hostList.get(i);
    if (host instanceof PowerContainerHost) {
    PowerContainerHost powerHost = (PowerContainerHost) host;
    double power = powerHost.getPower();
    totalPower += power;
    Log.printLine("Host " + i + " Power Consumption: " + dft.format(power) + " Joules");
    }
    }

    Log.printLine("Total Power Consumption: " + dft.format(totalPower) + " Joules");
    }
    }
Screenshots
  • 28
  • 29

List