chore: make init score inaccessible to users (#1501)

The init score exposed by the Score interface is now always zero. To
find out when the solver has finished initializing a solution, users are
encouraged to catch the initialization event thrown by the solver
manager.

Internally, the init score remains. A new type was created (InnerScore),
which now carries the information that init score used to carry. All
code which requires to know the initialization status of the solution
now has to use InnerScore. Code which does not care about this
information can continue using Score.

Author: triceo

.github/workflows/pull_request_secure.yml

@@ -371,13 +371,21 @@ jobs:
         run: mvn -B clean install -Prun-code-coverage
 
       - name: Get JaCoCo Agent
-        run: mvn org.apache.maven.plugins:maven-dependency-plugin:2.8:get -Dartifact=org.jacoco:org.jacoco.agent:0.8.11:jar:runtime -Ddest=target/jacocoagent.jar
+        run: mvn org.apache.maven.plugins:maven-dependency-plugin:3.8.1:copy -Dartifact=org.jacoco:org.jacoco.agent:0.8.13:jar:runtime -DoutputDirectory=target/jacocoagent.jar
 
       - name: Run tox to measure timefold solver python code coverage from Python tests
+        # Sometimes crashes at the very end when using JaCoCo.
+        # This crash happens after everything is processed and stored, and therefore can be safely ignored.
+        # Ignore the crash to not ruin the long-running build.
+        continue-on-error: true
         run: python -m tox -- --cov=timefold --cov-report=xml:target/coverage.xml --cov-config=tox.ini --cov-branch --cov-append --jacoco-agent=./target/jacocoagent.jar
 
       - name: Run tox to measure jpyinterpreter code coverage from Python tests
         working-directory: ./python/jpyinterpreter
+        # Sometimes crashes at the very end when using JaCoCo.
+        # This crash happens after everything is processed and stored, and therefore can be safely ignored.
+        # Ignore the crash to not ruin the long-running build.
+        continue-on-error: true
         run: python -m tox -- --cov=jpyinterpreter --cov-report=xml:target/coverage.xml --cov-config=tox.ini --cov-branch --cov-append --jacoco-agent=../../target/jacocoagent.jar --jacoco-output=../../target/jacoco.exec
 
       - name: Run analysis

benchmark/src/main/java/ai/timefold/solver/benchmark/impl/SubSingleBenchmarkRunner.java

@@ -1,16 +1,11 @@
 package ai.timefold.solver.benchmark.impl;
 
 import java.util.HashMap;
-import java.util.Map;
 import java.util.UUID;
 import java.util.concurrent.Callable;
 
-import ai.timefold.solver.benchmark.impl.result.ProblemBenchmarkResult;
-import ai.timefold.solver.benchmark.impl.result.SingleBenchmarkResult;
 import ai.timefold.solver.benchmark.impl.result.SubSingleBenchmarkResult;
 import ai.timefold.solver.benchmark.impl.statistic.StatisticRegistry;
-import ai.timefold.solver.benchmark.impl.statistic.SubSingleStatistic;
-import ai.timefold.solver.core.api.score.ScoreExplanation;
 import ai.timefold.solver.core.api.solver.SolutionManager;
 import ai.timefold.solver.core.api.solver.SolutionUpdatePolicy;
 import ai.timefold.solver.core.config.solver.SolverConfig;
@@ -67,71 +62,68 @@ public void setFailureThrowable(Throwable failureThrowable) {
     @Override
     public SubSingleBenchmarkRunner<Solution_> call() {
         MDC.put(NAME_MDC, subSingleBenchmarkResult.getName());
-        Runtime runtime = Runtime.getRuntime();
-        SingleBenchmarkResult singleBenchmarkResult = subSingleBenchmarkResult.getSingleBenchmarkResult();
-        ProblemBenchmarkResult<Solution_> problemBenchmarkResult = singleBenchmarkResult
-                .getProblemBenchmarkResult();
-        Solution_ problem = problemBenchmarkResult.readProblem();
+        var runtime = Runtime.getRuntime();
+        var singleBenchmarkResult = subSingleBenchmarkResult.getSingleBenchmarkResult();
+        var problemBenchmarkResult = singleBenchmarkResult.getProblemBenchmarkResult();
+        var problem = (Solution_) problemBenchmarkResult.readProblem();
         if (!problemBenchmarkResult.getPlannerBenchmarkResult().hasMultipleParallelBenchmarks()) {
             runtime.gc();
             subSingleBenchmarkResult.setUsedMemoryAfterInputSolution(runtime.totalMemory() - runtime.freeMemory());
         }
         LOGGER.trace("Benchmark problem has been read for subSingleBenchmarkResult ({}).",
                 subSingleBenchmarkResult);
 
-        SolverConfig solverConfig = singleBenchmarkResult.getSolverBenchmarkResult()
+        var solverConfig = singleBenchmarkResult.getSolverBenchmarkResult()
                 .getSolverConfig();
         if (singleBenchmarkResult.getSubSingleCount() > 1) {
             solverConfig = new SolverConfig(solverConfig);
             solverConfig.offerRandomSeedFromSubSingleIndex(subSingleBenchmarkResult.getSubSingleBenchmarkIndex());
         }
-        Map<String, String> subSingleBenchmarkTagMap = new HashMap<>();
-        String runId = UUID.randomUUID().toString();
+        var subSingleBenchmarkTagMap = new HashMap<String, String>();
+        var runId = UUID.randomUUID().toString();
         subSingleBenchmarkTagMap.put("timefold.benchmark.run", runId);
         solverConfig = new SolverConfig(solverConfig);
         randomSeed = solverConfig.getRandomSeed();
 
         // Defensive copy of solverConfig for every SingleBenchmarkResult to reset Random, tabu lists, ...
-        DefaultSolverFactory<Solution_> solverFactory = new DefaultSolverFactory<>(new SolverConfig(solverConfig));
+        var solverFactory = new DefaultSolverFactory<Solution_>(new SolverConfig(solverConfig));
 
         // Register metrics
-        StatisticRegistry<Solution_> statisticRegistry =
-                new StatisticRegistry<>(solverFactory.getSolutionDescriptor().getScoreDefinition());
+        var statisticRegistry = new StatisticRegistry<Solution_>(solverFactory.getSolutionDescriptor().getScoreDefinition());
         Metrics.addRegistry(statisticRegistry);
-        Tags runTag = Tags.of("timefold.benchmark.run", runId);
+        var runTag = Tags.of("timefold.benchmark.run", runId);
         subSingleBenchmarkResult.getEffectiveSubSingleStatisticMap().forEach((statisticType, subSingleStatistic) -> {
             subSingleStatistic.open(statisticRegistry, runTag);
             subSingleStatistic.initPointList();
         });
 
-        DefaultSolver<Solution_> solver = (DefaultSolver<Solution_>) solverFactory.buildSolver();
+        var solver = (DefaultSolver<Solution_>) solverFactory.buildSolver();
         solver.setMonitorTagMap(subSingleBenchmarkTagMap);
         solver.addPhaseLifecycleListener(statisticRegistry);
-        Solution_ solution = solver.solve(problem);
+        var solution = solver.solve(problem);
 
         solver.removePhaseLifecycleListener(statisticRegistry);
         Metrics.removeRegistry(statisticRegistry);
-        long timeMillisSpent = solver.getTimeMillisSpent();
+        var timeMillisSpent = solver.getTimeMillisSpent();
 
-        for (SubSingleStatistic<Solution_, ?> subSingleStatistic : subSingleBenchmarkResult.getEffectiveSubSingleStatisticMap()
-                .values()) {
+        for (var subSingleStatistic : subSingleBenchmarkResult.getEffectiveSubSingleStatisticMap().values()) {
             subSingleStatistic.close(statisticRegistry, runTag);
             subSingleStatistic.hibernatePointList();
         }
         if (!warmUp) {
             var solverScope = solver.getSolverScope();
             var solutionDescriptor = solverScope.getSolutionDescriptor();
             problemBenchmarkResult.registerProblemSizeStatistics(solverScope.getProblemSizeStatistics());
-            subSingleBenchmarkResult.setScore(solutionDescriptor.getScore(solution));
+            subSingleBenchmarkResult.setScore(solutionDescriptor.getScore(solution), solverScope.isBestSolutionInitialized());
             subSingleBenchmarkResult.setTimeMillisSpent(timeMillisSpent);
             subSingleBenchmarkResult.setScoreCalculationCount(solverScope.getScoreCalculationCount());
             subSingleBenchmarkResult.setMoveEvaluationCount(solverScope.getMoveEvaluationCount());
 
-            SolutionManager<Solution_, ?> solutionManager = SolutionManager.create(solverFactory);
-            boolean isConstraintMatchEnabled = solver.getSolverScope().getScoreDirector().getConstraintMatchPolicy()
+            var solutionManager = SolutionManager.create(solverFactory);
+            var isConstraintMatchEnabled = solver.getSolverScope().getScoreDirector().getConstraintMatchPolicy()
                     .isEnabled();
             if (isConstraintMatchEnabled) { // Easy calculator fails otherwise.
-                ScoreExplanation<Solution_, ?> scoreExplanation =
+                var scoreExplanation =
                         solutionManager.explain(solution, SolutionUpdatePolicy.NO_UPDATE);
                 subSingleBenchmarkResult.setScoreExplanationSummary(scoreExplanation.getSummary());
             }

benchmark/src/main/java/ai/timefold/solver/benchmark/impl/ranking/ScoreSubSingleBenchmarkRankingComparator.java

@@ -3,16 +3,16 @@
 import java.util.Comparator;
 
 import ai.timefold.solver.benchmark.impl.result.SubSingleBenchmarkResult;
-import ai.timefold.solver.core.impl.score.definition.ScoreDefinition;
 
 public class ScoreSubSingleBenchmarkRankingComparator implements Comparator<SubSingleBenchmarkResult> {
 
     @Override
     public int compare(SubSingleBenchmarkResult a, SubSingleBenchmarkResult b) {
-        ScoreDefinition<?> aScoreDefinition = a.getSingleBenchmarkResult().getSolverBenchmarkResult().getScoreDefinition();
+        var aScoreDefinition = a.getSingleBenchmarkResult().getSolverBenchmarkResult().getScoreDefinition();
         return Comparator
                 // Reverse, less is better (redundant: failed benchmarks don't get ranked at all)
                 .comparing(SubSingleBenchmarkResult::hasAnyFailure, Comparator.reverseOrder())
+                .thenComparing(SubSingleBenchmarkResult::isInitialized)
                 .thenComparing(SubSingleBenchmarkResult::getScore,
                         new ResilientScoreComparator(aScoreDefinition))
                 .compare(a, b);

benchmark/src/main/java/ai/timefold/solver/benchmark/impl/ranking/TotalScoreSingleBenchmarkRankingComparator.java

@@ -3,18 +3,17 @@
 import java.util.Comparator;
 
 import ai.timefold.solver.benchmark.impl.result.SingleBenchmarkResult;
-import ai.timefold.solver.core.impl.score.definition.ScoreDefinition;
 
 public class TotalScoreSingleBenchmarkRankingComparator implements Comparator<SingleBenchmarkResult> {
 
     @Override
     public int compare(SingleBenchmarkResult a, SingleBenchmarkResult b) {
-        ScoreDefinition aScoreDefinition = a.getSolverBenchmarkResult().getScoreDefinition();
+        var aScoreDefinition = a.getSolverBenchmarkResult().getScoreDefinition();
         return Comparator
                 // Reverse, less is better (redundant: failed benchmarks don't get ranked at all)
                 .comparing(SingleBenchmarkResult::hasAnyFailure, Comparator.reverseOrder())
-                .thenComparing(SingleBenchmarkResult::getTotalScore,
-                        new ResilientScoreComparator(aScoreDefinition))
+                .thenComparing(SingleBenchmarkResult::isInitialized)
+                .thenComparing(SingleBenchmarkResult::getTotalScore, new ResilientScoreComparator(aScoreDefinition))
                 .compare(a, b);
     }
 

benchmark/src/main/java/ai/timefold/solver/benchmark/impl/result/PlannerBenchmarkResult.java

@@ -314,7 +314,7 @@ public void accumulateResults(BenchmarkReport benchmarkReport) {
         determineSolverRanking(benchmarkReport);
     }
 
-    private void determineTotalsAndAverages() {
+    private <Score_ extends Score<Score_>> void determineTotalsAndAverages() {
         failureCount = 0;
         long totalProblemScale = 0L;
         int problemScaleCount = 0;
@@ -327,7 +327,7 @@ private void determineTotalsAndAverages() {
             failureCount += problemBenchmarkResult.getFailureCount();
         }
         averageProblemScale = problemScaleCount == 0 ? null : totalProblemScale / problemScaleCount;
-        Score totalScore = null;
+        Score_ totalScore = null;
         int solverBenchmarkCount = 0;
         boolean firstSolverBenchmarkResult = true;
         for (SolverBenchmarkResult solverBenchmarkResult : solverBenchmarkResultList) {
@@ -339,9 +339,9 @@ private void determineTotalsAndAverages() {
                 environmentMode = null;
             }
 
-            Score score = solverBenchmarkResult.getAverageScore();
+            Score_ score = (Score_) solverBenchmarkResult.getAverageScore();
             if (score != null) {
-                ScoreDefinition scoreDefinition = solverBenchmarkResult.getScoreDefinition();
+                ScoreDefinition<Score_> scoreDefinition = solverBenchmarkResult.getScoreDefinition();
                 if (totalScore != null && !scoreDefinition.isCompatibleArithmeticArgument(totalScore)) {
                     // Mixing different use cases with different score definitions.
                     totalScore = null;