Add missing graph.concurrentCopy in DegreeCentrality

Co-Authored-By: Max Kießling <[email protected]>

Author: breakanalysis

algo-common/src/main/java/org/neo4j/graphalgo/degree/DegreeCentrality.java renamed to alpha/alpha-algo/src/main/java/org/neo4j/graphalgo/centrality/degreecentrality/DegreeCentrality.java

@@ -17,10 +17,11 @@
  * 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.graphalgo.degree;
+package org.neo4j.graphalgo.centrality.degreecentrality;
 
 import org.neo4j.graphalgo.Algorithm;
 import org.neo4j.graphalgo.api.Graph;
+import org.neo4j.graphalgo.api.RelationshipIterator;
 import org.neo4j.graphalgo.core.concurrency.ParallelUtil;
 import org.neo4j.graphalgo.core.utils.paged.AllocationTracker;
 import org.neo4j.graphalgo.core.utils.paged.HugeDoubleArray;
@@ -66,9 +67,9 @@ public DegreeCentrality compute() {
         for (int i = 0; i < taskCount; i++) {
             starts[i] = startNode;
             if (weighted) {
-                tasks.add(new WeightedDegreeTask(starts[i], partitions[i]));
+                tasks.add(new WeightedDegreeTask(graph.concurrentCopy(), starts[i], partitions[i]));
             } else {
-                tasks.add(new DegreeTask(starts[i], partitions[i]));
+                tasks.add(new DegreeTask(graph, starts[i], partitions[i]));
             }
             startNode += batchSize;
         }
@@ -96,11 +97,13 @@ public CentralityResult result() {
     }
 
     private class DegreeTask implements Runnable {
+        private final Graph graph;
         private final long startNodeId;
         private final double[] partition;
         private final long endNodeId;
 
-        DegreeTask(long start, double[] partition) {
+        DegreeTask(Graph graph, long start, double[] partition) {
+            this.graph = graph;
             this.startNodeId = start;
             this.partition = partition;
             this.endNodeId = Math.min(start + partition.length, nodeCount);
@@ -116,11 +119,17 @@ public void run() {
     }
 
     private class WeightedDegreeTask implements Runnable {
+        private final RelationshipIterator relationshipIterator;
         private final long startNodeId;
         private final double[] partition;
         private final long endNodeId;
 
-        WeightedDegreeTask(long start, double[] partition) {
+        WeightedDegreeTask(
+            RelationshipIterator relationshipIterator,
+            long start,
+            double[] partition
+        ) {
+            this.relationshipIterator = relationshipIterator;
             this.startNodeId = start;
             this.partition = partition;
             this.endNodeId = Math.min(start + partition.length, nodeCount);
@@ -130,7 +139,7 @@ private class WeightedDegreeTask implements Runnable {
         public void run() {
             for (long nodeId = startNodeId; nodeId < endNodeId && running(); nodeId++) {
                 int index = Math.toIntExact(nodeId - startNodeId);
-                graph.forEachRelationship(nodeId, DEFAULT_WEIGHT, (sourceNodeId, targetNodeId, weight) -> {
+                relationshipIterator.forEachRelationship(nodeId, DEFAULT_WEIGHT, (sourceNodeId, targetNodeId, weight) -> {
                     if (weight > 0) {
                         partition[index] += weight;
                     }

algo-common/src/test/java/org/neo4j/graphalgo/degree/DegreeCentralityTest.java renamed to alpha/alpha-algo/src/test/java/org/neo4j/graphalgo/impl/degreecentrality/DegreeCentralityTest.java

@@ -17,23 +17,33 @@
  * 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.graphalgo.degree;
+package org.neo4j.graphalgo.impl.degreecentrality;
 
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.neo4j.graphalgo.AlgoTestBase;
 import org.neo4j.graphalgo.Orientation;
 import org.neo4j.graphalgo.StoreLoaderBuilder;
+import org.neo4j.graphalgo.beta.generator.RandomGraphGenerator;
+import org.neo4j.graphalgo.beta.generator.RelationshipDistribution;
+import org.neo4j.graphalgo.beta.generator.RelationshipPropertyProducer;
+import org.neo4j.graphalgo.centrality.degreecentrality.DegreeCentrality;
+import org.neo4j.graphalgo.config.RandomGraphGeneratorConfig;
 import org.neo4j.graphalgo.core.Aggregation;
 import org.neo4j.graphalgo.core.concurrency.Pools;
+import org.neo4j.graphalgo.core.huge.HugeGraph;
 import org.neo4j.graphalgo.core.utils.paged.AllocationTracker;
+import org.neo4j.graphalgo.core.utils.paged.HugeDoubleArray;
+import org.neo4j.graphalgo.result.CentralityResult;
 import org.neo4j.graphdb.Label;
 
 import java.util.HashMap;
 import java.util.Map;
+import java.util.Optional;
 import java.util.stream.IntStream;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.neo4j.graphalgo.compat.GraphDatabaseApiProxy.runInTransaction;
 
 final class DegreeCentralityTest extends AlgoTestBase {
@@ -104,6 +114,42 @@ void setupGraphDb() {
         runQuery(DB_CYPHER);
     }
 
+    @Test
+    void shouldRunConcurrently() {
+        int nodeCount = 20002;
+        int averageDegree = 2;
+        HugeGraph graph = new RandomGraphGenerator(
+            nodeCount,
+            averageDegree,
+            RelationshipDistribution.POWER_LAW,
+            0L,
+            Optional.of(RelationshipPropertyProducer.random("similarity", 0, 1)),
+            Aggregation.NONE,
+            Orientation.NATURAL,
+            RandomGraphGeneratorConfig.AllowSelfLoops.NO,
+            AllocationTracker.EMPTY
+        ).generate();
+
+        DegreeCentrality degreeCentrality = new DegreeCentrality(
+            graph,
+            Pools.DEFAULT,
+            2,
+            true,
+            AllocationTracker.EMPTY
+        );
+
+        DegreeCentrality centrality = degreeCentrality.compute();
+        HugeDoubleArray centralityResult = centrality.result().array();
+
+        double sum = 0;
+        for (double v : centralityResult.toArray()) {
+            sum += v;
+        }
+
+        double expected = nodeCount * averageDegree * 0.5;
+        assertEquals(expected, sum, expected * 0.1);
+    }
+
     @Test
     void outgoingCentrality() {
         final Label label = Label.label("Label1");

alpha/alpha-proc/src/main/java/org/neo4j/graphalgo/centrality/DegreeCentralityProc.java

@@ -27,7 +27,7 @@
 import org.neo4j.graphalgo.core.CypherMapWrapper;
 import org.neo4j.graphalgo.core.concurrency.Pools;
 import org.neo4j.graphalgo.core.utils.paged.AllocationTracker;
-import org.neo4j.graphalgo.degree.DegreeCentrality;
+import org.neo4j.graphalgo.centrality.degreecentrality.DegreeCentrality;
 import org.neo4j.graphalgo.result.AbstractResultBuilder;
 import org.neo4j.graphalgo.results.CentralityScore;
 import org.neo4j.logging.Log;