Per reviewer suggestion change benchmark_base::optinal_ref to optional_ptr

oleksandr-pavlyk · oleksandr-pavlyk · commit cb3adbda5436 · 2026-03-24T06:17:35.000-05:00
benchmark_base::get_printer now return optional_ptr, i.e.
std::optional&lt;nvbench::printer_base *&gt;.

All use sites are updated accordingly.
diff --git a/nvbench/benchmark_base.cuh b/nvbench/benchmark_base.cuh
@@ -33,7 +33,6 @@
 #include <nvbench/state.cuh>
 #include <nvbench/stopping_criterion.cuh>
 
-#include <functional> // reference_wrapper, ref
 #include <memory>
 #include <optional>
 #include <vector>
@@ -57,13 +56,13 @@ struct runner;
 struct benchmark_base
 {
   template <typename T>
-  using optional_ref = std::optional<std::reference_wrapper<T>>;
+  using optional_ptr = std::optional<T *>;
 
   template <typename TypeAxes>
   explicit benchmark_base(TypeAxes type_axes)
       : m_axes(type_axes)
   {
-    this->init_printer_ref();
+    this->init_printer_ptr();
     this->set_stopping_criterion(nvbench::detail::default_stopping_criterion());
   }
 
@@ -161,7 +160,7 @@ struct benchmark_base
   void set_printer(nvbench::printer_base &printer);
   void clear_printer();
 
-  [[nodiscard]] optional_ref<nvbench::printer_base> get_printer() const;
+  [[nodiscard]] optional_ptr<nvbench::printer_base> get_printer() const;
 
   /// Execute at least this many trials per measurement. @{
   [[nodiscard]] nvbench::int64_t get_min_samples() const { return m_min_samples; }
@@ -338,16 +337,16 @@ protected:
   std::string m_stopping_criterion{};
 
 private:
-  struct printer_optional_ref_impl_t;
+  struct printer_optional_ptr_impl_t;
 
-  struct printer_optional_ref_deleter_t
+  struct printer_optional_ptr_deleter_t
   {
-    void operator()(printer_optional_ref_impl_t *) const noexcept;
+    void operator()(printer_optional_ptr_impl_t *) const noexcept;
   };
 
-  std::unique_ptr<printer_optional_ref_impl_t, printer_optional_ref_deleter_t> m_printer_wrapper;
+  std::unique_ptr<printer_optional_ptr_impl_t, printer_optional_ptr_deleter_t> m_printer_wrapper;
 
-  void init_printer_ref();
+  void init_printer_ptr();
 
   // route these through virtuals so the templated subclass can inject type info
   virtual std::unique_ptr<benchmark_base> do_clone() const            = 0;
diff --git a/nvbench/benchmark_base.cxx b/nvbench/benchmark_base.cxx
@@ -29,34 +29,34 @@
 namespace nvbench
 {
 
-struct benchmark_base::printer_optional_ref_impl_t
+struct benchmark_base::printer_optional_ptr_impl_t
 {
-  benchmark_base::optional_ref<printer_base> optional_ref;
+  benchmark_base::optional_ptr<printer_base> optional_ptr;
 };
 
 benchmark_base::~benchmark_base() = default;
 
-void benchmark_base::printer_optional_ref_deleter_t::operator()(
-  printer_optional_ref_impl_t *p) const noexcept
+void benchmark_base::printer_optional_ptr_deleter_t::operator()(
+  printer_optional_ptr_impl_t *p) const noexcept
 {
   delete p;
 }
 
-void benchmark_base::init_printer_ref()
+void benchmark_base::init_printer_ptr()
 {
-  m_printer_wrapper.reset(new printer_optional_ref_impl_t{});
+  m_printer_wrapper.reset(new printer_optional_ptr_impl_t{});
 }
 
 void benchmark_base::set_printer(nvbench::printer_base &printer)
 {
-  m_printer_wrapper->optional_ref = std::ref(printer);
+  m_printer_wrapper->optional_ptr = &printer;
 }
 
-void benchmark_base::clear_printer() { m_printer_wrapper->optional_ref = std::nullopt; }
+void benchmark_base::clear_printer() { m_printer_wrapper->optional_ptr = std::nullopt; }
 
-benchmark_base::optional_ref<nvbench::printer_base> benchmark_base::get_printer() const
+benchmark_base::optional_ptr<nvbench::printer_base> benchmark_base::get_printer() const
 {
-  return m_printer_wrapper->optional_ref;
+  return m_printer_wrapper->optional_ptr;
 }
 
 std::unique_ptr<benchmark_base> benchmark_base::clone() const
@@ -68,8 +68,8 @@ std::unique_ptr<benchmark_base> benchmark_base::clone() const
   result->m_axes    = m_axes;
   result->m_devices = m_devices;
 
-  result->m_printer_wrapper.reset(new printer_optional_ref_impl_t{m_printer_wrapper->optional_ref});
-  result->m_printer_wrapper->optional_ref = m_printer_wrapper->optional_ref;
+  result->m_printer_wrapper.reset(new printer_optional_ptr_impl_t{m_printer_wrapper->optional_ptr});
+  result->m_printer_wrapper->optional_ptr = m_printer_wrapper->optional_ptr;
 
   result->m_is_cpu_only             = m_is_cpu_only;
   result->m_run_once                = m_run_once;
diff --git a/nvbench/detail/measure_cold.cu b/nvbench/detail/measure_cold.cu
@@ -115,9 +115,9 @@ void measure_cold_base::record_measurements()
                                                       0.5f);
       }
 
