perf(bulk-model-sync): use lightweight node reference instead of nodes in critical indices

An example are `MPSNode`s and `MPSModelReference`s used during importing into MPS.
`MPSNode` (an `INode`) uses more memory because it references an `SNode` and prevents it from being garbage collected.
`MPSModelReference` (an `INodeReference`) is much lighter because it only references `SModelReference`.
`MPSModelReference` only needs to be resolved to `MPSNode` in the special case when a node was moved.

Author: Oleksandr Dzhychko

bulk-model-sync-lib/src/commonMain/kotlin/org/modelix/model/sync/bulk/ModelImporter.kt

@@ -25,6 +25,7 @@ import org.modelix.model.api.SerializedNodeReference
 import org.modelix.model.api.getDescendants
 import org.modelix.model.api.isChildRoleOrdered
 import org.modelix.model.api.remove
+import org.modelix.model.api.resolveInCurrentContext
 import org.modelix.model.data.ModelData
 import org.modelix.model.data.NodeData
 import kotlin.jvm.JvmName
@@ -50,7 +51,13 @@ class ModelImporter(
 ) {
     // We have seen imports where the `originalIdToExisting` had a dozen ten million entries.
     // Therefore, choose a map with is optimized for memory usage.
-    private var originalIdToExisting = MemoryEfficientMap<String, INode>()
+    // For the same reason store `INodeReference`s instead of `INode`s.
+    // In a few cases, where we need the `INode` we can resolve it.
+    private var originalIdToExisting = MemoryEfficientMap<String, INodeReference>()
+
+    // Use`INode` instead of `INodeReference` in `postponedReferences` and `nodesToRemove`
+    // because we know that we will always need the `INode`s in those cases.
+    // Those cases are deleting nodes and adding references to nodes.
     private val postponedReferences = mutableListOf<PostponedReference>()
     private val nodesToRemove = HashSet<INode>()
     private var numExpectedNodes = 0
@@ -109,7 +116,7 @@ class ModelImporter(
             buildExistingIndex(root)
 
             logger.info { "Importing nodes..." }
-            data.root.originalId()?.let { originalIdToExisting[it] = root }
+            data.root.originalId()?.let { originalIdToExisting[it] = root.reference }
             syncNode(root, data.root, progressReporter)
 
             logger.info { "Synchronizing references..." }
@@ -162,7 +169,7 @@ class ModelImporter(
                         val expectedId = expected.originalId()
                         checkNotNull(expectedId) { "Specified node '$expected' has no ID." }
                         newChild.setPropertyValue(NodeData.idPropertyKey, expectedId)
-                        originalIdToExisting[expectedId] = newChild
+                        originalIdToExisting[expectedId] = newChild.reference
                         syncNode(newChild, expected, progressReporter)
                     }
                 continue
@@ -197,13 +204,18 @@ class ModelImporter(
                 val nodeAtIndex = existingChildren.getOrNull(newIndex)
                 val expectedConcept = expected.concept?.let { s -> ConceptReference(s) }
                 val childNode = if (nodeAtIndex?.originalId() != expectedId) {
-                    val existingNode = originalIdToExisting[expectedId]
-                    if (existingNode == null) {
+                    val existingNodeReference = originalIdToExisting[expectedId]
+                    if (existingNodeReference == null) {
                         val newChild = existingParent.addNewChild(role, newIndex, expectedConcept)
                         newChild.setPropertyValue(NodeData.idPropertyKey, expectedId)
-                        originalIdToExisting[expectedId] = newChild
+                        originalIdToExisting[expectedId] = newChild.reference
                         newChild
                     } else {
+                        val existingNode = existingNodeReference.resolveInCurrentContext()
+                        checkNotNull(existingNode) {
+                            // This reference should always be resolvable because the node existed or was created before.
+                            "Could not resolve $existingNodeReference."
+                        }
                         // The existing child node is not only moved to a new index,
                         // it is potentially moved to a new parent and role.
                         existingParent.moveChild(role, newIndex, existingNode)
@@ -230,7 +242,7 @@ class ModelImporter(
 
     private fun buildExistingIndex(root: INode) {
         root.getDescendants(true).forEach { node ->
-            node.originalId()?.let { originalIdToExisting[it] = node }
+            node.originalId()?.let { originalIdToExisting[it] = node.reference }
         }
     }
 

mps-model-adapters/src/main/kotlin/org/modelix/model/mpsadapters/MPSArea.kt

@@ -19,6 +19,7 @@ import jetbrains.mps.project.facets.JavaModuleFacet
 import jetbrains.mps.project.structure.modules.ModuleReference
 import jetbrains.mps.smodel.GlobalModelAccess
 import jetbrains.mps.smodel.SNodePointer
+import org.jetbrains.mps.openapi.model.SNodeReference
 import org.jetbrains.mps.openapi.module.SRepository
 import org.jetbrains.mps.openapi.persistence.PersistenceFacade
 import org.modelix.model.api.IBranch
@@ -54,6 +55,11 @@ data class MPSArea(val repository: SRepository) : IArea, IAreaReference {
     }
 
     override fun resolveNode(ref: INodeReference): INode? {
+        // By far, the most common case is to resolve a MPSNodeReference.
+        // Optimize for that case by not serializing and doing string operations.
+        if (ref is MPSNodeReference) {
+            return resolveSNodeReferenceToMPSNode(ref.ref)
+        }
         val serialized = ref.serialize()
         val prefix = serialized.substringBefore(":")
         return when (prefix) {
@@ -138,18 +144,19 @@ data class MPSArea(val repository: SRepository) : IArea, IAreaReference {
     }
 
     private fun resolveMPSNodeReference(ref: INodeReference): MPSNode? {
-        val sNodeReference = if (ref is MPSNodeReference) {
-            ref.ref
-        } else {
-            val serialized = ref.serialize()
-            val serializedMPSRef = when {
-                serialized.startsWith("mps-node:") -> serialized.substringAfter("mps-node:")
-                serialized.startsWith("mps:") -> serialized.substringAfter("mps:")
-                else -> return null
-            }
-            SNodePointer.deserialize(serializedMPSRef)
+        if (ref is MPSNodeReference) {
+            return resolveSNodeReferenceToMPSNode(ref.ref)
         }
+        val serialized = ref.serialize()
+        val serializedMPSRef = when {
+            serialized.startsWith("mps-node:") -> serialized.substringAfter("mps-node:")
+            serialized.startsWith("mps:") -> serialized.substringAfter("mps:")
+            else -> return null
+        }
+        return resolveSNodeReferenceToMPSNode(SNodePointer.deserialize(serializedMPSRef))
+    }
 
+    private fun resolveSNodeReferenceToMPSNode(sNodeReference: SNodeReference): MPSNode? {
         return sNodeReference.resolve(repository)?.let { MPSNode(it) }
     }