Make in-process diagnosers work in wasm and in-process toolchains.

timcassell · timcassell · commit 9f6f0d9a3786 · 2025-10-25T03:15:13.000-04:00
Add tests.
diff --git a/src/BenchmarkDotNet/Diagnosers/CompositeDiagnoser.cs b/src/BenchmarkDotNet/Diagnosers/CompositeDiagnoser.cs
@@ -61,7 +61,7 @@ public IEnumerable<ValidationError> Validate(ValidationParameters validationPara
     public sealed class CompositeInProcessDiagnoser(IReadOnlyList<IInProcessDiagnoser> inProcessDiagnosers)
     {
         public const string HeaderKey = "// InProcessDiagnoser";
-        public const string ResultsKey = "// InProcessDiagnoserResults";
+        public const string ResultsKey = $"{HeaderKey}Results";
 
         public IEnumerable<string> GetHandlersSourceCode(BenchmarkCase benchmarkCase)
             => inProcessDiagnosers
diff --git a/src/BenchmarkDotNet/Disassemblers/DisassemblyDiagnoser.cs b/src/BenchmarkDotNet/Disassemblers/DisassemblyDiagnoser.cs
@@ -45,12 +45,10 @@ internal static ClrMdDisassembler GetClrMdDisassembler() =>
 
         private readonly MonoDisassembler monoDisassembler = new();
         private readonly Dictionary<BenchmarkCase, DisassemblyResult> results = [];
-        private readonly bool runInHost;
 
         public DisassemblyDiagnoser(DisassemblyDiagnoserConfig config)
         {
             Config = config;
-            runInHost = Config.RunInHost;
 
             Exporters = GetExporters(results, config);
         }
@@ -100,7 +98,7 @@ public void Handle(HostSignal signal, DiagnoserActionParameters parameters)
 
             switch (signal)
             {
-                case HostSignal.AfterAll when (runInHost || isInProcess) && ShouldUseClrMdDisassembler(benchmark):
+                case HostSignal.AfterAll when (Config.RunInHost || isInProcess) && ShouldUseClrMdDisassembler(benchmark):
                     results.Add(benchmark, ClrMdDisassembler.AttachAndDisassemble(
                         BuildDisassemblerSettings(parameters.BenchmarkCase, $"BenchmarkDotNet.Autogenerated.Runnable_{parameters.BenchmarkId.Value}", parameters.Process.Id))
                     );
@@ -139,7 +137,7 @@ public IEnumerable<ValidationError> Validate(ValidationParameters validationPara
 
                 if (ShouldUseClrMdDisassembler(benchmark))
                 {
-                    if (runInHost && toolchain?.IsInProcess != true && !PlatformsMatch(currentPlatform, benchmark.Job.Environment.Platform))
+                    if (Config.RunInHost && toolchain?.IsInProcess != true && !PlatformsMatch(currentPlatform, benchmark.Job.Environment.Platform))
                     {
                         yield return new ValidationError(true, "DisassemblyDiagnoser cannot run in host for a job that targets a different platform", benchmark);
                     }
@@ -216,7 +214,7 @@ private static long SumNativeCodeSize(DisassemblyResult disassembly)
         string IInProcessDiagnoser.GetHandlerSourceCode(BenchmarkCase benchmarkCase, int index)
         {
             // Mono disassembler always runs another process.
-            if (runInHost || ShouldUseMonoDisassembler(benchmarkCase))
+            if (Config.RunInHost || ShouldUseMonoDisassembler(benchmarkCase))
             {
                 return null;
             }
diff --git a/src/BenchmarkDotNet/Loggers/Broker.cs b/src/BenchmarkDotNet/Loggers/Broker.cs
@@ -90,17 +90,23 @@ private void ProcessDataBlocking()
                 {
                     Results.Add(line);
                 }
+                // Keep in sync with WasmExecutor and InProcessHost.
                 else if (line.StartsWith(CompositeInProcessDiagnoser.HeaderKey))
                 {
-                    // Something like "// InProcessDiagnoserHandlerResults 0 1"
+                    // Something like "// InProcessDiagnoser 0 1"
                     string[] lineItems = line.Split(' ');
                     int diagnoserIndex = int.Parse(lineItems[2]);
                     int resultsLinesCount = int.Parse(lineItems[3]);
                     var resultsStringBuilder = new StringBuilder();
-                    for (int i = 0; i < resultsLinesCount; ++i)
+                    for (int i = 0; i < resultsLinesCount;)
                     {
                         // Strip the prepended "// InProcessDiagnoserResults ".
-                        resultsStringBuilder.AppendLine(reader.ReadLine().Substring(CompositeInProcessDiagnoser.ResultsKey.Length + 1));
+                        line = reader.ReadLine().Substring(CompositeInProcessDiagnoser.ResultsKey.Length + 1);
+                        resultsStringBuilder.Append(line);
+                        if (++i < resultsLinesCount)
+                        {
+                            resultsStringBuilder.AppendLine();
+                        }
                     }
                     compositeInProcessDiagnoser.DeserializeResults(diagnoserIndex, DiagnoserActionParameters.BenchmarkCase, resultsStringBuilder.ToString());
                 }
diff --git a/src/BenchmarkDotNet/Toolchains/InProcess/Emit/InProcessEmitExecutor.cs b/src/BenchmarkDotNet/Toolchains/InProcess/Emit/InProcessEmitExecutor.cs
@@ -76,6 +76,8 @@ public ExecuteResult Execute(ExecuteParameters executeParameters)
                     $"Benchmark {executeParameters.BenchmarkCase.DisplayInfo} takes too long to run. " +
                     "Prefer to use out-of-process toolchains for long-running benchmarks.");
 
+            host.HandleInProcessDiagnoserResults(executeParameters.BenchmarkCase, executeParameters.CompositeInProcessDiagnoser);
+
             return ExecuteResult.FromRunResults(host.RunResults, exitCode);
         }
 
diff --git a/src/BenchmarkDotNet/Toolchains/InProcess/InProcessHost.cs b/src/BenchmarkDotNet/Toolchains/InProcess/InProcessHost.cs
@@ -1,27 +1,25 @@
 ﻿using System;
+using System.Collections.Generic;
 using System.Diagnostics;
 using System.IO;
-
+using System.Text;
 using BenchmarkDotNet.Configs;
 using BenchmarkDotNet.Diagnosers;
 using BenchmarkDotNet.Engines;
 using BenchmarkDotNet.Loggers;
 using BenchmarkDotNet.Running;
 using BenchmarkDotNet.Validators;
 
-using JetBrains.Annotations;
-
 namespace BenchmarkDotNet.Toolchains.InProcess
 {
     /// <summary>Host API for in-process benchmarks.</summary>
     /// <seealso cref="IHost"/>
-    public sealed class InProcessHost : IHost
+    internal sealed class InProcessHost : IHost
     {
         private readonly ILogger logger;
-
         private readonly IDiagnoser? diagnoser;
-
         private readonly DiagnoserActionParameters? diagnoserActionParameters;
+        private readonly List<string> inProcessDiagnoserLines = [];
 
         /// <summary>Creates a new instance of <see cref="InProcessHost"/>.</summary>
         /// <param name="benchmarkCase">Current benchmark.</param>
@@ -34,7 +32,6 @@ public InProcessHost(BenchmarkCase benchmarkCase, ILogger logger, IDiagnoser dia
 
             this.logger = logger ?? throw new ArgumentNullException(nameof(logger));
             this.diagnoser = diagnoser;
-            IsDiagnoserAttached = diagnoser != null;
             Config = benchmarkCase.Config;
 
             if (diagnoser != null)
@@ -44,16 +41,12 @@ public InProcessHost(BenchmarkCase benchmarkCase, ILogger logger, IDiagnoser dia
                     default);
         }
 
-        /// <summary><c>True</c> if there are diagnosers attached.</summary>
-        /// <value><c>True</c> if there are diagnosers attached.</value>
-        [PublicAPI] public bool IsDiagnoserAttached { get; }
-
         /// <summary>Results of the run.</summary>
         /// <value>Results of the run.</value>
         public RunResults RunResults { get; private set; }
 
         /// <summary>Current config</summary>
-        [PublicAPI] public IConfig Config { get; set; }
+        public IConfig Config { get; set; }
 
         /// <summary>Passes text to the host.</summary>
         /// <param name="message">Text to write.</param>
@@ -64,20 +57,18 @@ public InProcessHost(BenchmarkCase benchmarkCase, ILogger logger, IDiagnoser dia
 
         /// <summary>Passes text (new line appended) to the host.</summary>
         /// <param name="message">Text to write.</param>
-        public void WriteLine(string message) => logger.WriteLine(message);
+        public void WriteLine(string message)
+        {
+            logger.WriteLine(message);
+            if (message.StartsWith(CompositeInProcessDiagnoser.HeaderKey)) // Captures both header and results
+            {
+                inProcessDiagnoserLines.Add(message);
+            }
+        }
 
         /// <summary>Sends notification signal to the host.</summary>
         /// <param name="hostSignal">The signal to send.</param>
-        public void SendSignal(HostSignal hostSignal)
-        {
-            if (!IsDiagnoserAttached) // no need to send the signal, nobody is listening for it
-                return;
-
-            if (diagnoser == null)
-                throw new NullReferenceException(nameof(diagnoser));
-
-            diagnoser.Handle(hostSignal, diagnoserActionParameters);
-        }
+        public void SendSignal(HostSignal hostSignal) => diagnoser?.Handle(hostSignal, diagnoserActionParameters);
 
         public void SendError(string message) => logger.WriteLine(LogKind.Error, $"{ValidationErrorReporter.ConsoleErrorPrefix} {message}");
 
@@ -94,6 +85,34 @@ public void ReportResults(RunResults runResults)
             }
         }
 
+        // Keep in sync with Broker and WasmExecutor.
+        internal void HandleInProcessDiagnoserResults(BenchmarkCase benchmarkCase, CompositeInProcessDiagnoser compositeInProcessDiagnoser)
+        {
+            var linesEnumerator = inProcessDiagnoserLines.GetEnumerator();
+            while (linesEnumerator.MoveNext())
+            {
+                // Something like "// InProcessDiagnoser 0 1"
+                var line = linesEnumerator.Current;
+                string[] lineItems = line.Split(' ');
+                int diagnoserIndex = int.Parse(lineItems[2]);
+                int resultsLinesCount = int.Parse(lineItems[3]);
+                var resultsStringBuilder = new StringBuilder();
+                for (int i = 0; i < resultsLinesCount;)
+                {
+                    // Strip the prepended "// InProcessDiagnoserResults ".
+                    bool movedNext = linesEnumerator.MoveNext();
+                    Debug.Assert(movedNext);
+                    line = linesEnumerator.Current.Substring(CompositeInProcessDiagnoser.ResultsKey.Length + 1);
+                    resultsStringBuilder.Append(line);
+                    if (++i < resultsLinesCount)
+                    {
+                        resultsStringBuilder.AppendLine();
+                    }
+                }
+                compositeInProcessDiagnoser.DeserializeResults(diagnoserIndex, benchmarkCase, resultsStringBuilder.ToString());
+            }
+        }
+
         public void Dispose()
         {
             // do nothing on purpose
diff --git a/src/BenchmarkDotNet/Toolchains/InProcess/NoEmit/InProcessNoEmitExecutor.cs b/src/BenchmarkDotNet/Toolchains/InProcess/NoEmit/InProcessNoEmitExecutor.cs
@@ -76,6 +76,8 @@ public ExecuteResult Execute(ExecuteParameters executeParameters)
                     $"Benchmark {executeParameters.BenchmarkCase.DisplayInfo} takes too long to run. " +
                     "Prefer to use out-of-process toolchains for long-running benchmarks.");
 
+            host.HandleInProcessDiagnoserResults(executeParameters.BenchmarkCase, executeParameters.CompositeInProcessDiagnoser);
+
             return ExecuteResult.FromRunResults(host.RunResults, exitCode);
         }
 
diff --git a/src/BenchmarkDotNet/Toolchains/MonoWasm/WasmExecutor.cs b/src/BenchmarkDotNet/Toolchains/MonoWasm/WasmExecutor.cs
@@ -10,10 +10,11 @@
 using BenchmarkDotNet.Toolchains.Parameters;
 using BenchmarkDotNet.Toolchains.Results;
 using System;
+using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Diagnostics;
 using System.IO;
-using System.Linq;
+using System.Text;
 
 namespace BenchmarkDotNet.Toolchains.MonoWasm
 {
@@ -100,14 +101,50 @@ private static ExecuteResult Execute(Process process, BenchmarkCase benchmarkCas
                 processOutputReader.StopRead();
             }
 
-            // TODO: Handle InProcessDiagnoser messages since this executor does not use Broker.
             ImmutableArray<string> outputLines = processOutputReader.GetOutputLines();
+            var prefixedLines = new List<string>();
+            var standardOutput = new List<string>();
+            var outputEnumerator = outputLines.GetEnumerator();
+            while (outputEnumerator.MoveNext())
+            {
+                var line = outputEnumerator.Current;
+                if (!line.StartsWith("//"))
+                {
+                    standardOutput.Add(line);
+                    continue;
+                }
+
+                prefixedLines.Add(line);
+
+                // Keep in sync with Broker and InProcessHost.
+                if (line.StartsWith(CompositeInProcessDiagnoser.HeaderKey))
+                {
+                    // Something like "// InProcessDiagnoser 0 1"
+                    string[] lineItems = line.Split(' ');
+                    int diagnoserIndex = int.Parse(lineItems[2]);
+                    int resultsLinesCount = int.Parse(lineItems[3]);
+                    var resultsStringBuilder = new StringBuilder();
+                    for (int i = 0; i < resultsLinesCount;)
+                    {
+                        // Strip the prepended "// InProcessDiagnoserResults ".
+                        bool movedNext = outputEnumerator.MoveNext();
+                        Debug.Assert(movedNext);
+                        line = outputEnumerator.Current.Substring(CompositeInProcessDiagnoser.ResultsKey.Length + 1);
+                        resultsStringBuilder.Append(line);
+                        if (++i < resultsLinesCount)
+                        {
+                            resultsStringBuilder.AppendLine();
+                        }
+                    }
+                    compositeInProcessDiagnoser.DeserializeResults(diagnoserIndex, benchmarkCase, resultsStringBuilder.ToString());
+                }
+            }
 
             return new ExecuteResult(true,
                 process.HasExited ? process.ExitCode : null,
                 process.Id,
-                outputLines.Where(line => !line.StartsWith("//")).ToArray(),
-                outputLines.Where(line => line.StartsWith("//")).ToArray(),
+                [.. prefixedLines],
+                [.. standardOutput],
                 outputLines,
                 launchIndex);
         }
diff --git a/tests/BenchmarkDotNet.IntegrationTests/Diagnosers/MockInProcessDiagnoser.cs b/tests/BenchmarkDotNet.IntegrationTests/Diagnosers/MockInProcessDiagnoser.cs
@@ -0,0 +1,53 @@
+﻿using BenchmarkDotNet.Analysers;
+using BenchmarkDotNet.Diagnosers;
+using BenchmarkDotNet.Engines;
+using BenchmarkDotNet.Exporters;
+using BenchmarkDotNet.Loggers;
+using BenchmarkDotNet.Reports;
+using BenchmarkDotNet.Running;
+using BenchmarkDotNet.Validators;
+using BenchmarkDotNet.Extensions;
+using System.Collections.Generic;
+using BenchmarkDotNet.Helpers;
+
+namespace BenchmarkDotNet.IntegrationTests.Diagnosers
+{
+    public sealed class MockInProcessDiagnoser : IInProcessDiagnoser
+    {
+        public Dictionary<BenchmarkCase, string> Results { get; } = [];
+
+        public IEnumerable<string> Ids => [nameof(MockInProcessDiagnoser)];
+
+        public IEnumerable<IExporter> Exporters => [];
+
+        public IEnumerable<IAnalyser> Analysers => [];
+
+        public void DeserializeResults(BenchmarkCase benchmarkCase, string results) => Results.Add(benchmarkCase, results);
+
+        public void DisplayResults(ILogger logger) => logger.WriteLine($"{nameof(MockInProcessDiagnoser)} results: [{string.Join(", ", Results.Values)}]");
+
+        public IInProcessDiagnoserHandler GetHandler(BenchmarkCase benchmarkCase, int index) => new MockInProcessDiagnoserHandler(index, GetRunMode(benchmarkCase));
+
+        public string GetHandlerSourceCode(BenchmarkCase benchmarkCase, int index)
+            => $"new {typeof(MockInProcessDiagnoserHandler).GetCorrectCSharpTypeName()}({index}, {SourceCodeHelper.ToSourceCode(GetRunMode(benchmarkCase))})";
+
+        public RunMode GetRunMode(BenchmarkCase benchmarkCase) => RunMode.NoOverhead;
+
+        public void Handle(HostSignal signal, DiagnoserActionParameters parameters) { }
+
+        public IEnumerable<Metric> ProcessResults(DiagnoserResults results) => [];
+
+        public IEnumerable<ValidationError> Validate(ValidationParameters validationParameters) => [];
+    }
+
+    public sealed class MockInProcessDiagnoserHandler(int index, RunMode runMode) : IInProcessDiagnoserHandler
+    {
+        public int Index { get; } = index;
+
+        public RunMode RunMode { get; } = runMode;
+
+        public void Handle(BenchmarkSignal signal, InProcessDiagnoserActionArgs parameters) { }
+
+        public string SerializeResults() => $"DummyResult{Index}";
+    }
+}
diff --git a/tests/BenchmarkDotNet.IntegrationTests/InProcessEmitTest.cs b/tests/BenchmarkDotNet.IntegrationTests/InProcessEmitTest.cs
@@ -6,6 +6,7 @@
 using BenchmarkDotNet.Columns;
 using BenchmarkDotNet.Configs;
 using BenchmarkDotNet.Engines;
+using BenchmarkDotNet.IntegrationTests.Diagnosers;
 using BenchmarkDotNet.IntegrationTests.InProcess.EmitTests;
 using BenchmarkDotNet.Jobs;
 using BenchmarkDotNet.Loggers;
@@ -130,6 +131,19 @@ public void InProcessBenchmarkEmitsSameIL(Type benchmarkType)
             Assert.DoesNotContain("No benchmarks found", logger.GetLog());
         }
 
+        [Fact]
+        public void InProcessEmitSupportsInProcessDiagnosers()
+        {
+            var logger = new OutputLogger(Output);
+            var diagnoser = new MockInProcessDiagnoser();
+            var config = CreateInProcessConfig(logger).AddDiagnoser(diagnoser);
+
+            var summary = CanExecute<BenchmarkAllCases>(config);
+
+            var expected = Enumerable.Repeat("DummyResult0", summary.BenchmarksCases.Length);
+            Assert.Equal(expected, diagnoser.Results.Values);
+        }
+
         [UsedImplicitly(ImplicitUseTargetFlags.WithMembers)]
         public class BenchmarkAllCases
         {
diff --git a/tests/BenchmarkDotNet.IntegrationTests/InProcessTest.cs b/tests/BenchmarkDotNet.IntegrationTests/InProcessTest.cs
@@ -9,6 +9,7 @@
 using BenchmarkDotNet.Configs;
 using BenchmarkDotNet.Engines;
 using BenchmarkDotNet.Environments;
+using BenchmarkDotNet.IntegrationTests.Diagnosers;
 using BenchmarkDotNet.Jobs;
 using BenchmarkDotNet.Loggers;
 using BenchmarkDotNet.Running;
@@ -217,6 +218,19 @@ public void InProcessBenchmarkAllCasesSupported()
             }
         }
 
+        [Fact]
+        public void InProcessNoEmitSupportsInProcessDiagnosers()
+        {
+            var logger = new OutputLogger(Output);
+            var diagnoser = new MockInProcessDiagnoser();
+            var config = CreateInProcessConfig(logger).AddDiagnoser(diagnoser);
+
+            var summary = CanExecute<BenchmarkAllCases>(config);
+
+            var expected = Enumerable.Repeat("DummyResult0", summary.BenchmarksCases.Length);
+            Assert.Equal(expected, diagnoser.Results.Values);
+        }
+
         [UsedImplicitly(ImplicitUseTargetFlags.WithMembers)]
         public class BenchmarkAllCases
         {
diff --git a/tests/BenchmarkDotNet.IntegrationTests/NativeAotTests.cs b/tests/BenchmarkDotNet.IntegrationTests/NativeAotTests.cs
diff --git a/tests/BenchmarkDotNet.IntegrationTests/WasmTests.cs b/tests/BenchmarkDotNet.IntegrationTests/WasmTests.cs

Original file line number	Diff line number	Diff line change
`@@ -61,7 +61,7 @@ public IEnumerable<ValidationError> Validate(ValidationParameters validationPara`
`61`	`61`	`public sealed class CompositeInProcessDiagnoser(IReadOnlyList<IInProcessDiagnoser> inProcessDiagnosers)`
`62`	`62`	`{`
`63`	`63`	`public const string HeaderKey = "// InProcessDiagnoser";`
`64`		`- public const string ResultsKey = "// InProcessDiagnoserResults";`
	`64`	`+ public const string ResultsKey = $"{HeaderKey}Results";`
`65`	`65`
`66`	`66`	`public IEnumerable<string> GetHandlersSourceCode(BenchmarkCase benchmarkCase)`
`67`	`67`	`=> inProcessDiagnosers`
Original file line number	Diff line number	Diff line change
`@@ -45,12 +45,10 @@ internal static ClrMdDisassembler GetClrMdDisassembler() =>`
`45`	`45`
`46`	`46`	`private readonly MonoDisassembler monoDisassembler = new();`
`47`	`47`	`private readonly Dictionary<BenchmarkCase, DisassemblyResult> results = [];`
`48`		`- private readonly bool runInHost;`
`49`	`48`
`50`	`49`	`public DisassemblyDiagnoser(DisassemblyDiagnoserConfig config)`
`51`	`50`	`{`
`52`	`51`	`Config = config;`
`53`		`- runInHost = Config.RunInHost;`
`54`	`52`
`55`	`53`	`Exporters = GetExporters(results, config);`
`56`	`54`	`}`
`@@ -100,7 +98,7 @@ public void Handle(HostSignal signal, DiagnoserActionParameters parameters)`
`100`	`98`
`101`	`99`	`switch (signal)`
`102`	`100`	`{`
`103`		`- case HostSignal.AfterAll when (runInHost \|\| isInProcess) && ShouldUseClrMdDisassembler(benchmark):`
	`101`	`+ case HostSignal.AfterAll when (Config.RunInHost \|\| isInProcess) && ShouldUseClrMdDisassembler(benchmark):`
`104`	`102`	`results.Add(benchmark, ClrMdDisassembler.AttachAndDisassemble(`
`105`	`103`	`BuildDisassemblerSettings(parameters.BenchmarkCase, $"BenchmarkDotNet.Autogenerated.Runnable_{parameters.BenchmarkId.Value}", parameters.Process.Id))`
`106`	`104`	`);`
`@@ -139,7 +137,7 @@ public IEnumerable<ValidationError> Validate(ValidationParameters validationPara`
`139`	`137`
`140`	`138`	`if (ShouldUseClrMdDisassembler(benchmark))`
`141`	`139`	`{`
`142`		`- if (runInHost && toolchain?.IsInProcess != true && !PlatformsMatch(currentPlatform, benchmark.Job.Environment.Platform))`
	`140`	`+ if (Config.RunInHost && toolchain?.IsInProcess != true && !PlatformsMatch(currentPlatform, benchmark.Job.Environment.Platform))`
`143`	`141`	`{`
`144`	`142`	`yield return new ValidationError(true, "DisassemblyDiagnoser cannot run in host for a job that targets a different platform", benchmark);`
`145`	`143`	`}`
`@@ -216,7 +214,7 @@ private static long SumNativeCodeSize(DisassemblyResult disassembly)`
`216`	`214`	`string IInProcessDiagnoser.GetHandlerSourceCode(BenchmarkCase benchmarkCase, int index)`
`217`	`215`	`{`
`218`	`216`	`// Mono disassembler always runs another process.`
`219`		`- if (runInHost \|\| ShouldUseMonoDisassembler(benchmarkCase))`
	`217`	`+ if (Config.RunInHost \|\| ShouldUseMonoDisassembler(benchmarkCase))`
`220`	`218`	`{`
`221`	`219`	`return null;`
`222`	`220`	`}`
Original file line number	Diff line number	Diff line change
`@@ -90,17 +90,23 @@ private void ProcessDataBlocking()`
`90`	`90`	`{`
`91`	`91`	`Results.Add(line);`
`92`	`92`	`}`
	`93`	`+ // Keep in sync with WasmExecutor and InProcessHost.`
`93`	`94`	`else if (line.StartsWith(CompositeInProcessDiagnoser.HeaderKey))`
`94`	`95`	`{`
`95`		`- // Something like "// InProcessDiagnoserHandlerResults 0 1"`
	`96`	`+ // Something like "// InProcessDiagnoser 0 1"`
`96`	`97`	`string[] lineItems = line.Split(' ');`
`97`	`98`	`int diagnoserIndex = int.Parse(lineItems[2]);`
`98`	`99`	`int resultsLinesCount = int.Parse(lineItems[3]);`
`99`	`100`	`var resultsStringBuilder = new StringBuilder();`
`100`		`- for (int i = 0; i < resultsLinesCount; ++i)`
	`101`	`+ for (int i = 0; i < resultsLinesCount;)`
`101`	`102`	`{`
`102`	`103`	`// Strip the prepended "// InProcessDiagnoserResults ".`
`103`		`- resultsStringBuilder.AppendLine(reader.ReadLine().Substring(CompositeInProcessDiagnoser.ResultsKey.Length + 1));`
	`104`	`+ line = reader.ReadLine().Substring(CompositeInProcessDiagnoser.ResultsKey.Length + 1);`
	`105`	`+ resultsStringBuilder.Append(line);`
	`106`	`+ if (++i < resultsLinesCount)`
	`107`	`+ {`
	`108`	`+ resultsStringBuilder.AppendLine();`
	`109`	`+ }`
`104`	`110`	`}`
`105`	`111`	`compositeInProcessDiagnoser.DeserializeResults(diagnoserIndex, DiagnoserActionParameters.BenchmarkCase, resultsStringBuilder.ToString());`
`106`	`112`	`}`
Original file line number	Diff line number	Diff line change
`@@ -76,6 +76,8 @@ public ExecuteResult Execute(ExecuteParameters executeParameters)`
`76`	`76`	`$"Benchmark {executeParameters.BenchmarkCase.DisplayInfo} takes too long to run. " +`
`77`	`77`	`"Prefer to use out-of-process toolchains for long-running benchmarks.");`
`78`	`78`
	`79`	`+ host.HandleInProcessDiagnoserResults(executeParameters.BenchmarkCase, executeParameters.CompositeInProcessDiagnoser);`
	`80`	`+`
`79`	`81`	`return ExecuteResult.FromRunResults(host.RunResults, exitCode);`
`80`	`82`	`}`
`81`	`83`