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

Author: GuillaumeLagrange

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

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

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

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

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

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();

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 {

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;

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;