chore: reconfiguration strategy compatible with MT

Author: zepfred

core/src/main/java/ai/timefold/solver/core/impl/localsearch/DefaultLocalSearchPhaseFactory.java

@@ -70,8 +70,8 @@ public LocalSearchPhase<Solution_> buildPhase(int phaseIndex, boolean triggerFir
     private LocalSearchDecider<Solution_> buildDecider(HeuristicConfigPolicy<Solution_> configPolicy,
             Termination<Solution_> termination) {
         var moveSelector = buildMoveSelector(configPolicy);
-        var reconfigurationStrategy = buildReconfigurationStrategy(configPolicy);
         var acceptor = buildAcceptor(configPolicy);
+        var reconfigurationStrategy = buildReconfigurationStrategy(configPolicy, moveSelector, acceptor);
         var forager = buildForager(configPolicy);
         if (moveSelector.isNeverEnding() && !forager.supportsNeverEndingMoveSelector()) {
             throw new IllegalStateException("The moveSelector (" + moveSelector
@@ -97,9 +97,6 @@ private LocalSearchDecider<Solution_> buildDecider(HeuristicConfigPolicy<Solutio
         if (environmentMode.isIntrusiveFastAsserted()) {
             decider.setAssertExpectedUndoMoveScore(true);
         }
-        if (reconfigurationStrategy instanceof RestoreBestSolutionReconfigurationStrategy<Solution_> castReconfigurationStrategy) {
-            castReconfigurationStrategy.setDecider(decider);
-        }
         return decider;
     }
 
@@ -206,14 +203,15 @@ protected MoveSelector<Solution_> buildMoveSelector(HeuristicConfigPolicy<Soluti
         return moveSelector;
     }
 
-    private ReconfigurationStrategy<Solution_> buildReconfigurationStrategy(HeuristicConfigPolicy<Solution_> configPolicy) {
+    private ReconfigurationStrategy<Solution_> buildReconfigurationStrategy(HeuristicConfigPolicy<Solution_> configPolicy,
+            MoveSelector<Solution_> moveSelector, Acceptor<Solution_> acceptor) {
         var acceptorConfig = phaseConfig.getAcceptorConfig();
         if (acceptorConfig != null) {
             var enableReconfiguration =
                     acceptorConfig.getEnableReconfiguration() != null && acceptorConfig.getEnableReconfiguration();
             if (enableReconfiguration) {
                 configPolicy.ensurePreviewFeature(PreviewFeature.RECONFIGURATION);
-                return new RestoreBestSolutionReconfigurationStrategy<>();
+                return new RestoreBestSolutionReconfigurationStrategy<>(moveSelector, acceptor);
             }
         }
         return new NoOpReconfigurationStrategy<>();

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

@@ -5,6 +5,7 @@
 import ai.timefold.solver.core.impl.localsearch.scope.LocalSearchMoveScope;
 import ai.timefold.solver.core.impl.localsearch.scope.LocalSearchPhaseScope;
 import ai.timefold.solver.core.impl.localsearch.scope.LocalSearchStepScope;
+import ai.timefold.solver.core.impl.solver.scope.SolverScope;
 
 /**
  * Base class designed to analyze whether the solving process needs to be restarted.
@@ -24,6 +25,12 @@ protected boolean isEnabled() {
         return enabled;
     }
 
+    @Override
+    public void solvingStarted(SolverScope<Solution_> solverScope) {
+        super.solvingStarted(solverScope);
+        restartStrategy.solvingStarted(solverScope);
+    }
+
     @Override
     public void phaseStarted(LocalSearchPhaseScope<Solution_> phaseScope) {
         super.phaseStarted(phaseScope);

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

@@ -42,10 +42,10 @@ protected UnimprovedTimeGeometricRestartStrategy(Clock clock) {
     @Override
     public void phaseStarted(LocalSearchPhaseScope<Solution_> phaseScope) {
         currentBestScore = phaseScope.getBestScore();
-        geometricGrowFactor = 1;
-        nextRestart = (long) (1_000 * SCALING_FACTOR);
+        if (lastImprovementMillis == 0) {
+            lastImprovementMillis = clock.millis();
+        }
         restartTriggered = false;
-        lastImprovementMillis = clock.millis();
     }
 
     @Override
@@ -69,7 +69,9 @@ public void stepEnded(LocalSearchStepScope<Solution_> stepScope) {
 
     @Override
     public void solvingStarted(SolverScope<Solution_> solverScope) {
-        // Do nothing
+        lastImprovementMillis = 0;
+        geometricGrowFactor = 1;
+        nextRestart = (long) (1_000 * SCALING_FACTOR);
     }
 
     @Override

core/src/main/java/ai/timefold/solver/core/impl/localsearch/decider/reconfiguration/RestoreBestSolutionReconfigurationStrategy.java

@@ -3,7 +3,8 @@
 import java.util.Objects;
 
 import ai.timefold.solver.core.api.score.Score;
-import ai.timefold.solver.core.impl.localsearch.decider.LocalSearchDecider;
+import ai.timefold.solver.core.impl.heuristic.selector.move.MoveSelector;
+import ai.timefold.solver.core.impl.localsearch.decider.acceptor.Acceptor;
 import ai.timefold.solver.core.impl.localsearch.scope.LocalSearchPhaseScope;
 import ai.timefold.solver.core.impl.phase.scope.AbstractPhaseScope;
 import ai.timefold.solver.core.impl.phase.scope.AbstractStepScope;
@@ -15,10 +16,12 @@
 public final class RestoreBestSolutionReconfigurationStrategy<Solution_> implements ReconfigurationStrategy<Solution_> {
 
     private final Logger logger = LoggerFactory.getLogger(getClass());
-    private LocalSearchDecider<Solution_> decider;
+    private final MoveSelector<Solution_> moveSelector;
+    private final Acceptor<Solution_> acceptor;
 
-    public void setDecider(LocalSearchDecider<Solution_> decider) {
-        this.decider = decider;
+    public RestoreBestSolutionReconfigurationStrategy(MoveSelector<Solution_> moveSelector, Acceptor<Solution_> acceptor) {
+        this.moveSelector = moveSelector;
+        this.acceptor = acceptor;
     }
 
     @Override
@@ -29,8 +32,9 @@ public <Score_ extends Score<Score_>> Score_ apply(AbstractStepScope<Solution_>
         solverScope.setWorkingSolutionFromBestSolution();
         // Changing the working solution requires reinitializing the move selector and acceptor
         // 1 - The move selector will reset all cached lists using old solution entity references
+        moveSelector.phaseStarted(stepScope.getPhaseScope());
         // 2 - The acceptor will restart its search from the updated working solution (last best solution)
-        decider.phaseStarted((LocalSearchPhaseScope<Solution_>) stepScope.getPhaseScope());
+        acceptor.phaseStarted((LocalSearchPhaseScope<Solution_>) stepScope.getPhaseScope());
         // Reset it as the best solution is already restored
         stepScope.getPhaseScope().resetReconfiguration();
         return (Score_) solverScope.getBestScore();
@@ -48,7 +52,8 @@ public void stepEnded(AbstractStepScope<Solution_> stepScope) {
 
     @Override
     public void phaseStarted(AbstractPhaseScope<Solution_> phaseScope) {
-        Objects.requireNonNull(decider);
+        Objects.requireNonNull(moveSelector);
+        Objects.requireNonNull(acceptor);
     }
 
     @Override

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

@@ -4,7 +4,8 @@
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 import static org.mockito.Mockito.*;
 
-import ai.timefold.solver.core.impl.localsearch.decider.LocalSearchDecider;
+import ai.timefold.solver.core.impl.heuristic.selector.move.MoveSelector;
+import ai.timefold.solver.core.impl.localsearch.decider.acceptor.Acceptor;
 import ai.timefold.solver.core.impl.localsearch.decider.acceptor.restart.NoOpRestartStrategy;
 import ai.timefold.solver.core.impl.localsearch.scope.LocalSearchMoveScope;
 import ai.timefold.solver.core.impl.localsearch.scope.LocalSearchPhaseScope;
@@ -23,24 +24,26 @@ void noOp() {
 
     @Test
     void restoreBestSolution() {
-        var decider = mock(LocalSearchDecider.class);
-        var strategy = new RestoreBestSolutionReconfigurationStrategy<>();
-
         // Requires the decider
-        assertThatThrownBy(() -> strategy.phaseStarted(null)).isInstanceOf(NullPointerException.class);
+        assertThatThrownBy(() -> new RestoreBestSolutionReconfigurationStrategy<>(null, null).phaseStarted(null))
+                .isInstanceOf(NullPointerException.class);
 
         // Restore the best solution
+        var moveSelector = mock(MoveSelector.class);
+        var acceptor = mock(Acceptor.class);
+        var strategy = new RestoreBestSolutionReconfigurationStrategy<>(moveSelector, acceptor);
+
         var solverScope = mock(SolverScope.class);
         var phaseScope = mock(LocalSearchPhaseScope.class);
         when(phaseScope.getSolverScope()).thenReturn(solverScope);
         var stepScope = mock(LocalSearchStepScope.class);
         when(stepScope.getPhaseScope()).thenReturn(phaseScope);
-        strategy.setDecider(decider);
         strategy.apply(stepScope);
         // Restore the best solution
         verify(solverScope, times(1)).setWorkingSolutionFromBestSolution();
         // Restart the phase
         verify(phaseScope, times(1)).resetReconfiguration();
-        verify(decider, times(1)).phaseStarted(any());
+        verify(moveSelector, times(1)).phaseStarted(any());
+        verify(acceptor, times(1)).phaseStarted(any());
     }
 }