perf: improve performance of Bavet indexing (#1324)

Refactors indexing in Bavet so that:

- IndexKeys (formerly IndexProperties) become bimorphic as opposed to
megamorphic, enabling all kinds of JVM optimizations.
- Many instances of IndexKeys are no longer created as they were
unnecessary. (Case in point: SingleIndexProperties is gone, without
replacement.)
- There is less indirection in the nodes.
- Naming of keys, functions and mappings is standardized across the
board.

In the score director benchmarks, these changes show throughput
improvements of up to 10 %, with GC pressure reduced by up to 40 %.

Author: triceo

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

@@ -65,23 +65,20 @@ public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> bui
         TupleLifecycle<BiTuple<A, B>> downstream = buildHelper.getAggregatedTupleLifecycle(childStreamList);
         IndexerFactory<C> indexerFactory = new IndexerFactory<>(joiner);
         var node = indexerFactory.hasJoiners()
-                ? (filtering == null ? new IndexedIfExistsBiNode<>(shouldExist,
-                        indexerFactory.buildBiLeftMapping(), indexerFactory.buildRightMapping(),
+                ? (filtering == null ? new IndexedIfExistsBiNode<>(shouldExist, indexerFactory,
                         buildHelper.reserveTupleStoreIndex(parentAB.getTupleSource()),
                         buildHelper.reserveTupleStoreIndex(parentAB.getTupleSource()),
                         buildHelper.reserveTupleStoreIndex(parentBridgeC.getTupleSource()),
                         buildHelper.reserveTupleStoreIndex(parentBridgeC.getTupleSource()),
-                        downstream, indexerFactory.buildIndexer(true), indexerFactory.buildIndexer(false))
-                        : new IndexedIfExistsBiNode<>(shouldExist,
-                                indexerFactory.buildBiLeftMapping(), indexerFactory.buildRightMapping(),
+                        downstream)
+                        : new IndexedIfExistsBiNode<>(shouldExist, indexerFactory,
                                 buildHelper.reserveTupleStoreIndex(parentAB.getTupleSource()),
                                 buildHelper.reserveTupleStoreIndex(parentAB.getTupleSource()),
                                 buildHelper.reserveTupleStoreIndex(parentAB.getTupleSource()),
                                 buildHelper.reserveTupleStoreIndex(parentBridgeC.getTupleSource()),
                                 buildHelper.reserveTupleStoreIndex(parentBridgeC.getTupleSource()),
                                 buildHelper.reserveTupleStoreIndex(parentBridgeC.getTupleSource()),
-                                downstream, indexerFactory.buildIndexer(true), indexerFactory.buildIndexer(false),
-                                filtering))
+                                downstream, filtering))
                 : (filtering == null ? new UnindexedIfExistsBiNode<>(shouldExist,
                         buildHelper.reserveTupleStoreIndex(parentAB.getTupleSource()),
                         buildHelper.reserveTupleStoreIndex(parentBridgeC.getTupleSource()), downstream)

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

@@ -56,17 +56,15 @@ public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> bui
         TupleLifecycle<BiTuple<A, B>> downstream = buildHelper.getAggregatedTupleLifecycle(childStreamList);
         IndexerFactory<B> indexerFactory = new IndexerFactory<>(joiner);
         var node = indexerFactory.hasJoiners()
-                ? new IndexedJoinBiNode<>(
-                        indexerFactory.buildUniLeftMapping(), indexerFactory.buildRightMapping(),
+                ? new IndexedJoinBiNode<>(indexerFactory,
                         buildHelper.reserveTupleStoreIndex(leftParent.getTupleSource()),
                         buildHelper.reserveTupleStoreIndex(leftParent.getTupleSource()),
                         buildHelper.reserveTupleStoreIndex(leftParent.getTupleSource()),
                         buildHelper.reserveTupleStoreIndex(rightParent.getTupleSource()),
                         buildHelper.reserveTupleStoreIndex(rightParent.getTupleSource()),
                         buildHelper.reserveTupleStoreIndex(rightParent.getTupleSource()),
                         downstream, filtering, outputStoreSize + 2,
-                        outputStoreSize, outputStoreSize + 1,
-                        indexerFactory.buildIndexer(true), indexerFactory.buildIndexer(false))
+                        outputStoreSize, outputStoreSize + 1)
                 : new UnindexedJoinBiNode<>(
                         buildHelper.reserveTupleStoreIndex(leftParent.getTupleSource()),
                         buildHelper.reserveTupleStoreIndex(leftParent.getTupleSource()),

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

@@ -1,56 +1,37 @@
 package ai.timefold.solver.core.impl.score.stream.bavet.bi;
 
-import java.util.function.BiFunction;
-import java.util.function.Function;
-
 import ai.timefold.solver.core.api.function.TriPredicate;
 import ai.timefold.solver.core.impl.score.stream.bavet.common.AbstractIndexedIfExistsNode;
-import ai.timefold.solver.core.impl.score.stream.bavet.common.ExistsCounter;
-import ai.timefold.solver.core.impl.score.stream.bavet.common.index.IndexProperties;
-import ai.timefold.solver.core.impl.score.stream.bavet.common.index.Indexer;
+import ai.timefold.solver.core.impl.score.stream.bavet.common.index.IndexerFactory;
 import ai.timefold.solver.core.impl.score.stream.bavet.common.tuple.BiTuple;
 import ai.timefold.solver.core.impl.score.stream.bavet.common.tuple.TupleLifecycle;
 import ai.timefold.solver.core.impl.score.stream.bavet.common.tuple.UniTuple;
 
 final class IndexedIfExistsBiNode<A, B, C> extends AbstractIndexedIfExistsNode<BiTuple<A, B>, C> {
 
-    private final BiFunction<A, B, IndexProperties> mappingAB;
     private final TriPredicate<A, B, C> filtering;
 
-    public IndexedIfExistsBiNode(boolean shouldExist,
-            BiFunction<A, B, IndexProperties> mappingAB, Function<C, IndexProperties> mappingC,
-            int inputStoreIndexLeftProperties, int inputStoreIndexLeftCounterEntry, int inputStoreIndexRightProperties,
-            int inputStoreIndexRightEntry,
-            TupleLifecycle<BiTuple<A, B>> nextNodesTupleLifecycle,
-            Indexer<ExistsCounter<BiTuple<A, B>>> indexerAB, Indexer<UniTuple<C>> indexerC) {
-        this(shouldExist, mappingAB, mappingC,
-                inputStoreIndexLeftProperties, inputStoreIndexLeftCounterEntry, -1, inputStoreIndexRightProperties,
-                inputStoreIndexRightEntry, -1,
-                nextNodesTupleLifecycle, indexerAB, indexerC,
-                null);
+    public IndexedIfExistsBiNode(boolean shouldExist, IndexerFactory<C> indexerFactory,
+            int inputStoreIndexLeftKeys, int inputStoreIndexLeftCounterEntry,
+            int inputStoreIndexRightKeys, int inputStoreIndexRightEntry,
+            TupleLifecycle<BiTuple<A, B>> nextNodesTupleLifecycle) {
+        this(shouldExist, indexerFactory,
+                inputStoreIndexLeftKeys, inputStoreIndexLeftCounterEntry, -1,
+                inputStoreIndexRightKeys, inputStoreIndexRightEntry, -1,
+                nextNodesTupleLifecycle, null);
     }
 
-    public IndexedIfExistsBiNode(boolean shouldExist,
-            BiFunction<A, B, IndexProperties> mappingAB, Function<C, IndexProperties> mappingC,
-            int inputStoreIndexLeftProperties, int inputStoreIndexLeftCounterEntry, int inputStoreIndexLeftTrackerList,
-            int inputStoreIndexRightProperties, int inputStoreIndexRightEntry, int inputStoreIndexRightTrackerList,
-            TupleLifecycle<BiTuple<A, B>> nextNodesTupleLifecycle,
-            Indexer<ExistsCounter<BiTuple<A, B>>> indexerAB, Indexer<UniTuple<C>> indexerC,
-            TriPredicate<A, B, C> filtering) {
-        super(shouldExist, mappingC,
-                inputStoreIndexLeftProperties, inputStoreIndexLeftCounterEntry, inputStoreIndexLeftTrackerList,
-                inputStoreIndexRightProperties, inputStoreIndexRightEntry, inputStoreIndexRightTrackerList,
-                nextNodesTupleLifecycle, indexerAB, indexerC,
-                filtering != null);
-        this.mappingAB = mappingAB;
+    public IndexedIfExistsBiNode(boolean shouldExist, IndexerFactory<C> indexerFactory,
+            int inputStoreIndexLeftKeys, int inputStoreIndexLeftCounterEntry, int inputStoreIndexLeftTrackerList,
+            int inputStoreIndexRightKeys, int inputStoreIndexRightEntry, int inputStoreIndexRightTrackerList,
+            TupleLifecycle<BiTuple<A, B>> nextNodesTupleLifecycle, TriPredicate<A, B, C> filtering) {
+        super(shouldExist, indexerFactory.buildBiLeftKeysExtractor(), indexerFactory,
+                inputStoreIndexLeftKeys, inputStoreIndexLeftCounterEntry, inputStoreIndexLeftTrackerList,
+                inputStoreIndexRightKeys, inputStoreIndexRightEntry, inputStoreIndexRightTrackerList,
+                nextNodesTupleLifecycle, filtering != null);
         this.filtering = filtering;
     }
 
-    @Override
-    protected IndexProperties createIndexProperties(BiTuple<A, B> leftTuple) {
-        return mappingAB.apply(leftTuple.factA, leftTuple.factB);
-    }
-
     @Override
     protected boolean testFiltering(BiTuple<A, B> leftTuple, UniTuple<C> rightTuple) {
         return filtering.test(leftTuple.factA, leftTuple.factB, rightTuple.factA);

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

@@ -1,45 +1,32 @@
 package ai.timefold.solver.core.impl.score.stream.bavet.bi;
 
 import java.util.function.BiPredicate;
-import java.util.function.Function;
 
 import ai.timefold.solver.core.impl.score.stream.bavet.common.AbstractIndexedJoinNode;
-import ai.timefold.solver.core.impl.score.stream.bavet.common.index.IndexProperties;
-import ai.timefold.solver.core.impl.score.stream.bavet.common.index.Indexer;
+import ai.timefold.solver.core.impl.score.stream.bavet.common.index.IndexerFactory;
 import ai.timefold.solver.core.impl.score.stream.bavet.common.tuple.BiTuple;
 import ai.timefold.solver.core.impl.score.stream.bavet.common.tuple.TupleLifecycle;
 import ai.timefold.solver.core.impl.score.stream.bavet.common.tuple.UniTuple;
 
 final class IndexedJoinBiNode<A, B> extends AbstractIndexedJoinNode<UniTuple<A>, B, BiTuple<A, B>> {
 
-    private final Function<A, IndexProperties> mappingA;
     private final BiPredicate<A, B> filtering;
     private final int outputStoreSize;
 
-    public IndexedJoinBiNode(Function<A, IndexProperties> mappingA, Function<B, IndexProperties> mappingB,
+    public IndexedJoinBiNode(IndexerFactory<B> indexerFactory,
             int inputStoreIndexA, int inputStoreIndexEntryA, int inputStoreIndexOutTupleListA,
             int inputStoreIndexB, int inputStoreIndexEntryB, int inputStoreIndexOutTupleListB,
             TupleLifecycle<BiTuple<A, B>> nextNodesTupleLifecycle, BiPredicate<A, B> filtering,
-            int outputStoreSize,
-            int outputStoreIndexOutEntryA, int outputStoreIndexOutEntryB,
-            Indexer<UniTuple<A>> indexerA,
-            Indexer<UniTuple<B>> indexerB) {
-        super(mappingB,
+            int outputStoreSize, int outputStoreIndexOutEntryA, int outputStoreIndexOutEntryB) {
+        super(indexerFactory.buildUniLeftKeysExtractor(), indexerFactory,
                 inputStoreIndexA, inputStoreIndexEntryA, inputStoreIndexOutTupleListA,
                 inputStoreIndexB, inputStoreIndexEntryB, inputStoreIndexOutTupleListB,
                 nextNodesTupleLifecycle, filtering != null,
-                outputStoreIndexOutEntryA, outputStoreIndexOutEntryB,
-                indexerA, indexerB);
-        this.mappingA = mappingA;
+                outputStoreIndexOutEntryA, outputStoreIndexOutEntryB);
         this.filtering = filtering;
         this.outputStoreSize = outputStoreSize;
     }
 
-    @Override
-    protected IndexProperties createIndexPropertiesLeft(UniTuple<A> leftTuple) {
-        return mappingA.apply(leftTuple.factA);
-    }
-
     @Override
     protected BiTuple<A, B> createOutTuple(UniTuple<A> leftTuple, UniTuple<B> rightTuple) {
         return new BiTuple<>(leftTuple.factA, rightTuple.factA, outputStoreSize);

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

@@ -52,7 +52,7 @@ protected void initCounterLeft(ExistsCounter<LeftTuple_> counter) {
 
     protected final void updateUnchangedCounterLeft(ExistsCounter<LeftTuple_> counter) {
         if (counter.state != TupleState.OK) {
-            // Counter state does not change because the index properties didn't change
+            // Counter state does not change because the index keys didn't change
             return;
         }
         // Still needed to propagate the update for downstream filters, matchWeighers, ...