fix stale session state when loading a second (new) trace via file>open

src/ProfileExplorerCore/Profile/Data/RawProfileData.cs

@@ -26,6 +26,15 @@ public class RawProfileData : IDisposable {
   private static ProfileImage lastIpImage_;
   [ThreadStatic]
   private static IpToImageCache globalIpImageCache_;
+
+  /// <summary>
+  /// Clears thread-local caches on the current thread
+  /// </summary>
+  public static void ClearThreadLocalCaches() {
+    ipImageCache_ = null;
+    lastIpImage_ = null;
+    globalIpImageCache_ = null;
+  }
   [ProtoMember(1)]
   private List<ProfileSample> samples_;
   [ProtoMember(2)]

src/ProfileExplorerCore/Profile/Data/ResolvedProfileStack.cs

@@ -86,6 +86,16 @@ public sealed class ResolvedProfileStack {
   public static ConcurrentDictionary<long, ResolvedProfileStackFrame> frameInstances_ = new();
   public static ConcurrentDictionary<long, ResolvedProfileStackFrame> kernelFrameInstances_ = new();
 
+  /// <summary>
+  /// Clears all static frame caches. Must be called before processing a new trace
+  /// to prevent stale frame references from a previous session.
+  /// </summary>
+  public static void ResetCaches() {
+    uniqueFrames_.Clear();
+    frameInstances_.Clear();
+    kernelFrameInstances_.Clear();
+  }
+
   public ResolvedProfileStack(int frameCount, ProfileContext context) {
     StackFrames = new List<ResolvedProfileStackFrame>(frameCount);
     Context = context;

src/ProfileExplorerCore/Profile/ETW/ETWProfileDataProvider.cs

@@ -69,6 +69,10 @@ public ETWProfileDataProvider() {
     for (int i = 0; i < imageLocks_.Length; i++) {
       imageLocks_[i] = new object();
     }
+
+    // Clear static caches from any previous trace load to prevent
+    // stale frame/function references leaking across sessions.
+    ResolvedProfileStack.ResetCaches();
   }
 
   public static async Task<List<ProcessSummary>>
@@ -425,6 +429,12 @@ private void CollectChunkSamples(List<Task<List<(ProfileSample Sample, ResolvedP
                         SymbolFileSourceSettings symbolSettings,
                         ProfileLoadProgressHandler progressCallback,
                         CancelableTask cancelableTask, int chunks) {
+
+    // Clear thread-local caches to prevent stale data from previous trace loads
+    prevImage_ = null;
+    prevProfileModuleBuilder_ = null;
+    RawProfileData.ClearThreadLocalCaches();
+
     var totalWeight = TimeSpan.Zero;
     var profileWeight = TimeSpan.Zero;
     var samples = new List<(ProfileSample Sample, ResolvedProfileStack Stack)>(end - start + 1);

src/ProfileExplorerUI/MainWindowPanels.cs

@@ -1032,10 +1032,13 @@ private async Task SetupSectionPanel() {
       SectionPanel.CompilerInfo = compilerInfo_;
       SectionPanel.Session = this;
 
+      // Clear stale module summaries from any previous session
+      // before adding the new ones.
+      SectionPanel.ClearModuleSummaries();
+
       foreach (var doc in sessionState_.Documents) {
         if (doc != sessionState_.MainDocument &&
             doc != sessionState_.DiffDocument) {
-          // Add optional modules, usually used for profiling.
           SectionPanel.AddModuleSummary(doc.Summary);
         }
       }

src/ProfileExplorerUI/Panels/SectionPanel.xaml.cs

@@ -1252,6 +1252,11 @@ public void AddModuleSummary(IRTextSummary summary) {
     }
   }
 
+  public void ClearModuleSummaries() {
+    moduleSummaries_.Clear();
+    sectionExtensionComputed_ = false;
+  }
+
   public bool HasSummary(IRTextSummary summary) {
     return summary == summary_ ||
            moduleSummaries_.Contains(summary);

src/ProfileExplorerUI/Panels/SectionPanelPair.xaml.cs

@@ -151,6 +151,10 @@ public void AddModuleSummary(IRTextSummary summary) {
     MainPanel.AddModuleSummary(summary);
   }
 
+  public void ClearModuleSummaries() {
+    MainPanel.ClearModuleSummaries();
+  }
+
   public async Task RefreshDocumentsDiffs() {
     if (MainPanel.CurrentFunction == null) {
       return;