Remove temporary artifacts from previous GFXR replays so that data shown in UI is consistent

angela28chen · angela28chen · commit 0a8d396c878c · 2025-09-18T15:35:18.000-04:00
diff --git a/ui/analyze_window.cpp b/ui/analyze_window.cpp
@@ -142,6 +142,15 @@ AnalyzeDialog::AnalyzeDialog(QWidget *parent)
     m_frame_count_layout->addWidget(m_frame_count_label);
     m_frame_count_layout->addWidget(m_frame_count_box);
 
+    // Replay Warning
+    m_replay_warning_layout = new QHBoxLayout();
+    m_replay_warning_label = new QLabel(tr("WARNING: Initiating replay will clear any temporary "
+                                           "artifacts produced by previous replays. Please save "
+                                           "them manually in a different folder before proceeding, "
+                                           "if those artifacts are desired."));
+    m_replay_warning_label->setWordWrap(true);
+    m_replay_warning_layout->addWidget(m_replay_warning_label);
+
     // Left Panel Layout
     m_left_panel_layout = new QVBoxLayout();
     m_left_panel_layout->addWidget(m_settings_list_label);
@@ -158,6 +167,7 @@ AnalyzeDialog::AnalyzeDialog(QWidget *parent)
     m_right_panel_layout->addLayout(m_dump_pm4_layout);
     m_right_panel_layout->addLayout(m_gpu_time_layout);
     m_right_panel_layout->addLayout(m_frame_count_layout);
+    m_right_panel_layout->addLayout(m_replay_warning_layout);
     m_right_panel_layout->addLayout(m_button_layout);
 
     // Main Layout
@@ -550,34 +560,17 @@ void AnalyzeDialog::SetReplayButton(const std::string &message, bool is_enabled)
     QApplication::processEvents();
 }
 
-void AnalyzeDialog::UpdatePerfTabView(const std::string remote_file_name)
-{
-    QString directory = m_capture_file_directory.value().c_str();
-
-    // Get the original filename from the remote path
-    QFileInfo original_file_info(QString::fromStdString(remote_file_name));
-    QString   file_name = original_file_info.completeBaseName() + Dive::kProfilingMetricsCsvSuffix;
-
-    // Construct the new full path.
-    QString     full_path = QDir(directory).filePath(file_name);
-    std::string output_path = full_path.toStdString();
-
-    emit OnDisplayPerfCounterResults(output_path.c_str());
-}
-
-void AnalyzeDialog::UpdateGpuTimingTabView(const std::string remote_file_name)
+std::filesystem::path AnalyzeDialog::GetFullLocalPath(const std::string &gfxr_stem,
+                                                      const std::string &suffix) const
 {
-    QString directory = m_capture_file_directory.value().c_str();
-
-    // Get the original filename from the original remote path
-    QFileInfo original_file_info(QString::fromStdString(remote_file_name));
-    QString   file_name = original_file_info.completeBaseName() + Dive::kGpuTimingCsvSuffix;
-
-    // Construct the new full path.
-    QString     full_path = QDir(directory).filePath(file_name);
-    std::string output_path = full_path.toStdString();
+    if (!m_local_capture_file_directory.ok())
+    {
+        return "";
+    }
 
-    emit OnDisplayGpuTimingResults(output_path.c_str());
+    std::filesystem::path full_path = m_local_capture_file_directory.value();
+    full_path /= (gfxr_stem + suffix);
+    return full_path;
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -599,7 +592,7 @@ absl::Status AnalyzeDialog::Pm4Replay(Dive::DeviceManager &device_manager,
     return device_manager.RunReplayApk(remote_gfxr_file,
                                        replay_args,
                                        m_dump_pm4_enabled,
-                                       m_capture_file_directory.value());
+                                       m_local_capture_file_directory.value());
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -610,7 +603,7 @@ absl::Status AnalyzeDialog::PerfCounterReplay(Dive::DeviceManager &device_manage
 
     return device_manager.RunProfilingOnReplay(remote_gfxr_file,
                                                *m_enabled_settings_vector,
-                                               m_capture_file_directory.value());
+                                               m_local_capture_file_directory.value());
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -624,7 +617,7 @@ absl::Status AnalyzeDialog::GpuTimeReplay(Dive::DeviceManager &device_manager,
     return device_manager.RunReplayApk(remote_gfxr_file,
                                        replay_args,
                                        false,
-                                       m_capture_file_directory.value());
+                                       m_local_capture_file_directory.value());
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -690,17 +683,41 @@ void AnalyzeDialog::OnReplay()
     }
 
     // Set the download directory to the directory of the current capture file
