Add progress tracking for clique counting

AlfredClemedtson · AlfredClemedtson · commit 6f425486f335 · 2025-08-12T10:15:00.000+02:00
diff --git a/algo/src/main/java/org/neo4j/gds/CommunityAlgorithmTasks.java b/algo/src/main/java/org/neo4j/gds/CommunityAlgorithmTasks.java
@@ -23,6 +23,8 @@
 import org.neo4j.gds.applications.algorithms.machinery.AlgorithmLabel;
 import org.neo4j.gds.approxmaxkcut.ApproxMaxKCutParameters;
 import org.neo4j.gds.approxmaxkcut.ApproximateKCutTaskFactory;
+import org.neo4j.gds.cliqueCounting.CliqueCountingTaskFactory;
+import org.neo4j.gds.cliquecounting.CliqueCountingParameters;
 import org.neo4j.gds.core.utils.progress.tasks.Task;
 import org.neo4j.gds.core.utils.progress.tasks.Tasks;
 import org.neo4j.gds.hdbscan.HDBScanProgressTrackerCreator;
@@ -51,8 +53,8 @@ public Task approximateMaximumKCut(Graph graph, ApproxMaxKCutParameters paramete
         return ApproximateKCutTaskFactory.createTask(graph, parameters);
     }
 
-    public Task cliqueCounting(Graph graph) {
-        return Tasks.leaf(AlgorithmLabel.CliqueCounting.asString(), -1); //todo
+    public Task cliqueCounting(Graph graph, CliqueCountingParameters parameters) {
+        return CliqueCountingTaskFactory.createTask(graph, parameters);
     }
 
     public Task conductance(Graph graph) {
diff --git a/algo/src/main/java/org/neo4j/gds/cliqueCounting/CliqueCounting.java b/algo/src/main/java/org/neo4j/gds/cliqueCounting/CliqueCounting.java
@@ -175,11 +175,11 @@ private  Collection<? extends Runnable> createTasks(){
         return countingMode == CliqueCountingMode.ForGivenSubcliques ?
             ParallelUtil.tasks(
                 concurrency,
-                () -> new SubcliqueCliqueCountingTask(graph.concurrentCopy())
+                () -> new SubcliqueCliqueCountingTask(graph.concurrentCopy(), progressTracker)
             ) :
             ParallelUtil.tasks(
                 concurrency,
-                () -> new GlobalCliqueCountingTask(graph.concurrentCopy(), cliqueCountsHandler.takeOrCreate())
+                () -> new GlobalCliqueCountingTask(graph.concurrentCopy(), cliqueCountsHandler.takeOrCreate(), progressTracker)
             );
 
     }
@@ -364,10 +364,12 @@ long[] rootNodeNeighbors(long rootNode, boolean filter){
     private class GlobalCliqueCountingTask implements Runnable {
         Graph graph;
         SizeFrequencies sizeFrequencies;
+        ProgressTracker progressTracker;
 
-        GlobalCliqueCountingTask(Graph graph, SizeFrequencies sizeFrequencies) {
+        GlobalCliqueCountingTask(Graph graph, SizeFrequencies sizeFrequencies, ProgressTracker progressTracker) {
             this.graph = graph;
             this.sizeFrequencies = sizeFrequencies;
+            this.progressTracker = progressTracker;
         }
 
         public void run() {
@@ -380,16 +382,19 @@ public void run() {
                 long[][] feasibleNeighborhoods = computeIntersections(positiveNeighborhood);
                 recursiveSctCliqueCount(positiveNeighborhood, feasibleNeighborhoods, cliqueNodes, sizeFrequencies);
 
+               progressTracker.logProgress();
             }
             cliqueCountsHandler.giveBack(sizeFrequencies);
         }
     }
 
     private class SubcliqueCliqueCountingTask implements Runnable {
         Graph graph;
+        ProgressTracker progressTracker;
 
-        SubcliqueCliqueCountingTask(Graph graph) {
+        SubcliqueCliqueCountingTask(Graph graph, ProgressTracker progressTracker) {
             this.graph = graph;
+            this.progressTracker = progressTracker;
         }
 
         public void run() {
@@ -412,6 +417,7 @@ public void run() {
                 }
                 long[][] feasibleNeighborhoods = computeIntersections(subset);
                 recursiveSctCliqueCount(subset, feasibleNeighborhoods, cliqueNodes, sizeFrequencies);
+                progressTracker.logProgress();
             }
         }
     }
diff --git a/algo/src/main/java/org/neo4j/gds/cliqueCounting/CliqueCountingTaskFactory.java b/algo/src/main/java/org/neo4j/gds/cliqueCounting/CliqueCountingTaskFactory.java
@@ -0,0 +1,42 @@
+/*
+ * 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.neo4j.gds.api.Graph;
+import org.neo4j.gds.applications.algorithms.machinery.AlgorithmLabel;
+import org.neo4j.gds.cliquecounting.CliqueCountingParameters;
+import org.neo4j.gds.core.utils.progress.tasks.Task;
+import org.neo4j.gds.core.utils.progress.tasks.Tasks;
+
+public final class CliqueCountingTaskFactory {
+
+    private CliqueCountingTaskFactory() {}
+
+    private static long volume(Graph graph, CliqueCountingParameters parameters) {
+        return parameters.subcliques().isEmpty() ? graph.nodeCount() : parameters.subcliques().size();
+    }
+
+    public static Task createTask(Graph graph, CliqueCountingParameters parameters) {
+        return Tasks.leaf(AlgorithmLabel.CliqueCounting.asString(), volume(graph, parameters));
+    }
+
+
+
+}
diff --git a/algo/src/test/java/org/neo4j/gds/cliqueCounting/CliqueCountingTest.java b/algo/src/test/java/org/neo4j/gds/cliqueCounting/CliqueCountingTest.java
@@ -19,16 +19,20 @@
  */
 package org.neo4j.gds.cliqueCounting;
 
+import org.assertj.core.api.Assertions;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
+import org.neo4j.gds.CommunityAlgorithmTasks;
 import org.neo4j.gds.Orientation;
+import org.neo4j.gds.TestProgressTrackerHelper;
 import org.neo4j.gds.TestSupport;
 import org.neo4j.gds.api.Graph;
 import org.neo4j.gds.cliquecounting.CliqueCountingMode;
 import org.neo4j.gds.cliquecounting.CliqueCountingParameters;
 import org.neo4j.gds.collections.ha.HugeObjectArray;
+import org.neo4j.gds.compat.TestLog;
 import org.neo4j.gds.core.concurrency.Concurrency;
 import org.neo4j.gds.core.concurrency.DefaultPool;
 import org.neo4j.gds.core.utils.progress.tasks.ProgressTracker;
@@ -38,9 +42,12 @@
 import java.io.InputStream;
 import java.nio.charset.StandardCharsets;
 import java.util.Arrays;
+import java.util.List;
 import java.util.stream.Stream;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.neo4j.gds.assertj.Extractors.removingThreadId;
+import static org.neo4j.gds.assertj.Extractors.replaceTimings;
 
 class CliqueCountingTest {
 
@@ -190,4 +197,61 @@ void biggerGraph() throws IOException {
         assertEquals(6L, result.globalCount()[10 - 3]);
     }
 
+    @Test
+    void shouldLogProgress(){
+        Graph graph = fromGdl("CREATE (a1)-[:T]->(a2)-[:T]->(a3)-[:T]->(a4), (a2)-[:T]->(a4)-[:T]->(a1)-[:T]->(a3), (a1)-[:T]->(a2), (a1)-[:T1]->(a3)");
+        var params = new CliqueCountingParameters(CliqueCountingMode.ForEveryNode, List.of(), new Concurrency(4));
+
+        var progressTrackerWithLog = TestProgressTrackerHelper.create(
+            new CommunityAlgorithmTasks().cliqueCounting(graph, params),
+            new Concurrency(4)
+        );
+
+        var progressTracker = progressTrackerWithLog.progressTracker();
+        var log = progressTrackerWithLog.log();
+
+        var cliques = CliqueCounting.create(graph, params, DefaultPool.INSTANCE, progressTracker, TerminationFlag.RUNNING_TRUE);
+        cliques.compute();
+
+        Assertions.assertThat(log.getMessages(TestLog.INFO))
+            .extracting(removingThreadId())
+            .extracting(replaceTimings())
+            .containsExactly(
+                "Clique Counting :: Start",
+                "Clique Counting 25%",
+                "Clique Counting 50%",
+                "Clique Counting 75%",
+                "Clique Counting 100%",
+                "Clique Counting :: Finished"
+            );
+    }
+
+    @Test
+    void shouldLogProgressSubclique(){
+        Graph graph = fromGdl("CREATE (a1)-[:T]->(a2)-[:T]->(a3)-[:T]->(a4), (a2)-[:T]->(a4)-[:T]->(a1)-[:T]->(a3), (a1)-[:T]->(a2), (a1)-[:T1]->(a3)");
+        var params = new CliqueCountingParameters(CliqueCountingMode.ForEveryNode, List.of(new long[] {0L, 1L}, new long[] {3L}), new Concurrency(4));
+
+        var progressTrackerWithLog = TestProgressTrackerHelper.create(
+            new CommunityAlgorithmTasks().cliqueCounting(graph, params),
+            new Concurrency(4)
+        );
+
+        var progressTracker = progressTrackerWithLog.progressTracker();
+        var log = progressTrackerWithLog.log();
+
+        var cliques = CliqueCounting.create(graph, params, DefaultPool.INSTANCE, progressTracker, TerminationFlag.RUNNING_TRUE);
+        cliques.compute();
+
+        Assertions.assertThat(log.getMessages(TestLog.INFO))
+            .extracting(removingThreadId())
+            .extracting(replaceTimings())
+            .containsExactly(
+                "Clique Counting :: Start",
+                "Clique Counting 50%",
+                "Clique Counting 100%",
+                "Clique Counting :: Finished"
+            );
+    }
+
+
 }
diff --git a/applications/algorithms/community/src/main/java/org/neo4j/gds/applications/algorithms/community/CommunityAlgorithms.java b/applications/algorithms/community/src/main/java/org/neo4j/gds/applications/algorithms/community/CommunityAlgorithms.java
@@ -27,7 +27,6 @@
 import org.neo4j.gds.beta.pregel.PregelResult;
 import org.neo4j.gds.cliqueCounting.CliqueCounting;
 import org.neo4j.gds.cliqueCounting.CliqueCountingResult;
-import org.neo4j.gds.cliquecounting.CliqueCountingParameters;
 import org.neo4j.gds.collections.ha.HugeLongArray;
 import org.neo4j.gds.conductance.Conductance;
 import org.neo4j.gds.conductance.ConductanceParameters;
@@ -103,7 +102,7 @@ public ApproxMaxKCutResult approximateMaximumKCut(
         ).compute();
     }
 
-    public CliqueCountingResult cliqueCounting(Graph graph, CliqueCountingParameters parameters, ProgressTracker progressTracker) {
+    public CliqueCountingResult cliqueCounting(Graph graph, org.neo4j.gds.cliquecounting.CliqueCountingParameters parameters, ProgressTracker progressTracker) {
         return CliqueCounting.create(
             graph,
             parameters,
diff --git a/applications/algorithms/community/src/main/java/org/neo4j/gds/applications/algorithms/community/CommunityAlgorithmsBusinessFacade.java b/applications/algorithms/community/src/main/java/org/neo4j/gds/applications/algorithms/community/CommunityAlgorithmsBusinessFacade.java
@@ -89,9 +89,9 @@ ApproxMaxKCutResult approximateMaximumKCut(Graph graph, ApproxMaxKCutBaseConfig
     }
 
     public CliqueCountingResult cliqueCounting(Graph graph, CliqueCountingBaseConfig configuration) {
-        var task = tasks.cliqueCounting(graph);
-        var progressTracker = progressTrackerCreator.createProgressTracker(task, configuration);
         var params = configuration.toParameters();
+        var task = tasks.cliqueCounting(graph, params);
+        var progressTracker = progressTrackerCreator.createProgressTracker(task, configuration);
 
         return algorithmMachinery.getResult(
             () -> algorithms.cliqueCounting(graph, params, progressTracker),

Original file line number	Diff line number	Diff line change
`@@ -175,11 +175,11 @@ private Collection<? extends Runnable> createTasks(){`
`175`	`175`	`return countingMode == CliqueCountingMode.ForGivenSubcliques ?`
`176`	`176`	`ParallelUtil.tasks(`
`177`	`177`	`concurrency,`
`178`		`- () -> new SubcliqueCliqueCountingTask(graph.concurrentCopy())`
	`178`	`+ () -> new SubcliqueCliqueCountingTask(graph.concurrentCopy(), progressTracker)`
`179`	`179`	`) :`
`180`	`180`	`ParallelUtil.tasks(`
`181`	`181`	`concurrency,`
`182`		`- () -> new GlobalCliqueCountingTask(graph.concurrentCopy(), cliqueCountsHandler.takeOrCreate())`
	`182`	`+ () -> new GlobalCliqueCountingTask(graph.concurrentCopy(), cliqueCountsHandler.takeOrCreate(), progressTracker)`
`183`	`183`	`);`
`184`	`184`
`185`	`185`	`}`
`@@ -364,10 +364,12 @@ long[] rootNodeNeighbors(long rootNode, boolean filter){`
`364`	`364`	`private class GlobalCliqueCountingTask implements Runnable {`
`365`	`365`	`Graph graph;`
`366`	`366`	`SizeFrequencies sizeFrequencies;`
	`367`	`+ ProgressTracker progressTracker;`
`367`	`368`
`368`		`- GlobalCliqueCountingTask(Graph graph, SizeFrequencies sizeFrequencies) {`
	`369`	`+ GlobalCliqueCountingTask(Graph graph, SizeFrequencies sizeFrequencies, ProgressTracker progressTracker) {`
`369`	`370`	`this.graph = graph;`
`370`	`371`	`this.sizeFrequencies = sizeFrequencies;`
	`372`	`+ this.progressTracker = progressTracker;`
`371`	`373`	`}`
`372`	`374`
`373`	`375`	`public void run() {`
`@@ -380,16 +382,19 @@ public void run() {`
`380`	`382`	`long[][] feasibleNeighborhoods = computeIntersections(positiveNeighborhood);`
`381`	`383`	`recursiveSctCliqueCount(positiveNeighborhood, feasibleNeighborhoods, cliqueNodes, sizeFrequencies);`
`382`	`384`
	`385`	`+ progressTracker.logProgress();`
`383`	`386`	`}`
`384`	`387`	`cliqueCountsHandler.giveBack(sizeFrequencies);`
`385`	`388`	`}`
`386`	`389`	`}`
`387`	`390`
`388`	`391`	`private class SubcliqueCliqueCountingTask implements Runnable {`
`389`	`392`	`Graph graph;`
	`393`	`+ ProgressTracker progressTracker;`
`390`	`394`
`391`		`- SubcliqueCliqueCountingTask(Graph graph) {`
	`395`	`+ SubcliqueCliqueCountingTask(Graph graph, ProgressTracker progressTracker) {`
`392`	`396`	`this.graph = graph;`
	`397`	`+ this.progressTracker = progressTracker;`
`393`	`398`	`}`
`394`	`399`
`395`	`400`	`public void run() {`
`@@ -412,6 +417,7 @@ public void run() {`
`412`	`417`	`}`
`413`	`418`	`long[][] feasibleNeighborhoods = computeIntersections(subset);`
`414`	`419`	`recursiveSctCliqueCount(subset, feasibleNeighborhoods, cliqueNodes, sizeFrequencies);`
	`420`	`+ progressTracker.logProgress();`
`415`	`421`	`}`
`416`	`422`	`}`
`417`	`423`	`}`