Slightly tigthen mem. est

Author: IoannisPanagiotas

algo/src/main/java/org/neo4j/gds/harmonic/HarmonicCentralityAlgorithmEstimateDefinition.java

@@ -19,8 +19,8 @@
  */
 package org.neo4j.gds.harmonic;
 
-import org.neo4j.gds.mem.MemoryEstimateDefinition;
 import org.neo4j.gds.collections.haa.HugeAtomicDoubleArray;
+import org.neo4j.gds.mem.MemoryEstimateDefinition;
 import org.neo4j.gds.mem.MemoryEstimation;
 import org.neo4j.gds.mem.MemoryEstimations;
 import org.neo4j.gds.msbfs.MSBFSMemoryEstimation;
@@ -31,7 +31,7 @@ public final class HarmonicCentralityAlgorithmEstimateDefinition implements Memo
     public MemoryEstimation memoryEstimation() {
         return MemoryEstimations.builder(HarmonicCentrality.class)
             .perNode("inverse farness", HugeAtomicDoubleArray::memoryEstimation)
-            .add("MSBFS", MSBFSMemoryEstimation.MSBFSWithANPStrategy())
+            .add("MSBFS", MSBFSMemoryEstimation.MSBFSWithANPStrategy(0))
             .build();
     }
 

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

@@ -20,28 +20,38 @@
 package org.neo4j.gds.msbfs;
 
 import org.neo4j.gds.collections.ha.HugeLongArray;
+import org.neo4j.gds.mem.Estimate;
 import org.neo4j.gds.mem.MemoryEstimation;
 import org.neo4j.gds.mem.MemoryEstimations;
 
 public final class MSBFSMemoryEstimation {
 
     private MSBFSMemoryEstimation() {}
 
-    private static MemoryEstimations.Builder MSBFS(){
 
-        return MemoryEstimations.builder(MultiSourceBFSAccessMethods.class)
+    private static MemoryEstimations.Builder MSBFS(int sourceNodes){
+        var runnable = MemoryEstimations.builder(MultiSourceBFSRunnable.class).build();
+
+        var builder = MemoryEstimations.builder(MultiSourceBFSAccessMethods.class)
             .perThread("visits", HugeLongArray::memoryEstimation)
             .perThread("visitsNext", HugeLongArray::memoryEstimation)
-            .perThread("seens", HugeLongArray::memoryEstimation);
+            .perThread("seens", HugeLongArray::memoryEstimation)
+            .perThread("runnable", runnable);
+
+        if (sourceNodes > 0 ) {
+            builder.fixed("source nodes", Estimate.sizeOfLongArray(sourceNodes));
+        }
+
+        return builder;
     }
 
-    public static MemoryEstimation MSBFSWithPredecessorStrategy(){
-        return MSBFS()
+    public static MemoryEstimation MSBFSWithPredecessorStrategy(int sourceNodes){
+        return MSBFS(sourceNodes)
             .perThread("seenNext", HugeLongArray::memoryEstimation)
             .build();
     }
-    public static MemoryEstimation MSBFSWithANPStrategy(){
-        return MSBFS()
+    public static MemoryEstimation MSBFSWithANPStrategy(int sourceNodes){
+        return MSBFS(sourceNodes)
             .build();
     }
 }

algo/src/test/java/org/neo4j/gds/harmonic/HarmonicCentralityAlgorithmEstimateDefinitionTest.java

@@ -29,12 +29,12 @@ 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"
+        "10_000, 1, 80_368",
+        "10_000, 4, 80_632",
+        "500_000, 4, 4_000_632",
+        "10_000_000, 4, 80_000_632",
+        "10_000, 2, 80_456",
+        "10_000, 128, 91_544"
     })
     void testMemoryEstimation(long nodeCount, int concurrency, long expectedMemory) {
         var memoryEstimation = new HarmonicCentralityAlgorithmEstimateDefinition().memoryEstimation();

algo/src/test/java/org/neo4j/gds/msbfs/MSBFSMemoryEstimationTest.java

@@ -29,22 +29,27 @@ class MSBFSMemoryEstimationTest {
 
     @ParameterizedTest
     @CsvSource({
-        "100,1,264",
-        "100,4,360"
+        "100,1,0, 328",
+        "100,1,10, 424",
+        "100,4,0, 616",
+        "100,4,10, 712"
+
     })
-    void shouldWorkForPredecessor(long nodeCount, int concurrency, long expectedMemory){
-        MemoryEstimationAssert.assertThat(MSBFSMemoryEstimation.MSBFSWithPredecessorStrategy())
+    void shouldWorkForPredecessor(long nodeCount, int concurrency,  int sourceNodesSize, long expectedMemory){
+        MemoryEstimationAssert.assertThat(MSBFSMemoryEstimation.MSBFSWithPredecessorStrategy(sourceNodesSize))
             .memoryRange(GraphDimensions.of(nodeCount),new Concurrency(concurrency))
             .hasSameMinAndMaxEqualTo(expectedMemory);
     }
 
     @ParameterizedTest
     @CsvSource({
-        "100,1,216",
-        "100,4,288"
+        "100,1,0,280",
+        "100,1,10,376",
+        "100,4,0,544",
+        "100,4,10,640"
     })
-    void shouldWorkForANP(long nodeCount, int concurrency, long expectedMemory){
-        MemoryEstimationAssert.assertThat(MSBFSMemoryEstimation.MSBFSWithANPStrategy())
+    void shouldWorkForANP(long nodeCount, int concurrency,  int sourceNodesSize, long expectedMemory){
+        MemoryEstimationAssert.assertThat(MSBFSMemoryEstimation.MSBFSWithANPStrategy(sourceNodesSize))
             .memoryRange(GraphDimensions.of(nodeCount),new Concurrency(concurrency))
             .hasSameMinAndMaxEqualTo(expectedMemory);
     }