mkl-devel-dpcpp 2024.0.0__py2.py3-none-manylinux1_x86_64.whl → 2024.2.0__py2.py3-none-manylinux1_x86_64.whl

{mkl_devel_dpcpp-2024.0.0.data → mkl_devel_dpcpp-2024.2.0.data}/data/include/oneapi/mkl/blas/buffer_decls.hpp

@@ -123,6 +123,21 @@ ONEMKL_DECLARE_BUF_TRMM(std::complex<double>)
 
 #undef ONEMKL_DECLARE_BUF_TRMM
 
+#define ONEMKL_DECLARE_BUF_TRMM_OOP(T) \
+DLL_EXPORT void trmm(sycl::queue &queue, side left_right, uplo upper_lower, transpose trans, diag unit_diag, \
+              std::int64_t m, std::int64_t n, \
+              T alpha, sycl::buffer<T, 1> &a, std::int64_t lda, \
+              sycl::buffer<T, 1> &b, std::int64_t ldb, \
+              T beta, sycl::buffer<T, 1> &c, std::int64_t ldc, \
+              compute_mode mode = MKL_BLAS_COMPUTE_MODE);
+
+ONEMKL_DECLARE_BUF_TRMM_OOP(float)
+ONEMKL_DECLARE_BUF_TRMM_OOP(double)
+ONEMKL_DECLARE_BUF_TRMM_OOP(std::complex<float>)
+ONEMKL_DECLARE_BUF_TRMM_OOP(std::complex<double>)
+
+#undef ONEMKL_DECLARE_BUF_TRMM_OOP
+
 #define ONEMKL_DECLARE_BUF_TRSM(T) \
 DLL_EXPORT void trsm(sycl::queue &queue, side left_right, uplo upper_lower, transpose trans, diag unit_diag, \
               std::int64_t m, std::int64_t n, \
@@ -137,6 +152,21 @@ ONEMKL_DECLARE_BUF_TRSM(std::complex<double>)
 
 #undef ONEMKL_DECLARE_BUF_TRSM
 
+#define ONEMKL_DECLARE_BUF_TRSM_OOP(T) \
+DLL_EXPORT void trsm(sycl::queue &queue, side left_right, uplo upper_lower, transpose trans, diag unit_diag, \
+              std::int64_t m, std::int64_t n, \
+              T alpha, sycl::buffer<T, 1> &a, std::int64_t lda, \
+              sycl::buffer<T, 1> &b, std::int64_t ldb, \
+              T beta, sycl::buffer<T, 1> &c, std::int64_t ldc, \
+              compute_mode mode = MKL_BLAS_COMPUTE_MODE);
+
+ONEMKL_DECLARE_BUF_TRSM_OOP(float)
+ONEMKL_DECLARE_BUF_TRSM_OOP(double)
+ONEMKL_DECLARE_BUF_TRSM_OOP(std::complex<float>)
+ONEMKL_DECLARE_BUF_TRSM_OOP(std::complex<double>)
+
+#undef ONEMKL_DECLARE_BUF_TRSM_OOP
+
 // Level 2
 
 #define ONEMKL_DECLARE_BUF_DGMM(T) \
@@ -467,25 +497,33 @@ ONEMKL_DECLARE_BUF_DOTU(std::complex<double>)
 
 #undef ONEMKL_DECLARE_BUF_DOTU
 
-#define ONEMKL_DECLARE_BUF_IAMAX(T) \
-DLL_EXPORT void iamax(sycl::queue &queue, std::int64_t n, sycl::buffer<T, 1> &x, std::int64_t incx, \
-                      sycl::buffer<std::int64_t, 1> &result, index_base base=index_base::zero);
+#define ONEMKL_DECLARE_BUF_IAMAX(Tf, Ti) \
+DLL_EXPORT void iamax(sycl::queue &queue, std::int64_t n, sycl::buffer<Tf, 1> &x, std::int64_t incx, \
+                      sycl::buffer<Ti, 1> &result, index_base base=index_base::zero);
 
-ONEMKL_DECLARE_BUF_IAMAX(float)
-ONEMKL_DECLARE_BUF_IAMAX(double)
-ONEMKL_DECLARE_BUF_IAMAX(std::complex<float>)
-ONEMKL_DECLARE_BUF_IAMAX(std::complex<double>)
+ONEMKL_DECLARE_BUF_IAMAX(float, std::int64_t)
+ONEMKL_DECLARE_BUF_IAMAX(float, std::int32_t)
+ONEMKL_DECLARE_BUF_IAMAX(double, std::int64_t)
+ONEMKL_DECLARE_BUF_IAMAX(double, std::int32_t)
+ONEMKL_DECLARE_BUF_IAMAX(std::complex<float>, std::int64_t)
+ONEMKL_DECLARE_BUF_IAMAX(std::complex<float>, std::int32_t)
+ONEMKL_DECLARE_BUF_IAMAX(std::complex<double>, std::int64_t)
+ONEMKL_DECLARE_BUF_IAMAX(std::complex<double>, std::int32_t)
 
 #undef ONEMKL_DECLARE_BUF_IAMAX
 
-#define ONEMKL_DECLARE_BUF_IAMIN(T) \
-DLL_EXPORT void iamin(sycl::queue &queue, std::int64_t n, sycl::buffer<T, 1> &x, std::int64_t incx, \
-               sycl::buffer<std::int64_t, 1> &result, index_base base=index_base::zero);
-
-ONEMKL_DECLARE_BUF_IAMIN(float)
-ONEMKL_DECLARE_BUF_IAMIN(double)
-ONEMKL_DECLARE_BUF_IAMIN(std::complex<float>)
-ONEMKL_DECLARE_BUF_IAMIN(std::complex<double>)
+#define ONEMKL_DECLARE_BUF_IAMIN(Tf, Ti) \
+DLL_EXPORT void iamin(sycl::queue &queue, std::int64_t n, sycl::buffer<Tf, 1> &x, std::int64_t incx, \
+                      sycl::buffer<Ti, 1> &result, index_base base=index_base::zero);
+
+ONEMKL_DECLARE_BUF_IAMIN(float, std::int64_t)
+ONEMKL_DECLARE_BUF_IAMIN(float, std::int32_t)
+ONEMKL_DECLARE_BUF_IAMIN(double, std::int64_t)
+ONEMKL_DECLARE_BUF_IAMIN(double, std::int32_t)
+ONEMKL_DECLARE_BUF_IAMIN(std::complex<float>, std::int64_t)
+ONEMKL_DECLARE_BUF_IAMIN(std::complex<float>, std::int32_t)
+ONEMKL_DECLARE_BUF_IAMIN(std::complex<double>, std::int64_t)
+ONEMKL_DECLARE_BUF_IAMIN(std::complex<double>, std::int32_t)
 
 #undef ONEMKL_DECLARE_BUF_IAMIN
 

{mkl_devel_dpcpp-2024.0.0.data → mkl_devel_dpcpp-2024.2.0.data}/data/include/oneapi/mkl/blas/usm_decls.hpp

@@ -188,6 +188,27 @@ ONEMKL_DECLARE_TRMM(std::complex<double>)
 
 #undef ONEMKL_DECLARE_TRMM
 
+#define ONEMKL_DECLARE_TRMM_OOP(T) \
+DLL_EXPORT sycl::event trmm(sycl::queue &queue, side left_right, uplo upper_lower, transpose trans, \
+    diag unit_diag, std::int64_t m, std::int64_t n, value_or_pointer<T> alpha, const T *a, std::int64_t lda, \
+    const T *b, std::int64_t ldb, value_or_pointer<T> beta, T *c, std::int64_t ldc, \
+    compute_mode mode, const std::vector<sycl::event> &dependencies = {}); \
+ONEMKL_INLINE_DECLARE sycl::event trmm(sycl::queue &queue, side left_right, uplo upper_lower, transpose trans, \
+    diag unit_diag, std::int64_t m, std::int64_t n, value_or_pointer<T> alpha, const T *a, std::int64_t lda, \
+    const T *b, std::int64_t ldb, value_or_pointer<T> beta, T *c, std::int64_t ldc, \
+    const std::vector<sycl::event> &dependencies = {}) \
+{ \
+    return trmm(queue, left_right, upper_lower, trans, unit_diag, m, n, alpha, a, lda, b, ldb, \
+                beta, c, ldc, MKL_BLAS_COMPUTE_MODE, dependencies); \
+}
+
+ONEMKL_DECLARE_TRMM_OOP(float)
+ONEMKL_DECLARE_TRMM_OOP(double)
+ONEMKL_DECLARE_TRMM_OOP(std::complex<float>)
+ONEMKL_DECLARE_TRMM_OOP(std::complex<double>)
+
+#undef ONEMKL_DECLARE_TRMM_OOP
+
 #define ONEMKL_DECLARE_TRSM(T) \
 DLL_EXPORT sycl::event trsm(sycl::queue &queue, side left_right, uplo upper_lower, transpose trans, diag unit_diag, \
               std::int64_t m, std::int64_t n, \
@@ -210,6 +231,27 @@ ONEMKL_DECLARE_TRSM(std::complex<double>)
 
 #undef ONEMKL_DECLARE_TRSM
 
+#define ONEMKL_DECLARE_TRSM_OOP(T) \
+DLL_EXPORT sycl::event trsm(sycl::queue &queue, side left_right, uplo upper_lower, transpose trans, \
+    diag unit_diag, std::int64_t m, std::int64_t n, value_or_pointer<T> alpha, const T *a, std::int64_t lda, \
+    const T *b, std::int64_t ldb, value_or_pointer<T> beta, T *c, std::int64_t ldc, \
+    compute_mode mode, const std::vector<sycl::event> &dependencies = {}); \
+ONEMKL_INLINE_DECLARE sycl::event trsm(sycl::queue &queue, side left_right, uplo upper_lower, transpose trans, \
+    diag unit_diag, std::int64_t m, std::int64_t n, value_or_pointer<T> alpha, const T *a, std::int64_t lda, \
+    const T *b, std::int64_t ldb, value_or_pointer<T> beta, T *c, std::int64_t ldc, \
+    const std::vector<sycl::event> &dependencies = {}) \
+{ \
+    return trsm(queue, left_right, upper_lower, trans, unit_diag, m, n, alpha, a, lda, b, ldb, \
+                beta, c, ldc, MKL_BLAS_COMPUTE_MODE, dependencies); \
+}
+
+ONEMKL_DECLARE_TRSM_OOP(float)
+ONEMKL_DECLARE_TRSM_OOP(double)
+ONEMKL_DECLARE_TRSM_OOP(std::complex<float>)
+ONEMKL_DECLARE_TRSM_OOP(std::complex<double>)
+
+#undef ONEMKL_DECLARE_TRSM_OOP
+
 // Level 2
 
 #define ONEMKL_DECLARE_DGMM(T) \
@@ -543,39 +585,47 @@ ONEMKL_DECLARE_DOTU(std::complex<double>)
 
 #undef ONEMKL_DECLARE_DOTU
 
-#define ONEMKL_DECLARE_IAMAX(T) \
-DLL_EXPORT sycl::event iamax(sycl::queue &queue, std::int64_t n, const T *x, std::int64_t incx, \
-                             std::int64_t *result, index_base base, \
+#define ONEMKL_DECLARE_IAMAX(Tf, Ti) \
+DLL_EXPORT sycl::event iamax(sycl::queue &queue, std::int64_t n, const Tf *x, std::int64_t incx, \
+                             Ti *result, index_base base, \
                              const std::vector<sycl::event> &dependencies = {}); \
-ONEMKL_INLINE_DECLARE sycl::event iamax(sycl::queue &queue, std::int64_t n, const T *x, \
-                                        std::int64_t incx, std::int64_t *result, \
+ONEMKL_INLINE_DECLARE sycl::event iamax(sycl::queue &queue, std::int64_t n, const Tf *x, \
+                                        std::int64_t incx, Ti *result, \
                                         const std::vector<sycl::event> &dependencies = {}) \
 { \
     return iamax(queue, n, x, incx, result, index_base::zero, dependencies); \
 }
 
-ONEMKL_DECLARE_IAMAX(float)
-ONEMKL_DECLARE_IAMAX(double)
-ONEMKL_DECLARE_IAMAX(std::complex<float>)
-ONEMKL_DECLARE_IAMAX(std::complex<double>)
+ONEMKL_DECLARE_IAMAX(float, std::int64_t)
+ONEMKL_DECLARE_IAMAX(float, std::int32_t)
+ONEMKL_DECLARE_IAMAX(double, std::int64_t)
+ONEMKL_DECLARE_IAMAX(double, std::int32_t)
+ONEMKL_DECLARE_IAMAX(std::complex<float>, std::int64_t)
+ONEMKL_DECLARE_IAMAX(std::complex<float>, std::int32_t)
+ONEMKL_DECLARE_IAMAX(std::complex<double>, std::int64_t)
+ONEMKL_DECLARE_IAMAX(std::complex<double>, std::int32_t)
 
 #undef ONEMKL_DECLARE_IAMAX
 
-#define ONEMKL_DECLARE_IAMIN(T) \
-DLL_EXPORT sycl::event iamin(sycl::queue &queue, std::int64_t n, const T *x, std::int64_t incx, \
-                             std::int64_t *result, index_base base, \
+#define ONEMKL_DECLARE_IAMIN(Tf, Ti) \
+DLL_EXPORT sycl::event iamin(sycl::queue &queue, std::int64_t n, const Tf *x, std::int64_t incx, \
+                             Ti *result, index_base base, \
                              const std::vector<sycl::event> &dependencies = {}); \
-ONEMKL_INLINE_DECLARE sycl::event iamin(sycl::queue &queue, std::int64_t n, const T *x, \
-                                        std::int64_t incx, std::int64_t *result, \
+ONEMKL_INLINE_DECLARE sycl::event iamin(sycl::queue &queue, std::int64_t n, const Tf *x, \
+                                        std::int64_t incx, Ti *result, \
                                         const std::vector<sycl::event> &dependencies = {}) \
 { \
     return iamin(queue, n, x, incx, result, index_base::zero, dependencies); \
 }
 
-ONEMKL_DECLARE_IAMIN(float)
-ONEMKL_DECLARE_IAMIN(double)
-ONEMKL_DECLARE_IAMIN(std::complex<float>)
-ONEMKL_DECLARE_IAMIN(std::complex<double>)
+ONEMKL_DECLARE_IAMIN(float, std::int64_t)
+ONEMKL_DECLARE_IAMIN(float, std::int32_t)
+ONEMKL_DECLARE_IAMIN(double, std::int64_t)
+ONEMKL_DECLARE_IAMIN(double, std::int32_t)
+ONEMKL_DECLARE_IAMIN(std::complex<float>, std::int64_t)
+ONEMKL_DECLARE_IAMIN(std::complex<float>, std::int32_t)
+ONEMKL_DECLARE_IAMIN(std::complex<double>, std::int64_t)
+ONEMKL_DECLARE_IAMIN(std::complex<double>, std::int32_t)
 
 #undef ONEMKL_DECLARE_IAMIN
 
@@ -666,7 +716,7 @@ ONEMKL_DECLARE_ROT(std::complex<double>, double, std::complex<double>)
 #undef ONEMKL_DECLARE_ROT
 
 #define ONEMKL_DECLARE_ROT_EXPLICIT_SCALARS(T, Tc, Ts) \
-DLL_EXPORT sycl::event rot(sycl::queue &queue, std::int64_t n, T *x, std::int64_t incx, T *y, std::int64_t incy, Tc c, Ts s, const std::vector<sycl::event> &dependencies = {});
+DLL_EXPORT sycl::event rot(sycl::queue &queue, std::int64_t n, T *x, std::int64_t incx, T *y, std::int64_t incy, value_or_pointer<Tc> c, Ts s, const std::vector<sycl::event> &dependencies = {});
 
 ONEMKL_DECLARE_ROT_EXPLICIT_SCALARS(std::complex<float>, float, float)
 ONEMKL_DECLARE_ROT_EXPLICIT_SCALARS(std::complex<float>, float, std::complex<float>)
@@ -731,7 +781,8 @@ ONEMKL_DECLARE_SWAP(std::complex<double>)
 
 #define ONEMKL_DECLARE_GEMM_BATCH(Ta, Tb, Tc, Ts) \
     ONEMKL_DECLARE_GEMM_BATCH_STRIDED(Ta, Tb, Tc, Ts) \
-    ONEMKL_DECLARE_GEMM_BATCH_GROUP(Ta, Tb, Tc, Ts) \
+    ONEMKL_DECLARE_GEMM_BATCH_GROUP(Ta, Tb, Tc, Ts, std::int64_t)  \
+    ONEMKL_DECLARE_GEMM_BATCH_GROUP(Ta, Tb, Tc, Ts, std::int32_t)  \
     ONEMKL_DECLARE_GEMM_BATCH_SPAN(Ta, Tb, Tc, Ts)
 
 #define ONEMKL_DECLARE_GEMM_BATCH_STRIDED(Ta, Tb, Tc, Ts) \
@@ -753,20 +804,20 @@ ONEMKL_INLINE_DECLARE sycl::event gemm_batch(sycl::queue &queue, transpose trans
     return gemm_batch(queue, transa, transb, m, n, k, alpha, a, lda, stride_a, b, ldb, stride_b, beta, c, ldc, stride_c, batch_size, MKL_BLAS_COMPUTE_MODE, dependencies); \
 }
 
-#define ONEMKL_DECLARE_GEMM_BATCH_GROUP(Ta, Tb, Tc, Ts) \
+#define ONEMKL_DECLARE_GEMM_BATCH_GROUP(Ta, Tb, Tc, Ts, Ti) \
 DLL_EXPORT sycl::event gemm_batch(sycl::queue &queue, const transpose *transa, const transpose *transb, \
-                           const std::int64_t *m, const std::int64_t *n, const std::int64_t *k, const Ts *alpha, \
-                           const Ta **a, const std::int64_t *lda, \
-                           const Tb **b, const std::int64_t *ldb, \
-                           const Ts *beta, Tc **c, const std::int64_t *ldc, \
-                           std::int64_t group_count, const std::int64_t *groupsize, \
+                           const Ti *m, const Ti *n, const Ti *k, const Ts *alpha, \
+                           const Ta **a, const Ti *lda, \
+                           const Tb **b, const Ti *ldb, \
+                           const Ts *beta, Tc **c, const Ti *ldc, \
+                           std::int64_t group_count, const Ti *groupsize, \
                            compute_mode mode, const std::vector<sycl::event> &dependencies = {}); \
 ONEMKL_INLINE_DECLARE sycl::event gemm_batch(sycl::queue &queue, const transpose *transa, const transpose *transb, \
-                           const std::int64_t *m, const std::int64_t *n, const std::int64_t *k, const Ts *alpha, \
-                           const Ta **a, const std::int64_t *lda, \
-                           const Tb **b, const std::int64_t *ldb, \
-                           const Ts *beta, Tc **c, const std::int64_t *ldc, \
-                           std::int64_t group_count, const std::int64_t *groupsize, \
+                           const Ti *m, const Ti *n, const Ti *k, const Ts *alpha, \
+                           const Ta **a, const Ti *lda, \
+                           const Tb **b, const Ti *ldb, \
+                           const Ts *beta, Tc **c, const Ti *ldc, \
+                           std::int64_t group_count, const Ti *groupsize, \
                            const std::vector<sycl::event> &dependencies = {}) \
 { \
     return gemm_batch(queue, transa, transb, m, n, k, alpha, a, lda, b, ldb, beta, c, ldc, group_count, groupsize, MKL_BLAS_COMPUTE_MODE, dependencies); \
@@ -815,7 +866,8 @@ ONEMKL_DECLARE_GEMM_BATCH(std::int8_t, std::int8_t, float, float)
 
 #define ONEMKL_DECLARE_SYRK_BATCH(T) \
     ONEMKL_DECLARE_SYRK_BATCH_STRIDED(T) \
-    ONEMKL_DECLARE_SYRK_BATCH_GROUP(T)
+    ONEMKL_DECLARE_SYRK_BATCH_GROUP(T, std::int64_t) \
+    ONEMKL_DECLARE_SYRK_BATCH_GROUP(T, std::int32_t)
 
 #define ONEMKL_DECLARE_SYRK_BATCH_STRIDED(T) \
 DLL_EXPORT sycl::event syrk_batch(sycl::queue &queue, \
@@ -833,18 +885,18 @@ ONEMKL_INLINE_DECLARE sycl::event syrk_batch(sycl::queue &queue, \
     return syrk_batch(queue, upper_lower, trans, n, k, alpha, a, lda, stride_a, beta, c, ldc, stride_c, batch_size, MKL_BLAS_COMPUTE_MODE, dependencies); \
 }
 
-#define ONEMKL_DECLARE_SYRK_BATCH_GROUP(T) \
+#define ONEMKL_DECLARE_SYRK_BATCH_GROUP(T, Ti) \
 DLL_EXPORT sycl::event syrk_batch(sycl::queue &queue, \
-                                      const uplo *upper_lower, const transpose *trans, const std::int64_t *n, const std::int64_t *k, \
-                                      const T *alpha, const T **a, const std::int64_t *lda, const T *beta, \
-                                      T **c, const std::int64_t *ldc, \
-                                      std::int64_t group_count, const std::int64_t *groupsize, \
-                                      compute_mode mode, const std::vector<sycl::event> &dependencies = {}); \
+                                  const uplo *upper_lower, const transpose *trans, const Ti *n, const Ti *k, \
+                                  const T *alpha, const T **a, const Ti *lda, const T *beta, \
+                                  T **c, const Ti *ldc, \
+                                  std::int64_t group_count, const Ti *groupsize, \
+                                  compute_mode mode, const std::vector<sycl::event> &dependencies = {}); \
 ONEMKL_INLINE_DECLARE sycl::event syrk_batch(sycl::queue &queue, \
-                                      const uplo *upper_lower, const transpose *trans, const std::int64_t *n, const std::int64_t *k, \
-                                      const T *alpha, const T **a, const std::int64_t *lda, const T *beta, \
-                                      T **c, const std::int64_t *ldc, \
-                                      std::int64_t group_count, const std::int64_t *groupsize, \
+                                      const uplo *upper_lower, const transpose *trans, const Ti *n, const Ti *k, \
+                                      const T *alpha, const T **a, const Ti *lda, const T *beta, \
+                                      T **c, const Ti *ldc, \
+                                      std::int64_t group_count, const Ti *groupsize, \
                                       const std::vector<sycl::event> &dependencies = {}) \
 { \
     return syrk_batch(queue, upper_lower, trans, n, k, alpha, a, lda, beta, c, ldc, group_count, groupsize, MKL_BLAS_COMPUTE_MODE, dependencies); \
@@ -859,7 +911,8 @@ ONEMKL_DECLARE_SYRK_BATCH(std::complex<double>)
 
 #define ONEMKL_DECLARE_TRSM_BATCH(T) \
     ONEMKL_DECLARE_TRSM_BATCH_STRIDED(T) \
-    ONEMKL_DECLARE_TRSM_BATCH_GROUP(T)
+    ONEMKL_DECLARE_TRSM_BATCH_GROUP(T, std::int64_t) \
+    ONEMKL_DECLARE_TRSM_BATCH_GROUP(T, std::int32_t)
 
 #define ONEMKL_DECLARE_TRSM_BATCH_STRIDED(T) \
 DLL_EXPORT sycl::event trsm_batch(sycl::queue &queue, side left_right, uplo upper_lower, \
@@ -882,20 +935,20 @@ ONEMKL_INLINE_DECLARE sycl::event trsm_batch(sycl::queue &queue, side left_right
     return trsm_batch(queue, left_right, upper_lower, trans, unit_diag, m, n, alpha, a, lda, stride_a, b, ldb, stride_b, batch_size, MKL_BLAS_COMPUTE_MODE, dependencies); \
 }
 
-#define ONEMKL_DECLARE_TRSM_BATCH_GROUP(T) \
+#define ONEMKL_DECLARE_TRSM_BATCH_GROUP(T, Ti) \
 DLL_EXPORT sycl::event trsm_batch(sycl::queue &queue, const side *left_right, const uplo *upper_lower, \
                            const transpose *trans, const diag *unit_diag, \
-                           const std::int64_t *m, const std::int64_t *n, \
-                           const T *alpha, const T **a, const std::int64_t *lda, \
-                           T **b, const std::int64_t *ldb, \
-                           std::int64_t group_count, const std::int64_t *group_size, \
+                           const Ti *m, const Ti *n, \
+                           const T *alpha, const T **a, const Ti *lda, \
+                           T **b, const Ti *ldb, \
+                           std::int64_t group_count, const Ti *group_size, \
                            compute_mode mode, const std::vector<sycl::event> &dependencies = {}); \
 ONEMKL_INLINE_DECLARE sycl::event trsm_batch(sycl::queue &queue, const side *left_right, const uplo *upper_lower, \
                            const transpose *trans, const diag *unit_diag, \
-                           const std::int64_t *m, const std::int64_t *n, \
-                           const T *alpha, const T **a, const std::int64_t *lda, \
-                           T **b, const std::int64_t *ldb, \
-                           std::int64_t group_count, const std::int64_t *group_size, \
+                           const Ti *m, const Ti *n, \
+                           const T *alpha, const T **a, const Ti *lda, \
+                           T **b, const Ti *ldb, \
+                           std::int64_t group_count, const Ti *group_size, \
                            const std::vector<sycl::event> &dependencies = {}) \
 { \
     return trsm_batch(queue, left_right, upper_lower, trans, unit_diag, m, n, alpha, a, lda, b, ldb, group_count, group_size, MKL_BLAS_COMPUTE_MODE, dependencies); \
@@ -910,7 +963,8 @@ ONEMKL_DECLARE_TRSM_BATCH(std::complex<double>)
 
 #define ONEMKL_DECLARE_DGMM_BATCH(T) \
     ONEMKL_DECLARE_DGMM_BATCH_STRIDED(T) \
-    ONEMKL_DECLARE_DGMM_BATCH_GROUP(T)
+    ONEMKL_DECLARE_DGMM_BATCH_GROUP(T, std::int64_t) \
+    ONEMKL_DECLARE_DGMM_BATCH_GROUP(T, std::int32_t)
 
 #define ONEMKL_DECLARE_DGMM_BATCH_STRIDED(T) \
 DLL_EXPORT sycl::event dgmm_batch(sycl::queue &queue, side left_right, \
@@ -920,30 +974,28 @@ DLL_EXPORT sycl::event dgmm_batch(sycl::queue &queue, side left_right, \
               T *c, std::int64_t ldc, std::int64_t stridec, std::int64_t batch_size, \
               const std::vector<sycl::event> &dependencies = {});
 
-ONEMKL_DECLARE_DGMM_BATCH_STRIDED(float)
-ONEMKL_DECLARE_DGMM_BATCH_STRIDED(double)
-ONEMKL_DECLARE_DGMM_BATCH_STRIDED(std::complex<float>)
-ONEMKL_DECLARE_DGMM_BATCH_STRIDED(std::complex<double>)
-
-#define ONEMKL_DECLARE_DGMM_BATCH_GROUP(T) \
+#define ONEMKL_DECLARE_DGMM_BATCH_GROUP(Tf, Ti) \
 DLL_EXPORT sycl::event dgmm_batch(sycl::queue &queue, const side *left_right, \
-              const std::int64_t *m, const std::int64_t *n, \
-              const T **a, const std::int64_t *lda, \
-              const T **x, const std::int64_t *incx, \
-              T **c, const std::int64_t *ldc, \
-              std::int64_t group_count, const std::int64_t *group_size, \
+              const Ti *m, const Ti *n, \
+              const Tf **a, const Ti *lda, \
+              const Tf **x, const Ti *incx, \
+              Tf **c, const Ti *ldc, \
+              std::int64_t group_count, const Ti *group_size, \
               const std::vector<sycl::event> &dependencies = {});
 
-ONEMKL_DECLARE_DGMM_BATCH_GROUP(float)
-ONEMKL_DECLARE_DGMM_BATCH_GROUP(double)
-ONEMKL_DECLARE_DGMM_BATCH_GROUP(std::complex<float>)
-ONEMKL_DECLARE_DGMM_BATCH_GROUP(std::complex<double>)
+ONEMKL_DECLARE_DGMM_BATCH(float)
+ONEMKL_DECLARE_DGMM_BATCH(double)
+ONEMKL_DECLARE_DGMM_BATCH(std::complex<float>)
+ONEMKL_DECLARE_DGMM_BATCH(std::complex<double>)
 
+#undef ONEMKL_DECLARE_DGMM_BATCH_STRIDED
+#undef ONEMKL_DECLARE_DGMM_BATCH_GROUP
 #undef ONEMKL_DECLARE_DGMM_BATCH
 
 #define ONEMKL_DECLARE_GEMV_BATCH(T) \
     ONEMKL_DECLARE_GEMV_BATCH_STRIDED(T) \
-    ONEMKL_DECLARE_GEMV_BATCH_GROUP(T)
+    ONEMKL_DECLARE_GEMV_BATCH_GROUP(T, std::int64_t) \
+    ONEMKL_DECLARE_GEMV_BATCH_GROUP(T, std::int32_t)
 
 #define ONEMKL_DECLARE_GEMV_BATCH_STRIDED(T) \
 DLL_EXPORT sycl::event gemv_batch(sycl::queue &queue, transpose trans, \
@@ -953,30 +1005,28 @@ DLL_EXPORT sycl::event gemv_batch(sycl::queue &queue, transpose trans, \
               T *y, std::int64_t incy, std::int64_t stridey, std::int64_t batch_size, \
               const std::vector<sycl::event> &dependencies = {});
 
-ONEMKL_DECLARE_GEMV_BATCH_STRIDED(float)
-ONEMKL_DECLARE_GEMV_BATCH_STRIDED(double)
-ONEMKL_DECLARE_GEMV_BATCH_STRIDED(std::complex<float>)
-ONEMKL_DECLARE_GEMV_BATCH_STRIDED(std::complex<double>)
-
-#define ONEMKL_DECLARE_GEMV_BATCH_GROUP(T) \
+#define ONEMKL_DECLARE_GEMV_BATCH_GROUP(Tf, Ti) \
 DLL_EXPORT sycl::event gemv_batch(sycl::queue &queue, const transpose *trans, \
-              const std::int64_t *m, const std::int64_t *n, const T *alpha, \
-              const T **a, const std::int64_t *lda, \
-              const T **x, const std::int64_t *incx, const T *beta, \
-              T **y, const std::int64_t *incy, \
-              std::int64_t group_count, const std::int64_t *group_size, \
+              const Ti *m, const Ti *n, const Tf *alpha, \
+              const Tf **a, const Ti *lda, \
+              const Tf **x, const Ti *incx, const Tf *beta, \
+              Tf **y, const Ti *incy, \
+              std::int64_t group_count, const Ti *group_size, \
               const std::vector<sycl::event> &dependencies = {});
 
-ONEMKL_DECLARE_GEMV_BATCH_GROUP(float)
-ONEMKL_DECLARE_GEMV_BATCH_GROUP(double)
-ONEMKL_DECLARE_GEMV_BATCH_GROUP(std::complex<float>)
-ONEMKL_DECLARE_GEMV_BATCH_GROUP(std::complex<double>)
+ONEMKL_DECLARE_GEMV_BATCH(float)
+ONEMKL_DECLARE_GEMV_BATCH(double)
+ONEMKL_DECLARE_GEMV_BATCH(std::complex<float>)
+ONEMKL_DECLARE_GEMV_BATCH(std::complex<double>)
 
+#undef ONEMKL_DECLARE_GEMV_BATCH_STRIDED
+#undef ONEMKL_DECLARE_GEMV_BATCH_GROUP
 #undef ONEMKL_DECLARE_GEMV_BATCH
 
-#define ONEMKL_DECLARE_AXPY_BATCH(T) \
-    ONEMKL_DECLARE_AXPY_BATCH_STRIDED(T) \
-    ONEMKL_DECLARE_AXPY_BATCH_GROUP(T)
+#define ONEMKL_DECLARE_AXPY_BATCH(T)                 \
+    ONEMKL_DECLARE_AXPY_BATCH_STRIDED(T)             \
+    ONEMKL_DECLARE_AXPY_BATCH_GROUP(T, std::int64_t) \
+    ONEMKL_DECLARE_AXPY_BATCH_GROUP(T, std::int32_t) \
 
 #define ONEMKL_DECLARE_AXPY_BATCH_STRIDED(T) \
 DLL_EXPORT sycl::event axpy_batch(sycl::queue &queue, std::int64_t n, value_or_pointer<T> alpha, \
@@ -984,27 +1034,25 @@ DLL_EXPORT sycl::event axpy_batch(sycl::queue &queue, std::int64_t n, value_or_p
                            T *y, std::int64_t incy, std::int64_t stridey, std::int64_t batch_size, \
                            const std::vector<sycl::event> &dependencies = {});
 
-ONEMKL_DECLARE_AXPY_BATCH_STRIDED(float)
-ONEMKL_DECLARE_AXPY_BATCH_STRIDED(double)
-ONEMKL_DECLARE_AXPY_BATCH_STRIDED(std::complex<float>)
-ONEMKL_DECLARE_AXPY_BATCH_STRIDED(std::complex<double>)
-
-#define ONEMKL_DECLARE_AXPY_BATCH_GROUP(T) \
-DLL_EXPORT sycl::event axpy_batch(sycl::queue &queue, const std::int64_t *n, const T *alpha, const T **x, \
-                           const std::int64_t *incx, T **y, const std::int64_t *incy, std::int64_t group_count, \
-                           const std::int64_t *group_size, \
+#define ONEMKL_DECLARE_AXPY_BATCH_GROUP(Tf, Ti) \
+DLL_EXPORT sycl::event axpy_batch(sycl::queue &queue, const Ti *n, const Tf *alpha, const Tf **x, \
+                           const Ti *incx, Tf **y, const Ti *incy, std::int64_t group_count, \
+                           const Ti *group_size, \
                            const std::vector<sycl::event> &dependencies = {});
 
-ONEMKL_DECLARE_AXPY_BATCH_GROUP(float)
-ONEMKL_DECLARE_AXPY_BATCH_GROUP(double)
-ONEMKL_DECLARE_AXPY_BATCH_GROUP(std::complex<float>)
-ONEMKL_DECLARE_AXPY_BATCH_GROUP(std::complex<double>)
+ONEMKL_DECLARE_AXPY_BATCH(float)
+ONEMKL_DECLARE_AXPY_BATCH(double)
+ONEMKL_DECLARE_AXPY_BATCH(std::complex<float>)
+ONEMKL_DECLARE_AXPY_BATCH(std::complex<double>)
 
+#undef ONEMKL_DECLARE_AXPY_BATCH_STRIDED
+#undef ONEMKL_DECLARE_AXPY_BATCH_GROUP
 #undef ONEMKL_DECLARE_AXPY_BATCH
 
 #define ONEMKL_DECLARE_COPY_BATCH(T) \
     ONEMKL_DECLARE_COPY_BATCH_STRIDED(T) \
-    ONEMKL_DECLARE_COPY_BATCH_GROUP(T)
+    ONEMKL_DECLARE_COPY_BATCH_GROUP(T, std::int64_t) \
+    ONEMKL_DECLARE_COPY_BATCH_GROUP(T, std::int32_t)
 
 #define ONEMKL_DECLARE_COPY_BATCH_STRIDED(T) \
 DLL_EXPORT sycl::event copy_batch(sycl::queue &queue, std::int64_t n, \
@@ -1013,23 +1061,19 @@ DLL_EXPORT sycl::event copy_batch(sycl::queue &queue, std::int64_t n, \
                                       std::int64_t batch_size, \
                                       const std::vector<sycl::event> &dependencies = {});
 
-ONEMKL_DECLARE_COPY_BATCH_STRIDED(float)
-ONEMKL_DECLARE_COPY_BATCH_STRIDED(double)
-ONEMKL_DECLARE_COPY_BATCH_STRIDED(std::complex<float>)
-ONEMKL_DECLARE_COPY_BATCH_STRIDED(std::complex<double>)
+#define ONEMKL_DECLARE_COPY_BATCH_GROUP(Tf, Ti) \
+DLL_EXPORT sycl::event copy_batch(sycl::queue &queue, const Ti *n, \
+                                  const Tf **x, const Ti *incx, Tf **y, const Ti *incy, \
+                                  std::int64_t group_count, const Ti *group_size, \
+                                  const std::vector<sycl::event> &dependencies = {});
 
-#define ONEMKL_DECLARE_COPY_BATCH_GROUP(T) \
-DLL_EXPORT sycl::event copy_batch(sycl::queue &queue, const std::int64_t *n, \
-                                      const T **x, const std::int64_t *incx, \
-                                      T **y, const std::int64_t *incy, \
-                                      std::int64_t group_count, const std::int64_t *group_size, \
-                                      const std::vector<sycl::event> &dependencies = {});
-
-ONEMKL_DECLARE_COPY_BATCH_GROUP(float)
-ONEMKL_DECLARE_COPY_BATCH_GROUP(double)
-ONEMKL_DECLARE_COPY_BATCH_GROUP(std::complex<float>)
-ONEMKL_DECLARE_COPY_BATCH_GROUP(std::complex<double>)
+ONEMKL_DECLARE_COPY_BATCH(float)
+ONEMKL_DECLARE_COPY_BATCH(double)
+ONEMKL_DECLARE_COPY_BATCH(std::complex<float>)
+ONEMKL_DECLARE_COPY_BATCH(std::complex<double>)
 
+#undef ONEMKL_DECLARE_COPY_BATCH_STRIDED
+#undef ONEMKL_DECLARE_COPY_BATCH_GROUP
 #undef ONEMKL_DECLARE_COPY_BATCH
 
 // BLAS like
@@ -1121,7 +1165,8 @@ ONEMKL_DECLARE_OMATADD(std::complex<double>)
 
 #define ONEMKL_DECLARE_IMATCOPY_BATCH(T) \
     ONEMKL_DECLARE_IMATCOPY_BATCH_STRIDED(T) \
-    ONEMKL_DECLARE_IMATCOPY_BATCH_GROUP(T)
+    ONEMKL_DECLARE_IMATCOPY_BATCH_GROUP(T, std::int64_t) \
+    ONEMKL_DECLARE_IMATCOPY_BATCH_GROUP(T, std::int32_t)
 
 #define ONEMKL_DECLARE_IMATCOPY_BATCH_STRIDED(T) \
 DLL_EXPORT sycl::event imatcopy_batch(sycl::queue &queue, transpose trans, \
@@ -1129,28 +1174,26 @@ DLL_EXPORT sycl::event imatcopy_batch(sycl::queue &queue, transpose trans, \
                                           std::int64_t ldb, std::int64_t stride, std::int64_t batch_size, \
                                           const std::vector<sycl::event> &dependencies = {});
 
-ONEMKL_DECLARE_IMATCOPY_BATCH_STRIDED(float)
-ONEMKL_DECLARE_IMATCOPY_BATCH_STRIDED(double)
-ONEMKL_DECLARE_IMATCOPY_BATCH_STRIDED(std::complex<float>)
-ONEMKL_DECLARE_IMATCOPY_BATCH_STRIDED(std::complex<double>)
-
-#define ONEMKL_DECLARE_IMATCOPY_BATCH_GROUP(T) \
+#define ONEMKL_DECLARE_IMATCOPY_BATCH_GROUP(T, Ti) \
 DLL_EXPORT sycl::event imatcopy_batch(sycl::queue &queue, const transpose *trans, \
-                                          const std::int64_t *m, const std::int64_t *n, const T *alpha, T **ab, \
-                                          const std::int64_t *lda, const std::int64_t *ldb, std::int64_t group_count, \
-                                          const std::int64_t *groupsize, \
-                                          const std::vector<sycl::event> &dependencies = {});
+                                      const Ti *m, const Ti *n, const T *alpha, T **ab, \
+                                      const Ti *lda, const Ti *ldb, std::int64_t group_count, \
+                                      const Ti *groupsize, \
+                                      const std::vector<sycl::event> &dependencies = {});
 
-ONEMKL_DECLARE_IMATCOPY_BATCH_GROUP(float)
-ONEMKL_DECLARE_IMATCOPY_BATCH_GROUP(double)
-ONEMKL_DECLARE_IMATCOPY_BATCH_GROUP(std::complex<float>)
-ONEMKL_DECLARE_IMATCOPY_BATCH_GROUP(std::complex<double>)
+ONEMKL_DECLARE_IMATCOPY_BATCH(float)
+ONEMKL_DECLARE_IMATCOPY_BATCH(double)
+ONEMKL_DECLARE_IMATCOPY_BATCH(std::complex<float>)
+ONEMKL_DECLARE_IMATCOPY_BATCH(std::complex<double>)
 
+#undef ONEMKL_DECLARE_IMATCOPY_BATCH_GROUP
+#undef ONEMKL_DECLARE_IMATCOPY_BATCH_STRIDED
 #undef ONEMKL_DECLARE_IMATCOPY_BATCH
 
 #define ONEMKL_DECLARE_OMATCOPY_BATCH(T) \
     ONEMKL_DECLARE_OMATCOPY_BATCH_STRIDED(T) \
-    ONEMKL_DECLARE_OMATCOPY_BATCH_GROUP(T)
+    ONEMKL_DECLARE_OMATCOPY_BATCH_GROUP(T, std::int64_t) \
+    ONEMKL_DECLARE_OMATCOPY_BATCH_GROUP(T, std::int32_t)
 
 #define ONEMKL_DECLARE_OMATCOPY_BATCH_STRIDED(T) \
 DLL_EXPORT sycl::event omatcopy_batch(sycl::queue &queue, transpose trans, \
@@ -1160,23 +1203,20 @@ DLL_EXPORT sycl::event omatcopy_batch(sycl::queue &queue, transpose trans, \
                                           std::int64_t batch_size, \
                                           const std::vector<sycl::event> &dependencies = {});
 
-ONEMKL_DECLARE_OMATCOPY_BATCH_STRIDED(float)
-ONEMKL_DECLARE_OMATCOPY_BATCH_STRIDED(double)
-ONEMKL_DECLARE_OMATCOPY_BATCH_STRIDED(std::complex<float>)
-ONEMKL_DECLARE_OMATCOPY_BATCH_STRIDED(std::complex<double>)
-
-#define ONEMKL_DECLARE_OMATCOPY_BATCH_GROUP(T) \
+#define ONEMKL_DECLARE_OMATCOPY_BATCH_GROUP(T, Ti) \
 DLL_EXPORT sycl::event omatcopy_batch(sycl::queue &queue, const transpose *trans, \
-                                          const std::int64_t *m, const std::int64_t *n, const T *alpha, const T **a, \
-                                          const std::int64_t *lda, T **b, const std::int64_t *ldb, std::int64_t group_count, \
-                                          const std::int64_t *groupsize, \
-                                          const std::vector<sycl::event> &dependencies = {});
+                                      const Ti *m, const Ti *n, const T *alpha, const T **a, \
+                                      const Ti *lda, T **b, const Ti *ldb, std::int64_t group_count, \
+                                      const Ti *groupsize, \
+                                      const std::vector<sycl::event> &dependencies = {});
 
-ONEMKL_DECLARE_OMATCOPY_BATCH_GROUP(float)
-ONEMKL_DECLARE_OMATCOPY_BATCH_GROUP(double)
-ONEMKL_DECLARE_OMATCOPY_BATCH_GROUP(std::complex<float>)
-ONEMKL_DECLARE_OMATCOPY_BATCH_GROUP(std::complex<double>)
+ONEMKL_DECLARE_OMATCOPY_BATCH(float)
+ONEMKL_DECLARE_OMATCOPY_BATCH(double)
+ONEMKL_DECLARE_OMATCOPY_BATCH(std::complex<float>)
+ONEMKL_DECLARE_OMATCOPY_BATCH(std::complex<double>)
 
+#undef ONEMKL_DECLARE_OMATCOPY_BATCH_GROUP
+#undef ONEMKL_DECLARE_OMATCOPY_BATCH_STRIDED
 #undef ONEMKL_DECLARE_OMATCOPY_BATCH
 
 #define ONEMKL_DECLARE_OMATADD_BATCH(T) \

{mkl_devel_dpcpp-2024.0.0.data → mkl_devel_dpcpp-2024.2.0.data}/data/include/oneapi/mkl/dfti.hpp

@@ -62,7 +62,9 @@ enum class config_param {
     THREAD_LIMIT            = DFTI_THREAD_LIMIT,
     DESTROY_INPUT           = DFTI_DESTROY_INPUT,
     WORKSPACE_ESTIMATE_BYTES,
-    WORKSPACE_BYTES
+    WORKSPACE_BYTES,
+    FWD_STRIDES,
+    BWD_STRIDES
 };
 
 enum class config_value {