private string CompareEnvironmentSummary(ConcurrentDictionary <string, DependencySummary <string> > otherEnvironmentSummary)
        {
            var environmentCompare = SummaryAnalyzer.GenerateEnvironmentDifference(m_analyzer.Summary.EnvironmentSummary, otherEnvironmentSummary);

            if (environmentCompare.enviromentChanges.Count == 0 && environmentCompare.enviromentMissing.Count == 0)
            {
                return("Environments are identical.");
            }

            using (var output = new StringWriter(CultureInfo.InvariantCulture))
            {
                // Now compare
                output.WriteLine("List differences in distinct EnvironmentVariableName = value; pairs");
                output.WriteLine("defined in process pips between execution log current and previous.");
                output.WriteLine("=====================================================================");
                foreach (var values in environmentCompare.enviromentChanges)
                {
                    output.WriteLine("Environment variable ({0} pips): {1} = {2} <> {3}", values[1], values[0], values[2], values[3]);
                }

                if (environmentCompare.Item2.Count > 0)
                {
                    output.WriteLine("Current log missing following environmet variables:");
                    foreach (var values in environmentCompare.Item2)
                    {
                        output.WriteLine("Variable ({0} pips): {1} = {2}", values[1], values[0], values[3]);
                    }
                }

                return(output.ToString());
            }
        }
        internal static string GetPipEnvironmentMissReport(
            ConcurrentDictionary <string, DependencySummary <string> > environmentSummary,
            ConcurrentDictionary <string, DependencySummary <string> > otherEnvironmentSummary)
        {
            var environmentCompare = SummaryAnalyzer.GenerateEnvironmentDifference(environmentSummary, otherEnvironmentSummary);

            if (environmentCompare.enviromentChanges.Count == 0 && environmentCompare.enviromentMissing.Count == 0)
            {
                return(string.Empty);
            }

            using (var output = new StringWriter(CultureInfo.InvariantCulture))
            {
                output.WriteLine("\n   Environment Changes:");
                foreach (var values in environmentCompare.enviromentChanges)
                {
                    output.WriteLine("Environment variable ({0} pips): {1} = {2} <> {3}", values[1], values[0], values[2], values[3]);
                }

                if (environmentCompare.Item2.Count > 0)
                {
                    output.WriteLine("Current log missing following environmet variables:");
                    foreach (var values in environmentCompare.Item2)
                    {
                        output.WriteLine("Variable ({0} pips): {1} = {2}", values[1], values[0], values[3]);
                    }
                }

                return(output.ToString());
            }
        }
        internal string CompareDirectoryDependencySummary(ConcurrentDictionary <string, DependencySummary <string> > otherDirectorySummary, string otherLogPath)
        {
            var directoriesNotInTwo = SummaryAnalyzer.GetDependencyDiff(m_analyzer.Summary.DirectorySummary, otherDirectorySummary).ToList();
            var directoriesNotInOne = SummaryAnalyzer.GetDependencyDiff(otherDirectorySummary, m_analyzer.Summary.DirectorySummary).ToList();

            // Directory dependencies in some PIPs are distinct.
            using (var output = new StringWriter(CultureInfo.InvariantCulture))
            {
                var hadOutput = false;
                int longest   = directoriesNotInOne.Select(s => s.Name.Length).Concat(new[] { 50 }).Max();
                longest = directoriesNotInTwo.Select(s => s.Name.Length).Concat(new[] { longest }).Max();

                // List the differences
                output.WriteLine("List differences between a summary of distinct directory dependencies");
                output.WriteLine("defined in process pips between execution log current and previous.");
                output.WriteLine("=====================================================================");
                string formatString = "{0,-" + longest + "} | {1,19} | {2, 15} | {3, 6} | {4, 6}";
                output.WriteLine("Top Directory Dependency Differences:");
                output.WriteLine("Current Execution Log = {0}", m_analyzer.ExecutionLogPath);
                output.WriteLine("Previous Execution Log = {0}", otherLogPath);
                output.WriteLine(formatString, "Directory Dependency", "Pip Reference count", "% Pip Reference", "Current", "Previous");

                foreach (var s in directoriesNotInTwo)
                {
                    var referencePercentage = m_analyzer.GetProcessPipCount() > 0
                        ? (int)((s.Count * 100) / m_analyzer.GetProcessPipCount())
                        : 0;
                    output.WriteLine(formatString, s.Name.ToLowerInvariant(), s.Count, referencePercentage, "yes", "no");
                    hadOutput = true;
                }

                foreach (var s in directoriesNotInOne)
                {
                    var referencePercentage = m_analyzer.GetProcessPipCount() > 0
                        ? (int)((s.Count * 100) / m_analyzer.GetProcessPipCount())
                        : 0;
                    output.WriteLine(formatString, s.Name.ToLowerInvariant(), s.Count, referencePercentage, "no", "yes");
                    hadOutput = true;
                }

                return(hadOutput ? output.ToString() : "Top Directory Dependency Differences: none");
            }
        }
        public void PrintHygienatorTwoLogsCsvOutput(StreamWriter writer, SummaryAnalyzer analyzer)
        {
            // TODO: allo adding prefix : SourceNamespace,Island,BuildName,Branch,BuildDate,ComputerName,Architecture,
            writer.WriteLine(
                "timeStart,Name,directCount,rootPipTransitiveCount,pipDuration,pipKernelTime,pipUserTime,pipDurationCriticalPath,pipKernelTimeCriticalPath,pipUserTimeCriticalPath,dependencyType,FileHash");
            if (!m_analyzer.CompareSaltsEquals(analyzer))
            {
                // Add the flag changes
                var saltDiffs = m_analyzer.GetSaltsDifference(analyzer);
                foreach (var diff in saltDiffs)
                {
                    writer.WriteLine(
                        "0,{0},{1},{2},0,0,0,0,0,0,GlobalFlagsChange,",
                        diff,
                        m_analyzer.GetProcessPipCount(),
                        m_analyzer.GetProcessPipCount());
                }
            }

            PrintTransitiveDependenciesImpact(writer);
        }
        private void WriteSummary(SummaryAnalyzer otherAnalyzer, StreamWriter writer)
        {
            writer.WriteLine("Current Execution Log = {0}", m_analyzer.ExecutionLogPath);
            writer.WriteLine("Previous Execution Log: {0}", otherAnalyzer.ExecutionLogPath);
            writer.WriteLine("Number of Process Pips :  {0}", m_analyzer.GetProcessPipCount());
            writer.WriteLine("Number of executed Process Pips :  {0}", m_analyzer.GetExecutedProcessPipCount());

            var fileDependencyDiff = SummaryAnalyzer.GetFileDependencyDiff(m_analyzer.Summary.FileArtifactSummary, otherAnalyzer.Summary.FileArtifactSummary);

            writer.WriteLine("Number of dependency files with mismatch hash : {0}", fileDependencyDiff.Count());

            var observedDiff = SummaryAnalyzer.GetFileDependencyDiff(m_analyzer.Summary.ObservedSummary, otherAnalyzer.Summary.ObservedSummary);

            writer.WriteLine("Number of observed inputs with mismatch hash : {0}", observedDiff.Count());

            if (m_analyzer.Summary.DirectoryMembership.Count == 0 || otherAnalyzer.Summary.DirectoryMembership.Count == 0)
            {
                var fileName = m_analyzer.Summary.DirectoryMembership.Count == 0 ? m_analyzer.ExecutionLogPath : otherAnalyzer.ExecutionLogPath;
                writer.WriteLine("No directory membership event in execution log : {0}", fileName);
            }
            else
            {
                var directoryMembershipNotInTwo = SummaryAnalyzer.GetDirectoryMembershipDiff(m_analyzer.Summary.DirectoryMembership, otherAnalyzer.Summary.DirectoryMembership);
                var directoryMembershipNotInOne = SummaryAnalyzer.GetDirectoryMembershipDiff(otherAnalyzer.Summary.DirectoryMembership, m_analyzer.Summary.DirectoryMembership);
                writer.WriteLine("Number of directory membership differences : {0}", directoryMembershipNotInTwo.Count() + directoryMembershipNotInOne.Count);
            }

            int produced = m_analyzer.GetProducedFileCount();
            var cached   = m_analyzer.GetCachedFileCount();
            var upToDate = m_analyzer.GetUpToDateFileCount();

            writer.WriteLine("Current XLG Output Files : {0}/{1}/{2}(Produced/FromCache/UpToDate)", produced, cached, upToDate);

            produced = otherAnalyzer.GetProducedFileCount();
            cached   = otherAnalyzer.GetCachedFileCount();
            upToDate = otherAnalyzer.GetUpToDateFileCount();
            writer.WriteLine("Previous XLG Output Files : {0}/{1}/{2}(Produced/FromCache/UpToDate)", produced, cached, upToDate);
            writer.WriteLine();
        }
