Minor compiler optimizations

- Cache methods for behaviour lookups - Cache types more aggressively and prioritize assemblies more likely to contain needed types
MerlinVR · Mar 29, 2020 · a711a63 · a711a63
1 parent abe77da
commit a711a63
Show file tree

Hide file tree

Showing 2 changed files with 47 additions and 10 deletions.
diff --git a/Assets/UdonSharp/Editor/UdonSharpExpressionCapture.cs b/Assets/UdonSharp/Editor/UdonSharpExpressionCapture.cs
@@ -1511,21 +1511,36 @@ private bool HandleLocalMethodLookup(string localMethodName)
             return true;
         }
 
+        private static Dictionary<(System.Type, BindingFlags), MethodInfo[]> typeMethodCache = new Dictionary<(System.Type, BindingFlags), MethodInfo[]>();
+
+        private static MethodInfo[] GetTypeMethods(System.Type type, BindingFlags bindingFlags)
+        {
+            MethodInfo[] methods;
+            if (!typeMethodCache.TryGetValue((type, bindingFlags), out methods))
+            {
+                methods = type.GetMethods(bindingFlags);
+                typeMethodCache.Add((type, bindingFlags), methods);
+            }
+
+            return methods;
+        }
+
         private bool HandleLocalUdonBehaviourMethodLookup(string localUdonMethodName)
         {
-            MethodInfo[] foundMethods = typeof(VRC.Udon.Common.Interfaces.IUdonEventReceiver).GetMethods(BindingFlags.Instance | BindingFlags.Public).Where(e => e.Name == localUdonMethodName).ToArray();
-            foundMethods = foundMethods.Concat(typeof(Component).GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.Static | BindingFlags.FlattenHierarchy).Where(e => e.Name == localUdonMethodName)).ToArray();
-            foundMethods = foundMethods.Concat(typeof(Object).GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.Static | BindingFlags.FlattenHierarchy).Where(e => e.Name == localUdonMethodName)).ToArray();
-            foundMethods = foundMethods.Distinct().ToArray();
+            List<MethodInfo> methods = new List<MethodInfo>(GetTypeMethods(typeof(VRC.Udon.Common.Interfaces.IUdonEventReceiver), BindingFlags.Instance | BindingFlags.Public));
+            methods.AddRange(GetTypeMethods(typeof(Component), BindingFlags.Instance | BindingFlags.Public | BindingFlags.Static | BindingFlags.FlattenHierarchy));
+            methods.AddRange(GetTypeMethods(typeof(Object), BindingFlags.Instance | BindingFlags.Public | BindingFlags.Static | BindingFlags.FlattenHierarchy));
 
             if (localUdonMethodName == "VRCInstantiate")
-                foundMethods = foundMethods.Concat(typeof(UdonSharpBehaviour).GetMethods(BindingFlags.Static | BindingFlags.Public).Where(e => e.Name == localUdonMethodName)).ToArray();
+                methods.AddRange(GetTypeMethods(typeof(UdonSharpBehaviour), BindingFlags.Static | BindingFlags.Public));
+
+            IEnumerable<MethodInfo> foundMethods = methods.Where(e => e.Name == localUdonMethodName).Distinct();
 
-            if (foundMethods.Length == 0)
+            if (foundMethods.Count() == 0)
                 return false;
 
             accessSymbol = visitorContext.topTable.CreateThisSymbol(visitorContext.behaviourUserType);
-            captureMethods = foundMethods;
+            captureMethods = foundMethods.ToArray();
             captureArchetype = ExpressionCaptureArchetype.Method;
 
             return true;

diff --git a/Assets/UdonSharp/Editor/UdonSharpResolverContext.cs b/Assets/UdonSharp/Editor/UdonSharpResolverContext.cs
@@ -212,6 +212,8 @@ public string ParseBuiltinTypeAlias(string typeName)
             return typeName;
         }
 
+        private static List<Assembly> loadedAssemblyCache = null;
+
         public System.Type ResolveExternType(string qualifiedTypeName)
         {
             qualifiedTypeName = ParseBuiltinTypeAlias(qualifiedTypeName);
@@ -239,18 +241,38 @@ public System.Type ResolveExternType(string qualifiedTypeName)
 
                 if (foundType != null)
                 {
-                    typeLookupCache.Add(testFullyQualifiedType, foundType);
+                    if (!typeLookupCache.ContainsKey(qualifiedTypeName))
+                        typeLookupCache.Add(qualifiedTypeName, foundType);
+                    if (!typeLookupCache.ContainsKey(testFullyQualifiedType))
+                        typeLookupCache.Add(testFullyQualifiedType, foundType);
                     return foundType;
                 }
                 else // Type wasn't found in current assembly, look through all loaded assemblies
                 {
-                    foreach (Assembly assembly in System.AppDomain.CurrentDomain.GetAssemblies())
+                    if (loadedAssemblyCache == null)
                     {
+                        loadedAssemblyCache = System.AppDomain.CurrentDomain.GetAssemblies()
+                            .OrderBy(e =>
+                                e.GetName().Name.Contains("UnityEngine") ||
+                                e.GetName().Name.Contains("System") || 
+                                e.GetName().Name.Contains("VRC") ||
+                                e.GetName().Name.Contains("Udon") || 
+                                e.GetName().Name.Contains("Assembly-CSharp") ||
+                                e.GetName().Name.Contains("mscorlib")).Reverse().ToList();
+                    }
+
+                    foreach (Assembly assembly in loadedAssemblyCache)
+                    { 
                         foundType = assembly.GetType(testFullyQualifiedType);
 
                         if (foundType != null)
                         {
-                            typeLookupCache.Add(testFullyQualifiedType, foundType);
+                            //Debug.Log($"Found type {foundType} in assembly {assembly.GetName().Name}");
+
+                            if (!typeLookupCache.ContainsKey(qualifiedTypeName)) 
+                                typeLookupCache.Add(qualifiedTypeName, foundType);
+                            if (!typeLookupCache.ContainsKey(testFullyQualifiedType))
+                                typeLookupCache.Add(testFullyQualifiedType, foundType);
                             return foundType;
                         }
                     }