Add some semblance of progress tracking

Author: IoannisPanagiotas

alpha/alpha-algo/src/main/java/org/neo4j/gds/impl/spanningtree/KSpanningTree.java

@@ -77,7 +77,10 @@ public SpanningTree compute() {
 
         prim.setTerminationFlag(getTerminationFlag());
         SpanningTree spanningTree = prim.compute();
-        return combineApproach(spanningTree);
+
+        var outputTree = combineApproach(spanningTree);
+        progressTracker.endSubTask();
+        return outputTree;
     }
 
     @NotNull
@@ -121,7 +124,9 @@ private SpanningTree cutLeafApproach(SpanningTree spanningTree) {
         HugeDoubleArray costToParent = HugeDoubleArray.newArray(graph.nodeCount());
 
         double totalCost = init(parent, costToParent, spanningTree);
+        long numberOfDeletions = spanningTree.effectiveNodeCount() - k;
 
+        progressTracker.beginSubTask(numberOfDeletions);
         //calculate degree of each node in MST
         for (long nodeId = 0; nodeId < graph.nodeCount(); ++nodeId) {
             var nodeParent = parent.get(nodeId);
@@ -145,7 +150,6 @@ private SpanningTree cutLeafApproach(SpanningTree spanningTree) {
             }
         }
 
-        long numberOfDeletions = spanningTree.effectiveNodeCount() - k;
         for (long i = 0; i < numberOfDeletions; ++i) {
             var nextNode = priorityQueue.pop();
             long affectedNode;
@@ -184,9 +188,10 @@ private SpanningTree cutLeafApproach(SpanningTree spanningTree) {
                     associatedCost = costToParent.get(affectedNode);
                 }
                 priorityQueue.add(affectedNode, associatedCost);
-
             }
+            progressTracker.logProgress();
         }
+        progressTracker.endSubTask();
         return new SpanningTree(-1, graph.nodeCount(), k, parent, costToParent, totalCost);
     }
 
@@ -218,8 +223,10 @@ private SpanningTree growApproach(SpanningTree spanningTree) {
         priorityQueue.add(startNodeId, 0);
         long root = startNodeId; //current root is startNodeId
         long nodesInTree = 0;
+        progressTracker.beginSubTask(graph.nodeCount());
         while (!priorityQueue.isEmpty()) {
             long node = priorityQueue.top();
+            progressTracker.logProgress();
             double associatedCost = priorityQueue.cost(node);
             priorityQueue.pop();
             long nodeParent = parent.get(node);
@@ -333,7 +340,7 @@ private SpanningTree growApproach(SpanningTree spanningTree) {
             }
             return true;
         });
-
+        progressTracker.endSubTask();
         return new SpanningTree(-1, graph.nodeCount(), k, parent, costToParent, totalCost);
 
     }

alpha/alpha-algo/src/main/java/org/neo4j/gds/impl/spanningtree/KSpanningTreeAlgorithmFactory.java

@@ -52,9 +52,10 @@ public Task progressTask(
             ) {
             return Tasks.task(
                 taskName(),
-                Tasks.leaf("SpanningTree", graph.nodeCount()),
-                Tasks.leaf("Add relationship weights"),
-                Tasks.leaf("Remove relationships")
+                Tasks.leaf("SpanningTree", graph.relationshipCount()),
+                Tasks.leaf("Remove relationships 1"),
+                Tasks.leaf("Remove relationships 2")
+
             );
         }
 

alpha/alpha-algo/src/test/java/org/neo4j/gds/impl/spanningtree/KSpanningTreeTest.java

@@ -25,7 +25,11 @@
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.CsvSource;
 import org.neo4j.gds.Orientation;
+import org.neo4j.gds.TestProgressTracker;
 import org.neo4j.gds.api.Graph;
+import org.neo4j.gds.compat.Neo4jProxy;
+import org.neo4j.gds.compat.TestLog;
+import org.neo4j.gds.core.utils.progress.EmptyTaskRegistryFactory;
 import org.neo4j.gds.core.utils.progress.tasks.ProgressTracker;
 import org.neo4j.gds.extension.GdlExtension;
 import org.neo4j.gds.extension.GdlGraph;
@@ -37,6 +41,8 @@
 import java.util.HashSet;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.neo4j.gds.assertj.Extractors.removingThreadId;
+import static org.neo4j.gds.assertj.Extractors.replaceTimings;
 
 /**
  *           1
@@ -286,4 +292,41 @@ void worstCaseForPruningLeaves() {
 
     }
 
+    @Test
+    void shouldLogProgress() {
+        var config = KSpanningTreeBaseConfigImpl.builder().sourceNode(idFunction.of("a")).k(2).build();
+        var factory = new KSpanningTreeAlgorithmFactory<>();
+        var log = Neo4jProxy.testLog();
+        var progressTracker = new TestProgressTracker(
+            factory.progressTask(graph, config),
+            log,
+            1,
+            EmptyTaskRegistryFactory.INSTANCE
+        );
+        factory.build(graph, config, progressTracker).compute();
+        assertThat(log.getMessages(TestLog.INFO))
+            .extracting(removingThreadId())
+            .extracting(replaceTimings())
+            .containsExactly(
+                "KSpanningTree :: Start",
+                "KSpanningTree :: SpanningTree :: Start",
+                "KSpanningTree :: SpanningTree 30%",
+                "KSpanningTree :: SpanningTree 50%",
+                "KSpanningTree :: SpanningTree 80%",
+                "KSpanningTree :: SpanningTree 100%",
+                "KSpanningTree :: SpanningTree :: Finished",
+                "KSpanningTree :: Remove relationships 1 :: Start",
+                "KSpanningTree :: Remove relationships 1 50%",
+                "KSpanningTree :: Remove relationships 1 100%",
+                "KSpanningTree :: Remove relationships 1 :: Finished",
+                "KSpanningTree :: Remove relationships 2 :: Start",
+                "KSpanningTree :: Remove relationships 2 20%",
+                "KSpanningTree :: Remove relationships 2 40%",
+                "KSpanningTree :: Remove relationships 2 60%",
+                "KSpanningTree :: Remove relationships 2 100%",
+                "KSpanningTree :: Remove relationships 2 :: Finished",
+                "KSpanningTree :: Finished"
+            );
+    }
+
 }