backend_types.hpp

Go to the documentation of this file.

 
#ifndef PLSSVM_BACKEND_TYPES_HPP_
#define PLSSVM_BACKEND_TYPES_HPP_
#pragma once
 
#include "plssvm/backends/SYCL/implementation_type.hpp"  // plssvm::sycl::implementation_type
#include "plssvm/detail/type_traits.hpp"                 // plssvm::detail::remove_cvref_t
#include "plssvm/target_platforms.hpp"                   // plssvm::list_available_target_platforms
 
#include <iosfwd>                                        // forward declare std::ostream and std::istream
#include <vector>                                        // std::vector
 
namespace plssvm {
 
enum class backend_type {
    automatic,
    openmp,
    cuda,
    hip,
    opencl,
    sycl
};
 
[[nodiscard]] std::vector<backend_type> list_available_backends();
 
[[nodiscard]] backend_type determine_default_backend(const std::vector<backend_type> &available_backends = list_available_backends(),
                                                     const std::vector<target_platform> &available_target_platforms = list_available_target_platforms());
 
std::ostream &operator<<(std::ostream &out, backend_type backend);
 
std::istream &operator>>(std::istream &in, backend_type &backend);
 
// clang-format off
// Forward declare all possible C-SVMs.
namespace openmp { class csvm; }
namespace cuda { class csvm; }
namespace hip { class csvm; }
namespace opencl { class csvm; }
namespace hipsycl { class csvm; }
namespace dpcpp { class csvm; }
// clang-format on
 
namespace detail {
 
template <typename T>
struct csvm_to_backend_type {};
 
template <>
struct csvm_to_backend_type<openmp::csvm> {
    static constexpr backend_type value = backend_type::openmp;
};
template <>
struct csvm_to_backend_type<cuda::csvm> {
    static constexpr backend_type value = backend_type::cuda;
};
template <>
struct csvm_to_backend_type<hip::csvm> {
    static constexpr backend_type value = backend_type::hip;
};
template <>
struct csvm_to_backend_type<opencl::csvm> {
    static constexpr backend_type value = backend_type::opencl;
};
template <>
struct csvm_to_backend_type<hipsycl::csvm> {
    static constexpr backend_type value = backend_type::sycl;
    static constexpr sycl::implementation_type impl = sycl::implementation_type::hipsycl;
};
template <>
struct csvm_to_backend_type<dpcpp::csvm> {
    static constexpr backend_type value = backend_type::sycl;
    static constexpr sycl::implementation_type impl = sycl::implementation_type::dpcpp;
};
 
}  // namespace detail
 
template <typename T>
struct csvm_to_backend_type : detail::csvm_to_backend_type<detail::remove_cvref_t<T>> {};
template <typename T>
constexpr backend_type csvm_to_backend_type_v = csvm_to_backend_type<T>::value;
 
}  // namespace plssvm
 
#endif  // PLSSVM_BACKEND_TYPES_HPP_