How to Perform Genetic Algorithm Using Containercloudsim?
Share
Condition for Perform Genetic Algorithm Using Containercloudsim
Description: The Genetic Algorithm implementation provides a robust evolutionary computing approach to solving the complex container allocation problem in cloud environments, drawing inspiration from natural selection and genetic evolution principles. This population-based optimization technique maintains a diverse set of candidate solutions (chromosomes) that represent different container-to-VM mapping configurations, each evaluated through a comprehensive fitness function that balances multiple cloud management objectives.
Through successive generations, the algorithm employs sophisticated genetic operators including tournament selection to identify promising parent solutions, single-point crossover to combine beneficial traits from different allocations, and random mutation to introduce novel variations and maintain population diversity.The fitness evaluation comprehensively addresses four critical optimization criteria: load balancing across virtual machines to prevent resource bottlenecks and ensure Quality of Service, maximizing overall resource utilization to improve cost-effectiveness, minimizing power consumption through intelligent workload consolidation strategies, and reducing migration costs by favoring stable container placements.
The algorithm's elitism mechanism ensures that the best solution found is preserved across generations, while the carefully tuned parameters—including population size, crossover rate, and mutation probability—strike an optimal balance between exploration of new solution regions and exploitation of promising allocations. This evolutionary approach enables the GA to efficiently navigate the complex, high-dimensional search space of container allocation possibilities, consistently converging toward high-quality solutions that significantly enhance cloud infrastructure performance, resource efficiency, and operational stability in dynamic computing environments.
Sample Code
1. SourceCode1:
package GeneticAlgorithm;
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 one host, one VM,
* one container and run one cloudlet on it.
*/
public class ContainerCloudsimGA {
/**
* 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 Genetic Algorithm 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;
GeneticAlgorithmContainerDatacenterBroker broker = createGeneticAlgorithmBroker(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-1", 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("ContainerCloudSimExample1 finished!");
} catch (Exception e) {
e.printStackTrace();
Log.printLine("Unwanted errors happen");
}
}
private static GeneticAlgorithmContainerDatacenterBroker createGeneticAlgorithmBroker(int overBookingFactor) {
GeneticAlgorithmContainerDatacenterBroker broker = null;
try {
broker = new GeneticAlgorithmContainerDatacenterBroker("GA_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 GeneticAlgorithm;
import org.cloudbus.cloudsim.container.core.*;
import java.util.ArrayList;
import java.util.List;
public class GeneticAlgorithmContainerDatacenterBroker extends ContainerDatacenterBroker {
private GeneticAlgorithm geneticAlgorithm;
private boolean gaEnabled;
private List containers;
private List vms;
private List hosts;
private List cloudlets;
public GeneticAlgorithmContainerDatacenterBroker(String name, int overBookingFactor) throws Exception {
super(name, overBookingFactor);
this.gaEnabled = true;
this.containers = new ArrayList<>();
this.vms = new ArrayList<>();
this.hosts = new ArrayList<>();
this.cloudlets = new ArrayList<>();
// Initialize Genetic Algorithm with parameters
int populationSize = 50;
int maxGenerations = 100;
double crossoverRate = 0.8;
double mutationRate = 0.1;
int tournamentSize = 5;
this.geneticAlgorithm = new GeneticAlgorithm(populationSize, maxGenerations, crossoverRate,
mutationRate, tournamentSize);
}
@Override
public void submitContainerList(List< extends Container> list) {
super.submitContainerList(list);
this.containers.addAll(list);
if (gaEnabled && !vms.isEmpty() && !hosts.isEmpty() && !cloudlets.isEmpty()) {
runGeneticAlgorithmOptimization();
}
}
@Override
public void submitVmList(List< extends ContainerVm> list) {
super.submitVmList(list);
this.vms.addAll(list);
if (gaEnabled && !containers.isEmpty() && !hosts.isEmpty() && !cloudlets.isEmpty()) {
runGeneticAlgorithmOptimization();
}
}
@Override
public void submitCloudletList(List< extends ContainerCloudlet> list) {
super.submitCloudletList(list);
this.cloudlets.addAll(list);
if (gaEnabled && !containers.isEmpty() && !vms.isEmpty() && !hosts.isEmpty()) {
runGeneticAlgorithmOptimization();
}
}
public void setHostList(List hostList) {
this.hosts = hostList;
if (gaEnabled && !containers.isEmpty() && !vms.isEmpty() && !cloudlets.isEmpty()) {
runGeneticAlgorithmOptimization();
}
}
private void runGeneticAlgorithmOptimization() {
System.out.println("Running Genetic Algorithm optimization for resource allocation...");
// Initialize GA with current system state
geneticAlgorithm.initialize(containers, vms, hosts, cloudlets);
// Run GA optimization
geneticAlgorithm.run();
// Get best solution and apply it
Chromosome bestSolution = geneticAlgorithm.getBestSolution();
applyGeneticAlgorithmSolution(bestSolution);
// Print results
geneticAlgorithm.printBestSolution();
}
private void applyGeneticAlgorithmSolution(Chromosome 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("GA Allocation: Container %d -> VM %d%n",
container.getId(), vm.getId());
}
}
public void setGaEnabled(boolean enabled) {
this.gaEnabled = enabled;
}
public GeneticAlgorithm getGeneticAlgorithm() {
return geneticAlgorithm;
}
}
3. SourceCode3:
package GeneticAlgorithm;
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.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Random;
/**
* Genetic Algorithm for container allocation in cloud environment
*/
public class GeneticAlgorithm {
private int populationSize;
private int maxGenerations;
private double crossoverRate;
private double mutationRate;
private int tournamentSize;
private List population;
private Chromosome bestChromosome;
private Random random;
// Problem parameters
private List containers;
private List vms;
private List hosts;
private List cloudlets;
public GeneticAlgorithm(int populationSize, int maxGenerations, double crossoverRate,
double mutationRate, int tournamentSize) {
this.populationSize = populationSize;
this.maxGenerations = maxGenerations;
this.crossoverRate = crossoverRate;
this.mutationRate = mutationRate;
this.tournamentSize = tournamentSize;
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 population
population = new ArrayList<>();
for (int i = 0; i < populationSize; i++) {
population.add(new Chromosome(containers.size(), vms.size()));
}
bestChromosome = null;
}
public void run() {
System.out.println(" Starting Genetic Algorithm optimization...");
System.out.printf("Configuration: %d chromosomes, %d generations%n", populationSize, maxGenerations);
System.out.printf("Rates: crossover=%.3f, mutation=%.3f, tournament size=%d%n",
crossoverRate, mutationRate, tournamentSize);
// Evaluate initial population
evaluatePopulation();
for (int generation = 0; generation < maxGenerations; generation++) {
// Create new population
List newPopulation = new ArrayList<>();
// Elitism: keep the best chromosome
newPopulation.add(getBestChromosome().copy());
// Create rest of the population
while (newPopulation.size() < populationSize) {
// Selection
Chromosome parent1 = tournamentSelection();
Chromosome parent2 = tournamentSelection();
// Crossover
Chromosome offspring1 = parent1.copy();
Chromosome offspring2 = parent2.copy();
if (random.nextDouble() < crossoverRate) {
crossover(offspring1, offspring2);
}
// Mutation
if (random.nextDouble() < mutationRate) {
mutate(offspring1);
}
if (random.nextDouble() < mutationRate) {
mutate(offspring2);
}
newPopulation.add(offspring1);
if (newPopulation.size() < populationSize) {
newPopulation.add(offspring2);
}
}
population = newPopulation;
evaluatePopulation();
if (generation % 10 == 0) {
printDetailedProgress(generation, bestChromosome);
}
}
System.out.println(" Genetic Algorithm optimization completed!");
}
private void evaluatePopulation() {
for (Chromosome chromosome : population) {
double fitness = evaluateFitness(chromosome);
chromosome.setFitness(fitness);
// Update global best
if (bestChromosome == null || fitness < bestChromosome.getFitness()) {
bestChromosome = chromosome.copy();
}
}
}
private Chromosome tournamentSelection() {
Chromosome best = null;
for (int i = 0; i < tournamentSize; i++) {
Chromosome candidate = population.get(random.nextInt(population.size()));
if (best == null || candidate.getFitness() < best.getFitness()) {
best = candidate;
}
}
return best.copy();
}
private void crossover(Chromosome parent1, Chromosome parent2) {
int crossoverPoint = random.nextInt(parent1.getAllocation().size());
for (int i = crossoverPoint; i < parent1.getAllocation().size(); i++) {
int temp = parent1.getAllocation().get(i);
parent1.getAllocation().set(i, parent2.getAllocation().get(i));
parent2.getAllocation().set(i, temp);
}
}
private void mutate(Chromosome chromosome) {
int mutationPoint = random.nextInt(chromosome.getAllocation().size());
int newVm = random.nextInt(vms.size());
chromosome.getAllocation().set(mutationPoint, newVm);
}
public void printDetailedProgress(int generation, Chromosome best) {
// 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(Chromosome chromosome) {
double totalFitness = 0.0;
// 1. Load balancing fitness (minimize variance in VM utilization)
totalFitness += calculateLoadBalancingFitness(chromosome);
// 2. Resource utilization fitness (maximize overall utilization)
totalFitness += calculateResourceUtilizationFitness(chromosome);
// 3. Power consumption fitness (minimize power usage)
totalFitness += calculatePowerFitness(chromosome);
// 4. Migration cost fitness (minimize unnecessary migrations)
totalFitness += calculateMigrationFitness(chromosome);
return totalFitness;
}
private double calculateLoadBalancingFitness(Chromosome chromosome) {
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 = chromosome.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
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(Chromosome chromosome) {
double totalUtilization = 0.0;
int count = 0;
for (int vmIdx = 0; vmIdx < vms.size(); vmIdx++) {
double vmUtilization = calculateVmUtilization(vmIdx, chromosome);
totalUtilization += vmUtilization;
count++;
}
return 1.0 / (totalUtilization / count + 0.001); // Avoid division by zero
}
private double calculatePowerFitness(Chromosome chromosome) {
double totalPower = 0.0;
for (int vmIdx = 0; vmIdx < vms.size(); vmIdx++) {
double utilization = calculateVmUtilization(vmIdx, chromosome);
// 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(Chromosome chromosome) {
return 0.1;
}
private double calculateVmUtilization(int vmIdx, Chromosome chromosome) {
double totalMipsRequired = 0.0;
for (int containerIdx = 0; containerIdx < containers.size(); containerIdx++) {
if (chromosome.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;
}
private Chromosome getBestChromosome() {
return Collections.min(population, Comparator.comparingDouble(Chromosome::getFitness));
}
public Chromosome getBestSolution() {
return bestChromosome;
}
public void printBestSolution() {
System.out.println("\n=== Genetic Algorithm Best Solution ===");
System.out.println("Fitness: " + bestChromosome.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(), bestChromosome.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, bestChromosome);
System.out.printf("VM %d: %.2f%% utilization%n", vmIdx, utilization * 100);
}
}
}
Research Breakthrough Possible @S-Logix
