Merge pull request #10744 from brs96/harmonic-centrality-mem-est

brs96 · web-flow · commit 3b02a0b43969 · 2025-06-05T10:19:40.000+01:00
Harmonic centrality mem est
diff --git a/algo/src/main/java/org/neo4j/gds/harmonic/HarmonicCentralityAlgorithmEstimateDefinition.java b/algo/src/main/java/org/neo4j/gds/harmonic/HarmonicCentralityAlgorithmEstimateDefinition.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.harmonic;
+
+import org.neo4j.gds.mem.MemoryEstimateDefinition;
+import org.neo4j.gds.collections.haa.HugeAtomicDoubleArray;
+import org.neo4j.gds.mem.MemoryEstimation;
+import org.neo4j.gds.mem.MemoryEstimations;
+import org.neo4j.gds.msbfs.MSBFSMemoryEstimation;
+
+public final class HarmonicCentralityAlgorithmEstimateDefinition implements MemoryEstimateDefinition {
+
+    @Override
+    public MemoryEstimation memoryEstimation() {
+        return MemoryEstimations.builder(HarmonicCentrality.class)
+            .perNode("inverse farness", HugeAtomicDoubleArray::memoryEstimation)
+            .add("MSBFS", MSBFSMemoryEstimation.MSBFSWithANPStrategy())
+            .build();
+    }
+
+}
diff --git a/algo/src/main/java/org/neo4j/gds/msbfs/MSBFSMemoryEstimation.java b/algo/src/main/java/org/neo4j/gds/msbfs/MSBFSMemoryEstimation.java
@@ -35,12 +35,12 @@ private static MemoryEstimations.Builder MSBFS(){
             .perThread("seens", HugeLongArray::memoryEstimation);
     }
 
