test(perf): fix performance test benchmark compare code

zhangjipeng · zhangjipeng · commit 72b24695c843 · 2026-01-08T15:43:19.000+08:00
Signed-off-by: zhangjipeng &lt;zhangjipeng@xiaomi.com&gt;
diff --git a/perf_tests/perf_tests.cmake b/perf_tests/perf_tests.cmake
@@ -25,7 +25,7 @@ FetchContent_Declare(
 )
 FetchContent_MakeAvailable(cJSON)
 add_library(CJson::CJson INTERFACE IMPORTED)
-target_compile_definitions(CJson::CJson INTERFACE ENABLE_CJSON_TEST=OFF)
+target_compile_definitions(CJson::CJson INTERFACE -DENABLE_CJSON_TEST=OFF)
 target_link_libraries(CJson::CJson INTERFACE cjson)
 
 
@@ -63,7 +63,7 @@ if (WIN32)
         COMMAND_EXPAND_LISTS
     )
 else()
-    target_compile_definitions(${PERF_TESTS} PRIVATE LINUX=1)
+    target_compile_definitions(${PERF_TESTS} PRIVATE -DLINUX=1)
     target_compile_options(${PERF_TESTS} PRIVATE -std=gnu++17)
     configure_file(${PROJECT_ROOT}/cfg/ZCOOLXiaoWei-Regular.ttf ${CMAKE_CURRENT_BINARY_DIR}/ZCOOLXiaoWei-Regular.ttf COPYONLY)
 endif()
diff --git a/perf_tests/test.cpp b/perf_tests/test.cpp
@@ -142,14 +142,13 @@ void clear_test_canvas(void)
     memset(test_buffer, 0xFF, TEST_WIDTH * TEST_HEIGHT * 4);
 }
 
-void PerformanceTest::LoadBaseline()
+bool PerformanceTest::LoadBaseline(const std::string& file_name, BenchmarkData& data)
 {
-    baseline_data.clear();
+    data.clear();
 
-    std::ifstream file(baseline_file);
+    std::ifstream file(file_name);
     if (!file.is_open()) {
-        need_write_baseline = true;
-        return;
+        return false;
     }
 
     std::string json_str((std::istreambuf_iterator<char>(file)),
@@ -158,8 +157,7 @@ void PerformanceTest::LoadBaseline()
 
     if (json_str.empty()) {
         std::cerr << "Error: JSON file is empty" << std::endl;
-        need_write_baseline = true;
-        return;
+        return false;
     }
 
     cJSON* root = cJSON_Parse(json_str.c_str());
@@ -169,15 +167,13 @@ void PerformanceTest::LoadBaseline()
             std::cerr << "Error: JSON parse error before: " << error_ptr << std::endl;
         }
         std::cerr << "Error: Failed to parse JSON from file " << baseline_file << std::endl;
-        need_write_baseline = true;
-        return;
+        return false;
     }
 
     if (cJSON_IsObject(root) == 0) {
         std::cerr << "Error: Root JSON element is not an object" << std::endl;
         cJSON_Delete(root);
-        need_write_baseline = true;
-        return;
+        return false;
     }
 
     cJSON* current = NULL;
@@ -229,22 +225,23 @@ void PerformanceTest::LoadBaseline()
         }
 
         if (valid) {
-            baseline_data[key] = result;
+            data[key] = result;
         }
     }
 
     cJSON_Delete(root);
+    return true;
 }
 
