execspaces.hpp

Go to the documentation of this file.

//
// This file is subject to the terms and conditions defined in
// file 'LICENSE', which is part of this source code package.
//
 
#pragma once
 
#include <Kokkos_Core.hpp>
#include <cstdlib>
#include <iostream>
#include <variant>
 
namespace PACMAN {

struct ExecSpaces {
  static constexpr const unsigned char SERIAL = 0x00;
  static constexpr const unsigned char OPENMP = 0x01;
  static constexpr const unsigned char THREADS = 0x02;
  static constexpr const unsigned char CUDA = 0x03;
  static constexpr const unsigned char HIP = 0x04;
  static constexpr const unsigned char SYCL = 0x05;
};

namespace detail {
template <typename... Types> struct TypeList {};
 
template <typename List, typename Type> struct Append;
 
template <typename... Types, typename Type>
struct Append<TypeList<Types...>, Type> {
      using type = TypeList<Types..., Type>;
};
 
template <typename List> struct ToVariant;
 
template <typename... Types> struct ToVariant<TypeList<Types...>> {
      using type = std::variant<Types...>;
};
 
using ExecSpaces0 = TypeList<>;
#if defined(KOKKOS_ENABLE_SERIAL)
using ExecSpaces1 = typename Append<ExecSpaces0, Kokkos::Serial>::type;
#else
using ExecSpaces1 = ExecSpaces0;
#endif
#if defined(KOKKOS_ENABLE_OPENMP)
using ExecSpaces2 = typename Append<ExecSpaces1, Kokkos::OpenMP>::type;
#else
using ExecSpaces2 = ExecSpaces1;
#endif
#if defined(KOKKOS_ENABLE_THREADS)
using ExecSpaces3 = typename Append<ExecSpaces2, Kokkos::Threads>::type;
#else
using ExecSpaces3 = ExecSpaces2;
#endif
#if defined(KOKKOS_ENABLE_CUDA)
using ExecSpaces4 = typename Append<ExecSpaces3, Kokkos::Cuda>::type;
#else
using ExecSpaces4 = ExecSpaces3;
#endif
#if defined(KOKKOS_ENABLE_HIP)
using ExecSpaces5 = typename Append<ExecSpaces4, Kokkos::HIP>::type;
#else
using ExecSpaces5 = ExecSpaces4;
#endif
#if defined(KOKKOS_ENABLE_SYCL)
using ExecSpaces6 = typename Append<ExecSpaces5, Kokkos::SYCL>::type;
#else
using ExecSpaces6 = ExecSpaces5;
#endif
} // namespace detail
 
using AvailableExecSpaces = typename detail::ToVariant<detail::ExecSpaces6>::type;

static inline AvailableExecSpaces MakeExecSpace(const unsigned char s) {
  // clang-format off
  switch (s) {
    case ExecSpaces::SERIAL:
#if defined(KOKKOS_ENABLE_SERIAL)
      return Kokkos::Serial{};
#else
      std::cerr << "Kokkos::Serial is not enabled! Please recompile Kokkos with Kokkos_ENABLE_SERIAL!" << std::endl;
      exit(EXIT_FAILURE);
#endif
    case ExecSpaces::OPENMP:
#if defined(KOKKOS_ENABLE_OPENMP)
      return Kokkos::OpenMP{};
#else
      std::cerr << "Kokkos::OpenMP is not enabled! Please recompile Kokkos with Kokkos_ENABLE_OPENMP!" << std::endl;
      exit(EXIT_FAILURE);
#endif
    case ExecSpaces::THREADS:
#if defined(KOKKOS_ENABLE_THREADS)
      return Kokkos::Threads{};
#else
      std::cerr << "Kokkos::Threads is not enabled! Please recompile Kokkos with Kokkos_ENABLE_THREADS!" << std::endl;
      exit(EXIT_FAILURE);
#endif
    case ExecSpaces::CUDA:
#if defined(KOKKOS_ENABLE_CUDA)
      return Kokkos::Cuda{};
#else
      std::cerr << "Kokkos::Cuda is not enabled! Please recompile Kokkos with Kokkos_ENABLE_CUDA!" << std::endl;
      exit(EXIT_FAILURE);
#endif
    case ExecSpaces::HIP:
#if defined(KOKKOS_ENABLE_HIP)
      return Kokkos::HIP{};
#else
      std::cerr << "Kokkos::HIP is not enabled! Please recompile Kokkos with Kokkos_ENABLE_HIP!" << std::endl;
      exit(EXIT_FAILURE);
#endif
    case ExecSpaces::SYCL:
#if defined(KOKKOS_ENABLE_SYCL)
      return Kokkos::SYCL{};
#else
      std::cerr << "Kokkos::SYCL is not enabled! Please recompile Kokkos with Kokkos_ENABLE_SYCL!" << std::endl;
      exit(EXIT_FAILURE);
#endif
    default:
      std::cerr << "execspace: Serial, OpenMP, Threads, Cuda, HIP, SYCL" << std::endl;
      exit(EXIT_FAILURE);
  }
  // clang-format on
}
 
} // namespace PACMAN