Replace params class with nvbench::named_values.

Refactor nvbench::state to use this for axis parameters.

These will also be useful for summaries and measurements.

Also adds a new ASSERT_THROWS_ANY macro to test some of the new API.

testing/CMakeLists.txt

@@ -5,7 +5,7 @@ set(test_srcs
   cpu_timer.cu
   float64_axis.cu
   int64_axis.cu
-  params.cu
+  named_values.cu
   state.cu
   state_generator.cu
   string_axis.cu

testing/named_values.cu

@@ -0,0 +1,94 @@
+#include <nvbench/named_values.cuh>
+
+#include "test_asserts.cuh"
+
+#include <algorithm>
+
+void test_empty()
+{
+  nvbench::named_values vals;
+  ASSERT(vals.get_size() == 0);
+  ASSERT(vals.get_names().size() == 0);
+  ASSERT(vals.has_value("Nope") == false);
+  ASSERT_THROWS_ANY([[maybe_unused]] auto val = vals.get_value("Nope"));
+  ASSERT_THROWS_ANY([[maybe_unused]] auto type = vals.get_type("Nope"));
+  // Removing non-existent entries shouldn't cause a problem:
+  vals.remove_value("Nope");
+}
+
+void test_basic()
+{
+  auto sort = [](auto &&vec) {
+    std::sort(vec.begin(), vec.end());
+    return std::forward<decltype(vec)>(vec);
+  };
+
+  nvbench::named_values vals;
+  vals.set_int64("Int", 32);
+  vals.set_float64("Float", 34.5);
+  vals.set_string("String", "string!");
+  vals.set_value("IntVar", nvbench::named_values::value_type{36ll});
+
+  std::vector<std::string> names{"Float", "Int", "IntVar", "String"};
+
+  ASSERT(vals.get_size() == 4);
+  ASSERT(sort(vals.get_names()) == names);
+
+  ASSERT(vals.has_value("Float"));
+  ASSERT(vals.has_value("Int"));
+  ASSERT(vals.has_value("IntVar"));
+  ASSERT(vals.has_value("String"));
+
+  ASSERT(std::get<nvbench::float64_t>(vals.get_value("Float")) == 34.5);
+  ASSERT(std::get<nvbench::int64_t>(vals.get_value("Int")) == 32);
+  ASSERT(std::get<nvbench::int64_t>(vals.get_value("IntVar")) == 36);
+  ASSERT(std::get<std::string>(vals.get_value("String")) == "string!");
+
+  ASSERT(vals.get_type("Float") == nvbench::named_values::type::float64);
+  ASSERT(vals.get_type("Int") == nvbench::named_values::type::int64);
+  ASSERT(vals.get_type("IntVar") == nvbench::named_values::type::int64);
+  ASSERT(vals.get_type("String") == nvbench::named_values::type::string);
+
+  ASSERT(vals.get_int64("Int") == 32);
+  ASSERT(vals.get_int64("IntVar") == 36);
+  ASSERT_THROWS_ANY([[maybe_unused]] auto v = vals.get_int64("Float"));
+  ASSERT_THROWS_ANY([[maybe_unused]] auto v = vals.get_int64("String"));
+
+  ASSERT(vals.get_float64("Float") == 34.5);
+  ASSERT_THROWS_ANY([[maybe_unused]] auto v = vals.get_float64("Int"));
+  ASSERT_THROWS_ANY([[maybe_unused]] auto v = vals.get_float64("IntVar"));
+  ASSERT_THROWS_ANY([[maybe_unused]] auto v = vals.get_float64("String"));
+
+  ASSERT(vals.get_string("String") == "string!");
+  ASSERT_THROWS_ANY([[maybe_unused]] auto v = vals.get_string("Int"));
+  ASSERT_THROWS_ANY([[maybe_unused]] auto v = vals.get_string("IntVar"));
+  ASSERT_THROWS_ANY([[maybe_unused]] auto v = vals.get_string("Float"));
+
+  vals.remove_value("IntVar");
+  names = {"Float", "Int", "String"};
+
+  ASSERT(vals.get_size() == 3);
+  ASSERT(sort(vals.get_names()) == names);
+
+  ASSERT(!vals.has_value("IntVar"));
+  ASSERT(vals.has_value("Float"));
+  ASSERT(vals.has_value("Int"));
+  ASSERT(vals.has_value("String"));
+
+  vals.clear();
+  names = {};
+
+  ASSERT(vals.get_size() == 0);
+  ASSERT(sort(vals.get_names()) == names);
+
+  ASSERT(!vals.has_value("IntVar"));
+  ASSERT(!vals.has_value("Float"));
+  ASSERT(!vals.has_value("Int"));
+  ASSERT(!vals.has_value("String"));
+}
+
+int main()
+{
+  test_empty();
+  test_basic();
+}

testing/params.cu

@@ -1,26 +0,0 @@
-#include <nvbench/params.cuh>
-
-#include "test_asserts.cuh"
-
-void test_basic()
-{
-  nvbench::params params;
-  params.add_string_param("Axis 1", "Value 1");
-  params.add_int64_param("Axis 2", 2);
-  params.add_float64_param("Axis 3", 3.);
-  params.add_string_param("Axis 4", "Value 4");
-  params.add_int64_param("Axis 5", 5);
-  params.add_float64_param("Axis 6", 6.);
-
-  ASSERT(params.get_string_param("Axis 1") == "Value 1");
-  ASSERT(params.get_int64_param("Axis 2") == 2);
-  ASSERT(params.get_float64_param("Axis 3") == 3.);
-  ASSERT(params.get_string_param("Axis 4") == "Value 4");
-  ASSERT(params.get_int64_param("Axis 5") == 5);
-  ASSERT(params.get_float64_param("Axis 6") == 6.);
-}
-
-int main()
-{
-  test_basic();
-}

testing/state.cu

@@ -7,22 +7,17 @@
 // Subclass to gain access to protected members for testing:
 struct state_tester : public nvbench::state
 {
-  using params_type = nvbench::state::params_type;
-
   state_tester()
       : nvbench::state()
   {}
-  explicit state_tester(params_type params)
-      : nvbench::state{std::move(params)}
-  {}
 
-  template <typename... Args>
-  void set_param(Args &&...args)
+  template <typename T>
+  void set_param(std::string name, T &&value)
   {
-    this->state::set_param(std::forward<Args>(args)...);
+    this->state::m_axis_values.set_value(std::move(name),
+                                         nvbench::named_values::value_type{
+                                           std::forward<T>(value)});
   }
-
-  const auto &get_params() const { return m_params; }
 };
 
 void test_params()
@@ -36,13 +31,6 @@ void test_params()
   ASSERT(state1.get_int64("TestInt") == nvbench::int64_t{22});
   ASSERT(state1.get_float64("TestFloat") == nvbench::float64_t{3.14});
   ASSERT(state1.get_string("TestString") == "A String!");
-
-  // Construct a state from the parameter map built above:
-  state_tester state2{state1.get_params()};
-
-  ASSERT(state2.get_int64("TestInt") == nvbench::int64_t{22});
-  ASSERT(state2.get_float64("TestFloat") == nvbench::float64_t{3.14});
-  ASSERT(state2.get_string("TestString") == "A String!");
 }
 
 int main() { test_params(); }

testing/test_asserts.cuh

@@ -29,3 +29,25 @@
       exit(EXIT_FAILURE);                                                      \
     }                                                                          \
   } while (false)
+
+#define ASSERT_THROWS_ANY(expr)                                                \
+  do                                                                           \
+  {                                                                            \
+    bool threw = false;                                                        \
+    try                                                                        \
+    {                                                                          \
+      expr;                                                                    \
+    }                                                                          \
+    catch (...)                                                                \
+    {                                                                          \
+      threw = true;                                                            \
+    }                                                                          \
+    if (!threw)                                                                \
+    {                                                                          \
+      fmt::print("{}:{}: Expression expected exception: '{}'.",                \
+                 __FILE__,                                                     \
+                 __LINE__,                                                     \
+                 #expr);                                                       \
+      exit(EXIT_FAILURE);                                                      \
+    }                                                                          \
+  } while (false)