[profiler] export frame data using time interval

George540 · George540 · commit 2b632442f8c7 · 2026-01-01T01:30:17.000-05:00
diff --git a/source/editor/Widgets/Profiler.cpp b/source/editor/Widgets/Profiler.cpp
@@ -146,13 +146,11 @@ void Profiler::OnTickVisible()
             if (ImGui::Selectable("GPU", mode_hardware == 0))
             {
                 mode_hardware = 0;
-                spartan::CsvExporter::StopRecording(true);
             }
 
             if (ImGui::Selectable("CPU", mode_hardware == 1))
             {
                 mode_hardware = 1;
-                spartan::CsvExporter::StopRecording(true);
             }
 
             ImGui::EndCombo();
@@ -166,13 +164,11 @@ void Profiler::OnTickVisible()
             if (ImGui::Selectable("Alphabetically", mode_sort == 0))
             {
                 mode_sort = 0;
-                spartan::CsvExporter::StopRecording(true);
             }
 
             if (ImGui::Selectable("By Duration", mode_sort == 1))
             {
                 mode_sort = 1;
-                spartan::CsvExporter::StopRecording(true);
             }
 
             ImGui::EndCombo();
@@ -187,7 +183,7 @@ void Profiler::OnTickVisible()
         ImGui::SameLine();
         if (ImGui::Button("Start Recording"))
         {
-            spartan::CsvExporter::StartRecording(mode_hardware);
+            spartan::CsvExporter::StartRecording();
         }
         ImGui::SameLine();
         if (ImGui::Button("Stop Recording"))
@@ -228,11 +224,7 @@ void Profiler::OnTickVisible()
             continue;
 
         show_time_block(time_blocks[i]);
-
-        // Csv recording
-        spartan::CsvExporter::WriteFrameData(time_blocks[i], spartan::Renderer::GetFrameNumber());
     }
-    spartan::CsvExporter::NextFrame();
 
     // plot
     ImGui::Separator();
diff --git a/source/runtime/Profiling/CsvExporter.cpp b/source/runtime/Profiling/CsvExporter.cpp
@@ -28,6 +28,7 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 //= NAMESPACES ===============
 using namespace std;
+using namespace filesystem;
 //============================
 
 namespace spartan
@@ -36,14 +37,13 @@ namespace spartan
     {
         constexpr const char* file_path_name = "data/profiling/ProfilingReport.csv";
 
-        std::ofstream csv_export_file;
-        filesystem::path file_path(file_path_name);
-        int current_mode_hardware   = 0;
-        int current_csv_col         = 0; // frames by columns
-        int current_csv_row         = 0; // frame data by row
+        ofstream csv_export_file;
+        path file_path(file_path_name);
+        int current_csv_col = 0; // frames by columns
+        int current_csv_row = 0; // frame data by row
     }
 
-    void CsvExporter::StartRecording(int mode_hardware)
+    void CsvExporter::StartRecording()
     {
         if (csv_export_file.is_open())
         {
@@ -55,11 +55,10 @@ namespace spartan
         {
             if (file_path.has_parent_path())
             {
-                filesystem::create_directories(file_path.parent_path());
+                create_directories(file_path.parent_path());
             }
 
-            csv_export_file.exceptions(std::ofstream::failbit | std::ofstream::badbit);
-
+            csv_export_file.exceptions(ofstream::failbit | ofstream::badbit);
             csv_export_file.open(file_path, ios::out | ios::trunc);
 
             if (current_csv_col == 0)
@@ -68,11 +67,10 @@ namespace spartan
                 csv_export_file.flush();
                 current_csv_col++;
             }
-            current_mode_hardware = mode_hardware;
 
-            SP_LOG_INFO("Started recording %s data for CSV report: %s", current_mode_hardware == 0 ? "GPU" : "CPU", file_path.generic_string().c_str());
+            SP_LOG_INFO("Started recording profiling data for CSV report: %s", file_path.generic_string().c_str());
         }
-        catch (const filesystem::filesystem_error& e) // directory creation failures
+        catch (const filesystem_error& e) // directory creation failures
         {
             SP_LOG_ERROR("Filesystem Error: %s", e.what());
         }
@@ -88,7 +86,8 @@ namespace spartan
         {
             if (current_csv_row == 0)
             {
-                csv_export_file << current_time_block.GetName() << ",";
+                const char* hardware_type = current_time_block.GetType() == TimeBlockType::Gpu ? "GPU" : "CPU";
+                csv_export_file << hardware_type << "/" << current_time_block.GetName() << ",";
                 return;
             }
             if (current_csv_col == 0)
@@ -103,7 +102,7 @@ namespace spartan
         }
     }
 
