public DumpPipXldbAnalyzer(AnalysisInput input, string outputFilePath, string inputDirPath, long semiStableHash)
: base(input)
{
m_outputFilePath = outputFilePath;
m_inputDirPath = inputDirPath;
m_semiStableHash = semiStableHash;
}
public Analyzer InitializeBuildSimulatorAnalyzer(AnalysisInput analysisInput)
{
string outputDirectory = null;
var simulator = new BuildSimulatorAnalyzer(analysisInput);
foreach (var opt in AnalyzerOptions)
{
if (opt.Name.Equals("outputDirectory", StringComparison.OrdinalIgnoreCase) ||
opt.Name.Equals("o", StringComparison.OrdinalIgnoreCase))
{
simulator.OutputDirectory = ParseSingletonPathOption(opt, outputDirectory);
}
else if (opt.Name.Equals("step", StringComparison.OrdinalIgnoreCase) ||
opt.Name.Equals("s", StringComparison.OrdinalIgnoreCase))
{
simulator.IncludedExecutionSteps[(int)ParseEnumOption <PipExecutionStep>(opt)] = true;
}
else
{
throw Error("Unknown option for build simulation analysis: {0}", opt.Name);
}
}
return(simulator);
}
/// <nodoc />
internal DebugLogsAnalyzer(AnalysisInput input, int port, bool enableCaching, bool ensureOrdering)
: base(input)
{
m_port = port;
EnableEvalCaching = enableCaching;
EnsureOrdering = ensureOrdering;
XlgState = new XlgDebuggerState(this);
m_dirData = new MultiValueDictionary <AbsolutePath, DirectoryMembershipHashedEventData>();
m_criticalPathAnalyzer = new CriticalPathAnalyzer(input, outputFilePath: null);
m_lazyCriticalPath = Lazy.Create(() =>
{
m_criticalPathAnalyzer.Analyze();
return(m_criticalPathAnalyzer.criticalPathData);
});
m_state = new DebuggerState(PathTable, LoggingContext, XlgState.Render, XlgState);
m_lazyPipPerfDict = new Lazy <Dictionary <PipId, PipExecutionPerformance> >(() =>
{
return(m_writeExecutionEntries.ToDictionary(e => e.PipId, e => e.ExecutionPerformance));
});
m_lazyPipsBySemiStableHash = new Lazy <Dictionary <long, PipId> >(() =>
{
var result = new Dictionary <long, PipId>();
foreach (var pipId in PipTable.Keys)
{
result[PipTable.GetPipSemiStableHash(pipId)] = pipId;
}
return(result);
});
}
public CacheDumpAnalyzer(AnalysisInput input, string outputDir, HashSet <long> targetSemistableHashSet)
: base(input)
{
m_model = new AnalysisModel(CachedGraph);
m_outputDir = outputDir;
m_targetSemistableHashSet = targetSemistableHashSet;
}
internal PipGraphExporter(AnalysisInput input, string jsonFilePath)
: base(input)
{
Contract.Requires(!string.IsNullOrWhiteSpace(jsonFilePath), "Output path parameter is missing");
m_writer = new PipGraphJsonWriter(jsonFilePath);
}
public FingerprintTextAnalyzer(AnalysisInput input)
: base(input)
{
m_completedPips = new HashSet <PipId>();
m_contentFingerprinter = null;
m_pathExpander = input.CachedGraph.MountPathExpander;
}
/// <summary>
/// Constructor.
/// </summary>
public FingerprintStoreAnalyzer(AnalysisInput analysisInputOld, AnalysisInput analysisInputNew)
: base(analysisInputNew)
{
if (analysisInputOld.ExecutionLogPath.Equals(analysisInputNew.ExecutionLogPath, StringComparison.OrdinalIgnoreCase))
{
var fingerprintStoreDirectories = Directory.GetDirectories(Path.GetDirectoryName(analysisInputNew.ExecutionLogPath), Scheduler.Scheduler.FingerprintStoreDirectory + "*", SearchOption.AllDirectories);
if (fingerprintStoreDirectories.Length != 2)
{
throw new BuildXLException($"Expecting two '{Scheduler.Scheduler.FingerprintStoreDirectory}' directories under log path '{Path.GetDirectoryName(analysisInputNew.ExecutionLogPath)}'");
}
else
{
m_oldStoreLocation = fingerprintStoreDirectories.First(x => !x.EndsWith(Scheduler.Scheduler.FingerprintStoreDirectory));
m_newStoreLocation = fingerprintStoreDirectories.First(x => x.EndsWith(Scheduler.Scheduler.FingerprintStoreDirectory));
Console.WriteLine($"Comparing old fingerprint store {m_oldStoreLocation} with new one {m_newStoreLocation}");
m_model = new AnalysisModel(CachedGraph);
}
}
else
{
m_oldStoreLocation = GetStoreLocation(analysisInputOld);
m_newStoreLocation = GetStoreLocation(analysisInputNew);
m_model = new AnalysisModel(CachedGraph);
}
}
public DumpPipLiteAnalyzer(AnalysisInput input, string outputDirectory, long semiStableHash, bool dumpObservedFileAccesses)
: base(input)
{
if (string.IsNullOrEmpty(outputDirectory))
{
// Use the execution log path
m_logPath = Path.Combine(Path.GetDirectoryName(input.ExecutionLogPath), "FailedPips");
}
else
{
m_logPath = Path.Combine(outputDirectory, "FailedPips");
}
m_pipTable = input.CachedGraph.PipTable;
m_pipGraph = input.CachedGraph.PipGraph;
m_dumpObservedFileAccesses = dumpObservedFileAccesses;
m_dynamicData = null;
foreach (var pipId in m_pipTable.StableKeys)
{
var possibleMatch = m_pipTable.GetPipSemiStableHash(pipId);
if (possibleMatch == semiStableHash)
{
m_pip = m_pipTable.HydratePip(pipId, PipQueryContext.DumpPipLiteAnalyzer);
break;
}
}
if (m_pip == null)
{
// If no matches were found, then we likely got some bad input from the user.
throw new InvalidArgumentException($"Specified Pip 'Pip{semiStableHash:X}' does not exist.");
}
}
internal IdeGenerator(AnalysisInput input)
: base(input)
{
AbsolutePath enlistmentRoot;
if (!CachedGraph.MountPathExpander.TryGetRootByMountName("SourceRoot", out enlistmentRoot))
{
throw new BuildXLException("Source root is not available");
}
var config = new CommandLineConfiguration
{
Startup = new StartupConfiguration
{
ConfigFile = enlistmentRoot.Combine(PathTable, PathAtom.Create(StringTable, Names.ConfigDsc)),
},
Ide = new IdeConfiguration {
IsEnabled = true
},
Layout =
{
OutputDirectory = enlistmentRoot.Combine(PathTable, PathAtom.Create(StringTable, "Out")),
},
Engine =
{
TrackBuildsInUserFolder = false,
}
};
Ide.Generator.IdeGenerator.Configure(config, config.Startup, PathTable);
m_ideGenerator = new Ide.Generator.IdeGenerator(PipGraph.Context, PipGraph, PipGraph.DataflowGraph, config.Startup.ConfigFile, config.Ide);
m_solutionFile = Ide.Generator.IdeGenerator.GetSolutionPath(config.Ide, PathTable);
}
public PipExecutionPerformanceAnalyzer(AnalysisInput input, string outputFilePath)
: base(input)
{
Contract.Requires(!string.IsNullOrWhiteSpace(outputFilePath));
m_writer = new StreamWriter(outputFilePath);
}
internal CosineJsonExport(AnalysisInput input, string jsonFilePath)
: base(input)
{
Contract.Requires(!string.IsNullOrWhiteSpace(jsonFilePath));
m_writer = new CosineJsonWriter(jsonFilePath);
}
public FileChangeTrackerAnalyzer(AnalysisInput input, string inputFile, string outputFile)
: base(input)
{
m_cachedGraphDirectory = input.CachedGraphDirectory;
m_inputFile = inputFile;
m_outputFile = outputFile;
}
public Analyzer InitializeCacheDumpAnalyzer(AnalysisInput analysisInput)
{
string outputDir = null;
HashSet <long> semistableHashSet = new HashSet <long>();
foreach (var opt in AnalyzerOptions)
{
if (opt.Name.Equals("outputDir", StringComparison.OrdinalIgnoreCase) ||
opt.Name.Equals("o", StringComparison.OrdinalIgnoreCase))
{
outputDir = ParseSingletonPathOption(opt, outputDir);
if (!FileUtilities.DirectoryExistsNoFollow(outputDir))
{
FileUtilities.CreateDirectory(outputDir);
}
}
else if (opt.Name.StartsWith("pip", StringComparison.OrdinalIgnoreCase) ||
opt.Name.StartsWith("p", StringComparison.OrdinalIgnoreCase))
{
semistableHashSet.Add(ParseSemistableHash(opt));
}
else
{
throw Error("Unknown option for fingerprint text analysis: {0}", opt.Name);
}
}
if (semistableHashSet.Count == 0)
{
throw Error("pip parameter is required");
}
return(new CacheDumpAnalyzer(analysisInput, outputDir, semistableHashSet));
}
public Analyzer InitializeCacheDumpAnalyzer(AnalysisInput analysisInput)
{
string outputFile = null;
long? semistableHash = null;
foreach (var opt in AnalyzerOptions)
{
if (opt.Name.Equals("outputFile", StringComparison.OrdinalIgnoreCase) ||
opt.Name.Equals("o", StringComparison.OrdinalIgnoreCase))
{
outputFile = ParseSingletonPathOption(opt, outputFile);
}
else if (opt.Name.StartsWith("pip", StringComparison.OrdinalIgnoreCase) ||
opt.Name.StartsWith("p", StringComparison.OrdinalIgnoreCase))
{
semistableHash = ParseSemistableHash(opt);
}
else
{
throw Error("Unknown option for fingerprint text analysis: {0}", opt.Name);
}
}
if (semistableHash == null)
{
throw Error("pip parameter is required");
}
return(new CacheDumpAnalyzer(analysisInput)
{
OutputFile = outputFile,
TargetSemistableHash = semistableHash.Value,
});
}
public FailedPipInputAnalyzer(AnalysisInput input)
: base(input)
{
nodeVisitor = new NodeVisitor(DirectedGraph);
m_failedPipsClosure = new VisitationTracker(DirectedGraph);
m_cachedPips = new VisitationTracker(DirectedGraph);
}
internal Analyzer GetDiffAnalyzer(AnalysisInput input)
{
Console.WriteLine("Loaded new graph from compared to log");
// Set analyzer to perform Compare and ignore single log analisys
m_performSingleLogAnalysis = false;
return(new DiffAnalyzer(input, this));
}
/// <nodoc />
internal DebugLogsAnalyzer(AnalysisInput input, int port)
: base(input)
{
XlgState = new XlgDebuggerState(this);
m_criticalPathAnalyzer = new CriticalPathAnalyzer(input, outputFilePath: null);
m_lazyCriticalPath = Lazy.Create(() =>
{
m_criticalPathAnalyzer.Analyze();
return(m_criticalPathAnalyzer.criticalPathData);
});
m_port = port;
m_state = new DebuggerState(PathTable, LoggingContext, XlgState.Render, XlgState);
m_lazyPipPerfDict = new Lazy <Dictionary <PipId, PipExecutionPerformance> >(() =>
{
return(m_writeExecutionEntries.ToDictionary(e => e.PipId, e => e.ExecutionPerformance));
});
m_lazyPipsBySemiStableHash = new Lazy <Dictionary <long, PipId> >(() =>
{
var result = new Dictionary <long, PipId>();
foreach (var pipId in PipTable.Keys)
{
result[PipTable.GetPipSemiStableHash(pipId)] = pipId;
}
return(result);
});
}
public DumpPipAnalyzer(AnalysisInput input, string outputFilePath, long semiStableHash, bool useOriginalPaths, bool logProgress = false)
: base(input)
{
m_outputFilePath = outputFilePath;
m_useOriginalPaths = useOriginalPaths;
if (logProgress)
{
Console.WriteLine("Finding matching pip");
}
var pipTable = input.CachedGraph.PipTable;
foreach (var pipId in pipTable.StableKeys)
{
if (pipTable.GetPipType(pipId) == PipType.Module)
{
var modulePip = (ModulePip)pipTable.HydratePip(pipId, PipQueryContext.ViewerAnalyzer);
m_moduleIdToFriendlyName.Add(modulePip.Module, modulePip.Identity.ToString(StringTable));
}
var possibleMatch = pipTable.GetPipSemiStableHash(pipId);
if (possibleMatch == semiStableHash)
{
m_pip = pipTable.HydratePip(pipId, PipQueryContext.ViewerAnalyzer);
}
}
m_html = new HtmlHelper(PathTable, StringTable, SymbolTable, CachedGraph.PipTable);
}
public Analyzer InitializeCacheMissAnalyzer(AnalysisInput analysisInput)
{
string outputDirectory = null;
bool allPips = false;
foreach (var opt in AnalyzerOptions)
{
if (opt.Name.Equals("outputDirectory", StringComparison.OrdinalIgnoreCase) ||
opt.Name.Equals("o", StringComparison.OrdinalIgnoreCase))
{
outputDirectory = ParseSingletonPathOption(opt, outputDirectory);
}
else if (opt.Name.StartsWith("allPips", StringComparison.OrdinalIgnoreCase))
{
allPips = ParseBooleanOption(opt);
}
else
{
throw Error("Unknown option for cache miss analysis: {0}", opt.Name);
}
}
if (string.IsNullOrEmpty(outputDirectory))
{
throw new Exception("'outputDirectory' is required.");
}
return(new CacheMissAnalyzer(analysisInput)
{
OutputDirectory = outputDirectory,
AllPips = allPips,
});
}
public CacheMissAnalyzer(AnalysisInput input)
: base(input)
{
Console.WriteLine("Loaded old graph");
m_model = new AnalysisModel(CachedGraph);
m_logPath = input.ExecutionLogPath;
}
public FailedPipsDumpAnalyzer(AnalysisInput input)
: base(input)
{
nodeVisitor = new NodeVisitor(DirectedGraph);
m_failedPipsClosure = new VisitationTracker(DirectedGraph);
m_cachedPips = new VisitationTracker(DirectedGraph);
m_pipTable = input.CachedGraph.PipTable;
}
public GraphDiffAnalyzer(AnalysisInput firstGraphAnalysisInput, AnalysisInput secondGraphAnalysisInput, string outputDirectoryPath) : base(secondGraphAnalysisInput)
{
m_outputDirectoryPath = outputDirectoryPath;
m_firstGraphAnalysisInput = firstGraphAnalysisInput;
m_secondGraphAnalysisInput = secondGraphAnalysisInput;
EnsureEmptyOutputDirectory();
}
public CosineDumpPip(AnalysisInput input, string outputFilePath, DumpPipFilters filters)
: base(input)
{
OutputFilePath = outputFilePath;
Filters = filters;
Console.WriteLine($"CosineDumpPip: Constructed at {DateTime.Now}.");
}
protected Analyzer(AnalysisInput input)
: base(input.CachedGraph.PipGraph)
{
Contract.Requires(input.CachedGraph != null);
Input = input;
CachedGraph = input.CachedGraph;
}
public ContentPlacementAnalyzer(AnalysisInput input, double sampleProportion, int sampleSizeHardLimit, string buildQueue, string buildId, long buildStartTicks, double buildDurationMs) : base(input)
{
m_sampleProportion = sampleProportion;
m_sampleSizeHardLimit = sampleSizeHardLimit;
m_buildQueue = buildQueue;
m_buildId = buildId;
m_buildStartTicks = buildStartTicks;
m_buildDurationMs = buildDurationMs;
}
public BuildStatus(AnalysisInput input, int maxDifferenceReportCount, FilterOptions filterOptions, WhatBuiltOptions whatBuiltOptions, string outputFilterPath, List <string> rootSubdirectories)
: base(input, maxDifferenceReportCount, filterOptions)
{
m_generateWhatBuiltOutput = filterOptions.WhatBuilt;
m_whatBuiltOptions = whatBuiltOptions;
m_outputFilterPath = outputFilterPath;
m_rootSubdirectories = rootSubdirectories;
SingleLog = true;
}
public DumpPipAnalyzer(AnalysisInput input, string outputFilePath, long semiStableHash, DirectoryArtifact directory, bool useOriginalPaths, bool logProgress = false)
: base(input)
{
if (string.IsNullOrEmpty(outputFilePath))
{
outputFilePath = Path.Combine(Path.GetDirectoryName(input.ExecutionLogPath), $"Pip{semiStableHash:X16}.html");
Console.WriteLine($"Missing option /outputFilePath using: {outputFilePath}");
}
m_outputFilePath = outputFilePath;
m_useOriginalPaths = useOriginalPaths;
if (logProgress)
{
Console.WriteLine("Finding matching pip");
}
var pipTable = input.CachedGraph.PipTable;
foreach (var pipId in pipTable.StableKeys)
{
if (pipTable.GetPipType(pipId) == PipType.Module)
{
var modulePip = (ModulePip)pipTable.HydratePip(pipId, PipQueryContext.ViewerAnalyzer);
m_moduleIdToFriendlyName.Add(modulePip.Module, modulePip.Identity.ToString(StringTable));
}
var possibleMatch = pipTable.GetPipSemiStableHash(pipId);
if (possibleMatch == semiStableHash)
{
m_pip = pipTable.HydratePip(pipId, PipQueryContext.ViewerAnalyzer);
}
}
if (directory.IsValid)
{
Console.WriteLine("Looking for a pip that produced the specified DirectoryArtifact.");
var directoryProducers = input.CachedGraph.PipGraph.AllOutputDirectoriesAndProducers.ToDictionary(kvp => kvp.Key, kvp => kvp.Value);
if (directoryProducers.TryGetValue(directory, out var pipId))
{
m_pip = pipTable.HydratePip(pipId, PipQueryContext.ViewerAnalyzer);
}
// This directory artifact does not have a registered producer. This might happen if it represents a composite SOD.
else if (directory.IsSharedOpaque)
{
directoryProducers = input.CachedGraph.PipGraph.AllCompositeSharedOpaqueDirectoriesAndProducers.ToDictionary(kvp => kvp.Key, kvp => kvp.Value);
if (directoryProducers.TryGetValue(directory, out pipId))
{
m_pip = pipTable.HydratePip(pipId, PipQueryContext.ViewerAnalyzer);
}
}
}
m_html = new HtmlHelper(PathTable, StringTable, SymbolTable, CachedGraph.PipTable);
}
public Analyzer InitializeFingerprintStoreAnalyzer(AnalysisInput oldAnalysisInput, AnalysisInput newAnalysisInput)
{
string outputDirectory = null;
bool allPips = false;
bool noBanner = false;
long sshValue = -1;
CacheMissDiffFormat cacheMissDiffFormat = CacheMissDiffFormat.CustomJsonDiff;
foreach (var opt in AnalyzerOptions)
{
if (opt.Name.Equals("outputDirectory", StringComparison.OrdinalIgnoreCase) ||
opt.Name.Equals("o", StringComparison.OrdinalIgnoreCase))
{
outputDirectory = ParseSingletonPathOption(opt, outputDirectory);
}
else if (opt.Name.Equals("pip", StringComparison.OrdinalIgnoreCase) ||
opt.Name.Equals("p", StringComparison.OrdinalIgnoreCase))
{
sshValue = ParseSemistableHash(opt);
}
else if (opt.Name.StartsWith("allPips", StringComparison.OrdinalIgnoreCase))
{
allPips = ParseBooleanOption(opt);
}
else if (opt.Name.Equals("nobanner", StringComparison.OrdinalIgnoreCase))
{
noBanner = ParseBooleanOption(opt);
}
else if (opt.Name.Equals("cacheMissDiffFormat", StringComparison.OrdinalIgnoreCase))
{
cacheMissDiffFormat = ParseEnumOption <CacheMissDiffFormat>(opt);
}
else
{
throw Error("Unknown option for cache miss analysis: {0}", opt.Name);
}
}
if (string.IsNullOrEmpty(outputDirectory))
{
throw new Exception("'outputDirectory' is required.");
}
if (allPips && sshValue != -1)
{
throw new Exception("'allPips' can't be true if pipId is set.");
}
return(new FingerprintStoreAnalyzer(oldAnalysisInput, newAnalysisInput)
{
OutputDirectory = outputDirectory,
AllPips = allPips,
SemiStableHashToRun = sshValue,
NoBanner = noBanner
});
}
public PipExecutionPerformanceAnalyzer(AnalysisInput input, string outputFilePath, bool isCsvFormat, bool includeProcessTree, bool useOriginalPaths)
: base(input)
{
Contract.Requires(!string.IsNullOrWhiteSpace(outputFilePath));
m_writer = new StreamWriter(outputFilePath);
m_isCsvFormat = isCsvFormat;
m_includeProcessTree = includeProcessTree;
m_useOriginalPaths = useOriginalPaths;
}
private void DumpPip(Pip pip, AnalysisInput analysisInput, string dumpPath)
{
var dumpPipAnalyzer = new DumpPipAnalyzer(analysisInput, dumpPath, pip.SemiStableHash, true, false);
var result = dumpPipAnalyzer.Analyze();
if (result != 0)
{
throw new Exception($"DumpPip failed for {pip.FormattedSemiStableHash}");
}
}
