Precommit reformatting.

Author: alliepiper

examples/custom_iteration_spaces.cu

@@ -48,17 +48,15 @@ void copy_sweep_grid_shape(nvbench::state &state)
   thrust::device_vector<nvbench::int32_t> in(num_values, 0);
   thrust::device_vector<nvbench::int32_t> out(num_values, 0);
 
-  state.exec(
-    [block_size,
-     num_blocks,
-     num_values,
-     in_ptr  = thrust::raw_pointer_cast(in.data()),
-     out_ptr = thrust::raw_pointer_cast(out.data())](nvbench::launch &launch) {
-      nvbench::copy_kernel<<<num_blocks, block_size, 0, launch.get_stream()>>>(
-        in_ptr,
-        out_ptr,
-        num_values);
-    });
+  state.exec([block_size,
+              num_blocks,
+              num_values,
+              in_ptr  = thrust::raw_pointer_cast(in.data()),
+              out_ptr = thrust::raw_pointer_cast(out.data())](nvbench::launch &launch) {
+    nvbench::copy_kernel<<<num_blocks, block_size, 0, launch.get_stream()>>>(in_ptr,
+                                                                             out_ptr,
+                                                                             num_values);
+  });
 }
 
 //==============================================================================
@@ -100,8 +98,7 @@ struct under_diag final : nvbench::user_axis_space
   nvbench::detail::axis_space_iterator do_get_iterator(axes_info info) const
   {
     // generate our increment function
-    auto adv_func = [&, info](std::size_t &inc_index,
-                              std::size_t /*len*/) -> bool {
+    auto adv_func = [&, info](std::size_t &inc_index, std::size_t /*len*/) -> bool {
       inc_index++;
       x_pos++;
       if (x_pos == info[0].size)
@@ -114,19 +111,15 @@ struct under_diag final : nvbench::user_axis_space
     };
 
     // our update function
-    auto diag_under =
-      [&, info](std::size_t,
-                std::vector<nvbench::detail::axis_index>::iterator start,
-                std::vector<nvbench::detail::axis_index>::iterator end) {
-        start->index = x_pos;
-        end->index   = y_pos;
-      };
+    auto diag_under = [&, info](std::size_t,
+                                std::vector<nvbench::detail::axis_index>::iterator start,
+                                std::vector<nvbench::detail::axis_index>::iterator end) {
+      start->index = x_pos;
+      end->index   = y_pos;
+    };
 
     const size_t iteration_length = ((info[0].size * (info[1].size + 1)) / 2);
-    return nvbench::detail::axis_space_iterator(info,
-                                                iteration_length,
-                                                adv_func,
-                                                diag_under);
+    return nvbench::detail::axis_space_iterator(info, iteration_length, adv_func, diag_under);
   }
 
   std::size_t do_get_size(const axes_info &info) const
@@ -184,29 +177,20 @@ struct gauss final : nvbench::user_axis_space
     }
 
     // our update function
-    auto gauss_func =
-      [=](std::size_t index,
-          std::vector<nvbench::detail::axis_index>::iterator start,
-          std::vector<nvbench::detail::axis_index>::iterator) {
-        start->index = gauss_indices[index];
-      };
-
-    return nvbench::detail::axis_space_iterator(info,
-                                                iteration_length,
-                                                gauss_func);
+    auto gauss_func = [=](std::size_t index,
+                          std::vector<nvbench::detail::axis_index>::iterator start,
+                          std::vector<nvbench::detail::axis_index>::iterator) {
+      start->index = gauss_indices[index];
+    };
+
+    return nvbench::detail::axis_space_iterator(info, iteration_length, gauss_func);
   }
 
   std::size_t do_get_size(const axes_info &info) const { return info[0].size; }
 
-  std::size_t do_get_active_count(const axes_info &info) const
-  {
-    return info[0].size;
-  }
+  std::size_t do_get_active_count(const axes_info &info) const { return info[0].size; }
 
-  std::unique_ptr<iteration_space_base> do_clone() const
-  {
-    return std::make_unique<gauss>(*this);
-  }
+  std::unique_ptr<iteration_space_base> do_clone() const { return std::make_unique<gauss>(*this); }
 };
 //==============================================================================
 // Dual parameter sweep:
@@ -216,8 +200,7 @@ void dual_float64_axis(nvbench::state &state)
   const auto duration_B = state.get_float64("Duration_B");
 
   state.exec([duration_A, duration_B](nvbench::launch &launch) {
-    nvbench::sleep_kernel<<<1, 1, 0, launch.get_stream()>>>(duration_A +
-                                                            duration_B);
+    nvbench::sleep_kernel<<<1, 1, 0, launch.get_stream()>>>(duration_A + duration_B);
   });
 }
 NVBENCH_BENCH(dual_float64_axis)

nvbench/axes_metadata.cuh

