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}"); } }