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

Office Address

Social List

How to Evaluate the Impact of the Most Full Container Placement Policy on Resource Utilization, Load Balancing, and Performance in Containercloudsim?

Host-Level Power Consumption Using Planetlab

Condition for Evaluate the Impact of the Most Full Container Placement Policy on Resource Utilization

  • Description:
    This simulation presents a comprehensive analysis of the Most Full Container Placement Policy in a CloudSim-based containerized cloud computing environment. The model evaluates how containers are placed onto virtual machines (VMs) based on the "most full" heuristic — a policy that aims to maximize resource utilization by allocating new containers to VMs that are already heavily loaded but not yet overloaded. The experiment integrates the PowerContainerDatacenter, PowerContainerVmAllocationPolicyMigrationAbstractHostSelection, and ContainerPlacementPolicyMostFull to simulate realistic workload dynamics.The system measures key performance metrics including VM utilization, overload frequency, execution time distribution, concentration index, and performance degradation under various load conditions. Through detailed post-simulation analytics, it identifies trade-offs between high utilization and system stability, highlighting scenarios where aggressive packing improves energy efficiency but risks overloading.This study provides valuable insights into resource consolidation strategies, load concentration metrics, and efficiency analysis in container-based cloud infrastructures — contributing to optimization models for energy-efficient cloud resource management.
