How to Perform Ant Colony Optimization Algorithm Using Containercloudsim?
Share
Condition for Perform Ant Colony Optimization Algorithm Using Containercloudsim
Description: The Ant Colony Optimization algorithm implemented in this system provides a sophisticated bio-inspired approach for solving the complex container allocation problem in cloud environments. Drawing inspiration from the foraging behavior of real ants, the ACO algorithm employs a population of artificial ants that collaboratively explore the solution space to find optimal container-to-VM mappings. Each ant constructs a complete solution by probabilistically assigning containers to virtual machines based on both pheromone trails, which represent historical knowledge about good solutions, and heuristic information that captures the immediate quality of potential assignments.
The pheromone matrix dynamically evolves through an evaporation mechanism that prevents premature convergence and a reinforcement process that deposits more pheromone on paths corresponding to higher-quality solutions. The algorithm intelligently balances exploration and exploitation through a tunable parameter (q0), allowing it to either greedily select the most promising VM or explore alternative assignments based on a probability distribution. Additional local search operations further refine the best-found solutions by testing small perturbations to container placements.
This multi-objective optimization approach simultaneously addresses four critical cloud management concerns: load balancing across VMs to prevent resource contention, maximizing overall resource utilization for cost efficiency, minimizing power consumption through intelligent workload consolidation, and reducing migration costs by favoring stable allocations. The ACO implementation demonstrates remarkable adaptability to dynamic cloud environments, efficiently navigating the high-dimensional search space of container-VM assignments while providing robust, high-quality solutions that significantly improve cloud infrastructure performance and resource management efficiency.
Sample Code
1. SourceCode1:
package AntColony;
import org.cloudbus.cloudsim.Log;
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.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.examples.container.ConstantsExamples;
import org.cloudbus.cloudsim.examples.container.UtilizationModelPlanetLabInMemoryExtended;
import java.io.FileNotFoundException;
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.LinkedList;
import java.util.List;
/**
* A simple example showing how to create a data center with ACO optimization
*/
public class ContainerCloudsimACO {
/**
* 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;
/**
* Creates main() to run this example.
*
* @param args the args
*/
public static void main(String[] args) {
Log.printLine("Starting Ant Colony Optimization...");
try {
/**
* number of cloud Users
*/
int num_user = 1;
/**
* The fields of calender 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;
AcoContainerDatacenterBroker broker = createAcoBroker(overBookingFactor);
int brokerId = broker.getId();
broker.setHostList(hostList);
/**
* 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";
@SuppressWarnings("unused")
PowerContainerDatacenter e = (PowerContainerDatacenter) createDatacenter("datacenter",
PowerContainerDatacenterCM.class, hostList, vmAllocationPolicy, containerAllocationPolicy,
getExperimentName("ContainerCloudSimExample-ACO", String.valueOf(overBookingFactor)),
ConstantsExamples.SCHEDULING_INTERVAL, logAddress,
ConstantsExamples.VM_STARTTUP_DELAY, ConstantsExamples.CONTAINER_STARTTUP_DELAY);
/**
* 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- Determining the simulation termination time according to the
* cloudlet's workload.
*/
CloudSim.terminateSimulation(86400.00);
/**
* 13- Starting the simualtion.
*/
CloudSim.startSimulation();
/**
* 14- Stopping the simualtion.
*/
CloudSim.stopSimulation();
/**
* 15- Printing the results when the simulation is finished.
*/
List newList = broker.getCloudletReceivedList();
printCloudletList(newList);
Log.printLine("ContainerCloudSimExample ACO finished!");
} catch (Exception e) {
e.printStackTrace();
Log.printLine("Unwanted errors happen");
}
}
private static AcoContainerDatacenterBroker createAcoBroker(int overBookingFactor) {
AcoContainerDatacenterBroker broker = null;
try {
broker = new AcoContainerDatacenterBroker("ACO_Broker", overBookingFactor);
} catch (Exception var2) {
var2.printStackTrace();
System.exit(0);
}
return broker;
}
/**
* 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]);
}
}
return experimentName.toString();
}
/**
* 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";
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;
}
}
2. SourceCode2:
package AntColony;
import org.cloudbus.cloudsim.container.core.ContainerCloudlet;
import org.cloudbus.cloudsim.container.core.Container;
import org.cloudbus.cloudsim.container.core.ContainerVm;
import org.cloudbus.cloudsim.container.core.ContainerHost;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
/**
* Ant Colony Optimization for container allocation in cloud environment
*/
public class AcoAlgorithm {
private int numberOfAnts;
private int maxIterations;
private double evaporationRate;
private double alpha; // Pheromone importance
private double beta; // Heuristic importance
private double initialPheromone;
private double q0; // Exploitation probability
private List ants;
private Ant bestAnt;
private double[][] pheromoneMatrix;
private Random random;
// Problem parameters
private List containers;
private List vms;
private List hosts;
private List cloudlets;
public AcoAlgorithm(int numberOfAnts, int maxIterations, double evaporationRate,
double alpha, double beta, double initialPheromone, double q0) {
this.numberOfAnts = numberOfAnts;
this.maxIterations = maxIterations;
this.evaporationRate = evaporationRate;
this.alpha = alpha;
this.beta = beta;
this.initialPheromone = initialPheromone;
this.q0 = q0;
this.random = new Random();
}
public void initialize(List containers, List vms,
List hosts, List cloudlets) {
this.containers = containers;
this.vms = vms;
this.hosts = hosts;
this.cloudlets = cloudlets;
// Initialize pheromone matrix
initializePheromoneMatrix();
// Initialize ants
ants = new ArrayList<>();
for (int i = 0; i < numberOfAnts; i++) {
ants.add(new Ant(containers.size()));
}
bestAnt = null;
}
private void initializePheromoneMatrix() {
int numContainers = containers.size();
int numVms = vms.size();
pheromoneMatrix = new double[numContainers][numVms];
for (int i = 0; i < numContainers; i++) {
for (int j = 0; j < numVms; j++) {
pheromoneMatrix[i][j] = initialPheromone;
}
}
}
public void run() {
System.out.println(" Starting ACO optimization...");
System.out.printf("Configuration: %d ants, %d iterations%n", numberOfAnts, maxIterations);
System.out.printf("Parameters: evaporation=%.3f, alpha=%.3f, beta=%.3f, q0=%.3f%n",
evaporationRate, alpha, beta, q0);
for (int iteration = 0; iteration < maxIterations; iteration++) {
// Construct solutions for all ants
for (Ant ant : ants) {
constructSolution(ant);
double fitness = evaluateFitness(ant);
ant.setFitness(fitness);
// Update best solution
if (bestAnt == null || fitness < bestAnt.getFitness()) {
bestAnt = ant.copy();
}
}
// Update pheromones
updatePheromones();
// Apply local search to best ant (optional)
localSearch(bestAnt);
if (iteration % 10 == 0) {
printDetailedProgress(iteration, bestAnt);
}
}
System.out.println(" ACO optimization completed!");
}
private void constructSolution(Ant ant) {
ant.clearSolution();
// For each container, choose a VM based on pheromone and heuristic information
for (int containerIdx = 0; containerIdx < containers.size(); containerIdx++) {
int selectedVm = selectVmForContainer(containerIdx);
ant.getAllocation().add(selectedVm);
}
}
private int selectVmForContainer(int containerIdx) {
double q = random.nextDouble();
if (q < q0) {
// Exploitation: choose the VM with highest probability
return exploitationSelection(containerIdx);
} else {
// Exploration: choose based on probability distribution
return explorationSelection(containerIdx);
}
}
private int exploitationSelection(int containerIdx) {
double maxProbability = -1.0;
int selectedVm = -1;
for (int vmIdx = 0; vmIdx < vms.size(); vmIdx++) {
double probability = calculateProbability(containerIdx, vmIdx);
if (probability > maxProbability) {
maxProbability = probability;
selectedVm = vmIdx;
}
}
return selectedVm;
}
private int explorationSelection(int containerIdx) {
double[] probabilities = new double[vms.size()];
double total = 0.0;
// Calculate probabilities for all VMs
for (int vmIdx = 0; vmIdx < vms.size(); vmIdx++) {
probabilities[vmIdx] = calculateProbability(containerIdx, vmIdx);
total += probabilities[vmIdx];
}
// Roulette wheel selection
double randomValue = random.nextDouble() * total;
double cumulative = 0.0;
for (int vmIdx = 0; vmIdx < vms.size(); vmIdx++) {
cumulative += probabilities[vmIdx];
if (cumulative >= randomValue) {
return vmIdx;
}
}
return vms.size() - 1; // Fallback
}
private double calculateProbability(int containerIdx, int vmIdx) {
double pheromone = Math.pow(pheromoneMatrix[containerIdx][vmIdx], alpha);
double heuristic = Math.pow(calculateHeuristic(containerIdx, vmIdx), beta);
return pheromone * heuristic;
}
private double calculateHeuristic(int containerIdx, int vmIdx) {
// Heuristic: prefer VMs with lower current utilization
// This helps in load balancing
double currentUtilization = calculateCurrentVmUtilization(vmIdx);
return 1.0 / (1.0 + currentUtilization); // Lower utilization -> higher heuristic
}
private double calculateCurrentVmUtilization(int vmIdx) {
// Calculate current utilization of VM (based on existing allocations)
double totalMipsRequired = 0.0;
int allocatedContainers = 0;
for (int i = 0; i < containers.size(); i++) {
// This is a simplified calculation - in real implementation,
// you'd track current allocations
Container container = containers.get(i);
ContainerCloudlet cloudlet = findCloudletForContainer(container.getId());
if (cloudlet != null) {
totalMipsRequired += cloudlet.getCloudletLength();
allocatedContainers++;
}
}
double vmMipsCapacity = vms.get(vmIdx).getMips() * vms.get(vmIdx).getNumberOfPes();
double avgMipsPerContainer = allocatedContainers > 0 ? totalMipsRequired / allocatedContainers : 0;
return avgMipsPerContainer / vmMipsCapacity;
}
private void updatePheromones() {
// Evaporate pheromones
evaporatePheromones();
// Deposit pheromones based on ant solutions
for (Ant ant : ants) {
depositPheromones(ant);
}
// Additional pheromone deposit for best solution
if (bestAnt != null) {
depositBestPheromones();
}
}
private void evaporatePheromones() {
for (int i = 0; i < containers.size(); i++) {
for (int j = 0; j < vms.size(); j++) {
pheromoneMatrix[i][j] *= (1.0 - evaporationRate);
// Ensure minimum pheromone level
pheromoneMatrix[i][j] = Math.max(pheromoneMatrix[i][j], 0.001);
}
}
}
private void depositPheromones(Ant ant) {
double depositAmount = 1.0 / (ant.getFitness() + 0.001); // Better fitness -> more pheromone
for (int containerIdx = 0; containerIdx < containers.size(); containerIdx++) {
int vmIdx = ant.getAllocation().get(containerIdx);
pheromoneMatrix[containerIdx][vmIdx] += depositAmount;
}
}
private void depositBestPheromones() {
double bestDepositAmount = 2.0 / (bestAnt.getFitness() + 0.001); // Extra deposit for best solution
for (int containerIdx = 0; containerIdx < containers.size(); containerIdx++) {
int vmIdx = bestAnt.getAllocation().get(containerIdx);
pheromoneMatrix[containerIdx][vmIdx] += bestDepositAmount;
}
}
private void localSearch(Ant ant) {
// Simple local search: try to improve solution by swapping container assignments
int improvements = 0;
int maxImprovements = containers.size() / 10; // Limit number of improvements
for (int i = 0; i < containers.size() && improvements < maxImprovements; i++) {
int currentVm = ant.getAllocation().get(i);
// Try all possible VMs for this container
for (int newVm = 0; newVm < vms.size(); newVm++) {
if (newVm != currentVm) {
// Create temporary solution
Ant tempAnt = ant.copy();
tempAnt.getAllocation().set(i, newVm);
double newFitness = evaluateFitness(tempAnt);
if (newFitness < ant.getFitness()) {
ant.getAllocation().set(i, newVm);
ant.setFitness(newFitness);
improvements++;
break;
}
}
}
}
}
public void printDetailedProgress(int iteration, Ant best) {
System.out.printf("Iteration %d - Best Fitness: %.4f%n", iteration, best.getFitness());
// Print top 5 container allocations
System.out.print(" Sample Allocations: ");
for (int i = 0; i < Math.min(5, best.getAllocation().size()); i++) {
System.out.printf("C%d->VM%d ", i, best.getAllocation().get(i));
}
System.out.println();
}
private double evaluateFitness(Ant ant) {
double totalFitness = 0.0;
// 1. Load balancing fitness (minimize variance in VM utilization)
totalFitness += calculateLoadBalancingFitness(ant);
// 2. Resource utilization fitness (maximize overall utilization)
totalFitness += calculateResourceUtilizationFitness(ant);
// 3. Power consumption fitness (minimize power usage)
totalFitness += calculatePowerFitness(ant);
// 4. Migration cost fitness (minimize unnecessary migrations)
totalFitness += calculateMigrationFitness(ant);
return totalFitness;
}
private double calculateLoadBalancingFitness(Ant ant) {
double[] vmCpuLoad = new double[vms.size()];
double[] vmRamLoad = new double[vms.size()];
double[] vmBwLoad = new double[vms.size()];
// Calculate load on each VM
for (int containerIdx = 0; containerIdx < containers.size(); containerIdx++) {
int vmIdx = ant.getAllocation().get(containerIdx);
Container container = containers.get(containerIdx);
// Find corresponding cloudlet for this container
ContainerCloudlet cloudlet = findCloudletForContainer(container.getId());
if (cloudlet != null) {
vmCpuLoad[vmIdx] += cloudlet.getCloudletLength() / vms.get(vmIdx).getMips();
vmRamLoad[vmIdx] += container.getRam();
vmBwLoad[vmIdx] += container.getBw();
}
}
// Calculate variance (we want to minimize variance for load balancing)
double cpuVariance = calculateVariance(vmCpuLoad);
double ramVariance = calculateVariance(vmRamLoad);
double bwVariance = calculateVariance(vmBwLoad);
return 0.4 * cpuVariance + 0.3 * ramVariance + 0.3 * bwVariance;
}
private double calculateResourceUtilizationFitness(Ant ant) {
double totalUtilization = 0.0;
int count = 0;
for (int vmIdx = 0; vmIdx < vms.size(); vmIdx++) {
double vmUtilization = calculateVmUtilization(vmIdx, ant);
totalUtilization += vmUtilization;
count++;
}
// We want to maximize utilization, so return inverse
return 1.0 / (totalUtilization / count + 0.001); // Avoid division by zero
}
private double calculatePowerFitness(Ant ant) {
double totalPower = 0.0;
for (int vmIdx = 0; vmIdx < vms.size(); vmIdx++) {
double utilization = calculateVmUtilization(vmIdx, ant);
// Simple linear power model: power = idle_power + utilization * (max_power - idle_power)
double power = 100 + utilization * 200; // Example values
totalPower += power;
}
return totalPower;
}
private double calculateMigrationFitness(Ant ant) {
// This would compare with current allocation to estimate migration cost
// For simplicity, we'll return a small constant
return 0.1;
}
private double calculateVmUtilization(int vmIdx, Ant ant) {
double totalMipsRequired = 0.0;
for (int containerIdx = 0; containerIdx < containers.size(); containerIdx++) {
if (ant.getAllocation().get(containerIdx) == vmIdx) {
Container container = containers.get(containerIdx);
ContainerCloudlet cloudlet = findCloudletForContainer(container.getId());
if (cloudlet != null) {
totalMipsRequired += cloudlet.getCloudletLength();
}
}
}
double vmMipsCapacity = vms.get(vmIdx).getMips() * vms.get(vmIdx).getNumberOfPes();
return Math.min(totalMipsRequired / vmMipsCapacity, 1.0);
}
private ContainerCloudlet findCloudletForContainer(int containerId) {
for (ContainerCloudlet cloudlet : cloudlets) {
if (cloudlet.getContainerId() == containerId) {
return cloudlet;
}
}
return null;
}
private double calculateVariance(double[] values) {
double mean = 0.0;
for (double value : values) {
mean += value;
}
mean /= values.length;
double variance = 0.0;
for (double value : values) {
variance += Math.pow(value - mean, 2);
}
return variance / values.length;
}
public Ant getBestSolution() {
return bestAnt;
}
public void printBestSolution() {
System.out.println("\n=== ACO Best Solution ===");
System.out.println("Fitness: " + bestAnt.getFitness());
System.out.println("Container to VM Allocation:");
for (int i = 0; i < containers.size(); i++) {
System.out.printf("Container %d -> VM %d%n",
containers.get(i).getId(), bestAnt.getAllocation().get(i));
}
// Print VM utilization
System.out.println("\nVM Utilization in Best Solution:");
for (int vmIdx = 0; vmIdx < vms.size(); vmIdx++) {
double utilization = calculateVmUtilization(vmIdx, bestAnt);
System.out.printf("VM %d: %.2f%% utilization%n", vmIdx, utilization * 100);
}
}
}
3. SourceCode3:
package AntColony;
import org.cloudbus.cloudsim.container.core.*;
import java.util.ArrayList;
import java.util.List;
public class AcoContainerDatacenterBroker extends ContainerDatacenterBroker {
private AcoAlgorithm aco;
private boolean acoEnabled;
private List containers;
private List vms;
private List hosts;
private List cloudlets;
public AcoContainerDatacenterBroker(String name, int overBookingFactor) throws Exception {
super(name, overBookingFactor);
this.acoEnabled = true;
this.containers = new ArrayList<>();
this.vms = new ArrayList<>();
this.hosts = new ArrayList<>();
this.cloudlets = new ArrayList<>();
// Initialize ACO with parameters
int numberOfAnts = 20;
int maxIterations = 100;
double evaporationRate = 0.5;
double alpha = 1.0; // Pheromone importance
double beta = 2.0; // Heuristic importance
double initialPheromone = 0.1;
double q0 = 0.7; // Exploitation probability
this.aco = new AcoAlgorithm(numberOfAnts, maxIterations, evaporationRate,
alpha, beta, initialPheromone, q0);
}
@Override
public void submitContainerList(List< extends Container> list) {
super.submitContainerList(list);
this.containers.addAll(list);
if (acoEnabled && !vms.isEmpty() && !hosts.isEmpty() && !cloudlets.isEmpty()) {
runAcoOptimization();
}
}
@Override
public void submitVmList(List< extends ContainerVm> list) {
super.submitVmList(list);
this.vms.addAll(list);
if (acoEnabled && !containers.isEmpty() && !hosts.isEmpty() && !cloudlets.isEmpty()) {
runAcoOptimization();
}
}
@Override
public void submitCloudletList(List< extends ContainerCloudlet> list) {
super.submitCloudletList(list);
this.cloudlets.addAll(list);
if (acoEnabled && !containers.isEmpty() && !vms.isEmpty() && !hosts.isEmpty()) {
runAcoOptimization();
}
}
public void setHostList(List hostList) {
this.hosts = hostList;
if (acoEnabled && !containers.isEmpty() && !vms.isEmpty() && !cloudlets.isEmpty()) {
runAcoOptimization();
}
}
private void runAcoOptimization() {
System.out.println("Running ACO optimization for resource allocation...");
// Initialize ACO with current system state
aco.initialize(containers, vms, hosts, cloudlets);
// Run ACO optimization
aco.run();
// Get best solution and apply it
Ant bestSolution = aco.getBestSolution();
applyAcoSolution(bestSolution);
// Print results
aco.printBestSolution();
}
private void applyAcoSolution(Ant solution) {
List allocation = solution.getAllocation();
// Apply the container-to-VM allocation
for (int containerIdx = 0; containerIdx < containers.size(); containerIdx++) {
Container container = containers.get(containerIdx);
int vmIdx = allocation.get(containerIdx);
ContainerVm vm = vms.get(vmIdx);
// Set the container to be allocated to the specified VM
// This would typically involve modifying the allocation policy
System.out.printf("ACO Allocation: Container %d -> VM %d%n",
container.getId(), vm.getId());
}
}
public void setAcoEnabled(boolean enabled) {
this.acoEnabled = enabled;
}
public AcoAlgorithm getAcoAlgorithm() {
return aco;
}
}
4. SourceCode4:
package AntColony;
import java.util.ArrayList;
import java.util.List;
public class Ant {
private List allocation; // containerId -> vmId mapping
private double fitness;
public Ant(int numberOfContainers) {
this.allocation = new ArrayList<>();
this.fitness = Double.MAX_VALUE;
}
public Ant(List allocation) {
this.allocation = new ArrayList<>(allocation);
this.fitness = Double.MAX_VALUE;
}
// Getters and setters
public List getAllocation() {
return allocation;
}
public double getFitness() {
return fitness;
}
public void setFitness(double fitness) {
this.fitness = fitness;
}
public void clearSolution() {
allocation.clear();
}
public Ant copy() {
return new Ant(new ArrayList<>(allocation));
}
@Override
public String toString() {
return "Ant{" +
"fitness=" + fitness +
", allocation=" + allocation +
'}';
}
}
Research Breakthrough Possible @S-Logix
