feat(model-datastructure): optimize merge algorithm

Author: Oleksandr Dzhychko

model-datastructure/src/commonMain/kotlin/org/modelix/model/LinearHistory.kt

@@ -9,7 +9,7 @@ class LinearHistory(val baseVersionHash: String?) {
      * This means that a version must come after all its descendants.
      * Returns the ordered versions starting with the earliest version.
      */
-    fun loadLazy(vararg fromVersions: CLVersion) = sequence {
+    fun computeHistoryLazy(vararg fromVersions: CLVersion) = sequence {
         // The algorithm sorts the versions topologically.
         // It performs a depth-first search.
         // It is implemented as an iterative algorithm with a stack.
@@ -31,9 +31,7 @@ class LinearHistory(val baseVersionHash: String?) {
                 val versionWasVisited = !visited.add(version)
                 if (versionWasVisited) {
                     stack.removeLast()
-                    if (!version.isMerge()) {
-                        yield(version)
-                    }
+                    yield(version)
                 }
                 val descendants = if (version.isMerge()) {
                     // Put version 1 last, so that is processed first.
@@ -52,9 +50,9 @@ class LinearHistory(val baseVersionHash: String?) {
     }
 
     /**
-     * Same as [[loadLazy]], but returning as a list instead of a lazy sequence.
+     * Same as [[computeHistoryLazy]], but returning as a list instead of a lazy sequence and omitting merge versions.
      */
-    fun load(vararg fromVersions: CLVersion): List<CLVersion> {
-        return loadLazy(*fromVersions).toList()
+    fun computeHistoryWithoutMerges(vararg fromVersions: CLVersion): List<CLVersion> {
+        return computeHistoryLazy(*fromVersions).filterNot { it.isMerge() }.toList()
     }
 }

model-datastructure/src/commonMain/kotlin/org/modelix/model/VersionMerger.kt

@@ -51,23 +51,25 @@ class VersionMerger(private val storeCache: IDeserializingKeyValueStore, private
         if (commonBase?.hash == leftVersion.hash) return rightVersion
         if (commonBase?.hash == rightVersion.hash) return leftVersion
 
-        val leftNonMerges = LinearHistory(commonBase?.hash).loadLazy(leftVersion).toSet()
-        val rightNonMerges = LinearHistory(commonBase?.hash).loadLazy(rightVersion).toSet()
-        if (leftNonMerges == rightNonMerges) {
-            // If there is no actual change on both sides, but they just did the same merge, we have to pick one
-            // of them, otherwise both sides will continue creating merges forever.
-            return if (leftVersion.id < rightVersion.id) leftVersion else rightVersion
-        }
-        if (leftNonMerges.containsAll(rightNonMerges)) {
+        val leftVersions = LinearHistory(commonBase?.hash).computeHistoryLazy(leftVersion)
+        if (leftVersions.contains(rightVersion)) {
             // No merge needed, fast-forward to the left version
             return leftVersion
         }
-        if (rightNonMerges.containsAll(leftNonMerges)) {
+        val rightVersions = LinearHistory(commonBase?.hash).computeHistoryLazy(rightVersion)
+        if (rightVersions.contains(leftVersion)) {
             // No merge needed, fast-forward to the right version
             return rightVersion
         }
+        val leftNonMerges = leftVersions.filterNot { it.isMerge() }.toSet()
+        val rightNonMerges = rightVersions.filterNot { it.isMerge() }.toSet()
+        if (leftNonMerges == rightNonMerges) {
+            // If there is no actual change on both sides, but they just did the same merge, we have to pick one
+            // of them, otherwise both sides will continue creating merges forever.
+            return if (leftVersion.id < rightVersion.id) leftVersion else rightVersion
+        }
 
-        val versionsToApply = LinearHistory(commonBase?.hash).load(leftVersion, rightVersion)
+        val versionsToApply = LinearHistory(commonBase?.hash).computeHistoryWithoutMerges(leftVersion, rightVersion)
 
         val operationsToApply = versionsToApply.flatMap { captureIntend(it) }
         var mergedVersion: CLVersion? = null

model-datastructure/src/commonMain/kotlin/org/modelix/model/lazy/CLVersion.kt

@@ -324,7 +324,7 @@ private fun computeDelta(keyValueStore: IKeyValueStore, versionHash: String, bas
 //            VersionMerger(store, IdGenerator.newInstance(0)).mergeChange(version, baseVersion)
 //        }
 
-        val history = LinearHistory(baseVersionHash).load(version)
+        val history = LinearHistory(baseVersionHash).computeHistoryWithoutMerges(version)
         val bulkQuery = BulkQuery(store)
         var v1 = baseVersion
         for (v2 in history) {

model-datastructure/src/commonTest/kotlin/LinearHistoryTest.kt

@@ -197,7 +197,7 @@ class LinearHistoryTest {
 
     private fun history(v1: CLVersion, v2: CLVersion): List<CLVersion> {
         val base = VersionMerger.commonBaseVersion(v1, v2)
-        val history = LinearHistory(base?.getContentHash()).load(v1, v2)
+        val history = LinearHistory(base?.getContentHash()).computeHistoryWithoutMerges(v1, v2)
         assertHistoryIsCorrect(history)
         return history
     }

model-datastructure/src/commonTest/kotlin/UndoTest.kt

@@ -140,7 +140,7 @@ class UndoTest {
     }
 
     fun printHistory(version: CLVersion, store: IDeserializingKeyValueStore) {
-        LinearHistory(null).load(version).forEach {
+        LinearHistory(null).computeHistoryWithoutMerges(version).forEach {
             println("Version ${it.id.toString(16)} ${it.hash} ${it.author}")
             for (op in it.operations) {
                 println("    $op")

model-server/src/main/kotlin/org/modelix/model/server/handlers/HistoryHandler.kt

@@ -221,7 +221,7 @@ class HistoryHandler(val client: IModelClient, private val repositoriesManager:
                     if (rowIndex >= skip) {
                         createTableRow(version, latestVersion)
                         if (version.isMerge()) {
-                            for (v in LinearHistory(version.baseVersion!!.getContentHash()).load(version.getMergedVersion1()!!, version.getMergedVersion2()!!)) {
+                            for (v in LinearHistory(version.baseVersion!!.getContentHash()).computeHistoryWithoutMerges(version.getMergedVersion1()!!, version.getMergedVersion2()!!)) {
                                 createTableRow(v, latestVersion)
                                 rowIndex++
                                 if (rowIndex >= skip + limit) {