From 5c6b4ca7bff21e299050b9e54d891724aa541c85 Mon Sep 17 00:00:00 2001 From: Alexis Montoison Date: Fri, 12 Apr 2024 21:24:08 -0400 Subject: [PATCH] Pass values by references --- deps/src/onemkl.cpp | 438 +++++++++++++++--------------- deps/src/onemkl.h | 131 ++++----- lib/support/liboneapi_support.jl | 447 ++++++++++++++++--------------- res/support.toml | 235 ++++++++-------- 4 files changed, 621 insertions(+), 630 deletions(-) diff --git a/deps/src/onemkl.cpp b/deps/src/onemkl.cpp index 81d3ffe6..3e6d0e3c 100644 --- a/deps/src/onemkl.cpp +++ b/deps/src/onemkl.cpp @@ -553,187 +553,187 @@ extern "C" int onemklZtrsm_batch(syclQueue_t device_queue, onemklSide left_right } // BLAS extern "C" int onemklHgemm(syclQueue_t device_queue, onemklTranspose transa, onemklTranspose transb, int64_t m, int64_t n, int64_t k, short *alpha, short *a, int64_t lda, short *b, int64_t ldb, short *beta, short *c, int64_t ldc) { - auto status = oneapi::mkl::blas::column_major::gemm(device_queue->val, convert(transa), convert(transb), m, n, k, reinterpret_cast(alpha), reinterpret_cast(a), lda, reinterpret_cast(b), ldb, reinterpret_cast(beta), reinterpret_cast(c), ldc, {}); + auto status = oneapi::mkl::blas::column_major::gemm(device_queue->val, convert(transa), convert(transb), m, n, k, *reinterpret_cast(alpha), reinterpret_cast(a), lda, reinterpret_cast(b), ldb, *reinterpret_cast(beta), reinterpret_cast(c), ldc, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklSgemm(syclQueue_t device_queue, onemklTranspose transa, onemklTranspose transb, int64_t m, int64_t n, int64_t k, float *alpha, float *a, int64_t lda, float *b, int64_t ldb, float *beta, float *c, int64_t ldc) { - auto status = oneapi::mkl::blas::column_major::gemm(device_queue->val, convert(transa), convert(transb), m, n, k, alpha, a, lda, b, ldb, beta, c, ldc, {}); + auto status = oneapi::mkl::blas::column_major::gemm(device_queue->val, convert(transa), convert(transb), m, n, k, *alpha, a, lda, b, ldb, *beta, c, ldc, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklDgemm(syclQueue_t device_queue, onemklTranspose transa, onemklTranspose transb, int64_t m, int64_t n, int64_t k, double *alpha, double *a, int64_t lda, double *b, int64_t ldb, double *beta, double *c, int64_t ldc) { - auto status = oneapi::mkl::blas::column_major::gemm(device_queue->val, convert(transa), convert(transb), m, n, k, alpha, a, lda, b, ldb, beta, c, ldc, {}); + auto status = oneapi::mkl::blas::column_major::gemm(device_queue->val, convert(transa), convert(transb), m, n, k, *alpha, a, lda, b, ldb, *beta, c, ldc, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklCgemm(syclQueue_t device_queue, onemklTranspose transa, onemklTranspose transb, int64_t m, int64_t n, int64_t k, float _Complex *alpha, float _Complex *a, int64_t lda, float _Complex *b, int64_t ldb, float _Complex *beta, float _Complex *c, int64_t ldc) { - auto status = oneapi::mkl::blas::column_major::gemm(device_queue->val, convert(transa), convert(transb), m, n, k, reinterpret_cast*>(alpha), reinterpret_cast*>(a), lda, reinterpret_cast*>(b), ldb, reinterpret_cast*>(beta), reinterpret_cast*>(c), ldc, {}); + auto status = oneapi::mkl::blas::column_major::gemm(device_queue->val, convert(transa), convert(transb), m, n, k, *reinterpret_cast*>(alpha), reinterpret_cast*>(a), lda, reinterpret_cast*>(b), ldb, *reinterpret_cast*>(beta), reinterpret_cast*>(c), ldc, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklZgemm(syclQueue_t device_queue, onemklTranspose transa, onemklTranspose transb, int64_t m, int64_t n, int64_t k, double _Complex *alpha, double _Complex *a, int64_t lda, double _Complex *b, int64_t ldb, double _Complex *beta, double _Complex *c, int64_t ldc) { - auto status = oneapi::mkl::blas::column_major::gemm(device_queue->val, convert(transa), convert(transb), m, n, k, reinterpret_cast*>(alpha), reinterpret_cast*>(a), lda, reinterpret_cast*>(b), ldb, reinterpret_cast*>(beta), reinterpret_cast*>(c), ldc, {}); + auto status = oneapi::mkl::blas::column_major::gemm(device_queue->val, convert(transa), convert(transb), m, n, k, *reinterpret_cast*>(alpha), reinterpret_cast*>(a), lda, reinterpret_cast*>(b), ldb, *reinterpret_cast*>(beta), reinterpret_cast*>(c), ldc, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklSsymm(syclQueue_t device_queue, onemklSide left_right, onemklUplo upper_lower, int64_t m, int64_t n, float *alpha, float *a, int64_t lda, float *b, int64_t ldb, float *beta, float *c, int64_t ldc) { - auto status = oneapi::mkl::blas::column_major::symm(device_queue->val, convert(left_right), convert(upper_lower), m, n, alpha, a, lda, b, ldb, beta, c, ldc, {}); + auto status = oneapi::mkl::blas::column_major::symm(device_queue->val, convert(left_right), convert(upper_lower), m, n, *alpha, a, lda, b, ldb, *beta, c, ldc, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklDsymm(syclQueue_t device_queue, onemklSide left_right, onemklUplo upper_lower, int64_t m, int64_t n, double *alpha, double *a, int64_t lda, double *b, int64_t ldb, double *beta, double *c, int64_t ldc) { - auto status = oneapi::mkl::blas::column_major::symm(device_queue->val, convert(left_right), convert(upper_lower), m, n, alpha, a, lda, b, ldb, beta, c, ldc, {}); + auto status = oneapi::mkl::blas::column_major::symm(device_queue->val, convert(left_right), convert(upper_lower), m, n, *alpha, a, lda, b, ldb, *beta, c, ldc, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklCsymm(syclQueue_t device_queue, onemklSide left_right, onemklUplo upper_lower, int64_t m, int64_t n, float _Complex *alpha, float _Complex *a, int64_t lda, float _Complex *b, int64_t ldb, float _Complex *beta, float _Complex *c, int64_t ldc) { - auto status = oneapi::mkl::blas::column_major::symm(device_queue->val, convert(left_right), convert(upper_lower), m, n, reinterpret_cast*>(alpha), reinterpret_cast*>(a), lda, reinterpret_cast*>(b), ldb, reinterpret_cast*>(beta), reinterpret_cast*>(c), ldc, {}); + auto status = oneapi::mkl::blas::column_major::symm(device_queue->val, convert(left_right), convert(upper_lower), m, n, *reinterpret_cast*>(alpha), reinterpret_cast*>(a), lda, reinterpret_cast*>(b), ldb, *reinterpret_cast*>(beta), reinterpret_cast*>(c), ldc, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklZsymm(syclQueue_t device_queue, onemklSide left_right, onemklUplo upper_lower, int64_t m, int64_t n, double _Complex *alpha, double _Complex *a, int64_t lda, double _Complex *b, int64_t ldb, double _Complex *beta, double _Complex *c, int64_t ldc) { - auto status = oneapi::mkl::blas::column_major::symm(device_queue->val, convert(left_right), convert(upper_lower), m, n, reinterpret_cast*>(alpha), reinterpret_cast*>(a), lda, reinterpret_cast*>(b), ldb, reinterpret_cast*>(beta), reinterpret_cast*>(c), ldc, {}); + auto status = oneapi::mkl::blas::column_major::symm(device_queue->val, convert(left_right), convert(upper_lower), m, n, *reinterpret_cast*>(alpha), reinterpret_cast*>(a), lda, reinterpret_cast*>(b), ldb, *reinterpret_cast*>(beta), reinterpret_cast*>(c), ldc, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklChemm(syclQueue_t device_queue, onemklSide left_right, onemklUplo upper_lower, int64_t m, int64_t n, float _Complex *alpha, float _Complex *a, int64_t lda, float _Complex *b, int64_t ldb, float _Complex *beta, float _Complex *c, int64_t ldc) { - auto status = oneapi::mkl::blas::column_major::hemm(device_queue->val, convert(left_right), convert(upper_lower), m, n, reinterpret_cast*>(alpha), reinterpret_cast*>(a), lda, reinterpret_cast*>(b), ldb, reinterpret_cast*>(beta), reinterpret_cast*>(c), ldc, {}); + auto status = oneapi::mkl::blas::column_major::hemm(device_queue->val, convert(left_right), convert(upper_lower), m, n, *reinterpret_cast*>(alpha), reinterpret_cast*>(a), lda, reinterpret_cast*>(b), ldb, *reinterpret_cast*>(beta), reinterpret_cast*>(c), ldc, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklZhemm(syclQueue_t device_queue, onemklSide left_right, onemklUplo upper_lower, int64_t m, int64_t n, double _Complex *alpha, double _Complex *a, int64_t lda, double _Complex *b, int64_t ldb, double _Complex *beta, double _Complex *c, int64_t ldc) { - auto status = oneapi::mkl::blas::column_major::hemm(device_queue->val, convert(left_right), convert(upper_lower), m, n, reinterpret_cast*>(alpha), reinterpret_cast*>(a), lda, reinterpret_cast*>(b), ldb, reinterpret_cast*>(beta), reinterpret_cast*>(c), ldc, {}); + auto status = oneapi::mkl::blas::column_major::hemm(device_queue->val, convert(left_right), convert(upper_lower), m, n, *reinterpret_cast*>(alpha), reinterpret_cast*>(a), lda, reinterpret_cast*>(b), ldb, *reinterpret_cast*>(beta), reinterpret_cast*>(c), ldc, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklSsyrk(syclQueue_t device_queue, onemklUplo upper_lower, onemklTranspose trans, int64_t n, int64_t k, float *alpha, float *a, int64_t lda, float *beta, float *c, int64_t ldc) { - auto status = oneapi::mkl::blas::column_major::syrk(device_queue->val, convert(upper_lower), convert(trans), n, k, alpha, a, lda, beta, c, ldc, {}); + auto status = oneapi::mkl::blas::column_major::syrk(device_queue->val, convert(upper_lower), convert(trans), n, k, *alpha, a, lda, *beta, c, ldc, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklDsyrk(syclQueue_t device_queue, onemklUplo upper_lower, onemklTranspose trans, int64_t n, int64_t k, double *alpha, double *a, int64_t lda, double *beta, double *c, int64_t ldc) { - auto status = oneapi::mkl::blas::column_major::syrk(device_queue->val, convert(upper_lower), convert(trans), n, k, alpha, a, lda, beta, c, ldc, {}); + auto status = oneapi::mkl::blas::column_major::syrk(device_queue->val, convert(upper_lower), convert(trans), n, k, *alpha, a, lda, *beta, c, ldc, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklCsyrk(syclQueue_t device_queue, onemklUplo upper_lower, onemklTranspose trans, int64_t n, int64_t k, float _Complex *alpha, float _Complex *a, int64_t lda, float _Complex *beta, float _Complex *c, int64_t ldc) { - auto status = oneapi::mkl::blas::column_major::syrk(device_queue->val, convert(upper_lower), convert(trans), n, k, reinterpret_cast*>(alpha), reinterpret_cast*>(a), lda, reinterpret_cast*>(beta), reinterpret_cast*>(c), ldc, {}); + auto status = oneapi::mkl::blas::column_major::syrk(device_queue->val, convert(upper_lower), convert(trans), n, k, *reinterpret_cast*>(alpha), reinterpret_cast*>(a), lda, *reinterpret_cast*>(beta), reinterpret_cast*>(c), ldc, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklZsyrk(syclQueue_t device_queue, onemklUplo upper_lower, onemklTranspose trans, int64_t n, int64_t k, double _Complex *alpha, double _Complex *a, int64_t lda, double _Complex *beta, double _Complex *c, int64_t ldc) { - auto status = oneapi::mkl::blas::column_major::syrk(device_queue->val, convert(upper_lower), convert(trans), n, k, reinterpret_cast*>(alpha), reinterpret_cast*>(a), lda, reinterpret_cast*>(beta), reinterpret_cast*>(c), ldc, {}); + auto status = oneapi::mkl::blas::column_major::syrk(device_queue->val, convert(upper_lower), convert(trans), n, k, *reinterpret_cast*>(alpha), reinterpret_cast*>(a), lda, *reinterpret_cast*>(beta), reinterpret_cast*>(c), ldc, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklCherk(syclQueue_t device_queue, onemklUplo upper_lower, onemklTranspose trans, int64_t n, int64_t k, float *alpha, float _Complex *a, int64_t lda, float *beta, float _Complex *c, int64_t ldc) { - auto status = oneapi::mkl::blas::column_major::herk(device_queue->val, convert(upper_lower), convert(trans), n, k, alpha, reinterpret_cast*>(a), lda, beta, reinterpret_cast*>(c), ldc, {}); + auto status = oneapi::mkl::blas::column_major::herk(device_queue->val, convert(upper_lower), convert(trans), n, k, *alpha, reinterpret_cast*>(a), lda, *beta, reinterpret_cast*>(c), ldc, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklZherk(syclQueue_t device_queue, onemklUplo upper_lower, onemklTranspose trans, int64_t n, int64_t k, double *alpha, double _Complex *a, int64_t lda, double *beta, double _Complex *c, int64_t ldc) { - auto status = oneapi::mkl::blas::column_major::herk(device_queue->val, convert(upper_lower), convert(trans), n, k, alpha, reinterpret_cast*>(a), lda, beta, reinterpret_cast*>(c), ldc, {}); + auto status = oneapi::mkl::blas::column_major::herk(device_queue->val, convert(upper_lower), convert(trans), n, k, *alpha, reinterpret_cast*>(a), lda, *beta, reinterpret_cast*>(c), ldc, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklSsyr2k(syclQueue_t device_queue, onemklUplo upper_lower, onemklTranspose trans, int64_t n, int64_t k, float *alpha, float *a, int64_t lda, float *b, int64_t ldb, float *beta, float *c, int64_t ldc) { - auto status = oneapi::mkl::blas::column_major::syr2k(device_queue->val, convert(upper_lower), convert(trans), n, k, alpha, a, lda, b, ldb, beta, c, ldc, {}); + auto status = oneapi::mkl::blas::column_major::syr2k(device_queue->val, convert(upper_lower), convert(trans), n, k, *alpha, a, lda, b, ldb, *beta, c, ldc, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklDsyr2k(syclQueue_t device_queue, onemklUplo upper_lower, onemklTranspose trans, int64_t n, int64_t k, double *alpha, double *a, int64_t lda, double *b, int64_t ldb, double *beta, double *c, int64_t ldc) { - auto status = oneapi::mkl::blas::column_major::syr2k(device_queue->val, convert(upper_lower), convert(trans), n, k, alpha, a, lda, b, ldb, beta, c, ldc, {}); + auto status = oneapi::mkl::blas::column_major::syr2k(device_queue->val, convert(upper_lower), convert(trans), n, k, *alpha, a, lda, b, ldb, *beta, c, ldc, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklCsyr2k(syclQueue_t device_queue, onemklUplo upper_lower, onemklTranspose trans, int64_t n, int64_t k, float _Complex *alpha, float _Complex *a, int64_t lda, float _Complex *b, int64_t ldb, float _Complex *beta, float _Complex *c, int64_t ldc) { - auto status = oneapi::mkl::blas::column_major::syr2k(device_queue->val, convert(upper_lower), convert(trans), n, k, reinterpret_cast*>(alpha), reinterpret_cast*>(a), lda, reinterpret_cast*>(b), ldb, reinterpret_cast*>(beta), reinterpret_cast*>(c), ldc, {}); + auto status = oneapi::mkl::blas::column_major::syr2k(device_queue->val, convert(upper_lower), convert(trans), n, k, *reinterpret_cast*>(alpha), reinterpret_cast*>(a), lda, reinterpret_cast*>(b), ldb, *reinterpret_cast*>(beta), reinterpret_cast*>(c), ldc, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklZsyr2k(syclQueue_t device_queue, onemklUplo upper_lower, onemklTranspose trans, int64_t n, int64_t k, double _Complex *alpha, double _Complex *a, int64_t lda, double _Complex *b, int64_t ldb, double _Complex *beta, double _Complex *c, int64_t ldc) { - auto status = oneapi::mkl::blas::column_major::syr2k(device_queue->val, convert(upper_lower), convert(trans), n, k, reinterpret_cast*>(alpha), reinterpret_cast*>(a), lda, reinterpret_cast*>(b), ldb, reinterpret_cast*>(beta), reinterpret_cast*>(c), ldc, {}); + auto status = oneapi::mkl::blas::column_major::syr2k(device_queue->val, convert(upper_lower), convert(trans), n, k, *reinterpret_cast*>(alpha), reinterpret_cast*>(a), lda, reinterpret_cast*>(b), ldb, *reinterpret_cast*>(beta), reinterpret_cast*>(c), ldc, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklCher2k(syclQueue_t device_queue, onemklUplo upper_lower, onemklTranspose trans, int64_t n, int64_t k, float _Complex *alpha, float _Complex *a, int64_t lda, float _Complex *b, int64_t ldb, float *beta, float _Complex *c, int64_t ldc) { - auto status = oneapi::mkl::blas::column_major::her2k(device_queue->val, convert(upper_lower), convert(trans), n, k, reinterpret_cast*>(alpha), reinterpret_cast*>(a), lda, reinterpret_cast*>(b), ldb, beta, reinterpret_cast*>(c), ldc, {}); + auto status = oneapi::mkl::blas::column_major::her2k(device_queue->val, convert(upper_lower), convert(trans), n, k, *reinterpret_cast*>(alpha), reinterpret_cast*>(a), lda, reinterpret_cast*>(b), ldb, *beta, reinterpret_cast*>(c), ldc, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklZher2k(syclQueue_t device_queue, onemklUplo upper_lower, onemklTranspose trans, int64_t n, int64_t k, double _Complex *alpha, double _Complex *a, int64_t lda, double _Complex *b, int64_t ldb, double *beta, double _Complex *c, int64_t ldc) { - auto status = oneapi::mkl::blas::column_major::her2k(device_queue->val, convert(upper_lower), convert(trans), n, k, reinterpret_cast*>(alpha), reinterpret_cast*>(a), lda, reinterpret_cast*>(b), ldb, beta, reinterpret_cast*>(c), ldc, {}); + auto status = oneapi::mkl::blas::column_major::her2k(device_queue->val, convert(upper_lower), convert(trans), n, k, *reinterpret_cast*>(alpha), reinterpret_cast*>(a), lda, reinterpret_cast*>(b), ldb, *beta, reinterpret_cast*>(c), ldc, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklStrmm(syclQueue_t device_queue, onemklSide left_right, onemklUplo upper_lower, onemklTranspose trans, onemklDiag unit_diag, int64_t m, int64_t n, float *alpha, float *a, int64_t lda, float *b, int64_t ldb) { - auto status = oneapi::mkl::blas::column_major::trmm(device_queue->val, convert(left_right), convert(upper_lower), convert(trans), convert(unit_diag), m, n, alpha, a, lda, b, ldb, {}); + auto status = oneapi::mkl::blas::column_major::trmm(device_queue->val, convert(left_right), convert(upper_lower), convert(trans), convert(unit_diag), m, n, *alpha, a, lda, b, ldb, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklDtrmm(syclQueue_t device_queue, onemklSide left_right, onemklUplo upper_lower, onemklTranspose trans, onemklDiag unit_diag, int64_t m, int64_t n, double *alpha, double *a, int64_t lda, double *b, int64_t ldb) { - auto status = oneapi::mkl::blas::column_major::trmm(device_queue->val, convert(left_right), convert(upper_lower), convert(trans), convert(unit_diag), m, n, alpha, a, lda, b, ldb, {}); + auto status = oneapi::mkl::blas::column_major::trmm(device_queue->val, convert(left_right), convert(upper_lower), convert(trans), convert(unit_diag), m, n, *alpha, a, lda, b, ldb, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklCtrmm(syclQueue_t device_queue, onemklSide left_right, onemklUplo upper_lower, onemklTranspose trans, onemklDiag unit_diag, int64_t m, int64_t n, float _Complex *alpha, float _Complex *a, int64_t lda, float _Complex *b, int64_t ldb) { - auto status = oneapi::mkl::blas::column_major::trmm(device_queue->val, convert(left_right), convert(upper_lower), convert(trans), convert(unit_diag), m, n, reinterpret_cast*>(alpha), reinterpret_cast*>(a), lda, reinterpret_cast*>(b), ldb, {}); + auto status = oneapi::mkl::blas::column_major::trmm(device_queue->val, convert(left_right), convert(upper_lower), convert(trans), convert(unit_diag), m, n, *reinterpret_cast*>(alpha), reinterpret_cast*>(a), lda, reinterpret_cast*>(b), ldb, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklZtrmm(syclQueue_t device_queue, onemklSide left_right, onemklUplo upper_lower, onemklTranspose trans, onemklDiag unit_diag, int64_t m, int64_t n, double _Complex *alpha, double _Complex *a, int64_t lda, double _Complex *b, int64_t ldb) { - auto status = oneapi::mkl::blas::column_major::trmm(device_queue->val, convert(left_right), convert(upper_lower), convert(trans), convert(unit_diag), m, n, reinterpret_cast*>(alpha), reinterpret_cast*>(a), lda, reinterpret_cast*>(b), ldb, {}); + auto status = oneapi::mkl::blas::column_major::trmm(device_queue->val, convert(left_right), convert(upper_lower), convert(trans), convert(unit_diag), m, n, *reinterpret_cast*>(alpha), reinterpret_cast*>(a), lda, reinterpret_cast*>(b), ldb, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklStrsm(syclQueue_t device_queue, onemklSide left_right, onemklUplo upper_lower, onemklTranspose trans, onemklDiag unit_diag, int64_t m, int64_t n, float *alpha, float *a, int64_t lda, float *b, int64_t ldb) { - auto status = oneapi::mkl::blas::column_major::trsm(device_queue->val, convert(left_right), convert(upper_lower), convert(trans), convert(unit_diag), m, n, alpha, a, lda, b, ldb, {}); + auto status = oneapi::mkl::blas::column_major::trsm(device_queue->val, convert(left_right), convert(upper_lower), convert(trans), convert(unit_diag), m, n, *alpha, a, lda, b, ldb, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklDtrsm(syclQueue_t device_queue, onemklSide left_right, onemklUplo upper_lower, onemklTranspose trans, onemklDiag unit_diag, int64_t m, int64_t n, double *alpha, double *a, int64_t lda, double *b, int64_t ldb) { - auto status = oneapi::mkl::blas::column_major::trsm(device_queue->val, convert(left_right), convert(upper_lower), convert(trans), convert(unit_diag), m, n, alpha, a, lda, b, ldb, {}); + auto status = oneapi::mkl::blas::column_major::trsm(device_queue->val, convert(left_right), convert(upper_lower), convert(trans), convert(unit_diag), m, n, *alpha, a, lda, b, ldb, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklCtrsm(syclQueue_t device_queue, onemklSide left_right, onemklUplo upper_lower, onemklTranspose trans, onemklDiag unit_diag, int64_t m, int64_t n, float _Complex *alpha, float _Complex *a, int64_t lda, float _Complex *b, int64_t ldb) { - auto status = oneapi::mkl::blas::column_major::trsm(device_queue->val, convert(left_right), convert(upper_lower), convert(trans), convert(unit_diag), m, n, reinterpret_cast*>(alpha), reinterpret_cast*>(a), lda, reinterpret_cast*>(b), ldb, {}); + auto status = oneapi::mkl::blas::column_major::trsm(device_queue->val, convert(left_right), convert(upper_lower), convert(trans), convert(unit_diag), m, n, *reinterpret_cast*>(alpha), reinterpret_cast*>(a), lda, reinterpret_cast*>(b), ldb, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklZtrsm(syclQueue_t device_queue, onemklSide left_right, onemklUplo upper_lower, onemklTranspose trans, onemklDiag unit_diag, int64_t m, int64_t n, double _Complex *alpha, double _Complex *a, int64_t lda, double _Complex *b, int64_t ldb) { - auto status = oneapi::mkl::blas::column_major::trsm(device_queue->val, convert(left_right), convert(upper_lower), convert(trans), convert(unit_diag), m, n, reinterpret_cast*>(alpha), reinterpret_cast*>(a), lda, reinterpret_cast*>(b), ldb, {}); + auto status = oneapi::mkl::blas::column_major::trsm(device_queue->val, convert(left_right), convert(upper_lower), convert(trans), convert(unit_diag), m, n, *reinterpret_cast*>(alpha), reinterpret_cast*>(a), lda, reinterpret_cast*>(b), ldb, {}); __FORCE_MKL_FLUSH__(status); return 0; } @@ -763,289 +763,289 @@ extern "C" int onemklZdgmm(syclQueue_t device_queue, onemklSide left_right, int6 } extern "C" int onemklSgemv(syclQueue_t device_queue, onemklTranspose trans, int64_t m, int64_t n, float *alpha, float *a, int64_t lda, float *x, int64_t incx, float *beta, float *y, int64_t incy) { - auto status = oneapi::mkl::blas::column_major::gemv(device_queue->val, convert(trans), m, n, alpha, a, lda, x, incx, beta, y, incy, {}); + auto status = oneapi::mkl::blas::column_major::gemv(device_queue->val, convert(trans), m, n, *alpha, a, lda, x, incx, *beta, y, incy, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklDgemv(syclQueue_t device_queue, onemklTranspose trans, int64_t m, int64_t n, double *alpha, double *a, int64_t lda, double *x, int64_t incx, double *beta, double *y, int64_t incy) { - auto status = oneapi::mkl::blas::column_major::gemv(device_queue->val, convert(trans), m, n, alpha, a, lda, x, incx, beta, y, incy, {}); + auto status = oneapi::mkl::blas::column_major::gemv(device_queue->val, convert(trans), m, n, *alpha, a, lda, x, incx, *beta, y, incy, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklCgemv(syclQueue_t device_queue, onemklTranspose trans, int64_t m, int64_t n, float _Complex *alpha, float _Complex *a, int64_t lda, float _Complex *x, int64_t incx, float _Complex *beta, float _Complex *y, int64_t incy) { - auto status = oneapi::mkl::blas::column_major::gemv(device_queue->val, convert(trans), m, n, reinterpret_cast*>(alpha), reinterpret_cast*>(a), lda, reinterpret_cast*>(x), incx, reinterpret_cast*>(beta), reinterpret_cast*>(y), incy, {}); + auto status = oneapi::mkl::blas::column_major::gemv(device_queue->val, convert(trans), m, n, *reinterpret_cast*>(alpha), reinterpret_cast*>(a), lda, reinterpret_cast*>(x), incx, *reinterpret_cast*>(beta), reinterpret_cast*>(y), incy, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklZgemv(syclQueue_t device_queue, onemklTranspose trans, int64_t m, int64_t n, double _Complex *alpha, double _Complex *a, int64_t lda, double _Complex *x, int64_t incx, double _Complex *beta, double _Complex *y, int64_t incy) { - auto status = oneapi::mkl::blas::column_major::gemv(device_queue->val, convert(trans), m, n, reinterpret_cast*>(alpha), reinterpret_cast*>(a), lda, reinterpret_cast*>(x), incx, reinterpret_cast*>(beta), reinterpret_cast*>(y), incy, {}); + auto status = oneapi::mkl::blas::column_major::gemv(device_queue->val, convert(trans), m, n, *reinterpret_cast*>(alpha), reinterpret_cast*>(a), lda, reinterpret_cast*>(x), incx, *reinterpret_cast*>(beta), reinterpret_cast*>(y), incy, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklSgbmv(syclQueue_t device_queue, onemklTranspose trans, int64_t m, int64_t n, int64_t kl, int64_t ku, float *alpha, float *a, int64_t lda, float *x, int64_t incx, float *beta, float *y, int64_t incy) { - auto status = oneapi::mkl::blas::column_major::gbmv(device_queue->val, convert(trans), m, n, kl, ku, alpha, a, lda, x, incx, beta, y, incy, {}); + auto status = oneapi::mkl::blas::column_major::gbmv(device_queue->val, convert(trans), m, n, kl, ku, *alpha, a, lda, x, incx, *beta, y, incy, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklDgbmv(syclQueue_t device_queue, onemklTranspose trans, int64_t m, int64_t n, int64_t kl, int64_t ku, double *alpha, double *a, int64_t lda, double *x, int64_t incx, double *beta, double *y, int64_t incy) { - auto status = oneapi::mkl::blas::column_major::gbmv(device_queue->val, convert(trans), m, n, kl, ku, alpha, a, lda, x, incx, beta, y, incy, {}); + auto status = oneapi::mkl::blas::column_major::gbmv(device_queue->val, convert(trans), m, n, kl, ku, *alpha, a, lda, x, incx, *beta, y, incy, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklCgbmv(syclQueue_t device_queue, onemklTranspose trans, int64_t m, int64_t n, int64_t kl, int64_t ku, float _Complex *alpha, float _Complex *a, int64_t lda, float _Complex *x, int64_t incx, float _Complex *beta, float _Complex *y, int64_t incy) { - auto status = oneapi::mkl::blas::column_major::gbmv(device_queue->val, convert(trans), m, n, kl, ku, reinterpret_cast*>(alpha), reinterpret_cast*>(a), lda, reinterpret_cast*>(x), incx, reinterpret_cast*>(beta), reinterpret_cast*>(y), incy, {}); + auto status = oneapi::mkl::blas::column_major::gbmv(device_queue->val, convert(trans), m, n, kl, ku, *reinterpret_cast*>(alpha), reinterpret_cast*>(a), lda, reinterpret_cast*>(x), incx, *reinterpret_cast*>(beta), reinterpret_cast*>(y), incy, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklZgbmv(syclQueue_t device_queue, onemklTranspose trans, int64_t m, int64_t n, int64_t kl, int64_t ku, double _Complex *alpha, double _Complex *a, int64_t lda, double _Complex *x, int64_t incx, double _Complex *beta, double _Complex *y, int64_t incy) { - auto status = oneapi::mkl::blas::column_major::gbmv(device_queue->val, convert(trans), m, n, kl, ku, reinterpret_cast*>(alpha), reinterpret_cast*>(a), lda, reinterpret_cast*>(x), incx, reinterpret_cast*>(beta), reinterpret_cast*>(y), incy, {}); + auto status = oneapi::mkl::blas::column_major::gbmv(device_queue->val, convert(trans), m, n, kl, ku, *reinterpret_cast*>(alpha), reinterpret_cast*>(a), lda, reinterpret_cast*>(x), incx, *reinterpret_cast*>(beta), reinterpret_cast*>(y), incy, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklSger(syclQueue_t device_queue, int64_t m, int64_t n, float *alpha, float *x, int64_t incx, float *y, int64_t incy, float *a, int64_t lda) { - auto status = oneapi::mkl::blas::column_major::ger(device_queue->val, m, n, alpha, x, incx, y, incy, a, lda, {}); + auto status = oneapi::mkl::blas::column_major::ger(device_queue->val, m, n, *alpha, x, incx, y, incy, a, lda, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklDger(syclQueue_t device_queue, int64_t m, int64_t n, double *alpha, double *x, int64_t incx, double *y, int64_t incy, double *a, int64_t lda) { - auto status = oneapi::mkl::blas::column_major::ger(device_queue->val, m, n, alpha, x, incx, y, incy, a, lda, {}); + auto status = oneapi::mkl::blas::column_major::ger(device_queue->val, m, n, *alpha, x, incx, y, incy, a, lda, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklCgerc(syclQueue_t device_queue, int64_t m, int64_t n, float _Complex *alpha, float _Complex *x, int64_t incx, float _Complex *y, int64_t incy, float _Complex *a, int64_t lda) { - auto status = oneapi::mkl::blas::column_major::gerc(device_queue->val, m, n, reinterpret_cast*>(alpha), reinterpret_cast*>(x), incx, reinterpret_cast*>(y), incy, reinterpret_cast*>(a), lda, {}); + auto status = oneapi::mkl::blas::column_major::gerc(device_queue->val, m, n, *reinterpret_cast*>(alpha), reinterpret_cast*>(x), incx, reinterpret_cast*>(y), incy, reinterpret_cast*>(a), lda, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklZgerc(syclQueue_t device_queue, int64_t m, int64_t n, double _Complex *alpha, double _Complex *x, int64_t incx, double _Complex *y, int64_t incy, double _Complex *a, int64_t lda) { - auto status = oneapi::mkl::blas::column_major::gerc(device_queue->val, m, n, reinterpret_cast*>(alpha), reinterpret_cast*>(x), incx, reinterpret_cast*>(y), incy, reinterpret_cast*>(a), lda, {}); + auto status = oneapi::mkl::blas::column_major::gerc(device_queue->val, m, n, *reinterpret_cast*>(alpha), reinterpret_cast*>(x), incx, reinterpret_cast*>(y), incy, reinterpret_cast*>(a), lda, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklCgeru(syclQueue_t device_queue, int64_t m, int64_t n, float _Complex *alpha, float _Complex *x, int64_t incx, float _Complex *y, int64_t incy, float _Complex *a, int64_t lda) { - auto status = oneapi::mkl::blas::column_major::geru(device_queue->val, m, n, reinterpret_cast*>(alpha), reinterpret_cast*>(x), incx, reinterpret_cast*>(y), incy, reinterpret_cast*>(a), lda, {}); + auto status = oneapi::mkl::blas::column_major::geru(device_queue->val, m, n, *reinterpret_cast*>(alpha), reinterpret_cast*>(x), incx, reinterpret_cast*>(y), incy, reinterpret_cast*>(a), lda, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklZgeru(syclQueue_t device_queue, int64_t m, int64_t n, double _Complex *alpha, double _Complex *x, int64_t incx, double _Complex *y, int64_t incy, double _Complex *a, int64_t lda) { - auto status = oneapi::mkl::blas::column_major::geru(device_queue->val, m, n, reinterpret_cast*>(alpha), reinterpret_cast*>(x), incx, reinterpret_cast*>(y), incy, reinterpret_cast*>(a), lda, {}); + auto status = oneapi::mkl::blas::column_major::geru(device_queue->val, m, n, *reinterpret_cast*>(alpha), reinterpret_cast*>(x), incx, reinterpret_cast*>(y), incy, reinterpret_cast*>(a), lda, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklChbmv(syclQueue_t device_queue, onemklUplo upper_lower, int64_t n, int64_t k, float _Complex *alpha, float _Complex *a, int64_t lda, float _Complex *x, int64_t incx, float _Complex *beta, float _Complex *y, int64_t incy) { - auto status = oneapi::mkl::blas::column_major::hbmv(device_queue->val, convert(upper_lower), n, k, reinterpret_cast*>(alpha), reinterpret_cast*>(a), lda, reinterpret_cast*>(x), incx, reinterpret_cast*>(beta), reinterpret_cast*>(y), incy, {}); + auto status = oneapi::mkl::blas::column_major::hbmv(device_queue->val, convert(upper_lower), n, k, *reinterpret_cast*>(alpha), reinterpret_cast*>(a), lda, reinterpret_cast*>(x), incx, *reinterpret_cast*>(beta), reinterpret_cast*>(y), incy, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklZhbmv(syclQueue_t device_queue, onemklUplo upper_lower, int64_t n, int64_t k, double _Complex *alpha, double _Complex *a, int64_t lda, double _Complex *x, int64_t incx, double _Complex *beta, double _Complex *y, int64_t incy) { - auto status = oneapi::mkl::blas::column_major::hbmv(device_queue->val, convert(upper_lower), n, k, reinterpret_cast*>(alpha), reinterpret_cast*>(a), lda, reinterpret_cast*>(x), incx, reinterpret_cast*>(beta), reinterpret_cast*>(y), incy, {}); + auto status = oneapi::mkl::blas::column_major::hbmv(device_queue->val, convert(upper_lower), n, k, *reinterpret_cast*>(alpha), reinterpret_cast*>(a), lda, reinterpret_cast*>(x), incx, *reinterpret_cast*>(beta), reinterpret_cast*>(y), incy, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklChemv(syclQueue_t device_queue, onemklUplo upper_lower, int64_t n, float _Complex *alpha, float _Complex *a, int64_t lda, float _Complex *x, int64_t incx, float _Complex *beta, float _Complex *y, int64_t incy) { - auto status = oneapi::mkl::blas::column_major::hemv(device_queue->val, convert(upper_lower), n, reinterpret_cast*>(alpha), reinterpret_cast*>(a), lda, reinterpret_cast*>(x), incx, reinterpret_cast*>(beta), reinterpret_cast*>(y), incy, {}); + auto status = oneapi::mkl::blas::column_major::hemv(device_queue->val, convert(upper_lower), n, *reinterpret_cast*>(alpha), reinterpret_cast*>(a), lda, reinterpret_cast*>(x), incx, *reinterpret_cast*>(beta), reinterpret_cast*>(y), incy, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklZhemv(syclQueue_t device_queue, onemklUplo upper_lower, int64_t n, double _Complex *alpha, double _Complex *a, int64_t lda, double _Complex *x, int64_t incx, double _Complex *beta, double _Complex *y, int64_t incy) { - auto status = oneapi::mkl::blas::column_major::hemv(device_queue->val, convert(upper_lower), n, reinterpret_cast*>(alpha), reinterpret_cast*>(a), lda, reinterpret_cast*>(x), incx, reinterpret_cast*>(beta), reinterpret_cast*>(y), incy, {}); + auto status = oneapi::mkl::blas::column_major::hemv(device_queue->val, convert(upper_lower), n, *reinterpret_cast*>(alpha), reinterpret_cast*>(a), lda, reinterpret_cast*>(x), incx, *reinterpret_cast*>(beta), reinterpret_cast*>(y), incy, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklCher(syclQueue_t device_queue, onemklUplo upper_lower, int64_t n, float *alpha, float _Complex *x, int64_t incx, float _Complex *a, int64_t lda) { - auto status = oneapi::mkl::blas::column_major::her(device_queue->val, convert(upper_lower), n, alpha, reinterpret_cast*>(x), incx, reinterpret_cast*>(a), lda, {}); + auto status = oneapi::mkl::blas::column_major::her(device_queue->val, convert(upper_lower), n, *alpha, reinterpret_cast*>(x), incx, reinterpret_cast*>(a), lda, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklZher(syclQueue_t device_queue, onemklUplo upper_lower, int64_t n, double *alpha, double _Complex *x, int64_t incx, double _Complex *a, int64_t lda) { - auto status = oneapi::mkl::blas::column_major::her(device_queue->val, convert(upper_lower), n, alpha, reinterpret_cast*>(x), incx, reinterpret_cast*>(a), lda, {}); + auto status = oneapi::mkl::blas::column_major::her(device_queue->val, convert(upper_lower), n, *alpha, reinterpret_cast*>(x), incx, reinterpret_cast*>(a), lda, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklCher2(syclQueue_t device_queue, onemklUplo upper_lower, int64_t n, float _Complex *alpha, float _Complex *x, int64_t incx, float _Complex *y, int64_t incy, float _Complex *a, int64_t lda) { - auto status = oneapi::mkl::blas::column_major::her2(device_queue->val, convert(upper_lower), n, reinterpret_cast*>(alpha), reinterpret_cast*>(x), incx, reinterpret_cast*>(y), incy, reinterpret_cast*>(a), lda, {}); + auto status = oneapi::mkl::blas::column_major::her2(device_queue->val, convert(upper_lower), n, *reinterpret_cast*>(alpha), reinterpret_cast*>(x), incx, reinterpret_cast*>(y), incy, reinterpret_cast*>(a), lda, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklZher2(syclQueue_t device_queue, onemklUplo upper_lower, int64_t n, double _Complex *alpha, double _Complex *x, int64_t incx, double _Complex *y, int64_t incy, double _Complex *a, int64_t lda) { - auto status = oneapi::mkl::blas::column_major::her2(device_queue->val, convert(upper_lower), n, reinterpret_cast*>(alpha), reinterpret_cast*>(x), incx, reinterpret_cast*>(y), incy, reinterpret_cast*>(a), lda, {}); + auto status = oneapi::mkl::blas::column_major::her2(device_queue->val, convert(upper_lower), n, *reinterpret_cast*>(alpha), reinterpret_cast*>(x), incx, reinterpret_cast*>(y), incy, reinterpret_cast*>(a), lda, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklChpmv(syclQueue_t device_queue, onemklUplo upper_lower, int64_t n, float _Complex *alpha, float _Complex *a, float _Complex *x, int64_t incx, float _Complex *beta, float _Complex *y, int64_t incy) { - auto status = oneapi::mkl::blas::column_major::hpmv(device_queue->val, convert(upper_lower), n, reinterpret_cast*>(alpha), reinterpret_cast*>(a), reinterpret_cast*>(x), incx, reinterpret_cast*>(beta), reinterpret_cast*>(y), incy, {}); + auto status = oneapi::mkl::blas::column_major::hpmv(device_queue->val, convert(upper_lower), n, *reinterpret_cast*>(alpha), reinterpret_cast*>(a), reinterpret_cast*>(x), incx, *reinterpret_cast*>(beta), reinterpret_cast*>(y), incy, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklZhpmv(syclQueue_t device_queue, onemklUplo upper_lower, int64_t n, double _Complex *alpha, double _Complex *a, double _Complex *x, int64_t incx, double _Complex *beta, double _Complex *y, int64_t incy) { - auto status = oneapi::mkl::blas::column_major::hpmv(device_queue->val, convert(upper_lower), n, reinterpret_cast*>(alpha), reinterpret_cast*>(a), reinterpret_cast*>(x), incx, reinterpret_cast*>(beta), reinterpret_cast*>(y), incy, {}); + auto status = oneapi::mkl::blas::column_major::hpmv(device_queue->val, convert(upper_lower), n, *reinterpret_cast*>(alpha), reinterpret_cast*>(a), reinterpret_cast*>(x), incx, *reinterpret_cast*>(beta), reinterpret_cast*>(y), incy, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklChpr(syclQueue_t device_queue, onemklUplo upper_lower, int64_t n, float *alpha, float _Complex *x, int64_t incx, float _Complex *a) { - auto status = oneapi::mkl::blas::column_major::hpr(device_queue->val, convert(upper_lower), n, alpha, reinterpret_cast*>(x), incx, reinterpret_cast*>(a), {}); + auto status = oneapi::mkl::blas::column_major::hpr(device_queue->val, convert(upper_lower), n, *alpha, reinterpret_cast*>(x), incx, reinterpret_cast*>(a), {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklZhpr(syclQueue_t device_queue, onemklUplo upper_lower, int64_t n, double *alpha, double _Complex *x, int64_t incx, double _Complex *a) { - auto status = oneapi::mkl::blas::column_major::hpr(device_queue->val, convert(upper_lower), n, alpha, reinterpret_cast*>(x), incx, reinterpret_cast*>(a), {}); + auto status = oneapi::mkl::blas::column_major::hpr(device_queue->val, convert(upper_lower), n, *alpha, reinterpret_cast*>(x), incx, reinterpret_cast*>(a), {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklChpr2(syclQueue_t device_queue, onemklUplo upper_lower, int64_t n, float _Complex *alpha, float _Complex *x, int64_t incx, float _Complex *y, int64_t incy, float _Complex *a) { - auto status = oneapi::mkl::blas::column_major::hpr2(device_queue->val, convert(upper_lower), n, reinterpret_cast*>(alpha), reinterpret_cast*>(x), incx, reinterpret_cast*>(y), incy, reinterpret_cast*>(a), {}); + auto status = oneapi::mkl::blas::column_major::hpr2(device_queue->val, convert(upper_lower), n, *reinterpret_cast*>(alpha), reinterpret_cast*>(x), incx, reinterpret_cast*>(y), incy, reinterpret_cast*>(a), {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklZhpr2(syclQueue_t device_queue, onemklUplo upper_lower, int64_t n, double _Complex *alpha, double _Complex *x, int64_t incx, double _Complex *y, int64_t incy, double _Complex *a) { - auto status = oneapi::mkl::blas::column_major::hpr2(device_queue->val, convert(upper_lower), n, reinterpret_cast*>(alpha), reinterpret_cast*>(x), incx, reinterpret_cast*>(y), incy, reinterpret_cast*>(a), {}); + auto status = oneapi::mkl::blas::column_major::hpr2(device_queue->val, convert(upper_lower), n, *reinterpret_cast*>(alpha), reinterpret_cast*>(x), incx, reinterpret_cast*>(y), incy, reinterpret_cast*>(a), {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklSsbmv(syclQueue_t device_queue, onemklUplo upper_lower, int64_t n, int64_t k, float *alpha, float *a, int64_t lda, float *x, int64_t incx, float *beta, float *y, int64_t incy) { - auto status = oneapi::mkl::blas::column_major::sbmv(device_queue->val, convert(upper_lower), n, k, alpha, a, lda, x, incx, beta, y, incy, {}); + auto status = oneapi::mkl::blas::column_major::sbmv(device_queue->val, convert(upper_lower), n, k, *alpha, a, lda, x, incx, *beta, y, incy, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklDsbmv(syclQueue_t device_queue, onemklUplo upper_lower, int64_t n, int64_t k, double *alpha, double *a, int64_t lda, double *x, int64_t incx, double *beta, double *y, int64_t incy) { - auto status = oneapi::mkl::blas::column_major::sbmv(device_queue->val, convert(upper_lower), n, k, alpha, a, lda, x, incx, beta, y, incy, {}); + auto status = oneapi::mkl::blas::column_major::sbmv(device_queue->val, convert(upper_lower), n, k, *alpha, a, lda, x, incx, *beta, y, incy, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklSsymv(syclQueue_t device_queue, onemklUplo upper_lower, int64_t n, float *alpha, float *a, int64_t lda, float *x, int64_t incx, float *beta, float *y, int64_t incy) { - auto status = oneapi::mkl::blas::column_major::symv(device_queue->val, convert(upper_lower), n, alpha, a, lda, x, incx, beta, y, incy, {}); + auto status = oneapi::mkl::blas::column_major::symv(device_queue->val, convert(upper_lower), n, *alpha, a, lda, x, incx, *beta, y, incy, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklDsymv(syclQueue_t device_queue, onemklUplo upper_lower, int64_t n, double *alpha, double *a, int64_t lda, double *x, int64_t incx, double *beta, double *y, int64_t incy) { - auto status = oneapi::mkl::blas::column_major::symv(device_queue->val, convert(upper_lower), n, alpha, a, lda, x, incx, beta, y, incy, {}); + auto status = oneapi::mkl::blas::column_major::symv(device_queue->val, convert(upper_lower), n, *alpha, a, lda, x, incx, *beta, y, incy, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklCsymv(syclQueue_t device_queue, onemklUplo upper_lower, int64_t n, float _Complex *alpha, float _Complex *a, int64_t lda, float _Complex *x, int64_t incx, float _Complex *beta, float _Complex *y, int64_t incy) { - auto status = oneapi::mkl::blas::column_major::symv(device_queue->val, convert(upper_lower), n, reinterpret_cast*>(alpha), reinterpret_cast*>(a), lda, reinterpret_cast*>(x), incx, reinterpret_cast*>(beta), reinterpret_cast*>(y), incy, {}); + auto status = oneapi::mkl::blas::column_major::symv(device_queue->val, convert(upper_lower), n, *reinterpret_cast*>(alpha), reinterpret_cast*>(a), lda, reinterpret_cast*>(x), incx, *reinterpret_cast*>(beta), reinterpret_cast*>(y), incy, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklZsymv(syclQueue_t device_queue, onemklUplo upper_lower, int64_t n, double _Complex *alpha, double _Complex *a, int64_t lda, double _Complex *x, int64_t incx, double _Complex *beta, double _Complex *y, int64_t incy) { - auto status = oneapi::mkl::blas::column_major::symv(device_queue->val, convert(upper_lower), n, reinterpret_cast*>(alpha), reinterpret_cast*>(a), lda, reinterpret_cast*>(x), incx, reinterpret_cast*>(beta), reinterpret_cast*>(y), incy, {}); + auto status = oneapi::mkl::blas::column_major::symv(device_queue->val, convert(upper_lower), n, *reinterpret_cast*>(alpha), reinterpret_cast*>(a), lda, reinterpret_cast*>(x), incx, *reinterpret_cast*>(beta), reinterpret_cast*>(y), incy, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklSsyr(syclQueue_t device_queue, onemklUplo upper_lower, int64_t n, float *alpha, float *x, int64_t incx, float *a, int64_t lda) { - auto status = oneapi::mkl::blas::column_major::syr(device_queue->val, convert(upper_lower), n, alpha, x, incx, a, lda, {}); + auto status = oneapi::mkl::blas::column_major::syr(device_queue->val, convert(upper_lower), n, *alpha, x, incx, a, lda, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklDsyr(syclQueue_t device_queue, onemklUplo upper_lower, int64_t n, double *alpha, double *x, int64_t incx, double *a, int64_t lda) { - auto status = oneapi::mkl::blas::column_major::syr(device_queue->val, convert(upper_lower), n, alpha, x, incx, a, lda, {}); + auto status = oneapi::mkl::blas::column_major::syr(device_queue->val, convert(upper_lower), n, *alpha, x, incx, a, lda, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklCsyr(syclQueue_t device_queue, onemklUplo upper_lower, int64_t n, float _Complex *alpha, float _Complex *x, int64_t incx, float _Complex *a, int64_t lda) { - auto status = oneapi::mkl::blas::column_major::syr(device_queue->val, convert(upper_lower), n, reinterpret_cast*>(alpha), reinterpret_cast*>(x), incx, reinterpret_cast*>(a), lda, {}); + auto status = oneapi::mkl::blas::column_major::syr(device_queue->val, convert(upper_lower), n, *reinterpret_cast*>(alpha), reinterpret_cast*>(x), incx, reinterpret_cast*>(a), lda, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklZsyr(syclQueue_t device_queue, onemklUplo upper_lower, int64_t n, double _Complex *alpha, double _Complex *x, int64_t incx, double _Complex *a, int64_t lda) { - auto status = oneapi::mkl::blas::column_major::syr(device_queue->val, convert(upper_lower), n, reinterpret_cast*>(alpha), reinterpret_cast*>(x), incx, reinterpret_cast*>(a), lda, {}); + auto status = oneapi::mkl::blas::column_major::syr(device_queue->val, convert(upper_lower), n, *reinterpret_cast*>(alpha), reinterpret_cast*>(x), incx, reinterpret_cast*>(a), lda, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklSsyr2(syclQueue_t device_queue, onemklUplo upper_lower, int64_t n, float *alpha, float *x, int64_t incx, float *y, int64_t incy, float *a, int64_t lda) { - auto status = oneapi::mkl::blas::column_major::syr2(device_queue->val, convert(upper_lower), n, alpha, x, incx, y, incy, a, lda, {}); + auto status = oneapi::mkl::blas::column_major::syr2(device_queue->val, convert(upper_lower), n, *alpha, x, incx, y, incy, a, lda, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklDsyr2(syclQueue_t device_queue, onemklUplo upper_lower, int64_t n, double *alpha, double *x, int64_t incx, double *y, int64_t incy, double *a, int64_t lda) { - auto status = oneapi::mkl::blas::column_major::syr2(device_queue->val, convert(upper_lower), n, alpha, x, incx, y, incy, a, lda, {}); + auto status = oneapi::mkl::blas::column_major::syr2(device_queue->val, convert(upper_lower), n, *alpha, x, incx, y, incy, a, lda, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklCsyr2(syclQueue_t device_queue, onemklUplo upper_lower, int64_t n, float _Complex *alpha, float _Complex *x, int64_t incx, float _Complex *y, int64_t incy, float _Complex *a, int64_t lda) { - auto status = oneapi::mkl::blas::column_major::syr2(device_queue->val, convert(upper_lower), n, reinterpret_cast*>(alpha), reinterpret_cast*>(x), incx, reinterpret_cast*>(y), incy, reinterpret_cast*>(a), lda, {}); + auto status = oneapi::mkl::blas::column_major::syr2(device_queue->val, convert(upper_lower), n, *reinterpret_cast*>(alpha), reinterpret_cast*>(x), incx, reinterpret_cast*>(y), incy, reinterpret_cast*>(a), lda, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklZsyr2(syclQueue_t device_queue, onemklUplo upper_lower, int64_t n, double _Complex *alpha, double _Complex *x, int64_t incx, double _Complex *y, int64_t incy, double _Complex *a, int64_t lda) { - auto status = oneapi::mkl::blas::column_major::syr2(device_queue->val, convert(upper_lower), n, reinterpret_cast*>(alpha), reinterpret_cast*>(x), incx, reinterpret_cast*>(y), incy, reinterpret_cast*>(a), lda, {}); + auto status = oneapi::mkl::blas::column_major::syr2(device_queue->val, convert(upper_lower), n, *reinterpret_cast*>(alpha), reinterpret_cast*>(x), incx, reinterpret_cast*>(y), incy, reinterpret_cast*>(a), lda, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklSspmv(syclQueue_t device_queue, onemklUplo upper_lower, int64_t n, float *alpha, float *a, float *x, int64_t incx, float *beta, float *y, int64_t incy) { - auto status = oneapi::mkl::blas::column_major::spmv(device_queue->val, convert(upper_lower), n, alpha, a, x, incx, beta, y, incy, {}); + auto status = oneapi::mkl::blas::column_major::spmv(device_queue->val, convert(upper_lower), n, *alpha, a, x, incx, *beta, y, incy, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklDspmv(syclQueue_t device_queue, onemklUplo upper_lower, int64_t n, double *alpha, double *a, double *x, int64_t incx, double *beta, double *y, int64_t incy) { - auto status = oneapi::mkl::blas::column_major::spmv(device_queue->val, convert(upper_lower), n, alpha, a, x, incx, beta, y, incy, {}); + auto status = oneapi::mkl::blas::column_major::spmv(device_queue->val, convert(upper_lower), n, *alpha, a, x, incx, *beta, y, incy, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklSspr(syclQueue_t device_queue, onemklUplo upper_lower, int64_t n, float *alpha, float *x, int64_t incx, float *a) { - auto status = oneapi::mkl::blas::column_major::spr(device_queue->val, convert(upper_lower), n, alpha, x, incx, a, {}); + auto status = oneapi::mkl::blas::column_major::spr(device_queue->val, convert(upper_lower), n, *alpha, x, incx, a, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklDspr(syclQueue_t device_queue, onemklUplo upper_lower, int64_t n, double *alpha, double *x, int64_t incx, double *a) { - auto status = oneapi::mkl::blas::column_major::spr(device_queue->val, convert(upper_lower), n, alpha, x, incx, a, {}); + auto status = oneapi::mkl::blas::column_major::spr(device_queue->val, convert(upper_lower), n, *alpha, x, incx, a, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklSspr2(syclQueue_t device_queue, onemklUplo upper_lower, int64_t n, float *alpha, float *x, int64_t incx, float *y, int64_t incy, float *a) { - auto status = oneapi::mkl::blas::column_major::spr2(device_queue->val, convert(upper_lower), n, alpha, x, incx, y, incy, a, {}); + auto status = oneapi::mkl::blas::column_major::spr2(device_queue->val, convert(upper_lower), n, *alpha, x, incx, y, incy, a, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklDspr2(syclQueue_t device_queue, onemklUplo upper_lower, int64_t n, double *alpha, double *x, int64_t incx, double *y, int64_t incy, double *a) { - auto status = oneapi::mkl::blas::column_major::spr2(device_queue->val, convert(upper_lower), n, alpha, x, incx, y, incy, a, {}); + auto status = oneapi::mkl::blas::column_major::spr2(device_queue->val, convert(upper_lower), n, *alpha, x, incx, y, incy, a, {}); __FORCE_MKL_FLUSH__(status); return 0; } @@ -1291,55 +1291,55 @@ extern "C" int onemklZasum(syclQueue_t device_queue, int64_t n, double _Complex } extern "C" int onemklHaxpy(syclQueue_t device_queue, int64_t n, short *alpha, short *x, int64_t incx, short *y, int64_t incy) { - auto status = oneapi::mkl::blas::column_major::axpy(device_queue->val, n, reinterpret_cast(alpha), reinterpret_cast(x), incx, reinterpret_cast(y), incy, {}); + auto status = oneapi::mkl::blas::column_major::axpy(device_queue->val, n, *reinterpret_cast(alpha), reinterpret_cast(x), incx, reinterpret_cast(y), incy, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklSaxpy(syclQueue_t device_queue, int64_t n, float *alpha, float *x, int64_t incx, float *y, int64_t incy) { - auto status = oneapi::mkl::blas::column_major::axpy(device_queue->val, n, alpha, x, incx, y, incy, {}); + auto status = oneapi::mkl::blas::column_major::axpy(device_queue->val, n, *alpha, x, incx, y, incy, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklDaxpy(syclQueue_t device_queue, int64_t n, double *alpha, double *x, int64_t incx, double *y, int64_t incy) { - auto status = oneapi::mkl::blas::column_major::axpy(device_queue->val, n, alpha, x, incx, y, incy, {}); + auto status = oneapi::mkl::blas::column_major::axpy(device_queue->val, n, *alpha, x, incx, y, incy, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklCaxpy(syclQueue_t device_queue, int64_t n, float _Complex *alpha, float _Complex *x, int64_t incx, float _Complex *y, int64_t incy) { - auto status = oneapi::mkl::blas::column_major::axpy(device_queue->val, n, reinterpret_cast*>(alpha), reinterpret_cast*>(x), incx, reinterpret_cast*>(y), incy, {}); + auto status = oneapi::mkl::blas::column_major::axpy(device_queue->val, n, *reinterpret_cast*>(alpha), reinterpret_cast*>(x), incx, reinterpret_cast*>(y), incy, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklZaxpy(syclQueue_t device_queue, int64_t n, double _Complex *alpha, double _Complex *x, int64_t incx, double _Complex *y, int64_t incy) { - auto status = oneapi::mkl::blas::column_major::axpy(device_queue->val, n, reinterpret_cast*>(alpha), reinterpret_cast*>(x), incx, reinterpret_cast*>(y), incy, {}); + auto status = oneapi::mkl::blas::column_major::axpy(device_queue->val, n, *reinterpret_cast*>(alpha), reinterpret_cast*>(x), incx, reinterpret_cast*>(y), incy, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklSaxpby(syclQueue_t device_queue, int64_t n, float *alpha, float *x, int64_t incx, float *beta, float *y, int64_t incy) { - auto status = oneapi::mkl::blas::column_major::axpby(device_queue->val, n, alpha, x, incx, beta, y, incy, {}); + auto status = oneapi::mkl::blas::column_major::axpby(device_queue->val, n, *alpha, x, incx, *beta, y, incy, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklDaxpby(syclQueue_t device_queue, int64_t n, double *alpha, double *x, int64_t incx, double *beta, double *y, int64_t incy) { - auto status = oneapi::mkl::blas::column_major::axpby(device_queue->val, n, alpha, x, incx, beta, y, incy, {}); + auto status = oneapi::mkl::blas::column_major::axpby(device_queue->val, n, *alpha, x, incx, *beta, y, incy, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklCaxpby(syclQueue_t device_queue, int64_t n, float _Complex *alpha, float _Complex *x, int64_t incx, float _Complex *beta, float _Complex *y, int64_t incy) { - auto status = oneapi::mkl::blas::column_major::axpby(device_queue->val, n, reinterpret_cast*>(alpha), reinterpret_cast*>(x), incx, reinterpret_cast*>(beta), reinterpret_cast*>(y), incy, {}); + auto status = oneapi::mkl::blas::column_major::axpby(device_queue->val, n, *reinterpret_cast*>(alpha), reinterpret_cast*>(x), incx, *reinterpret_cast*>(beta), reinterpret_cast*>(y), incy, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklZaxpby(syclQueue_t device_queue, int64_t n, double _Complex *alpha, double _Complex *x, int64_t incx, double _Complex *beta, double _Complex *y, int64_t incy) { - auto status = oneapi::mkl::blas::column_major::axpby(device_queue->val, n, reinterpret_cast*>(alpha), reinterpret_cast*>(x), incx, reinterpret_cast*>(beta), reinterpret_cast*>(y), incy, {}); + auto status = oneapi::mkl::blas::column_major::axpby(device_queue->val, n, *reinterpret_cast*>(alpha), reinterpret_cast*>(x), incx, *reinterpret_cast*>(beta), reinterpret_cast*>(y), incy, {}); __FORCE_MKL_FLUSH__(status); return 0; } @@ -1386,8 +1386,8 @@ extern "C" int onemklDdot(syclQueue_t device_queue, int64_t n, double *x, int64_ return 0; } -extern "C" int onemklSsdsdot(syclQueue_t device_queue, int64_t n, float sb, float *x, int64_t incx, float *y, int64_t incy, float *result) { - auto status = oneapi::mkl::blas::column_major::sdsdot(device_queue->val, n, sb, x, incx, y, incy, result, {}); +extern "C" int onemklSsdsdot(syclQueue_t device_queue, int64_t n, float *sb, float *x, int64_t incx, float *y, int64_t incy, float *result) { + auto status = oneapi::mkl::blas::column_major::sdsdot(device_queue->val, n, *sb, x, incx, y, incy, result, {}); __FORCE_MKL_FLUSH__(status); return 0; } @@ -1423,43 +1423,43 @@ extern "C" int onemklZnrm2(syclQueue_t device_queue, int64_t n, double _Complex } extern "C" int onemklHrot(syclQueue_t device_queue, int64_t n, short *x, int64_t incx, short *y, int64_t incy, short *c, short *s) { - auto status = oneapi::mkl::blas::column_major::rot(device_queue->val, n, reinterpret_cast(x), incx, reinterpret_cast(y), incy, reinterpret_cast(c), reinterpret_cast(s), {}); + auto status = oneapi::mkl::blas::column_major::rot(device_queue->val, n, reinterpret_cast(x), incx, reinterpret_cast(y), incy, *reinterpret_cast(c), *reinterpret_cast(s), {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklSrot(syclQueue_t device_queue, int64_t n, float *x, int64_t incx, float *y, int64_t incy, float *c, float *s) { - auto status = oneapi::mkl::blas::column_major::rot(device_queue->val, n, x, incx, y, incy, c, s, {}); + auto status = oneapi::mkl::blas::column_major::rot(device_queue->val, n, x, incx, y, incy, *c, *s, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklDrot(syclQueue_t device_queue, int64_t n, double *x, int64_t incx, double *y, int64_t incy, double *c, double *s) { - auto status = oneapi::mkl::blas::column_major::rot(device_queue->val, n, x, incx, y, incy, c, s, {}); + auto status = oneapi::mkl::blas::column_major::rot(device_queue->val, n, x, incx, y, incy, *c, *s, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklCSrot(syclQueue_t device_queue, int64_t n, float _Complex *x, int64_t incx, float _Complex *y, int64_t incy, float *c, float *s) { - auto status = oneapi::mkl::blas::column_major::rot(device_queue->val, n, reinterpret_cast*>(x), incx, reinterpret_cast*>(y), incy, c, s, {}); + auto status = oneapi::mkl::blas::column_major::rot(device_queue->val, n, reinterpret_cast*>(x), incx, reinterpret_cast*>(y), incy, *c, *s, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklCrot(syclQueue_t device_queue, int64_t n, float _Complex *x, int64_t incx, float _Complex *y, int64_t incy, float *c, float _Complex *s) { - auto status = oneapi::mkl::blas::column_major::rot(device_queue->val, n, reinterpret_cast*>(x), incx, reinterpret_cast*>(y), incy, c, reinterpret_cast*>(s), {}); + auto status = oneapi::mkl::blas::column_major::rot(device_queue->val, n, reinterpret_cast*>(x), incx, reinterpret_cast*>(y), incy, *c, *reinterpret_cast*>(s), {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklZDrot(syclQueue_t device_queue, int64_t n, double _Complex *x, int64_t incx, double _Complex *y, int64_t incy, double *c, double *s) { - auto status = oneapi::mkl::blas::column_major::rot(device_queue->val, n, reinterpret_cast*>(x), incx, reinterpret_cast*>(y), incy, c, s, {}); + auto status = oneapi::mkl::blas::column_major::rot(device_queue->val, n, reinterpret_cast*>(x), incx, reinterpret_cast*>(y), incy, *c, *s, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklZrot(syclQueue_t device_queue, int64_t n, double _Complex *x, int64_t incx, double _Complex *y, int64_t incy, double *c, double _Complex *s) { - auto status = oneapi::mkl::blas::column_major::rot(device_queue->val, n, reinterpret_cast*>(x), incx, reinterpret_cast*>(y), incy, c, reinterpret_cast*>(s), {}); + auto status = oneapi::mkl::blas::column_major::rot(device_queue->val, n, reinterpret_cast*>(x), incx, reinterpret_cast*>(y), incy, *c, *reinterpret_cast*>(s), {}); __FORCE_MKL_FLUSH__(status); return 0; } @@ -1500,56 +1500,56 @@ extern "C" int onemklDrotm(syclQueue_t device_queue, int64_t n, double *x, int64 return 0; } -extern "C" int onemklSrotmg(syclQueue_t device_queue, float *d1, float *d2, float *x1, float *y, float *param) { - auto status = oneapi::mkl::blas::column_major::rotmg(device_queue->val, d1, d2, x1, y, param, {}); +extern "C" int onemklSrotmg(syclQueue_t device_queue, float *d1, float *d2, float *x1, float *y1, float *param) { + auto status = oneapi::mkl::blas::column_major::rotmg(device_queue->val, d1, d2, x1, *y1, param, {}); __FORCE_MKL_FLUSH__(status); return 0; } -extern "C" int onemklDrotmg(syclQueue_t device_queue, double *d1, double *d2, double *x1, double *y, double *param) { - auto status = oneapi::mkl::blas::column_major::rotmg(device_queue->val, d1, d2, x1, y, param, {}); +extern "C" int onemklDrotmg(syclQueue_t device_queue, double *d1, double *d2, double *x1, double *y1, double *param) { + auto status = oneapi::mkl::blas::column_major::rotmg(device_queue->val, d1, d2, x1, *y1, param, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklHscal(syclQueue_t device_queue, int64_t n, short *alpha, short *x, int64_t incx) { - auto status = oneapi::mkl::blas::column_major::scal(device_queue->val, n, reinterpret_cast(alpha), reinterpret_cast(x), incx, {}); + auto status = oneapi::mkl::blas::column_major::scal(device_queue->val, n, *reinterpret_cast(alpha), reinterpret_cast(x), incx, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklSscal(syclQueue_t device_queue, int64_t n, float *alpha, float *x, int64_t incx) { - auto status = oneapi::mkl::blas::column_major::scal(device_queue->val, n, alpha, x, incx, {}); + auto status = oneapi::mkl::blas::column_major::scal(device_queue->val, n, *alpha, x, incx, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklDscal(syclQueue_t device_queue, int64_t n, double *alpha, double *x, int64_t incx) { - auto status = oneapi::mkl::blas::column_major::scal(device_queue->val, n, alpha, x, incx, {}); + auto status = oneapi::mkl::blas::column_major::scal(device_queue->val, n, *alpha, x, incx, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklCSscal(syclQueue_t device_queue, int64_t n, float *alpha, float _Complex *x, int64_t incx) { - auto status = oneapi::mkl::blas::column_major::scal(device_queue->val, n, alpha, reinterpret_cast*>(x), incx, {}); + auto status = oneapi::mkl::blas::column_major::scal(device_queue->val, n, *alpha, reinterpret_cast*>(x), incx, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklZDscal(syclQueue_t device_queue, int64_t n, double *alpha, double _Complex *x, int64_t incx) { - auto status = oneapi::mkl::blas::column_major::scal(device_queue->val, n, alpha, reinterpret_cast*>(x), incx, {}); + auto status = oneapi::mkl::blas::column_major::scal(device_queue->val, n, *alpha, reinterpret_cast*>(x), incx, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklCscal(syclQueue_t device_queue, int64_t n, float _Complex *alpha, float _Complex *x, int64_t incx) { - auto status = oneapi::mkl::blas::column_major::scal(device_queue->val, n, reinterpret_cast*>(alpha), reinterpret_cast*>(x), incx, {}); + auto status = oneapi::mkl::blas::column_major::scal(device_queue->val, n, *reinterpret_cast*>(alpha), reinterpret_cast*>(x), incx, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklZscal(syclQueue_t device_queue, int64_t n, double _Complex *alpha, double _Complex *x, int64_t incx) { - auto status = oneapi::mkl::blas::column_major::scal(device_queue->val, n, reinterpret_cast*>(alpha), reinterpret_cast*>(x), incx, {}); + auto status = oneapi::mkl::blas::column_major::scal(device_queue->val, n, *reinterpret_cast*>(alpha), reinterpret_cast*>(x), incx, {}); __FORCE_MKL_FLUSH__(status); return 0; } @@ -1579,103 +1579,103 @@ extern "C" int onemklZswap(syclQueue_t device_queue, int64_t n, double _Complex } extern "C" int onemklHgemm_batch_strided(syclQueue_t device_queue, onemklTranspose transa, onemklTranspose transb, int64_t m, int64_t n, int64_t k, short *alpha, short *a, int64_t lda, int64_t stride_a, short *b, int64_t ldb, int64_t stride_b, short *beta, short *c, int64_t ldc, int64_t stride_c, int64_t batch_size) { - auto status = oneapi::mkl::blas::column_major::gemm_batch(device_queue->val, convert(transa), convert(transb), m, n, k, reinterpret_cast(alpha), reinterpret_cast(a), lda, stride_a, reinterpret_cast(b), ldb, stride_b, reinterpret_cast(beta), reinterpret_cast(c), ldc, stride_c, batch_size, {}); + auto status = oneapi::mkl::blas::column_major::gemm_batch(device_queue->val, convert(transa), convert(transb), m, n, k, *reinterpret_cast(alpha), reinterpret_cast(a), lda, stride_a, reinterpret_cast(b), ldb, stride_b, *reinterpret_cast(beta), reinterpret_cast(c), ldc, stride_c, batch_size, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklSgemm_batch_strided(syclQueue_t device_queue, onemklTranspose transa, onemklTranspose transb, int64_t m, int64_t n, int64_t k, float *alpha, float *a, int64_t lda, int64_t stride_a, float *b, int64_t ldb, int64_t stride_b, float *beta, float *c, int64_t ldc, int64_t stride_c, int64_t batch_size) { - auto status = oneapi::mkl::blas::column_major::gemm_batch(device_queue->val, convert(transa), convert(transb), m, n, k, alpha, a, lda, stride_a, b, ldb, stride_b, beta, c, ldc, stride_c, batch_size, {}); + auto status = oneapi::mkl::blas::column_major::gemm_batch(device_queue->val, convert(transa), convert(transb), m, n, k, *alpha, a, lda, stride_a, b, ldb, stride_b, *beta, c, ldc, stride_c, batch_size, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklDgemm_batch_strided(syclQueue_t device_queue, onemklTranspose transa, onemklTranspose transb, int64_t m, int64_t n, int64_t k, double *alpha, double *a, int64_t lda, int64_t stride_a, double *b, int64_t ldb, int64_t stride_b, double *beta, double *c, int64_t ldc, int64_t stride_c, int64_t batch_size) { - auto status = oneapi::mkl::blas::column_major::gemm_batch(device_queue->val, convert(transa), convert(transb), m, n, k, alpha, a, lda, stride_a, b, ldb, stride_b, beta, c, ldc, stride_c, batch_size, {}); + auto status = oneapi::mkl::blas::column_major::gemm_batch(device_queue->val, convert(transa), convert(transb), m, n, k, *alpha, a, lda, stride_a, b, ldb, stride_b, *beta, c, ldc, stride_c, batch_size, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklCgemm_batch_strided(syclQueue_t device_queue, onemklTranspose transa, onemklTranspose transb, int64_t m, int64_t n, int64_t k, float _Complex *alpha, float _Complex *a, int64_t lda, int64_t stride_a, float _Complex *b, int64_t ldb, int64_t stride_b, float _Complex *beta, float _Complex *c, int64_t ldc, int64_t stride_c, int64_t batch_size) { - auto status = oneapi::mkl::blas::column_major::gemm_batch(device_queue->val, convert(transa), convert(transb), m, n, k, reinterpret_cast*>(alpha), reinterpret_cast*>(a), lda, stride_a, reinterpret_cast*>(b), ldb, stride_b, reinterpret_cast*>(beta), reinterpret_cast*>(c), ldc, stride_c, batch_size, {}); + auto status = oneapi::mkl::blas::column_major::gemm_batch(device_queue->val, convert(transa), convert(transb), m, n, k, *reinterpret_cast*>(alpha), reinterpret_cast*>(a), lda, stride_a, reinterpret_cast*>(b), ldb, stride_b, *reinterpret_cast*>(beta), reinterpret_cast*>(c), ldc, stride_c, batch_size, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklZgemm_batch_strided(syclQueue_t device_queue, onemklTranspose transa, onemklTranspose transb, int64_t m, int64_t n, int64_t k, double _Complex *alpha, double _Complex *a, int64_t lda, int64_t stride_a, double _Complex *b, int64_t ldb, int64_t stride_b, double _Complex *beta, double _Complex *c, int64_t ldc, int64_t stride_c, int64_t batch_size) { - auto status = oneapi::mkl::blas::column_major::gemm_batch(device_queue->val, convert(transa), convert(transb), m, n, k, reinterpret_cast*>(alpha), reinterpret_cast*>(a), lda, stride_a, reinterpret_cast*>(b), ldb, stride_b, reinterpret_cast*>(beta), reinterpret_cast*>(c), ldc, stride_c, batch_size, {}); + auto status = oneapi::mkl::blas::column_major::gemm_batch(device_queue->val, convert(transa), convert(transb), m, n, k, *reinterpret_cast*>(alpha), reinterpret_cast*>(a), lda, stride_a, reinterpret_cast*>(b), ldb, stride_b, *reinterpret_cast*>(beta), reinterpret_cast*>(c), ldc, stride_c, batch_size, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklSsyrk_batch_strided(syclQueue_t device_queue, onemklUplo upper_lower, onemklTranspose trans, int64_t n, int64_t k, float *alpha, float *a, int64_t lda, int64_t stride_a, float *beta, float *c, int64_t ldc, int64_t stride_c, int64_t batch_size) { - auto status = oneapi::mkl::blas::column_major::syrk_batch(device_queue->val, convert(upper_lower), convert(trans), n, k, alpha, a, lda, stride_a, beta, c, ldc, stride_c, batch_size, {}); + auto status = oneapi::mkl::blas::column_major::syrk_batch(device_queue->val, convert(upper_lower), convert(trans), n, k, *alpha, a, lda, stride_a, *beta, c, ldc, stride_c, batch_size, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklDsyrk_batch_strided(syclQueue_t device_queue, onemklUplo upper_lower, onemklTranspose trans, int64_t n, int64_t k, double *alpha, double *a, int64_t lda, int64_t stride_a, double *beta, double *c, int64_t ldc, int64_t stride_c, int64_t batch_size) { - auto status = oneapi::mkl::blas::column_major::syrk_batch(device_queue->val, convert(upper_lower), convert(trans), n, k, alpha, a, lda, stride_a, beta, c, ldc, stride_c, batch_size, {}); + auto status = oneapi::mkl::blas::column_major::syrk_batch(device_queue->val, convert(upper_lower), convert(trans), n, k, *alpha, a, lda, stride_a, *beta, c, ldc, stride_c, batch_size, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklCsyrk_batch_strided(syclQueue_t device_queue, onemklUplo upper_lower, onemklTranspose trans, int64_t n, int64_t k, float _Complex *alpha, float _Complex *a, int64_t lda, int64_t stride_a, float _Complex *beta, float _Complex *c, int64_t ldc, int64_t stride_c, int64_t batch_size) { - auto status = oneapi::mkl::blas::column_major::syrk_batch(device_queue->val, convert(upper_lower), convert(trans), n, k, reinterpret_cast*>(alpha), reinterpret_cast*>(a), lda, stride_a, reinterpret_cast*>(beta), reinterpret_cast*>(c), ldc, stride_c, batch_size, {}); + auto status = oneapi::mkl::blas::column_major::syrk_batch(device_queue->val, convert(upper_lower), convert(trans), n, k, *reinterpret_cast*>(alpha), reinterpret_cast*>(a), lda, stride_a, *reinterpret_cast*>(beta), reinterpret_cast*>(c), ldc, stride_c, batch_size, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklZsyrk_batch_strided(syclQueue_t device_queue, onemklUplo upper_lower, onemklTranspose trans, int64_t n, int64_t k, double _Complex *alpha, double _Complex *a, int64_t lda, int64_t stride_a, double _Complex *beta, double _Complex *c, int64_t ldc, int64_t stride_c, int64_t batch_size) { - auto status = oneapi::mkl::blas::column_major::syrk_batch(device_queue->val, convert(upper_lower), convert(trans), n, k, reinterpret_cast*>(alpha), reinterpret_cast*>(a), lda, stride_a, reinterpret_cast*>(beta), reinterpret_cast*>(c), ldc, stride_c, batch_size, {}); + auto status = oneapi::mkl::blas::column_major::syrk_batch(device_queue->val, convert(upper_lower), convert(trans), n, k, *reinterpret_cast*>(alpha), reinterpret_cast*>(a), lda, stride_a, *reinterpret_cast*>(beta), reinterpret_cast*>(c), ldc, stride_c, batch_size, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklStrsm_batch_strided(syclQueue_t device_queue, onemklSide left_right, onemklUplo upper_lower, onemklTranspose trans, onemklDiag unit_diag, int64_t m, int64_t n, float *alpha, float *a, int64_t lda, int64_t stride_a, float *b, int64_t ldb, int64_t stride_b, int64_t batch_size) { - auto status = oneapi::mkl::blas::column_major::trsm_batch(device_queue->val, convert(left_right), convert(upper_lower), convert(trans), convert(unit_diag), m, n, alpha, a, lda, stride_a, b, ldb, stride_b, batch_size, {}); + auto status = oneapi::mkl::blas::column_major::trsm_batch(device_queue->val, convert(left_right), convert(upper_lower), convert(trans), convert(unit_diag), m, n, *alpha, a, lda, stride_a, b, ldb, stride_b, batch_size, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklDtrsm_batch_strided(syclQueue_t device_queue, onemklSide left_right, onemklUplo upper_lower, onemklTranspose trans, onemklDiag unit_diag, int64_t m, int64_t n, double *alpha, double *a, int64_t lda, int64_t stride_a, double *b, int64_t ldb, int64_t stride_b, int64_t batch_size) { - auto status = oneapi::mkl::blas::column_major::trsm_batch(device_queue->val, convert(left_right), convert(upper_lower), convert(trans), convert(unit_diag), m, n, alpha, a, lda, stride_a, b, ldb, stride_b, batch_size, {}); + auto status = oneapi::mkl::blas::column_major::trsm_batch(device_queue->val, convert(left_right), convert(upper_lower), convert(trans), convert(unit_diag), m, n, *alpha, a, lda, stride_a, b, ldb, stride_b, batch_size, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklCtrsm_batch_strided(syclQueue_t device_queue, onemklSide left_right, onemklUplo upper_lower, onemklTranspose trans, onemklDiag unit_diag, int64_t m, int64_t n, float _Complex *alpha, float _Complex *a, int64_t lda, int64_t stride_a, float _Complex *b, int64_t ldb, int64_t stride_b, int64_t batch_size) { - auto status = oneapi::mkl::blas::column_major::trsm_batch(device_queue->val, convert(left_right), convert(upper_lower), convert(trans), convert(unit_diag), m, n, reinterpret_cast*>(alpha), reinterpret_cast*>(a), lda, stride_a, reinterpret_cast*>(b), ldb, stride_b, batch_size, {}); + auto status = oneapi::mkl::blas::column_major::trsm_batch(device_queue->val, convert(left_right), convert(upper_lower), convert(trans), convert(unit_diag), m, n, *reinterpret_cast*>(alpha), reinterpret_cast*>(a), lda, stride_a, reinterpret_cast*>(b), ldb, stride_b, batch_size, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklZtrsm_batch_strided(syclQueue_t device_queue, onemklSide left_right, onemklUplo upper_lower, onemklTranspose trans, onemklDiag unit_diag, int64_t m, int64_t n, double _Complex *alpha, double _Complex *a, int64_t lda, int64_t stride_a, double _Complex *b, int64_t ldb, int64_t stride_b, int64_t batch_size) { - auto status = oneapi::mkl::blas::column_major::trsm_batch(device_queue->val, convert(left_right), convert(upper_lower), convert(trans), convert(unit_diag), m, n, reinterpret_cast*>(alpha), reinterpret_cast*>(a), lda, stride_a, reinterpret_cast*>(b), ldb, stride_b, batch_size, {}); + auto status = oneapi::mkl::blas::column_major::trsm_batch(device_queue->val, convert(left_right), convert(upper_lower), convert(trans), convert(unit_diag), m, n, *reinterpret_cast*>(alpha), reinterpret_cast*>(a), lda, stride_a, reinterpret_cast*>(b), ldb, stride_b, batch_size, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklSgemv_batch_strided(syclQueue_t device_queue, onemklTranspose trans, int64_t m, int64_t n, float *alpha, float *a, int64_t lda, int64_t stridea, float *x, int64_t incx, int64_t stridex, float *beta, float *y, int64_t incy, int64_t stridey, int64_t batch_size) { - auto status = oneapi::mkl::blas::column_major::gemv_batch(device_queue->val, convert(trans), m, n, alpha, a, lda, stridea, x, incx, stridex, beta, y, incy, stridey, batch_size, {}); + auto status = oneapi::mkl::blas::column_major::gemv_batch(device_queue->val, convert(trans), m, n, *alpha, a, lda, stridea, x, incx, stridex, *beta, y, incy, stridey, batch_size, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklDgemv_batch_strided(syclQueue_t device_queue, onemklTranspose trans, int64_t m, int64_t n, double *alpha, double *a, int64_t lda, int64_t stridea, double *x, int64_t incx, int64_t stridex, double *beta, double *y, int64_t incy, int64_t stridey, int64_t batch_size) { - auto status = oneapi::mkl::blas::column_major::gemv_batch(device_queue->val, convert(trans), m, n, alpha, a, lda, stridea, x, incx, stridex, beta, y, incy, stridey, batch_size, {}); + auto status = oneapi::mkl::blas::column_major::gemv_batch(device_queue->val, convert(trans), m, n, *alpha, a, lda, stridea, x, incx, stridex, *beta, y, incy, stridey, batch_size, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklCgemv_batch_strided(syclQueue_t device_queue, onemklTranspose trans, int64_t m, int64_t n, float _Complex *alpha, float _Complex *a, int64_t lda, int64_t stridea, float _Complex *x, int64_t incx, int64_t stridex, float _Complex *beta, float _Complex *y, int64_t incy, int64_t stridey, int64_t batch_size) { - auto status = oneapi::mkl::blas::column_major::gemv_batch(device_queue->val, convert(trans), m, n, reinterpret_cast*>(alpha), reinterpret_cast*>(a), lda, stridea, reinterpret_cast*>(x), incx, stridex, reinterpret_cast*>(beta), reinterpret_cast*>(y), incy, stridey, batch_size, {}); + auto status = oneapi::mkl::blas::column_major::gemv_batch(device_queue->val, convert(trans), m, n, *reinterpret_cast*>(alpha), reinterpret_cast*>(a), lda, stridea, reinterpret_cast*>(x), incx, stridex, *reinterpret_cast*>(beta), reinterpret_cast*>(y), incy, stridey, batch_size, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklZgemv_batch_strided(syclQueue_t device_queue, onemklTranspose trans, int64_t m, int64_t n, double _Complex *alpha, double _Complex *a, int64_t lda, int64_t stridea, double _Complex *x, int64_t incx, int64_t stridex, double _Complex *beta, double _Complex *y, int64_t incy, int64_t stridey, int64_t batch_size) { - auto status = oneapi::mkl::blas::column_major::gemv_batch(device_queue->val, convert(trans), m, n, reinterpret_cast*>(alpha), reinterpret_cast*>(a), lda, stridea, reinterpret_cast*>(x), incx, stridex, reinterpret_cast*>(beta), reinterpret_cast*>(y), incy, stridey, batch_size, {}); + auto status = oneapi::mkl::blas::column_major::gemv_batch(device_queue->val, convert(trans), m, n, *reinterpret_cast*>(alpha), reinterpret_cast*>(a), lda, stridea, reinterpret_cast*>(x), incx, stridex, *reinterpret_cast*>(beta), reinterpret_cast*>(y), incy, stridey, batch_size, {}); __FORCE_MKL_FLUSH__(status); return 0; } @@ -1705,25 +1705,25 @@ extern "C" int onemklZdgmm_batch_strided(syclQueue_t device_queue, onemklSide le } extern "C" int onemklSaxpy_batch_strided(syclQueue_t device_queue, int64_t n, float *alpha, float *x, int64_t incx, int64_t stridex, float *y, int64_t incy, int64_t stridey, int64_t batch_size) { - auto status = oneapi::mkl::blas::column_major::axpy_batch(device_queue->val, n, alpha, x, incx, stridex, y, incy, stridey, batch_size, {}); + auto status = oneapi::mkl::blas::column_major::axpy_batch(device_queue->val, n, *alpha, x, incx, stridex, y, incy, stridey, batch_size, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklDaxpy_batch_strided(syclQueue_t device_queue, int64_t n, double *alpha, double *x, int64_t incx, int64_t stridex, double *y, int64_t incy, int64_t stridey, int64_t batch_size) { - auto status = oneapi::mkl::blas::column_major::axpy_batch(device_queue->val, n, alpha, x, incx, stridex, y, incy, stridey, batch_size, {}); + auto status = oneapi::mkl::blas::column_major::axpy_batch(device_queue->val, n, *alpha, x, incx, stridex, y, incy, stridey, batch_size, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklCaxpy_batch_strided(syclQueue_t device_queue, int64_t n, float _Complex *alpha, float _Complex *x, int64_t incx, int64_t stridex, float _Complex *y, int64_t incy, int64_t stridey, int64_t batch_size) { - auto status = oneapi::mkl::blas::column_major::axpy_batch(device_queue->val, n, reinterpret_cast*>(alpha), reinterpret_cast*>(x), incx, stridex, reinterpret_cast*>(y), incy, stridey, batch_size, {}); + auto status = oneapi::mkl::blas::column_major::axpy_batch(device_queue->val, n, *reinterpret_cast*>(alpha), reinterpret_cast*>(x), incx, stridex, reinterpret_cast*>(y), incy, stridey, batch_size, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklZaxpy_batch_strided(syclQueue_t device_queue, int64_t n, double _Complex *alpha, double _Complex *x, int64_t incx, int64_t stridex, double _Complex *y, int64_t incy, int64_t stridey, int64_t batch_size) { - auto status = oneapi::mkl::blas::column_major::axpy_batch(device_queue->val, n, reinterpret_cast*>(alpha), reinterpret_cast*>(x), incx, stridex, reinterpret_cast*>(y), incy, stridey, batch_size, {}); + auto status = oneapi::mkl::blas::column_major::axpy_batch(device_queue->val, n, *reinterpret_cast*>(alpha), reinterpret_cast*>(x), incx, stridex, reinterpret_cast*>(y), incy, stridey, batch_size, {}); __FORCE_MKL_FLUSH__(status); return 0; } @@ -1753,169 +1753,169 @@ extern "C" int onemklZcopy_batch_strided(syclQueue_t device_queue, int64_t n, do } extern "C" int onemklSgemmt(syclQueue_t device_queue, onemklUplo upper_lower, onemklTranspose transa, onemklTranspose transb, int64_t n, int64_t k, float *alpha, float *a, int64_t lda, float *b, int64_t ldb, float *beta, float *c, int64_t ldc) { - auto status = oneapi::mkl::blas::column_major::gemmt(device_queue->val, convert(upper_lower), convert(transa), convert(transb), n, k, alpha, a, lda, b, ldb, beta, c, ldc, {}); + auto status = oneapi::mkl::blas::column_major::gemmt(device_queue->val, convert(upper_lower), convert(transa), convert(transb), n, k, *alpha, a, lda, b, ldb, *beta, c, ldc, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklDgemmt(syclQueue_t device_queue, onemklUplo upper_lower, onemklTranspose transa, onemklTranspose transb, int64_t n, int64_t k, double *alpha, double *a, int64_t lda, double *b, int64_t ldb, double *beta, double *c, int64_t ldc) { - auto status = oneapi::mkl::blas::column_major::gemmt(device_queue->val, convert(upper_lower), convert(transa), convert(transb), n, k, alpha, a, lda, b, ldb, beta, c, ldc, {}); + auto status = oneapi::mkl::blas::column_major::gemmt(device_queue->val, convert(upper_lower), convert(transa), convert(transb), n, k, *alpha, a, lda, b, ldb, *beta, c, ldc, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklCgemmt(syclQueue_t device_queue, onemklUplo upper_lower, onemklTranspose transa, onemklTranspose transb, int64_t n, int64_t k, float _Complex *alpha, float _Complex *a, int64_t lda, float _Complex *b, int64_t ldb, float _Complex *beta, float _Complex *c, int64_t ldc) { - auto status = oneapi::mkl::blas::column_major::gemmt(device_queue->val, convert(upper_lower), convert(transa), convert(transb), n, k, reinterpret_cast*>(alpha), reinterpret_cast*>(a), lda, reinterpret_cast*>(b), ldb, reinterpret_cast*>(beta), reinterpret_cast*>(c), ldc, {}); + auto status = oneapi::mkl::blas::column_major::gemmt(device_queue->val, convert(upper_lower), convert(transa), convert(transb), n, k, *reinterpret_cast*>(alpha), reinterpret_cast*>(a), lda, reinterpret_cast*>(b), ldb, *reinterpret_cast*>(beta), reinterpret_cast*>(c), ldc, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklZgemmt(syclQueue_t device_queue, onemklUplo upper_lower, onemklTranspose transa, onemklTranspose transb, int64_t n, int64_t k, double _Complex *alpha, double _Complex *a, int64_t lda, double _Complex *b, int64_t ldb, double _Complex *beta, double _Complex *c, int64_t ldc) { - auto status = oneapi::mkl::blas::column_major::gemmt(device_queue->val, convert(upper_lower), convert(transa), convert(transb), n, k, reinterpret_cast*>(alpha), reinterpret_cast*>(a), lda, reinterpret_cast*>(b), ldb, reinterpret_cast*>(beta), reinterpret_cast*>(c), ldc, {}); + auto status = oneapi::mkl::blas::column_major::gemmt(device_queue->val, convert(upper_lower), convert(transa), convert(transb), n, k, *reinterpret_cast*>(alpha), reinterpret_cast*>(a), lda, reinterpret_cast*>(b), ldb, *reinterpret_cast*>(beta), reinterpret_cast*>(c), ldc, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklSimatcopy(syclQueue_t device_queue, onemklTranspose trans, int64_t m, int64_t n, float *alpha, float *ab, int64_t lda, int64_t ldb) { - auto status = oneapi::mkl::blas::column_major::imatcopy(device_queue->val, convert(trans), m, n, alpha, ab, lda, ldb, {}); + auto status = oneapi::mkl::blas::column_major::imatcopy(device_queue->val, convert(trans), m, n, *alpha, ab, lda, ldb, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklDimatcopy(syclQueue_t device_queue, onemklTranspose trans, int64_t m, int64_t n, double *alpha, double *ab, int64_t lda, int64_t ldb) { - auto status = oneapi::mkl::blas::column_major::imatcopy(device_queue->val, convert(trans), m, n, alpha, ab, lda, ldb, {}); + auto status = oneapi::mkl::blas::column_major::imatcopy(device_queue->val, convert(trans), m, n, *alpha, ab, lda, ldb, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklCimatcopy(syclQueue_t device_queue, onemklTranspose trans, int64_t m, int64_t n, float _Complex *alpha, float _Complex *ab, int64_t lda, int64_t ldb) { - auto status = oneapi::mkl::blas::column_major::imatcopy(device_queue->val, convert(trans), m, n, reinterpret_cast*>(alpha), reinterpret_cast*>(ab), lda, ldb, {}); + auto status = oneapi::mkl::blas::column_major::imatcopy(device_queue->val, convert(trans), m, n, *reinterpret_cast*>(alpha), reinterpret_cast*>(ab), lda, ldb, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklZimatcopy(syclQueue_t device_queue, onemklTranspose trans, int64_t m, int64_t n, double _Complex *alpha, double _Complex *ab, int64_t lda, int64_t ldb) { - auto status = oneapi::mkl::blas::column_major::imatcopy(device_queue->val, convert(trans), m, n, reinterpret_cast*>(alpha), reinterpret_cast*>(ab), lda, ldb, {}); + auto status = oneapi::mkl::blas::column_major::imatcopy(device_queue->val, convert(trans), m, n, *reinterpret_cast*>(alpha), reinterpret_cast*>(ab), lda, ldb, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklSomatcopy(syclQueue_t device_queue, onemklTranspose trans, int64_t m, int64_t n, float *alpha, float *a, int64_t lda, float *b, int64_t ldb) { - auto status = oneapi::mkl::blas::column_major::omatcopy(device_queue->val, convert(trans), m, n, alpha, a, lda, b, ldb, {}); + auto status = oneapi::mkl::blas::column_major::omatcopy(device_queue->val, convert(trans), m, n, *alpha, a, lda, b, ldb, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklDomatcopy(syclQueue_t device_queue, onemklTranspose trans, int64_t m, int64_t n, double *alpha, double *a, int64_t lda, double *b, int64_t ldb) { - auto status = oneapi::mkl::blas::column_major::omatcopy(device_queue->val, convert(trans), m, n, alpha, a, lda, b, ldb, {}); + auto status = oneapi::mkl::blas::column_major::omatcopy(device_queue->val, convert(trans), m, n, *alpha, a, lda, b, ldb, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklComatcopy(syclQueue_t device_queue, onemklTranspose trans, int64_t m, int64_t n, float _Complex *alpha, float _Complex *a, int64_t lda, float _Complex *b, int64_t ldb) { - auto status = oneapi::mkl::blas::column_major::omatcopy(device_queue->val, convert(trans), m, n, reinterpret_cast*>(alpha), reinterpret_cast*>(a), lda, reinterpret_cast*>(b), ldb, {}); + auto status = oneapi::mkl::blas::column_major::omatcopy(device_queue->val, convert(trans), m, n, *reinterpret_cast*>(alpha), reinterpret_cast*>(a), lda, reinterpret_cast*>(b), ldb, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklZomatcopy(syclQueue_t device_queue, onemklTranspose trans, int64_t m, int64_t n, double _Complex *alpha, double _Complex *a, int64_t lda, double _Complex *b, int64_t ldb) { - auto status = oneapi::mkl::blas::column_major::omatcopy(device_queue->val, convert(trans), m, n, reinterpret_cast*>(alpha), reinterpret_cast*>(a), lda, reinterpret_cast*>(b), ldb, {}); + auto status = oneapi::mkl::blas::column_major::omatcopy(device_queue->val, convert(trans), m, n, *reinterpret_cast*>(alpha), reinterpret_cast*>(a), lda, reinterpret_cast*>(b), ldb, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklSomatadd(syclQueue_t device_queue, onemklTranspose transa, onemklTranspose transb, int64_t m, int64_t n, float *alpha, float *a, int64_t lda, float *beta, float *b, int64_t ldb, float *c, int64_t ldc) { - auto status = oneapi::mkl::blas::column_major::omatadd(device_queue->val, convert(transa), convert(transb), m, n, alpha, a, lda, beta, b, ldb, c, ldc, {}); + auto status = oneapi::mkl::blas::column_major::omatadd(device_queue->val, convert(transa), convert(transb), m, n, *alpha, a, lda, *beta, b, ldb, c, ldc, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklDomatadd(syclQueue_t device_queue, onemklTranspose transa, onemklTranspose transb, int64_t m, int64_t n, double *alpha, double *a, int64_t lda, double *beta, double *b, int64_t ldb, double *c, int64_t ldc) { - auto status = oneapi::mkl::blas::column_major::omatadd(device_queue->val, convert(transa), convert(transb), m, n, alpha, a, lda, beta, b, ldb, c, ldc, {}); + auto status = oneapi::mkl::blas::column_major::omatadd(device_queue->val, convert(transa), convert(transb), m, n, *alpha, a, lda, *beta, b, ldb, c, ldc, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklComatadd(syclQueue_t device_queue, onemklTranspose transa, onemklTranspose transb, int64_t m, int64_t n, float _Complex *alpha, float _Complex *a, int64_t lda, float _Complex *beta, float _Complex *b, int64_t ldb, float _Complex *c, int64_t ldc) { - auto status = oneapi::mkl::blas::column_major::omatadd(device_queue->val, convert(transa), convert(transb), m, n, reinterpret_cast*>(alpha), reinterpret_cast*>(a), lda, reinterpret_cast*>(beta), reinterpret_cast*>(b), ldb, reinterpret_cast*>(c), ldc, {}); + auto status = oneapi::mkl::blas::column_major::omatadd(device_queue->val, convert(transa), convert(transb), m, n, *reinterpret_cast*>(alpha), reinterpret_cast*>(a), lda, *reinterpret_cast*>(beta), reinterpret_cast*>(b), ldb, reinterpret_cast*>(c), ldc, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklZomatadd(syclQueue_t device_queue, onemklTranspose transa, onemklTranspose transb, int64_t m, int64_t n, double _Complex *alpha, double _Complex *a, int64_t lda, double _Complex *beta, double _Complex *b, int64_t ldb, double _Complex *c, int64_t ldc) { - auto status = oneapi::mkl::blas::column_major::omatadd(device_queue->val, convert(transa), convert(transb), m, n, reinterpret_cast*>(alpha), reinterpret_cast*>(a), lda, reinterpret_cast*>(beta), reinterpret_cast*>(b), ldb, reinterpret_cast*>(c), ldc, {}); + auto status = oneapi::mkl::blas::column_major::omatadd(device_queue->val, convert(transa), convert(transb), m, n, *reinterpret_cast*>(alpha), reinterpret_cast*>(a), lda, *reinterpret_cast*>(beta), reinterpret_cast*>(b), ldb, reinterpret_cast*>(c), ldc, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklSimatcopy_batch_strided(syclQueue_t device_queue, onemklTranspose trans, int64_t m, int64_t n, float *alpha, float *ab, int64_t lda, int64_t ldb, int64_t stride, int64_t batch_size) { - auto status = oneapi::mkl::blas::column_major::imatcopy_batch(device_queue->val, convert(trans), m, n, alpha, ab, lda, ldb, stride, batch_size, {}); + auto status = oneapi::mkl::blas::column_major::imatcopy_batch(device_queue->val, convert(trans), m, n, *alpha, ab, lda, ldb, stride, batch_size, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklDimatcopy_batch_strided(syclQueue_t device_queue, onemklTranspose trans, int64_t m, int64_t n, double *alpha, double *ab, int64_t lda, int64_t ldb, int64_t stride, int64_t batch_size) { - auto status = oneapi::mkl::blas::column_major::imatcopy_batch(device_queue->val, convert(trans), m, n, alpha, ab, lda, ldb, stride, batch_size, {}); + auto status = oneapi::mkl::blas::column_major::imatcopy_batch(device_queue->val, convert(trans), m, n, *alpha, ab, lda, ldb, stride, batch_size, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklCimatcopy_batch_strided(syclQueue_t device_queue, onemklTranspose trans, int64_t m, int64_t n, float _Complex *alpha, float _Complex *ab, int64_t lda, int64_t ldb, int64_t stride, int64_t batch_size) { - auto status = oneapi::mkl::blas::column_major::imatcopy_batch(device_queue->val, convert(trans), m, n, reinterpret_cast*>(alpha), reinterpret_cast*>(ab), lda, ldb, stride, batch_size, {}); + auto status = oneapi::mkl::blas::column_major::imatcopy_batch(device_queue->val, convert(trans), m, n, *reinterpret_cast*>(alpha), reinterpret_cast*>(ab), lda, ldb, stride, batch_size, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklZimatcopy_batch_strided(syclQueue_t device_queue, onemklTranspose trans, int64_t m, int64_t n, double _Complex *alpha, double _Complex *ab, int64_t lda, int64_t ldb, int64_t stride, int64_t batch_size) { - auto status = oneapi::mkl::blas::column_major::imatcopy_batch(device_queue->val, convert(trans), m, n, reinterpret_cast*>(alpha), reinterpret_cast*>(ab), lda, ldb, stride, batch_size, {}); + auto status = oneapi::mkl::blas::column_major::imatcopy_batch(device_queue->val, convert(trans), m, n, *reinterpret_cast*>(alpha), reinterpret_cast*>(ab), lda, ldb, stride, batch_size, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklSomatcopy_batch_strided(syclQueue_t device_queue, onemklTranspose trans, int64_t m, int64_t n, float *alpha, float *a, int64_t lda, int64_t stride_a, float *b, int64_t ldb, int64_t stride_b, int64_t batch_size) { - auto status = oneapi::mkl::blas::column_major::omatcopy_batch(device_queue->val, convert(trans), m, n, alpha, a, lda, stride_a, b, ldb, stride_b, batch_size, {}); + auto status = oneapi::mkl::blas::column_major::omatcopy_batch(device_queue->val, convert(trans), m, n, *alpha, a, lda, stride_a, b, ldb, stride_b, batch_size, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklDomatcopy_batch_strided(syclQueue_t device_queue, onemklTranspose trans, int64_t m, int64_t n, double *alpha, double *a, int64_t lda, int64_t stride_a, double *b, int64_t ldb, int64_t stride_b, int64_t batch_size) { - auto status = oneapi::mkl::blas::column_major::omatcopy_batch(device_queue->val, convert(trans), m, n, alpha, a, lda, stride_a, b, ldb, stride_b, batch_size, {}); + auto status = oneapi::mkl::blas::column_major::omatcopy_batch(device_queue->val, convert(trans), m, n, *alpha, a, lda, stride_a, b, ldb, stride_b, batch_size, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklComatcopy_batch_strided(syclQueue_t device_queue, onemklTranspose trans, int64_t m, int64_t n, float _Complex *alpha, float _Complex *a, int64_t lda, int64_t stride_a, float _Complex *b, int64_t ldb, int64_t stride_b, int64_t batch_size) { - auto status = oneapi::mkl::blas::column_major::omatcopy_batch(device_queue->val, convert(trans), m, n, reinterpret_cast*>(alpha), reinterpret_cast*>(a), lda, stride_a, reinterpret_cast*>(b), ldb, stride_b, batch_size, {}); + auto status = oneapi::mkl::blas::column_major::omatcopy_batch(device_queue->val, convert(trans), m, n, *reinterpret_cast*>(alpha), reinterpret_cast*>(a), lda, stride_a, reinterpret_cast*>(b), ldb, stride_b, batch_size, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklZomatcopy_batch_strided(syclQueue_t device_queue, onemklTranspose trans, int64_t m, int64_t n, double _Complex *alpha, double _Complex *a, int64_t lda, int64_t stride_a, double _Complex *b, int64_t ldb, int64_t stride_b, int64_t batch_size) { - auto status = oneapi::mkl::blas::column_major::omatcopy_batch(device_queue->val, convert(trans), m, n, reinterpret_cast*>(alpha), reinterpret_cast*>(a), lda, stride_a, reinterpret_cast*>(b), ldb, stride_b, batch_size, {}); + auto status = oneapi::mkl::blas::column_major::omatcopy_batch(device_queue->val, convert(trans), m, n, *reinterpret_cast*>(alpha), reinterpret_cast*>(a), lda, stride_a, reinterpret_cast*>(b), ldb, stride_b, batch_size, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklSomatadd_batch_strided(syclQueue_t device_queue, onemklTranspose transa, onemklTranspose transb, int64_t m, int64_t n, float *alpha, float *a, int64_t lda, int64_t stride_a, float *beta, float *b, int64_t ldb, int64_t stride_b, float *c, int64_t ldc, int64_t stride_c, int64_t batch_size) { - auto status = oneapi::mkl::blas::column_major::omatadd_batch(device_queue->val, convert(transa), convert(transb), m, n, alpha, a, lda, stride_a, beta, b, ldb, stride_b, c, ldc, stride_c, batch_size, {}); + auto status = oneapi::mkl::blas::column_major::omatadd_batch(device_queue->val, convert(transa), convert(transb), m, n, *alpha, a, lda, stride_a, *beta, b, ldb, stride_b, c, ldc, stride_c, batch_size, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklDomatadd_batch_strided(syclQueue_t device_queue, onemklTranspose transa, onemklTranspose transb, int64_t m, int64_t n, double *alpha, double *a, int64_t lda, int64_t stride_a, double *beta, double *b, int64_t ldb, int64_t stride_b, double *c, int64_t ldc, int64_t stride_c, int64_t batch_size) { - auto status = oneapi::mkl::blas::column_major::omatadd_batch(device_queue->val, convert(transa), convert(transb), m, n, alpha, a, lda, stride_a, beta, b, ldb, stride_b, c, ldc, stride_c, batch_size, {}); + auto status = oneapi::mkl::blas::column_major::omatadd_batch(device_queue->val, convert(transa), convert(transb), m, n, *alpha, a, lda, stride_a, *beta, b, ldb, stride_b, c, ldc, stride_c, batch_size, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklComatadd_batch_strided(syclQueue_t device_queue, onemklTranspose transa, onemklTranspose transb, int64_t m, int64_t n, float _Complex *alpha, float _Complex *a, int64_t lda, int64_t stride_a, float _Complex *beta, float _Complex *b, int64_t ldb, int64_t stride_b, float _Complex *c, int64_t ldc, int64_t stride_c, int64_t batch_size) { - auto status = oneapi::mkl::blas::column_major::omatadd_batch(device_queue->val, convert(transa), convert(transb), m, n, reinterpret_cast*>(alpha), reinterpret_cast*>(a), lda, stride_a, reinterpret_cast*>(beta), reinterpret_cast*>(b), ldb, stride_b, reinterpret_cast*>(c), ldc, stride_c, batch_size, {}); + auto status = oneapi::mkl::blas::column_major::omatadd_batch(device_queue->val, convert(transa), convert(transb), m, n, *reinterpret_cast*>(alpha), reinterpret_cast*>(a), lda, stride_a, *reinterpret_cast*>(beta), reinterpret_cast*>(b), ldb, stride_b, reinterpret_cast*>(c), ldc, stride_c, batch_size, {}); __FORCE_MKL_FLUSH__(status); return 0; } extern "C" int onemklZomatadd_batch_strided(syclQueue_t device_queue, onemklTranspose transa, onemklTranspose transb, int64_t m, int64_t n, double _Complex *alpha, double _Complex *a, int64_t lda, int64_t stride_a, double _Complex *beta, double _Complex *b, int64_t ldb, int64_t stride_b, double _Complex *c, int64_t ldc, int64_t stride_c, int64_t batch_size) { - auto status = oneapi::mkl::blas::column_major::omatadd_batch(device_queue->val, convert(transa), convert(transb), m, n, reinterpret_cast*>(alpha), reinterpret_cast*>(a), lda, stride_a, reinterpret_cast*>(beta), reinterpret_cast*>(b), ldb, stride_b, reinterpret_cast*>(c), ldc, stride_c, batch_size, {}); + auto status = oneapi::mkl::blas::column_major::omatadd_batch(device_queue->val, convert(transa), convert(transb), m, n, *reinterpret_cast*>(alpha), reinterpret_cast*>(a), lda, stride_a, *reinterpret_cast*>(beta), reinterpret_cast*>(b), ldb, stride_b, reinterpret_cast*>(c), ldc, stride_c, batch_size, {}); __FORCE_MKL_FLUSH__(status); return 0; } @@ -2977,24 +2977,24 @@ extern "C" int onemklSsyevd(syclQueue_t device_queue, onemklJob jobz, onemklUplo return 0; } -extern "C" int64_t onemklSsyevx_scratchpad_size(syclQueue_t device_queue, onemklCompz jobz, onemklRangev range, onemklUplo uplo, int64_t n, int64_t lda, float vl, float vu, int64_t il, int64_t iu, float abstol, int64_t ldz) { - int64_t scratchpad_size = oneapi::mkl::lapack::syevx_scratchpad_size(device_queue->val, convert(jobz), convert(range), convert(uplo), n, lda, vl, vu, il, iu, abstol, ldz); +extern "C" int64_t onemklSsyevx_scratchpad_size(syclQueue_t device_queue, onemklCompz jobz, onemklRangev range, onemklUplo uplo, int64_t n, int64_t lda, float *vl, float *vu, int64_t il, int64_t iu, float *abstol, int64_t ldz) { + int64_t scratchpad_size = oneapi::mkl::lapack::syevx_scratchpad_size(device_queue->val, convert(jobz), convert(range), convert(uplo), n, lda, *vl, *vu, il, iu, *abstol, ldz); return scratchpad_size; } -extern "C" int64_t onemklDsyevx_scratchpad_size(syclQueue_t device_queue, onemklCompz jobz, onemklRangev range, onemklUplo uplo, int64_t n, int64_t lda, double vl, double vu, int64_t il, int64_t iu, double abstol, int64_t ldz) { - int64_t scratchpad_size = oneapi::mkl::lapack::syevx_scratchpad_size(device_queue->val, convert(jobz), convert(range), convert(uplo), n, lda, vl, vu, il, iu, abstol, ldz); +extern "C" int64_t onemklDsyevx_scratchpad_size(syclQueue_t device_queue, onemklCompz jobz, onemklRangev range, onemklUplo uplo, int64_t n, int64_t lda, double *vl, double *vu, int64_t il, int64_t iu, double *abstol, int64_t ldz) { + int64_t scratchpad_size = oneapi::mkl::lapack::syevx_scratchpad_size(device_queue->val, convert(jobz), convert(range), convert(uplo), n, lda, *vl, *vu, il, iu, *abstol, ldz); return scratchpad_size; } -extern "C" int onemklDsyevx(syclQueue_t device_queue, onemklCompz jobz, onemklRangev range, onemklUplo uplo, int64_t n, double *a, int64_t lda, double vl, double vu, int64_t il, int64_t iu, double abstol, int64_t *m, double *w, double *z, int64_t ldz, double *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::syevx(device_queue->val, convert(jobz), convert(range), convert(uplo), n, a, lda, vl, vu, il, iu, abstol, m, w, z, ldz, scratchpad, scratchpad_size, {}); +extern "C" int onemklDsyevx(syclQueue_t device_queue, onemklCompz jobz, onemklRangev range, onemklUplo uplo, int64_t n, double *a, int64_t lda, double *vl, double *vu, int64_t il, int64_t iu, double *abstol, int64_t *m, double *w, double *z, int64_t ldz, double *scratchpad, int64_t scratchpad_size) { + auto status = oneapi::mkl::lapack::syevx(device_queue->val, convert(jobz), convert(range), convert(uplo), n, a, lda, *vl, *vu, il, iu, *abstol, m, w, z, ldz, scratchpad, scratchpad_size, {}); __FORCE_MKL_FLUSH__(status); return 0; } -extern "C" int onemklSsyevx(syclQueue_t device_queue, onemklCompz jobz, onemklRangev range, onemklUplo uplo, int64_t n, float *a, int64_t lda, float vl, float vu, int64_t il, int64_t iu, float abstol, int64_t *m, float *w, float *z, int64_t ldz, float *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::syevx(device_queue->val, convert(jobz), convert(range), convert(uplo), n, a, lda, vl, vu, il, iu, abstol, m, w, z, ldz, scratchpad, scratchpad_size, {}); +extern "C" int onemklSsyevx(syclQueue_t device_queue, onemklCompz jobz, onemklRangev range, onemklUplo uplo, int64_t n, float *a, int64_t lda, float *vl, float *vu, int64_t il, int64_t iu, float *abstol, int64_t *m, float *w, float *z, int64_t ldz, float *scratchpad, int64_t scratchpad_size) { + auto status = oneapi::mkl::lapack::syevx(device_queue->val, convert(jobz), convert(range), convert(uplo), n, a, lda, *vl, *vu, il, iu, *abstol, m, w, z, ldz, scratchpad, scratchpad_size, {}); __FORCE_MKL_FLUSH__(status); return 0; } @@ -3021,24 +3021,24 @@ extern "C" int onemklSsygvd(syclQueue_t device_queue, int64_t itype, onemklJob j return 0; } -extern "C" int64_t onemklSsygvx_scratchpad_size(syclQueue_t device_queue, int64_t itype, onemklCompz jobz, onemklRangev range, onemklUplo uplo, int64_t n, int64_t lda, int64_t ldb, float vl, float vu, int64_t il, int64_t iu, float abstol, int64_t ldz) { - int64_t scratchpad_size = oneapi::mkl::lapack::sygvx_scratchpad_size(device_queue->val, itype, convert(jobz), convert(range), convert(uplo), n, lda, ldb, vl, vu, il, iu, abstol, ldz); +extern "C" int64_t onemklSsygvx_scratchpad_size(syclQueue_t device_queue, int64_t itype, onemklCompz jobz, onemklRangev range, onemklUplo uplo, int64_t n, int64_t lda, int64_t ldb, float *vl, float *vu, int64_t il, int64_t iu, float *abstol, int64_t ldz) { + int64_t scratchpad_size = oneapi::mkl::lapack::sygvx_scratchpad_size(device_queue->val, itype, convert(jobz), convert(range), convert(uplo), n, lda, ldb, *vl, *vu, il, iu, *abstol, ldz); return scratchpad_size; } -extern "C" int64_t onemklDsygvx_scratchpad_size(syclQueue_t device_queue, int64_t itype, onemklCompz jobz, onemklRangev range, onemklUplo uplo, int64_t n, int64_t lda, int64_t ldb, double vl, double vu, int64_t il, int64_t iu, double abstol, int64_t ldz) { - int64_t scratchpad_size = oneapi::mkl::lapack::sygvx_scratchpad_size(device_queue->val, itype, convert(jobz), convert(range), convert(uplo), n, lda, ldb, vl, vu, il, iu, abstol, ldz); +extern "C" int64_t onemklDsygvx_scratchpad_size(syclQueue_t device_queue, int64_t itype, onemklCompz jobz, onemklRangev range, onemklUplo uplo, int64_t n, int64_t lda, int64_t ldb, double *vl, double *vu, int64_t il, int64_t iu, double *abstol, int64_t ldz) { + int64_t scratchpad_size = oneapi::mkl::lapack::sygvx_scratchpad_size(device_queue->val, itype, convert(jobz), convert(range), convert(uplo), n, lda, ldb, *vl, *vu, il, iu, *abstol, ldz); return scratchpad_size; } -extern "C" int onemklDsygvx(syclQueue_t device_queue, int64_t itype, onemklCompz jobz, onemklRangev range, onemklUplo uplo, int64_t n, double *a, int64_t lda, double *b, int64_t ldb, double vl, double vu, int64_t il, int64_t iu, double abstol, int64_t *m, double *w, double *z, int64_t ldz, double *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::sygvx(device_queue->val, itype, convert(jobz), convert(range), convert(uplo), n, a, lda, b, ldb, vl, vu, il, iu, abstol, m, w, z, ldz, scratchpad, scratchpad_size, {}); +extern "C" int onemklDsygvx(syclQueue_t device_queue, int64_t itype, onemklCompz jobz, onemklRangev range, onemklUplo uplo, int64_t n, double *a, int64_t lda, double *b, int64_t ldb, double *vl, double *vu, int64_t il, int64_t iu, double *abstol, int64_t *m, double *w, double *z, int64_t ldz, double *scratchpad, int64_t scratchpad_size) { + auto status = oneapi::mkl::lapack::sygvx(device_queue->val, itype, convert(jobz), convert(range), convert(uplo), n, a, lda, b, ldb, *vl, *vu, il, iu, *abstol, m, w, z, ldz, scratchpad, scratchpad_size, {}); __FORCE_MKL_FLUSH__(status); return 0; } -extern "C" int onemklSsygvx(syclQueue_t device_queue, int64_t itype, onemklCompz jobz, onemklRangev range, onemklUplo uplo, int64_t n, float *a, int64_t lda, float *b, int64_t ldb, float vl, float vu, int64_t il, int64_t iu, float abstol, int64_t *m, float *w, float *z, int64_t ldz, float *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::sygvx(device_queue->val, itype, convert(jobz), convert(range), convert(uplo), n, a, lda, b, ldb, vl, vu, il, iu, abstol, m, w, z, ldz, scratchpad, scratchpad_size, {}); +extern "C" int onemklSsygvx(syclQueue_t device_queue, int64_t itype, onemklCompz jobz, onemklRangev range, onemklUplo uplo, int64_t n, float *a, int64_t lda, float *b, int64_t ldb, float *vl, float *vu, int64_t il, int64_t iu, float *abstol, int64_t *m, float *w, float *z, int64_t ldz, float *scratchpad, int64_t scratchpad_size) { + auto status = oneapi::mkl::lapack::sygvx(device_queue->val, itype, convert(jobz), convert(range), convert(uplo), n, a, lda, b, ldb, *vl, *vu, il, iu, *abstol, m, w, z, ldz, scratchpad, scratchpad_size, {}); __FORCE_MKL_FLUSH__(status); return 0; } @@ -4079,98 +4079,98 @@ extern "C" int onemklXsparse_optimize_trsv(syclQueue_t device_queue, onemklUplo return 0; } -extern "C" int onemklSsparse_gemv(syclQueue_t device_queue, onemklTranspose opA, float alpha, matrix_handle_t A, float *x, float beta, float *y) { - auto status = oneapi::mkl::sparse::gemv(device_queue->val, convert(opA), alpha, (oneapi::mkl::sparse::matrix_handle_t) A, x, beta, y, {}); +extern "C" int onemklSsparse_gemv(syclQueue_t device_queue, onemklTranspose opA, float *alpha, matrix_handle_t A, float *x, float *beta, float *y) { + auto status = oneapi::mkl::sparse::gemv(device_queue->val, convert(opA), *alpha, (oneapi::mkl::sparse::matrix_handle_t) A, x, *beta, y, {}); __FORCE_MKL_FLUSH__(status); return 0; } -extern "C" int onemklDsparse_gemv(syclQueue_t device_queue, onemklTranspose opA, double alpha, matrix_handle_t A, double *x, double beta, double *y) { - auto status = oneapi::mkl::sparse::gemv(device_queue->val, convert(opA), alpha, (oneapi::mkl::sparse::matrix_handle_t) A, x, beta, y, {}); +extern "C" int onemklDsparse_gemv(syclQueue_t device_queue, onemklTranspose opA, double *alpha, matrix_handle_t A, double *x, double *beta, double *y) { + auto status = oneapi::mkl::sparse::gemv(device_queue->val, convert(opA), *alpha, (oneapi::mkl::sparse::matrix_handle_t) A, x, *beta, y, {}); __FORCE_MKL_FLUSH__(status); return 0; } -extern "C" int onemklCsparse_gemv(syclQueue_t device_queue, onemklTranspose opA, float _Complex alpha, matrix_handle_t A, float _Complex *x, float _Complex beta, float _Complex *y) { - auto status = oneapi::mkl::sparse::gemv(device_queue->val, convert(opA), static_cast >(alpha), (oneapi::mkl::sparse::matrix_handle_t) A, reinterpret_cast*>(x), static_cast >(beta), reinterpret_cast*>(y), {}); +extern "C" int onemklCsparse_gemv(syclQueue_t device_queue, onemklTranspose opA, float _Complex *alpha, matrix_handle_t A, float _Complex *x, float _Complex *beta, float _Complex *y) { + auto status = oneapi::mkl::sparse::gemv(device_queue->val, convert(opA), *reinterpret_cast*>(alpha), (oneapi::mkl::sparse::matrix_handle_t) A, reinterpret_cast*>(x), *reinterpret_cast*>(beta), reinterpret_cast*>(y), {}); __FORCE_MKL_FLUSH__(status); return 0; } -extern "C" int onemklZsparse_gemv(syclQueue_t device_queue, onemklTranspose opA, double _Complex alpha, matrix_handle_t A, double _Complex *x, double _Complex beta, double _Complex *y) { - auto status = oneapi::mkl::sparse::gemv(device_queue->val, convert(opA), static_cast >(alpha), (oneapi::mkl::sparse::matrix_handle_t) A, reinterpret_cast*>(x), static_cast >(beta), reinterpret_cast*>(y), {}); +extern "C" int onemklZsparse_gemv(syclQueue_t device_queue, onemklTranspose opA, double _Complex *alpha, matrix_handle_t A, double _Complex *x, double _Complex *beta, double _Complex *y) { + auto status = oneapi::mkl::sparse::gemv(device_queue->val, convert(opA), *reinterpret_cast*>(alpha), (oneapi::mkl::sparse::matrix_handle_t) A, reinterpret_cast*>(x), *reinterpret_cast*>(beta), reinterpret_cast*>(y), {}); __FORCE_MKL_FLUSH__(status); return 0; } -extern "C" int onemklSsparse_gemvdot(syclQueue_t device_queue, onemklTranspose opA, float alpha, matrix_handle_t A, float *x, float beta, float *y, float *d) { - auto status = oneapi::mkl::sparse::gemvdot(device_queue->val, convert(opA), alpha, (oneapi::mkl::sparse::matrix_handle_t) A, x, beta, y, d, {}); +extern "C" int onemklSsparse_gemvdot(syclQueue_t device_queue, onemklTranspose opA, float *alpha, matrix_handle_t A, float *x, float *beta, float *y, float *d) { + auto status = oneapi::mkl::sparse::gemvdot(device_queue->val, convert(opA), *alpha, (oneapi::mkl::sparse::matrix_handle_t) A, x, *beta, y, d, {}); __FORCE_MKL_FLUSH__(status); return 0; } -extern "C" int onemklDsparse_gemvdot(syclQueue_t device_queue, onemklTranspose opA, double alpha, matrix_handle_t A, double *x, double beta, double *y, double *d) { - auto status = oneapi::mkl::sparse::gemvdot(device_queue->val, convert(opA), alpha, (oneapi::mkl::sparse::matrix_handle_t) A, x, beta, y, d, {}); +extern "C" int onemklDsparse_gemvdot(syclQueue_t device_queue, onemklTranspose opA, double *alpha, matrix_handle_t A, double *x, double *beta, double *y, double *d) { + auto status = oneapi::mkl::sparse::gemvdot(device_queue->val, convert(opA), *alpha, (oneapi::mkl::sparse::matrix_handle_t) A, x, *beta, y, d, {}); __FORCE_MKL_FLUSH__(status); return 0; } -extern "C" int onemklCsparse_gemvdot(syclQueue_t device_queue, onemklTranspose opA, float _Complex alpha, matrix_handle_t A, float _Complex *x, float _Complex beta, float _Complex *y, float _Complex *d) { - auto status = oneapi::mkl::sparse::gemvdot(device_queue->val, convert(opA), static_cast >(alpha), (oneapi::mkl::sparse::matrix_handle_t) A, reinterpret_cast*>(x), static_cast >(beta), reinterpret_cast*>(y), reinterpret_cast*>(d), {}); +extern "C" int onemklCsparse_gemvdot(syclQueue_t device_queue, onemklTranspose opA, float _Complex *alpha, matrix_handle_t A, float _Complex *x, float _Complex *beta, float _Complex *y, float _Complex *d) { + auto status = oneapi::mkl::sparse::gemvdot(device_queue->val, convert(opA), *reinterpret_cast*>(alpha), (oneapi::mkl::sparse::matrix_handle_t) A, reinterpret_cast*>(x), *reinterpret_cast*>(beta), reinterpret_cast*>(y), reinterpret_cast*>(d), {}); __FORCE_MKL_FLUSH__(status); return 0; } -extern "C" int onemklZsparse_gemvdot(syclQueue_t device_queue, onemklTranspose opA, double _Complex alpha, matrix_handle_t A, double _Complex *x, double _Complex beta, double _Complex *y, double _Complex *d) { - auto status = oneapi::mkl::sparse::gemvdot(device_queue->val, convert(opA), static_cast >(alpha), (oneapi::mkl::sparse::matrix_handle_t) A, reinterpret_cast*>(x), static_cast >(beta), reinterpret_cast*>(y), reinterpret_cast*>(d), {}); +extern "C" int onemklZsparse_gemvdot(syclQueue_t device_queue, onemklTranspose opA, double _Complex *alpha, matrix_handle_t A, double _Complex *x, double _Complex *beta, double _Complex *y, double _Complex *d) { + auto status = oneapi::mkl::sparse::gemvdot(device_queue->val, convert(opA), *reinterpret_cast*>(alpha), (oneapi::mkl::sparse::matrix_handle_t) A, reinterpret_cast*>(x), *reinterpret_cast*>(beta), reinterpret_cast*>(y), reinterpret_cast*>(d), {}); __FORCE_MKL_FLUSH__(status); return 0; } -extern "C" int onemklSsparse_symv(syclQueue_t device_queue, onemklUplo uplo_val, float alpha, matrix_handle_t A, float *x, float beta, float *y) { - auto status = oneapi::mkl::sparse::symv(device_queue->val, convert(uplo_val), alpha, (oneapi::mkl::sparse::matrix_handle_t) A, x, beta, y, {}); +extern "C" int onemklSsparse_symv(syclQueue_t device_queue, onemklUplo uplo_val, float *alpha, matrix_handle_t A, float *x, float *beta, float *y) { + auto status = oneapi::mkl::sparse::symv(device_queue->val, convert(uplo_val), *alpha, (oneapi::mkl::sparse::matrix_handle_t) A, x, *beta, y, {}); __FORCE_MKL_FLUSH__(status); return 0; } -extern "C" int onemklDsparse_symv(syclQueue_t device_queue, onemklUplo uplo_val, double alpha, matrix_handle_t A, double *x, double beta, double *y) { - auto status = oneapi::mkl::sparse::symv(device_queue->val, convert(uplo_val), alpha, (oneapi::mkl::sparse::matrix_handle_t) A, x, beta, y, {}); +extern "C" int onemklDsparse_symv(syclQueue_t device_queue, onemklUplo uplo_val, double *alpha, matrix_handle_t A, double *x, double *beta, double *y) { + auto status = oneapi::mkl::sparse::symv(device_queue->val, convert(uplo_val), *alpha, (oneapi::mkl::sparse::matrix_handle_t) A, x, *beta, y, {}); __FORCE_MKL_FLUSH__(status); return 0; } -extern "C" int onemklCsparse_symv(syclQueue_t device_queue, onemklUplo uplo_val, float _Complex alpha, matrix_handle_t A, float _Complex *x, float _Complex beta, float _Complex *y) { - auto status = oneapi::mkl::sparse::symv(device_queue->val, convert(uplo_val), static_cast >(alpha), (oneapi::mkl::sparse::matrix_handle_t) A, reinterpret_cast*>(x), static_cast >(beta), reinterpret_cast*>(y), {}); +extern "C" int onemklCsparse_symv(syclQueue_t device_queue, onemklUplo uplo_val, float _Complex *alpha, matrix_handle_t A, float _Complex *x, float _Complex *beta, float _Complex *y) { + auto status = oneapi::mkl::sparse::symv(device_queue->val, convert(uplo_val), *reinterpret_cast*>(alpha), (oneapi::mkl::sparse::matrix_handle_t) A, reinterpret_cast*>(x), *reinterpret_cast*>(beta), reinterpret_cast*>(y), {}); __FORCE_MKL_FLUSH__(status); return 0; } -extern "C" int onemklZsparse_symv(syclQueue_t device_queue, onemklUplo uplo_val, double _Complex alpha, matrix_handle_t A, double _Complex *x, double _Complex beta, double _Complex *y) { - auto status = oneapi::mkl::sparse::symv(device_queue->val, convert(uplo_val), static_cast >(alpha), (oneapi::mkl::sparse::matrix_handle_t) A, reinterpret_cast*>(x), static_cast >(beta), reinterpret_cast*>(y), {}); +extern "C" int onemklZsparse_symv(syclQueue_t device_queue, onemklUplo uplo_val, double _Complex *alpha, matrix_handle_t A, double _Complex *x, double _Complex *beta, double _Complex *y) { + auto status = oneapi::mkl::sparse::symv(device_queue->val, convert(uplo_val), *reinterpret_cast*>(alpha), (oneapi::mkl::sparse::matrix_handle_t) A, reinterpret_cast*>(x), *reinterpret_cast*>(beta), reinterpret_cast*>(y), {}); __FORCE_MKL_FLUSH__(status); return 0; } -extern "C" int onemklSsparse_trmv(syclQueue_t device_queue, onemklUplo uplo_val, onemklTranspose opA, onemklDiag diag_val, float alpha, matrix_handle_t A, float *x, float beta, float *y) { - auto status = oneapi::mkl::sparse::trmv(device_queue->val, convert(uplo_val), convert(opA), convert(diag_val), alpha, (oneapi::mkl::sparse::matrix_handle_t) A, x, beta, y, {}); +extern "C" int onemklSsparse_trmv(syclQueue_t device_queue, onemklUplo uplo_val, onemklTranspose opA, onemklDiag diag_val, float *alpha, matrix_handle_t A, float *x, float *beta, float *y) { + auto status = oneapi::mkl::sparse::trmv(device_queue->val, convert(uplo_val), convert(opA), convert(diag_val), *alpha, (oneapi::mkl::sparse::matrix_handle_t) A, x, *beta, y, {}); __FORCE_MKL_FLUSH__(status); return 0; } -extern "C" int onemklDsparse_trmv(syclQueue_t device_queue, onemklUplo uplo_val, onemklTranspose opA, onemklDiag diag_val, double alpha, matrix_handle_t A, double *x, double beta, double *y) { - auto status = oneapi::mkl::sparse::trmv(device_queue->val, convert(uplo_val), convert(opA), convert(diag_val), alpha, (oneapi::mkl::sparse::matrix_handle_t) A, x, beta, y, {}); +extern "C" int onemklDsparse_trmv(syclQueue_t device_queue, onemklUplo uplo_val, onemklTranspose opA, onemklDiag diag_val, double *alpha, matrix_handle_t A, double *x, double *beta, double *y) { + auto status = oneapi::mkl::sparse::trmv(device_queue->val, convert(uplo_val), convert(opA), convert(diag_val), *alpha, (oneapi::mkl::sparse::matrix_handle_t) A, x, *beta, y, {}); __FORCE_MKL_FLUSH__(status); return 0; } -extern "C" int onemklCsparse_trmv(syclQueue_t device_queue, onemklUplo uplo_val, onemklTranspose opA, onemklDiag diag_val, float _Complex alpha, matrix_handle_t A, float _Complex *x, float _Complex beta, float _Complex *y) { - auto status = oneapi::mkl::sparse::trmv(device_queue->val, convert(uplo_val), convert(opA), convert(diag_val), static_cast >(alpha), (oneapi::mkl::sparse::matrix_handle_t) A, reinterpret_cast*>(x), static_cast >(beta), reinterpret_cast*>(y), {}); +extern "C" int onemklCsparse_trmv(syclQueue_t device_queue, onemklUplo uplo_val, onemklTranspose opA, onemklDiag diag_val, float _Complex *alpha, matrix_handle_t A, float _Complex *x, float _Complex *beta, float _Complex *y) { + auto status = oneapi::mkl::sparse::trmv(device_queue->val, convert(uplo_val), convert(opA), convert(diag_val), *reinterpret_cast*>(alpha), (oneapi::mkl::sparse::matrix_handle_t) A, reinterpret_cast*>(x), *reinterpret_cast*>(beta), reinterpret_cast*>(y), {}); __FORCE_MKL_FLUSH__(status); return 0; } -extern "C" int onemklZsparse_trmv(syclQueue_t device_queue, onemklUplo uplo_val, onemklTranspose opA, onemklDiag diag_val, double _Complex alpha, matrix_handle_t A, double _Complex *x, double _Complex beta, double _Complex *y) { - auto status = oneapi::mkl::sparse::trmv(device_queue->val, convert(uplo_val), convert(opA), convert(diag_val), static_cast >(alpha), (oneapi::mkl::sparse::matrix_handle_t) A, reinterpret_cast*>(x), static_cast >(beta), reinterpret_cast*>(y), {}); +extern "C" int onemklZsparse_trmv(syclQueue_t device_queue, onemklUplo uplo_val, onemklTranspose opA, onemklDiag diag_val, double _Complex *alpha, matrix_handle_t A, double _Complex *x, double _Complex *beta, double _Complex *y) { + auto status = oneapi::mkl::sparse::trmv(device_queue->val, convert(uplo_val), convert(opA), convert(diag_val), *reinterpret_cast*>(alpha), (oneapi::mkl::sparse::matrix_handle_t) A, reinterpret_cast*>(x), *reinterpret_cast*>(beta), reinterpret_cast*>(y), {}); __FORCE_MKL_FLUSH__(status); return 0; } @@ -4199,26 +4199,26 @@ extern "C" int onemklZsparse_trsv(syclQueue_t device_queue, onemklUplo uplo_val, return 0; } -extern "C" int onemklSsparse_gemm(syclQueue_t device_queue, onemklLayout layout_val, onemklTranspose opA, onemklTranspose opX, float alpha, matrix_handle_t A, float *X, int64_t columns, int64_t ldx, float beta, float *Y, int64_t ldy) { - auto status = oneapi::mkl::sparse::gemm(device_queue->val, convert(layout_val), convert(opA), convert(opX), alpha, (oneapi::mkl::sparse::matrix_handle_t) A, X, columns, ldx, beta, Y, ldy, {}); +extern "C" int onemklSsparse_gemm(syclQueue_t device_queue, onemklLayout layout_val, onemklTranspose opA, onemklTranspose opX, float *alpha, matrix_handle_t A, float *X, int64_t columns, int64_t ldx, float *beta, float *Y, int64_t ldy) { + auto status = oneapi::mkl::sparse::gemm(device_queue->val, convert(layout_val), convert(opA), convert(opX), *alpha, (oneapi::mkl::sparse::matrix_handle_t) A, X, columns, ldx, *beta, Y, ldy, {}); __FORCE_MKL_FLUSH__(status); return 0; } -extern "C" int onemklDsparse_gemm(syclQueue_t device_queue, onemklLayout layout_val, onemklTranspose opA, onemklTranspose opX, double alpha, matrix_handle_t A, double *X, int64_t columns, int64_t ldx, double beta, double *Y, int64_t ldy) { - auto status = oneapi::mkl::sparse::gemm(device_queue->val, convert(layout_val), convert(opA), convert(opX), alpha, (oneapi::mkl::sparse::matrix_handle_t) A, X, columns, ldx, beta, Y, ldy, {}); +extern "C" int onemklDsparse_gemm(syclQueue_t device_queue, onemklLayout layout_val, onemklTranspose opA, onemklTranspose opX, double *alpha, matrix_handle_t A, double *X, int64_t columns, int64_t ldx, double *beta, double *Y, int64_t ldy) { + auto status = oneapi::mkl::sparse::gemm(device_queue->val, convert(layout_val), convert(opA), convert(opX), *alpha, (oneapi::mkl::sparse::matrix_handle_t) A, X, columns, ldx, *beta, Y, ldy, {}); __FORCE_MKL_FLUSH__(status); return 0; } -extern "C" int onemklCsparse_gemm(syclQueue_t device_queue, onemklLayout layout_val, onemklTranspose opA, onemklTranspose opX, float _Complex alpha, matrix_handle_t A, float _Complex *X, int64_t columns, int64_t ldx, float _Complex beta, float _Complex *Y, int64_t ldy) { - auto status = oneapi::mkl::sparse::gemm(device_queue->val, convert(layout_val), convert(opA), convert(opX), static_cast >(alpha), (oneapi::mkl::sparse::matrix_handle_t) A, reinterpret_cast*>(X), columns, ldx, static_cast >(beta), reinterpret_cast*>(Y), ldy, {}); +extern "C" int onemklCsparse_gemm(syclQueue_t device_queue, onemklLayout layout_val, onemklTranspose opA, onemklTranspose opX, float _Complex *alpha, matrix_handle_t A, float _Complex *X, int64_t columns, int64_t ldx, float _Complex *beta, float _Complex *Y, int64_t ldy) { + auto status = oneapi::mkl::sparse::gemm(device_queue->val, convert(layout_val), convert(opA), convert(opX), *reinterpret_cast*>(alpha), (oneapi::mkl::sparse::matrix_handle_t) A, reinterpret_cast*>(X), columns, ldx, *reinterpret_cast*>(beta), reinterpret_cast*>(Y), ldy, {}); __FORCE_MKL_FLUSH__(status); return 0; } -extern "C" int onemklZsparse_gemm(syclQueue_t device_queue, onemklLayout layout_val, onemklTranspose opA, onemklTranspose opX, double _Complex alpha, matrix_handle_t A, double _Complex *X, int64_t columns, int64_t ldx, double _Complex beta, double _Complex *Y, int64_t ldy) { - auto status = oneapi::mkl::sparse::gemm(device_queue->val, convert(layout_val), convert(opA), convert(opX), static_cast >(alpha), (oneapi::mkl::sparse::matrix_handle_t) A, reinterpret_cast*>(X), columns, ldx, static_cast >(beta), reinterpret_cast*>(Y), ldy, {}); +extern "C" int onemklZsparse_gemm(syclQueue_t device_queue, onemklLayout layout_val, onemklTranspose opA, onemklTranspose opX, double _Complex *alpha, matrix_handle_t A, double _Complex *X, int64_t columns, int64_t ldx, double _Complex *beta, double _Complex *Y, int64_t ldy) { + auto status = oneapi::mkl::sparse::gemm(device_queue->val, convert(layout_val), convert(opA), convert(opX), *reinterpret_cast*>(alpha), (oneapi::mkl::sparse::matrix_handle_t) A, reinterpret_cast*>(X), columns, ldx, *reinterpret_cast*>(beta), reinterpret_cast*>(Y), ldy, {}); __FORCE_MKL_FLUSH__(status); return 0; } @@ -4237,18 +4237,10 @@ extern "C" int onemklXsparse_matmat(syclQueue_t device_queue, matrix_handle_t A, // other // oneMKL keeps a cache of SYCL queues and tries to destroy them when unloading the library. -// that is incompatible with oneAPI.jl destroying queues before that, so expose a function +// that is incompatible with oneAPI.jl destroying queues before that, so call mkl_free_buffers // to manually wipe the device cache when we're destroying queues. -namespace oneapi { -namespace mkl { -namespace gpu { -int clean_gpu_caches(); -} -} -} - extern "C" int onemklDestroy() { - oneapi::mkl::gpu::clean_gpu_caches(); + mkl_free_buffers(); return 0; } diff --git a/deps/src/onemkl.h b/deps/src/onemkl.h index c347281b..0bf42533 100644 --- a/deps/src/onemkl.h +++ b/deps/src/onemkl.h @@ -676,7 +676,7 @@ int onemklSdot(syclQueue_t device_queue, int64_t n, float *x, int64_t incx, floa int onemklDdot(syclQueue_t device_queue, int64_t n, double *x, int64_t incx, double *y, int64_t incy, double *result); -int onemklSsdsdot(syclQueue_t device_queue, int64_t n, float sb, float *x, int64_t incx, float *y, +int onemklSsdsdot(syclQueue_t device_queue, int64_t n, float *sb, float *x, int64_t incx, float *y, int64_t incy, float *result); int onemklHnrm2(syclQueue_t device_queue, int64_t n, short *x, int64_t incx, short *result); @@ -727,9 +727,9 @@ int onemklSrotm(syclQueue_t device_queue, int64_t n, float *x, int64_t incx, flo int onemklDrotm(syclQueue_t device_queue, int64_t n, double *x, int64_t incx, double *y, int64_t incy, double *param); -int onemklSrotmg(syclQueue_t device_queue, float *d1, float *d2, float *x1, float *y, float *param); +int onemklSrotmg(syclQueue_t device_queue, float *d1, float *d2, float *x1, float *y1, float *param); -int onemklDrotmg(syclQueue_t device_queue, double *d1, double *d2, double *x1, double *y, double +int onemklDrotmg(syclQueue_t device_queue, double *d1, double *d2, double *x1, double *y1, double *param); int onemklHscal(syclQueue_t device_queue, int64_t n, short *alpha, short *x, int64_t incx); @@ -1701,21 +1701,22 @@ int onemklSsyevd(syclQueue_t device_queue, onemklJob jobz, onemklUplo uplo, int6 int64_t lda, float *w, float *scratchpad, int64_t scratchpad_size); int64_t onemklSsyevx_scratchpad_size(syclQueue_t device_queue, onemklCompz jobz, onemklRangev - range, onemklUplo uplo, int64_t n, int64_t lda, float vl, - float vu, int64_t il, int64_t iu, float abstol, int64_t ldz); + range, onemklUplo uplo, int64_t n, int64_t lda, float *vl, + float *vu, int64_t il, int64_t iu, float *abstol, int64_t ldz); int64_t onemklDsyevx_scratchpad_size(syclQueue_t device_queue, onemklCompz jobz, onemklRangev - range, onemklUplo uplo, int64_t n, int64_t lda, double vl, - double vu, int64_t il, int64_t iu, double abstol, int64_t ldz); + range, onemklUplo uplo, int64_t n, int64_t lda, double *vl, + double *vu, int64_t il, int64_t iu, double *abstol, int64_t + ldz); int onemklDsyevx(syclQueue_t device_queue, onemklCompz jobz, onemklRangev range, onemklUplo uplo, - int64_t n, double *a, int64_t lda, double vl, double vu, int64_t il, int64_t iu, double - abstol, int64_t *m, double *w, double *z, int64_t ldz, double *scratchpad, int64_t - scratchpad_size); + int64_t n, double *a, int64_t lda, double *vl, double *vu, int64_t il, int64_t iu, + double *abstol, int64_t *m, double *w, double *z, int64_t ldz, double *scratchpad, + int64_t scratchpad_size); int onemklSsyevx(syclQueue_t device_queue, onemklCompz jobz, onemklRangev range, onemklUplo uplo, - int64_t n, float *a, int64_t lda, float vl, float vu, int64_t il, int64_t iu, float - abstol, int64_t *m, float *w, float *z, int64_t ldz, float *scratchpad, int64_t + int64_t n, float *a, int64_t lda, float *vl, float *vu, int64_t il, int64_t iu, float + *abstol, int64_t *m, float *w, float *z, int64_t ldz, float *scratchpad, int64_t scratchpad_size); int64_t onemklSsygvd_scratchpad_size(syclQueue_t device_queue, int64_t itype, onemklJob jobz, @@ -1734,23 +1735,23 @@ int onemklSsygvd(syclQueue_t device_queue, int64_t itype, onemklJob jobz, onemkl int64_t onemklSsygvx_scratchpad_size(syclQueue_t device_queue, int64_t itype, onemklCompz jobz, onemklRangev range, onemklUplo uplo, int64_t n, int64_t lda, - int64_t ldb, float vl, float vu, int64_t il, int64_t iu, float - abstol, int64_t ldz); + int64_t ldb, float *vl, float *vu, int64_t il, int64_t iu, + float *abstol, int64_t ldz); int64_t onemklDsygvx_scratchpad_size(syclQueue_t device_queue, int64_t itype, onemklCompz jobz, onemklRangev range, onemklUplo uplo, int64_t n, int64_t lda, - int64_t ldb, double vl, double vu, int64_t il, int64_t iu, - double abstol, int64_t ldz); + int64_t ldb, double *vl, double *vu, int64_t il, int64_t iu, + double *abstol, int64_t ldz); int onemklDsygvx(syclQueue_t device_queue, int64_t itype, onemklCompz jobz, onemklRangev range, - onemklUplo uplo, int64_t n, double *a, int64_t lda, double *b, int64_t ldb, double vl, - double vu, int64_t il, int64_t iu, double abstol, int64_t *m, double *w, double *z, - int64_t ldz, double *scratchpad, int64_t scratchpad_size); + onemklUplo uplo, int64_t n, double *a, int64_t lda, double *b, int64_t ldb, double + *vl, double *vu, int64_t il, int64_t iu, double *abstol, int64_t *m, double *w, double + *z, int64_t ldz, double *scratchpad, int64_t scratchpad_size); int onemklSsygvx(syclQueue_t device_queue, int64_t itype, onemklCompz jobz, onemklRangev range, - onemklUplo uplo, int64_t n, float *a, int64_t lda, float *b, int64_t ldb, float vl, - float vu, int64_t il, int64_t iu, float abstol, int64_t *m, float *w, float *z, int64_t - ldz, float *scratchpad, int64_t scratchpad_size); + onemklUplo uplo, int64_t n, float *a, int64_t lda, float *b, int64_t ldb, float *vl, + float *vu, int64_t il, int64_t iu, float *abstol, int64_t *m, float *w, float *z, + int64_t ldz, float *scratchpad, int64_t scratchpad_size); int64_t onemklSsytrd_scratchpad_size(syclQueue_t device_queue, onemklUplo uplo, int64_t n, int64_t lda); @@ -2475,61 +2476,63 @@ int onemklXsparse_optimize_trmv(syclQueue_t device_queue, onemklUplo uplo_val, o int onemklXsparse_optimize_trsv(syclQueue_t device_queue, onemklUplo uplo_val, onemklTranspose opA, onemklDiag diag_val, matrix_handle_t A); -int onemklSsparse_gemv(syclQueue_t device_queue, onemklTranspose opA, float alpha, - matrix_handle_t A, float *x, float beta, float *y); +int onemklSsparse_gemv(syclQueue_t device_queue, onemklTranspose opA, float *alpha, + matrix_handle_t A, float *x, float *beta, float *y); -int onemklDsparse_gemv(syclQueue_t device_queue, onemklTranspose opA, double alpha, - matrix_handle_t A, double *x, double beta, double *y); +int onemklDsparse_gemv(syclQueue_t device_queue, onemklTranspose opA, double *alpha, + matrix_handle_t A, double *x, double *beta, double *y); -int onemklCsparse_gemv(syclQueue_t device_queue, onemklTranspose opA, float _Complex alpha, - matrix_handle_t A, float _Complex *x, float _Complex beta, float _Complex *y); - -int onemklZsparse_gemv(syclQueue_t device_queue, onemklTranspose opA, double _Complex alpha, - matrix_handle_t A, double _Complex *x, double _Complex beta, double _Complex +int onemklCsparse_gemv(syclQueue_t device_queue, onemklTranspose opA, float _Complex *alpha, + matrix_handle_t A, float _Complex *x, float _Complex *beta, float _Complex *y); -int onemklSsparse_gemvdot(syclQueue_t device_queue, onemklTranspose opA, float alpha, - matrix_handle_t A, float *x, float beta, float *y, float *d); +int onemklZsparse_gemv(syclQueue_t device_queue, onemklTranspose opA, double _Complex *alpha, + matrix_handle_t A, double _Complex *x, double _Complex *beta, double + _Complex *y); -int onemklDsparse_gemvdot(syclQueue_t device_queue, onemklTranspose opA, double alpha, - matrix_handle_t A, double *x, double beta, double *y, double *d); +int onemklSsparse_gemvdot(syclQueue_t device_queue, onemklTranspose opA, float *alpha, + matrix_handle_t A, float *x, float *beta, float *y, float *d); -int onemklCsparse_gemvdot(syclQueue_t device_queue, onemklTranspose opA, float _Complex alpha, - matrix_handle_t A, float _Complex *x, float _Complex beta, float _Complex - *y, float _Complex *d); +int onemklDsparse_gemvdot(syclQueue_t device_queue, onemklTranspose opA, double *alpha, + matrix_handle_t A, double *x, double *beta, double *y, double *d); -int onemklZsparse_gemvdot(syclQueue_t device_queue, onemklTranspose opA, double _Complex alpha, - matrix_handle_t A, double _Complex *x, double _Complex beta, double - _Complex *y, double _Complex *d); +int onemklCsparse_gemvdot(syclQueue_t device_queue, onemklTranspose opA, float _Complex *alpha, + matrix_handle_t A, float _Complex *x, float _Complex *beta, float + _Complex *y, float _Complex *d); -int onemklSsparse_symv(syclQueue_t device_queue, onemklUplo uplo_val, float alpha, - matrix_handle_t A, float *x, float beta, float *y); +int onemklZsparse_gemvdot(syclQueue_t device_queue, onemklTranspose opA, double _Complex *alpha, + matrix_handle_t A, double _Complex *x, double _Complex *beta, double + _Complex *y, double _Complex *d); -int onemklDsparse_symv(syclQueue_t device_queue, onemklUplo uplo_val, double alpha, - matrix_handle_t A, double *x, double beta, double *y); +int onemklSsparse_symv(syclQueue_t device_queue, onemklUplo uplo_val, float *alpha, + matrix_handle_t A, float *x, float *beta, float *y); -int onemklCsparse_symv(syclQueue_t device_queue, onemklUplo uplo_val, float _Complex alpha, - matrix_handle_t A, float _Complex *x, float _Complex beta, float _Complex *y); +int onemklDsparse_symv(syclQueue_t device_queue, onemklUplo uplo_val, double *alpha, + matrix_handle_t A, double *x, double *beta, double *y); -int onemklZsparse_symv(syclQueue_t device_queue, onemklUplo uplo_val, double _Complex alpha, - matrix_handle_t A, double _Complex *x, double _Complex beta, double _Complex +int onemklCsparse_symv(syclQueue_t device_queue, onemklUplo uplo_val, float _Complex *alpha, + matrix_handle_t A, float _Complex *x, float _Complex *beta, float _Complex *y); +int onemklZsparse_symv(syclQueue_t device_queue, onemklUplo uplo_val, double _Complex *alpha, + matrix_handle_t A, double _Complex *x, double _Complex *beta, double + _Complex *y); + int onemklSsparse_trmv(syclQueue_t device_queue, onemklUplo uplo_val, onemklTranspose opA, - onemklDiag diag_val, float alpha, matrix_handle_t A, float *x, float beta, + onemklDiag diag_val, float *alpha, matrix_handle_t A, float *x, float *beta, float *y); int onemklDsparse_trmv(syclQueue_t device_queue, onemklUplo uplo_val, onemklTranspose opA, - onemklDiag diag_val, double alpha, matrix_handle_t A, double *x, double - beta, double *y); + onemklDiag diag_val, double *alpha, matrix_handle_t A, double *x, double + *beta, double *y); int onemklCsparse_trmv(syclQueue_t device_queue, onemklUplo uplo_val, onemklTranspose opA, - onemklDiag diag_val, float _Complex alpha, matrix_handle_t A, float - _Complex *x, float _Complex beta, float _Complex *y); + onemklDiag diag_val, float _Complex *alpha, matrix_handle_t A, float + _Complex *x, float _Complex *beta, float _Complex *y); int onemklZsparse_trmv(syclQueue_t device_queue, onemklUplo uplo_val, onemklTranspose opA, - onemklDiag diag_val, double _Complex alpha, matrix_handle_t A, double - _Complex *x, double _Complex beta, double _Complex *y); + onemklDiag diag_val, double _Complex *alpha, matrix_handle_t A, double + _Complex *x, double _Complex *beta, double _Complex *y); int onemklSsparse_trsv(syclQueue_t device_queue, onemklUplo uplo_val, onemklTranspose opA, onemklDiag diag_val, matrix_handle_t A, float *x, float *y); @@ -2546,21 +2549,21 @@ int onemklZsparse_trsv(syclQueue_t device_queue, onemklUplo uplo_val, onemklTran _Complex *x, double _Complex *y); int onemklSsparse_gemm(syclQueue_t device_queue, onemklLayout layout_val, onemklTranspose opA, - onemklTranspose opX, float alpha, matrix_handle_t A, float *X, int64_t - columns, int64_t ldx, float beta, float *Y, int64_t ldy); + onemklTranspose opX, float *alpha, matrix_handle_t A, float *X, int64_t + columns, int64_t ldx, float *beta, float *Y, int64_t ldy); int onemklDsparse_gemm(syclQueue_t device_queue, onemklLayout layout_val, onemklTranspose opA, - onemklTranspose opX, double alpha, matrix_handle_t A, double *X, int64_t - columns, int64_t ldx, double beta, double *Y, int64_t ldy); + onemklTranspose opX, double *alpha, matrix_handle_t A, double *X, int64_t + columns, int64_t ldx, double *beta, double *Y, int64_t ldy); int onemklCsparse_gemm(syclQueue_t device_queue, onemklLayout layout_val, onemklTranspose opA, - onemklTranspose opX, float _Complex alpha, matrix_handle_t A, float - _Complex *X, int64_t columns, int64_t ldx, float _Complex beta, float + onemklTranspose opX, float _Complex *alpha, matrix_handle_t A, float + _Complex *X, int64_t columns, int64_t ldx, float _Complex *beta, float _Complex *Y, int64_t ldy); int onemklZsparse_gemm(syclQueue_t device_queue, onemklLayout layout_val, onemklTranspose opA, - onemklTranspose opX, double _Complex alpha, matrix_handle_t A, double - _Complex *X, int64_t columns, int64_t ldx, double _Complex beta, double + onemklTranspose opX, double _Complex *alpha, matrix_handle_t A, double + _Complex *X, int64_t columns, int64_t ldx, double _Complex *beta, double _Complex *Y, int64_t ldy); int onemklXsparse_set_matmat_data(matmat_descr_t descr, onemklMatrixView viewA, onemklTranspose diff --git a/lib/support/liboneapi_support.jl b/lib/support/liboneapi_support.jl index cc144ee2..5a5ca871 100644 --- a/lib/support/liboneapi_support.jl +++ b/lib/support/liboneapi_support.jl @@ -192,72 +192,72 @@ function onemklHgemm_batch(device_queue, transa, transb, m, n, k, alpha, a, lda, beta, c, ldc, group_count, group_size) @ccall liboneapi_support.onemklHgemm_batch(device_queue::syclQueue_t, transa::onemklTranspose, - transb::onemklTranspose, m::Ptr{Int64}, - n::Ptr{Int64}, k::Ptr{Int64}, - alpha::Ptr{UInt16}, a::Ptr{Ptr{Cshort}}, - lda::Ptr{Int64}, b::Ptr{Ptr{Cshort}}, - ldb::Ptr{Int64}, beta::Ptr{UInt16}, - c::Ptr{Ptr{Cshort}}, ldc::Ptr{Int64}, - group_count::Int64, - group_size::Ptr{Int64})::Cint + transb::onemklTranspose, m::ZePtr{Int64}, + n::ZePtr{Int64}, k::ZePtr{Int64}, + alpha::ZePtr{Float16}, + a::ZePtr{Ptr{Float16}}, lda::ZePtr{Int64}, + b::ZePtr{Ptr{Float16}}, ldb::ZePtr{Int64}, + beta::ZePtr{Float16}, c::ZePtr{Ptr{Float16}}, + ldc::ZePtr{Int64}, group_count::Int64, + group_size::ZePtr{Int64})::Cint end function onemklSgemm_batch(device_queue, transa, transb, m, n, k, alpha, a, lda, b, ldb, beta, c, ldc, group_count, group_size) @ccall liboneapi_support.onemklSgemm_batch(device_queue::syclQueue_t, transa::onemklTranspose, - transb::onemklTranspose, m::Ptr{Int64}, - n::Ptr{Int64}, k::Ptr{Int64}, - alpha::Ptr{Cfloat}, a::Ptr{Ptr{Cfloat}}, - lda::Ptr{Int64}, b::Ptr{Ptr{Cfloat}}, - ldb::Ptr{Int64}, beta::Ptr{Cfloat}, - c::Ptr{Ptr{Cfloat}}, ldc::Ptr{Int64}, + transb::onemklTranspose, m::ZePtr{Int64}, + n::ZePtr{Int64}, k::ZePtr{Int64}, + alpha::ZePtr{Cfloat}, a::ZePtr{Ptr{Cfloat}}, + lda::ZePtr{Int64}, b::ZePtr{Ptr{Cfloat}}, + ldb::ZePtr{Int64}, beta::ZePtr{Cfloat}, + c::ZePtr{Ptr{Cfloat}}, ldc::ZePtr{Int64}, group_count::Int64, - group_size::Ptr{Int64})::Cint + group_size::ZePtr{Int64})::Cint end function onemklDgemm_batch(device_queue, transa, transb, m, n, k, alpha, a, lda, b, ldb, beta, c, ldc, group_count, group_size) @ccall liboneapi_support.onemklDgemm_batch(device_queue::syclQueue_t, transa::onemklTranspose, - transb::onemklTranspose, m::Ptr{Int64}, - n::Ptr{Int64}, k::Ptr{Int64}, - alpha::Ptr{Cdouble}, a::Ptr{Ptr{Cdouble}}, - lda::Ptr{Int64}, b::Ptr{Ptr{Cdouble}}, - ldb::Ptr{Int64}, beta::Ptr{Cdouble}, - c::Ptr{Ptr{Cdouble}}, ldc::Ptr{Int64}, - group_count::Int64, - group_size::Ptr{Int64})::Cint + transb::onemklTranspose, m::ZePtr{Int64}, + n::ZePtr{Int64}, k::ZePtr{Int64}, + alpha::ZePtr{Cdouble}, + a::ZePtr{Ptr{Cdouble}}, lda::ZePtr{Int64}, + b::ZePtr{Ptr{Cdouble}}, ldb::ZePtr{Int64}, + beta::ZePtr{Cdouble}, c::ZePtr{Ptr{Cdouble}}, + ldc::ZePtr{Int64}, group_count::Int64, + group_size::ZePtr{Int64})::Cint end function onemklCgemm_batch(device_queue, transa, transb, m, n, k, alpha, a, lda, b, ldb, beta, c, ldc, group_count, group_size) @ccall liboneapi_support.onemklCgemm_batch(device_queue::syclQueue_t, transa::onemklTranspose, - transb::onemklTranspose, m::Ptr{Int64}, - n::Ptr{Int64}, k::Ptr{Int64}, - alpha::Ptr{ComplexF32}, - a::Ptr{Ptr{ComplexF32}}, lda::Ptr{Int64}, - b::Ptr{Ptr{ComplexF32}}, ldb::Ptr{Int64}, - beta::Ptr{ComplexF32}, - c::Ptr{Ptr{ComplexF32}}, ldc::Ptr{Int64}, + transb::onemklTranspose, m::ZePtr{Int64}, + n::ZePtr{Int64}, k::ZePtr{Int64}, + alpha::ZePtr{ComplexF32}, + a::ZePtr{Ptr{ComplexF32}}, lda::ZePtr{Int64}, + b::ZePtr{Ptr{ComplexF32}}, ldb::ZePtr{Int64}, + beta::ZePtr{ComplexF32}, + c::ZePtr{Ptr{ComplexF32}}, ldc::ZePtr{Int64}, group_count::Int64, - group_size::Ptr{Int64})::Cint + group_size::ZePtr{Int64})::Cint end function onemklZgemm_batch(device_queue, transa, transb, m, n, k, alpha, a, lda, b, ldb, beta, c, ldc, group_count, group_size) @ccall liboneapi_support.onemklZgemm_batch(device_queue::syclQueue_t, transa::onemklTranspose, - transb::onemklTranspose, m::Ptr{Int64}, - n::Ptr{Int64}, k::Ptr{Int64}, - alpha::Ptr{ComplexF32}, - a::Ptr{Ptr{ComplexF32}}, lda::Ptr{Int64}, - b::Ptr{Ptr{ComplexF32}}, ldb::Ptr{Int64}, - beta::Ptr{ComplexF32}, - c::Ptr{Ptr{ComplexF32}}, ldc::Ptr{Int64}, + transb::onemklTranspose, m::ZePtr{Int64}, + n::ZePtr{Int64}, k::ZePtr{Int64}, + alpha::ZePtr{ComplexF64}, + a::ZePtr{Ptr{ComplexF64}}, lda::ZePtr{Int64}, + b::ZePtr{Ptr{ComplexF64}}, ldb::ZePtr{Int64}, + beta::ZePtr{ComplexF64}, + c::ZePtr{Ptr{ComplexF64}}, ldc::ZePtr{Int64}, group_count::Int64, - group_size::Ptr{Int64})::Cint + group_size::ZePtr{Int64})::Cint end function onemklStrsm_batch(device_queue, left_right, upper_lower, transa, unit_diag, m, n, @@ -266,12 +266,12 @@ function onemklStrsm_batch(device_queue, left_right, upper_lower, transa, unit_d left_right::onemklSide, upper_lower::onemklUplo, transa::onemklTranspose, - unit_diag::onemklDiag, m::Ptr{Int64}, - n::Ptr{Int64}, alpha::Ptr{Cfloat}, - a::Ptr{Ptr{Cfloat}}, lda::Ptr{Int64}, - b::Ptr{Ptr{Cfloat}}, ldb::Ptr{Int64}, + unit_diag::onemklDiag, m::ZePtr{Int64}, + n::ZePtr{Int64}, alpha::ZePtr{Cfloat}, + a::ZePtr{Ptr{Cfloat}}, lda::ZePtr{Int64}, + b::ZePtr{Ptr{Cfloat}}, ldb::ZePtr{Int64}, group_count::Int64, - group_size::Ptr{Int64})::Cint + group_size::ZePtr{Int64})::Cint end function onemklDtrsm_batch(device_queue, left_right, upper_lower, transa, unit_diag, m, n, @@ -280,12 +280,12 @@ function onemklDtrsm_batch(device_queue, left_right, upper_lower, transa, unit_d left_right::onemklSide, upper_lower::onemklUplo, transa::onemklTranspose, - unit_diag::onemklDiag, m::Ptr{Int64}, - n::Ptr{Int64}, alpha::Ptr{Cdouble}, - a::Ptr{Ptr{Cdouble}}, lda::Ptr{Int64}, - b::Ptr{Ptr{Cdouble}}, ldb::Ptr{Int64}, + unit_diag::onemklDiag, m::ZePtr{Int64}, + n::ZePtr{Int64}, alpha::ZePtr{Cdouble}, + a::ZePtr{Ptr{Cdouble}}, lda::ZePtr{Int64}, + b::ZePtr{Ptr{Cdouble}}, ldb::ZePtr{Int64}, group_count::Int64, - group_size::Ptr{Int64})::Cint + group_size::ZePtr{Int64})::Cint end function onemklCtrsm_batch(device_queue, left_right, upper_lower, transa, unit_diag, m, n, @@ -294,12 +294,12 @@ function onemklCtrsm_batch(device_queue, left_right, upper_lower, transa, unit_d left_right::onemklSide, upper_lower::onemklUplo, transa::onemklTranspose, - unit_diag::onemklDiag, m::Ptr{Int64}, - n::Ptr{Int64}, alpha::Ptr{ComplexF32}, - a::Ptr{Ptr{ComplexF32}}, lda::Ptr{Int64}, - b::Ptr{Ptr{ComplexF32}}, ldb::Ptr{Int64}, + unit_diag::onemklDiag, m::ZePtr{Int64}, + n::ZePtr{Int64}, alpha::ZePtr{ComplexF32}, + a::ZePtr{Ptr{ComplexF32}}, lda::ZePtr{Int64}, + b::ZePtr{Ptr{ComplexF32}}, ldb::ZePtr{Int64}, group_count::Int64, - group_size::Ptr{Int64})::Cint + group_size::ZePtr{Int64})::Cint end function onemklZtrsm_batch(device_queue, left_right, upper_lower, transa, unit_diag, m, n, @@ -308,12 +308,12 @@ function onemklZtrsm_batch(device_queue, left_right, upper_lower, transa, unit_d left_right::onemklSide, upper_lower::onemklUplo, transa::onemklTranspose, - unit_diag::onemklDiag, m::Ptr{Int64}, - n::Ptr{Int64}, alpha::Ptr{ComplexF32}, - a::Ptr{Ptr{ComplexF32}}, lda::Ptr{Int64}, - b::Ptr{Ptr{ComplexF32}}, ldb::Ptr{Int64}, + unit_diag::onemklDiag, m::ZePtr{Int64}, + n::ZePtr{Int64}, alpha::ZePtr{ComplexF64}, + a::ZePtr{Ptr{ComplexF64}}, lda::ZePtr{Int64}, + b::ZePtr{Ptr{ComplexF64}}, ldb::ZePtr{Int64}, group_count::Int64, - group_size::Ptr{Int64})::Cint + group_size::ZePtr{Int64})::Cint end function onemklHgemm(device_queue, transa, transb, m, n, k, alpha, a, lda, b, ldb, beta, c, @@ -740,14 +740,14 @@ end function onemklCgeru(device_queue, m, n, alpha, x, incx, y, incy, a, lda) @ccall liboneapi_support.onemklCgeru(device_queue::syclQueue_t, m::Int64, n::Int64, - alpha::Ptr{ComplexF32}, x::ZePtr{ComplexF32}, + alpha::Ref{ComplexF32}, x::ZePtr{ComplexF32}, incx::Int64, y::ZePtr{ComplexF32}, incy::Int64, a::ZePtr{ComplexF32}, lda::Int64)::Cint end function onemklZgeru(device_queue, m, n, alpha, x, incx, y, incy, a, lda) @ccall liboneapi_support.onemklZgeru(device_queue::syclQueue_t, m::Int64, n::Int64, - alpha::Ptr{ComplexF32}, x::ZePtr{ComplexF64}, + alpha::Ref{ComplexF64}, x::ZePtr{ComplexF64}, incx::Int64, y::ZePtr{ComplexF64}, incy::Int64, a::ZePtr{ComplexF64}, lda::Int64)::Cint end @@ -820,46 +820,46 @@ end function onemklChpmv(device_queue, upper_lower, n, alpha, a, x, incx, beta, y, incy) @ccall liboneapi_support.onemklChpmv(device_queue::syclQueue_t, upper_lower::onemklUplo, - n::Int64, alpha::Ptr{ComplexF32}, - a::Ptr{ComplexF32}, x::Ptr{ComplexF32}, - incx::Int64, beta::Ptr{ComplexF32}, - y::Ptr{ComplexF32}, incy::Int64)::Cint + n::Int64, alpha::Ref{ComplexF32}, + a::ZePtr{ComplexF32}, x::ZePtr{ComplexF32}, + incx::Int64, beta::Ref{ComplexF32}, + y::ZePtr{ComplexF32}, incy::Int64)::Cint end function onemklZhpmv(device_queue, upper_lower, n, alpha, a, x, incx, beta, y, incy) @ccall liboneapi_support.onemklZhpmv(device_queue::syclQueue_t, upper_lower::onemklUplo, - n::Int64, alpha::Ptr{ComplexF32}, - a::Ptr{ComplexF32}, x::Ptr{ComplexF32}, - incx::Int64, beta::Ptr{ComplexF32}, - y::Ptr{ComplexF32}, incy::Int64)::Cint + n::Int64, alpha::Ref{ComplexF64}, + a::ZePtr{ComplexF64}, x::ZePtr{ComplexF64}, + incx::Int64, beta::Ref{ComplexF64}, + y::ZePtr{ComplexF64}, incy::Int64)::Cint end function onemklChpr(device_queue, upper_lower, n, alpha, x, incx, a) @ccall liboneapi_support.onemklChpr(device_queue::syclQueue_t, upper_lower::onemklUplo, - n::Int64, alpha::Ptr{Cfloat}, x::Ptr{ComplexF32}, - incx::Int64, a::Ptr{ComplexF32})::Cint + n::Int64, alpha::Ref{Float32}, x::ZePtr{ComplexF32}, + incx::Int64, a::ZePtr{ComplexF32})::Cint end function onemklZhpr(device_queue, upper_lower, n, alpha, x, incx, a) @ccall liboneapi_support.onemklZhpr(device_queue::syclQueue_t, upper_lower::onemklUplo, - n::Int64, alpha::Ptr{Cdouble}, x::Ptr{ComplexF32}, - incx::Int64, a::Ptr{ComplexF32})::Cint + n::Int64, alpha::Ref{Float64}, x::ZePtr{ComplexF64}, + incx::Int64, a::ZePtr{ComplexF64})::Cint end function onemklChpr2(device_queue, upper_lower, n, alpha, x, incx, y, incy, a) @ccall liboneapi_support.onemklChpr2(device_queue::syclQueue_t, upper_lower::onemklUplo, - n::Int64, alpha::Ptr{ComplexF32}, - x::Ptr{ComplexF32}, incx::Int64, - y::Ptr{ComplexF32}, incy::Int64, - a::Ptr{ComplexF32})::Cint + n::Int64, alpha::Ref{ComplexF32}, + x::ZePtr{ComplexF32}, incx::Int64, + y::ZePtr{ComplexF32}, incy::Int64, + a::ZePtr{ComplexF32})::Cint end function onemklZhpr2(device_queue, upper_lower, n, alpha, x, incx, y, incy, a) @ccall liboneapi_support.onemklZhpr2(device_queue::syclQueue_t, upper_lower::onemklUplo, - n::Int64, alpha::Ptr{ComplexF32}, - x::Ptr{ComplexF32}, incx::Int64, - y::Ptr{ComplexF32}, incy::Int64, - a::Ptr{ComplexF32})::Cint + n::Int64, alpha::Ref{ComplexF64}, + x::ZePtr{ComplexF64}, incx::Int64, + y::ZePtr{ComplexF64}, incy::Int64, + a::ZePtr{ComplexF64})::Cint end function onemklSsbmv(device_queue, upper_lower, n, k, alpha, a, lda, x, incx, beta, y, incy) @@ -940,72 +940,72 @@ end function onemklSsyr2(device_queue, upper_lower, n, alpha, x, incx, y, incy, a, lda) @ccall liboneapi_support.onemklSsyr2(device_queue::syclQueue_t, upper_lower::onemklUplo, - n::Int64, alpha::Ptr{Cfloat}, x::Ptr{Cfloat}, - incx::Int64, y::Ptr{Cfloat}, incy::Int64, - a::Ptr{Cfloat}, lda::Int64)::Cint + n::Int64, alpha::Ref{Cfloat}, x::ZePtr{Cfloat}, + incx::Int64, y::ZePtr{Cfloat}, incy::Int64, + a::ZePtr{Cfloat}, lda::Int64)::Cint end function onemklDsyr2(device_queue, upper_lower, n, alpha, x, incx, y, incy, a, lda) @ccall liboneapi_support.onemklDsyr2(device_queue::syclQueue_t, upper_lower::onemklUplo, - n::Int64, alpha::Ptr{Cdouble}, x::Ptr{Cdouble}, - incx::Int64, y::Ptr{Cdouble}, incy::Int64, - a::Ptr{Cdouble}, lda::Int64)::Cint + n::Int64, alpha::Ref{Cdouble}, x::ZePtr{Cdouble}, + incx::Int64, y::ZePtr{Cdouble}, incy::Int64, + a::ZePtr{Cdouble}, lda::Int64)::Cint end function onemklCsyr2(device_queue, upper_lower, n, alpha, x, incx, y, incy, a, lda) @ccall liboneapi_support.onemklCsyr2(device_queue::syclQueue_t, upper_lower::onemklUplo, - n::Int64, alpha::Ptr{ComplexF32}, - x::Ptr{ComplexF32}, incx::Int64, - y::Ptr{ComplexF32}, incy::Int64, - a::Ptr{ComplexF32}, lda::Int64)::Cint + n::Int64, alpha::Ref{ComplexF32}, + x::ZePtr{ComplexF32}, incx::Int64, + y::ZePtr{ComplexF32}, incy::Int64, + a::ZePtr{ComplexF32}, lda::Int64)::Cint end function onemklZsyr2(device_queue, upper_lower, n, alpha, x, incx, y, incy, a, lda) @ccall liboneapi_support.onemklZsyr2(device_queue::syclQueue_t, upper_lower::onemklUplo, - n::Int64, alpha::Ptr{ComplexF32}, - x::Ptr{ComplexF32}, incx::Int64, - y::Ptr{ComplexF32}, incy::Int64, - a::Ptr{ComplexF32}, lda::Int64)::Cint + n::Int64, alpha::Ref{ComplexF64}, + x::ZePtr{ComplexF64}, incx::Int64, + y::ZePtr{ComplexF64}, incy::Int64, + a::ZePtr{ComplexF64}, lda::Int64)::Cint end function onemklSspmv(device_queue, upper_lower, n, alpha, a, x, incx, beta, y, incy) @ccall liboneapi_support.onemklSspmv(device_queue::syclQueue_t, upper_lower::onemklUplo, - n::Int64, alpha::Ptr{Cfloat}, a::Ptr{Cfloat}, - x::Ptr{Cfloat}, incx::Int64, beta::Ptr{Cfloat}, - y::Ptr{Cfloat}, incy::Int64)::Cint + n::Int64, alpha::Ref{Cfloat}, a::ZePtr{Cfloat}, + x::ZePtr{Cfloat}, incx::Int64, beta::Ref{Cfloat}, + y::ZePtr{Cfloat}, incy::Int64)::Cint end function onemklDspmv(device_queue, upper_lower, n, alpha, a, x, incx, beta, y, incy) @ccall liboneapi_support.onemklDspmv(device_queue::syclQueue_t, upper_lower::onemklUplo, - n::Int64, alpha::Ptr{Cdouble}, a::Ptr{Cdouble}, - x::Ptr{Cdouble}, incx::Int64, beta::Ptr{Cdouble}, - y::Ptr{Cdouble}, incy::Int64)::Cint + n::Int64, alpha::Ref{Cdouble}, a::ZePtr{Cdouble}, + x::ZePtr{Cdouble}, incx::Int64, beta::Ref{Cdouble}, + y::ZePtr{Cdouble}, incy::Int64)::Cint end function onemklSspr(device_queue, upper_lower, n, alpha, x, incx, a) @ccall liboneapi_support.onemklSspr(device_queue::syclQueue_t, upper_lower::onemklUplo, - n::Int64, alpha::Ptr{Cfloat}, x::Ptr{Cfloat}, - incx::Int64, a::Ptr{Cfloat})::Cint + n::Int64, alpha::Ref{Cfloat}, x::ZePtr{Cfloat}, + incx::Int64, a::ZePtr{Cfloat})::Cint end function onemklDspr(device_queue, upper_lower, n, alpha, x, incx, a) @ccall liboneapi_support.onemklDspr(device_queue::syclQueue_t, upper_lower::onemklUplo, - n::Int64, alpha::Ptr{Cdouble}, x::Ptr{Cdouble}, - incx::Int64, a::Ptr{Cdouble})::Cint + n::Int64, alpha::Ref{Cdouble}, x::ZePtr{Cdouble}, + incx::Int64, a::ZePtr{Cdouble})::Cint end function onemklSspr2(device_queue, upper_lower, n, alpha, x, incx, y, incy, a) @ccall liboneapi_support.onemklSspr2(device_queue::syclQueue_t, upper_lower::onemklUplo, - n::Int64, alpha::Ptr{Cfloat}, x::Ptr{Cfloat}, - incx::Int64, y::Ptr{Cfloat}, incy::Int64, - a::Ptr{Cfloat})::Cint + n::Int64, alpha::Ref{Cfloat}, x::ZePtr{Cfloat}, + incx::Int64, y::ZePtr{Cfloat}, incy::Int64, + a::ZePtr{Cfloat})::Cint end function onemklDspr2(device_queue, upper_lower, n, alpha, x, incx, y, incy, a) @ccall liboneapi_support.onemklDspr2(device_queue::syclQueue_t, upper_lower::onemklUplo, - n::Int64, alpha::Ptr{Cdouble}, x::Ptr{Cdouble}, - incx::Int64, y::Ptr{Cdouble}, incy::Int64, - a::Ptr{Cdouble})::Cint + n::Int64, alpha::Ref{Cdouble}, x::ZePtr{Cdouble}, + incx::Int64, y::ZePtr{Cdouble}, incy::Int64, + a::ZePtr{Cdouble})::Cint end function onemklStbmv(device_queue, upper_lower, trans, unit_diag, n, k, a, lda, x, incx) @@ -1381,9 +1381,10 @@ function onemklDdot(device_queue, n, x, incx, y, incy, result) end function onemklSsdsdot(device_queue, n, sb, x, incx, y, incy, result) - @ccall liboneapi_support.onemklSsdsdot(device_queue::syclQueue_t, n::Int64, sb::Cfloat, - x::Ptr{Cfloat}, incx::Int64, y::Ptr{Cfloat}, - incy::Int64, result::Ptr{Cfloat})::Cint + @ccall liboneapi_support.onemklSsdsdot(device_queue::syclQueue_t, n::Int64, + sb::Ref{Float32}, x::ZePtr{Float32}, incx::Int64, + y::ZePtr{Float32}, incy::Int64, + result::Ref{Float32})::Cint end function onemklHnrm2(device_queue, n, x, incx, result) @@ -1419,47 +1420,47 @@ end function onemklHrot(device_queue, n, x, incx, y, incy, c, s) @ccall liboneapi_support.onemklHrot(device_queue::syclQueue_t, n::Int64, x::ZePtr{Float16}, incx::Int64, y::ZePtr{Float16}, - incy::Int64, c::Ptr{Cshort}, s::Ptr{Cshort})::Cint + incy::Int64, c::Ref{Float16}, s::Ref{Float16})::Cint end function onemklSrot(device_queue, n, x, incx, y, incy, c, s) @ccall liboneapi_support.onemklSrot(device_queue::syclQueue_t, n::Int64, x::ZePtr{Cfloat}, incx::Int64, y::ZePtr{Cfloat}, - incy::Int64, c::Ptr{Cfloat}, s::Ptr{Cfloat})::Cint + incy::Int64, c::Ref{Cfloat}, s::Ref{Cfloat})::Cint end function onemklDrot(device_queue, n, x, incx, y, incy, c, s) @ccall liboneapi_support.onemklDrot(device_queue::syclQueue_t, n::Int64, x::ZePtr{Cdouble}, incx::Int64, y::ZePtr{Cdouble}, - incy::Int64, c::Ptr{Cdouble}, s::Ptr{Cdouble})::Cint + incy::Int64, c::Ref{Cdouble}, s::Ref{Cdouble})::Cint end function onemklCSrot(device_queue, n, x, incx, y, incy, c, s) @ccall liboneapi_support.onemklCSrot(device_queue::syclQueue_t, n::Int64, x::ZePtr{ComplexF32}, incx::Int64, - y::ZePtr{ComplexF32}, incy::Int64, c::Ptr{Cfloat}, - s::Ptr{Cfloat})::Cint + y::ZePtr{ComplexF32}, incy::Int64, c::Ref{Float32}, + s::Ref{Float32})::Cint end function onemklCrot(device_queue, n, x, incx, y, incy, c, s) @ccall liboneapi_support.onemklCrot(device_queue::syclQueue_t, n::Int64, x::ZePtr{ComplexF32}, incx::Int64, - y::ZePtr{ComplexF32}, incy::Int64, c::Ptr{Cfloat}, - s::Ptr{ComplexF32})::Cint + y::ZePtr{ComplexF32}, incy::Int64, c::Ref{Float32}, + s::Ref{ComplexF32})::Cint end function onemklZDrot(device_queue, n, x, incx, y, incy, c, s) @ccall liboneapi_support.onemklZDrot(device_queue::syclQueue_t, n::Int64, x::ZePtr{ComplexF64}, incx::Int64, - y::ZePtr{ComplexF64}, incy::Int64, c::Ptr{Cdouble}, - s::Ptr{Cdouble})::Cint + y::ZePtr{ComplexF64}, incy::Int64, c::Ref{Float64}, + s::Ref{Float64})::Cint end function onemklZrot(device_queue, n, x, incx, y, incy, c, s) @ccall liboneapi_support.onemklZrot(device_queue::syclQueue_t, n::Int64, x::ZePtr{ComplexF64}, incx::Int64, - y::ZePtr{ComplexF64}, incy::Int64, c::Ptr{Cdouble}, - s::Ptr{ComplexF32})::Cint + y::ZePtr{ComplexF64}, incy::Int64, c::Ref{Float64}, + s::Ref{ComplexF64})::Cint end function onemklSrotg(device_queue, a, b, c, s) @@ -1498,16 +1499,16 @@ function onemklDrotm(device_queue, n, x, incx, y, incy, param) incy::Int64, param::Ptr{Cdouble})::Cint end -function onemklSrotmg(device_queue, d1, d2, x1, y, param) +function onemklSrotmg(device_queue, d1, d2, x1, y1, param) @ccall liboneapi_support.onemklSrotmg(device_queue::syclQueue_t, d1::Ptr{Cfloat}, - d2::Ptr{Cfloat}, x1::Ptr{Cfloat}, y::Ptr{Cfloat}, + d2::Ptr{Cfloat}, x1::Ptr{Cfloat}, y1::Ptr{Cfloat}, param::Ptr{Cfloat})::Cint end -function onemklDrotmg(device_queue, d1, d2, x1, y, param) +function onemklDrotmg(device_queue, d1, d2, x1, y1, param) @ccall liboneapi_support.onemklDrotmg(device_queue::syclQueue_t, d1::Ptr{Cdouble}, d2::Ptr{Cdouble}, x1::Ptr{Cdouble}, - y::Ptr{Cdouble}, param::Ptr{Cdouble})::Cint + y1::Ptr{Cdouble}, param::Ptr{Cdouble})::Cint end function onemklHscal(device_queue, n, alpha, x, incx) @@ -1530,13 +1531,13 @@ end function onemklCSscal(device_queue, n, alpha, x, incx) @ccall liboneapi_support.onemklCSscal(device_queue::syclQueue_t, n::Int64, - alpha::Ptr{Cfloat}, x::ZePtr{ComplexF32}, + alpha::Ref{Float32}, x::ZePtr{ComplexF32}, incx::Int64)::Cint end function onemklZDscal(device_queue, n, alpha, x, incx) @ccall liboneapi_support.onemklZDscal(device_queue::syclQueue_t, n::Int64, - alpha::Ptr{Cdouble}, x::ZePtr{ComplexF64}, + alpha::Ref{Float64}, x::ZePtr{ComplexF64}, incx::Int64)::Cint end @@ -1583,11 +1584,12 @@ function onemklHgemm_batch_strided(device_queue, transa, transb, m, n, k, alpha, transa::onemklTranspose, transb::onemklTranspose, m::Int64, n::Int64, k::Int64, - alpha::Ptr{Cshort}, a::Ptr{Cshort}, - lda::Int64, stride_a::Int64, - b::Ptr{Cshort}, ldb::Int64, - stride_b::Int64, beta::Ptr{Cshort}, - c::Ptr{Cshort}, ldc::Int64, + alpha::Ref{Float16}, + a::ZePtr{Float16}, lda::Int64, + stride_a::Int64, b::ZePtr{Float16}, + ldb::Int64, stride_b::Int64, + beta::Ref{Float16}, + c::ZePtr{Float16}, ldc::Int64, stride_c::Int64, batch_size::Int64)::Cint end @@ -1599,11 +1601,11 @@ function onemklSgemm_batch_strided(device_queue, transa, transb, m, n, k, alpha, transa::onemklTranspose, transb::onemklTranspose, m::Int64, n::Int64, k::Int64, - alpha::Ptr{Cfloat}, a::Ptr{Cfloat}, + alpha::Ref{Cfloat}, a::ZePtr{Cfloat}, lda::Int64, stride_a::Int64, - b::Ptr{Cfloat}, ldb::Int64, - stride_b::Int64, beta::Ptr{Cfloat}, - c::Ptr{Cfloat}, ldc::Int64, + b::ZePtr{Cfloat}, ldb::Int64, + stride_b::Int64, beta::Ref{Cfloat}, + c::ZePtr{Cfloat}, ldc::Int64, stride_c::Int64, batch_size::Int64)::Cint end @@ -1615,11 +1617,12 @@ function onemklDgemm_batch_strided(device_queue, transa, transb, m, n, k, alpha, transa::onemklTranspose, transb::onemklTranspose, m::Int64, n::Int64, k::Int64, - alpha::Ptr{Cdouble}, a::Ptr{Cdouble}, - lda::Int64, stride_a::Int64, - b::Ptr{Cdouble}, ldb::Int64, - stride_b::Int64, beta::Ptr{Cdouble}, - c::Ptr{Cdouble}, ldc::Int64, + alpha::Ref{Cdouble}, + a::ZePtr{Cdouble}, lda::Int64, + stride_a::Int64, b::ZePtr{Cdouble}, + ldb::Int64, stride_b::Int64, + beta::Ref{Cdouble}, + c::ZePtr{Cdouble}, ldc::Int64, stride_c::Int64, batch_size::Int64)::Cint end @@ -1631,12 +1634,13 @@ function onemklCgemm_batch_strided(device_queue, transa, transb, m, n, k, alpha, transa::onemklTranspose, transb::onemklTranspose, m::Int64, n::Int64, k::Int64, - alpha::Ptr{ComplexF32}, - a::Ptr{ComplexF32}, lda::Int64, - stride_a::Int64, b::Ptr{ComplexF32}, - ldb::Int64, stride_b::Int64, - beta::Ptr{ComplexF32}, - c::Ptr{ComplexF32}, ldc::Int64, + alpha::Ref{ComplexF32}, + a::ZePtr{ComplexF32}, lda::Int64, + stride_a::Int64, + b::ZePtr{ComplexF32}, ldb::Int64, + stride_b::Int64, + beta::Ref{ComplexF32}, + c::ZePtr{ComplexF32}, ldc::Int64, stride_c::Int64, batch_size::Int64)::Cint end @@ -1648,12 +1652,13 @@ function onemklZgemm_batch_strided(device_queue, transa, transb, m, n, k, alpha, transa::onemklTranspose, transb::onemklTranspose, m::Int64, n::Int64, k::Int64, - alpha::Ptr{ComplexF32}, - a::Ptr{ComplexF32}, lda::Int64, - stride_a::Int64, b::Ptr{ComplexF32}, - ldb::Int64, stride_b::Int64, - beta::Ptr{ComplexF32}, - c::Ptr{ComplexF32}, ldc::Int64, + alpha::Ref{ComplexF64}, + a::ZePtr{ComplexF64}, lda::Int64, + stride_a::Int64, + b::ZePtr{ComplexF64}, ldb::Int64, + stride_b::Int64, + beta::Ref{ComplexF64}, + c::ZePtr{ComplexF64}, ldc::Int64, stride_c::Int64, batch_size::Int64)::Cint end @@ -3854,9 +3859,10 @@ function onemklSsyevx_scratchpad_size(device_queue, jobz, range, uplo, n, lda, v jobz::onemklCompz, range::onemklRangev, uplo::onemklUplo, n::Int64, - lda::Int64, vl::Cfloat, - vu::Cfloat, il::Int64, iu::Int64, - abstol::Cfloat, ldz::Int64)::Int64 + lda::Int64, vl::Ptr{Cfloat}, + vu::Ptr{Cfloat}, il::Int64, + iu::Int64, abstol::Ptr{Cfloat}, + ldz::Int64)::Int64 end function onemklDsyevx_scratchpad_size(device_queue, jobz, range, uplo, n, lda, vl, vu, il, @@ -3865,9 +3871,9 @@ function onemklDsyevx_scratchpad_size(device_queue, jobz, range, uplo, n, lda, v jobz::onemklCompz, range::onemklRangev, uplo::onemklUplo, n::Int64, - lda::Int64, vl::Cdouble, - vu::Cdouble, il::Int64, iu::Int64, - abstol::Cdouble, + lda::Int64, vl::Ptr{Cdouble}, + vu::Ptr{Cdouble}, il::Int64, + iu::Int64, abstol::Ptr{Cdouble}, ldz::Int64)::Int64 end @@ -3875,10 +3881,10 @@ function onemklDsyevx(device_queue, jobz, range, uplo, n, a, lda, vl, vu, il, iu w, z, ldz, scratchpad, scratchpad_size) @ccall liboneapi_support.onemklDsyevx(device_queue::syclQueue_t, jobz::onemklCompz, range::onemklRangev, uplo::onemklUplo, n::Int64, - a::Ptr{Cdouble}, lda::Int64, vl::Cdouble, - vu::Cdouble, il::Int64, iu::Int64, - abstol::Cdouble, m::Ptr{Int64}, w::Ptr{Cdouble}, - z::Ptr{Cdouble}, ldz::Int64, + a::Ptr{Cdouble}, lda::Int64, vl::Ptr{Cdouble}, + vu::Ptr{Cdouble}, il::Int64, iu::Int64, + abstol::Ptr{Cdouble}, m::Ptr{Int64}, + w::Ptr{Cdouble}, z::Ptr{Cdouble}, ldz::Int64, scratchpad::Ptr{Cdouble}, scratchpad_size::Int64)::Cint end @@ -3887,10 +3893,11 @@ function onemklSsyevx(device_queue, jobz, range, uplo, n, a, lda, vl, vu, il, iu w, z, ldz, scratchpad, scratchpad_size) @ccall liboneapi_support.onemklSsyevx(device_queue::syclQueue_t, jobz::onemklCompz, range::onemklRangev, uplo::onemklUplo, n::Int64, - a::Ptr{Cfloat}, lda::Int64, vl::Cfloat, - vu::Cfloat, il::Int64, iu::Int64, abstol::Cfloat, - m::Ptr{Int64}, w::Ptr{Cfloat}, z::Ptr{Cfloat}, - ldz::Int64, scratchpad::Ptr{Cfloat}, + a::Ptr{Cfloat}, lda::Int64, vl::Ptr{Cfloat}, + vu::Ptr{Cfloat}, il::Int64, iu::Int64, + abstol::Ptr{Cfloat}, m::Ptr{Int64}, + w::Ptr{Cfloat}, z::Ptr{Cfloat}, ldz::Int64, + scratchpad::Ptr{Cfloat}, scratchpad_size::Int64)::Cint end @@ -3935,8 +3942,9 @@ function onemklSsygvx_scratchpad_size(device_queue, itype, jobz, range, uplo, n, range::onemklRangev, uplo::onemklUplo, n::Int64, lda::Int64, ldb::Int64, - vl::Cfloat, vu::Cfloat, il::Int64, - iu::Int64, abstol::Cfloat, + vl::Ptr{Cfloat}, vu::Ptr{Cfloat}, + il::Int64, iu::Int64, + abstol::Ptr{Cfloat}, ldz::Int64)::Int64 end @@ -3947,9 +3955,9 @@ function onemklDsygvx_scratchpad_size(device_queue, itype, jobz, range, uplo, n, range::onemklRangev, uplo::onemklUplo, n::Int64, lda::Int64, ldb::Int64, - vl::Cdouble, vu::Cdouble, - il::Int64, iu::Int64, - abstol::Cdouble, + vl::Ptr{Cdouble}, + vu::Ptr{Cdouble}, il::Int64, + iu::Int64, abstol::Ptr{Cdouble}, ldz::Int64)::Int64 end @@ -3959,9 +3967,9 @@ function onemklDsygvx(device_queue, itype, jobz, range, uplo, n, a, lda, b, ldb, jobz::onemklCompz, range::onemklRangev, uplo::onemklUplo, n::Int64, a::Ptr{Cdouble}, lda::Int64, b::Ptr{Cdouble}, ldb::Int64, - vl::Cdouble, vu::Cdouble, il::Int64, iu::Int64, - abstol::Cdouble, m::Ptr{Int64}, w::Ptr{Cdouble}, - z::Ptr{Cdouble}, ldz::Int64, + vl::Ptr{Cdouble}, vu::Ptr{Cdouble}, il::Int64, + iu::Int64, abstol::Ptr{Cdouble}, m::Ptr{Int64}, + w::Ptr{Cdouble}, z::Ptr{Cdouble}, ldz::Int64, scratchpad::Ptr{Cdouble}, scratchpad_size::Int64)::Cint end @@ -3972,9 +3980,9 @@ function onemklSsygvx(device_queue, itype, jobz, range, uplo, n, a, lda, b, ldb, jobz::onemklCompz, range::onemklRangev, uplo::onemklUplo, n::Int64, a::Ptr{Cfloat}, lda::Int64, b::Ptr{Cfloat}, ldb::Int64, - vl::Cfloat, vu::Cfloat, il::Int64, iu::Int64, - abstol::Cfloat, m::Ptr{Int64}, w::Ptr{Cfloat}, - z::Ptr{Cfloat}, ldz::Int64, + vl::Ptr{Cfloat}, vu::Ptr{Cfloat}, il::Int64, + iu::Int64, abstol::Ptr{Cfloat}, m::Ptr{Int64}, + w::Ptr{Cfloat}, z::Ptr{Cfloat}, ldz::Int64, scratchpad::Ptr{Cfloat}, scratchpad_size::Int64)::Cint end @@ -5782,16 +5790,16 @@ end function onemklSsparse_gemv(device_queue, opA, alpha, A, x, beta, y) @ccall liboneapi_support.onemklSsparse_gemv(device_queue::syclQueue_t, - opA::onemklTranspose, alpha::Ref{Float32}, - A::matrix_handle_t, x::ZePtr{Float32}, - beta::Ref{Float32}, y::ZePtr{Float32})::Cint + opA::onemklTranspose, alpha::Ref{Cfloat}, + A::matrix_handle_t, x::ZePtr{Cfloat}, + beta::Ref{Cfloat}, y::ZePtr{Cfloat})::Cint end function onemklDsparse_gemv(device_queue, opA, alpha, A, x, beta, y) @ccall liboneapi_support.onemklDsparse_gemv(device_queue::syclQueue_t, - opA::onemklTranspose, alpha::Ref{Float64}, - A::matrix_handle_t, x::ZePtr{Float64}, - beta::Ref{Float64}, y::ZePtr{Float64})::Cint + opA::onemklTranspose, alpha::Ref{Cdouble}, + A::matrix_handle_t, x::ZePtr{Cdouble}, + beta::Ref{Cdouble}, y::ZePtr{Cdouble})::Cint end function onemklCsparse_gemv(device_queue, opA, alpha, A, x, beta, y) @@ -5812,23 +5820,25 @@ end function onemklSsparse_gemvdot(device_queue, opA, alpha, A, x, beta, y, d) @ccall liboneapi_support.onemklSsparse_gemvdot(device_queue::syclQueue_t, - opA::onemklTranspose, alpha::Cfloat, - A::matrix_handle_t, x::ZePtr{Float32}, - beta::Ref{Float32}, y::ZePtr{Float32}, - d::ZePtr{Float32})::Cint + opA::onemklTranspose, alpha::Ref{Cfloat}, + A::matrix_handle_t, x::ZePtr{Cfloat}, + beta::Ref{Cfloat}, y::ZePtr{Cfloat}, + d::ZePtr{Cfloat})::Cint end function onemklDsparse_gemvdot(device_queue, opA, alpha, A, x, beta, y, d) @ccall liboneapi_support.onemklDsparse_gemvdot(device_queue::syclQueue_t, - opA::onemklTranspose, alpha::Cdouble, - A::matrix_handle_t, x::ZePtr{Float64}, - beta::Ref{Float64}, y::ZePtr{Float64}, - d::ZePtr{Float64})::Cint + opA::onemklTranspose, + alpha::Ref{Cdouble}, A::matrix_handle_t, + x::ZePtr{Cdouble}, beta::Ref{Cdouble}, + y::ZePtr{Cdouble}, + d::ZePtr{Cdouble})::Cint end function onemklCsparse_gemvdot(device_queue, opA, alpha, A, x, beta, y, d) @ccall liboneapi_support.onemklCsparse_gemvdot(device_queue::syclQueue_t, - opA::onemklTranspose, alpha::ComplexF32, + opA::onemklTranspose, + alpha::Ref{ComplexF32}, A::matrix_handle_t, x::ZePtr{ComplexF32}, beta::Ref{ComplexF32}, y::ZePtr{ComplexF32}, @@ -5837,7 +5847,8 @@ end function onemklZsparse_gemvdot(device_queue, opA, alpha, A, x, beta, y, d) @ccall liboneapi_support.onemklZsparse_gemvdot(device_queue::syclQueue_t, - opA::onemklTranspose, alpha::ComplexF32, + opA::onemklTranspose, + alpha::Ref{ComplexF64}, A::matrix_handle_t, x::ZePtr{ComplexF64}, beta::Ref{ComplexF64}, y::ZePtr{ComplexF64}, @@ -5846,16 +5857,16 @@ end function onemklSsparse_symv(device_queue, uplo_val, alpha, A, x, beta, y) @ccall liboneapi_support.onemklSsparse_symv(device_queue::syclQueue_t, - uplo_val::onemklUplo, alpha::Ref{Float32}, - A::matrix_handle_t, x::ZePtr{Float32}, - beta::Ref{Float32}, y::ZePtr{Float32})::Cint + uplo_val::onemklUplo, alpha::Ref{Cfloat}, + A::matrix_handle_t, x::ZePtr{Cfloat}, + beta::Ref{Cfloat}, y::ZePtr{Cfloat})::Cint end function onemklDsparse_symv(device_queue, uplo_val, alpha, A, x, beta, y) @ccall liboneapi_support.onemklDsparse_symv(device_queue::syclQueue_t, - uplo_val::onemklUplo, alpha::Ref{Float64}, - A::matrix_handle_t, x::ZePtr{Float64}, - beta::Ref{Float64}, y::ZePtr{Float64})::Cint + uplo_val::onemklUplo, alpha::Ref{Cdouble}, + A::matrix_handle_t, x::ZePtr{Cdouble}, + beta::Ref{Cdouble}, y::ZePtr{Cdouble})::Cint end function onemklCsparse_symv(device_queue, uplo_val, alpha, A, x, beta, y) @@ -5877,17 +5888,17 @@ end function onemklSsparse_trmv(device_queue, uplo_val, opA, diag_val, alpha, A, x, beta, y) @ccall liboneapi_support.onemklSsparse_trmv(device_queue::syclQueue_t, uplo_val::onemklUplo, opA::onemklTranspose, - diag_val::onemklDiag, alpha::Ref{Float32}, - A::matrix_handle_t, x::ZePtr{Float32}, - beta::Ref{Float32}, y::ZePtr{Float32})::Cint + diag_val::onemklDiag, alpha::Ref{Cfloat}, + A::matrix_handle_t, x::ZePtr{Cfloat}, + beta::Ref{Cfloat}, y::ZePtr{Cfloat})::Cint end function onemklDsparse_trmv(device_queue, uplo_val, opA, diag_val, alpha, A, x, beta, y) @ccall liboneapi_support.onemklDsparse_trmv(device_queue::syclQueue_t, uplo_val::onemklUplo, opA::onemklTranspose, - diag_val::onemklDiag, alpha::Ref{Float64}, - A::matrix_handle_t, x::ZePtr{Float64}, - beta::Ref{Float64}, y::ZePtr{Float64})::Cint + diag_val::onemklDiag, alpha::Ref{Cdouble}, + A::matrix_handle_t, x::ZePtr{Cdouble}, + beta::Ref{Cdouble}, y::ZePtr{Cdouble})::Cint end function onemklCsparse_trmv(device_queue, uplo_val, opA, diag_val, alpha, A, x, beta, y) @@ -5943,10 +5954,10 @@ function onemklSsparse_gemm(device_queue, layout_val, opA, opX, alpha, A, X, col @ccall liboneapi_support.onemklSsparse_gemm(device_queue::syclQueue_t, layout_val::onemklLayout, opA::onemklTranspose, opX::onemklTranspose, - alpha::Ref{Float32}, A::matrix_handle_t, - X::ZePtr{Float32}, columns::Int64, - ldx::Int64, beta::Ref{Float32}, - Y::ZePtr{Float32}, ldy::Int64)::Cint + alpha::Ref{Cfloat}, A::matrix_handle_t, + X::ZePtr{Cfloat}, columns::Int64, + ldx::Int64, beta::Ref{Cfloat}, + Y::ZePtr{Cfloat}, ldy::Int64)::Cint end function onemklDsparse_gemm(device_queue, layout_val, opA, opX, alpha, A, X, columns, ldx, @@ -5954,10 +5965,10 @@ function onemklDsparse_gemm(device_queue, layout_val, opA, opX, alpha, A, X, col @ccall liboneapi_support.onemklDsparse_gemm(device_queue::syclQueue_t, layout_val::onemklLayout, opA::onemklTranspose, opX::onemklTranspose, - alpha::Ref{Float64}, A::matrix_handle_t, - X::ZePtr{Float64}, columns::Int64, - ldx::Int64, beta::Ref{Float64}, - Y::ZePtr{Float64}, ldy::Int64)::Cint + alpha::Ref{Cdouble}, A::matrix_handle_t, + X::ZePtr{Cdouble}, columns::Int64, + ldx::Int64, beta::Ref{Cdouble}, + Y::ZePtr{Cdouble}, ldy::Int64)::Cint end function onemklCsparse_gemm(device_queue, layout_val, opA, opX, alpha, A, X, columns, ldx, diff --git a/res/support.toml b/res/support.toml index 6891cf6f..393b051d 100644 --- a/res/support.toml +++ b/res/support.toml @@ -6,7 +6,7 @@ output_file_path = "../lib/support/liboneapi_support.jl" [codegen] use_ccall_macro = true -[api.onemklXgemmBatched.argtypes] +[api.onemklXgemm_batch.argtypes] 4 = "ZePtr{Int64}" 5 = "ZePtr{Int64}" 6 = "ZePtr{Int64}" @@ -20,7 +20,7 @@ use_ccall_macro = true 14 = "ZePtr{Int64}" 16 = "ZePtr{Int64}" -[api.onemklXtrsmBatched.argtypes] +[api.onemklXtrsm_batch.argtypes] 6 = "ZePtr{Int64}" 7 = "ZePtr{Int64}" 8 = "ZePtr{T}" @@ -30,7 +30,7 @@ use_ccall_macro = true 12 = "ZePtr{Int64}" 14 = "ZePtr{Int64}" -[api.onemklXgemmBatchStrided.argtypes] +[api.onemklXgemm_batch_strided.argtypes] 7 = "Ref{T}" 8 = "ZePtr{T}" 11 = "ZePtr{T}" @@ -149,24 +149,44 @@ use_ccall_macro = true [api.onemklXrot.argtypes] 3 = "ZePtr{T}" 5 = "ZePtr{T}" +7 = "Ref{T}" +8 = "Ref{T}" -[api.onemklXDrot.argtypes] -3 = "ZePtr{T}" -5 = "ZePtr{T}" +[api.onemklCrot.argtypes] +3 = "ZePtr{ComplexF32}" +5 = "ZePtr{ComplexF32}" +7 = "Ref{Float32}" +8 = "Ref{ComplexF32}" -[api.onemklXSrot.argtypes] -3 = "ZePtr{T}" -5 = "ZePtr{T}" +[api.onemklZrot.argtypes] +3 = "ZePtr{ComplexF64}" +5 = "ZePtr{ComplexF64}" +7 = "Ref{Float64}" +8 = "Ref{ComplexF64}" + +[api.onemklCSrot.argtypes] +3 = "ZePtr{ComplexF32}" +5 = "ZePtr{ComplexF32}" +7 = "Ref{Float32}" +8 = "Ref{Float32}" + +[api.onemklZDrot.argtypes] +3 = "ZePtr{ComplexF64}" +5 = "ZePtr{ComplexF64}" +7 = "Ref{Float64}" +8 = "Ref{Float64}" [api.onemklXscal.argtypes] 3 = "Ref{T}" 4 = "ZePtr{T}" -[api.onemklXDscal.argtypes] -4 = "ZePtr{T}" +[api.onemklCSscal.argtypes] +3 = "Ref{Float32}" +4 = "ZePtr{ComplexF32}" -[api.onemklXSscal.argtypes] -4 = "ZePtr{T}" +[api.onemklZDscal.argtypes] +3 = "Ref{Float64}" +4 = "ZePtr{ComplexF64}" [api.onemklXger.argtypes] 4 = "Ref{T}" @@ -270,146 +290,111 @@ use_ccall_macro = true 9 = "ZePtr{T}" [api.onemklXgeru.argtypes] +4 = "Ref{T}" 5 = "ZePtr{T}" 7 = "ZePtr{T}" 9 = "ZePtr{T}" -[api.onemklXsparse_set_csr_data.argtypes] -6 = "ZePtr{Int32}" -7 = "ZePtr{Int32}" -8 = "ZePtr{T}" - -[api.onemklXsparse_set_csr_data_64.argtypes] -6 = "ZePtr{Int64}" -7 = "ZePtr{Int64}" -8 = "ZePtr{T}" - -[api.onemklSsparse_gemv.argtypes] -3 = "Ref{Float32}" -5 = "ZePtr{Float32}" -6 = "Ref{Float32}" -7 = "ZePtr{Float32}" - -[api.onemklDsparse_gemv.argtypes] -3 = "Ref{Float64}" -5 = "ZePtr{Float64}" -6 = "Ref{Float64}" -7 = "ZePtr{Float64}" +[api.onemklXhpmv.argtypes] +4 = "Ref{T}" +5 = "ZePtr{T}" +6 = "ZePtr{T}" +8 = "Ref{T}" +9 = "ZePtr{T}" -[api.onemklCsparse_gemv.argtypes] -3 = "Ref{ComplexF32}" +[api.onemklChpr.argtypes] +4 = "Ref{Float32}" 5 = "ZePtr{ComplexF32}" -6 = "Ref{ComplexF32}" 7 = "ZePtr{ComplexF32}" -[api.onemklZsparse_gemv.argtypes] -3 = "Ref{ComplexF64}" +[api.onemklZhpr.argtypes] +4 = "Ref{Float64}" 5 = "ZePtr{ComplexF64}" -6 = "Ref{ComplexF64}" 7 = "ZePtr{ComplexF64}" -[api.onemklSsparse_symv.argtypes] -3 = "Ref{Float32}" -5 = "ZePtr{Float32}" -6 = "Ref{Float32}" -7 = "ZePtr{Float32}" +[api.onemklXhpr2.argtypes] +4 = "Ref{T}" +5 = "ZePtr{T}" +7 = "ZePtr{T}" +9 = "ZePtr{T}" -[api.onemklDsparse_symv.argtypes] -3 = "Ref{Float64}" -5 = "ZePtr{Float64}" -6 = "Ref{Float64}" -7 = "ZePtr{Float64}" +[api.onemklXsyr2.argtypes] +4 = "Ref{T}" +5 = "ZePtr{T}" +7 = "ZePtr{T}" +9 = "ZePtr{T}" -[api.onemklCsparse_symv.argtypes] -3 = "Ref{ComplexF32}" -5 = "ZePtr{ComplexF32}" -6 = "Ref{ComplexF32}" -7 = "ZePtr{ComplexF32}" +[api.onemklXspmv.argtypes] +4 = "Ref{T}" +5 = "ZePtr{T}" +6 = "ZePtr{T}" +8 = "Ref{T}" +9 = "ZePtr{T}" -[api.onemklZsparse_symv.argtypes] -3 = "Ref{ComplexF64}" -5 = "ZePtr{ComplexF64}" -6 = "Ref{ComplexF64}" -7 = "ZePtr{ComplexF64}" +[api.onemklXspr.argtypes] +4 = "Ref{T}" +5 = "ZePtr{T}" +7 = "ZePtr{T}" -[api.onemklSsparse_trmv.argtypes] -5 = "Ref{Float32}" -7 = "ZePtr{Float32}" -8 = "Ref{Float32}" -9 = "ZePtr{Float32}" +[api.onemklXspr2.argtypes] +4 = "Ref{T}" +5 = "ZePtr{T}" +7 = "ZePtr{T}" +9 = "ZePtr{T}" -[api.onemklDsparse_trmv.argtypes] -5 = "Ref{Float64}" -7 = "ZePtr{Float64}" -8 = "Ref{Float64}" -9 = "ZePtr{Float64}" +[api.onemklSsdsdot.argtypes] +3 = "Ref{Float32}" +4 = "ZePtr{Float32}" +6 = "ZePtr{Float32}" +8 = "Ref{Float32}" -[api.onemklCsparse_trmv.argtypes] -5 = "Ref{ComplexF32}" -7 = "ZePtr{ComplexF32}" -8 = "Ref{ComplexF32}" -9 = "ZePtr{ComplexF32}" +[api.onemklXsparse_set_csr_data.argtypes] +6 = "ZePtr{Int32}" +7 = "ZePtr{Int32}" +8 = "ZePtr{T}" -[api.onemklZsparse_trmv.argtypes] -5 = "Ref{ComplexF64}" -7 = "ZePtr{ComplexF64}" -8 = "Ref{ComplexF64}" -9 = "ZePtr{ComplexF64}" +[api.onemklXsparse_set_csr_data_64.argtypes] +6 = "ZePtr{Int64}" +7 = "ZePtr{Int64}" +8 = "ZePtr{T}" -[api.onemklXsparse_trsv.argtypes] -6 = "ZePtr{T}" +[api.onemklXsparse_gemv.argtypes] +3 = "Ref{T}" +5 = "ZePtr{T}" +6 = "Ref{T}" 7 = "ZePtr{T}" -[api.onemklSsparse_gemm.argtypes] -5 = "Ref{Float32}" -7 = "ZePtr{Float32}" -10 = "Ref{Float32}" -11 = "ZePtr{Float32}" - -[api.onemklDsparse_gemm.argtypes] -5 = "Ref{Float64}" -7 = "ZePtr{Float64}" -10 = "Ref{Float64}" -11 = "ZePtr{Float64}" +[api.onemklXsparse_symv.argtypes] +3 = "Ref{T}" +5 = "ZePtr{T}" +6 = "Ref{T}" +7 = "ZePtr{T}" -[api.onemklCsparse_gemm.argtypes] -5 = "Ref{ComplexF32}" -7 = "ZePtr{ComplexF32}" -10 = "Ref{ComplexF32}" -11 = "ZePtr{ComplexF32}" +[api.onemklXsparse_trmv.argtypes] +5 = "Ref{T}" +7 = "ZePtr{T}" +8 = "Ref{T}" +9 = "ZePtr{T}" -[api.onemklZsparse_gemm.argtypes] -5 = "Ref{ComplexF64}" -7 = "ZePtr{ComplexF64}" -10 = "Ref{ComplexF64}" -11 = "ZePtr{ComplexF64}" +[api.onemklXsparse_trsv.argtypes] +6 = "ZePtr{T}" +7 = "ZePtr{T}" [api.onemklXsparse_update_diagonal_values.argtypes] 4 = "ZePtr{T}" -[api.onemklSsparse_gemvdot.argtypes] -5 = "ZePtr{Float32}" -6 = "Ref{Float32}" -7 = "ZePtr{Float32}" -8 = "ZePtr{Float32}" - -[api.onemklDsparse_gemvdot.argtypes] -5 = "ZePtr{Float64}" -6 = "Ref{Float64}" -7 = "ZePtr{Float64}" -8 = "ZePtr{Float64}" - -[api.onemklCsparse_gemvdot.argtypes] -5 = "ZePtr{ComplexF32}" -6 = "Ref{ComplexF32}" -7 = "ZePtr{ComplexF32}" -8 = "ZePtr{ComplexF32}" +[api.onemklXsparse_gemvdot.argtypes] +3 = "Ref{T}" +5 = "ZePtr{T}" +6 = "Ref{T}" +7 = "ZePtr{T}" +8 = "ZePtr{T}" -[api.onemklZsparse_gemvdot.argtypes] -5 = "ZePtr{ComplexF64}" -6 = "Ref{ComplexF64}" -7 = "ZePtr{ComplexF64}" -8 = "ZePtr{ComplexF64}" +[api.onemklXsparse_gemm.argtypes] +5 = "Ref{T}" +7 = "ZePtr{T}" +10 = "Ref{T}" +11 = "ZePtr{T}" [api.onemklXsparse_matmat.argtypes] 8 = "ZePtr{Cvoid}"