def do_it(self, ngen, cxpb, mutpb): pop = self.toolbox.population(n=self.no_list) #inital calculation of fitness for base population. TODO: Optimization. InitialFitness can be taken from the Job Object itself. fitness = self.toolbox.map(self.toolbox.evaluate, pop) for ind, fit in zip(pop, fitness): ind.fitness.values = fit best = [copy.deepcopy(ind) for ind in pop] for g in range(ngen): Logger.info("ListGA Generation: %s" % (g)) best = select(pop, self.no_list) record = self.stats.compile(best) self.logbook.record(**record) pop = [copy.deepcopy(ind) for ind in best] for child1, child2 in zip(pop[::2], pop[1::2]): if random.random() < cxpb: crossover(child1, child2) del child1.fitness.values, child2.fitness.values for mutant in pop: mutate(mutant, mutpb) #TODO: Perform double justification here for ind in best: if not ind in pop: pop.append(ind) #invalids = [ind for ind in pop if not ind.fitness.valid] fitnesses = self.toolbox.map(self.toolbox.evaluate, pop) for ind, fit in zip(pop, fitnesses): if fit is not None: ind.fitness.values = fit return select(pop, n=1)
def visualize(simulation_result): resource_frequency = {} for task in simulation_result.execution_history: if task.finished - task.started == 0: continue for resource in task.usedResources: if resource.max_share_count is not 0: if not resource in resource_frequency: resource_frequency[resource] = 0 resource_frequency[resource] += 1 top_resources = [] for resource, frequency in resource_frequency.items(): top_resources.append((resource, frequency)) top_resources.sort(key=lambda tup: tup[1], reverse=True) Logger.info("Top required Resources:") for resource in top_resources[:10]: Logger.info("name: '%s', is testbed: %s, frequency: %s" % (resource[0].name, resource[0].is_testbed, resource[1])) fig = plt.figure(figsize=(30, 25)) ax1 = fig.add_subplot(211) plot_gantt(simulation_result, top_resources[:7], ax1) ax2 = fig.add_subplot(212) plot_gantt(simulation_result, top_resources[:7], ax2) ax2.set_xscale('log') return ax1, ax2
def initialize(self): super(PPPolicies, self).initialize() Logger.info("Generating initial Population with RBRS") initial_pop = self._generate_RBRS(self.job, self.param["listNoList"]) Logger.info("Applying ListGA to initial population") listGA = ListGA(self.job, initial_pop) task_list = listGA.do_it(self.param["listGAGen"], self.param["listGACXp"], self.param["listGAMUTp"])[0] self.listGALog = listGA.get_logbook() if self.param["arcGAGen"] > 0: arcGA = ArcGA(self.job, task_list) arc_list = arcGA.do_it(self.param["arcGAGen"], self.param["arcGACXp"], self.param["arcGAMUTp"])[0] #2, 0.5, 0.1 #Logger.warning("len arc list: %s" % (len(arc_list))) self.arcGALog = arcGA.get_logbook() self.scheduler = MfssRB(self.job, task_list, arc_list, ignore_infeasible_schedules=True) else: self.arcGALog = [] self.arcGALog.append({"min": 0, "max": 0}) self.scheduler = MfssRB(self.job, task_list, [], ignore_infeasible_schedules=True)
def initialize(self): super(JFPol, self).initialize() Logger.info("Generating initial Population with RBRS") initial_pop = self._generate_RBRS(self.job, 10) Logger.info("Applying ListGA to initial population") listGA = ListGA(self.job, initial_pop) task_list = listGA.do_it(150, 0.8, 0.2)[0] self.listGALog = listGA.get_logbook() self.scheduler = DomainRB(self.job, task_list, ignore_infeasible_schedules=True)
def deserialize(file_path): Logger.info("loading data from file: %s" % file_path) job = cPickle.load(open(file_path, "rb")) Logger.info("loaded %s tasks" % (len(job.tasks.values()))) Logger.info("loaded %s resources" % (len(job.resources.values()))) Logger.info("loaded %s capabilities" % (len(job.capabilities.values()))) return job
def initialize(self): super(PPPolicies, self).initialize() Logger.info("Generating initial Population with RBRS") initial_pop = self._generate_RBRS(self.job, self.param["listNoList"]) Logger.info("Applying ListGA to initial population") listGA = ListGA(self.job, initial_pop) task_list = listGA.do_it(self.param["listGAGen"], self.param["listGACXp"], self.param["listGAMUTp"])[0] self.listGALog = listGA.get_logbook() if self.param["arcGAGen"] > 0: arcGA = ArcGA(self.job, task_list) arc_list = arcGA.do_it(self.param["arcGAGen"], self.param["arcGACXp"],self.param["arcGAMUTp"])[0] #2, 0.5, 0.1 #Logger.warning("len arc list: %s" % (len(arc_list))) self.arcGALog = arcGA.get_logbook() self.scheduler = MfssRB(self.job, task_list, arc_list, ignore_infeasible_schedules=True) else: self.arcGALog = [] self.arcGALog.append({"min":0, "max":0}) self.scheduler = MfssRB(self.job, task_list, [], ignore_infeasible_schedules=True)
def do_it(self, ngen, cxpb, mutpb): pop = self.toolbox.population(n=self.no_list) #inital calculation of fitness for base population. TODO: Optimization. InitialFitness can be taken from the Job Object itself. fitness = self.toolbox.map(self.toolbox.evaluate, pop) for ind, fit in zip(pop, fitness): ind.fitness.values = fit best = [copy.deepcopy(ind) for ind in pop] for g in range(ngen): Logger.info("ListGA Generation: %s" % (g)) best = select(pop,self.no_list) record = self.stats.compile(best) self.logbook.record(**record) pop = [copy.deepcopy(ind) for ind in best] for child1, child2 in zip(pop[::2], pop[1::2]): if random.random() < cxpb: crossover(child1, child2) del child1.fitness.values, child2.fitness.values for mutant in pop: mutate(mutant, mutpb) #TODO: Perform double justification here for ind in best: if not ind in pop: pop.append(ind) #invalids = [ind for ind in pop if not ind.fitness.valid] fitnesses = self.toolbox.map(self.toolbox.evaluate, pop) for ind, fit in zip(pop, fitnesses): if fit is not None: ind.fitness.values = fit return select(pop, n=1)
def worker(id, nr_cores, scheduler, job, n, return_values, extremes, parameters=None): os.system("taskset -p 0xFFFFFFFF %d" % os.getpid()) pbar = ProgressBar(maxval=n).start() Logger.info("spawning worker id %s" % id) numpy.random.seed(id + int(time.time())) random.seed() #Logger.log_level = 2 results = [] min = None max = None if job.already_initialized == True: for task in job.tasks.values(): size = len(task.pre_computed_execution_times) / nr_cores task.pre_computed_execution_times = task.pre_computed_execution_times[id*size:(id +1)*size] Scheduler = schedulerForName(scheduler) #gives us the correct class to use for i in range(0, n): if id == 0: pbar.update(i) scheduler = Scheduler(job, parameters) if job.already_initialized == False: job.initialize() scheduler.initialize() result = simulate_schedule(scheduler) results.append(result.total_time) if min is None or result.total_time < min.total_time: min = result if max is None or result.total_time > max.total_time: max = result return_values[id] = results extremes[id] = (min, max) if id == 0: pbar.finish()
def do_it(self, ngen, cxpb, mutpb): Logger.info("ArcGA: Creating Initial Population") pop = self.toolbox.population(n=self.no_p) Logger.info("ArcGA: Calculating base fitness") #inital calculation of fitness for base population. fitness = self.toolbox.map(self.toolbox.evaluate, pop) for ind, fit in zip(pop, fitness): if fit is not None: ind.fitness.values = fit best = [copy.deepcopy(ind) for ind in pop] for g in range(ngen): Logger.info("ArcGA Generation: %s" % (g)) best = self.select(pop, self.no_p) record = self.stats.compile(best) self.logbook.record(**record) pop = [copy.deepcopy(ind) for ind in best] if random.random() < cxpb: self.crossover(pop, cxpb) for mutant in pop: if random.random() < mutpb: self.mutate(mutant, 0.5) #invalids = [ind for ind in pop if not ind.fitness.valid] for ind in best: if not ind in pop: pop.append(ind) fitnesses = self.toolbox.map(self.toolbox.evaluate, pop) for ind, fit in zip(pop, fitnesses): if fit is not None: ind.fitness.values = fit best = self.select(pop, n=1) return best
def load_simulation_result(file_path): Logger.info("loading simulation result from file: %s " % file_path) return cPickle.load(open(file_path, "rb"))
def save_simulation_result(result, output_file): Logger.info("writing simulation result to file: %s" % output_file) cPickle.dump(result, open(output_file, "wb"))
def load_simulation_result(file_path): Logger.info("loading simulation result from file: %s " % file_path ) return cPickle.load(open(file_path, "rb"))