Rename to vc_aos

benchmarks/CMakeLists.txt

@@ -65,22 +65,22 @@ if( ALGEBRA_PLUGINS_INCLUDE_VC )
    target_include_directories( algebra_bench_vc_aos INTERFACE 
       "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/vc_aos/include>" )
    target_link_libraries(algebra_bench_vc_aos INTERFACE
-                                                   algebra::vc_vc
+                                                   algebra::vc_aos
                                                    algebra::common_storage)
    add_library( algebra::bench_vc_aos ALIAS algebra_bench_vc_aos )
 
    algebra_add_benchmark( vc_aos_getter
       "vc_aos/vc_aos_getter.cpp"
       LINK_LIBRARIES benchmark::benchmark algebra::bench_common
-                     algebra::bench_vc_aos algebra::vc_vc )
+                     algebra::bench_vc_aos algebra::vc_aos )
    algebra_add_benchmark( vc_aos_vector
       "vc_aos/vc_aos_vector.cpp"
       LINK_LIBRARIES benchmark::benchmark algebra::bench_common
-                     algebra::bench_vc_aos algebra::vc_vc )
+                     algebra::bench_vc_aos algebra::vc_aos )
    algebra_add_benchmark( vc_aos_transform3
       "vc_aos/vc_aos_transform3.cpp"
       LINK_LIBRARIES benchmark::benchmark algebra::bench_common
-                     algebra::bench_vc_aos algebra::vc_vc )
+                     algebra::bench_vc_aos algebra::vc_aos )
 
    if( NOT "${CMAKE_CXX_COMPILER_ID}" MATCHES "AppleClang" )
       add_library( algebra_bench_vc_soa INTERFACE )

benchmarks/array/array_getter.cpp

