unify community algo results

algo/src/main/java/org/neo4j/graphalgo/LabelPropagationProc.java

@@ -105,15 +105,15 @@ public Stream<LabelPropagationStats> labelPropagation(
 
         if(graph.nodeCount() == 0) {
             graph.release();
-            return Stream.of(stats.build());
+            return Stream.of(LabelPropagationStats.EMPTY);
         }
 
-        int[] labels = compute(direction, iterations, batchSize, concurrency, graph, stats);
+        final int[] labels = compute(direction, iterations, batchSize, concurrency, graph, stats);
         if (configuration.isWriteFlag(DEFAULT_WRITE) && partitionProperty != null) {
             write(concurrency, partitionProperty, graph, labels, stats);
         }
 
-        return Stream.of(stats.build());
+        return Stream.of(stats.build(graph.nodeCount(), l -> (long) labels[(int) l]));
     }
 
     @Procedure(value = "algo.labelPropagation.stream")
@@ -205,7 +205,6 @@ private int[] compute(
 
             stats.iterations(labelPropagation.ranIterations());
             stats.didConverge(labelPropagation.didConverge());
-            stats.nodes(result.length);
 
             labelPropagation.release();
             graph.release();

algo/src/main/java/org/neo4j/graphalgo/LouvainProc.java

@@ -18,25 +18,27 @@
  */
 package org.neo4j.graphalgo;
 
+import com.carrotsearch.hppc.LongLongMap;
+import org.HdrHistogram.Histogram;
 import org.neo4j.graphalgo.api.*;
 import org.neo4j.graphalgo.core.GraphLoader;
 import org.neo4j.graphalgo.core.ProcedureConfiguration;
-import org.neo4j.graphalgo.core.ProcedureConstants;
-import org.neo4j.graphalgo.core.heavyweight.HeavyGraph;
-import org.neo4j.graphalgo.core.heavyweight.HeavyGraphFactory;
 import org.neo4j.graphalgo.core.utils.Pools;
 import org.neo4j.graphalgo.core.utils.ProgressLogger;
 import org.neo4j.graphalgo.core.utils.ProgressTimer;
 import org.neo4j.graphalgo.core.utils.TerminationFlag;
 import org.neo4j.graphalgo.core.utils.paged.AllocationTracker;
 import org.neo4j.graphalgo.impl.louvain.*;
-import org.neo4j.graphalgo.results.LouvainResult;
+import org.neo4j.graphalgo.results.AbstractCommunityResultBuilder;
+import org.neo4j.graphalgo.results.DefaultCommunityResult;
 import org.neo4j.kernel.api.KernelTransaction;
-import org.neo4j.kernel.impl.store.PropertyType;
 import org.neo4j.kernel.internal.GraphDatabaseAPI;
 import org.neo4j.logging.Log;
 import org.neo4j.procedure.*;
 
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
 import java.util.Map;
 import java.util.stream.Stream;
 
@@ -75,18 +77,17 @@ public Stream<LouvainResult> louvain(
                 .overrideNodeLabelOrQuery(label)
                 .overrideRelationshipTypeOrQuery(relationship);
 
-        LouvainResult.Builder builder = LouvainResult.builder();
+
+        final Builder builder = new Builder();
 
         final Graph graph;
         try (ProgressTimer timer = builder.timeLoad()) {
             graph = graph(label, relationship, configuration);
         }
 
-        builder.withNodeCount(graph.nodeCount());
-
         if(graph.nodeCount() == 0) {
             graph.release();
-            return Stream.of(builder.build());
+            return Stream.of(LouvainResult.EMPTY);
         }
 
         final Louvain louvain = new Louvain(graph, Pools.DEFAULT, configuration.getConcurrency(), AllocationTracker.create())
@@ -102,14 +103,14 @@ public Stream<LouvainResult> louvain(
             } else {
                 louvain.compute(configuration.getIterations(10), configuration.get("innerIterations", 10));
             }
-            builder.withIterations(louvain.getLevel()).withCommunityCount(louvain.getCommunityCount());
         }
 
         if (configuration.isWriteFlag()) {
             builder.timeWrite(() -> write(graph, louvain.getDendrogram(), louvain.getCommunityIds(), configuration));
         }
 
-        return Stream.of(builder.build());
+        final int[] communityIds = louvain.getCommunityIds();
+        return Stream.of(builder.build(graph.nodeCount(), n -> (long) communityIds[(int) n]));
     }
 
     @Procedure(value = "algo.louvain.stream")
@@ -180,4 +181,100 @@ private void write(Graph graph, int[][] allCommunities, int[] finalCommunities,
                 configuration.get(INTERMEDIATE_COMMUNITIES_WRITE_PROPERTY, "communities"))
                 .export(allCommunities, finalCommunities, includeIntermediateCommunities);
     }
