Fixed memory leak and formatting issues.

include/benchmark/benchmark.h

@@ -930,7 +930,7 @@ class BENCHMARK_EXPORT State {
     return max_iterations - total_iterations_ + batch_leftover_;
   }
 
- BENCHMARK_ALWAYS_INLINE
+  BENCHMARK_ALWAYS_INLINE
   int GetNumThreadStates() const { return num_thread_states_; }
 
   BENCHMARK_ALWAYS_INLINE
@@ -998,6 +998,7 @@ class BENCHMARK_EXPORT ThreadState : public State {
  public:
   explicit ThreadState(State& s);
   ~ThreadState();
+
  private:
   State* parent_;
 
@@ -1294,8 +1295,12 @@ class BENCHMARK_EXPORT Benchmark {
   // Equivalent to ThreadRange(NumCPUs(), NumCPUs())
   Benchmark* ThreadPerCpu();
 
-  // Don't create threads. Let the user evaluate state.threads and/or use ThreadState.
-  Benchmark* ManualThreading() { manual_threading_ = true; return this; }
+  // Don't create threads. Let the user evaluate state.threads and/or use
+  // ThreadState.
+  Benchmark* ManualThreading() {
+    manual_threading_ = true;
+    return this;
+  }
 
   virtual void Run(State& state) = 0;
 

src/benchmark.cc

@@ -333,8 +333,11 @@ ThreadState::ThreadState(State& s) : State(s), parent_(&s) {
   BM_CHECK(!started())
       << "Don't create a ThreadState object after measurement has started";
   timer_ = new internal::ThreadTimer(*timer_);
-  perf_counters_measurement_ = new internal::PerfCountersMeasurement(
-      perf_counters_measurement_->names());
+  if (perf_counters_measurement_)
+  {
+      perf_counters_measurement_ = new internal::PerfCountersMeasurement(
+          perf_counters_measurement_->names());
+  }
 }
 
 ThreadState::~ThreadState() {
@@ -342,6 +345,7 @@ ThreadState::~ThreadState() {
       << "Benchmark returned before ThreadState::KeepRunning() returned false!";
   MergeThreadStateToParent(*parent_);
   delete timer_;
+  delete perf_counters_measurement_;
 }
 
 namespace internal {

src/benchmark_api_internal.h

@@ -84,7 +84,8 @@ bool FindBenchmarksInternal(const std::string& re,
 
 bool IsZero(double n);
 
-void MergeResults(const State& st, const ThreadTimer* timer,    // only call while holding benchmark_mutex_
+// only call while holding benchmark_mutex_:
+void MergeResults(const State& st, const ThreadTimer* timer,
                   ThreadManager* manager) NO_THREAD_SAFETY_ANALYSIS;
 
 BENCHMARK_EXPORT

test/manual_threading_test.cc

@@ -2,8 +2,8 @@
 #undef NDEBUG
 
 #include <chrono>
-#include <thread>
 #include <future>
+#include <thread>
 
 #include "../src/timers.h"
 #include "benchmark/benchmark.h"
@@ -30,7 +30,7 @@ void MyBusySpinwait() {
   }
 }
 
-}
+}  // namespace
 
 // ========================================================================= //
 // --------------------------- TEST CASES BEGIN ---------------------------- //
@@ -42,17 +42,15 @@ void MyBusySpinwait() {
 
 void BM_ManualThreadingInLoop(benchmark::State& state) {
   int numWorkerThreads = state.threads() - 1;
-  std::vector<std::thread> pool (numWorkerThreads);
+  std::vector<std::thread> pool(numWorkerThreads);
 
   for (auto _ : state) {
 
-    for (int i = 0; i < numWorkerThreads; ++i)
-    {
+    for (int i = 0; i < numWorkerThreads; ++i) {
       pool[i] = std::thread(MyBusySpinwait);
     }
     MyBusySpinwait();
-    for (int i = 0; i < numWorkerThreads; ++i)
-    {
+    for (int i = 0; i < numWorkerThreads; ++i) {
       pool[i].join();
     }
     state.SetIterationTime(time_frame_in_sec);
@@ -61,10 +59,25 @@ void BM_ManualThreadingInLoop(benchmark::State& state) {
       benchmark::Counter{1, benchmark::Counter::kIsRate};
 }
 
-BENCHMARK(BM_ManualThreadingInLoop)->Iterations(1)->ManualThreading()->Threads(1);
-BENCHMARK(BM_ManualThreadingInLoop)->Iterations(1)->ManualThreading()->Threads(1)->UseRealTime();
-BENCHMARK(BM_ManualThreadingInLoop)->Iterations(1)->ManualThreading()->Threads(1)->UseManualTime();
-BENCHMARK(BM_ManualThreadingInLoop)->Iterations(1)->ManualThreading()->Threads(1)->MeasureProcessCPUTime();
+BENCHMARK(BM_ManualThreadingInLoop)
+    ->Iterations(1)
+    ->ManualThreading()
+    ->Threads(1);
+BENCHMARK(BM_ManualThreadingInLoop)
+    ->Iterations(1)
+    ->ManualThreading()
+    ->Threads(1)
+    ->UseRealTime();
+BENCHMARK(BM_ManualThreadingInLoop)
+    ->Iterations(1)
+    ->ManualThreading()
+    ->Threads(1)
+    ->UseManualTime();
+BENCHMARK(BM_ManualThreadingInLoop)
+    ->Iterations(1)
+    ->ManualThreading()
+    ->Threads(1)
+    ->MeasureProcessCPUTime();
 BENCHMARK(BM_ManualThreadingInLoop)
     ->Iterations(1)
     ->ManualThreading()
@@ -78,10 +91,25 @@ BENCHMARK(BM_ManualThreadingInLoop)
     ->MeasureProcessCPUTime()
     ->UseManualTime();
 
-BENCHMARK(BM_ManualThreadingInLoop)->Iterations(1)->ManualThreading()->Threads(2);
-BENCHMARK(BM_ManualThreadingInLoop)->Iterations(1)->ManualThreading()->Threads(2)->UseRealTime();
-BENCHMARK(BM_ManualThreadingInLoop)->Iterations(1)->ManualThreading()->Threads(2)->UseManualTime();
-BENCHMARK(BM_ManualThreadingInLoop)->Iterations(1)->ManualThreading()->Threads(2)->MeasureProcessCPUTime();
+BENCHMARK(BM_ManualThreadingInLoop)
+    ->Iterations(1)
+    ->ManualThreading()
+    ->Threads(2);
+BENCHMARK(BM_ManualThreadingInLoop)
+    ->Iterations(1)
+    ->ManualThreading()
+    ->Threads(2)
+    ->UseRealTime();
+BENCHMARK(BM_ManualThreadingInLoop)
+    ->Iterations(1)
+    ->ManualThreading()
+    ->Threads(2)
+    ->UseManualTime();
+BENCHMARK(BM_ManualThreadingInLoop)
+    ->Iterations(1)
+    ->ManualThreading()
+    ->Threads(2)
+    ->MeasureProcessCPUTime();
 BENCHMARK(BM_ManualThreadingInLoop)
     ->Iterations(1)
     ->ManualThreading()
@@ -97,10 +125,10 @@ BENCHMARK(BM_ManualThreadingInLoop)
 
 // ========================================================================= //
 // BM_ManualThreadingBeforeLoop
-// Creation of threads is done before the start of the measurement, joining after the finish of the measurement.
+// Creation of threads is done before the start of the measurement,
+// joining after the finish of the measurement.
 
 void BM_ManualThreadingBeforeLoop(benchmark::State& state) {
-
   std::promise<void> thread_starter;
   auto starter_future = thread_starter.get_future();
 
@@ -113,14 +141,12 @@ void BM_ManualThreadingBeforeLoop(benchmark::State& state) {
     }
   };
 
-  std::vector<std::thread> pool (state.threads());
-  for (int i = 0; i < state.threads(); ++i)
-  {
+  std::vector<std::thread> pool(state.threads());
+  for (int i = 0; i < state.threads(); ++i) {
     pool[i] = std::thread(threadedLoop);
   }
   thread_starter.set_value();
-  for (int i = 0; i < state.threads(); ++i)
-  {
+  for (int i = 0; i < state.threads(); ++i) {
     pool[i].join();
   }
 
@@ -128,10 +154,25 @@ void BM_ManualThreadingBeforeLoop(benchmark::State& state) {
       benchmark::Counter{1, benchmark::Counter::kIsRate};
 }
 
-BENCHMARK(BM_ManualThreadingBeforeLoop)->Iterations(1)->ManualThreading()->Threads(1);
-BENCHMARK(BM_ManualThreadingBeforeLoop)->Iterations(1)->ManualThreading()->Threads(1)->UseRealTime();
-BENCHMARK(BM_ManualThreadingBeforeLoop)->Iterations(1)->ManualThreading()->Threads(1)->UseManualTime();
-BENCHMARK(BM_ManualThreadingBeforeLoop)->Iterations(1)->ManualThreading()->Threads(1)->MeasureProcessCPUTime();
+BENCHMARK(BM_ManualThreadingBeforeLoop)
+    ->Iterations(1)
+    ->ManualThreading()
+    ->Threads(1);
+BENCHMARK(BM_ManualThreadingBeforeLoop)
+    ->Iterations(1)
+    ->ManualThreading()
+    ->Threads(1)
+    ->UseRealTime();
+BENCHMARK(BM_ManualThreadingBeforeLoop)
+    ->Iterations(1)
+    ->ManualThreading()
+    ->Threads(1)
+    ->UseManualTime();
+BENCHMARK(BM_ManualThreadingBeforeLoop)
+    ->Iterations(1)
+    ->ManualThreading()
+    ->Threads(1)
+    ->MeasureProcessCPUTime();
 BENCHMARK(BM_ManualThreadingBeforeLoop)
     ->Iterations(1)
     ->ManualThreading()
@@ -145,10 +186,25 @@ BENCHMARK(BM_ManualThreadingBeforeLoop)
     ->MeasureProcessCPUTime()
     ->UseManualTime();
 
-BENCHMARK(BM_ManualThreadingBeforeLoop)->Iterations(1)->ManualThreading()->Threads(2);
-BENCHMARK(BM_ManualThreadingBeforeLoop)->Iterations(1)->ManualThreading()->Threads(2)->UseRealTime();
-BENCHMARK(BM_ManualThreadingBeforeLoop)->Iterations(1)->ManualThreading()->Threads(2)->UseManualTime();
-BENCHMARK(BM_ManualThreadingBeforeLoop)->Iterations(1)->ManualThreading()->Threads(2)->MeasureProcessCPUTime();
+BENCHMARK(BM_ManualThreadingBeforeLoop)
+    ->Iterations(1)
+    ->ManualThreading()
+    ->Threads(2);
+BENCHMARK(BM_ManualThreadingBeforeLoop)
+    ->Iterations(1)
+    ->ManualThreading()
+    ->Threads(2)
+    ->UseRealTime();
+BENCHMARK(BM_ManualThreadingBeforeLoop)
+    ->Iterations(1)
+    ->ManualThreading()
+    ->Threads(2)
+    ->UseManualTime();
+BENCHMARK(BM_ManualThreadingBeforeLoop)
+    ->Iterations(1)
+    ->ManualThreading()
+    ->Threads(2)
+    ->MeasureProcessCPUTime();
 BENCHMARK(BM_ManualThreadingBeforeLoop)
     ->Iterations(1)
     ->ManualThreading()