feat: relative stuck criterion definition

Author: zepfred

core/src/main/java/ai/timefold/solver/core/impl/localsearch/decider/acceptor/restart/AbstractGeometricStuckCriterion.java

@@ -24,16 +24,21 @@ public abstract class AbstractGeometricStuckCriterion<Solution_> implements Stuc
     private static final double GEOMETRIC_FACTOR = 1.4; // Value extracted from the cited paper
     private static final long GRACE_PERIOD_MILLIS = 30_000; // 30s by default
 
-    private final double scalingFactor;
     private final Clock clock;
+    private double scalingFactor;
     private boolean gracePeriodFinished;
     private Instant gracePeriodEnd;
     protected long nextRestart;
     private double currentGeometricGrowFactor;
 
-    protected AbstractGeometricStuckCriterion(Clock clock, double scalingFactor) {
+    protected AbstractGeometricStuckCriterion(Clock clock) {
         this.clock = clock;
+        this.scalingFactor = -1;
+    }
+
+    protected void setScalingFactor(double scalingFactor) {
         this.scalingFactor = scalingFactor;
+        this.nextRestart = calculateNextRestart();
     }
 
     @Override
@@ -67,6 +72,9 @@ public boolean isSolverStuck(LocalSearchMoveScope<Solution_> moveScope) {
         if (isGracePeriodFinished()) {
             var triggered = evaluateCriterion(moveScope);
             if (triggered) {
+                if (scalingFactor == -1) {
+                    throw new IllegalStateException("The scaling factor is not defined for this criterion.");
+                }
                 logger.trace(
                         "Restart triggered with geometric factor {}, scaling factor of {}, best score ({}), move count ({})",
                         currentGeometricGrowFactor,

core/src/main/java/ai/timefold/solver/core/impl/localsearch/decider/acceptor/restart/UnimprovedMoveCountStuckCriterion.java

@@ -15,8 +15,10 @@
  */
 public class UnimprovedMoveCountStuckCriterion<Solution_> extends AbstractGeometricStuckCriterion<Solution_> {
 
-    // Multiplier defined through experiments
-    protected static final long UNIMPROVED_MOVE_COUNT_MULTIPLIER = 300_000;
+    // The multiplier will lead to an unimproved move count near a 10-second window without any improvements.
+    // In this manner, the first restart will occur after approximately 10 seconds without any improvement,
+    // then after 20 seconds, and so on.
+    protected static final int UNIMPROVED_MOVE_COUNT_MULTIPLIER = 10;
     // Last checkpoint of a solution improvement or the restart process
     protected long lastCheckpoint;
     private Score<?> currentBestScore;
@@ -26,7 +28,7 @@ public UnimprovedMoveCountStuckCriterion() {
     }
 
     protected UnimprovedMoveCountStuckCriterion(Clock clock) {
-        super(clock, UNIMPROVED_MOVE_COUNT_MULTIPLIER);
+        super(clock);
     }
 
     @Override
@@ -54,6 +56,12 @@ public boolean evaluateCriterion(LocalSearchMoveScope<Solution_> moveScope) {
         var currentMoveCount = moveScope.getStepScope().getPhaseScope().getSolverScope().getMoveEvaluationCount();
         if (lastCheckpoint == 0) {
             lastCheckpoint = currentMoveCount;
+            // Grace period is finished
+            // Now we use the current move evaluation speed to define the scaling factor
+            var scalingFactor = (double) (moveScope.getStepScope().getPhaseScope().getSolverScope().getMoveEvaluationSpeed()
+                    * UNIMPROVED_MOVE_COUNT_MULTIPLIER);
+            logger.trace("Scaling factor set to {}.", scalingFactor);
+            setScalingFactor(scalingFactor);
             return false;
         }
         if (currentMoveCount - lastCheckpoint >= nextRestart) {

core/src/test/java/ai/timefold/solver/core/impl/localsearch/decider/acceptor/restart/UnimprovedMoveCountStuckCriterionTest.java

@@ -34,6 +34,7 @@ void isSolverStuck() {
         when(instant.plusMillis(anyLong())).thenReturn(Instant.ofEpochMilli(UNIMPROVED_MOVE_COUNT_MULTIPLIER + 1000L));
         when(clock.millis()).thenReturn(UNIMPROVED_MOVE_COUNT_MULTIPLIER + 1000L);
         when(solverScope.getMoveEvaluationCount()).thenReturn(1000L);
+        when(solverScope.getMoveEvaluationSpeed()).thenReturn(1L);
         when(phaseScope.getBestScore()).thenReturn(SimpleScore.of(1000));
 
         // Finish grace period

core/src/test/java/ai/timefold/solver/core/impl/localsearch/decider/reconfiguration/RestartStrategyTest.java

@@ -16,7 +16,7 @@ class RestartStrategyTest {
     void restoreBestSolution() {
         // Requires the decider
         var badStrategy = new RestoreBestSolutionRestartStrategy<>();
-        assertThatThrownBy(() -> badStrategy.solvingStarted(null)).isInstanceOf(NullPointerException.class);
+        assertThatThrownBy(() -> badStrategy.phaseStarted(null)).isInstanceOf(NullPointerException.class);
 
         // Restore the best solution
         var strategy = new RestoreBestSolutionRestartStrategy<>();
@@ -25,9 +25,11 @@ void restoreBestSolution() {
         var solverScope = mock(SolverScope.class);
         var phaseScope = mock(LocalSearchPhaseScope.class);
         when(phaseScope.getSolverScope()).thenReturn(solverScope);
+        when(phaseScope.getDecider()).thenReturn(decider);
         var stepScope = mock(LocalSearchStepScope.class);
         when(stepScope.getPhaseScope()).thenReturn(phaseScope);
-        strategy.solvingStarted(new AdaptedSolverScope<>(solverScope, decider));
+        strategy.solvingStarted(solverScope);
+        strategy.phaseStarted(phaseScope);
         strategy.applyRestart(stepScope);
         // Restore the best solution
         verify(decider, times(1)).setWorkingSolutionFromBestSolution(any());