Add the ability to append to the result json file for wallclock benchmarks (AI Generated)

Author: OsamaAhmad00

core/src/walltime.cpp

@@ -59,30 +59,8 @@ static std::string escape_backslashes(const std::string &input) {
   return output;
 }
 
-static void write_codspeed_benchmarks_to_json(
-    const std::vector<CodspeedWalltimeBenchmark> &benchmarks) {
+static std::string serialize_benchmark_objects(const std::vector<CodspeedWalltimeBenchmark> &benchmarks) {
   std::ostringstream oss;
-
-  std::string creator_name = "codspeed-cpp";
-  std::string creator_version = CODSPEED_VERSION;
-#ifdef _WIN32
-  auto creator_pid = _getpid();
-#else
-  pid_t creator_pid = getpid();
-#endif
-  std::string instrument_type = "walltime";
-
-  oss << "{\n";
-  oss << "  \"creator\": {\n";
-  oss << "    \"name\": \"" << creator_name << "\",\n";
-  oss << "    \"version\": \"" << creator_version << "\",\n";
-  oss << "    \"pid\": " << creator_pid << "\n";
-  oss << "  },\n";
-  oss << "  \"instrument\": {\n";
-  oss << "    \"type\": \"" << instrument_type << "\"\n";
-  oss << "  },\n";
-  oss << "  \"benchmarks\": [\n";
-
   for (size_t i = 0; i < benchmarks.size(); ++i) {
     const auto &benchmark = benchmarks[i];
     const auto &stats = benchmark.stats;
@@ -122,9 +100,16 @@ static void write_codspeed_benchmarks_to_json(
     }
     oss << "\n";
   }
+  return oss.str();
+}
 
-  oss << "  ]\n";
-  oss << "}";
+// Extracts the file path calculation and directory creation to avoid redundancy
+static std::string get_codspeed_results_file_path() {
+#ifdef _WIN32
+  auto creator_pid = _getpid();
+#else
+  pid_t creator_pid = getpid();
+#endif
 
   // Determine the directory path
   std::string profile_folder = safe_getenv("CODSPEED_PROFILE_FOLDER");
@@ -135,25 +120,145 @@ static void write_codspeed_benchmarks_to_json(
   if (!std::filesystem::exists(results_path)) {
     if (!std::filesystem::create_directories(results_path)) {
       std::cerr << "Failed to create directory: " << results_path << std::endl;
-      return;
+      return "";
     }
   }
 
   // Create the file path
   std::ostringstream file_path;
   file_path << results_path.string() << "/" << creator_pid << ".json";
+  return file_path.str();
+}
+
+static void write_codspeed_benchmarks_to_json(
+    const std::vector<CodspeedWalltimeBenchmark> &benchmarks) {
+  std::ostringstream oss;
+
+  std::string creator_name = "codspeed-cpp";
+  std::string creator_version = CODSPEED_VERSION;
+#ifdef _WIN32
+  auto creator_pid = _getpid();
+#else
+  pid_t creator_pid = getpid();
+#endif
+  std::string instrument_type = "walltime";
+
+  oss << "{\n";
+  oss << "  \"creator\": {\n";
+  oss << "    \"name\": \"" << creator_name << "\",\n";
+  oss << "    \"version\": \"" << creator_version << "\",\n";
+  oss << "    \"pid\": " << creator_pid << "\n";
+  oss << "  },\n";
+  oss << "  \"instrument\": {\n";
+  oss << "    \"type\": \"" << instrument_type << "\"\n";
+  oss << "  },\n";
+  oss << "  \"benchmarks\": [\n";
+
+  oss << serialize_benchmark_objects(benchmarks);
+
+  oss << "  ]\n";
+  oss << "}";
+
+  std::string file_path_str = get_codspeed_results_file_path();
+  if (file_path_str.empty()) return;
 
   // Write to file
-  std::ofstream out_file(file_path.str());
+  std::ofstream out_file(file_path_str);
   if (out_file.is_open()) {
     out_file << oss.str();
     out_file.close();
-    std::cout << "JSON written to " << file_path.str() << std::endl;
+    std::cout << "JSON written to " << file_path_str << std::endl;
   } else {
-    std::cerr << "Unable to open file " << file_path.str() << std::endl;
+    std::cerr << "Unable to open file " << file_path_str << std::endl;
   }
 }
 
+static void append_codspeed_benchmarks_to_json(
+    const std::vector<CodspeedWalltimeBenchmark> &benchmarks) {
+
+  if (benchmarks.empty()) return;
+
+  std::string file_path_str = get_codspeed_results_file_path();
+  if (file_path_str.empty()) return;
+
+  // Condition: If file is missing or entirely empty, generate fresh
+  if (!std::filesystem::exists(file_path_str) || std::filesystem::file_size(file_path_str) == 0) {
+    write_codspeed_benchmarks_to_json(benchmarks);
+    return;
+  }
+
+  // Open in read/write binary mode to prevent Windows newline conversion from messing with stream offsets
+  std::fstream file(file_path_str, std::ios::in | std::ios::out | std::ios::binary);
+  if (!file) {
+    std::cerr << "Failed to open file for appending: " << file_path_str << std::endl;
+    return;
+  }
+
+  // Back up from the EOF until we strip away '}', ']', and whitespace
+  file.seekp(0, std::ios::end);
+  std::streampos pos = file.tellp();
+
+  int state = 0;
+  bool array_was_empty = false;
+  std::streampos truncation_pos = 0;
+
+  // Read backwards to safely find where the trailing array structural markers close
+  while (pos > 0) {
+    pos -= 1;
+    file.seekg(pos);
+    char ch;
+    file.get(ch);
+
+    if (std::isspace(static_cast<unsigned char>(ch))) {
+      continue;
+    }
+
+    // State 0: Find the outer root object closure '}'
+    if (state == 0 && ch == '}') {
+      state = 1;
+      continue;
+    }
+
+    // State 1: Find the array list closure ']'
+    if (state == 1 && ch == ']') {
+      state = 2;
+      // Truncate right here! This preserves whatever character came right before the array bracket ']'
+      truncation_pos = pos;
+      continue;
+    }
+
+    // State 2: Check what the last character inside the array was
+    if (state == 2) {
+      if (ch == '[') {
+        array_was_empty = true;
+      }
+      break;
+    }
+  }
+
+  if (state < 2) {
+    std::cerr << "Failed to find valid JSON structural endings to safely append." << std::endl;
+    return;
+  }
+
+  file.seekp(truncation_pos);
+
+  if (!array_was_empty) {
+    file << ",\n"; // Commas are mandatory between pre-existing elements
+  } else {
+    file << "\n";
+  }
+
+  // Inject the new items
+  file << serialize_benchmark_objects(benchmarks);
+
+  // Re-close the JSON root safely (matches old string generation spaces precisely)
+  file << "  ]\n}";
+
+  file.flush();
+  std::filesystem::resize_file(file_path_str, file.tellp());
+}
+
 BenchmarkStats compute_benchmark_stats(
     const RawWalltimeBenchmark &raw_benchmark) {
   assert(raw_benchmark.iters_per_round.size() ==
@@ -245,7 +350,7 @@ void generate_codspeed_walltime_report(
     codspeed_walltime_benchmarks.push_back(codspeed_benchmark);
   }
 
-  write_codspeed_benchmarks_to_json(codspeed_walltime_benchmarks);
+  append_codspeed_benchmarks_to_json(codspeed_walltime_benchmarks);
 }
 
 }  // namespace codspeed