perf: DynamicIntArray gets different clearing strategies

Author: triceo

core/src/main/java/ai/timefold/solver/core/impl/domain/variable/declarative/LoopedTracker.java

@@ -1,5 +1,7 @@
 package ai.timefold.solver.core.impl.domain.variable.declarative;
 
+import static ai.timefold.solver.core.impl.util.DynamicIntArray.ClearingStrategy.PARTIAL;
+
 import ai.timefold.solver.core.impl.util.DynamicIntArray;
 
 import org.jspecify.annotations.NullMarked;
@@ -14,7 +16,8 @@ public final class LoopedTracker {
     private final DynamicIntArray looped;
 
     public LoopedTracker(int nodeCount) {
-        this.looped = new DynamicIntArray(nodeCount);
+        // We never fully clear the array, as that was shown to cause too much GC pressure.
+        this.looped = new DynamicIntArray(nodeCount, PARTIAL);
     }
 
     public void mark(int node, LoopedStatus status) {

core/src/main/java/ai/timefold/solver/core/impl/util/DynamicIntArray.java

@@ -1,5 +1,7 @@
 package ai.timefold.solver.core.impl.util;
 
+import java.util.Arrays;
+
 /**
  * A class representing an int array that is dynamically allocated based on the first set index.
  * The array is only created when the first element is set and is reallocated as needed
@@ -12,6 +14,7 @@ public final class DynamicIntArray {
     // Minimum capacity increment to avoid small incremental growth
     private static final int MIN_CAPACITY_INCREMENT = 10;
 
+    private final ClearingStrategy clearingStrategy;
     private final int maxLength;
     private int[] array;
     private int firstIndex;
@@ -21,12 +24,18 @@ public DynamicIntArray() {
         this(Integer.MAX_VALUE);
     }
 
-    /**
-     * Creates a new empty DynamicIntArray.
-     */
+    public DynamicIntArray(ClearingStrategy clearingStrategy) {
+        this(Integer.MAX_VALUE, clearingStrategy);
+    }
+
     public DynamicIntArray(int maxLength) {
+        this(maxLength, ClearingStrategy.FULL);
+    }
+
+    public DynamicIntArray(int maxLength, ClearingStrategy clearingStrategy) {
         this.maxLength = maxLength;
-        clear();
+        this.clearingStrategy = clearingStrategy;
+        initializeArray();
     }
 
     /**
@@ -171,28 +180,47 @@ int getLastIndex() {
         return lastIndex;
     }
 
-    /**
-     * Gets the length of the array.
-     *
-     * @return the length of the array, or 0 if the array is empty
-     */
-    int length() {
-        if (array == null) {
-            return 0;
-        }
-        return lastIndex + 1;
-    }
-
     /**
      * Clears the array by setting all values to 0.
      * The array structure is preserved, only the values are reset.
      */
     public void clear() {
-        // Array is null until first element is set
+        if (clearingStrategy == ClearingStrategy.FULL) {
+            initializeArray();
+        } else {
+            // If array is null, there's nothing to clear
+            if (array == null) {
+                return;
+            }
+
+            // Only clear the used portion of the array (from firstIndex to lastIndex)
+            // This is more efficient for large arrays with sparse indices
+            Arrays.fill(array, 0, lastIndex - firstIndex + 1, 0);
+        }
+    }
+
+    private void initializeArray() {
         this.array = null;
-        // Initialize with invalid indices
         this.firstIndex = Integer.MAX_VALUE;
         this.lastIndex = Integer.MIN_VALUE;
     }
 
+    public enum ClearingStrategy {
+
+        /**
+         * The GC will be allowed to reclaim the array.
+         * This means that, on next access, the array will have to be reallocated and gradually resized,
+         * possibly leading to excessive GC pressure.
+         *
+         * This is the default.
+         */
+        FULL,
+        /**
+         * The array will not be returned to GC and will be filled with zeros instead.
+         * This has no impact on GC, but may result in greater at-rest heap usage than strictly necessary.
+         */
+        PARTIAL
+
+    }
+
 }

core/src/test/java/ai/timefold/solver/core/impl/util/DynamicIntArrayTest.java

@@ -28,7 +28,6 @@ void defaultConstructor() {
                     .isThrownBy(array::getLastIndex)
                     .withMessage("Array is empty");
 
-            assertThat(array.length()).isZero();
             assertThat(array.containsIndex(0)).isFalse();
             assertThat(array.get(0)).isZero();
         }
@@ -41,8 +40,6 @@ void constructorWithMaxSize() {
             assertThatExceptionOfType(IllegalStateException.class)
                     .isThrownBy(array::getFirstIndex);
 
-            assertThat(array.length()).isZero();
-
             // Test bound checking with maxSize
             assertThatExceptionOfType(ArrayIndexOutOfBoundsException.class)
                     .isThrownBy(() -> array.set(100, 5));
@@ -65,7 +62,6 @@ void setFirstElement() {
             assertThat(array.containsIndex(10)).isTrue();
             assertThat(array.containsIndex(9)).isFalse();
             assertThat(array.containsIndex(11)).isFalse();
-            assertThat(array.length()).isEqualTo(11); // 0-10 inclusive
         }
 
         @Test
@@ -81,7 +77,6 @@ void setLowerIndex() {
             assertThat(array.getLastIndex()).isEqualTo(10);
             assertThat(array.containsIndex(5)).isTrue();
             assertThat(array.containsIndex(10)).isTrue();
-            assertThat(array.length()).isEqualTo(11); // 0-10 inclusive
         }
 
         @Test
@@ -97,7 +92,6 @@ void setHigherIndex() {
             assertThat(array.getLastIndex()).isEqualTo(10);
             assertThat(array.containsIndex(5)).isTrue();
             assertThat(array.containsIndex(10)).isTrue();
-            assertThat(array.length()).isEqualTo(11); // 0-10 inclusive
         }
 
         @Test
@@ -216,34 +210,6 @@ void containsIndexOutsideRange() {
         }
     }
 
-    @Nested
-    @DisplayName("Length method tests")
-    class LengthMethodTests {
-
-        @Test
-        @DisplayName("Length returns 0 for empty array")
-        void lengthEmptyArray() {
-            var array = new DynamicIntArray();
-
-            assertThat(array.length()).isZero();
-        }
-
-        @Test
-        @DisplayName("Length returns correct value after setting elements")
-        void lengthAfterSettingElements() {
-            var array = new DynamicIntArray();
-            array.set(0, 1);
-
-            assertThat(array.length()).isEqualTo(1);
-
-            array.set(5, 24);
-            assertThat(array.length()).isEqualTo(6); // 0-5 inclusive
-
-            array.set(10, 42);
-            assertThat(array.length()).isEqualTo(11); // 0-10 inclusive
-        }
-    }
-
     @Nested
     @DisplayName("Complex scenario tests")
     class ComplexScenarioTests {
@@ -288,9 +254,6 @@ void testMultipleOperations() {
             assertThat(array.containsIndex(15)).isTrue();
             assertThat(array.containsIndex(4)).isFalse();
             assertThat(array.containsIndex(16)).isFalse();
-
-            // Verify length
-            assertThat(array.length()).isEqualTo(16); // 0-15 inclusive
         }
 
         @Test
@@ -307,7 +270,6 @@ void testWithSparseIndices() {
             assertThat(array.get(10)).isEqualTo(3);
             assertThat(array.get(100)).isEqualTo(1);
             assertThat(array.get(1000)).isEqualTo(2);
-            assertThat(array.length()).isEqualTo(1001); // 0-1000 inclusive
         }
     }
 
@@ -322,8 +284,6 @@ void clearEmptyArray() {
 
             // Should not throw an exception
             array.clear();
-
-            assertThat(array.length()).isZero();
         }
 
         @Test
@@ -340,11 +300,8 @@ void clearResetsValues() {
             assertThat(array.get(10)).isZero();
 
             // Array structure should be preserved
-            assertThat(array.getFirstIndex()).isEqualTo(5);
-            assertThat(array.getLastIndex()).isEqualTo(10);
-            assertThat(array.containsIndex(5)).isTrue();
-            assertThat(array.containsIndex(10)).isTrue();
-            assertThat(array.length()).isEqualTo(11); // 0-10 inclusive
+            assertThat(array.containsIndex(5)).isFalse();
+            assertThat(array.containsIndex(10)).isFalse();
         }
 
         @Test
@@ -367,30 +324,10 @@ void clearAndSetNewValues() {
             assertThat(array.get(10)).isZero();
 
             // Array structure should be updated
-            assertThat(array.getFirstIndex()).isEqualTo(5);
-            assertThat(array.getLastIndex()).isEqualTo(10);
+            assertThat(array.getFirstIndex()).isEqualTo(7);
+            assertThat(array.getLastIndex()).isEqualTo(7);
         }
 
-        @Test
-        @DisplayName("Clear with sparse indices")
-        void clearWithSparseIndices() {
-            var array = new DynamicIntArray();
-            array.set(10, 1);
-            array.set(100, 2);
-            array.set(1000, 3);
-
-            array.clear();
-
-            // All values should be reset to 0
-            assertThat(array.get(10)).isZero();
-            assertThat(array.get(100)).isZero();
-            assertThat(array.get(1000)).isZero();
-
-            // Array structure should be preserved
-            assertThat(array.getFirstIndex()).isEqualTo(10);
-            assertThat(array.getLastIndex()).isEqualTo(1000);
-            assertThat(array.length()).isEqualTo(1001); // 0-1000 inclusive
-        }
     }
 
 }