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

Office Address

Social List

How to Demonstrate the Mapping Between Containers and Virtual Machines (Vms) in a Container-Based Cloud Data Center Using Containercloudsim?

Cloud Data Center using ContainerCloudSim

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

  • Description:
    The PowerConsumptio is designed to simulate and analyze the energy consumption of a container-based cloud data center using the CloudSim and ContainerCloudSim frameworks. It models a realistic cloud environment where physical hosts, virtual machines (VMs), containers, and cloudlets interact to execute workloads under specific power management and allocation policies.

    The simulation begins with initializing the CloudSim environment, followed by the creation of multiple physical hosts equipped with power models to monitor their energy usage. A power-aware VM allocation policy and container allocation policy are employed to efficiently distribute workloads based on host utilization thresholds, enabling migration and consolidation of VMs to reduce power waste.

    The program uses the PlanetLab workload traces to simulate real-world task execution. During and after the simulation, the total power consumption of each host is recorded, converted from joules to kilowatt-hours (kWh), and printed along with the total data center energy usage. Overall, this program demonstrates how energy-efficient resource management strategies can be modeled and evaluated in a containerized cloud environment to achieve optimized performance with minimal power consumption.
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;

    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
    // Define policies and thresholds
    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);
    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 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])));
    }

    // Create VM with appropriate scheduler and provisioners
    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("========== 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);
    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() {
    Log.printLine();
    Log.printLine("========== POWER CONSUMPTION ==========");

    double totalPower = 0.0;
    for (ContainerHost host : hostList) {
    if (host instanceof PowerContainerHostUtilizationHistory) {
    PowerContainerHostUtilizationHistory powerHost
    = (PowerContainerHostUtilizationHistory) host;

    // Get the total energy consumption in kWh
    double energy = powerHost.getPower() / (1000 * 3600); // Convert from Joules to kWh
    Log.printLine("Host #" + host.getId() + " energy consumption: "
    + String.format("%.5f", energy) + " kWh");
    totalPower += energy;
    }
    }

    Log.printLine("Total energy consumption: "
    + String.format("%.5f", totalPower) + " kWh");
    }
    }
Screenshots
  • 5
  • 6

List