DYN-2226: Graphs with large node quantities cause long delays when setting element bound Revit nodes to update (#10083)

saintentropy · aparajit-pratap · commit 9115b988e575 · 2019-11-22T11:17:26.000-05:00
* Add Map for Node guids to Callsite identifier strings

* Load RuntimeData map for Node guids to Callsite identifier strings on Callsite construction

* look up matching callsites directly for a node Guid with maps versus interaction with instruction stream data

* Add test to validate map for node to callsite identifier is intialized and used correctly

* Remove c#7 inline out variable declaration

* remove more inline declaration

* Remove graphnode check

* Change map from callsiteIdentifier to callsite object

* Update test strings

* make new property internal

* add code comments
diff --git a/src/Engine/ProtoCore/Properties/AssemblyInfo.cs b/src/Engine/ProtoCore/Properties/AssemblyInfo.cs
@@ -12,4 +12,5 @@
 [assembly: InternalsVisibleTo("ProtoTest")]
 [assembly: InternalsVisibleTo("ProtoTestFx")]
 [assembly: InternalsVisibleTo("DynamoCoreTests")]
+[assembly: InternalsVisibleTo("DynamoCoreWpfTests")]
 
diff --git a/src/Engine/ProtoCore/RuntimeData.cs b/src/Engine/ProtoCore/RuntimeData.cs
@@ -46,23 +46,25 @@ public class RuntimeData
         /// Map from a callsite's guid to a graph UI node. 		
         /// </summary>
         public Dictionary<Guid, Guid> CallSiteToNodeMap { get; }
- 		 
- #endregion
+        /// <summary>		
+        /// Map from a graph UI node to callsite identifiers. 		
+        /// </summary>
+        internal Dictionary<Guid, List<CallSite>> NodeToCallsiteObjectMap { get; }
+        
+#endregion
 
         public RuntimeData()
         {
             CallsiteCache = new Dictionary<string, CallSite>();
             CallSiteToNodeMap = new Dictionary<Guid, Guid>();
+            NodeToCallsiteObjectMap = new Dictionary<Guid, List<CallSite>>();
         }
 
-      
 
         /// <summary>
         /// Retrieves an existing instance of a callsite associated with a UID
         /// It creates a new callsite if non was found
         /// </summary>
-        /// <param name="core"></param>
-        /// <param name="uid"></param>
         /// <returns></returns>
         public CallSite GetCallSite(int classScope, string methodName, Executable executable, RuntimeCore runtimeCore)
         {
@@ -120,6 +122,15 @@ public CallSite GetCallSite(int classScope, string methodName, Executable execut
 
                 CallsiteCache[callsiteID] = csInstance;
                 CallSiteToNodeMap[csInstance.CallSiteID] = topGraphNode.guid;
+                List<CallSite> callsites;
+                if (NodeToCallsiteObjectMap.TryGetValue(topGraphNode.guid, out callsites))
+                {
+                    callsites.Add(csInstance);
+                }
+                else
+                {
+                    NodeToCallsiteObjectMap[topGraphNode.guid] = new List<CallSite>() { csInstance };
+                }
             }
 
             if (graphNode != null && !CoreUtils.IsDisposeMethod(methodName))
@@ -134,8 +145,15 @@ public CallSite GetCallSite(int classScope, string methodName, Executable execut
             return csInstance;
         }
 
-        public Dictionary<Guid, List<CallSite>>
-        GetCallsitesForNodes(IEnumerable<Guid> nodeGuids, Executable executable)
+        /// <summary>
+        /// This API is used by host integrations such as for Revit and C3D.
+        /// It is used to gets the trace data list for all nodes binding to elements in the host.
+        /// </summary>
+        /// <param name="nodeGuids"></param>
+        /// <param name="executable"></param>
+        /// <returns></returns>
+        public Dictionary<Guid, List<CallSite>> GetCallsitesForNodes(
+            IEnumerable<Guid> nodeGuids, Executable executable)
         {
             if (nodeGuids == null)
                 throw new ArgumentNullException("nodeGuids");
@@ -145,41 +163,17 @@ public Dictionary<Guid, List<CallSite>>
             if (!nodeGuids.Any()) // Nothing to persist now.
                 return nodeMap;
 
-            // Attempt to get the list of graph node if one exists.
-            IEnumerable<GraphNode> graphNodes = null;
+            List<CallSite> callsites;
+            foreach (Guid nodeGuid in nodeGuids)
             {
-                if (executable != null)
+                if (NodeToCallsiteObjectMap.TryGetValue(nodeGuid, out callsites))
                 {
-                    var stream = executable.instrStreamList;
-                    if (stream != null && (stream.Length > 0))
-                    {
-                        var graph = stream[0].dependencyGraph;
-                        if (graph != null)
-                            graphNodes = graph.GraphList;
-                    }
+                    nodeMap[nodeGuid] = callsites;
+                }
+                else
+                {
+                    nodeMap[nodeGuid] = new List<CallSite>();
                 }
-
-
-                if (graphNodes == null) // No execution has taken place.
-                    return nodeMap;
-            }
-
-            foreach (Guid nodeGuid in nodeGuids)
-            {
-                // Get a list of GraphNode objects that correspond to this node.
-                var matchingGraphNodes = graphNodes.Where(gn => gn.guid == nodeGuid);
-
-                if (!matchingGraphNodes.Any())
-                    continue;
-
-                // Get all callsites that match the graph node ids.
-                var matchingCallSites = (from cs in CallsiteCache
-                                         from gn in matchingGraphNodes
-                                         where string.Equals(cs.Key, gn.CallsiteIdentifier)
-                                         select cs.Value);
-
-                // Append each callsite element under node element.
-                nodeMap[nodeGuid] = matchingCallSites.ToList();
             }
 
             return nodeMap;
diff --git a/test/DynamoCoreWpfTests/RecordedTests.cs b/test/DynamoCoreWpfTests/RecordedTests.cs
@@ -21,6 +21,7 @@
 using Dynamo.ViewModels;
 using DynamoShapeManager;
 using NUnit.Framework;
+using ProtoCore;
 using PythonNodeModels;
 using SystemTestServices;
 using TestServices;
@@ -2770,6 +2771,63 @@ public void TestCallsiteMapModifyInputConnection()
             });
         }
 
