Merge pull request #10837 from IoannisPanagiotas/msbfs-refactoring

Msbfs refactoring

Author: IoannisPanagiotas

algo/src/main/java/org/neo4j/gds/msbfs/EmptySourceNodesSpec.java

@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) "Neo4j"
+ * Neo4j Sweden AB [http://neo4j.com]
+ *
+ * This file is part of Neo4j.
+ *
+ * Neo4j is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.neo4j.gds.msbfs;
+
+import org.neo4j.gds.collections.ha.HugeLongArray;
+
+public class EmptySourceNodesSpec implements SourceNodesSpec{
+
+    private final int localNodeCount;
+    private final long nodeOffset;
+
+    public EmptySourceNodesSpec(long nodeOffset, int localNodeCount) {
+        this.localNodeCount = localNodeCount;
+        this.nodeOffset = nodeOffset;
+    }
+
+    @Override
+    public SourceNodes setUp(HugeLongArray visitSet, HugeLongArray seenSet, boolean allowStartNodeTraversal) {
+
+        for (int i = 0; i < localNodeCount; ++i) {
+            long currentNode = nodeOffset + i;
+
+            if (!allowStartNodeTraversal) {
+                seenSet.set(currentNode, 1L << i);
+            }
+
+            visitSet.or(currentNode, 1L << i);
+        }
+
+        return new SourceNodes(nodeOffset, localNodeCount);
+    }
+
+    @Override
+    public long[] nodes() {
+        var array = new long[localNodeCount];
+        for (int i=0; i<localNodeCount;++i){
+            long currentNode = nodeOffset + i;
+            array[i] = currentNode;
+        }
+        return array;
+    }
+
+}

algo/src/main/java/org/neo4j/gds/msbfs/ListSourceNodesSpec.java

@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) "Neo4j"
+ * Neo4j Sweden AB [http://neo4j.com]
+ *
+ * This file is part of Neo4j.
+ *
+ * Neo4j is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.neo4j.gds.msbfs;
+
+import org.neo4j.gds.collections.ha.HugeLongArray;
+
+ public class ListSourceNodesSpec implements SourceNodesSpec{
+
+    private final long[] sourceNodes;
+    private final int from;
+    private final int to;
+
+     public ListSourceNodesSpec(long[] sourceNodes, int from, int length) {
+        this.sourceNodes = sourceNodes;
+        this.from = from;
+        this.to = Math.min(from + length, sourceNodes.length);
+    }
+
+    @Override
+    public SourceNodes setUp(HugeLongArray visitSet, HugeLongArray seenSet, boolean allowStartNodeTraversal) {
+
+        for (int i = from; i < to; ++i) {
+            int adaptedI = i-from;
+            long nodeId = sourceNodes[i];
+            if (!allowStartNodeTraversal) {
+                seenSet.set(nodeId, 1L << adaptedI);
+            }
+            visitSet.or(nodeId, 1L << adaptedI);
+        }
+
+        return new SourceNodes(nodes());
+    }
+
+     @Override
+     public long[] nodes() {
+         var array = new long[to-from];
+         System.arraycopy(sourceNodes, from, array, 0, to - from);
+         return array;
+     }
+
+ }

algo/src/main/java/org/neo4j/gds/msbfs/MultiSourceBFSAccessMethods.java

@@ -78,13 +78,8 @@ public final class MultiSourceBFSAccessMethods {
     private final boolean allowStartNodeTraversal;
     private final long @Nullable [] sourceNodes;
 
-    // hypothesis: you supply actual source nodes, or you provide a count - if so that should be rationalised
-    private final int sourceNodeCount;
-    private final long nodeOffset;
-
     private final TerminationFlag terminationFlag;
 
-
     public static MultiSourceBFSAccessMethods aggregatedNeighborProcessing(
         long nodeCount,
         RelationshipIterator relationships,
@@ -157,8 +152,6 @@ private static MultiSourceBFSAccessMethods createMultiSourceBFS(
             strategy,
             spec.allowStartNodeTraversal(),
             sourceNodes,
-            0,
-            0,
             terminationFlag
         );
 
@@ -177,8 +170,6 @@ private MultiSourceBFSAccessMethods(
         ExecutionStrategy strategy,
         boolean allowStartNodeTraversal,
         long @Nullable [] sourceNodes,
-        int sourceNodeCount,
-        long nodeOffset,
         TerminationFlag terminationFlag
     ) {
         this.visits = visits;
@@ -190,8 +181,6 @@ private MultiSourceBFSAccessMethods(
         this.strategy = strategy;
         this.allowStartNodeTraversal = allowStartNodeTraversal;
         this.sourceNodes = sourceNodes;
-        this.sourceNodeCount = sourceNodeCount;
-        this.nodeOffset = nodeOffset;
         this.terminationFlag = terminationFlag;
     }
 
@@ -213,14 +202,9 @@ public void run(Concurrency concurrency, ExecutorService executor) {
     }
 
     private long sourceLength() {
-        if (sourceNodes != null) {
-            return sourceNodes.length;
-        }
-        if (sourceNodeCount == 0) {
-            return nodeCount;
-        }
-        return sourceNodeCount;
-    }
+        if (sourceNodes == null || sourceNodes.length==0) return  nodeCount;
+        return sourceNodes.length;
+     }
 
     private int numberOfThreads() {
         long sourceLength = sourceLength();
@@ -233,30 +217,8 @@ private int numberOfThreads() {
 
     // lazily creates MS-BFS instances for OMEGA sized source chunks
     private Collection<MultiSourceBFSRunnable> allSourceBfss(int threads) {
-        if (sourceNodes == null) {
-            long sourceLength = nodeCount;
-            return new ParallelMultiSources(threads, sourceLength) {
-                @Override
-                MultiSourceBFSRunnable next(final long from, final int length) {
-                    return new MultiSourceBFSRunnable(
-                        visits,
-                        visitsNext,
-                        seens,
-                        seensNext,
-                        sourceLength,
-                        relationships.concurrentCopy(),
-                        strategy,
-                        allowStartNodeTraversal,
-                        null,
-                        length,
-                        from
-                    );
-                }
-            };
-        }
-        long[] sourceNodes = this.sourceNodes;
-        int sourceLength = sourceNodes.length;
-        return new ParallelMultiSources(threads, sourceLength) {
+        var producer = SourceNodeSpecFactory.createProducer(sourceNodes);
+        return new ParallelMultiSources(threads, sourceLength()) {
             @Override
             MultiSourceBFSRunnable next(final long from, final int length) {
                 return new MultiSourceBFSRunnable(
@@ -268,25 +230,10 @@ MultiSourceBFSRunnable next(final long from, final int length) {
                     relationships.concurrentCopy(),
                     strategy,
                     allowStartNodeTraversal,
-                    Arrays.copyOfRange(sourceNodes, (int) from, (int) (from + length)),
-                    0,
-                    0
+                    producer.create(from,length)
                 );
             }
         };
     }
 
-    @Override
-    public String toString() {
-        if (sourceNodes != null && sourceNodes.length > 0) {
-            return "MSBFS{" + sourceNodes[0] +
-                " .. " + (sourceNodes[sourceNodes.length - 1] + 1) +
-                " (" + sourceNodes.length +
-                ")}";
-        }
-        return "MSBFS{" + nodeOffset +
-            " .. " + (nodeOffset + sourceNodeCount) +
-            " (" + sourceNodeCount +
-            ")}";
-    }
 }

algo/src/main/java/org/neo4j/gds/msbfs/MultiSourceBFSRunnable.java

@@ -65,19 +65,14 @@ public final class MultiSourceBFSRunnable implements Runnable {
     private final RelationshipIterator relationships;
     private final ExecutionStrategy strategy;
     private final boolean allowStartNodeTraversal;
-    private final long @Nullable [] sourceNodes;
-
-    // hypothesis: you supply actual source nodes, or you provide a count - if so that should be rationalised
-    private final int sourceNodeCount;
-    private final long nodeOffset;
+    private final SourceNodesSpec sourceNodesSpec;
 
     public static MultiSourceBFSRunnable createWithoutSeensNext(
         long nodeCount,
         RelationshipIterator relationships,
         ExecutionStrategy strategy,
         boolean allowStartNodeTraversal,
-        int sourceNodeCount,
-        long nodeOffset
+        SourceNodesSpec sourceNodesSpec
     ) {
         var visits = new LocalHugeLongArray(nodeCount);
         var visitsNext = new LocalHugeLongArray(nodeCount);
@@ -92,9 +87,7 @@ public static MultiSourceBFSRunnable createWithoutSeensNext(
             relationships,
             strategy,
             allowStartNodeTraversal,
-            null,
-            sourceNodeCount,
-            nodeOffset
+            sourceNodesSpec
         );
     }
 
@@ -110,9 +103,7 @@ public static MultiSourceBFSRunnable createWithoutSeensNext(
         RelationshipIterator relationships,
         ExecutionStrategy strategy,
         boolean allowStartNodeTraversal,
-        long @Nullable [] sourceNodes,
-        int sourceNodeCount,
-        long nodeOffset
+        SourceNodesSpec sourceNodesSpec
     ) {
 
         this.visits = visits;
@@ -123,9 +114,7 @@ public static MultiSourceBFSRunnable createWithoutSeensNext(
         this.relationships = relationships;
         this.strategy = strategy;
         this.allowStartNodeTraversal = allowStartNodeTraversal;
-        this.sourceNodes = sourceNodes;
-        this.sourceNodeCount = sourceNodeCount;
-        this.nodeOffset = nodeOffset;
+        this.sourceNodesSpec = sourceNodesSpec;
     }
 
     /**
@@ -138,62 +127,11 @@ public void run() {
         var seenSet = seens.get();
         var seenNextSet = seensNext != null ? seensNext.get() : null;
 
-        SourceNodes sourceNodes = this.sourceNodes == null
-            ? prepareOffsetSources(visitSet, seenSet, allowStartNodeTraversal)
-            : prepareSpecifiedSources(visitSet, seenSet, this.sourceNodes, allowStartNodeTraversal);
-
-        strategy.run(relationships, nodeCount, sourceNodes, visitSet, visitNextSet, seenSet, seenNextSet);
-    }
-
-    private SourceNodes prepareOffsetSources(
-        HugeLongArray visitSet,
-        HugeLongArray seenSet,
-        boolean allowStartNodeTraversal
-    ) {
-        var localNodeCount = this.sourceNodeCount;
-        var nodeOffset = this.nodeOffset;
-
-        for (int i = 0; i < localNodeCount; ++i) {
-            long currentNode = nodeOffset + i;
 
-            if (!allowStartNodeTraversal) {
-                seenSet.set(currentNode, 1L << i);
-            }
-            
-            visitSet.or(currentNode, 1L << i);
-        }
+        var sourceNodes  = sourceNodesSpec.setUp(visitSet,seenSet,allowStartNodeTraversal);
 
-        return new SourceNodes(nodeOffset, localNodeCount);
+        strategy.run(relationships, nodeCount, sourceNodes, visitSet, visitNextSet, seenSet, seenNextSet);
     }
 
-    private static SourceNodes prepareSpecifiedSources(
-        HugeLongArray visitSet,
-        HugeLongArray seenSet,
-        long[] sourceNodes,
-        boolean allowStartNodeTraversal
-    ) {
-        for (int i = 0; i < sourceNodes.length; ++i) {
-            long nodeId = sourceNodes[i];
-            if (!allowStartNodeTraversal) {
-                seenSet.set(nodeId, 1L << i);
-            }
-            visitSet.or(nodeId, 1L << i);
-        }
 
-        return new SourceNodes(sourceNodes);
-    }
-
-    @Override
-    public String toString() {
-        if (sourceNodes != null && sourceNodes.length > 0) {
-            return "MSBFS{" + sourceNodes[0] +
-                   " .. " + (sourceNodes[sourceNodes.length - 1] + 1) +
-                   " (" + sourceNodes.length +
-                   ")}";
-        }
-        return "MSBFS{" + nodeOffset +
-               " .. " + (nodeOffset + sourceNodeCount) +
-               " (" + sourceNodeCount +
-               ")}";
-    }
 }

algo/src/main/java/org/neo4j/gds/msbfs/SourceNodeSpecFactory.java

@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) "Neo4j"
+ * Neo4j Sweden AB [http://neo4j.com]
+ *
+ * This file is part of Neo4j.
+ *
+ * Neo4j is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.neo4j.gds.msbfs;
+
+import org.jetbrains.annotations.Nullable;
+
+public  final class SourceNodeSpecFactory {
+
+    private SourceNodeSpecFactory() {}
+
+    static SourceNodesSpecProducer createProducer(@Nullable long  [] sourceNodes){
+
+        if (sourceNodes == null || sourceNodes.length == 0){
+            return EmptySourceNodesSpec::new;
+        }else{
+            return  (from,length) -> new ListSourceNodesSpec(sourceNodes,(int)from, length);
+        }
+
+    }
+
+}