Remove non-functioning StartStopMingledComputer in favor of better factored stats page

davidwrighton · davidwrighton · commit b669d1beb72a · 2020-08-11T18:31:31.000-07:00
diff --git a/src/PerfView/PerfViewData.cs b/src/PerfView/PerfViewData.cs
@@ -3564,9 +3564,7 @@ protected override void WriteHtmlBody(TraceLog dataFile, TextWriter writer, stri
             using (var source = dataFile.Events.GetSource())
             {
                 CLRRuntimeActivityComputer runtimeLoaderComputer = new CLRRuntimeActivityComputer(source);
-                var stackSource = new MutableTraceEventStackSource(source.TraceLog);
-                StartStopStackMingledComputer mingledComputer = new StartStopStackMingledComputer(stackSource, null, true, source, runtimeLoaderComputer.StartStopEvents);
-                m_PerThreadData = mingledComputer.StartStopData;
+                m_PerThreadData = runtimeLoaderComputer.StartStopData;
                 m_interestingProcesses = new Dictionary<int, Microsoft.Diagnostics.Tracing.Analysis.TraceProcess>();
 
                 Microsoft.Diagnostics.Tracing.Analysis.TraceLoadedDotNetRuntimeExtensions.NeedLoadedDotNetRuntimes(source);
@@ -4371,10 +4369,6 @@ protected internal override StackSource OpenStackSourceImpl(string streamName, T
             {
                 return eventLog.ThreadTimeStacks();
             }
-            else if (streamName == "Runtime Loader (CPU Time)")
-            {
-                return eventLog.RuntimeLoaderStacks();
-            }
             else if (streamName == "Processes / Files / Registry")
             {
                 return GetProcessFileRegistryStackSource(eventSource, log);
diff --git a/src/PerfView/RuntimeLoaderStats.cs b/src/PerfView/RuntimeLoaderStats.cs
@@ -99,7 +99,7 @@ public static void ToTxt(string filePath, TraceProcess process, Microsoft.Diagno
 
 
                             writer.Write($"{startTime.ToString("F3").PadLeft(12)}~{inclusiveTimeStr.PadLeft(9)}~{exclusiveTime.ToString("F3").PadLeft(9)}~");
-                            int stackDepth = CountStackDepth(runtimeOps, eventData) - 3;
+                            int stackDepth = eventData.StackDepth;
                             for (int iStackDepth = 0; iStackDepth < stackDepth; iStackDepth++)
                                 writer.Write(" |");
 
@@ -108,7 +108,7 @@ public static void ToTxt(string filePath, TraceProcess process, Microsoft.Diagno
                             else
                                 writer.Write("--");
 
-                            writer.WriteLine(runtimeOps.StackSource.GetFrameName(eventData.NameFrame, false));
+                            writer.WriteLine(eventData.Name, false);
                             seenEvents.Add(eventData.End.EventId);
                         }
                     }
@@ -151,18 +151,5 @@ public static double TotalCPUMSec(Microsoft.Diagnostics.Tracing.Analysis.TracePr
 
             return cpuTime;
         }
-
-        private static int CountStackDepth(Microsoft.Diagnostics.Tracing.RuntimeLoaderStats runtimeOps, StartStopStackMingledComputer.StartStopThreadEventData data)
-        {
-            var currentStack = data.OutputStacks.ReplacementStack;
-            int depthCount = 0;
-
-            for (;currentStack != StackSourceCallStackIndex.Invalid; currentStack = runtimeOps.StackSource.GetCallerIndex(currentStack))
-            {
-                depthCount++;
-            }
-
-            return depthCount;
-        }
     }
 }
diff --git a/src/PerfView/UserCommands.cs b/src/PerfView/UserCommands.cs
@@ -1874,38 +1874,6 @@ public static MutableTraceEventStackSource ThreadTimeStacks(this TraceLog eventL
         return stackSource;
     }
 
-    public static StackSource RuntimeLoaderStacks(this TraceLog eventLog, TraceProcess process = null, Predicate<TraceEvent> predicate = null)
-    {
-        TraceEvents events;
-        if (process == null)
-        {
-            events = eventLog.Events.Filter((x) => ((predicate == null) || predicate(x)) && x is SampledProfileTraceData && x.ProcessID != 0);
-        }
-        else
-        {
-            events = process.EventsInProcess.Filter((x) => ((predicate == null) || predicate(x)) && x is SampledProfileTraceData);
-        }
-
-        var stackSource = new MutableTraceEventStackSource(eventLog);
-        stackSource.ShowUnknownAddresses = App.CommandLineArgs.ShowUnknownAddresses;
-
-        StackSourceSample sample = new StackSourceSample(stackSource);
-        foreach (var event_ in ((IEnumerable<TraceEvent>)events))
-        {
-            sample.TimeRelativeMSec = event_.TimeStampRelativeMSec;
-            sample.StackIndex = stackSource.GetCallStack(event_.CallStackIndex(), event_);
-            stackSource.AddSample(sample);
-        };
-        stackSource.DoneAddingSamples();
-
-        CLRRuntimeActivityComputer runtimeLoaderComputer = new CLRRuntimeActivityComputer(eventLog.Events.GetSource());
-
-        var finalStackSource = new MutableTraceEventStackSource(eventLog);
-        StartStopStackMingledComputer mingledComputer = new StartStopStackMingledComputer(finalStackSource, stackSource, false, eventLog.Events.GetSource(), runtimeLoaderComputer.StartStopEvents);
-
-        return CopyStackSource.Clone(finalStackSource);
-    }
-
     public static MutableTraceEventStackSource ThreadTimeWithReadyThreadStacks(this TraceLog eventLog, TraceProcess process = null)
     {
         var stackSource = new MutableTraceEventStackSource(eventLog);
diff --git a/src/TraceEvent/Computers/CLRRuntimeActivityComputer.cs b/src/TraceEvent/Computers/CLRRuntimeActivityComputer.cs
@@ -20,8 +20,76 @@
 
 namespace Microsoft.Diagnostics.Tracing
 {
+    public class RuntimeLoaderStats : Dictionary<int, CLRRuntimeActivityComputer.PerThreadStartStopData>
+    {
+        public TraceLogEventSource EventSource;
+    }
+
+
     public class CLRRuntimeActivityComputer
     {
+        public struct EventUID : IComparable<EventUID>, IEquatable<EventUID>
+        {
+            public EventUID(TraceEvent evt) : this(evt.EventIndex, evt.TimeStampRelativeMSec) { }
+
+            public EventUID(EventIndex eventId, double time)
+            {
+                EventId = eventId;
+                Time = time;
+            }
+
+            public readonly EventIndex EventId;
+            public readonly double Time;
+
+            public int CompareTo(EventUID other)
+            {
+                int timeCompare = Time.CompareTo(other.Time);
+                if (timeCompare != 0)
+                    return timeCompare;
+
+                return EventId.CompareTo(other.EventId);
+            }
+
+            public override int GetHashCode()
+            {
+                return (int)EventId;
+            }
+
+            public override bool Equals(object obj)
+            {
+                if (!(obj is EventUID))
+                    return false;
+                return this.CompareTo((EventUID)obj) == 0;
+            }
+
+            public bool Equals(EventUID other)
+            {
+                return this.CompareTo(other) == 0;
+            }
+        }
+
+        public struct StartStopThreadEventData : IComparable<StartStopThreadEventData>
+        {
+            public StartStopThreadEventData(EventUID start, EventUID end, string name)
+            {
+                Start = start;
+                End = end;
+                Name = name;
+                StackDepth = 0;
+            }
+
+            public EventUID Start;
+            public EventUID End;
+            public int StackDepth;
+            public string Name;
+
+            int IComparable<StartStopThreadEventData>.CompareTo(StartStopThreadEventData other)
+            {
+                return Start.CompareTo(other.Start);
+            }
+        }
+
+
         struct IdOfIncompleteAction : IEquatable<IdOfIncompleteAction>
         {
             public long Identifier;
@@ -48,19 +116,32 @@ public bool Equals(IdOfIncompleteAction other)
 
         struct IncompleteActionDesc
         {
-            public StartStopStackMingledComputer.EventUID Start;
+            public EventUID Start;
             public string OperationType;
             public string Name;
         }
 
+        public class PerThreadStartStopData
+        {
+            public int Offset;
+
+            public StartStopThreadEventData[] Data;
+            public StartStopThreadEventData[] SplitUpData;
+            public double[] SplitUpDataStarts;
+        }
+
+        RuntimeLoaderStats _startStopData = new RuntimeLoaderStats();
+        public RuntimeLoaderStats StartStopData => _startStopData;
+
         Dictionary<IdOfIncompleteAction, IncompleteActionDesc> _incompleteJitEvents = new Dictionary<IdOfIncompleteAction, IncompleteActionDesc>();
         Dictionary<IdOfIncompleteAction, IncompleteActionDesc> _incompleteR2REvents = new Dictionary<IdOfIncompleteAction, IncompleteActionDesc>();
         Dictionary<IdOfIncompleteAction, IncompleteActionDesc> _incompleteTypeLoadEvents = new Dictionary<IdOfIncompleteAction, IncompleteActionDesc>();
 
-        public Dictionary<int, List<StartStopStackMingledComputer.StartStopThreadEventData>> StartStopEvents { get; } = new Dictionary<int, List<StartStopStackMingledComputer.StartStopThreadEventData>>();
+        public Dictionary<int, List<StartStopThreadEventData>> StartStopEvents { get; } = new Dictionary<int, List<StartStopThreadEventData>>();
 
         public CLRRuntimeActivityComputer(TraceLogEventSource source)
         {
+            _startStopData.EventSource = source;
             source.Clr.MethodJittingStarted += Clr_MethodJittingStarted;
             source.Clr.MethodR2RGetEntryPoint += Clr_MethodR2RGetEntryPoint;
             source.Clr.MethodLoadVerbose += Clr_MethodLoadVerbose;
@@ -78,21 +159,74 @@ public CLRRuntimeActivityComputer(TraceLogEventSource source)
             source.Clr.LoaderAssemblyLoad -= Clr_LoaderAssemblyLoad;
             source.Clr.TypeLoadStart -= Clr_TypeLoadStart;
             source.Clr.TypeLoadStop -= Clr_TypeLoadStop;
+
+            HashSet<EventUID> interestingEvents = new HashSet<EventUID>();
+            foreach (var entry in StartStopEvents)
+            {
+                StartStopThreadEventData[] data = entry.Value.ToArray();
+                Array.Sort(data);
+                PerThreadStartStopData perThread = new PerThreadStartStopData();
+                perThread.Data = data;
+                for (int i = 0; i < data.Length; i++)
+                {
+                    interestingEvents.Add(data[i].Start);
+                    interestingEvents.Add(data[i].End);
+                }
+                _startStopData.Add(entry.Key, perThread);
+            }
+
+            foreach (var entry in _startStopData)
+            {
+                List<StartStopThreadEventData> splitUpStartStopData = new List<StartStopThreadEventData>();
+
+                Stack<StartStopThreadEventData> currentPerThreadProcessingState = new Stack<StartStopThreadEventData>();
+                for (int i = 0; i < entry.Value.Data.Length; i++)
+                {
+                    var startStop = entry.Value.Data[i];
+
+                    if (currentPerThreadProcessingState.Count > 0)
+                    {
+                        while ((currentPerThreadProcessingState.Count > 0) && (currentPerThreadProcessingState.Peek().End.CompareTo(startStop.Start) < 0))
+                        {
+                            // Current stack top event finished before this event happened.
+                            var poppedEvent = currentPerThreadProcessingState.Pop();
+                            EventUID lastEventProcessedEnd = poppedEvent.End;
+                            if (currentPerThreadProcessingState.Count > 0)
+                            {
+                                var tempPoppedEvent = currentPerThreadProcessingState.Pop();
+                                tempPoppedEvent.Start = lastEventProcessedEnd;
+                                splitUpStartStopData.Add(tempPoppedEvent);
+                                currentPerThreadProcessingState.Push(tempPoppedEvent);
+                            }
+                        }
+                    }
+
+                    startStop.StackDepth = currentPerThreadProcessingState.Count;
+                    splitUpStartStopData.Add(startStop);
+                    currentPerThreadProcessingState.Push(startStop);
+                }
+                entry.Value.SplitUpData = splitUpStartStopData.ToArray();
+                entry.Value.SplitUpDataStarts = new double[entry.Value.SplitUpData.Length];
+                for (int i = 0; i < entry.Value.SplitUpDataStarts.Length; i++)
+                {
+                    entry.Value.SplitUpDataStarts[i] = entry.Value.SplitUpData[i].Start.Time;
+                }
+            }
         }
 
-        private void AddStartStopData(int threadId, StartStopStackMingledComputer.EventUID start, StartStopStackMingledComputer.EventUID end, string name)
+        private void AddStartStopData(int threadId, EventUID start, EventUID end, string name)
         {
             if (!StartStopEvents.ContainsKey(threadId))
-                StartStopEvents[threadId] = new List<StartStopStackMingledComputer.StartStopThreadEventData>();
+                StartStopEvents[threadId] = new List<StartStopThreadEventData>();
 
-            List<StartStopStackMingledComputer.StartStopThreadEventData> startStopData = StartStopEvents[threadId];
-            startStopData.Add(new StartStopStackMingledComputer.StartStopThreadEventData(start, end, name));
+            List<StartStopThreadEventData> startStopData = StartStopEvents[threadId];
+            startStopData.Add(new StartStopThreadEventData(start, end, name));
         }
 
         private void Clr_LoaderAssemblyLoad(AssemblyLoadUnloadTraceData obj)
         {
             // Since we don't have start stop data, simply treat the assembly load event as a point in time so that it is visible in the textual load view
-            StartStopStackMingledComputer.EventUID eventTime = new StartStopStackMingledComputer.EventUID(obj);
+            EventUID eventTime = new EventUID(obj);
             AddStartStopData(obj.ThreadID, eventTime, eventTime, $"ASMLOAD({obj.FullyQualifiedAssemblyName},{obj.AssemblyID})");
         }
 
@@ -116,14 +250,14 @@ private void MethodJittedEvent(TraceEvent evt, long methodID)
                 // JitStart is processed, don't process it again.
                 _incompleteJitEvents.Remove(id);
 
-                AddStartStopData(id.ThreadID, jitStartData.Start, new StartStopStackMingledComputer.EventUID(evt), jitStartData.OperationType + "(" + jitStartData.Name + ")");
+                AddStartStopData(id.ThreadID, jitStartData.Start, new EventUID(evt), jitStartData.OperationType + "(" + jitStartData.Name + ")");
             }
         }
 
         private void Clr_MethodJittingStarted(MethodJittingStartedTraceData obj)
         {
             IncompleteActionDesc incompleteDesc = new IncompleteActionDesc();
-            incompleteDesc.Start = new StartStopStackMingledComputer.EventUID(obj);
+            incompleteDesc.Start = new EventUID(obj);
             incompleteDesc.Name = JITStats.GetMethodName(obj);
             incompleteDesc.OperationType = "JIT";
 
@@ -137,7 +271,7 @@ private void Clr_MethodJittingStarted(MethodJittingStartedTraceData obj)
         private void Clr_R2RGetEntryPointStarted(R2RGetEntryPointStartedTraceData obj)
         {
             IncompleteActionDesc incompleteDesc = new IncompleteActionDesc();
-            incompleteDesc.Start = new StartStopStackMingledComputer.EventUID(obj);
+            incompleteDesc.Start = new EventUID(obj);
             incompleteDesc.Name = "";
             incompleteDesc.OperationType = "R2R";
 
@@ -156,7 +290,7 @@ private void Clr_MethodR2RGetEntryPoint(R2RGetEntryPointTraceData obj)
 
             // If we had a R2R start lookup event, capture that start time, otherwise, use the R2REntrypoint
             // data as both start and stop
-            StartStopStackMingledComputer.EventUID startUID = new StartStopStackMingledComputer.EventUID(obj);
+            EventUID startUID = new EventUID(obj);
             if (_incompleteR2REvents.TryGetValue(id, out IncompleteActionDesc r2rStartData))
             {
                 startUID = r2rStartData.Start;
@@ -166,18 +300,18 @@ private void Clr_MethodR2RGetEntryPoint(R2RGetEntryPointTraceData obj)
             if (obj.EntryPoint == 0)
             {
                 // If Entrypoint is null then the search failed.
-                AddStartStopData(id.ThreadID, startUID, new StartStopStackMingledComputer.EventUID(obj), "R2R_Failed" + "(" + JITStats.GetMethodName(obj) + ")");
+                AddStartStopData(id.ThreadID, startUID, new EventUID(obj), "R2R_Failed" + "(" + JITStats.GetMethodName(obj) + ")");
             }
             else
             {
-                AddStartStopData(id.ThreadID, startUID, new StartStopStackMingledComputer.EventUID(obj), "R2R_Found" + "(" + JITStats.GetMethodName(obj) + ")");
+                AddStartStopData(id.ThreadID, startUID, new EventUID(obj), "R2R_Found" + "(" + JITStats.GetMethodName(obj) + ")");
             }
         }
 
         private void Clr_TypeLoadStart(TypeLoadStartTraceData obj)
         {
             IncompleteActionDesc incompleteDesc = new IncompleteActionDesc();
-            incompleteDesc.Start = new StartStopStackMingledComputer.EventUID(obj);
+            incompleteDesc.Start = new EventUID(obj);
             incompleteDesc.Name = "";
             incompleteDesc.OperationType = "TypeLoad";
 
@@ -196,14 +330,14 @@ private void Clr_TypeLoadStop(TypeLoadStopTraceData obj)
 
             // If we had a TypeLoad start lookup event, capture that start time, otherwise, use the TypeLoadStop
             // data as both start and stop
-            StartStopStackMingledComputer.EventUID startUID = new StartStopStackMingledComputer.EventUID(obj);
+            EventUID startUID = new EventUID(obj);
             if (_incompleteTypeLoadEvents.TryGetValue(id, out IncompleteActionDesc typeLoadStartData))
             {
                 startUID = typeLoadStartData.Start;
                 _incompleteTypeLoadEvents.Remove(id);
             }
 
-            AddStartStopData(id.ThreadID, startUID, new StartStopStackMingledComputer.EventUID(obj), $"TypeLoad ({obj.TypeName}, {obj.LoadLevel})");
+            AddStartStopData(id.ThreadID, startUID, new EventUID(obj), $"TypeLoad ({obj.TypeName}, {obj.LoadLevel})");
         }
     }
 }
diff --git a/src/TraceEvent/Computers/StartStopStackMingledComputer.cs b/src/TraceEvent/Computers/StartStopStackMingledComputer.cs

Original file line number	Diff line number	Diff line change
`@@ -3564,9 +3564,7 @@ protected override void WriteHtmlBody(TraceLog dataFile, TextWriter writer, stri`
`3564`	`3564`	`using (var source = dataFile.Events.GetSource())`
`3565`	`3565`	`{`
`3566`	`3566`	`CLRRuntimeActivityComputer runtimeLoaderComputer = new CLRRuntimeActivityComputer(source);`
`3567`		`- var stackSource = new MutableTraceEventStackSource(source.TraceLog);`
`3568`		`- StartStopStackMingledComputer mingledComputer = new StartStopStackMingledComputer(stackSource, null, true, source, runtimeLoaderComputer.StartStopEvents);`
`3569`		`- m_PerThreadData = mingledComputer.StartStopData;`
	`3567`	`+ m_PerThreadData = runtimeLoaderComputer.StartStopData;`
`3570`	`3568`	`m_interestingProcesses = new Dictionary<int, Microsoft.Diagnostics.Tracing.Analysis.TraceProcess>();`
`3571`	`3569`
`3572`	`3570`	`Microsoft.Diagnostics.Tracing.Analysis.TraceLoadedDotNetRuntimeExtensions.NeedLoadedDotNetRuntimes(source);`
`@@ -4371,10 +4369,6 @@ protected internal override StackSource OpenStackSourceImpl(string streamName, T`
`4371`	`4369`	`{`
`4372`	`4370`	`return eventLog.ThreadTimeStacks();`
`4373`	`4371`	`}`
`4374`		`- else if (streamName == "Runtime Loader (CPU Time)")`
`4375`		`- {`
`4376`		`- return eventLog.RuntimeLoaderStacks();`
`4377`		`- }`
`4378`	`4372`	`else if (streamName == "Processes / Files / Registry")`
`4379`	`4373`	`{`
`4380`	`4374`	`return GetProcessFileRegistryStackSource(eventSource, log);`