Point in-process disassembly at the benchmark's own runnable type. (#3269)

Run host-side disasm in a threadpool thread.
Remove unnecessary single-method branch.

The in-process host passed a default BenchmarkId to diagnosers, so every
benchmark of a run was disassembled as Runnable_0. The disassembler also
resolved the runnable by name across all loaded modules, and earlier
in-process runs leave same-named runnables loaded (never unloaded when saved
to disk), so it could disassemble a previous run's code.

The host now passes the real BenchmarkId and the emitted runnable type, and
the disassembler resolves that type by its method table.

Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: timcassell

src/BenchmarkDotNet/Diagnosers/DiagnoserActionParameters.cs

@@ -21,6 +21,9 @@ public DiagnoserActionParameters(Process? process, BenchmarkCase benchmarkCase,
 
         public BenchmarkId BenchmarkId { get; }
 
+        /// <summary>The runnable type an in-process toolchain emitted for this benchmark, which only it can name unambiguously.</summary>
+        internal Type? InProcessRunnableType { get; init; }
+
         public ImmutableConfig Config => BenchmarkCase.Config;
     }
 }

src/BenchmarkDotNet/Disassemblers/ClrMdArgs.cs

@@ -11,6 +11,11 @@ internal struct ClrMdArgs(int processId, string typeName, string methodName, boo
         [JsonIgnore]
         internal string TypeName = typeName ?? "";
 
+        // Identifies the type exactly when the disassembler runs in the process that loaded it. Several loaded modules can
+        // define a type of the same name: an in-process toolchain emits the same runnable type names on every run.
+        [JsonIgnore]
+        internal IntPtr TypeHandle;
+
         [JsonInclude]
         internal string MethodName = methodName;
 

src/BenchmarkDotNet/Disassemblers/ClrMdDisassembler.cs

@@ -86,7 +86,11 @@ internal DisassemblyResult AttachAndDisassemble(ClrMdArgs args)
             }
             else
             {
-                var typeWithBenchmark = state.Runtime.EnumerateModules().Select(module => module.GetTypeByName(args.TypeName)).WhereNotNull().First();
+                // A type handle is the type's method table, so it cannot resolve to a same-named type of another module.
+                var typeWithBenchmark = args.TypeHandle != IntPtr.Zero
+                    ? state.Runtime.GetTypeByMethodTable((ulong)args.TypeHandle.ToInt64())
+                        ?? throw new InvalidOperationException($"No type has the method table {args.TypeHandle.ToInt64():X} ({args.TypeName}).")
+                    : state.Runtime.EnumerateModules().Select(module => module.GetTypeByName(args.TypeName)).WhereNotNull().First();
 
                 // The whole signature, because the name alone is not enough: ClrType.Methods also surfaces inherited methods
                 // on the desktop CLR, and ClrMethod.Type reports the type being enumerated rather than the declaring one, so
@@ -104,9 +108,7 @@ internal DisassemblyResult AttachAndDisassemble(ClrMdArgs args)
             // we don't want to export the disassembler entry point method which is just an artificial method added to get generic types working.
             // Identified by its native code address rather than its name: a signature does not always carry the declaring
             // type (see AddressToNameMapping below), so a benchmark method of the same name could match it.
-            var filteredMethods = disassembledMethods.Length == 1
-                ? disassembledMethods // if there is only one method we want to return it (most probably benchmark got inlined)
-                : disassembledMethods.Where(method => method.NativeCode != entryPoint?.NativeCode).ToArray();
+            var filteredMethods = disassembledMethods.Where(method => method.NativeCode != entryPoint?.NativeCode).ToArray();
 
             return new DisassemblyResult
             {

src/BenchmarkDotNet/Disassemblers/DisassemblyDiagnoser.cs

@@ -95,9 +95,15 @@ public async ValueTask HandleAsync(HostSignal signal, DiagnoserActionParameters
             switch (signal)
             {
                 case HostSignal.AfterAll when (Config.RunInHost || isInProcess) && ShouldUseClrMdDisassembler(benchmark):
-                    results.Add(benchmark, ClrMdDisassembler.AttachAndDisassemble(
-                        BuildClrMdArgs(parameters.BenchmarkCase, $"{RunnableConstants.EmittedTypePrefix}{parameters.BenchmarkId.Value}", parameters.ProcessId))
-                    );
+                    await ThreadPoolHelper.Switch(cancellationToken);
+
+                    var clrMdArgs = BuildClrMdArgs(parameters.BenchmarkCase, $"{RunnableConstants.EmittedTypePrefix}{parameters.BenchmarkId.Value}", parameters.ProcessId);
+                    if (parameters.InProcessRunnableType is { } runnableType)
+                    {
+                        clrMdArgs.TypeName = runnableType.FullName!;
+                        clrMdArgs.TypeHandle = runnableType.TypeHandle.Value;
+                    }
+                    results.Add(benchmark, ClrMdDisassembler.AttachAndDisassemble(clrMdArgs));
                     break;
                 case HostSignal.SeparateLogic when ShouldUseMonoDisassembler(benchmark):
                     var result = await monoDisassembler.Disassemble(benchmark, cancellationToken).ConfigureAwait(false);
@@ -270,6 +276,7 @@ ValueTask IInProcessDiagnoserHandler.HandleAsync(BenchmarkSignal signal, InProce
             var clrMdArgs = _clrMdArgs;
             clrMdArgs.ProcessId = Process.GetCurrentProcess().Id;
             clrMdArgs.TypeName = args.BenchmarkInstance.GetType().FullName!;
+            clrMdArgs.TypeHandle = args.BenchmarkInstance.GetType().TypeHandle.Value;
             _result = DisassemblyDiagnoser.GetClrMdDisassembler().AttachAndDisassemble(clrMdArgs);
             return new();
         }

src/BenchmarkDotNet/Toolchains/InProcess/Emit/InProcessEmitExecutor.cs

@@ -15,7 +15,7 @@ internal class InProcessEmitExecutor(bool executeOnSeparateThread) : IExecutor
     {
         public async ValueTask<ExecuteResult> ExecuteAsync(ExecuteParameters executeParameters, CancellationToken cancellationToken)
         {
-            var host = new InProcessHost(executeParameters.BenchmarkCase, executeParameters.Logger, executeParameters.Diagnoser, cancellationToken);
+            var host = new InProcessHost(executeParameters.BenchmarkCase, executeParameters.BenchmarkId, InProcessEmitRunner.GetRunnableType(executeParameters), executeParameters.Logger, executeParameters.Diagnoser, cancellationToken);
 
             int exitCode = -1;
             if (executeOnSeparateThread)

src/BenchmarkDotNet/Toolchains/InProcess/Emit/InProcessEmitRunner.cs

@@ -22,11 +22,7 @@ public static async ValueTask<int> Run(IHost host, ExecuteParameters parameters)
 
         try
         {
-            var runnableType = ((InProcessEmitArtifactsPath)parameters.BuildResult.ArtifactsPaths)
-                .GeneratedAssembly
-                .GetType(EmittedTypePrefix + parameters.BenchmarkId)!;
-
-            await RunCore(runnableType, host, parameters).ConfigureAwait();
+            await RunCore(GetRunnableType(parameters), host, parameters).ConfigureAwait();
 
             return 0;
         }
@@ -54,6 +50,11 @@ public static async ValueTask<int> Run(IHost host, ExecuteParameters parameters)
         }
     }
 
+    internal static Type GetRunnableType(ExecuteParameters parameters)
+        => ((InProcessEmitArtifactsPath)parameters.BuildResult.ArtifactsPaths)
+            .GeneratedAssembly
+            .GetType(EmittedTypePrefix + parameters.BenchmarkId)!;
+
     private static async ValueTask RunCore(Type runnableType, IHost host, ExecuteParameters parameters)
     {
         var benchmarkCase = parameters.BenchmarkCase;

src/BenchmarkDotNet/Toolchains/InProcess/InProcessHost.cs

@@ -19,7 +19,7 @@ internal sealed class InProcessHost : IHost
         private readonly List<string> inProcessDiagnoserLines = [];
         private readonly List<string> prefixedLines = [];
 
-        public InProcessHost(BenchmarkCase benchmarkCase, ILogger logger, IDiagnoser diagnoser, CancellationToken cancellationToken)
+        public InProcessHost(BenchmarkCase benchmarkCase, BenchmarkId benchmarkId, Type? runnableType, ILogger logger, IDiagnoser diagnoser, CancellationToken cancellationToken)
         {
             this.logger = logger;
             this.diagnoser = diagnoser;
@@ -30,7 +30,10 @@ public InProcessHost(BenchmarkCase benchmarkCase, ILogger logger, IDiagnoser dia
                 diagnoserActionParameters = new DiagnoserActionParameters(
                     Process.GetCurrentProcess(),
                     benchmarkCase,
-                    default);
+                    benchmarkId)
+                {
+                    InProcessRunnableType = runnableType
+                };
         }
 
         public RunResults RunResults { get; private set; }

src/BenchmarkDotNet/Toolchains/InProcess/NoEmit/InProcessNoEmitExecutor.cs

@@ -15,7 +15,7 @@ internal class InProcessNoEmitExecutor(bool executeOnSeparateThread, IBenchmarkA
     {
         public async ValueTask<ExecuteResult> ExecuteAsync(ExecuteParameters executeParameters, CancellationToken cancellationToken)
         {
-            var host = new InProcessHost(executeParameters.BenchmarkCase, executeParameters.Logger, executeParameters.Diagnoser, cancellationToken);
+            var host = new InProcessHost(executeParameters.BenchmarkCase, executeParameters.BenchmarkId, null, executeParameters.Logger, executeParameters.Diagnoser, cancellationToken);
 
             int exitCode = -1;
             if (executeOnSeparateThread)

tests/BenchmarkDotNet.IntegrationTests/DisassemblyDiagnoserTests.cs

@@ -210,6 +210,66 @@ public void CanDisassembleWhenBenchmarkDeclaresGeneratedMemberNames(Jit jit, Pla
             AssertDisassemblyResult(result, $"{nameof(WithGeneratedMemberNames.Called)}()");
         }
 
+        public class WithTwoBenchmarks
+        {
+            [Benchmark] public void First() => FirstCallee();
+
+            [Benchmark] public void Second() => SecondCallee();
+
+            [MethodImpl(MethodImplOptions.NoInlining)] public void FirstCallee() { }
+
+            [MethodImpl(MethodImplOptions.NoInlining)] public void SecondCallee() { }
+        }
+
+        // Every benchmark of an in-process run is emitted into the same assembly, one runnable type each, so the disassembler
+        // has to be pointed at the runnable of the benchmark it is handling rather than the first one.
+        [Fact]
+        public void InProcessDisassemblyTargetsTheRunnableOfEachBenchmark()
+        {
+            var disassemblyDiagnoser = new DisassemblyDiagnoser(
+                new DisassemblyDiagnoserConfig(printSource: true, maxDepth: 3));
+
+            CanExecute<WithTwoBenchmarks>(CreateInProcessConfig(disassemblyDiagnoser));
+
+            Assert.Equal(2, disassemblyDiagnoser.Results.Count);
+            foreach (var pair in disassemblyDiagnoser.Results)
+            {
+                var benchmarkCase = pair.Key;
+                var result = pair.Value;
+                Assert.Empty(result.Errors);
+                string called = benchmarkCase.Descriptor.WorkloadMethod.Name == nameof(WithTwoBenchmarks.First)
+                    ? nameof(WithTwoBenchmarks.FirstCallee)
+                    : nameof(WithTwoBenchmarks.SecondCallee);
+                AssertDisassemblyResult(result, $"{benchmarkCase.Descriptor.WorkloadMethod.Name}()");
+                AssertDisassemblyResult(result, $"{called}()");
+            }
+        }
+
+        // Each in-process run emits its runnables under the same type names, and the assemblies of earlier runs can still be
+        // loaded (never collected when saved to disk, which KeepBenchmarkFiles does on .NET Framework).
+        [Fact]
+        public void InProcessDisassemblyIgnoresRunnablesOfEarlierRuns()
+        {
+            CanExecute<WithCalls>(ManualConfig.CreateEmpty()
+                .AddJob(Job.Dry.WithToolchain(InProcessEmitToolchain.Default))
+                .AddLogger(new OutputLogger(Output))
+                .WithOptions(ConfigOptions.KeepBenchmarkFiles));
+
+            var disassemblyDiagnoser = new DisassemblyDiagnoser(
+                new DisassemblyDiagnoserConfig(printSource: true, maxDepth: 3));
+
+            CanExecute<WithGeneratedMemberNames>(CreateInProcessConfig(disassemblyDiagnoser));
+
+            DisassemblyResult result = disassemblyDiagnoser.Results.Single().Value;
+
+            Assert.Empty(result.Errors);
+            AssertDisassemblyResult(result, $"{nameof(WithGeneratedMemberNames.Benchmark)}()");
+            AssertDisassemblyResult(result, $"{nameof(WithGeneratedMemberNames.Called)}()");
+        }
+
+        private IConfig CreateInProcessConfig(IDiagnoser disassemblyDiagnoser)
+            => CreateConfig(JitInfo.GetCurrentJit(), RuntimeInformation.GetCurrentPlatform(), InProcessEmitToolchain.Default, disassemblyDiagnoser, RunStrategy.ColdStart);
+
         private IConfig CreateConfig(Jit jit, Platform platform, IToolchain toolchain, IDiagnoser disassemblyDiagnoser, RunStrategy runStrategy)
             => ManualConfig.CreateEmpty()
                 .AddJob(Job.Dry.WithJit(jit)