How to Implement the Random Selection Policy in Containercloudsim?
Share
Condition for Implement the Random Selection Policy in Containercloudsim
Description: The Random Selection Policy is a straightforward container placement strategy that selects virtual machines for container deployment through a randomized process. Unlike more complex algorithms that consider resource utilization metrics, this policy operates by generating a random index to choose any eligible VM from the available pool. When a container needs placement, the policy first checks if there are available VMs, then uses a random number generator to select one candidate VM. If the randomly selected VM is in the exclusion list (typically containing overloaded or unsuitable hosts), the process repeats until a valid VM is found. This approach provides inherent load distribution across the infrastructure by preventing any systematic bias toward specific VMs, which can help avoid hot spots that might occur with deterministic algorithms.
However, its stochastic nature means performance can be unpredictable—sometimes achieving good load balancing by chance, while other times potentially placing containers on poorly suited VMs. The policy's main advantages include simplicity, low computational overhead, and natural avoidance of pattern-based placement decisions that could lead to resource fragmentation. It's particularly useful in environments where workload characteristics are highly variable or when seeking to evaluate baseline performance against more sophisticated placement strategies.
Sample Code
/*
* Click nbfs://nbhost/SystemFileSystem/Templates/Licenses/license-default.txt to change this license
* Click nbfs://nbhost/SystemFileSystem/Templates/Classes/Class.java to edit this template
*/
package containercloudsim;
import org.cloudbus.cloudsim.Log;
import org.cloudbus.cloudsim.container.containerPlacementPolicies.*;
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.vmSelectionPolicies.PowerContainerVmSelectionPolicy;
import org.cloudbus.cloudsim.container.vmSelectionPolicies .PowerContainerVmSelectionPolicyMaximumUsage;
import org.cloudbus.cloudsim.core.CloudSim;
import org.cloudbus.cloudsim.examples.container.ConstantsExamples;
import java.io.FileNotFoundException;
import java.text.DecimalFormat;
import java.util.*;
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.ContainerPeProvisionerSimple;
import org.cloudbus.cloudsim.container.containerProvisioners.ContainerRamProvisionerSimple;
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.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.examples.container.UtilizationModelPlanetLabInMemoryExtended;
/**
* A simple example showing how to create a data center with different container
* placement policies and compare their performance.
*/
public class RandomSelectionPolicy {
/**
* The cloudlet list.
*/
private static List cloudletList;
/**
* The vmlist.
*/
private static List vmList;
/**
* The vmlist.
*/
private static List containerList;
/**
* The hostList.
*/
private static List hostList;
/**
* Results storage for different policies
*/
private static Map resultsMap = new HashMap<>();
/**
* Creates main() to run this example.
*
* @param args the args
*/
public static void main(String[] args) {
Log.printLine("Starting Random selection Placement Policies Comparison...");
try {
// Define the placement policies to test
ContainerPlacementPolicy[] policies = {
new ContainerPlacementPolicyFirstFit(),
new ContainerPlacementPolicyLeastFull(),
new ContainerPlacementPolicyMostFull(),
new ContainerPlacementPolicyRandomSelection()
};
String[] policyNames = {
"FirstFit",
"LeastFull",
"MostFull",
"RandomSelection"
};
// Run simulation for each policy
for (int i = 0; i < policies.length; i++) {
Log.printLine("\n\n=== Running Simulation with " + policyNames[i+3] + " Policy ===");
runSimulationWithPolicy(policies[i], policyNames[i+3]);
}
// Print comparative results
printComparativeResults();
Log.printLine("Container Placement Policies Comparison finished!");
} catch (Exception e) {
e.printStackTrace();
Log.printLine("Unwanted errors happen");
}
}
/**
* Run simulation with a specific container placement policy
*/
private static void runSimulationWithPolicy(ContainerPlacementPolicy placementPolicy, String policyName) {
try {
/**
* number of cloud Users
*/
int num_user = 1;
Calendar calendar = Calendar.getInstance();
boolean trace_flag = false;
// Initialize CloudSim for this simulation run
CloudSim.init(num_user, calendar, trace_flag);
/**
* Defining the container allocation Policy with specific placement
* policy
*/
ContainerAllocationPolicy containerAllocationPolicy
= new PowerContainerAllocationPolicySimple();
// Set the placement policy
// ((PowerContainerAllocationPolicySimple) containerAllocationPolicy).setContainerPlacementPolicy(placementPolicy);
/**
* Defining the VM selection Policy.
*/
PowerContainerVmSelectionPolicy vmSelectionPolicy
= new PowerContainerVmSelectionPolicyMaximumUsage();
/**
* Defining the host selection Policy.
*/
HostSelectionPolicy hostSelectionPolicy = new HostSelectionPolicyFirstFit();
double overUtilizationThreshold = 0.80;
double underUtilizationThreshold = 0.70;
/**
* Create host list
*/
hostList = new ArrayList();
hostList = createHostList(ConstantsExamples.NUMBER_HOSTS);
cloudletList = new ArrayList();
vmList = new ArrayList();
/**
* VM allocation policy
*/
ContainerVmAllocationPolicy vmAllocationPolicy
= new PowerContainerVmAllocationPolicyMigrationAbstractHostSelection(
hostList, vmSelectionPolicy, hostSelectionPolicy,
overUtilizationThreshold, underUtilizationThreshold);
/**
* The overbooking factor for allocating containers to VMs.
*/
int overBookingFactor = 80;
ContainerDatacenterBroker broker = createBroker(overBookingFactor);
int brokerId = broker.getId();
/**
* Creating the cloudlet, container and VM lists
*/
cloudletList = createContainerCloudletList(brokerId, ConstantsExamples.NUMBER_CLOUDLETS);
containerList = createContainerList(brokerId, ConstantsExamples.NUMBER_CLOUDLETS);
vmList = createVmList(brokerId, ConstantsExamples.NUMBER_VMS);
/**
* Log address for statistics
*/
String logAddress = "~/Results/" + policyName;
/**
* Create datacenter with experiment name including policy name
*/
@SuppressWarnings("unused")
PowerContainerDatacenter datacenter = (PowerContainerDatacenter) createDatacenter(
"datacenter_" + policyName,
PowerContainerDatacenterCM.class,
hostList,
vmAllocationPolicy,
containerAllocationPolicy,
getExperimentName("ContainerCloudSim", policyName, String.valueOf(overBookingFactor)),
ConstantsExamples.SCHEDULING_INTERVAL,
logAddress,
ConstantsExamples.VM_STARTTUP_DELAY,
ConstantsExamples.CONTAINER_STARTTUP_DELAY);
/**
* Submit lists to broker
*/
broker.submitCloudletList(cloudletList.subList(0, containerList.size()));
broker.submitContainerList(containerList);
broker.submitVmList(vmList);
/**
* Run simulation
*/
CloudSim.terminateSimulation(86400.00);
CloudSim.startSimulation();
CloudSim.stopSimulation();
/**
* Collect and store results
*/
List completedCloudlets = broker.getCloudletReceivedList();
SimulationResults results = analyzeResults(completedCloudlets, policyName);
resultsMap.put(policyName, results);
/**
* Print results for this policy
*/
printPolicyResults(completedCloudlets, policyName);
} catch (Exception e) {
e.printStackTrace();
Log.printLine("Error in simulation with policy: " + policyName);
}
}
/**
* Analyze simulation results for a specific policy
*/
private static SimulationResults analyzeResults(List cloudlets, String policyName) {
SimulationResults results = new SimulationResults(policyName);
if (cloudlets == null || cloudlets.isEmpty()) {
return results;
}
double totalExecutionTime = 0;
double totalWaitTime = 0;
int successfulCloudlets = 0;
double minExecutionTime = Double.MAX_VALUE;
double maxExecutionTime = Double.MIN_VALUE;
for (ContainerCloudlet cloudlet : cloudlets) {
if ("Success".equals(cloudlet.getCloudletStatusString())) {
double executionTime = cloudlet.getActualCPUTime();
double waitTime = cloudlet.getExecStartTime();
totalExecutionTime += executionTime;
totalWaitTime += waitTime;
successfulCloudlets++;
if (executionTime < minExecutionTime) {
minExecutionTime = executionTime;
}
if (executionTime > maxExecutionTime) {
maxExecutionTime = executionTime;
}
}
}
if (successfulCloudlets > 0) {
results.avgExecutionTime = totalExecutionTime / successfulCloudlets;
results.avgWaitTime = totalWaitTime / successfulCloudlets;
results.minExecutionTime = minExecutionTime;
results.maxExecutionTime = maxExecutionTime;
results.successRate = (double) successfulCloudlets / cloudlets.size() * 100;
results.totalCloudlets = cloudlets.size();
results.successfulCloudlets = successfulCloudlets;
}
return results;
}
/**
* Print results for a specific policy
*/
private static void printPolicyResults(List list, String policyName) {
int size = list.size();
int successful = 0;
for (ContainerCloudlet cloudlet : list) {
if ("Success".equals(cloudlet.getCloudletStatusString())) {
successful++;
}
}
Log.printLine("\n=== " + policyName + " Policy Results ===");
Log.printLine("Total Cloudlets: " + size);
Log.printLine("Successful Cloudlets: " + successful);
Log.printLine("Success Rate: " + String.format("%.2f", (double) successful / size * 100) + "%");
if (resultsMap.containsKey(policyName)) {
SimulationResults results = resultsMap.get(policyName);
Log.printLine("Average Execution Time: " + String.format("%.2f", results.avgExecutionTime));
Log.printLine("Average Wait Time: " + String.format("%.2f", results.avgWaitTime));
Log.printLine("Min Execution Time: " + String.format("%.2f", results.minExecutionTime));
Log.printLine("Max Execution Time: " + String.format("%.2f", results.maxExecutionTime));
}
}
/**
* Print comparative results across all policies
*/
private static void printComparativeResults() {
Log.printLine("\n\n" + "=".repeat(80));
Log.printLine("COMPARATIVE RESULTS OF CONTAINER PLACEMENT POLICIES");
Log.printLine("=".repeat(80));
Log.printLine(String.format("%-15s %-8s %-8s %-12s %-12s %-12s %-12s",
"Policy", "Success", "Rate%", "AvgExecTime", "AvgWaitTime", "MinExecTime", "MaxExecTime"));
Log.printLine("-".repeat(80));
for (String policyName : new String[]{"FirstFit", "LeastFull", "MostFull", "RandomSelection"}) {
if (resultsMap.containsKey(policyName)) {
SimulationResults results = resultsMap.get(policyName);
Log.printLine(String.format("%-15s %-8d %-8.2f %-12.2f %-12.2f %-12.2f %-12.2f",
policyName,
results.successfulCloudlets,
results.successRate,
results.avgExecutionTime,
results.avgWaitTime,
results.minExecutionTime,
results.maxExecutionTime));
}
}
Log.printLine("=".repeat(80));
}
/**
* Results storage class
*/
static class SimulationResults {
String policyName;
double avgExecutionTime = 0;
double avgWaitTime = 0;
double minExecutionTime = 0;
double maxExecutionTime = 0;
double successRate = 0;
int totalCloudlets = 0;
int successfulCloudlets = 0;
public SimulationResults(String policyName) {
this.policyName = policyName;
}
}
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;
}
/**
* Prints the Cloudlet objects.
*
* @param list list of Cloudlets
*/
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);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
/**
* Create the Virtual machines and add them to the list
*
* @param brokerId
* @param containerVmsNumber
*/
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;
}
/**
* Create the host list considering the specs listed in the
* {@link ConstantsExamples}.
*
* @param hostsNumber
* @return
*/
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;
}
/**
* Create the data center
*
* @param name
* @param datacenterClass
* @param hostList
* @param vmAllocationPolicy
* @param containerAllocationPolicy
* @param experimentName
* @param logAddress
* @return
* @throws Exception
*/
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;
}
/**
* create the containers for hosting the cloudlets and binding them
* together.
*
* @param brokerId
* @param containersNumber
* @return
*/
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;
}
/**
* Creating the cloudlet list that are going to run on containers
*
* @param brokerId
* @param numberOfCloudlets
* @return
* @throws FileNotFoundException
*/
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;
}
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();
}
}