-    m_capture_file_directory = GetCaptureFileDirectory();
-    if (!m_capture_file_directory.ok())
+    m_local_capture_file_directory = GetCaptureFileDirectory();
+    if (!m_local_capture_file_directory.ok())
     {
         std::string err_msg = absl::StrCat("Failed to set download directory: ",
-                                           m_capture_file_directory.status().message());
+                                           m_local_capture_file_directory.status().message());
         qDebug() << err_msg.c_str();
         ShowErrorMessage(err_msg);
         SetReplayButton(kDefaultReplayButtonText, true);
         return;
     }
 
+    // Delete any temporary artifacts from previous runs (.rd, .csv, etc)
+    std::filesystem::path gfxr_filename_stem = std::filesystem::path(remote_file.value()).stem();
+    std::filesystem::path perf_counter_csv = GetFullLocalPath(gfxr_filename_stem.string(),
+                                                              Dive::kProfilingMetricsCsvSuffix);
+    std::filesystem::path gpu_timing_csv = GetFullLocalPath(gfxr_filename_stem.string(),
+                                                            Dive::kGpuTimingCsvSuffix);
+    qDebug() << "Attempting to delete temporary artifacts from previous runs...";
+    if (std::filesystem::remove(perf_counter_csv))
+    {
+        qDebug() << "Successfully deleted: " << perf_counter_csv.string().c_str();
+    }
+    else
+    {
+        qDebug() << "Was not present: " << perf_counter_csv.string().c_str();
+    }
+    if (std::filesystem::remove(gpu_timing_csv))
+    {
+        qDebug() << "Successfully deleted: " << gpu_timing_csv.string().c_str();
+    }
+    else
+    {
+        qDebug() << "Was not present: " << gpu_timing_csv.string().c_str();
+    }
+
     // Get the enabled settings
     m_dump_pm4_enabled = m_dump_pm4_box->currentIndex() == 0;
     m_gpu_time_enabled = m_gpu_time_box->currentIndex() == 0;
@@ -740,12 +757,18 @@ void AnalyzeDialog::OnReplay()
             SetReplayButton(kDefaultReplayButtonText, true);
             return;
         }
-
-        UpdatePerfTabView(remote_file.value());
         WaitForReplay(*device);
+        qDebug() << "Loading perf counter data: " << perf_counter_csv.string().c_str();
+        emit OnDisplayPerfCounterResults(QString::fromStdString(perf_counter_csv.string()));
+    }
+    else
+    {
+        qDebug() << "Cleared perf counter data";
+        emit OnDisplayPerfCounterResults("");
     }
 
     // Run the gpu_time replay
+    std::string gpu_time_csv_stem = "";
     if (m_gpu_time_enabled)
     {
         ret = GpuTimeReplay(device_manager, remote_file.value());
@@ -757,8 +780,14 @@ void AnalyzeDialog::OnReplay()
             SetReplayButton(kDefaultReplayButtonText, true);
             return;
         }
-        UpdateGpuTimingTabView(remote_file.value());
         WaitForReplay(*device);
+        qDebug() << "Loading gpu timing data: " << perf_counter_csv.string().c_str();
+        emit OnDisplayGpuTimingResults(QString::fromStdString(gpu_timing_csv.string()));
+    }
+    else
+    {
+        qDebug() << "Cleared gpu timing data";
+        emit OnDisplayGpuTimingResults("");
     }
 
     SetReplayButton(kDefaultReplayButtonText, true);
