Stack view for Contention events (#2000)

* Stack view for Contention events

Metric is equal to the duration of contention in milliseconds
EventData DurationNs fake frame

* Include the same view for WaitHandleWait event

* Fixed some comments

* More fixes

* Fixed documentation and class names

Author: ezsilmar

.gitignore

@@ -205,3 +205,6 @@ OSExtensions.cs
 password.txt
 documentation/internal/
 *.userosscache
+
+# Rider
+.idea/

src/PerfView/PerfViewData.cs

@@ -37,6 +37,7 @@
 using System.Windows;
 using System.Windows.Media;
 using System.Xml;
+using Microsoft.Diagnostics.Tracing.Computers;
 using Microsoft.Diagnostics.Tracing.Parsers.Tpl;
 using Utilities;
 using Address = System.UInt64;
@@ -994,6 +995,19 @@ protected bool IsMyFormat(string fileName)
 
         private static Dictionary<string, PerfViewFile> s_internTable = new Dictionary<string, PerfViewFile>();
         #endregion
+
+        protected static void ConfigureStackWindowForStartStopThreadTime(StackWindow stackWindow)
+        {
+            var foldPats = StartStopLatencyComputer.GetDefaultFoldPatterns();
+            for (var i = 0; i < foldPats.Length; i++)
+            {
+                if (i == 0)
+                {
+                    stackWindow.FoldRegExTextBox.Text = foldPats[i];
+                }
+                stackWindow.FoldRegExTextBox.Items.Insert(0, foldPats[i]);
+            }
+        }
     }
 
     // Used for new user defined file formats.  
@@ -6289,6 +6303,28 @@ string GetAllocationType(CallStackIndex csi)
 
                 return stackSource;
             }
+            else if (streamName == "Contention")
+            {
+                var contentionSource = new MutableTraceEventStackSource(eventLog);
+                contentionSource.ShowUnknownAddresses = App.CommandLineArgs.ShowUnknownAddresses;
+                contentionSource.ShowOptimizationTiers = App.CommandLineArgs.ShowOptimizationTiers;
+
+                var computer = new ContentionLatencyComputer(eventLog, contentionSource);
+                computer.GenerateStacks();
+
+                return contentionSource;
+            }
+            else if (streamName == "WaitHandleWait")
+            {
+                var waitHandleWaitSource = new MutableTraceEventStackSource(eventLog);
+                waitHandleWaitSource.ShowUnknownAddresses = App.CommandLineArgs.ShowUnknownAddresses;
+                waitHandleWaitSource.ShowOptimizationTiers = App.CommandLineArgs.ShowOptimizationTiers;
+
+                var computer = new WaitHandleWaitLatencyComputer(eventLog, waitHandleWaitSource);
+                computer.GenerateStacks();
+
+                return waitHandleWaitSource;
+            }
             else
             {
                 throw new Exception("Unknown stream " + streamName);
@@ -7010,6 +7046,11 @@ protected internal override void ConfigureStackWindow(string stackSourceName, St
                 stackWindow.FoldRegExTextBox.Text = prev;
                 stackWindow.FoldRegExTextBox.Items.Insert(0, prev);
             }
+            
+            if (stackSourceName == "Contention" || stackSourceName == "WaitHandleWait")
+            {
+                ConfigureStackWindowForStartStopThreadTime(stackWindow);
+            }
 
             if (m_extraTopStats != null)
             {
@@ -7033,6 +7074,7 @@ protected internal override void ConfigureStackWindow(string stackSourceName, St
                 }
             }
         }
+
         public override bool SupportsProcesses { get { return true; } }
 
         /// <summary>