@@ -41,9 +41,8 @@ namespace nvbench
 // Holds dynamic axes information.
 struct axes_metadata
 {
-  using axes_type = std::vector<std::unique_ptr<nvbench::axis_base>>;
-  using iteration_space_type =
-    std::vector<std::unique_ptr<nvbench::iteration_space_base>>;
+  using axes_type            = std::vector<std::unique_ptr<nvbench::axis_base>>;
+  using iteration_space_type = std::vector<std::unique_ptr<nvbench::iteration_space_base>>;
 
   template <typename... TypeAxes>
   explicit axes_metadata(nvbench::type_list<TypeAxes...>);
@@ -78,9 +77,8 @@ struct axes_metadata
   }
 
   template <typename... Args>
-  void add_user_iteration_axes(
-    std::function<nvbench::make_user_space_signature> make,
-    Args &&...args)
+  void add_user_iteration_axes(std::function<nvbench::make_user_space_signature> make,
+                               Args &&...args)
   {
     const std::size_t start = this->m_axes.size();
     const std::size_t count = sizeof...(Args);
@@ -132,10 +130,9 @@ private:
   iteration_space_type m_value_space;
 
   void add_zip_space(std::size_t first_index, std::size_t count);
-  void add_user_iteration_space(
-    std::function<nvbench::make_user_space_signature> make,
-    std::size_t first_index,
-    std::size_t count);
+  void add_user_iteration_space(std::function<nvbench::make_user_space_signature> make,
+                                std::size_t first_index,
+                                std::size_t count);
 };
 
 template <typename... TypeAxes>
