[runtime] Optionally preload all the assemblies from the apk

Documentation/guides/BuildProcess.md

@@ -754,6 +754,30 @@ when packaing Release applications.
 
     Added in Xamarin.Android 8.3.
 
+- **AndroidEnablePreloadAssemblies** – A boolean property which controls
+    whether or not all managed assemblies bundled within the application package
+    are loaded during process startup or not.
+
+    When set to `True`, all assemblies bundled within the application package
+    will be loaded during process startup, before any application code is invoked.
+    This is consistent with what Xamarin.Android did in releases prior to
+    Xamarin.Andorid 9.2.
+
+    When set to `False`, assemblies will only be loaded on an as-needed basis.
+    This allows applications to startup faster, and is also more consistent with
+    desktop .NET semantics.  To see the time savings, set the `debug.mono.log`
+    System Property to include `timing`, and look for the
+    `Finished loading assemblies: preloaded` message within `adb logcat`.
+
+    Applications or libraries which use dependency injection may *require* that
+    this property be `True` if they in turn require that
+    `AppDomain.CurrentDomain.GetAssemblies()` return all assemblies within the
+    application bundle, even if the assembly wouldn't otherwise have been needed.
+
+    By default this value will be set to `True`.
+
+    Added in Xamarin.Android 9.2.
+
 ### Binding Project Build Properties
 
 The following MSBuild properties are used with

src/Xamarin.Android.Build.Tasks/Xamarin.Android.Common.targets

@@ -317,6 +317,9 @@ Copyright (C) 2011-2012 Xamarin. All rights reserved.
 	<_AndroidDesignTimeBuildPropertiesCache>$(_AndroidIntermediateDesignTimeBuildDirectory)build.props</_AndroidDesignTimeBuildPropertiesCache>
 	<AndroidGenerateJniMarshalMethods Condition=" '$(AndroidGenerateJniMarshalMethods)' == '' ">False</AndroidGenerateJniMarshalMethods>
 	<AndroidMakeBundleKeepTemporaryFiles Condition=" '$(AndroidMakeBundleKeepTemporaryFiles)' == '' ">False</AndroidMakeBundleKeepTemporaryFiles>
+
+	<!-- If true it will cause all the assemblies in the apk to be preloaded on startup time -->
+	<AndroidEnablePreloadAssemblies Condition=" '$(AndroidEnablePreloadAssemblies)' == '' ">True</AndroidEnablePreloadAssemblies>
 </PropertyGroup>
 
 <Choose>
@@ -2386,8 +2389,23 @@ because xbuild doesn't support framework reference assemblies.
   </GetAddOnPlatformLibraries>
 </Target>
 
+<Target Name="_SetupAssemblyPreload"
+    Condition=" '$(AndroidEnablePreloadAssemblies)' != 'True' "
+    Inputs="$(IntermediateOutputPath)javastubs.cache"
+    Outputs="$(IntermediateOutputPath)preloadAssembliesEnvironment.txt">
+  <WriteLinesToFile
+      File="$(IntermediateOutputPath)preloadAssembliesEnvironment.txt"
+      Lines="mono.enable_assembly_preload=0"
+      Overwrite="True"
+  />
+  <ItemGroup>
+    <AndroidEnvironment Include="$(IntermediateOutputPath)preloadAssembliesEnvironment.txt" />
+    <FileWrites         Include="$(IntermediateOutputPath)preloadAssembliesEnvironment.txt" />
+  </ItemGroup>
+</Target>
+
 <Target Name="_GeneratePackageManagerJava"
-  DependsOnTargets="_GetAddOnPlatformLibraries;_AddStaticResources;$(_AfterAddStaticResources);_PrepareAssemblies"
+  DependsOnTargets="_GetAddOnPlatformLibraries;_AddStaticResources;$(_AfterAddStaticResources);_PrepareAssemblies;_SetupAssemblyPreload"
   Inputs="$(MSBuildAllProjects);$(_ResolvedUserAssembliesHashFile);$(MSBuildProjectFile);$(_AndroidBuildPropertiesCache)"
   Outputs="$(_AndroidStampDirectory)_GeneratePackageManagerJava.stamp">
   <!-- Create java needed for Mono runtime -->

src/monodroid/jni/android-system.cc

@@ -779,6 +779,16 @@ AndroidSystem::setup_environment (jstring_wrapper& name, jstring_wrapper& value)
 			knownEnvVars.MonoLLVM = true;
 			return;
 		}
+
+		if (strcmp (k, "mono.enable_assembly_preload") == 0) {
+			if (*v == '\0')
+				knownEnvVars.EnableAssemblyPreload = KnownEnvironmentVariables::AssemblyPreloadDefault;
+			else if (v[0] == '1')
+				knownEnvVars.EnableAssemblyPreload = true;
+			else
+				knownEnvVars.EnableAssemblyPreload = false;
+			return;
+		}
 	}
 
 	add_system_property (k, v);

src/monodroid/jni/android-system.h

