/// <summary>Sends notification signal to the host.</summary>
/// <param name="hostSignal">The signal to send.</param>
public void SendSignal(HostSignal hostSignal)
{
switch (hostSignal)
{
case HostSignal.BeforeAnythingElse:
diagnoser?.BeforeAnythingElse(currentProcess, benchmark);
WriteLine(Engine.Signals.BeforeAnythingElse);
break;
case HostSignal.AfterSetup:
diagnoser?.AfterSetup(currentProcess, benchmark);
WriteLine(Engine.Signals.AfterSetup);
break;
case HostSignal.BeforeMainRun:
diagnoser?.BeforeMainRun(currentProcess, benchmark);
WriteLine(Engine.Signals.BeforeMainRun);
break;
case HostSignal.BeforeCleanup:
diagnoser?.BeforeCleanup();
WriteLine(Engine.Signals.BeforeCleanup);
break;
case HostSignal.AfterAnythingElse:
WriteLine(Engine.Signals.AfterAnythingElse);
break;
default:
throw new ArgumentOutOfRangeException(nameof(hostSignal), hostSignal, null);
}
}
/// <summary>Sends notification signal to the host.</summary>
/// <param name="hostSignal">The signal to send.</param>
public void SendSignal(HostSignal hostSignal)
{
switch (hostSignal)
{
case HostSignal.BeforeAnythingElse:
diagnoser?.BeforeAnythingElse(diagnoserActionParameters);
WriteLine(Engine.Signals.BeforeAnythingElse);
break;
case HostSignal.AfterGlobalSetup:
diagnoser?.AfterGlobalSetup(diagnoserActionParameters);
WriteLine(Engine.Signals.AfterGlobalSetup);
break;
case HostSignal.BeforeMainRun:
diagnoser?.BeforeMainRun(diagnoserActionParameters);
WriteLine(Engine.Signals.BeforeMainRun);
break;
case HostSignal.BeforeGlobalCleanup:
diagnoser?.BeforeGlobalCleanup(diagnoserActionParameters);
WriteLine(Engine.Signals.BeforeGlobalCleanup);
break;
case HostSignal.AfterAnythingElse:
WriteLine(Engine.Signals.AfterAnythingElse);
break;
default:
throw new ArgumentOutOfRangeException(nameof(hostSignal), hostSignal, null);
}
}
public void SendSignal(HostSignal hostSignal)
{
switch (hostSignal)
{
case HostSignal.BeforeAnythingElse:
WriteLine(Engine.Signals.BeforeAnythingElse);
break;
case HostSignal.AfterSetup:
WriteLine(Engine.Signals.AfterSetup);
break;
case HostSignal.BeforeMainRun:
WriteLine(Engine.Signals.BeforeMainRun);
break;;
case HostSignal.BeforeCleanup:
WriteLine(Engine.Signals.BeforeCleanup);
break;
case HostSignal.AfterAnythingElse:
WriteLine(Engine.Signals.AfterAnythingElse);
break;
default:
throw new ArgumentOutOfRangeException(nameof(hostSignal), hostSignal, null);
}
}
/// <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;
}
diagnoser.Handle(hostSignal, diagnoserActionParameters);
}
/// <inheritdoc />
public void Handle(HostSignal signal, DiagnoserActionParameters parameters)
{
switch (signal)
{
case HostSignal.BeforeMainRun:
try
{
var startInfo = new ProcessStartInfo(
@"C:\Users\chris\AppData\Local\JetBrains\Installations\dotTrace11\ConsoleProfiler.exe",
$"attach {parameters.Process.Id} --save-to={_saveLocation} --profiling-type=Sampling")
{
RedirectStandardError = true,
RedirectStandardOutput = true,
WindowStyle = ProcessWindowStyle.Normal,
UseShellExecute = false,
};
Console.WriteLine(startInfo.FileName);
Console.WriteLine(startInfo.Arguments);
_process = new Process
{
StartInfo = startInfo
};
_process.ErrorDataReceived += (sender, eventArgs) => Console.Error.WriteLine(eventArgs.Data);
_process.OutputDataReceived += (sender, eventArgs) => Console.WriteLine(eventArgs.Data);
_process.Start();
_process.BeginErrorReadLine();
_process.BeginOutputReadLine();
_process.Exited += (sender, args) =>
{
_process.Dispose();
};
}
catch (Exception e)
{
Console.Error.WriteLine(e.StackTrace);
throw;
}
break;
case HostSignal.AfterMainRun:
break;
case HostSignal.BeforeAnythingElse:
break;
case HostSignal.AfterAll:
break;
case HostSignal.SeparateLogic:
break;
default:
throw new ArgumentOutOfRangeException(nameof(signal), signal, null);
}
}
public void Handle(HostSignal signal, DiagnoserActionParameters parameters)
{
if (signal == HostSignal.BeforeAnythingElse)
{
Start(parameters);
}
else if (signal == HostSignal.AfterAll)
{
Stop();
}
}
public void Handle(HostSignal signal, DiagnoserActionParameters parameters)
{
if (signal == HostSignal.BeforeGeneralRun)
{
Start(parameters);
}
else if (signal == HostSignal.AfterGeneralRun)
{
Stop();
}
}
public void Handle(HostSignal signal, DiagnoserActionParameters parameters)
{
if (signal == HostSignal.AfterProcessExit)
{
System.IO.File.Delete(MarkerFileName);
}
else if (signal == HostSignal.BeforeProcessStart)
{
System.IO.File.CreateText(MarkerFileName).Dispose();
}
}
public void Handle(HostSignal signal, DiagnoserActionParameters parameters)
{
// it's crucial to start the trace before the process starts and stop it after the benchmarked process stops to have all of the necessary events in the trace file!
if (signal == HostSignal.BeforeProcessStart)
{
Start(parameters);
}
else if (signal == HostSignal.AfterProcessExit)
{
Stop(parameters);
}
}
public void Handle(HostSignal signal, DiagnoserActionParameters parameters)
{
switch (signal)
{
case HostSignal.AfterActualRun:
this.TotalMemory = GC.GetTotalMemory(true);
break;
default:
break;
}
}
public void Handle(HostSignal signal, DiagnoserActionParameters parameters)
{
if (signal == HostSignal.BeforeActualRun)
{
userStart = proc.UserProcessorTime.Ticks;
privStart = proc.PrivilegedProcessorTime.Ticks;
}
if (signal == HostSignal.AfterActualRun)
{
userEnd = proc.UserProcessorTime.Ticks;
privEnd = proc.PrivilegedProcessorTime.Ticks;
}
}
public void Handle(HostSignal signal, DiagnoserActionParameters parameters)
{
var benchmark = parameters.Benchmark;
if (signal == HostSignal.AfterAll && ShouldUseWindowsDissasembler(benchmark))
{
results.Add(benchmark, windowsDisassembler.Dissasemble(parameters));
}
else if (signal == HostSignal.SeparateLogic && ShouldUseMonoDisassembler(benchmark))
{
results.Add(benchmark, monoDisassembler.Disassemble(benchmark, benchmark.Job.Env.Runtime as MonoRuntime));
}
}
public void SendSignal(HostSignal hostSignal)
{
WriteLine(Engine.Signals.ToMessage(hostSignal));
// read the response from Parent process, make the communication blocking
// I did not use Mutexes because they are not supported for Linux/MacOs for .NET Core
// this solution is stupid simple and it works
var acknowledgment = inReader.ReadLine();
if (acknowledgment != Engine.Signals.Acknowledgment)
{
throw new NotSupportedException($"Unknown Acknowledgment: {acknowledgment}");
}
}
/// <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 Handle(HostSignal signal, DiagnoserActionParameters parameters)
{
if (signal == HostSignal.BeforeActualRun)
{
// reset counters
_data = new EventData();
EnableEvents(_quicEventSource, EventLevel.Verbose);
}
if (signal == HostSignal.AfterActualRun)
{
DisableEvents(_quicEventSource);
}
}
public void Handle(HostSignal signal, DiagnoserActionParameters parameters)
{
if (signal != HostSignal.BeforeAnythingElse)
{
return;
}
var diagnosticsClient = new DiagnosticsClient(parameters.Process.Id);
EventPipeSession session = diagnosticsClient.StartEventPipeSession(eventPipeProviders, true);
var fileName = ArtifactFileNameHelper.GetTraceFilePath(parameters, DateTime.Now, "nettrace").EnsureFolderExists();
benchmarkToTraceFile[parameters.BenchmarkCase] = fileName;
collectingTask = Task.Run(() => CopyEventStreamToFile(session, fileName, parameters.Config.GetCompositeLogger()));
}
public void Handle(HostSignal signal, DiagnoserActionParameters parameters)
{
var benchmark = parameters.BenchmarkCase;
switch (signal)
{
case HostSignal.AfterAll when ShouldUseWindowsDisassembler(benchmark):
results.Add(benchmark, windowsDisassembler.Disassemble(parameters));
break;
case HostSignal.SeparateLogic when ShouldUseMonoDisassembler(benchmark):
results.Add(benchmark, monoDisassembler.Disassemble(benchmark, benchmark.Job.Environment.Runtime as MonoRuntime));
break;
}
}
public void Handle(HostSignal signal, DiagnoserActionParameters parameters)
{
//Only turn on the recording of information at certain points.
//For example, ignore the warm up, etc.
switch (signal)
{
case HostSignal.BeforeActualRun:
_uowLogInterceptor.StartReading();
break;
case HostSignal.AfterActualRun:
_uowLogInterceptor.StopReading();
break;
default:
break;
}
}
public void Handle(HostSignal signal, DiagnoserActionParameters parameters)
{
switch (signal)
{
case HostSignal.BeforeActualRun:
this.StartTime = DateTime.Now;
this.StartProcessorTime = parameters.Process.TotalProcessorTime;
break;
case HostSignal.AfterActualRun:
this.EndTime = DateTime.Now;
this.EndProcessorTime = parameters.Process.TotalProcessorTime;
break;
default:
break;
}
}
public static bool TryGetSignal(string message, out HostSignal signal) => MessagesToSignals.TryGetValue(message, out signal);
public static string ToMessage(HostSignal signal) => SignalsToMessages[signal];
public void Handle(HostSignal signal, DiagnoserActionParameters parameters) => diagnosers.ForEach(diagnoser => diagnoser.Handle(signal, parameters));
public void SendSignal(HostSignal hostSignal) => WriteLine(Engine.Signals.ToMessage(hostSignal));
// the following methods are left empty on purpose
// the action takes places in other process, and the values are gathered by Engine
public void Handle(HostSignal signal, DiagnoserActionParameters parameters)
{
}
