Startup performance improvements (less reflection)

Java.Interop uses the `JniAddNativeMethodRegistrationAttribute` custom
attribute to determine whether to register native methods for a given
type. It turns out that in most cases there isn't a single instance of
this attribute throughout the application and all the calls to
`GetCustomAttribute` end up returning nothing while incurring a large
performance penalty on application startup.

Eliminate the call after checking that no type in the application is
decorated with the above custom attribute.

Another observation made while profiling a couple of XA applications was
that the installation of the uncaught exception handler with
`Java.Lang.Thread` was quite expensive while, in most cases, completely
not useful during startup (and, hopefully, during application lifetime).
Instead of registering a managed type to handle the exceptions, register
the handler in Java which then calls down to Xamarin.Android native
runtime which, in turn, propagates the exception to the managed code.

Gains in startup time are quite nice:

Device name: **Pixel 3 XL**
Device architecture: **arm64-v8a**
Number of test runs: **10**
Test application: **Xamarin.Forms integration test**

|                 | **Native to managed**  | **Runtime init** | **Displayed** | **Notes**                      |
|-----------------|------------------------|------------------|---------------|--------------------------------|
| **master**      | 131.278                | 149.074          | 789.10        |  preload enabled; 32-bit build |
| **this commit** | 50.637                 | 68.323           | 783.50        |                                |
| **master**      | 132.315                | 147.187          | 795.60        | preload disabled; 32-bit build |
| **this commit** | 50.972                 | 65.785           | 787.90        |                                |
| **master**      | 121.544                | 137.736          | 728.20        |  preload enabled; 64-bit build |
| **this commit** | 47.804                 | 64.003           | 739.70        |                                |
| **master**      | 123.448                | 137.052          | 727.40        | preload disabled; 64-bit build |
| **this commit** | 47.274                 | 60.772           | 742.20        |                                |

Device name: **Pixel 3 XL**
Device architecture: **arm64-v8a**
Number of test runs: **10**
Test application: Xamarin.Forms "Hello World" app with one label

|                 | **Native to managed**  | **Runtime init** | **Displayed** | **Notes**                      |
|-----------------|------------------------|------------------|---------------|--------------------------------|
| **master**      | 122.090                | 142.004          | 639.00        |  preload enabled; 32-bit build |
| **this commit** | 49.272                 | 69.298           | 654.20        |                                |
| **master**      | 121.110                | 134.378          | 634.20        | preload disabled; 32-bit build |
| **this commit** | 47.719                 | 60.788           | 616.00        |                                |
| **master**      | 120.973                | 141.235          | 637.20        |  preload enabled; 64-bit build |
| **this commit** | 48.642                 | 68.290           | 626.00        |                                |
| **master**      | 120.785                | 134.588          | 627.00        | preload disabled; 64-bit build |
| **this commit** | 48.657                 | 63.290           | 625.00        |                                |

Author: grendello

.gitmodules

@@ -12,8 +12,8 @@
     branch = v1.1.1
 [submodule "external/Java.Interop"]
     path = external/Java.Interop
-    url = https://github.com/xamarin/java.interop.git
-    branch = master
+    url = https://github.com/grendello/java.interop.git
+    branch = no-reflection
 [submodule "external/mman-win32"]
     path = external/mman-win32
     url = https://github.com/witwall/mman-win32.git

external/Java.Interop