-    void CsvExporter::NextFrame()
+    void CsvExporter::NextInterval()
     {
         if (csv_export_file.is_open())
         {
@@ -113,24 +112,17 @@ namespace spartan
         }
     }
 
-    void CsvExporter::StopRecording(bool has_data_changed)
+    void CsvExporter::StopRecording()
     {
         if (csv_export_file.is_open())
         {
             csv_export_file.flush();
             csv_export_file.close();
             current_csv_col = 0;
             current_csv_row = 0;
-            if (has_data_changed)
-            {
-                SP_LOG_WARNING("Stopped recording data for CSV report %s. Time block data were modified.", file_path.generic_string().c_str());
-            }
-            else
-            {
-                SP_LOG_INFO("Stopped recording %s data for CSV report: %s", current_mode_hardware == 0 ? "GPU" : "CPU", file_path.generic_string().c_str());
-            }
+            SP_LOG_INFO("Stopped recording profiling data for CSV report: %s", file_path.generic_string().c_str());
         }
-        else if (!csv_export_file.is_open() && !has_data_changed)
+        else if (!csv_export_file.is_open())
         {
             SP_LOG_WARNING("Invalid action. There is no active CSV recording.");
         }
diff --git a/source/runtime/Profiling/CsvExporter.h b/source/runtime/Profiling/CsvExporter.h
@@ -30,9 +30,9 @@ namespace spartan
     class CsvExporter
     {
     public:
-        static void StartRecording(int mode_hardware);
+        static void StartRecording();
         static void WriteFrameData(const TimeBlock& current_time_block, uint64_t frame_number);
-        static void NextFrame();
-        static void StopRecording(bool has_data_changed = false);
+        static void NextInterval();
+        static void StopRecording();
     };
 }
diff --git a/source/runtime/Profiling/Profiler.cpp b/source/runtime/Profiling/Profiler.cpp
@@ -22,6 +22,7 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 //= INCLUDES =========================
 #include "pch.h"
 #include "Profiler.h"
+#include "CsvExporter.h"
 #include "../RHI/RHI_Device.h"
 #include "../RHI/RHI_Implementation.h"
 #include "../RHI/RHI_SwapChain.h"
@@ -233,7 +234,9 @@ namespace spartan
 
             // copy
             m_time_blocks_read.push_back(time_block);
+            CsvExporter::WriteFrameData(time_block, Renderer::GetFrameNumber());
         }
+        CsvExporter::NextInterval();
 
         // clear write array
         m_time_blocks_write.clear();