-      if (auto printer_opt_ref = m_state.get_benchmark().get_printer(); printer_opt_ref.has_value())
+      if (auto printer_opt_ptr = m_state.get_benchmark().get_printer(); printer_opt_ptr.has_value())
       {
-        auto &printer = printer_opt_ref.value().get();
+        auto &printer = *(printer_opt_ptr.value());
         printer.log(nvbench::log_level::warn,
                     fmt::format("GPU throttled below threshold ({:0.2f} MHz / {:0.2f} MHz) "
                                 "({:0.0f}% < {:0.0f}%) on sample {}. Discarding previous trial "
@@ -386,9 +386,9 @@ void measure_cold_base::generate_summaries()
   }
 
   // Log if a printer exists:
-  if (auto printer_opt_ref = m_state.get_benchmark().get_printer(); printer_opt_ref.has_value())
+  if (auto printer_opt_ptr = m_state.get_benchmark().get_printer(); printer_opt_ptr.has_value())
   {
-    auto &printer = printer_opt_ref.value().get();
+    auto &printer = *(printer_opt_ptr.value());
 
     if (m_max_time_exceeded)
     {
diff --git a/nvbench/detail/measure_cpu_only.cxx b/nvbench/detail/measure_cpu_only.cxx
@@ -204,9 +204,9 @@ void measure_cpu_only_base::generate_summaries()
   }
 
   // Log if a printer exists:
-  if (auto printer_opt_ref = m_state.get_benchmark().get_printer(); printer_opt_ref.has_value())
+  if (auto printer_opt_ptr = m_state.get_benchmark().get_printer(); printer_opt_ptr.has_value())
   {
-    auto &printer = printer_opt_ref.value().get();
+    auto &printer = *(printer_opt_ptr.value());
 
     if (m_max_time_exceeded)
     {
diff --git a/nvbench/detail/measure_cupti.cu b/nvbench/detail/measure_cupti.cu
@@ -171,9 +171,9 @@ try
 // clang-format on
 catch (const std::exception &ex)
 {
-  if (auto printer_opt_ref = exec_state.get_benchmark().get_printer(); printer_opt_ref)
+  if (auto printer_opt_ptr = exec_state.get_benchmark().get_printer(); printer_opt_ptr)
   {
-    auto &printer = printer_opt_ref.value().get();
+    auto &printer = *(printer_opt_ptr.value());
     printer.log(nvbench::log_level::warn,
                 fmt::format("CUPTI failed to construct profiler: {}", ex.what()));
   }
@@ -247,9 +247,9 @@ try
   }
 
   // Log if a printer exists:
-  if (auto printer_opt_ref = m_state.get_benchmark().get_printer(); printer_opt_ref.has_value())
+  if (auto printer_opt_ptr = m_state.get_benchmark().get_printer(); printer_opt_ptr.has_value())
   {
-    auto &printer = printer_opt_ref.value().get();
+    auto &printer = *(printer_opt_ptr.value());
     printer.log(nvbench::log_level::pass,
                 fmt::format("CUPTI: {:0.2f}s total wall, {}x",
                             m_walltime_timer.get_duration(),
@@ -258,9 +258,9 @@ try
 }
 catch (const std::exception &ex)
 {
-  if (auto printer_opt_ref = m_state.get_benchmark().get_printer(); printer_opt_ref)
+  if (auto printer_opt_ptr = m_state.get_benchmark().get_printer(); printer_opt_ptr)
   {
-    auto &printer = printer_opt_ref.value().get();
+    auto &printer = *(printer_opt_ptr.value());
     printer.log(nvbench::log_level::warn,
                 fmt::format("CUPTI failed to generate the summary: {}", ex.what()));
   }
diff --git a/nvbench/detail/measure_hot.cu b/nvbench/detail/measure_hot.cu
@@ -112,9 +112,9 @@ void measure_hot_base::generate_summaries()
   }
 
   // Log if a printer exists:
-  if (auto printer_opt_ref = m_state.get_benchmark().get_printer(); printer_opt_ref.has_value())
+  if (auto printer_opt_ptr = m_state.get_benchmark().get_printer(); printer_opt_ptr.has_value())
   {
-    auto &printer = printer_opt_ref.value().get();
+    auto &printer = *(printer_opt_ptr.value());
 
     // Warn if timed out:
     if (m_max_time_exceeded)
diff --git a/nvbench/json_printer.cu b/nvbench/json_printer.cu
@@ -247,9 +247,9 @@ void json_printer::do_process_bulk_data_float64(state &state,
     }
     catch (std::exception &e)
     {
-      if (auto printer_opt_ref = state.get_benchmark().get_printer(); printer_opt_ref.has_value())
+      if (auto printer_opt_ptr = state.get_benchmark().get_printer(); printer_opt_ptr.has_value())
       {
-        auto &printer = printer_opt_ref.value().get();
+        auto &printer = *(printer_opt_ptr.value());
         printer.log(
           nvbench::log_level::warn,
           fmt::format("Error writing {} ({}) to {}: {}", tag, hint, result_path.string(), e.what()));
@@ -267,9 +267,9 @@ void json_printer::do_process_bulk_data_float64(state &state,
     summ.set_string("hide", "Not needed in table.");
 
     timer.stop();
-    if (auto printer_opt_ref = state.get_benchmark().get_printer(); printer_opt_ref.has_value())
+    if (auto printer_opt_ptr = state.get_benchmark().get_printer(); printer_opt_ptr.has_value())
     {
-      auto &printer = printer_opt_ref.value().get();
+      auto &printer = *(printer_opt_ptr.value());
       printer.log(
         nvbench::log_level::info,
         fmt::format("Wrote '{}' in {:>6.3f}ms", result_path.string(), timer.get_duration() * 1000));
@@ -307,9 +307,9 @@ void json_printer::do_process_bulk_data_float64(state &state,
     }
     catch (std::exception &e)
     {
-      if (auto printer_opt_ref = state.get_benchmark().get_printer(); printer_opt_ref.has_value())
+      if (auto printer_opt_ptr = state.get_benchmark().get_printer(); printer_opt_ptr.has_value())
       {
-        auto &printer = printer_opt_ref.value().get();
+        auto &printer = *(printer_opt_ptr.value());
         printer.log(
           nvbench::log_level::warn,
           fmt::format("Error writing {} ({}) to {}: {}", tag, hint, result_path.string(), e.what()));
@@ -327,9 +327,9 @@ void json_printer::do_process_bulk_data_float64(state &state,
     summ.set_string("hide", "Not needed in table.");
 
     timer.stop();
-    if (auto printer_opt_ref = state.get_benchmark().get_printer(); printer_opt_ref.has_value())
+    if (auto printer_opt_ptr = state.get_benchmark().get_printer(); printer_opt_ptr.has_value())
     {
-      auto &printer = printer_opt_ref.value().get();
+      auto &printer = *(printer_opt_ptr.value());
       printer.log(
         nvbench::log_level::info,
         fmt::format("Wrote '{}' in {:>6.3f}ms", result_path.string(), timer.get_duration() * 1000));
diff --git a/nvbench/runner.cxx b/nvbench/runner.cxx
@@ -46,10 +46,10 @@ void runner_base::handle_sampling_exception(const std::exception &e, state &exec
   {
     const auto reason = fmt::format("Unexpected error: {}", e.what());
 
-    if (auto printer_opt_ref = exec_state.get_benchmark().get_printer();
-        printer_opt_ref.has_value())
+    if (auto printer_opt_ptr = exec_state.get_benchmark().get_printer();
+        printer_opt_ptr.has_value())
     {
-      auto &printer = printer_opt_ref.value().get();
+      auto &printer = *(printer_opt_ptr.value());
       printer.log(nvbench::log_level::fail, reason);
     }
 
@@ -60,28 +60,28 @@ void runner_base::handle_sampling_exception(const std::exception &e, state &exec
 void runner_base::run_state_prologue(nvbench::state &exec_state) const
 {
   // Log if a printer exists:
-  if (auto printer_opt_ref = exec_state.get_benchmark().get_printer(); printer_opt_ref.has_value())
+  if (auto printer_opt_ptr = exec_state.get_benchmark().get_printer(); printer_opt_ptr.has_value())
   {
-    auto &printer = printer_opt_ref.value().get();
+    auto &printer = *(printer_opt_ptr.value());
     printer.log_run_state(exec_state);
   }
 }
 
 void runner_base::run_state_epilogue(state &exec_state) const
 {
   // Notify the printer that the state has completed::
-  if (auto printer_opt_ref = exec_state.get_benchmark().get_printer(); printer_opt_ref.has_value())
+  if (auto printer_opt_ptr = exec_state.get_benchmark().get_printer(); printer_opt_ptr.has_value())
   {
-    auto &printer = printer_opt_ref.value().get();
+    auto &printer = *(printer_opt_ptr.value());
     printer.add_completed_state();
   }
 }
 
 void runner_base::print_skip_notification(state &exec_state) const
 {
-  if (auto printer_opt_ref = exec_state.get_benchmark().get_printer(); printer_opt_ref.has_value())
+  if (auto printer_opt_ptr = exec_state.get_benchmark().get_printer(); printer_opt_ptr.has_value())
   {
-    auto &printer = printer_opt_ref.value().get();
+    auto &printer = *(printer_opt_ptr.value());
     printer.log(nvbench::log_level::skip, exec_state.get_skip_reason());
   }
 }

Original file line number	Diff line number	Diff line change
`@@ -29,34 +29,34 @@`
`29`	`29`	`namespace nvbench`
`30`	`30`	`{`
`31`	`31`
`32`		`-struct benchmark_base::printer_optional_ref_impl_t`
	`32`	`+struct benchmark_base::printer_optional_ptr_impl_t`
`33`	`33`	`{`
`34`		`- benchmark_base::optional_ref<printer_base> optional_ref;`
	`34`	`+ benchmark_base::optional_ptr<printer_base> optional_ptr;`
`35`	`35`	`};`
`36`	`36`
`37`	`37`	`benchmark_base::~benchmark_base() = default;`
`38`	`38`
`39`		`-void benchmark_base::printer_optional_ref_deleter_t::operator()(`
`40`		`- printer_optional_ref_impl_t *p) const noexcept`
	`39`	`+void benchmark_base::printer_optional_ptr_deleter_t::operator()(`
	`40`	`+ printer_optional_ptr_impl_t *p) const noexcept`
`41`	`41`	`{`
`42`	`42`	`delete p;`
`43`	`43`	`}`
`44`	`44`
`45`		`-void benchmark_base::init_printer_ref()`
	`45`	`+void benchmark_base::init_printer_ptr()`
`46`	`46`	`{`
`47`		`- m_printer_wrapper.reset(new printer_optional_ref_impl_t{});`
	`47`	`+ m_printer_wrapper.reset(new printer_optional_ptr_impl_t{});`
`48`	`48`	`}`
`49`	`49`
`50`	`50`	`void benchmark_base::set_printer(nvbench::printer_base &printer)`
`51`	`51`	`{`
`52`		`- m_printer_wrapper->optional_ref = std::ref(printer);`
	`52`	`+ m_printer_wrapper->optional_ptr = &printer;`
`53`	`53`	`}`
`54`	`54`
`55`		`-void benchmark_base::clear_printer() { m_printer_wrapper->optional_ref = std::nullopt; }`
	`55`	`+void benchmark_base::clear_printer() { m_printer_wrapper->optional_ptr = std::nullopt; }`
`56`	`56`
`57`		`-benchmark_base::optional_ref<nvbench::printer_base> benchmark_base::get_printer() const`
	`57`	`+benchmark_base::optional_ptr<nvbench::printer_base> benchmark_base::get_printer() const`
`58`	`58`	`{`
`59`		`- return m_printer_wrapper->optional_ref;`
	`59`	`+ return m_printer_wrapper->optional_ptr;`
`60`	`60`	`}`
`61`	`61`
`62`	`62`	`std::unique_ptr<benchmark_base> benchmark_base::clone() const`
`@@ -68,8 +68,8 @@ std::unique_ptr<benchmark_base> benchmark_base::clone() const`
`68`	`68`	`result->m_axes = m_axes;`
`69`	`69`	`result->m_devices = m_devices;`
`70`	`70`
`71`		`- result->m_printer_wrapper.reset(new printer_optional_ref_impl_t{m_printer_wrapper->optional_ref});`
`72`		`- result->m_printer_wrapper->optional_ref = m_printer_wrapper->optional_ref;`
	`71`	`+ result->m_printer_wrapper.reset(new printer_optional_ptr_impl_t{m_printer_wrapper->optional_ptr});`
	`72`	`+ result->m_printer_wrapper->optional_ptr = m_printer_wrapper->optional_ptr;`
`73`	`73`
`74`	`74`	`result->m_is_cpu_only = m_is_cpu_only;`
`75`	`75`	`result->m_run_once = m_run_once;`
Original file line number	Diff line number	Diff line change
`@@ -115,9 +115,9 @@ void measure_cold_base::record_measurements()`
`115`	`115`	`0.5f);`
`116`	`116`	`}`
`117`	`117`
`118`		`- if (auto printer_opt_ref = m_state.get_benchmark().get_printer(); printer_opt_ref.has_value())`
	`118`	`+ if (auto printer_opt_ptr = m_state.get_benchmark().get_printer(); printer_opt_ptr.has_value())`
`119`	`119`	`{`
`120`		`- auto &printer = printer_opt_ref.value().get();`
	`120`	`+ auto &printer = *(printer_opt_ptr.value());`
`121`	`121`	`printer.log(nvbench::log_level::warn,`
`122`	`122`	`fmt::format("GPU throttled below threshold ({:0.2f} MHz / {:0.2f} MHz) "`
`123`	`123`	`"({:0.0f}% < {:0.0f}%) on sample {}. Discarding previous trial "`
`@@ -386,9 +386,9 @@ void measure_cold_base::generate_summaries()`
`386`	`386`	`}`
`387`	`387`
`388`	`388`	`// Log if a printer exists:`
`389`		`- if (auto printer_opt_ref = m_state.get_benchmark().get_printer(); printer_opt_ref.has_value())`
	`389`	`+ if (auto printer_opt_ptr = m_state.get_benchmark().get_printer(); printer_opt_ptr.has_value())`
`390`	`390`	`{`
`391`		`- auto &printer = printer_opt_ref.value().get();`
	`391`	`+ auto &printer = *(printer_opt_ptr.value());`
`392`	`392`
`393`	`393`	`if (m_max_time_exceeded)`
`394`	`394`	`{`
Original file line number	Diff line number	Diff line change
`@@ -204,9 +204,9 @@ void measure_cpu_only_base::generate_summaries()`
`204`	`204`	`}`
`205`	`205`
`206`	`206`	`// Log if a printer exists:`
`207`		`- if (auto printer_opt_ref = m_state.get_benchmark().get_printer(); printer_opt_ref.has_value())`
	`207`	`+ if (auto printer_opt_ptr = m_state.get_benchmark().get_printer(); printer_opt_ptr.has_value())`
`208`	`208`	`{`
`209`		`- auto &printer = printer_opt_ref.value().get();`
	`209`	`+ auto &printer = *(printer_opt_ptr.value());`
`210`	`210`
`211`	`211`	`if (m_max_time_exceeded)`
`212`	`212`	`{`
Original file line number	Diff line number	Diff line change
`@@ -171,9 +171,9 @@ try`
`171`	`171`	`// clang-format on`
`172`	`172`	`catch (const std::exception &ex)`
`173`	`173`	`{`
`174`		`- if (auto printer_opt_ref = exec_state.get_benchmark().get_printer(); printer_opt_ref)`
	`174`	`+ if (auto printer_opt_ptr = exec_state.get_benchmark().get_printer(); printer_opt_ptr)`
`175`	`175`	`{`
`176`		`- auto &printer = printer_opt_ref.value().get();`
	`176`	`+ auto &printer = *(printer_opt_ptr.value());`
`177`	`177`	`printer.log(nvbench::log_level::warn,`
`178`	`178`	`fmt::format("CUPTI failed to construct profiler: {}", ex.what()));`
`179`	`179`	`}`
`@@ -247,9 +247,9 @@ try`
`247`	`247`	`}`
`248`	`248`
`249`	`249`	`// Log if a printer exists:`
`250`		`- if (auto printer_opt_ref = m_state.get_benchmark().get_printer(); printer_opt_ref.has_value())`
	`250`	`+ if (auto printer_opt_ptr = m_state.get_benchmark().get_printer(); printer_opt_ptr.has_value())`
`251`	`251`	`{`
`252`		`- auto &printer = printer_opt_ref.value().get();`
	`252`	`+ auto &printer = *(printer_opt_ptr.value());`
`253`	`253`	`printer.log(nvbench::log_level::pass,`
`254`	`254`	`fmt::format("CUPTI: {:0.2f}s total wall, {}x",`
`255`	`255`	`m_walltime_timer.get_duration(),`
`@@ -258,9 +258,9 @@ try`
`258`	`258`	`}`
`259`	`259`	`catch (const std::exception &ex)`
`260`	`260`	`{`
`261`		`- if (auto printer_opt_ref = m_state.get_benchmark().get_printer(); printer_opt_ref)`
	`261`	`+ if (auto printer_opt_ptr = m_state.get_benchmark().get_printer(); printer_opt_ptr)`
`262`	`262`	`{`
`263`		`- auto &printer = printer_opt_ref.value().get();`
	`263`	`+ auto &printer = *(printer_opt_ptr.value());`
`264`	`264`	`printer.log(nvbench::log_level::warn,`
`265`	`265`	`fmt::format("CUPTI failed to generate the summary: {}", ex.what()));`
`266`	`266`	`}`
Original file line number	Diff line number	Diff line change
`@@ -112,9 +112,9 @@ void measure_hot_base::generate_summaries()`
`112`	`112`	`}`
`113`	`113`
`114`	`114`	`// Log if a printer exists:`
`115`		`- if (auto printer_opt_ref = m_state.get_benchmark().get_printer(); printer_opt_ref.has_value())`
	`115`	`+ if (auto printer_opt_ptr = m_state.get_benchmark().get_printer(); printer_opt_ptr.has_value())`
`116`	`116`	`{`
`117`		`- auto &printer = printer_opt_ref.value().get();`
	`117`	`+ auto &printer = *(printer_opt_ptr.value());`
`118`	`118`
`119`	`119`	`// Warn if timed out:`
`120`	`120`	`if (m_max_time_exceeded)`
Original file line number	Diff line number	Diff line change
`@@ -247,9 +247,9 @@ void json_printer::do_process_bulk_data_float64(state &state,`
`247`	`247`	`}`
`248`	`248`	`catch (std::exception &e)`
`249`	`249`	`{`
`250`		`- if (auto printer_opt_ref = state.get_benchmark().get_printer(); printer_opt_ref.has_value())`
	`250`	`+ if (auto printer_opt_ptr = state.get_benchmark().get_printer(); printer_opt_ptr.has_value())`
`251`	`251`	`{`
`252`		`- auto &printer = printer_opt_ref.value().get();`
	`252`	`+ auto &printer = *(printer_opt_ptr.value());`
`253`	`253`	`printer.log(`
`254`	`254`	`nvbench::log_level::warn,`
`255`	`255`	`fmt::format("Error writing {} ({}) to {}: {}", tag, hint, result_path.string(), e.what()));`
`@@ -267,9 +267,9 @@ void json_printer::do_process_bulk_data_float64(state &state,`
`267`	`267`	`summ.set_string("hide", "Not needed in table.");`
`268`	`268`
`269`	`269`	`timer.stop();`
`270`		`- if (auto printer_opt_ref = state.get_benchmark().get_printer(); printer_opt_ref.has_value())`
	`270`	`+ if (auto printer_opt_ptr = state.get_benchmark().get_printer(); printer_opt_ptr.has_value())`
`271`	`271`	`{`
`272`		`- auto &printer = printer_opt_ref.value().get();`
	`272`	`+ auto &printer = *(printer_opt_ptr.value());`
`273`	`273`	`printer.log(`
`274`	`274`	`nvbench::log_level::info,`
`275`	`275`	`fmt::format("Wrote '{}' in {:>6.3f}ms", result_path.string(), timer.get_duration() * 1000));`
`@@ -307,9 +307,9 @@ void json_printer::do_process_bulk_data_float64(state &state,`
`307`	`307`	`}`
`308`	`308`	`catch (std::exception &e)`
`309`	`309`	`{`
`310`		`- if (auto printer_opt_ref = state.get_benchmark().get_printer(); printer_opt_ref.has_value())`
	`310`	`+ if (auto printer_opt_ptr = state.get_benchmark().get_printer(); printer_opt_ptr.has_value())`
`311`	`311`	`{`
`312`		`- auto &printer = printer_opt_ref.value().get();`
	`312`	`+ auto &printer = *(printer_opt_ptr.value());`
`313`	`313`	`printer.log(`
`314`	`314`	`nvbench::log_level::warn,`
`315`	`315`	`fmt::format("Error writing {} ({}) to {}: {}", tag, hint, result_path.string(), e.what()));`
`@@ -327,9 +327,9 @@ void json_printer::do_process_bulk_data_float64(state &state,`
`327`	`327`	`summ.set_string("hide", "Not needed in table.");`
`328`	`328`
`329`	`329`	`timer.stop();`
`330`		`- if (auto printer_opt_ref = state.get_benchmark().get_printer(); printer_opt_ref.has_value())`
	`330`	`+ if (auto printer_opt_ptr = state.get_benchmark().get_printer(); printer_opt_ptr.has_value())`
`331`	`331`	`{`
`332`		`- auto &printer = printer_opt_ref.value().get();`
	`332`	`+ auto &printer = *(printer_opt_ptr.value());`
`333`	`333`	`printer.log(`
`334`	`334`	`nvbench::log_level::info,`
`335`	`335`	`fmt::format("Wrote '{}' in {:>6.3f}ms", result_path.string(), timer.get_duration() * 1000));`
Original file line number	Diff line number	Diff line change
`@@ -46,10 +46,10 @@ void runner_base::handle_sampling_exception(const std::exception &e, state &exec`
`46`	`46`	`{`
`47`	`47`	`const auto reason = fmt::format("Unexpected error: {}", e.what());`
`48`	`48`
`49`		`- if (auto printer_opt_ref = exec_state.get_benchmark().get_printer();`
`50`		`- printer_opt_ref.has_value())`
	`49`	`+ if (auto printer_opt_ptr = exec_state.get_benchmark().get_printer();`
	`50`	`+ printer_opt_ptr.has_value())`
`51`	`51`	`{`
`52`		`- auto &printer = printer_opt_ref.value().get();`
	`52`	`+ auto &printer = *(printer_opt_ptr.value());`
`53`	`53`	`printer.log(nvbench::log_level::fail, reason);`
`54`	`54`	`}`
`55`	`55`
`@@ -60,28 +60,28 @@ void runner_base::handle_sampling_exception(const std::exception &e, state &exec`
`60`	`60`	`void runner_base::run_state_prologue(nvbench::state &exec_state) const`
`61`	`61`	`{`
`62`	`62`	`// Log if a printer exists:`
`63`		`- if (auto printer_opt_ref = exec_state.get_benchmark().get_printer(); printer_opt_ref.has_value())`
	`63`	`+ if (auto printer_opt_ptr = exec_state.get_benchmark().get_printer(); printer_opt_ptr.has_value())`
`64`	`64`	`{`
`65`		`- auto &printer = printer_opt_ref.value().get();`
	`65`	`+ auto &printer = *(printer_opt_ptr.value());`
`66`	`66`	`printer.log_run_state(exec_state);`
`67`	`67`	`}`
`68`	`68`	`}`
`69`	`69`
`70`	`70`	`void runner_base::run_state_epilogue(state &exec_state) const`
`71`	`71`	`{`
`72`	`72`	`// Notify the printer that the state has completed::`
`73`		`- if (auto printer_opt_ref = exec_state.get_benchmark().get_printer(); printer_opt_ref.has_value())`
	`73`	`+ if (auto printer_opt_ptr = exec_state.get_benchmark().get_printer(); printer_opt_ptr.has_value())`
`74`	`74`	`{`
`75`		`- auto &printer = printer_opt_ref.value().get();`
	`75`	`+ auto &printer = *(printer_opt_ptr.value());`
`76`	`76`	`printer.add_completed_state();`
`77`	`77`	`}`
`78`	`78`	`}`
`79`	`79`
`80`	`80`	`void runner_base::print_skip_notification(state &exec_state) const`
`81`	`81`	`{`
`82`		`- if (auto printer_opt_ref = exec_state.get_benchmark().get_printer(); printer_opt_ref.has_value())`
	`82`	`+ if (auto printer_opt_ptr = exec_state.get_benchmark().get_printer(); printer_opt_ptr.has_value())`
`83`	`83`	`{`
`84`		`- auto &printer = printer_opt_ref.value().get();`
	`84`	`+ auto &printer = *(printer_opt_ptr.value());`
`85`	`85`	`printer.log(nvbench::log_level::skip, exec_state.get_skip_reason());`
`86`	`86`	`}`
`87`	`87`	`}`