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;
@@ -118,40 +96,134 @@ static void write_codspeed_benchmarks_to_json(
     oss << "    }";
 
     if (i < benchmarks.size() - 1) {
-      oss << ",";
+      oss << ",\n";
     }
-    oss << "\n";
   }
+  return oss.str();
+}
 
-  oss << "  ]\n";
-  oss << "}";
-
-  // Determine the directory path
+static std::filesystem::path get_results_path() {
   std::string profile_folder = safe_getenv("CODSPEED_PROFILE_FOLDER");
   std::string directory = profile_folder.empty() ? "." : profile_folder;
+  return std::filesystem::path(directory) / "results" / "benchmarks.json";
+}
+
+static void write_codspeed_benchmarks_to_json(
+    const std::vector<CodspeedWalltimeBenchmark> &benchmarks) {
+
+  std::filesystem::path file_path = get_results_path();
+  std::filesystem::create_directories(file_path.parent_path());
+
+  std::ofstream out(file_path, std::ios::trunc);
+  if (!out) {
+    std::cerr << "Failed to open file for writing: " << file_path << std::endl;
+    return;
+  }
 
-  // Create the results directory if it does not exist
-  std::filesystem::path results_path = directory + "/results";
-  if (!std::filesystem::exists(results_path)) {
-    if (!std::filesystem::create_directories(results_path)) {
-      std::cerr << "Failed to create directory: " << results_path << std::endl;
-      return;
+  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";
+
+  out << "{\n";
+  out << "  \"creator\": {\n";
+  out << "    \"name\": \"" << creator_name << "\",\n";
+  out << "    \"version\": \"" << creator_version << "\",\n";
+  out << "    \"pid\": " << creator_pid << "\n";
+  out << "  },\n";
+  out << "  \"instrument\": {\n";
+  out << "    \"type\": \"" << instrument_type << "\"\n";
+  out << "  },\n";
+  out << "  \"benchmarks\": [\n";
+
+  out << serialize_benchmark_objects(benchmarks);
+
+  out << "\n  ]\n}";
+}
+
+static void append_codspeed_benchmarks_to_json(
+    const std::vector<CodspeedWalltimeBenchmark> &benchmarks) {
+
+  if (benchmarks.empty()) return;
+
+  std::filesystem::path file_path = get_results_path();
+
+  // Condition: If file is missing or entirely empty, generate fresh
+  if (!std::filesystem::exists(file_path) || std::filesystem::file_size(file_path) == 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, std::ios::in | std::ios::out | std::ios::binary);
+  if (!file) {
+    std::cerr << "Failed to open file for appending: " << file_path << 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 brackets_found = 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;
+    }
+
+    if (brackets_found == 0 && ch == '}') {
+      brackets_found = 1;
+      continue;
+    }
+
+    if (brackets_found == 1 && ch == ']') {
+      brackets_found = 2;
+      continue;
     }
+
+    if (brackets_found == 2) {
+      // Check if the last character before whitespace is the open bracket '[' (meaning array was empty)
+      if (ch == '[') {
+        array_was_empty = true;
+      }
+      truncation_pos = pos + std::streamoff(1);
+      break;
+    }
+  }
+
+  if (brackets_found < 2) {
+    std::cerr << "Failed to find valid JSON structural endings to safely append." << std::endl;
+    return;
   }
 
-  // Create the file path
-  std::ostringstream file_path;
-  file_path << results_path.string() << "/" << creator_pid << ".json";
+  file.seekp(truncation_pos);
 
-  // Write to file
-  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;
+  if (!array_was_empty) {
+    file << ",\n"; // Commas are mandatory between pre-existing elements
   } else {
-    std::cerr << "Unable to open file " << file_path.str() << std::endl;
+    file << "\n";
   }
+
+  // Inject the new items
+  file << serialize_benchmark_objects(benchmarks);
+
+  // Re-close the JSON root safely
+  file << "\n  ]\n}";
+
+  std::filesystem::resize_file(file_path, file.tellp());
 }
 
 BenchmarkStats compute_benchmark_stats(
@@ -245,7 +317,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