copilot

Author: triceo

core/src/main/java/ai/timefold/solver/core/impl/bavet/AbstractBavetNodeNetwork.java

@@ -30,8 +30,7 @@ public abstract class AbstractBavetNodeNetwork {
 
     protected static AbstractNode[][] buildLayeredNodes(List<AbstractNode> nodeList) {
         var layerMap = new TreeMap<Long, List<AbstractNode>>();
-        nodeList.forEach(node -> layerMap.computeIfAbsent(node.getLayerIndex(), unused -> new ArrayList<>())
-                .add(node));
+        nodeList.forEach(node -> layerMap.computeIfAbsent(node.getLayerIndex(), unused -> new ArrayList<>()).add(node));
         var layerCount = layerMap.size();
         var layeredNodes = new AbstractNode[layerCount][];
         for (var i = 0; i < layerCount; i++) {
@@ -73,13 +72,21 @@ public int forEachNodeCount() {
         return declaredClassToNodeMap.size();
     }
 
+    /**
+     *
+     * @param factClass
+     * @return if {@link #isActivationCheckComplete()} is true, only returns active root nodes;
+     *         otherwise returns all root nodes.
+     *         This means that if this information was ever read before activation checks were complete,
+     *         it should be re-read after to make sure no inactive nodes are included.
+     */
     public Stream<AbstractRootNode<?>> getRootNodesAcceptingType(Class<?> factClass) {
         // The node needs to match the fact, or the node needs to be applicable to the entire solution.
         // The latter is for FromSolution nodes.
-        return declaredClassToNodeMap.entrySet()
-                .stream()
+        return declaredClassToNodeMap.entrySet().stream()
                 .flatMap(entry -> entry.getValue().stream())
-                .filter(tupleSourceRoot -> factClass == PlanningSolution.class || tupleSourceRoot.allowsInstancesOf(factClass));
+                .filter(tupleSourceRoot -> factClass == PlanningSolution.class || tupleSourceRoot.allowsInstancesOf(factClass))
+                .filter(node -> !isActivationCheckComplete() || activeNodeSet.contains(node));
     }
 
     public void settle() {
@@ -102,11 +109,8 @@ public void settle() {
                                 case AbstractTwoInputNode<?, ?> twoInputNode -> twoInputNode.isActive();
                             })
                             .peek(activeNodes::add)
-                            .map(propagatorFunction)
-                            .toArray(Propagator[]::new))
-                    .filter(layer -> layer.length > 0)
-                    .peek(AbstractBavetNodeNetwork::settleLayer)
-                    .toArray(Propagator[][]::new);
+                            .map(propagatorFunction).toArray(Propagator[]::new))
+                    .filter(layer -> layer.length > 0).peek(AbstractBavetNodeNetwork::settleLayer).toArray(Propagator[][]::new);
             this.activeNodeSet = activeNodes;
             return;
         }
@@ -116,15 +120,10 @@ public void settle() {
         }
     }
 
