Refactoring / renaming.

Author: alliepiper

examples/custom_iteration_spaces.cu

@@ -96,13 +96,13 @@ struct under_diag final : nvbench::user_axis_space
   mutable std::size_t y_pos   = 0;
   mutable std::size_t x_start = 0;
 
-  nvbench::detail::axis_space_iterator do_get_iterator(axes_info info) const
+  nvbench::detail::axis_space_iterator do_get_iterator(axis_value_indices info) const
   {
     // generate our increment function
     auto adv_func = [&, info](std::size_t &inc_index, std::size_t /*len*/) -> bool {
       inc_index++;
       x_pos++;
-      if (x_pos == info[0].size)
+      if (x_pos == info[0].axis_size)
       {
         x_pos = ++x_start;
         y_pos = x_start;
@@ -112,25 +112,24 @@ 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, axis_value_indices::iterator start, axis_value_indices::iterator end) {
+        start->value_index = x_pos;
+        end->value_index   = y_pos;
+      };
 
-    const size_t iteration_length = ((info[0].size * (info[1].size + 1)) / 2);
+    const size_t iteration_length = ((info[0].axis_size * (info[1].axis_size + 1)) / 2);
     return nvbench::detail::axis_space_iterator(info, iteration_length, adv_func, diag_under);
   }
 
-  std::size_t do_get_size(const axes_info &info) const
+  std::size_t do_get_size(const axis_value_indices &info) const
   {
-    return ((info[0].size * (info[1].size + 1)) / 2);
+    return ((info[0].axis_size * (info[1].axis_size + 1)) / 2);
   }
 
-  std::size_t do_get_active_count(const axes_info &info) const
+  std::size_t do_get_active_count(const axis_value_indices &info) const
   {
-    return ((info[0].size * (info[1].size + 1)) / 2);
+    return ((info[0].axis_size * (info[1].axis_size + 1)) / 2);
   }
 
   std::unique_ptr<nvbench::iteration_space_base> do_clone() const
@@ -160,36 +159,38 @@ struct gauss final : nvbench::user_axis_space
       : nvbench::user_axis_space(std::move(input_indices))
   {}
 
-  nvbench::detail::axis_space_iterator do_get_iterator(axes_info info) const
+  nvbench::detail::axis_space_iterator do_get_iterator(axis_value_indices info) const
   {
-    const double mid_point = static_cast<double>((info[0].size / 2));
+    const double mid_point = static_cast<double>((info[0].axis_size / 2));
 
     std::random_device rd{};
     std::mt19937 gen{rd()};
     std::normal_distribution<> d{mid_point, 2};
 
-    const size_t iteration_length = info[0].size;
+    const size_t iteration_length = info[0].axis_size;
     std::vector<std::size_t> gauss_indices(iteration_length);
     for (auto &g : gauss_indices)
     {
-      auto v = std::min(static_cast<double>(info[0].size), d(gen));
+      auto v = std::min(static_cast<double>(info[0].axis_size), d(gen));
       v      = std::max(0.0, v);
       g      = static_cast<std::size_t>(v);
     }
 
     // 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];
-    };
+    auto gauss_func =
+      [=](std::size_t index, axis_value_indices::iterator start, axis_value_indices::iterator) {
+        start->value_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_size(const axis_value_indices &info) const { return info[0].axis_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 axis_value_indices &info) const
+  {
+    return info[0].axis_size;
+  }
 
   std::unique_ptr<iteration_space_base> do_clone() const { return std::make_unique<gauss>(*this); }
 };

nvbench/detail/axis_space_iterator.cuh

@@ -30,76 +30,86 @@ namespace nvbench
 namespace detail
 {
 
-struct axis_index
+// Tracks current value and axis information used while iterating through axes.
+struct axis_value_index
 {
-  axis_index() = default;
-
-  explicit axis_index(const axis_base *axis)
-      : index(0)
-      , 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 *>(axis)->get_active_count();
-    }
-  }
-  std::size_t index;
-  std::string name;
-  nvbench::axis_type type;
-  std::size_t size;
-  std::size_t active_size;
+  axis_value_index() = default;
+
+  explicit axis_value_index(const axis_base *axis)
+      : value_index(0)
+      , axis_name(axis->get_name())
+      , axis_type(axis->get_type())
+      , axis_size(axis->get_size())
+      , axis_active_size(axis_type == nvbench::axis_type::type
+                           ? static_cast<const nvbench::type_axis *>(axis)->get_active_count()
+                           : axis->get_size())
+  {}
+
+  std::size_t value_index;
+  std::string axis_name;
+  nvbench::axis_type axis_type;
+  std::size_t axis_size;
+  std::size_t axis_active_size;
 };
 
 struct axis_space_iterator
 {
-  using axes_info        = std::vector<detail::axis_index>;
-  using AdvanceSignature = bool(std::size_t &current_index, std::size_t length);
-  using UpdateSignature  = void(std::size_t index,
-                               axes_info::iterator start,
-                               axes_info::iterator end);
+  using axis_value_indices = std::vector<detail::axis_value_index>;
+  using advance_signature  = bool(std::size_t &current_iteration, std::size_t iteration_size);
+  using update_signature   = void(std::size_t current_iteration,
+                                axis_value_indices::iterator start_axis_value_info,
+                                axis_value_indices::iterator end_axis_value_info);
 
-  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)
+  axis_space_iterator(axis_value_indices info,
+                      std::size_t iteration_size,
+                      std::function<axis_space_iterator::advance_signature> &&advance,
+                      std::function<axis_space_iterator::update_signature> &&update)
+      : m_iteration_size(iteration_size)
+      , m_axis_value_indices(std::move(info))
       , m_advance(std::move(advance))
       , m_update(std::move(update))
   {}
 