diff --git a/ui/analyze_window.h b/ui/analyze_window.h
@@ -73,8 +73,8 @@ private slots:
     void                        SetReplayButton(const std::string &message, bool is_enabled);
     void                        PopulateSettings();
     void                        UpdateSelectedSettingsList();
-    void                        UpdatePerfTabView(const std::string remote_file_name);
-    void                        UpdateGpuTimingTabView(const std::string remote_file_name);
+    std::filesystem::path       GetFullLocalPath(const std::string &gfxr_stem,
+                                                 const std::string &suffix) const;
     void                        WaitForReplay(Dive::AndroidDevice &device);
     absl::StatusOr<std::string> GetCaptureFileDirectory();
     absl::StatusOr<std::string> GetAssetFile();
@@ -122,6 +122,9 @@ private slots:
     QLabel      *m_frame_count_label;
     QSpinBox    *m_frame_count_box;
 
+    QHBoxLayout *m_replay_warning_layout;
+    QLabel      *m_replay_warning_label;
+
     QHBoxLayout *m_button_layout;
     QPushButton *m_load_settings_button;
     QPushButton *m_replay_button;
@@ -139,7 +142,7 @@ private slots:
     const int                   kDataRole = Qt::UserRole + 1;
     const int                   kDefaultFrameCount = 3;
     const std::string           kDefaultReplayButtonText = "Replay";
-    absl::StatusOr<std::string> m_capture_file_directory = "";
+    absl::StatusOr<std::string> m_local_capture_file_directory = "";
 
     bool m_dump_pm4_enabled;
     bool m_gpu_time_enabled;
diff --git a/ui/gpu_timing_model.cpp b/ui/gpu_timing_model.cpp
@@ -29,6 +29,13 @@ void GpuTimingModel::OnGpuTimingResultsGenerated(const QString &file_path)
     emit beginResetModel();
     m_available_gpu_timing_data = {};  // Need to create a new AvailableGpuTiming object because it
                                        // can only be loaded once
+
+    if (file_path.size() == 0)
+    {
+        emit endResetModel();
+        return;
+    }
+
     ParseCsv(file_path);
     emit endResetModel();
 }
diff --git a/ui/main_window.cpp b/ui/main_window.cpp
@@ -1066,6 +1066,11 @@ bool MainWindow::LoadFile(const std::string &file_name, bool is_temp_file)
             QString::fromStdWString(perf_counter_file_path.wstring()));
             qDebug() << "Loaded: " << perf_counter_file_path.string().c_str();
         }
+        else
+        {
+            m_perf_counter_model->OnPerfCounterResultsGenerated("");
+            qDebug() << "Failed to find perf counter data";
+        }
 
         // Check if there is existing gpu timing data
         qDebug() << "Attempting to load gpu timing data from: "
@@ -1076,6 +1081,11 @@ bool MainWindow::LoadFile(const std::string &file_name, bool is_temp_file)
             QString::fromStdWString(gpu_time_file_path.wstring()));
             qDebug() << "Loaded: " << gpu_time_file_path.string().c_str();
         }
+        else
+        {
+            m_gpu_timing_model->OnGpuTimingResultsGenerated("");
+            qDebug() << "Failed to find gpu timing data";
+        }
     }
 
     bool file_loaded = false;
diff --git a/ui/perf_counter_model.cpp b/ui/perf_counter_model.cpp
@@ -27,6 +27,19 @@ PerfCounterModel::PerfCounterModel(QObject *parent) :
 void PerfCounterModel::OnPerfCounterResultsGenerated(const QString &file_path)
 {
     emit beginResetModel();
+
+    m_csv_data.clear();
+    m_search_results.clear();
+    m_search_iterator = nullptr;
+    m_headers.clear();
+    m_column_count = 0;
+
+    if (file_path.length() == 0)
+    {
+        emit endResetModel();
+        return;
+    }
+
     ParseCsv(file_path);
     emit endResetModel();
 }