+        [Test, RequiresSTA]
+        public void TestNodeToCallsitesObjMapModifyInputConnection()
+        {
+            Guid callsiteIdFirstCall = new Guid();
+            Guid callsiteIdSecondCall = new Guid();
+            Guid functionCallNodeGuid = new Guid("16e960e5-8a24-44e7-ac81-3759aaf11d25");
+
+            preloadGeometry = true;
+            RunCommandsFromFile("TestCallsiteMapModifyModifyInputConnection.xml", (commandTag) =>
+            {
+                ProtoCore.RuntimeCore core = ViewModel.Model.EngineController.LiveRunnerRuntimeCore;
+                if (commandTag == "ModifyX_FirstTime")
+                {
+                    // There must only be 1 node at this point
+                    Assert.AreEqual(1, core.RuntimeData.NodeToCallsiteObjectMap.Count);
+
+                    // Verify that the map contains the node guid
+                    List<CallSite> callSites;
+                    bool containsNodeGuid = core.RuntimeData.NodeToCallsiteObjectMap.TryGetValue(functionCallNodeGuid, out callSites);
+                    Assert.AreEqual(true, containsNodeGuid);
+
+                    // There must only be 1 callsite at this point
+                    Assert.AreEqual(1, callSites.Count);
+
+                    // Get the callsite id
+                    foreach (var cs in callSites)
+                    {
+                        callsiteIdFirstCall = cs.CallSiteID;
+                    }
+                }
+                else if (commandTag == "ModifyX_SecondTime")
+                {
+                    // There must only be 1 callsite at this point
+                    Assert.AreEqual(1, core.RuntimeData.NodeToCallsiteObjectMap.Count);
+
+                    // Verify that the map contains the node guid
+                    List<CallSite> callSites;
+                    bool containsNodeGuid = core.RuntimeData.NodeToCallsiteObjectMap.TryGetValue(functionCallNodeGuid, out callSites);
+                    Assert.AreEqual(true, containsNodeGuid);
+
+                    // There must still only be 1 callsite at this point
+                    Assert.AreEqual(1, callSites.Count);
+
+                    // Get the callsite id
+                    foreach (var cs in callSites)
+                    {
+                        callsiteIdSecondCall = cs.CallSiteID;
+                    }
+
+                    // The callsite guid must match 
+                    // This means that that the callsite was cached and reused
+                    Assert.AreEqual(callsiteIdFirstCall, callsiteIdSecondCall);
+                }
+
+            });
+        }
+
         [Test, RequiresSTA]
         [Category("RegressionTests")]
 