Sample Code
  • package containercloudsim;

    import org.cloudbus.cloudsim.Log;
    import org.cloudbus.cloudsim.Storage;
    import org.cloudbus.cloudsim.UtilizationModelNull;
    import org.cloudbus.cloudsim.container.containerPlacementPolicies.ContainerPlacementPolicy;
    import org.cloudbus.cloudsim.container.containerPlacementPolicies.ContainerPlacementPolicyMostFull;
    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.*;
    import org.cloudbus.cloudsim.examples.container.ConstantsExamples;
    import org.cloudbus.cloudsim.examples.container.UtilizationModelPlanetLabInMemoryExtended;

    /**
    * Comprehensive analysis of Most Full Container Placement Policy
    */
    public class PlacementPolicyMostFull {

    private static List cloudletList;
    private static List vmList;
    private static List containerList;
    private static List hostList;

    // Statistics for Most Full analysis
    private static MostFullStats mostFullStats;

    public static void main(String[] args) {
    Log.printLine("Starting Most Full Container Placement Policy Analysis...");
    mostFullStats = new MostFullStats();

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

    // Initialize CloudSim
    CloudSim.init(num_user, calendar, trace_flag);

    // Define policies
    ContainerAllocationPolicy containerAllocationPolicy = new PowerContainerAllocationPolicySimple();
    PowerContainerVmSelectionPolicy vmSelectionPolicy = new PowerContainerVmSelectionPolicyMaximumUsage();
    HostSelectionPolicy hostSelectionPolicy = new HostSelectionPolicyFirstFit();

    double overUtilizationThreshold = 0.80;
    double underUtilizationThreshold = 0.70;

    // Create infrastructure
    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();

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

    String logAddress = "~/Results/MostFullAnalysis";

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

    // Submit to broker
    broker.submitCloudletList(cloudletList.subList(0, containerList.size()));
    broker.submitContainerList(containerList);
    broker.submitVmList(vmList);

    // Analyze Most Full placement before simulation
    analyzeMostFullPlacement(containerList, vmList);

    CloudSim.terminateSimulation(86400.00);
    CloudSim.startSimulation();
    CloudSim.stopSimulation();

    // Get results and analyze
    List completedCloudlets = broker.getCloudletReceivedList();
    printCloudletList(completedCloudlets);
    analyzeMostFullResults(completedCloudlets, containerList, vmList);
    printMostFullStatistics();

    Log.printLine("Most Full Container Placement Analysis finished!");

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

    /**
    * Analyze Most Full placement pattern
    */
    private static void analyzeMostFullPlacement(List containers, List vms) {
    Log.printLine("\n=== MOST FULL PLACEMENT ANALYSIS ===");

    // Simulate Most Full placement
    ContainerPlacementPolicy mostFullPolicy = new ContainerPlacementPolicyMostFull();
    Map vmContainerCount = new HashMap<>();
    Map vmCpuUtilization = new HashMap<>();
    Map vmRamUtilization = new HashMap<>();
    Map initialAvailableMips = new HashMap<>();
    Map overloadedVMs = new HashMap<>();

    // Initialize maps and record initial available MIPS
    for (ContainerVm vm : vms) {
    vmContainerCount.put(vm.getId(), 0);
    vmCpuUtilization.put(vm.getId(), 0.0);
    vmRamUtilization.put(vm.getId(), 0.0);
    overloadedVMs.put(vm.getId(), 0);
    initialAvailableMips.put(vm.getId(), vm.getContainerScheduler().getAvailableMips());
    }

    Log.printLine("Initial Available MIPS per VM:");
    for (ContainerVm vm : vms) {
    Log.printLine(String.format("VM %d: %.2f MIPS available",
    vm.getId(), initialAvailableMips.get(vm.getId())));
    }

    // Simulate placement for each container
    List containersCopy = new ArrayList<>(containers);
    for (Container container : containersCopy) {
    ContainerVm selectedVm = mostFullPolicy.getContainerVm(vmList, container, new HashSet());

    if (selectedVm != null) {
    // Update statistics
    int vmId = selectedVm.getId();
    vmContainerCount.put(vmId, vmContainerCount.get(vmId) + 1);

    // Calculate utilization (simplified)
    double cpuUtil = vmCpuUtilization.get(vmId)
    + (container.getMips() / selectedVm.getMips());
    double ramUtil = vmRamUtilization.get(vmId)
    + (container.getRam() / (double) selectedVm.getRam());

    vmCpuUtilization.put(vmId, cpuUtil);
    vmRamUtilization.put(vmId, ramUtil);

    // Check for overload
    if (cpuUtil > 1.0) {
    overloadedVMs.put(vmId, overloadedVMs.get(vmId) + 1);
    mostFullStats.overloadEvents++;
    }

    mostFullStats.totalPlacements++;
    mostFullStats.placementSequence.add(new Placement(container.getId(), vmId));

    // Record available MIPS decision metric
    double availableMips = selectedVm.getContainerScheduler().getAvailableMips();
    mostFullStats.availableMipsAtPlacement.add(availableMips);
    }
    }

    for (ContainerVm vm : vms) {
    int vmId = vm.getId();
    int containerCount = vmContainerCount.get(vmId);
    double cpuUtilPercent = Math.min(vmCpuUtilization.get(vmId) * 100, 100);
    double ramUtilPercent = Math.min(vmRamUtilization.get(vmId) * 100, 100);
    double initialMips = initialAvailableMips.get(vmId);
    int overloadCount = overloadedVMs.get(vmId);

    // Update statistics
    mostFullStats.vmUtilization.add(cpuUtilPercent);
    mostFullStats.finalVmUtilization.put(vmId, cpuUtilPercent);
    mostFullStats.overloadCounts.put(vmId, overloadCount);

    if (cpuUtilPercent > mostFullStats.maxVmUtilization) {
    mostFullStats.maxVmUtilization = cpuUtilPercent;
    mostFullStats.mostUtilizedVm = vmId;
    }
    if (cpuUtilPercent < mostFullStats.minVmUtilization || mostFullStats.minVmUtilization == -1) {
    mostFullStats.minVmUtilization = cpuUtilPercent;
    mostFullStats.leastUtilizedVm = vmId;
    }

    // Track concentration
    if (cpuUtilPercent > 80) {
    mostFullStats.highlyUtilizedVMs++;
    }
    }

    // Calculate concentration metrics
    calculateConcentrationMetrics();
    }

    /**
    * Calculate concentration and overload metrics
    */
    private static void calculateConcentrationMetrics() {
    double sum = 0;
    double sumSquared = 0;
    int count = mostFullStats.vmUtilization.size();

    for (double utilization : mostFullStats.vmUtilization) {
    sum += utilization;
    sumSquared += utilization * utilization;
    }

    double mean = sum / count;
    double variance = (sumSquared / count) - (mean * mean);
    double stdDev = Math.sqrt(variance);

    mostFullStats.averageUtilization = mean;
    mostFullStats.utilizationStdDev = stdDev;

    // Calculate concentration ratio (Gini coefficient-like metric)
    List sortedUtilization = new ArrayList<>(mostFullStats.vmUtilization);
    Collections.sort(sortedUtilization);

    double concentrationIndex = 0;
    for (int i = 0; i < sortedUtilization.size(); i++) {
    concentrationIndex += (i + 1) * sortedUtilization.get(i);
    }
    concentrationIndex = (2 * concentrationIndex) / (count * sum) - ((double) (count + 1) / count);
    mostFullStats.concentrationIndex = concentrationIndex;

    Log.printLine(String.format("\nConcentration Metrics:"));
    Log.printLine(String.format("Average VM Utilization: %.2f%%", mean));
    Log.printLine(String.format("Utilization Std Deviation: %.2f%%", stdDev));
    Log.printLine(String.format("Concentration Index: %.3f (0 = even, 1 = concentrated)", concentrationIndex));
    Log.printLine(String.format("Highly Utilized VMs (>80%%): %d", mostFullStats.highlyUtilizedVMs));
    Log.printLine(String.format("Total Overload Events: %d", mostFullStats.overloadEvents));
    }

    /**
    * Analyze Most Full results after simulation
    */
    private static void analyzeMostFullResults(List completedCloudlets,
    List containers, List vms) {
    Log.printLine("\n=== MOST FULL PERFORMANCE RESULTS ===");

    Map> vmExecutionTimes = new HashMap<>();
    Map vmSuccessCount = new HashMap<>();
    Map vmFailureCount = new HashMap<>();
    Map vmTotalMips = new HashMap<>();

    // Initialize maps
    for (ContainerVm vm : vms) {
    vmExecutionTimes.put(vm.getId(), new ArrayList());
    vmSuccessCount.put(vm.getId(), 0);
    vmFailureCount.put(vm.getId(), 0);
    vmTotalMips.put(vm.getId(), vm.getMips());
    }

    // Analyze completed cloudlets
    for (ContainerCloudlet cloudlet : completedCloudlets) {
    int vmId = cloudlet.getVmId();

    if (cloudlet.getCloudletStatusString().equals("Success")) {
    double executionTime = cloudlet.getActualCPUTime();

    vmExecutionTimes.get(vmId).add(executionTime);
    vmSuccessCount.put(vmId, vmSuccessCount.get(vmId) + 1);
    mostFullStats.successfulCloudlets++;

    mostFullStats.totalExecutionTime += executionTime;
    if (executionTime > mostFullStats.maxExecutionTime) {
    mostFullStats.maxExecutionTime = executionTime;
    }
    if (executionTime < mostFullStats.minExecutionTime || mostFullStats.minExecutionTime == -1) {
    mostFullStats.minExecutionTime = executionTime;
    }
    } else {
    vmFailureCount.put(vmId, vmFailureCount.get(vmId) + 1);
    mostFullStats.failedCloudlets++;
    }
    }

    // Calculate performance metrics per VM with focus on overload impact
    Log.printLine("\nVM ID | Success | Failure | Avg Time (s) | Std Dev | Util (%) | Overloads");
    Log.printLine("------|---------|---------|--------------|----------|----------|----------");

    for (ContainerVm vm : vms) {
    int vmId = vm.getId();
    List times = vmExecutionTimes.get(vmId);
    int successCount = vmSuccessCount.get(vmId);
    int failureCount = vmFailureCount.get(vmId);
    double utilization = mostFullStats.finalVmUtilization.get(vmId);
    int overloadCount = mostFullStats.overloadCounts.get(vmId);

    if (successCount > 0) {
    double avgTime = times.stream().mapToDouble(Double::doubleValue).average().orElse(0);
    double stdDev = calculateStdDev(times, avgTime);

    Log.printLine(String.format("%5d | %7d | %7d | %12.2f | %8.2f | %8.1f | %8d",
    vmId, successCount, failureCount, avgTime, stdDev, utilization, overloadCount));

    mostFullStats.vmAvgTimes.put(vmId, avgTime);

    // Track performance degradation due to overload
    if (overloadCount > 0 && avgTime > mostFullStats.avgExecutionTimeNoOverload) {
    mostFullStats.performanceDegradation += (avgTime - mostFullStats.avgExecutionTimeNoOverload) * overloadCount;
    }
    } else if (failureCount > 0) {
    Log.printLine(String.format("%5d | %7d | %7d | %12s | %8s | %8.1f | %8d",
    vmId, successCount, failureCount, "N/A", "N/A", utilization, overloadCount));
    }
    }

    // Calculate overall performance metrics
    calculatePerformanceMetrics(vmExecutionTimes, vmSuccessCount, vmFailureCount);
    }

    /**
    * Calculate standard deviation
    */
    private static double calculateStdDev(List values, double mean) {
    if (values.size() <= 1) {
    return 0;
    }
    double sum = 0;
    for (double value : values) {
    sum += Math.pow(value - mean, 2);
    }
    return Math.sqrt(sum / values.size());
    }

    /**
    * Calculate overall performance metrics
    */
    private static void calculatePerformanceMetrics(Map> vmExecutionTimes,
    Map vmSuccessCount,
    Map vmFailureCount) {
    double totalAvgTime = 0;
    int vmCount = 0;

    for (List times : vmExecutionTimes.values()) {
    if (!times.isEmpty()) {
    double avgTime = times.stream().mapToDouble(Double::doubleValue).average().orElse(0);
    totalAvgTime += avgTime;
    vmCount++;

    // Set baseline for performance degradation calculation
    if (mostFullStats.avgExecutionTimeNoOverload == 0) {
    mostFullStats.avgExecutionTimeNoOverload = avgTime;
    }
    }
    }

    if (vmCount > 0) {
    mostFullStats.overallAvgExecutionTime = totalAvgTime / vmCount;
    }

    // Calculate success and failure rates
    int totalSuccess = vmSuccessCount.values().stream().mapToInt(Integer::intValue).sum();
    int totalFailures = vmFailureCount.values().stream().mapToInt(Integer::intValue).sum();
    mostFullStats.successRate = (double) totalSuccess / mostFullStats.totalPlacements * 100;
    mostFullStats.failureRate = (double) totalFailures / mostFullStats.totalPlacements * 100;

    // Calculate efficiency loss due to overload
    if (mostFullStats.overloadEvents > 0) {
    mostFullStats.avgPerformanceDegradation = mostFullStats.performanceDegradation / mostFullStats.overloadEvents;
    }
    }

    /**
    * Print comprehensive Most Full statistics
    */
    private static void printMostFullStatistics() {
    Log.printLine("\n=== MOST FULL STATISTICS SUMMARY ===");

    Log.printLine("Total Placements: " + mostFullStats.totalPlacements);
    Log.printLine("Successful Cloudlets: " + mostFullStats.successfulCloudlets);
    Log.printLine("Failed Cloudlets: " + mostFullStats.failedCloudlets);
    Log.printLine("Success Rate: " + String.format("%.2f%%", mostFullStats.successRate));
    Log.printLine("Failure Rate: " + String.format("%.2f%%", mostFullStats.failureRate));
    Log.printLine("Overall Average Execution Time: " + String.format("%.2f seconds", mostFullStats.overallAvgExecutionTime));
    Log.printLine("Min Execution Time: " + String.format("%.2f seconds", mostFullStats.minExecutionTime));
    Log.printLine("Max Execution Time: " + String.format("%.2f seconds", mostFullStats.maxExecutionTime));
    Log.printLine("Min VM Utilization: " + String.format("%.2f%% (VM %d)", mostFullStats.minVmUtilization, mostFullStats.leastUtilizedVm));
    Log.printLine("Max VM Utilization: " + String.format("%.2f%% (VM %d)", mostFullStats.maxVmUtilization, mostFullStats.mostUtilizedVm));
    Log.printLine("Average VM Utilization: " + String.format("%.2f%%", mostFullStats.averageUtilization));
    Log.printLine("VM Utilization Std Dev: " + String.format("%.2f%%", mostFullStats.utilizationStdDev));
    Log.printLine("Concentration Index: " + String.format("%.3f", mostFullStats.concentrationIndex));
    Log.printLine("Highly Utilized VMs (>80%): " + mostFullStats.highlyUtilizedVMs);
    Log.printLine("Total Overload Events: " + mostFullStats.overloadEvents);
    Log.printLine("Average Performance Degradation per Overload: " + String.format("%.2f seconds", mostFullStats.avgPerformanceDegradation));

    // Analyze placement patterns
    analyzeMostFullPlacementPatterns();
    }

    /**
    * Analyze placement patterns for Most Full
    */
    private static void analyzeMostFullPlacementPatterns() {
    Log.printLine("\n=== MOST FULL PLACEMENT PATTERN ANALYSIS ===");

    // Count containers per VM in placement sequence
    Map placementDistribution = new HashMap<>();
    for (Placement placement : mostFullStats.placementSequence) {
    placementDistribution.put(placement.vmId,
    placementDistribution.getOrDefault(placement.vmId, 0) + 1);
    }

    Log.printLine("Placement Distribution (sorted by utilization):");
    List> sortedEntries = new ArrayList<>(placementDistribution.entrySet());
    sortedEntries.sort((a, b) -> Double.compare(
    mostFullStats.finalVmUtilization.get(b.getKey()),
    mostFullStats.finalVmUtilization.get(a.getKey())
    ));

    for (Map.Entry entry : sortedEntries) {
    int vmId = entry.getKey();
    double percentage = (double) entry.getValue() / mostFullStats.totalPlacements * 100;
    double finalUtilization = mostFullStats.finalVmUtilization.get(vmId);
    int overloads = mostFullStats.overloadCounts.get(vmId);
    Log.printLine(String.format(" VM %d: %d containers (%.1f%%) - Utilization: %.1f%% - Overloads: %d",
    vmId, entry.getValue(), percentage, finalUtilization, overloads));
    }

    // Analyze available MIPS pattern
    if (!mostFullStats.availableMipsAtPlacement.isEmpty()) {
    double avgAvailableMips = mostFullStats.availableMipsAtPlacement.stream()
    .mapToDouble(Double::doubleValue).average().orElse(0);
    double minAvailableMips = mostFullStats.availableMipsAtPlacement.stream()
    .mapToDouble(Double::doubleValue).min().orElse(0);
    double maxAvailableMips = mostFullStats.availableMipsAtPlacement.stream()
    .mapToDouble(Double::doubleValue).max().orElse(0);

    Log.printLine(String.format("\nAvailable MIPS at Placement Decisions:"));
    Log.printLine(String.format(" Average: %.2f MIPS", avgAvailableMips));
    Log.printLine(String.format(" Minimum: %.2f MIPS", minAvailableMips));
    Log.printLine(String.format(" Maximum: %.2f MIPS", maxAvailableMips));
    Log.printLine(String.format(" Note: Lower values indicate more aggressive concentration"));
    }

    // Calculate load concentration metrics
    double avgContainersPerVm = (double) mostFullStats.totalPlacements / placementDistribution.size();
    double concentrationScore = 0;
    for (int count : placementDistribution.values()) {
    concentrationScore += Math.abs(count - avgContainersPerVm);
    }
    concentrationScore /= mostFullStats.totalPlacements;

    Log.printLine(String.format("\nLoad Concentration Score: %.3f (0 = even distribution, 1 = maximum concentration)", concentrationScore));
    Log.printLine(String.format("Utilization Range: %.1f%% (difference between min and max utilization)",
    mostFullStats.maxVmUtilization - mostFullStats.minVmUtilization));
    Log.printLine(String.format("Top VM Utilization: %.1f%%", mostFullStats.maxVmUtilization));

    // Power saving potential analysis
    int potentiallyIdleVMs = 0;
    for (double utilization : mostFullStats.finalVmUtilization.values()) {
    if (utilization < 20) {
    potentiallyIdleVMs++;
    }
    }
    Log.printLine(String.format("Potentially Idle VMs (<20%% utilization): %d", potentiallyIdleVMs));
    Log.printLine(String.format("Power Saving Potential: %.1f%%", (double) potentiallyIdleVMs / mostFullStats.finalVmUtilization.size() * 100));
    }

    // Existing utility methods (similar to previous implementations)
    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("Broker", 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("\n========== CLOUDLET EXECUTION RESULTS ==========");
    Log.printLine("Cloudlet ID" + indent + "VM ID" + indent + "Container ID" + indent + "STATUS" + 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 + indent);
    Log.print(cloudlet.getVmId() + indent + indent);
    Log.print(cloudlet.getContainerId() + indent + indent);

    if (cloudlet.getCloudletStatusString().equals("Success")) {
    Log.print("SUCCESS" + indent + indent);
    Log.printLine(dft.format(cloudlet.getActualCPUTime()) + indent + indent
    + dft.format(cloudlet.getExecStartTime()) + indent + indent
    + dft.format(cloudlet.getFinishTime()));
    } else {
    Log.printLine("FAILED");
    }
    }
    }

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

    /**
    * Statistics class for Most Full analysis
    */
    static class MostFullStats {

    int totalPlacements = 0;
    int successfulCloudlets = 0;
    int failedCloudlets = 0;
    double totalExecutionTime = 0;
    double minExecutionTime = -1;
    double maxExecutionTime = 0;
    double overallAvgExecutionTime = 0;
    double minVmUtilization = -1;
    double maxVmUtilization = 0;
    double averageUtilization = 0;
    double utilizationStdDev = 0;
    double concentrationIndex = 0;
    double successRate = 0;
    double failureRate = 0;
    int overloadEvents = 0;
    int highlyUtilizedVMs = 0;
    int mostUtilizedVm = -1;
    int leastUtilizedVm = -1;
    double performanceDegradation = 0;
    double avgPerformanceDegradation = 0;
    double avgExecutionTimeNoOverload = 0;

    List vmUtilization = new ArrayList<>();
    List availableMipsAtPlacement = new ArrayList<>();
    List placementSequence = new ArrayList<>();
    Map vmAvgTimes = new HashMap<>();
    Map finalVmUtilization = new HashMap<>();
    Map overloadCounts = new HashMap<>();
    }

    /**
    * Placement record class
    */
    static class Placement {

    int containerId;
    int vmId;

    Placement(int containerId, int vmId) {
    this.containerId = containerId;
    this.vmId = vmId;
    }
    }
    }
Screenshots
  • 120
  • 121
  • 122
  • 123

List