/** * Unused alternative. Abnormal way to create a {@link Solver}. * <p> * Not recommended! It is recommended to use {@link #createSolverByXml()} instead. * @return never null */ protected Solver<NQueens> createSolverByApi() { SolverFactory<NQueens> solverFactory = SolverFactory.createEmpty(); SolverConfig solverConfig = solverFactory.getSolverConfig(); solverConfig.setSolutionClass(NQueens.class); solverConfig.setEntityClassList(Collections.<Class<?>>singletonList(Queen.class)); ScoreDirectorFactoryConfig scoreDirectorFactoryConfig = new ScoreDirectorFactoryConfig(); scoreDirectorFactoryConfig.setScoreDrlList( Arrays.asList("org/optaplanner/examples/nqueens/solver/nQueensScoreRules.drl")); solverConfig.setScoreDirectorFactoryConfig(scoreDirectorFactoryConfig); solverConfig.setTerminationConfig(new TerminationConfig().withBestScoreLimit("0")); List<PhaseConfig> phaseConfigList = new ArrayList<>(); ConstructionHeuristicPhaseConfig constructionHeuristicPhaseConfig = new ConstructionHeuristicPhaseConfig(); constructionHeuristicPhaseConfig.setConstructionHeuristicType( ConstructionHeuristicType.FIRST_FIT_DECREASING); phaseConfigList.add(constructionHeuristicPhaseConfig); LocalSearchPhaseConfig localSearchPhaseConfig = new LocalSearchPhaseConfig(); ChangeMoveSelectorConfig changeMoveSelectorConfig = new ChangeMoveSelectorConfig(); changeMoveSelectorConfig.setSelectionOrder(SelectionOrder.ORIGINAL); localSearchPhaseConfig.setMoveSelectorConfig(changeMoveSelectorConfig); localSearchPhaseConfig.setAcceptorConfig(new AcceptorConfig().withEntityTabuSize(5)); phaseConfigList.add(localSearchPhaseConfig); solverConfig.setPhaseConfigList(phaseConfigList); return solverFactory.buildSolver(); }
@Test public void moveThreadCountThrowsExceptionWhenValueIsNegative() { SolverConfig solverConfig = new SolverConfig(); solverConfig.setMoveThreadCount("-6"); try { solverConfig.resolveMoveThreadCount(); fail("IllegalArgumentException should have been thrown."); } catch (IllegalArgumentException expectedException) { //expected } }
@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()); }
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); } }
public SolverConfig get() { SolverConfig solverConfig = new SolverConfig(); solverConfig.setScanAnnotatedClassesConfig(new ScanAnnotatedClassesConfig()); solverConfig.setTerminationConfig(create(config.getTermination())); solverConfig.setScoreDirectorFactoryConfig(create(config.getScoreDirectorFactoryConfig())); solverConfig.setPhaseConfigList(create(config.getPhaseConfigList())); return solverConfig; }
@Test public void uninitializedBenchmarkResult() { PlannerBenchmarkFactory plannerBenchmarkFactory = PlannerBenchmarkFactory.createFromXmlResource( "org/optaplanner/benchmark/api/testdataPlannerBenchmarkConfig.xml"); SolverBenchmarkConfig solverBenchmarkConfig = plannerBenchmarkFactory.getPlannerBenchmarkConfig().getSolverBenchmarkConfigList().get(0); CustomPhaseConfig phaseConfig = new CustomPhaseConfig(); phaseConfig.setCustomPhaseCommandClassList(Collections.singletonList(NoChangeCustomPhaseCommand.class)); solverBenchmarkConfig.getSolverConfig() .setPhaseConfigList(Collections.singletonList(phaseConfig)); PlannerBenchmark plannerBenchmark = plannerBenchmarkFactory.buildPlannerBenchmark(); assertNotNull(plannerBenchmark); plannerBenchmark.benchmark(); }
final SolverConfig config = builder.getSolverConfig(); config.setEntityClassList( ImmutableList.<Class<?>>of(ParcelVisit.class, Visit.class)); config.setSolutionClass(PDPSolution.class); terminationConfig .setUnimprovedMillisecondsSpentLimit(builder.getUnimprovedMsLimit()); config.setTerminationConfig(terminationConfig); } else if (builder.getUnimprovedStepCountLimit() > 0) { terminationConfig .setUnimprovedStepCountLimit(builder.getUnimprovedStepCountLimit()); for (final PhaseConfig phase : config.getPhaseConfigList()) { if (phase instanceof LocalSearchPhaseConfig) { phase.setTerminationConfig(terminationConfig); scoreConfig.setScoreDefinitionType(ScoreDefinitionType.HARD_SOFT_LONG); scoreConfig.setIncrementalScoreCalculatorClass(ScoreCalculator.class); config.setScoreDirectorFactoryConfig(scoreConfig); config.setRandomSeed(seed); config.setRandomType(RandomType.MERSENNE_TWISTER); config.setEnvironmentMode( builder.isValidated() ? EnvironmentMode.FULL_ASSERT : EnvironmentMode.REPRODUCIBLE); factory.getSolverConfig().inherit(config); return factory.buildSolver();
@Override protected SolverFactory<Solution_> buildSolverFactory() { SolverFactory<Solution_> solverFactory = SolverFactory.createFromXmlResource(commonApp.getSolverConfig()); SolverConfig solverConfig = solverFactory.getSolverConfig(); solverConfig.setTerminationConfig(new TerminationConfig()); ExhaustiveSearchPhaseConfig exhaustiveSearchPhaseConfig = new ExhaustiveSearchPhaseConfig(); exhaustiveSearchPhaseConfig.setExhaustiveSearchType(exhaustiveSearchType); solverConfig.setPhaseConfigList(Arrays.asList(exhaustiveSearchPhaseConfig)); return solverFactory; }
public SolverConfigModel get() { SolverConfigModel model = new SolverConfigModel(); model.setTerminationConfig(create(solverConfig.getTerminationConfig())); model.setScoreDirectorFactoryConfig(create(solverConfig.getScoreDirectorFactoryConfig())); model.setPhaseConfigList(create(solverConfig.getPhaseConfigList())); return model; }
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; }
private static void restoreBenchmarkConfig(PlannerBenchmarkResult plannerBenchmarkResult, Map<ProblemBenchmarkResult, List<ProblemStatistic>> originalProblemStatisticMap, Map<SolverBenchmarkResult, WarmUpConfigBackup> warmUpConfigBackupMap) { for (SolverBenchmarkResult solverBenchmarkResult : plannerBenchmarkResult.getSolverBenchmarkResultList()) { WarmUpConfigBackup warmUpConfigBackup = warmUpConfigBackupMap.get(solverBenchmarkResult); TerminationConfig originalTerminationConfig = warmUpConfigBackup.getTerminationConfig(); solverBenchmarkResult.getSolverConfig().setTerminationConfig(originalTerminationConfig); for (SingleBenchmarkResult singleBenchmarkResult : solverBenchmarkResult.getSingleBenchmarkResultList()) { ProblemBenchmarkResult problemBenchmarkResult = singleBenchmarkResult.getProblemBenchmarkResult(); if (problemBenchmarkResult.getProblemStatisticList() == null || problemBenchmarkResult.getProblemStatisticList().size() <= 0) { problemBenchmarkResult.setProblemStatisticList(originalProblemStatisticMap.get(problemBenchmarkResult)); } for (SubSingleBenchmarkResult subSingleBenchmarkResult : singleBenchmarkResult.getSubSingleBenchmarkResultList()) { List<PureSubSingleStatistic> pureSubSingleStatisticList = warmUpConfigBackup.getPureSubSingleStatisticMap().get(subSingleBenchmarkResult); subSingleBenchmarkResult.setPureSubSingleStatisticList(pureSubSingleStatisticList); subSingleBenchmarkResult.initSubSingleStatisticMap(); } singleBenchmarkResult.initSubSingleStatisticMaps(); } } }
protected SolverFactory<Solution_> buildSolverFactory(String bestScoreLimitString, EnvironmentMode environmentMode) { SolverFactory<Solution_> solverFactory = SolverFactory.createFromXmlResource(solverConfig); solverFactory.getSolverConfig().setEnvironmentMode(environmentMode); solverFactory.getSolverConfig().setTerminationConfig( new TerminationConfig().withBestScoreLimit(bestScoreLimitString)); solverFactory.getSolverConfig().setMoveThreadCount(moveThreadCount); return solverFactory; }
protected SolverFactory<Solution_> buildSolverFactory() { SolverFactory<Solution_> solverFactory = SolverFactory.createFromXmlResource(createSolverConfigResource()); SolverConfig solverConfig = solverFactory.getSolverConfig(); solverConfig.setDaemon(true); solverConfig.setTerminationConfig(new TerminationConfig().withMillisecondsSpentLimit(SPENT_LIMIT)); return solverFactory; }
@Before public void createUninitializedSolutions() { checkRunTurtleTests(); final VehicleRoutingImporter importer = new VehicleRoutingImporter(); for (int i = 0; i < REPETITION_COUNT; i++) { File dataSetFile = new File(CommonApp.determineDataDir(vehicleRoutingApp.getDataDirName()), DATA_SET); VehicleRoutingSolution solution = importer.readSolution(dataSetFile); vehicleRoutingSolutions[i] = solution; } solverFactory = SolverFactory.createFromXmlResource(vehicleRoutingApp.getSolverConfig()); SolverConfig solverConfig = solverFactory.getSolverConfig(); solverConfig.getPhaseConfigList().forEach(phaseConfig -> { if (LocalSearchPhaseConfig.class.isAssignableFrom(phaseConfig.getClass())) { phaseConfig.setTerminationConfig(new TerminationConfig().withStepCountLimit(STEP_LIMIT)); } }); solverConfig.setMoveThreadCount(MOVE_THREAD_COUNT); solverConfig.setEnvironmentMode(EnvironmentMode.REPRODUCIBLE); }
SolverConfig solverConfig = new SolverConfig(); List<PhaseConfig> phaseConfigList = new ArrayList<>(2); ConstructionHeuristicPhaseConfig constructionHeuristicPhaseConfig = new ConstructionHeuristicPhaseConfig(); solverConfig.setPhaseConfigList(phaseConfigList); solverBenchmarkConfig.setSolverConfig(solverConfig); return solverBenchmarkConfig;
protected SolverFactory<Solution_> buildSolverFactory() { SolverFactory<Solution_> solverFactory = SolverFactory.createFromXmlResource(solverConfig); // buildAndSolve() fills in minutesSpentLimit solverFactory.getSolverConfig().setTerminationConfig(new TerminationConfig()); if (MOVE_THREAD_COUNT_OVERRIDE != null) { solverFactory.getSolverConfig().setMoveThreadCount(MOVE_THREAD_COUNT_OVERRIDE); } return solverFactory; }
solverConfig = new SolverConfig(solverConfig); solverConfig.offerRandomSeedFromSubSingleIndex((long) subSingleBenchmarkResult.getSubSingleBenchmarkIndex()); Solver<Solution_> solver = solverConfig.buildSolver(solverConfigContext);
@Test public void buildSolverEmptyWithKieContainer() throws IOException, ReflectiveOperationException { ReleaseId releaseId = deployTestdataKjar( "buildSolverWithReleaseId", "org/optaplanner/core/api/solver/kieContainerNamedKsessionKmodule.xml", null); KieContainer kieContainer = kieServices.newKieContainer(releaseId); SolverFactory<?> solverFactory = SolverFactory.createEmptyFromKieContainer(kieContainer); SolverConfig solverConfig = solverFactory.getSolverConfig(); solverConfig.setSolutionClass( kieContainer.getClassLoader().loadClass("testdata.kjar.ClassloadedTestdataSolution")); solverConfig.setEntityClassList(Collections.singletonList( kieContainer.getClassLoader().loadClass("testdata.kjar.ClassloadedTestdataEntity"))); ScoreDirectorFactoryConfig scoreDirectorFactoryConfig = new ScoreDirectorFactoryConfig(); scoreDirectorFactoryConfig.setKsessionName("testdataKsession"); solverConfig.setScoreDirectorFactoryConfig(scoreDirectorFactoryConfig); Solver<?> solver = solverFactory.buildSolver(); assertNotNull(solver); assertNewKieSessionSucceeds(solver); }
private static void setPartSize(SolverConfig solverConfig, int partSize) { PartitionedSearchPhaseConfig phaseConfig = (PartitionedSearchPhaseConfig) solverConfig.getPhaseConfigList().get(0); Map<String, String> map = new HashMap<>(); map.put("partSize", Integer.toString(partSize)); phaseConfig.setSolutionPartitionerCustomProperties(map); }
SolverConfig p1SolverConfigX = new SolverConfig(); p1SolverConfigX.setRandomType(RandomType.JDK); p1SolverX.setSolverConfig(p1SolverConfigX); p1SolverX.setSingleBenchmarkResultList(new ArrayList<>()); SolverBenchmarkResult p1SolverY = new SolverBenchmarkResult(p1); p1SolverY.setName("Solver Y"); SolverConfig p1SolverConfigY = new SolverConfig(); p1SolverConfigY.setRandomType(RandomType.MERSENNE_TWISTER); p1SolverY.setSolverConfig(p1SolverConfigY); p1SolverY.setSingleBenchmarkResultList(new ArrayList<>()); SolverBenchmarkResult p2SolverZ = new SolverBenchmarkResult(p2); p2SolverZ.setName("Solver Z"); SolverConfig p2SolverConfigZ = new SolverConfig(); p2SolverConfigZ.setRandomType(RandomType.WELL1024A); p2SolverZ.setSolverConfig(p2SolverConfigZ); p2SolverZ.setSingleBenchmarkResultList(new ArrayList<>());