@@ -22,13 +22,12 @@ using namespace algebra;
 int main(int argc, char** argv) {
 
   constexpr std::size_t n_samples{160000};
-  constexpr std::size_t n_warmup{static_cast<std::size_t>(0.1 * n_samples)};
 
   //
   // Prepare benchmarks
   //
   algebra::benchmark_base::configuration cfg{};
-  cfg.n_samples(n_samples).n_warmup(n_warmup);
+  cfg.n_samples(n_samples);
   cfg.do_sleep(false);
 
   vector_unaryOP_bm<array::vector3, float, bench_op::phi> v_phi_s{cfg};

benchmarks/array/array_transform3.cpp

@@ -19,13 +19,12 @@ using namespace algebra;
 int main(int argc, char** argv) {
 
   constexpr std::size_t n_samples{160000};
-  constexpr std::size_t n_warmup{static_cast<std::size_t>(0.1 * n_samples)};
 
   //
   // Prepare benchmarks
   //
   algebra::benchmark_base::configuration cfg{};
-  cfg.n_samples(n_samples).n_warmup(n_warmup);
+  cfg.n_samples(n_samples);
   cfg.do_sleep(false);
 
   transform3_bm<array::transform3<float>> v_trf_s{cfg};
@@ -48,4 +47,4 @@ int main(int argc, char** argv) {
   ::benchmark::Initialize(&argc, argv);
   ::benchmark::RunSpecifiedBenchmarks();
   ::benchmark::Shutdown();
-}
+}

benchmarks/array/array_vector.cpp

@@ -22,13 +22,12 @@ using namespace algebra;
 int main(int argc, char** argv) {
 
   constexpr std::size_t n_samples{160000};
-  constexpr std::size_t n_warmup{static_cast<std::size_t>(0.1 * n_samples)};
 
   //
   // Prepare benchmarks
   //
   algebra::benchmark_base::configuration cfg{};
-  cfg.n_samples(n_samples).n_warmup(n_warmup);
+  cfg.n_samples(n_samples);
   cfg.do_sleep(false);
 
   vector_binaryOP_bm<array::vector3, float, bench_op::add> v_add_s{cfg};

benchmarks/common/include/benchmark/common/benchmark_base.hpp

@@ -22,13 +22,9 @@ struct benchmark_base {
   struct configuration {
     /// Size of data sample to be used in benchmark
     std::size_t m_samples{100u};
-    /// Run a number of operations before the benchmark
-    bool m_warmup = true;
     // Sleep after building data sample
     bool m_sleep = false;
-    // Size of data in warm-up round
-    std::size_t m_n_warmup{static_cast<std::size_t>(0.1f * m_samples)};
-    // Size of data in warm-up round
+    // Number of seconds to sleep
     std::size_t m_n_sleep{1u};
 
     /// Setters
@@ -37,15 +33,6 @@ struct benchmark_base {
       m_samples = n;
       return *this;
     }
-    configuration& do_warmup(bool b) {
-      m_warmup = b;
-      return *this;
-    }
-    configuration& n_warmup(std::size_t n) {
-      m_n_warmup = n;
-      m_warmup = true;
-      return *this;
-    }
     configuration& do_sleep(bool b) {
       m_sleep = b;
       return *this;
@@ -60,8 +47,6 @@ struct benchmark_base {
     /// Getters
     /// @{
     std::size_t n_samples() const { return m_samples; }
-    constexpr bool do_warmup() const { return m_warmup; }
-    constexpr std::size_t n_warmup() const { return m_n_warmup; }
     constexpr bool do_sleep() const { return m_sleep; }
     constexpr std::size_t n_sleep() const { return m_n_sleep; }
     /// @}
@@ -95,14 +80,11 @@ struct benchmark_base {
 std::ostream& operator<<(std::ostream& os,
                          const benchmark_base::configuration& cfg) {
   os << " -> running:\t " << cfg.n_samples() << " samples" << std::endl;
-  if (cfg.do_warmup()) {
-    os << " -> warmup: \t " << cfg.n_warmup() << " samples" << std::endl;
-  }
   if (cfg.do_sleep()) {
     os << " -> cool down:\t " << cfg.n_sleep() << "s" << std::endl;
   }
   os << std::endl;
   return os;
 }
 
-}  // namespace algebra
+}  // namespace algebra

benchmarks/common/include/benchmark/common/benchmark_transform3.hpp

@@ -41,9 +41,7 @@ struct transform3_bm : public vector_bm<typename transform3_t::vector3> {
   /// Construct from an externally provided configuration @param cfg
   transform3_bm(benchmark_base::configuration cfg) : base_type{cfg} {
 
-    const std::size_t n_data{this->m_cfg.n_samples() + this->m_cfg.n_warmup()};
-
-    trfs.reserve(n_data);
+    trfs.reserve(this->m_cfg.n_samples());
 
     fill_random_trf(trfs);
   }
@@ -55,7 +53,6 @@ struct transform3_bm : public vector_bm<typename transform3_t::vector3> {
   void operator()(::benchmark::State &state) override {
 
     const std::size_t n_samples{this->m_cfg.n_samples()};
-    const std::size_t n_warmup{this->m_cfg.n_warmup()};
 
     // Spin down before benchmark (Thread zero is counting the clock)
     if (state.thread_index() == 0 && this->m_cfg.do_sleep()) {
@@ -64,19 +61,11 @@ struct transform3_bm : public vector_bm<typename transform3_t::vector3> {
 
     // Run the benchmark
     for (auto _ : state) {
-      // Warm-up
-      state.PauseTiming();
-      if (this->m_cfg.do_warmup()) {
-        for (std::size_t i{0u}; i < n_warmup; ++i) {
-          ::benchmark::DoNotOptimize(
-              this->trfs[i].vector_to_global(this->a[i]));
-          benchmark::ClobberMemory();
-        }
-      }
-      state.ResumeTiming();
-
-      for (std::size_t i{n_warmup}; i < n_samples + n_warmup; ++i) {
+      for (std::size_t i{0}; i < n_samples; ++i) {
+        ::benchmark::DoNotOptimize(this->trfs[i].point_to_global(this->a[i]));
+        ::benchmark::DoNotOptimize(this->trfs[i].point_to_local(this->a[i]));
         ::benchmark::DoNotOptimize(this->trfs[i].vector_to_global(this->a[i]));
+        ::benchmark::DoNotOptimize(this->trfs[i].vector_to_local(this->a[i]));
         benchmark::ClobberMemory();
       }
     }

benchmarks/common/include/benchmark/common/benchmark_vector.hpp

@@ -37,7 +37,7 @@ struct vector_bm : public benchmark_base {
   /// Construct from an externally provided configuration @param cfg
   vector_bm(benchmark_base::configuration cfg) : benchmark_base{cfg} {
 
-    const std::size_t n_data{this->m_cfg.n_samples() + this->m_cfg.n_warmup()};
+    const std::size_t n_data{this->m_cfg.n_samples()};
 
     a.reserve(n_data);
     b.reserve(n_data);
@@ -68,7 +68,6 @@ struct vector_unaryOP_bm : public vector_bm<vector_t<scalar_t>> {
   void operator()(::benchmark::State &state) override {
 
     const std::size_t n_samples{this->m_cfg.n_samples()};
-    const std::size_t n_warmup{this->m_cfg.n_warmup()};
 
     // Spin down before benchmark (Thread zero is counting the clock)
     if (state.thread_index() == 0 && this->m_cfg.do_sleep()) {
@@ -77,17 +76,7 @@ struct vector_unaryOP_bm : public vector_bm<vector_t<scalar_t>> {
 
     // Run the benchmark
     for (auto _ : state) {
-      // Warm-up
-      state.PauseTiming();
-      if (this->m_cfg.do_warmup()) {
-        for (std::size_t i{0u}; i < n_warmup; ++i) {
-          ::benchmark::DoNotOptimize(unaryOP{}(this->a[i]));
-          benchmark::ClobberMemory();
-        }
-      }
-      state.ResumeTiming();
-
-      for (std::size_t i{n_warmup}; i < n_samples + n_warmup; ++i) {
+      for (std::size_t i{0}; i < n_samples; ++i) {
         ::benchmark::DoNotOptimize(unaryOP{}(this->a[i]));
         benchmark::ClobberMemory();
       }
@@ -110,7 +99,6 @@ struct vector_binaryOP_bm : public vector_bm<vector_t<scalar_t>> {
   void operator()(::benchmark::State &state) override {
 
     const std::size_t n_samples{this->m_cfg.n_samples()};
-    const std::size_t n_warmup{this->m_cfg.n_warmup()};
 
     // Spin down before benchmark (Thread zero is counting the clock)
     if ((state.thread_index() == 0) && this->m_cfg.do_sleep()) {
@@ -119,17 +107,7 @@ struct vector_binaryOP_bm : public vector_bm<vector_t<scalar_t>> {
 
     // Run the benchmark
     for (auto _ : state) {
-      // Warm-up
-      state.PauseTiming();
-      if (this->m_cfg.do_warmup()) {
-        for (std::size_t i{0u}; i < n_warmup; ++i) {
-          ::benchmark::DoNotOptimize(binaryOP{}(this->a[i], this->b[i]));
-          benchmark::ClobberMemory();
-        }
-      }
-      state.ResumeTiming();
-
-      for (std::size_t i{n_warmup}; i < n_samples + n_warmup; ++i) {
+      for (std::size_t i{0}; i < n_samples; ++i) {
         ::benchmark::DoNotOptimize(binaryOP{}(this->a[i], this->b[i]));
         benchmark::ClobberMemory();
       }

benchmarks/eigen/eigen_getter.cpp

@@ -22,13 +22,12 @@ using namespace algebra;
 int main(int argc, char** argv) {
 
   constexpr std::size_t n_samples{160000};
-  constexpr std::size_t n_warmup{static_cast<std::size_t>(0.1 * n_samples)};
 
   //
   // Prepare benchmarks
   //
   algebra::benchmark_base::configuration cfg{};
-  cfg.n_samples(n_samples).n_warmup(n_warmup);
+  cfg.n_samples(n_samples);
   cfg.do_sleep(false);
 
   vector_unaryOP_bm<eigen::vector3, float, bench_op::phi> v_phi_s{cfg};

benchmarks/eigen/eigen_transform3.cpp

@@ -19,13 +19,12 @@ using namespace algebra;
 int main(int argc, char** argv) {
 
   constexpr std::size_t n_samples{160000};
-  constexpr std::size_t n_warmup{static_cast<std::size_t>(0.1 * n_samples)};
 
   //
   // Prepare benchmarks
   //
   algebra::benchmark_base::configuration cfg{};
-  cfg.n_samples(n_samples).n_warmup(n_warmup);
+  cfg.n_samples(n_samples);
   cfg.do_sleep(false);
 
   transform3_bm<eigen::transform3<float>> v_trf_s{cfg};
@@ -48,4 +47,4 @@ int main(int argc, char** argv) {
   ::benchmark::Initialize(&argc, argv);
   ::benchmark::RunSpecifiedBenchmarks();
   ::benchmark::Shutdown();
-}
+}

benchmarks/eigen/eigen_vector.cpp

@@ -22,13 +22,12 @@ using namespace algebra;
 int main(int argc, char** argv) {
 
   constexpr std::size_t n_samples{160000};
-  constexpr std::size_t n_warmup{static_cast<std::size_t>(0.1 * n_samples)};
 
   //
   // Prepare benchmarks
   //
   algebra::benchmark_base::configuration cfg{};
-  cfg.n_samples(n_samples).n_warmup(n_warmup);
+  cfg.n_samples(n_samples);
   cfg.do_sleep(false);
 
   vector_binaryOP_bm<eigen::vector3, float, bench_op::add> v_add_s{cfg};

benchmarks/vc_aos/include/benchmark/vc_aos/data_generator.hpp

@@ -8,7 +8,7 @@
 #pragma once
 
 // Project include(s)
-#include "algebra/vc_vc.hpp"
+#include "algebra/vc_aos.hpp"
 
 // System include(s)
 #include <algorithm>

benchmarks/vc_aos/vc_aos_getter.cpp

@@ -6,7 +6,7 @@
  */
 
 // Project include(s)
-#include "algebra/vc_vc.hpp"
+#include "algebra/vc_aos.hpp"
 #include "benchmark/common/benchmark_getter.hpp"
 #include "benchmark/vc_aos/data_generator.hpp"
 
@@ -22,13 +22,12 @@ using namespace algebra;
 int main(int argc, char** argv) {
 
   constexpr std::size_t n_samples{160000};
-  constexpr std::size_t n_warmup{static_cast<std::size_t>(0.1 * n_samples)};
 
   //
   // Prepare benchmarks
   //
   algebra::benchmark_base::configuration cfg{};
-  cfg.n_samples(n_samples).n_warmup(n_warmup);
+  cfg.n_samples(n_samples);
   cfg.do_sleep(false);
 
   vector_unaryOP_bm<vc::vector3, float, bench_op::phi> v_phi_s{cfg};

benchmarks/vc_aos/vc_aos_transform3.cpp

@@ -6,7 +6,7 @@
  */
 
 // Project include(s)
-#include "algebra/vc_vc.hpp"
+#include "algebra/vc_aos.hpp"
 #include "benchmark/common/benchmark_transform3.hpp"
 #include "benchmark/vc_aos/data_generator.hpp"
 
@@ -24,8 +24,7 @@ int main(int argc, char** argv) {
   // Prepare benchmarks
   //
   algebra::benchmark_base::configuration cfg{};
-  cfg.n_samples(n_samples).n_warmup(
-      static_cast<std::size_t>(0.1 * cfg.n_samples()));
+  cfg.n_samples(n_samples);
   cfg.do_sleep(false);
 
   transform3_bm<vc::transform3<float>> v_trf_s{cfg};

benchmarks/vc_aos/vc_aos_vector.cpp

@@ -6,7 +6,7 @@
  */
 
 // Project include(s)
-#include "algebra/vc_vc.hpp"
+#include "algebra/vc_aos.hpp"
 #include "benchmark/common/benchmark_vector.hpp"
 #include "benchmark/vc_aos/data_generator.hpp"
 
@@ -24,8 +24,7 @@ int main(int argc, char** argv) {
   // Prepare benchmarks
   //
   algebra::benchmark_base::configuration cfg{};
-  cfg.n_samples(n_samples).n_warmup(
-      static_cast<std::size_t>(0.1 * cfg.n_samples()));
+  cfg.n_samples(n_samples);
   cfg.do_sleep(false);
 
   vector_binaryOP_bm<vc::vector3, float, bench_op::add> v_add_s{cfg};

benchmarks/vc_soa/vc_soa_getter.cpp

@@ -29,14 +29,12 @@ int main(int argc, char** argv) {
   algebra::benchmark_base::configuration cfg_s{};
   // Reduce the number of samples, since a single SoA struct contains multiple
   // vectors
-  cfg_s.n_samples(n_samples / Vc::float_v::Size)
-      .n_warmup(static_cast<std::size_t>(0.1 * cfg_s.n_samples()));
+  cfg_s.n_samples(n_samples / Vc::float_v::Size);
   cfg_s.do_sleep(false);
 
   // For double precision we need more samples (less vectors per SoA)
   algebra::benchmark_base::configuration cfg_d{cfg_s};
-  cfg_d.n_samples(n_samples / Vc::double_v::Size)
-      .n_warmup(static_cast<std::size_t>(0.1 * cfg_d.n_samples()));
+  cfg_d.n_samples(n_samples / Vc::double_v::Size);
 
   vector_unaryOP_bm<vc_soa::vector3, float, bench_op::phi> v_phi_s{cfg_s};
   vector_unaryOP_bm<vc_soa::vector3, float, bench_op::theta> v_theta_s{cfg_s};