@@ -148,14 +145,12 @@ axes_metadata::axes_metadata(nvbench::type_list<TypeAxes...>)
 
   auto names_iter = names.begin(); // contents will be moved from
   nvbench::tl::foreach<type_axes_list>(
-    [&axes = m_axes, &spaces = m_type_space, &names_iter](
-      [[maybe_unused]] auto wrapped_type) {
+    [&axes = m_axes, &spaces = m_type_space, &names_iter]([[maybe_unused]] auto wrapped_type) {
       // This is always called before other axes are added, so the length of the
       // axes vector will be the type axis index:
       const std::size_t type_axis_index = axes.size();
 
-      spaces.push_back(
-        std::make_unique<linear_axis_space>(type_axis_index));
+      spaces.push_back(std::make_unique<linear_axis_space>(type_axis_index));
 
       // Note:
       // The word "type" appears 6 times in the next line.

nvbench/axes_metadata.cxx

@@ -24,12 +24,11 @@
 
 #include <algorithm>
 #include <cassert>
+#include <iostream>
 #include <numeric>
 #include <stdexcept>
 #include <unordered_set>
 
-#include <iostream>
-
 namespace nvbench
 {
 
@@ -129,16 +128,15 @@ void axes_metadata::add_string_axis(std::string name, std::vector<std::string> d
 
 void axes_metadata::add_axis(const axis_base &axis)
 {
-  m_value_space.push_back(
-    std::make_unique<linear_axis_space>(m_axes.size()));
+  m_value_space.push_back(std::make_unique<linear_axis_space>(m_axes.size()));
   m_axes.push_back(axis.clone());
 }
 
 void axes_metadata::add_zip_space(std::size_t first_index, std::size_t count)
 {
   NVBENCH_THROW_IF((count < 2),
                    std::runtime_error,
-                   "At least two axi ( {} provided ) need to be provided "
+                   "At least two axes ( {} provided ) need to be provided "
                    "when using zip_axes.",
                    count);
 
@@ -151,13 +149,13 @@ void axes_metadata::add_zip_space(std::size_t first_index, std::size_t count)
   {
     NVBENCH_THROW_IF((m_axes[i]->get_type() == nvbench::axis_type::type),
                      std::runtime_error,
-                     "Currently no support for tieing type axis ( {} ).",
+                     "Currently no support for zipping type axis ( {} ).",
                      m_axes[i]->get_name());
 
     NVBENCH_THROW_IF((m_axes[i]->get_size() < expected_size),
                      std::runtime_error,
-                     "All axes that are tied together must be atleast as long "
-                     "the first axi provided ( {} ).",
+                     "All axes that are zipped together must be at least as long "
+                     "as the first axis provided ( {} ).",
                      expected_size);
   }
 
@@ -166,10 +164,9 @@ void axes_metadata::add_zip_space(std::size_t first_index, std::size_t count)
   m_value_space.push_back(std::move(tied));
 }
 
-void axes_metadata::add_user_iteration_space(
-  std::function<nvbench::make_user_space_signature> make,
-  std::size_t first_index,
-  std::size_t count)
+void axes_metadata::add_user_iteration_space(std::function<nvbench::make_user_space_signature> make,
+                                             std::size_t first_index,
+                                             std::size_t count)
 {
   // compute the numeric indice for each name we have
   std::vector<std::size_t> input_indices(count);

nvbench/benchmark_base.cuh

@@ -116,8 +116,8 @@ struct benchmark_base
   /// @param[axes] a set of axis_base to be added to the benchmark
   /// and zipped together
   ///
-  template<typename... Axes>
-  benchmark_base &add_zip_axes(Axes&&... axes)
+  template <typename... Axes>
+  benchmark_base &add_zip_axes(Axes &&...axes)
   {
     m_axes.add_zip_axes(std::forward<Axes>(axes)...);
     return *this;
@@ -135,8 +135,8 @@ struct benchmark_base
   /// which constructs the user iteration space, and the reseet are axis_base to be
   /// added to the benchmark and iterated using the user iteration space
   ///
-  template<typename... ConstructorAndAxes>
-  benchmark_base &add_user_iteration_axes(ConstructorAndAxes&&... args)
+  template <typename... ConstructorAndAxes>
+  benchmark_base &add_user_iteration_axes(ConstructorAndAxes &&...args)
   {
     m_axes.add_user_iteration_axes(std::forward<ConstructorAndAxes>(args)...);
     return *this;

nvbench/benchmark_base.cxx

@@ -75,13 +75,13 @@ benchmark_base &benchmark_base::add_device(int device_id)
 
 std::size_t benchmark_base::get_config_count() const
 {
-  const auto& axes = m_axes.get_axes();
-  const std::size_t value_count = nvbench::detail::transform_reduce(
-    m_axes.get_value_iteration_space().cbegin(),
-    m_axes.get_value_iteration_space().cend(),
-    std::size_t{1},
-    std::multiplies<>{},
-    [&axes](const auto &space) { return space->get_size(axes); });
+  const auto &axes = m_axes.get_axes();
+  const std::size_t value_count =
+    nvbench::detail::transform_reduce(m_axes.get_value_iteration_space().cbegin(),
+                                      m_axes.get_value_iteration_space().cend(),
+                                      std::size_t{1},
+                                      std::multiplies<>{},
+                                      [&axes](const auto &space) { return space->get_size(axes); });
 
   const std::size_t type_count = nvbench::detail::transform_reduce(
     m_axes.get_type_iteration_space().cbegin(),

nvbench/detail/axes_iterator.cuh

@@ -34,17 +34,16 @@ struct axis_index
 {
   axis_index() = default;
 
-  explicit axis_index(const axis_base *axi)
+  explicit axis_index(const axis_base *axis)
       : index(0)
-      , name(axi->get_name())
-      , type(axi->get_type())
-      , size(axi->get_size())
-      , active_size(axi->get_size())
+      , name(axis->get_name())
+      , type(axis->get_type())
+      , size(axis->get_size())
+      , active_size(axis->get_size())
   {
     if (type == nvbench::axis_type::type)
     {
-      active_size =
-        static_cast<const nvbench::type_axis *>(axi)->get_active_count();
+      active_size = static_cast<const nvbench::type_axis *>(axis)->get_active_count();
     }
   }
   std::size_t index;
@@ -62,30 +61,25 @@ struct axis_space_iterator
                                axes_info::iterator start,
                                axes_info::iterator end);
 
-  axis_space_iterator(
-    std::vector<detail::axis_index> info,
-    std::size_t iter_count,
-    std::function<axis_space_iterator::AdvanceSignature> &&advance,
-    std::function<axis_space_iterator::UpdateSignature> &&update)
+  axis_space_iterator(std::vector<detail::axis_index> info,
+                      std::size_t iter_count,
+                      std::function<axis_space_iterator::AdvanceSignature> &&advance,
+                      std::function<axis_space_iterator::UpdateSignature> &&update)
       : m_info(info)
       , m_iteration_size(iter_count)
       , m_advance(std::move(advance))
       , m_update(std::move(update))
   {}
 
-  axis_space_iterator(
-    std::vector<detail::axis_index> info,
-    std::size_t iter_count,
-    std::function<axis_space_iterator::UpdateSignature> &&update)
+  axis_space_iterator(std::vector<detail::axis_index> info,
+                      std::size_t iter_count,
+                      std::function<axis_space_iterator::UpdateSignature> &&update)
       : m_info(info)
       , m_iteration_size(iter_count)
       , m_update(std::move(update))
   {}
 
-  [[nodiscard]] bool next()
-  {
-    return this->m_advance(m_current_index, m_iteration_size);
-  }
+  [[nodiscard]] bool next() { return this->m_advance(m_current_index, m_iteration_size); }
 
   void update_indices(std::vector<axis_index> &indices) const
   {
@@ -97,8 +91,7 @@ struct axis_space_iterator
 
   axes_info m_info;
   std::size_t m_iteration_size              = 1;
-  std::function<AdvanceSignature> m_advance = [](std::size_t &current_index,
-                                                 std::size_t length) {
+  std::function<AdvanceSignature> m_advance = [](std::size_t &current_index, std::size_t length) {
     (current_index + 1 == length) ? current_index = 0 : current_index++;
     return (current_index == 0); // we rolled over
   };

nvbench/detail/state_generator.cuh

@@ -83,7 +83,7 @@ struct state_iterator
   void next();
 
   std::vector<axis_space_iterator> m_space;
-  std::size_t  m_axes_count        = 0;
+  std::size_t m_axes_count        = 0;
   std::size_t m_current_space     = 0;
   std::size_t m_current_iteration = 0;
   std::size_t m_max_iteration     = 1;