-  axis_space_iterator(std::vector<detail::axis_index> info,
+  axis_space_iterator(axis_value_indices info,
                       std::size_t iter_count,
-                      std::function<axis_space_iterator::UpdateSignature> &&update)
-      : m_info(info)
-      , m_iteration_size(iter_count)
+                      std::function<axis_space_iterator::update_signature> &&update)
+      : m_iteration_size(iter_count)
+      , m_axis_value_indices(std::move(info))
       , m_update(std::move(update))
   {}
 
-  [[nodiscard]] bool next() { return this->m_advance(m_current_index, m_iteration_size); }
+  [[nodiscard]] bool next() { return m_advance(m_current_iteration, m_iteration_size); }
 
-  void update_indices(std::vector<axis_index> &indices) const
+  void update_axis_value_indices(axis_value_indices &info) const
   {
-    using diff_t = typename axes_info::difference_type;
-    indices.insert(indices.end(), m_info.begin(), m_info.end());
-    axes_info::iterator end   = indices.end();
-    axes_info::iterator start = end - static_cast<diff_t>(m_info.size());
-    this->m_update(m_current_index, start, end);
+    using diff_t = typename axis_value_indices::difference_type;
+    info.insert(info.end(), m_axis_value_indices.begin(), m_axis_value_indices.end());
+    axis_value_indices::iterator end   = info.end();
+    axis_value_indices::iterator start = end - static_cast<diff_t>(m_axis_value_indices.size());
+    m_update(m_current_iteration, start, end);
   }
 
-  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) {
-    (current_index + 1 == length) ? current_index = 0 : current_index++;
-    return (current_index == 0); // we rolled over
-  };
-  std::function<UpdateSignature> m_update = nullptr;
+  [[nodiscard]] const axis_value_indices &get_axis_value_indices() const
+  {
+    return m_axis_value_indices;
+  }
+  [[nodiscard]] axis_value_indices &get_axis_value_indices() { return m_axis_value_indices; }
+
+  [[nodiscard]] std::size_t get_iteration_size() const { return m_iteration_size; }
 
 private:
-  std::size_t m_current_index = 0;
+  std::size_t m_current_iteration = 0;
+  std::size_t m_iteration_size    = 1;
+
+  axis_value_indices m_axis_value_indices;
+
+  std::function<advance_signature> m_advance = [](std::size_t &current_iteration,
+                                                  std::size_t iteration_size) {
+    (current_iteration + 1 == iteration_size) ? current_iteration = 0 : current_iteration++;
+    return (current_iteration == 0); // we rolled over
+  };
+
+  std::function<update_signature> m_update = nullptr;
 };
 
 } // namespace detail

nvbench/detail/state_generator.cuh

@@ -78,13 +78,12 @@ struct state_iterator
 
   [[nodiscard]] std::size_t get_number_of_states() const;
   void init();
-  [[nodiscard]] std::vector<axis_index> get_current_indices() const;
+  [[nodiscard]] std::vector<axis_value_index> get_current_axis_value_indices() const;
   [[nodiscard]] bool iter_valid() const;
   void next();
 
-  std::vector<axis_space_iterator> m_space;
+  std::vector<axis_space_iterator> m_axis_space_iterators;
   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;
 };

nvbench/detail/state_generator.cxx

@@ -18,13 +18,15 @@
 
 #include <nvbench/benchmark_base.cuh>
 #include <nvbench/detail/state_generator.cuh>
+#include <nvbench/detail/throw.cuh>
 #include <nvbench/detail/transform_reduce.cuh>
 #include <nvbench/device_info.cuh>
 #include <nvbench/named_values.cuh>
 #include <nvbench/type_axis.cuh>
 
 #include <algorithm>
 #include <cassert>
