[DependencyInjection] introduce feature switch to disable S.R.E #91133
Conversation
When recording a new AOT profile for .NET MAUI apps running on Android,
we noticed that System.Reflection.Emit work was being done on a
background thread. The call seen in `dotnet-trace` output:
11.32ms microsoft.extensions.dependencyinjection!Microsoft.Extensions.DependencyInjection.ServiceLookup.ILEmitResolverBuilder.GenerateMethodBody(Microsoft.Extensions.DependencyInjection.ServiceLookup.ServiceCallSite,System.Reflection.Emit.ILGenerator)
.NET Android apps are unique in that there is a JIT,
`RuntimeFeature.IsDynamicCodeCompiled` is true, System.Reflection.Emit
is possible -- S.R.E is however, not great for startup performance.
Starting threads on Android during startup can also be slow, as Android
will commonly put all but a single core to sleep for battery saving
purposes. We try to avoid starting threads on startup for "hello world"
applications on Android.
To solve this for now, introduce a new feature flag:
Microsoft.Extensions.DependencyInjection.DisableDynamicEngine
Which, we will provide a value in either the Android or .NET MAUI
optional workload via an MSBuild property. To test, I put this in my
app's `.csproj` file:
<RuntimeHostConfigurationOption Include="Microsoft.Extensions.DependencyInjection.DisableDynamicEngine"
Condition="'$(DisableDynamicEngine)' != ''"
Value="$(DisableDynamicEngine)"
Trim="true" />
Customers *could* opt to change this flag, but we don't think it will
particularly useful. An example of services realized by .NET MAUI at
startup, via some logging added:
08-25 13:21:55.647 16530 16530 I DOTNET : RealizeService called: System.Collections.Generic.IEnumerable`1[Microsoft.Maui.Hosting.IMauiInitializeService]
08-25 13:21:55.664 16530 16530 I DOTNET : RealizeService called: System.Collections.Generic.IEnumerable`1[Microsoft.Maui.Hosting.IMauiInitializeScopedService]
08-25 13:21:55.665 16530 16530 I DOTNET : RealizeService called: Microsoft.Maui.Dispatching.IDispatcher
08-25 13:21:55.668 16530 16530 I DOTNET : RealizeService called: System.Collections.Generic.IEnumerable`1[Microsoft.Maui.LifecycleEvents.LifecycleEventRegistration]
08-25 13:21:56.057 16530 16530 I DOTNET : RealizeService called: System.Collections.Generic.IEnumerable`1[Microsoft.Maui.Hosting.HandlerMauiAppBuilderExtensions+HandlerRegistration]
08-25 13:21:56.115 16530 16530 I DOTNET : RealizeService called: Microsoft.Extensions.DependencyInjection.IServiceScopeFactory
08-25 13:21:56.670 16530 16530 I DOTNET : RealizeService called: Microsoft.Maui.Controls.HideSoftInputOnTappedChangedManager
08-25 13:21:56.712 16530 16530 I DOTNET : RealizeService called: System.Collections.Generic.IEnumerable`1[Microsoft.Maui.Hosting.ImageSourcesMauiAppBuilderExtensions+ImageSourceRegistration]
08-25 13:21:57.700 16530 16530 I DOTNET : RealizeService using S.R.E: Microsoft.Maui.Controls.HideSoftInputOnTappedChangedManager
`HideSoftInputOnTappedChangedManager` would be realized once per page,
which would not be a huge payoff to use S.R.E for. So the only way the
S.R.E codepath could be useful on Android would be if the customer is
registering lots of services themselves. They might be better off just
using `new()` in that case?
An example of the startup time Android reports with the new flag on/off:
DisableDynamicEngine=false
08-25 14:31:37.462 2090 2330 I ActivityTaskManager: Displayed com.companyname.testmaui/crc643c09abdeec717b83.MainActivity: +733ms
08-25 14:31:39.394 2090 2330 I ActivityTaskManager: Displayed com.companyname.testmaui/crc643c09abdeec717b83.MainActivity: +737ms
08-25 14:31:41.326 2090 2330 I ActivityTaskManager: Displayed com.companyname.testmaui/crc643c09abdeec717b83.MainActivity: +730ms
DisableDynamicEngine=true
08-25 14:32:20.233 2090 2330 I ActivityTaskManager: Displayed com.companyname.testmaui/crc643c09abdeec717b83.MainActivity: +724ms
08-25 14:32:22.137 2090 2330 I ActivityTaskManager: Displayed com.companyname.testmaui/crc643c09abdeec717b83.MainActivity: +727ms
08-25 14:32:24.042 2090 2330 I ActivityTaskManager: Displayed com.companyname.testmaui/crc643c09abdeec717b83.MainActivity: +716ms
This was a `dotnet new maui` project, using dotnet/maui/main on a Pixel
5 device.
ghost
assigned 
|
Tagging subscribers to this area: @dotnet/area-extensions-dependencyinjection Issue DetailsWhen recording a new AOT profile for .NET MAUI apps running on Android, we noticed that System.Reflection.Emit work was being done on a background thread. The call seen in .NET Android apps are unique in that there is a JIT, Starting threads on Android during startup can also be slow, as Android will commonly put all but a single core to sleep for battery saving purposes. We try to avoid starting threads on startup for "hello world" applications on Android. To solve this for now, introduce a new feature flag: Which, we will provide a value in either the Android or .NET MAUI optional workload via an MSBuild property. To test, I put this in my app's Customers could opt to change this flag, but we don't think it will particularly useful. An example of services realized by .NET MAUI at startup, via some logging added:
An example of the startup time Android reports with the new flag on/off: This was a
|
Co-authored-by: Eric Erhardt <eric.erhardt@microsoft.com>
| @@ -246,7 +249,7 @@ private ServiceProviderEngine GetEngine() | |||
| #if NETFRAMEWORK || NETSTANDARD2_0 | |||
| engine = CreateDynamicEngine(); | |||
| #else | |||
| if (RuntimeFeature.IsDynamicCodeCompiled) | |||
| if (RuntimeFeature.IsDynamicCodeCompiled && !DisableDynamicEngine) | |||
There was a problem hiding this comment.
For other reviewers: the check for IsDynamicCodeCompiled here was added prior to v8.
|
Note the related emit+Android issue where emit is also to be avoided for reflection invoke: #83893 which uses Should the changes there that use |
|
Tagging subscribers to 'arch-android': @steveisok, @akoeplinger Issue DetailsWhen recording a new AOT profile for .NET MAUI apps running on Android, we noticed that System.Reflection.Emit work was being done on a background thread. The call seen in .NET Android apps are unique in that there is a JIT, Starting threads on Android during startup can also be slow, as Android will commonly put all but a single core to sleep for battery saving purposes. We try to avoid starting threads on startup for "hello world" applications on Android. To solve this for now, introduce a new feature flag: Which, we will provide a value in either the Android or .NET MAUI optional workload via an MSBuild property. To test, I put this in my app's Customers could opt to change this flag, but we don't think it will particularly useful. An example of services realized by .NET MAUI at startup, via some logging added:
An example of the startup time Android reports with the new flag on/off: This was a
|
|
My plan was to add changes to the <DisableDependencyInjectionDynamicEngine Condition="'$(DisableDependencyInjectionDynamicEngine)' == ''">true</DisableDependencyInjectionDynamicEngine>I wouldn't expect many of our customers to know about these or try to use them. I can unify these both to use a single MSBuild property, though -- thoughts on a good name? |
| @@ -27,6 +27,7 @@ configurations but their defaults might vary as any SDK can set the defaults dif | |||
| | MetadataUpdaterSupport | System.Reflection.Metadata.MetadataUpdater.IsSupported | Metadata update related code to be trimmed when set to false | | |||
| | _EnableConsumingManagedCodeFromNativeHosting | System.Runtime.InteropServices.EnableConsumingManagedCodeFromNativeHosting | Getting a managed function from native hosting is disabled when set to false and related functionality can be trimmed. | | |||
| | VerifyDependencyInjectionOpenGenericServiceTrimmability | Microsoft.Extensions.DependencyInjection.VerifyOpenGenericServiceTrimmability | When set to true, DependencyInjection will verify trimming annotations applied to open generic services are correct | | |||
| | DisableDependencyInjectionDynamicEngine | Microsoft.Extensions.DependencyInjection.DisableDynamicEngine | When set to true, DependencyInjection will avoid using System.Reflection.Emit when realizing services | | |||
There was a problem hiding this comment.
I wonder if a more universal "AvoidEmitForPerformance" switch makes sense. That would also be checked in the couple places where the undocumented ForceInterpretedInvoke is used (which was originally added for testing).
There was a problem hiding this comment.
Yes, I think it makes sense to rework dotnet/android#7972 so it sets both feature switches on a name similar to $(AvoidEmitForPerformance).
We would try to ship this in .NET 8 RC 2 if possible.
There was a problem hiding this comment.
Per offline discussion, we may want to remove the .md file changes since this switch is considered internal and may be replaced by "AvoidEmitForPerformance" (or a better name) in the future where that new switch would also by used by Reflection and DependencyInjection for emit cases where today they use IsDynamicCodeSupported.
jonathanpeppers
deleted the
Microsoft.Extensions.DependencyInjection.DisableDynamicEngine
branch
|
/backport to release/8.0 |
|
Started backporting to release/8.0: https://github.com/dotnet/runtime/actions/runs/6029373668 |
|
@jonathanpeppers an error occurred while backporting to release/8.0, please check the run log for details! Error: @jonathanpeppers is not a repo collaborator, backporting is not allowed. If you're a collaborator please make sure your dotnet team membership visibility is set to Public on https://github.com/orgs/dotnet/people?query=jonathanpeppers |
|
/backport to release/8.0 |
|
Started backporting to release/8.0: https://github.com/dotnet/runtime/actions/runs/6029397098 |
When recording a new AOT profile for .NET MAUI apps running on Android, we noticed that System.Reflection.Emit work was being done on a background thread. The call seen in
dotnet-traceoutput:.NET Android apps are unique in that there is a JIT,
RuntimeFeature.IsDynamicCodeCompiledis true, System.Reflection.Emit is possible -- S.R.E is however, not great for startup performance.Starting threads on Android during startup can also be slow, as Android will commonly put all but a single core to sleep for battery saving purposes. We try to avoid starting threads on startup for "hello world" applications on Android.
To solve this for now, introduce a new feature flag:
Which, we will provide a value in either the Android or .NET MAUI optional workload via an MSBuild property. To test, I put this in my app's
.csprojfile:Customers could opt to change this flag, but we don't think it will particularly useful. An example of services realized by .NET MAUI at startup, via some logging added:
HideSoftInputOnTappedChangedManagerwould be realized once per page, which would not be a huge payoff to use S.R.E for. So the only way the S.R.E codepath could be useful on Android would be if the customer is registering lots of services themselves. They might be better off just usingnew()in that case?An example of the startup time Android reports with the new flag on/off:
This was a
dotnet new mauiproject, using dotnet/maui/main on a Pixel 5 device.