-void PerformanceTest::SaveBaseline()
+void PerformanceTest::SaveBaseline(const std::string& file_name)
 {
     cJSON* root = cJSON_CreateObject();
     if (!root) {
         std::cerr << "Error: Failed to create root JSON object" << std::endl;
         return;
     }
 
-    for (const auto& pair : baseline_data) {
+    for (const auto& pair : newbase_data) {
         const std::string& key = pair.first;
         const BenchmarkResult& result = pair.second;
 
@@ -270,9 +267,9 @@ void PerformanceTest::SaveBaseline()
         return;
     }
 
-    std::ofstream file(baseline_file);
+    std::ofstream file(file_name);
     if (!file.is_open()) {
-        std::cerr << "Error: Failed to open file " << baseline_file << " for writing" << std::endl;
+        std::cerr << "Error: Failed to open file " << file_name << " for writing" << std::endl;
         free(json_str);
         cJSON_Delete(root);
         return;
diff --git a/perf_tests/test.h b/perf_tests/test.h
@@ -87,8 +87,11 @@ class PerformanceTest : public ::testing::Test
         double max_ms;
     };
 
-    std::map<std::string, BenchmarkResult> baseline_data;
+    typedef std::map<std::string, BenchmarkResult> BenchmarkData;
+    BenchmarkData baseline_data;
+    BenchmarkData newbase_data;
     std::string baseline_file;
+    std::string newbase_file;
     bool need_write_baseline;
 
     static void SetUpTestSuite()
@@ -104,25 +107,29 @@ class PerformanceTest : public ::testing::Test
     void Init(const std::string& test_name)
     {
         baseline_file = "./benchmark/" + test_name + "_" + SYSTEM + "_" + ARCH + ".json";
+        newbase_file = "./benchmark/" + test_name + "_" + SYSTEM + "_" + ARCH + "_new.json";
     }
 
     void SetUp() override
     {
         need_write_baseline = false;
-        LoadBaseline();
+        if (!LoadBaseline(baseline_file, baseline_data)) {
+            need_write_baseline = true;
+        }
+        LoadBaseline(newbase_file, newbase_data);
 
         clear_dcache();
     }
 
     void TearDown() override
     {
         if (need_write_baseline) {
-            SaveBaseline();
+            SaveBaseline(newbase_file);
         }
     }
 
-    void LoadBaseline();
-    void SaveBaseline();
+    bool LoadBaseline(const std::string& file_name, BenchmarkData& data);
+    void SaveBaseline(const std::string& file_name);
 
     template<typename Func>
     BenchmarkResult RunBenchmark(const std::string& test_name, Func&& func)
@@ -175,7 +182,7 @@ class PerformanceTest : public ::testing::Test
         std::string key = test_name;
 
         if (baseline_data.find(key) == baseline_data.end()) {
-            baseline_data[key] = result;
+            newbase_data[key] = result;
             std::cout << "[New Baseline] " << test_name << ": "
                       << std::setprecision(6)
                       << "median: " << result.mid_ms << " ms (avg: "
@@ -191,8 +198,9 @@ class PerformanceTest : public ::testing::Test
                               << std::setprecision(6) << "median: " << result.mid_ms << " ms (avg: " << result.avg_ms
                               << ", min: " << result.min_ms
                               << ", max: " << result.max_ms << ")" << std::endl;
-                    baseline_data[key] = result;
+                    need_write_baseline = true;
                 }
+                newbase_data[key] = result;
             } else {
                 EXPECT_LE(std::abs(diff_percent), TOLERANCE_PERCENT)
                         << "Performance regression detected for " << test_name
diff --git a/unit_tests/unit_tests.cmake b/unit_tests/unit_tests.cmake
@@ -62,7 +62,7 @@ if (WIN32)
         COMMAND_EXPAND_LISTS
     )
 else()
-    target_compile_definitions(${UNIT_TESTS} PRIVATE LINUX=1)
+    target_compile_definitions(${UNIT_TESTS} PRIVATE -DLINUX=1)
     target_compile_options(${UNIT_TESTS} PRIVATE -std=gnu++17)
     configure_file(${PROJECT_ROOT}/cfg/ZCOOLXiaoWei-Regular.ttf ${CMAKE_CURRENT_BINARY_DIR}/ZCOOLXiaoWei-Regular.ttf COPYONLY)
 endif()

Original file line number	Diff line number	Diff line change
`@@ -142,14 +142,13 @@ void clear_test_canvas(void)`
`142`	`142`	`memset(test_buffer, 0xFF, TEST_WIDTH * TEST_HEIGHT * 4);`
`143`	`143`	`}`
`144`	`144`
`145`		`-void PerformanceTest::LoadBaseline()`
	`145`	`+bool PerformanceTest::LoadBaseline(const std::string& file_name, BenchmarkData& data)`
`146`	`146`	`{`
`147`		`- baseline_data.clear();`
	`147`	`+ data.clear();`
`148`	`148`
`149`		`- std::ifstream file(baseline_file);`
	`149`	`+ std::ifstream file(file_name);`
`150`	`150`	`if (!file.is_open()) {`
`151`		`- need_write_baseline = true;`
`152`		`- return;`
	`151`	`+ return false;`
`153`	`152`	`}`
`154`	`153`
`155`	`154`	`std::string json_str((std::istreambuf_iterator<char>(file)),`
`@@ -158,8 +157,7 @@ void PerformanceTest::LoadBaseline()`
`158`	`157`
`159`	`158`	`if (json_str.empty()) {`
`160`	`159`	`std::cerr << "Error: JSON file is empty" << std::endl;`
`161`		`- need_write_baseline = true;`
`162`		`- return;`
	`160`	`+ return false;`
`163`	`161`	`}`
`164`	`162`
`165`	`163`	`cJSON* root = cJSON_Parse(json_str.c_str());`
`@@ -169,15 +167,13 @@ void PerformanceTest::LoadBaseline()`
`169`	`167`	`std::cerr << "Error: JSON parse error before: " << error_ptr << std::endl;`
`170`	`168`	`}`
`171`	`169`	`std::cerr << "Error: Failed to parse JSON from file " << baseline_file << std::endl;`
`172`		`- need_write_baseline = true;`
`173`		`- return;`
	`170`	`+ return false;`
`174`	`171`	`}`
`175`	`172`
`176`	`173`	`if (cJSON_IsObject(root) == 0) {`
`177`	`174`	`std::cerr << "Error: Root JSON element is not an object" << std::endl;`
`178`	`175`	`cJSON_Delete(root);`
`179`		`- need_write_baseline = true;`
`180`		`- return;`
	`176`	`+ return false;`
`181`	`177`	`}`
`182`	`178`
`183`	`179`	`cJSON* current = NULL;`
`@@ -229,22 +225,23 @@ void PerformanceTest::LoadBaseline()`
`229`	`225`	`}`
`230`	`226`
`231`	`227`	`if (valid) {`
`232`		`- baseline_data[key] = result;`
	`228`	`+ data[key] = result;`
`233`	`229`	`}`
`234`	`230`	`}`
`235`	`231`
`236`	`232`	`cJSON_Delete(root);`
	`233`	`+ return true;`
`237`	`234`	`}`
`238`	`235`
`239`		`-void PerformanceTest::SaveBaseline()`
	`236`	`+void PerformanceTest::SaveBaseline(const std::string& file_name)`
`240`	`237`	`{`
`241`	`238`	`cJSON* root = cJSON_CreateObject();`
`242`	`239`	`if (!root) {`
`243`	`240`	`std::cerr << "Error: Failed to create root JSON object" << std::endl;`
`244`	`241`	`return;`
`245`	`242`	`}`
`246`	`243`
`247`		`- for (const auto& pair : baseline_data) {`
	`244`	`+ for (const auto& pair : newbase_data) {`
`248`	`245`	`const std::string& key = pair.first;`
`249`	`246`	`const BenchmarkResult& result = pair.second;`
`250`	`247`
`@@ -270,9 +267,9 @@ void PerformanceTest::SaveBaseline()`
`270`	`267`	`return;`
`271`	`268`	`}`
`272`	`269`
`273`		`- std::ofstream file(baseline_file);`
	`270`	`+ std::ofstream file(file_name);`
`274`	`271`	`if (!file.is_open()) {`
`275`		`- std::cerr << "Error: Failed to open file " << baseline_file << " for writing" << std::endl;`
	`272`	`+ std::cerr << "Error: Failed to open file " << file_name << " for writing" << std::endl;`
`276`	`273`	`free(json_str);`
`277`	`274`	`cJSON_Delete(root);`
`278`	`275`	`return;`
Original file line number	Diff line number	Diff line change
`@@ -62,7 +62,7 @@ if (WIN32)`
`62`	`62`	`COMMAND_EXPAND_LISTS`
`63`	`63`	`)`
`64`	`64`	`else()`
`65`		`- target_compile_definitions(${UNIT_TESTS} PRIVATE LINUX=1)`
	`65`	`+ target_compile_definitions(${UNIT_TESTS} PRIVATE -DLINUX=1)`
`66`	`66`	`target_compile_options(${UNIT_TESTS} PRIVATE -std=gnu++17)`
`67`	`67`	`configure_file(${PROJECT_ROOT}/cfg/ZCOOLXiaoWei-Regular.ttf ${CMAKE_CURRENT_BINARY_DIR}/ZCOOLXiaoWei-Regular.ttf COPYONLY)`
`68`	`68`	`endif()`