Performance improvements of graph calculations (#151)

* Move mutation methods out of the DependencyGraph to signal the graph is immutable after creation

* Add test for a very large graph

Author: jraska

plugin/src/main/kotlin/com/jraska/module/graph/DependencyGraph.kt

@@ -61,11 +61,14 @@ class DependencyGraph private constructor() {
   fun subTree(key: String): DependencyGraph {
     require(nodes.contains(key)) { "Dependency Tree doesn't contain module: $key" }
 
-    val dependencyTree = createSingular(key)
+    val connections = mutableListOf<Pair<String, String>>()
+    addConnections(nodes.getValue(key), connections)
 
-    addConnections(nodes.getValue(key), dependencyTree)
-
-    return dependencyTree
+    return if (connections.isEmpty()) {
+      createSingular(key)
+    } else {
+      create(connections)
+    }
   }
 
   fun serializableGraph(): SerializableGraph {
@@ -75,25 +78,17 @@ class DependencyGraph private constructor() {
     )
   }
 
-  private fun addConnections(node: Node, into: DependencyGraph) {
+  private fun addConnections(node: Node, into: MutableList<Pair<String, String>>) {
     node.dependsOn.forEach {
-      into.addEdge(node.key, it.key)
+      into.add(node.key to it.key)
       addConnections(it, into)
     }
   }
 
-  private fun addEdge(from: String, to: String) {
-    getOrCreate(from).dependsOn.add(getOrCreate(to))
-  }
-
   private fun countEdges(): Int {
     return nodes().flatMap { node -> node.dependsOn }.count()
   }
 
-  private fun getOrCreate(key: String): Node {
-    return nodes[key] ?: Node(key).also { nodes[key] = it }
-  }
-
   class SerializableGraph(
     val dependencyPairs: ArrayList<Pair<String, String>>,
     val firstModule: String
@@ -102,16 +97,20 @@ class DependencyGraph private constructor() {
   class Node(val key: String) {
     val dependsOn = mutableSetOf<Node>()
 
-    private fun isLeaf() = dependsOn.isEmpty()
-
-    fun height(): Int {
+    private val calculatedHeight by lazy {
       if (isLeaf()) {
-        return 0
+        0
       } else {
-        return 1 + dependsOn.map { it.height() }.maxOrNull()!!
+        1 + dependsOn.map { it.height() }.maxOrNull()!!
       }
     }
 
+    private fun isLeaf() = dependsOn.isEmpty()
+
+    fun height(): Int {
+      return calculatedHeight
+    }
+
     internal fun longestPath(): List<Node> {
       if (isLeaf()) {
         return listOf(this)
@@ -156,5 +155,13 @@ class DependencyGraph private constructor() {
         return create(graph.dependencyPairs)
       }
     }
+
+    private fun DependencyGraph.addEdge(from: String, to: String) {
+      getOrCreate(from).dependsOn.add(getOrCreate(to))
+    }
+
+    private fun DependencyGraph.getOrCreate(key: String): Node {
+      return nodes[key] ?: Node(key).also { nodes[key] = it }
+    }
   }
 }

plugin/src/test/kotlin/com/jraska/module/graph/DependencyGraphPerformanceTest.kt

@@ -0,0 +1,31 @@
+package com.jraska.module.graph
+
+import org.junit.Before
+import org.junit.Test
+import java.io.File
+
+class DependencyGraphPerformanceTest {
+  lateinit var dependencyGraph: DependencyGraph
+
+  @Before
+  fun setUp() {
+    val uri = javaClass.classLoader.getResource("graph/large-graph.txt")
+    val file = File(uri?.path!!)
+    val dependencyPairs = file.readLines().map {
+      val parts = it.split(" -> ")
+      parts[0] to parts[1]
+    }
+
+    dependencyGraph = DependencyGraph.create(dependencyPairs)
+  }
+
+  @Test(timeout = 1000) // 1000 ms is more than enough - it was taking hours before optimisations
+  fun whenTheGraphIsLarge_statisticsCalculatedFast() {
+    val statistics = dependencyGraph.statistics()
+
+    assert(statistics.height == 59)
+    assert(statistics.modulesCount == 1000)
+    assert(statistics.edgesCount == 15259)
+    assert(statistics.longestPath.pathString().startsWith("23 -> 31 -> 36 -> 57 -> 61 -> 72 -> 74 -> 75"))
+  }
+}