-    static MemoryEstimation MSBFSWithPredecessorStrategy(){
+    public static MemoryEstimation MSBFSWithPredecessorStrategy(){
         return MSBFS()
             .perThread("seenNext", HugeLongArray::memoryEstimation)
             .build();
     }
-    static MemoryEstimation MSBFSWithANPStrategy(){
+    public static MemoryEstimation MSBFSWithANPStrategy(){
         return MSBFS()
             .build();
     }
diff --git a/algo/src/test/java/org/neo4j/gds/harmonic/HarmonicCentralityAlgorithmEstimateDefinitionTest.java b/algo/src/test/java/org/neo4j/gds/harmonic/HarmonicCentralityAlgorithmEstimateDefinitionTest.java
@@ -0,0 +1,45 @@
+/*
+ * 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.harmonic;
+
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.CsvSource;
+import org.neo4j.gds.core.concurrency.Concurrency;
+
+import static org.neo4j.gds.assertions.MemoryEstimationAssert.assertThat;
+
+class HarmonicCentralityAlgorithmEstimateDefinitionTest {
+
+    @ParameterizedTest
+    @CsvSource({
+        "10_000, 1, 80304",
+        "10_000, 4, 80376",
+        "500_000, 4, 4000376", 
+        "10_000_000, 4, 80000376",
+        "10_000, 2, 80328", 
+        "10_000, 128, 83352"
+    })
+    void testMemoryEstimation(long nodeCount, int concurrency, long expectedMemory) {
+        var memoryEstimation = new HarmonicCentralityAlgorithmEstimateDefinition().memoryEstimation();
+        assertThat(memoryEstimation)
+            .memoryRange(nodeCount, new Concurrency(concurrency))
+            .hasSameMinAndMaxEqualTo(expectedMemory);
+    }
+}
diff --git a/applications/algorithms/centrality/src/main/java/org/neo4j/gds/applications/algorithms/centrality/CentralityAlgorithmsEstimationModeBusinessFacade.java b/applications/algorithms/centrality/src/main/java/org/neo4j/gds/applications/algorithms/centrality/CentralityAlgorithmsEstimationModeBusinessFacade.java
@@ -40,6 +40,8 @@
 import org.neo4j.gds.mem.MemoryEstimation;
 import org.neo4j.gds.pagerank.PageRankMemoryEstimateDefinition;
 import org.neo4j.gds.pagerank.RankConfig;
+import org.neo4j.gds.harmonic.HarmonicCentralityAlgorithmEstimateDefinition;
+import org.neo4j.gds.harmonic.HarmonicCentralityBaseConfig;
 
 public class CentralityAlgorithmsEstimationModeBusinessFacade {
     private final AlgorithmEstimationTemplate algorithmEstimationTemplate;
@@ -133,7 +135,20 @@ public MemoryEstimateResult degreeCentrality(
     }
 
     public MemoryEstimation harmonicCentrality() {
-        throw new MemoryEstimationNotImplementedException();
+        return new HarmonicCentralityAlgorithmEstimateDefinition().memoryEstimation();
+    }
+
+    public MemoryEstimateResult harmonicCentrality(
+        HarmonicCentralityBaseConfig configuration,
+        Object graphNameOrConfiguration
+    ) {
+        var memoryEstimation = harmonicCentrality();
+
+        return algorithmEstimationTemplate.estimate(
+            configuration,
+            graphNameOrConfiguration,
+            memoryEstimation
+        );
     }
 
     public MemoryEstimation pageRank() {
diff --git a/doc/modules/ROOT/pages/operations-reference/algorithm-references.adoc b/doc/modules/ROOT/pages/operations-reference/algorithm-references.adoc
@@ -404,11 +404,15 @@
 .1+<.^|xref:algorithms/all-pairs-shortest-path.adoc[All Shortest Paths]
 | `gds.allShortestPaths.stream` label:procedure[Procedure]
 | xref:alpha-algorithms/common-neighbors.adoc[Common Neighbors] | `gds.alpha.linkprediction.commonNeighbors` label:function[Function]
-.4+<.^|xref:algorithms/harmonic-centrality.adoc[Harmonic Centrality]
+.8+<.^|xref:algorithms/harmonic-centrality.adoc[Harmonic Centrality]
 | `gds.closeness.harmonic.mutate` label:procedure[Procedure]
+| `gds.closeness.harmonic.mutate.estimate` label:procedure[Procedure]
 | `gds.closeness.harmonic.stats` label:procedure[Procedure]
+| `gds.closeness.harmonic.stats.estimate` label:procedure[Procedure]
 | `gds.closeness.harmonic.stream` label:procedure[Procedure]
+| `gds.closeness.harmonic.stream.estimate` label:procedure[Procedure]
 | `gds.closeness.harmonic.write` label:procedure[Procedure]
+| `gds.closeness.harmonic.write.estimate` label:procedure[Procedure]
 .8+<.^|xref:algorithms/hits.adoc[HITS]
 | `gds.hits.mutate` label:procedure[Procedure]
 | `gds.hits.mutate.estimate` label:procedure[Procedure]
diff --git a/open-packaging/src/test/java/org/neo4j/gds/OpenGdsProcedureSmokeTest.java b/open-packaging/src/test/java/org/neo4j/gds/OpenGdsProcedureSmokeTest.java
@@ -80,9 +80,13 @@ class OpenGdsProcedureSmokeTest extends BaseProcTest {
         "gds.conductance.stream",
 
         "gds.closeness.harmonic.mutate",
+        "gds.closeness.harmonic.mutate.estimate",
         "gds.closeness.harmonic.stats",
+        "gds.closeness.harmonic.stats.estimate",
         "gds.closeness.harmonic.stream",
+        "gds.closeness.harmonic.stream.estimate",
         "gds.closeness.harmonic.write",
+        "gds.closeness.harmonic.write.estimate",
 
         "gds.closeness.mutate",
         "gds.closeness.stats",
@@ -611,7 +615,7 @@ void countShouldMatch() {
         );
 
         // If you find yourself updating this count, please also update the count in SmokeTest.kt
-        int expectedCount = 451;
+        int expectedCount = 455;
         assertEquals(
             expectedCount,
             returnedRows,
diff --git a/proc/centrality/src/main/java/org/neo4j/gds/harmonic/HarmonicCentralityMutateProc.java b/proc/centrality/src/main/java/org/neo4j/gds/harmonic/HarmonicCentralityMutateProc.java
@@ -21,6 +21,7 @@
 
 import org.neo4j.gds.procedures.GraphDataScienceProcedures;
 import org.neo4j.gds.procedures.algorithms.centrality.CentralityMutateResult;
+import org.neo4j.gds.applications.algorithms.machinery.MemoryEstimateResult;
 import org.neo4j.procedure.Context;
 import org.neo4j.procedure.Description;
 import org.neo4j.procedure.Name;
@@ -30,6 +31,7 @@
 import java.util.stream.Stream;
 
 import static org.neo4j.gds.harmonic.Constants.HARMONIC_CENTRALITY_DESCRIPTION;
+import static org.neo4j.gds.procedures.ProcedureConstants.MEMORY_ESTIMATION_DESCRIPTION;
 import static org.neo4j.procedure.Mode.READ;
 
 public class HarmonicCentralityMutateProc {
@@ -44,4 +46,13 @@ public Stream<CentralityMutateResult> mutate(
     ) {
         return facade.algorithms().centrality().harmonicCentralityMutate(graphName, configuration);
     }
+
+    @Procedure(name = "gds.closeness.harmonic.mutate.estimate", mode = READ)
+    @Description(MEMORY_ESTIMATION_DESCRIPTION)
+    public Stream<MemoryEstimateResult> estimate(
+        @Name(value = "graphNameOrConfiguration") Object graphNameOrConfiguration,
+        @Name(value = "algoConfiguration") Map<String, Object> algoConfiguration
+    ) {
+        return facade.algorithms().centrality().harmonicCentralityMutateEstimate(graphNameOrConfiguration, algoConfiguration);
+    }
 }
diff --git a/proc/centrality/src/main/java/org/neo4j/gds/harmonic/HarmonicCentralityStatsProc.java b/proc/centrality/src/main/java/org/neo4j/gds/harmonic/HarmonicCentralityStatsProc.java
@@ -21,6 +21,7 @@
 
 import org.neo4j.gds.procedures.GraphDataScienceProcedures;
 import org.neo4j.gds.procedures.algorithms.centrality.CentralityStatsResult;
+import org.neo4j.gds.applications.algorithms.machinery.MemoryEstimateResult;
 import org.neo4j.procedure.Context;
 import org.neo4j.procedure.Description;
 import org.neo4j.procedure.Name;
@@ -30,6 +31,7 @@
 import java.util.stream.Stream;
 
 import static org.neo4j.gds.harmonic.Constants.HARMONIC_CENTRALITY_DESCRIPTION;
+import static org.neo4j.gds.procedures.ProcedureConstants.MEMORY_ESTIMATION_DESCRIPTION;
 import static org.neo4j.procedure.Mode.READ;
 
 public class HarmonicCentralityStatsProc {
@@ -44,4 +46,13 @@ public Stream<CentralityStatsResult> stats(
     ) {
         return facade.algorithms().centrality().harmonicCentralityStats(graphName, configuration);
     }
+
+    @Procedure(name = "gds.closeness.harmonic.stats.estimate", mode = READ)
+    @Description(MEMORY_ESTIMATION_DESCRIPTION)
+    public Stream<MemoryEstimateResult> estimate(
+        @Name(value = "graphNameOrConfiguration") Object graphNameOrConfiguration,
+        @Name(value = "algoConfiguration") Map<String, Object> algoConfiguration
+    ) {
+        return facade.algorithms().centrality().harmonicCentralityStatsEstimate(graphNameOrConfiguration, algoConfiguration);
+    }
 }
diff --git a/proc/centrality/src/main/java/org/neo4j/gds/harmonic/HarmonicCentralityStreamProc.java b/proc/centrality/src/main/java/org/neo4j/gds/harmonic/HarmonicCentralityStreamProc.java
@@ -22,6 +22,7 @@
 import org.neo4j.gds.procedures.GraphDataScienceProcedures;
 import org.neo4j.gds.procedures.algorithms.centrality.AlphaHarmonicStreamResult;
 import org.neo4j.gds.procedures.algorithms.centrality.CentralityStreamResult;
+import org.neo4j.gds.applications.algorithms.machinery.MemoryEstimateResult;
 import org.neo4j.procedure.Context;
 import org.neo4j.procedure.Description;
 import org.neo4j.procedure.Internal;
@@ -48,6 +49,15 @@ public Stream<CentralityStreamResult> stream(
         return facade.algorithms().centrality().harmonicCentralityStream(graphName, configuration);
     }
 
+    @Procedure(name = "gds.closeness.harmonic.stream.estimate", mode = READ)
+    @Description(MEMORY_ESTIMATION_DESCRIPTION)
+    public Stream<MemoryEstimateResult> estimate(
+        @Name(value = "graphNameOrConfiguration") Object graphNameOrConfiguration,
+        @Name(value = "algoConfiguration") Map<String, Object> algoConfiguration
+    ) {
+        return facade.algorithms().centrality().harmonicCentralityStreamEstimate(graphNameOrConfiguration, algoConfiguration);
+    }
+
     @Deprecated(forRemoval = true)
     @Internal
     @Procedure(name = "gds.alpha.closeness.harmonic.stream", mode = READ, deprecatedBy = "gds.closeness.harmonic.stream")
diff --git a/proc/centrality/src/main/java/org/neo4j/gds/harmonic/HarmonicCentralityWriteProc.java b/proc/centrality/src/main/java/org/neo4j/gds/harmonic/HarmonicCentralityWriteProc.java
@@ -22,6 +22,7 @@
 import org.neo4j.gds.procedures.GraphDataScienceProcedures;
 import org.neo4j.gds.procedures.algorithms.centrality.CentralityWriteResult;
 import org.neo4j.gds.procedures.algorithms.centrality.AlphaHarmonicWriteResult;
+import org.neo4j.gds.applications.algorithms.machinery.MemoryEstimateResult;
 import org.neo4j.procedure.Context;
 import org.neo4j.procedure.Description;
 import org.neo4j.procedure.Internal;
@@ -33,6 +34,7 @@
 
 import static org.neo4j.gds.harmonic.Constants.HARMONIC_CENTRALITY_DESCRIPTION;
 import static org.neo4j.gds.procedures.ProcedureConstants.MEMORY_ESTIMATION_DESCRIPTION;
+import static org.neo4j.procedure.Mode.READ;
 import static org.neo4j.procedure.Mode.WRITE;
 
 public class HarmonicCentralityWriteProc {
@@ -48,6 +50,15 @@ public Stream<CentralityWriteResult> write(
         return facade.algorithms().centrality().harmonicCentralityWrite(graphName, configuration);
     }
 
+    @Procedure(name = "gds.closeness.harmonic.write.estimate", mode = READ)
+    @Description(MEMORY_ESTIMATION_DESCRIPTION)
+    public Stream<MemoryEstimateResult> estimate(
+        @Name(value = "graphNameOrConfiguration") Object graphNameOrConfiguration,
+        @Name(value = "algoConfiguration") Map<String, Object> algoConfiguration
+    ) {
+        return facade.algorithms().centrality().harmonicCentralityWriteEstimate(graphNameOrConfiguration, algoConfiguration);
+    }
+
     @Deprecated(forRemoval = true)
     @Internal
     @Procedure(value = "gds.alpha.closeness.harmonic.write", mode = WRITE, deprecatedBy = "gds.closeness.harmonic.write")
diff --git a/procedures/algorithms-facade/src/main/java/org/neo4j/gds/procedures/algorithms/centrality/LocalCentralityProcedureFacade.java b/procedures/algorithms-facade/src/main/java/org/neo4j/gds/procedures/algorithms/centrality/LocalCentralityProcedureFacade.java
@@ -1107,6 +1107,14 @@ public Stream<CentralityMutateResult> harmonicCentralityMutate(
         return stubs.harmonic().execute(graphName, configuration);
     }
 
+    @Override
+    public Stream<MemoryEstimateResult> harmonicCentralityMutateEstimate(
+        Object graphNameOrConfiguration,
+        Map<String, Object> algorithmConfiguration
+    ) {
+        return stubs.harmonic().estimate(graphNameOrConfiguration, algorithmConfiguration);
+    }
+
     @Override
     public Stream<CentralityStatsResult> harmonicCentralityStats(String graphName, Map<String, Object> configuration) {
         var shouldComputeSimilarityDistribution = procedureReturnColumns.contains("centralityDistribution");
@@ -1127,6 +1135,22 @@ public Stream<CentralityStatsResult> harmonicCentralityStats(String graphName, M
         );
     }
 
+    @Override
+    public Stream<MemoryEstimateResult> harmonicCentralityStatsEstimate(
+        Object graphNameOrConfiguration,
+        Map<String, Object> algorithmConfiguration
+    ) {
+        var parsedConfiguration = configurationParser.parseConfiguration(
+            algorithmConfiguration,
+            HarmonicCentralityStatsConfig::of
+        );
+
+        return Stream.of(estimationModeBusinessFacade.harmonicCentrality(
+            parsedConfiguration,
+            graphNameOrConfiguration
+        ));
+    }
+
     @Override
     public Stream<CentralityStreamResult> harmonicCentralityStream(
         String graphName,
@@ -1146,6 +1170,22 @@ public Stream<CentralityStreamResult> harmonicCentralityStream(
         );
     }
 
+    @Override
+    public Stream<MemoryEstimateResult> harmonicCentralityStreamEstimate(
+        Object graphNameOrConfiguration,
+        Map<String, Object> algorithmConfiguration
+    ) {
+        var parsedConfiguration = configurationParser.parseConfiguration(
+            algorithmConfiguration,
+            HarmonicCentralityStreamConfig::of
+        );
+
+        return Stream.of(estimationModeBusinessFacade.harmonicCentrality(
+            parsedConfiguration,
+            graphNameOrConfiguration
+        ));
+    }
+
     @Override
     public Stream<CentralityWriteResult> harmonicCentralityWrite(String graphName, Map<String, Object> configuration) {
         var shouldComputeCentralityDistribution = procedureReturnColumns.contains("centralityDistribution");
@@ -1163,6 +1203,22 @@ public Stream<CentralityWriteResult> harmonicCentralityWrite(String graphName, M
         );
     }
 
+    @Override
+    public Stream<MemoryEstimateResult> harmonicCentralityWriteEstimate(
+        Object graphNameOrConfiguration,
+        Map<String, Object> algorithmConfiguration
+    ) {
+        var parsedConfiguration = configurationParser.parseConfiguration(
+            algorithmConfiguration,
+            HarmonicCentralityWriteConfig::of
+        );
+
+        return Stream.of(estimationModeBusinessFacade.harmonicCentrality(
+            parsedConfiguration,
+            graphNameOrConfiguration
+        ));
+    }
+
     @Override
     public Stream<PageRankMutateResult> pageRankMutate(String graphName, Map<String, Object> configuration) {
         return stubs.pageRank().execute(graphName, configuration);
diff --git a/procedures/facade-api/centrality-facade-api/src/main/java/org/neo4j/gds/procedures/algorithms/centrality/CentralityProcedureFacade.java b/procedures/facade-api/centrality-facade-api/src/main/java/org/neo4j/gds/procedures/algorithms/centrality/CentralityProcedureFacade.java

Original file line number	Diff line number	Diff line change
`@@ -35,12 +35,12 @@ private static MemoryEstimations.Builder MSBFS(){`
`35`	`35`	`.perThread("seens", HugeLongArray::memoryEstimation);`
`36`	`36`	`}`
`37`	`37`
`38`		`- static MemoryEstimation MSBFSWithPredecessorStrategy(){`
	`38`	`+ public static MemoryEstimation MSBFSWithPredecessorStrategy(){`
`39`	`39`	`return MSBFS()`
`40`	`40`	`.perThread("seenNext", HugeLongArray::memoryEstimation)`
`41`	`41`	`.build();`
`42`	`42`	`}`
`43`		`- static MemoryEstimation MSBFSWithANPStrategy(){`
	`43`	`+ public static MemoryEstimation MSBFSWithANPStrategy(){`
`44`	`44`	`return MSBFS()`
`45`	`45`	`.build();`
`46`	`46`	`}`