Merge branch 'regression' into spack

Author: vancraar

bindings/Python/backend_types.cpp

@@ -18,7 +18,7 @@ namespace py = pybind11;
 
 void init_backend_types(py::module_ &m) {
     // bind enum class
-    py::enum_<plssvm::backend_type>(m, "BackendType")
+    py::enum_<plssvm::backend_type>(m, "BackendType", "Enum class for all possible backend types, all different SYCL implementations have the same backend type \"sycl\".")
         .value("AUTOMATIC", plssvm::backend_type::automatic, "the default backend; depends on the specified target platform")
         .value("OPENMP", plssvm::backend_type::openmp, "OpenMP to target CPUs only (currently no OpenMP target offloading support)")
         .value("HPX", plssvm::backend_type::hpx, "HPX to target CPUs only (currently no GPU executor support)")

bindings/Python/backends/adaptivecpp_csvm.cpp

@@ -35,12 +35,13 @@ void bind_adaptivecpp_csvms(py::module_ &m, const std::string &csvm_name) {
     using backend_csvm_type = plssvm::adaptivecpp::backend_csvm_type_t<csvm_type>;
 
     // assemble docstrings
+    const std::string class_docstring{ fmt::format("A {} using the AdaptiveCpp SYCL backend.", csvm_name) };
     const std::string param_docstring{ fmt::format("create an AdaptiveCpp SYCL {} with the provided parameters and optional SYCL specific keyword arguments", csvm_name) };
     const std::string target_param_docstring{ fmt::format("create an AdaptiveCpp SYCL {} with the provided target platform, parameters, and optional SYCL specific keyword arguments", csvm_name) };
     const std::string kwargs_docstring{ fmt::format("create an AdaptiveCpp SYCL {} with the provided keyword arguments (including optional SYCL specific keyword arguments)", csvm_name) };
     const std::string target_kwargs_docstring{ fmt::format("create an AdaptiveCpp SYCL {} with the provided target platform and keyword arguments (including optional SYCL specific keyword arguments)", csvm_name) };
 
-    py::class_<backend_csvm_type, plssvm::adaptivecpp::csvm, csvm_type>(m, csvm_name.c_str())
+    py::class_<backend_csvm_type, plssvm::adaptivecpp::csvm, csvm_type>(m, csvm_name.c_str(), class_docstring.c_str())
         .def(py::init([](const plssvm::parameter params, const py::kwargs &args) {
                  // check for valid keys
                  plssvm::bindings::python::util::check_kwargs_for_correctness(args, { "sycl_kernel_invocation_type" });
@@ -81,7 +82,10 @@ void bind_adaptivecpp_csvms(py::module_ &m, const std::string &csvm_name) {
                  return std::make_unique<backend_csvm_type>(target, params, plssvm::sycl_kernel_invocation_type = invocation);
              }),
              target_kwargs_docstring.c_str())
-        .def("get_kernel_invocation_type", &plssvm::adaptivecpp::csvm::get_kernel_invocation_type, "get the kernel invocation type used in this SYCL C-SVM");
+        .def("get_kernel_invocation_type", &plssvm::adaptivecpp::csvm::get_kernel_invocation_type, "get the kernel invocation type used in this SYCL C-SVM")
+        .def("__repr__", [csvm_name](const backend_csvm_type &self) {
+            return fmt::format("<plssvm.adaptivecpp.{} with {{ #devices: {}, kernel_invocation_type: {} }}>", csvm_name, self.num_available_devices(), self.get_kernel_invocation_type());
+        });
 }
 
 }  // namespace

bindings/Python/backends/cuda_csvm.cpp

@@ -34,12 +34,13 @@ void bind_cuda_csvms(py::module_ &m, const std::string &csvm_name) {
     using backend_csvm_type = plssvm::cuda::backend_csvm_type_t<csvm_type>;
 
     // assemble docstrings
+    const std::string class_docstring{ fmt::format("A {} using the CUDA backend.", csvm_name) };
     const std::string param_docstring{ fmt::format("create a CUDA {} with the provided parameters", csvm_name) };
     const std::string target_param_docstring{ fmt::format("create a CUDA {} with the provided target platform and parameters", csvm_name) };
     const std::string kwargs_docstring{ fmt::format("create a CUDA {} with the provided keyword arguments", csvm_name) };
     const std::string target_kwargs_docstring{ fmt::format("create a CUDA {} with the provided target platform and keyword arguments", csvm_name) };
 
-    py::class_<backend_csvm_type, plssvm::cuda::csvm, csvm_type>(m, csvm_name.c_str())
+    py::class_<backend_csvm_type, plssvm::cuda::csvm, csvm_type>(m, csvm_name.c_str(), class_docstring.c_str())
         .def(py::init<plssvm::parameter>(), param_docstring.c_str())
         .def(py::init<plssvm::target_platform, plssvm::parameter>(), target_param_docstring.c_str())
         .def(py::init([](const py::kwargs &args) {
@@ -59,7 +60,10 @@ void bind_cuda_csvms(py::module_ &m, const std::string &csvm_name) {
                  // create C-SVM with the provided target platform
                  return std::make_unique<backend_csvm_type>(target, params);
              }),
-             target_kwargs_docstring.c_str());
+             target_kwargs_docstring.c_str())
+        .def("__repr__", [csvm_name](const backend_csvm_type &self) {
+            return fmt::format("<plssvm.cuda.{} with {{ #devices: {} }}>", csvm_name, self.num_available_devices());
+        });
 }
 
 }  // namespace