+
+    public static class LouvainResult {
+
+        public static final LouvainResult EMPTY = new LouvainResult(
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                -1,
+                -1,
+                -1,
+                -1,
+                -1,
+                -1,
+                -1,
+                -1,
+                -1,
+                Collections.emptyList(),
+                0
+        );
+
+        public final long loadMillis;
+        public final long computeMillis;
+        public final long postProcessingMillis;
+        public final long writeMillis;
+        public final long nodes;
+        public final long communityCount;
+        public final long p99;
+        public final long p95;
+        public final long p90;
+        public final long p75;
+        public final long p50;
+        public final long p25;
+        public final long p10;
+        public final long p05;
+        public final long p01;
+        public final List<Long> top3;
+        public final long iterations;
+
+        public LouvainResult(long loadMillis, long computeMillis, long postProcessingMillis, long writeMillis, long nodes, long communityCount, long p99, long p95, long p90, long p75, long p50, long p25, long p10, long p05, long p01, List<Long> top3, long iterations) {
+            this.loadMillis = loadMillis;
+            this.computeMillis = computeMillis;
+            this.postProcessingMillis = postProcessingMillis;
+            this.writeMillis = writeMillis;
+            this.nodes = nodes;
+            this.communityCount = communityCount;
+            this.p99 = p99;
+            this.p95 = p95;
+            this.p90 = p90;
+            this.p75 = p75;
+            this.p50 = p50;
+            this.p25 = p25;
+            this.p10 = p10;
+            this.p05 = p05;
+            this.p01 = p01;
+            this.top3 = top3;
+            this.iterations = iterations;
+        }
+    }
+
+    public static class Builder extends AbstractCommunityResultBuilder<LouvainResult> {
+
+        private long iterations = -1;
+
+        public Builder withIterations(long iterations) {
+            this.iterations = iterations;
+            return this;
+        }
+
+        @Override
+        protected LouvainResult build(long loadMillis, long computeMillis, long writeMillis, long postProcessingMillis, long nodeCount, long communityCount, LongLongMap communitySizeMap, Histogram communityHistogram, List<Long> top3Communities) {
+            return new LouvainResult(
+                    loadMillis,
+                    computeMillis,
+                    postProcessingMillis,
+                    writeMillis,
+                    nodeCount,
+                    communityCount,
+                    communityHistogram.getValueAtPercentile(.99),
+                    communityHistogram.getValueAtPercentile(.95),
+                    communityHistogram.getValueAtPercentile(.9),
+                    communityHistogram.getValueAtPercentile(.75),
+                    communityHistogram.getValueAtPercentile(.5),
+                    communityHistogram.getValueAtPercentile(.25),
+                    communityHistogram.getValueAtPercentile(.1),
+                    communityHistogram.getValueAtPercentile(.05),
+                    communityHistogram.getValueAtPercentile(.01),
+                    top3Communities,
+                    iterations
+            );
+        }
+    }
+
+
 }

algo/src/main/java/org/neo4j/graphalgo/MSColoringProc.java

@@ -26,7 +26,7 @@
 import org.neo4j.graphalgo.core.write.Exporter;
 import org.neo4j.graphalgo.core.write.Translators;
 import org.neo4j.graphalgo.impl.MSColoring;
-import org.neo4j.graphalgo.results.UnionFindResult;
+import org.neo4j.graphalgo.results.DefaultCommunityResult;
 import org.neo4j.graphdb.Direction;
 import org.neo4j.kernel.internal.GraphDatabaseAPI;
 import org.neo4j.logging.Log;
@@ -54,7 +54,7 @@ public class MSColoringProc {
     @Description("CALL algo.unionFind.mscoloring(label:String, relationship:String, " +
             "{property:'weight', threshold:0.42, defaultValue:1.0, write: true, partitionProperty:'partition', concurrency:4}) " +
             "YIELD nodes, setCount, loadMillis, computeMillis, writeMillis")
-    public Stream<UnionFindResult> unionFind(
+    public Stream<DefaultCommunityResult> unionFind(
             @Name(value = "label", defaultValue = "") String label,
             @Name(value = "relationship", defaultValue = "") String relationship,
             @Name(value = "config", defaultValue = "{}") Map<String, Object> config) {
@@ -63,7 +63,7 @@ public Stream<UnionFindResult> unionFind(
                 .overrideNodeLabelOrQuery(label)
                 .overrideRelationshipTypeOrQuery(relationship);
 
-        UnionFindResult.Builder builder = UnionFindResult.builder();
+        final DefaultCommunityResult.DefaultCommunityResultBuilder builder = new DefaultCommunityResult.DefaultCommunityResultBuilder();
 
         // loading
         final Graph graph;
@@ -73,7 +73,7 @@ public Stream<UnionFindResult> unionFind(
 
         if (graph.nodeCount() == 0) {
             graph.release();
-            return Stream.of(builder.build());
+            return Stream.of(DefaultCommunityResult.EMPTY);
         }
 
         // evaluation
@@ -88,7 +88,7 @@ public Stream<UnionFindResult> unionFind(
                     write(graph, struct, configuration));
         }
 
-        return Stream.of(builder.build());
+        return Stream.of(builder.build(graph.nodeCount(), n -> (long) struct.get((int) n)));
     }
 
     @Procedure(value = "algo.unionFind.mscoloring.stream")