@Override public void initStrategy(ThreadContext context) { this.context = context; dsm = context.getDesignSpaceManager(); lengthRemaining = newLength(); initialPopulation = new HashSet<TrajectoryFitness>(populationSize); }
@Override public void initStrategy(ThreadContext context) { this.context = context; initialPopulation = new HashSet<TrajectoryFitness>(populationSize); dsm = context.getDesignSpaceManager(); trajectoryInfo = dsm.getTrajectoryInfo(); }
@Override public void init(ThreadContext context) { super.init(context); DesignSpaceManager dsm = context.getDesignSpaceManager(); if (activationCostProcessors != null) { for (Entry<BatchTransformationRule<?, ?>, ActivationFitnessProcessor> entry : activationCostProcessors.entrySet()) { dsm.registerActivationCostProcessor(name, entry.getKey(), entry.getValue()); } } }
public void initVisualizersForThread(ThreadContext threadContext) { if (visualizers != null && !visualizers.isEmpty()) { for (IDesignSpaceVisualizer visualizer : visualizers) { visualizer.init(threadContext); threadContext.getDesignSpaceManager().registerExploreEventHandler(visualizer); } } }
@Override public boolean mutate(TrajectoryFitness parent1, TrajectoryFitness parent2, ThreadContext context) { DesignSpaceManager dsm = context.getDesignSpaceManager(); TrajectoryInfo trajectoryInfo = dsm.getTrajectoryInfo(); parent1t = parent1.trajectory; parent2t = parent2.trajectory; p1Size = parent1t.length; p2Size = parent2t.length; if (p1Size < 2 || p2Size < 2) { return false; } int minSize = Math.min(p1Size, p2Size); index = random.nextInt(minSize); dsm.executeTrajectoryWithMinimalBacktrackWithoutStateCoding(parent1t, index); addPermutation(dsm, trajectoryInfo, parent2t); return true; }
@Override public boolean mutate(TrajectoryFitness parent1, TrajectoryFitness parent2, ThreadContext context) { dsm = context.getDesignSpaceManager(); parent1t = parent1.trajectory; parent2t = parent2.trajectory; p1Size = parent1t.length; p2Size = parent2t.length; if (p1Size < 2 || p2Size < 2) { return false; } index1 = random.nextInt(p1Size); index2 = random.nextInt(p2Size); dsm.executeTrajectoryWithMinimalBacktrackWithoutStateCoding(parent1t, index1); dsm.tryFireActivation(parent2t[index2]); context.executeTrajectoryByTryingWithoutStateCoding(parent1t, index1 + 1, p1Size); return true; }
@Override public boolean mutate(TrajectoryFitness parent, ThreadContext context) { DesignSpaceManager dsm = context.getDesignSpaceManager(); context.executeTrajectoryWithMinimalBacktrackWithoutStateCoding(parent.trajectory); Collection<Object> transitions = dsm.getTransitionsFromCurrentState(); int size = transitions.size(); if (size == 0) { return false; } int bestPriority = Integer.MIN_VALUE; for (Object iTransition : transitions) { int priority = priorities.get(dsm.getRuleByActivationId(iTransition)).intValue(); if (priority > bestPriority) { bestPriority = priority; } } List<Object> bestTrasitions = new ArrayList<>(); for (Object iTransition : transitions) { if (priorities.get(dsm.getRuleByActivationId(iTransition)).intValue() == bestPriority) { bestTrasitions.add(iTransition); } } int index = rnd.nextInt(bestTrasitions.size()); Object transition = bestTrasitions.get(index); dsm.fireActivation(transition); return true; }
@Override public Double getFitness(ThreadContext context) { DesignSpaceManager dsm = context.getDesignSpaceManager(); TrajectoryInfo trajectoryInfo = dsm.getTrajectoryInfo(); List<Object> trajectory = trajectoryInfo.getTrajectory(); List<BatchTransformationRule<?, ?>> rules = trajectoryInfo.getRules(); double result = 0; for (int i = 0; i < trajectory.size(); i++) { BatchTransformationRule<?, ?> rule = rules.get(i); Double cost = fixCosts.get(rule); if (cost != null) { result += cost; } Map<String, Double> costs = trajectoryInfo.getMeasuredCosts().get(i); if (costs != null) { cost = costs.get(name); if (cost != null) { result += cost; } } } if (calculateTrajectoryLengthWeight) { result += trajectory.size() * trajectoryLengthWeight; } return result; }
@Override public boolean mutateAlternate(TrajectoryFitness parent1, TrajectoryFitness parent2, ThreadContext context) { DesignSpaceManager dsm = context.getDesignSpaceManager(); dsm.executeTrajectoryWithMinimalBacktrackWithoutStateCoding(parent2t, index); addPermutation(dsm, dsm.getTrajectoryInfo(), parent1t); return true; }
@Override public boolean mutate(TrajectoryFitness parent, ThreadContext context) { DesignSpaceManager dsm = context.getDesignSpaceManager(); Object[] trajectory = parent.trajectory;
@Override public void initStrategy(ThreadContext context) { this.context = context; dsm = context.getDesignSpaceManager(); initialPopulation = new HashSet<TrajectoryFitness>(populationSize); Objects.requireNonNull(objective, "Hard objective is missing for FixedPriorityInitialSelector."); Preconditions.checkState(objective.isHardObjective(), "Given objective is not hard objective for FixedPriorityInitialSelector."); for (BatchTransformationRule<?, ?> batchTransformationRule : context.getGlobalContext().getTransformations()) { if (!priorities.containsKey(batchTransformationRule)) { throw new IllegalStateException("Missing rule priority for FixedPriorityInitialSelector."); } } FixedPriorityConflictResolver fixedPriorityResolver = ConflictResolvers.createFixedPriorityResolver(); for (Entry<BatchTransformationRule<?, ?>, Integer> entry : priorities.entrySet()) { fixedPriorityResolver.setPriority(entry.getKey().getRuleSpecification(), entry.getValue()); } context.changeActivationOrdering(fixedPriorityResolver.createConflictSet()); objective.init(context); logger.info("FixedPriorityInitialSelector inited."); }
@Override public void initStrategy(ThreadContext context) { this.context = context; dsm = context.getDesignSpaceManager();
logger.debug("New trajectory is chosen: " + currentTrajectoryWithFittness); context.getDesignSpaceManager().executeTrajectoryWithMinimalBacktrackWithoutStateCoding(currentTrajectoryWithFittness.trajectory);
DseIdPoolHelper.INSTANCE.registerRules(new GetRuleExecutionsImpl(getDesignSpaceManager().getTrajectoryInfo().getRules()), getRules());
public synchronized void newSolution(ThreadContext context) { solutionSaver.setSolutionsCollection(solutions); Fitness fitness = context.getLastFitness(); DesignSpaceManager dsm = context.getDesignSpaceManager(); Object id = dsm.getCurrentState(); IStateCoderFactory stateCoderFactory = context.getGlobalContext().getStateCoderFactory(); SolutionTrajectory solutionTrajectory = dsm.getTrajectoryInfo().createSolutionTrajectory(stateCoderFactory); solutionTrajectory.setFitness(fitness); if (acceptOnlyGoalSolutions && !fitness.isSatisifiesHardObjectives()) { unsavedSolutionCallbacks(context, solutionTrajectory); return; } boolean solutionSaved = solutionSaver.saveSolution(context, id, solutionTrajectory); if (solutionSaved) { enoughSolutions.solutionFound(context, solutionTrajectory); savedSolutionCallbacks(context, solutionTrajectory); if (enoughSolutions.enoughSolutions()) { context.getGlobalContext().stopAllThreads(); } } else { unsavedSolutionCallbacks(context, solutionTrajectory); } }