+#include <exception>
 #include <functional>
 #include <numeric>
 
@@ -34,33 +36,37 @@ namespace nvbench::detail
 
 void state_iterator::add_iteration_space(const nvbench::detail::axis_space_iterator &iter)
 {
-  m_axes_count += iter.m_info.size();
-  m_max_iteration *= iter.m_iteration_size;
+  m_axes_count += iter.get_axis_value_indices().size();
+  m_max_iteration *= iter.get_iteration_size();
 
-  m_space.push_back(std::move(iter));
+  m_axis_space_iterators.push_back(std::move(iter));
 }
 
 [[nodiscard]] std::size_t state_iterator::get_number_of_states() const
 {
   return this->m_max_iteration;
 }
 
-void state_iterator::init()
-{
-  m_current_space     = 0;
-  m_current_iteration = 0;
-}
+void state_iterator::init() { m_current_iteration = 0; }
 
-[[nodiscard]] std::vector<axis_index> state_iterator::get_current_indices() const
+[[nodiscard]] std::vector<axis_value_index> state_iterator::get_current_axis_value_indices() const
 {
-  std::vector<axis_index> indices;
-  indices.reserve(m_axes_count);
-  for (auto &m : m_space)
+  std::vector<axis_value_index> info;
+  info.reserve(m_axes_count);
+  for (auto &iter : m_axis_space_iterators)
+  {
+    iter.update_axis_value_indices(info);
+  }
+
+  if (info.size() != m_axes_count)
   {
-    m.update_indices(indices);
+    NVBENCH_THROW(std::runtime_error,
+                  "Internal error: State iterator has {} axes, but only {} were updated.",
+                  m_axes_count,
+                  info.size());
   }
-  // verify length
-  return indices;
+
+  return info;
 }
 
 [[nodiscard]] bool state_iterator::iter_valid() const
@@ -72,9 +78,9 @@ void state_iterator::next()
 {
   m_current_iteration++;
 
-  for (auto &&space : this->m_space)
+  for (auto &iter : this->m_axis_space_iterators)
   {
-    auto rolled_over = space.next();
+    const auto rolled_over = iter.next();
     if (rolled_over)
     {
       continue;
@@ -128,13 +134,13 @@ void state_generator::build_axis_configs()
     auto &[config, active_mask] =
       m_type_axis_configs.emplace_back(std::make_pair(nvbench::named_values{}, true));
 
-    for (const auto &axis_info : ti.get_current_indices())
+    for (const auto &info : ti.get_current_axis_value_indices())
     {
-      const auto &axis = axes.get_type_axis(axis_info.name);
+      const auto &axis = axes.get_type_axis(info.axis_name);
 
-      active_mask &= axis.get_is_active(axis_info.index);
+      active_mask &= axis.get_is_active(info.value_index);
 
-      config.set_string(axis.get_name(), axis.get_input_string(axis_info.index));
+      config.set_string(axis.get_name(), axis.get_input_string(info.value_index));
     }
   }
 
@@ -143,30 +149,33 @@ void state_generator::build_axis_configs()
     auto &config = m_non_type_axis_configs.emplace_back();
 
     // Add non-type parameters to state:
-    for (const auto &axis_info : vi.get_current_indices())
+    for (const auto &axis_value : vi.get_current_axis_value_indices())
     {
-      switch (axis_info.type)
+      switch (axis_value.axis_type)
       {
         default:
         case axis_type::type:
           assert("unreachable." && false);
           break;
         case axis_type::int64:
-          config.set_int64(axis_info.name,
-                           axes.get_int64_axis(axis_info.name).get_value(axis_info.index));
+          config.set_int64(
+            axis_value.axis_name,
+            axes.get_int64_axis(axis_value.axis_name).get_value(axis_value.value_index));
           break;
 
         case axis_type::float64:
-          config.set_float64(axis_info.name,
-                             axes.get_float64_axis(axis_info.name).get_value(axis_info.index));
+          config.set_float64(
+            axis_value.axis_name,
+            axes.get_float64_axis(axis_value.axis_name).get_value(axis_value.value_index));
           break;
 
         case axis_type::string:
-          config.set_string(axis_info.name,
-                            axes.get_string_axis(axis_info.name).get_value(axis_info.index));
+          config.set_string(
+            axis_value.axis_name,
+            axes.get_string_axis(axis_value.axis_name).get_value(axis_value.value_index));
           break;
       } // switch (type)
-    } // for (axis_info : current_indices)
+    } // for (axis_values)
   }
 
   if (m_type_axis_configs.empty())