Add New Test to Track Number of Jitted Methods

eng/pipelines/coreclr/ci.yml

@@ -80,6 +80,7 @@ extends:
           platforms:
           - linux_arm
           - linux_musl_arm64
+          - linux_arm64
           - linux_x64
           - osx_arm64
           - osx_x64

eng/pipelines/runtime.yml

@@ -61,6 +61,9 @@ extends:
       - ${{ if eq(variables.dependOnEvaluatePaths, true) }}:
         - template: /eng/pipelines/common/evaluate-default-paths.yml
 
+      # WIP-ONLY CHANGE: Need to "debug" something that only happens in CI, so
+      # disabling these pipelines to speed up the running procedure.
+
       #
       # Build CoreCLR checked
       # Only when CoreCLR is changed
@@ -70,6 +73,7 @@ extends:
           jobTemplate: /eng/pipelines/coreclr/templates/build-job.yml
           buildConfig: checked
           platforms:
+          - linux_x86
           - linux_x64
           - linux_arm
           - linux_arm64
@@ -78,6 +82,7 @@ extends:
           - linux_musl_arm64
           - linux_musl_x64
           - osx_arm64
+          - tizen_armel
           - windows_x86
           - windows_x64
           - windows_arm64
@@ -186,48 +191,6 @@ extends:
                   eq(dependencies.evaluate_paths.outputs['SetPathVars_coreclr_jit.containsChange'], true),
                   eq(variables['isRollingBuild'], true)))
 
-      #
-      # Build CoreCLR with no R2R
-      #
-      - template: /eng/pipelines/common/platform-matrix.yml
-        parameters:
-          jobTemplate: /eng/pipelines/common/global-build-job.yml
-          helixQueuesTemplate: /eng/pipelines/libraries/helix-queues-setup.yml
-          buildConfig: checked
-          runtimeFlavor: coreclr
-          platforms:
-          - linux_x86
-          jobParameters:
-            testScope: innerloop
-            nameSuffix: CoreCLR_NoR2R
-            buildArgs: -s clr.runtime+clr.jit+clr.iltools+clr.spmi+clr.corelib -c $(_BuildConfig)
-            timeoutInMinutes: 120
-            condition: >-
-              or(
-                eq(dependencies.evaluate_paths.outputs['SetPathVars_coreclr.containsChange'], true),
-                eq(variables['isRollingBuild'], true))
-
-      #
-      # Build CoreCLR as a non-portable build
-      #
-      - template: /eng/pipelines/common/platform-matrix.yml
-        parameters:
-          jobTemplate: /eng/pipelines/common/global-build-job.yml
-          helixQueuesTemplate: /eng/pipelines/libraries/helix-queues-setup.yml
-          buildConfig: checked
-          runtimeFlavor: coreclr
-          platforms:
-          - tizen_armel
-          jobParameters:
-            testScope: innerloop
-            nameSuffix: CoreCLR_NonPortable
-            buildArgs: -s clr.native+clr.tools+clr.corelib+clr.nativecorelib+clr.aot+clr.packages -c $(_BuildConfig) /p:PortableBuild=false
-            timeoutInMinutes: 120
-            condition: >-
-              or(
-                eq(dependencies.evaluate_paths.outputs['SetPathVars_coreclr.containsChange'], true),
-                eq(variables['isRollingBuild'], true))
-
       #
       # CoreCLR NativeAOT debug build and smoke tests
       # Only when CoreCLR is changed

src/tests/Directory.Build.targets

@@ -153,6 +153,7 @@
   <Target Name="CheckForTestOutsideOfGroup" BeforeTargets="Build">
     <Error Condition="'$(InMergedTestDirectory)' == 'true'
       and '$(OutputType)' == 'Exe'
+      and '$(_CLRTestNeedsToRun)' == 'true'
       and '$(RequiresProcessIsolation)' != 'true'
       and '$(BuildAsStandalone)' != 'true'
       and '$(IsMergedTestRunnerAssembly)' != 'true'"
@@ -510,7 +511,7 @@
     </ItemGroup>
   </Target>
 
-  <PropertyGroup Condition="'$(Language)' == 'C#' and ('$(BuildAsStandalone)' == 'true' or '$(RequiresProcessIsolation)' == 'true' or '$(InMergedTestDirectory)' == 'true' or '$(IsMergedTestRunnerAssembly)' == 'true')">
+  <PropertyGroup Condition="'$(Language)' == 'C#' and '$(_CLRTestNeedsToRun)' == 'true' and ('$(BuildAsStandalone)' == 'true' or '$(RequiresProcessIsolation)' == 'true' or '$(InMergedTestDirectory)' == 'true' or '$(IsMergedTestRunnerAssembly)' == 'true')">
     <ReferenceXUnitWrapperGenerator Condition="'$(ReferenceXUnitWrapperGenerator)' == ''">true</ReferenceXUnitWrapperGenerator>
   </PropertyGroup>
 

src/tests/readytorun/JittedMethodsCountingTest/HelloWorld/HelloWorld.cs

