Report mean SM clock rate

nvbench/detail/measure_cold.cu

@@ -54,6 +54,7 @@ measure_cold_base::measure_cold_base(state &exec_state)
   {
     m_cuda_times.reserve(static_cast<std::size_t>(m_min_samples));
     m_cpu_times.reserve(static_cast<std::size_t>(m_min_samples));
+    m_sm_clock_rates.reserve(static_cast<std::size_t>(m_min_samples));
   }
 }
 
@@ -83,6 +84,7 @@ void measure_cold_base::initialize()
 
   m_cuda_times.clear();
   m_cpu_times.clear();
+  m_sm_clock_rates.clear();
 
   m_stopping_criterion.initialize(m_criterion_params);
 }
@@ -94,6 +96,7 @@ void measure_cold_base::record_measurements()
   if (!m_run_once)
   {
     auto peak_clock_rate = static_cast<float>(m_state.get_device()->get_sm_default_clock_rate());
+    m_sm_clock_rates.push_back(peak_clock_rate);
 
     if (m_gpu_frequency.has_throttled(peak_clock_rate, m_throttle_threshold))
     {
@@ -338,6 +341,17 @@ void measure_cold_base::generate_summaries()
     summ.set_string("hide", "Hidden by default.");
   }
 
+  if (!m_sm_clock_rates.empty())
+  {
+    auto &summ = m_state.add_summary("nv/cold/sm_clock_rate/mean");
+    summ.set_string("name", "Clock Rate");
+    summ.set_string("hint", "frequency");
+    summ.set_string("description", "Mean SM clock rate");
+    summ.set_string("hide", "Hidden by default.");
+    summ.set_float64("value", nvbench::detail::statistics::compute_mean(m_sm_clock_rates.cbegin(), 
+                                                                        m_sm_clock_rates.cend()));
+  }
+
   // Log if a printer exists:
   if (auto printer_opt_ref = m_state.get_benchmark().get_printer(); printer_opt_ref.has_value())
   {

nvbench/detail/measure_cold.cuh

@@ -36,6 +36,7 @@
 
 #include <utility>
 #include <vector>
+#include "nvbench/types.cuh"
 
 namespace nvbench
 {
@@ -117,6 +118,7 @@ protected:
 
   std::vector<nvbench::float64_t> m_cuda_times;
   std::vector<nvbench::float64_t> m_cpu_times;
+  std::vector<nvbench::float32_t> m_sm_clock_rates;
 
   bool m_max_time_exceeded{};
 };

nvbench/markdown_printer.cu

@@ -294,6 +294,10 @@ void markdown_printer::do_print_benchmark_results(const printer_base::benchmark_
             {
               table.add_cell(row, tag, header, this->do_format_item_rate(summ));
             }
+            else if (hint == "frequency")
+            {
+              table.add_cell(row, tag, header, this->do_format_frequency(summ));
+            }
             else if (hint == "bytes")
             {
               table.add_cell(row, tag, header, this->do_format_bytes(summ));
@@ -399,6 +403,27 @@ std::string markdown_printer::do_format_item_rate(const summary &data)
   }
 }
 
+std::string markdown_printer::do_format_frequency(const nvbench::summary &data)
+{
+  const auto frequency_hz = data.get_float64("value");
+  if (frequency_hz >= 1e9)
+  {
+    return fmt::format("{:0.3f} GHz", frequency_hz * 1e-9);
+  }
+  else if (frequency_hz >= 1e6)
+  {
+    return fmt::format("{:0.3f} MHz", frequency_hz * 1e-6);
+  }
+  else if (frequency_hz >= 1e3)
+  {
+    return fmt::format("{:0.3f} KHz", frequency_hz * 1e-3);
+  }
+  else
+  {
+    return fmt::format("{:0.3f} Hz", frequency_hz);
+  }
+}
+
 std::string markdown_printer::do_format_bytes(const summary &data)
 {
   const auto bytes = static_cast<nvbench::float64_t>(data.get_int64("value"));

nvbench/markdown_printer.cuh

@@ -64,6 +64,7 @@ protected:
   virtual std::string do_format_default(const nvbench::summary &data);
   virtual std::string do_format_duration(const nvbench::summary &seconds);
   virtual std::string do_format_item_rate(const nvbench::summary &items_per_sec);
+  virtual std::string do_format_frequency(const nvbench::summary &frequency_hz);
   virtual std::string do_format_bytes(const nvbench::summary &bytes);
   virtual std::string do_format_byte_rate(const nvbench::summary &bytes_per_sec);
   virtual std::string do_format_sample_size(const nvbench::summary &count);