@@ -15,8 +15,18 @@ namespace Android.Runtime {
 
 	class AndroidRuntime : JniRuntime {
 
-		internal AndroidRuntime (IntPtr jnienv, IntPtr vm, bool allocNewObjectSupported, IntPtr classLoader, IntPtr classLoader_loadClass)
-			: base (new AndroidRuntimeOptions (jnienv, vm, allocNewObjectSupported, classLoader, classLoader_loadClass))
+		internal AndroidRuntime (IntPtr jnienv,
+				IntPtr vm,
+				bool allocNewObjectSupported,
+				IntPtr classLoader,
+				IntPtr classLoader_loadClass,
+				bool jniAddNativeMethodRegistrationAttributePresent)
+			: base (new AndroidRuntimeOptions (jnienv,
+					vm,
+					allocNewObjectSupported,
+					classLoader,
+					classLoader_loadClass,
+					jniAddNativeMethodRegistrationAttributePresent))
 		{
 		}
 
@@ -67,18 +77,23 @@ public override void RaisePendingException (Exception pendingException)
 	}
 
 	class AndroidRuntimeOptions : JniRuntime.CreationOptions {
-
-		public AndroidRuntimeOptions (IntPtr jnienv, IntPtr vm, bool allocNewObjectSupported, IntPtr classLoader, IntPtr classLoader_loadClass)
+		public AndroidRuntimeOptions (IntPtr jnienv,
+				IntPtr vm,
+				bool allocNewObjectSupported,
+				IntPtr classLoader,
+				IntPtr classLoader_loadClass,
+				bool jniAddNativeMethodRegistrationAttributePresent)
 		{
 			EnvironmentPointer      = jnienv;
 			ClassLoader             = new JniObjectReference (classLoader, JniObjectReferenceType.Global);
 			ClassLoader_LoadClass_id= classLoader_loadClass;
 			InvocationPointer       = vm;
 			NewObjectRequired       = !allocNewObjectSupported;
 			ObjectReferenceManager  = new AndroidObjectReferenceManager ();
-			TypeManager             = new AndroidTypeManager ();
+			TypeManager             = new AndroidTypeManager (jniAddNativeMethodRegistrationAttributePresent);
 			ValueManager            = new AndroidValueManager ();
 			UseMarshalMemberBuilder = false;
+			JniAddNativeMethodRegistrationAttributePresent = jniAddNativeMethodRegistrationAttributePresent;
 		}
 	}
 
@@ -219,6 +234,12 @@ public override void DeleteWeakGlobalReference (ref JniObjectReference value)
 	}
 
 	class AndroidTypeManager : JniRuntime.JniTypeManager {
+		bool jniAddNativeMethodRegistrationAttributePresent;
+
+		public AndroidTypeManager (bool jniAddNativeMethodRegistrationAttributePresent)
+		{
+			this.jniAddNativeMethodRegistrationAttributePresent = jniAddNativeMethodRegistrationAttributePresent;
+		}
 
 		protected override IEnumerable<Type> GetTypesForSimpleReference (string jniSimpleReference)
 		{
@@ -347,13 +368,15 @@ public override void RegisterNativeMembers (JniType nativeClass, Type type, stri
 				return;
 
 			if (string.IsNullOrEmpty (methods)) {
-				base.RegisterNativeMembers (nativeClass, type, methods);
+				if (jniAddNativeMethodRegistrationAttributePresent)
+					base.RegisterNativeMembers (nativeClass, type, methods);
 				return;
 			}
 
 			string[] members = methods.Split ('\n');
 			if (members.Length < 2) {
-				base.RegisterNativeMembers (nativeClass, type, methods);
+				if (jniAddNativeMethodRegistrationAttributePresent)
+					base.RegisterNativeMembers (nativeClass, type, methods);
 				return;
 			}
 

src/Mono.Android/Android.Runtime/AndroidRuntime.cs

@@ -33,6 +33,7 @@ struct JnienvInitializeArgs {
 		public byte            brokenExceptionTransitions;
 		public int             packageNamingPolicy;
 		public byte            ioExceptionType;
+		public int             jniAddNativeMethodRegistrationAttributePresent;
 	}
 #pragma warning restore 0649
 
@@ -54,7 +55,6 @@ public static partial class JNIEnv {
 		internal static int    gref_gc_threshold;
 
 		internal  static  bool  PropagateExceptions;
-		static UncaughtExceptionHandler defaultUncaughtExceptionHandler;
 
 		internal static bool IsRunningOnDesktop;
 		internal static bool LogTypemapMissStackTrace;
@@ -173,7 +173,7 @@ internal static unsafe void Initialize (JnienvInitializeArgs* args)
 			Mono.SystemDependencyProvider.Initialize ();
 
 			BoundExceptionType = (BoundExceptionType)args->ioExceptionType;
-			androidRuntime = new AndroidRuntime (args->env, args->javaVm, androidSdkVersion > 10, args->grefLoader, args->Loader_loadClass);
+			androidRuntime = new AndroidRuntime (args->env, args->javaVm, androidSdkVersion > 10, args->grefLoader, args->Loader_loadClass, args->jniAddNativeMethodRegistrationAttributePresent != 0);
 			AndroidValueManager = (AndroidValueManager) androidRuntime.ValueManager;
 
 			AllocObjectSupported = androidSdkVersion > 10;
@@ -183,12 +183,6 @@ internal static unsafe void Initialize (JnienvInitializeArgs* args)
 
 			PropagateExceptions = args->brokenExceptionTransitions == 0;
 
-			if (PropagateExceptions) {
-				defaultUncaughtExceptionHandler = new UncaughtExceptionHandler (Java.Lang.Thread.DefaultUncaughtExceptionHandler);
-				if (!IsRunningOnDesktop)
-					Java.Lang.Thread.DefaultUncaughtExceptionHandler = defaultUncaughtExceptionHandler;
-			}
-
 			JavaNativeTypeManager.PackageNamingPolicy = (PackageNamingPolicy)args->packageNamingPolicy;
 			if (IsRunningOnDesktop) {
 				string packageNamingPolicy = Environment.GetEnvironmentVariable ("__XA_PACKAGE_NAMING_POLICY__");
@@ -204,13 +198,6 @@ internal static unsafe void Initialize (JnienvInitializeArgs* args)
 
 		internal static void Exit ()
 		{
-			/* Reset uncaught exception handler so that we don't mistakenly reuse a
-			 * now-invalid handler the next time we reinitialize JNIEnv.
-			 */
-			var uncaughtExceptionHandler = Java.Lang.Thread.DefaultUncaughtExceptionHandler as UncaughtExceptionHandler;
-			if (uncaughtExceptionHandler != null && uncaughtExceptionHandler == defaultUncaughtExceptionHandler)
-				Java.Lang.Thread.DefaultUncaughtExceptionHandler = uncaughtExceptionHandler.DefaultHandler;
-
 			/* Manually dispose surfaced objects and close the current JniEnvironment to
 			 * avoid ObjectDisposedException thrown on finalizer threads after shutdown
 			 */
@@ -249,15 +236,56 @@ static void ManualJavaObjectDispose (Java.Lang.Object obj)
 			GC.SuppressFinalize (obj);
 		}
 
+		static Action<Exception> mono_unhandled_exception;
+		static Action<AppDomain, UnhandledExceptionEventArgs> AppDomain_DoUnhandledException;
+
+		static void InitializeUncaughtExceptionHandling ()
+		{
+			if (mono_unhandled_exception == null) {
+				var mono_UnhandledException = typeof (System.Diagnostics.Debugger)
+					.GetMethod ("Mono_UnhandledException", BindingFlags.NonPublic | BindingFlags.Static);
+				mono_unhandled_exception = (Action<Exception>) Delegate.CreateDelegate (typeof(Action<Exception>), mono_UnhandledException);
+			}
+
+			if (AppDomain_DoUnhandledException == null) {
+				var ad_due = typeof (AppDomain)
+					.GetMethod ("DoUnhandledException",
+					            bindingAttr:  BindingFlags.NonPublic | BindingFlags.Instance,
+					            binder:       null,
+					            types:        new []{typeof (UnhandledExceptionEventArgs)},
+					            modifiers:    null);
+				if (ad_due != null) {
+					AppDomain_DoUnhandledException  = (Action<AppDomain, UnhandledExceptionEventArgs>) Delegate.CreateDelegate (
+						typeof (Action<AppDomain, UnhandledExceptionEventArgs>), ad_due);
+				}
+			}
+		}
+
 		internal static void PropagateUncaughtException (IntPtr env, IntPtr javaThreadPtr, IntPtr javaExceptionPtr)
 		{
-			if (defaultUncaughtExceptionHandler == null)
+			if (!PropagateExceptions)
 				return;
 
-			var javaThread = JavaObject.GetObject<Java.Lang.Thread> (env, javaThreadPtr, JniHandleOwnership.DoNotTransfer);
+			try {
+				InitializeUncaughtExceptionHandling ();
+			} catch (Exception e) {
+				Android.Runtime.AndroidEnvironment.FailFast ($"Unable to initialize UncaughtExceptionHandler. Nested exception caught: {e}");
+			}
+
 			var javaException = JavaObject.GetObject<Java.Lang.Throwable> (env, javaExceptionPtr, JniHandleOwnership.DoNotTransfer);
 
-			defaultUncaughtExceptionHandler.UncaughtException (javaThread, javaException);
+			mono_unhandled_exception (javaException);
+			if (AppDomain_DoUnhandledException == null)
+				return;
+
+			try {
+				var jltp = javaException as JavaProxyThrowable;
+				Exception innerException = jltp?.InnerException;
+				var args  = new UnhandledExceptionEventArgs (innerException ?? javaException, isTerminating: true);
+				AppDomain_DoUnhandledException (AppDomain.CurrentDomain, args);
+			} catch (Exception e) {
+				Logger.Log (LogLevel.Error, "monodroid", "Exception thrown while raising AppDomain.UnhandledException event: " + e.ToString ());
+			}
 		}
 
 		[DllImport ("__Internal", CallingConvention = CallingConvention.Cdecl)]

src/Mono.Android/Android.Runtime/JNIEnv.cs

@@ -7,7 +7,7 @@ namespace Android.Runtime {
 
 	public class XAPeerMembers : JniPeerMembers {
 
-		static  Dictionary<string,  JniPeerMembers>         LegacyPeerMembers = new Dictionary<string, JniPeerMembers> ();
+		static  Dictionary<string,  JniPeerMembers>         LegacyPeerMembers = new Dictionary<string, JniPeerMembers> (StringComparer.Ordinal);
 
 		public XAPeerMembers (string jniPeerTypeName, Type managedPeerType)
 			: base (jniPeerTypeName, managedPeerType)
@@ -73,4 +73,4 @@ static IntPtr GetThresholdClass (IJavaPeerable value)
 			return IntPtr.Zero;
 		}
 	}
-}
+}

src/Mono.Android/Android.Runtime/UncaughtExceptionHandler.cs

@@ -23,7 +23,7 @@ static class TypeManagerMapDictionaries
 		public static Dictionary<string, Type> JniToManaged {
 			get {
 				if (_jniToManaged == null)
-					_jniToManaged = new Dictionary<string, Type> ();
+					_jniToManaged = new Dictionary<string, Type> (StringComparer.Ordinal);
 				return _jniToManaged;
 			}
 		}

src/Mono.Android/Android.Runtime/XAPeerMembers.cs

@@ -233,7 +233,6 @@
     <Compile Include="Android.Runtime\StringDefAttribute.cs" />
     <Compile Include="Android.Runtime\TimingLogger.cs" />
     <Compile Include="Android.Runtime\TypeManager.cs" />
-    <Compile Include="Android.Runtime\UncaughtExceptionHandler.cs" />
     <Compile Include="Android.Runtime\XAPeerMembers.cs" />
     <Compile Include="Android.Runtime\XmlPullParserReader.cs" />
     <Compile Include="Android.Runtime\XmlReaderPullParser.cs" />

src/Mono.Android/Java.Interop/TypeManager.cs

@@ -400,9 +400,10 @@ void SaveResource (string resource, string filename, string destDir, Func<string
 		void WriteTypeMappings (List<TypeDefinition> types)
 		{
 			var tmg = new TypeMapGenerator ((string message) => Log.LogDebugMessage (message), SupportedAbis);
-			if (!tmg.Generate (types, TypemapOutputDirectory, GenerateNativeAssembly))
+			if (!tmg.Generate (types, TypemapOutputDirectory, GenerateNativeAssembly, out ApplicationConfigTaskState appConfState))
 				throw new XamarinAndroidException (4308, Properties.Resources.XA4308);
 			GeneratedBinaryTypeMaps = tmg.GeneratedBinaryTypeMaps.ToArray ();
+			BuildEngine4.RegisterTaskObject (ApplicationConfigTaskState.RegisterTaskObjectKey, appConfState, RegisteredTaskObjectLifetime.AppDomain, allowEarlyCollection: false);
 		}
 	}
 }

src/Mono.Android/Mono.Android.csproj

@@ -249,6 +249,7 @@ void AddEnvironment ()
 				throw new InvalidOperationException ($"Unsupported BoundExceptionType value '{BoundExceptionType}'");
 			}
 
+			var appConfState = BuildEngine4.GetRegisteredTaskObject (ApplicationConfigTaskState.RegisterTaskObjectKey, RegisteredTaskObjectLifetime.AppDomain) as ApplicationConfigTaskState;
 			foreach (string abi in SupportedAbis) {
 				NativeAssemblerTargetProvider asmTargetProvider;
 				string baseAsmFilePath = Path.Combine (EnvironmentOutputDirectory, $"environment.{abi.ToLowerInvariant ()}");
@@ -285,6 +286,7 @@ void AddEnvironment ()
 					PackageNamingPolicy = pnp,
 					BoundExceptionType = boundExceptionType,
 					InstantRunEnabled = InstantRunEnabled,
+					JniAddNativeMethodRegistrationAttributePresent = appConfState != null ? appConfState.JniAddNativeMethodRegistrationAttributePresent : false,
 				};
 
 				using (var sw = MemoryStreamPool.Shared.CreateStreamWriter ()) {