Original file line number	Diff line number	Diff line change
`@@ -146,13 +146,11 @@ void Profiler::OnTickVisible()`
`146`	`146`	`if (ImGui::Selectable("GPU", mode_hardware == 0))`
`147`	`147`	`{`
`148`	`148`	`mode_hardware = 0;`
`149`		`- spartan::CsvExporter::StopRecording(true);`
`150`	`149`	`}`
`151`	`150`
`152`	`151`	`if (ImGui::Selectable("CPU", mode_hardware == 1))`
`153`	`152`	`{`
`154`	`153`	`mode_hardware = 1;`
`155`		`- spartan::CsvExporter::StopRecording(true);`
`156`	`154`	`}`
`157`	`155`
`158`	`156`	`ImGui::EndCombo();`
`@@ -166,13 +164,11 @@ void Profiler::OnTickVisible()`
`166`	`164`	`if (ImGui::Selectable("Alphabetically", mode_sort == 0))`
`167`	`165`	`{`
`168`	`166`	`mode_sort = 0;`
`169`		`- spartan::CsvExporter::StopRecording(true);`
`170`	`167`	`}`
`171`	`168`
`172`	`169`	`if (ImGui::Selectable("By Duration", mode_sort == 1))`
`173`	`170`	`{`
`174`	`171`	`mode_sort = 1;`
`175`		`- spartan::CsvExporter::StopRecording(true);`
`176`	`172`	`}`
`177`	`173`
`178`	`174`	`ImGui::EndCombo();`
`@@ -187,7 +183,7 @@ void Profiler::OnTickVisible()`
`187`	`183`	`ImGui::SameLine();`
`188`	`184`	`if (ImGui::Button("Start Recording"))`
`189`	`185`	`{`
`190`		`- spartan::CsvExporter::StartRecording(mode_hardware);`
	`186`	`+ spartan::CsvExporter::StartRecording();`
`191`	`187`	`}`
`192`	`188`	`ImGui::SameLine();`
`193`	`189`	`if (ImGui::Button("Stop Recording"))`
`@@ -228,11 +224,7 @@ void Profiler::OnTickVisible()`
`228`	`224`	`continue;`
`229`	`225`
`230`	`226`	`show_time_block(time_blocks[i]);`
`231`		`-`
`232`		`- // Csv recording`
`233`		`- spartan::CsvExporter::WriteFrameData(time_blocks[i], spartan::Renderer::GetFrameNumber());`
`234`	`227`	`}`
`235`		`- spartan::CsvExporter::NextFrame();`
`236`	`228`
`237`	`229`	`// plot`
`238`	`230`	`ImGui::Separator();`
Original file line number	Diff line number	Diff line change
`@@ -28,6 +28,7 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.`
`28`	`28`
`29`	`29`	`//= NAMESPACES ===============`
`30`	`30`	`using namespace std;`
	`31`	`+using namespace filesystem;`
`31`	`32`	`//============================`
`32`	`33`
`33`	`34`	`namespace spartan`
`@@ -36,14 +37,13 @@ namespace spartan`
`36`	`37`	`{`
`37`	`38`	`constexpr const char* file_path_name = "data/profiling/ProfilingReport.csv";`
`38`	`39`
`39`		`- std::ofstream csv_export_file;`
`40`		`- filesystem::path file_path(file_path_name);`
`41`		`- int current_mode_hardware = 0;`
`42`		`- int current_csv_col = 0; // frames by columns`
`43`		`- int current_csv_row = 0; // frame data by row`
	`40`	`+ ofstream csv_export_file;`
	`41`	`+ path file_path(file_path_name);`
	`42`	`+ int current_csv_col = 0; // frames by columns`
	`43`	`+ int current_csv_row = 0; // frame data by row`
`44`	`44`	`}`
`45`	`45`
`46`		`- void CsvExporter::StartRecording(int mode_hardware)`
	`46`	`+ void CsvExporter::StartRecording()`
`47`	`47`	`{`
`48`	`48`	`if (csv_export_file.is_open())`
`49`	`49`	`{`
`@@ -55,11 +55,10 @@ namespace spartan`
`55`	`55`	`{`
`56`	`56`	`if (file_path.has_parent_path())`
`57`	`57`	`{`
`58`		`- filesystem::create_directories(file_path.parent_path());`
	`58`	`+ create_directories(file_path.parent_path());`
`59`	`59`	`}`
`60`	`60`
`61`		`- csv_export_file.exceptions(std::ofstream::failbit \| std::ofstream::badbit);`
`62`		`-`
	`61`	`+ csv_export_file.exceptions(ofstream::failbit \| ofstream::badbit);`