@@ -7160,6 +7202,8 @@ protected override Action<Action> OpenImpl(Window parentWindow, StatusBar worker
             bool hasAssemblyLoad = false;
             bool hasJIT = false;
             bool hasUserCrit = false;
+            bool hasContention = false;
+            bool hasWaitHandle = false;
 
             var stackEvents = new List<TraceEventCounts>();
             foreach (var counts in tracelog.Stats)
@@ -7237,6 +7281,16 @@ protected override Action<Action> OpenImpl(Window parentWindow, StatusBar worker
                     hasUserCrit = true;
                 }
 
+                if (name.StartsWith("Contention/Start"))
+                {
+                    hasContention = true;
+                }
+                
+                if (name.StartsWith("WaitHandleWait/Start"))
+                {
+                    hasWaitHandle = true;
+                }
+                
                 if (counts.StackCount > 0)
                 {
                     hasAnyStacks = true;
@@ -7495,6 +7549,16 @@ protected override Action<Action> OpenImpl(Window parentWindow, StatusBar worker
                 }
             }
 
+            if (hasContention)
+            {
+                advanced.Children.Add(new PerfViewStackSource(this, "Contention"));
+            }
+
+            if (hasWaitHandle)
+            {
+                advanced.Children.Add(new PerfViewStackSource(this, "WaitHandleWait"));
+            }
+            
             if (hasAnyStacks)
             {
                 advanced.Children.Add(new PerfViewStackSource(this, "Any"));
@@ -8920,6 +8984,8 @@ protected override Action<Action> OpenImpl(Window parentWindow, StatusBar worker
             bool hasMemAllocStacks = false;
             bool hasTypeLoad = false;
             bool hasAssemblyLoad = false;
+            bool hasContention = false;
+            bool hasWaitHandle = false;
             if (m_traceLog != null)
             {
                 foreach (TraceEventCounts eventStats in m_traceLog.Stats)
@@ -8961,6 +9027,14 @@ protected override Action<Action> OpenImpl(Window parentWindow, StatusBar worker
                     {
                         hasAssemblyLoad = true;
                     }
+                    else if (eventStats.EventName.StartsWith("Contention/Start"))
+                    {
+                        hasContention = true;
+                    }
+                    else if (eventStats.EventName.StartsWith("WaitHandleWait/Start"))
+                    {
+                        hasWaitHandle = true;
+                    }
                 }
             }
 
@@ -9012,6 +9086,16 @@ protected override Action<Action> OpenImpl(Window parentWindow, StatusBar worker
                 {
                     advanced.AddChild(new PerfViewRuntimeLoaderStats(this));
                 }
+
+                if (hasContention)
+                {
+                    advanced.AddChild(new PerfViewStackSource(this, "Contention"));
+                }
+
+                if (hasWaitHandle)
+                {
+                    advanced.AddChild(new PerfViewStackSource(this, "WaitHandleWait"));
+                }
             }
 
             if (memory.Children.Count > 0)
@@ -9144,6 +9228,36 @@ protected internal override StackSource OpenStackSourceImpl(string streamName, T
                         stackSource.DoneAddingSamples();
                         return stackSource;
                     }
+                case "Contention":
+                    {
+                        var eventLog = GetTraceLog(log);
+
+                        var contentionSource = new MutableTraceEventStackSource(eventLog);
+                        // EventPipe currently only has managed code stacks.
+                        contentionSource.OnlyManagedCodeStacks = true;
+                        contentionSource.ShowUnknownAddresses = App.CommandLineArgs.ShowUnknownAddresses;
+                        contentionSource.ShowOptimizationTiers = App.CommandLineArgs.ShowOptimizationTiers;
+
+                        var computer = new ContentionLatencyComputer(eventLog, contentionSource);
+                        computer.GenerateStacks();
+
+                        return contentionSource;
+                    }
+                case "WaitHandleWait":
+                    {
+                        var eventLog = GetTraceLog(log);
+
+                        var waitHandleWaitSource = new MutableTraceEventStackSource(eventLog);
+                        // EventPipe currently only has managed code stacks.
+                        waitHandleWaitSource.OnlyManagedCodeStacks = true;
+                        waitHandleWaitSource.ShowUnknownAddresses = App.CommandLineArgs.ShowUnknownAddresses;
+                        waitHandleWaitSource.ShowOptimizationTiers = App.CommandLineArgs.ShowOptimizationTiers;
+
+                        var computer = new WaitHandleWaitLatencyComputer(eventLog, waitHandleWaitSource);
+                        computer.GenerateStacks();
+
+                        return waitHandleWaitSource;
+                    }
                 case "Thread Time (with StartStop Activities)":
                     {
                         var eventLog = GetTraceLog(log);
@@ -9351,6 +9465,11 @@ protected internal override void ConfigureStackWindow(string stackSourceName, St
                 stackWindow.ComputeMaxInTopStats = true;
             }
 
+            if (stackSourceName == "Contention" || stackSourceName == "WaitHandleWait")
+            {
+                ConfigureStackWindowForStartStopThreadTime(stackWindow);
+            }
+            
             if (m_extraTopStats != null)
             {
                 stackWindow.ExtraTopStats += " " + m_extraTopStats;

src/PerfView/SupportFiles/UsersGuide.htm

@@ -2437,6 +2437,28 @@ <h2>
                             objects pinned because they are pointed to by a async pinned handle at the time of
                             the heap snapshot.
                         </li>
+                        <li>
+                            <strong><a id="ContentionStacks">Contention Stacks</a></strong> - This view aggregates Contention events.&nbsp;
+                            Contention event is fired when a thread tries to acquire a managed lock that is currently owned
+                            by another thread. Note that each event has useful event data that is folded by default.
+                            For example, unfolding <code>EventData DurationNs</code> reveals individual pauses of each thread: this can be useful 
+                            to correlate a particular long wait to another events in the trace. Note that not all contention events
+                            are real OS-level waits: the runtime may first spin wait to try acquire the lock fast. The metric
+                            represents the amount of time spent to acquire the lock in milliseconds.
+                        </li>
+                        <li>
+                            <strong><a id="WaitHandleWaitStacks">WaitHandleWait Stacks</a></strong> - This view is similar to <a href="#ContentionStacks">Contention Stacks</a>
+                            in a sense that it allows to diagnose the blocking waits. However, there are important differences.
+                            Contention events are emitted exclusively on <code>System.Threading.Monitor</code> and <code>System.Threading.Lock</code> code paths.
+                            WaitHandleWait events are lower level and fire when the OS-provided wait handle is used to block the thread execution.
+                            For example, WaitHandleWait will catch waiting inside <code>SemaphoreSlim.Wait()</code> while Contention event won't.
+                            WaitHandleWait can be fired alongside the Contention event: for instance, during <code>Monitor.Enter</code> if spin waiting
+                            was not enough to acquire the lock. Also note that WaitHandleWait is much more noisy: you'd need to clean up
+                            the stacks from "legit" waiting like a main thread waiting for application shutdown signal, or a consumer thread
+                            that waits for new items in a blocking channel. WaitHandleWait may not cover all waits in your application, like waits that
+                            bypass the dotnet runtime or waits on other synchronous OS APIs like a blocking write to a socket.
+                            For more details, refer to <a href="https://github.com/dotnet/runtime/pull/94737#discussion_r1409607825">this diagram</a> from the original PR.
+                        </li>
                         <li>
                             <strong><a id="AnyStacks">Any Stacks</a></strong> - This view shows
                             every event that has a stack.&nbsp; It is useful when none of the more specialized