bindings/Python/backends/dpcpp_csvm.cpp

@@ -35,12 +35,13 @@ void bind_dpcpp_csvms(py::module_ &m, const std::string &csvm_name) {
     using backend_csvm_type = plssvm::dpcpp::backend_csvm_type_t<csvm_type>;
 
     // assemble docstrings
+    const std::string class_docstring{ fmt::format("A {} using the DPC++ SYCL backend.", csvm_name) };
     const std::string param_docstring{ fmt::format("create a DPC++ SYCL {} with the provided parameters and optional SYCL specific keyword arguments", csvm_name) };
     const std::string target_param_docstring{ fmt::format("create a DPC++ SYCL {} with the provided target platform, parameters, and optional SYCL specific keyword arguments", csvm_name) };
     const std::string kwargs_docstring{ fmt::format("create a DPC++ SYCL {} with the provided keyword arguments (including optional SYCL specific keyword arguments)", csvm_name) };
     const std::string target_kwargs_docstring{ fmt::format("create a DPC++ SYCL {} with the provided target platform and keyword arguments (including optional SYCL specific keyword arguments)", csvm_name) };
 
-    py::class_<backend_csvm_type, plssvm::dpcpp::csvm, csvm_type>(m, csvm_name.c_str())
+    py::class_<backend_csvm_type, plssvm::dpcpp::csvm, csvm_type>(m, csvm_name.c_str(), class_docstring.c_str())
         .def(py::init([](const plssvm::parameter params, const py::kwargs &args) {
                  // check for valid keys
                  plssvm::bindings::python::util::check_kwargs_for_correctness(args, { "sycl_kernel_invocation_type" });
@@ -81,7 +82,10 @@ void bind_dpcpp_csvms(py::module_ &m, const std::string &csvm_name) {
                  return std::make_unique<backend_csvm_type>(target, params, plssvm::sycl_kernel_invocation_type = invocation);
              }),
              target_kwargs_docstring.c_str())
-        .def("get_kernel_invocation_type", &plssvm::dpcpp::csvm::get_kernel_invocation_type, "get the kernel invocation type used in this SYCL C-SVM");
+        .def("get_kernel_invocation_type", &plssvm::dpcpp::csvm::get_kernel_invocation_type, "get the kernel invocation type used in this SYCL C-SVM")
+        .def("__repr__", [csvm_name](const backend_csvm_type &self) {
+            return fmt::format("<plssvm.dpcpp.{} with {{ #devices: {}, kernel_invocation_type: {} }}>", csvm_name, self.num_available_devices(), self.get_kernel_invocation_type());
+        });
 }
 
 }  // namespace

bindings/Python/backends/hip_csvm.cpp

