refactor(core): add a codspeed namespace for codspeed core functions

GuillaumeLagrange · GuillaumeLagrange · commit 680721aa1454 · 2025-05-02T14:33:54.000+02:00
diff --git a/core/include/codspeed.h b/core/include/codspeed.h
@@ -4,6 +4,8 @@
 #include <string>
 #include <vector>
 
+namespace codspeed {
+
 class CodSpeed {
 public:
   // Public static method to access the single instance
@@ -44,4 +46,6 @@ void generate_codspeed_walltime_report(
 std::string extract_lambda_namespace(const std::string &pretty_func);
 std::string sanitize_bench_args(std::string &text);
 
+} // namespace codspeed
+
 #endif // CODSPEED_H
diff --git a/core/src/codspeed.cpp b/core/src/codspeed.cpp
@@ -4,6 +4,7 @@
 #include <string>
 #include <vector>
 
+namespace codspeed {
 // Remove any `::` between brackets at the end to not mess with the URI
 // parsing
 // FIXME: Remove this bandaid when we migrate to structured benchmark metadata
@@ -91,3 +92,5 @@ void CodSpeed::end_benchmark() {
   std::cerr << action_str << ": " << current_benchmark << group_str
             << std::endl;
 }
+
+} // namespace codspeed
diff --git a/core/src/uri.cpp b/core/src/uri.cpp
@@ -1,10 +1,12 @@
 #include "codspeed.h"
-#include <string>
 #include <iostream>
+#include <string>
+
+namespace codspeed {
 
 // Example: auto outer::test12::(anonymous class)::operator()() const
 // Returns: outer::test12::
-std::string extract_namespace_clang(const std::string& pretty_func) {
+std::string extract_namespace_clang(const std::string &pretty_func) {
   std::size_t anon_class_pos = pretty_func.find("::(anonymous class)");
   std::size_t space_pos = pretty_func.find(' ');
 
@@ -18,31 +20,34 @@ std::string extract_namespace_clang(const std::string& pretty_func) {
 
 // Example: outer::test12::<lambda()>
 // Returns: outer::test12::
-std::string extract_namespace_gcc(const std::string& pretty_func) {
-    auto lambda_pos = pretty_func.find("::<lambda()>");
-    if (lambda_pos == std::string::npos) {
-        return {};
-    }
+std::string extract_namespace_gcc(const std::string &pretty_func) {
+  auto lambda_pos = pretty_func.find("::<lambda()>");
+  if (lambda_pos == std::string::npos) {
+    return {};
+  }
 
-    return pretty_func.substr(0, lambda_pos) + "::";
+  return pretty_func.substr(0, lambda_pos) + "::";
 }
 
-// Has to pass the pretty function from a lambda: 
+// Has to pass the pretty function from a lambda:
 //   (([]() { return __PRETTY_FUNCTION__; })())
 //
-// Returns: An empty string if the namespace could not be extracted, 
+// Returns: An empty string if the namespace could not be extracted,
 //         otherwise the namespace with a trailing "::"
-std::string extract_lambda_namespace(const std::string& pretty_func) {
+std::string extract_lambda_namespace(const std::string &pretty_func) {
   if (pretty_func.find("(anonymous namespace)") != std::string::npos) {
-    std::cerr << "[ERROR] Anonymous namespace not supported in " << pretty_func << std::endl;
+    std::cerr << "[ERROR] Anonymous namespace not supported in " << pretty_func
+              << std::endl;
     return {};
   }
 
 #ifdef __clang__
-    return extract_namespace_clang(pretty_func);
+  return extract_namespace_clang(pretty_func);
 #elif __GNUC__
-    return extract_namespace_gcc(pretty_func);
+  return extract_namespace_gcc(pretty_func);
 #else
 #error "Unsupported compiler"
 #endif
 }
+
+} // namespace codspeed
diff --git a/core/src/walltime.cpp b/core/src/walltime.cpp
@@ -15,6 +15,8 @@
 #endif
 #include <vector>
 
+namespace codspeed {
+
 const double IQR_OUTLIER_FACTOR = 1.5;
 const double STDEV_OUTLIER_FACTOR = 3.0;
 
@@ -243,3 +245,5 @@ void generate_codspeed_walltime_report(
 
   write_codspeed_benchmarks_to_json(codspeed_walltime_benchmarks);
 }
+
+} // namespace codspeed
diff --git a/core/test/codspeed.cpp b/core/test/codspeed.cpp
@@ -8,15 +8,16 @@ TEST(CodSpeedTest, TestSearchAndReplaceBetweenBracketsNamespace) {
       "examples/google_benchmark/main.cpp::BM_rand_vector";
   std::string no_brackets_output =
       "examples/google_benchmark/main.cpp::BM_rand_vector";
-  EXPECT_EQ(sanitize_bench_args(no_brackets_input), no_brackets_output);
+  EXPECT_EQ(codspeed::sanitize_bench_args(no_brackets_input),
+            no_brackets_output);
 
   std::string brackets_and_no_escaped_type_input =
       "examples/google_benchmark/"
       "template_bench.hpp::BM_Template1_Capture[two_type_test, int, double]";
   std::string brackets_and_no_escaped_type_output =
       "examples/google_benchmark/"
       "template_bench.hpp::BM_Template1_Capture[two_type_test, int, double]";
-  EXPECT_EQ(sanitize_bench_args(brackets_and_no_escaped_type_input),
+  EXPECT_EQ(codspeed::sanitize_bench_args(brackets_and_no_escaped_type_input),
             brackets_and_no_escaped_type_output);
 
   std::string brackets_and_escaped_type_input =
@@ -26,7 +27,7 @@ TEST(CodSpeedTest, TestSearchAndReplaceBetweenBracketsNamespace) {
       "examples/google_benchmark/"
       "template_bench.hpp::test::BM_Template[std\\:\\:string]";
 
-  EXPECT_EQ(sanitize_bench_args(brackets_and_escaped_type_input),
+  EXPECT_EQ(codspeed::sanitize_bench_args(brackets_and_escaped_type_input),
             brackets_and_escaped_type_output);
 
   std::string brackets_and_escaped_types_input =
@@ -36,7 +37,7 @@ TEST(CodSpeedTest, TestSearchAndReplaceBetweenBracketsNamespace) {
       "examples/google_benchmark/"
       "template_bench.hpp::test::BM_Template[std\\:\\:string, std\\:\\:string]";
 
-  EXPECT_EQ(sanitize_bench_args(brackets_and_escaped_types_input),
+  EXPECT_EQ(codspeed::sanitize_bench_args(brackets_and_escaped_types_input),
             brackets_and_escaped_types_output);
 
   std::string brackets_and_multiple_types_input =
@@ -46,6 +47,6 @@ TEST(CodSpeedTest, TestSearchAndReplaceBetweenBracketsNamespace) {
       "examples/google_benchmark/"
       "template_bench.hpp::test::BM_Template[std\\:\\:string, int, double]";
 
-  EXPECT_EQ(sanitize_bench_args(brackets_and_multiple_types_input),
+  EXPECT_EQ(codspeed::sanitize_bench_args(brackets_and_multiple_types_input),
             brackets_and_multiple_types_output);
 }
diff --git a/core/test/uri.cpp b/core/test/uri.cpp
@@ -1,29 +1,38 @@
-#include <gtest/gtest.h>
 #include "codspeed.h"
+#include <gtest/gtest.h>
 
 // Manual definition (to avoid including it in the public header):
-std::string extract_namespace_clang(const std::string& func_str); 
-std::string extract_namespace_gcc(const std::string& func_str);
+namespace codspeed {
+std::string extract_namespace_clang(const std::string &func_str);
+std::string extract_namespace_gcc(const std::string &func_str);
+} // namespace codspeed
 
 TEST(UriTest, TestExtractNamespaceClang) {
-    EXPECT_EQ(extract_namespace_clang("auto outer::test12::(anonymous class)::operator()() const"), "outer::test12::");
-    EXPECT_EQ(extract_namespace_clang("auto outer::(anonymous namespace)::test12::(anonymous class)::operator()() const"), "outer::(anonymous namespace)::test12::");
+  EXPECT_EQ(codspeed::extract_namespace_clang(
+                "auto outer::test12::(anonymous class)::operator()() const"),
+            "outer::test12::");
+  EXPECT_EQ(codspeed::extract_namespace_clang(
+                "auto outer::(anonymous namespace)::test12::(anonymous "
+                "class)::operator()() const"),
+            "outer::(anonymous namespace)::test12::");
 }
 
 TEST(UriTest, TestExtractNamespaceGcc) {
-    EXPECT_EQ(extract_namespace_gcc("outer::test12::<lambda()>"), "outer::test12::");
-    EXPECT_EQ(extract_namespace_gcc("outer::(anonymous namespace)::test12::<lambda()>"), "outer::(anonymous namespace)::test12::");
+  EXPECT_EQ(codspeed::extract_namespace_gcc("outer::test12::<lambda()>"),
+            "outer::test12::");
+  EXPECT_EQ(codspeed::extract_namespace_gcc(
+                "outer::(anonymous namespace)::test12::<lambda()>"),
+            "outer::(anonymous namespace)::test12::");
 }
 
-
 namespace a {
 namespace b {
 namespace c {
 static std::string pretty_func = ([]() { return __PRETTY_FUNCTION__; })();
 
 TEST(UriTest, TestExtractNamespace) {
-    EXPECT_EQ(extract_lambda_namespace(pretty_func), "a::b::c::");
-}
-}
-}
+  EXPECT_EQ(codspeed::extract_lambda_namespace(pretty_func), "a::b::c::");
 }
+} // namespace c
+} // namespace b
+} // namespace a
diff --git a/google_benchmark/include/benchmark/benchmark.h b/google_benchmark/include/benchmark/benchmark.h
@@ -1446,7 +1446,7 @@ class Fixture : public internal::Benchmark {
 #define CUR_FILE \
   std::filesystem::relative(__FILE__, CODSPEED_GIT_ROOT_DIR).string() + "::"
 #define NAMESPACE \
-  (([]() { return extract_lambda_namespace(__PRETTY_FUNCTION__); })())
+  (([]() { return codspeed::extract_lambda_namespace(__PRETTY_FUNCTION__); })())
 #define STATIC_NAMESPACE_STRING(name) static std::string name = NAMESPACE;
 
 #define FILE_AND_NAMESPACE CUR_FILE + NAMESPACE
diff --git a/google_benchmark/src/benchmark.cc b/google_benchmark/src/benchmark.cc
@@ -352,12 +352,13 @@ void FlushStreams(BenchmarkReporter* reporter) {
 #ifdef CODSPEED_WALLTIME
 // We use real time by default, but we could offer CPU time usage as a build
 // option, open an issue if you need it.
-RawWalltimeBenchmark generate_raw_walltime_data(const RunResults& run_results) {
-  RawWalltimeBenchmark walltime_data;
+codspeed::RawWalltimeBenchmark generate_raw_walltime_data(
+    const RunResults& run_results) {
+  codspeed::RawWalltimeBenchmark walltime_data;
 
   for (const auto& run : run_results.non_aggregates) {
     walltime_data.uri = run.benchmark_name();
-    walltime_data.uri = sanitize_bench_args(walltime_data.uri);
+    walltime_data.uri = codspeed::sanitize_bench_args(walltime_data.uri);
 
     size_t pos = walltime_data.uri.rfind("::");
 
@@ -529,7 +530,7 @@ void RunBenchmarks(const std::vector<BenchmarkInstance>& benchmarks,
     }
 
 #ifdef CODSPEED_WALLTIME
-    std::vector<RawWalltimeBenchmark> codspeed_walltime_data;
+    std::vector<codspeed::RawWalltimeBenchmark> codspeed_walltime_data;
 #endif
     for (size_t repetition_index : repetition_indices) {
       internal::BenchmarkRunner& runner = runners[repetition_index];
@@ -568,7 +569,7 @@ void RunBenchmarks(const std::vector<BenchmarkInstance>& benchmarks,
       Report(display_reporter, file_reporter, run_results);
     }
 #ifdef CODSPEED_WALLTIME
-    generate_codspeed_walltime_report(codspeed_walltime_data);
+    codspeed::generate_codspeed_walltime_report(codspeed_walltime_data);
 #endif
   }
   display_reporter->Finalize();
diff --git a/google_benchmark/src/benchmark_api_internal.cc b/google_benchmark/src/benchmark_api_internal.cc
@@ -93,7 +93,7 @@ BenchmarkInstance::BenchmarkInstance(Benchmark* benchmark, int family_idx,
 
 #ifdef CODSPEED_INSTRUMENTATION
 State BenchmarkInstance::RunInstrumented(
-    CodSpeed* codspeed, internal::ThreadTimer* timer,
+    codspeed::CodSpeed* codspeed, internal::ThreadTimer* timer,
     internal::ThreadManager* manager,
     internal::PerfCountersMeasurement* perf_counters_measurement,
     ProfilerManager* profiler_manager) const {
diff --git a/google_benchmark/src/benchmark_api_internal.h b/google_benchmark/src/benchmark_api_internal.h
@@ -59,7 +59,7 @@ class BenchmarkInstance {
 
 #ifdef CODSPEED_INSTRUMENTATION
   State RunInstrumented(
-      CodSpeed* codspeed, internal::ThreadTimer* timer,
+      codspeed::CodSpeed* codspeed, internal::ThreadTimer* timer,
       internal::ThreadManager* manager,
       internal::PerfCountersMeasurement* perf_counters_measurement,
       ProfilerManager* profiler_manager) const;
diff --git a/google_benchmark/src/benchmark_runner.cc b/google_benchmark/src/benchmark_runner.cc
@@ -466,8 +466,8 @@ void BenchmarkRunner::DoOneRepetition() {
   manager.reset(new internal::ThreadManager(b.threads()));
   internal::ThreadTimer timer = internal::ThreadTimer::Create();
   b.Setup();
-  State st = b.RunInstrumented(CodSpeed::getInstance(), &timer, manager.get(),
-                               nullptr, nullptr);
+  State st = b.RunInstrumented(codspeed::CodSpeed::getInstance(), &timer,
+                               manager.get(), nullptr, nullptr);
   b.Teardown();
 
   return;
