fix: improve strategy

Author: zepfred

core/src/main/java/ai/timefold/solver/core/impl/heuristic/selector/move/decorator/FilteringMoveSelector.java

@@ -77,6 +77,7 @@ public Iterator<Move<Solution_>> iterator() {
 
     private class JustInTimeFilteringMoveIterator extends UpcomingSelectionIterator<Move<Solution_>> {
 
+        private final double TERMINATION_CHECK_RATIO = 0.1;
         private final Iterator<Move<Solution_>> childMoveIterator;
         private final long bailOutSize;
         private final AbstractPhaseScope<Solution_> phaseScope;
@@ -94,6 +95,9 @@ public JustInTimeFilteringMoveIterator(Iterator<Move<Solution_>> childMoveIterat
         protected Move<Solution_> createUpcomingSelection() {
             Move<Solution_> next;
             long attemptsBeforeBailOut = bailOutSize;
+            // To reduce the impact of checking for termination on each move,
+            // we only check termination after evaluating 10% of the available moves
+            long attemptsBeforeCheckTermination = (long) (bailOutSize * TERMINATION_CHECK_RATIO);
             do {
                 if (!childMoveIterator.hasNext()) {
                     return noUpcomingSelection();
@@ -104,13 +108,18 @@ protected Move<Solution_> createUpcomingSelection() {
                         logger.trace("Bailing out of neverEnding selector ({}) after ({}) attempts to avoid infinite loop.",
                                 FilteringMoveSelector.this, bailOutSize);
                         return noUpcomingSelection();
-                    } else if (termination != null && termination.isPhaseTerminated(phaseScope)) {
-                        logger.trace(
-                                "Bailing out of neverEnding selector ({}) because the termination setting has been triggered.",
-                                FilteringMoveSelector.this);
-                        return noUpcomingSelection();
+                    } else if (termination != null && attemptsBeforeCheckTermination <= 0L) {
+                        // Reset the counter
+                        attemptsBeforeCheckTermination = (long) (bailOutSize * TERMINATION_CHECK_RATIO);
+                        if (termination.isPhaseTerminated(phaseScope)) {
+                            logger.trace(
+                                    "Bailing out of neverEnding selector ({}) because the termination setting has been triggered.",
+                                    FilteringMoveSelector.this);
+                            return noUpcomingSelection();
+                        }
                     }
                     attemptsBeforeBailOut--;
+                    attemptsBeforeCheckTermination--;
                 }
                 next = childMoveIterator.next();
             } while (!accept(scoreDirector, next));

core/src/test/java/ai/timefold/solver/core/impl/heuristic/selector/move/decorator/FilteringMoveSelectorTest.java

@@ -52,18 +52,17 @@ void bailOutByTermination() {
         var moveSelector = mock(MoveSelector.class);
         var termination = mock(BasicPlumbingTermination.class);
         var iterator = mock(Iterator.class);
-        // We set the maximum value to force it to run many evaluations
-        when(moveSelector.getSize()).thenReturn(Long.MAX_VALUE / 11);
+        when(moveSelector.getSize()).thenReturn(100L);
         when(moveSelector.isNeverEnding()).thenReturn(true);
         when(moveSelector.iterator()).thenReturn(iterator);
         when(iterator.hasNext()).thenReturn(true);
         when(phaseScope.getTermination()).thenReturn(termination);
-        when(termination.isPhaseTerminated(any(AbstractPhaseScope.class))).thenReturn(false, false, true);
+        when(termination.isPhaseTerminated(any(AbstractPhaseScope.class))).thenReturn(false, true);
         var filteredMoveSelector = FilteringMoveSelector.of(moveSelector, (scoreDirector, selection) -> false);
         filteredMoveSelector.phaseStarted(phaseScope);
         assertThat(filteredMoveSelector.iterator().hasNext()).isFalse();
-        // The termination returns true at the third call
-        verify(iterator, times(2)).next();
+        // The termination returns true at the second call, and only (100 * 10) * 30% calls are executed per check
+        verify(iterator, times(200)).next();
     }
 
     public void filter(SelectionCacheType cacheType, int timesCalled) {