@@ -0,0 +1,17 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+
+internal class HelloWorld
+{
+    static int Main(string[] args)
+    {
+        Console.WriteLine("Hello World!");
+        // We're fine converting to int here because if we got that many jitted
+        // methods that would require a long, then that means something is
+        // extremely wrong. Actually, I'm not even sure it's possible.
+        int jits = (int) System.Runtime.JitInfo.GetCompiledMethodCount(false);
+        return jits > 0 ? jits : -1;
+    }
+}

src/tests/readytorun/JittedMethodsCountingTest/HelloWorld/HelloWorld.csproj

@@ -0,0 +1,14 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>$(NetCoreAppToolCurrent)</TargetFramework>
+    <CLRTestKind>BuildOnly</CLRTestKind>
+    <AlwaysUseCrossgen2>true</AlwaysUseCrossgen2>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Compile Include="HelloWorld.cs" />
+  </ItemGroup>
+
+</Project>

src/tests/readytorun/JittedMethodsCountingTest/JittedMethodsCountingTest.cs

@@ -0,0 +1,114 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+using System.Diagnostics;
+using System.IO;
+using System.Linq;
+using Xunit;
+
+using Reflection = System.Reflection;
+using InteropServices = System.Runtime.InteropServices;
+
+public class JittedMethodsCountingTest
+{
+    private const int MAX_JITTED_METHODS_ACCEPTED = 100;
+
+    [Fact]
+    public static int TestEntryPoint()
+    {
+        // If DOTNET_ReadyToRun is disabled, then this test ought to be skipped.
+        if (!IsReadyToRunEnvSet())
+        {
+            Console.WriteLine("\nThis test is only supported in ReadyToRun scenarios."
+                              + " Skipping...\n");
+            return 100;
+        }
+
+        if (IsRunCrossgen2Set() && IsRunningOnARM64())
+        {
+            Console.WriteLine("\nThis test is currently unsupported on ARM64 when"
+                              + " RunCrossGen2 is enabled. Skipping...\n");
+            return 100;
+        }
+
+        string testAppLocation = Path.GetDirectoryName(Reflection
+                                                      .Assembly
+                                                      .GetExecutingAssembly()
+                                                      .Location);
+        string appName = Path.Combine(testAppLocation, "HelloWorld.dll");
+
+        // For adding any new apps for this test, make sure they return a negative
+        // number when failing.
+        int appResult = RunHelloWorldApp(appName);
+
+        if (appResult < 0)
+        {
+            Console.WriteLine("App failed somewhere and so we can't proceed with"
+                              + " the Jitted Methods analysis.");
+
+            Console.WriteLine("App Exit Code: {0}", appResult);
+            Console.WriteLine("Exiting...");
+
+            return 101;
+        }
+
+        // App finished successfully. We can now take a look at how many methods
+        // got jitted at runtime.
+        Console.WriteLine("Number of Jitted Methods: {0}\n", appResult);
+        return appResult > 0 && appResult <= MAX_JITTED_METHODS_ACCEPTED ? 100 : 101;
+    }
+
+    private static bool IsReadyToRunEnvSet()
+    {
+        string? dotnetR2R = Environment.GetEnvironmentVariable("DOTNET_ReadyToRun");
+        return (string.IsNullOrEmpty(dotnetR2R) || dotnetR2R == "1");
+    }
+
+    private static bool IsRunCrossgen2Set()
+    {
+        string? runCrossgen2 = Environment.GetEnvironmentVariable("RunCrossGen2");
+        return (runCrossgen2 == "1");
+    }
+
+    private static bool IsRunningOnARM64()
+    {
+        InteropServices.Architecture thisMachineArch = InteropServices
+                                                      .RuntimeInformation
+                                                      .OSArchitecture;
+
+        return (thisMachineArch == InteropServices.Architecture.Arm64);
+    }
+
+    private static int RunHelloWorldApp(string appName)
+    {
+        // The app's exit code is the number of jitted methods it got.
+        int appExitCode = -1;
+
+        // Set up our CoreRun call.
+        string coreRoot = Environment.GetEnvironmentVariable("CORE_ROOT");
+        string exeSuffix = OperatingSystem.IsWindows() ? ".exe" : "";
+        string coreRun = Path.Combine(coreRoot, $"corerun{exeSuffix}");
+
+        using (Process app = new Process())
+        {
+            var startInfo = new ProcessStartInfo
+            {
+                FileName = coreRun,
+                Arguments = appName,
+                CreateNoWindow = true,
+                UseShellExecute = false,
+            };
+
+            Console.WriteLine("\nLaunching Test App: {0} {1}", startInfo.FileName,
+                                                               startInfo.Arguments);
+
+            app.StartInfo = startInfo;
+            app.Start();
+            app.WaitForExit();
+            appExitCode = app.ExitCode;
+        }
+
+        return appExitCode;
+    }
+}

src/tests/readytorun/JittedMethodsCountingTest/JittedMethodsCountingTest.csproj

@@ -0,0 +1,21 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <JitOptimizationSensitive>true</JitOptimizationSensitive>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Compile Include="JittedMethodsCountingTest.cs" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="HelloWorld/HelloWorld.csproj">
+      <ReferenceOutputAssembly>false</ReferenceOutputAssembly>
+      <OutputItemType>Content</OutputItemType>
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </ProjectReference>
+  </ItemGroup>
+
+</Project>