@@ -34,12 +34,13 @@ void bind_hip_csvms(py::module_ &m, const std::string &csvm_name) {
     using backend_csvm_type = plssvm::hip::backend_csvm_type_t<csvm_type>;
 
     // assemble docstrings
+    const std::string class_docstring{ fmt::format("A {} using the HIP backend.", csvm_name) };
     const std::string param_docstring{ fmt::format("create a HIP {} with the provided parameters", csvm_name) };
     const std::string target_param_docstring{ fmt::format("create a HIP {} with the provided target platform and parameters", csvm_name) };
     const std::string kwargs_docstring{ fmt::format("create a HIP {} with the provided keyword arguments", csvm_name) };
     const std::string target_kwargs_docstring{ fmt::format("create a HIP {} with the provided target platform and keyword arguments", csvm_name) };
 
-    py::class_<backend_csvm_type, plssvm::hip::csvm, csvm_type>(m, csvm_name.c_str())
+    py::class_<backend_csvm_type, plssvm::hip::csvm, csvm_type>(m, csvm_name.c_str(), class_docstring.c_str())
         .def(py::init<plssvm::parameter>(), param_docstring.c_str())
         .def(py::init<plssvm::target_platform, plssvm::parameter>(), target_param_docstring.c_str())
         .def(py::init([](const py::kwargs &args) {
@@ -59,7 +60,10 @@ void bind_hip_csvms(py::module_ &m, const std::string &csvm_name) {
                  // create C-SVM with the provided target platform
                  return std::make_unique<backend_csvm_type>(target, params);
              }),
-             target_kwargs_docstring.c_str());
+             target_kwargs_docstring.c_str())
+        .def("__repr__", [csvm_name](const backend_csvm_type &self) {
+            return fmt::format("<plssvm.hip.{} with {{ #devices: {} }}>", csvm_name, self.num_available_devices());
+        });
 }
 
 }  // namespace

bindings/Python/backends/hpx_csvm.cpp

@@ -35,12 +35,13 @@ void bind_hpx_csvms(py::module_ &m, const std::string &csvm_name) {
     using backend_csvm_type = plssvm::hpx::backend_csvm_type_t<csvm_type>;
 
     // assemble docstrings
+    const std::string class_docstring{ fmt::format("A {} using the HPX backend.", csvm_name) };
     const std::string param_docstring{ fmt::format("create an HPX {} with the provided parameters", csvm_name) };
     const std::string target_param_docstring{ fmt::format("create an HPX {} with the provided target platform and parameters", csvm_name) };
     const std::string kwargs_docstring{ fmt::format("create an HPX {} with the provided keyword arguments", csvm_name) };
     const std::string target_kwargs_docstring{ fmt::format("create an HPX {} with the provided target platform and keyword arguments", csvm_name) };
 
-    py::class_<backend_csvm_type, plssvm::hpx::csvm, csvm_type>(m, csvm_name.c_str())
+    py::class_<backend_csvm_type, plssvm::hpx::csvm, csvm_type>(m, csvm_name.c_str(), class_docstring.c_str())
         .def(py::init<plssvm::parameter>(), param_docstring.c_str())
         .def(py::init<plssvm::target_platform, plssvm::parameter>(), target_param_docstring.c_str())
         .def(py::init([](const py::kwargs &args) {
@@ -60,7 +61,10 @@ void bind_hpx_csvms(py::module_ &m, const std::string &csvm_name) {
                  // create C-SVM with the provided target platform
                  return std::make_unique<backend_csvm_type>(target, params);
              }),
-             target_kwargs_docstring.c_str());
+             target_kwargs_docstring.c_str())
+        .def("__repr__", [csvm_name](const backend_csvm_type &self) {
+            return fmt::format("<plssvm.hpx.{} with {{ #devices: {} }}>", csvm_name, self.num_available_devices());
+        });
 }
 
 }  // namespace

bindings/Python/backends/kokkos_csvm.cpp

