static int InnerMergeMain(CommandLineOptions commandLineOptions)
{
if (commandLineOptions.InputFilesToMerge.Count == 0)
{
PrintUsage(commandLineOptions, "--input must be specified");
return(-8);
}
if (commandLineOptions.OutputFileName == null)
{
PrintUsage(commandLineOptions, "--output must be specified");
return(-8);
}
PEReader[] mibcReaders = new PEReader[commandLineOptions.InputFilesToMerge.Count];
for (int i = 0; i < mibcReaders.Length; i++)
{
PrintMessage($"Opening {commandLineOptions.InputFilesToMerge[i].FullName}");
mibcReaders[i] = MIbcProfileParser.OpenMibcAsPEReader(commandLineOptions.InputFilesToMerge[i].FullName);
}
HashSet <string> assemblyNamesInBubble = null;
if (commandLineOptions.IncludedAssemblies.Count > 0)
{
assemblyNamesInBubble = new HashSet <string>();
foreach (var asmName in commandLineOptions.IncludedAssemblies)
{
assemblyNamesInBubble.Add(asmName.Name);
}
}
try
{
var tsc = new TypeRefTypeSystem.TypeRefTypeSystemContext(mibcReaders);
bool partialNgen = false;
Dictionary <MethodDesc, MethodProfileData> mergedProfileData = new Dictionary <MethodDesc, MethodProfileData>();
for (int i = 0; i < mibcReaders.Length; i++)
{
var peReader = mibcReaders[i];
PrintDetailedMessage($"Merging {commandLineOptions.InputFilesToMerge[i].FullName}");
ProfileData.MergeProfileData(ref partialNgen, mergedProfileData, MIbcProfileParser.ParseMIbcFile(tsc, peReader, assemblyNamesInBubble, onlyDefinedInAssembly: null));
}
return(MibcEmitter.GenerateMibcFile(tsc, commandLineOptions.OutputFileName, mergedProfileData.Values, commandLineOptions.ValidateOutputFile, commandLineOptions.Uncompressed));
}
finally
{
foreach (var peReader in mibcReaders)
{
peReader.Dispose();
}
}
}
static int InnerProcessTraceFileMain(CommandLineOptions commandLineOptions)
{
if (commandLineOptions.TraceFile == null)
{
PrintUsage(commandLineOptions, "--trace must be specified");
return(-8);
}
if (commandLineOptions.OutputFileName == null)
{
PrintUsage(commandLineOptions, "--output must be specified");
return(-8);
}
if (commandLineOptions.OutputFileName != null)
{
if (!commandLineOptions.FileType.HasValue)
{
PrintUsage(commandLineOptions, $"--pgo-file-type must be specified");
return(-9);
}
if ((commandLineOptions.FileType.Value != PgoFileType.jittrace) && (commandLineOptions.FileType != PgoFileType.mibc))
{
PrintUsage(commandLineOptions, $"Invalid output pgo type {commandLineOptions.FileType} specified.");
return(-9);
}
if (commandLineOptions.FileType == PgoFileType.jittrace)
{
if (!commandLineOptions.OutputFileName.Name.EndsWith(".jittrace"))
{
PrintUsage(commandLineOptions, $"jittrace output file name must end with .jittrace");
return(-9);
}
}
if (commandLineOptions.FileType == PgoFileType.mibc)
{
if (!commandLineOptions.OutputFileName.Name.EndsWith(".mibc"))
{
PrintUsage(commandLineOptions, $"mibc output file name must end with .mibc");
return(-9);
}
}
}
string etlFileName = commandLineOptions.TraceFile.FullName;
foreach (string nettraceExtension in new string[] { ".netperf", ".netperf.zip", ".nettrace" })
{
if (commandLineOptions.TraceFile.FullName.EndsWith(nettraceExtension))
{
etlFileName = commandLineOptions.TraceFile.FullName.Substring(0, commandLineOptions.TraceFile.FullName.Length - nettraceExtension.Length) + ".etlx";
PrintMessage($"Creating ETLX file {etlFileName} from {commandLineOptions.TraceFile.FullName}");
TraceLog.CreateFromEventPipeDataFile(commandLineOptions.TraceFile.FullName, etlFileName);
}
}
string lttngExtension = ".trace.zip";
if (commandLineOptions.TraceFile.FullName.EndsWith(lttngExtension))
{
etlFileName = commandLineOptions.TraceFile.FullName.Substring(0, commandLineOptions.TraceFile.FullName.Length - lttngExtension.Length) + ".etlx";
PrintMessage($"Creating ETLX file {etlFileName} from {commandLineOptions.TraceFile.FullName}");
TraceLog.CreateFromLttngTextDataFile(commandLineOptions.TraceFile.FullName, etlFileName);
}
UnZipIfNecessary(ref etlFileName, commandLineOptions.BasicProgressMessages ? Console.Out : new StringWriter());
using (var traceLog = TraceLog.OpenOrConvert(etlFileName))
{
if ((!commandLineOptions.Pid.HasValue && commandLineOptions.ProcessName == null) && traceLog.Processes.Count != 1)
{
PrintError("Trace file contains multiple processes to distinguish between");
PrintOutput("Either a pid or process name from the following list must be specified");
foreach (TraceProcess proc in traceLog.Processes)
{
PrintOutput($"Procname = {proc.Name} Pid = {proc.ProcessID}");
}
return(1);
}
if (commandLineOptions.Pid.HasValue && (commandLineOptions.ProcessName != null))
{
PrintError("--pid and --process-name cannot be specified together");
return(-1);
}
// For a particular process
TraceProcess p;
if (commandLineOptions.Pid.HasValue)
{
p = traceLog.Processes.LastProcessWithID(commandLineOptions.Pid.Value);
}
else if (commandLineOptions.ProcessName != null)
{
List <TraceProcess> matchingProcesses = new List <TraceProcess>();
foreach (TraceProcess proc in traceLog.Processes)
{
if (String.Compare(proc.Name, commandLineOptions.ProcessName, StringComparison.OrdinalIgnoreCase) == 0)
{
matchingProcesses.Add(proc);
}
}
if (matchingProcesses.Count == 0)
{
PrintError("Unable to find matching process in trace");
return(-1);
}
if (matchingProcesses.Count > 1)
{
StringBuilder errorMessage = new StringBuilder();
errorMessage.AppendLine("Found multiple matching processes in trace");
foreach (TraceProcess proc in matchingProcesses)
{
errorMessage.AppendLine($"{proc.Name}\tpid={proc.ProcessID}\tCPUMSec={proc.CPUMSec}");
}
PrintError(errorMessage.ToString());
return(-2);
}
p = matchingProcesses[0];
}
else
{
p = traceLog.Processes.First();
}
if (!p.EventsInProcess.ByEventType <MethodDetailsTraceData>().Any())
{
PrintError($"No MethodDetails\nWas the trace collected with provider at least \"Microsoft-Windows-DotNETRuntime:0x4000080018:5\"?");
return(-3);
}
if (!p.EventsInProcess.ByEventType <GCBulkTypeTraceData>().Any())
{
PrintError($"No BulkType data\nWas the trace collected with provider at least \"Microsoft-Windows-DotNETRuntime:0x4000080018:5\"?");
return(-4);
}
if (!p.EventsInProcess.ByEventType <ModuleLoadUnloadTraceData>().Any())
{
PrintError($"No managed module load data\nWas the trace collected with provider at least \"Microsoft-Windows-DotNETRuntime:0x4000080018:5\"?");
return(-5);
}
if (!p.EventsInProcess.ByEventType <MethodJittingStartedTraceData>().Any())
{
PrintError($"No managed jit starting data\nWas the trace collected with provider at least \"Microsoft-Windows-DotNETRuntime:0x4000080018:5\"?");
return(-5);
}
PgoTraceProcess pgoProcess = new PgoTraceProcess(p);
int? clrInstanceId = commandLineOptions.ClrInstanceId;
if (!clrInstanceId.HasValue)
{
HashSet <int> clrInstanceIds = new HashSet <int>();
HashSet <int> examinedClrInstanceIds = new HashSet <int>();
foreach (var assemblyLoadTrace in p.EventsInProcess.ByEventType <AssemblyLoadUnloadTraceData>())
{
if (examinedClrInstanceIds.Add(assemblyLoadTrace.ClrInstanceID))
{
if (pgoProcess.ClrInstanceIsCoreCLRInstance(assemblyLoadTrace.ClrInstanceID))
{
clrInstanceIds.Add(assemblyLoadTrace.ClrInstanceID);
}
}
}
if (clrInstanceIds.Count != 1)
{
if (clrInstanceIds.Count == 0)
{
PrintError($"No managed CLR in target process, or per module information could not be loaded from the trace.");
}
else
{
// There are multiple clr processes... search for the one that implements
int[] clrInstanceIdsArray = clrInstanceIds.ToArray();
Array.Sort(clrInstanceIdsArray);
StringBuilder errorMessage = new StringBuilder();
errorMessage.AppendLine("Multiple CLR instances used in process. Choose one to examine with -clrInstanceID:<id> Valid ids:");
foreach (int instanceID in clrInstanceIds)
{
errorMessage.AppendLine(instanceID.ToString());
}
PrintError(errorMessage.ToString());
}
return(-10);
}
else
{
clrInstanceId = clrInstanceIds.First();
}
}
var tsc = new TraceTypeSystemContext(pgoProcess, clrInstanceId.Value, s_logger);
if (commandLineOptions.VerboseWarnings)
{
PrintWarning($"{traceLog.EventsLost} Lost events");
}
bool filePathError = false;
if (commandLineOptions.Reference != null)
{
foreach (FileInfo fileReference in commandLineOptions.Reference)
{
if (!File.Exists(fileReference.FullName))
{
PrintError($"Unable to find reference '{fileReference.FullName}'");
filePathError = true;
}
else
{
tsc.GetModuleFromPath(fileReference.FullName);
}
}
}
if (filePathError)
{
return(-6);
}
if (!tsc.Initialize())
{
return(-12);
}
TraceRuntimeDescToTypeSystemDesc idParser = new TraceRuntimeDescToTypeSystemDesc(p, tsc, clrInstanceId.Value);
SortedDictionary <int, ProcessedMethodData> methodsToAttemptToPrepare = new SortedDictionary <int, ProcessedMethodData>();
if (commandLineOptions.ProcessR2REvents)
{
foreach (var e in p.EventsInProcess.ByEventType <R2RGetEntryPointTraceData>())
{
int parenIndex = e.MethodSignature.IndexOf('(');
string retArg = e.MethodSignature.Substring(0, parenIndex);
string paramsArgs = e.MethodSignature.Substring(parenIndex);
string methodNameFromEventDirectly = retArg + e.MethodNamespace + "." + e.MethodName + paramsArgs;
if (e.ClrInstanceID != clrInstanceId.Value)
{
if (!commandLineOptions.Warnings)
{
continue;
}
PrintWarning($"Skipped R2REntryPoint {methodNameFromEventDirectly} due to ClrInstanceID of {e.ClrInstanceID}");
continue;
}
MethodDesc method = null;
string extraWarningText = null;
try
{
method = idParser.ResolveMethodID(e.MethodID, commandLineOptions.VerboseWarnings);
}
catch (Exception exception)
{
extraWarningText = exception.ToString();
}
if (method == null)
{
if ((e.MethodNamespace == "dynamicClass") || !commandLineOptions.Warnings)
{
continue;
}
PrintWarning($"Unable to parse {methodNameFromEventDirectly} when looking up R2R methods");
if (extraWarningText != null)
{
PrintWarning(extraWarningText);
}
continue;
}
if ((e.TimeStampRelativeMSec >= commandLineOptions.ExcludeEventsBefore) && (e.TimeStampRelativeMSec <= commandLineOptions.ExcludeEventsAfter))
{
methodsToAttemptToPrepare.Add((int)e.EventIndex, new ProcessedMethodData(e.TimeStampRelativeMSec, method, "R2RLoad"));
}
}
}
// Find all the jitStart events.
if (commandLineOptions.ProcessJitEvents)
{
foreach (var e in p.EventsInProcess.ByEventType <MethodJittingStartedTraceData>())
{
int parenIndex = e.MethodSignature.IndexOf('(');
string retArg = e.MethodSignature.Substring(0, parenIndex);
string paramsArgs = e.MethodSignature.Substring(parenIndex);
string methodNameFromEventDirectly = retArg + e.MethodNamespace + "." + e.MethodName + paramsArgs;
if (e.ClrInstanceID != clrInstanceId.Value)
{
if (!commandLineOptions.Warnings)
{
continue;
}
PrintWarning($"Skipped {methodNameFromEventDirectly} due to ClrInstanceID of {e.ClrInstanceID}");
continue;
}
MethodDesc method = null;
string extraWarningText = null;
try
{
method = idParser.ResolveMethodID(e.MethodID, commandLineOptions.VerboseWarnings);
}
catch (Exception exception)
{
extraWarningText = exception.ToString();
}
if (method == null)
{
if ((e.MethodNamespace == "dynamicClass") || !commandLineOptions.Warnings)
{
continue;
}
PrintWarning($"Unable to parse {methodNameFromEventDirectly}");
if (extraWarningText != null)
{
PrintWarning(extraWarningText);
}
continue;
}
if ((e.TimeStampRelativeMSec >= commandLineOptions.ExcludeEventsBefore) && (e.TimeStampRelativeMSec <= commandLineOptions.ExcludeEventsAfter))
{
methodsToAttemptToPrepare.Add((int)e.EventIndex, new ProcessedMethodData(e.TimeStampRelativeMSec, method, "JitStart"));
}
}
}
Dictionary <MethodDesc, Dictionary <MethodDesc, int> > callGraph = null;
Dictionary <MethodDesc, int> exclusiveSamples = null;
if (commandLineOptions.GenerateCallGraph)
{
HashSet <MethodDesc> methodsListedToPrepare = new HashSet <MethodDesc>();
foreach (var entry in methodsToAttemptToPrepare)
{
methodsListedToPrepare.Add(entry.Value.Method);
}
callGraph = new Dictionary <MethodDesc, Dictionary <MethodDesc, int> >();
exclusiveSamples = new Dictionary <MethodDesc, int>();
// Capture the addresses of jitted code
List <ValueTuple <InstructionPointerRange, MethodDesc> > codeLocations = new List <(InstructionPointerRange, MethodDesc)>();
foreach (var e in p.EventsInProcess.ByEventType <MethodLoadUnloadTraceData>())
{
if (e.ClrInstanceID != clrInstanceId.Value)
{
continue;
}
MethodDesc method = null;
try
{
method = idParser.ResolveMethodID(e.MethodID, commandLineOptions.VerboseWarnings);
}
catch (Exception)
{
}
if (method != null)
{
codeLocations.Add((new InstructionPointerRange(e.MethodStartAddress, e.MethodSize), method));
}
}
foreach (var e in p.EventsInProcess.ByEventType <MethodLoadUnloadVerboseTraceData>())
{
if (e.ClrInstanceID != clrInstanceId.Value)
{
continue;
}
MethodDesc method = null;
try
{
method = idParser.ResolveMethodID(e.MethodID, commandLineOptions.VerboseWarnings);
}
catch (Exception)
{
}
if (method != null)
{
codeLocations.Add((new InstructionPointerRange(e.MethodStartAddress, e.MethodSize), method));
}
}
var sigProvider = new R2RSignatureTypeProvider(tsc);
foreach (var module in p.LoadedModules)
{
if (module.FilePath == "")
{
continue;
}
if (!File.Exists(module.FilePath))
{
continue;
}
try
{
byte[] image = File.ReadAllBytes(module.FilePath);
using (FileStream fstream = new FileStream(module.FilePath, FileMode.Open, FileAccess.Read, FileShare.Read))
{
var r2rCheckPEReader = new System.Reflection.PortableExecutable.PEReader(fstream, System.Reflection.PortableExecutable.PEStreamOptions.LeaveOpen);
if (!ILCompiler.Reflection.ReadyToRun.ReadyToRunReader.IsReadyToRunImage(r2rCheckPEReader))
{
continue;
}
}
var reader = new ILCompiler.Reflection.ReadyToRun.ReadyToRunReader(tsc, module.FilePath);
foreach (var methodEntry in reader.GetCustomMethodToRuntimeFunctionMapping <TypeDesc, MethodDesc, R2RSigProviderContext>(sigProvider))
{
foreach (var runtimeFunction in methodEntry.Value.RuntimeFunctions)
{
codeLocations.Add((new InstructionPointerRange(module.ImageBase + (ulong)runtimeFunction.StartAddress, runtimeFunction.Size), methodEntry.Key));
}
}
}
catch { }
}
InstructionPointerRange[] instructionPointerRanges = new InstructionPointerRange[codeLocations.Count];
MethodDesc[] methods = new MethodDesc[codeLocations.Count];
for (int i = 0; i < codeLocations.Count; i++)
{
instructionPointerRanges[i] = codeLocations[i].Item1;
methods[i] = codeLocations[i].Item2;
}
Array.Sort(instructionPointerRanges, methods);
foreach (var e in p.EventsInProcess.ByEventType <SampledProfileTraceData>())
{
var callstack = e.CallStack();
if (callstack == null)
{
continue;
}
ulong address1 = callstack.CodeAddress.Address;
MethodDesc topOfStackMethod = LookupMethodByAddress(address1);
MethodDesc nextMethod = null;
if (callstack.Caller != null)
{
ulong address2 = callstack.Caller.CodeAddress.Address;
nextMethod = LookupMethodByAddress(address2);
}
if (topOfStackMethod != null)
{
if (!methodsListedToPrepare.Contains(topOfStackMethod))
{
methodsListedToPrepare.Add(topOfStackMethod);
methodsToAttemptToPrepare.Add((int)e.EventIndex, new ProcessedMethodData(e.TimeStampRelativeMSec, topOfStackMethod, "SampleMethod"));
}
if (exclusiveSamples.TryGetValue(topOfStackMethod, out int count))
{
exclusiveSamples[topOfStackMethod] = count + 1;
}
else
{
exclusiveSamples[topOfStackMethod] = 1;
}
}
if (topOfStackMethod != null && nextMethod != null)
{
if (!methodsListedToPrepare.Contains(nextMethod))
{
methodsListedToPrepare.Add(nextMethod);
methodsToAttemptToPrepare.Add((int)e.EventIndex, new ProcessedMethodData(e.TimeStampRelativeMSec, nextMethod, "SampleMethodCaller"));
}
if (!callGraph.TryGetValue(nextMethod, out var innerDictionary))
{
innerDictionary = new Dictionary <MethodDesc, int>();
callGraph[nextMethod] = innerDictionary;
}
if (innerDictionary.TryGetValue(topOfStackMethod, out int count))
{
innerDictionary[topOfStackMethod] = count + 1;
}
else
{
innerDictionary[topOfStackMethod] = 1;
}
}
}
MethodDesc LookupMethodByAddress(ulong address)
{
int index = Array.BinarySearch(instructionPointerRanges, new InstructionPointerRange(address, 1));
if (index >= 0)
{
return(methods[index]);
}
else
{
index = ~index;
if (index >= instructionPointerRanges.Length)
{
return(null);
}
if (instructionPointerRanges[index].StartAddress < address)
{
if (instructionPointerRanges[index].EndAddress > address)
{
return(methods[index]);
}
}
if (index == 0)
{
return(null);
}
index--;
if (instructionPointerRanges[index].StartAddress < address)
{
if (instructionPointerRanges[index].EndAddress > address)
{
return(methods[index]);
}
}
return(null);
}
}
}
Dictionary <MethodDesc, MethodChunks> instrumentationDataByMethod = new Dictionary <MethodDesc, MethodChunks>();
foreach (var e in p.EventsInProcess.ByEventType <JitInstrumentationDataVerboseTraceData>())
{
AddToInstrumentationData(e.ClrInstanceID, e.MethodID, e.MethodFlags, e.Data);
}
foreach (var e in p.EventsInProcess.ByEventType <JitInstrumentationDataTraceData>())
{
AddToInstrumentationData(e.ClrInstanceID, e.MethodID, e.MethodFlags, e.Data);
}
// Local function used with the above two loops as the behavior is supposed to be identical
void AddToInstrumentationData(int eventClrInstanceId, long methodID, int methodFlags, byte[] data)
{
if (eventClrInstanceId != clrInstanceId.Value)
{
return;
}
MethodDesc method = null;
try
{
method = idParser.ResolveMethodID(methodID, commandLineOptions.VerboseWarnings);
}
catch (Exception)
{
}
if (method != null)
{
if (!instrumentationDataByMethod.TryGetValue(method, out MethodChunks perMethodChunks))
{
perMethodChunks = new MethodChunks();
instrumentationDataByMethod.Add(method, perMethodChunks);
}
const int FinalChunkFlag = unchecked ((int)0x80000000);
int chunkIndex = methodFlags & ~FinalChunkFlag;
if ((chunkIndex != (perMethodChunks.LastChunk + 1)) || perMethodChunks.Done)
{
instrumentationDataByMethod.Remove(method);
return;
}
perMethodChunks.LastChunk = perMethodChunks.InstrumentationData.Count;
perMethodChunks.InstrumentationData.Add(data);
if ((methodFlags & FinalChunkFlag) == FinalChunkFlag)
{
perMethodChunks.Done = true;
}
}
}
if (commandLineOptions.DisplayProcessedEvents)
{
foreach (var entry in methodsToAttemptToPrepare)
{
MethodDesc method = entry.Value.Method;
string reason = entry.Value.Reason;
PrintOutput($"{entry.Value.Millisecond.ToString("F4")} {reason} {method}");
}
}
PrintMessage($"Done processing input file");
if (commandLineOptions.OutputFileName == null)
{
return(0);
}
// Deduplicate entries
HashSet <MethodDesc> methodsInListAlready = new HashSet <MethodDesc>();
List <ProcessedMethodData> methodsUsedInProcess = new List <ProcessedMethodData>();
PgoDataLoader pgoDataLoader = new PgoDataLoader(idParser);
foreach (var entry in methodsToAttemptToPrepare)
{
if (methodsInListAlready.Add(entry.Value.Method))
{
var methodData = entry.Value;
if (commandLineOptions.GenerateCallGraph)
{
exclusiveSamples.TryGetValue(methodData.Method, out methodData.ExclusiveWeight);
callGraph.TryGetValue(methodData.Method, out methodData.WeightedCallData);
}
if (instrumentationDataByMethod.TryGetValue(methodData.Method, out MethodChunks chunks))
{
int size = 0;
foreach (byte[] arr in chunks.InstrumentationData)
{
size += arr.Length;
}
byte[] instrumentationData = new byte[size];
int offset = 0;
foreach (byte[] arr in chunks.InstrumentationData)
{
arr.CopyTo(instrumentationData, offset);
offset += arr.Length;
}
var intDecompressor = new PgoProcessor.PgoEncodedCompressedIntParser(instrumentationData, 0);
methodData.InstrumentationData = PgoProcessor.ParsePgoData <TypeSystemEntityOrUnknown>(pgoDataLoader, intDecompressor, true).ToArray();
}
methodsUsedInProcess.Add(methodData);
}
}
if (commandLineOptions.FileType.Value == PgoFileType.jittrace)
{
GenerateJittraceFile(commandLineOptions.OutputFileName, methodsUsedInProcess, commandLineOptions.JitTraceOptions);
}
else if (commandLineOptions.FileType.Value == PgoFileType.mibc)
{
ILCompiler.MethodProfileData[] methodProfileData = new ILCompiler.MethodProfileData[methodsUsedInProcess.Count];
for (int i = 0; i < methodProfileData.Length; i++)
{
ProcessedMethodData processedData = methodsUsedInProcess[i];
methodProfileData[i] = new ILCompiler.MethodProfileData(processedData.Method, ILCompiler.MethodProfilingDataFlags.ReadMethodCode, processedData.ExclusiveWeight, processedData.WeightedCallData, 0xFFFFFFFF, processedData.InstrumentationData);
}
return(MibcEmitter.GenerateMibcFile(tsc, commandLineOptions.OutputFileName, methodProfileData, commandLineOptions.ValidateOutputFile, commandLineOptions.Uncompressed));
}
}
return(0);
}