How to Apply Dynamic Resource-Scaling Policies in Containercloudsim to Improve Resource Utilization, Workload Performance, and Energy Efficiency?
Share
Condition for Apply Dynamic Resource-Scaling Policies in Containercloudsim
Description: The proposed system dynamically monitors workload intensity and adjusts computational resources through scaling-up and scaling-down mechanisms based on defined utilization thresholds. When the system detects over-utilization or under-utilization, it automatically provisions or deallocates virtual machines (VMs) to maintain balanced performance and cost-efficiency. The simulation implements threshold-based scaling strategies that aim to optimize CPU, RAM, and bandwidth utilization under varying workload conditions. By integrating container and VM allocation policies with workload monitoring, the framework enables an adaptive infrastructure that enhances resource utilization, reduces energy consumption, and maintains service-level agreement (SLA) compliance. The experimental scenarios—covering low, moderate, high, and critical loads—demonstrate how resource-scaling contributes to achieving elastic and energy-efficient container cloud operations.
/**
* A simple example showing how to create a data center with resource-scaling capabilities
*/
public class ResourceScaling {
/**
* The cloudlet list.
*/
private static List cloudletList;
/**
* The vmlist.
*/
private static List vmList;
/**
* The container list.
*/
private static List containerList;
/**
* The hostList.
*/
private static List hostList;
/**
* Resource-scaling configuration
*/
private static final double SCALE_UP_THRESHOLD = 0.75; // 75% load
private static final double SCALE_DOWN_THRESHOLD = 0.30; // 30% load
private static final int MAX_VMS = 10;
private static final int MIN_VMS = 2;
/**
* Creates main() to run this example.
*
* @param args the args
*/
public static void main(String[] args) {
Log.printLine("Starting ContainerCloudSim with Resource-Scaling...");
try {
/**
* number of cloud Users
*/
int num_user = 1;
/**
* The fields of calendar have been initialized with the current
* date and time.
*/
Calendar calendar = Calendar.getInstance();
/**
* Deactivating the event tracing
*/
boolean trace_flag = false;
/**
* 1- Like CloudSim the first step is initializing the CloudSim
* Package before creating any entities.
*/
CloudSim.init(num_user, calendar, trace_flag);
/**
* 2- Defining the container allocation Policy. This policy
* determines how Containers are allocated to VMs in the data
* center.
*/
ContainerAllocationPolicy containerAllocationPolicy = new PowerContainerAllocationPolicySimple();
/**
* 3- Defining the VM selection Policy. This policy determines which
* VMs should be selected for migration when a host is identified as
* over-loaded.
*/
PowerContainerVmSelectionPolicy vmSelectionPolicy = new PowerContainerVmSelectionPolicyMaximumUsage();
/**
* 4- Defining the host selection Policy. This policy determines
* which hosts should be selected as migration destination.
*/
HostSelectionPolicy hostSelectionPolicy = new HostSelectionPolicyFirstFit();
/**
* 5- Defining the thresholds for selecting the under-utilized and
* over-utilized hosts.
*/
double overUtilizationThreshold = 0.80;
double underUtilizationThreshold = 0.70;
/**
* 6- The host list is created considering the number of hosts, and
* host types which are specified in the {@link ConstantsExamples}.
*/
hostList = new ArrayList();
hostList = createHostList(ConstantsExamples.NUMBER_HOSTS);
cloudletList = new ArrayList();
vmList = new ArrayList();
/**
* 7- The container allocation policy which defines the allocation
* of VMs to containers.
*/
ContainerVmAllocationPolicy vmAllocationPolicy = new PowerContainerVmAllocationPolicyMigrationAbstractHostSelection(
hostList, vmSelectionPolicy, hostSelectionPolicy, overUtilizationThreshold, underUtilizationThreshold);
/**
* 8- The overbooking factor for allocating containers to VMs. This
* factor is used by the broker for the allocation process.
*/
int overBookingFactor = 80;
ContainerDatacenterBroker broker = createBroker(overBookingFactor);
int brokerId = broker.getId();
/**
* 9- Creating the cloudlet, container and VM lists for submitting
* to the broker.
*/
cloudletList = createContainerCloudletList(brokerId, ConstantsExamples.NUMBER_CLOUDLETS);
containerList = createContainerList(brokerId, ConstantsExamples.NUMBER_CLOUDLETS);
vmList = createVmList(brokerId, ConstantsExamples.NUMBER_VMS);
/**
* 10- The address for logging the statistics of the VMs, containers
* in the data center.
*/
String logAddress = "~/Results";
/**
* 11- Submitting the cloudlet's, container's, and VM's lists to
* the broker.
*/
broker.submitCloudletList(cloudletList.subList(0, containerList.size()));
broker.submitContainerList(containerList);
broker.submitVmList(vmList);
/**
* 12- Run resource-scaling simulation before starting
*/
simulateResourceScalingWithMonitoring();
/**
* 13- Determining the simulation termination time according to the
* cloudlet's workload.
*/
CloudSim.terminateSimulation(86400.00);
/**
* 14- Starting the simulation.
*/
CloudSim.startSimulation();
/**
* 15- Stopping the simulation.
*/
CloudSim.stopSimulation();
/**
* 16- Printing the results when the simulation is finished.
*/
List newList = broker.getCloudletReceivedList();
printCloudletList(newList);
/**
* 17- Print final scaling report
*/
printScalingReport();
if (currentLoad > scaleThreshold) {
int vmsToAdd = calculateVmsToAdd(vms.size(), currentLoad, scaleThreshold);
if (vms.size() + vmsToAdd <= MAX_VMS) {
Log.printLine("SCALE UP: Add " + vmsToAdd + " VMs");
Log.printLine("Reason: Load exceeds threshold by " +
String.format("%.1f%%", (currentLoad - scaleThreshold) * 100));
// Simulate adding VMs
for (int i = 0; i < vmsToAdd; i++) {
ContainerVm newVm = createNewVm(vms.get(0).getUserId());
vms.add(newVm);
Log.printLine(" -> Added VM " + newVm.getId() + " (Type: " + getVmType(newVm) + ")");
}
} else {
Log.printLine("SCALE UP: Cannot add more VMs - Maximum limit (" + MAX_VMS + ") reached");
}
} else if (currentLoad < SCALE_DOWN_THRESHOLD) {
int vmsToRemove = calculateVmsToRemove(vms.size(), currentLoad, SCALE_DOWN_THRESHOLD);
if (vms.size() - vmsToRemove >= MIN_VMS) {
Log.printLine("SCALE DOWN: Remove " + vmsToRemove + " VMs");
Log.printLine("Reason: Load below scale-down threshold of " +
String.format("%.1f%%", SCALE_DOWN_THRESHOLD * 100));
// Simulate removing VMs (remove from end of list)
for (int i = 0; i < vmsToRemove; i++) {
if (!vms.isEmpty()) {
ContainerVm removedVm = vms.remove(vms.size() - 1);
Log.printLine(" -> Removed VM " + removedVm.getId());
}
}
} else {
Log.printLine("SCALE DOWN: Cannot remove more VMs - Minimum limit (" + MIN_VMS + ") reached");
}
} else {
Log.printLine("NO SCALING: Load within optimal range");
Log.printLine("Optimal range: " + String.format("%.1f%%", SCALE_DOWN_THRESHOLD * 100) +
" - " + String.format("%.1f%%", scaleThreshold * 100));
}
Log.printLine("Final VM count: " + vms.size());
}
/**
* Calculate how many VMs to add based on load
*/
private static int calculateVmsToAdd(int currentVmCount, double currentLoad, double scaleThreshold) {
double overloadPercentage = (currentLoad - scaleThreshold) / scaleThreshold;
int vmsToAdd = (int) Math.ceil(currentVmCount * overloadPercentage);
return Math.max(1, Math.min(vmsToAdd, MAX_VMS - currentVmCount));
}
/**
* Calculate how many VMs to remove based on load
*/
private static int calculateVmsToRemove(int currentVmCount, double currentLoad, double scaleDownThreshold) {
double underloadPercentage = (scaleDownThreshold - currentLoad) / scaleDownThreshold;
int vmsToRemove = (int) Math.floor(currentVmCount * underloadPercentage * 0.5);
return Math.max(1, Math.min(vmsToRemove, currentVmCount - MIN_VMS));
}
/**
* Create a new VM for scaling (same specs as first VM)
*/
private static ContainerVm createNewVm(int brokerId) {
ArrayList peList = new ArrayList();
int vmType = 0; // Use first VM type for new VMs
for (int j = 0; j < ConstantsExamples.VM_PES[vmType]; ++j) {
peList.add(new ContainerPe(j,
new ContainerPeProvisionerSimple((double) ConstantsExamples.VM_MIPS[vmType])));
}
return 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);
}
/**
* Get VM type for logging
*/
private static String getVmType(ContainerVm vm) {
double mips = vm.getMips();
if (mips == 2500) return "High-CPU";
else if (mips == 2000) return "Medium-CPU";
else if (mips == 1000) return "Low-CPU";
else return "Custom-CPU";
}
/**
* Simulate resource-scaling with multiple load scenarios
*/
private static void simulateResourceScalingWithMonitoring() {
Log.printLine("\n" + "=".repeat(60));
Log.printLine("RESOURCE-SCALING SIMULATION WITH DIFFERENT LOAD SCENARIOS");
Log.printLine("=".repeat(60));
// Test different load scenarios
double[] loadScenarios = {0.25, 0.45, 0.65, 0.85, 0.95};
String[] scenarioNames = {
"LOW LOAD", "MODERATE LOAD", "HIGH LOAD", "VERY HIGH LOAD", "CRITICAL LOAD"
};
for (int i = 0; i < loadScenarios.length; i++) {
Log.printLine("\n--- Scenario " + (i + 1) + ": " + scenarioNames[i] + " ---");
// Create a copy of VMs for this scenario
List scenarioVms = new ArrayList<>(vmList);
// Run resource-scaling for this load scenario
simulateResourceScaling(scenarioVms, loadScenarios[i], SCALE_UP_THRESHOLD);
// Calculate resource utilization after scaling
calculateResourceUtilization(scenarioVms, loadScenarios[i]);
try {
Thread.sleep(500); // Pause between scenarios for readability
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
Log.printLine("\nAverage VM Specifications:");
Log.printLine(" CPU: " + String.format("%.0f", avgMips) + " MIPS per core");
Log.printLine(" Cores: " + avgPes + " per VM");
Log.printLine(" RAM: " + String.format("%.0f", avgRam) + " MB per VM");
Log.printLine(" Total CPU: " + String.format("%.0f", avgMips * avgPes) + " MIPS per VM");
}
}
/**
* It creates a specific name for the experiment which is used for creating
* the Log address folder.
*/
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]);
}
}
/**
* Prints the Cloudlet objects.
*
* @param list list of Cloudlets
*/
private static void printCloudletList(List list) {
int size = list.size();
ContainerCloudlet cloudlet;
/**
* 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]));
}
/**
* 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);
/**
* 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";
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;
if (files1 != null) {
for (java.io.File aFiles1 : files1) {
java.io.File inputFolder = new java.io.File(aFiles1.toString());
java.io.File[] files = inputFolder.listFiles();
if (files != null) {
for (int i = 0; i < files.length; ++i) {
if (createdCloudlets < numberOfCloudlets) {
ContainerCloudlet cloudlet = null;
Research Breakthrough Possible @S-Logix