@@ -23,9 +23,12 @@ namespace xamarin { namespace android { namespace internal
 
 	struct KnownEnvironmentVariables
 	{
+		static constexpr bool AssemblyPreloadDefault = true;
+
 		bool        DSOInApk = false;
 		MonoAotMode MonoAOT = MonoAotMode::MONO_AOT_MODE_NONE;
 		bool        MonoLLVM = false;
+		bool        EnableAssemblyPreload = AssemblyPreloadDefault;
 	};
 
 	class AndroidSystem
@@ -133,6 +136,10 @@ namespace xamarin { namespace android { namespace internal
 #if defined (WINDOWS)
 		int setenv (const char *name, const char *value, int overwrite);
 #endif
+		bool is_assembly_preload_enabled () const
+		{
+			return knownEnvVars.EnableAssemblyPreload;
+		}
 
 		bool is_mono_llvm_enabled () const
 		{

src/monodroid/jni/monodroid-glue.cc

@@ -957,7 +957,7 @@ mono_runtime_init (char *runtime_args)
 }
 
 static MonoDomain*
-create_domain (JNIEnv *env, jclass runtimeClass, jstring_array_wrapper &runtimeApks, jstring assembly, jobject loader, bool is_root_domain)
+create_domain (JNIEnv *env, jclass runtimeClass, jstring_array_wrapper &runtimeApks, jobject loader, bool is_root_domain)
 {
 	MonoDomain *domain;
 	int user_assemblies_count   = 0;;
@@ -1779,21 +1779,75 @@ _monodroid_counters_dump (const char *format, ...)
 	monoFunctions.counters_dump (XA_LOG_COUNTERS, counters);
 }
 
+static void
+load_assembly (MonoDomain *domain, JNIEnv *env, jstring_wrapper &assembly)
+{
+	timing_period total_time;
+	if (XA_UNLIKELY (utils.should_log (LOG_TIMING)))
+		total_time.mark_start ();
+
+	const char *assm_name = assembly.get_cstr ();
+	MonoAssemblyName *aname;
+
+	aname = monoFunctions.assembly_name_new (assm_name);
+
+	if (domain != monoFunctions.domain_get ()) {
+		MonoDomain *current = monoFunctions.domain_get ();
+		monoFunctions.domain_set (domain, FALSE);
+		monoFunctions.assembly_load_full (aname, NULL, NULL, 0);
+		monoFunctions.domain_set (current, FALSE);
+	} else {
+		monoFunctions.assembly_load_full (aname, NULL, NULL, 0);
+	}
+
+	monoFunctions.assembly_name_free (aname);
+
+	if (XA_UNLIKELY (utils.should_log (LOG_TIMING))) {
+		total_time.mark_end ();
+
+		timing_diff diff (total_time);
+		log_info (LOG_TIMING, "Assembly load: %s preloaded; elapsed: %lis:%lu::%lu", assm_name, diff.sec, diff.ms, diff.ns);
+	}
+}
+
+static void
+load_assemblies (MonoDomain *domain, JNIEnv *env, jstring_array_wrapper &assemblies)
+{
+	timing_period total_time;
+	if (XA_UNLIKELY (utils.should_log (LOG_TIMING)))
+		total_time.mark_start ();
+
+	/* skip element 0, as that's loaded in create_domain() */
+	for (size_t i = 1; i < assemblies.get_length (); ++i) {
+		jstring_wrapper &assembly = assemblies [i];
+		load_assembly (domain, env, assembly);
+	}
+
+	if (XA_UNLIKELY (utils.should_log (LOG_TIMING))) {
+		total_time.mark_end ();
+
+		timing_diff diff (total_time);
+		log_info (LOG_TIMING, "Finished loading assemblies: preloaded %u assemblies; wasted time: %lis:%lu::%lu", assemblies.get_length (), diff.sec, diff.ms, diff.ns);
+	}
+}
+
 static void
 monodroid_Mono_UnhandledException_internal (MonoException *ex)
 {
 	// Do nothing with it here, we let the exception naturally propagate on the managed side
 }
 
 static MonoDomain*
-create_and_initialize_domain (JNIEnv* env, jclass runtimeClass, jstring_array_wrapper &runtimeApks, jobjectArray assemblies, jobject loader, bool is_root_domain)
+create_and_initialize_domain (JNIEnv* env, jclass runtimeClass, jstring_array_wrapper &runtimeApks, jstring_array_wrapper &assemblies, jobject loader, bool is_root_domain)
 {
-	MonoDomain* domain = create_domain (env, runtimeClass, runtimeApks, reinterpret_cast <jstring> (env->GetObjectArrayElement (assemblies, 0)), loader, is_root_domain);
+	MonoDomain* domain = create_domain (env, runtimeClass, runtimeApks, loader, is_root_domain);
 
 	// When running on desktop, the root domain is only a dummy so don't initialize it
 	if (is_running_on_desktop && is_root_domain)
 		return domain;
 
+	if (androidSystem.is_assembly_preload_enabled ())
+		load_assemblies (domain, env, assemblies);
 	init_android_runtime (domain, env, runtimeClass, loader);
 
 	osBridge.add_monodroid_domain (domain);
@@ -1804,7 +1858,7 @@ create_and_initialize_domain (JNIEnv* env, jclass runtimeClass, jstring_array_wr
 JNIEXPORT void JNICALL
 Java_mono_android_Runtime_init (JNIEnv *env, jclass klass, jstring lang, jobjectArray runtimeApksJava,
                                 jstring runtimeNativeLibDir, jobjectArray appDirs, jobject loader,
-                                jobjectArray externalStorageDirs, jobjectArray assemblies, jstring packageName,
+                                jobjectArray externalStorageDirs, jobjectArray assembliesJava, jstring packageName,
                                 jint apiLevel, jobjectArray environmentVariables)
 {
 	init_logging_categories ();
@@ -1987,6 +2041,7 @@ Java_mono_android_Runtime_init (JNIEnv *env, jclass klass, jstring lang, jobject
 		log_info_nocheck (LOG_TIMING, "Runtime.init: Mono runtime init; elapsed: %lis:%lu::%lu", diff.sec, diff.ms, diff.ns);
 	}
 
+	jstring_array_wrapper assemblies (env, assembliesJava);
 	/* the first assembly is used to initialize the AppDomain name */
 	create_and_initialize_domain (env, klass, runtimeApks, assemblies, loader, /*is_root_domain:*/ true);
 
@@ -2070,14 +2125,15 @@ reinitialize_android_runtime_type_manager (JNIEnv *env)
 }
 
 JNIEXPORT jint
-JNICALL Java_mono_android_Runtime_createNewContext (JNIEnv *env, jclass klass, jobjectArray runtimeApksJava, jobjectArray assemblies, jobject loader)
+JNICALL Java_mono_android_Runtime_createNewContext (JNIEnv *env, jclass klass, jobjectArray runtimeApksJava, jobjectArray assembliesJava, jobject loader)
 {
 	log_info (LOG_DEFAULT, "CREATING NEW CONTEXT");
 	reinitialize_android_runtime_type_manager (env);
 	MonoDomain *root_domain = monoFunctions.get_root_domain ();
 	monoFunctions.jit_thread_attach (root_domain);
 
 	jstring_array_wrapper runtimeApks (env, runtimeApksJava);
+	jstring_array_wrapper assemblies (env, assembliesJava);
 	MonoDomain *domain = create_and_initialize_domain (env, klass, runtimeApks, assemblies, loader, /*is_root_domain:*/ false);
 	monoFunctions.domain_set (domain, FALSE);
 	int domain_id = monoFunctions.domain_get_id (domain);

tests/Xamarin.Forms-Performance-Integration/App.xaml.cs

@@ -2,7 +2,9 @@
 using Xamarin.Forms;
 using Xamarin.Forms.Xaml;
 
+#if !DEBUG
 [assembly: XamlCompilation (XamlCompilationOptions.Compile)]
+#endif
 
 namespace Xamarin.Forms.Performance.Integration
 {

tests/Xamarin.Forms-Performance-Integration/Global.css

@@ -0,0 +1,5 @@
+.featureHeader {
+	font-size: 20;
+	font-style: bold;
+	margin: 0,20,0,10;
+}

tests/Xamarin.Forms-Performance-Integration/Views/MainPage.xaml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<TabbedPage
+    xmlns="http://xamarin.com/schemas/2014/forms"
+    xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
+    x:Class="Xamarin.Forms.Performance.Integration.MainPage"
+    Resources="{StyleSheet Source=../Global.css}">
+</TabbedPage>

tests/Xamarin.Forms-Performance-Integration/Views/MainPage.xaml.cs

@@ -0,0 +1,50 @@
+using System;
+
+using Xamarin.Forms;
+
+namespace Xamarin.Forms.Performance.Integration
+{
+	public partial class MainPage : TabbedPage
+	{
+		public MainPage ()
+		{
+			InitializeComponent ();
+
+			Page itemsPage, aboutPage = null;
+
+			switch (Device.RuntimePlatform) {
+				case Device.iOS:
+					itemsPage = new NavigationPage (new ItemsPage ()) {
+						Title = "Browse"
+					};
+
+					aboutPage = new NavigationPage (new AboutPage ()) {
+						Title = "About"
+					};
+					itemsPage.Icon = "tab_feed.png";
+					aboutPage.Icon = "tab_about.png";
+					break;
+				default:
+					itemsPage = new ItemsPage () {
+						Title = "Browse"
+					};
+
+					aboutPage = new AboutPage () {
+						Title = "About"
+					};
+					break;
+			}
+
+			Children.Add (itemsPage);
+			Children.Add (aboutPage);
+
+			Title = Children [0].Title;
+		}
+
+		protected override void OnCurrentPageChanged ()
+		{
+			base.OnCurrentPageChanged ();
+			Title = CurrentPage?.Title ?? string.Empty;
+		}
+	}
+}