] llvmutils.toAssembly(llvmfiles.get_original_bc(), "original.ll") llvmutils.toExecutable(llvmfiles.get_original_bc(), "original.o") evaluator.evaluate("original.ll", "./original.o") original_results = [] #original_results.append(evaluator.get_runtime()) original_results.append(evaluator.get_total_codelines()) original_results.append(evaluator.get_codelines()) original_results.append(evaluator.get_tags()) #original_results.append(evaluator.get_total_jmps()) original_results.append(evaluator.get_conditional_jmps()) original_results.append(evaluator.get_unconditional_jmps()) original_results.append(evaluator.get_function_tags()) original_results.append(evaluator.get_calls()) evaluator.reset() allpasses = [] with open('20_20_20/20_20_20_25_results.csv', 'r') as file: for line in file.readlines(): line = line[:-1] keyvalue = line.split(sep=';') passes = to_int_array(keyvalue[0]) fitness = to_int_array(keyvalue[1]) strpasses = "" for s in passes: strpasses += f" {LlvmUtils.get_passes()[s]}"
class llvmMultiobjetiveProblem(IntegerProblem): def __init__(self, max_epochs: int = 500, filename: str = None, solution_length: int = 100, population_size = int, offspring_population_size = int, verbose: bool = True, upper_bound : int = 86): self.llvm = LlvmUtils(llvmpath='/usr/bin/', clangexe='clang-10', optexe='opt-10', llcexe='llc-10') self.llvmfiles = LlvmFiles(basepath='./', source_bc='polybench_small/polybench_small_original.bc', jobid=f'{population_size}_{offspring_population_size}_{solution_length}') self.evaluator = Evaluator(runs=0) self.number_of_variables = solution_length self.lower_bound = [0 for _ in range(self.number_of_variables)] self.upper_bound = [upper_bound for _ in range(self.number_of_variables)] self.obj_labels = ['codelines', 'tags', 'jumps', 'function_tags', 'calls'] self.obj_directions = [self.MAXIMIZE, self.MINIMIZE, self.MINIMIZE, self.MINIMIZE, self.MINIMIZE] self.number_of_objectives = 5 self.number_of_constraints = 0 self.max_epochs = max_epochs self.evaluations = 0 self.epoch = 1 self.phenotype = 0 self.population_size = population_size self.offspring_population_size = offspring_population_size self.dictionary = dict() self.verbose = verbose self.preloaded_dictionary = f"{self.number_of_variables}_dictionary.data" if os.path.exists(self.preloaded_dictionary): with open(self.preloaded_dictionary,"r") as file: print(f"reading '{self.preloaded_dictionary}'...") for line in file.readlines(): line = line[:-1] # \n keyvalue = line.split(sep=";") self.dictionary.update({keyvalue[0]:keyvalue[1]}) def get_name(self): return 'Llvm Multiobjective Problem' def config_to_str(self): return f"{self.population_size}_{self.offspring_population_size}_{self.number_of_variables}_{self.max_epochs}" def evaluate(self, solution: IntegerSolution) -> IntegerSolution: self.phenotype +=1 limit = [self.offspring_population_size if self.epoch != 1 else self.population_size] if self.phenotype%(limit[0]+1) == 0: self.epoch += 1 self.phenotype = 1 key = f"{solution.variables}" value = self.dictionary.get(key) if value == None: # Decoding passes = "" for i in range(self.number_of_variables): passes += f" {self.llvm.get_passes()[solution.variables[i]]}" # Optimize and generate resources self.llvm.toIR(self.llvmfiles.get_original_bc(), self.llvmfiles.get_optimized_bc(), passes=passes) self.llvm.toExecutable(self.llvmfiles.get_optimized_bc(), self.llvmfiles.get_optimized_exe()) self.llvm.toAssembly(self.llvmfiles.get_optimized_bc(), self.llvmfiles.get_optimized_ll()) # Get measures self.evaluator.evaluate(source_ll=self.llvmfiles.get_optimized_ll(), source_exe=self.llvmfiles.get_optimized_exe()) solution.objectives[0] = self.evaluator.get_codelines() solution.objectives[1] = self.evaluator.get_tags() solution.objectives[2] = self.evaluator.get_total_jmps() solution.objectives[3] = self.evaluator.get_function_tags() solution.objectives[4] = self.evaluator.get_calls() self.dictionary.update({key: solution.objectives}) self.evaluator.reset() else: # Get stored value solution.objectives[0] = value[0] solution.objectives[1] = value[1] solution.objectives[2] = value[2] solution.objectives[3] = value[3] solution.objectives[4] = value[4] if self.verbose: print("evaluated solution {:3} from epoch {:3} : variables={}, fitness={}"\ .format(self.phenotype,self.epoch,solution.variables,solution.objectives)) return solution ### FOR TERMINATION CRITERION ### def update(self, *args, **kwargs): self.evaluations = kwargs['EVALUATIONS'] ### FOR TERMINATION CRITERION ### @property def is_met(self): met = self.epoch >= self.max_epochs if self.phenotype*self.epoch % 100 == 0 or met: with open(self.preloaded_dictionary, "w") as file: for keys,values in self.dictionary.items(): file.write('{};{}\n'.format(keys,values)) return met