WIP CPU-only

Author: alliepiper

examples/CMakeLists.txt

@@ -2,6 +2,7 @@ set(example_srcs
   auto_throughput.cu
   axes.cu
   custom_criterion.cu
+  cpu_only.cu
   enums.cu
   exec_tag_sync.cu
   exec_tag_timer.cu

examples/cpu_only.cu

@@ -0,0 +1,66 @@
+/*
+ *  Copyright 2025 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 with the LLVM exception
+ *  (the "License"); you may not use this file except in compliance with
+ *  the License.
+ *
+ *  You may obtain a copy of the License at
+ *
+ *      http://llvm.org/foundation/relicensing/LICENSE.txt
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#include <nvbench/nvbench.cuh>
+
+#include <chrono>
+#include <thread>
+
+// Block execution of the current CPU thread for `seconds` seconds.
+void sleep_host(double seconds)
+{
+  const auto ms =
+    std::chrono::milliseconds(static_cast<nvbench::int64_t>(seconds * 1000));
+  std::this_thread::sleep_for(ms);
+}
+
+// Simple CPU-only benchmark that sleeps on host for a specified duration.
+void simple(nvbench::state &state)
+{
+  const auto duration = state.get_float64("Duration");
+
+  state.exec([duration](nvbench::launch &) { sleep_host(duration); });
+}
+NVBENCH_BENCH(simple)
+  // 100 -> 500 ms in 100 ms increments.
+  .add_float64_axis("Duration", nvbench::range(.1, .5, .1))
+  // Mark as CPU-only.
+  .set_is_cpu_only(true);
+
+// Simple CPU-only benchmark that sleeps on host for a specified duration and
+// uses a custom timed region.
+void simple_timer(nvbench::state &state)
+{
+  const auto duration = state.get_float64("Duration");
+
+  state.exec(nvbench::exec_tag::timer, [duration](nvbench::launch &, auto &timer) {
+    // Do any setup work before starting the timer here...
+    timer.start();
+
+    // The region of code to be timed:
+    sleep_host(duration);
+
+    timer.stop();
+    // Any per-run cleanup here...
+  });
+}
+NVBENCH_BENCH(simple_timer)
+  // 100 -> 500 ms in 100 ms increments.
+  .add_float64_axis("Duration", nvbench::range(.1, .5, .1))
+  // Mark as CPU-only.
+  .set_is_cpu_only(true);

nvbench/CMakeLists.txt

@@ -25,6 +25,7 @@ set(srcs
 
   detail/entropy_criterion.cxx
   detail/measure_cold.cu
+  detail/measure_cpu_only.cxx
   detail/measure_hot.cu
   detail/state_generator.cxx
   detail/stdrel_criterion.cxx

nvbench/benchmark_base.cuh

@@ -159,6 +159,16 @@ struct benchmark_base
   }
   /// @}
 
+  /// If true, the benchmark measurements only record CPU time and assume no GPU work is performed.
+  /// @{
+  [[nodiscard]] bool get_is_cpu_only() const { return m_is_cpu_only; }
+  benchmark_base &set_is_cpu_only(bool is_cpu_only)
+  {
+    m_is_cpu_only = is_cpu_only;
+    return *this;
+  }
+  /// @}
+
   /// If true, the benchmark is only run once, skipping all warmup runs and only
   /// executing a single non-batched measurement. This is intended for use with
   /// external profiling tools. @{
@@ -263,6 +273,7 @@ protected:
 
   optional_ref<nvbench::printer_base> m_printer;
 
+  bool m_is_cpu_only{false};
   bool m_run_once{false};
   bool m_disable_blocking_kernel{false};
 

nvbench/benchmark_base.cxx

@@ -34,12 +34,18 @@ std::unique_ptr<benchmark_base> benchmark_base::clone() const
   result->m_axes    = m_axes;
   result->m_devices = m_devices;
 
-  result->m_min_samples      = m_min_samples;
-  result->m_criterion_params = m_criterion_params;
+  result->m_printer = m_printer;
+
+  result->m_is_cpu_only             = m_is_cpu_only;
+  result->m_run_once                = m_run_once;
+  result->m_disable_blocking_kernel = m_disable_blocking_kernel;
+
+  result->m_min_samples = m_min_samples;
 
   result->m_skip_time = m_skip_time;
   result->m_timeout   = m_timeout;
 
+  result->m_criterion_params   = m_criterion_params;
   result->m_stopping_criterion = m_stopping_criterion;
 
   return result;

nvbench/benchmark_manager.cxx

@@ -40,7 +40,10 @@ void benchmark_manager::initialize()
   const auto& mgr = device_manager::get();
   for (auto& bench : m_benchmarks)
   {
-    bench->set_devices(mgr.get_devices());
+    if (!bench->get_is_cpu_only())
+    {
+      bench->set_devices(mgr.get_devices());
+    }
   }
 }
 

nvbench/detail/measure_cpu_only.cuh

@@ -0,0 +1,141 @@
+/*
+ *  Copyright 2021-2025 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 with the LLVM exception
+ *  (the "License"); you may not use this file except in compliance with
+ *  the License.
+ *
+ *  You may obtain a copy of the License at
+ *
+ *      http://llvm.org/foundation/relicensing/LICENSE.txt
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <nvbench/cpu_timer.cuh>
+#include <nvbench/exec_tag.cuh>
+#include <nvbench/launch.cuh>
+#include <nvbench/stopping_criterion.cuh>
+
+#include <nvbench/detail/kernel_launcher_timer_wrapper.cuh>
+#include <nvbench/detail/statistics.cuh>
+
+#include <utility>
+#include <vector>
+
+namespace nvbench
+{
+
+struct state;
+
+namespace detail
+{
+
+// non-templated code goes here:
+struct measure_cpu_only_base
+{
+  explicit measure_cpu_only_base(nvbench::state &exec_state);
+  measure_cpu_only_base(const measure_cpu_only_base &)            = delete;
+  measure_cpu_only_base(measure_cpu_only_base &&)                 = delete;
+  measure_cpu_only_base &operator=(const measure_cpu_only_base &) = delete;
+  measure_cpu_only_base &operator=(measure_cpu_only_base &&)      = delete;
+
+protected:
+  void check();
+  void initialize();
+  void run_trials_prologue();
+  void record_measurements();
+  bool is_finished();
+  void run_trials_epilogue();
+  void generate_summaries();
+
+  void check_skip_time(nvbench::float64_t warmup_time);
+
+  nvbench::state &m_state;
+
+  // Required to satisfy the KernelLauncher interface:
+  nvbench::launch m_launch;
+
+  nvbench::cpu_timer m_cpu_timer;
+  nvbench::cpu_timer m_walltime_timer;
+
+  nvbench::criterion_params m_criterion_params;
+  nvbench::stopping_criterion_base& m_stopping_criterion;
+
+  bool m_run_once{false};
+
+  nvbench::int64_t m_min_samples{};
+
+  nvbench::float64_t m_skip_time{};
+  nvbench::float64_t m_timeout{};
+
+  nvbench::int64_t m_total_samples{};
+  nvbench::float64_t m_total_cpu_time{};
+  nvbench::float64_t m_cpu_noise{}; // rel stdev
+
+  std::vector<nvbench::float64_t> m_cpu_times;
+
+  bool m_max_time_exceeded{};
+};
+
+template <typename KernelLauncher>
+struct measure_cpu_only : public measure_cpu_only_base
+{
+  measure_cpu_only(nvbench::state &state, KernelLauncher &kernel_launcher)
+      : measure_cpu_only_base(state)
+      , m_kernel_launcher{kernel_launcher}
+  {}
+
+  void operator()()
+  {
+    this->check();
+    this->initialize();
+    this->run_warmup();
+
+    this->run_trials_prologue();
+    this->run_trials();
+    this->run_trials_epilogue();
+
+    this->generate_summaries();
+  }
+
+private:
+  // Run the kernel once, measuring the CPU time. If under skip_time, skip the
+  // measurement.
+  void run_warmup()
+  {
+    if (m_run_once)
+    { // Skip warmups
+      return;
+    }
+
+    this->launch_kernel(m_cpu_timer);
+    this->check_skip_time(m_cpu_timer.get_duration());
+  }
+
+  void run_trials()
+  {
+    do
+    {
+      this->launch_kernel(m_cpu_timer);
+      this->record_measurements();
+    } while (!this->is_finished());
+  }
+
+  template <typename TimerT>
+  __forceinline__ void launch_kernel(TimerT &timer)
+  {
+    m_kernel_launcher(m_launch, timer);
+  }
+
+  KernelLauncher &m_kernel_launcher;
+};
+
+} // namespace detail
+} // namespace nvbench