@@ -35,12 +35,13 @@ void bind_kokkos_csvms(py::module_ &m, const std::string &csvm_name) {
     using backend_csvm_type = plssvm::kokkos::backend_csvm_type_t<csvm_type>;
 
     // assemble docstrings
+    const std::string class_docstring{ fmt::format("A {} using the Kokkos backend.", csvm_name) };
     const std::string param_docstring{ fmt::format("create a Kokkos {} with the provided parameters and optional Kokkos specific keyword arguments", csvm_name) };
     const std::string target_param_docstring{ fmt::format("create a Kokkos {} with the provided target platform, parameters, and optional Kokkos specific keyword arguments", csvm_name) };
     const std::string kwargs_docstring{ fmt::format("create a Kokkos {} with the provided keyword arguments (including optional Kokkos specific keyword arguments)", csvm_name) };
     const std::string target_kwargs_docstring{ fmt::format("create a Kokkos {} with the provided target platform and keyword arguments (including optional Kokkos specific keyword arguments)", csvm_name) };
 
-    py::class_<backend_csvm_type, plssvm::kokkos::csvm, csvm_type>(m, csvm_name.c_str())
+    py::class_<backend_csvm_type, plssvm::kokkos::csvm, csvm_type>(m, csvm_name.c_str(), class_docstring.c_str())
         .def(py::init([](const plssvm::parameter params, const py::kwargs &args) {
                  // check for valid keys
                  plssvm::bindings::python::util::check_kwargs_for_correctness(args, { "kokkos_execution_space" });
@@ -81,7 +82,10 @@ void bind_kokkos_csvms(py::module_ &m, const std::string &csvm_name) {
                  return std::make_unique<backend_csvm_type>(target, params, plssvm::kokkos_execution_space = space);
              }),
              target_kwargs_docstring.c_str())
-        .def("get_execution_space", &plssvm::kokkos::csvm::get_execution_space, "get the Kokkos execution space used in this Kokkos C-SVM");
+        .def("get_execution_space", &plssvm::kokkos::csvm::get_execution_space, "get the Kokkos execution space used in this Kokkos C-SVM")
+        .def("__repr__", [csvm_name](const backend_csvm_type &self) {
+            return fmt::format("<plssvm.kokkos.{} with {{ #devices: {}, execution_space: {} }}>", csvm_name, self.num_available_devices(), self.get_execution_space());
+        });
 }
 
 }  // namespace

bindings/Python/backends/opencl_csvm.cpp

@@ -34,12 +34,13 @@ void bind_opencl_csvms(py::module_ &m, const std::string &csvm_name) {
     using backend_csvm_type = plssvm::opencl::backend_csvm_type_t<csvm_type>;
 
     // assemble docstrings
+    const std::string class_docstring{ fmt::format("A {} using the OpenCL backend.", csvm_name) };
     const std::string param_docstring{ fmt::format("create an OpenCL {} with provided parameters", csvm_name) };
     const std::string target_param_docstring{ fmt::format("create an OpenCL {} with the provided target platform and parameters", csvm_name) };
     const std::string kwargs_docstring{ fmt::format("create an OpenCL {} with the provided keyword arguments", csvm_name) };
     const std::string target_kwargs_docstring{ fmt::format("create an OpenCL {} with the provided target platform and keyword arguments", csvm_name) };
 
-    py::class_<backend_csvm_type, plssvm::opencl::csvm, csvm_type>(m, csvm_name.c_str())
+    py::class_<backend_csvm_type, plssvm::opencl::csvm, csvm_type>(m, csvm_name.c_str(), class_docstring.c_str())
         .def(py::init<plssvm::parameter>(), param_docstring.c_str())
         .def(py::init<plssvm::target_platform, plssvm::parameter>(), target_param_docstring.c_str())
         .def(py::init([](const py::kwargs &args) {
@@ -59,7 +60,10 @@ void bind_opencl_csvms(py::module_ &m, const std::string &csvm_name) {
                  // create C-SVM with the provided target platform
                  return std::make_unique<backend_csvm_type>(target, params);
              }),
-             target_kwargs_docstring.c_str());
+             target_kwargs_docstring.c_str())
+        .def("__repr__", [csvm_name](const backend_csvm_type &self) {
+            return fmt::format("<plssvm.opencl.{} with {{ #devices: {} }}>", csvm_name, self.num_available_devices());
+        });
 }
 
 }  // namespace

bindings/Python/backends/openmp_csvm.cpp