-    protected boolean isActivationCheckComplete() {
+    public boolean isActivationCheckComplete() {
         return layeredActivePropagators != null;
     }
 
-    /**
-     * For testing only. The nodes that remained active after {@link #settle()}.
-     *
-     * @throws IllegalStateException if called before {@link #settle()}.
-     */
     Set<AbstractNode> getActiveNodes() {
         if (activeNodeSet == null) {
             throw new IllegalStateException("Impossible state: getActiveNodes() called before settle().");
@@ -136,9 +135,7 @@ Set<AbstractNode> getActiveNodes() {
      * For testing only. All nodes in the network, regardless of activity.
      */
     List<AbstractNode> getNodes() {
-        return Arrays.stream(layeredNodes)
-                .flatMap(Arrays::stream)
-                .toList();
+        return Arrays.stream(layeredNodes).flatMap(Arrays::stream).toList();
     }
 
     private static void settleLayer(Propagator[] nodesInLayer) {
@@ -174,8 +171,7 @@ public int hashCode() {
 
     @Override
     public String toString() {
-        return "%s with %d forEach nodes."
-                .formatted(getClass().getSimpleName(), forEachNodeCount());
+        return "%s with %d forEach nodes.".formatted(getClass().getSimpleName(), forEachNodeCount());
     }
 
 }

core/src/main/java/ai/timefold/solver/core/impl/bavet/AbstractSession.java

@@ -1,6 +1,7 @@
 package ai.timefold.solver.core.impl.bavet;
 
-import java.util.IdentityHashMap;
+import java.util.Arrays;
+import java.util.HashMap;
 import java.util.Map;
 
 import ai.timefold.solver.core.impl.bavet.common.AbstractRootNode;
@@ -12,13 +13,14 @@ public abstract class AbstractSession<Network_ extends AbstractBavetNodeNetwork>
     private final Map<Class<?>, AbstractRootNode<Object>[]> insertEffectiveClassToNodeArrayMap;
     private final Map<Class<?>, AbstractRootNode<Object>[]> updateEffectiveClassToNodeArrayMap;
     private final Map<Class<?>, AbstractRootNode<Object>[]> retractEffectiveClassToNodeArrayMap;
-    private boolean settled = true;
+    private boolean initialized = false;
+    private boolean settled = false;
 
     protected AbstractSession(Network_ nodeNetwork) {
         this.nodeNetwork = nodeNetwork;
-        this.insertEffectiveClassToNodeArrayMap = new IdentityHashMap<>(nodeNetwork.forEachNodeCount());
-        this.updateEffectiveClassToNodeArrayMap = new IdentityHashMap<>(nodeNetwork.forEachNodeCount());
-        this.retractEffectiveClassToNodeArrayMap = new IdentityHashMap<>(nodeNetwork.forEachNodeCount());
+        this.insertEffectiveClassToNodeArrayMap = HashMap.newHashMap(nodeNetwork.forEachNodeCount());
+        this.updateEffectiveClassToNodeArrayMap = HashMap.newHashMap(nodeNetwork.forEachNodeCount());
+        this.retractEffectiveClassToNodeArrayMap = HashMap.newHashMap(nodeNetwork.forEachNodeCount());
     }
 
     public final void insert(Object fact) {
@@ -68,9 +70,22 @@ public final void settle() {
             return;
         }
         nodeNetwork.settle();
+        if (!initialized && nodeNetwork.isActivationCheckComplete()) {
+            removeInactiveRootNodes(insertEffectiveClassToNodeArrayMap);
+            removeInactiveRootNodes(updateEffectiveClassToNodeArrayMap);
+            removeInactiveRootNodes(retractEffectiveClassToNodeArrayMap);
+            initialized = true;
+        }
         settled = true;
     }
 
+    private void removeInactiveRootNodes(Map<Class<?>, AbstractRootNode<Object>[]> effectiveClassToNodeArrayMap) {
+        // Use getActiveNodes() for this, to not rerun the activity checking logic again.
+        effectiveClassToNodeArrayMap.replaceAll((k, v) -> Arrays.stream(v)
+                .filter(n -> nodeNetwork.getActiveNodes().contains(n))
+                .toArray(AbstractRootNode[]::new));
+    }
+
     public Network_ getNodeNetwork() {
         return nodeNetwork;
     }

core/src/main/java/ai/timefold/solver/core/impl/bavet/common/AbstractPrecomputeNode.java

@@ -92,4 +92,5 @@ public final void retract(@Nullable Object a) {
     }
 
     protected abstract Tuple_ remapTuple(Tuple_ tuple);
+
 }

core/src/main/java/ai/timefold/solver/core/impl/bavet/common/RecordAndReplayPropagator.java

@@ -249,7 +249,7 @@ private void recalculateTuples(AbstractBavetNodeNetwork internalNodeNetwork,
                             internalTupleToOutputTupleMapper, internalTupleToOutputTupleMap))) {
                 for (var fact : seenFactSet) {
                     classToRootNodeList.get(fact.getClass())
-                            .forEach(node -> ((BavetRootNode<Object>) node).update(fact));
+                            .forEach(node -> ((AbstractRootNode<Object>) node).update(fact));
                 }
                 internalNodeNetwork.settle();
             }

core/src/main/java/ai/timefold/solver/core/impl/bavet/common/tuple/AggregatedTupleLifecycle.java

@@ -1,7 +1,6 @@
 package ai.timefold.solver.core.impl.bavet.common.tuple;
 
 import java.util.Arrays;
-import java.util.Objects;
 
 public final class AggregatedTupleLifecycle<Tuple_ extends Tuple>
         implements TupleLifecycle<Tuple_> {
@@ -64,12 +63,6 @@ public void retract(Tuple_ tuple) {
         }
     }
 
-    @Override
-    public boolean equals(Object o) {
-        return o instanceof AggregatedTupleLifecycle<?> that &&
-                Arrays.deepEquals(downstream, that.downstream);
-    }
-
     /**
      * Users must not modify this array. (Defensive copy avoided for performance reasons.)
      *
@@ -79,9 +72,15 @@ public TupleLifecycle<Tuple_>[] downstream() {
         return downstream;
     }
 
+    @Override
+    public boolean equals(Object o) {
+        return o instanceof AggregatedTupleLifecycle<?> that &&
+                Arrays.deepEquals(downstream, that.downstream);
+    }
+
     @Override
     public int hashCode() {
-        return Objects.hashCode(downstream);
+        return Arrays.deepHashCode(downstream);
     }
 
     @Override

core/src/main/java/ai/timefold/solver/core/impl/score/stream/bavet/ConstraintStreamsBavetNodeNetwork.java

@@ -19,7 +19,7 @@
 import org.slf4j.event.Level;
 
 /**
- * Represents Constraint Streams's network of nodes, specific to a particular session.
+ * Represents Constraint Streams' network of nodes, specific to a particular session.
  * Nodes only used by disabled constraints have already been removed.
  *
  */

core/src/main/java/ai/timefold/solver/core/impl/score/stream/bavet/common/ConstraintNodeBuildHelper.java

@@ -141,7 +141,7 @@ public ConstraintStreamsBavetNodeNetwork buildNodeNetwork(List<AbstractNode> nod
                     ConstraintNodeProfileId.Qualifier.NODE, node.getLocationSet());
             constraintProfiler.register(profileId);
             var stream = getNodeCreator(node);
-            for (var affectedSet : streamToProfileIdSets.get(stream)) {
+            for (var affectedSet : streamToProfileIdSets.getOrDefault(stream, Collections.emptyList())) {
                 affectedSet.add(profileId);
             }
             return new ProfilingPropagator(constraintProfiler, profileId, node.getPropagator());