fix: isolate cold-start allocation measurements for 10.1.3

Author: KSemenenko

.github/workflows/ci.yml

@@ -32,6 +32,14 @@ jobs:
     - name: Test including performance budgets
       run: dotnet test --configuration Release --no-build --verbosity normal
 
+    - name: Preserve full test results
+      if: always()
+      uses: actions/upload-artifact@v4
+      with:
+        name: full-test-results
+        path: ./**/TestResults/*.trx
+        retention-days: 5
+
     # Coverage instrumentation changes allocations and startup timing. Keep all
     # performance assertions in the uninstrumented full suite above.
     - name: Collect functional coverage

.github/workflows/release.yml

@@ -41,6 +41,14 @@ jobs:
     - name: Test
       run: dotnet test --configuration Release --no-build --verbosity normal
 
+    - name: Preserve full test results
+      if: always()
+      uses: actions/upload-artifact@v4
+      with:
+        name: full-test-results
+        path: ./**/TestResults/*.trx
+        retention-days: 5
+
     - name: Pack NuGet packages
       run: dotnet pack --configuration Release --no-build --output ./artifacts
 

Directory.Build.props

@@ -17,8 +17,8 @@
     <RepositoryUrl>https://github.com/managedcode/MimeTypes</RepositoryUrl>
     <PackageProjectUrl>https://github.com/managedcode/MimeTypes</PackageProjectUrl>
     <Product>Managed Code - MimeTypes</Product>
-    <Version>10.1.2</Version>
-    <PackageVersion>10.1.2</PackageVersion>
+    <Version>10.1.3</Version>
+    <PackageVersion>10.1.3</PackageVersion>
 
 </PropertyGroup>
 <PropertyGroup Condition="'$(GITHUB_ACTIONS)' == 'true'">

ManagedCode.MimeTypes.StartupProbe/Program.cs

@@ -1,13 +1,23 @@
+using System.Runtime.CompilerServices;
 using ManagedCode.MimeTypes;
 
+var input = args.Length == 0 ? "https://cdn.example.test/assets/photo.png?v=1" : args[0];
 var mime = MimeHelper.GetMimeType("asset.png");
 var extensions = MimeHelper.GetExtensions(mime);
 var knownMimeTypes = MimeHelper.GetKnownMimeTypes();
 var before = GC.GetAllocatedBytesForCurrentThread();
 for (var index = 0; index < 100_000; index++)
 {
-    _ = MimeHelper.GetMimeType("https://cdn.example.test/assets/photo.png?v=1");
+    mime = MimeHelper.GetMimeType(input);
 }
 var allocated = GC.GetAllocatedBytesForCurrentThread() - before;
 
-Console.WriteLine($"{mime}|{extensions.Count}|{knownMimeTypes.Count}|{allocated}");
+Report(mime, extensions.Count, knownMimeTypes.Count, allocated);
+
+// Keep interpolated output in a separate JIT body. Otherwise OSR can initialize
+// formatting infrastructure while the lookup allocation counter is running.
+[MethodImpl(MethodImplOptions.NoInlining)]
+static void Report(string mime, int extensionCount, int knownCount, long allocated)
+{
+    Console.WriteLine($"{mime}|{extensionCount}|{knownCount}|{allocated}");
+}

ManagedCode.MimeTypes.Tests/MimeHelperPerformanceTests.cs

@@ -6,13 +6,20 @@
 using System.Threading.Tasks;
 using Shouldly;
 using Xunit;
+using Xunit.Abstractions;
 
 namespace ManagedCode.MimeTypes.Tests;
 
 [Collection(MimeHelperMutableStateCollection.Name)]
 public sealed class MimeHelperPerformanceTests
 {
     private static readonly TimeSpan HotPathBudget = TimeSpan.FromSeconds(2);
+    private readonly ITestOutputHelper _output;
+
+    public MimeHelperPerformanceTests(ITestOutputHelper output)
+    {
+        _output = output;
+    }
 
     [Fact]
     [Trait("Category", "Performance")]
@@ -107,37 +114,82 @@ public void ParallelLookups_ShouldStayWithinBudget()
     [Trait("Category", "Performance")]
     public void ColdProcessStartup_ShouldStayBelowCatastrophicRegressionBudget()
     {
-        var probe = FindStartupProbe();
         var durations = new List<TimeSpan>();
 
         for (var index = 0; index < 3; index++)
         {
-            var startInfo = new ProcessStartInfo("dotnet")
-            {
-                RedirectStandardOutput = true,
-                RedirectStandardError = true,
-                UseShellExecute = false
-            };
-            startInfo.ArgumentList.Add(probe);
-
-            var stopwatch = Stopwatch.StartNew();
-            using var process = Process.Start(startInfo);
-            process.ShouldNotBeNull();
-            var output = process.StandardOutput.ReadToEnd();
-            var error = process.StandardError.ReadToEnd();
-            process.WaitForExit();
-            stopwatch.Stop();
-
-            process.ExitCode.ShouldBe(0, error);
-            output.Trim().ShouldStartWith("image/png|");
-            var allocated = long.Parse(output.Trim().Split('|')[3], System.Globalization.CultureInfo.InvariantCulture);
-            allocated.ShouldBeLessThanOrEqualTo(256);
-            durations.Add(stopwatch.Elapsed);
+            var result = RunStartupProbe(null, "default");
+            result.Mime.ShouldBe("image/png");
+            result.Allocated.ShouldBeLessThanOrEqualTo(256);
+            durations.Add(result.Duration);
         }
 
         durations.Max().ShouldBeLessThan(TimeSpan.FromSeconds(2));
     }
 
+    [Theory]
+    [Trait("Category", "Performance")]
+    [InlineData("default", "https://cdn.example.test/assets/photo.png?v=1", "image/png")]
+    [InlineData("tiered", "https://cdn.example.test/assets/photo.png?v=1", "image/png")]
+    [InlineData("optimized", "https://cdn.example.test/assets/photo.png?v=1", "image/png")]
+    [InlineData("default", "png", "image/png")]
+    [InlineData("tiered", "assets/photo.png", "image/png")]
+    [InlineData("tiered", "HTTPS://cdn.example.test/assets/PHOTO.PNG#preview?file=doc.pdf", "image/png")]
+    [InlineData("tiered", "types/module.d.ts", "application/typescript")]
+    [InlineData("optimized", "archive.tar.gz?download=1", "application/gzip")]
+    [InlineData("tiered", "unknown.no-extension", "application/octet-stream")]
+    public void ColdProcessLookups_ShouldPreserveAllocationBudgetAcrossJitModes(
+        string runtimeMode, string input, string expectedMime)
+    {
+        var result = RunStartupProbe(input, runtimeMode);
+
+        result.Mime.ShouldBe(expectedMime);
+        result.Allocated.ShouldBeLessThanOrEqualTo(256);
+    }
+
+    private (TimeSpan Duration, long Allocated, string Mime) RunStartupProbe(string? input, string runtimeMode)
+    {
+        var startInfo = new ProcessStartInfo("dotnet")
+        {
+            RedirectStandardOutput = true,
+            RedirectStandardError = true,
+            UseShellExecute = false
+        };
+        startInfo.ArgumentList.Add(FindStartupProbe());
+        if (input != null)
+        {
+            startInfo.ArgumentList.Add(input);
+        }
+
+        if (runtimeMode == "tiered")
+        {
+            startInfo.Environment["DOTNET_TieredCompilation"] = "1";
+            startInfo.Environment["DOTNET_TieredPGO"] = "1";
+            startInfo.Environment["DOTNET_TC_QuickJitForLoops"] = "1";
+            startInfo.Environment["DOTNET_TC_OnStackReplacement"] = "1";
+            startInfo.Environment["DOTNET_TC_CallCountingDelayMs"] = "0";
+        }
+        else if (runtimeMode == "optimized")
+        {
+            startInfo.Environment["DOTNET_TieredCompilation"] = "0";
+        }
+
+        var stopwatch = Stopwatch.StartNew();
+        using var process = Process.Start(startInfo);
+        process.ShouldNotBeNull();
+        var output = process.StandardOutput.ReadToEnd();
+        var error = process.StandardError.ReadToEnd();
+        process.WaitForExit();
+        stopwatch.Stop();
+
+        process.ExitCode.ShouldBe(0, error);
+        var parts = output.Trim().Split('|');
+        parts.Length.ShouldBe(4, output);
+        var allocated = long.Parse(parts[3], System.Globalization.CultureInfo.InvariantCulture);
+        _output.WriteLine($"runtime={runtimeMode}; input={input ?? "default"}; result={output.Trim()}; elapsed={stopwatch.Elapsed}");
+        return (stopwatch.Elapsed, allocated, parts[0]);
+    }
+
     private static TimeSpan Measure<T>(int iterations, Func<T> operation)
     {
         var stopwatch = Stopwatch.StartNew();