Remove pimpl to hide reference_wrapper<nvbench::benchmake_base>, use plain pointer

Since benchmark_base instance lifetime is guaranteed while state instance exists,
one can just use plain const nvbench::benchmark_base * instead of
std::reference_wrapper<const nvbench::benchmark_base> while allowing for
nvbench::benchmark_base to be incomplete type.

Author: oleksandr-pavlyk

nvbench/state.cuh

@@ -26,7 +26,6 @@
 #include <nvbench/summary.cuh>
 #include <nvbench/types.cuh>
 
-#include <memory>
 #include <optional>
 #include <string>
 #include <vector>
@@ -60,13 +59,9 @@ struct state
 {
   // move-only
   state(const state &)            = delete;
+  state(state &&)                 = default;
   state &operator=(const state &) = delete;
-  state(state &&);
-  state &operator=(state &&);
-
-  // Destructor must be defined in C++ where complete definitions of
-  // all types for member variables are available. See #235
-  ~state();
+  state &operator=(state &&)      = default;
 
   /// If a stream exists, return that. Otherwise, create a new stream using the current
   /// device (or the current device if none is set), save it, and return it.
@@ -312,11 +307,7 @@ private:
 
   [[nodiscard]] bool skip_hot_measurement() const { return get_run_once() || get_skip_batched(); }
 
-  // PImpl to structure holding reference to benchmark, needed to
-  // work around -Wsfinae-incomplete.
-  // See https://github.com/NVIDIA/nvbench/issues/235
-  struct bench_ref_impl;
-  std::unique_ptr<bench_ref_impl> m_benchmark_wrapper;
+  const nvbench::benchmark_base *m_benchmark_ptr;
 
   nvbench::named_values m_axis_values;
   std::optional<nvbench::device_info> m_device;

nvbench/state.cxx

@@ -25,25 +25,14 @@
 #include <fmt/format.h>
 
 #include <algorithm>
-#include <functional>
-#include <memory>
 #include <stdexcept>
 #include <string>
 
 namespace nvbench
 {
 
-struct state::bench_ref_impl
-{
-  explicit bench_ref_impl(const benchmark_base &bench)
-      : m_benchmark{bench}
-  {}
-
-  std::reference_wrapper<const benchmark_base> m_benchmark;
-};
-
 state::state(const benchmark_base &bench)
-    : m_benchmark_wrapper{std::make_unique<bench_ref_impl>(bench)}
+    : m_benchmark_ptr{&bench}
     , m_is_cpu_only(bench.get_is_cpu_only())
     , m_run_once{bench.get_run_once()}
     , m_disable_blocking_kernel{bench.get_disable_blocking_kernel()}
@@ -61,7 +50,7 @@ state::state(const benchmark_base &bench,
              nvbench::named_values values,
              std::optional<nvbench::device_info> device,
              std::size_t type_config_index)
-    : m_benchmark_wrapper{std::make_unique<bench_ref_impl>(bench)}
+    : m_benchmark_ptr{&bench}
     , m_axis_values{std::move(values)}
     , m_device{std::move(device)}
     , m_type_config_index{type_config_index}
@@ -79,17 +68,7 @@ state::state(const benchmark_base &bench,
     , m_cuda_stream{std::nullopt}
 {}
 
-// Destructor and move-constructor, move-assignment must be defined in C++ file
-// where benchmark_base type definition is known to be complete. See #235
-state::state(state &&)            = default;
-state &state::operator=(state &&) = default;
-
-state::~state() = default;
-
-const nvbench::benchmark_base &state::get_benchmark() const
-{
-  return m_benchmark_wrapper->m_benchmark.get();
-}
+const nvbench::benchmark_base &state::get_benchmark() const { return *m_benchmark_ptr; }
 
 nvbench::int64_t state::get_int64(const std::string &axis_name) const
 {
@@ -228,7 +207,7 @@ std::string state::get_axis_values_as_string(bool color) const
     append_key_value("Device", m_device->get_id());
   }
 
-  const axes_metadata &axes = m_benchmark_wrapper->m_benchmark.get().get_axes();
+  const axes_metadata &axes = m_benchmark_ptr->get_axes();
   for (const auto &name : m_axis_values.get_names())
   {
     const auto axis_type = m_axis_values.get_type(name);
@@ -265,9 +244,7 @@ std::string state::get_short_description(bool color) const
   };
 
   return fmt::format("{} [{}]",
-                     fmt::format(style(fmt::emphasis::bold),
-                                 "{}",
-                                 m_benchmark_wrapper->m_benchmark.get().get_name()),
+                     fmt::format(style(fmt::emphasis::bold), "{}", m_benchmark_ptr->get_name()),
                      this->get_axis_values_as_string(color));
 }