Extend testing for the new pruning parameter.

Author: IoannisPanagiotas

algo/src/main/java/org/neo4j/gds/steiner/ShortestPathsSteinerAlgorithm.java

@@ -49,6 +49,8 @@ public class ShortestPathsSteinerAlgorithm extends Algorithm<SteinerTreeResult>
     private final double delta;
     private final ExecutorService executorService;
 
+    private int binSizeThreshold;
+
 
     public ShortestPathsSteinerAlgorithm(
         Graph graph,
@@ -70,6 +72,28 @@ public ShortestPathsSteinerAlgorithm(
         this.executorService = executorService;
     }
 
+     ShortestPathsSteinerAlgorithm(
+         Graph graph,
+         long sourceId,
+         List<Long> terminals,
+         double delta,
+         int concurrency,
+         boolean applyRerouting,
+         int binSizeThreshold,
+         ExecutorService executorService
+     ) {
+         super(ProgressTracker.NULL_TRACKER);
+        this.graph = graph;
+        this.sourceId = sourceId;
+        this.terminals = terminals;
+        this.concurrency = concurrency;
+        this.delta = delta;
+        this.isTerminal = createTerminals();
+        this.applyRerouting = applyRerouting;
+        this.executorService = executorService;
+        this.binSizeThreshold = binSizeThreshold;
+    }
+
     private BitSet createTerminals() {
         long maxTerminalId = -1;
         for (long terminalId : terminals) {
@@ -168,6 +192,7 @@ private DijkstraResult runShortestPaths() {
             delta,
             isTerminal,
             concurrency,
+            binSizeThreshold,
             executorService,
             ProgressTracker.NULL_TRACKER
         );

algo/src/main/java/org/neo4j/gds/steiner/SteinerBasedDeltaStepping.java

@@ -72,13 +72,15 @@ public final class SteinerBasedDeltaStepping extends Algorithm<DijkstraResult> {
     private final BitSet unvisitedTerminal;
     private final BitSet mergedWithSource;
     private final LongAdder metTerminals;
+    private int binSizeThreshold;
 
     SteinerBasedDeltaStepping(
         Graph graph,
         long startNode,
         double delta,
         BitSet isTerminal,
         int concurrency,
+        int binSizeThreshold,
         ExecutorService executorService,
         ProgressTracker progressTracker
     ) {
@@ -99,7 +101,7 @@ public final class SteinerBasedDeltaStepping extends Algorithm<DijkstraResult> {
         this.pathIndex = 0;
         this.metTerminals = new LongAdder();
         this.numOfTerminals = isTerminal.cardinality();
-
+        this.binSizeThreshold = binSizeThreshold;
     }
 
     private void mergeNodesOnPathToSource(long nodeId, AtomicLong frontierIndex) {
@@ -198,7 +200,6 @@ private boolean ensureShortest(
                 .min()
                 .orElseThrow();
             //return true if the closet terminal is at least as close as the  closest next node
-            System.out.println("hi" + distance + " " + currentMinDistance + " " + (distance <= currentMinDistance) + " " + oldBin + " " + currentBin);
             return distance <= currentMinDistance;
         } else {
             return (distance < currentBin * delta);
@@ -286,7 +287,8 @@ public DijkstraResult compute() {
                 mergedWithSource,
                 terminalQueue,
                 terminalQueueLock,
-                unvisitedTerminal
+                unvisitedTerminal,
+                binSizeThreshold
             ))
             .collect(Collectors.toList());
 

algo/src/main/java/org/neo4j/gds/steiner/SteinerBasedDeltaTask.java

@@ -32,7 +32,6 @@
 import java.util.concurrent.atomic.AtomicLong;
 import java.util.concurrent.locks.ReentrantLock;
 
-import static org.neo4j.gds.steiner.SteinerBasedDeltaStepping.BIN_SIZE_THRESHOLD;
 import static org.neo4j.gds.steiner.SteinerBasedDeltaStepping.NO_BIN;
 
 class SteinerBasedDeltaTask implements Runnable {
@@ -49,8 +48,8 @@ class SteinerBasedDeltaTask implements Runnable {
     private final BitSet uninvisitedTerminal;
     private final HugeLongPriorityQueue terminalQueue;
     private final ReentrantLock terminalQueueLock;
-
     private double smallestConsideredDistance;
+    private int binSizeThreshold;
 
     SteinerBasedDeltaTask(
         Graph graph,
@@ -61,7 +60,8 @@ class SteinerBasedDeltaTask implements Runnable {
         BitSet mergedToSource,
         HugeLongPriorityQueue terminalQueue,
         ReentrantLock terminalQueueLock,
-        BitSet uninvisitedTerminal
+        BitSet uninvisitedTerminal,
+        int binSizeThreshold
     ) {
 
         this.graph = graph;
@@ -74,6 +74,7 @@ class SteinerBasedDeltaTask implements Runnable {
         this.terminalQueue = terminalQueue;
         this.terminalQueueLock = terminalQueueLock;
         this.uninvisitedTerminal = uninvisitedTerminal;
+        this.binSizeThreshold = binSizeThreshold;
     }
 
     @Override
@@ -128,7 +129,7 @@ private void relaxLocalBin() {
         while (binIndex < localBins.length
                && localBins[binIndex] != null
                && !localBins[binIndex].isEmpty()
-               && localBins[binIndex].size() < BIN_SIZE_THRESHOLD) {
+               && localBins[binIndex].size() < binSizeThreshold) {
             var binCopy = localBins[binIndex].clone();
             localBins[binIndex].elementsCount = 0;
             binCopy.forEach((LongProcedure) this::relaxNode);

algo/src/test/java/org/neo4j/gds/steiner/ShortestPathSteinerAlgorithmExtendedTest.java

@@ -22,7 +22,8 @@
 import com.carrotsearch.hppc.BitSet;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.ValueSource;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
 import org.neo4j.gds.Orientation;
 import org.neo4j.gds.core.concurrency.Pools;
 import org.neo4j.gds.core.utils.progress.tasks.ProgressTracker;
@@ -34,8 +35,10 @@
 import org.neo4j.gds.paths.PathResult;
 
 import java.util.List;
+import java.util.stream.Stream;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.params.provider.Arguments.arguments;
 
 @GdlExtension
 class ShortestPathSteinerAlgorithmExtendedTest {
@@ -140,12 +143,18 @@ class ShortestPathSteinerAlgorithmExtendedTest {
     @Inject
     private IdFunction triangleIdFunction;
 
+    static Stream<Arguments> inputTuples() {
+        return Stream.of(
+
+            arguments(2.0, SteinerBasedDeltaStepping.BIN_SIZE_THRESHOLD), //default settings
+            arguments(5.0, 0), //values in two buckets, can deduce lowest shortest without changing bucket
+            arguments(100, 0) //everything in a single bucket, can likewise
+        );
+    }
+    
     @ParameterizedTest
-    @ValueSource(doubles = {2.0, 5.0, 100.0})
-        //2.0 is the standard one we use everything
-        //5.0 is one such that we can deduce a2 is best without changing bucket
-        //100.0 is a big one where everything takes place inside a single bucket
-    void shouldWorkCorrectly(double delta) {
+    @MethodSource("inputTuples")
+    void shouldWorkCorrectly(double delta, int binSizeThreshold) {
 
         var a = SteinerTestUtils.getNodes(idFunction, 6);
         var steinerTreeResult = new ShortestPathsSteinerAlgorithm(
@@ -155,6 +164,8 @@ void shouldWorkCorrectly(double delta) {
             delta,
             1,
             false,
+            binSizeThreshold,
+            //setting custom threshold for such a small graph allows to not examine everything in a single iteration
             Pools.DEFAULT
         ).compute();
 
@@ -198,6 +209,7 @@ void deltaSteppingShouldWorkCorrectly() {
             2.0,
             isTerminal,
             1,
+            SteinerBasedDeltaStepping.BIN_SIZE_THRESHOLD,
             Pools.DEFAULT,
             ProgressTracker.NULL_TRACKER
         );