private void warmUpPopulate(Map<Future<SubSingleBenchmarkRunner>, SubSingleBenchmarkRunner> futureMap, ConcurrentMap<SolverBenchmarkResult, Integer> singleBenchmarkResultIndexMap, SolverBenchmarkResult[] solverBenchmarkResultArray, long timeLeftPerSolverConfig) { for (SolverBenchmarkResult solverBenchmarkResult : solverBenchmarkResultArray) { TerminationConfig originalTerminationConfig = solverBenchmarkResult.getSolverConfig().getTerminationConfig(); TerminationConfig tmpTerminationConfig = new TerminationConfig(); if (originalTerminationConfig != null) { tmpTerminationConfig.inherit(originalTerminationConfig); } tmpTerminationConfig.shortenTimeMillisSpentLimit(timeLeftPerSolverConfig); solverBenchmarkResult.getSolverConfig().setTerminationConfig(tmpTerminationConfig); Integer singleBenchmarkResultIndex = singleBenchmarkResultIndexMap.get(solverBenchmarkResult); singleBenchmarkResultIndex = (singleBenchmarkResultIndex == null) ? 0 : singleBenchmarkResultIndex % solverBenchmarkResult.getSingleBenchmarkResultList().size(); SingleBenchmarkResult singleBenchmarkResult = solverBenchmarkResult.getSingleBenchmarkResultList().get(singleBenchmarkResultIndex); // Just take the first subSingle, we don't need to warm up each one SubSingleBenchmarkRunner subSingleBenchmarkRunner = new SubSingleBenchmarkRunner( singleBenchmarkResult.getSubSingleBenchmarkResultList().get(0), true, solverConfigContext); Future<SubSingleBenchmarkRunner> future = warmUpExecutorCompletionService.submit(subSingleBenchmarkRunner); futureMap.put(future, subSingleBenchmarkRunner); singleBenchmarkResultIndexMap.put(solverBenchmarkResult, singleBenchmarkResultIndex + 1); } }
private static Map<SolverBenchmarkResult, WarmUpConfigBackup> backupBenchmarkConfig(PlannerBenchmarkResult plannerBenchmarkResult, Map<ProblemBenchmarkResult, List<ProblemStatistic>> originalProblemStatisticMap) { // backup & remove stats, backup termination config Map<SolverBenchmarkResult, WarmUpConfigBackup> warmUpConfigBackupMap = new HashMap<>(plannerBenchmarkResult.getSolverBenchmarkResultList().size()); for (SolverBenchmarkResult solverBenchmarkResult : plannerBenchmarkResult.getSolverBenchmarkResultList()) { TerminationConfig originalTerminationConfig = solverBenchmarkResult.getSolverConfig().getTerminationConfig(); WarmUpConfigBackup warmUpConfigBackup = new WarmUpConfigBackup(originalTerminationConfig); for (SingleBenchmarkResult singleBenchmarkResult : solverBenchmarkResult.getSingleBenchmarkResultList()) {
@Override protected PlannerBenchmarkFactory buildPlannerBenchmarkFactory() { PlannerBenchmarkFactory benchmarkFactory = super.buildPlannerBenchmarkFactory(); PlannerBenchmarkConfig benchmarkConfig = benchmarkFactory.getPlannerBenchmarkConfig(); benchmarkConfig.setWarmUpSecondsSpentLimit(0L); benchmarkConfig.getInheritedSolverBenchmarkConfig().getSolverConfig().getTerminationConfig() .setStepCountLimit(-100); // Intentionally crash the solver return benchmarkFactory; }
@Test public void cloneSolverFactory() { SolverFactory<TestdataSolution> solverFactoryTemplate = SolverFactory.createFromXmlResource( "org/optaplanner/core/api/solver/testdataSolverConfig.xml"); solverFactoryTemplate.getSolverConfig().setTerminationConfig(new TerminationConfig()); SolverFactory<TestdataSolution> solverFactory1 = solverFactoryTemplate.cloneSolverFactory(); SolverFactory<TestdataSolution> solverFactory2 = solverFactoryTemplate.cloneSolverFactory(); assertNotSame(solverFactory1, solverFactory2); solverFactory1.getSolverConfig().getTerminationConfig().setMinutesSpentLimit(1L); solverFactory2.getSolverConfig().getTerminationConfig().setMinutesSpentLimit(2L); assertEquals((Long) 1L, solverFactory1.getSolverConfig().getTerminationConfig().getMinutesSpentLimit()); assertEquals((Long) 2L, solverFactory2.getSolverConfig().getTerminationConfig().getMinutesSpentLimit()); Solver<TestdataSolution> solver1 = solverFactory1.buildSolver(); Solver<TestdataSolution> solver2 = solverFactory2.buildSolver(); assertNotSame(solver1, solver2); }
protected Solution_ buildAndSolve(SolverFactory<Solution_> solverFactory, EnvironmentMode environmentMode, Solution_ problem, long maximumMinutesSpent) { SolverConfig solverConfig = solverFactory.getSolverConfig(); solverConfig.getTerminationConfig().setMinutesSpentLimit(maximumMinutesSpent); solverConfig.setEnvironmentMode(environmentMode); Class<? extends EasyScoreCalculator> easyScoreCalculatorClass = overwritingEasyScoreCalculatorClass(); if (easyScoreCalculatorClass != null && environmentMode.isAsserted()) { ScoreDirectorFactoryConfig assertionScoreDirectorFactoryConfig = new ScoreDirectorFactoryConfig(); assertionScoreDirectorFactoryConfig.setEasyScoreCalculatorClass(easyScoreCalculatorClass); solverConfig.getScoreDirectorFactoryConfig().setAssertionScoreDirectorFactory( assertionScoreDirectorFactoryConfig); } Solver<Solution_> solver = solverFactory.buildSolver(); Solution_ bestSolution = solver.solve(problem); return bestSolution; }
@Override public void inherit(SolverConfig inheritedConfig) { environmentMode = ConfigUtils.inheritOverwritableProperty(environmentMode, inheritedConfig.getEnvironmentMode()); daemon = ConfigUtils.inheritOverwritableProperty(daemon, inheritedConfig.getDaemon()); randomType = ConfigUtils.inheritOverwritableProperty(randomType, inheritedConfig.getRandomType()); randomSeed = ConfigUtils.inheritOverwritableProperty(randomSeed, inheritedConfig.getRandomSeed()); randomFactoryClass = ConfigUtils.inheritOverwritableProperty( randomFactoryClass, inheritedConfig.getRandomFactoryClass()); moveThreadCount = ConfigUtils.inheritOverwritableProperty(moveThreadCount, inheritedConfig.getMoveThreadCount()); moveThreadBufferSize = ConfigUtils.inheritOverwritableProperty(moveThreadBufferSize, inheritedConfig.getMoveThreadBufferSize()); threadFactoryClass = ConfigUtils.inheritOverwritableProperty(threadFactoryClass, inheritedConfig.getThreadFactoryClass()); scanAnnotatedClassesConfig = ConfigUtils.inheritConfig(scanAnnotatedClassesConfig, inheritedConfig.getScanAnnotatedClassesConfig()); solutionClass = ConfigUtils.inheritOverwritableProperty(solutionClass, inheritedConfig.getSolutionClass()); entityClassList = ConfigUtils.inheritMergeableListProperty( entityClassList, inheritedConfig.getEntityClassList()); scoreDirectorFactoryConfig = ConfigUtils.inheritConfig(scoreDirectorFactoryConfig, inheritedConfig.getScoreDirectorFactoryConfig()); terminationConfig = ConfigUtils.inheritConfig(terminationConfig, inheritedConfig.getTerminationConfig()); phaseConfigList = ConfigUtils.inheritMergeableListConfig( phaseConfigList, inheritedConfig.getPhaseConfigList()); }
public SolverConfigModel get() { SolverConfigModel model = new SolverConfigModel(); model.setTerminationConfig(create(solverConfig.getTerminationConfig())); model.setScoreDirectorFactoryConfig(create(solverConfig.getScoreDirectorFactoryConfig())); model.setPhaseConfigList(create(solverConfig.getPhaseConfigList())); return model; }
solverFactory.getSolverConfig().getTerminationConfig().shortenTimeMillisSpentLimit(SMOKE_TEST_MILLISECONDS_SPENT_LIMIT); if (solverFactory.getSolverConfig().getScoreDirectorFactoryConfig().getKsessionName() == null) { solverFactory.getSolverConfig().getScoreDirectorFactoryConfig().setKsessionName(kieProject.getDefaultKieSession().getName());
@Override protected PlannerBenchmarkFactory buildPlannerBenchmarkFactory() { PlannerBenchmarkFactory benchmarkFactory = super.buildPlannerBenchmarkFactory(); PlannerBenchmarkConfig benchmarkConfig = benchmarkFactory.getPlannerBenchmarkConfig(); benchmarkConfig.setWarmUpSecondsSpentLimit(0L); benchmarkConfig.getInheritedSolverBenchmarkConfig().getSolverConfig().getTerminationConfig() .setStepCountLimit(-100); // Intentionally crash the solver return benchmarkFactory; }
@Test public void get() { ToSolverConfig toSolverConfigModel = new ToSolverConfig(getSolverConfigModel()); SolverConfig solverConfig = toSolverConfigModel.get(); TerminationConfig terminationConfig = solverConfig.getTerminationConfig(); assertEquals(Long.valueOf(1), terminationConfig.getMillisecondsSpentLimit()); assertEquals(1, terminationConfig.getTerminationConfigList().size()); assertEquals(Boolean.TRUE, terminationConfig.getTerminationConfigList().get(0).getBestScoreFeasible()); assertEquals("testKsession", solverConfig.getScoreDirectorFactoryConfig().getKsessionName()); assertEquals(2, solverConfig.getPhaseConfigList().size()); ConstructionHeuristicPhaseConfig constructionHeuristicPhaseConfig = (ConstructionHeuristicPhaseConfig) solverConfig.getPhaseConfigList().get(0); assertEquals(ConstructionHeuristicType.FIRST_FIT, constructionHeuristicPhaseConfig.getConstructionHeuristicType()); assertEquals(EntitySorterManner.DECREASING_DIFFICULTY, constructionHeuristicPhaseConfig.getEntitySorterManner()); LocalSearchPhaseConfig localSearchPhaseConfig = (LocalSearchPhaseConfig) solverConfig.getPhaseConfigList().get(1); assertEquals(LocalSearchType.TABU_SEARCH, localSearchPhaseConfig.getLocalSearchType()); }
protected Solution_ buildAndSolve(SolverFactory<Solution_> solverFactory, EnvironmentMode environmentMode, Solution_ problem, long maximumMinutesSpent) { SolverConfig solverConfig = solverFactory.getSolverConfig(); solverConfig.getTerminationConfig().setMinutesSpentLimit(maximumMinutesSpent); solverConfig.setEnvironmentMode(environmentMode); Class<? extends EasyScoreCalculator> easyScoreCalculatorClass = overwritingEasyScoreCalculatorClass(); if (easyScoreCalculatorClass != null && environmentMode.isAsserted()) { ScoreDirectorFactoryConfig assertionScoreDirectorFactoryConfig = new ScoreDirectorFactoryConfig(); assertionScoreDirectorFactoryConfig.setEasyScoreCalculatorClass(easyScoreCalculatorClass); solverConfig.getScoreDirectorFactoryConfig().setAssertionScoreDirectorFactory( assertionScoreDirectorFactoryConfig); } Solver<Solution_> solver = solverFactory.buildSolver(); Solution_ bestSolution = solver.solve(problem); return bestSolution; }