move benchmark to internal namespace

include/benchmark/benchmark.h

@@ -37,6 +37,68 @@ inline void SetLabel(std::string const& label) {
     SetLabel(label.c_str());
 }
 
+// ------------------------------------------------------
+// Benchmarks reporter interface + data containers.
+
+// Interface for custom benchmark result printers.
+// By default, benchmark reports are printed to stdout. However an application
+// can control the destination of the reports by calling
+// RunMatchingBenchmarks and passing it a custom reporter object.
+// The reporter object must implement the following interface.
+class BenchmarkReporter {
+ public:
+  struct Context {
+    int num_cpus;
+    double mhz_per_cpu;
+    bool cpu_scaling_enabled;
+
+    // The number of chars in the longest benchmark name.
+    int name_field_width;
+  };
+
+  struct Run {
+    Run() :
+      iters(1),
+      real_accumulated_time(0),
+      cpu_accumulated_time(0),
+      bytes_per_second(0),
+      items_per_second(0),
+      max_heapbytes_used(0) {}
+
+    std::string benchmark_name;
+    std::string report_label;  // Empty if not set by benchmark.
+    int64_t iters;
+    double real_accumulated_time;
+    double cpu_accumulated_time;
+
+    // Zero if not set by benchmark.
+    double bytes_per_second;
+    double items_per_second;
+
+    // This is set to 0.0 if memory tracing is not enabled.
+    double max_heapbytes_used;
+  };
+
+  // Called once for every suite of benchmarks run.
+  // The parameter "context" contains information that the
+  // reporter may wish to use when generating its report, for example the
+  // platform under which the benchmarks are running. The benchmark run is
+  // never started if this function returns false, allowing the reporter
+  // to skip runs based on the context information.
+  virtual bool ReportContext(const Context& context) = 0;
+
+  // Called once for each group of benchmark runs, gives information about
+  // cpu-time and heap memory usage during the benchmark run.
+  // Note that all the grouped benchmark runs should refer to the same
+  // benchmark, thus have the same name.
+  virtual void ReportRuns(const std::vector<Run>& report) const = 0;
+
+  virtual ~BenchmarkReporter();
+};
+
+namespace internal {
+
+
 class Benchmark {
  public:
   // The Benchmark takes ownership of the Callback pointed to by f.
@@ -129,67 +191,6 @@ class Benchmark {
   BENCHMARK_DISALLOW_COPY_AND_ASSIGN(Benchmark);
 };
 
-// ------------------------------------------------------
-// Benchmarks reporter interface + data containers.
-
-// Interface for custom benchmark result printers.
-// By default, benchmark reports are printed to stdout. However an application
-// can control the destination of the reports by calling
-// RunMatchingBenchmarks and passing it a custom reporter object.
-// The reporter object must implement the following interface.
-class BenchmarkReporter {
- public:
-  struct Context {
-    int num_cpus;
-    double mhz_per_cpu;
-    bool cpu_scaling_enabled;
-
-    // The number of chars in the longest benchmark name.
-    int name_field_width;
-  };
-
-  struct Run {
-    Run() :
-      iters(1),
-      real_accumulated_time(0),
-      cpu_accumulated_time(0),
-      bytes_per_second(0),
-      items_per_second(0),
-      max_heapbytes_used(0) {}
-
-    std::string benchmark_name;
-    std::string report_label;  // Empty if not set by benchmark.
-    int64_t iters;
-    double real_accumulated_time;
-    double cpu_accumulated_time;
-
-    // Zero if not set by benchmark.
-    double bytes_per_second;
-    double items_per_second;
-
-    // This is set to 0.0 if memory tracing is not enabled.
-    double max_heapbytes_used;
-  };
-
-  // Called once for every suite of benchmarks run.
-  // The parameter "context" contains information that the
-  // reporter may wish to use when generating its report, for example the
-  // platform under which the benchmarks are running. The benchmark run is
-  // never started if this function returns false, allowing the reporter
-  // to skip runs based on the context information.
-  virtual bool ReportContext(const Context& context) = 0;
-
-  // Called once for each group of benchmark runs, gives information about
-  // cpu-time and heap memory usage during the benchmark run.
-  // Note that all the grouped benchmark runs should refer to the same
-  // benchmark, thus have the same name.
-  virtual void ReportRuns(const std::vector<Run>& report) const = 0;
-
-  virtual ~BenchmarkReporter();
-};
-
-namespace internal {
-
 // Run all benchmarks whose name is a partial match for the regular
 // expression in "spec". The results of benchmark runs are fed to "reporter".
 void RunMatchingBenchmarks(const std::string& spec,

include/benchmark/minimal_benchmark.h

@@ -188,8 +188,6 @@ namespace internal {
 void StartBenchmarkTiming();
 void StopBenchmarkTiming();
 
-} // end namespace internal
-
 // ------------------------------------------------------
 // Benchmark registration object.  The BENCHMARK() macro expands
 // into a benchmark::Benchmark* object.  Various methods can
@@ -199,6 +197,7 @@ void StopBenchmarkTiming();
 
 class Benchmark;
 
+} // end namespace internal
 
 // State is passed to a running Benchmark and contains state for the
 // benchmark to use.
@@ -399,7 +398,7 @@ public:
   // Pass this benchmark object to *func, which can customize
   // the benchmark by calling various methods like Arg, ArgPair,
   // Threads, etc.
-  MinimalBenchmark& Apply(void (*func)(Benchmark* benchmark));
+  MinimalBenchmark& Apply(void (*func)(internal::Benchmark* benchmark));
 
   // Support for running multiple copies of the same benchmark concurrently
   // in multiple threads.  This may be useful when measuring the scaling
@@ -428,14 +427,14 @@ public:
   MinimalBenchmark* operator->() {
     return this;
   }
-  operator Benchmark*() {
-    Benchmark *tmp = imp_;
+  operator internal::Benchmark*() {
+    internal::Benchmark *tmp = imp_;
     imp_ = nullptr;
     return tmp;
   }
 
 private:
-  Benchmark *imp_;
+  internal::Benchmark *imp_;
   BENCHMARK_DISALLOW_COPY_AND_ASSIGN(MinimalBenchmark);
 };
 
@@ -449,8 +448,8 @@ private:
 #define BENCHMARK_CONCAT(a, b, c) BENCHMARK_CONCAT2(a, b, c)
 #define BENCHMARK_CONCAT2(a, b, c) a ## b ## c
 
-#define BENCHMARK(n)                                                    \
-  static ::benchmark::Benchmark*                                          \
+#define BENCHMARK(n)                                                   \
+  static ::benchmark::internal::Benchmark*                             \
   BENCHMARK_CONCAT(_benchmark_, n, __LINE__) BENCHMARK_UNUSED =        \
   (::benchmark::MinimalBenchmark(#n, &n))
 
@@ -473,18 +472,18 @@ private:
 // template arguments.
 #if __cplusplus < 201103L
 # define BENCHMARK_TEMPLATE(n, a)                                           \
-    static ::benchmark::Benchmark*                                          \
+    static ::benchmark::internal::Benchmark*                                \
     BENCHMARK_CONCAT(_benchmark_, n, __LINE__) BENCHMARK_UNUSED =           \
     (::benchmark::MinimalBenchmark(#n "<" #a ">", &n<a>))
 #else
 # define BENCHMARK_TEMPLATE(n, ...)                                           \
-    static ::benchmark::Benchmark*                                            \
+    static ::benchmark::internal::Benchmark*                                  \
     BENCHMARK_CONCAT(_benchmark_, n, __LINE__) BENCHMARK_UNUSED =             \
     (::benchmark::MinimalBenchmark(#n "<" #__VA_ARGS__ ">", &n<__VA_ARGS__>))
 #endif
 
 #define BENCHMARK_TEMPLATE2(n, a, b)                                      \
-  static ::benchmark::Benchmark*                                          \
+  static ::benchmark::internal::Benchmark*                                \
   BENCHMARK_CONCAT(__benchmark_, n, __LINE__) BENCHMARK_UNUSED =          \
   (::benchmark::MinimalBenchmark(#n "<" #a "," #b ">",                    \
                                &n<a, b>))

src/benchmark.cc

@@ -128,7 +128,7 @@ GetBenchmarkLock()
 
 // List of all registered benchmarks.  Note that each registered
 // benchmark identifies a family of related benchmarks to run.
-static std::vector<Benchmark*>* families = NULL;
+static std::vector<internal::Benchmark*>* families = NULL;
 
 struct ThreadStats {
     ThreadStats() : bytes_processed(0), items_processed(0) {}
@@ -265,6 +265,8 @@ class TimerManager {
 // TimerManager for current run.
 static TimerManager* timer_manager = nullptr;
 
+namespace internal {
+
 const int Benchmark::kNumCpuMarker;
 
 // Information kept per benchmark we may want to run
@@ -468,6 +470,7 @@ void Benchmark::FindBenchmarks(
   }
 }
 
+} // end namespace internal
 
 namespace {
 
@@ -511,7 +514,7 @@ static bool CpuScalingEnabled() {
 
 // Execute one thread of benchmark b for the specified number of iterations.
 // Adds the stats collected for the thread into *total.
-void RunInThread(const benchmark::Benchmark::Instance* b,
+void RunInThread(const benchmark::internal::Benchmark::Instance* b,
                  int iters, int thread_id,
                  ThreadStats* total) EXCLUDES(GetBenchmarkLock()) {
   State st(iters, b->has_arg1, b->arg1, b->has_arg2, b->arg2, thread_id);
@@ -526,7 +529,7 @@ void RunInThread(const benchmark::Benchmark::Instance* b,
   timer_manager->Finalize();
 }
 
-void RunBenchmark(const benchmark::Benchmark::Instance& b,
+void RunBenchmark(const benchmark::internal::Benchmark::Instance& b,
                   BenchmarkReporter* br) EXCLUDES(GetBenchmarkLock()) {
   int iters = FLAGS_benchmark_min_iters;
   std::vector<BenchmarkReporter::Run> reports;
@@ -817,8 +820,8 @@ void RunMatchingBenchmarks(const std::string& spec,
     << " must be less than or equal to -benchmark_max_iters="
     << FLAGS_benchmark_max_iters;
 
-  std::vector<benchmark::Benchmark::Instance> benchmarks;
-  benchmark::Benchmark::FindBenchmarks(spec, &benchmarks);
+  std::vector<benchmark::internal::Benchmark::Instance> benchmarks;
+  benchmark::internal::Benchmark::FindBenchmarks(spec, &benchmarks);
 
 
   // Determine the width of the name field using a minimum width of 10.
@@ -850,8 +853,8 @@ void FindMatchingBenchmarkNames(const std::string& spec,
                                 std::vector<std::string>* benchmark_names) {
   if (spec.empty()) return;
 
-  std::vector<benchmark::Benchmark::Instance> benchmarks;
-  benchmark::Benchmark::FindBenchmarks(spec, &benchmarks);
+  std::vector<benchmark::internal::Benchmark::Instance> benchmarks;
+  benchmark::internal::Benchmark::FindBenchmarks(spec, &benchmarks);
   for (const auto& bench_instance : benchmarks) {
     benchmark_names->push_back(bench_instance.name);
   }

src/minimal_benchmark.cc

@@ -18,7 +18,7 @@
 namespace benchmark {
 
 MinimalBenchmark::MinimalBenchmark(const char* name, Function* f)
-  : imp_(new Benchmark(name, f))
+  : imp_(new internal::Benchmark(name, f))
 { }
 
 MinimalBenchmark::~MinimalBenchmark() {
@@ -52,7 +52,7 @@ MinimalBenchmark& MinimalBenchmark::RangePair(int lo1, int hi1, int lo2,
   return *this;
 }
 
-MinimalBenchmark& MinimalBenchmark::Apply(void (*func)(Benchmark*)) {
+MinimalBenchmark& MinimalBenchmark::Apply(void (*func)(internal::Benchmark*)) {
   imp_->Apply(func);
   return *this;
 }