`63`	`62`	`csv_export_file.open(file_path, ios::out \| ios::trunc);`
`64`	`63`
`65`	`64`	`if (current_csv_col == 0)`
`@@ -68,11 +67,10 @@ namespace spartan`
`68`	`67`	`csv_export_file.flush();`
`69`	`68`	`current_csv_col++;`
`70`	`69`	`}`
`71`		`- current_mode_hardware = mode_hardware;`
`72`	`70`
`73`		`- SP_LOG_INFO("Started recording %s data for CSV report: %s", current_mode_hardware == 0 ? "GPU" : "CPU", file_path.generic_string().c_str());`
	`71`	`+ SP_LOG_INFO("Started recording profiling data for CSV report: %s", file_path.generic_string().c_str());`
`74`	`72`	`}`
`75`		`- catch (const filesystem::filesystem_error& e) // directory creation failures`
	`73`	`+ catch (const filesystem_error& e) // directory creation failures`
`76`	`74`	`{`
`77`	`75`	`SP_LOG_ERROR("Filesystem Error: %s", e.what());`
`78`	`76`	`}`
`@@ -88,7 +86,8 @@ namespace spartan`
`88`	`86`	`{`
`89`	`87`	`if (current_csv_row == 0)`
`90`	`88`	`{`
`91`		`- csv_export_file << current_time_block.GetName() << ",";`
	`89`	`+ const char* hardware_type = current_time_block.GetType() == TimeBlockType::Gpu ? "GPU" : "CPU";`
	`90`	`+ csv_export_file << hardware_type << "/" << current_time_block.GetName() << ",";`
`92`	`91`	`return;`
`93`	`92`	`}`
`94`	`93`	`if (current_csv_col == 0)`
`@@ -103,7 +102,7 @@ namespace spartan`
`103`	`102`	`}`
`104`	`103`	`}`
`105`	`104`
`106`		`- void CsvExporter::NextFrame()`
	`105`	`+ void CsvExporter::NextInterval()`
`107`	`106`	`{`
`108`	`107`	`if (csv_export_file.is_open())`
`109`	`108`	`{`
`@@ -113,24 +112,17 @@ namespace spartan`
`113`	`112`	`}`
`114`	`113`	`}`
`115`	`114`
`116`		`- void CsvExporter::StopRecording(bool has_data_changed)`
	`115`	`+ void CsvExporter::StopRecording()`
`117`	`116`	`{`
`118`	`117`	`if (csv_export_file.is_open())`
`119`	`118`	`{`
`120`	`119`	`csv_export_file.flush();`
`121`	`120`	`csv_export_file.close();`
`122`	`121`	`current_csv_col = 0;`
`123`	`122`	`current_csv_row = 0;`
`124`		`- if (has_data_changed)`
`125`		`- {`
`126`		`- SP_LOG_WARNING("Stopped recording data for CSV report %s. Time block data were modified.", file_path.generic_string().c_str());`
`127`		`- }`
`128`		`- else`
`129`		`- {`
`130`		`- SP_LOG_INFO("Stopped recording %s data for CSV report: %s", current_mode_hardware == 0 ? "GPU" : "CPU", file_path.generic_string().c_str());`
`131`		`- }`
	`123`	`+ SP_LOG_INFO("Stopped recording profiling data for CSV report: %s", file_path.generic_string().c_str());`
`132`	`124`	`}`
`133`		`- else if (!csv_export_file.is_open() && !has_data_changed)`
	`125`	`+ else if (!csv_export_file.is_open())`
`134`	`126`	`{`
`135`	`127`	`SP_LOG_WARNING("Invalid action. There is no active CSV recording.");`
`136`	`128`	`}`
Original file line number	Diff line number	Diff line change
`@@ -30,9 +30,9 @@ namespace spartan`
`30`	`30`	`class CsvExporter`
`31`	`31`	`{`
`32`	`32`	`public:`
`33`		`- static void StartRecording(int mode_hardware);`
	`33`	`+ static void StartRecording();`
`34`	`34`	`static void WriteFrameData(const TimeBlock& current_time_block, uint64_t frame_number);`
`35`		`- static void NextFrame();`
`36`		`- static void StopRecording(bool has_data_changed = false);`
	`35`	`+ static void NextInterval();`
	`36`	`+ static void StopRecording();`
`37`	`37`	`};`
`38`	`38`	`}`