feature: runtime cache for running a batch of node

TNode/TNodeCore/Runtime/Attribute/Ports/BatchInputAttribute.cs

@@ -1,5 +0,0 @@
-namespace TNodeCore.Attribute.Ports{
-    public class BatchInputAttribute{
-        
-    }
-}

TNode/TNodeCore/Runtime/Attributes/Ports/BatchInputAttribute.cs

@@ -0,0 +1,5 @@
+namespace TNode.TNodeCore.Runtime.Attributes.Ports{
+    public class BatchInputAttribute{
+        
+    }
+}

TNode/TNodeCore/Runtime/Attributes/Ports/PortAttribute.cs

@@ -22,6 +22,7 @@ namespace TNodeCore.Attribute.Ports{
         public readonly string Name;
         public readonly PortNameHandling NameHandling;
         public Type HandledType;
+        public bool Multiple = true;
         public TypeHandling TypeHandling{ get; set; }
         public PortAttribute(string name,PortNameHandling nameHandling=PortNameHandling.Auto,TypeHandling typeHandling=TypeHandling.Declared){
             this.Name = name;

TNode/TNodeCore/Runtime/Components/RuntimeGraph.cs

@@ -17,6 +17,8 @@ namespace TNodeCore.Components{
             [NonSerialized]
             public readonly List<RuntimeNode> TopologicalOrder = new List<RuntimeNode>();
             public readonly List<RuntimeNode> EntryNodes = new List<RuntimeNode>();
+            public readonly Dictionary<string, object> OutputCached = new Dictionary<string, object>();
+            private bool _isCachingOutput = false;
             /// <summary>
             /// elements are read only ,do not modify them
             /// </summary>
@@ -30,24 +32,52 @@ namespace TNodeCore.Components{
                     node.NodeData.Process();
                 }
             }
-            public void DependencyTraversal(RuntimeNode runtimeNode){
+            //Cache outport info in the graph tool so that we can directly access it in the traversal
+            public void StartCachingPort(){
+                _isCachingOutput = true;
+            }
+            public void EndCachingPort(){
+                _isCachingOutput = false;
+                OutputCached.Clear();
+            }
+            public void ResolveDependency(RuntimeNode runtimeNode,int dependencyLevel=0){
                 var links = runtimeNode.InputLink;
                 foreach (var link in links){
                     var outputNode = RuntimeNodes[link.outPort.nodeDataId];
-                    DependencyTraversal(outputNode);
+                    ResolveDependency(outputNode,dependencyLevel+1);
                     HandlingLink(link);
                 }
+
+                if (dependencyLevel > DependencyLevelMax){
+                    throw new Exception("Dependency anomaly detected,check if there is a loop in the graph");
+                }
+
+       
+                //if the runtime node has no output ,it will not be processed
+                if (runtimeNode.OutputLink.Count == 0 && dependencyLevel != 0){
+                    return;
+                }
                 runtimeNode.NodeData.Process();
+                
+          
             }
 
+            private const int DependencyLevelMax = 1145;
+
             public void HandlingLink(NodeLink nodeLink){
+                //out node is node output data
+                //in node is node receive data
                 var inNode = RuntimeNodes[nodeLink.inPort.nodeDataId];
                 var outNode = RuntimeNodes[nodeLink.outPort.nodeDataId];
                 
-                //out node is node output data
-                //in node is node receive data
-                var outValue = outNode.GetOutput(nodeLink.outPort.portEntryName);
                 
+                //TODO looks like this string would be too long to make a cache
+                
+                var cachedKey = $"{outNode.NodeData.id}-{nodeLink.inPort.portEntryName}";
+                var outValue = OutputCached.ContainsKey(cachedKey) ? OutputCached[cachedKey] : outNode.GetOutput(nodeLink.outPort.portEntryName);;
+                if (_isCachingOutput){
+                    OutputCached[cachedKey] = outValue;
+                }
                 inNode.SetInput(nodeLink.inPort.portEntryName, outValue);
             }
             public GraphTool(List<RuntimeNode> list, Dictionary<string, RuntimeNode> graphNodes){
@@ -125,12 +155,12 @@ namespace TNodeCore.Components{
             return null;
         }
         //DFS search for resolving dependency
-        public bool ResolveDependency(NodeData startNode){
+        public bool RunOnDependency(NodeData startNode){
             if(!_build)
                 Build();
             if (_graphTool == null)
                 return false;
-            _graphTool.DependencyTraversal(Get(startNode));
+            _graphTool.ResolveDependency(Get(startNode));
             return true;
         }
         public bool ResolveDependency(){
@@ -152,10 +182,20 @@ namespace TNodeCore.Components{
             
         }
         public List<RuntimeNode> GetRuntimeNodesOfType<T>(){
-            return RuntimeNodes.Values.Where(x => x.NodeType == typeof(T)).ToList();
+            return RuntimeNodes.Values.Where(x => typeof(T).IsAssignableFrom(x.NodeType)).ToList();
         }
         public  List<RuntimeNode> GetRuntimeNodesOfType(Type type){
-            return RuntimeNodes.Values.Where(x => x.NodeType == type).ToList();
+            return RuntimeNodes.Values.Where(x => type.IsAssignableFrom(type)).ToList();
+        }
+        public void RunNodesOfType(Type t){
+            var nodes = GetRuntimeNodesOfType(t);
+            _graphTool.StartCachingPort();
+            foreach (var runtimeNode in nodes){
+                RunOnDependency(runtimeNode.NodeData);
+            }
+            _graphTool.EndCachingPort();
+            
+            
         }
         private void ModifyOrCreateOutNode(NodeLink linkData){
             var outNodeId = linkData.outPort.nodeDataId;
@@ -170,7 +210,7 @@ namespace TNodeCore.Components{
         public void OnValidate(){
             if(runtimeBlackboardData==null||runtimeBlackboardData.GetType()==typeof(BlackboardData)){
                 if (graphData != null)
-                    runtimeBlackboardData = graphData.blackboardData.Clone() as BlackboardData;
+                    runtimeBlackboardData = graphData.blackboardData?.Clone() as BlackboardData;
             }
         }
 
@@ -186,6 +226,7 @@ namespace TNodeCore.Components{
 
         public void Start(){
             Build();
+          
         }
         public virtual void RuntimeExecute(){
             _graphTool.DirectlyTraversal();

TNode/TNodeCore/Runtime/RuntimeCache/RuntimeCache.cs

@@ -267,6 +267,9 @@ namespace TNodeCore.RuntimeCache{
             return (T) method.Invoke(data);
         }
         public static object GetValue(this  IModel data, string path,Type type=null){
+            if(!RuntimeCache.Instance.CachedDelegatesForGettingValue.ContainsKey(type??data.GetType())){
+                return null;
+            }
             var dic = RuntimeCache.Instance.CachedDelegatesForGettingValue[type ?? data.GetType()];
             var method = dic.ContainsKey(path) ? dic[path] : null;
             return method?.Invoke(data);

TNode/TNodeGraphViewImpl/Editor/Inspector/NodeInspectorInNode.cs

@@ -80,7 +80,7 @@ namespace TNode.Editor.Inspector{
                     if(!test.IsRuntimeGraph) return;
                     var runtimeGraph = test.GetRuntimeGraph();
                     if (runtimeGraph != null){
-                       var res = runtimeGraph.ResolveDependency(_data);
+                       var res = runtimeGraph.RunOnDependency(_data);
                     }
                     _data.OnTest();
                 }

TNode/TNodeGraphViewImpl/Editor/NodeViews/NodeView.cs

@@ -105,7 +105,8 @@ namespace TNodeGraphViewImpl.Editor.NodeViews{
    
             foreach (var propertyInfo in propertyInfos){
                 if (propertyInfo.GetCustomAttributes(typeof(OutputAttribute),true).FirstOrDefault() is OutputAttribute attribute){
-                    Port port = InstantiatePort(Orientation.Horizontal, Direction.Output,Port.Capacity.Multi,BuildPortType(attribute,propertyInfo));
+             
+                    Port port = InstantiatePort(Orientation.Horizontal, Direction.Output,attribute.Multiple?Port.Capacity.Multi:Port.Capacity.Single,BuildPortType(attribute,propertyInfo));
                     this.outputContainer.Add(port);
                     var portName = ObjectNames.NicifyVariableName(BuildPortName(attribute,propertyInfo));
                     port.portName = portName;
@@ -115,7 +116,7 @@ namespace TNodeGraphViewImpl.Editor.NodeViews{
             }
             foreach (var propertyInfo in propertyInfos){
                 if(propertyInfo.GetCustomAttributes(typeof(InputAttribute),true).FirstOrDefault() is InputAttribute attribute){
-                    Port port = InstantiatePort(Orientation.Horizontal, Direction.Input,Port.Capacity.Single,BuildPortType(attribute,propertyInfo));
+                    Port port = InstantiatePort(Orientation.Horizontal, Direction.Input,attribute.Multiple?Port.Capacity.Multi:Port.Capacity.Single,BuildPortType(attribute,propertyInfo));
                     this.inputContainer.Add(port);
                     var portName = BuildPortName(attribute,propertyInfo);
                     port.portName = portName;