Fix incorrect workload calculation for filtered node similarity

Co-authored-by: Veselin Nikolov <veselin.nikolov@neotechnology.com>

Author: IoannisPanagiotas

algo/src/main/java/org/neo4j/gds/similarity/nodesim/NodeSimilarity.java

@@ -437,8 +437,14 @@ private LongStream checkProgress(LongStream stream) {
     }
 
     private long calculateWorkload() {
-        long workload = nodesToCompare * nodesToCompare;
-        if (concurrency == 1) {
+        //for each source node, examine all their target nodes
+        //if no filter then sourceNodes == targetNodes
+        long workload = sourceNodes.cardinality() * targetNodes.cardinality();
+
+        //when on concurrency of 1 on not-filtered similarity,  we only compare nodeId with greater indexed nodes
+        // so work is halved. This does not hold for filtered similarity, since the targetNodes might be lesser indexed.
+        boolean isNotFiltered = sourceNodes.equals(NodeFilter.noOp) && targetNodeFilter.equals(NodeFilter.noOp);
+        if (concurrency == 1 && isNotFiltered) {
             workload = workload / 2;
         }
         return workload;

algo/src/test/java/org/neo4j/gds/similarity/filterednodesim/FilteredNodeSimilarityTest.java

@@ -20,6 +20,12 @@
 package org.neo4j.gds.similarity.filterednodesim;
 
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+import org.neo4j.gds.TestProgressTracker;
+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;
@@ -30,6 +36,8 @@
 import java.util.List;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.neo4j.gds.assertj.Extractors.removingThreadId;
+import static org.neo4j.gds.compat.TestLog.INFO;
 
 @GdlExtension
 class FilteredNodeSimilarityTest {
@@ -154,4 +162,55 @@ void shouldSurviveIoannisFurtherObjections() {
 
         nodeSimilarity.release();
     }
+
+    @ParameterizedTest
+    @ValueSource(ints = {1, 2})
+    void shouldLogProgressAccurately(int concurrency) {
+        var sourceNodeFilter = List.of(2L, 3L);
+
+        var config = ImmutableFilteredNodeSimilarityStreamConfig.builder()
+            .sourceNodeFilter(NodeFilterSpecFactory.create(sourceNodeFilter))
+            .concurrency(concurrency)
+            .topK(0)
+            .topN(10)
+            .build();
+        var progressTask = new FilteredNodeSimilarityFactory<>().progressTask(graph, config);
+        TestLog log = Neo4jProxy.testLog();
+        var progressTracker = new TestProgressTracker(
+            progressTask,
+            log,
+            concurrency,
+            EmptyTaskRegistryFactory.INSTANCE
+        );
+
+
+        new FilteredNodeSimilarityFactory<>().build(
+            graph,
+            config,
+            progressTracker
+        ).compute();
+
+
+        assertThat(log.getMessages(INFO))
+            .extracting(removingThreadId())
+            .containsExactly(
+                "FilteredNodeSimilarity :: Start",
+                "FilteredNodeSimilarity :: prepare :: Start",
+                "FilteredNodeSimilarity :: prepare 33%",
+                "FilteredNodeSimilarity :: prepare 55%",
+                "FilteredNodeSimilarity :: prepare 66%",
+                "FilteredNodeSimilarity :: prepare 100%",
+                "FilteredNodeSimilarity :: prepare :: Finished",
+                "FilteredNodeSimilarity :: compare node pairs :: Start",
+                "FilteredNodeSimilarity :: compare node pairs 12%",
+                "FilteredNodeSimilarity :: compare node pairs 25%",
+                "FilteredNodeSimilarity :: compare node pairs 37%",
+                "FilteredNodeSimilarity :: compare node pairs 50%",
+                "FilteredNodeSimilarity :: compare node pairs 62%",
+                "FilteredNodeSimilarity :: compare node pairs 75%",
+                "FilteredNodeSimilarity :: compare node pairs 100%",
+                "FilteredNodeSimilarity :: compare node pairs :: Finished",
+                "FilteredNodeSimilarity :: Finished"
+            );
+    }
 }