示例#6
0
文件: Args.cs 项目: kittinap/kunnjae
        public int Analyze()
        {
            if (m_analyzer == null)
            {
                return(0);
            }

            m_analyzer.Prepare();
            if (m_analysisInput.ExecutionLogPath != null)
            {
                // NOTE: We call Prepare above so we don't need to prepare as a part of reading the execution log
                var reader = Task.Run(() => m_analyzer.ReadExecutionLog(prepare: false));
                if (m_mode == AnalysisMode.LogCompare)
                {
                    m_analyzerOther.Prepare();
                    var otherReader = Task.Run(() => m_analyzerOther.ReadExecutionLog());
                    otherReader.Wait();
                }

                if (m_mode == AnalysisMode.FailedPipsDump && m_analyzerOther != null)
                {
                    var start = DateTime.Now;
                    Console.WriteLine($"[{start}] Reading compare to Log");
                    var otherReader = Task.Run(() => m_analyzerOther.ReadExecutionLog());
                    otherReader.Wait();
                    var duration = DateTime.Now - start;
                    Console.WriteLine($"Done reading compare to log : duration = [{duration}]");
                }

                reader.Wait();

                if (m_mode == AnalysisMode.CacheMissLegacy)
                {
                    // First pass just to read in PipCacheMissType data
                    var otherReader = Task.Run(() => m_analyzerOther.ReadExecutionLog());
                    otherReader.Wait();

                    // Second pass to do fingerprint differences analysis
                    otherReader = Task.Run(() => m_analyzerOther.ReadExecutionLog());
                    otherReader.Wait();
                }
            }

            var exitCode = m_analyzer.Analyze();

            if (m_mode == AnalysisMode.FailedPipsDump && m_analyzerOther != null)
            {
                var failedPipsDump = (FailedPipsDumpAnalyzer)m_analyzer;
                exitCode = failedPipsDump.Compare(m_analyzerOther);
            }

            if (m_mode == AnalysisMode.LogCompare)
            {
                m_analyzerOther.Analyze();
                SummaryAnalyzer summary = (SummaryAnalyzer)m_analyzer;
                exitCode = summary.Compare((SummaryAnalyzer)m_analyzerOther);
            }

            if (m_mode == AnalysisMode.CacheMissLegacy)
            {
                exitCode = m_analyzerOther.Analyze();
            }

            m_analyzer?.Dispose();
            m_analyzerOther?.Dispose();

            TelemetryShutdown();
            return(exitCode);
        }
        /// <summary>
        /// Writes the artifact reason for execution when comparing the two pips into the csv file.
        /// The pips comparared are the roots in order of longest critical path and only its difference is written. No transitive down pips are compared.
        /// </summary>
        private void PrintTransitiveDependenciesImpact(StreamWriter writer)
        {
            var summariesToReport = m_analyzer.GetDifferecesToReport();

            // keep track of distinct dependencies
            var fileArtifacts        = new HashSet <FileArtifactSummary>();
            var environmentVariables = new HashSet <DependencySummary <string> >();
            var observedInputs       = new HashSet <ObservedInputSummary>();

            foreach (var pipDiff in summariesToReport.OrderByDescending(a => a.pipSummary1.CriticalPath.Time))
            {
                var pipSummary      = pipDiff.pipSummary1;
                var otherPipSummary = pipDiff.pipSummary2;

                if (pipSummary.NewPip)
                {
                    continue;
                }

                // TODO: add removed dependencies in output
                if (!pipSummary.Fingerprint.Equals(otherPipSummary.Fingerprint))
                {
                    var filesDiff = SummaryAnalyzer.GetFileDependencyDiff(pipSummary.DependencySummary, otherPipSummary.DependencySummary).ToList();
                    foreach (var item in filesDiff)
                    {
                        if (item.CachedCount > 0)
                        {
                            // This was reported cached in other pips so it has not changed
                            continue;
                        }

                        if (item.OutputOrigin == PipOutputOrigin.Produced || fileArtifacts.Contains(item))
                        {
                            // Output file so not interesting or already written
                            continue;
                        }

                        PrintCsvArtifact(writer, pipSummary, item, "Input", item.GetHashName());
                        fileArtifacts.Add(item);
                    }

                    var environmentDiff = SummaryAnalyzer.GetDependencyDiff(pipSummary.EnvironmentSummary, otherPipSummary.EnvironmentSummary).ToList();
                    foreach (var item in environmentDiff)
                    {
                        if (!environmentVariables.Contains(item))
                        {
                            PrintCsvArtifact(writer, pipSummary, item, "EnvironmentVariable", string.Empty);
                            environmentVariables.Add(item);
                        }
                    }
                }

                var observedDiff = SummaryAnalyzer.GetFileDependencyDiff(pipSummary.ObservedInputSummary, otherPipSummary.ObservedInputSummary).ToList();
                foreach (var item in observedDiff)
                {
                    if (item.CachedCount > 0)
                    {
                        // This was reported cached in other pips so it has not changed
                        continue;
                    }

                    if (!observedInputs.Contains(item))
                    {
                        PrintCsvArtifact(writer, pipSummary, item, "ObservedInput", item.GetHashName());
                        observedInputs.Add(item);
                    }
                }
            }
        }
        /// <summary>
        /// Summary of directory membership differences
        /// </summary>
        internal string CompareDirectoryMembership(SummaryAnalyzer otherSummaryAnalyzer)
        {
            var directoryMembership = otherSummaryAnalyzer.Summary.DirectoryMembership;
            var otherLogPath        = otherSummaryAnalyzer.ExecutionLogPath;

            if (m_analyzer.Summary.DirectoryMembership.Count == 0 || otherSummaryAnalyzer.Summary.DirectoryMembership.Count == 0)
            {
                var fileName = m_analyzer.Summary.DirectoryMembership.Count == 0 ? m_analyzer.ExecutionLogPath : otherLogPath;
                return(string.Format(CultureInfo.InvariantCulture, "No directory membership events in execution log : {0}", fileName));
            }

            // Find the top observed imput directories that have changed and make sure the enumeration is listed
            var observedDiff           = SummaryAnalyzer.GetFileDependencyDiff(m_analyzer.Summary.ObservedSummary, otherSummaryAnalyzer.Summary.ObservedSummary).ToList();
            var count                  = 0;
            var directoriesToEnumerate = new HashSet <string>();

            foreach (var entry in observedDiff)
            {
                if (m_analyzer.Summary.DirectoryMembership.ContainsKey(entry.Name))
                {
                    directoriesToEnumerate.Add(entry.Name);
                }

                if (count++ > m_analyzer.MaxDifferenceReportCount)
                {
                    break;
                }
            }

            var directoryMembershipNotInTwo = SummaryAnalyzer.GetDirectoryMembershipDiff(m_analyzer.Summary.DirectoryMembership, directoryMembership);
            var directoryMembershipNotInOne = SummaryAnalyzer.GetDirectoryMembershipDiff(directoryMembership, m_analyzer.Summary.DirectoryMembership);

            using (var output = new StringWriter(CultureInfo.InvariantCulture))
            {
                var hadOutput = false;
                output.WriteLine("Top Directory Membership Differences:");
                output.WriteLine("Current Execution Log = {0}", m_analyzer.ExecutionLogPath);
                output.WriteLine("Previous Execution Log = {0}", otherLogPath);
                output.WriteLine("Directory  |  Current Execution Log   | Previous Execution Log");

                int outReportCount = 0;

                // Enumerate changes in observed inputs first to show those relevant changes
                foreach (var directory in directoriesToEnumerate)
                {
                    List <string> entry;
                    if (directoryMembershipNotInTwo.TryGetValue(directory, out entry))
                    {
                        hadOutput = PrintDirectoryEnumeration(output, directory, entry);
                        if (outReportCount++ > m_analyzer.MaxDifferenceReportCount)
                        {
                            break;
                        }
                    }
                }

                foreach (var s in directoryMembershipNotInTwo)
                {
                    if (directoriesToEnumerate.Contains(s.Key))
                    {
                        continue;
                    }

                    hadOutput = PrintDirectoryEnumeration(output, s.Key, s.Value);
                    if (outReportCount++ > m_analyzer.MaxDifferenceReportCount)
                    {
                        break;
                    }
                }

                foreach (var s in directoryMembershipNotInOne)
                {
                    hadOutput = PrintDirectoryEnumeration(output, s.Key, s.Value);
                    if (outReportCount++ > m_analyzer.MaxDifferenceReportCount)
                    {
                        break;
                    }
                }

                return(hadOutput ? output.ToString() : "Directory Membership Differences: none");
            }
        }
        public void PrintTextReport(SummaryAnalyzer analyzer, StreamWriter writer)
        {
            WriteSummary(analyzer, writer);
            PrintTransitiveImpact(writer);
            writer.WriteLine(" Summary Section");
            writer.WriteLine("=====================================================================");
            writer.WriteLine("Environment variables Analysis");
            writer.WriteLine("=====================================================================");
            writer.WriteLine(CompareEnvironmentSummary(analyzer.Summary.EnvironmentSummary));
            writer.WriteLine();
            writer.WriteLine("=====================================================================");
            writer.WriteLine("Directory dependency summary analysis");
            writer.WriteLine("=====================================================================");
            writer.WriteLine(CompareDirectoryDependencySummary(analyzer.Summary.DirectorySummary, analyzer.ExecutionLogPath));
            writer.WriteLine();

            writer.WriteLine("=====================================================================");
            writer.WriteLine("File dependency summary analysis");
            writer.WriteLine("=====================================================================");
            var compareHeader = "Summary of file dependencies with mismatch hash" + Environment.NewLine +
                                "defined in process pips between execution log current and previous." +
                                Environment.NewLine +
                                "=====================================================================" +
                                Environment.NewLine +
                                "Top File Dependency Differences: orderd by Pip reference count" +
                                Environment.NewLine +
                                "File Name, source/output, origin, % direct PIP referenced, direct PIP reference Count, File Hash - Current, File Hash - Previous";
            var fileArtifactDiff = CompareFileDependencySummary(
                compareHeader,
                m_analyzer.Summary.FileArtifactSummary,
                analyzer.Summary.FileArtifactSummary);

            if (string.IsNullOrEmpty(fileArtifactDiff))
            {
                fileArtifactDiff = "Top File Dependency Differences: None";
            }

            writer.WriteLine(fileArtifactDiff);
            writer.WriteLine();

            writer.WriteLine("=====================================================================");
            writer.WriteLine("Observed inputs dependency summary analysis");
            writer.WriteLine("=====================================================================");
            compareHeader = "List differences between a summary of observed inputs" + Environment.NewLine +
                            "between execution log current and previous." + Environment.NewLine +
                            "=====================================================================" +
                            Environment.NewLine +
                            "Top Observed File Dependency Differences: orderd by Pip reference count" +
                            Environment.NewLine +
                            "File Name, Observed Input Type, % PIP referenced, PIP dependent Count , File Hash - Current, File Hash - Previous";
            var observedInputDiff = CompareObservedDependencySummary(
                compareHeader,
                m_analyzer.Summary.ObservedSummary,
                analyzer.Summary.ObservedSummary);

            if (string.IsNullOrEmpty(observedInputDiff))
            {
                observedInputDiff = "Top Observed File Dependency Differences: None";
            }

            writer.WriteLine(observedInputDiff);
            writer.WriteLine();
            writer.WriteLine("=====================================================================");
            writer.WriteLine("Directory membership difference");
            writer.WriteLine("=====================================================================");
            writer.WriteLine(CompareDirectoryMembership(analyzer));
            writer.WriteLine();
        }
 public SummaryAnalyzerTextWriter(SummaryAnalyzer analyzer)
 {
     m_analyzer = analyzer;
 }
        private void PrintTransitiveImpact(StreamWriter writer)
        {
            writer.WriteLine("=====================================================================");
            writer.WriteLine("Executed Process Analysis Current Execution Log : {0}", m_analyzer.ExecutionLogPath);
            writer.WriteLine("=====================================================================");
            writer.WriteLine("This section lists executed process pips in longest pole order in File A.");
            writer.WriteLine("Reason for execution by comparing to matching pip in File B.");
            writer.WriteLine("Dependent process pips executed");
            writer.WriteLine("Critical path of transitive down dependent pips.");
            writer.WriteLine("Dependent list of process Pips (optional)");
            writer.WriteLine("Reporting Top level executed pips");
            writer.WriteLine("=====================================================================");

            var summariesToReport  = m_analyzer.GetDifferecesToReport();
            var invalidationReason = new HashSet <string>();

            foreach (var pipDiff in summariesToReport.OrderByDescending(a => a.Item1.CriticalPath.Time))
            {
                var pipSummary      = pipDiff.pipSummary1;
                var otherPipSummary = pipDiff.pipSummary2;
                var pip             = pipSummary.Pip;

                bool weakFingerprintCacheMiss;
                m_analyzer.TryGetWeakFingerprintCacheMiss(pipSummary.Pip.PipId, out weakFingerprintCacheMiss);
                var missReason = pipSummary.UncacheablePip
                    ? "Un-cacheable Pip"
                    : weakFingerprintCacheMiss ? "Weak Fingerprint Cache-Miss" : "Strong Fingerprint Cache-Miss";
                if (!pipSummary.NewPip)
                {
                    if (!pipSummary.Fingerprint.Equals(otherPipSummary.Fingerprint))
                    {
                        missReason = CompareFileDependencySummary(
                            "   File Dependency Changes:",
                            pipSummary.DependencySummary,
                            otherPipSummary.DependencySummary);
                        missReason += GetPipEnvironmentMissReport(
                            pipSummary.EnvironmentSummary,
                            otherPipSummary.EnvironmentSummary);
                    }

                    missReason += CompareObservedDependencySummary(
                        "   Observed File Dependency Changes:",
                        pipSummary.ObservedInputSummary, otherPipSummary.ObservedInputSummary);
                }

                if (invalidationReason.Contains(missReason))
                {
                    // This invalidation is known, so cut down the noise on the report
                    continue;
                }

                writer.WriteLine(m_analyzer.GetPipDescription(pip));
                writer.WriteLine(" Transitive Process invalidated count: {0}", pipSummary.ExecutedDependentProcessCount);
                writer.WriteLine(" Cache-Miss reason analysis:");
                writer.WriteLine(SummaryAnalyzer.GetFingerprintMismatch(pipSummary, otherPipSummary));
                writer.WriteLine(missReason);
                if (!string.IsNullOrEmpty(missReason))
                {
                    invalidationReason.Add(missReason);
                }

                var executionStart     = m_analyzer.GetPipStartTime(pip);
                var executionStartText = executionStart.Equals(DateTime.MinValue) ? "-" : executionStart.ToString("h:mm:ss.ff", CultureInfo.InvariantCulture);

                writer.WriteLine(" Start time: {0}", executionStartText);
                writer.WriteLine(
                    " Critical path (seconds): Duration: ( {0} )  Kernel Time: ( {1} )  User Time: ( {2} )",
                    ToSeconds(pipSummary.CriticalPath.Time),
                    ToSeconds(pipSummary.CriticalPath.KernelTime),
                    ToSeconds(pipSummary.CriticalPath.UserTime));

                if (pipSummary.ExecutedDependentProcessCount > 0)
                {
                    var criticalPathReport = m_analyzer.GetCriticalPathText(pipSummary.CriticalPath);
                    writer.WriteLine();
                    writer.WriteLine(criticalPathReport);
                }

                if (m_analyzer.WriteTransitiveDownPips && pipSummary.ExecutedDependentProcessCount > 0)
                {
                    writer.WriteLine(WriteDependentProcess(pipSummary.DependentNodes));
                }

                writer.WriteLine("=====================================================================");
            }
        }