Add oneMKL BLAS Level 1 copy support

Fix and add test for 'copy'

Fix onemklZcopy/onemklCcopy mapping errors and remove redundant test setup code in onemkl.jl test

Remove oneAPI.L0 check.

Remove using Test

Author: pengtu

deps/onemkl.cpp

@@ -81,6 +81,29 @@ extern "C" int onemklZgemm(syclQueue_t device_queue, onemklTranspose transA,
     return 0;
 }
 
+extern "C" void onemklDcopy(syclQueue_t device_queue, int64_t n, const double *x,
+                            int64_t incx, double *y, int64_t incy) {
+    oneapi::mkl::blas::column_major::copy(device_queue->val, n, x, incx, y, incy);
+}
+
+extern "C" void onemklScopy(syclQueue_t device_queue, int64_t n, const float *x,
+                            int64_t incx, float *y, int64_t incy) {
+    oneapi::mkl::blas::column_major::copy(device_queue->val, n, x, incx, y, incy);
+}
+
+extern "C" void onemklZcopy(syclQueue_t device_queue, int64_t n, const double _Complex *x,
+                            int64_t incx, double _Complex *y, int64_t incy) {
+    oneapi::mkl::blas::column_major::copy(device_queue->val, n,
+        reinterpret_cast<const std::complex<double> *>(x), incx,
+        reinterpret_cast<std::complex<double> *>(y), incy);
+}
+
+extern "C" void onemklCcopy(syclQueue_t device_queue, int64_t n, const float _Complex *x,
+                            int64_t incx, float _Complex *y, int64_t incy) {
+    oneapi::mkl::blas::column_major::copy(device_queue->val, n, 
+        reinterpret_cast<const std::complex<float> *>(x), incx, 
+        reinterpret_cast<std::complex<float> *>(y), incy);
+}
 
 // other
 

deps/onemkl.h

@@ -39,6 +39,15 @@ int onemklZgemm(syclQueue_t device_queue, onemklTranspose transA,
                 const double _Complex *B, int64_t ldb, double _Complex beta,
                 double _Complex *C, int64_t ldc);
 
+void onemklDcopy(syclQueue_t device_queue, int64_t n, const double *x,
+                 int64_t incx, double *y, int64_t incy);
+void onemklScopy(syclQueue_t device_queue, int64_t n, const float *x,
+                 int64_t incx, float *y, int64_t incy);
+void onemklZcopy(syclQueue_t device_queue, int64_t n, const double _Complex *x,
+                 int64_t incx, double _Complex *y, int64_t incy);
+void onemklCcopy(syclQueue_t device_queue, int64_t n, const float _Complex *x,
+                 int64_t incx, float _Complex *y, int64_t incy);
+
 void onemklDestroy();
 #ifdef __cplusplus
 }

lib/mkl/libonemkl.jl

@@ -41,3 +41,28 @@ function onemklZgemm(device_queue, transA, transB, m, n, k, alpha, A, lda, B, ld
                                     B::ZePtr{ComplexF64}, ldb::Int64, beta::ComplexF64,
                                     C::ZePtr{ComplexF64}, ldc::Int64)::Cint
 end
+
+function onemklDcopy(device_queue, n, x, incx, y, incy)
+    @ccall liboneapi_support.onemklDcopy(device_queue::syclQueue_t, n::Int64, 
+                                x::ZePtr{Cdouble}, incx::Int64,
+                                y::ZePtr{Cdouble}, incy::Int64)::Cvoid
+end
+
+function onemklScopy(device_queue, n, x, incx, y, incy)
+    @ccall liboneapi_support.onemklScopy(device_queue::syclQueue_t, n::Int64, 
+                                x::ZePtr{Cfloat}, incx::Int64,
+                                y::ZePtr{Cfloat}, incy::Int64)::Cvoid
+end
+
+function onemklZcopy(device_queue, n, x, incx, y, incy)
+    @ccall liboneapi_support.onemklZcopy(device_queue::syclQueue_t, n::Int64, 
+                                x::ZePtr{ComplexF64}, incx::Int64,
+                                y::ZePtr{ComplexF64}, incy::Int64)::Cvoid
+end
+
+function onemklCcopy(device_queue, n, x, incx, y, incy)
+    @ccall liboneapi_support.onemklCcopy(device_queue::syclQueue_t, n::Int64, 
+                                x::ZePtr{ComplexF32}, incx::Int64,
+                                y::ZePtr{ComplexF32}, incy::Int64)::Cvoid
+end
+

lib/mkl/wrappers.jl

@@ -20,6 +20,25 @@ end
 # BLAS
 #
 
+# level 1
+## copy
+for (fname, elty) in
+        ((:onemklDcopy,:Float64),
+         (:onemklScopy,:Float32),
+         (:onemklZcopy,:ComplexF64),
+         (:onemklCcopy,:ComplexF32))
+    @eval begin
+        function copy!(n::Integer,
+                       x::StridedArray{$elty},
+                       y::StridedArray{$elty})
+            queue = global_queue(context(x), device(x))
+            $fname(sycl_queue(queue), n, x, stride(x, 1), y, stride(y, 1))
+            y
+        end
+    end
+end
+
+
 # level 3
 
 for (fname, elty) in

test/onemkl.jl

@@ -0,0 +1,18 @@
+using oneAPI
+using oneAPI.oneMKL
+
+using LinearAlgebra
+
+m = 20
+n = 35
+k = 13
+
+############################################################################################
+@testset "level 1" begin
+    @testset for T in intersect(eltypes, [Float32, Float64, ComplexF32, ComplexF64])
+        A = oneArray(rand(T, m))
+        B = oneArray{T}(undef, m)
+        oneMKL.copy!(m,A,B)
+        @test Array(A) == Array(B)
+    end # level 1 testset
+end