Simplify IInProcessDiagnoser interface.

timcassell · timcassell · commit 3cbd6dcb754c · 2025-11-29T04:00:45.000-05:00
Return `InProcessDiagnoserHandlerData` type instead of tuple.
diff --git a/src/BenchmarkDotNet/Code/CodeGenerator.cs b/src/BenchmarkDotNet/Code/CodeGenerator.cs
@@ -260,15 +260,15 @@ private static string GetInProcessDiagnoserRouters(BenchmarkBuildInfo buildInfo)
 
             static string? ToSourceCode(IInProcessDiagnoser diagnoser, BenchmarkCase benchmarkCase, int index)
             {
-                var (handlerType, serializedConfig) = diagnoser.GetSeparateProcessHandlerTypeAndSerializedConfig(benchmarkCase);
-                if (handlerType is null)
+                var handlerData = diagnoser.GetHandlerData(benchmarkCase);
+                if (handlerData.HandlerType is null)
                 {
                     return null;
                 }
                 string routerType = typeof(InProcessDiagnoserRouter).GetCorrectCSharpTypeName();
                 return $$"""
                 new {{routerType}}() {
-                    {{nameof(InProcessDiagnoserRouter.handler)}} = {{routerType}}.{{nameof(InProcessDiagnoserRouter.Init)}}(new {{handlerType.GetCorrectCSharpTypeName()}}(), {{SourceCodeHelper.ToSourceCode(serializedConfig)}}),
+                    {{nameof(InProcessDiagnoserRouter.handler)}} = {{routerType}}.{{nameof(InProcessDiagnoserRouter.Init)}}(new {{handlerData.HandlerType.GetCorrectCSharpTypeName()}}(), {{SourceCodeHelper.ToSourceCode(handlerData.SerializedConfig)}}),
                     {{nameof(InProcessDiagnoserRouter.index)}} = {{index}},
                     {{nameof(InProcessDiagnoserRouter.runMode)}} = {{SourceCodeHelper.ToSourceCode(diagnoser.GetRunMode(benchmarkCase))}}
                 }
diff --git a/src/BenchmarkDotNet/Diagnosers/IDiagnoser.cs b/src/BenchmarkDotNet/Diagnosers/IDiagnoser.cs
@@ -1,6 +1,4 @@
-﻿using System;
-using System.Collections.Generic;
-using System.ComponentModel;
+﻿using System.Collections.Generic;
 using BenchmarkDotNet.Analysers;
 using BenchmarkDotNet.Engines;
 using BenchmarkDotNet.Exporters;
@@ -42,24 +40,14 @@ public interface IConfigurableDiagnoser<in TConfig> : IDiagnoser
     public interface IInProcessDiagnoser : IDiagnoser
     {
         /// <summary>
-        /// Gets the type of the handler that will run in the separate benchmark process and its serialized config.
+        /// Gets the data used to construct the <see cref="IInProcessDiagnoserHandler"/> that will run in the benchmark process.
         /// </summary>
         /// <remarks>
-        /// The handlerType must implement <see cref="IInProcessDiagnoserHandler"/> and have a publicly accessible default constructor.
+        /// The <see cref="InProcessDiagnoserHandlerData.HandlerType"/> must implement <see cref="IInProcessDiagnoserHandler"/> and have a publicly accessible default constructor.
         /// <para/>
         /// Return <see langword="default"/> to not run the diagnoser handler for the <paramref name="benchmarkCase"/>.
         /// </remarks>
-        (Type? handlerType, string? serializedConfig) GetSeparateProcessHandlerTypeAndSerializedConfig(BenchmarkCase benchmarkCase);
-
-        // GetSameProcessHandler is needed to prevent the handler type from being trimmed for InProcess toolchains.
-
-        /// <summary>
-        /// Gets the handler that will run in the same process.
-        /// </summary>
-        /// <remarks>
-        /// Return <see langword="null"/> to not run the diagnoser handler for the <paramref name="benchmarkCase"/>.
-        /// </remarks>
-        IInProcessDiagnoserHandler? GetSameProcessHandler(BenchmarkCase benchmarkCase);
+        InProcessDiagnoserHandlerData GetHandlerData(BenchmarkCase benchmarkCase);
 
         /// <summary>
         /// Deserializes the results of the handler.
diff --git a/src/BenchmarkDotNet/Diagnosers/InProcessDiagnoserHandlerData.cs b/src/BenchmarkDotNet/Diagnosers/InProcessDiagnoserHandlerData.cs
@@ -0,0 +1,31 @@
+﻿using System;
+using System.Diagnostics.CodeAnalysis;
+
+namespace BenchmarkDotNet.Diagnosers
+{
+    /// <summary>
+    /// The data used to construct the <see cref="IInProcessDiagnoserHandler"/> in the separate process.
+    /// </summary>
+    /// <param name="handlerType">The type of the <see cref="IInProcessDiagnoserHandler"/>.</param>
+    /// <param name="serializedConfig">The serialized config that will be passed to <see cref="IInProcessDiagnoserHandler.Initialize(string?)"/>.</param>
+    public readonly struct InProcessDiagnoserHandlerData(
+        [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)]
+        Type? handlerType,
+        string? serializedConfig)
+    {
+        /// <summary>
+        /// The type of the <see cref="IInProcessDiagnoserHandler"/>. If <see langword="null"/>, the handler will not be created.
+        /// </summary>
+        /// <remarks>
+        /// The type must implement <see cref="IInProcessDiagnoserHandler"/> and have a publicly accessible default constructor.
+        /// <para/>
+        /// </remarks>
+        [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)]
+        public Type? HandlerType { get; } = handlerType;
+
+        /// <summary>
+        /// The serialized config that will be passed to <see cref="IInProcessDiagnoserHandler.Initialize(string?)"/>.
+        /// </summary>
+        public string? SerializedConfig { get; } = serializedConfig;
+    }
+}
diff --git a/src/BenchmarkDotNet/Diagnosers/InProcessDiagnoserRouter.cs b/src/BenchmarkDotNet/Diagnosers/InProcessDiagnoserRouter.cs
@@ -1,4 +1,5 @@
 ﻿using JetBrains.Annotations;
+using System;
 using System.ComponentModel;
 
 namespace BenchmarkDotNet.Diagnosers;
@@ -16,4 +17,9 @@ public static IInProcessDiagnoserHandler Init(IInProcessDiagnoserHandler handler
         handler.Initialize(serializedConfig);
         return handler;
     }
+
+    internal static IInProcessDiagnoserHandler? CreateOrNull(InProcessDiagnoserHandlerData data)
+        => data.HandlerType is null
+        ? null
+        : Init((IInProcessDiagnoserHandler) Activator.CreateInstance(data.HandlerType), data.SerializedConfig);
 }
diff --git a/src/BenchmarkDotNet/Disassemblers/DisassemblyDiagnoser.cs b/src/BenchmarkDotNet/Disassemblers/DisassemblyDiagnoser.cs
@@ -215,16 +215,18 @@ private static IEnumerable<IExporter> GetExporters(Dictionary<BenchmarkCase, Dis
         private static long SumNativeCodeSize(DisassemblyResult disassembly)
             => disassembly.Methods.Sum(method => method.Maps.Sum(map => map.SourceCodes.OfType<Asm>().Sum(asm => asm.InstructionLength)));
 
-        (Type? handlerType, string? serializedConfig) IInProcessDiagnoser.GetSeparateProcessHandlerTypeAndSerializedConfig(BenchmarkCase benchmarkCase)
+        InProcessDiagnoserHandlerData IInProcessDiagnoser.GetHandlerData(BenchmarkCase benchmarkCase)
         {
             if (GetRunMode(benchmarkCase) == RunMode.None
                 || Config.RunInHost
+                // We don't use handler for InProcess toolchains, the host diagnoser already handles it without needing to serialize data.
+                || (benchmarkCase.Job.Infrastructure.TryGetToolchain(out var toolchain) && toolchain.IsInProcess)
                 // Mono disassembler always runs another process.
                 || ShouldUseMonoDisassembler(benchmarkCase))
             {
                 return default;
             }
-            return (typeof(DisassemblyDiagnoserInProcessHandler), BuildClrMdArgs(benchmarkCase, null, 0).Serialize());
+            return new(typeof(DisassemblyDiagnoserInProcessHandler), BuildClrMdArgs(benchmarkCase, null, 0).Serialize());
         }
 
         void IInProcessDiagnoser.DeserializeResults(BenchmarkCase benchmarkCase, string results)
@@ -235,9 +237,6 @@ void IInProcessDiagnoser.DeserializeResults(BenchmarkCase benchmarkCase, string
             this.results.Add(benchmarkCase, result);
         }
 
-        // We don't use handler for InProcess toolchains, the host diagnoser already handles it without needing to serialize data.
-        public IInProcessDiagnoserHandler? GetSameProcessHandler(BenchmarkCase benchmarkCase) => null;
-
         private class NativeCodeSizeMetricDescriptor : IMetricDescriptor
         {
             internal static readonly IMetricDescriptor Instance = new NativeCodeSizeMetricDescriptor();
diff --git a/src/BenchmarkDotNet/Toolchains/InProcess/Emit/Implementation/Runnable/RunnableReuse.cs b/src/BenchmarkDotNet/Toolchains/InProcess/Emit/Implementation/Runnable/RunnableReuse.cs
@@ -34,7 +34,7 @@ public static (Job, EngineParameters, IEngineFactory) PrepareForRun<T>(T instanc
                         {
                             index = i,
                             runMode = d.GetRunMode(benchmarkCase),
-                            handler = d.GetSameProcessHandler(benchmarkCase)
+                            handler = InProcessDiagnoserRouter.CreateOrNull(d.GetHandlerData(benchmarkCase))
                         })
                         .Where(r => r.handler != null)
                         .ToArray(),
diff --git a/src/BenchmarkDotNet/Toolchains/InProcess/NoEmit/InProcessNoEmitRunner.cs b/src/BenchmarkDotNet/Toolchains/InProcess/NoEmit/InProcessNoEmitRunner.cs
@@ -136,7 +136,7 @@ public static void RunCore(IHost host, ExecuteParameters parameters)
                         {
                             index = i,
                             runMode = d.GetRunMode(benchmarkCase),
-                            handler = d.GetSameProcessHandler(benchmarkCase)
+                            handler = Diagnosers.InProcessDiagnoserRouter.CreateOrNull(d.GetHandlerData(benchmarkCase))
                         })
                         .Where(r => r.handler != null)
                         .ToArray()],
diff --git a/tests/BenchmarkDotNet.IntegrationTests/Diagnosers/MockInProcessDiagnoser.cs b/tests/BenchmarkDotNet.IntegrationTests/Diagnosers/MockInProcessDiagnoser.cs
@@ -7,7 +7,6 @@
 using BenchmarkDotNet.Running;
 using BenchmarkDotNet.Validators;
 using System.Collections.Generic;
-using System;
 
 namespace BenchmarkDotNet.IntegrationTests.Diagnosers;
 
@@ -36,22 +35,10 @@ public void Handle(HostSignal signal, DiagnoserActionParameters parameters) { }
 
     public IEnumerable<ValidationError> Validate(ValidationParameters validationParameters) => [];
 
-    public (Type? handlerType, string? serializedConfig) GetSeparateProcessHandlerTypeAndSerializedConfig(BenchmarkCase benchmarkCase)
+    InProcessDiagnoserHandlerData IInProcessDiagnoser.GetHandlerData(BenchmarkCase benchmarkCase)
         => RunMode == RunMode.None
             ? default
-            : (typeof(MockInProcessDiagnoserHandler), ExpectedResult);
-
-    public virtual IInProcessDiagnoserHandler? GetSameProcessHandler(BenchmarkCase benchmarkCase)
-    {
-        var (handlerType, serializedConfig) = GetSeparateProcessHandlerTypeAndSerializedConfig(benchmarkCase);
-        if (handlerType == null)
-        {
-            return null;
-        }
-        var handler = (IInProcessDiagnoserHandler)Activator.CreateInstance(handlerType);
-        handler.Initialize(serializedConfig);
-        return handler;
-    }
+            : new(typeof(MockInProcessDiagnoserHandler), ExpectedResult);
 
     public void DeserializeResults(BenchmarkCase benchmarkCase, string results)
     {
diff --git a/tests/BenchmarkDotNet.IntegrationTests/DisassemblyDiagnoserTests.cs b/tests/BenchmarkDotNet.IntegrationTests/DisassemblyDiagnoserTests.cs
@@ -28,7 +28,7 @@ public DisassemblyDiagnoserTests(ITestOutputHelper output) : base(output) { }
 
         public static IEnumerable<object[]> GetAllJits()
         {
-            yield return [RuntimeInformation.GetCurrentJit(), RuntimeInformation.GetCurrentPlatform(), InProcessEmitToolchain.DontLogOutput]; // InProcess
+            yield return [RuntimeInformation.GetCurrentJit(), RuntimeInformation.GetCurrentPlatform(), InProcessEmitToolchain.Instance]; // InProcess
 
             if (RuntimeInformation.IsFullFramework)
             {

Original file line number	Diff line number	Diff line change
`@@ -260,15 +260,15 @@ private static string GetInProcessDiagnoserRouters(BenchmarkBuildInfo buildInfo)`
`260`	`260`
`261`	`261`	`static string? ToSourceCode(IInProcessDiagnoser diagnoser, BenchmarkCase benchmarkCase, int index)`
`262`	`262`	`{`
`263`		`- var (handlerType, serializedConfig) = diagnoser.GetSeparateProcessHandlerTypeAndSerializedConfig(benchmarkCase);`
`264`		`- if (handlerType is null)`
	`263`	`+ var handlerData = diagnoser.GetHandlerData(benchmarkCase);`
	`264`	`+ if (handlerData.HandlerType is null)`
`265`	`265`	`{`
`266`	`266`	`return null;`
`267`	`267`	`}`
`268`	`268`	`string routerType = typeof(InProcessDiagnoserRouter).GetCorrectCSharpTypeName();`
`269`	`269`	`return $$"""`
`270`	`270`	`new {{routerType}}() {`
`271`		`- {{nameof(InProcessDiagnoserRouter.handler)}} = {{routerType}}.{{nameof(InProcessDiagnoserRouter.Init)}}(new {{handlerType.GetCorrectCSharpTypeName()}}(), {{SourceCodeHelper.ToSourceCode(serializedConfig)}}),`
	`271`	`+ {{nameof(InProcessDiagnoserRouter.handler)}} = {{routerType}}.{{nameof(InProcessDiagnoserRouter.Init)}}(new {{handlerData.HandlerType.GetCorrectCSharpTypeName()}}(), {{SourceCodeHelper.ToSourceCode(handlerData.SerializedConfig)}}),`
`272`	`272`	`{{nameof(InProcessDiagnoserRouter.index)}} = {{index}},`
`273`	`273`	`{{nameof(InProcessDiagnoserRouter.runMode)}} = {{SourceCodeHelper.ToSourceCode(diagnoser.GetRunMode(benchmarkCase))}}`
`274`	`274`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,5 @@`
`1`	`1`	`using JetBrains.Annotations;`
	`2`	`+using System;`
`2`	`3`	`using System.ComponentModel;`
`3`	`4`
`4`	`5`	`namespace BenchmarkDotNet.Diagnosers;`
`@@ -16,4 +17,9 @@ public static IInProcessDiagnoserHandler Init(IInProcessDiagnoserHandler handler`
`16`	`17`	`handler.Initialize(serializedConfig);`
`17`	`18`	`return handler;`
`18`	`19`	`}`
	`20`	`+`
	`21`	`+ internal static IInProcessDiagnoserHandler? CreateOrNull(InProcessDiagnoserHandlerData data)`
	`22`	`+ => data.HandlerType is null`
	`23`	`+ ? null`
	`24`	`+ : Init((IInProcessDiagnoserHandler) Activator.CreateInstance(data.HandlerType), data.SerializedConfig);`
`19`	`25`	`}`
Original file line number	Diff line number	Diff line change
`@@ -215,16 +215,18 @@ private static IEnumerable<IExporter> GetExporters(Dictionary<BenchmarkCase, Dis`
`215`	`215`	`private static long SumNativeCodeSize(DisassemblyResult disassembly)`
`216`	`216`	`=> disassembly.Methods.Sum(method => method.Maps.Sum(map => map.SourceCodes.OfType<Asm>().Sum(asm => asm.InstructionLength)));`
`217`	`217`
`218`		`- (Type? handlerType, string? serializedConfig) IInProcessDiagnoser.GetSeparateProcessHandlerTypeAndSerializedConfig(BenchmarkCase benchmarkCase)`
	`218`	`+ InProcessDiagnoserHandlerData IInProcessDiagnoser.GetHandlerData(BenchmarkCase benchmarkCase)`
`219`	`219`	`{`
`220`	`220`	`if (GetRunMode(benchmarkCase) == RunMode.None`
`221`	`221`	`\|\| Config.RunInHost`
	`222`	`+ // We don't use handler for InProcess toolchains, the host diagnoser already handles it without needing to serialize data.`
	`223`	`+ \|\| (benchmarkCase.Job.Infrastructure.TryGetToolchain(out var toolchain) && toolchain.IsInProcess)`
`222`	`224`	`// Mono disassembler always runs another process.`
`223`	`225`	`\|\| ShouldUseMonoDisassembler(benchmarkCase))`
`224`	`226`	`{`
`225`	`227`	`return default;`
`226`	`228`	`}`
`227`		`- return (typeof(DisassemblyDiagnoserInProcessHandler), BuildClrMdArgs(benchmarkCase, null, 0).Serialize());`
	`229`	`+ return new(typeof(DisassemblyDiagnoserInProcessHandler), BuildClrMdArgs(benchmarkCase, null, 0).Serialize());`
`228`	`230`	`}`
`229`	`231`
`230`	`232`	`void IInProcessDiagnoser.DeserializeResults(BenchmarkCase benchmarkCase, string results)`
`@@ -235,9 +237,6 @@ void IInProcessDiagnoser.DeserializeResults(BenchmarkCase benchmarkCase, string`
`235`	`237`	`this.results.Add(benchmarkCase, result);`
`236`	`238`	`}`
`237`	`239`
`238`		`- // We don't use handler for InProcess toolchains, the host diagnoser already handles it without needing to serialize data.`
`239`		`- public IInProcessDiagnoserHandler? GetSameProcessHandler(BenchmarkCase benchmarkCase) => null;`
`240`		`-`
`241`	`240`	`private class NativeCodeSizeMetricDescriptor : IMetricDescriptor`
`242`	`241`	`{`
`243`	`242`	`internal static readonly IMetricDescriptor Instance = new NativeCodeSizeMetricDescriptor();`
Original file line number	Diff line number	Diff line change
`@@ -34,7 +34,7 @@ public static (Job, EngineParameters, IEngineFactory) PrepareForRun<T>(T instanc`
`34`	`34`	`{`
`35`	`35`	`index = i,`
`36`	`36`	`runMode = d.GetRunMode(benchmarkCase),`
`37`		`- handler = d.GetSameProcessHandler(benchmarkCase)`
	`37`	`+ handler = InProcessDiagnoserRouter.CreateOrNull(d.GetHandlerData(benchmarkCase))`
`38`	`38`	`})`
`39`	`39`	`.Where(r => r.handler != null)`
`40`	`40`	`.ToArray(),`
Original file line number	Diff line number	Diff line change
`@@ -136,7 +136,7 @@ public static void RunCore(IHost host, ExecuteParameters parameters)`
`136`	`136`	`{`
`137`	`137`	`index = i,`
`138`	`138`	`runMode = d.GetRunMode(benchmarkCase),`
`139`		`- handler = d.GetSameProcessHandler(benchmarkCase)`
	`139`	`+ handler = Diagnosers.InProcessDiagnoserRouter.CreateOrNull(d.GetHandlerData(benchmarkCase))`
`140`	`140`	`})`
`141`	`141`	`.Where(r => r.handler != null)`
`142`	`142`	`.ToArray()],`
Original file line number	Diff line number	Diff line change
`@@ -28,7 +28,7 @@ public DisassemblyDiagnoserTests(ITestOutputHelper output) : base(output) { }`
`28`	`28`
`29`	`29`	`public static IEnumerable<object[]> GetAllJits()`
`30`	`30`	`{`
`31`		`- yield return [RuntimeInformation.GetCurrentJit(), RuntimeInformation.GetCurrentPlatform(), InProcessEmitToolchain.DontLogOutput]; // InProcess`
	`31`	`+ yield return [RuntimeInformation.GetCurrentJit(), RuntimeInformation.GetCurrentPlatform(), InProcessEmitToolchain.Instance]; // InProcess`
`32`	`32`
`33`	`33`	`if (RuntimeInformation.IsFullFramework)`
`34`	`34`	`{`