[SYCLomatic] Use macro __INTEL_MKL__ to distinguish functionality of helper functions, make it buildable with Intel open source MKL library (#785)

open source MKL: oneAPI Math Kernel Library (oneMKL) Interfaces

Signed-off-by: Tang, Jiajun [email protected]

Author: tangjj11

clang/runtime/dpct-rt/include/blas_utils.hpp.inc

@@ -147,6 +147,10 @@ public:
 template <typename Tx, typename Tr>
 inline void nrm2_impl(sycl::queue &q, int n, const void *x, int incx,
                          void *result) {
+#ifndef __INTEL_MKL__
+  throw std::runtime_error("The oneAPI Math Kernel Library (oneMKL) Interfaces "
+                           "Project does not support this API.");
+#else
 #ifdef DPCT_USM_LEVEL_NONE
   auto x_buffer = dpct::get_buffer<Tx>(x);
   auto r_buffer =
@@ -159,6 +163,7 @@ inline void nrm2_impl(sycl::queue &q, int n, const void *x, int incx,
   oneapi::mkl::blas::column_major::nrm2(q, n, reinterpret_cast<const Tx *>(x),
                                         incx, res_mem.get_ptr());
 #endif
+#endif
 }
 // DPCT_LABEL_END
 
@@ -172,6 +177,10 @@ inline void nrm2_impl(sycl::queue &q, int n, const void *x, int incx,
 template <bool is_conjugate, class Txy, class Tr>
 inline void dotuc_impl(sycl::queue &q, int n, const Txy *x, int incx,
                           const Txy *y, int incy, Tr *result) {
+#ifndef __INTEL_MKL__
+  throw std::runtime_error("The oneAPI Math Kernel Library (oneMKL) Interfaces "
+                           "Project does not support this API.");
+#else
 #ifdef DPCT_USM_LEVEL_NONE
   auto x_buffer = dpct::get_buffer<Txy>(x);
   auto y_buffer = dpct::get_buffer<Txy>(y);
@@ -200,6 +209,7 @@ inline void dotuc_impl(sycl::queue &q, int n, const Txy *x, int incx,
   } else
     oneapi::mkl::blas::column_major::dot(q, n, x, incx, y, incy, res_mem.get_ptr());
 #endif
+#endif
 }
 // DPCT_LABEL_END
 
@@ -273,10 +283,15 @@ inline void dotuc(sycl::queue &q, int n, const void *x,
 template <class Tx, class Te>
 inline void scal_impl(sycl::queue &q, int n, const void *alpha, void *x,
                          int incx) {
+#ifndef __INTEL_MKL__
+  throw std::runtime_error("The oneAPI Math Kernel Library (oneMKL) Interfaces "
+                           "Project does not support this API.");
+#else
   Te alpha_val = dpct::get_value(reinterpret_cast<const Te *>(alpha), q);
   auto data_x = get_memory(reinterpret_cast<Tx *>(x));
   oneapi::mkl::blas::column_major::scal(q, n, alpha_val,
                                         data_x, incx);
+#endif
 }
 // DPCT_LABEL_END
 
@@ -289,12 +304,17 @@ inline void scal_impl(sycl::queue &q, int n, const void *alpha, void *x,
 template <class Txy, class Te>
 inline void axpy_impl(sycl::queue &q, int n, const void *alpha, const void *x,
                         int incx, void *y, int incy) {
+#ifndef __INTEL_MKL__
+  throw std::runtime_error("The oneAPI Math Kernel Library (oneMKL) Interfaces "
+                           "Project does not support this API.");
+#else
   Te alpha_val = dpct::get_value(reinterpret_cast<const Te *>(alpha), q);
   auto data_x = get_memory(reinterpret_cast<const Txy *>(x));
   auto data_y = get_memory(reinterpret_cast<Txy *>(y));
   oneapi::mkl::blas::column_major::axpy(q, n, alpha_val,
                                         data_x, incx,
                                         data_y, incy);
+#endif
 }
 // DPCT_LABEL_END
 
@@ -307,13 +327,18 @@ inline void axpy_impl(sycl::queue &q, int n, const void *alpha, const void *x,
 template <class Txy, class Tc, class Ts>
 inline void rot_impl(sycl::queue &q, int n, void *x, int incx, void *y,
                         int incy, const void *c, const void *s) {
+#ifndef __INTEL_MKL__
+  throw std::runtime_error("The oneAPI Math Kernel Library (oneMKL) Interfaces "
+                           "Project does not support this API.");
+#else
   Tc c_value = dpct::get_value(reinterpret_cast<const Tc *>(c), q);
   Ts s_value = dpct::get_value(reinterpret_cast<const Ts *>(s), q);
   auto data_x = get_memory(reinterpret_cast<Txy *>(x));
   auto data_y = get_memory(reinterpret_cast<Txy *>(y));
   oneapi::mkl::blas::column_major::rot(q, n, data_x, incx,
                                        data_y, incy, c_value,
                                        s_value);
+#endif
 }
 // DPCT_LABEL_END
 
@@ -328,6 +353,10 @@ inline void gemm_impl(sycl::queue &q, oneapi::mkl::transpose a_trans,
                          oneapi::mkl::transpose b_trans, int m, int n, int k,
                          const void *alpha, const void *a, int lda, const void *b,
                          int ldb, const void *beta, void *c, int ldc) {
+#ifndef __INTEL_MKL__
+  throw std::runtime_error("The oneAPI Math Kernel Library (oneMKL) Interfaces "
+                           "Project does not support this API.");
+#else
   Ts alpha_value = dpct::get_value(reinterpret_cast<const Ts *>(alpha), q);
   Ts beta_value = dpct::get_value(reinterpret_cast<const Ts *>(beta), q);
   auto data_a = get_memory(reinterpret_cast<const Ta *>(a));
@@ -336,6 +365,7 @@ inline void gemm_impl(sycl::queue &q, oneapi::mkl::transpose a_trans,
   oneapi::mkl::blas::column_major::gemm(
       q, a_trans, b_trans, m, n, k, alpha_value, data_a, lda,
       data_b, ldb, beta_value, data_c, ldc);
+#endif
 }
 // DPCT_LABEL_END
 
@@ -350,6 +380,10 @@ inline void gemm_batch_impl(sycl::queue &q, oneapi::mkl::transpose a_trans,
                             const void *alpha, const void **a, int lda,
                             const void **b, int ldb, const void *beta, void **c,
                             int ldc, int batch_size) {
+#ifndef __INTEL_MKL__
+  throw std::runtime_error("The oneAPI Math Kernel Library (oneMKL) Interfaces "
+                           "Project does not support this API.");
+#else
   struct matrix_info_t {
     oneapi::mkl::transpose transpose_info[2];
     Ts value_info[2];
@@ -388,6 +422,7 @@ inline void gemm_batch_impl(sycl::queue &q, oneapi::mkl::transpose a_trans,
     cgh.depends_on(e);
     cgh.host_task([=] { std::free(matrix_info); });
   });
+#endif
 }
 // DPCT_LABEL_END
 
@@ -405,6 +440,10 @@ gemm_batch_impl(sycl::queue &q, oneapi::mkl::transpose a_trans,
                     long long int stride_a, const void *b, int ldb,
                     long long int stride_b, const void *beta, void *c,
                     int ldc, long long int stride_c, int batch_size) {
+#ifndef __INTEL_MKL__
+  throw std::runtime_error("The oneAPI Math Kernel Library (oneMKL) Interfaces "
+                           "Project does not support this API.");
+#else
   Ts alpha_value = dpct::get_value(reinterpret_cast<const Ts *>(alpha), q);
   Ts beta_value = dpct::get_value(reinterpret_cast<const Ts *>(beta), q);
   auto data_a = get_memory(reinterpret_cast<const Ta *>(a));
@@ -414,6 +453,7 @@ gemm_batch_impl(sycl::queue &q, oneapi::mkl::transpose a_trans,
       q, a_trans, b_trans, m, n, k, alpha_value, data_a, lda,
       stride_a, data_b, ldb, stride_b, beta_value,
       data_c, ldc, stride_c, batch_size);
+#endif
 }
 // DPCT_LABEL_END
 
@@ -566,6 +606,10 @@ trsm_batch_impl(sycl::queue &q, oneapi::mkl::side left_right,
 template <typename T>
 inline void getrfnp_batch_wrapper(sycl::queue &exec_queue, int n, T *a[],
                                   int lda, int *info, int batch_size) {
+#ifndef __INTEL_MKL__
+  throw std::runtime_error("The oneAPI Math Kernel Library (oneMKL) Interfaces "
+                           "Project does not support this API.");
+#else
   using Ty = typename DataType<T>::T2;
   // Set the info array value to 0
   detail::dpct_memset(exec_queue, info, 0, sizeof(int) * batch_size);
@@ -614,6 +658,7 @@ inline void getrfnp_batch_wrapper(sycl::queue &exec_queue, int n, T *a[],
     cgh.depends_on(events);
     cgh.host_task([=] { free(host_a); });
   });
+#endif
 }
 // DPCT_LABEL_END
 

clang/runtime/dpct-rt/include/fft_utils.hpp.inc

@@ -83,6 +83,7 @@ enum fft_type : int {
 // Device|get_default_queue
 // DPCT_DEPENDENCY_END
 // DPCT_CODE
+#ifdef __INTEL_MKL__ // The oneMKL Interfaces Project does not support this.
 /// A class to perform FFT calculation.
 class fft_engine {
 public:
@@ -1292,6 +1293,7 @@ private:
 };
 
 using fft_engine_ptr = fft_engine *;
+#endif
 // DPCT_LABEL_END
 } // namespace fft
 } // namespace dpct

clang/runtime/dpct-rt/include/lapack_utils.hpp.inc

@@ -678,13 +678,19 @@ template <typename T> struct getrfnp_impl {
                   library_data_t a_type, void *a, std::int64_t lda,
                   std::int64_t *ipiv, void *device_ws,
                   std::size_t device_ws_size, int *info) {
+#ifndef __INTEL_MKL__
+    throw std::runtime_error(
+        "The oneAPI Math Kernel Library (oneMKL) Interfaces "
+        "Project does not support this API.");
+#else
     std::int64_t a_stride = m * lda;
     auto a_data = dpct::detail::get_memory(reinterpret_cast<T *>(a));
     auto device_ws_data =
         dpct::detail::get_memory(reinterpret_cast<T *>(device_ws));
     oneapi::mkl::lapack::getrfnp_batch(q, m, n, a_data, lda, a_stride, 1,
                                        device_ws_data, device_ws_size);
     dpct::detail::dpct_memset(q, info, 0, sizeof(int));
+#endif
   }
 };
 // DPCT_LABEL_END
@@ -749,13 +755,19 @@ template <typename T> struct gesvd_conj_impl : public gesvd_impl<T> {
                   void *u, std::int64_t ldu, library_data_t vt_type, void *vt,
                   std::int64_t ldvt, void *device_ws,
                   std::size_t device_ws_size, int *info) {
+#ifndef __INTEL_MKL__
+    throw std::runtime_error(
+        "The oneAPI Math Kernel Library (oneMKL) Interfaces "
+        "Project does not support this API.");
+#else
     using base = gesvd_impl<T>;
     base::operator()(q, jobu, jobvt, m, n, a_type, a, lda, s_type, s, u_type, u,
                      ldu, vt_type, vt, ldvt, device_ws, device_ws_size, info);
     auto vt_data = dpct::detail::get_memory(reinterpret_cast<T *>(vt));
     oneapi::mkl::blas::row_major::imatcopy(q, oneapi::mkl::transpose::conjtrans,
                                            n, n, T(1.0f), vt_data, ldvt, ldvt);
     dpct::detail::dpct_memset(q, info, 0, sizeof(int));
+#endif
   }
 };
 // DPCT_LABEL_END
@@ -883,6 +895,10 @@ inline int getrf(sycl::queue &q, std::int64_t m, std::int64_t n,
                  library_data_t a_type, void *a, std::int64_t lda,
                  std::int64_t *ipiv, void *device_ws,
                  std::size_t device_ws_size, int *info) {
+#ifndef __INTEL_MKL__
+  throw std::runtime_error("The oneAPI Math Kernel Library (oneMKL) Interfaces "
+                           "Project does not support this API.");
+#else
   std::size_t device_ws_size_in_element_number =
       detail::byte_to_element_number(device_ws_size, a_type);
   if (ipiv == nullptr) {
@@ -893,6 +909,7 @@ inline int getrf(sycl::queue &q, std::int64_t m, std::int64_t n,
   return detail::lapack_shim<detail::getrf_impl>(
       q, a_type, info, "getrf", q, m, n, a_type, a, lda, ipiv, device_ws,
       device_ws_size_in_element_number, info);
+#endif
 }
 // DPCT_LABEL_END
 

clang/runtime/dpct-rt/include/lib_common_utils.hpp.inc

@@ -99,6 +99,10 @@ enum class version_field : int {
 /// \param field The version information field (major, minor, update or patch).
 /// \param result The result value.
 inline void mkl_get_version(version_field field, int *result) {
+#ifndef __INTEL_MKL__
+  throw std::runtime_error("The oneAPI Math Kernel Library (oneMKL) Interfaces "
+                           "Project does not support this API.");
+#else
   MKLVersion version;
   mkl_get_version(&version);
   if (version_field::major == field) {
@@ -112,6 +116,7 @@ inline void mkl_get_version(version_field field, int *result) {
   } else {
     throw std::runtime_error("unknown field");
   }
+#endif
 }
 // DPCT_LABEL_END
 

clang/runtime/dpct-rt/include/rng_utils.hpp.inc

@@ -40,7 +40,9 @@
 // DPCT_CODE
 #include <sycl/sycl.hpp>
 #include <oneapi/mkl.hpp>
+#ifdef __INTEL_MKL__ // The oneMKL Interfaces Project does not support this.
 #include <oneapi/mkl/rng/device.hpp>
+#endif
 // DPCT_LABEL_END
 // DPCT_LABEL_BEGIN|local_include_dependency|
 // DPCT_DEPENDENCY_EMPTY
@@ -51,6 +53,7 @@
 
 namespace dpct {
 namespace rng {
+#ifdef __INTEL_MKL__ // The oneMKL Interfaces Project does not support this.
 namespace device {
 // DPCT_LABEL_BEGIN|rng_generator|dpct::rng::device
 // DPCT_DEPENDENCY_BEGIN
@@ -265,6 +268,7 @@ private:
 // DPCT_LABEL_END
 
 } // namespace device
+#endif
 
 namespace host {
 namespace detail {
@@ -407,9 +411,14 @@ public:
   /// \param output The pointer of the first random number.
   /// \param n The number of random numbers.
   inline void generate_uniform_bits(unsigned int *output, std::int64_t n) {
+#ifndef __INTEL_MKL__
+    throw std::runtime_error("The oneAPI Math Kernel Library (oneMKL) "
+                             "Interfaces Project does not support this API.");
+#else
     static_assert(sizeof(unsigned int) == sizeof(std::uint32_t));
     generate<oneapi::mkl::rng::uniform_bits<std::uint32_t>>(
         (std::uint32_t *)output, n);
+#endif
   }
 
   /// Generate unsigned long long random number(s) with 'uniform_bits'
@@ -418,9 +427,14 @@ public:
   /// \param n The number of random numbers.
   inline void generate_uniform_bits(unsigned long long *output,
                                     std::int64_t n) {
+#ifndef __INTEL_MKL__
+    throw std::runtime_error("The oneAPI Math Kernel Library (oneMKL) "
+                             "Interfaces Project does not support this API.");
+#else
     static_assert(sizeof(unsigned long long) == sizeof(std::uint64_t));
     generate<oneapi::mkl::rng::uniform_bits<std::uint64_t>>(
         (std::uint64_t *)output, n);
+#endif
   }
 
   /// Generate float random number(s) with 'lognormal' distribution.
@@ -489,19 +503,27 @@ public:
   /// Skip ahead several random number(s).
   /// \param num_to_skip The number of random numbers to be skipped.
   void skip_ahead(const std::uint64_t num_to_skip) {
+#ifndef __INTEL_MKL__
+    oneapi::mkl::rng::skip_ahead(_engine, num_to_skip);
+#else
     if constexpr (std::is_same_v<engine_t, oneapi::mkl::rng::mt2203>)
       throw std::runtime_error("no skip_ahead method of mt2203 engine.");
     else
       oneapi::mkl::rng::skip_ahead(_engine, num_to_skip);
+#endif
   }
 
 private:
   static inline engine_t create_engine(sycl::queue *queue,
                                        const std::uint64_t seed,
                                        const std::uint32_t dimensions) {
+#ifdef __INTEL_MKL__
     return std::is_same_v<engine_t, oneapi::mkl::rng::sobol>
                ? engine_t(*queue, dimensions)
                : engine_t(*queue, seed);
+#else
+    return engine_t(*queue, seed);
+#endif
   }
 
   template <typename distr_t, typename buffer_t, class... distr_params_t>
@@ -554,6 +576,10 @@ inline host_rng_ptr create_host_rng(const random_engine_type type) {
   case random_engine_type::mrg32k3a:
     return std::make_shared<
         rng::host::detail::rng_generator<oneapi::mkl::rng::mrg32k3a>>();
+#ifndef __INTEL_MKL__
+    throw std::runtime_error("The oneAPI Math Kernel Library (oneMKL) "
+                             "Interfaces Project does not support this API.");
+#else
   case random_engine_type::mt2203:
     return std::make_shared<
         rng::host::detail::rng_generator<oneapi::mkl::rng::mt2203>>();
@@ -566,6 +592,7 @@ inline host_rng_ptr create_host_rng(const random_engine_type type) {
   case random_engine_type::mcg59:
     return std::make_shared<
         rng::host::detail::rng_generator<oneapi::mkl::rng::mcg59>>();
+#endif
   }
 }
 // DPCT_LABEL_END