disable fragmentation output for peak benchmark

Author: lplewa

benchmark/benchmark.hpp

@@ -303,6 +303,9 @@ class multiple_malloc_free_benchmark : public benchmark_interface<Size, Alloc> {
         typename std::vector<next_alloc_data>::const_iterator;
     std::vector<std::unique_ptr<next_alloc_data_iterator>> next_iter;
     int64_t iterations;
+    bool log_fragmentation;
+    multiple_malloc_free_benchmark(bool log_fragmentation = true)
+        : log_fragmentation(log_fragmentation) {}
 
   public:
     void SetUp(::benchmark::State &state) override {
@@ -350,7 +353,7 @@ class multiple_malloc_free_benchmark : public benchmark_interface<Size, Alloc> {
     void TearDown(::benchmark::State &state) override {
         base::allocator.postBench(state);
         auto tid = state.thread_index();
-        if (tid == 0) {
+        if (tid == 0 && log_fragmentation) {
             size_t current_memory_allocated = 0;
             for (const auto &allocationsPerThread : allocations) {
                 for (const auto &allocation : allocationsPerThread) {
@@ -518,87 +521,88 @@ template <
 class peak_alloc_benchmark
     : public multiple_malloc_free_benchmark<Size, Alloc> {
     using base = multiple_malloc_free_benchmark<Size, Alloc>;
-    virtual void prepareWorkload(benchmark::State &state) override {
-        // Retrieve the thread index and corresponding operation buffer.
-        auto tid = state.thread_index();
-        auto &n = this->next[tid];
-
-        // Set up the random generators for index selection and decision making.
-        std::default_random_engine generator;
-        std::uniform_int_distribution<size_t> dist_offset(0,
-                                                          this->max_allocs - 1);
-        std::uniform_real_distribution<double> dist_opt_type(0, 1);
-        generator.seed(0);
-        auto sizeGenerator = this->alloc_sizes[tid];
-
-        n.clear();
-        std::vector<size_t> free;
-        std::vector<size_t> allocated;
-        free.reserve(this->max_allocs);
-        // Initially, all indices are available.
-        for (size_t i = 0; i < this->max_allocs; i++) {
-            free.push_back(i);
-        }
-
-        // Total number of allocation/free operations to simulate.
-        int64_t operations_number =
-            state.max_iterations * this->allocsPerIterations;
-        for (int64_t j = 0; j < operations_number; j++) {
-            int64_t target_allocation;
-
-            // Determine the target number of allocations based on the progress of the iterations.
-            // In the first half of the iterations, the target allocation increases linearly.
-            // In the second half, it decreases linearly.
-            if (j < operations_number / 2) {
-                target_allocation = 2 * static_cast<int64_t>(this->max_allocs) *
-                                    j / operations_number;
-            } else {
-                target_allocation = -2 *
-                                        static_cast<int64_t>(this->max_allocs) *
-                                        j / operations_number +
-                                    2 * static_cast<int64_t>(this->max_allocs);
-            }
-
-            // x represents the gap between the target and current allocations.
-            auto x = static_cast<double>(target_allocation -
-                                         static_cast<double>(allocated.size()));
-
-            // Use a normal CDF with high sigma so that when x is positive,
-            // we are slightly more likely to allocate,
-            // and when x is negative, slightly more likely to free memory,
-            // keeping the overall change gradual.
-
-            const double sigma = 1000;
-            auto cdf = normalCDF(x, sigma);
-
-            // Decide whether to allocate or free:
-            // - If no allocations exist, allocation is forced.
-            // - If there is maximum number of allocation, free is forced
-            // - Otherwise, Based on the computed probability, choose whether to allocate or free
-            if (allocated.empty() ||
-                (!free.empty() && cdf > dist_opt_type(generator))) {
-                // Allocation
-                std::swap(free[dist_offset(generator) % free.size()],
-                          free.back());
-                auto offset = free.back();
-                free.pop_back();
-                n.push_back({true, offset, sizeGenerator.nextSize()});
-                allocated.push_back(offset);
-            } else {
-                // Free
-                std::swap(allocated[dist_offset(generator) % allocated.size()],
-                          allocated.back());
-                auto offset = allocated.back();
-                allocated.pop_back();
-                n.push_back({false, offset, 0});
-                free.push_back(offset);
-            }
-        }
-
-        this->next_iter[tid] =
-            std::make_unique<std::vector<next_alloc_data>::const_iterator>(
-                n.cbegin());
-    }
+public:
+  peak_alloc_benchmark() : base(false) {}
+  virtual void prepareWorkload(benchmark::State &state) override {
+      // Retrieve the thread index and corresponding operation buffer.
+      auto tid = state.thread_index();
+      auto &n = this->next[tid];
+
+      // Set up the random generators for index selection and decision making.
+      std::default_random_engine generator;
+      std::uniform_int_distribution<size_t> dist_offset(0,
+                                                        this->max_allocs - 1);
+      std::uniform_real_distribution<double> dist_opt_type(0, 1);
+      generator.seed(0);
+      auto sizeGenerator = this->alloc_sizes[tid];
+
+      n.clear();
+      std::vector<size_t> free;
+      std::vector<size_t> allocated;
+      free.reserve(this->max_allocs);
+      // Initially, all indices are available.
+      for (size_t i = 0; i < this->max_allocs; i++) {
+          free.push_back(i);
+      }
+
+      // Total number of allocation/free operations to simulate.
+      int64_t operations_number =
+          state.max_iterations * this->allocsPerIterations;
+      for (int64_t j = 0; j < operations_number; j++) {
+          int64_t target_allocation;
+
+          // Determine the target number of allocations based on the progress of the iterations.
+          // In the first half of the iterations, the target allocation increases linearly.
+          // In the second half, it decreases linearly.
+          if (j < operations_number / 2) {
+              target_allocation = 2 * static_cast<int64_t>(this->max_allocs) *
+                                  j / operations_number;
+          } else {
+              target_allocation = -2 * static_cast<int64_t>(this->max_allocs) *
+                                      j / operations_number +
+                                  2 * static_cast<int64_t>(this->max_allocs);
+          }
+
+          // x represents the gap between the target and current allocations.
+          auto x = static_cast<double>(target_allocation -
+                                       static_cast<double>(allocated.size()));
+
+          // Use a normal CDF with high sigma so that when x is positive,
+          // we are slightly more likely to allocate,
+          // and when x is negative, slightly more likely to free memory,
+          // keeping the overall change gradual.
+
+          const double sigma = 1000;
+          auto cdf = normalCDF(x, sigma);
+
+          // Decide whether to allocate or free:
+          // - If no allocations exist, allocation is forced.
+          // - If there is maximum number of allocation, free is forced
+          // - Otherwise, Based on the computed probability, choose whether to allocate or free
+          if (allocated.empty() ||
+              (!free.empty() && cdf > dist_opt_type(generator))) {
+              // Allocation
+              std::swap(free[dist_offset(generator) % free.size()],
+                        free.back());
+              auto offset = free.back();
+              free.pop_back();
+              n.push_back({true, offset, sizeGenerator.nextSize()});
+              allocated.push_back(offset);
+          } else {
+              // Free
+              std::swap(allocated[dist_offset(generator) % allocated.size()],
+                        allocated.back());
+              auto offset = allocated.back();
+              allocated.pop_back();
+              n.push_back({false, offset, 0});
+              free.push_back(offset);
+          }
+      }
+
+      this->next_iter[tid] =
+          std::make_unique<std::vector<next_alloc_data>::const_iterator>(
+              n.cbegin());
+  }
 
     virtual void prealloc(benchmark::State &state) {
         auto tid = state.thread_index();