Merge pull request microsoft#1186 from brianrob/recipes

Automated Performance Analysis Framework

Author: brianrob

PerfView.sln

@@ -1,6 +1,6 @@
 Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio 15
-VisualStudioVersion = 15.0.26918.3
+# Visual Studio Version 16
+VisualStudioVersion = 16.0.30104.5
 MinimumVisualStudioVersion = 15.0
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "ETWClrProfilerX86", "src\EtwClrProfiler\ETWClrProfilerX86.vcxproj", "{E9980619-4016-4A4A-B7CC-F8B0E483BDB8}"
 EndProject

src/PerfView/PerfViewData.cs

@@ -3,6 +3,7 @@
 using Graphs;
 using Microsoft.Diagnostics.Symbols;
 using Microsoft.Diagnostics.Tracing;
+using Microsoft.Diagnostics.Tracing.AutomatedAnalysis;
 using Microsoft.Diagnostics.Tracing.Etlx;
 using Microsoft.Diagnostics.Tracing.EventPipe;
 using Microsoft.Diagnostics.Tracing.Parsers;
@@ -1516,6 +1517,17 @@ private void MakeModuleCsv(List<TraceProcess> processes, string filepath)
         #endregion
     }
 
+    public class AutomatedAnalysisReport : PerfViewHtmlReport
+    {
+        public AutomatedAnalysisReport(PerfViewFile dataFile) : base(dataFile, "Automatic CPU Analysis") { }
+
+        protected override void WriteHtmlBody(TraceLog dataFile, TextWriter writer, string fileName, TextWriter log)
+        {
+            AutomatedAnalysisManager manager = new AutomatedAnalysisManager(dataFile, log, App.GetSymbolReader(dataFile.FilePath));
+            manager.GenerateReport(writer);
+        }
+    }
+
     public class PerfViewIisStats : PerfViewHtmlReport
     {
         private Dictionary<Guid, IisRequest> m_Requests = new Dictionary<Guid, IisRequest>();
@@ -6840,6 +6852,7 @@ protected override Action<Action> OpenImpl(Window parentWindow, StatusBar worker
             var advanced = new PerfViewTreeGroup("Advanced Group");
             var memory = new PerfViewTreeGroup("Memory Group");
             var obsolete = new PerfViewTreeGroup("Old Group");
+            var experimental = new PerfViewTreeGroup("Experimental Group");
             m_Children = new List<PerfViewTreeItem>();
 
             bool hasCPUStacks = false;
@@ -7028,7 +7041,7 @@ protected override Action<Action> OpenImpl(Window parentWindow, StatusBar worker
             if (hasCPUStacks)
             {
                 m_Children.Add(new PerfViewStackSource(this, "CPU"));
-
+                experimental.Children.Add(new AutomatedAnalysisReport(this));
                 if (!App.CommandLineArgs.ShowOptimizationTiers &&
                     tracelog.Events.Any(
                         e => e is MethodLoadUnloadTraceDataBase td && td.OptimizationTier != OptimizationTier.Unknown))
@@ -7245,6 +7258,11 @@ protected override Action<Action> OpenImpl(Window parentWindow, StatusBar worker
                 m_Children.Add(obsolete);
             }
 
+            if(AppLog.InternalUser && 0 < experimental.Children.Count)
+            {
+                m_Children.Add(experimental);
+            }
+
             return null;
         }
         // public override string DefaultStackSourceName { get { return "CPU"; } }

src/TraceEvent/AutomatedAnalysis/AutomatedAnalysisExecutionContext.cs

@@ -0,0 +1,29 @@
+using System;
+using System.Collections.Generic;
+using Microsoft.Diagnostics.Tracing.Etlx;
+using Microsoft.Diagnostics.Tracing.Stacks;
+using System.IO;
+using System.Text.RegularExpressions;
+using Microsoft.Diagnostics.Symbols;
+
+namespace Microsoft.Diagnostics.Tracing.AutomatedAnalysis
+{
+    public sealed class AutomatedAnalysisExecutionContext
+    {
+        internal AutomatedAnalysisExecutionContext(TraceLog traceLog, TextWriter textLog, SymbolReader symbolReader, AutomatedAnalysisIssueCollection issues)
+        {
+            TraceLog = traceLog;
+            TextLog = textLog;
+            SymbolReader = symbolReader;
+            Issues = issues;
+        }
+
+        public SymbolReader SymbolReader { get; }
+
+        public TraceLog TraceLog { get; }
+
+        public TextWriter TextLog { get; }
+
+        public AutomatedAnalysisIssueCollection Issues { get; }
+    }
+}

src/TraceEvent/AutomatedAnalysis/AutomatedAnalysisIssue.cs

@@ -0,0 +1,21 @@
+using System;
+
+namespace Microsoft.Diagnostics.Tracing.AutomatedAnalysis
+{
+    public sealed class AutomatedAnalysisIssue
+    {
+        public AutomatedAnalysisIssue(
+            string title,
+            string description,
+            string url)
+        {
+            Title = title;
+            Description = description;
+            URL = url;
+        }
+
+        public string Title { get; private set; }
+        public string Description { get; private set; }
+        public string URL { get; private set; }
+    }
+}

src/TraceEvent/AutomatedAnalysis/AutomatedAnalysisIssueCollection.cs

@@ -0,0 +1,41 @@
+using Microsoft.Diagnostics.Tracing.Etlx;
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Microsoft.Diagnostics.Tracing.AutomatedAnalysis
+{
+    public sealed class AutomatedAnalysisIssueCollection : IEnumerable<KeyValuePair<TraceProcess, List<AutomatedAnalysisIssue>>>
+    {
+        private Dictionary<TraceProcess, List<AutomatedAnalysisIssue>> _issues = new Dictionary<TraceProcess, List<AutomatedAnalysisIssue>>();
+
+        public List<AutomatedAnalysisIssue> this[TraceProcess process]
+        {
+            get
+            {
+                List<AutomatedAnalysisIssue> issues;
+                if(!_issues.TryGetValue(process, out issues))
+                {
+                    issues = new List<AutomatedAnalysisIssue>();
+                    _issues.Add(process, issues);
+                }
+
+                return issues;
+            }
+        }
+
+        public IEnumerator GetEnumerator()
+        {
+            return ((IEnumerable)_issues).GetEnumerator();
+        }
+
+        IEnumerator<KeyValuePair<TraceProcess, List<AutomatedAnalysisIssue>>> IEnumerable<KeyValuePair<TraceProcess, List<AutomatedAnalysisIssue>>>.GetEnumerator()
+        {
+            return ((IEnumerable<KeyValuePair<TraceProcess, List<AutomatedAnalysisIssue>>>)_issues).GetEnumerator();
+        }
+    }
+}

src/TraceEvent/AutomatedAnalysis/AutomatedAnalysisManager.cs

@@ -0,0 +1,76 @@
+using System.IO;
+using System.Collections.Generic;
+using Microsoft.Diagnostics.Tracing.Etlx;
+using Microsoft.Diagnostics.Symbols;
+
+namespace Microsoft.Diagnostics.Tracing.AutomatedAnalysis
+{
+    public sealed class AutomatedAnalysisManager
+    {
+        private TraceLog _traceLog;
+        private TextWriter _textLog;
+        private SymbolReader _symbolReader;
+        private AutomatedAnalysisIssueCollection _issueCollection = new AutomatedAnalysisIssueCollection();
+
+        public AutomatedAnalysisManager(TraceLog traceLog, TextWriter textLog, SymbolReader symbolReader)
+        {
+            _traceLog = traceLog;
+            _textLog = textLog;
+            _symbolReader = symbolReader;
+        }
+        public void GenerateReport(TextWriter writer)
+        {
+            using (AutomatedAnalysisReportGenerator reportGenerator = new AutomatedAnalysisReportGenerator(writer))
+            {
+                List<AutomatedAnalysisRule> allRules = new List<AutomatedAnalysisRule>();
+                List<AutomatedAnalysisPerProcessRule> perProcessRules = new List<AutomatedAnalysisPerProcessRule>();
+
+                // Run global rules, deferring per-process rules.
+                AutomatedAnalysisExecutionContext executionContext = new AutomatedAnalysisExecutionContext(_traceLog, _textLog, _symbolReader, _issueCollection);
+                foreach (AutomatedAnalysisRule rule in AutomatedAnalysisRuleResolver.GetRules())
+                {
+                    // Create a list of all executed rules so that they can be written into the report.
+                    allRules.Add(rule);
+
+                    if (rule is AutomatedAnalysisPerProcessRule)
+                    {
+                        // Defer per-process rules.
+                        perProcessRules.Add((AutomatedAnalysisPerProcessRule)rule);
+                    }
+                    else
+                    {
+                        // Execute the rule.
+                        rule.RunRule(executionContext, null);
+                    }
+                }
+
+                // Run per-process rules.
+                foreach (TraceProcess process in executionContext.TraceLog.Processes)
+                {
+                    if (process.ManagedProcess())
+                    {
+                        // Create the process context.
+                        ProcessContext processContext = new ProcessContext(executionContext, process);
+
+                        foreach (AutomatedAnalysisPerProcessRule rule in perProcessRules)
+                        {
+                            rule.RunRule(executionContext, processContext);
+                        }
+                    }
+                }
+
+                // Write out issues.
+                foreach (KeyValuePair<TraceProcess, List<AutomatedAnalysisIssue>> pair in _issueCollection)
+                {
+                    if (pair.Value.Count > 0)
+                    {
+                        reportGenerator.WriteIssuesForProcess(pair.Key, pair.Value);
+                    }
+                }
+
+                // Write the list of executed rules.
+               reportGenerator.WriteExecutedRulesList(allRules);
+            }
+        }
+    }
+}

src/TraceEvent/AutomatedAnalysis/AutomatedAnalysisPerProcessRule.cs

@@ -0,0 +1,21 @@
+using System;
+using System.Collections.Generic;
+using Microsoft.Diagnostics.Tracing.Etlx;
+
+namespace Microsoft.Diagnostics.Tracing.AutomatedAnalysis
+{
+    public abstract class AutomatedAnalysisPerProcessRule : AutomatedAnalysisRule
+    {
+        protected abstract void Execute(AutomatedAnalysisExecutionContext executionContext, ProcessContext processContext);
+
+        internal override void RunRule(AutomatedAnalysisExecutionContext executionContext, ProcessContext processContext)
+        {
+            Execute(executionContext, processContext);
+        }
+
+        protected override void Execute(AutomatedAnalysisExecutionContext executionContext)
+        {
+            throw new InvalidOperationException();
+        }
+    }
+}

src/TraceEvent/AutomatedAnalysis/AutomatedAnalysisReportGenerator.cs

@@ -0,0 +1,74 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Microsoft.Diagnostics.Tracing.Etlx;
+
+namespace Microsoft.Diagnostics.Tracing.AutomatedAnalysis
+{
+    public sealed class AutomatedAnalysisReportGenerator : IDisposable
+    {
+        private TextWriter _writer;
+
+        public AutomatedAnalysisReportGenerator(TextWriter writer)
+        {
+            _writer = writer;
+            StartReport();
+        }
+
+        void IDisposable.Dispose()
+        {
+            EndReport();
+        }
+
+        private void StartReport()
+        {
+            _writer.WriteLine("<html>");
+            _writer.WriteLine("<head>");
+            _writer.WriteLine("<title>Automated CPU Analysis</title>");
+            _writer.WriteLine("<meta charset=\"UTF-8\"/>");
+            _writer.WriteLine("<meta http-equiv=\"X-UA-Compatible\" content=\"IE=edge\"/>");
+            _writer.WriteLine("</head>");
+            _writer.WriteLine("<body>");
+            _writer.WriteLine("<H2>Automated CPU Analysis</H2>");
+        }
+
+        private void EndReport()
+        {
+            _writer.WriteLine("</body>");
+            _writer.WriteLine("</html>");
+        }
+
+        public void WriteIssuesForProcess(TraceProcess process, List<AutomatedAnalysisIssue> issues)
+        {
+            _writer.WriteLine($"<H3>Process {process.ProcessID}: {process.CommandLine}</H3>");
+            _writer.WriteLine("<Table Border=\"1\">");
+            _writer.WriteLine("<TR><TH>Issue Title</TH><TH>Notes</TH></TR>");
+            foreach(AutomatedAnalysisIssue issue in issues)
+            {
+                _writer.WriteLine($"<TR><TD>{issue.Title}</TD><TD>{issue.Description}<BR/><BR/>More details: <A HREF=\"{issue.URL}\">{issue.URL}</A></TD></TR>");
+            }
+            _writer.WriteLine("</Table>");
+        }
+
+        public void WriteExecutedRulesList(List<AutomatedAnalysisRule> rules)
+        {
+            if(rules.Count > 0)
+            {
+                _writer.WriteLine("<H3>Rules Executed:</H3>");
+                _writer.WriteLine("<ul style=\"list-style-type:circle\">");
+                foreach (AutomatedAnalysisRule rule in rules)
+                {
+                    _writer.WriteLine($"<li>{rule.GetType().AssemblyQualifiedName}</li>");
+                }
+                _writer.WriteLine("</ul>");
+            }
+            else
+            {
+                _writer.WriteLine($"<H3>No rules were executed.  Check '{AutomatedAnalysisRuleResolver.RulesDirectory}' for DLLs containing rules.</H3>");
+            }
+        }
+    }
+}

src/TraceEvent/AutomatedAnalysis/AutomatedAnalysisRule.cs

@@ -0,0 +1,14 @@
+using System.Collections.Generic;
+
+namespace Microsoft.Diagnostics.Tracing.AutomatedAnalysis
+{
+    public abstract class AutomatedAnalysisRule
+    {
+        protected abstract void Execute(AutomatedAnalysisExecutionContext executionContext);
+
+        internal virtual void RunRule(AutomatedAnalysisExecutionContext executionContext, ProcessContext processContext)
+        {
+            Execute(executionContext);
+        }
+    }
+}