[BLAS] add interfaces to matrix copy/transposition routines

include/oneapi/mkl/blas/detail/blas_ct_backends.hxx

@@ -1083,6 +1083,82 @@ static inline void symv(backend_selector<backend::BACKEND> selector, uplo upper_
                         std::int64_t lda, sycl::buffer<double, 1> &x, std::int64_t incx,
                         double beta, sycl::buffer<double, 1> &y, std::int64_t incy);
 
+static inline void omatcopy_batch(backend_selector<backend::BACKEND> selector, transpose trans,
+                                  std::int64_t m, std::int64_t n, float alpha,
+                                  sycl::buffer<float, 1> &a, std::int64_t lda,
+                                  std::int64_t stride_a, sycl::buffer<float, 1> &b,
+                                  std::int64_t ldb, std::int64_t stride_b, std::int64_t batch_size);
+
+static inline void omatcopy_batch(backend_selector<backend::BACKEND> selector, transpose trans,
+                                  std::int64_t m, std::int64_t n, double alpha,
+                                  sycl::buffer<double, 1> &a, std::int64_t lda,
+                                  std::int64_t stride_a, sycl::buffer<double, 1> &b,
+                                  std::int64_t ldb, std::int64_t stride_b, std::int64_t batch_size);
+
+static inline void omatcopy_batch(backend_selector<backend::BACKEND> selector, transpose trans,
+                                  std::int64_t m, std::int64_t n, std::complex<float> alpha,
+                                  sycl::buffer<std::complex<float>, 1> &a, std::int64_t lda,
+                                  std::int64_t stride_a, sycl::buffer<std::complex<float>, 1> &b,
+                                  std::int64_t ldb, std::int64_t stride_b, std::int64_t batch_size);
+
+static inline void omatcopy_batch(backend_selector<backend::BACKEND> selector, transpose trans,
+                                  std::int64_t m, std::int64_t n, std::complex<double> alpha,
+                                  sycl::buffer<std::complex<double>, 1> &a, std::int64_t lda,
+                                  std::int64_t stride_a, sycl::buffer<std::complex<double>, 1> &b,
+                                  std::int64_t ldb, std::int64_t stride_b, std::int64_t batch_size);
+
+static inline void imatcopy_batch(backend_selector<backend::BACKEND> selector, transpose trans,
+                                  std::int64_t m, std::int64_t n, float alpha,
+                                  sycl::buffer<float, 1> &ab, std::int64_t lda, std::int64_t ldb,
+                                  std::int64_t stride, std::int64_t batch_size);
+
+static inline void imatcopy_batch(backend_selector<backend::BACKEND> selector, transpose trans,
+                                  std::int64_t m, std::int64_t n, double alpha,
+                                  sycl::buffer<double, 1> &ab, std::int64_t lda, std::int64_t ldb,
+                                  std::int64_t stride, std::int64_t batch_size);
+
+static inline void imatcopy_batch(backend_selector<backend::BACKEND> selector, transpose trans,
+                                  std::int64_t m, std::int64_t n, std::complex<float> alpha,
+                                  sycl::buffer<std::complex<float>, 1> &ab, std::int64_t lda,
+                                  std::int64_t ldb, std::int64_t stride, std::int64_t batch_size);
+
+static inline void imatcopy_batch(backend_selector<backend::BACKEND> selector, transpose trans,
+                                  std::int64_t m, std::int64_t n, std::complex<double> alpha,
+                                  sycl::buffer<std::complex<double>, 1> &ab, std::int64_t lda,
+                                  std::int64_t ldb, std::int64_t stride, std::int64_t batch_size);
+
+static inline void omatadd_batch(backend_selector<backend::BACKEND> selector, transpose transa,
+                                 transpose transb, std::int64_t m, std::int64_t n, float alpha,
+                                 sycl::buffer<float, 1> &a, std::int64_t lda, std::int64_t stride_a,
+                                 float beta, sycl::buffer<float, 1> &b, std::int64_t ldb,
+                                 std::int64_t stride_b, sycl::buffer<float, 1> &c, std::int64_t ldc,
+                                 std::int64_t stride_c, std::int64_t batch_size);
+
+static inline void omatadd_batch(backend_selector<backend::BACKEND> selector, transpose transa,
+                                 transpose transb, std::int64_t m, std::int64_t n, double alpha,
+                                 sycl::buffer<double, 1> &a, std::int64_t lda,
+                                 std::int64_t stride_a, double beta, sycl::buffer<double, 1> &b,
+                                 std::int64_t ldb, std::int64_t stride_b,
+                                 sycl::buffer<double, 1> &c, std::int64_t ldc,
+                                 std::int64_t stride_c, std::int64_t batch_size);
+
+static inline void omatadd_batch(backend_selector<backend::BACKEND> selector, transpose transa,
+                                 transpose transb, std::int64_t m, std::int64_t n,
+                                 std::complex<float> alpha, sycl::buffer<std::complex<float>, 1> &a,
+                                 std::int64_t lda, std::int64_t stride_a, std::complex<float> beta,
+                                 sycl::buffer<std::complex<float>, 1> &b, std::int64_t ldb,
+                                 std::int64_t stride_b, sycl::buffer<std::complex<float>, 1> &c,
+                                 std::int64_t ldc, std::int64_t stride_c, std::int64_t batch_size);
+
+static inline void omatadd_batch(backend_selector<backend::BACKEND> selector, transpose transa,
+                                 transpose transb, std::int64_t m, std::int64_t n,
+                                 std::complex<double> alpha,
+                                 sycl::buffer<std::complex<double>, 1> &a, std::int64_t lda,
+                                 std::int64_t stride_a, std::complex<double> beta,
+                                 sycl::buffer<std::complex<double>, 1> &b, std::int64_t ldb,
+                                 std::int64_t stride_b, sycl::buffer<std::complex<double>, 1> &c,
+                                 std::int64_t ldc, std::int64_t stride_c, std::int64_t batch_size);
+
 // USM APIs
 
 static inline sycl::event syr2(backend_selector<backend::BACKEND> selector, uplo upper_lower,
@@ -2484,3 +2560,93 @@ static inline sycl::event symv(backend_selector<backend::BACKEND> selector, uplo
                                    const double *x, std::int64_t incx, double beta, double *y,
                                    std::int64_t incy,
                                    const std::vector<sycl::event> &dependencies = {});
+
+static inline sycl::event omatcopy_batch(backend_selector<backend::BACKEND> selector,
+                                         transpose trans, std::int64_t m, std::int64_t n,
+                                         float alpha, const float *a, std::int64_t lda,
+                                         std::int64_t stride_a, float *b, std::int64_t ldb,
+                                         std::int64_t stride_b, std::int64_t batch_size,
+                                         const std::vector<sycl::event> &dependencies = {});
+
+static inline sycl::event omatcopy_batch(backend_selector<backend::BACKEND> selector,
+                                         transpose trans, std::int64_t m, std::int64_t n,
+                                         double alpha, const double *a, std::int64_t lda,
+                                         std::int64_t stride_a, double *b, std::int64_t ldb,
+                                         std::int64_t stride_b, std::int64_t batch_size,
+                                         const std::vector<sycl::event> &dependencies = {});
+
+static inline sycl::event omatcopy_batch(backend_selector<backend::BACKEND> selector,
+                                         transpose trans, std::int64_t m, std::int64_t n,
+                                         std::complex<float> alpha, const std::complex<float> *a,
+                                         std::int64_t lda, std::int64_t stride_a,
+                                         std::complex<float> *b, std::int64_t ldb,
+                                         std::int64_t stride_b, std::int64_t batch_size,
+                                         const std::vector<sycl::event> &dependencies = {});
+
+static inline sycl::event omatcopy_batch(backend_selector<backend::BACKEND> selector,
+                                         transpose trans, std::int64_t m, std::int64_t n,
+                                         std::complex<double> alpha, const std::complex<double> *a,
+                                         std::int64_t lda, std::int64_t stride_a,
+                                         std::complex<double> *b, std::int64_t ldb,
+                                         std::int64_t stride_b, std::int64_t batch_size,
+                                         const std::vector<sycl::event> &dependencies = {});
+
+static inline sycl::event imatcopy_batch(backend_selector<backend::BACKEND> selector,
+                                         transpose trans, std::int64_t m, std::int64_t n,
+                                         float alpha, float *ab, std::int64_t lda, std::int64_t ldb,
+                                         std::int64_t stride, std::int64_t batch_size,
+                                         const std::vector<sycl::event> &dependencies = {});
+
+static inline sycl::event imatcopy_batch(backend_selector<backend::BACKEND> selector,
+                                         transpose trans, std::int64_t m, std::int64_t n,
+                                         double alpha, double *ab, std::int64_t lda,
+                                         std::int64_t ldb, std::int64_t stride,
+                                         std::int64_t batch_size,
+                                         const std::vector<sycl::event> &dependencies = {});
+
+static inline sycl::event imatcopy_batch(backend_selector<backend::BACKEND> selector,
+                                         transpose trans, std::int64_t m, std::int64_t n,
+                                         std::complex<float> alpha, std::complex<float> *ab,
+                                         std::int64_t lda, std::int64_t ldb, std::int64_t stride,
+                                         std::int64_t batch_size,
+                                         const std::vector<sycl::event> &dependencies = {});
+
+static inline sycl::event imatcopy_batch(backend_selector<backend::BACKEND> selector,
+                                         transpose trans, std::int64_t m, std::int64_t n,
+                                         std::complex<double> alpha, std::complex<double> *ab,
+                                         std::int64_t lda, std::int64_t ldb, std::int64_t stride,
+                                         std::int64_t batch_size,
+                                         const std::vector<sycl::event> &dependencies = {});
+
+static inline sycl::event omatadd_batch(backend_selector<backend::BACKEND> selector,
+                                        transpose transa, transpose transb, std::int64_t m,
+                                        std::int64_t n, float alpha, const float *a,
+                                        std::int64_t lda, std::int64_t stride_a, float beta,
+                                        const float *b, std::int64_t ldb, std::int64_t stride_b,
+                                        float *c, std::int64_t ldc, std::int64_t stride_c,
+                                        std::int64_t batch_size,
+                                        const std::vector<sycl::event> &dependencies = {});
+
+static inline sycl::event omatadd_batch(backend_selector<backend::BACKEND> selector,
+                                        transpose transa, transpose transb, std::int64_t m,
+                                        std::int64_t n, double alpha, const double *a,
+                                        std::int64_t lda, std::int64_t stride_a, double beta,
+                                        const double *b, std::int64_t ldb, std::int64_t stride_b,
+                                        double *c, std::int64_t ldc, std::int64_t stride_c,
+                                        std::int64_t batch_size,
+                                        const std::vector<sycl::event> &dependencies = {});
+
+static inline sycl::event omatadd_batch(
+    backend_selector<backend::BACKEND> selector, transpose transa, transpose transb, std::int64_t m,
+    std::int64_t n, std::complex<float> alpha, const std::complex<float> *a, std::int64_t lda,
+    std::int64_t stride_a, std::complex<float> beta, const std::complex<float> *b, std::int64_t ldb,
+    std::int64_t stride_b, std::complex<float> *c, std::int64_t ldc, std::int64_t stride_c,
+    std::int64_t batch_size, const std::vector<sycl::event> &dependencies = {});
+
+static inline sycl::event omatadd_batch(
+    backend_selector<backend::BACKEND> selector, transpose transa, transpose transb, std::int64_t m,
+    std::int64_t n, std::complex<double> alpha, const std::complex<double> *a, std::int64_t lda,
+    std::int64_t stride_a, std::complex<double> beta, const std::complex<double> *b,
+    std::int64_t ldb, std::int64_t stride_b, std::complex<double> *c, std::int64_t ldc,
+    std::int64_t stride_c, std::int64_t batch_size,
+    const std::vector<sycl::event> &dependencies = {});