Implement super-upperbounded memory estimation for clique counting

Co-authored-by: Ioannis Panagiotas <ioannis.panagiotas@neo4j.com>

Author: AlfredClemedtson

algo/src/main/java/org/neo4j/gds/cliqueCounting/CliqueCountingMemoryEstimateDefinition.java

@@ -20,25 +20,44 @@
 package org.neo4j.gds.cliqueCounting;
 
 //import org.neo4j.gds.collections.ha.HugeLongArray;
-import org.neo4j.gds.exceptions.MemoryEstimationNotImplementedException;
-//import org.neo4j.gds.k1coloring.ColoringStep;
-//import org.neo4j.gds.k1coloring.K1Coloring;
-//import org.neo4j.gds.mem.Estimate;
+
 import org.neo4j.gds.mem.MemoryEstimateDefinition;
 import org.neo4j.gds.mem.MemoryEstimation;
+import org.neo4j.gds.mem.MemoryEstimations;
+import org.neo4j.gds.mem.MemoryRange;
 //import org.neo4j.gds.mem.MemoryEstimations;
 
 public final class CliqueCountingMemoryEstimateDefinition implements MemoryEstimateDefinition {
+
+    public CliqueCountingMemoryEstimateDefinition() {
+    }
+
     @Override
     public MemoryEstimation memoryEstimation() {
-        throw new MemoryEstimationNotImplementedException();
-//        return MemoryEstimations.builder(K1Coloring.class)
-//            .perNode("colors", HugeLongArray::memoryEstimation)
-//            .perNode("nodesToColor", Estimate::sizeOfBitset)
-//            .perThread("coloring", MemoryEstimations.builder()
-//                .field("coloringStep", ColoringStep.class)
-//                .perNode("forbiddenColors", Estimate::sizeOfBitset)
-//                .build())
-//            .build();
+
+        return  MemoryEstimations.builder(CliqueCounting.class)
+            .perThread("intersection cost per thread",  thread())
+            .build();
     }
+
+    private MemoryEstimation thread(){
+            return MemoryEstimations.builder()
+                .rangePerGraphDimension("Intersections",((graphDimensions, concurrency) -> {
+                    var  bound1 = (long)(graphDimensions.averageDegree()*2.7);
+                    var bound2  = (long) (0.48*Math.sqrt(graphDimensions.relCountUpperBound())); //a theoretical bound  ¯\_(ツ)_/¯
+                    var cost1 = cost(bound1);
+                    var cost2 = cost(bound2);
+                    return MemoryRange.of(Math.min(cost1, cost2), Math.max(cost1, cost2));
+                }))
+                .build();
+
+    }
+
+    private long cost(long bound) {
+        //very very loose bounds
+        long recursionLevels = bound;
+        long intersectionsPerLevel = (bound * (bound-1))/2;
+        return recursionLevels * intersectionsPerLevel;
+    }
+
 }

algo/src/test/java/org/neo4j/gds/cliqueCounting/CliqueCountingMemoryEstimateDefinitionTest.java

@@ -0,0 +1,53 @@
+/*
+ * 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.cliqueCounting;
+
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+import org.neo4j.gds.assertions.MemoryEstimationAssert;
+import org.neo4j.gds.core.concurrency.Concurrency;
+
+import java.util.stream.Stream;
+
+class CliqueCountingMemoryEstimateDefinitionTest {
+
+
+    static Stream<Arguments> memoryEstimationTuples() {
+        return Stream.of(
+            Arguments.of(1, 1744377118L),
+            Arguments.of(4, 6977508304L)
+        );
+    }
+
+    @ParameterizedTest
+    @MethodSource("memoryEstimationTuples")
+    void shouldEstimateMemoryAccurately(int concurrency, long expectedMemory) {
+        var memoryEstimation = new CliqueCountingMemoryEstimateDefinition().memoryEstimation();
+
+        MemoryEstimationAssert.assertThat(memoryEstimation)
+            .memoryRange(1_000_000, 10_000_000, new Concurrency(concurrency))
+            .hasMax(expectedMemory);
+    }
+
+       // 29858008xxx
+       // 1408353856
+
+}

algo/src/test/java/org/neo4j/gds/cliqueCounting/CliqueCountingTest.java

@@ -253,5 +253,4 @@ void shouldLogProgressSubclique(){
             );
     }
 
-
 }