diff --git a/deps/generate_interfaces.jl b/deps/generate_interfaces.jl index e287ef03..108518db 100644 --- a/deps/generate_interfaces.jl +++ b/deps/generate_interfaces.jl @@ -444,20 +444,48 @@ function generate_cpp(library::String, filename::Vector{String}, output::String; variant = "column_major::" end + # Build catch clause: LAPACK functions also catch computation_error for info + lapack_catch = "catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; }" + sycl_catch = "catch (const sycl::exception& e) { return -1; }" + write(oneapi_cpp, "extern \"C\" $header {\n") if template type = version_types[version] - !occursin("scratchpad_size", name) && write(oneapi_cpp, " auto status = oneapi::mkl::$library::$variant$name<$type>($parameters, {});\n device_queue->val.wait_and_throw();\n") - occursin("scratchpad_size", name) && write(oneapi_cpp, " int64_t scratchpad_size = oneapi::mkl::$library::$variant$name<$type>($parameters);\n device_queue->val.wait_and_throw();\n") - # !occursin("scratchpad_size", name) && write(oneapi_cpp, " auto status = oneapi::mkl::$library::$variant$name<$type>($parameters, {});\n") - # occursin("scratchpad_size", name) && write(oneapi_cpp, " int64_t scratchpad_size = oneapi::mkl::$library::$variant$name<$type>($parameters);\n") + if !occursin("scratchpad_size", name) + catch_clause = library == "lapack" ? lapack_catch : sycl_catch + write(oneapi_cpp, " try {\n") + write(oneapi_cpp, " auto status = oneapi::mkl::$library::$variant$name<$type>($parameters, {});\n") + write(oneapi_cpp, " device_queue->val.wait_and_throw();\n") + write(oneapi_cpp, " } $catch_clause\n") + end + if occursin("scratchpad_size", name) + write(oneapi_cpp, " int64_t scratchpad_size = oneapi::mkl::$library::$variant$name<$type>($parameters);\n device_queue->val.wait_and_throw();\n") + end else if !(name ∈ void_output) - write(oneapi_cpp, " auto status = oneapi::mkl::$library::$variant$name($parameters, {});\n") - occursin("device_queue", parameters) && write(oneapi_cpp, " device_queue->val.wait_and_throw();\n") + has_queue = occursin("device_queue", parameters) + is_scratchpad = occursin("scratchpad_size", name) + if has_queue && !is_scratchpad + catch_clause = library == "lapack" ? lapack_catch : sycl_catch + write(oneapi_cpp, " try {\n") + write(oneapi_cpp, " auto status = oneapi::mkl::$library::$variant$name($parameters, {});\n") + write(oneapi_cpp, " device_queue->val.wait_and_throw();\n") + write(oneapi_cpp, " } $catch_clause\n") + else + write(oneapi_cpp, " auto status = oneapi::mkl::$library::$variant$name($parameters, {});\n") + if has_queue + write(oneapi_cpp, " device_queue->val.wait_and_throw();\n") + end + end else - write(oneapi_cpp, " oneapi::mkl::$library::$variant$name($parameters);\n") - occursin("device_queue", parameters) && write(oneapi_cpp, " device_queue->val.wait_and_throw();\n") + if occursin("device_queue", parameters) + write(oneapi_cpp, " try {\n") + write(oneapi_cpp, " oneapi::mkl::$library::$variant$name($parameters);\n") + write(oneapi_cpp, " device_queue->val.wait_and_throw();\n") + write(oneapi_cpp, " } $sycl_catch\n") + else + write(oneapi_cpp, " oneapi::mkl::$library::$variant$name($parameters);\n") + end end end if occursin("scratchpad_size", name) diff --git a/deps/src/onemkl.cpp b/deps/src/onemkl.cpp index d875b489..2b880327 100644 --- a/deps/src/onemkl.cpp +++ b/deps/src/onemkl.cpp @@ -578,2727 +578,3635 @@ 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::syrk(device_queue->val, convert(upper_lower), convert(trans), n, k, *alpha, a, lda, *beta, c, ldc, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::syrk(device_queue->val, convert(upper_lower), convert(trans), n, k, *alpha, a, lda, *beta, c, ldc, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklStrmm_variant(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, float *beta, float *c, int64_t ldc) { - 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, *beta, c, ldc, {}); - device_queue->val.wait_and_throw(); + try { + 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, *beta, c, ldc, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklDtrmm_variant(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, double *beta, double *c, int64_t ldc) { - 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, *beta, c, ldc, {}); - device_queue->val.wait_and_throw(); + try { + 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, *beta, c, ldc, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklCtrmm_variant(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, float _Complex *beta, float _Complex *c, int64_t ldc) { - 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, *reinterpret_cast*>(beta), reinterpret_cast*>(c), ldc, {}); - device_queue->val.wait_and_throw(); + try { + 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, *reinterpret_cast*>(beta), reinterpret_cast*>(c), ldc, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklZtrmm_variant(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, double _Complex *beta, double _Complex *c, int64_t ldc) { - 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, *reinterpret_cast*>(beta), reinterpret_cast*>(c), ldc, {}); - device_queue->val.wait_and_throw(); + try { + 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, *reinterpret_cast*>(beta), reinterpret_cast*>(c), ldc, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklStrsm_variant(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, float *beta, float *c, int64_t ldc) { - 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, *beta, c, ldc, {}); - device_queue->val.wait_and_throw(); + try { + 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, *beta, c, ldc, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklDtrsm_variant(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, double *beta, double *c, int64_t ldc) { - 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, *beta, c, ldc, {}); - device_queue->val.wait_and_throw(); + try { + 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, *beta, c, ldc, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklCtrsm_variant(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, float _Complex *beta, float _Complex *c, int64_t ldc) { - 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, *reinterpret_cast*>(beta), reinterpret_cast*>(c), ldc, {}); - device_queue->val.wait_and_throw(); + try { + 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, *reinterpret_cast*>(beta), reinterpret_cast*>(c), ldc, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklZtrsm_variant(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, double _Complex *beta, double _Complex *c, int64_t ldc) { - 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, *reinterpret_cast*>(beta), reinterpret_cast*>(c), ldc, {}); - device_queue->val.wait_and_throw(); + try { + 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, *reinterpret_cast*>(beta), reinterpret_cast*>(c), ldc, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklSdgmm(syclQueue_t device_queue, onemklSide left_right, int64_t m, int64_t n, float *a, int64_t lda, float *x, int64_t incx, float *c, int64_t ldc) { - auto status = oneapi::mkl::blas::column_major::dgmm(device_queue->val, convert(left_right), m, n, a, lda, x, incx, c, ldc, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::dgmm(device_queue->val, convert(left_right), m, n, a, lda, x, incx, c, ldc, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklDdgmm(syclQueue_t device_queue, onemklSide left_right, int64_t m, int64_t n, double *a, int64_t lda, double *x, int64_t incx, double *c, int64_t ldc) { - auto status = oneapi::mkl::blas::column_major::dgmm(device_queue->val, convert(left_right), m, n, a, lda, x, incx, c, ldc, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::dgmm(device_queue->val, convert(left_right), m, n, a, lda, x, incx, c, ldc, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklCdgmm(syclQueue_t device_queue, onemklSide left_right, int64_t m, int64_t n, float _Complex *a, int64_t lda, float _Complex *x, int64_t incx, float _Complex *c, int64_t ldc) { - auto status = oneapi::mkl::blas::column_major::dgmm(device_queue->val, convert(left_right), m, n, reinterpret_cast*>(a), lda, reinterpret_cast*>(x), incx, reinterpret_cast*>(c), ldc, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::dgmm(device_queue->val, convert(left_right), m, n, reinterpret_cast*>(a), lda, reinterpret_cast*>(x), incx, reinterpret_cast*>(c), ldc, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklZdgmm(syclQueue_t device_queue, onemklSide left_right, int64_t m, int64_t n, double _Complex *a, int64_t lda, double _Complex *x, int64_t incx, double _Complex *c, int64_t ldc) { - auto status = oneapi::mkl::blas::column_major::dgmm(device_queue->val, convert(left_right), m, n, reinterpret_cast*>(a), lda, reinterpret_cast*>(x), incx, reinterpret_cast*>(c), ldc, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::dgmm(device_queue->val, convert(left_right), m, n, reinterpret_cast*>(a), lda, reinterpret_cast*>(x), incx, reinterpret_cast*>(c), ldc, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } 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, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::gemv(device_queue->val, convert(trans), m, n, *alpha, a, lda, x, incx, *beta, y, incy, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::gemv(device_queue->val, convert(trans), m, n, *alpha, a, lda, x, incx, *beta, y, incy, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::ger(device_queue->val, m, n, *alpha, x, incx, y, incy, a, lda, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::ger(device_queue->val, m, n, *alpha, x, incx, y, incy, a, lda, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::her(device_queue->val, convert(upper_lower), n, *alpha, reinterpret_cast*>(x), incx, reinterpret_cast*>(a), lda, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::her(device_queue->val, convert(upper_lower), n, *alpha, reinterpret_cast*>(x), incx, reinterpret_cast*>(a), lda, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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), {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::hpr(device_queue->val, convert(upper_lower), n, *alpha, reinterpret_cast*>(x), incx, reinterpret_cast*>(a), {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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), {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::hpr(device_queue->val, convert(upper_lower), n, *alpha, reinterpret_cast*>(x), incx, reinterpret_cast*>(a), {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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), {}); - device_queue->val.wait_and_throw(); + try { + 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), {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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), {}); - device_queue->val.wait_and_throw(); + try { + 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), {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::sbmv(device_queue->val, convert(upper_lower), n, k, *alpha, a, lda, x, incx, *beta, y, incy, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::sbmv(device_queue->val, convert(upper_lower), n, k, *alpha, a, lda, x, incx, *beta, y, incy, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::symv(device_queue->val, convert(upper_lower), n, *alpha, a, lda, x, incx, *beta, y, incy, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::symv(device_queue->val, convert(upper_lower), n, *alpha, a, lda, x, incx, *beta, y, incy, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::syr(device_queue->val, convert(upper_lower), n, *alpha, x, incx, a, lda, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::syr(device_queue->val, convert(upper_lower), n, *alpha, x, incx, a, lda, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::syr2(device_queue->val, convert(upper_lower), n, *alpha, x, incx, y, incy, a, lda, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::syr2(device_queue->val, convert(upper_lower), n, *alpha, x, incx, y, incy, a, lda, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::spmv(device_queue->val, convert(upper_lower), n, *alpha, a, x, incx, *beta, y, incy, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::spmv(device_queue->val, convert(upper_lower), n, *alpha, a, x, incx, *beta, y, incy, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::spr(device_queue->val, convert(upper_lower), n, *alpha, x, incx, a, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::spr(device_queue->val, convert(upper_lower), n, *alpha, x, incx, a, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::spr2(device_queue->val, convert(upper_lower), n, *alpha, x, incx, y, incy, a, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::spr2(device_queue->val, convert(upper_lower), n, *alpha, x, incx, y, incy, a, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklStbmv(syclQueue_t device_queue, onemklUplo upper_lower, onemklTranspose trans, onemklDiag unit_diag, int64_t n, int64_t k, float *a, int64_t lda, float *x, int64_t incx) { - auto status = oneapi::mkl::blas::column_major::tbmv(device_queue->val, convert(upper_lower), convert(trans), convert(unit_diag), n, k, a, lda, x, incx, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::tbmv(device_queue->val, convert(upper_lower), convert(trans), convert(unit_diag), n, k, a, lda, x, incx, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklDtbmv(syclQueue_t device_queue, onemklUplo upper_lower, onemklTranspose trans, onemklDiag unit_diag, int64_t n, int64_t k, double *a, int64_t lda, double *x, int64_t incx) { - auto status = oneapi::mkl::blas::column_major::tbmv(device_queue->val, convert(upper_lower), convert(trans), convert(unit_diag), n, k, a, lda, x, incx, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::tbmv(device_queue->val, convert(upper_lower), convert(trans), convert(unit_diag), n, k, a, lda, x, incx, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklCtbmv(syclQueue_t device_queue, onemklUplo upper_lower, onemklTranspose trans, onemklDiag unit_diag, int64_t n, int64_t k, float _Complex *a, int64_t lda, float _Complex *x, int64_t incx) { - auto status = oneapi::mkl::blas::column_major::tbmv(device_queue->val, convert(upper_lower), convert(trans), convert(unit_diag), n, k, reinterpret_cast*>(a), lda, reinterpret_cast*>(x), incx, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::tbmv(device_queue->val, convert(upper_lower), convert(trans), convert(unit_diag), n, k, reinterpret_cast*>(a), lda, reinterpret_cast*>(x), incx, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklZtbmv(syclQueue_t device_queue, onemklUplo upper_lower, onemklTranspose trans, onemklDiag unit_diag, int64_t n, int64_t k, double _Complex *a, int64_t lda, double _Complex *x, int64_t incx) { - auto status = oneapi::mkl::blas::column_major::tbmv(device_queue->val, convert(upper_lower), convert(trans), convert(unit_diag), n, k, reinterpret_cast*>(a), lda, reinterpret_cast*>(x), incx, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::tbmv(device_queue->val, convert(upper_lower), convert(trans), convert(unit_diag), n, k, reinterpret_cast*>(a), lda, reinterpret_cast*>(x), incx, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklStbsv(syclQueue_t device_queue, onemklUplo upper_lower, onemklTranspose trans, onemklDiag unit_diag, int64_t n, int64_t k, float *a, int64_t lda, float *x, int64_t incx) { - auto status = oneapi::mkl::blas::column_major::tbsv(device_queue->val, convert(upper_lower), convert(trans), convert(unit_diag), n, k, a, lda, x, incx, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::tbsv(device_queue->val, convert(upper_lower), convert(trans), convert(unit_diag), n, k, a, lda, x, incx, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklDtbsv(syclQueue_t device_queue, onemklUplo upper_lower, onemklTranspose trans, onemklDiag unit_diag, int64_t n, int64_t k, double *a, int64_t lda, double *x, int64_t incx) { - auto status = oneapi::mkl::blas::column_major::tbsv(device_queue->val, convert(upper_lower), convert(trans), convert(unit_diag), n, k, a, lda, x, incx, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::tbsv(device_queue->val, convert(upper_lower), convert(trans), convert(unit_diag), n, k, a, lda, x, incx, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklCtbsv(syclQueue_t device_queue, onemklUplo upper_lower, onemklTranspose trans, onemklDiag unit_diag, int64_t n, int64_t k, float _Complex *a, int64_t lda, float _Complex *x, int64_t incx) { - auto status = oneapi::mkl::blas::column_major::tbsv(device_queue->val, convert(upper_lower), convert(trans), convert(unit_diag), n, k, reinterpret_cast*>(a), lda, reinterpret_cast*>(x), incx, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::tbsv(device_queue->val, convert(upper_lower), convert(trans), convert(unit_diag), n, k, reinterpret_cast*>(a), lda, reinterpret_cast*>(x), incx, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklZtbsv(syclQueue_t device_queue, onemklUplo upper_lower, onemklTranspose trans, onemklDiag unit_diag, int64_t n, int64_t k, double _Complex *a, int64_t lda, double _Complex *x, int64_t incx) { - auto status = oneapi::mkl::blas::column_major::tbsv(device_queue->val, convert(upper_lower), convert(trans), convert(unit_diag), n, k, reinterpret_cast*>(a), lda, reinterpret_cast*>(x), incx, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::tbsv(device_queue->val, convert(upper_lower), convert(trans), convert(unit_diag), n, k, reinterpret_cast*>(a), lda, reinterpret_cast*>(x), incx, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklStpmv(syclQueue_t device_queue, onemklUplo upper_lower, onemklTranspose trans, onemklDiag unit_diag, int64_t n, float *a, float *x, int64_t incx) { - auto status = oneapi::mkl::blas::column_major::tpmv(device_queue->val, convert(upper_lower), convert(trans), convert(unit_diag), n, a, x, incx, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::tpmv(device_queue->val, convert(upper_lower), convert(trans), convert(unit_diag), n, a, x, incx, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklDtpmv(syclQueue_t device_queue, onemklUplo upper_lower, onemklTranspose trans, onemklDiag unit_diag, int64_t n, double *a, double *x, int64_t incx) { - auto status = oneapi::mkl::blas::column_major::tpmv(device_queue->val, convert(upper_lower), convert(trans), convert(unit_diag), n, a, x, incx, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::tpmv(device_queue->val, convert(upper_lower), convert(trans), convert(unit_diag), n, a, x, incx, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklCtpmv(syclQueue_t device_queue, onemklUplo upper_lower, onemklTranspose trans, onemklDiag unit_diag, int64_t n, float _Complex *a, float _Complex *x, int64_t incx) { - auto status = oneapi::mkl::blas::column_major::tpmv(device_queue->val, convert(upper_lower), convert(trans), convert(unit_diag), n, reinterpret_cast*>(a), reinterpret_cast*>(x), incx, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::tpmv(device_queue->val, convert(upper_lower), convert(trans), convert(unit_diag), n, reinterpret_cast*>(a), reinterpret_cast*>(x), incx, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklZtpmv(syclQueue_t device_queue, onemklUplo upper_lower, onemklTranspose trans, onemklDiag unit_diag, int64_t n, double _Complex *a, double _Complex *x, int64_t incx) { - auto status = oneapi::mkl::blas::column_major::tpmv(device_queue->val, convert(upper_lower), convert(trans), convert(unit_diag), n, reinterpret_cast*>(a), reinterpret_cast*>(x), incx, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::tpmv(device_queue->val, convert(upper_lower), convert(trans), convert(unit_diag), n, reinterpret_cast*>(a), reinterpret_cast*>(x), incx, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklStpsv(syclQueue_t device_queue, onemklUplo upper_lower, onemklTranspose trans, onemklDiag unit_diag, int64_t n, float *a, float *x, int64_t incx) { - auto status = oneapi::mkl::blas::column_major::tpsv(device_queue->val, convert(upper_lower), convert(trans), convert(unit_diag), n, a, x, incx, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::tpsv(device_queue->val, convert(upper_lower), convert(trans), convert(unit_diag), n, a, x, incx, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklDtpsv(syclQueue_t device_queue, onemklUplo upper_lower, onemklTranspose trans, onemklDiag unit_diag, int64_t n, double *a, double *x, int64_t incx) { - auto status = oneapi::mkl::blas::column_major::tpsv(device_queue->val, convert(upper_lower), convert(trans), convert(unit_diag), n, a, x, incx, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::tpsv(device_queue->val, convert(upper_lower), convert(trans), convert(unit_diag), n, a, x, incx, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklCtpsv(syclQueue_t device_queue, onemklUplo upper_lower, onemklTranspose trans, onemklDiag unit_diag, int64_t n, float _Complex *a, float _Complex *x, int64_t incx) { - auto status = oneapi::mkl::blas::column_major::tpsv(device_queue->val, convert(upper_lower), convert(trans), convert(unit_diag), n, reinterpret_cast*>(a), reinterpret_cast*>(x), incx, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::tpsv(device_queue->val, convert(upper_lower), convert(trans), convert(unit_diag), n, reinterpret_cast*>(a), reinterpret_cast*>(x), incx, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklZtpsv(syclQueue_t device_queue, onemklUplo upper_lower, onemklTranspose trans, onemklDiag unit_diag, int64_t n, double _Complex *a, double _Complex *x, int64_t incx) { - auto status = oneapi::mkl::blas::column_major::tpsv(device_queue->val, convert(upper_lower), convert(trans), convert(unit_diag), n, reinterpret_cast*>(a), reinterpret_cast*>(x), incx, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::tpsv(device_queue->val, convert(upper_lower), convert(trans), convert(unit_diag), n, reinterpret_cast*>(a), reinterpret_cast*>(x), incx, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklStrmv(syclQueue_t device_queue, onemklUplo upper_lower, onemklTranspose trans, onemklDiag unit_diag, int64_t n, float *a, int64_t lda, float *x, int64_t incx) { - auto status = oneapi::mkl::blas::column_major::trmv(device_queue->val, convert(upper_lower), convert(trans), convert(unit_diag), n, a, lda, x, incx, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::trmv(device_queue->val, convert(upper_lower), convert(trans), convert(unit_diag), n, a, lda, x, incx, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklDtrmv(syclQueue_t device_queue, onemklUplo upper_lower, onemklTranspose trans, onemklDiag unit_diag, int64_t n, double *a, int64_t lda, double *x, int64_t incx) { - auto status = oneapi::mkl::blas::column_major::trmv(device_queue->val, convert(upper_lower), convert(trans), convert(unit_diag), n, a, lda, x, incx, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::trmv(device_queue->val, convert(upper_lower), convert(trans), convert(unit_diag), n, a, lda, x, incx, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklCtrmv(syclQueue_t device_queue, onemklUplo upper_lower, onemklTranspose trans, onemklDiag unit_diag, int64_t n, float _Complex *a, int64_t lda, float _Complex *x, int64_t incx) { - auto status = oneapi::mkl::blas::column_major::trmv(device_queue->val, convert(upper_lower), convert(trans), convert(unit_diag), n, reinterpret_cast*>(a), lda, reinterpret_cast*>(x), incx, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::trmv(device_queue->val, convert(upper_lower), convert(trans), convert(unit_diag), n, reinterpret_cast*>(a), lda, reinterpret_cast*>(x), incx, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklZtrmv(syclQueue_t device_queue, onemklUplo upper_lower, onemklTranspose trans, onemklDiag unit_diag, int64_t n, double _Complex *a, int64_t lda, double _Complex *x, int64_t incx) { - auto status = oneapi::mkl::blas::column_major::trmv(device_queue->val, convert(upper_lower), convert(trans), convert(unit_diag), n, reinterpret_cast*>(a), lda, reinterpret_cast*>(x), incx, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::trmv(device_queue->val, convert(upper_lower), convert(trans), convert(unit_diag), n, reinterpret_cast*>(a), lda, reinterpret_cast*>(x), incx, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklStrsv(syclQueue_t device_queue, onemklUplo upper_lower, onemklTranspose trans, onemklDiag unit_diag, int64_t n, float *a, int64_t lda, float *x, int64_t incx) { - auto status = oneapi::mkl::blas::column_major::trsv(device_queue->val, convert(upper_lower), convert(trans), convert(unit_diag), n, a, lda, x, incx, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::trsv(device_queue->val, convert(upper_lower), convert(trans), convert(unit_diag), n, a, lda, x, incx, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklDtrsv(syclQueue_t device_queue, onemklUplo upper_lower, onemklTranspose trans, onemklDiag unit_diag, int64_t n, double *a, int64_t lda, double *x, int64_t incx) { - auto status = oneapi::mkl::blas::column_major::trsv(device_queue->val, convert(upper_lower), convert(trans), convert(unit_diag), n, a, lda, x, incx, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::trsv(device_queue->val, convert(upper_lower), convert(trans), convert(unit_diag), n, a, lda, x, incx, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklCtrsv(syclQueue_t device_queue, onemklUplo upper_lower, onemklTranspose trans, onemklDiag unit_diag, int64_t n, float _Complex *a, int64_t lda, float _Complex *x, int64_t incx) { - auto status = oneapi::mkl::blas::column_major::trsv(device_queue->val, convert(upper_lower), convert(trans), convert(unit_diag), n, reinterpret_cast*>(a), lda, reinterpret_cast*>(x), incx, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::trsv(device_queue->val, convert(upper_lower), convert(trans), convert(unit_diag), n, reinterpret_cast*>(a), lda, reinterpret_cast*>(x), incx, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklZtrsv(syclQueue_t device_queue, onemklUplo upper_lower, onemklTranspose trans, onemklDiag unit_diag, int64_t n, double _Complex *a, int64_t lda, double _Complex *x, int64_t incx) { - auto status = oneapi::mkl::blas::column_major::trsv(device_queue->val, convert(upper_lower), convert(trans), convert(unit_diag), n, reinterpret_cast*>(a), lda, reinterpret_cast*>(x), incx, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::trsv(device_queue->val, convert(upper_lower), convert(trans), convert(unit_diag), n, reinterpret_cast*>(a), lda, reinterpret_cast*>(x), incx, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklCdotc(syclQueue_t device_queue, int64_t n, float _Complex *x, int64_t incx, float _Complex *y, int64_t incy, float _Complex *result) { - auto status = oneapi::mkl::blas::column_major::dotc(device_queue->val, n, reinterpret_cast*>(x), incx, reinterpret_cast*>(y), incy, reinterpret_cast*>(result), {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::dotc(device_queue->val, n, reinterpret_cast*>(x), incx, reinterpret_cast*>(y), incy, reinterpret_cast*>(result), {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklZdotc(syclQueue_t device_queue, int64_t n, double _Complex *x, int64_t incx, double _Complex *y, int64_t incy, double _Complex *result) { - auto status = oneapi::mkl::blas::column_major::dotc(device_queue->val, n, reinterpret_cast*>(x), incx, reinterpret_cast*>(y), incy, reinterpret_cast*>(result), {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::dotc(device_queue->val, n, reinterpret_cast*>(x), incx, reinterpret_cast*>(y), incy, reinterpret_cast*>(result), {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklCdotu(syclQueue_t device_queue, int64_t n, float _Complex *x, int64_t incx, float _Complex *y, int64_t incy, float _Complex *result) { - auto status = oneapi::mkl::blas::column_major::dotu(device_queue->val, n, reinterpret_cast*>(x), incx, reinterpret_cast*>(y), incy, reinterpret_cast*>(result), {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::dotu(device_queue->val, n, reinterpret_cast*>(x), incx, reinterpret_cast*>(y), incy, reinterpret_cast*>(result), {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklZdotu(syclQueue_t device_queue, int64_t n, double _Complex *x, int64_t incx, double _Complex *y, int64_t incy, double _Complex *result) { - auto status = oneapi::mkl::blas::column_major::dotu(device_queue->val, n, reinterpret_cast*>(x), incx, reinterpret_cast*>(y), incy, reinterpret_cast*>(result), {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::dotu(device_queue->val, n, reinterpret_cast*>(x), incx, reinterpret_cast*>(y), incy, reinterpret_cast*>(result), {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklSiamax(syclQueue_t device_queue, int64_t n, float *x, int64_t incx, int32_t *result, onemklIndex base) { - auto status = oneapi::mkl::blas::column_major::iamax(device_queue->val, n, x, incx, result, convert(base), {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::iamax(device_queue->val, n, x, incx, result, convert(base), {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklSiamax_64(syclQueue_t device_queue, int64_t n, float *x, int64_t incx, int64_t *result, onemklIndex base) { - auto status = oneapi::mkl::blas::column_major::iamax(device_queue->val, n, x, incx, result, convert(base), {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::iamax(device_queue->val, n, x, incx, result, convert(base), {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklDiamax(syclQueue_t device_queue, int64_t n, double *x, int64_t incx, int32_t *result, onemklIndex base) { - auto status = oneapi::mkl::blas::column_major::iamax(device_queue->val, n, x, incx, result, convert(base), {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::iamax(device_queue->val, n, x, incx, result, convert(base), {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklDiamax_64(syclQueue_t device_queue, int64_t n, double *x, int64_t incx, int64_t *result, onemklIndex base) { - auto status = oneapi::mkl::blas::column_major::iamax(device_queue->val, n, x, incx, result, convert(base), {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::iamax(device_queue->val, n, x, incx, result, convert(base), {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklCiamax(syclQueue_t device_queue, int64_t n, float _Complex *x, int64_t incx, int32_t *result, onemklIndex base) { - auto status = oneapi::mkl::blas::column_major::iamax(device_queue->val, n, reinterpret_cast*>(x), incx, result, convert(base), {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::iamax(device_queue->val, n, reinterpret_cast*>(x), incx, result, convert(base), {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklCiamax_64(syclQueue_t device_queue, int64_t n, float _Complex *x, int64_t incx, int64_t *result, onemklIndex base) { - auto status = oneapi::mkl::blas::column_major::iamax(device_queue->val, n, reinterpret_cast*>(x), incx, result, convert(base), {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::iamax(device_queue->val, n, reinterpret_cast*>(x), incx, result, convert(base), {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklZiamax(syclQueue_t device_queue, int64_t n, double _Complex *x, int64_t incx, int32_t *result, onemklIndex base) { - auto status = oneapi::mkl::blas::column_major::iamax(device_queue->val, n, reinterpret_cast*>(x), incx, result, convert(base), {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::iamax(device_queue->val, n, reinterpret_cast*>(x), incx, result, convert(base), {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklZiamax_64(syclQueue_t device_queue, int64_t n, double _Complex *x, int64_t incx, int64_t *result, onemklIndex base) { - auto status = oneapi::mkl::blas::column_major::iamax(device_queue->val, n, reinterpret_cast*>(x), incx, result, convert(base), {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::iamax(device_queue->val, n, reinterpret_cast*>(x), incx, result, convert(base), {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklSiamin(syclQueue_t device_queue, int64_t n, float *x, int64_t incx, int32_t *result, onemklIndex base) { - auto status = oneapi::mkl::blas::column_major::iamin(device_queue->val, n, x, incx, result, convert(base), {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::iamin(device_queue->val, n, x, incx, result, convert(base), {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklSiamin_64(syclQueue_t device_queue, int64_t n, float *x, int64_t incx, int64_t *result, onemklIndex base) { - auto status = oneapi::mkl::blas::column_major::iamin(device_queue->val, n, x, incx, result, convert(base), {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::iamin(device_queue->val, n, x, incx, result, convert(base), {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklDiamin(syclQueue_t device_queue, int64_t n, double *x, int64_t incx, int32_t *result, onemklIndex base) { - auto status = oneapi::mkl::blas::column_major::iamin(device_queue->val, n, x, incx, result, convert(base), {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::iamin(device_queue->val, n, x, incx, result, convert(base), {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklDiamin_64(syclQueue_t device_queue, int64_t n, double *x, int64_t incx, int64_t *result, onemklIndex base) { - auto status = oneapi::mkl::blas::column_major::iamin(device_queue->val, n, x, incx, result, convert(base), {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::iamin(device_queue->val, n, x, incx, result, convert(base), {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklCiamin(syclQueue_t device_queue, int64_t n, float _Complex *x, int64_t incx, int32_t *result, onemklIndex base) { - auto status = oneapi::mkl::blas::column_major::iamin(device_queue->val, n, reinterpret_cast*>(x), incx, result, convert(base), {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::iamin(device_queue->val, n, reinterpret_cast*>(x), incx, result, convert(base), {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklCiamin_64(syclQueue_t device_queue, int64_t n, float _Complex *x, int64_t incx, int64_t *result, onemklIndex base) { - auto status = oneapi::mkl::blas::column_major::iamin(device_queue->val, n, reinterpret_cast*>(x), incx, result, convert(base), {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::iamin(device_queue->val, n, reinterpret_cast*>(x), incx, result, convert(base), {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklZiamin(syclQueue_t device_queue, int64_t n, double _Complex *x, int64_t incx, int32_t *result, onemklIndex base) { - auto status = oneapi::mkl::blas::column_major::iamin(device_queue->val, n, reinterpret_cast*>(x), incx, result, convert(base), {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::iamin(device_queue->val, n, reinterpret_cast*>(x), incx, result, convert(base), {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklZiamin_64(syclQueue_t device_queue, int64_t n, double _Complex *x, int64_t incx, int64_t *result, onemklIndex base) { - auto status = oneapi::mkl::blas::column_major::iamin(device_queue->val, n, reinterpret_cast*>(x), incx, result, convert(base), {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::iamin(device_queue->val, n, reinterpret_cast*>(x), incx, result, convert(base), {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklSasum(syclQueue_t device_queue, int64_t n, float *x, int64_t incx, float *result) { - auto status = oneapi::mkl::blas::column_major::asum(device_queue->val, n, x, incx, result, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::asum(device_queue->val, n, x, incx, result, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklDasum(syclQueue_t device_queue, int64_t n, double *x, int64_t incx, double *result) { - auto status = oneapi::mkl::blas::column_major::asum(device_queue->val, n, x, incx, result, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::asum(device_queue->val, n, x, incx, result, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklCasum(syclQueue_t device_queue, int64_t n, float _Complex *x, int64_t incx, float *result) { - auto status = oneapi::mkl::blas::column_major::asum(device_queue->val, n, reinterpret_cast*>(x), incx, result, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::asum(device_queue->val, n, reinterpret_cast*>(x), incx, result, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklZasum(syclQueue_t device_queue, int64_t n, double _Complex *x, int64_t incx, double *result) { - auto status = oneapi::mkl::blas::column_major::asum(device_queue->val, n, reinterpret_cast*>(x), incx, result, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::asum(device_queue->val, n, reinterpret_cast*>(x), incx, result, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } 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, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::axpy(device_queue->val, n, *reinterpret_cast(alpha), reinterpret_cast(x), incx, reinterpret_cast(y), incy, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::axpy(device_queue->val, n, *alpha, x, incx, y, incy, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::axpy(device_queue->val, n, *alpha, x, incx, y, incy, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::axpy(device_queue->val, n, *reinterpret_cast*>(alpha), reinterpret_cast*>(x), incx, reinterpret_cast*>(y), incy, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::axpy(device_queue->val, n, *reinterpret_cast*>(alpha), reinterpret_cast*>(x), incx, reinterpret_cast*>(y), incy, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::axpby(device_queue->val, n, *alpha, x, incx, *beta, y, incy, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::axpby(device_queue->val, n, *alpha, x, incx, *beta, y, incy, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklScopy(syclQueue_t device_queue, int64_t n, float *x, int64_t incx, float *y, int64_t incy) { - auto status = oneapi::mkl::blas::column_major::copy(device_queue->val, n, x, incx, y, incy, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::copy(device_queue->val, n, x, incx, y, incy, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklDcopy(syclQueue_t device_queue, int64_t n, double *x, int64_t incx, double *y, int64_t incy) { - auto status = oneapi::mkl::blas::column_major::copy(device_queue->val, n, x, incx, y, incy, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::copy(device_queue->val, n, x, incx, y, incy, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklCcopy(syclQueue_t device_queue, int64_t n, float _Complex *x, int64_t incx, float _Complex *y, int64_t incy) { - auto status = oneapi::mkl::blas::column_major::copy(device_queue->val, n, reinterpret_cast*>(x), incx, reinterpret_cast*>(y), incy, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::copy(device_queue->val, n, reinterpret_cast*>(x), incx, reinterpret_cast*>(y), incy, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklZcopy(syclQueue_t device_queue, int64_t n, double _Complex *x, int64_t incx, double _Complex *y, int64_t incy) { - auto status = oneapi::mkl::blas::column_major::copy(device_queue->val, n, reinterpret_cast*>(x), incx, reinterpret_cast*>(y), incy, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::copy(device_queue->val, n, reinterpret_cast*>(x), incx, reinterpret_cast*>(y), incy, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklHdot(syclQueue_t device_queue, int64_t n, short *x, int64_t incx, short *y, int64_t incy, short *result) { - auto status = oneapi::mkl::blas::column_major::dot(device_queue->val, n, reinterpret_cast(x), incx, reinterpret_cast(y), incy, reinterpret_cast(result), {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::dot(device_queue->val, n, reinterpret_cast(x), incx, reinterpret_cast(y), incy, reinterpret_cast(result), {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklSdot(syclQueue_t device_queue, int64_t n, float *x, int64_t incx, float *y, int64_t incy, float *result) { - auto status = oneapi::mkl::blas::column_major::dot(device_queue->val, n, x, incx, y, incy, result, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::dot(device_queue->val, n, x, incx, y, incy, result, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklDdot(syclQueue_t device_queue, int64_t n, double *x, int64_t incx, double *y, int64_t incy, double *result) { - auto status = oneapi::mkl::blas::column_major::dot(device_queue->val, n, x, incx, y, incy, result, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::dot(device_queue->val, n, x, incx, y, incy, result, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::sdsdot(device_queue->val, n, *sb, x, incx, y, incy, result, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklHnrm2(syclQueue_t device_queue, int64_t n, short *x, int64_t incx, short *result) { - auto status = oneapi::mkl::blas::column_major::nrm2(device_queue->val, n, reinterpret_cast(x), incx, reinterpret_cast(result), {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::nrm2(device_queue->val, n, reinterpret_cast(x), incx, reinterpret_cast(result), {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklSnrm2(syclQueue_t device_queue, int64_t n, float *x, int64_t incx, float *result) { - auto status = oneapi::mkl::blas::column_major::nrm2(device_queue->val, n, x, incx, result, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::nrm2(device_queue->val, n, x, incx, result, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklDnrm2(syclQueue_t device_queue, int64_t n, double *x, int64_t incx, double *result) { - auto status = oneapi::mkl::blas::column_major::nrm2(device_queue->val, n, x, incx, result, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::nrm2(device_queue->val, n, x, incx, result, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklCnrm2(syclQueue_t device_queue, int64_t n, float _Complex *x, int64_t incx, float *result) { - auto status = oneapi::mkl::blas::column_major::nrm2(device_queue->val, n, reinterpret_cast*>(x), incx, result, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::nrm2(device_queue->val, n, reinterpret_cast*>(x), incx, result, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklZnrm2(syclQueue_t device_queue, int64_t n, double _Complex *x, int64_t incx, double *result) { - auto status = oneapi::mkl::blas::column_major::nrm2(device_queue->val, n, reinterpret_cast*>(x), incx, result, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::nrm2(device_queue->val, n, reinterpret_cast*>(x), incx, result, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } 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), {}); - device_queue->val.wait_and_throw(); + try { + 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), {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::rot(device_queue->val, n, x, incx, y, incy, *c, *s, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::rot(device_queue->val, n, x, incx, y, incy, *c, *s, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::rot(device_queue->val, n, reinterpret_cast*>(x), incx, reinterpret_cast*>(y), incy, *c, *s, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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), {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::rot(device_queue->val, n, reinterpret_cast*>(x), incx, reinterpret_cast*>(y), incy, *c, *reinterpret_cast*>(s), {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::rot(device_queue->val, n, reinterpret_cast*>(x), incx, reinterpret_cast*>(y), incy, *c, *s, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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), {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::rot(device_queue->val, n, reinterpret_cast*>(x), incx, reinterpret_cast*>(y), incy, *c, *reinterpret_cast*>(s), {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklSrotg(syclQueue_t device_queue, float *a, float *b, float *c, float *s) { - auto status = oneapi::mkl::blas::column_major::rotg(device_queue->val, a, b, c, s, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::rotg(device_queue->val, a, b, c, s, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklDrotg(syclQueue_t device_queue, double *a, double *b, double *c, double *s) { - auto status = oneapi::mkl::blas::column_major::rotg(device_queue->val, a, b, c, s, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::rotg(device_queue->val, a, b, c, s, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklCrotg(syclQueue_t device_queue, float _Complex *a, float _Complex *b, float *c, float _Complex *s) { - auto status = oneapi::mkl::blas::column_major::rotg(device_queue->val, reinterpret_cast*>(a), reinterpret_cast*>(b), c, reinterpret_cast*>(s), {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::rotg(device_queue->val, reinterpret_cast*>(a), reinterpret_cast*>(b), c, reinterpret_cast*>(s), {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklZrotg(syclQueue_t device_queue, double _Complex *a, double _Complex *b, double *c, double _Complex *s) { - auto status = oneapi::mkl::blas::column_major::rotg(device_queue->val, reinterpret_cast*>(a), reinterpret_cast*>(b), c, reinterpret_cast*>(s), {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::rotg(device_queue->val, reinterpret_cast*>(a), reinterpret_cast*>(b), c, reinterpret_cast*>(s), {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklSrotm(syclQueue_t device_queue, int64_t n, float *x, int64_t incx, float *y, int64_t incy, float *param) { - auto status = oneapi::mkl::blas::column_major::rotm(device_queue->val, n, x, incx, y, incy, param, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::rotm(device_queue->val, n, x, incx, y, incy, param, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklDrotm(syclQueue_t device_queue, int64_t n, double *x, int64_t incx, double *y, int64_t incy, double *param) { - auto status = oneapi::mkl::blas::column_major::rotm(device_queue->val, n, x, incx, y, incy, param, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::rotm(device_queue->val, n, x, incx, y, incy, param, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } 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, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::rotmg(device_queue->val, d1, d2, x1, *y1, param, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } 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, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::rotmg(device_queue->val, d1, d2, x1, *y1, param, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::scal(device_queue->val, n, *reinterpret_cast(alpha), reinterpret_cast(x), incx, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::scal(device_queue->val, n, *alpha, x, incx, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::scal(device_queue->val, n, *alpha, x, incx, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::scal(device_queue->val, n, *alpha, reinterpret_cast*>(x), incx, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::scal(device_queue->val, n, *alpha, reinterpret_cast*>(x), incx, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::scal(device_queue->val, n, *reinterpret_cast*>(alpha), reinterpret_cast*>(x), incx, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::scal(device_queue->val, n, *reinterpret_cast*>(alpha), reinterpret_cast*>(x), incx, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklSswap(syclQueue_t device_queue, int64_t n, float *x, int64_t incx, float *y, int64_t incy) { - auto status = oneapi::mkl::blas::column_major::swap(device_queue->val, n, x, incx, y, incy, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::swap(device_queue->val, n, x, incx, y, incy, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklDswap(syclQueue_t device_queue, int64_t n, double *x, int64_t incx, double *y, int64_t incy) { - auto status = oneapi::mkl::blas::column_major::swap(device_queue->val, n, x, incx, y, incy, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::swap(device_queue->val, n, x, incx, y, incy, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklCswap(syclQueue_t device_queue, int64_t n, float _Complex *x, int64_t incx, float _Complex *y, int64_t incy) { - auto status = oneapi::mkl::blas::column_major::swap(device_queue->val, n, reinterpret_cast*>(x), incx, reinterpret_cast*>(y), incy, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::swap(device_queue->val, n, reinterpret_cast*>(x), incx, reinterpret_cast*>(y), incy, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklZswap(syclQueue_t device_queue, int64_t n, double _Complex *x, int64_t incx, double _Complex *y, int64_t incy) { - auto status = oneapi::mkl::blas::column_major::swap(device_queue->val, n, reinterpret_cast*>(x), incx, reinterpret_cast*>(y), incy, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::swap(device_queue->val, n, reinterpret_cast*>(x), incx, reinterpret_cast*>(y), incy, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklSdgmm_batch_strided(syclQueue_t device_queue, onemklSide left_right, int64_t m, int64_t n, float *a, int64_t lda, int64_t stridea, float *x, int64_t incx, int64_t stridex, float *c, int64_t ldc, int64_t stridec, int64_t batch_size) { - auto status = oneapi::mkl::blas::column_major::dgmm_batch(device_queue->val, convert(left_right), m, n, a, lda, stridea, x, incx, stridex, c, ldc, stridec, batch_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::dgmm_batch(device_queue->val, convert(left_right), m, n, a, lda, stridea, x, incx, stridex, c, ldc, stridec, batch_size, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklDdgmm_batch_strided(syclQueue_t device_queue, onemklSide left_right, int64_t m, int64_t n, double *a, int64_t lda, int64_t stridea, double *x, int64_t incx, int64_t stridex, double *c, int64_t ldc, int64_t stridec, int64_t batch_size) { - auto status = oneapi::mkl::blas::column_major::dgmm_batch(device_queue->val, convert(left_right), m, n, a, lda, stridea, x, incx, stridex, c, ldc, stridec, batch_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::dgmm_batch(device_queue->val, convert(left_right), m, n, a, lda, stridea, x, incx, stridex, c, ldc, stridec, batch_size, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklCdgmm_batch_strided(syclQueue_t device_queue, onemklSide left_right, int64_t m, int64_t n, float _Complex *a, int64_t lda, int64_t stridea, float _Complex *x, int64_t incx, int64_t stridex, float _Complex *c, int64_t ldc, int64_t stridec, int64_t batch_size) { - auto status = oneapi::mkl::blas::column_major::dgmm_batch(device_queue->val, convert(left_right), m, n, reinterpret_cast*>(a), lda, stridea, reinterpret_cast*>(x), incx, stridex, reinterpret_cast*>(c), ldc, stridec, batch_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::dgmm_batch(device_queue->val, convert(left_right), m, n, reinterpret_cast*>(a), lda, stridea, reinterpret_cast*>(x), incx, stridex, reinterpret_cast*>(c), ldc, stridec, batch_size, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklZdgmm_batch_strided(syclQueue_t device_queue, onemklSide left_right, int64_t m, int64_t n, double _Complex *a, int64_t lda, int64_t stridea, double _Complex *x, int64_t incx, int64_t stridex, double _Complex *c, int64_t ldc, int64_t stridec, int64_t batch_size) { - auto status = oneapi::mkl::blas::column_major::dgmm_batch(device_queue->val, convert(left_right), m, n, reinterpret_cast*>(a), lda, stridea, reinterpret_cast*>(x), incx, stridex, reinterpret_cast*>(c), ldc, stridec, batch_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::dgmm_batch(device_queue->val, convert(left_right), m, n, reinterpret_cast*>(a), lda, stridea, reinterpret_cast*>(x), incx, stridex, reinterpret_cast*>(c), ldc, stridec, batch_size, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } 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, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::axpy_batch(device_queue->val, n, *alpha, x, incx, stridex, y, incy, stridey, batch_size, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::axpy_batch(device_queue->val, n, *alpha, x, incx, stridex, y, incy, stridey, batch_size, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklScopy_batch_strided(syclQueue_t device_queue, int64_t n, 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::copy_batch(device_queue->val, n, x, incx, stridex, y, incy, stridey, batch_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::copy_batch(device_queue->val, n, x, incx, stridex, y, incy, stridey, batch_size, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklDcopy_batch_strided(syclQueue_t device_queue, int64_t n, 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::copy_batch(device_queue->val, n, x, incx, stridex, y, incy, stridey, batch_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::copy_batch(device_queue->val, n, x, incx, stridex, y, incy, stridey, batch_size, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklCcopy_batch_strided(syclQueue_t device_queue, int64_t n, 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::copy_batch(device_queue->val, n, reinterpret_cast*>(x), incx, stridex, reinterpret_cast*>(y), incy, stridey, batch_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::copy_batch(device_queue->val, n, reinterpret_cast*>(x), incx, stridex, reinterpret_cast*>(y), incy, stridey, batch_size, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklZcopy_batch_strided(syclQueue_t device_queue, int64_t n, 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::copy_batch(device_queue->val, n, reinterpret_cast*>(x), incx, stridex, reinterpret_cast*>(y), incy, stridey, batch_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::copy_batch(device_queue->val, n, reinterpret_cast*>(x), incx, stridex, reinterpret_cast*>(y), incy, stridey, batch_size, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::imatcopy(device_queue->val, convert(trans), m, n, *alpha, ab, lda, ldb, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::imatcopy(device_queue->val, convert(trans), m, n, *alpha, ab, lda, ldb, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::imatcopy(device_queue->val, convert(trans), m, n, *reinterpret_cast*>(alpha), reinterpret_cast*>(ab), lda, ldb, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::imatcopy(device_queue->val, convert(trans), m, n, *reinterpret_cast*>(alpha), reinterpret_cast*>(ab), lda, ldb, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::omatcopy(device_queue->val, convert(trans), m, n, *alpha, a, lda, b, ldb, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::omatcopy(device_queue->val, convert(trans), m, n, *alpha, a, lda, b, ldb, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::imatcopy_batch(device_queue->val, convert(trans), m, n, *alpha, ab, lda, ldb, stride, batch_size, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::blas::column_major::imatcopy_batch(device_queue->val, convert(trans), m, n, *alpha, ab, lda, ldb, stride, batch_size, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } // LAPACK extern "C" int onemklSpotrf(syclQueue_t device_queue, onemklUplo uplo, int64_t n, float *a, int64_t lda, float *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::potrf(device_queue->val, convert(uplo), n, a, lda, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::potrf(device_queue->val, convert(uplo), n, a, lda, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklDpotrf(syclQueue_t device_queue, onemklUplo uplo, int64_t n, double *a, int64_t lda, double *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::potrf(device_queue->val, convert(uplo), n, a, lda, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::potrf(device_queue->val, convert(uplo), n, a, lda, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklCpotrf(syclQueue_t device_queue, onemklUplo uplo, int64_t n, float _Complex *a, int64_t lda, float _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::potrf(device_queue->val, convert(uplo), n, reinterpret_cast*>(a), lda, reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::potrf(device_queue->val, convert(uplo), n, reinterpret_cast*>(a), lda, reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklZpotrf(syclQueue_t device_queue, onemklUplo uplo, int64_t n, double _Complex *a, int64_t lda, double _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::potrf(device_queue->val, convert(uplo), n, reinterpret_cast*>(a), lda, reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::potrf(device_queue->val, convert(uplo), n, reinterpret_cast*>(a), lda, reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklSpotrs(syclQueue_t device_queue, onemklUplo uplo, int64_t n, int64_t nrhs, float *a, int64_t lda, float *b, int64_t ldb, float *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::potrs(device_queue->val, convert(uplo), n, nrhs, a, lda, b, ldb, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::potrs(device_queue->val, convert(uplo), n, nrhs, a, lda, b, ldb, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklDpotrs(syclQueue_t device_queue, onemklUplo uplo, int64_t n, int64_t nrhs, double *a, int64_t lda, double *b, int64_t ldb, double *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::potrs(device_queue->val, convert(uplo), n, nrhs, a, lda, b, ldb, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::potrs(device_queue->val, convert(uplo), n, nrhs, a, lda, b, ldb, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklCpotrs(syclQueue_t device_queue, onemklUplo uplo, int64_t n, int64_t nrhs, float _Complex *a, int64_t lda, float _Complex *b, int64_t ldb, float _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::potrs(device_queue->val, convert(uplo), n, nrhs, reinterpret_cast*>(a), lda, reinterpret_cast*>(b), ldb, reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::potrs(device_queue->val, convert(uplo), n, nrhs, reinterpret_cast*>(a), lda, reinterpret_cast*>(b), ldb, reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklZpotrs(syclQueue_t device_queue, onemklUplo uplo, int64_t n, int64_t nrhs, double _Complex *a, int64_t lda, double _Complex *b, int64_t ldb, double _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::potrs(device_queue->val, convert(uplo), n, nrhs, reinterpret_cast*>(a), lda, reinterpret_cast*>(b), ldb, reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::potrs(device_queue->val, convert(uplo), n, nrhs, reinterpret_cast*>(a), lda, reinterpret_cast*>(b), ldb, reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklSpotri(syclQueue_t device_queue, onemklUplo uplo, int64_t n, float *a, int64_t lda, float *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::potri(device_queue->val, convert(uplo), n, a, lda, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::potri(device_queue->val, convert(uplo), n, a, lda, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklDpotri(syclQueue_t device_queue, onemklUplo uplo, int64_t n, double *a, int64_t lda, double *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::potri(device_queue->val, convert(uplo), n, a, lda, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::potri(device_queue->val, convert(uplo), n, a, lda, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklCpotri(syclQueue_t device_queue, onemklUplo uplo, int64_t n, float _Complex *a, int64_t lda, float _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::potri(device_queue->val, convert(uplo), n, reinterpret_cast*>(a), lda, reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::potri(device_queue->val, convert(uplo), n, reinterpret_cast*>(a), lda, reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklZpotri(syclQueue_t device_queue, onemklUplo uplo, int64_t n, double _Complex *a, int64_t lda, double _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::potri(device_queue->val, convert(uplo), n, reinterpret_cast*>(a), lda, reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::potri(device_queue->val, convert(uplo), n, reinterpret_cast*>(a), lda, reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklStrtri(syclQueue_t device_queue, onemklUplo uplo, onemklDiag diag, int64_t n, float *a, int64_t lda, float *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::trtri(device_queue->val, convert(uplo), convert(diag), n, a, lda, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::trtri(device_queue->val, convert(uplo), convert(diag), n, a, lda, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklDtrtri(syclQueue_t device_queue, onemklUplo uplo, onemklDiag diag, int64_t n, double *a, int64_t lda, double *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::trtri(device_queue->val, convert(uplo), convert(diag), n, a, lda, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::trtri(device_queue->val, convert(uplo), convert(diag), n, a, lda, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklCtrtri(syclQueue_t device_queue, onemklUplo uplo, onemklDiag diag, int64_t n, float _Complex *a, int64_t lda, float _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::trtri(device_queue->val, convert(uplo), convert(diag), n, reinterpret_cast*>(a), lda, reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::trtri(device_queue->val, convert(uplo), convert(diag), n, reinterpret_cast*>(a), lda, reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklZtrtri(syclQueue_t device_queue, onemklUplo uplo, onemklDiag diag, int64_t n, double _Complex *a, int64_t lda, double _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::trtri(device_queue->val, convert(uplo), convert(diag), n, reinterpret_cast*>(a), lda, reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::trtri(device_queue->val, convert(uplo), convert(diag), n, reinterpret_cast*>(a), lda, reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklSgesv(syclQueue_t device_queue, int64_t n, int64_t nrhs, float *a, int64_t lda, int64_t *ipiv, float *b, int64_t ldb, float *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::gesv(device_queue->val, n, nrhs, a, lda, ipiv, b, ldb, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::gesv(device_queue->val, n, nrhs, a, lda, ipiv, b, ldb, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklDgesv(syclQueue_t device_queue, int64_t n, int64_t nrhs, double *a, int64_t lda, int64_t *ipiv, double *b, int64_t ldb, double *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::gesv(device_queue->val, n, nrhs, a, lda, ipiv, b, ldb, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::gesv(device_queue->val, n, nrhs, a, lda, ipiv, b, ldb, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklCgesv(syclQueue_t device_queue, int64_t n, int64_t nrhs, float _Complex *a, int64_t lda, int64_t *ipiv, float _Complex *b, int64_t ldb, float _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::gesv(device_queue->val, n, nrhs, reinterpret_cast*>(a), lda, ipiv, reinterpret_cast*>(b), ldb, reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::gesv(device_queue->val, n, nrhs, reinterpret_cast*>(a), lda, ipiv, reinterpret_cast*>(b), ldb, reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklZgesv(syclQueue_t device_queue, int64_t n, int64_t nrhs, double _Complex *a, int64_t lda, int64_t *ipiv, double _Complex *b, int64_t ldb, double _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::gesv(device_queue->val, n, nrhs, reinterpret_cast*>(a), lda, ipiv, reinterpret_cast*>(b), ldb, reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::gesv(device_queue->val, n, nrhs, reinterpret_cast*>(a), lda, ipiv, reinterpret_cast*>(b), ldb, reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklCgebrd(syclQueue_t device_queue, int64_t m, int64_t n, float _Complex *a, int64_t lda, float *d, float *e, float _Complex *tauq, float _Complex *taup, float _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::gebrd(device_queue->val, m, n, reinterpret_cast*>(a), lda, d, e, reinterpret_cast*>(tauq), reinterpret_cast*>(taup), reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::gebrd(device_queue->val, m, n, reinterpret_cast*>(a), lda, d, e, reinterpret_cast*>(tauq), reinterpret_cast*>(taup), reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklDgebrd(syclQueue_t device_queue, int64_t m, int64_t n, double *a, int64_t lda, double *d, double *e, double *tauq, double *taup, double *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::gebrd(device_queue->val, m, n, a, lda, d, e, tauq, taup, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::gebrd(device_queue->val, m, n, a, lda, d, e, tauq, taup, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklSgebrd(syclQueue_t device_queue, int64_t m, int64_t n, float *a, int64_t lda, float *d, float *e, float *tauq, float *taup, float *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::gebrd(device_queue->val, m, n, a, lda, d, e, tauq, taup, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::gebrd(device_queue->val, m, n, a, lda, d, e, tauq, taup, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklZgebrd(syclQueue_t device_queue, int64_t m, int64_t n, double _Complex *a, int64_t lda, double *d, double *e, double _Complex *tauq, double _Complex *taup, double _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::gebrd(device_queue->val, m, n, reinterpret_cast*>(a), lda, d, e, reinterpret_cast*>(tauq), reinterpret_cast*>(taup), reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::gebrd(device_queue->val, m, n, reinterpret_cast*>(a), lda, d, e, reinterpret_cast*>(tauq), reinterpret_cast*>(taup), reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklCgeqrf(syclQueue_t device_queue, int64_t m, int64_t n, float _Complex *a, int64_t lda, float _Complex *tau, float _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::geqrf(device_queue->val, m, n, reinterpret_cast*>(a), lda, reinterpret_cast*>(tau), reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::geqrf(device_queue->val, m, n, reinterpret_cast*>(a), lda, reinterpret_cast*>(tau), reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklDgeqrf(syclQueue_t device_queue, int64_t m, int64_t n, double *a, int64_t lda, double *tau, double *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::geqrf(device_queue->val, m, n, a, lda, tau, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::geqrf(device_queue->val, m, n, a, lda, tau, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklSgeqrf(syclQueue_t device_queue, int64_t m, int64_t n, float *a, int64_t lda, float *tau, float *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::geqrf(device_queue->val, m, n, a, lda, tau, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::geqrf(device_queue->val, m, n, a, lda, tau, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklZgeqrf(syclQueue_t device_queue, int64_t m, int64_t n, double _Complex *a, int64_t lda, double _Complex *tau, double _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::geqrf(device_queue->val, m, n, reinterpret_cast*>(a), lda, reinterpret_cast*>(tau), reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::geqrf(device_queue->val, m, n, reinterpret_cast*>(a), lda, reinterpret_cast*>(tau), reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklCgesvd(syclQueue_t device_queue, onemklJobsvd jobu, onemklJobsvd jobvt, int64_t m, int64_t n, float _Complex *a, int64_t lda, float *s, float _Complex *u, int64_t ldu, float _Complex *vt, int64_t ldvt, float _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::gesvd(device_queue->val, convert(jobu), convert(jobvt), m, n, reinterpret_cast*>(a), lda, s, reinterpret_cast*>(u), ldu, reinterpret_cast*>(vt), ldvt, reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::gesvd(device_queue->val, convert(jobu), convert(jobvt), m, n, reinterpret_cast*>(a), lda, s, reinterpret_cast*>(u), ldu, reinterpret_cast*>(vt), ldvt, reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklZgesvd(syclQueue_t device_queue, onemklJobsvd jobu, onemklJobsvd jobvt, int64_t m, int64_t n, double _Complex *a, int64_t lda, double *s, double _Complex *u, int64_t ldu, double _Complex *vt, int64_t ldvt, double _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::gesvd(device_queue->val, convert(jobu), convert(jobvt), m, n, reinterpret_cast*>(a), lda, s, reinterpret_cast*>(u), ldu, reinterpret_cast*>(vt), ldvt, reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::gesvd(device_queue->val, convert(jobu), convert(jobvt), m, n, reinterpret_cast*>(a), lda, s, reinterpret_cast*>(u), ldu, reinterpret_cast*>(vt), ldvt, reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklDgesvd(syclQueue_t device_queue, onemklJobsvd jobu, onemklJobsvd jobvt, int64_t m, int64_t n, double *a, int64_t lda, double *s, double *u, int64_t ldu, double *vt, int64_t ldvt, double *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::gesvd(device_queue->val, convert(jobu), convert(jobvt), m, n, a, lda, s, u, ldu, vt, ldvt, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::gesvd(device_queue->val, convert(jobu), convert(jobvt), m, n, a, lda, s, u, ldu, vt, ldvt, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklSgesvd(syclQueue_t device_queue, onemklJobsvd jobu, onemklJobsvd jobvt, int64_t m, int64_t n, float *a, int64_t lda, float *s, float *u, int64_t ldu, float *vt, int64_t ldvt, float *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::gesvd(device_queue->val, convert(jobu), convert(jobvt), m, n, a, lda, s, u, ldu, vt, ldvt, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::gesvd(device_queue->val, convert(jobu), convert(jobvt), m, n, a, lda, s, u, ldu, vt, ldvt, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklCgesvda_batch_strided(syclQueue_t device_queue, int64_t *iparm, int64_t *irank, int64_t m, int64_t n, float _Complex *a, int64_t lda, int64_t stride_a, float *s, int64_t stride_s, float _Complex *u, int64_t ldu, int64_t stride_u, float _Complex *vt, int64_t ldvt, int64_t stride_vt, float *tolerance, float *residual, int64_t batch_size, float _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::gesvda_batch(device_queue->val, iparm, irank, m, n, reinterpret_cast*>(a), lda, stride_a, s, stride_s, reinterpret_cast*>(u), ldu, stride_u, reinterpret_cast*>(vt), ldvt, stride_vt, *tolerance, residual, batch_size, reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::gesvda_batch(device_queue->val, iparm, irank, m, n, reinterpret_cast*>(a), lda, stride_a, s, stride_s, reinterpret_cast*>(u), ldu, stride_u, reinterpret_cast*>(vt), ldvt, stride_vt, *tolerance, residual, batch_size, reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklDgesvda_batch_strided(syclQueue_t device_queue, int64_t *iparm, int64_t *irank, int64_t m, int64_t n, double *a, int64_t lda, int64_t stride_a, double *s, int64_t stride_s, double *u, int64_t ldu, int64_t stride_u, double *vt, int64_t ldvt, int64_t stride_vt, double *tolerance, double *residual, int64_t batch_size, double *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::gesvda_batch(device_queue->val, iparm, irank, m, n, a, lda, stride_a, s, stride_s, u, ldu, stride_u, vt, ldvt, stride_vt, *tolerance, residual, batch_size, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::gesvda_batch(device_queue->val, iparm, irank, m, n, a, lda, stride_a, s, stride_s, u, ldu, stride_u, vt, ldvt, stride_vt, *tolerance, residual, batch_size, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklSgesvda_batch_strided(syclQueue_t device_queue, int64_t *iparm, int64_t *irank, int64_t m, int64_t n, float *a, int64_t lda, int64_t stride_a, float *s, int64_t stride_s, float *u, int64_t ldu, int64_t stride_u, float *vt, int64_t ldvt, int64_t stride_vt, float *tolerance, float *residual, int64_t batch_size, float *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::gesvda_batch(device_queue->val, iparm, irank, m, n, a, lda, stride_a, s, stride_s, u, ldu, stride_u, vt, ldvt, stride_vt, *tolerance, residual, batch_size, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::gesvda_batch(device_queue->val, iparm, irank, m, n, a, lda, stride_a, s, stride_s, u, ldu, stride_u, vt, ldvt, stride_vt, *tolerance, residual, batch_size, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklZgesvda_batch_strided(syclQueue_t device_queue, int64_t *iparm, int64_t *irank, int64_t m, int64_t n, double _Complex *a, int64_t lda, int64_t stride_a, double *s, int64_t stride_s, double _Complex *u, int64_t ldu, int64_t stride_u, double _Complex *vt, int64_t ldvt, int64_t stride_vt, double *tolerance, double *residual, int64_t batch_size, double _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::gesvda_batch(device_queue->val, iparm, irank, m, n, reinterpret_cast*>(a), lda, stride_a, s, stride_s, reinterpret_cast*>(u), ldu, stride_u, reinterpret_cast*>(vt), ldvt, stride_vt, *tolerance, residual, batch_size, reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::gesvda_batch(device_queue->val, iparm, irank, m, n, reinterpret_cast*>(a), lda, stride_a, s, stride_s, reinterpret_cast*>(u), ldu, stride_u, reinterpret_cast*>(vt), ldvt, stride_vt, *tolerance, residual, batch_size, reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklCgetrf(syclQueue_t device_queue, int64_t m, int64_t n, float _Complex *a, int64_t lda, int64_t *ipiv, float _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::getrf(device_queue->val, m, n, reinterpret_cast*>(a), lda, ipiv, reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::getrf(device_queue->val, m, n, reinterpret_cast*>(a), lda, ipiv, reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklDgetrf(syclQueue_t device_queue, int64_t m, int64_t n, double *a, int64_t lda, int64_t *ipiv, double *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::getrf(device_queue->val, m, n, a, lda, ipiv, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::getrf(device_queue->val, m, n, a, lda, ipiv, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklSgetrf(syclQueue_t device_queue, int64_t m, int64_t n, float *a, int64_t lda, int64_t *ipiv, float *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::getrf(device_queue->val, m, n, a, lda, ipiv, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::getrf(device_queue->val, m, n, a, lda, ipiv, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklZgetrf(syclQueue_t device_queue, int64_t m, int64_t n, double _Complex *a, int64_t lda, int64_t *ipiv, double _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::getrf(device_queue->val, m, n, reinterpret_cast*>(a), lda, ipiv, reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::getrf(device_queue->val, m, n, reinterpret_cast*>(a), lda, ipiv, reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklCgetrf_batch(syclQueue_t device_queue, int64_t *m, int64_t *n, float _Complex **a, int64_t *lda, int64_t **ipiv, int64_t group_count, int64_t *group_sizes, float _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::getrf_batch(device_queue->val, m, n, reinterpret_cast**>(a), lda, ipiv, group_count, group_sizes, reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::getrf_batch(device_queue->val, m, n, reinterpret_cast**>(a), lda, ipiv, group_count, group_sizes, reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklDgetrf_batch(syclQueue_t device_queue, int64_t *m, int64_t *n, double **a, int64_t *lda, int64_t **ipiv, int64_t group_count, int64_t *group_sizes, double *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::getrf_batch(device_queue->val, m, n, a, lda, ipiv, group_count, group_sizes, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::getrf_batch(device_queue->val, m, n, a, lda, ipiv, group_count, group_sizes, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklSgetrf_batch(syclQueue_t device_queue, int64_t *m, int64_t *n, float **a, int64_t *lda, int64_t **ipiv, int64_t group_count, int64_t *group_sizes, float *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::getrf_batch(device_queue->val, m, n, a, lda, ipiv, group_count, group_sizes, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::getrf_batch(device_queue->val, m, n, a, lda, ipiv, group_count, group_sizes, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklZgetrf_batch(syclQueue_t device_queue, int64_t *m, int64_t *n, double _Complex **a, int64_t *lda, int64_t **ipiv, int64_t group_count, int64_t *group_sizes, double _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::getrf_batch(device_queue->val, m, n, reinterpret_cast**>(a), lda, ipiv, group_count, group_sizes, reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::getrf_batch(device_queue->val, m, n, reinterpret_cast**>(a), lda, ipiv, group_count, group_sizes, reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklCgetrf_batch_strided(syclQueue_t device_queue, int64_t m, int64_t n, float _Complex *a, int64_t lda, int64_t stride_a, int64_t *ipiv, int64_t stride_ipiv, int64_t batch_size, float _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::getrf_batch(device_queue->val, m, n, reinterpret_cast*>(a), lda, stride_a, ipiv, stride_ipiv, batch_size, reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::getrf_batch(device_queue->val, m, n, reinterpret_cast*>(a), lda, stride_a, ipiv, stride_ipiv, batch_size, reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklDgetrf_batch_strided(syclQueue_t device_queue, int64_t m, int64_t n, double *a, int64_t lda, int64_t stride_a, int64_t *ipiv, int64_t stride_ipiv, int64_t batch_size, double *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::getrf_batch(device_queue->val, m, n, a, lda, stride_a, ipiv, stride_ipiv, batch_size, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::getrf_batch(device_queue->val, m, n, a, lda, stride_a, ipiv, stride_ipiv, batch_size, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklSgetrf_batch_strided(syclQueue_t device_queue, int64_t m, int64_t n, float *a, int64_t lda, int64_t stride_a, int64_t *ipiv, int64_t stride_ipiv, int64_t batch_size, float *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::getrf_batch(device_queue->val, m, n, a, lda, stride_a, ipiv, stride_ipiv, batch_size, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::getrf_batch(device_queue->val, m, n, a, lda, stride_a, ipiv, stride_ipiv, batch_size, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklZgetrf_batch_strided(syclQueue_t device_queue, int64_t m, int64_t n, double _Complex *a, int64_t lda, int64_t stride_a, int64_t *ipiv, int64_t stride_ipiv, int64_t batch_size, double _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::getrf_batch(device_queue->val, m, n, reinterpret_cast*>(a), lda, stride_a, ipiv, stride_ipiv, batch_size, reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::getrf_batch(device_queue->val, m, n, reinterpret_cast*>(a), lda, stride_a, ipiv, stride_ipiv, batch_size, reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklCgetrfnp(syclQueue_t device_queue, int64_t m, int64_t n, float _Complex *a, int64_t lda, float _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::getrfnp(device_queue->val, m, n, reinterpret_cast*>(a), lda, reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::getrfnp(device_queue->val, m, n, reinterpret_cast*>(a), lda, reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklDgetrfnp(syclQueue_t device_queue, int64_t m, int64_t n, double *a, int64_t lda, double *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::getrfnp(device_queue->val, m, n, a, lda, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::getrfnp(device_queue->val, m, n, a, lda, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklSgetrfnp(syclQueue_t device_queue, int64_t m, int64_t n, float *a, int64_t lda, float *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::getrfnp(device_queue->val, m, n, a, lda, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::getrfnp(device_queue->val, m, n, a, lda, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklZgetrfnp(syclQueue_t device_queue, int64_t m, int64_t n, double _Complex *a, int64_t lda, double _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::getrfnp(device_queue->val, m, n, reinterpret_cast*>(a), lda, reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::getrfnp(device_queue->val, m, n, reinterpret_cast*>(a), lda, reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklCgetrfnp_batch(syclQueue_t device_queue, int64_t *m, int64_t *n, float _Complex **a, int64_t *lda, int64_t group_count, int64_t *group_sizes, float _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::getrfnp_batch(device_queue->val, m, n, reinterpret_cast**>(a), lda, group_count, group_sizes, reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::getrfnp_batch(device_queue->val, m, n, reinterpret_cast**>(a), lda, group_count, group_sizes, reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklDgetrfnp_batch(syclQueue_t device_queue, int64_t *m, int64_t *n, double **a, int64_t *lda, int64_t group_count, int64_t *group_sizes, double *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::getrfnp_batch(device_queue->val, m, n, a, lda, group_count, group_sizes, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::getrfnp_batch(device_queue->val, m, n, a, lda, group_count, group_sizes, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklSgetrfnp_batch(syclQueue_t device_queue, int64_t *m, int64_t *n, float **a, int64_t *lda, int64_t group_count, int64_t *group_sizes, float *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::getrfnp_batch(device_queue->val, m, n, a, lda, group_count, group_sizes, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::getrfnp_batch(device_queue->val, m, n, a, lda, group_count, group_sizes, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklZgetrfnp_batch(syclQueue_t device_queue, int64_t *m, int64_t *n, double _Complex **a, int64_t *lda, int64_t group_count, int64_t *group_sizes, double _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::getrfnp_batch(device_queue->val, m, n, reinterpret_cast**>(a), lda, group_count, group_sizes, reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::getrfnp_batch(device_queue->val, m, n, reinterpret_cast**>(a), lda, group_count, group_sizes, reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklCgetrfnp_batch_strided(syclQueue_t device_queue, int64_t m, int64_t n, float _Complex *a, int64_t lda, int64_t stride_a, int64_t batch_size, float _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::getrfnp_batch(device_queue->val, m, n, reinterpret_cast*>(a), lda, stride_a, batch_size, reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::getrfnp_batch(device_queue->val, m, n, reinterpret_cast*>(a), lda, stride_a, batch_size, reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklDgetrfnp_batch_strided(syclQueue_t device_queue, int64_t m, int64_t n, double *a, int64_t lda, int64_t stride_a, int64_t batch_size, double *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::getrfnp_batch(device_queue->val, m, n, a, lda, stride_a, batch_size, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::getrfnp_batch(device_queue->val, m, n, a, lda, stride_a, batch_size, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklSgetrfnp_batch_strided(syclQueue_t device_queue, int64_t m, int64_t n, float *a, int64_t lda, int64_t stride_a, int64_t batch_size, float *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::getrfnp_batch(device_queue->val, m, n, a, lda, stride_a, batch_size, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::getrfnp_batch(device_queue->val, m, n, a, lda, stride_a, batch_size, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklZgetrfnp_batch_strided(syclQueue_t device_queue, int64_t m, int64_t n, double _Complex *a, int64_t lda, int64_t stride_a, int64_t batch_size, double _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::getrfnp_batch(device_queue->val, m, n, reinterpret_cast*>(a), lda, stride_a, batch_size, reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::getrfnp_batch(device_queue->val, m, n, reinterpret_cast*>(a), lda, stride_a, batch_size, reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklCgetri(syclQueue_t device_queue, int64_t n, float _Complex *a, int64_t lda, int64_t *ipiv, float _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::getri(device_queue->val, n, reinterpret_cast*>(a), lda, ipiv, reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::getri(device_queue->val, n, reinterpret_cast*>(a), lda, ipiv, reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklDgetri(syclQueue_t device_queue, int64_t n, double *a, int64_t lda, int64_t *ipiv, double *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::getri(device_queue->val, n, a, lda, ipiv, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::getri(device_queue->val, n, a, lda, ipiv, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklSgetri(syclQueue_t device_queue, int64_t n, float *a, int64_t lda, int64_t *ipiv, float *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::getri(device_queue->val, n, a, lda, ipiv, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::getri(device_queue->val, n, a, lda, ipiv, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklZgetri(syclQueue_t device_queue, int64_t n, double _Complex *a, int64_t lda, int64_t *ipiv, double _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::getri(device_queue->val, n, reinterpret_cast*>(a), lda, ipiv, reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::getri(device_queue->val, n, reinterpret_cast*>(a), lda, ipiv, reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklCgetrs(syclQueue_t device_queue, onemklTranspose trans, int64_t n, int64_t nrhs, float _Complex *a, int64_t lda, int64_t *ipiv, float _Complex *b, int64_t ldb, float _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::getrs(device_queue->val, convert(trans), n, nrhs, reinterpret_cast*>(a), lda, ipiv, reinterpret_cast*>(b), ldb, reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::getrs(device_queue->val, convert(trans), n, nrhs, reinterpret_cast*>(a), lda, ipiv, reinterpret_cast*>(b), ldb, reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklDgetrs(syclQueue_t device_queue, onemklTranspose trans, int64_t n, int64_t nrhs, double *a, int64_t lda, int64_t *ipiv, double *b, int64_t ldb, double *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::getrs(device_queue->val, convert(trans), n, nrhs, a, lda, ipiv, b, ldb, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::getrs(device_queue->val, convert(trans), n, nrhs, a, lda, ipiv, b, ldb, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklSgetrs(syclQueue_t device_queue, onemklTranspose trans, int64_t n, int64_t nrhs, float *a, int64_t lda, int64_t *ipiv, float *b, int64_t ldb, float *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::getrs(device_queue->val, convert(trans), n, nrhs, a, lda, ipiv, b, ldb, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::getrs(device_queue->val, convert(trans), n, nrhs, a, lda, ipiv, b, ldb, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklZgetrs(syclQueue_t device_queue, onemklTranspose trans, int64_t n, int64_t nrhs, double _Complex *a, int64_t lda, int64_t *ipiv, double _Complex *b, int64_t ldb, double _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::getrs(device_queue->val, convert(trans), n, nrhs, reinterpret_cast*>(a), lda, ipiv, reinterpret_cast*>(b), ldb, reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::getrs(device_queue->val, convert(trans), n, nrhs, reinterpret_cast*>(a), lda, ipiv, reinterpret_cast*>(b), ldb, reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklCgetrs_batch_strided(syclQueue_t device_queue, onemklTranspose trans, int64_t n, int64_t nrhs, float _Complex *a, int64_t lda, int64_t stride_a, int64_t *ipiv, int64_t stride_ipiv, float _Complex *b, int64_t ldb, int64_t stride_b, int64_t batch_size, float _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::getrs_batch(device_queue->val, convert(trans), n, nrhs, reinterpret_cast*>(a), lda, stride_a, ipiv, stride_ipiv, reinterpret_cast*>(b), ldb, stride_b, batch_size, reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::getrs_batch(device_queue->val, convert(trans), n, nrhs, reinterpret_cast*>(a), lda, stride_a, ipiv, stride_ipiv, reinterpret_cast*>(b), ldb, stride_b, batch_size, reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklDgetrs_batch_strided(syclQueue_t device_queue, onemklTranspose trans, int64_t n, int64_t nrhs, double *a, int64_t lda, int64_t stride_a, int64_t *ipiv, int64_t stride_ipiv, double *b, int64_t ldb, int64_t stride_b, int64_t batch_size, double *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::getrs_batch(device_queue->val, convert(trans), n, nrhs, a, lda, stride_a, ipiv, stride_ipiv, b, ldb, stride_b, batch_size, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::getrs_batch(device_queue->val, convert(trans), n, nrhs, a, lda, stride_a, ipiv, stride_ipiv, b, ldb, stride_b, batch_size, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklSgetrs_batch_strided(syclQueue_t device_queue, onemklTranspose trans, int64_t n, int64_t nrhs, float *a, int64_t lda, int64_t stride_a, int64_t *ipiv, int64_t stride_ipiv, float *b, int64_t ldb, int64_t stride_b, int64_t batch_size, float *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::getrs_batch(device_queue->val, convert(trans), n, nrhs, a, lda, stride_a, ipiv, stride_ipiv, b, ldb, stride_b, batch_size, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::getrs_batch(device_queue->val, convert(trans), n, nrhs, a, lda, stride_a, ipiv, stride_ipiv, b, ldb, stride_b, batch_size, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklZgetrs_batch_strided(syclQueue_t device_queue, onemklTranspose trans, int64_t n, int64_t nrhs, double _Complex *a, int64_t lda, int64_t stride_a, int64_t *ipiv, int64_t stride_ipiv, double _Complex *b, int64_t ldb, int64_t stride_b, int64_t batch_size, double _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::getrs_batch(device_queue->val, convert(trans), n, nrhs, reinterpret_cast*>(a), lda, stride_a, ipiv, stride_ipiv, reinterpret_cast*>(b), ldb, stride_b, batch_size, reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::getrs_batch(device_queue->val, convert(trans), n, nrhs, reinterpret_cast*>(a), lda, stride_a, ipiv, stride_ipiv, reinterpret_cast*>(b), ldb, stride_b, batch_size, reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklCgetrsnp_batch_strided(syclQueue_t device_queue, onemklTranspose trans, int64_t n, int64_t nrhs, float _Complex *a, int64_t lda, int64_t stride_a, float _Complex *b, int64_t ldb, int64_t stride_b, int64_t batch_size, float _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::getrsnp_batch(device_queue->val, convert(trans), n, nrhs, reinterpret_cast*>(a), lda, stride_a, reinterpret_cast*>(b), ldb, stride_b, batch_size, reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::getrsnp_batch(device_queue->val, convert(trans), n, nrhs, reinterpret_cast*>(a), lda, stride_a, reinterpret_cast*>(b), ldb, stride_b, batch_size, reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklDgetrsnp_batch_strided(syclQueue_t device_queue, onemklTranspose trans, int64_t n, int64_t nrhs, double *a, int64_t lda, int64_t stride_a, double *b, int64_t ldb, int64_t stride_b, int64_t batch_size, double *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::getrsnp_batch(device_queue->val, convert(trans), n, nrhs, a, lda, stride_a, b, ldb, stride_b, batch_size, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::getrsnp_batch(device_queue->val, convert(trans), n, nrhs, a, lda, stride_a, b, ldb, stride_b, batch_size, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklSgetrsnp_batch_strided(syclQueue_t device_queue, onemklTranspose trans, int64_t n, int64_t nrhs, float *a, int64_t lda, int64_t stride_a, float *b, int64_t ldb, int64_t stride_b, int64_t batch_size, float *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::getrsnp_batch(device_queue->val, convert(trans), n, nrhs, a, lda, stride_a, b, ldb, stride_b, batch_size, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::getrsnp_batch(device_queue->val, convert(trans), n, nrhs, a, lda, stride_a, b, ldb, stride_b, batch_size, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklZgetrsnp_batch_strided(syclQueue_t device_queue, onemklTranspose trans, int64_t n, int64_t nrhs, double _Complex *a, int64_t lda, int64_t stride_a, double _Complex *b, int64_t ldb, int64_t stride_b, int64_t batch_size, double _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::getrsnp_batch(device_queue->val, convert(trans), n, nrhs, reinterpret_cast*>(a), lda, stride_a, reinterpret_cast*>(b), ldb, stride_b, batch_size, reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::getrsnp_batch(device_queue->val, convert(trans), n, nrhs, reinterpret_cast*>(a), lda, stride_a, reinterpret_cast*>(b), ldb, stride_b, batch_size, reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklCheev(syclQueue_t device_queue, onemklCompz jobz, onemklUplo uplo, int64_t n, float _Complex *a, int64_t lda, float *w, float _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::heev(device_queue->val, convert(jobz), convert(uplo), n, reinterpret_cast*>(a), lda, w, reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::heev(device_queue->val, convert(jobz), convert(uplo), n, reinterpret_cast*>(a), lda, w, reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklZheev(syclQueue_t device_queue, onemklCompz jobz, onemklUplo uplo, int64_t n, double _Complex *a, int64_t lda, double *w, double _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::heev(device_queue->val, convert(jobz), convert(uplo), n, reinterpret_cast*>(a), lda, w, reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::heev(device_queue->val, convert(jobz), convert(uplo), n, reinterpret_cast*>(a), lda, w, reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklCheevd(syclQueue_t device_queue, onemklJob jobz, onemklUplo uplo, int64_t n, float _Complex *a, int64_t lda, float *w, float _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::heevd(device_queue->val, convert(jobz), convert(uplo), n, reinterpret_cast*>(a), lda, w, reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::heevd(device_queue->val, convert(jobz), convert(uplo), n, reinterpret_cast*>(a), lda, w, reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklZheevd(syclQueue_t device_queue, onemklJob jobz, onemklUplo uplo, int64_t n, double _Complex *a, int64_t lda, double *w, double _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::heevd(device_queue->val, convert(jobz), convert(uplo), n, reinterpret_cast*>(a), lda, w, reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::heevd(device_queue->val, convert(jobz), convert(uplo), n, reinterpret_cast*>(a), lda, w, reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklCheevx(syclQueue_t device_queue, onemklCompz jobz, onemklRangev range, onemklUplo uplo, int64_t n, float _Complex *a, int64_t lda, float *vl, float *vu, int64_t il, int64_t iu, float *abstol, int64_t *m, float *w, float _Complex *z, int64_t ldz, float _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::heevx(device_queue->val, convert(jobz), convert(range), convert(uplo), n, reinterpret_cast*>(a), lda, *vl, *vu, il, iu, *abstol, m, w, reinterpret_cast*>(z), ldz, reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::heevx(device_queue->val, convert(jobz), convert(range), convert(uplo), n, reinterpret_cast*>(a), lda, *vl, *vu, il, iu, *abstol, m, w, reinterpret_cast*>(z), ldz, reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklZheevx(syclQueue_t device_queue, onemklCompz jobz, onemklRangev range, onemklUplo uplo, int64_t n, double _Complex *a, int64_t lda, double *vl, double *vu, int64_t il, int64_t iu, double *abstol, int64_t *m, double *w, double _Complex *z, int64_t ldz, double _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::heevx(device_queue->val, convert(jobz), convert(range), convert(uplo), n, reinterpret_cast*>(a), lda, *vl, *vu, il, iu, *abstol, m, w, reinterpret_cast*>(z), ldz, reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::heevx(device_queue->val, convert(jobz), convert(range), convert(uplo), n, reinterpret_cast*>(a), lda, *vl, *vu, il, iu, *abstol, m, w, reinterpret_cast*>(z), ldz, reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklChegvd(syclQueue_t device_queue, int64_t itype, onemklJob jobz, onemklUplo uplo, int64_t n, float _Complex *a, int64_t lda, float _Complex *b, int64_t ldb, float *w, float _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::hegvd(device_queue->val, itype, convert(jobz), convert(uplo), n, reinterpret_cast*>(a), lda, reinterpret_cast*>(b), ldb, w, reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::hegvd(device_queue->val, itype, convert(jobz), convert(uplo), n, reinterpret_cast*>(a), lda, reinterpret_cast*>(b), ldb, w, reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklZhegvd(syclQueue_t device_queue, int64_t itype, onemklJob jobz, onemklUplo uplo, int64_t n, double _Complex *a, int64_t lda, double _Complex *b, int64_t ldb, double *w, double _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::hegvd(device_queue->val, itype, convert(jobz), convert(uplo), n, reinterpret_cast*>(a), lda, reinterpret_cast*>(b), ldb, w, reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::hegvd(device_queue->val, itype, convert(jobz), convert(uplo), n, reinterpret_cast*>(a), lda, reinterpret_cast*>(b), ldb, w, reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklChegvx(syclQueue_t device_queue, int64_t itype, onemklCompz jobz, onemklRangev range, onemklUplo uplo, int64_t n, float _Complex *a, int64_t lda, float _Complex *b, int64_t ldb, float *vl, float *vu, int64_t il, int64_t iu, float *abstol, int64_t *m, float *w, float _Complex *z, int64_t ldz, float _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::hegvx(device_queue->val, itype, convert(jobz), convert(range), convert(uplo), n, reinterpret_cast*>(a), lda, reinterpret_cast*>(b), ldb, *vl, *vu, il, iu, *abstol, m, w, reinterpret_cast*>(z), ldz, reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::hegvx(device_queue->val, itype, convert(jobz), convert(range), convert(uplo), n, reinterpret_cast*>(a), lda, reinterpret_cast*>(b), ldb, *vl, *vu, il, iu, *abstol, m, w, reinterpret_cast*>(z), ldz, reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklZhegvx(syclQueue_t device_queue, int64_t itype, onemklCompz jobz, onemklRangev range, onemklUplo uplo, int64_t n, double _Complex *a, int64_t lda, double _Complex *b, int64_t ldb, double *vl, double *vu, int64_t il, int64_t iu, double *abstol, int64_t *m, double *w, double _Complex *z, int64_t ldz, double _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::hegvx(device_queue->val, itype, convert(jobz), convert(range), convert(uplo), n, reinterpret_cast*>(a), lda, reinterpret_cast*>(b), ldb, *vl, *vu, il, iu, *abstol, m, w, reinterpret_cast*>(z), ldz, reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::hegvx(device_queue->val, itype, convert(jobz), convert(range), convert(uplo), n, reinterpret_cast*>(a), lda, reinterpret_cast*>(b), ldb, *vl, *vu, il, iu, *abstol, m, w, reinterpret_cast*>(z), ldz, reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklChetrd(syclQueue_t device_queue, onemklUplo uplo, int64_t n, float _Complex *a, int64_t lda, float *d, float *e, float _Complex *tau, float _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::hetrd(device_queue->val, convert(uplo), n, reinterpret_cast*>(a), lda, d, e, reinterpret_cast*>(tau), reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::hetrd(device_queue->val, convert(uplo), n, reinterpret_cast*>(a), lda, d, e, reinterpret_cast*>(tau), reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklZhetrd(syclQueue_t device_queue, onemklUplo uplo, int64_t n, double _Complex *a, int64_t lda, double *d, double *e, double _Complex *tau, double _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::hetrd(device_queue->val, convert(uplo), n, reinterpret_cast*>(a), lda, d, e, reinterpret_cast*>(tau), reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::hetrd(device_queue->val, convert(uplo), n, reinterpret_cast*>(a), lda, d, e, reinterpret_cast*>(tau), reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklChetrf(syclQueue_t device_queue, onemklUplo uplo, int64_t n, float _Complex *a, int64_t lda, int64_t *ipiv, float _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::hetrf(device_queue->val, convert(uplo), n, reinterpret_cast*>(a), lda, ipiv, reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::hetrf(device_queue->val, convert(uplo), n, reinterpret_cast*>(a), lda, ipiv, reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklZhetrf(syclQueue_t device_queue, onemklUplo uplo, int64_t n, double _Complex *a, int64_t lda, int64_t *ipiv, double _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::hetrf(device_queue->val, convert(uplo), n, reinterpret_cast*>(a), lda, ipiv, reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::hetrf(device_queue->val, convert(uplo), n, reinterpret_cast*>(a), lda, ipiv, reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklSorgbr(syclQueue_t device_queue, onemklGenerate vec, int64_t m, int64_t n, int64_t k, float *a, int64_t lda, float *tau, float *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::orgbr(device_queue->val, convert(vec), m, n, k, a, lda, tau, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::orgbr(device_queue->val, convert(vec), m, n, k, a, lda, tau, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklDorgbr(syclQueue_t device_queue, onemklGenerate vec, int64_t m, int64_t n, int64_t k, double *a, int64_t lda, double *tau, double *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::orgbr(device_queue->val, convert(vec), m, n, k, a, lda, tau, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::orgbr(device_queue->val, convert(vec), m, n, k, a, lda, tau, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklDorgqr(syclQueue_t device_queue, int64_t m, int64_t n, int64_t k, double *a, int64_t lda, double *tau, double *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::orgqr(device_queue->val, m, n, k, a, lda, tau, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::orgqr(device_queue->val, m, n, k, a, lda, tau, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklSorgqr(syclQueue_t device_queue, int64_t m, int64_t n, int64_t k, float *a, int64_t lda, float *tau, float *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::orgqr(device_queue->val, m, n, k, a, lda, tau, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::orgqr(device_queue->val, m, n, k, a, lda, tau, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklDormqr(syclQueue_t device_queue, onemklSide side, onemklTranspose trans, int64_t m, int64_t n, int64_t k, double *a, int64_t lda, double *tau, double *c, int64_t ldc, double *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::ormqr(device_queue->val, convert(side), convert(trans), m, n, k, a, lda, tau, c, ldc, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::ormqr(device_queue->val, convert(side), convert(trans), m, n, k, a, lda, tau, c, ldc, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklSormqr(syclQueue_t device_queue, onemklSide side, onemklTranspose trans, int64_t m, int64_t n, int64_t k, float *a, int64_t lda, float *tau, float *c, int64_t ldc, float *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::ormqr(device_queue->val, convert(side), convert(trans), m, n, k, a, lda, tau, c, ldc, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::ormqr(device_queue->val, convert(side), convert(trans), m, n, k, a, lda, tau, c, ldc, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklCsteqr(syclQueue_t device_queue, onemklCompz compz, int64_t n, float *d, float *e, float _Complex *z, int64_t ldz, float _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::steqr(device_queue->val, convert(compz), n, d, e, reinterpret_cast*>(z), ldz, reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::steqr(device_queue->val, convert(compz), n, d, e, reinterpret_cast*>(z), ldz, reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklDsteqr(syclQueue_t device_queue, onemklCompz compz, int64_t n, double *d, double *e, double *z, int64_t ldz, double *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::steqr(device_queue->val, convert(compz), n, d, e, z, ldz, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::steqr(device_queue->val, convert(compz), n, d, e, z, ldz, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklSsteqr(syclQueue_t device_queue, onemklCompz compz, int64_t n, float *d, float *e, float *z, int64_t ldz, float *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::steqr(device_queue->val, convert(compz), n, d, e, z, ldz, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::steqr(device_queue->val, convert(compz), n, d, e, z, ldz, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklZsteqr(syclQueue_t device_queue, onemklCompz compz, int64_t n, double *d, double *e, double _Complex *z, int64_t ldz, double _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::steqr(device_queue->val, convert(compz), n, d, e, reinterpret_cast*>(z), ldz, reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::steqr(device_queue->val, convert(compz), n, d, e, reinterpret_cast*>(z), ldz, reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklDsyev(syclQueue_t device_queue, onemklCompz jobz, onemklUplo uplo, int64_t n, double *a, int64_t lda, double *w, double *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::syev(device_queue->val, convert(jobz), convert(uplo), n, a, lda, w, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::syev(device_queue->val, convert(jobz), convert(uplo), n, a, lda, w, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklSsyev(syclQueue_t device_queue, onemklCompz jobz, onemklUplo uplo, int64_t n, float *a, int64_t lda, float *w, float *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::syev(device_queue->val, convert(jobz), convert(uplo), n, a, lda, w, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::syev(device_queue->val, convert(jobz), convert(uplo), n, a, lda, w, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklDsyevd(syclQueue_t device_queue, onemklJob jobz, onemklUplo uplo, int64_t n, double *a, int64_t lda, double *w, double *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::syevd(device_queue->val, convert(jobz), convert(uplo), n, a, lda, w, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::syevd(device_queue->val, convert(jobz), convert(uplo), n, a, lda, w, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklSsyevd(syclQueue_t device_queue, onemklJob jobz, onemklUplo uplo, int64_t n, float *a, int64_t lda, float *w, float *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::syevd(device_queue->val, convert(jobz), convert(uplo), n, a, lda, w, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::syevd(device_queue->val, convert(jobz), convert(uplo), n, a, lda, w, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklDsygvd(syclQueue_t device_queue, int64_t itype, onemklJob jobz, onemklUplo uplo, int64_t n, double *a, int64_t lda, double *b, int64_t ldb, double *w, double *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::sygvd(device_queue->val, itype, convert(jobz), convert(uplo), n, a, lda, b, ldb, w, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::sygvd(device_queue->val, itype, convert(jobz), convert(uplo), n, a, lda, b, ldb, w, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklSsygvd(syclQueue_t device_queue, int64_t itype, onemklJob jobz, onemklUplo uplo, int64_t n, float *a, int64_t lda, float *b, int64_t ldb, float *w, float *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::sygvd(device_queue->val, itype, convert(jobz), convert(uplo), n, a, lda, b, ldb, w, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::sygvd(device_queue->val, itype, convert(jobz), convert(uplo), n, a, lda, b, ldb, w, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklDsytrd(syclQueue_t device_queue, onemklUplo uplo, int64_t n, double *a, int64_t lda, double *d, double *e, double *tau, double *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::sytrd(device_queue->val, convert(uplo), n, a, lda, d, e, tau, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::sytrd(device_queue->val, convert(uplo), n, a, lda, d, e, tau, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklSsytrd(syclQueue_t device_queue, onemklUplo uplo, int64_t n, float *a, int64_t lda, float *d, float *e, float *tau, float *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::sytrd(device_queue->val, convert(uplo), n, a, lda, d, e, tau, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::sytrd(device_queue->val, convert(uplo), n, a, lda, d, e, tau, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklCtrtrs(syclQueue_t device_queue, onemklUplo uplo, onemklTranspose trans, onemklDiag diag, int64_t n, int64_t nrhs, float _Complex *a, int64_t lda, float _Complex *b, int64_t ldb, float _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::trtrs(device_queue->val, convert(uplo), convert(trans), convert(diag), n, nrhs, reinterpret_cast*>(a), lda, reinterpret_cast*>(b), ldb, reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::trtrs(device_queue->val, convert(uplo), convert(trans), convert(diag), n, nrhs, reinterpret_cast*>(a), lda, reinterpret_cast*>(b), ldb, reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklDtrtrs(syclQueue_t device_queue, onemklUplo uplo, onemklTranspose trans, onemklDiag diag, int64_t n, int64_t nrhs, double *a, int64_t lda, double *b, int64_t ldb, double *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::trtrs(device_queue->val, convert(uplo), convert(trans), convert(diag), n, nrhs, a, lda, b, ldb, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::trtrs(device_queue->val, convert(uplo), convert(trans), convert(diag), n, nrhs, a, lda, b, ldb, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklStrtrs(syclQueue_t device_queue, onemklUplo uplo, onemklTranspose trans, onemklDiag diag, int64_t n, int64_t nrhs, float *a, int64_t lda, float *b, int64_t ldb, float *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::trtrs(device_queue->val, convert(uplo), convert(trans), convert(diag), n, nrhs, a, lda, b, ldb, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::trtrs(device_queue->val, convert(uplo), convert(trans), convert(diag), n, nrhs, a, lda, b, ldb, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklZtrtrs(syclQueue_t device_queue, onemklUplo uplo, onemklTranspose trans, onemklDiag diag, int64_t n, int64_t nrhs, double _Complex *a, int64_t lda, double _Complex *b, int64_t ldb, double _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::trtrs(device_queue->val, convert(uplo), convert(trans), convert(diag), n, nrhs, reinterpret_cast*>(a), lda, reinterpret_cast*>(b), ldb, reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::trtrs(device_queue->val, convert(uplo), convert(trans), convert(diag), n, nrhs, reinterpret_cast*>(a), lda, reinterpret_cast*>(b), ldb, reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklCungbr(syclQueue_t device_queue, onemklGenerate vec, int64_t m, int64_t n, int64_t k, float _Complex *a, int64_t lda, float _Complex *tau, float _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::ungbr(device_queue->val, convert(vec), m, n, k, reinterpret_cast*>(a), lda, reinterpret_cast*>(tau), reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::ungbr(device_queue->val, convert(vec), m, n, k, reinterpret_cast*>(a), lda, reinterpret_cast*>(tau), reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklZungbr(syclQueue_t device_queue, onemklGenerate vec, int64_t m, int64_t n, int64_t k, double _Complex *a, int64_t lda, double _Complex *tau, double _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::ungbr(device_queue->val, convert(vec), m, n, k, reinterpret_cast*>(a), lda, reinterpret_cast*>(tau), reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::ungbr(device_queue->val, convert(vec), m, n, k, reinterpret_cast*>(a), lda, reinterpret_cast*>(tau), reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklCungqr(syclQueue_t device_queue, int64_t m, int64_t n, int64_t k, float _Complex *a, int64_t lda, float _Complex *tau, float _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::ungqr(device_queue->val, m, n, k, reinterpret_cast*>(a), lda, reinterpret_cast*>(tau), reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::ungqr(device_queue->val, m, n, k, reinterpret_cast*>(a), lda, reinterpret_cast*>(tau), reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklZungqr(syclQueue_t device_queue, int64_t m, int64_t n, int64_t k, double _Complex *a, int64_t lda, double _Complex *tau, double _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::ungqr(device_queue->val, m, n, k, reinterpret_cast*>(a), lda, reinterpret_cast*>(tau), reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::ungqr(device_queue->val, m, n, k, reinterpret_cast*>(a), lda, reinterpret_cast*>(tau), reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklCunmqr(syclQueue_t device_queue, onemklSide side, onemklTranspose trans, int64_t m, int64_t n, int64_t k, float _Complex *a, int64_t lda, float _Complex *tau, float _Complex *c, int64_t ldc, float _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::unmqr(device_queue->val, convert(side), convert(trans), m, n, k, reinterpret_cast*>(a), lda, reinterpret_cast*>(tau), reinterpret_cast*>(c), ldc, reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::unmqr(device_queue->val, convert(side), convert(trans), m, n, k, reinterpret_cast*>(a), lda, reinterpret_cast*>(tau), reinterpret_cast*>(c), ldc, reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklZunmqr(syclQueue_t device_queue, onemklSide side, onemklTranspose trans, int64_t m, int64_t n, int64_t k, double _Complex *a, int64_t lda, double _Complex *tau, double _Complex *c, int64_t ldc, double _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::unmqr(device_queue->val, convert(side), convert(trans), m, n, k, reinterpret_cast*>(a), lda, reinterpret_cast*>(tau), reinterpret_cast*>(c), ldc, reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::unmqr(device_queue->val, convert(side), convert(trans), m, n, k, reinterpret_cast*>(a), lda, reinterpret_cast*>(tau), reinterpret_cast*>(c), ldc, reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklSgerqf(syclQueue_t device_queue, int64_t m, int64_t n, float *a, int64_t lda, float *tau, float *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::gerqf(device_queue->val, m, n, a, lda, tau, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::gerqf(device_queue->val, m, n, a, lda, tau, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklDgerqf(syclQueue_t device_queue, int64_t m, int64_t n, double *a, int64_t lda, double *tau, double *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::gerqf(device_queue->val, m, n, a, lda, tau, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::gerqf(device_queue->val, m, n, a, lda, tau, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklCgerqf(syclQueue_t device_queue, int64_t m, int64_t n, float _Complex *a, int64_t lda, float _Complex *tau, float _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::gerqf(device_queue->val, m, n, reinterpret_cast*>(a), lda, reinterpret_cast*>(tau), reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::gerqf(device_queue->val, m, n, reinterpret_cast*>(a), lda, reinterpret_cast*>(tau), reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklZgerqf(syclQueue_t device_queue, int64_t m, int64_t n, double _Complex *a, int64_t lda, double _Complex *tau, double _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::gerqf(device_queue->val, m, n, reinterpret_cast*>(a), lda, reinterpret_cast*>(tau), reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::gerqf(device_queue->val, m, n, reinterpret_cast*>(a), lda, reinterpret_cast*>(tau), reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklSormrq(syclQueue_t device_queue, onemklSide side, onemklTranspose trans, int64_t m, int64_t n, int64_t k, float *a, int64_t lda, float *tau, float *c, int64_t ldc, float *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::ormrq(device_queue->val, convert(side), convert(trans), m, n, k, a, lda, tau, c, ldc, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::ormrq(device_queue->val, convert(side), convert(trans), m, n, k, a, lda, tau, c, ldc, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklDormrq(syclQueue_t device_queue, onemklSide side, onemklTranspose trans, int64_t m, int64_t n, int64_t k, double *a, int64_t lda, double *tau, double *c, int64_t ldc, double *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::ormrq(device_queue->val, convert(side), convert(trans), m, n, k, a, lda, tau, c, ldc, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::ormrq(device_queue->val, convert(side), convert(trans), m, n, k, a, lda, tau, c, ldc, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklCunmrq(syclQueue_t device_queue, onemklSide side, onemklTranspose trans, int64_t m, int64_t n, int64_t k, float _Complex *a, int64_t lda, float _Complex *tau, float _Complex *c, int64_t ldc, float _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::unmrq(device_queue->val, convert(side), convert(trans), m, n, k, reinterpret_cast*>(a), lda, reinterpret_cast*>(tau), reinterpret_cast*>(c), ldc, reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::unmrq(device_queue->val, convert(side), convert(trans), m, n, k, reinterpret_cast*>(a), lda, reinterpret_cast*>(tau), reinterpret_cast*>(c), ldc, reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklZunmrq(syclQueue_t device_queue, onemklSide side, onemklTranspose trans, int64_t m, int64_t n, int64_t k, double _Complex *a, int64_t lda, double _Complex *tau, double _Complex *c, int64_t ldc, double _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::unmrq(device_queue->val, convert(side), convert(trans), m, n, k, reinterpret_cast*>(a), lda, reinterpret_cast*>(tau), reinterpret_cast*>(c), ldc, reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::unmrq(device_queue->val, convert(side), convert(trans), m, n, k, reinterpret_cast*>(a), lda, reinterpret_cast*>(tau), reinterpret_cast*>(c), ldc, reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklSsytrf(syclQueue_t device_queue, onemklUplo uplo, int64_t n, float *a, int64_t lda, int64_t *ipiv, float *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::sytrf(device_queue->val, convert(uplo), n, a, lda, ipiv, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::sytrf(device_queue->val, convert(uplo), n, a, lda, ipiv, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklDsytrf(syclQueue_t device_queue, onemklUplo uplo, int64_t n, double *a, int64_t lda, int64_t *ipiv, double *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::sytrf(device_queue->val, convert(uplo), n, a, lda, ipiv, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::sytrf(device_queue->val, convert(uplo), n, a, lda, ipiv, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklCsytrf(syclQueue_t device_queue, onemklUplo uplo, int64_t n, float _Complex *a, int64_t lda, int64_t *ipiv, float _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::sytrf(device_queue->val, convert(uplo), n, reinterpret_cast*>(a), lda, ipiv, reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::sytrf(device_queue->val, convert(uplo), n, reinterpret_cast*>(a), lda, ipiv, reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklZsytrf(syclQueue_t device_queue, onemklUplo uplo, int64_t n, double _Complex *a, int64_t lda, int64_t *ipiv, double _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::sytrf(device_queue->val, convert(uplo), n, reinterpret_cast*>(a), lda, ipiv, reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::sytrf(device_queue->val, convert(uplo), n, reinterpret_cast*>(a), lda, ipiv, reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklSorgtr(syclQueue_t device_queue, onemklUplo uplo, int64_t n, float *a, int64_t lda, float *tau, float *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::orgtr(device_queue->val, convert(uplo), n, a, lda, tau, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::orgtr(device_queue->val, convert(uplo), n, a, lda, tau, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklDorgtr(syclQueue_t device_queue, onemklUplo uplo, int64_t n, double *a, int64_t lda, double *tau, double *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::orgtr(device_queue->val, convert(uplo), n, a, lda, tau, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::orgtr(device_queue->val, convert(uplo), n, a, lda, tau, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklCungtr(syclQueue_t device_queue, onemklUplo uplo, int64_t n, float _Complex *a, int64_t lda, float _Complex *tau, float _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::ungtr(device_queue->val, convert(uplo), n, reinterpret_cast*>(a), lda, reinterpret_cast*>(tau), reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::ungtr(device_queue->val, convert(uplo), n, reinterpret_cast*>(a), lda, reinterpret_cast*>(tau), reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklZungtr(syclQueue_t device_queue, onemklUplo uplo, int64_t n, double _Complex *a, int64_t lda, double _Complex *tau, double _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::ungtr(device_queue->val, convert(uplo), n, reinterpret_cast*>(a), lda, reinterpret_cast*>(tau), reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::ungtr(device_queue->val, convert(uplo), n, reinterpret_cast*>(a), lda, reinterpret_cast*>(tau), reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklSormtr(syclQueue_t device_queue, onemklSide side, onemklUplo uplo, onemklTranspose trans, int64_t m, int64_t n, float *a, int64_t lda, float *tau, float *c, int64_t ldc, float *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::ormtr(device_queue->val, convert(side), convert(uplo), convert(trans), m, n, a, lda, tau, c, ldc, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::ormtr(device_queue->val, convert(side), convert(uplo), convert(trans), m, n, a, lda, tau, c, ldc, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklDormtr(syclQueue_t device_queue, onemklSide side, onemklUplo uplo, onemklTranspose trans, int64_t m, int64_t n, double *a, int64_t lda, double *tau, double *c, int64_t ldc, double *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::ormtr(device_queue->val, convert(side), convert(uplo), convert(trans), m, n, a, lda, tau, c, ldc, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::ormtr(device_queue->val, convert(side), convert(uplo), convert(trans), m, n, a, lda, tau, c, ldc, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklCunmtr(syclQueue_t device_queue, onemklSide side, onemklUplo uplo, onemklTranspose trans, int64_t m, int64_t n, float _Complex *a, int64_t lda, float _Complex *tau, float _Complex *c, int64_t ldc, float _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::unmtr(device_queue->val, convert(side), convert(uplo), convert(trans), m, n, reinterpret_cast*>(a), lda, reinterpret_cast*>(tau), reinterpret_cast*>(c), ldc, reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::unmtr(device_queue->val, convert(side), convert(uplo), convert(trans), m, n, reinterpret_cast*>(a), lda, reinterpret_cast*>(tau), reinterpret_cast*>(c), ldc, reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklZunmtr(syclQueue_t device_queue, onemklSide side, onemklUplo uplo, onemklTranspose trans, int64_t m, int64_t n, double _Complex *a, int64_t lda, double _Complex *tau, double _Complex *c, int64_t ldc, double _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::unmtr(device_queue->val, convert(side), convert(uplo), convert(trans), m, n, reinterpret_cast*>(a), lda, reinterpret_cast*>(tau), reinterpret_cast*>(c), ldc, reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::unmtr(device_queue->val, convert(side), convert(uplo), convert(trans), m, n, reinterpret_cast*>(a), lda, reinterpret_cast*>(tau), reinterpret_cast*>(c), ldc, reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklSgels(syclQueue_t device_queue, onemklTranspose trans, int64_t m, int64_t n, int64_t nrhs, float *a, int64_t lda, float *b, int64_t ldb, float *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::gels(device_queue->val, convert(trans), m, n, nrhs, a, lda, b, ldb, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::gels(device_queue->val, convert(trans), m, n, nrhs, a, lda, b, ldb, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklDgels(syclQueue_t device_queue, onemklTranspose trans, int64_t m, int64_t n, int64_t nrhs, double *a, int64_t lda, double *b, int64_t ldb, double *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::gels(device_queue->val, convert(trans), m, n, nrhs, a, lda, b, ldb, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::gels(device_queue->val, convert(trans), m, n, nrhs, a, lda, b, ldb, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklCgels(syclQueue_t device_queue, onemklTranspose trans, int64_t m, int64_t n, int64_t nrhs, float _Complex *a, int64_t lda, float _Complex *b, int64_t ldb, float _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::gels(device_queue->val, convert(trans), m, n, nrhs, reinterpret_cast*>(a), lda, reinterpret_cast*>(b), ldb, reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::gels(device_queue->val, convert(trans), m, n, nrhs, reinterpret_cast*>(a), lda, reinterpret_cast*>(b), ldb, reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklZgels(syclQueue_t device_queue, onemklTranspose trans, int64_t m, int64_t n, int64_t nrhs, double _Complex *a, int64_t lda, double _Complex *b, int64_t ldb, double _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::gels(device_queue->val, convert(trans), m, n, nrhs, reinterpret_cast*>(a), lda, reinterpret_cast*>(b), ldb, reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::gels(device_queue->val, convert(trans), m, n, nrhs, reinterpret_cast*>(a), lda, reinterpret_cast*>(b), ldb, reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklSpotrf_batch(syclQueue_t device_queue, onemklUplo *uplo, int64_t *n, float **a, int64_t *lda, int64_t group_count, int64_t *group_sizes, float *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::potrf_batch(device_queue->val, convert(uplo, group_count), n, a, lda, group_count, group_sizes, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::potrf_batch(device_queue->val, convert(uplo, group_count), n, a, lda, group_count, group_sizes, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklDpotrf_batch(syclQueue_t device_queue, onemklUplo *uplo, int64_t *n, double **a, int64_t *lda, int64_t group_count, int64_t *group_sizes, double *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::potrf_batch(device_queue->val, convert(uplo, group_count), n, a, lda, group_count, group_sizes, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::potrf_batch(device_queue->val, convert(uplo, group_count), n, a, lda, group_count, group_sizes, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklCpotrf_batch(syclQueue_t device_queue, onemklUplo *uplo, int64_t *n, float _Complex **a, int64_t *lda, int64_t group_count, int64_t *group_sizes, float _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::potrf_batch(device_queue->val, convert(uplo, group_count), n, reinterpret_cast**>(a), lda, group_count, group_sizes, reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::potrf_batch(device_queue->val, convert(uplo, group_count), n, reinterpret_cast**>(a), lda, group_count, group_sizes, reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklZpotrf_batch(syclQueue_t device_queue, onemklUplo *uplo, int64_t *n, double _Complex **a, int64_t *lda, int64_t group_count, int64_t *group_sizes, double _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::potrf_batch(device_queue->val, convert(uplo, group_count), n, reinterpret_cast**>(a), lda, group_count, group_sizes, reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::potrf_batch(device_queue->val, convert(uplo, group_count), n, reinterpret_cast**>(a), lda, group_count, group_sizes, reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklSpotrs_batch(syclQueue_t device_queue, onemklUplo *uplo, int64_t *n, int64_t *nrhs, float **a, int64_t *lda, float **b, int64_t *ldb, int64_t group_count, int64_t *group_sizes, float *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::potrs_batch(device_queue->val, convert(uplo, group_count), n, nrhs, a, lda, b, ldb, group_count, group_sizes, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::potrs_batch(device_queue->val, convert(uplo, group_count), n, nrhs, a, lda, b, ldb, group_count, group_sizes, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklDpotrs_batch(syclQueue_t device_queue, onemklUplo *uplo, int64_t *n, int64_t *nrhs, double **a, int64_t *lda, double **b, int64_t *ldb, int64_t group_count, int64_t *group_sizes, double *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::potrs_batch(device_queue->val, convert(uplo, group_count), n, nrhs, a, lda, b, ldb, group_count, group_sizes, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::potrs_batch(device_queue->val, convert(uplo, group_count), n, nrhs, a, lda, b, ldb, group_count, group_sizes, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklCpotrs_batch(syclQueue_t device_queue, onemklUplo *uplo, int64_t *n, int64_t *nrhs, float _Complex **a, int64_t *lda, float _Complex **b, int64_t *ldb, int64_t group_count, int64_t *group_sizes, float _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::potrs_batch(device_queue->val, convert(uplo, group_count), n, nrhs, reinterpret_cast**>(a), lda, reinterpret_cast**>(b), ldb, group_count, group_sizes, reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::potrs_batch(device_queue->val, convert(uplo, group_count), n, nrhs, reinterpret_cast**>(a), lda, reinterpret_cast**>(b), ldb, group_count, group_sizes, reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklZpotrs_batch(syclQueue_t device_queue, onemklUplo *uplo, int64_t *n, int64_t *nrhs, double _Complex **a, int64_t *lda, double _Complex **b, int64_t *ldb, int64_t group_count, int64_t *group_sizes, double _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::potrs_batch(device_queue->val, convert(uplo, group_count), n, nrhs, reinterpret_cast**>(a), lda, reinterpret_cast**>(b), ldb, group_count, group_sizes, reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::potrs_batch(device_queue->val, convert(uplo, group_count), n, nrhs, reinterpret_cast**>(a), lda, reinterpret_cast**>(b), ldb, group_count, group_sizes, reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklSgeinv_batch(syclQueue_t device_queue, int64_t *n, float **a, int64_t *lda, int64_t group_count, int64_t *group_sizes, float *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::geinv_batch(device_queue->val, n, a, lda, group_count, group_sizes, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::geinv_batch(device_queue->val, n, a, lda, group_count, group_sizes, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklDgeinv_batch(syclQueue_t device_queue, int64_t *n, double **a, int64_t *lda, int64_t group_count, int64_t *group_sizes, double *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::geinv_batch(device_queue->val, n, a, lda, group_count, group_sizes, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::geinv_batch(device_queue->val, n, a, lda, group_count, group_sizes, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklCgeinv_batch(syclQueue_t device_queue, int64_t *n, float _Complex **a, int64_t *lda, int64_t group_count, int64_t *group_sizes, float _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::geinv_batch(device_queue->val, n, reinterpret_cast**>(a), lda, group_count, group_sizes, reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::geinv_batch(device_queue->val, n, reinterpret_cast**>(a), lda, group_count, group_sizes, reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklZgeinv_batch(syclQueue_t device_queue, int64_t *n, double _Complex **a, int64_t *lda, int64_t group_count, int64_t *group_sizes, double _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::geinv_batch(device_queue->val, n, reinterpret_cast**>(a), lda, group_count, group_sizes, reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::geinv_batch(device_queue->val, n, reinterpret_cast**>(a), lda, group_count, group_sizes, reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklSgetrs_batch(syclQueue_t device_queue, onemklTranspose *trans, int64_t *n, int64_t *nrhs, float **a, int64_t *lda, int64_t **ipiv, float **b, int64_t *ldb, int64_t group_count, int64_t *group_sizes, float *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::getrs_batch(device_queue->val, convert(trans, group_count), n, nrhs, a, lda, ipiv, b, ldb, group_count, group_sizes, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::getrs_batch(device_queue->val, convert(trans, group_count), n, nrhs, a, lda, ipiv, b, ldb, group_count, group_sizes, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklDgetrs_batch(syclQueue_t device_queue, onemklTranspose *trans, int64_t *n, int64_t *nrhs, double **a, int64_t *lda, int64_t **ipiv, double **b, int64_t *ldb, int64_t group_count, int64_t *group_sizes, double *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::getrs_batch(device_queue->val, convert(trans, group_count), n, nrhs, a, lda, ipiv, b, ldb, group_count, group_sizes, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::getrs_batch(device_queue->val, convert(trans, group_count), n, nrhs, a, lda, ipiv, b, ldb, group_count, group_sizes, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklCgetrs_batch(syclQueue_t device_queue, onemklTranspose *trans, int64_t *n, int64_t *nrhs, float _Complex **a, int64_t *lda, int64_t **ipiv, float _Complex **b, int64_t *ldb, int64_t group_count, int64_t *group_sizes, float _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::getrs_batch(device_queue->val, convert(trans, group_count), n, nrhs, reinterpret_cast**>(a), lda, ipiv, reinterpret_cast**>(b), ldb, group_count, group_sizes, reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::getrs_batch(device_queue->val, convert(trans, group_count), n, nrhs, reinterpret_cast**>(a), lda, ipiv, reinterpret_cast**>(b), ldb, group_count, group_sizes, reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklZgetrs_batch(syclQueue_t device_queue, onemklTranspose *trans, int64_t *n, int64_t *nrhs, double _Complex **a, int64_t *lda, int64_t **ipiv, double _Complex **b, int64_t *ldb, int64_t group_count, int64_t *group_sizes, double _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::getrs_batch(device_queue->val, convert(trans, group_count), n, nrhs, reinterpret_cast**>(a), lda, ipiv, reinterpret_cast**>(b), ldb, group_count, group_sizes, reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::getrs_batch(device_queue->val, convert(trans, group_count), n, nrhs, reinterpret_cast**>(a), lda, ipiv, reinterpret_cast**>(b), ldb, group_count, group_sizes, reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklSgetri_batch(syclQueue_t device_queue, int64_t *n, float **a, int64_t *lda, int64_t **ipiv, int64_t group_count, int64_t *group_sizes, float *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::getri_batch(device_queue->val, n, a, lda, ipiv, group_count, group_sizes, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::getri_batch(device_queue->val, n, a, lda, ipiv, group_count, group_sizes, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklDgetri_batch(syclQueue_t device_queue, int64_t *n, double **a, int64_t *lda, int64_t **ipiv, int64_t group_count, int64_t *group_sizes, double *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::getri_batch(device_queue->val, n, a, lda, ipiv, group_count, group_sizes, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::getri_batch(device_queue->val, n, a, lda, ipiv, group_count, group_sizes, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklCgetri_batch(syclQueue_t device_queue, int64_t *n, float _Complex **a, int64_t *lda, int64_t **ipiv, int64_t group_count, int64_t *group_sizes, float _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::getri_batch(device_queue->val, n, reinterpret_cast**>(a), lda, ipiv, group_count, group_sizes, reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::getri_batch(device_queue->val, n, reinterpret_cast**>(a), lda, ipiv, group_count, group_sizes, reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklZgetri_batch(syclQueue_t device_queue, int64_t *n, double _Complex **a, int64_t *lda, int64_t **ipiv, int64_t group_count, int64_t *group_sizes, double _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::getri_batch(device_queue->val, n, reinterpret_cast**>(a), lda, ipiv, group_count, group_sizes, reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::getri_batch(device_queue->val, n, reinterpret_cast**>(a), lda, ipiv, group_count, group_sizes, reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklSgeqrf_batch(syclQueue_t device_queue, int64_t *m, int64_t *n, float **a, int64_t *lda, float **tau, int64_t group_count, int64_t *group_sizes, float *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::geqrf_batch(device_queue->val, m, n, a, lda, tau, group_count, group_sizes, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::geqrf_batch(device_queue->val, m, n, a, lda, tau, group_count, group_sizes, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklDgeqrf_batch(syclQueue_t device_queue, int64_t *m, int64_t *n, double **a, int64_t *lda, double **tau, int64_t group_count, int64_t *group_sizes, double *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::geqrf_batch(device_queue->val, m, n, a, lda, tau, group_count, group_sizes, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::geqrf_batch(device_queue->val, m, n, a, lda, tau, group_count, group_sizes, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklCgeqrf_batch(syclQueue_t device_queue, int64_t *m, int64_t *n, float _Complex **a, int64_t *lda, float _Complex **tau, int64_t group_count, int64_t *group_sizes, float _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::geqrf_batch(device_queue->val, m, n, reinterpret_cast**>(a), lda, reinterpret_cast**>(tau), group_count, group_sizes, reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::geqrf_batch(device_queue->val, m, n, reinterpret_cast**>(a), lda, reinterpret_cast**>(tau), group_count, group_sizes, reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklZgeqrf_batch(syclQueue_t device_queue, int64_t *m, int64_t *n, double _Complex **a, int64_t *lda, double _Complex **tau, int64_t group_count, int64_t *group_sizes, double _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::geqrf_batch(device_queue->val, m, n, reinterpret_cast**>(a), lda, reinterpret_cast**>(tau), group_count, group_sizes, reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::geqrf_batch(device_queue->val, m, n, reinterpret_cast**>(a), lda, reinterpret_cast**>(tau), group_count, group_sizes, reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklSorgqr_batch(syclQueue_t device_queue, int64_t *m, int64_t *n, int64_t *k, float **a, int64_t *lda, float **tau, int64_t group_count, int64_t *group_sizes, float *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::orgqr_batch(device_queue->val, m, n, k, a, lda, tau, group_count, group_sizes, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::orgqr_batch(device_queue->val, m, n, k, a, lda, tau, group_count, group_sizes, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklDorgqr_batch(syclQueue_t device_queue, int64_t *m, int64_t *n, int64_t *k, double **a, int64_t *lda, double **tau, int64_t group_count, int64_t *group_sizes, double *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::orgqr_batch(device_queue->val, m, n, k, a, lda, tau, group_count, group_sizes, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::orgqr_batch(device_queue->val, m, n, k, a, lda, tau, group_count, group_sizes, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklCungqr_batch(syclQueue_t device_queue, int64_t *m, int64_t *n, int64_t *k, float _Complex **a, int64_t *lda, float _Complex **tau, int64_t group_count, int64_t *group_sizes, float _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::ungqr_batch(device_queue->val, m, n, k, reinterpret_cast**>(a), lda, reinterpret_cast**>(tau), group_count, group_sizes, reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::ungqr_batch(device_queue->val, m, n, k, reinterpret_cast**>(a), lda, reinterpret_cast**>(tau), group_count, group_sizes, reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklZungqr_batch(syclQueue_t device_queue, int64_t *m, int64_t *n, int64_t *k, double _Complex **a, int64_t *lda, double _Complex **tau, int64_t group_count, int64_t *group_sizes, double _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::ungqr_batch(device_queue->val, m, n, k, reinterpret_cast**>(a), lda, reinterpret_cast**>(tau), group_count, group_sizes, reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::ungqr_batch(device_queue->val, m, n, k, reinterpret_cast**>(a), lda, reinterpret_cast**>(tau), group_count, group_sizes, reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklSormqr_batch(syclQueue_t device_queue, onemklSide *side, onemklTranspose *trans, int64_t *m, int64_t *n, int64_t *k, float **a, int64_t *lda, float **tau, float **c, int64_t *ldc, int64_t group_count, int64_t *group_sizes, float *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::ormqr_batch(device_queue->val, convert(side, group_count), convert(trans, group_count), m, n, k, a, lda, tau, c, ldc, group_count, group_sizes, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::ormqr_batch(device_queue->val, convert(side, group_count), convert(trans, group_count), m, n, k, a, lda, tau, c, ldc, group_count, group_sizes, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklDormqr_batch(syclQueue_t device_queue, onemklSide *side, onemklTranspose *trans, int64_t *m, int64_t *n, int64_t *k, double **a, int64_t *lda, double **tau, double **c, int64_t *ldc, int64_t group_count, int64_t *group_sizes, double *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::ormqr_batch(device_queue->val, convert(side, group_count), convert(trans, group_count), m, n, k, a, lda, tau, c, ldc, group_count, group_sizes, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::ormqr_batch(device_queue->val, convert(side, group_count), convert(trans, group_count), m, n, k, a, lda, tau, c, ldc, group_count, group_sizes, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklCunmqr_batch(syclQueue_t device_queue, onemklSide *side, onemklTranspose *trans, int64_t *m, int64_t *n, int64_t *k, float _Complex **a, int64_t *lda, float _Complex **tau, float _Complex **c, int64_t *ldc, int64_t group_count, int64_t *group_sizes, float _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::unmqr_batch(device_queue->val, convert(side, group_count), convert(trans, group_count), m, n, k, reinterpret_cast**>(a), lda, reinterpret_cast**>(tau), reinterpret_cast**>(c), ldc, group_count, group_sizes, reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::unmqr_batch(device_queue->val, convert(side, group_count), convert(trans, group_count), m, n, k, reinterpret_cast**>(a), lda, reinterpret_cast**>(tau), reinterpret_cast**>(c), ldc, group_count, group_sizes, reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklZunmqr_batch(syclQueue_t device_queue, onemklSide *side, onemklTranspose *trans, int64_t *m, int64_t *n, int64_t *k, double _Complex **a, int64_t *lda, double _Complex **tau, double _Complex **c, int64_t *ldc, int64_t group_count, int64_t *group_sizes, double _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::unmqr_batch(device_queue->val, convert(side, group_count), convert(trans, group_count), m, n, k, reinterpret_cast**>(a), lda, reinterpret_cast**>(tau), reinterpret_cast**>(c), ldc, group_count, group_sizes, reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::unmqr_batch(device_queue->val, convert(side, group_count), convert(trans, group_count), m, n, k, reinterpret_cast**>(a), lda, reinterpret_cast**>(tau), reinterpret_cast**>(c), ldc, group_count, group_sizes, reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklStrtrs_batch(syclQueue_t device_queue, onemklUplo *uplo, onemklTranspose *trans, onemklDiag *diag, int64_t *n, int64_t *nrhs, float **a, int64_t *lda, float **b, int64_t *ldb, int64_t group_count, int64_t *group_sizes, float *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::trtrs_batch(device_queue->val, convert(uplo, group_count), convert(trans, group_count), convert(diag, group_count), n, nrhs, a, lda, b, ldb, group_count, group_sizes, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::trtrs_batch(device_queue->val, convert(uplo, group_count), convert(trans, group_count), convert(diag, group_count), n, nrhs, a, lda, b, ldb, group_count, group_sizes, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklDtrtrs_batch(syclQueue_t device_queue, onemklUplo *uplo, onemklTranspose *trans, onemklDiag *diag, int64_t *n, int64_t *nrhs, double **a, int64_t *lda, double **b, int64_t *ldb, int64_t group_count, int64_t *group_sizes, double *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::trtrs_batch(device_queue->val, convert(uplo, group_count), convert(trans, group_count), convert(diag, group_count), n, nrhs, a, lda, b, ldb, group_count, group_sizes, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::trtrs_batch(device_queue->val, convert(uplo, group_count), convert(trans, group_count), convert(diag, group_count), n, nrhs, a, lda, b, ldb, group_count, group_sizes, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklCtrtrs_batch(syclQueue_t device_queue, onemklUplo *uplo, onemklTranspose *trans, onemklDiag *diag, int64_t *n, int64_t *nrhs, float _Complex **a, int64_t *lda, float _Complex **b, int64_t *ldb, int64_t group_count, int64_t *group_sizes, float _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::trtrs_batch(device_queue->val, convert(uplo, group_count), convert(trans, group_count), convert(diag, group_count), n, nrhs, reinterpret_cast**>(a), lda, reinterpret_cast**>(b), ldb, group_count, group_sizes, reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::trtrs_batch(device_queue->val, convert(uplo, group_count), convert(trans, group_count), convert(diag, group_count), n, nrhs, reinterpret_cast**>(a), lda, reinterpret_cast**>(b), ldb, group_count, group_sizes, reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklZtrtrs_batch(syclQueue_t device_queue, onemklUplo *uplo, onemklTranspose *trans, onemklDiag *diag, int64_t *n, int64_t *nrhs, double _Complex **a, int64_t *lda, double _Complex **b, int64_t *ldb, int64_t group_count, int64_t *group_sizes, double _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::trtrs_batch(device_queue->val, convert(uplo, group_count), convert(trans, group_count), convert(diag, group_count), n, nrhs, reinterpret_cast**>(a), lda, reinterpret_cast**>(b), ldb, group_count, group_sizes, reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::trtrs_batch(device_queue->val, convert(uplo, group_count), convert(trans, group_count), convert(diag, group_count), n, nrhs, reinterpret_cast**>(a), lda, reinterpret_cast**>(b), ldb, group_count, group_sizes, reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklSgels_batch(syclQueue_t device_queue, onemklTranspose *trans, int64_t *m, int64_t *n, int64_t *nrhs, float **a, int64_t *lda, float **b, int64_t *ldb, int64_t group_count, int64_t *group_sizes, float *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::gels_batch(device_queue->val, convert(trans, group_count), m, n, nrhs, a, lda, b, ldb, group_count, group_sizes, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::gels_batch(device_queue->val, convert(trans, group_count), m, n, nrhs, a, lda, b, ldb, group_count, group_sizes, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklDgels_batch(syclQueue_t device_queue, onemklTranspose *trans, int64_t *m, int64_t *n, int64_t *nrhs, double **a, int64_t *lda, double **b, int64_t *ldb, int64_t group_count, int64_t *group_sizes, double *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::gels_batch(device_queue->val, convert(trans, group_count), m, n, nrhs, a, lda, b, ldb, group_count, group_sizes, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::gels_batch(device_queue->val, convert(trans, group_count), m, n, nrhs, a, lda, b, ldb, group_count, group_sizes, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklCgels_batch(syclQueue_t device_queue, onemklTranspose *trans, int64_t *m, int64_t *n, int64_t *nrhs, float _Complex **a, int64_t *lda,float _Complex **b, int64_t *ldb, int64_t group_count, int64_t *group_sizes, float _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::gels_batch(device_queue->val, convert(trans, group_count), m, n, nrhs, reinterpret_cast**>(a), lda,reinterpret_cast**>(b), ldb, group_count, group_sizes, reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::gels_batch(device_queue->val, convert(trans, group_count), m, n, nrhs, reinterpret_cast**>(a), lda,reinterpret_cast**>(b), ldb, group_count, group_sizes, reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklZgels_batch(syclQueue_t device_queue, onemklTranspose *trans, int64_t *m, int64_t *n, int64_t *nrhs, double _Complex **a, int64_t *lda, double _Complex **b, int64_t *ldb, int64_t group_count, int64_t *group_sizes, double _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::gels_batch(device_queue->val, convert(trans, group_count), m, n, nrhs, reinterpret_cast**>(a), lda, reinterpret_cast**>(b), ldb, group_count, group_sizes, reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::gels_batch(device_queue->val, convert(trans, group_count), m, n, nrhs, reinterpret_cast**>(a), lda, reinterpret_cast**>(b), ldb, group_count, group_sizes, reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklSpotrf_batch_strided(syclQueue_t device_queue, onemklUplo uplo, int64_t n, float *a, int64_t lda, int64_t stride_a, int64_t batch_size, float *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::potrf_batch(device_queue->val, convert(uplo), n, a, lda, stride_a, batch_size, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::potrf_batch(device_queue->val, convert(uplo), n, a, lda, stride_a, batch_size, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklDpotrf_batch_strided(syclQueue_t device_queue, onemklUplo uplo, int64_t n, double *a, int64_t lda, int64_t stride_a, int64_t batch_size, double *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::potrf_batch(device_queue->val, convert(uplo), n, a, lda, stride_a, batch_size, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::potrf_batch(device_queue->val, convert(uplo), n, a, lda, stride_a, batch_size, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklCpotrf_batch_strided(syclQueue_t device_queue, onemklUplo uplo, int64_t n, float _Complex *a, int64_t lda, int64_t stride_a, int64_t batch_size, float _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::potrf_batch(device_queue->val, convert(uplo), n, reinterpret_cast*>(a), lda, stride_a, batch_size, reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::potrf_batch(device_queue->val, convert(uplo), n, reinterpret_cast*>(a), lda, stride_a, batch_size, reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklZpotrf_batch_strided(syclQueue_t device_queue, onemklUplo uplo, int64_t n, double _Complex *a, int64_t lda, int64_t stride_a, int64_t batch_size, double _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::potrf_batch(device_queue->val, convert(uplo), n, reinterpret_cast*>(a), lda, stride_a, batch_size, reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::potrf_batch(device_queue->val, convert(uplo), n, reinterpret_cast*>(a), lda, stride_a, batch_size, reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklSpotrs_batch_strided(syclQueue_t device_queue, onemklUplo uplo, int64_t n, int64_t nrhs, float *a, int64_t lda, int64_t stride_a, float *b, int64_t ldb, int64_t stride_b, int64_t batch_size, float *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::potrs_batch(device_queue->val, convert(uplo), n, nrhs, a, lda, stride_a, b, ldb, stride_b, batch_size, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::potrs_batch(device_queue->val, convert(uplo), n, nrhs, a, lda, stride_a, b, ldb, stride_b, batch_size, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklDpotrs_batch_strided(syclQueue_t device_queue, onemklUplo uplo, int64_t n, int64_t nrhs, double *a, int64_t lda, int64_t stride_a, double *b, int64_t ldb, int64_t stride_b, int64_t batch_size, double *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::potrs_batch(device_queue->val, convert(uplo), n, nrhs, a, lda, stride_a, b, ldb, stride_b, batch_size, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::potrs_batch(device_queue->val, convert(uplo), n, nrhs, a, lda, stride_a, b, ldb, stride_b, batch_size, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklCpotrs_batch_strided(syclQueue_t device_queue, onemklUplo uplo, int64_t n, int64_t nrhs, float _Complex *a, int64_t lda, int64_t stride_a, float _Complex *b, int64_t ldb, int64_t stride_b, int64_t batch_size, float _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::potrs_batch(device_queue->val, convert(uplo), n, nrhs, reinterpret_cast*>(a), lda, stride_a, reinterpret_cast*>(b), ldb, stride_b, batch_size, reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::potrs_batch(device_queue->val, convert(uplo), n, nrhs, reinterpret_cast*>(a), lda, stride_a, reinterpret_cast*>(b), ldb, stride_b, batch_size, reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklZpotrs_batch_strided(syclQueue_t device_queue, onemklUplo uplo, int64_t n, int64_t nrhs, double _Complex *a, int64_t lda, int64_t stride_a, double _Complex *b, int64_t ldb, int64_t stride_b, int64_t batch_size, double _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::potrs_batch(device_queue->val, convert(uplo), n, nrhs, reinterpret_cast*>(a), lda, stride_a, reinterpret_cast*>(b), ldb, stride_b, batch_size, reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::potrs_batch(device_queue->val, convert(uplo), n, nrhs, reinterpret_cast*>(a), lda, stride_a, reinterpret_cast*>(b), ldb, stride_b, batch_size, reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklSgeqrf_batch_strided(syclQueue_t device_queue, int64_t m, int64_t n, float *a, int64_t lda, int64_t stride_a, float *tau, int64_t stride_tau, int64_t batch_size, float *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::geqrf_batch(device_queue->val, m, n, a, lda, stride_a, tau, stride_tau, batch_size, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::geqrf_batch(device_queue->val, m, n, a, lda, stride_a, tau, stride_tau, batch_size, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklDgeqrf_batch_strided(syclQueue_t device_queue, int64_t m, int64_t n, double *a, int64_t lda, int64_t stride_a, double *tau, int64_t stride_tau, int64_t batch_size, double *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::geqrf_batch(device_queue->val, m, n, a, lda, stride_a, tau, stride_tau, batch_size, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::geqrf_batch(device_queue->val, m, n, a, lda, stride_a, tau, stride_tau, batch_size, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklCgeqrf_batch_strided(syclQueue_t device_queue, int64_t m, int64_t n, float _Complex *a, int64_t lda, int64_t stride_a, float _Complex *tau, int64_t stride_tau, int64_t batch_size, float _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::geqrf_batch(device_queue->val, m, n, reinterpret_cast*>(a), lda, stride_a, reinterpret_cast*>(tau), stride_tau, batch_size, reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::geqrf_batch(device_queue->val, m, n, reinterpret_cast*>(a), lda, stride_a, reinterpret_cast*>(tau), stride_tau, batch_size, reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklZgeqrf_batch_strided(syclQueue_t device_queue, int64_t m, int64_t n, double _Complex *a, int64_t lda, int64_t stride_a, double _Complex *tau, int64_t stride_tau, int64_t batch_size, double _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::geqrf_batch(device_queue->val, m, n, reinterpret_cast*>(a), lda, stride_a, reinterpret_cast*>(tau), stride_tau, batch_size, reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::geqrf_batch(device_queue->val, m, n, reinterpret_cast*>(a), lda, stride_a, reinterpret_cast*>(tau), stride_tau, batch_size, reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklSorgqr_batch_strided(syclQueue_t device_queue, int64_t m, int64_t n, int64_t k, float *a, int64_t lda, int64_t stride_a, float *tau, int64_t stride_tau, int64_t batch_size, float *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::orgqr_batch(device_queue->val, m, n, k, a, lda, stride_a, tau, stride_tau, batch_size, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::orgqr_batch(device_queue->val, m, n, k, a, lda, stride_a, tau, stride_tau, batch_size, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklDorgqr_batch_strided(syclQueue_t device_queue, int64_t m, int64_t n, int64_t k, double *a, int64_t lda, int64_t stride_a, double *tau, int64_t stride_tau, int64_t batch_size, double *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::orgqr_batch(device_queue->val, m, n, k, a, lda, stride_a, tau, stride_tau, batch_size, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::orgqr_batch(device_queue->val, m, n, k, a, lda, stride_a, tau, stride_tau, batch_size, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklCungqr_batch_strided(syclQueue_t device_queue, int64_t m, int64_t n, int64_t k, float _Complex *a, int64_t lda, int64_t stride_a, float _Complex *tau, int64_t stride_tau, int64_t batch_size, float _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::ungqr_batch(device_queue->val, m, n, k, reinterpret_cast*>(a), lda, stride_a, reinterpret_cast*>(tau), stride_tau, batch_size, reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::ungqr_batch(device_queue->val, m, n, k, reinterpret_cast*>(a), lda, stride_a, reinterpret_cast*>(tau), stride_tau, batch_size, reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklZungqr_batch_strided(syclQueue_t device_queue, int64_t m, int64_t n, int64_t k, double _Complex *a, int64_t lda, int64_t stride_a, double _Complex *tau, int64_t stride_tau, int64_t batch_size, double _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::ungqr_batch(device_queue->val, m, n, k, reinterpret_cast*>(a), lda, stride_a, reinterpret_cast*>(tau), stride_tau, batch_size, reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::ungqr_batch(device_queue->val, m, n, k, reinterpret_cast*>(a), lda, stride_a, reinterpret_cast*>(tau), stride_tau, batch_size, reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklSgetri_batch_strided(syclQueue_t device_queue, int64_t n, float *a, int64_t lda, int64_t stride_a, int64_t *ipiv, int64_t stride_ipiv, int64_t batch_size, float *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::getri_batch(device_queue->val, n, a, lda, stride_a, ipiv, stride_ipiv, batch_size, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::getri_batch(device_queue->val, n, a, lda, stride_a, ipiv, stride_ipiv, batch_size, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklDgetri_batch_strided(syclQueue_t device_queue, int64_t n, double *a, int64_t lda, int64_t stride_a, int64_t *ipiv, int64_t stride_ipiv, int64_t batch_size, double *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::getri_batch(device_queue->val, n, a, lda, stride_a, ipiv, stride_ipiv, batch_size, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::getri_batch(device_queue->val, n, a, lda, stride_a, ipiv, stride_ipiv, batch_size, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklCgetri_batch_strided(syclQueue_t device_queue, int64_t n, float _Complex *a, int64_t lda, int64_t stride_a, int64_t *ipiv, int64_t stride_ipiv, int64_t batch_size, float _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::getri_batch(device_queue->val, n, reinterpret_cast*>(a), lda, stride_a, ipiv, stride_ipiv, batch_size, reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::getri_batch(device_queue->val, n, reinterpret_cast*>(a), lda, stride_a, ipiv, stride_ipiv, batch_size, reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklZgetri_batch_strided(syclQueue_t device_queue, int64_t n, double _Complex *a, int64_t lda, int64_t stride_a, int64_t *ipiv, int64_t stride_ipiv, int64_t batch_size, double _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::getri_batch(device_queue->val, n, reinterpret_cast*>(a), lda, stride_a, ipiv, stride_ipiv, batch_size, reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::getri_batch(device_queue->val, n, reinterpret_cast*>(a), lda, stride_a, ipiv, stride_ipiv, batch_size, reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklSgels_batch_strided(syclQueue_t device_queue, onemklTranspose trans, int64_t m, int64_t n, int64_t nrhs, float *_a, int64_t lda, int64_t stride_a, float *_b, int64_t ldb, int64_t stride_b, int64_t batch_size, float *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::gels_batch(device_queue->val, convert(trans), m, n, nrhs, _a, lda, stride_a, _b, ldb, stride_b, batch_size, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::gels_batch(device_queue->val, convert(trans), m, n, nrhs, _a, lda, stride_a, _b, ldb, stride_b, batch_size, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklDgels_batch_strided(syclQueue_t device_queue, onemklTranspose trans, int64_t m, int64_t n, int64_t nrhs, double *_a, int64_t lda, int64_t stride_a, double *_b, int64_t ldb, int64_t stride_b, int64_t batch_size, double *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::gels_batch(device_queue->val, convert(trans), m, n, nrhs, _a, lda, stride_a, _b, ldb, stride_b, batch_size, scratchpad, scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::gels_batch(device_queue->val, convert(trans), m, n, nrhs, _a, lda, stride_a, _b, ldb, stride_b, batch_size, scratchpad, scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklCgels_batch_strided(syclQueue_t device_queue, onemklTranspose trans, int64_t m, int64_t n, int64_t nrhs, float _Complex *_a, int64_t lda, int64_t stride_a, float _Complex *_b, int64_t ldb, int64_t stride_b, int64_t batch_size, float _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::gels_batch(device_queue->val, convert(trans), m, n, nrhs, reinterpret_cast*>(_a), lda, stride_a, reinterpret_cast*>(_b), ldb, stride_b, batch_size, reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::gels_batch(device_queue->val, convert(trans), m, n, nrhs, reinterpret_cast*>(_a), lda, stride_a, reinterpret_cast*>(_b), ldb, stride_b, batch_size, reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklZgels_batch_strided(syclQueue_t device_queue, onemklTranspose trans, int64_t m, int64_t n, int64_t nrhs, double _Complex *_a, int64_t lda, int64_t stride_a, double _Complex *_b, int64_t ldb, int64_t stride_b, int64_t batch_size, double _Complex *scratchpad, int64_t scratchpad_size) { - auto status = oneapi::mkl::lapack::gels_batch(device_queue->val, convert(trans), m, n, nrhs, reinterpret_cast*>(_a), lda, stride_a, reinterpret_cast*>(_b), ldb, stride_b, batch_size, reinterpret_cast*>(scratchpad), scratchpad_size, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::lapack::gels_batch(device_queue->val, convert(trans), m, n, nrhs, reinterpret_cast*>(_a), lda, stride_a, reinterpret_cast*>(_b), ldb, stride_b, batch_size, reinterpret_cast*>(scratchpad), scratchpad_size, {}); + device_queue->val.wait_and_throw(); + } catch (const oneapi::mkl::lapack::computation_error& e) { return e.info(); } catch (const sycl::exception& e) { return -1; } return 0; } @@ -4569,104 +5477,138 @@ extern "C" int onemklXsparse_init_matrix_handle(matrix_handle_t *p_spMat) { } extern "C" int onemklXsparse_release_matrix_handle(syclQueue_t device_queue, matrix_handle_t *p_spMat) { - auto status = oneapi::mkl::sparse::release_matrix_handle(device_queue->val, (oneapi::mkl::sparse::matrix_handle_t*) p_spMat, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::sparse::release_matrix_handle(device_queue->val, (oneapi::mkl::sparse::matrix_handle_t*) p_spMat, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklSsparse_set_csr_data(syclQueue_t device_queue, matrix_handle_t spMat, int32_t nrows, int32_t ncols, onemklIndex index, int32_t *row_ptr, int32_t *col_ind, float *values) { - auto status = oneapi::mkl::sparse::set_csr_data(device_queue->val, (oneapi::mkl::sparse::matrix_handle_t) spMat, nrows, ncols, convert(index), row_ptr, col_ind, values, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::sparse::set_csr_data(device_queue->val, (oneapi::mkl::sparse::matrix_handle_t) spMat, nrows, ncols, convert(index), row_ptr, col_ind, values, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklSsparse_set_csr_data_64(syclQueue_t device_queue, matrix_handle_t spMat, int64_t nrows, int64_t ncols, onemklIndex index, int64_t *row_ptr, int64_t *col_ind, float *values) { - auto status = oneapi::mkl::sparse::set_csr_data(device_queue->val, (oneapi::mkl::sparse::matrix_handle_t) spMat, nrows, ncols, convert(index), row_ptr, col_ind, values, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::sparse::set_csr_data(device_queue->val, (oneapi::mkl::sparse::matrix_handle_t) spMat, nrows, ncols, convert(index), row_ptr, col_ind, values, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklDsparse_set_csr_data(syclQueue_t device_queue, matrix_handle_t spMat, int32_t nrows, int32_t ncols, onemklIndex index, int32_t *row_ptr, int32_t *col_ind, double *values) { - auto status = oneapi::mkl::sparse::set_csr_data(device_queue->val, (oneapi::mkl::sparse::matrix_handle_t) spMat, nrows, ncols, convert(index), row_ptr, col_ind, values, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::sparse::set_csr_data(device_queue->val, (oneapi::mkl::sparse::matrix_handle_t) spMat, nrows, ncols, convert(index), row_ptr, col_ind, values, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklDsparse_set_csr_data_64(syclQueue_t device_queue, matrix_handle_t spMat, int64_t nrows, int64_t ncols, onemklIndex index, int64_t *row_ptr, int64_t *col_ind, double *values) { - auto status = oneapi::mkl::sparse::set_csr_data(device_queue->val, (oneapi::mkl::sparse::matrix_handle_t) spMat, nrows, ncols, convert(index), row_ptr, col_ind, values, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::sparse::set_csr_data(device_queue->val, (oneapi::mkl::sparse::matrix_handle_t) spMat, nrows, ncols, convert(index), row_ptr, col_ind, values, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklCsparse_set_csr_data(syclQueue_t device_queue, matrix_handle_t spMat, int32_t nrows, int32_t ncols, onemklIndex index, int32_t *row_ptr, int32_t *col_ind, float _Complex *values) { - auto status = oneapi::mkl::sparse::set_csr_data(device_queue->val, (oneapi::mkl::sparse::matrix_handle_t) spMat, nrows, ncols, convert(index), row_ptr, col_ind, reinterpret_cast*>(values), {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::sparse::set_csr_data(device_queue->val, (oneapi::mkl::sparse::matrix_handle_t) spMat, nrows, ncols, convert(index), row_ptr, col_ind, reinterpret_cast*>(values), {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklCsparse_set_csr_data_64(syclQueue_t device_queue, matrix_handle_t spMat, int64_t nrows, int64_t ncols, onemklIndex index, int64_t *row_ptr, int64_t *col_ind, float _Complex *values) { - auto status = oneapi::mkl::sparse::set_csr_data(device_queue->val, (oneapi::mkl::sparse::matrix_handle_t) spMat, nrows, ncols, convert(index), row_ptr, col_ind, reinterpret_cast*>(values), {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::sparse::set_csr_data(device_queue->val, (oneapi::mkl::sparse::matrix_handle_t) spMat, nrows, ncols, convert(index), row_ptr, col_ind, reinterpret_cast*>(values), {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklZsparse_set_csr_data(syclQueue_t device_queue, matrix_handle_t spMat, int32_t nrows, int32_t ncols, onemklIndex index, int32_t *row_ptr, int32_t *col_ind, double _Complex *values) { - auto status = oneapi::mkl::sparse::set_csr_data(device_queue->val, (oneapi::mkl::sparse::matrix_handle_t) spMat, nrows, ncols, convert(index), row_ptr, col_ind, reinterpret_cast*>(values), {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::sparse::set_csr_data(device_queue->val, (oneapi::mkl::sparse::matrix_handle_t) spMat, nrows, ncols, convert(index), row_ptr, col_ind, reinterpret_cast*>(values), {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklZsparse_set_csr_data_64(syclQueue_t device_queue, matrix_handle_t spMat, int64_t nrows, int64_t ncols, onemklIndex index, int64_t *row_ptr, int64_t *col_ind, double _Complex *values) { - auto status = oneapi::mkl::sparse::set_csr_data(device_queue->val, (oneapi::mkl::sparse::matrix_handle_t) spMat, nrows, ncols, convert(index), row_ptr, col_ind, reinterpret_cast*>(values), {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::sparse::set_csr_data(device_queue->val, (oneapi::mkl::sparse::matrix_handle_t) spMat, nrows, ncols, convert(index), row_ptr, col_ind, reinterpret_cast*>(values), {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklSsparse_set_coo_data(syclQueue_t device_queue, matrix_handle_t spMat, int32_t nrows, int32_t ncols, int32_t nnz, onemklIndex index, int32_t *row_ind, int32_t *col_ind, float *values) { - auto status = oneapi::mkl::sparse::set_coo_data(device_queue->val, (oneapi::mkl::sparse::matrix_handle_t) spMat, nrows, ncols, nnz, convert(index), row_ind, col_ind, values, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::sparse::set_coo_data(device_queue->val, (oneapi::mkl::sparse::matrix_handle_t) spMat, nrows, ncols, nnz, convert(index), row_ind, col_ind, values, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklSsparse_set_coo_data_64(syclQueue_t device_queue, matrix_handle_t spMat, int64_t nrows, int64_t ncols, int64_t nnz, onemklIndex index, int64_t *row_ind, int64_t *col_ind, float *values) { - auto status = oneapi::mkl::sparse::set_coo_data(device_queue->val, (oneapi::mkl::sparse::matrix_handle_t) spMat, nrows, ncols, nnz, convert(index), row_ind, col_ind, values, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::sparse::set_coo_data(device_queue->val, (oneapi::mkl::sparse::matrix_handle_t) spMat, nrows, ncols, nnz, convert(index), row_ind, col_ind, values, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklDsparse_set_coo_data(syclQueue_t device_queue, matrix_handle_t spMat, int32_t nrows, int32_t ncols, int32_t nnz, onemklIndex index, int32_t *row_ind, int32_t *col_ind, double *values) { - auto status = oneapi::mkl::sparse::set_coo_data(device_queue->val, (oneapi::mkl::sparse::matrix_handle_t) spMat, nrows, ncols, nnz, convert(index), row_ind, col_ind, values, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::sparse::set_coo_data(device_queue->val, (oneapi::mkl::sparse::matrix_handle_t) spMat, nrows, ncols, nnz, convert(index), row_ind, col_ind, values, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklDsparse_set_coo_data_64(syclQueue_t device_queue, matrix_handle_t spMat, int64_t nrows, int64_t ncols, int64_t nnz, onemklIndex index, int64_t *row_ind, int64_t *col_ind, double *values) { - auto status = oneapi::mkl::sparse::set_coo_data(device_queue->val, (oneapi::mkl::sparse::matrix_handle_t) spMat, nrows, ncols, nnz, convert(index), row_ind, col_ind, values, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::sparse::set_coo_data(device_queue->val, (oneapi::mkl::sparse::matrix_handle_t) spMat, nrows, ncols, nnz, convert(index), row_ind, col_ind, values, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklCsparse_set_coo_data(syclQueue_t device_queue, matrix_handle_t spMat, int32_t nrows, int32_t ncols, int32_t nnz, onemklIndex index, int32_t *row_ind, int32_t *col_ind, float _Complex *values) { - auto status = oneapi::mkl::sparse::set_coo_data(device_queue->val, (oneapi::mkl::sparse::matrix_handle_t) spMat, nrows, ncols, nnz, convert(index), row_ind, col_ind, reinterpret_cast*>(values), {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::sparse::set_coo_data(device_queue->val, (oneapi::mkl::sparse::matrix_handle_t) spMat, nrows, ncols, nnz, convert(index), row_ind, col_ind, reinterpret_cast*>(values), {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklCsparse_set_coo_data_64(syclQueue_t device_queue, matrix_handle_t spMat, int64_t nrows, int64_t ncols, int64_t nnz, onemklIndex index, int64_t *row_ind, int64_t *col_ind, float _Complex *values) { - auto status = oneapi::mkl::sparse::set_coo_data(device_queue->val, (oneapi::mkl::sparse::matrix_handle_t) spMat, nrows, ncols, nnz, convert(index), row_ind, col_ind, reinterpret_cast*>(values), {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::sparse::set_coo_data(device_queue->val, (oneapi::mkl::sparse::matrix_handle_t) spMat, nrows, ncols, nnz, convert(index), row_ind, col_ind, reinterpret_cast*>(values), {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklZsparse_set_coo_data(syclQueue_t device_queue, matrix_handle_t spMat, int32_t nrows, int32_t ncols, int32_t nnz, onemklIndex index, int32_t *row_ind, int32_t *col_ind, double _Complex *values) { - auto status = oneapi::mkl::sparse::set_coo_data(device_queue->val, (oneapi::mkl::sparse::matrix_handle_t) spMat, nrows, ncols, nnz, convert(index), row_ind, col_ind, reinterpret_cast*>(values), {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::sparse::set_coo_data(device_queue->val, (oneapi::mkl::sparse::matrix_handle_t) spMat, nrows, ncols, nnz, convert(index), row_ind, col_ind, reinterpret_cast*>(values), {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklZsparse_set_coo_data_64(syclQueue_t device_queue, matrix_handle_t spMat, int64_t nrows, int64_t ncols, int64_t nnz, onemklIndex index, int64_t *row_ind, int64_t *col_ind, double _Complex *values) { - auto status = oneapi::mkl::sparse::set_coo_data(device_queue->val, (oneapi::mkl::sparse::matrix_handle_t) spMat, nrows, ncols, nnz, convert(index), row_ind, col_ind, reinterpret_cast*>(values), {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::sparse::set_coo_data(device_queue->val, (oneapi::mkl::sparse::matrix_handle_t) spMat, nrows, ncols, nnz, convert(index), row_ind, col_ind, reinterpret_cast*>(values), {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } @@ -4681,272 +5623,362 @@ extern "C" int onemklXsparse_release_matmat_descr(matmat_descr_t *p_desc) { } extern "C" int onemklXsparse_init_omatconvert_descr(syclQueue_t device_queue, omatconvert_descr_t *p_descr) { - oneapi::mkl::sparse::init_omatconvert_descr(device_queue->val, (oneapi::mkl::sparse::omatconvert_descr_t*) p_descr); - device_queue->val.wait_and_throw(); + try { + oneapi::mkl::sparse::init_omatconvert_descr(device_queue->val, (oneapi::mkl::sparse::omatconvert_descr_t*) p_descr); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklXsparse_release_omatconvert_descr(syclQueue_t device_queue, omatconvert_descr_t descr) { - auto status = oneapi::mkl::sparse::release_omatconvert_descr(device_queue->val, (oneapi::mkl::sparse::omatconvert_descr_t) descr, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::sparse::release_omatconvert_descr(device_queue->val, (oneapi::mkl::sparse::omatconvert_descr_t) descr, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklXsparse_init_omatadd_descr(syclQueue_t device_queue, omatadd_descr_t *p_omatadd_desc) { - oneapi::mkl::sparse::init_omatadd_descr(device_queue->val, (oneapi::mkl::sparse::omatadd_descr_t*) p_omatadd_desc); - device_queue->val.wait_and_throw(); + try { + oneapi::mkl::sparse::init_omatadd_descr(device_queue->val, (oneapi::mkl::sparse::omatadd_descr_t*) p_omatadd_desc); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklXsparse_release_omatadd_descr(syclQueue_t device_queue, omatadd_descr_t omatadd_desc) { - auto status = oneapi::mkl::sparse::release_omatadd_descr(device_queue->val, (oneapi::mkl::sparse::omatadd_descr_t) omatadd_desc, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::sparse::release_omatadd_descr(device_queue->val, (oneapi::mkl::sparse::omatadd_descr_t) omatadd_desc, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklXsparse_omatcopy(syclQueue_t device_queue, onemklTranspose transpose_val, matrix_handle_t spMat_in, matrix_handle_t spMat_out) { - auto status = oneapi::mkl::sparse::omatcopy(device_queue->val, convert(transpose_val), (oneapi::mkl::sparse::matrix_handle_t) spMat_in, (oneapi::mkl::sparse::matrix_handle_t) spMat_out, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::sparse::omatcopy(device_queue->val, convert(transpose_val), (oneapi::mkl::sparse::matrix_handle_t) spMat_in, (oneapi::mkl::sparse::matrix_handle_t) spMat_out, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklXsparse_sort_matrix(syclQueue_t device_queue, matrix_handle_t spMat) { - auto status = oneapi::mkl::sparse::sort_matrix(device_queue->val, (oneapi::mkl::sparse::matrix_handle_t) spMat, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::sparse::sort_matrix(device_queue->val, (oneapi::mkl::sparse::matrix_handle_t) spMat, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklSsparse_update_diagonal_values(syclQueue_t device_queue, matrix_handle_t spMat, int64_t length, float *new_diag_values) { - auto status = oneapi::mkl::sparse::update_diagonal_values(device_queue->val, (oneapi::mkl::sparse::matrix_handle_t) spMat, length, new_diag_values, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::sparse::update_diagonal_values(device_queue->val, (oneapi::mkl::sparse::matrix_handle_t) spMat, length, new_diag_values, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklDsparse_update_diagonal_values(syclQueue_t device_queue, matrix_handle_t spMat, int64_t length, double *new_diag_values) { - auto status = oneapi::mkl::sparse::update_diagonal_values(device_queue->val, (oneapi::mkl::sparse::matrix_handle_t) spMat, length, new_diag_values, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::sparse::update_diagonal_values(device_queue->val, (oneapi::mkl::sparse::matrix_handle_t) spMat, length, new_diag_values, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklCsparse_update_diagonal_values(syclQueue_t device_queue, matrix_handle_t spMat, int64_t length, float _Complex *new_diag_values) { - auto status = oneapi::mkl::sparse::update_diagonal_values(device_queue->val, (oneapi::mkl::sparse::matrix_handle_t) spMat, length, reinterpret_cast*>(new_diag_values), {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::sparse::update_diagonal_values(device_queue->val, (oneapi::mkl::sparse::matrix_handle_t) spMat, length, reinterpret_cast*>(new_diag_values), {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklZsparse_update_diagonal_values(syclQueue_t device_queue, matrix_handle_t spMat, int64_t length, double _Complex *new_diag_values) { - auto status = oneapi::mkl::sparse::update_diagonal_values(device_queue->val, (oneapi::mkl::sparse::matrix_handle_t) spMat, length, reinterpret_cast*>(new_diag_values), {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::sparse::update_diagonal_values(device_queue->val, (oneapi::mkl::sparse::matrix_handle_t) spMat, length, reinterpret_cast*>(new_diag_values), {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklXsparse_optimize_gemv(syclQueue_t device_queue, onemklTranspose opA, matrix_handle_t A) { - auto status = oneapi::mkl::sparse::optimize_gemv(device_queue->val, convert(opA), (oneapi::mkl::sparse::matrix_handle_t) A, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::sparse::optimize_gemv(device_queue->val, convert(opA), (oneapi::mkl::sparse::matrix_handle_t) A, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklXsparse_optimize_trmv(syclQueue_t device_queue, onemklUplo uplo_val, onemklTranspose opA, onemklDiag diag_val, matrix_handle_t A) { - auto status = oneapi::mkl::sparse::optimize_trmv(device_queue->val, convert(uplo_val), convert(opA), convert(diag_val), (oneapi::mkl::sparse::matrix_handle_t) A, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::sparse::optimize_trmv(device_queue->val, convert(uplo_val), convert(opA), convert(diag_val), (oneapi::mkl::sparse::matrix_handle_t) A, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklXsparse_optimize_trsv(syclQueue_t device_queue, onemklUplo uplo_val, onemklTranspose opA, onemklDiag diag_val, matrix_handle_t A) { - auto status = oneapi::mkl::sparse::optimize_trsv(device_queue->val, convert(uplo_val), convert(opA), convert(diag_val), (oneapi::mkl::sparse::matrix_handle_t) A, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::sparse::optimize_trsv(device_queue->val, convert(uplo_val), convert(opA), convert(diag_val), (oneapi::mkl::sparse::matrix_handle_t) A, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklXsparse_optimize_gemm(syclQueue_t device_queue, onemklTranspose opA, matrix_handle_t A) { - auto status = oneapi::mkl::sparse::optimize_gemm(device_queue->val, convert(opA), (oneapi::mkl::sparse::matrix_handle_t) A, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::sparse::optimize_gemm(device_queue->val, convert(opA), (oneapi::mkl::sparse::matrix_handle_t) A, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklXsparse_optimize_gemm_advanced(syclQueue_t device_queue, onemklLayout layout_val, onemklTranspose opA, onemklTranspose opB, matrix_handle_t A, int64_t columns) { - auto status = oneapi::mkl::sparse::optimize_gemm(device_queue->val, convert(layout_val), convert(opA), convert(opB), (oneapi::mkl::sparse::matrix_handle_t) A, columns, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::sparse::optimize_gemm(device_queue->val, convert(layout_val), convert(opA), convert(opB), (oneapi::mkl::sparse::matrix_handle_t) A, columns, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklXsparse_optimize_trsm(syclQueue_t device_queue, onemklUplo uplo_val, onemklTranspose opA, onemklDiag diag_val, matrix_handle_t A) { - auto status = oneapi::mkl::sparse::optimize_trsm(device_queue->val, convert(uplo_val), convert(opA), convert(diag_val), (oneapi::mkl::sparse::matrix_handle_t) A, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::sparse::optimize_trsm(device_queue->val, convert(uplo_val), convert(opA), convert(diag_val), (oneapi::mkl::sparse::matrix_handle_t) A, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklXsparse_optimize_trsm_advanced(syclQueue_t device_queue, onemklLayout layout_val, onemklUplo uplo_val, onemklTranspose opA, onemklDiag diag_val, matrix_handle_t A, int64_t columns) { - auto status = oneapi::mkl::sparse::optimize_trsm(device_queue->val, convert(layout_val), convert(uplo_val), convert(opA), convert(diag_val), (oneapi::mkl::sparse::matrix_handle_t) A, columns, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::sparse::optimize_trsm(device_queue->val, convert(layout_val), convert(uplo_val), convert(opA), convert(diag_val), (oneapi::mkl::sparse::matrix_handle_t) A, columns, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::sparse::gemv(device_queue->val, convert(opA), *alpha, (oneapi::mkl::sparse::matrix_handle_t) A, x, *beta, y, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::sparse::gemv(device_queue->val, convert(opA), *alpha, (oneapi::mkl::sparse::matrix_handle_t) A, x, *beta, y, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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), *reinterpret_cast*>(alpha), (oneapi::mkl::sparse::matrix_handle_t) A, reinterpret_cast*>(x), *reinterpret_cast*>(beta), reinterpret_cast*>(y), {}); - device_queue->val.wait_and_throw(); + try { + 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), {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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), *reinterpret_cast*>(alpha), (oneapi::mkl::sparse::matrix_handle_t) A, reinterpret_cast*>(x), *reinterpret_cast*>(beta), reinterpret_cast*>(y), {}); - device_queue->val.wait_and_throw(); + try { + 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), {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::sparse::gemvdot(device_queue->val, convert(opA), *alpha, (oneapi::mkl::sparse::matrix_handle_t) A, x, *beta, y, d, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::sparse::gemvdot(device_queue->val, convert(opA), *alpha, (oneapi::mkl::sparse::matrix_handle_t) A, x, *beta, y, d, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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), *reinterpret_cast*>(alpha), (oneapi::mkl::sparse::matrix_handle_t) A, reinterpret_cast*>(x), *reinterpret_cast*>(beta), reinterpret_cast*>(y), reinterpret_cast*>(d), {}); - device_queue->val.wait_and_throw(); + try { + 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), {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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), *reinterpret_cast*>(alpha), (oneapi::mkl::sparse::matrix_handle_t) A, reinterpret_cast*>(x), *reinterpret_cast*>(beta), reinterpret_cast*>(y), reinterpret_cast*>(d), {}); - device_queue->val.wait_and_throw(); + try { + 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), {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::sparse::symv(device_queue->val, convert(uplo_val), *alpha, (oneapi::mkl::sparse::matrix_handle_t) A, x, *beta, y, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::sparse::symv(device_queue->val, convert(uplo_val), *alpha, (oneapi::mkl::sparse::matrix_handle_t) A, x, *beta, y, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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), *reinterpret_cast*>(alpha), (oneapi::mkl::sparse::matrix_handle_t) A, reinterpret_cast*>(x), *reinterpret_cast*>(beta), reinterpret_cast*>(y), {}); - device_queue->val.wait_and_throw(); + try { + 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), {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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), *reinterpret_cast*>(alpha), (oneapi::mkl::sparse::matrix_handle_t) A, reinterpret_cast*>(x), *reinterpret_cast*>(beta), reinterpret_cast*>(y), {}); - device_queue->val.wait_and_throw(); + try { + 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), {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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), *reinterpret_cast*>(alpha), (oneapi::mkl::sparse::matrix_handle_t) A, reinterpret_cast*>(x), *reinterpret_cast*>(beta), reinterpret_cast*>(y), {}); - device_queue->val.wait_and_throw(); + try { + 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), {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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), *reinterpret_cast*>(alpha), (oneapi::mkl::sparse::matrix_handle_t) A, reinterpret_cast*>(x), *reinterpret_cast*>(beta), reinterpret_cast*>(y), {}); - device_queue->val.wait_and_throw(); + try { + 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), {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklSsparse_trsv(syclQueue_t device_queue, onemklUplo uplo_val, onemklTranspose opA, onemklDiag diag_val, float *alpha, matrix_handle_t A, float *x, float *y) { - auto status = oneapi::mkl::sparse::trsv(device_queue->val, convert(uplo_val), convert(opA), convert(diag_val), *alpha, (oneapi::mkl::sparse::matrix_handle_t) A, x, y, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::sparse::trsv(device_queue->val, convert(uplo_val), convert(opA), convert(diag_val), *alpha, (oneapi::mkl::sparse::matrix_handle_t) A, x, y, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklDsparse_trsv(syclQueue_t device_queue, onemklUplo uplo_val, onemklTranspose opA, onemklDiag diag_val, double *alpha, matrix_handle_t A, double *x, double *y) { - auto status = oneapi::mkl::sparse::trsv(device_queue->val, convert(uplo_val), convert(opA), convert(diag_val), *alpha, (oneapi::mkl::sparse::matrix_handle_t) A, x, y, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::sparse::trsv(device_queue->val, convert(uplo_val), convert(opA), convert(diag_val), *alpha, (oneapi::mkl::sparse::matrix_handle_t) A, x, y, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklCsparse_trsv(syclQueue_t device_queue, onemklUplo uplo_val, onemklTranspose opA, onemklDiag diag_val, float _Complex *alpha, matrix_handle_t A, float _Complex *x, float _Complex *y) { - auto status = oneapi::mkl::sparse::trsv(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*>(y), {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::sparse::trsv(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*>(y), {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklZsparse_trsv(syclQueue_t device_queue, onemklUplo uplo_val, onemklTranspose opA, onemklDiag diag_val, double _Complex *alpha, matrix_handle_t A, double _Complex *x, double _Complex *y) { - auto status = oneapi::mkl::sparse::trsv(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*>(y), {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::sparse::trsv(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*>(y), {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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), *reinterpret_cast*>(alpha), (oneapi::mkl::sparse::matrix_handle_t) A, reinterpret_cast*>(X), columns, ldx, *reinterpret_cast*>(beta), reinterpret_cast*>(Y), ldy, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } 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), *reinterpret_cast*>(alpha), (oneapi::mkl::sparse::matrix_handle_t) A, reinterpret_cast*>(X), columns, ldx, *reinterpret_cast*>(beta), reinterpret_cast*>(Y), ldy, {}); - device_queue->val.wait_and_throw(); + try { + 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, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklSsparse_trsm(syclQueue_t device_queue, onemklLayout layout_val, onemklTranspose opA, onemklTranspose opX, onemklUplo uplo_val, onemklDiag diag_val, float *alpha, matrix_handle_t A, float *X, int64_t columns, int64_t ldx, float *Y, int64_t ldy) { - auto status = oneapi::mkl::sparse::trsm(device_queue->val, convert(layout_val), convert(opA), convert(opX), convert(uplo_val), convert(diag_val), *alpha, (oneapi::mkl::sparse::matrix_handle_t) A, X, columns, ldx, Y, ldy, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::sparse::trsm(device_queue->val, convert(layout_val), convert(opA), convert(opX), convert(uplo_val), convert(diag_val), *alpha, (oneapi::mkl::sparse::matrix_handle_t) A, X, columns, ldx, Y, ldy, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklDsparse_trsm(syclQueue_t device_queue, onemklLayout layout_val, onemklTranspose opA, onemklTranspose opX, onemklUplo uplo_val, onemklDiag diag_val, double *alpha, matrix_handle_t A, double *X, int64_t columns, int64_t ldx, double *Y, int64_t ldy) { - auto status = oneapi::mkl::sparse::trsm(device_queue->val, convert(layout_val), convert(opA), convert(opX), convert(uplo_val), convert(diag_val), *alpha, (oneapi::mkl::sparse::matrix_handle_t) A, X, columns, ldx, Y, ldy, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::sparse::trsm(device_queue->val, convert(layout_val), convert(opA), convert(opX), convert(uplo_val), convert(diag_val), *alpha, (oneapi::mkl::sparse::matrix_handle_t) A, X, columns, ldx, Y, ldy, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklCsparse_trsm(syclQueue_t device_queue, onemklLayout layout_val, onemklTranspose opA, onemklTranspose opX, onemklUplo uplo_val, onemklDiag diag_val, float _Complex *alpha, matrix_handle_t A, float _Complex *X, int64_t columns, int64_t ldx, float _Complex *Y, int64_t ldy) { - auto status = oneapi::mkl::sparse::trsm(device_queue->val, convert(layout_val), convert(opA), convert(opX), convert(uplo_val), convert(diag_val), *reinterpret_cast*>(alpha), (oneapi::mkl::sparse::matrix_handle_t) A, reinterpret_cast*>(X), columns, ldx, reinterpret_cast*>(Y), ldy, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::sparse::trsm(device_queue->val, convert(layout_val), convert(opA), convert(opX), convert(uplo_val), convert(diag_val), *reinterpret_cast*>(alpha), (oneapi::mkl::sparse::matrix_handle_t) A, reinterpret_cast*>(X), columns, ldx, reinterpret_cast*>(Y), ldy, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklZsparse_trsm(syclQueue_t device_queue, onemklLayout layout_val, onemklTranspose opA, onemklTranspose opX, onemklUplo uplo_val, onemklDiag diag_val, double _Complex *alpha, matrix_handle_t A, double _Complex *X, int64_t columns, int64_t ldx, double _Complex *Y, int64_t ldy) { - auto status = oneapi::mkl::sparse::trsm(device_queue->val, convert(layout_val), convert(opA), convert(opX), convert(uplo_val), convert(diag_val), *reinterpret_cast*>(alpha), (oneapi::mkl::sparse::matrix_handle_t) A, reinterpret_cast*>(X), columns, ldx, reinterpret_cast*>(Y), ldy, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::sparse::trsm(device_queue->val, convert(layout_val), convert(opA), convert(opX), convert(uplo_val), convert(diag_val), *reinterpret_cast*>(alpha), (oneapi::mkl::sparse::matrix_handle_t) A, reinterpret_cast*>(X), columns, ldx, reinterpret_cast*>(Y), ldy, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } @@ -4956,26 +5988,34 @@ extern "C" int onemklXsparse_set_matmat_data(matmat_descr_t descr, onemklMatrixV } extern "C" int onemklSsparse_matmatd(syclQueue_t device_queue, onemklLayout c_layout, onemklTranspose opA, onemklTranspose opB, float *alpha, matrix_handle_t A, matrix_handle_t B, float *beta, float *C, int64_t c_nrows, int64_t c_ncols, int64_t ldc) { - auto status = oneapi::mkl::sparse::matmatd(device_queue->val, convert(c_layout), convert(opA), convert(opB), *alpha, (oneapi::mkl::sparse::matrix_handle_t) A, (oneapi::mkl::sparse::matrix_handle_t) B, *beta, C, c_nrows, c_ncols, ldc, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::sparse::matmatd(device_queue->val, convert(c_layout), convert(opA), convert(opB), *alpha, (oneapi::mkl::sparse::matrix_handle_t) A, (oneapi::mkl::sparse::matrix_handle_t) B, *beta, C, c_nrows, c_ncols, ldc, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklDsparse_matmatd(syclQueue_t device_queue, onemklLayout c_layout, onemklTranspose opA, onemklTranspose opB, double *alpha, matrix_handle_t A, matrix_handle_t B, double *beta, double *C, int64_t c_nrows, int64_t c_ncols, int64_t ldc) { - auto status = oneapi::mkl::sparse::matmatd(device_queue->val, convert(c_layout), convert(opA), convert(opB), *alpha, (oneapi::mkl::sparse::matrix_handle_t) A, (oneapi::mkl::sparse::matrix_handle_t) B, *beta, C, c_nrows, c_ncols, ldc, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::sparse::matmatd(device_queue->val, convert(c_layout), convert(opA), convert(opB), *alpha, (oneapi::mkl::sparse::matrix_handle_t) A, (oneapi::mkl::sparse::matrix_handle_t) B, *beta, C, c_nrows, c_ncols, ldc, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklCsparse_matmatd(syclQueue_t device_queue, onemklLayout c_layout, onemklTranspose opA, onemklTranspose opB, float _Complex *alpha, matrix_handle_t A, matrix_handle_t B, float _Complex *beta, float _Complex *C, int64_t c_nrows, int64_t c_ncols, int64_t ldc) { - auto status = oneapi::mkl::sparse::matmatd(device_queue->val, convert(c_layout), convert(opA), convert(opB), *reinterpret_cast*>(alpha), (oneapi::mkl::sparse::matrix_handle_t) A, (oneapi::mkl::sparse::matrix_handle_t) B, *reinterpret_cast*>(beta), reinterpret_cast*>(C), c_nrows, c_ncols, ldc, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::sparse::matmatd(device_queue->val, convert(c_layout), convert(opA), convert(opB), *reinterpret_cast*>(alpha), (oneapi::mkl::sparse::matrix_handle_t) A, (oneapi::mkl::sparse::matrix_handle_t) B, *reinterpret_cast*>(beta), reinterpret_cast*>(C), c_nrows, c_ncols, ldc, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } extern "C" int onemklZsparse_matmatd(syclQueue_t device_queue, onemklLayout c_layout, onemklTranspose opA, onemklTranspose opB, double _Complex *alpha, matrix_handle_t A, matrix_handle_t B, double _Complex *beta, double _Complex *C, int64_t c_nrows, int64_t c_ncols, int64_t ldc) { - auto status = oneapi::mkl::sparse::matmatd(device_queue->val, convert(c_layout), convert(opA), convert(opB), *reinterpret_cast*>(alpha), (oneapi::mkl::sparse::matrix_handle_t) A, (oneapi::mkl::sparse::matrix_handle_t) B, *reinterpret_cast*>(beta), reinterpret_cast*>(C), c_nrows, c_ncols, ldc, {}); - device_queue->val.wait_and_throw(); + try { + auto status = oneapi::mkl::sparse::matmatd(device_queue->val, convert(c_layout), convert(opA), convert(opB), *reinterpret_cast*>(alpha), (oneapi::mkl::sparse::matrix_handle_t) A, (oneapi::mkl::sparse::matrix_handle_t) B, *reinterpret_cast*>(beta), reinterpret_cast*>(C), c_nrows, c_ncols, ldc, {}); + device_queue->val.wait_and_throw(); + } catch (const sycl::exception& e) { return -1; } return 0; } diff --git a/deps/src/sycl.cpp b/deps/src/sycl.cpp index 61973b0b..ae060da2 100644 --- a/deps/src/sycl.cpp +++ b/deps/src/sycl.cpp @@ -76,6 +76,11 @@ extern "C" int syclQueueDestroy(syclQueue_t obj) { return 0; } +extern "C" int syclQueueWait(syclQueue_t obj) { + obj->val.wait(); + return 0; +} + extern "C" int syclEventCreate(syclEvent_t *obj, syclContext_t context, ze_event_handle_t event, int keep_ownership) { auto sycl_ownership = diff --git a/deps/src/sycl.h b/deps/src/sycl.h index 8b3fe7bb..4c8cf2e4 100644 --- a/deps/src/sycl.h +++ b/deps/src/sycl.h @@ -26,6 +26,7 @@ typedef struct syclQueue_st *syclQueue_t; int syclQueueCreate(syclQueue_t *obj, syclContext_t context, syclDevice_t device, ze_command_queue_handle_t queue, int keep_ownership); int syclQueueDestroy(syclQueue_t obj); +int syclQueueWait(syclQueue_t obj); typedef struct syclEvent_st *syclEvent_t; int syclEventCreate(syclEvent_t *obj, syclContext_t context, diff --git a/lib/mkl/linalg.jl b/lib/mkl/linalg.jl index eb5e6ff1..287f0db7 100644 --- a/lib/mkl/linalg.jl +++ b/lib/mkl/linalg.jl @@ -98,9 +98,9 @@ function LinearAlgebra.generic_matvecmul!(Y::oneVector, tA::AbstractChar, A::one if tA in ('N', 'T', 'C') return gemv!(tA, alpha, A, B, beta, Y) elseif tA in ('S', 's') - return symv!(tA == 'S' ? 'U' : 'L', alpha, A, x, beta, y) + return symv!(tA == 'S' ? 'U' : 'L', alpha, A, B, beta, Y) elseif tA in ('H', 'h') - return hemv!(tA == 'H' ? 'U' : 'L', alpha, A, x, beta, y) + return hemv!(tA == 'H' ? 'U' : 'L', alpha, A, B, beta, Y) end end end diff --git a/lib/support/liboneapi_support.jl b/lib/support/liboneapi_support.jl index 5daba241..91146c99 100644 --- a/lib/support/liboneapi_support.jl +++ b/lib/support/liboneapi_support.jl @@ -58,6 +58,10 @@ function syclQueueDestroy(obj) @ccall liboneapi_support.syclQueueDestroy(obj::syclQueue_t)::Cint end +function syclQueueWait(obj) + @ccall liboneapi_support.syclQueueWait(obj::syclQueue_t)::Cint +end + mutable struct syclEvent_st end const syclEvent_t = Ptr{syclEvent_st} diff --git a/src/accumulate.jl b/src/accumulate.jl index f893dc96..d3647faa 100644 --- a/src/accumulate.jl +++ b/src/accumulate.jl @@ -2,12 +2,20 @@ import oneAPI import oneAPI: oneArray, oneAPIBackend import AcceleratedKernels as AK +# Use a smaller block size on Intel GPUs to work around a scan correctness issue +# with the Blelloch parallel prefix sum at larger block sizes (>=128). +const _ACCUMULATE_BLOCK_SIZE = 64 + # Accumulate operations using AcceleratedKernels -Base.accumulate!(op, B::oneArray, A::oneArray; init = zero(eltype(A)), kwargs...) = - AK.accumulate!(op, B, A, oneAPIBackend(); init, kwargs...) +Base.accumulate!(op, B::oneArray, A::oneArray; init = zero(eltype(A)), + block_size = _ACCUMULATE_BLOCK_SIZE, kwargs...) = + AK.accumulate!(op, B, A, oneAPIBackend(); init, block_size, kwargs...) -Base.accumulate(op, A::oneArray; init = zero(eltype(A)), kwargs...) = - AK.accumulate(op, A, oneAPIBackend(); init, kwargs...) +Base.accumulate(op, A::oneArray; init = zero(eltype(A)), + block_size = _ACCUMULATE_BLOCK_SIZE, kwargs...) = + AK.accumulate(op, A, oneAPIBackend(); init, block_size, kwargs...) -Base.cumsum(src::oneArray; kwargs...) = AK.cumsum(src, oneAPIBackend(); kwargs...) -Base.cumprod(src::oneArray; kwargs...) = AK.cumprod(src, oneAPIBackend(); kwargs...) +Base.cumsum(src::oneArray; block_size = _ACCUMULATE_BLOCK_SIZE, kwargs...) = + AK.cumsum(src, oneAPIBackend(); block_size, kwargs...) +Base.cumprod(src::oneArray; block_size = _ACCUMULATE_BLOCK_SIZE, kwargs...) = + AK.cumprod(src, oneAPIBackend(); block_size, kwargs...) diff --git a/src/mapreduce.jl b/src/mapreduce.jl index fd1a2c71..98d54c1a 100644 --- a/src/mapreduce.jl +++ b/src/mapreduce.jl @@ -4,14 +4,19 @@ # - serial version for lower latency # - group-stride loop to delay need for second kernel launch +# Widen sub-word types to avoid shared memory corruption on Intel GPUs. +# Writing 1/2-byte values to local memory can clobber adjacent bytes. +@inline _widen_type(::Type{T}) where T = sizeof(T) < 4 ? Int32 : T + # Reduce a value across a group, using local memory for communication @inline function reduce_group(op, val::T, neutral, ::Val{maxitems}) where {T, maxitems} items = get_local_size() item = get_local_id() - # local mem for a complete reduction - shared = oneLocalArray(T, (maxitems,)) - @inbounds shared[item] = val + # use a wider type for shared memory to avoid sub-word corruption + W = _widen_type(T) + shared = oneLocalArray(W, (maxitems,)) + @inbounds shared[item] = val % W # perform a reduction d = 1 @@ -20,18 +25,18 @@ index = 2 * d * (item-1) + 1 @inbounds if index <= items other_val = if index + d <= items - shared[index+d] + shared[index+d] % T else neutral end - shared[index] = op(shared[index], other_val) + shared[index] = op(shared[index] % T, other_val) % W end d *= 2 end # load the final value on the first item if item == 1 - val = @inbounds shared[item] + val = @inbounds shared[item] % T end return val @@ -135,8 +140,8 @@ function GPUArrays.mapreducedim!(f::F, op::OP, R::oneWrappedArray{T}, # that's why each items also loops across their inputs, processing multiple values # so that we can span the entire reduction dimension using a single item group. - # group size is restricted by local memory - max_lmem_elements = compute_properties(device()).maxSharedLocalMemory ÷ sizeof(T) + # group size is restricted by local memory (use widened type for sub-word types) + max_lmem_elements = compute_properties(device()).maxSharedLocalMemory ÷ sizeof(_widen_type(T)) max_items = min(compute_properties(device()).maxTotalGroupSize, compute_items(max_lmem_elements ÷ 2)) # TODO: dynamic local memory to avoid two compilations