def fitness(self, C):
"""Calculate the fitness of chromosome C.
The fitness of a solution is its cost. First convert C to the full representation.
Then calculate its cost. (The lower the better).
"""
solution = copy.deepcopy(self.scenario)
helpers.from_chromosome(solution, C)
if self.optimize_for == "availability":
return helpers.get_solution_availability(solution)
elif self.optimize_for == "latency":
return helpers.get_solution_global_latency(solution,
self.processing_latency)
else: #cost
return helpers.get_solution_cost(solution)
def execute(self):
"""Run the genetic algorithm.
Returns the scenario JSON object with placement decisions plus some
algorithm-specific information.
"""
# Fill in missing edges
helpers.add_missing_links(self.scenario)
# check if we will store data per generation in a file
log_generation_data = False
if self.generations_file is not None:
try:
gen_fp = open(self.generations_file, "w+")
log_generation_data = True
gen_fp.write("# Scenario: " + str(self.scenario_file) + "\n")
gen_fp.write("# Seed: " + str(self.seed) + "\n")
gen_fp.write(
"#-----------------------------------------------\n")
gen_fp.write("# Generation\tFitness\t\tTimestamp\n")
except:
logging.warn("Error opening/writing at " +
self.generations_file)
pass
prev_obj_value = 100000000 #inf
if self.convergence_check:
remaining_generations = self.stop_after
start_time = datetime.now()
self.init_solution_pool()
for i in range(0, self.generations):
obj_value = self.generation()
# get a timestamp for this generation
dt = datetime.now() - start_time
# convert to seconds. dt.days should really not matter...
time_taken = dt.days * 24 * 3600 + dt.seconds + dt.microseconds / 1000000.0
logging.info("Generation/fitness (" + self.optimize_for +
")/timestamp: " + str(i) + "\t" + str(obj_value) +
"\t" + str(time_taken))
if log_generation_data:
gen_fp.write(
str(i) + "\t\t" + str(obj_value) + "\t" + str(time_taken) +
"\n")
# if we're checking for convergence to finish execution faster
# we have to do some checks
if self.convergence_check:
if abs(obj_value - prev_obj_value) < self.delta:
# the solution fitness did not significantly changed
remaining_generations -= 1
else:
remaining_generations = self.stop_after
# the algorithm converged
if remaining_generations < 0:
break
prev_obj_value = obj_value
final_solution = helpers.from_chromosome(self.scenario,
self.solution_pool[0])
# add extra information about solution performance (cost, availability, latency, time taken, # generations)
# and indications about constraint violations
info = self.get_solution_info(final_solution)
info["generations"] = i + 1
info["execution_time"] = time_taken
info["link_capacity_constraints_ok"] = True
info["delay_constraints_ok"] = True
info["host_capacity_constraints_ok"] = True
info["mec_constraints_ok"] = True
info["legal_placement"] = True
# some final checks
if not helpers.check_mec_constraints(final_solution):
logging.warn("Final solution violates MEC constraints")
info["mec_constraints_ok"] = False
if not helpers.check_location_constraints(final_solution):
logging.warn("Final solution violates location constraints")
info["location_constraints_ok"] = False
if not helpers.check_link_capacity_constraints(final_solution):
logging.warn("Final solution violates link capacity constraints")
info["link_capacity_constraints_ok"] = False
if not helpers.check_delay_constraints(final_solution):
logging.warn("Final solution violates delay constraints")
info["delay_constraints_ok"] = False
for h in final_solution["hosts"]:
if not helpers.check_host_capacity_constraint(final_solution, h):
logging.warn("Final solution violates host " + h["host_name"] +
" capacity constraints")
info["host_capacity_constraints_ok"] = False
for v in final_solution["vnfs"]:
if not helpers.check_if_placement_allowed(
final_solution, v["place_at"][0], v["vnf_name"]):
logging.warn("Final solution includes illegal placement of " +
v["place_at"][0] + " at " + v["vnf_name"])
info["legal_placement"] = False
final_solution["solution_performance"] = info
used_hosts = helpers.get_used_hosts(final_solution)
logging.info("Used hosts:")
for uh in used_hosts:
logging.info(uh)
used_hedges = helpers.get_used_host_links(final_solution)
logging.info("Used host edges:")
for ue in used_hedges:
logging.info(ue["source"] + " -> " + ue["target"] + " (" +
str(ue["delay"]) + ")")
# Add host edge mapping info to VNF edges
helpers.add_vnf_edge_mapping(final_solution)
return final_solution
def mutation(self):
"""Mutation operator.
For each chromosome in the solution pool, decide according to the mutation
rate if we'll modify it or not. If its selected for mutation, we create a
mutant as follows: We select two random hosts and swap two random VNFs. If
none of the selected hosts has VNFs on it, we select two other hosts and so on.
If the constraints are violated, the mutant is rejected.
"""
counter = 0
for s in self.solution_pool:
if uniform(0, 1) <= self.mutation_rate:
logging.debug("Mutating solution: " + str(s))
# create a copy of the chromosome
scopy = copy.deepcopy(s)
# Corner-case: There's just one gene in the chromosomes, so nothing to
# mutate
if len(scopy.genes) < 2:
continue
# pick two hosts
while True:
h1 = choice(scopy.genes)
h2 = choice(scopy.genes)
if h1 == h2:
continue
if h1.vnfs or h2.vnfs:
break
# pick one VNF from each host
v1 = None
v2 = None
if h1.vnfs:
v1 = choice(h1.vnfs)
h1.vnfs = [
x for x in h1.vnfs if x["vnf_name"] != v1["vnf_name"]
]
if h2.vnfs:
v2 = choice(h2.vnfs)
h2.vnfs = [
x for x in h2.vnfs if x["vnf_name"] != v2["vnf_name"]
]
# swap the two VNFs
if v2:
h1.vnfs.append(v2)
if v1:
h2.vnfs.append(v1)
# create a solution represented in the full format
S = helpers.from_chromosome(self.scenario, scopy)
reject = False
# check constraints
for v in S["vnfs"]:
hname = v["place_at"][0]
vname = v["vnf_name"]
if not helpers.check_if_placement_allowed(S, hname, vname):
# There's a VNF "illegally" placed
reject = True
break
if not reject:
if helpers.check_mec_constraints(S) is False:
reject = True
if not reject:
if helpers.check_location_constraints(S) is False:
reject = True
if not reject:
for h in S["hosts"]:
if helpers.check_host_capacity_constraint(S,
h) is False:
reject = True
break
if not reject:
if helpers.check_link_capacity_constraints(S) is False:
reject = True
if not reject:
if helpers.check_delay_constraints(S) is False:
reject = True
mutant = helpers.to_chromosome(S)
if not reject:
# all constraints ok
# delete old solution and replace with mutant
self.solution_pool[counter] = mutant
logging.debug("Mutant ACCEPTED")
else:
logging.debug("Mutant REJECTED")
pass
counter += 1
def crossover(self):
"""Crossover operation.
- Select two random chromosomes
- Rank their genes according to an efficiency function
- Create a new chromosome by taking the "best" genes until all VNFs are placed
(if when adding a gene one of its VNFs is already placed, just ignore it)
"""
# Pick two random chromosomes (C1 and C2 could coincide)
C1 = choice(self.solution_pool)
C2 = choice(self.solution_pool)
# Create a list of all their genes (i.e., hosts with the VNFs assigned to them)
genes = copy.deepcopy(C1.genes + C2.genes)
# sort genes by efficiency (lowest cost first)
for g in genes:
g.efficiency = self.gene_efficiency(g)
# For availability, sort in descending order (as we want the max here)
rev = False
if self.optimize_for == "availability":
rev = True
genes = sorted(genes, key=attrgetter('efficiency'), reverse=rev)
# vnfs to place (list of strings)
vnfs = [v["vnf_name"] for v in self.scenario["vnfs"]]
# create new chromosome
new_genes = []
# continue as long as there are still vnfs to place
while vnfs and genes:
# if the gene host has already been put in the chromosome,
# skip the gene. This ensures that at this step no capacity
# constraints will be violated.
if genes[0].hostname in [g.hostname for g in new_genes]:
del (genes[0])
else:
# if a VNF of the gene is not in the remaining vnf list, remove it from the gene
# since this means it's already placed
for v in genes[0].vnfs:
if v["vnf_name"] not in vnfs:
genes[0].vnfs.remove(v)
# finally, add the new gene
# also, remove its vnfs from the list of pending ones (there should be a more efficient way to do this)
new_genes.append(
Gene(genes[0].hostname,
genes[0].vnfs,
host_failure_rate=genes[0].host_failure_rate))
for v in genes[0].vnfs:
if v["vnf_name"] in vnfs:
vnfs.remove(v["vnf_name"])
del (genes[0])
C = Chromosome(new_genes)
# Now we need to check if there are any VNFs left unassigned
# If so, we place them anywhere they fit and are allowed to
solution = copy.deepcopy(self.scenario)
helpers.from_chromosome(solution, C)
while vnfs:
vname = vnfs.pop()
v = filter(lambda x: x.get("vnf_name") == vname,
solution["vnfs"])[0]
host = helpers.check_if_there_is_space(solution, v)
if host: # host found, place VNF
v["place_at"].append(host["host_name"])
else:
# Normally we should not arrive here, but, if so,
# this means that there's nowhere to place the VNF
# in this case, we return None and the caller will see what to do
return None
# perform constraint checks
mec_constraints_ok = helpers.check_mec_constraints(solution)
location_constraints_ok = helpers.check_location_constraints(solution)
link_constraints_ok = helpers.check_link_capacity_constraints(solution)
delay_constraints_ok = helpers.check_delay_constraints(solution)
if link_constraints_ok and delay_constraints_ok and mec_constraints_ok and location_constraints_ok:
# return the chromosome
return helpers.to_chromosome(solution)
else:
return None