diff --git a/src/NativeProviders/CUDA/blas.cpp b/src/NativeProviders/CUDA/blas.cpp index e9e363e8..92c69764 100644 --- a/src/NativeProviders/CUDA/blas.cpp +++ b/src/NativeProviders/CUDA/blas.cpp @@ -4,201 +4,173 @@ #include "wrapper_cuda.h" template -void cuda_axpy(const cublasHandle_t blasHandle, const int n, const T alpha, const T x[], int incX, T y[], int incY, AXPY axpy, cudaError_t *error, cublasStatus_t *blasStatus) +CudaResults cuda_axpy(const cublasHandle_t blasHandle, const int n, const T alpha, const T x[], int incX, T y[], int incY, AXPY axpy) { T *d_X = NULL; T *d_Y = NULL; - *error = cudaError_t::cudaSuccess; - *blasStatus = cublasStatus_t::CUBLAS_STATUS_SUCCESS; + CudaResults results; - SAFECUDACALL(error, cudaMalloc((void**)&d_X, n*sizeof(T))) - SAFECUDACALL(error, cudaMalloc((void**)&d_Y, n*sizeof(T))) + SAFECUDACALL(results.error, cudaMalloc((void**)&d_X, n*sizeof(T))); + SAFECUDACALL(results.error, cudaMalloc((void**)&d_Y, n*sizeof(T))); - SAFECUDACALL(blasStatus, cublasSetVector(n, sizeof(T), x, incX, d_X, incX)) - SAFECUDACALL(blasStatus, cublasSetVector(n, sizeof(T), y, incY, d_Y, incY)) + SAFECUDACALL(results.blasStatus, cublasSetVector(n, sizeof(T), x, incX, d_X, incX)); + SAFECUDACALL(results.blasStatus, cublasSetVector(n, sizeof(T), y, incY, d_Y, incY)); - SAFECUDACALL(blasStatus, axpy(blasHandle, n, &alpha, d_X, incX, d_Y, incX)) + SAFECUDACALL(results.blasStatus, axpy(blasHandle, n, &alpha, d_X, incX, d_Y, incX)); - SAFECUDACALL(blasStatus, cublasGetVector(n, sizeof(T), d_Y, incY, y, incY)) + SAFECUDACALL(results.blasStatus, cublasGetVector(n, sizeof(T), d_Y, incY, y, incY)); exit: cudaFree(d_X); cudaFree(d_Y); + + return results; } template -void cuda_scal(const cublasHandle_t blasHandle, const int n, const T alpha, T x[], int incX, SCAL scal, cudaError_t *error, cublasStatus_t *blasStatus) +CudaResults cuda_scal(const cublasHandle_t blasHandle, const int n, const T alpha, T x[], int incX, SCAL scal) { T *d_X = NULL; - *error = cudaError_t::cudaSuccess; - *blasStatus = cublasStatus_t::CUBLAS_STATUS_SUCCESS; + CudaResults results; - SAFECUDACALL(error, cudaMalloc((void**)&d_X, n*sizeof(T))) - SAFECUDACALL(blasStatus, cublasSetVector(n, sizeof(T), x, incX, d_X, incX)) - SAFECUDACALL(blasStatus, scal(blasHandle, n, &alpha, d_X, incX)) - SAFECUDACALL(blasStatus, cublasGetVector(n, sizeof(T), d_X, incX, x, incX)) + SAFECUDACALL(results.error, cudaMalloc((void**)&d_X, n*sizeof(T))); + SAFECUDACALL(results.blasStatus, cublasSetVector(n, sizeof(T), x, incX, d_X, incX)); + SAFECUDACALL(results.blasStatus, scal(blasHandle, n, &alpha, d_X, incX)); + SAFECUDACALL(results.blasStatus, cublasGetVector(n, sizeof(T), d_X, incX, x, incX)); exit: cudaFree(d_X); + + return results; } template -void cuda_dot(const cublasHandle_t blasHandle, const int n, const T x[], int incX, const T y[], int incY, T* result, DOT dot, cudaError_t *error, cublasStatus_t *blasStatus) +CudaResults cuda_dot(const cublasHandle_t blasHandle, const int n, const T x[], int incX, const T y[], int incY, T* result, DOT dot) { T *d_X = NULL; T *d_Y = NULL; - *error = cudaError_t::cudaSuccess; - *blasStatus = cublasStatus_t::CUBLAS_STATUS_SUCCESS; + CudaResults results; - SAFECUDACALL(error, cudaMalloc((void**)&d_X, n*sizeof(T))) - SAFECUDACALL(error, cudaMalloc((void**)&d_Y, n*sizeof(T))) + SAFECUDACALL(results.error, cudaMalloc((void**)&d_X, n*sizeof(T))); + SAFECUDACALL(results.error, cudaMalloc((void**)&d_Y, n*sizeof(T))); - SAFECUDACALL(blasStatus, cublasSetVector(n, sizeof(T), x, incX, d_X, incX)) - SAFECUDACALL(blasStatus, cublasSetVector(n, sizeof(T), y, incY, d_Y, incY)) + SAFECUDACALL(results.blasStatus, cublasSetVector(n, sizeof(T), x, incX, d_X, incX)); + SAFECUDACALL(results.blasStatus, cublasSetVector(n, sizeof(T), y, incY, d_Y, incY)); - SAFECUDACALL(blasStatus, dot(blasHandle, n, d_X, incX, d_Y, incY, result)) + SAFECUDACALL(results.blasStatus, dot(blasHandle, n, d_X, incX, d_Y, incY, result)); exit: cudaFree(d_X); cudaFree(d_Y); + + return results; } template -void cuda_gemm(const cublasHandle_t handle, const cublasOperation_t transa, const cublasOperation_t transb, int m, int n, int k, const T alpha, const T A[], int lda, const T B[], int ldb, const T beta, T C[], int ldc, GEMM gemm, cudaError_t *error, cublasStatus_t *blasStatus) +CudaResults cuda_gemm(const cublasHandle_t handle, const cublasOperation_t transa, const cublasOperation_t transb, int m, int n, int k, const T alpha, const T A[], int lda, const T B[], int ldb, const T beta, T C[], int ldc, GEMM gemm) { T *d_A = NULL; T *d_B = NULL; T *d_C = NULL; - *error = cudaError_t::cudaSuccess; - *blasStatus = cublasStatus_t::CUBLAS_STATUS_SUCCESS; + CudaResults results; - SAFECUDACALL(error, cudaMalloc((void**)&d_A, m*k*sizeof(T))) - SAFECUDACALL(blasStatus, cublasSetMatrix(m, k, sizeof(T), A, m, d_A, m)) + SAFECUDACALL(results.error, cudaMalloc((void**)&d_A, m*k*sizeof(T))); + SAFECUDACALL(results.blasStatus, cublasSetMatrix(m, k, sizeof(T), A, m, d_A, m)); - SAFECUDACALL(error, cudaMalloc((void**)&d_B, k*n*sizeof(T))) - SAFECUDACALL(blasStatus, cublasSetMatrix(k, n, sizeof(T), B, k, d_B, k)) + SAFECUDACALL(results.error, cudaMalloc((void**)&d_B, k*n*sizeof(T))); + SAFECUDACALL(results.blasStatus, cublasSetMatrix(k, n, sizeof(T), B, k, d_B, k)); - SAFECUDACALL(error, cudaMalloc((void**)&d_C, m*n*sizeof(T))) - SAFECUDACALL(blasStatus, cublasSetMatrix(m, n, sizeof(T), C, m, d_C, m)) + SAFECUDACALL(results.error, cudaMalloc((void**)&d_C, m*n*sizeof(T))); + SAFECUDACALL(results.blasStatus, cublasSetMatrix(m, n, sizeof(T), C, m, d_C, m)); - SAFECUDACALL(blasStatus, gemm(handle, transa, transb, m, n, k, &alpha, d_A, lda, d_B, ldb, &beta, d_C, ldc)) + SAFECUDACALL(results.blasStatus, gemm(handle, transa, transb, m, n, k, &alpha, d_A, lda, d_B, ldb, &beta, d_C, ldc)); - SAFECUDACALL(blasStatus, cublasGetMatrix(m, n, sizeof(T), d_C, m, C, m)) + SAFECUDACALL(results.blasStatus, cublasGetMatrix(m, n, sizeof(T), d_C, m, C, m)); exit: cudaFree(d_A); cudaFree(d_B); cudaFree(d_C); + + return results; } extern "C" { DLLEXPORT CudaResults s_axpy(const cublasHandle_t blasHandle, const int n, const float alpha, const float x[], float y[]){ - CudaResults ret; - cuda_axpy(blasHandle, n, alpha, x, 1, y, 1, cublasSaxpy, &ret.error, &ret.blasStatus); - return ret; + return cuda_axpy(blasHandle, n, alpha, x, 1, y, 1, cublasSaxpy); } DLLEXPORT CudaResults d_axpy(const cublasHandle_t blasHandle, const int n, const double alpha, const double x[], double y[]){ - CudaResults ret; - cuda_axpy(blasHandle, n, alpha, x, 1, y, 1, cublasDaxpy, &ret.error, &ret.blasStatus); - return ret; + return cuda_axpy(blasHandle, n, alpha, x, 1, y, 1, cublasDaxpy); } DLLEXPORT CudaResults c_axpy(const cublasHandle_t blasHandle, const int n, const cuComplex alpha, const cuComplex x[], cuComplex y[]){ - CudaResults ret; - cuda_axpy(blasHandle, n, alpha, x, 1, y, 1, cublasCaxpy, &ret.error, &ret.blasStatus); - return ret; + return cuda_axpy(blasHandle, n, alpha, x, 1, y, 1, cublasCaxpy); } DLLEXPORT CudaResults z_axpy(const cublasHandle_t blasHandle, const int n, const cuDoubleComplex alpha, const cuDoubleComplex x[], cuDoubleComplex y[]){ - CudaResults ret; - cuda_axpy(blasHandle, n, alpha, x, 1, y, 1, cublasZaxpy, &ret.error, &ret.blasStatus); - return ret; + return cuda_axpy(blasHandle, n, alpha, x, 1, y, 1, cublasZaxpy); } DLLEXPORT CudaResults s_scale(const cublasHandle_t blasHandle, const int n, const float alpha, float x[]){ - CudaResults ret; - cuda_scal(blasHandle, n, alpha, x, 1, cublasSscal, &ret.error, &ret.blasStatus); - return ret; + return cuda_scal(blasHandle, n, alpha, x, 1, cublasSscal); } DLLEXPORT CudaResults d_scale(const cublasHandle_t blasHandle, const int n, const double alpha, double x[]){ - CudaResults ret; - cuda_scal(blasHandle, n, alpha, x, 1, cublasDscal, &ret.error, &ret.blasStatus); - return ret; + return cuda_scal(blasHandle, n, alpha, x, 1, cublasDscal); } DLLEXPORT CudaResults c_scale(const cublasHandle_t blasHandle, const int n, const cuComplex alpha, cuComplex x[]){ - CudaResults ret; - cuda_scal(blasHandle, n, alpha, x, 1, cublasCscal, &ret.error, &ret.blasStatus); - return ret; + return cuda_scal(blasHandle, n, alpha, x, 1, cublasCscal); } DLLEXPORT CudaResults z_scale(const cublasHandle_t blasHandle, const int n, const cuDoubleComplex alpha, cuDoubleComplex x[]){ - CudaResults ret; - cuda_scal(blasHandle, n, alpha, x, 1, cublasZscal, &ret.error, &ret.blasStatus); - return ret; + return cuda_scal(blasHandle, n, alpha, x, 1, cublasZscal); } DLLEXPORT CudaResults s_dot_product(const cublasHandle_t blasHandle, const int n, const float x[], const float y[], float *result){ - CudaResults ret; - cuda_dot(blasHandle, n, x, 1, y, 1, result, cublasSdot, &ret.error, &ret.blasStatus); - return ret; + return cuda_dot(blasHandle, n, x, 1, y, 1, result, cublasSdot); } DLLEXPORT CudaResults d_dot_product(const cublasHandle_t blasHandle, const int n, const double x[], const double y[], double *result){ - CudaResults ret; - cuda_dot(blasHandle, n, x, 1, y, 1, result, cublasDdot, &ret.error, &ret.blasStatus); - return ret; + return cuda_dot(blasHandle, n, x, 1, y, 1, result, cublasDdot); } DLLEXPORT CudaResults c_dot_product(const cublasHandle_t blasHandle, const int n, const cuComplex x[], const cuComplex y[], cuComplex *result){ - CudaResults ret; - cuda_dot(blasHandle, n, x, 1, y, 1, result, cublasCdotu, &ret.error, &ret.blasStatus); - return ret; + return cuda_dot(blasHandle, n, x, 1, y, 1, result, cublasCdotu); } DLLEXPORT CudaResults z_dot_product(const cublasHandle_t blasHandle, const int n, const cuDoubleComplex x[], const cuDoubleComplex y[], cuDoubleComplex *result){ - CudaResults ret; - cuda_dot(blasHandle, n, x, 1, y, 1, result, cublasZdotu, &ret.error, &ret.blasStatus); - return ret; + return cuda_dot(blasHandle, n, x, 1, y, 1, result, cublasZdotu); } DLLEXPORT CudaResults s_matrix_multiply(const cublasHandle_t blasHandle, cublasOperation_t transA, cublasOperation_t transB, const int m, const int n, const int k, const float alpha, const float x[], const float y[], const float beta, float c[]){ - CudaResults ret; int lda = transA == CUBLAS_OP_N ? m : k; int ldb = transB == CUBLAS_OP_N ? k : n; - cuda_gemm(blasHandle, transA, transB, m, n, k, alpha, x, lda, y, ldb, beta, c, m, cublasSgemm, &ret.error, &ret.blasStatus); - return ret; + return cuda_gemm(blasHandle, transA, transB, m, n, k, alpha, x, lda, y, ldb, beta, c, m, cublasSgemm); } DLLEXPORT CudaResults d_matrix_multiply(const cublasHandle_t blasHandle, cublasOperation_t transA, cublasOperation_t transB, const int m, const int n, const int k, const double alpha, const double x[], const double y[], const double beta, double c[]){ - CudaResults ret; int lda = transA == CUBLAS_OP_N ? m : k; int ldb = transB == CUBLAS_OP_N ? k : n; - cuda_gemm(blasHandle, transA, transB, m, n, k, alpha, x, lda, y, ldb, beta, c, m, cublasDgemm, &ret.error, &ret.blasStatus); - return ret; + return cuda_gemm(blasHandle, transA, transB, m, n, k, alpha, x, lda, y, ldb, beta, c, m, cublasDgemm); } DLLEXPORT CudaResults c_matrix_multiply(const cublasHandle_t blasHandle, cublasOperation_t transA, cublasOperation_t transB, const int m, const int n, const int k, const cuComplex alpha, const cuComplex x[], const cuComplex y[], const cuComplex beta, cuComplex c[]){ - CudaResults ret; int lda = transA == CUBLAS_OP_N ? m : k; int ldb = transB == CUBLAS_OP_N ? k : n; - cuda_gemm(blasHandle, transA, transB, m, n, k, alpha, x, lda, y, ldb, beta, c, m, cublasCgemm, &ret.error, &ret.blasStatus); - return ret; + return cuda_gemm(blasHandle, transA, transB, m, n, k, alpha, x, lda, y, ldb, beta, c, m, cublasCgemm); } DLLEXPORT CudaResults z_matrix_multiply(const cublasHandle_t blasHandle, cublasOperation_t transA, cublasOperation_t transB, const int m, const int n, const int k, const cuDoubleComplex alpha, const cuDoubleComplex x[], const cuDoubleComplex y[], const cuDoubleComplex beta, cuDoubleComplex c[]){ - CudaResults ret; int lda = transA == CUBLAS_OP_N ? m : k; int ldb = transB == CUBLAS_OP_N ? k : n; - cuda_gemm(blasHandle, transA, transB, m, n, k, alpha, x, lda, y, ldb, beta, c, m, cublasZgemm, &ret.error, &ret.blasStatus); - return ret; + return cuda_gemm(blasHandle, transA, transB, m, n, k, alpha, x, lda, y, ldb, beta, c, m, cublasZgemm); } } diff --git a/src/NativeProviders/CUDA/capabilities.cpp b/src/NativeProviders/CUDA/capabilities.cpp index aa922577..f1a15370 100644 --- a/src/NativeProviders/CUDA/capabilities.cpp +++ b/src/NativeProviders/CUDA/capabilities.cpp @@ -1,4 +1,4 @@ -#include "wrapper_common.h" +#include "wrapper_cuda.h" #include "cuda_runtime.h" #include "cublas_v2.h" #include "cusolverDn.h" @@ -79,20 +79,28 @@ extern "C" { } } - DLLEXPORT cublasStatus_t createBLASHandle(cublasHandle_t *blasHandle){ - return cublasCreate(blasHandle); + DLLEXPORT CudaResults createBLASHandle(cublasHandle_t *blasHandle){ + CudaResults ret; + ret.blasStatus = cublasCreate(blasHandle); + return ret; } - DLLEXPORT cublasStatus_t destroyBLASHandle(cublasHandle_t blasHandle){ - return cublasDestroy(blasHandle); + DLLEXPORT CudaResults destroyBLASHandle(cublasHandle_t blasHandle){ + CudaResults ret; + ret.blasStatus = cublasDestroy(blasHandle); + return ret; } - DLLEXPORT cusolverStatus_t createSolverHandle(cusolverDnHandle_t *solverHandle){ - return cusolverDnCreate(solverHandle); + DLLEXPORT CudaResults createSolverHandle(cusolverDnHandle_t *solverHandle){ + CudaResults ret; + ret.solverStatus = cusolverDnCreate(solverHandle); + return ret; } - DLLEXPORT cusolverStatus_t destroySolverHandle(cusolverDnHandle_t solverHandle){ - return cusolverDnDestroy(solverHandle); + DLLEXPORT CudaResults destroySolverHandle(cusolverDnHandle_t solverHandle){ + CudaResults ret; + ret.solverStatus = cusolverDnDestroy(solverHandle); + return ret; } #ifdef __cplusplus diff --git a/src/NativeProviders/CUDA/wrapper_cuda.h b/src/NativeProviders/CUDA/wrapper_cuda.h index d20d15b2..adcdbe08 100644 --- a/src/NativeProviders/CUDA/wrapper_cuda.h +++ b/src/NativeProviders/CUDA/wrapper_cuda.h @@ -3,9 +3,10 @@ #include "wrapper_common.h" #include "cuda_runtime.h" +#include "cublas_v2.h" #include "cusolver_common.h" -#define SAFECUDACALL(error,call) {*error = call; if(*error){goto exit;}} +#define SAFECUDACALL(error,call) {error = call; if(error){goto exit;}} typedef struct { diff --git a/src/Numerics/Control.cs b/src/Numerics/Control.cs index f8475fd2..253dd62c 100644 --- a/src/Numerics/Control.cs +++ b/src/Numerics/Control.cs @@ -261,6 +261,10 @@ namespace MathNet.Numerics { value.InitializeVerify(); + // dispose the previous value if necessary + if (_linearAlgebraProvider != null && _linearAlgebraProvider is IDisposable) + (_linearAlgebraProvider as IDisposable).Dispose(); + // only actually set if verification did not throw _linearAlgebraProvider = value; } diff --git a/src/Numerics/Providers/LinearAlgebra/Cuda/CudaLinearAlgebraProvider.Complex.cs b/src/Numerics/Providers/LinearAlgebra/Cuda/CudaLinearAlgebraProvider.Complex.cs index 31abfbc5..c4a05a8b 100644 --- a/src/Numerics/Providers/LinearAlgebra/Cuda/CudaLinearAlgebraProvider.Complex.cs +++ b/src/Numerics/Providers/LinearAlgebra/Cuda/CudaLinearAlgebraProvider.Complex.cs @@ -68,7 +68,9 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda throw new ArgumentException(Resources.ArgumentArraysSameLength); } - return SafeNativeMethods.z_dot_product(_blasHandle, x.Length, x, y); + Complex result = 0; + HandleResults(SafeNativeMethods.z_dot_product(_blasHandle, x.Length, x, y, ref result)); + return result; } /// @@ -107,7 +109,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda return; } - SafeNativeMethods.z_axpy(_blasHandle, y.Length, alpha, x, result); + HandleResults(SafeNativeMethods.z_axpy(_blasHandle, y.Length, alpha, x, result)); } /// @@ -135,7 +137,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda return; } - SafeNativeMethods.z_scale(_blasHandle, x.Length, alpha, result); + HandleResults(SafeNativeMethods.z_scale(_blasHandle, x.Length, alpha, result)); } /// @@ -202,7 +204,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda throw new ArgumentException(Resources.ArgumentMatrixDimensions); } - SafeNativeMethods.z_matrix_multiply(_blasHandle, transposeA.ToCUDA(), transposeB.ToCUDA(), m, n, k, alpha, a, b, beta, c); + HandleResults(SafeNativeMethods.z_matrix_multiply(_blasHandle, transposeA.ToCUDA(), transposeB.ToCUDA(), m, n, k, alpha, a, b, beta, c)); } /// @@ -237,7 +239,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda throw new ArgumentException(Resources.ArgumentArraysSameLength, "ipiv"); } - Solver(SafeNativeMethods.z_lu_factor(_solverHandle, order, data, ipiv)); + HandleResults(SafeNativeMethods.z_lu_factor(_solverHandle, order, data, ipiv)); } /// @@ -259,7 +261,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda throw new ArgumentException(Resources.ArgumentArraysSameLength, "a"); } - Solver(SafeNativeMethods.z_lu_inverse(_solverHandle, _blasHandle, order, a)); + HandleResults(SafeNativeMethods.z_lu_inverse(_solverHandle, _blasHandle, order, a)); } /// @@ -292,7 +294,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda throw new ArgumentException(Resources.ArgumentArraysSameLength, "ipiv"); } - BLAS(SafeNativeMethods.z_lu_inverse_factored(_blasHandle, order, a, ipiv)); + HandleResults(SafeNativeMethods.z_lu_inverse_factored(_blasHandle, order, a, ipiv)); } /// @@ -320,7 +322,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda throw new ArgumentException(Resources.UserWorkBufferNotSupported); } - Solver(SafeNativeMethods.z_lu_inverse(_solverHandle, _blasHandle, order, a)); + HandleResults(SafeNativeMethods.z_lu_inverse(_solverHandle, _blasHandle, order, a)); } /// @@ -359,7 +361,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda throw new ArgumentException(Resources.UserWorkBufferNotSupported); } - BLAS(SafeNativeMethods.z_lu_inverse_factored(_blasHandle, order, a, ipiv)); + HandleResults(SafeNativeMethods.z_lu_inverse_factored(_blasHandle, order, a, ipiv)); } /// @@ -393,7 +395,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda throw new ArgumentException(Resources.ArgumentReferenceDifferent); } - Solver(SafeNativeMethods.z_lu_solve(_solverHandle, order, columnsOfB, a, b)); + HandleResults(SafeNativeMethods.z_lu_solve(_solverHandle, order, columnsOfB, a, b)); } /// @@ -438,7 +440,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda throw new ArgumentException(Resources.ArgumentReferenceDifferent); } - Solver(SafeNativeMethods.z_lu_solve_factored(_solverHandle, order, columnsOfB, a, ipiv, b)); + HandleResults(SafeNativeMethods.z_lu_solve_factored(_solverHandle, order, columnsOfB, a, ipiv, b)); } /// @@ -466,7 +468,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda throw new ArgumentException(Resources.ArgumentArraysSameLength, "a"); } - Solver(SafeNativeMethods.z_cholesky_factor(_solverHandle, order, a)); + HandleResults(SafeNativeMethods.z_cholesky_factor(_solverHandle, order, a)); } /// @@ -501,7 +503,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda throw new ArgumentException(Resources.ArgumentReferenceDifferent); } - Solver(SafeNativeMethods.z_cholesky_solve(_solverHandle, orderA, columnsB, a, b)); + HandleResults(SafeNativeMethods.z_cholesky_solve(_solverHandle, orderA, columnsB, a, b)); } /// @@ -535,7 +537,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda throw new ArgumentException(Resources.ArgumentReferenceDifferent); } - Solver(SafeNativeMethods.z_cholesky_solve_factored(_solverHandle, orderA, columnsB, a, b)); + HandleResults(SafeNativeMethods.z_cholesky_solve_factored(_solverHandle, orderA, columnsB, a, b)); } /// @@ -697,7 +699,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda if (columnsA > rowsA || !computeVectors) // see remarks http://docs.nvidia.com/cuda/cusolver/index.html#cuds-lt-t-gt-gesvd base.SingularValueDecomposition(computeVectors, a, rowsA, columnsA, s, u, vt, new Complex[rowsA]); - else Solver(SafeNativeMethods.z_svd_factor(_solverHandle, computeVectors, rowsA, columnsA, a, s, u, vt)); + else HandleResults(SafeNativeMethods.z_svd_factor(_solverHandle, computeVectors, rowsA, columnsA, a, s, u, vt)); } } } diff --git a/src/Numerics/Providers/LinearAlgebra/Cuda/CudaLinearAlgebraProvider.Complex32.cs b/src/Numerics/Providers/LinearAlgebra/Cuda/CudaLinearAlgebraProvider.Complex32.cs index 81679c15..54ebefe4 100644 --- a/src/Numerics/Providers/LinearAlgebra/Cuda/CudaLinearAlgebraProvider.Complex32.cs +++ b/src/Numerics/Providers/LinearAlgebra/Cuda/CudaLinearAlgebraProvider.Complex32.cs @@ -68,7 +68,9 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda throw new ArgumentException(Resources.ArgumentArraysSameLength); } - return SafeNativeMethods.c_dot_product(_blasHandle, x.Length, x, y); + Complex32 result = 0; + HandleResults(SafeNativeMethods.c_dot_product(_blasHandle, x.Length, x, y, ref result)); + return result; } /// @@ -107,7 +109,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda return; } - SafeNativeMethods.c_axpy(_blasHandle, y.Length, alpha, x, result); + HandleResults(SafeNativeMethods.c_axpy(_blasHandle, y.Length, alpha, x, result)); } /// @@ -135,7 +137,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda return; } - SafeNativeMethods.c_scale(_blasHandle, x.Length, alpha, result); + HandleResults(SafeNativeMethods.c_scale(_blasHandle, x.Length, alpha, result)); } /// @@ -202,7 +204,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda throw new ArgumentException(Resources.ArgumentMatrixDimensions); } - SafeNativeMethods.c_matrix_multiply(_blasHandle, transposeA.ToCUDA(), transposeB.ToCUDA(), m, n, k, alpha, a, b, beta, c); + HandleResults(SafeNativeMethods.c_matrix_multiply(_blasHandle, transposeA.ToCUDA(), transposeB.ToCUDA(), m, n, k, alpha, a, b, beta, c)); } /// @@ -237,7 +239,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda throw new ArgumentException(Resources.ArgumentArraysSameLength, "ipiv"); } - Solver(SafeNativeMethods.c_lu_factor(_solverHandle, order, data, ipiv)); + HandleResults(SafeNativeMethods.c_lu_factor(_solverHandle, order, data, ipiv)); } /// @@ -259,7 +261,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda throw new ArgumentException(Resources.ArgumentArraysSameLength, "a"); } - Solver(SafeNativeMethods.c_lu_inverse(_solverHandle, _blasHandle, order, a)); + HandleResults(SafeNativeMethods.c_lu_inverse(_solverHandle, _blasHandle, order, a)); } /// @@ -292,7 +294,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda throw new ArgumentException(Resources.ArgumentArraysSameLength, "ipiv"); } - BLAS(SafeNativeMethods.c_lu_inverse_factored(_blasHandle, order, a, ipiv)); + HandleResults(SafeNativeMethods.c_lu_inverse_factored(_blasHandle, order, a, ipiv)); } /// @@ -320,7 +322,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda throw new ArgumentException(Resources.UserWorkBufferNotSupported); } - Solver(SafeNativeMethods.c_lu_inverse(_solverHandle, _blasHandle, order, a)); + HandleResults(SafeNativeMethods.c_lu_inverse(_solverHandle, _blasHandle, order, a)); } /// @@ -359,7 +361,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda throw new ArgumentException(Resources.UserWorkBufferNotSupported); } - BLAS(SafeNativeMethods.c_lu_inverse_factored(_blasHandle, order, a, ipiv)); + HandleResults(SafeNativeMethods.c_lu_inverse_factored(_blasHandle, order, a, ipiv)); } /// @@ -393,7 +395,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda throw new ArgumentException(Resources.ArgumentReferenceDifferent); } - Solver(SafeNativeMethods.c_lu_solve(_solverHandle, order, columnsOfB, a, b)); + HandleResults(SafeNativeMethods.c_lu_solve(_solverHandle, order, columnsOfB, a, b)); } /// @@ -438,7 +440,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda throw new ArgumentException(Resources.ArgumentReferenceDifferent); } - Solver(SafeNativeMethods.c_lu_solve_factored(_solverHandle, order, columnsOfB, a, ipiv, b)); + HandleResults(SafeNativeMethods.c_lu_solve_factored(_solverHandle, order, columnsOfB, a, ipiv, b)); } /// @@ -466,7 +468,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda throw new ArgumentException(Resources.ArgumentArraysSameLength, "a"); } - Solver(SafeNativeMethods.c_cholesky_factor(_solverHandle, order, a)); + HandleResults(SafeNativeMethods.c_cholesky_factor(_solverHandle, order, a)); } /// @@ -501,7 +503,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda throw new ArgumentException(Resources.ArgumentReferenceDifferent); } - Solver(SafeNativeMethods.c_cholesky_solve(_solverHandle, orderA, columnsB, a, b)); + HandleResults(SafeNativeMethods.c_cholesky_solve(_solverHandle, orderA, columnsB, a, b)); } /// @@ -535,7 +537,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda throw new ArgumentException(Resources.ArgumentReferenceDifferent); } - Solver(SafeNativeMethods.c_cholesky_solve_factored(_solverHandle, orderA, columnsB, a, b)); + HandleResults(SafeNativeMethods.c_cholesky_solve_factored(_solverHandle, orderA, columnsB, a, b)); } /// @@ -697,7 +699,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda if (columnsA > rowsA || !computeVectors) // see remarks http://docs.nvidia.com/cuda/cusolver/index.html#cuds-lt-t-gt-gesvd base.SingularValueDecomposition(computeVectors, a, rowsA, columnsA, s, u, vt, new Complex32[rowsA]); - else Solver(SafeNativeMethods.c_svd_factor(_solverHandle, computeVectors, rowsA, columnsA, a, s, u, vt)); + else HandleResults(SafeNativeMethods.c_svd_factor(_solverHandle, computeVectors, rowsA, columnsA, a, s, u, vt)); } } } diff --git a/src/Numerics/Providers/LinearAlgebra/Cuda/CudaLinearAlgebraProvider.Double.cs b/src/Numerics/Providers/LinearAlgebra/Cuda/CudaLinearAlgebraProvider.Double.cs index 6e73ed46..03ba9c03 100644 --- a/src/Numerics/Providers/LinearAlgebra/Cuda/CudaLinearAlgebraProvider.Double.cs +++ b/src/Numerics/Providers/LinearAlgebra/Cuda/CudaLinearAlgebraProvider.Double.cs @@ -68,7 +68,9 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda throw new ArgumentException(Resources.ArgumentArraysSameLength); } - return SafeNativeMethods.d_dot_product(_blasHandle, x.Length, x, y); + double result = 0; + HandleResults(SafeNativeMethods.d_dot_product(_blasHandle, x.Length, x, y, ref result)); + return result; } /// @@ -107,7 +109,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda return; } - SafeNativeMethods.d_axpy(_blasHandle, y.Length, alpha, x, result); + HandleResults(SafeNativeMethods.d_axpy(_blasHandle, y.Length, alpha, x, result)); } /// @@ -135,7 +137,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda return; } - SafeNativeMethods.d_scale(_blasHandle, x.Length, alpha, result); + HandleResults(SafeNativeMethods.d_scale(_blasHandle, x.Length, alpha, result)); } /// @@ -202,7 +204,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda throw new ArgumentException(Resources.ArgumentMatrixDimensions); } - SafeNativeMethods.d_matrix_multiply(_blasHandle, transposeA.ToCUDA(), transposeB.ToCUDA(), m, n, k, alpha, a, b, beta, c); + HandleResults(SafeNativeMethods.d_matrix_multiply(_blasHandle, transposeA.ToCUDA(), transposeB.ToCUDA(), m, n, k, alpha, a, b, beta, c)); } /// @@ -237,7 +239,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda throw new ArgumentException(Resources.ArgumentArraysSameLength, "ipiv"); } - Solver(SafeNativeMethods.d_lu_factor(_solverHandle, order, data, ipiv)); + HandleResults(SafeNativeMethods.d_lu_factor(_solverHandle, order, data, ipiv)); } /// @@ -259,7 +261,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda throw new ArgumentException(Resources.ArgumentArraysSameLength, "a"); } - Solver(SafeNativeMethods.d_lu_inverse(_solverHandle, _blasHandle, order, a)); + HandleResults(SafeNativeMethods.d_lu_inverse(_solverHandle, _blasHandle, order, a)); } /// @@ -292,7 +294,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda throw new ArgumentException(Resources.ArgumentArraysSameLength, "ipiv"); } - BLAS(SafeNativeMethods.d_lu_inverse_factored(_blasHandle, order, a, ipiv)); + HandleResults(SafeNativeMethods.d_lu_inverse_factored(_blasHandle, order, a, ipiv)); } /// @@ -320,7 +322,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda throw new ArgumentException(Resources.UserWorkBufferNotSupported); } - Solver(SafeNativeMethods.d_lu_inverse(_solverHandle, _blasHandle, order, a)); + HandleResults(SafeNativeMethods.d_lu_inverse(_solverHandle, _blasHandle, order, a)); } /// @@ -359,7 +361,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda throw new ArgumentException(Resources.UserWorkBufferNotSupported); } - BLAS(SafeNativeMethods.d_lu_inverse_factored(_blasHandle, order, a, ipiv)); + HandleResults(SafeNativeMethods.d_lu_inverse_factored(_blasHandle, order, a, ipiv)); } /// @@ -393,7 +395,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda throw new ArgumentException(Resources.ArgumentReferenceDifferent); } - Solver(SafeNativeMethods.d_lu_solve(_solverHandle, order, columnsOfB, a, b)); + HandleResults(SafeNativeMethods.d_lu_solve(_solverHandle, order, columnsOfB, a, b)); } /// @@ -438,7 +440,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda throw new ArgumentException(Resources.ArgumentReferenceDifferent); } - Solver(SafeNativeMethods.d_lu_solve_factored(_solverHandle, order, columnsOfB, a, ipiv, b)); + HandleResults(SafeNativeMethods.d_lu_solve_factored(_solverHandle, order, columnsOfB, a, ipiv, b)); } /// @@ -466,7 +468,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda throw new ArgumentException(Resources.ArgumentArraysSameLength, "a"); } - Solver(SafeNativeMethods.d_cholesky_factor(_solverHandle, order, a)); + HandleResults(SafeNativeMethods.d_cholesky_factor(_solverHandle, order, a)); } /// @@ -501,7 +503,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda throw new ArgumentException(Resources.ArgumentReferenceDifferent); } - Solver(SafeNativeMethods.d_cholesky_solve(_solverHandle, orderA, columnsB, a, b)); + HandleResults(SafeNativeMethods.d_cholesky_solve(_solverHandle, orderA, columnsB, a, b)); } /// @@ -535,7 +537,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda throw new ArgumentException(Resources.ArgumentReferenceDifferent); } - Solver(SafeNativeMethods.d_cholesky_solve_factored(_solverHandle, orderA, columnsB, a, b)); + HandleResults(SafeNativeMethods.d_cholesky_solve_factored(_solverHandle, orderA, columnsB, a, b)); } /// @@ -697,7 +699,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda if (columnsA > rowsA || !computeVectors) // see remarks http://docs.nvidia.com/cuda/cusolver/index.html#cuds-lt-t-gt-gesvd base.SingularValueDecomposition(computeVectors, a, rowsA, columnsA, s, u, vt, new double[rowsA]); - else Solver (SafeNativeMethods.d_svd_factor(_solverHandle, computeVectors, rowsA, columnsA, a, s, u, vt)); + else HandleResults(SafeNativeMethods.d_svd_factor(_solverHandle, computeVectors, rowsA, columnsA, a, s, u, vt)); } } } diff --git a/src/Numerics/Providers/LinearAlgebra/Cuda/CudaLinearAlgebraProvider.Single.cs b/src/Numerics/Providers/LinearAlgebra/Cuda/CudaLinearAlgebraProvider.Single.cs index 0ac4e34f..8ede7033 100644 --- a/src/Numerics/Providers/LinearAlgebra/Cuda/CudaLinearAlgebraProvider.Single.cs +++ b/src/Numerics/Providers/LinearAlgebra/Cuda/CudaLinearAlgebraProvider.Single.cs @@ -68,7 +68,9 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda throw new ArgumentException(Resources.ArgumentArraysSameLength); } - return SafeNativeMethods.s_dot_product(_blasHandle, x.Length, x, y); + float result = 0; + HandleResults(SafeNativeMethods.s_dot_product(_blasHandle, x.Length, x, y, ref result)); + return result; } /// @@ -107,7 +109,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda return; } - SafeNativeMethods.s_axpy(_blasHandle, y.Length, alpha, x, result); + HandleResults(SafeNativeMethods.s_axpy(_blasHandle, y.Length, alpha, x, result)); } /// @@ -135,7 +137,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda return; } - SafeNativeMethods.s_scale(_blasHandle, x.Length, alpha, result); + HandleResults(SafeNativeMethods.s_scale(_blasHandle, x.Length, alpha, result)); } /// @@ -202,7 +204,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda throw new ArgumentException(Resources.ArgumentMatrixDimensions); } - SafeNativeMethods.s_matrix_multiply(_blasHandle, transposeA.ToCUDA(), transposeB.ToCUDA(), m, n, k, alpha, a, b, beta, c); + HandleResults(SafeNativeMethods.s_matrix_multiply(_blasHandle, transposeA.ToCUDA(), transposeB.ToCUDA(), m, n, k, alpha, a, b, beta, c)); } /// @@ -237,7 +239,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda throw new ArgumentException(Resources.ArgumentArraysSameLength, "ipiv"); } - Solver(SafeNativeMethods.s_lu_factor(_solverHandle, order, data, ipiv)); + HandleResults(SafeNativeMethods.s_lu_factor(_solverHandle, order, data, ipiv)); } /// @@ -259,7 +261,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda throw new ArgumentException(Resources.ArgumentArraysSameLength, "a"); } - Solver(SafeNativeMethods.s_lu_inverse(_solverHandle, _blasHandle, order, a)); + HandleResults(SafeNativeMethods.s_lu_inverse(_solverHandle, _blasHandle, order, a)); } /// @@ -292,7 +294,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda throw new ArgumentException(Resources.ArgumentArraysSameLength, "ipiv"); } - BLAS(SafeNativeMethods.s_lu_inverse_factored(_blasHandle, order, a, ipiv)); + HandleResults(SafeNativeMethods.s_lu_inverse_factored(_blasHandle, order, a, ipiv)); } /// @@ -320,7 +322,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda throw new ArgumentException(Resources.UserWorkBufferNotSupported); } - Solver(SafeNativeMethods.s_lu_inverse(_solverHandle, _blasHandle, order, a)); + HandleResults(SafeNativeMethods.s_lu_inverse(_solverHandle, _blasHandle, order, a)); } /// @@ -359,7 +361,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda throw new ArgumentException(Resources.UserWorkBufferNotSupported); } - BLAS(SafeNativeMethods.s_lu_inverse_factored(_blasHandle, order, a, ipiv)); + HandleResults(SafeNativeMethods.s_lu_inverse_factored(_blasHandle, order, a, ipiv)); } /// @@ -393,7 +395,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda throw new ArgumentException(Resources.ArgumentReferenceDifferent); } - Solver(SafeNativeMethods.s_lu_solve(_solverHandle, order, columnsOfB, a, b)); + HandleResults(SafeNativeMethods.s_lu_solve(_solverHandle, order, columnsOfB, a, b)); } /// @@ -438,7 +440,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda throw new ArgumentException(Resources.ArgumentReferenceDifferent); } - Solver(SafeNativeMethods.s_lu_solve_factored(_solverHandle, order, columnsOfB, a, ipiv, b)); + HandleResults(SafeNativeMethods.s_lu_solve_factored(_solverHandle, order, columnsOfB, a, ipiv, b)); } /// @@ -466,7 +468,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda throw new ArgumentException(Resources.ArgumentArraysSameLength, "a"); } - Solver(SafeNativeMethods.s_cholesky_factor(_solverHandle, order, a)); + HandleResults(SafeNativeMethods.s_cholesky_factor(_solverHandle, order, a)); } /// @@ -501,7 +503,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda throw new ArgumentException(Resources.ArgumentReferenceDifferent); } - Solver(SafeNativeMethods.s_cholesky_solve(_solverHandle, orderA, columnsB, a, b)); + HandleResults(SafeNativeMethods.s_cholesky_solve(_solverHandle, orderA, columnsB, a, b)); } /// @@ -535,7 +537,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda throw new ArgumentException(Resources.ArgumentReferenceDifferent); } - Solver(SafeNativeMethods.s_cholesky_solve_factored(_solverHandle, orderA, columnsB, a, b)); + HandleResults(SafeNativeMethods.s_cholesky_solve_factored(_solverHandle, orderA, columnsB, a, b)); } /// @@ -697,7 +699,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda if (columnsA > rowsA || !computeVectors) // see remarks http://docs.nvidia.com/cuda/cusolver/index.html#cuds-lt-t-gt-gesvd base.SingularValueDecomposition(computeVectors, a, rowsA, columnsA, s, u, vt, new float[rowsA]); - else Solver(SafeNativeMethods.s_svd_factor(_solverHandle, computeVectors, rowsA, columnsA, a, s, u, vt)); + else HandleResults(SafeNativeMethods.s_svd_factor(_solverHandle, computeVectors, rowsA, columnsA, a, s, u, vt)); } } } diff --git a/src/Numerics/Providers/LinearAlgebra/Cuda/CudaLinearAlgebraProvider.cs b/src/Numerics/Providers/LinearAlgebra/Cuda/CudaLinearAlgebraProvider.cs index e27b38d9..52c016b8 100644 --- a/src/Numerics/Providers/LinearAlgebra/Cuda/CudaLinearAlgebraProvider.cs +++ b/src/Numerics/Providers/LinearAlgebra/Cuda/CudaLinearAlgebraProvider.cs @@ -104,9 +104,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda public override string ToString() { - return string.Format("Nvidia CUDA ({1}; revision {0})", - _nativeRevision, - _nativeIX86 ? "x86" : _nativeX64 ? "x64" : _nativeIA64 ? "IA64" : "unknown"); + return string.Format("Nvidia CUDA ({1}; compute capability {0})", _nativeRevision, _nativeIX86 ? "x86" : _nativeX64 ? "x64" : _nativeIA64 ? "IA64" : "unknown"); } diff --git a/src/Numerics/Providers/LinearAlgebra/Cuda/CudaResults.cs b/src/Numerics/Providers/LinearAlgebra/Cuda/CudaResults.cs index 4752de7c..4b0cc35b 100644 --- a/src/Numerics/Providers/LinearAlgebra/Cuda/CudaResults.cs +++ b/src/Numerics/Providers/LinearAlgebra/Cuda/CudaResults.cs @@ -38,7 +38,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda /// /// Struct containing the various results from different CUDA API calls. /// - private struct CudaResults + internal struct CudaResults { /// /// Maps to cudaError_t diff --git a/src/Numerics/Providers/LinearAlgebra/Cuda/SafeNativeMethods.cs b/src/Numerics/Providers/LinearAlgebra/Cuda/SafeNativeMethods.cs index 66937ac9..cca58c52 100644 --- a/src/Numerics/Providers/LinearAlgebra/Cuda/SafeNativeMethods.cs +++ b/src/Numerics/Providers/LinearAlgebra/Cuda/SafeNativeMethods.cs @@ -150,100 +150,100 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda //internal static extern double z_matrix_norm(byte norm, int rows, int columns, [In] Complex[] a, [In, Out] double[] work); [DllImport(_DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)] - internal static extern int s_cholesky_factor(IntPtr solverHandle, int n, [In, Out] float[] a); + internal static extern CudaResults s_cholesky_factor(IntPtr solverHandle, int n, [In, Out] float[] a); [DllImport(_DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)] - internal static extern int d_cholesky_factor(IntPtr solverHandle, int n, [In, Out] double[] a); + internal static extern CudaResults d_cholesky_factor(IntPtr solverHandle, int n, [In, Out] double[] a); [DllImport(_DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)] - internal static extern int c_cholesky_factor(IntPtr solverHandle, int n, [In, Out] Complex32[] a); + internal static extern CudaResults c_cholesky_factor(IntPtr solverHandle, int n, [In, Out] Complex32[] a); [DllImport(_DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)] - internal static extern int z_cholesky_factor(IntPtr solverHandle, int n, [In, Out] Complex[] a); + internal static extern CudaResults z_cholesky_factor(IntPtr solverHandle, int n, [In, Out] Complex[] a); [DllImport(_DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)] - internal static extern int s_lu_factor(IntPtr solverHandle, int n, [In, Out] float[] a, [In, Out] int[] ipiv); + internal static extern CudaResults s_lu_factor(IntPtr solverHandle, int n, [In, Out] float[] a, [In, Out] int[] ipiv); [DllImport(_DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)] - internal static extern int d_lu_factor(IntPtr solverHandle, int n, [In, Out] double[] a, [In, Out] int[] ipiv); + internal static extern CudaResults d_lu_factor(IntPtr solverHandle, int n, [In, Out] double[] a, [In, Out] int[] ipiv); [DllImport(_DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)] - internal static extern int c_lu_factor(IntPtr solverHandle, int n, [In, Out] Complex32[] a, [In, Out] int[] ipiv); + internal static extern CudaResults c_lu_factor(IntPtr solverHandle, int n, [In, Out] Complex32[] a, [In, Out] int[] ipiv); [DllImport(_DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)] - internal static extern int z_lu_factor(IntPtr solverHandle, int n, [In, Out] Complex[] a, [In, Out] int[] ipiv); + internal static extern CudaResults z_lu_factor(IntPtr solverHandle, int n, [In, Out] Complex[] a, [In, Out] int[] ipiv); [DllImport(_DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)] - internal static extern int s_lu_inverse(IntPtr solverHandle, IntPtr blasHandle, int n, [In, Out] float[] a); + internal static extern CudaResults s_lu_inverse(IntPtr solverHandle, IntPtr blasHandle, int n, [In, Out] float[] a); [DllImport(_DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)] - internal static extern int d_lu_inverse(IntPtr solverHandle, IntPtr blasHandle, int n, [In, Out] double[] a); + internal static extern CudaResults d_lu_inverse(IntPtr solverHandle, IntPtr blasHandle, int n, [In, Out] double[] a); [DllImport(_DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)] - internal static extern int c_lu_inverse(IntPtr solverHandle, IntPtr blasHandle, int n, [In, Out] Complex32[] a); + internal static extern CudaResults c_lu_inverse(IntPtr solverHandle, IntPtr blasHandle, int n, [In, Out] Complex32[] a); [DllImport(_DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)] - internal static extern int z_lu_inverse(IntPtr solverHandle, IntPtr blasHandle, int n, [In, Out] Complex[] a); + internal static extern CudaResults z_lu_inverse(IntPtr solverHandle, IntPtr blasHandle, int n, [In, Out] Complex[] a); [DllImport(_DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)] - internal static extern int s_lu_inverse_factored(IntPtr blasHandle, int n, [In, Out] float[] a, [In, Out] int[] ipiv); + internal static extern CudaResults s_lu_inverse_factored(IntPtr blasHandle, int n, [In, Out] float[] a, [In, Out] int[] ipiv); [DllImport(_DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)] - internal static extern int d_lu_inverse_factored(IntPtr blasHandle, int n, [In, Out] double[] a, [In, Out] int[] ipiv); + internal static extern CudaResults d_lu_inverse_factored(IntPtr blasHandle, int n, [In, Out] double[] a, [In, Out] int[] ipiv); [DllImport(_DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)] - internal static extern int c_lu_inverse_factored(IntPtr blasHandle, int n, [In, Out] Complex32[] a, [In, Out] int[] ipiv); + internal static extern CudaResults c_lu_inverse_factored(IntPtr blasHandle, int n, [In, Out] Complex32[] a, [In, Out] int[] ipiv); [DllImport(_DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)] - internal static extern int z_lu_inverse_factored(IntPtr blasHandle, int n, [In, Out] Complex[] a, [In, Out] int[] ipiv); + internal static extern CudaResults z_lu_inverse_factored(IntPtr blasHandle, int n, [In, Out] Complex[] a, [In, Out] int[] ipiv); [DllImport(_DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)] - internal static extern int s_lu_solve_factored(IntPtr solverHandle, int n, int nrhs, float[] a, [In, Out] int[] ipiv, [In, Out] float[] b); + internal static extern CudaResults s_lu_solve_factored(IntPtr solverHandle, int n, int nrhs, float[] a, [In, Out] int[] ipiv, [In, Out] float[] b); [DllImport(_DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)] - internal static extern int d_lu_solve_factored(IntPtr solverHandle, int n, int nrhs, double[] a, [In, Out] int[] ipiv, [In, Out] double[] b); + internal static extern CudaResults d_lu_solve_factored(IntPtr solverHandle, int n, int nrhs, double[] a, [In, Out] int[] ipiv, [In, Out] double[] b); [DllImport(_DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)] - internal static extern int c_lu_solve_factored(IntPtr solverHandle, int n, int nrhs, Complex32[] a, [In, Out] int[] ipiv, [In, Out] Complex32[] b); + internal static extern CudaResults c_lu_solve_factored(IntPtr solverHandle, int n, int nrhs, Complex32[] a, [In, Out] int[] ipiv, [In, Out] Complex32[] b); [DllImport(_DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)] - internal static extern int z_lu_solve_factored(IntPtr solverHandle, int n, int nrhs, Complex[] a, [In, Out] int[] ipiv, [In, Out] Complex[] b); + internal static extern CudaResults z_lu_solve_factored(IntPtr solverHandle, int n, int nrhs, Complex[] a, [In, Out] int[] ipiv, [In, Out] Complex[] b); [DllImport(_DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)] - internal static extern int s_lu_solve(IntPtr solverHandle, int n, int nrhs, float[] a, [In, Out] float[] b); + internal static extern CudaResults s_lu_solve(IntPtr solverHandle, int n, int nrhs, float[] a, [In, Out] float[] b); [DllImport(_DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)] - internal static extern int d_lu_solve(IntPtr solverHandle, int n, int nrhs, double[] a, [In, Out] double[] b); + internal static extern CudaResults d_lu_solve(IntPtr solverHandle, int n, int nrhs, double[] a, [In, Out] double[] b); [DllImport(_DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)] - internal static extern int c_lu_solve(IntPtr solverHandle, int n, int nrhs, Complex32[] a, [In, Out] Complex32[] b); + internal static extern CudaResults c_lu_solve(IntPtr solverHandle, int n, int nrhs, Complex32[] a, [In, Out] Complex32[] b); [DllImport(_DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)] - internal static extern int z_lu_solve(IntPtr solverHandle, int n, int nrhs, Complex[] a, [In, Out] Complex[] b); + internal static extern CudaResults z_lu_solve(IntPtr solverHandle, int n, int nrhs, Complex[] a, [In, Out] Complex[] b); [DllImport(_DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)] - internal static extern int s_cholesky_solve(IntPtr solverHandle, int n, int nrhs, float[] a, [In, Out] float[] b); + internal static extern CudaResults s_cholesky_solve(IntPtr solverHandle, int n, int nrhs, float[] a, [In, Out] float[] b); [DllImport(_DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)] - internal static extern int d_cholesky_solve(IntPtr solverHandle, int n, int nrhs, double[] a, [In, Out] double[] b); + internal static extern CudaResults d_cholesky_solve(IntPtr solverHandle, int n, int nrhs, double[] a, [In, Out] double[] b); [DllImport(_DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)] - internal static extern int c_cholesky_solve(IntPtr solverHandle, int n, int nrhs, Complex32[] a, [In, Out] Complex32[] b); + internal static extern CudaResults c_cholesky_solve(IntPtr solverHandle, int n, int nrhs, Complex32[] a, [In, Out] Complex32[] b); [DllImport(_DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)] - internal static extern int z_cholesky_solve(IntPtr solverHandle, int n, int nrhs, Complex[] a, [In, Out] Complex[] b); + internal static extern CudaResults z_cholesky_solve(IntPtr solverHandle, int n, int nrhs, Complex[] a, [In, Out] Complex[] b); [DllImport(_DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)] - internal static extern int s_cholesky_solve_factored(IntPtr solverHandle, int n, int nrhs, float[] a, [In, Out] float[] b); + internal static extern CudaResults s_cholesky_solve_factored(IntPtr solverHandle, int n, int nrhs, float[] a, [In, Out] float[] b); [DllImport(_DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)] - internal static extern int d_cholesky_solve_factored(IntPtr solverHandle, int n, int nrhs, double[] a, [In, Out] double[] b); + internal static extern CudaResults d_cholesky_solve_factored(IntPtr solverHandle, int n, int nrhs, double[] a, [In, Out] double[] b); [DllImport(_DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)] - internal static extern int c_cholesky_solve_factored(IntPtr solverHandle, int n, int nrhs, Complex32[] a, [In, Out] Complex32[] b); + internal static extern CudaResults c_cholesky_solve_factored(IntPtr solverHandle, int n, int nrhs, Complex32[] a, [In, Out] Complex32[] b); [DllImport(_DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)] - internal static extern int z_cholesky_solve_factored(IntPtr solverHandle, int n, int nrhs, Complex[] a, [In, Out] Complex[] b); + internal static extern CudaResults z_cholesky_solve_factored(IntPtr solverHandle, int n, int nrhs, Complex[] a, [In, Out] Complex[] b); //[DllImport(_DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)] //internal static extern int s_qr_factor(int m, int n, [In, Out] float[] r, [In, Out] float[] tau, [In, Out] float[] q, [In, Out] float[] work, int len); @@ -294,16 +294,16 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda //internal static extern int z_qr_solve_factored(int m, int n, int bn, Complex[] r, Complex[] b, Complex[] tau, [In, Out] Complex[] x, [In, Out] Complex[] work, int len); [DllImport(_DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)] - internal static extern int s_svd_factor(IntPtr solverHandle, [MarshalAs(UnmanagedType.U1)] bool computeVectors, int m, int n, [In, Out] float[] a, [In, Out] float[] s, [In, Out] float[] u, [In, Out] float[] v); + internal static extern CudaResults s_svd_factor(IntPtr solverHandle, [MarshalAs(UnmanagedType.U1)] bool computeVectors, int m, int n, [In, Out] float[] a, [In, Out] float[] s, [In, Out] float[] u, [In, Out] float[] v); [DllImport(_DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)] - internal static extern int d_svd_factor(IntPtr solverHandle, [MarshalAs(UnmanagedType.U1)] bool computeVectors, int m, int n, [In, Out] double[] a, [In, Out] double[] s, [In, Out] double[] u, [In, Out] double[] v); + internal static extern CudaResults d_svd_factor(IntPtr solverHandle, [MarshalAs(UnmanagedType.U1)] bool computeVectors, int m, int n, [In, Out] double[] a, [In, Out] double[] s, [In, Out] double[] u, [In, Out] double[] v); [DllImport(_DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)] - internal static extern int c_svd_factor(IntPtr solverHandle, [MarshalAs(UnmanagedType.U1)] bool computeVectors, int m, int n, [In, Out] Complex32[] a, [In, Out] Complex32[] s, [In, Out] Complex32[] u, [In, Out] Complex32[] v); + internal static extern CudaResults c_svd_factor(IntPtr solverHandle, [MarshalAs(UnmanagedType.U1)] bool computeVectors, int m, int n, [In, Out] Complex32[] a, [In, Out] Complex32[] s, [In, Out] Complex32[] u, [In, Out] Complex32[] v); [DllImport(_DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)] - internal static extern int z_svd_factor(IntPtr solverHandle, [MarshalAs(UnmanagedType.U1)] bool computeVectors, int m, int n, [In, Out] Complex[] a, [In, Out] Complex[] s, [In, Out] Complex[] u, [In, Out] Complex[] v); + internal static extern CudaResults z_svd_factor(IntPtr solverHandle, [MarshalAs(UnmanagedType.U1)] bool computeVectors, int m, int n, [In, Out] Complex[] a, [In, Out] Complex[] s, [In, Out] Complex[] u, [In, Out] Complex[] v); //[DllImport(_DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)] //internal static extern int s_eigen([MarshalAs(UnmanagedType.U1)] bool isSymmetric, int n, [In] float[] a, [In, Out] float[] vectors, [In, Out] Complex[] values, [In, Out] float[] d);