Correct memory estimation for MSBFS

Author: IoannisPanagiotas

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

@@ -29,29 +29,36 @@ public final class MSBFSMemoryEstimation {
     private MSBFSMemoryEstimation() {}
 
 
-    private static MemoryEstimations.Builder MSBFS(int sourceNodes){
-        var runnable = MemoryEstimations.builder(MultiSourceBFSRunnable.class).build();
+    private  static MemoryEstimation MSBFSRunnable(boolean seenNext){
+        var builder =  MemoryEstimations.builder(MultiSourceBFSRunnable.class)
+            .perNode("visits", HugeLongArray::memoryEstimation)
+            .perNode("visitsNext", HugeLongArray::memoryEstimation)
+            .perNode("seens", HugeLongArray::memoryEstimation);
 
-        var builder = MemoryEstimations.builder(MultiSourceBFSAccessMethods.class)
-            .perThread("visits", HugeLongArray::memoryEstimation)
-            .perThread("visitsNext", HugeLongArray::memoryEstimation)
-            .perThread("seens", HugeLongArray::memoryEstimation)
-            .perThread("runnable", runnable);
+        if (seenNext) {
+            builder.perNode("seenNext", HugeLongArray::memoryEstimation);
+        }
+
+        return  builder.build();
+
+    }
+    private static MemoryEstimations.Builder MSBFS(int sourceNodes, boolean seenNext){
+
+        var builder = MemoryEstimations.builder(MultiSourceBFSAccessMethods.class);
 
         if (sourceNodes > 0 ) {
             builder.fixed("source nodes", Estimate.sizeOfLongArray(sourceNodes));
         }
 
+        builder.perThread("runnable", MSBFSRunnable(seenNext));
+
         return builder;
     }
 
     public static MemoryEstimation MSBFSWithPredecessorStrategy(int sourceNodes){
-        return MSBFS(sourceNodes)
-            .perThread("seenNext", HugeLongArray::memoryEstimation)
-            .build();
+        return MSBFS(sourceNodes,true).build();
     }
     public static MemoryEstimation MSBFSWithANPStrategy(int sourceNodes){
-        return MSBFS(sourceNodes)
-            .build();
+        return MSBFS(sourceNodes,false).build();
     }
 }

algo/src/test/java/org/neo4j/gds/allshortestpaths/AllShortestPathsMemoryEstimateDefinitionTest.java

@@ -29,10 +29,10 @@ class AllShortestPathsMemoryEstimateDefinitionTest {
 
     @ParameterizedTest
     @CsvSource({
-        "10_000, 1, false, 320",
-        "10_000, 4, false, 584",
-        "500_000, 4, false, 584",
-        "10_000_000, 4, false, 584",
+        "10_000, 1, false, 24_0296",
+        "10_000, 4, false, 960_848",
+        "500_000, 4, false, 48_000_848",
+        "10_000_000, 4, false, 960_000_848",
         "10_000, 1, true, 120_280",
         "10_000, 4, true, 480_976",
         "500_000, 4, true, 24_000_976",

algo/src/test/java/org/neo4j/gds/closeness/ClosenessCentralityAlgorithmEstimateDefinitionTest.java

@@ -29,12 +29,12 @@ class ClosenessCentralityAlgorithmEstimateDefinitionTest {
 
     @ParameterizedTest
     @CsvSource({
-        "10_000, 1, 160_456",
-        "10_000, 4, 160_720",
-        "500_000, 4, 8_000_720",
-        "10_000_000, 4, 160_000_720",
-        "10_000, 2, 160_544",
-        "10_000, 128, 171_632"
+        "10_000, 1, 400_432",
+        "10_000, 4, 1_120_984",
+        "500_000, 4, 56_000_984",
+        "10_000_000, 4, 1_120_000_984",
+        "10_000, 2, 640_616",
+        "10_000, 128, 30_903_800"
     })
     void testMemoryEstimation(long nodeCount, int concurrency, long expectedMemory) {
         var memoryEstimation = new ClosenessCentralityAlgorithmEstimateDefinition().memoryEstimation();

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

@@ -29,12 +29,12 @@ class HarmonicCentralityAlgorithmEstimateDefinitionTest {
 
     @ParameterizedTest
     @CsvSource({
-        "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"
+        "10_000, 1, 320_344",
+        "10_000, 4, 1_040_896",
+        "500_000, 4, 52_000_896",
+        "10_000_000, 4, 1_040_000_896",
+        "10_000, 2, 560_528",
+        "10_000, 128, 30_823_712"
     })
     void testMemoryEstimation(long nodeCount, int concurrency, long expectedMemory) {
         var memoryEstimation = new HarmonicCentralityAlgorithmEstimateDefinition().memoryEstimation();

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

@@ -29,10 +29,14 @@ class MSBFSMemoryEstimationTest {
 
     @ParameterizedTest
     @CsvSource({
-        "100,1,0, 328",
-        "100,1,10, 424",
-        "100,4,0, 616",
-        "100,4,10, 712"
+        "100,1,0, 3496",
+        "100,1,10, 3592",
+        "100,4,0, 13768",
+        "100,4,10, 13864",
+        "200,1,0, 6696",
+        "200,1,10, 6792",
+        "200,4,0, 26568",
+        "201,4,10, 26792"
 
     })
     void shouldWorkForPredecessor(long nodeCount, int concurrency,  int sourceNodesSize, long expectedMemory){
@@ -43,10 +47,14 @@ void shouldWorkForPredecessor(long nodeCount, int concurrency,  int sourceNodesS
 
     @ParameterizedTest
     @CsvSource({
-        "100,1,0,280",
-        "100,1,10,376",
-        "100,4,0,544",
-        "100,4,10,640"
+        "100,1,0, 2656",
+        "100,1,10, 2752",
+        "100,4,0, 10408",
+        "100,4,10, 10504",
+        "200,1,0, 5056",
+        "200,1,10, 5152",
+        "200,4,0, 20008",
+        "200,4,10, 20104"
     })
     void shouldWorkForANP(long nodeCount, int concurrency,  int sourceNodesSize, long expectedMemory){
         MemoryEstimationAssert.assertThat(MSBFSMemoryEstimation.MSBFSWithANPStrategy(sourceNodesSize))

doc/modules/ROOT/pages/algorithms/harmonic-centrality.adoc

@@ -274,7 +274,7 @@ YIELD nodeCount, relationshipCount, bytesMin, bytesMax, requiredMemory
 [opts="header"]
 |===
 | nodeCount | relationshipCount | bytesMin | bytesMax | requiredMemory
-| 5         | 6                | 672      | 672      | "672 Bytes"
+| 5         | 6                | 1416      | 1416      | "1416 Bytes"
 |===
 --