Morpheus_GenericBackend.hpp

 
#ifndef MORPHEUS_GENERICBACKEND_HPP
#define MORPHEUS_GENERICBACKEND_HPP
 
#include <Morpheus_SpaceTraits.hpp>
 
namespace Morpheus {
template <typename Space>
struct GenericBackend {
  static_assert(has_execution_space_v<Space>,
                "Space needs to have a valid Execution Space!");
  static_assert(has_memory_space_v<Space>,
                "Space needs to have a valid Memory Space!");
  using backend = GenericBackend<Space>;  
  using execution_space =
      typename Space::execution_space;  
  using memory_space =
      typename Space::memory_space;  
  using device_type =
      Device<execution_space, memory_space,
             backend>;  
};
 
namespace Generic {
using DefaultHostExecutionSpace =
    Morpheus::GenericBackend<Kokkos::DefaultHostExecutionSpace>;
using DefaultExecutionSpace =
    Morpheus::GenericBackend<Kokkos::DefaultExecutionSpace>;
using HostSpace = Morpheus::GenericBackend<Kokkos::HostSpace>;
 
#if defined(MORPHEUS_ENABLE_SERIAL)
using Serial = Morpheus::GenericBackend<Kokkos::Serial>;
#endif
 
#if defined(MORPHEUS_ENABLE_OPENMP)
using OpenMP = Morpheus::GenericBackend<Kokkos::OpenMP>;
#endif
 
#if defined(MORPHEUS_ENABLE_CUDA)
using Cuda = Morpheus::GenericBackend<Kokkos::Cuda>;
using CudaSpace = Morpheus::GenericBackend<Kokkos::CudaSpace>;
#endif
 
#if defined(MORPHEUS_ENABLE_HIP)
using HIP = Morpheus::GenericBackend<Kokkos::HIP>;
using HIPSpace = Morpheus::GenericSpace<Kokkos::HIPSpace>;
#endif
}  // namespace Generic
 
namespace Impl {
template <typename T>
struct is_generic_backend_helper : std::false_type {};
 
template <typename Space>
struct is_generic_backend_helper<GenericBackend<Space>> : std::true_type {};
 
template <typename T>
using is_generic_backend = typename Impl::is_generic_backend_helper<
    typename std::remove_cv<T>::type>::type;
}  // namespace Impl
 
// Forward decl
template <class T>
class has_backend;
template <class T>
class is_generic_backend {
  typedef char yes[1];
  typedef char no[2];
 
  template <class U>
  static yes& test(
      U*,
      typename std::enable_if<
          Impl::is_generic_backend<U>::value || is_execution_space<U>::value ||
          is_memory_space<U>::value || Kokkos::is_device<U>::value>::type* =
          nullptr);
 
  template <class U>
  static no& test(...);
 
 public:
  static const bool value = sizeof(test<T>(nullptr)) == sizeof(yes);
};
template <class T>
inline constexpr bool is_generic_backend_v = is_generic_backend<T>::value;
 
template <class T>
class has_generic_backend {
  typedef char yes[1];
  typedef char no[2];
 
  template <class U>
  static yes& test(
      U*, typename std::enable_if<is_generic_backend_v<typename U::backend> ||
                                  is_generic_backend_v<U>>::type* = nullptr);
 
  template <class U>
  static no& test(...);
 
 public:
  static const bool value = sizeof(test<T>(nullptr)) == sizeof(yes);
};
template <class T>
inline constexpr bool has_generic_backend_v = has_generic_backend<T>::value;
 
}  // namespace Morpheus
 
#endif  // MORPHEUS_GENERICBACKEND_HPP