@@ -34,12 +34,13 @@ void bind_openmp_csvms(py::module_ &m, const std::string &csvm_name) {
     using backend_csvm_type = plssvm::openmp::backend_csvm_type_t<csvm_type>;
 
     // assemble docstrings
+    const std::string class_docstring{ fmt::format("A {} using the OpenMP backend.", csvm_name) };
     const std::string param_docstring{ fmt::format("create an OpenMP {} with the provided parameters", csvm_name) };
     const std::string target_param_docstring{ fmt::format("create an OpenMP {} with the provided target platform and parameters", csvm_name) };
     const std::string kwargs_docstring{ fmt::format("create an OpenMP {} with the provided keyword arguments", csvm_name) };
     const std::string target_kwargs_docstring{ fmt::format("create an OpenMP {} with the provided target platform and keyword arguments", csvm_name) };
 
-    py::class_<backend_csvm_type, plssvm::openmp::csvm, csvm_type>(m, csvm_name.c_str())
+    py::class_<backend_csvm_type, plssvm::openmp::csvm, csvm_type>(m, csvm_name.c_str(), class_docstring.c_str())
         .def(py::init<plssvm::parameter>(), param_docstring.c_str())
         .def(py::init<plssvm::target_platform, plssvm::parameter>(), target_param_docstring.c_str())
         .def(py::init([](const py::kwargs &args) {
@@ -59,7 +60,10 @@ void bind_openmp_csvms(py::module_ &m, const std::string &csvm_name) {
                  // create C-SVM with the provided target platform
                  return std::make_unique<backend_csvm_type>(target, params);
              }),
-             target_kwargs_docstring.c_str());
+             target_kwargs_docstring.c_str())
+        .def("__repr__", [csvm_name](const backend_csvm_type &self) {
+            return fmt::format("<plssvm.openmp.{} with {{ #devices: {} }}>", csvm_name, self.num_available_devices());
+        });
 }
 
 }  // namespace

bindings/Python/backends/stdpar_csvm.cpp

@@ -35,6 +35,7 @@ void bind_stdpar_csvms(py::module_ &m, const std::string &csvm_name) {
     using backend_csvm_type = plssvm::stdpar::backend_csvm_type_t<csvm_type>;
 
     // assemble docstrings
+    const std::string class_docstring{ fmt::format("A {} using the stdpar backend.", csvm_name) };
     const std::string param_docstring{ fmt::format("create an stdpar {} with the provided parameters", csvm_name) };
     const std::string target_param_docstring{ fmt::format("create an stdpar {} with the provided target platform and parameters", csvm_name) };
     const std::string kwargs_docstring{ fmt::format("create an stdpar {} with the provided keyword arguments", csvm_name) };
@@ -60,7 +61,11 @@ void bind_stdpar_csvms(py::module_ &m, const std::string &csvm_name) {
                  // create C-SVM with the provided target platform
                  return std::make_unique<backend_csvm_type>(target, params);
              }),
-             target_kwargs_docstring.c_str());
+             target_kwargs_docstring.c_str())
+        .def("get_implementation_type", &plssvm::stdpar::csvm::get_implementation_type, "get the stdpar implementation used in this stdpar C-SVM")
+        .def("__repr__", [csvm_name](const backend_csvm_type &self) {
+            return fmt::format("<plssvm.stdpar.{} with {{ #devices: {}, implementation_type: {} }}>", csvm_name, self.num_available_devices(), self.get_implementation_type());
+        });
 }
 
 }  // namespace
@@ -71,7 +76,7 @@ void init_stdpar_csvm(py::module_ &m, const py::exception<plssvm::exception> &ba
     const py::module_ stdpar_pure_virtual_module = stdpar_module.def_submodule("__pure_virtual", "a module containing all pure-virtual stdpar backend specific functionality");
 
     // bind the enum class
-    py::enum_<plssvm::stdpar::implementation_type>(stdpar_module, "ImplementationType")
+    py::enum_<plssvm::stdpar::implementation_type>(stdpar_module, "ImplementationType", "Enum class for all supported stdpar implementations in PLSSVM.")
         .value("NVHPC", plssvm::stdpar::implementation_type::nvhpc, "use NVIDIA's HPC SDK (NVHPC) compiler nvc++")
         .value("ROC_STDPAR", plssvm::stdpar::implementation_type::roc_stdpar, "use AMD's roc-stdpar compiler (patched LLVM)")
         .value("INTEL_LLVM", plssvm::stdpar::implementation_type::intel_llvm, "use Intel's LLVM compiler icpx")