http://git-wip-us.apache.org/repos/asf/mahout/blob/f7c1f802/native-viennaCL/src/main/cpp/libviennacl/src/blas1_opencl.cu ---------------------------------------------------------------------- diff --git a/native-viennaCL/src/main/cpp/libviennacl/src/blas1_opencl.cu b/native-viennaCL/src/main/cpp/libviennacl/src/blas1_opencl.cu new file mode 100644 index 0000000..617b128 --- /dev/null +++ b/native-viennaCL/src/main/cpp/libviennacl/src/blas1_opencl.cu @@ -0,0 +1,297 @@ +/* ========================================================================= + Copyright (c) 2010-2014, Institute for Microelectronics, + Institute for Analysis and Scientific Computing, + TU Wien. + Portions of this software are copyright by UChicago Argonne, LLC. + + ----------------- + ViennaCL - The Vienna Computing Library + ----------------- + + Project Head: Karl Rupp [email protected] + + (A list of authors and contributors can be found in the PDF manual) + + License: MIT (X11), see file LICENSE in the base directory +============================================================================= */ + +// include necessary system headers +#include <iostream> + +#include "viennacl.hpp" +#include "viennacl_private.hpp" + +//include basic scalar and vector types of ViennaCL +#include "viennacl/scalar.hpp" +#include "viennacl/vector.hpp" + +//include the generic inner product functions of ViennaCL +#include "viennacl/linalg/inner_prod.hpp" + +//include the generic norm functions of ViennaCL +#include "viennacl/linalg/norm_1.hpp" +#include "viennacl/linalg/norm_2.hpp" +#include "viennacl/linalg/norm_inf.hpp" + +#ifdef VIENNACL_WITH_OPENCL + +// IxAMAX + +VIENNACL_EXPORTED_FUNCTION ViennaCLStatus ViennaCLOpenCLiSamax(ViennaCLBackend backend, ViennaCLInt n, + ViennaCLInt *index, + cl_mem x, ViennaCLInt offx, ViennaCLInt incx) +{ + typedef viennacl::vector_base<float>::size_type size_type; + typedef viennacl::vector_base<float>::size_type difference_type; + viennacl::vector_base<float> v1(x, size_type(n), size_type(offx), difference_type(incx), viennacl::ocl::get_context(backend->opencl_backend.context_id)); + + *index = static_cast<ViennaCLInt>(viennacl::linalg::index_norm_inf(v1)); + return ViennaCLSuccess; +} + +VIENNACL_EXPORTED_FUNCTION ViennaCLStatus ViennaCLOpenCLiDamax(ViennaCLBackend backend, ViennaCLInt n, + ViennaCLInt *index, + cl_mem x, ViennaCLInt offx, ViennaCLInt incx) +{ + typedef viennacl::vector_base<double>::size_type size_type; + typedef viennacl::vector_base<double>::size_type difference_type; + viennacl::vector_base<double> v1(x, size_type(n), size_type(offx), difference_type(incx), viennacl::ocl::get_context(backend->opencl_backend.context_id)); + + *index = static_cast<ViennaCLInt>(viennacl::linalg::index_norm_inf(v1)); + return ViennaCLSuccess; +} + + + + +// xASUM + +VIENNACL_EXPORTED_FUNCTION ViennaCLStatus ViennaCLOpenCLSasum(ViennaCLBackend backend, ViennaCLInt n, + float *alpha, + cl_mem x, ViennaCLInt offx, ViennaCLInt incx) +{ + typedef viennacl::vector_base<float>::size_type size_type; + typedef viennacl::vector_base<float>::size_type difference_type; + viennacl::vector_base<float> v1(x, size_type(n), size_type(offx), difference_type(incx), viennacl::ocl::get_context(backend->opencl_backend.context_id)); + + *alpha = viennacl::linalg::norm_1(v1); + return ViennaCLSuccess; +} + +VIENNACL_EXPORTED_FUNCTION ViennaCLStatus ViennaCLOpenCLDasum(ViennaCLBackend backend, ViennaCLInt n, + double *alpha, + cl_mem x, ViennaCLInt offx, ViennaCLInt incx) +{ + typedef viennacl::vector_base<double>::size_type size_type; + typedef viennacl::vector_base<double>::size_type difference_type; + viennacl::vector_base<double> v1(x, size_type(n), size_type(offx), difference_type(incx), viennacl::ocl::get_context(backend->opencl_backend.context_id)); + + *alpha = viennacl::linalg::norm_1(v1); + return ViennaCLSuccess; +} + + + +// xAXPY + +VIENNACL_EXPORTED_FUNCTION ViennaCLStatus ViennaCLOpenCLSaxpy(ViennaCLBackend backend, ViennaCLInt n, + float alpha, + cl_mem x, ViennaCLInt offx, ViennaCLInt incx, + cl_mem y, ViennaCLInt offy, ViennaCLInt incy) +{ + typedef viennacl::vector_base<float>::size_type size_type; + typedef viennacl::vector_base<float>::size_type difference_type; + viennacl::vector_base<float> v1(x, size_type(n), size_type(offx), difference_type(incx), viennacl::ocl::get_context(backend->opencl_backend.context_id)); + viennacl::vector_base<float> v2(y, size_type(n), size_type(offy), difference_type(incy), viennacl::ocl::get_context(backend->opencl_backend.context_id)); + + v2 += alpha * v1; + return ViennaCLSuccess; +} + +VIENNACL_EXPORTED_FUNCTION ViennaCLStatus ViennaCLOpenCLDaxpy(ViennaCLBackend backend, ViennaCLInt n, + double alpha, + cl_mem x, ViennaCLInt offx, ViennaCLInt incx, + cl_mem y, ViennaCLInt offy, ViennaCLInt incy) +{ + typedef viennacl::vector_base<double>::size_type size_type; + typedef viennacl::vector_base<double>::size_type difference_type; + viennacl::vector_base<double> v1(x, size_type(n), size_type(offx), difference_type(incx), viennacl::ocl::get_context(backend->opencl_backend.context_id)); + viennacl::vector_base<double> v2(y, size_type(n), size_type(offy), difference_type(incy), viennacl::ocl::get_context(backend->opencl_backend.context_id)); + + v2 += alpha * v1; + return ViennaCLSuccess; +} + + +// xCOPY + +VIENNACL_EXPORTED_FUNCTION ViennaCLStatus ViennaCLOpenCLScopy(ViennaCLBackend backend, ViennaCLInt n, + cl_mem x, ViennaCLInt offx, ViennaCLInt incx, + cl_mem y, ViennaCLInt offy, ViennaCLInt incy) +{ + typedef viennacl::vector_base<float>::size_type size_type; + typedef viennacl::vector_base<float>::size_type difference_type; + viennacl::vector_base<float> v1(x, size_type(n), size_type(offx), difference_type(incx), viennacl::ocl::get_context(backend->opencl_backend.context_id)); + viennacl::vector_base<float> v2(y, size_type(n), size_type(offy), difference_type(incy), viennacl::ocl::get_context(backend->opencl_backend.context_id)); + + v2 = v1; + return ViennaCLSuccess; +} + +VIENNACL_EXPORTED_FUNCTION ViennaCLStatus ViennaCLOpenCLDcopy(ViennaCLBackend backend, ViennaCLInt n, + cl_mem x, ViennaCLInt offx, ViennaCLInt incx, + cl_mem y, ViennaCLInt offy, ViennaCLInt incy) +{ + typedef viennacl::vector_base<double>::size_type size_type; + typedef viennacl::vector_base<double>::size_type difference_type; + viennacl::vector_base<double> v1(x, size_type(n), size_type(offx), difference_type(incx), viennacl::ocl::get_context(backend->opencl_backend.context_id)); + viennacl::vector_base<double> v2(y, size_type(n), size_type(offy), difference_type(incy), viennacl::ocl::get_context(backend->opencl_backend.context_id)); + + v2 = v1; + return ViennaCLSuccess; +} + +// xDOT + +VIENNACL_EXPORTED_FUNCTION ViennaCLStatus ViennaCLOpenCLSdot(ViennaCLBackend backend, ViennaCLInt n, + float *alpha, + cl_mem x, ViennaCLInt offx, ViennaCLInt incx, + cl_mem y, ViennaCLInt offy, ViennaCLInt incy) +{ + typedef viennacl::vector_base<float>::size_type size_type; + typedef viennacl::vector_base<float>::size_type difference_type; + viennacl::vector_base<float> v1(x, size_type(n), size_type(offx), difference_type(incx), viennacl::ocl::get_context(backend->opencl_backend.context_id)); + viennacl::vector_base<float> v2(y, size_type(n), size_type(offy), difference_type(incy), viennacl::ocl::get_context(backend->opencl_backend.context_id)); + + *alpha = viennacl::linalg::inner_prod(v1, v2); + return ViennaCLSuccess; +} + +VIENNACL_EXPORTED_FUNCTION ViennaCLStatus ViennaCLOpenCLDdot(ViennaCLBackend backend, ViennaCLInt n, + double *alpha, + cl_mem x, ViennaCLInt offx, ViennaCLInt incx, + cl_mem y, ViennaCLInt offy, ViennaCLInt incy) +{ + typedef viennacl::vector_base<double>::size_type size_type; + typedef viennacl::vector_base<double>::size_type difference_type; + viennacl::vector_base<double> v1(x, size_type(n), size_type(offx), difference_type(incx), viennacl::ocl::get_context(backend->opencl_backend.context_id)); + viennacl::vector_base<double> v2(y, size_type(n), size_type(offy), difference_type(incy), viennacl::ocl::get_context(backend->opencl_backend.context_id)); + + *alpha = viennacl::linalg::inner_prod(v1, v2); + return ViennaCLSuccess; +} + + +// xNRM2 + +VIENNACL_EXPORTED_FUNCTION ViennaCLStatus ViennaCLOpenCLSnrm2(ViennaCLBackend backend, ViennaCLInt n, + float *alpha, + cl_mem x, ViennaCLInt offx, ViennaCLInt incx) +{ + typedef viennacl::vector_base<float>::size_type size_type; + typedef viennacl::vector_base<float>::size_type difference_type; + viennacl::vector_base<float> v1(x, size_type(n), size_type(offx), difference_type(incx), viennacl::ocl::get_context(backend->opencl_backend.context_id)); + + *alpha = viennacl::linalg::norm_2(v1); + return ViennaCLSuccess; +} + +VIENNACL_EXPORTED_FUNCTION ViennaCLStatus ViennaCLOpenCLDnrm2(ViennaCLBackend backend, ViennaCLInt n, + double *alpha, + cl_mem x, ViennaCLInt offx, ViennaCLInt incx) +{ + typedef viennacl::vector_base<double>::size_type size_type; + typedef viennacl::vector_base<double>::size_type difference_type; + viennacl::vector_base<double> v1(x, size_type(n), size_type(offx), difference_type(incx), viennacl::ocl::get_context(backend->opencl_backend.context_id)); + + *alpha = viennacl::linalg::norm_2(v1); + return ViennaCLSuccess; +} + + +// xROT + +VIENNACL_EXPORTED_FUNCTION ViennaCLStatus ViennaCLOpenCLSrot(ViennaCLBackend backend, ViennaCLInt n, + cl_mem x, ViennaCLInt offx, ViennaCLInt incx, + cl_mem y, ViennaCLInt offy, ViennaCLInt incy, + float c, float s) +{ + typedef viennacl::vector_base<float>::size_type size_type; + typedef viennacl::vector_base<float>::size_type difference_type; + viennacl::vector_base<float> v1(x, size_type(n), size_type(offx), difference_type(incx), viennacl::ocl::get_context(backend->opencl_backend.context_id)); + viennacl::vector_base<float> v2(y, size_type(n), size_type(offy), difference_type(incy), viennacl::ocl::get_context(backend->opencl_backend.context_id)); + + viennacl::linalg::plane_rotation(v1, v2, c, s); + return ViennaCLSuccess; +} + +VIENNACL_EXPORTED_FUNCTION ViennaCLStatus ViennaCLOpenCLDrot(ViennaCLBackend backend, ViennaCLInt n, + cl_mem x, ViennaCLInt offx, ViennaCLInt incx, + cl_mem y, ViennaCLInt offy, ViennaCLInt incy, + double c, double s) +{ + typedef viennacl::vector_base<double>::size_type size_type; + typedef viennacl::vector_base<double>::size_type difference_type; + viennacl::vector_base<double> v1(x, size_type(n), size_type(offx), difference_type(incx), viennacl::ocl::get_context(backend->opencl_backend.context_id)); + viennacl::vector_base<double> v2(y, size_type(n), size_type(offy), difference_type(incy), viennacl::ocl::get_context(backend->opencl_backend.context_id)); + + viennacl::linalg::plane_rotation(v1, v2, c, s); + return ViennaCLSuccess; +} + + + +// xSCAL + +VIENNACL_EXPORTED_FUNCTION ViennaCLStatus ViennaCLOpenCLSscal(ViennaCLBackend backend, ViennaCLInt n, + float alpha, + cl_mem x, ViennaCLInt offx, ViennaCLInt incx) +{ + typedef viennacl::vector_base<float>::size_type size_type; + typedef viennacl::vector_base<float>::size_type difference_type; + viennacl::vector_base<float> v1(x, size_type(n), size_type(offx), difference_type(incx), viennacl::ocl::get_context(backend->opencl_backend.context_id)); + + v1 *= alpha; + return ViennaCLSuccess; +} + +VIENNACL_EXPORTED_FUNCTION ViennaCLStatus ViennaCLOpenCLDscal(ViennaCLBackend backend, ViennaCLInt n, + double alpha, + cl_mem x, ViennaCLInt offx, ViennaCLInt incx) +{ + typedef viennacl::vector_base<double>::size_type size_type; + typedef viennacl::vector_base<double>::size_type difference_type; + viennacl::vector_base<double> v1(x, size_type(n), size_type(offx), difference_type(incx), viennacl::ocl::get_context(backend->opencl_backend.context_id)); + + v1 *= alpha; + return ViennaCLSuccess; +} + +// xSWAP + +VIENNACL_EXPORTED_FUNCTION ViennaCLStatus ViennaCLOpenCLSswap(ViennaCLBackend backend, ViennaCLInt n, + cl_mem x, ViennaCLInt offx, ViennaCLInt incx, + cl_mem y, ViennaCLInt offy, ViennaCLInt incy) +{ + typedef viennacl::vector_base<float>::size_type size_type; + typedef viennacl::vector_base<float>::size_type difference_type; + viennacl::vector_base<float> v1(x, size_type(n), size_type(offx), difference_type(incx), viennacl::ocl::get_context(backend->opencl_backend.context_id)); + viennacl::vector_base<float> v2(y, size_type(n), size_type(offy), difference_type(incy), viennacl::ocl::get_context(backend->opencl_backend.context_id)); + + viennacl::swap(v1, v2); + return ViennaCLSuccess; +} + +VIENNACL_EXPORTED_FUNCTION ViennaCLStatus ViennaCLOpenCLDswap(ViennaCLBackend backend, ViennaCLInt n, + cl_mem x, ViennaCLInt offx, ViennaCLInt incx, + cl_mem y, ViennaCLInt offy, ViennaCLInt incy) +{ + typedef viennacl::vector_base<double>::size_type size_type; + typedef viennacl::vector_base<double>::size_type difference_type; + viennacl::vector_base<double> v1(x, size_type(n), size_type(offx), difference_type(incx), viennacl::ocl::get_context(backend->opencl_backend.context_id)); + viennacl::vector_base<double> v2(y, size_type(n), size_type(offy), difference_type(incy), viennacl::ocl::get_context(backend->opencl_backend.context_id)); + + viennacl::swap(v1, v2); + return ViennaCLSuccess; +} +#endif
http://git-wip-us.apache.org/repos/asf/mahout/blob/f7c1f802/native-viennaCL/src/main/cpp/libviennacl/src/blas2.cpp ---------------------------------------------------------------------- diff --git a/native-viennaCL/src/main/cpp/libviennacl/src/blas2.cpp b/native-viennaCL/src/main/cpp/libviennacl/src/blas2.cpp new file mode 100644 index 0000000..bc2c095 --- /dev/null +++ b/native-viennaCL/src/main/cpp/libviennacl/src/blas2.cpp @@ -0,0 +1,231 @@ +/* ========================================================================= + Copyright (c) 2010-2014, Institute for Microelectronics, + Institute for Analysis and Scientific Computing, + TU Wien. + Portions of this software are copyright by UChicago Argonne, LLC. + + ----------------- + ViennaCL - The Vienna Computing Library + ----------------- + + Project Head: Karl Rupp [email protected] + + (A list of authors and contributors can be found in the PDF manual) + + License: MIT (X11), see file LICENSE in the base directory +============================================================================= */ + +// include necessary system headers +#include <iostream> + +#include "viennacl.hpp" +#include "viennacl_private.hpp" + +#include "init_vector.hpp" +#include "init_matrix.hpp" + +//include basic scalar and vector types of ViennaCL +#include "viennacl/scalar.hpp" +#include "viennacl/vector.hpp" +#include "viennacl/matrix.hpp" +#include "viennacl/linalg/direct_solve.hpp" +#include "viennacl/linalg/prod.hpp" + +// GEMV + +VIENNACL_EXPORTED_FUNCTION ViennaCLStatus ViennaCLgemv(ViennaCLHostScalar alpha, ViennaCLMatrix A, ViennaCLVector x, ViennaCLHostScalar beta, ViennaCLVector y) +{ + viennacl::backend::mem_handle v1_handle; + viennacl::backend::mem_handle v2_handle; + viennacl::backend::mem_handle A_handle; + + if (init_vector(v1_handle, x) != ViennaCLSuccess) + return ViennaCLGenericFailure; + + if (init_vector(v2_handle, y) != ViennaCLSuccess) + return ViennaCLGenericFailure; + + if (init_matrix(A_handle, A) != ViennaCLSuccess) + return ViennaCLGenericFailure; + + switch (x->precision) + { + case ViennaCLFloat: + { + typedef viennacl::vector_base<float>::size_type size_type; + typedef viennacl::vector_base<float>::size_type difference_type; + + viennacl::vector_base<float> v1(v1_handle, size_type(x->size), size_type(x->offset), difference_type(x->inc)); + viennacl::vector_base<float> v2(v2_handle, size_type(y->size), size_type(y->offset), difference_type(y->inc)); + + viennacl::matrix_base<float> mat(A_handle, + size_type(A->size1), size_type(A->start1), difference_type(A->stride1), size_type(A->internal_size1), + size_type(A->size2), size_type(A->start2), difference_type(A->stride2), size_type(A->internal_size2), A->order == ViennaCLRowMajor); + v2 *= beta->value_float; + if (A->trans == ViennaCLTrans) + v2 += alpha->value_float * viennacl::linalg::prod(viennacl::trans(mat), v1); + else + v2 += alpha->value_float * viennacl::linalg::prod(mat, v1); + + return ViennaCLSuccess; + } + + case ViennaCLDouble: + { + typedef viennacl::vector_base<double>::size_type size_type; + typedef viennacl::vector_base<double>::size_type difference_type; + + viennacl::vector_base<double> v1(v1_handle, size_type(x->size), size_type(x->offset), difference_type(x->inc)); + viennacl::vector_base<double> v2(v2_handle, size_type(y->size), size_type(y->offset), difference_type(y->inc)); + + viennacl::matrix_base<double> mat(A_handle, + size_type(A->size1), size_type(A->start1), difference_type(A->stride1), size_type(A->internal_size1), + size_type(A->size2), size_type(A->start2), difference_type(A->stride2), size_type(A->internal_size2), A->order == ViennaCLRowMajor); + v2 *= beta->value_double; + if (A->trans == ViennaCLTrans) + v2 += alpha->value_double * viennacl::linalg::prod(viennacl::trans(mat), v1); + else + v2 += alpha->value_double * viennacl::linalg::prod(mat, v1); + + return ViennaCLSuccess; + } + + default: + return ViennaCLGenericFailure; + } +} + + +// xTRSV + +VIENNACL_EXPORTED_FUNCTION ViennaCLStatus ViennaCLtrsv(ViennaCLMatrix A, ViennaCLVector x, ViennaCLUplo uplo) +{ + viennacl::backend::mem_handle v1_handle; + viennacl::backend::mem_handle A_handle; + + if (init_vector(v1_handle, x) != ViennaCLSuccess) + return ViennaCLGenericFailure; + + if (init_matrix(A_handle, A) != ViennaCLSuccess) + return ViennaCLGenericFailure; + + switch (x->precision) + { + case ViennaCLFloat: + { + typedef viennacl::vector_base<float>::size_type size_type; + typedef viennacl::vector_base<float>::size_type difference_type; + + viennacl::vector_base<float> v1(v1_handle, size_type(x->size), size_type(x->offset), difference_type(x->inc)); + + viennacl::matrix_base<float> mat(A_handle, + size_type(A->size1), size_type(A->start1), difference_type(A->stride1), size_type(A->internal_size1), + size_type(A->size2), size_type(A->start2), difference_type(A->stride2), size_type(A->internal_size2), A->order == ViennaCLRowMajor); + if (A->trans == ViennaCLTrans) + { + if (uplo == ViennaCLUpper) + viennacl::linalg::inplace_solve(viennacl::trans(mat), v1, viennacl::linalg::upper_tag()); + else + viennacl::linalg::inplace_solve(viennacl::trans(mat), v1, viennacl::linalg::lower_tag()); + } + else + { + if (uplo == ViennaCLUpper) + viennacl::linalg::inplace_solve(mat, v1, viennacl::linalg::upper_tag()); + else + viennacl::linalg::inplace_solve(mat, v1, viennacl::linalg::lower_tag()); + } + + return ViennaCLSuccess; + } + case ViennaCLDouble: + { + typedef viennacl::vector_base<double>::size_type size_type; + typedef viennacl::vector_base<double>::size_type difference_type; + + viennacl::vector_base<double> v1(v1_handle, size_type(x->size), size_type(x->offset), difference_type(x->inc)); + + viennacl::matrix_base<double> mat(A_handle, + size_type(A->size1), size_type(A->start1), difference_type(A->stride1), size_type(A->internal_size1), + size_type(A->size2), size_type(A->start2), difference_type(A->stride2), size_type(A->internal_size2), A->order == ViennaCLRowMajor); + if (A->trans == ViennaCLTrans) + { + if (uplo == ViennaCLUpper) + viennacl::linalg::inplace_solve(viennacl::trans(mat), v1, viennacl::linalg::upper_tag()); + else + viennacl::linalg::inplace_solve(viennacl::trans(mat), v1, viennacl::linalg::lower_tag()); + } + else + { + if (uplo == ViennaCLUpper) + viennacl::linalg::inplace_solve(mat, v1, viennacl::linalg::upper_tag()); + else + viennacl::linalg::inplace_solve(mat, v1, viennacl::linalg::lower_tag()); + } + + return ViennaCLSuccess; + } + + default: + return ViennaCLGenericFailure; + } +} + + +// xGER + +VIENNACL_EXPORTED_FUNCTION ViennaCLStatus ViennaCLger(ViennaCLHostScalar alpha, ViennaCLVector x, ViennaCLVector y, ViennaCLMatrix A) +{ + viennacl::backend::mem_handle v1_handle; + viennacl::backend::mem_handle v2_handle; + viennacl::backend::mem_handle A_handle; + + if (init_vector(v1_handle, x) != ViennaCLSuccess) + return ViennaCLGenericFailure; + + if (init_vector(v2_handle, y) != ViennaCLSuccess) + return ViennaCLGenericFailure; + + if (init_matrix(A_handle, A) != ViennaCLSuccess) + return ViennaCLGenericFailure; + + switch (x->precision) + { + case ViennaCLFloat: + { + typedef viennacl::vector_base<float>::size_type size_type; + typedef viennacl::vector_base<float>::size_type difference_type; + + viennacl::vector_base<float> v1(v1_handle, size_type(x->size), size_type(x->offset), difference_type(x->inc)); + viennacl::vector_base<float> v2(v2_handle, size_type(y->size), size_type(y->offset), difference_type(y->inc)); + + viennacl::matrix_base<float> mat(A_handle, + size_type(A->size1), size_type(A->start1), difference_type(A->stride1), size_type(A->internal_size1), + size_type(A->size2), size_type(A->start2), difference_type(A->stride2), size_type(A->internal_size2), A->order == ViennaCLRowMajor); + + mat += alpha->value_float * viennacl::linalg::outer_prod(v1, v2); + + return ViennaCLSuccess; + } + case ViennaCLDouble: + { + typedef viennacl::vector_base<double>::size_type size_type; + typedef viennacl::vector_base<double>::size_type difference_type; + + viennacl::vector_base<double> v1(v1_handle, size_type(x->size), size_type(x->offset), difference_type(x->inc)); + viennacl::vector_base<double> v2(v2_handle, size_type(y->size), size_type(y->offset), difference_type(y->inc)); + + viennacl::matrix_base<double> mat(A_handle, + size_type(A->size1), size_type(A->start1), difference_type(A->stride1), size_type(A->internal_size1), + size_type(A->size2), size_type(A->start2), difference_type(A->stride2), size_type(A->internal_size2), A->order == ViennaCLRowMajor); + + mat += alpha->value_double * viennacl::linalg::outer_prod(v1, v2); + + return ViennaCLSuccess; + } + default: + return ViennaCLGenericFailure; + } +} + + http://git-wip-us.apache.org/repos/asf/mahout/blob/f7c1f802/native-viennaCL/src/main/cpp/libviennacl/src/blas2.cu ---------------------------------------------------------------------- diff --git a/native-viennaCL/src/main/cpp/libviennacl/src/blas2.cu b/native-viennaCL/src/main/cpp/libviennacl/src/blas2.cu new file mode 100644 index 0000000..bc2c095 --- /dev/null +++ b/native-viennaCL/src/main/cpp/libviennacl/src/blas2.cu @@ -0,0 +1,231 @@ +/* ========================================================================= + Copyright (c) 2010-2014, Institute for Microelectronics, + Institute for Analysis and Scientific Computing, + TU Wien. + Portions of this software are copyright by UChicago Argonne, LLC. + + ----------------- + ViennaCL - The Vienna Computing Library + ----------------- + + Project Head: Karl Rupp [email protected] + + (A list of authors and contributors can be found in the PDF manual) + + License: MIT (X11), see file LICENSE in the base directory +============================================================================= */ + +// include necessary system headers +#include <iostream> + +#include "viennacl.hpp" +#include "viennacl_private.hpp" + +#include "init_vector.hpp" +#include "init_matrix.hpp" + +//include basic scalar and vector types of ViennaCL +#include "viennacl/scalar.hpp" +#include "viennacl/vector.hpp" +#include "viennacl/matrix.hpp" +#include "viennacl/linalg/direct_solve.hpp" +#include "viennacl/linalg/prod.hpp" + +// GEMV + +VIENNACL_EXPORTED_FUNCTION ViennaCLStatus ViennaCLgemv(ViennaCLHostScalar alpha, ViennaCLMatrix A, ViennaCLVector x, ViennaCLHostScalar beta, ViennaCLVector y) +{ + viennacl::backend::mem_handle v1_handle; + viennacl::backend::mem_handle v2_handle; + viennacl::backend::mem_handle A_handle; + + if (init_vector(v1_handle, x) != ViennaCLSuccess) + return ViennaCLGenericFailure; + + if (init_vector(v2_handle, y) != ViennaCLSuccess) + return ViennaCLGenericFailure; + + if (init_matrix(A_handle, A) != ViennaCLSuccess) + return ViennaCLGenericFailure; + + switch (x->precision) + { + case ViennaCLFloat: + { + typedef viennacl::vector_base<float>::size_type size_type; + typedef viennacl::vector_base<float>::size_type difference_type; + + viennacl::vector_base<float> v1(v1_handle, size_type(x->size), size_type(x->offset), difference_type(x->inc)); + viennacl::vector_base<float> v2(v2_handle, size_type(y->size), size_type(y->offset), difference_type(y->inc)); + + viennacl::matrix_base<float> mat(A_handle, + size_type(A->size1), size_type(A->start1), difference_type(A->stride1), size_type(A->internal_size1), + size_type(A->size2), size_type(A->start2), difference_type(A->stride2), size_type(A->internal_size2), A->order == ViennaCLRowMajor); + v2 *= beta->value_float; + if (A->trans == ViennaCLTrans) + v2 += alpha->value_float * viennacl::linalg::prod(viennacl::trans(mat), v1); + else + v2 += alpha->value_float * viennacl::linalg::prod(mat, v1); + + return ViennaCLSuccess; + } + + case ViennaCLDouble: + { + typedef viennacl::vector_base<double>::size_type size_type; + typedef viennacl::vector_base<double>::size_type difference_type; + + viennacl::vector_base<double> v1(v1_handle, size_type(x->size), size_type(x->offset), difference_type(x->inc)); + viennacl::vector_base<double> v2(v2_handle, size_type(y->size), size_type(y->offset), difference_type(y->inc)); + + viennacl::matrix_base<double> mat(A_handle, + size_type(A->size1), size_type(A->start1), difference_type(A->stride1), size_type(A->internal_size1), + size_type(A->size2), size_type(A->start2), difference_type(A->stride2), size_type(A->internal_size2), A->order == ViennaCLRowMajor); + v2 *= beta->value_double; + if (A->trans == ViennaCLTrans) + v2 += alpha->value_double * viennacl::linalg::prod(viennacl::trans(mat), v1); + else + v2 += alpha->value_double * viennacl::linalg::prod(mat, v1); + + return ViennaCLSuccess; + } + + default: + return ViennaCLGenericFailure; + } +} + + +// xTRSV + +VIENNACL_EXPORTED_FUNCTION ViennaCLStatus ViennaCLtrsv(ViennaCLMatrix A, ViennaCLVector x, ViennaCLUplo uplo) +{ + viennacl::backend::mem_handle v1_handle; + viennacl::backend::mem_handle A_handle; + + if (init_vector(v1_handle, x) != ViennaCLSuccess) + return ViennaCLGenericFailure; + + if (init_matrix(A_handle, A) != ViennaCLSuccess) + return ViennaCLGenericFailure; + + switch (x->precision) + { + case ViennaCLFloat: + { + typedef viennacl::vector_base<float>::size_type size_type; + typedef viennacl::vector_base<float>::size_type difference_type; + + viennacl::vector_base<float> v1(v1_handle, size_type(x->size), size_type(x->offset), difference_type(x->inc)); + + viennacl::matrix_base<float> mat(A_handle, + size_type(A->size1), size_type(A->start1), difference_type(A->stride1), size_type(A->internal_size1), + size_type(A->size2), size_type(A->start2), difference_type(A->stride2), size_type(A->internal_size2), A->order == ViennaCLRowMajor); + if (A->trans == ViennaCLTrans) + { + if (uplo == ViennaCLUpper) + viennacl::linalg::inplace_solve(viennacl::trans(mat), v1, viennacl::linalg::upper_tag()); + else + viennacl::linalg::inplace_solve(viennacl::trans(mat), v1, viennacl::linalg::lower_tag()); + } + else + { + if (uplo == ViennaCLUpper) + viennacl::linalg::inplace_solve(mat, v1, viennacl::linalg::upper_tag()); + else + viennacl::linalg::inplace_solve(mat, v1, viennacl::linalg::lower_tag()); + } + + return ViennaCLSuccess; + } + case ViennaCLDouble: + { + typedef viennacl::vector_base<double>::size_type size_type; + typedef viennacl::vector_base<double>::size_type difference_type; + + viennacl::vector_base<double> v1(v1_handle, size_type(x->size), size_type(x->offset), difference_type(x->inc)); + + viennacl::matrix_base<double> mat(A_handle, + size_type(A->size1), size_type(A->start1), difference_type(A->stride1), size_type(A->internal_size1), + size_type(A->size2), size_type(A->start2), difference_type(A->stride2), size_type(A->internal_size2), A->order == ViennaCLRowMajor); + if (A->trans == ViennaCLTrans) + { + if (uplo == ViennaCLUpper) + viennacl::linalg::inplace_solve(viennacl::trans(mat), v1, viennacl::linalg::upper_tag()); + else + viennacl::linalg::inplace_solve(viennacl::trans(mat), v1, viennacl::linalg::lower_tag()); + } + else + { + if (uplo == ViennaCLUpper) + viennacl::linalg::inplace_solve(mat, v1, viennacl::linalg::upper_tag()); + else + viennacl::linalg::inplace_solve(mat, v1, viennacl::linalg::lower_tag()); + } + + return ViennaCLSuccess; + } + + default: + return ViennaCLGenericFailure; + } +} + + +// xGER + +VIENNACL_EXPORTED_FUNCTION ViennaCLStatus ViennaCLger(ViennaCLHostScalar alpha, ViennaCLVector x, ViennaCLVector y, ViennaCLMatrix A) +{ + viennacl::backend::mem_handle v1_handle; + viennacl::backend::mem_handle v2_handle; + viennacl::backend::mem_handle A_handle; + + if (init_vector(v1_handle, x) != ViennaCLSuccess) + return ViennaCLGenericFailure; + + if (init_vector(v2_handle, y) != ViennaCLSuccess) + return ViennaCLGenericFailure; + + if (init_matrix(A_handle, A) != ViennaCLSuccess) + return ViennaCLGenericFailure; + + switch (x->precision) + { + case ViennaCLFloat: + { + typedef viennacl::vector_base<float>::size_type size_type; + typedef viennacl::vector_base<float>::size_type difference_type; + + viennacl::vector_base<float> v1(v1_handle, size_type(x->size), size_type(x->offset), difference_type(x->inc)); + viennacl::vector_base<float> v2(v2_handle, size_type(y->size), size_type(y->offset), difference_type(y->inc)); + + viennacl::matrix_base<float> mat(A_handle, + size_type(A->size1), size_type(A->start1), difference_type(A->stride1), size_type(A->internal_size1), + size_type(A->size2), size_type(A->start2), difference_type(A->stride2), size_type(A->internal_size2), A->order == ViennaCLRowMajor); + + mat += alpha->value_float * viennacl::linalg::outer_prod(v1, v2); + + return ViennaCLSuccess; + } + case ViennaCLDouble: + { + typedef viennacl::vector_base<double>::size_type size_type; + typedef viennacl::vector_base<double>::size_type difference_type; + + viennacl::vector_base<double> v1(v1_handle, size_type(x->size), size_type(x->offset), difference_type(x->inc)); + viennacl::vector_base<double> v2(v2_handle, size_type(y->size), size_type(y->offset), difference_type(y->inc)); + + viennacl::matrix_base<double> mat(A_handle, + size_type(A->size1), size_type(A->start1), difference_type(A->stride1), size_type(A->internal_size1), + size_type(A->size2), size_type(A->start2), difference_type(A->stride2), size_type(A->internal_size2), A->order == ViennaCLRowMajor); + + mat += alpha->value_double * viennacl::linalg::outer_prod(v1, v2); + + return ViennaCLSuccess; + } + default: + return ViennaCLGenericFailure; + } +} + + http://git-wip-us.apache.org/repos/asf/mahout/blob/f7c1f802/native-viennaCL/src/main/cpp/libviennacl/src/blas2_cuda.cu ---------------------------------------------------------------------- diff --git a/native-viennaCL/src/main/cpp/libviennacl/src/blas2_cuda.cu b/native-viennaCL/src/main/cpp/libviennacl/src/blas2_cuda.cu new file mode 100644 index 0000000..60c9293 --- /dev/null +++ b/native-viennaCL/src/main/cpp/libviennacl/src/blas2_cuda.cu @@ -0,0 +1,204 @@ +/* ========================================================================= + Copyright (c) 2010-2014, Institute for Microelectronics, + Institute for Analysis and Scientific Computing, + TU Wien. + Portions of this software are copyright by UChicago Argonne, LLC. + + ----------------- + ViennaCL - The Vienna Computing Library + ----------------- + + Project Head: Karl Rupp [email protected] + + (A list of authors and contributors can be found in the PDF manual) + + License: MIT (X11), see file LICENSE in the base directory +============================================================================= */ + +// include necessary system headers +#include <iostream> + +#include "viennacl.hpp" +#include "viennacl_private.hpp" + +//include basic scalar and vector types of ViennaCL +#include "viennacl/scalar.hpp" +#include "viennacl/vector.hpp" + +#include "viennacl/vector.hpp" +#include "viennacl/matrix.hpp" +#include "viennacl/linalg/direct_solve.hpp" +#include "viennacl/linalg/prod.hpp" + + +#ifdef VIENNACL_WITH_CUDA + +// xGEMV + +VIENNACL_EXPORTED_FUNCTION ViennaCLStatus ViennaCLCUDASgemv(ViennaCLBackend /*backend*/, + ViennaCLOrder order, ViennaCLTranspose transA, + ViennaCLInt m, ViennaCLInt n, float alpha, float *A, ViennaCLInt offA_row, ViennaCLInt offA_col, ViennaCLInt incA_row, ViennaCLInt incA_col, ViennaCLInt lda, + float *x, ViennaCLInt offx, ViennaCLInt incx, + float beta, + float *y, ViennaCLInt offy, ViennaCLInt incy) +{ + viennacl::vector_base<float> v1(x, viennacl::CUDA_MEMORY, n, offx, incx); + viennacl::vector_base<float> v2(y, viennacl::CUDA_MEMORY, m, offy, incy); + viennacl::matrix_base<float> mat(A, viennacl::CUDA_MEMORY, + m, offA_row, incA_row, m, + n, offA_col, incA_col, lda, order == ViennaCLRowMajor); + v2 *= beta; + if (transA == ViennaCLTrans) + v2 += alpha * viennacl::linalg::prod(viennacl::trans(mat), v1); + else + v2 += alpha * viennacl::linalg::prod(mat, v1); + + return ViennaCLSuccess; +} + +VIENNACL_EXPORTED_FUNCTION ViennaCLStatus ViennaCLCUDADgemv(ViennaCLBackend /*backend*/, + ViennaCLOrder order, ViennaCLTranspose transA, + ViennaCLInt m, ViennaCLInt n, double alpha, double *A, ViennaCLInt offA_row, ViennaCLInt offA_col, ViennaCLInt incA_row, ViennaCLInt incA_col, ViennaCLInt lda, + double *x, ViennaCLInt offx, ViennaCLInt incx, + double beta, + double *y, ViennaCLInt offy, ViennaCLInt incy) +{ + viennacl::vector_base<double> v1(x, viennacl::CUDA_MEMORY, n, offx, incx); + viennacl::vector_base<double> v2(y, viennacl::CUDA_MEMORY, m, offy, incy); + viennacl::matrix_base<double> mat(A, viennacl::CUDA_MEMORY, + m, offA_row, incA_row, m, + n, offA_col, incA_col, lda, order == ViennaCLRowMajor); + v2 *= beta; + if (transA == ViennaCLTrans) + v2 += alpha * viennacl::linalg::prod(viennacl::trans(mat), v1); + else + v2 += alpha * viennacl::linalg::prod(mat, v1); + + return ViennaCLSuccess; +} + + + +// xTRSV + +VIENNACL_EXPORTED_FUNCTION ViennaCLStatus ViennaCLCUDAStrsv(ViennaCLBackend /*backend*/, + ViennaCLUplo uplo, ViennaCLOrder order, ViennaCLTranspose transA, ViennaCLDiag diag, + ViennaCLInt n, float *A, ViennaCLInt offA_row, ViennaCLInt offA_col, ViennaCLInt incA_row, ViennaCLInt incA_col, ViennaCLInt lda, + float *x, ViennaCLInt offx, ViennaCLInt incx) +{ + viennacl::vector_base<float> v(x, viennacl::CUDA_MEMORY, n, offx, incx); + viennacl::matrix_base<float> mat(A, viennacl::CUDA_MEMORY, + n, offA_row, incA_row, n, + n, offA_col, incA_col, lda, order == ViennaCLRowMajor); + if (transA == ViennaCLTrans) + { + if (uplo == ViennaCLUpper) + if (diag == ViennaCLUnit) + viennacl::linalg::inplace_solve(viennacl::trans(mat), v, viennacl::linalg::unit_upper_tag()); + else + viennacl::linalg::inplace_solve(viennacl::trans(mat), v, viennacl::linalg::upper_tag()); + else + if (diag == ViennaCLUnit) + viennacl::linalg::inplace_solve(viennacl::trans(mat), v, viennacl::linalg::unit_lower_tag()); + else + viennacl::linalg::inplace_solve(viennacl::trans(mat), v, viennacl::linalg::lower_tag()); + } + else + { + if (uplo == ViennaCLUpper) + if (diag == ViennaCLUnit) + viennacl::linalg::inplace_solve(mat, v, viennacl::linalg::unit_upper_tag()); + else + viennacl::linalg::inplace_solve(mat, v, viennacl::linalg::upper_tag()); + else + if (diag == ViennaCLUnit) + viennacl::linalg::inplace_solve(mat, v, viennacl::linalg::unit_lower_tag()); + else + viennacl::linalg::inplace_solve(mat, v, viennacl::linalg::lower_tag()); + } + + return ViennaCLSuccess; +} + +VIENNACL_EXPORTED_FUNCTION ViennaCLStatus ViennaCLCUDADtrsv(ViennaCLBackend /*backend*/, + ViennaCLUplo uplo, ViennaCLOrder order, ViennaCLTranspose transA, ViennaCLDiag diag, + ViennaCLInt n, double *A, ViennaCLInt offA_row, ViennaCLInt offA_col, ViennaCLInt incA_row, ViennaCLInt incA_col, ViennaCLInt lda, + double *x, ViennaCLInt offx, ViennaCLInt incx) +{ + viennacl::vector_base<double> v(x, viennacl::CUDA_MEMORY, n, offx, incx); + viennacl::matrix_base<double> mat(A, viennacl::CUDA_MEMORY, + n, offA_row, incA_row, n, + n, offA_col, incA_col, lda, order == ViennaCLRowMajor); + if (transA == ViennaCLTrans) + { + if (uplo == ViennaCLUpper) + if (diag == ViennaCLUnit) + viennacl::linalg::inplace_solve(viennacl::trans(mat), v, viennacl::linalg::unit_upper_tag()); + else + viennacl::linalg::inplace_solve(viennacl::trans(mat), v, viennacl::linalg::upper_tag()); + else + if (diag == ViennaCLUnit) + viennacl::linalg::inplace_solve(viennacl::trans(mat), v, viennacl::linalg::unit_lower_tag()); + else + viennacl::linalg::inplace_solve(viennacl::trans(mat), v, viennacl::linalg::lower_tag()); + } + else + { + if (uplo == ViennaCLUpper) + if (diag == ViennaCLUnit) + viennacl::linalg::inplace_solve(mat, v, viennacl::linalg::unit_upper_tag()); + else + viennacl::linalg::inplace_solve(mat, v, viennacl::linalg::upper_tag()); + else + if (diag == ViennaCLUnit) + viennacl::linalg::inplace_solve(mat, v, viennacl::linalg::unit_lower_tag()); + else + viennacl::linalg::inplace_solve(mat, v, viennacl::linalg::lower_tag()); + } + + return ViennaCLSuccess; +} + + + +// xGER + +VIENNACL_EXPORTED_FUNCTION ViennaCLStatus ViennaCLCUDASger(ViennaCLBackend /*backend*/, + ViennaCLOrder order, + ViennaCLInt m, ViennaCLInt n, + float alpha, + float *x, ViennaCLInt offx, ViennaCLInt incx, + float *y, ViennaCLInt offy, ViennaCLInt incy, + float *A, ViennaCLInt offA_row, ViennaCLInt offA_col, ViennaCLInt incA_row, ViennaCLInt incA_col, ViennaCLInt lda) +{ + viennacl::vector_base<float> v1(x, viennacl::CUDA_MEMORY, n, offx, incx); + viennacl::vector_base<float> v2(y, viennacl::CUDA_MEMORY, m, offy, incy); + viennacl::matrix_base<float> mat(A, viennacl::CUDA_MEMORY, + m, offA_row, incA_row, m, + n, offA_col, incA_col, lda, order == ViennaCLRowMajor); + + mat += alpha * viennacl::linalg::outer_prod(v1, v2); + + return ViennaCLSuccess; +} + +VIENNACL_EXPORTED_FUNCTION ViennaCLStatus ViennaCLCUDADger(ViennaCLBackend /*backend*/, + ViennaCLOrder order, + ViennaCLInt m, ViennaCLInt n, + double alpha, + double *x, ViennaCLInt offx, ViennaCLInt incx, + double *y, ViennaCLInt offy, ViennaCLInt incy, + double *A, ViennaCLInt offA_row, ViennaCLInt offA_col, ViennaCLInt incA_row, ViennaCLInt incA_col, ViennaCLInt lda) +{ + viennacl::vector_base<double> v1(x, viennacl::CUDA_MEMORY, n, offx, incx); + viennacl::vector_base<double> v2(y, viennacl::CUDA_MEMORY, m, offy, incy); + viennacl::matrix_base<double> mat(A, viennacl::CUDA_MEMORY, + m, offA_row, incA_row, m, + n, offA_col, incA_col, lda, order == ViennaCLRowMajor); + + mat += alpha * viennacl::linalg::outer_prod(v1, v2); + + return ViennaCLSuccess; +} + +#endif http://git-wip-us.apache.org/repos/asf/mahout/blob/f7c1f802/native-viennaCL/src/main/cpp/libviennacl/src/blas2_host.cpp ---------------------------------------------------------------------- diff --git a/native-viennaCL/src/main/cpp/libviennacl/src/blas2_host.cpp b/native-viennaCL/src/main/cpp/libviennacl/src/blas2_host.cpp new file mode 100644 index 0000000..b1ef39a --- /dev/null +++ b/native-viennaCL/src/main/cpp/libviennacl/src/blas2_host.cpp @@ -0,0 +1,219 @@ +/* ========================================================================= + Copyright (c) 2010-2014, Institute for Microelectronics, + Institute for Analysis and Scientific Computing, + TU Wien. + Portions of this software are copyright by UChicago Argonne, LLC. + + ----------------- + ViennaCL - The Vienna Computing Library + ----------------- + + Project Head: Karl Rupp [email protected] + + (A list of authors and contributors can be found in the PDF manual) + + License: MIT (X11), see file LICENSE in the base directory +============================================================================= */ + +// include necessary system headers +#include <iostream> + +#include "viennacl.hpp" +#include "viennacl_private.hpp" + +//include basic scalar and vector types of ViennaCL +#include "viennacl/scalar.hpp" +#include "viennacl/vector.hpp" + +#include "viennacl/vector.hpp" +#include "viennacl/matrix.hpp" +#include "viennacl/linalg/direct_solve.hpp" +#include "viennacl/linalg/prod.hpp" + + +// xGEMV + +VIENNACL_EXPORTED_FUNCTION ViennaCLStatus ViennaCLHostSgemv(ViennaCLBackend /*backend*/, + ViennaCLOrder order, ViennaCLTranspose transA, + ViennaCLInt m, ViennaCLInt n, float alpha, float *A, ViennaCLInt offA_row, ViennaCLInt offA_col, ViennaCLInt incA_row, ViennaCLInt incA_col, ViennaCLInt lda, + float *x, ViennaCLInt offx, ViennaCLInt incx, + float beta, + float *y, ViennaCLInt offy, ViennaCLInt incy) +{ + typedef viennacl::vector_base<float>::size_type size_type; + typedef viennacl::vector_base<float>::size_type difference_type; + + viennacl::vector_base<float> v1(x, viennacl::MAIN_MEMORY, size_type(n), size_type(offx), difference_type(incx)); + viennacl::vector_base<float> v2(y, viennacl::MAIN_MEMORY, size_type(m), size_type(offy), difference_type(incy)); + viennacl::matrix_base<float> mat(A, viennacl::MAIN_MEMORY, + size_type(m), size_type(offA_row), difference_type(incA_row), size_type(m), + size_type(n), size_type(offA_col), difference_type(incA_col), size_type(lda), order == ViennaCLRowMajor); + v2 *= beta; + if (transA == ViennaCLTrans) + v2 += alpha * viennacl::linalg::prod(viennacl::trans(mat), v1); + else + v2 += alpha * viennacl::linalg::prod(mat, v1); + + return ViennaCLSuccess; +} + +VIENNACL_EXPORTED_FUNCTION ViennaCLStatus ViennaCLHostDgemv(ViennaCLBackend /*backend*/, + ViennaCLOrder order, ViennaCLTranspose transA, + ViennaCLInt m, ViennaCLInt n, double alpha, double *A, ViennaCLInt offA_row, ViennaCLInt offA_col, ViennaCLInt incA_row, ViennaCLInt incA_col, ViennaCLInt lda, + double *x, ViennaCLInt offx, ViennaCLInt incx, + double beta, + double *y, ViennaCLInt offy, ViennaCLInt incy) +{ + typedef viennacl::vector_base<double>::size_type size_type; + typedef viennacl::vector_base<double>::size_type difference_type; + + viennacl::vector_base<double> v1(x, viennacl::MAIN_MEMORY, size_type(n), size_type(offx), difference_type(incx)); + viennacl::vector_base<double> v2(y, viennacl::MAIN_MEMORY, size_type(m), size_type(offy), difference_type(incy)); + viennacl::matrix_base<double> mat(A, viennacl::MAIN_MEMORY, + size_type(m), size_type(offA_row), difference_type(incA_row), size_type(m), + size_type(n), size_type(offA_col), difference_type(incA_col), size_type(lda), order == ViennaCLRowMajor); + v2 *= beta; + if (transA == ViennaCLTrans) + v2 += alpha * viennacl::linalg::prod(viennacl::trans(mat), v1); + else + v2 += alpha * viennacl::linalg::prod(mat, v1); + + return ViennaCLSuccess; +} + + + +// xTRSV + +VIENNACL_EXPORTED_FUNCTION ViennaCLStatus ViennaCLHostStrsv(ViennaCLBackend /*backend*/, + ViennaCLUplo uplo, ViennaCLOrder order, ViennaCLTranspose transA, ViennaCLDiag diag, + ViennaCLInt n, float *A, ViennaCLInt offA_row, ViennaCLInt offA_col, ViennaCLInt incA_row, ViennaCLInt incA_col, ViennaCLInt lda, + float *x, ViennaCLInt offx, ViennaCLInt incx) +{ + typedef viennacl::vector_base<float>::size_type size_type; + typedef viennacl::vector_base<float>::size_type difference_type; + + viennacl::vector_base<float> v(x, viennacl::MAIN_MEMORY, size_type(n), size_type(offx), difference_type(incx)); + viennacl::matrix_base<float> mat(A, viennacl::MAIN_MEMORY, + size_type(n), size_type(offA_row), difference_type(incA_row), size_type(n), + size_type(n), size_type(offA_col), difference_type(incA_col), size_type(lda), order == ViennaCLRowMajor); + if (transA == ViennaCLTrans) + { + if (uplo == ViennaCLUpper) + if (diag == ViennaCLUnit) + viennacl::linalg::inplace_solve(viennacl::trans(mat), v, viennacl::linalg::unit_upper_tag()); + else + viennacl::linalg::inplace_solve(viennacl::trans(mat), v, viennacl::linalg::upper_tag()); + else + if (diag == ViennaCLUnit) + viennacl::linalg::inplace_solve(viennacl::trans(mat), v, viennacl::linalg::unit_lower_tag()); + else + viennacl::linalg::inplace_solve(viennacl::trans(mat), v, viennacl::linalg::lower_tag()); + } + else + { + if (uplo == ViennaCLUpper) + if (diag == ViennaCLUnit) + viennacl::linalg::inplace_solve(mat, v, viennacl::linalg::unit_upper_tag()); + else + viennacl::linalg::inplace_solve(mat, v, viennacl::linalg::upper_tag()); + else + if (diag == ViennaCLUnit) + viennacl::linalg::inplace_solve(mat, v, viennacl::linalg::unit_lower_tag()); + else + viennacl::linalg::inplace_solve(mat, v, viennacl::linalg::lower_tag()); + } + + return ViennaCLSuccess; +} + +VIENNACL_EXPORTED_FUNCTION ViennaCLStatus ViennaCLHostDtrsv(ViennaCLBackend /*backend*/, + ViennaCLUplo uplo, ViennaCLOrder order, ViennaCLTranspose transA, ViennaCLDiag diag, + ViennaCLInt n, double *A, ViennaCLInt offA_row, ViennaCLInt offA_col, ViennaCLInt incA_row, ViennaCLInt incA_col, ViennaCLInt lda, + double *x, ViennaCLInt offx, ViennaCLInt incx) +{ + typedef viennacl::vector_base<double>::size_type size_type; + typedef viennacl::vector_base<double>::size_type difference_type; + + viennacl::vector_base<double> v(x, viennacl::MAIN_MEMORY, size_type(n), size_type(offx), difference_type(incx)); + viennacl::matrix_base<double> mat(A, viennacl::MAIN_MEMORY, + size_type(n), size_type(offA_row), difference_type(incA_row), size_type(n), + size_type(n), size_type(offA_col), difference_type(incA_col), size_type(lda), order == ViennaCLRowMajor); + if (transA == ViennaCLTrans) + { + if (uplo == ViennaCLUpper) + if (diag == ViennaCLUnit) + viennacl::linalg::inplace_solve(viennacl::trans(mat), v, viennacl::linalg::unit_upper_tag()); + else + viennacl::linalg::inplace_solve(viennacl::trans(mat), v, viennacl::linalg::upper_tag()); + else + if (diag == ViennaCLUnit) + viennacl::linalg::inplace_solve(viennacl::trans(mat), v, viennacl::linalg::unit_lower_tag()); + else + viennacl::linalg::inplace_solve(viennacl::trans(mat), v, viennacl::linalg::lower_tag()); + } + else + { + if (uplo == ViennaCLUpper) + if (diag == ViennaCLUnit) + viennacl::linalg::inplace_solve(mat, v, viennacl::linalg::unit_upper_tag()); + else + viennacl::linalg::inplace_solve(mat, v, viennacl::linalg::upper_tag()); + else + if (diag == ViennaCLUnit) + viennacl::linalg::inplace_solve(mat, v, viennacl::linalg::unit_lower_tag()); + else + viennacl::linalg::inplace_solve(mat, v, viennacl::linalg::lower_tag()); + } + + return ViennaCLSuccess; +} + + + +// xGER + +VIENNACL_EXPORTED_FUNCTION ViennaCLStatus ViennaCLHostSger(ViennaCLBackend /*backend*/, + ViennaCLOrder order, + ViennaCLInt m, ViennaCLInt n, + float alpha, + float *x, ViennaCLInt offx, ViennaCLInt incx, + float *y, ViennaCLInt offy, ViennaCLInt incy, + float *A, ViennaCLInt offA_row, ViennaCLInt offA_col, ViennaCLInt incA_row, ViennaCLInt incA_col, ViennaCLInt lda) +{ + typedef viennacl::vector_base<float>::size_type size_type; + typedef viennacl::vector_base<float>::size_type difference_type; + + viennacl::vector_base<float> v1(x, viennacl::MAIN_MEMORY, size_type(n), size_type(offx), difference_type(incx)); + viennacl::vector_base<float> v2(y, viennacl::MAIN_MEMORY, size_type(m), size_type(offy), difference_type(incy)); + viennacl::matrix_base<float> mat(A, viennacl::MAIN_MEMORY, + size_type(m), size_type(offA_row), difference_type(incA_row), size_type(m), + size_type(n), size_type(offA_col), difference_type(incA_col), size_type(lda), order == ViennaCLRowMajor); + + mat += alpha * viennacl::linalg::outer_prod(v1, v2); + + return ViennaCLSuccess; +} + +VIENNACL_EXPORTED_FUNCTION ViennaCLStatus ViennaCLHostDger(ViennaCLBackend /*backend*/, + ViennaCLOrder order, + ViennaCLInt m, ViennaCLInt n, + double alpha, + double *x, ViennaCLInt offx, ViennaCLInt incx, + double *y, ViennaCLInt offy, ViennaCLInt incy, + double *A, ViennaCLInt offA_row, ViennaCLInt offA_col, ViennaCLInt incA_row, ViennaCLInt incA_col, ViennaCLInt lda) +{ + typedef viennacl::vector_base<double>::size_type size_type; + typedef viennacl::vector_base<double>::size_type difference_type; + + viennacl::vector_base<double> v1(x, viennacl::MAIN_MEMORY, size_type(n), size_type(offx), difference_type(incx)); + viennacl::vector_base<double> v2(y, viennacl::MAIN_MEMORY, size_type(m), size_type(offy), difference_type(incy)); + viennacl::matrix_base<double> mat(A, viennacl::MAIN_MEMORY, + size_type(m), size_type(offA_row), difference_type(incA_row), size_type(m), + size_type(n), size_type(offA_col), difference_type(incA_col), size_type(lda), order == ViennaCLRowMajor); + + mat += alpha * viennacl::linalg::outer_prod(v1, v2); + + return ViennaCLSuccess; +} + http://git-wip-us.apache.org/repos/asf/mahout/blob/f7c1f802/native-viennaCL/src/main/cpp/libviennacl/src/blas2_host.cu ---------------------------------------------------------------------- diff --git a/native-viennaCL/src/main/cpp/libviennacl/src/blas2_host.cu b/native-viennaCL/src/main/cpp/libviennacl/src/blas2_host.cu new file mode 100644 index 0000000..b1ef39a --- /dev/null +++ b/native-viennaCL/src/main/cpp/libviennacl/src/blas2_host.cu @@ -0,0 +1,219 @@ +/* ========================================================================= + Copyright (c) 2010-2014, Institute for Microelectronics, + Institute for Analysis and Scientific Computing, + TU Wien. + Portions of this software are copyright by UChicago Argonne, LLC. + + ----------------- + ViennaCL - The Vienna Computing Library + ----------------- + + Project Head: Karl Rupp [email protected] + + (A list of authors and contributors can be found in the PDF manual) + + License: MIT (X11), see file LICENSE in the base directory +============================================================================= */ + +// include necessary system headers +#include <iostream> + +#include "viennacl.hpp" +#include "viennacl_private.hpp" + +//include basic scalar and vector types of ViennaCL +#include "viennacl/scalar.hpp" +#include "viennacl/vector.hpp" + +#include "viennacl/vector.hpp" +#include "viennacl/matrix.hpp" +#include "viennacl/linalg/direct_solve.hpp" +#include "viennacl/linalg/prod.hpp" + + +// xGEMV + +VIENNACL_EXPORTED_FUNCTION ViennaCLStatus ViennaCLHostSgemv(ViennaCLBackend /*backend*/, + ViennaCLOrder order, ViennaCLTranspose transA, + ViennaCLInt m, ViennaCLInt n, float alpha, float *A, ViennaCLInt offA_row, ViennaCLInt offA_col, ViennaCLInt incA_row, ViennaCLInt incA_col, ViennaCLInt lda, + float *x, ViennaCLInt offx, ViennaCLInt incx, + float beta, + float *y, ViennaCLInt offy, ViennaCLInt incy) +{ + typedef viennacl::vector_base<float>::size_type size_type; + typedef viennacl::vector_base<float>::size_type difference_type; + + viennacl::vector_base<float> v1(x, viennacl::MAIN_MEMORY, size_type(n), size_type(offx), difference_type(incx)); + viennacl::vector_base<float> v2(y, viennacl::MAIN_MEMORY, size_type(m), size_type(offy), difference_type(incy)); + viennacl::matrix_base<float> mat(A, viennacl::MAIN_MEMORY, + size_type(m), size_type(offA_row), difference_type(incA_row), size_type(m), + size_type(n), size_type(offA_col), difference_type(incA_col), size_type(lda), order == ViennaCLRowMajor); + v2 *= beta; + if (transA == ViennaCLTrans) + v2 += alpha * viennacl::linalg::prod(viennacl::trans(mat), v1); + else + v2 += alpha * viennacl::linalg::prod(mat, v1); + + return ViennaCLSuccess; +} + +VIENNACL_EXPORTED_FUNCTION ViennaCLStatus ViennaCLHostDgemv(ViennaCLBackend /*backend*/, + ViennaCLOrder order, ViennaCLTranspose transA, + ViennaCLInt m, ViennaCLInt n, double alpha, double *A, ViennaCLInt offA_row, ViennaCLInt offA_col, ViennaCLInt incA_row, ViennaCLInt incA_col, ViennaCLInt lda, + double *x, ViennaCLInt offx, ViennaCLInt incx, + double beta, + double *y, ViennaCLInt offy, ViennaCLInt incy) +{ + typedef viennacl::vector_base<double>::size_type size_type; + typedef viennacl::vector_base<double>::size_type difference_type; + + viennacl::vector_base<double> v1(x, viennacl::MAIN_MEMORY, size_type(n), size_type(offx), difference_type(incx)); + viennacl::vector_base<double> v2(y, viennacl::MAIN_MEMORY, size_type(m), size_type(offy), difference_type(incy)); + viennacl::matrix_base<double> mat(A, viennacl::MAIN_MEMORY, + size_type(m), size_type(offA_row), difference_type(incA_row), size_type(m), + size_type(n), size_type(offA_col), difference_type(incA_col), size_type(lda), order == ViennaCLRowMajor); + v2 *= beta; + if (transA == ViennaCLTrans) + v2 += alpha * viennacl::linalg::prod(viennacl::trans(mat), v1); + else + v2 += alpha * viennacl::linalg::prod(mat, v1); + + return ViennaCLSuccess; +} + + + +// xTRSV + +VIENNACL_EXPORTED_FUNCTION ViennaCLStatus ViennaCLHostStrsv(ViennaCLBackend /*backend*/, + ViennaCLUplo uplo, ViennaCLOrder order, ViennaCLTranspose transA, ViennaCLDiag diag, + ViennaCLInt n, float *A, ViennaCLInt offA_row, ViennaCLInt offA_col, ViennaCLInt incA_row, ViennaCLInt incA_col, ViennaCLInt lda, + float *x, ViennaCLInt offx, ViennaCLInt incx) +{ + typedef viennacl::vector_base<float>::size_type size_type; + typedef viennacl::vector_base<float>::size_type difference_type; + + viennacl::vector_base<float> v(x, viennacl::MAIN_MEMORY, size_type(n), size_type(offx), difference_type(incx)); + viennacl::matrix_base<float> mat(A, viennacl::MAIN_MEMORY, + size_type(n), size_type(offA_row), difference_type(incA_row), size_type(n), + size_type(n), size_type(offA_col), difference_type(incA_col), size_type(lda), order == ViennaCLRowMajor); + if (transA == ViennaCLTrans) + { + if (uplo == ViennaCLUpper) + if (diag == ViennaCLUnit) + viennacl::linalg::inplace_solve(viennacl::trans(mat), v, viennacl::linalg::unit_upper_tag()); + else + viennacl::linalg::inplace_solve(viennacl::trans(mat), v, viennacl::linalg::upper_tag()); + else + if (diag == ViennaCLUnit) + viennacl::linalg::inplace_solve(viennacl::trans(mat), v, viennacl::linalg::unit_lower_tag()); + else + viennacl::linalg::inplace_solve(viennacl::trans(mat), v, viennacl::linalg::lower_tag()); + } + else + { + if (uplo == ViennaCLUpper) + if (diag == ViennaCLUnit) + viennacl::linalg::inplace_solve(mat, v, viennacl::linalg::unit_upper_tag()); + else + viennacl::linalg::inplace_solve(mat, v, viennacl::linalg::upper_tag()); + else + if (diag == ViennaCLUnit) + viennacl::linalg::inplace_solve(mat, v, viennacl::linalg::unit_lower_tag()); + else + viennacl::linalg::inplace_solve(mat, v, viennacl::linalg::lower_tag()); + } + + return ViennaCLSuccess; +} + +VIENNACL_EXPORTED_FUNCTION ViennaCLStatus ViennaCLHostDtrsv(ViennaCLBackend /*backend*/, + ViennaCLUplo uplo, ViennaCLOrder order, ViennaCLTranspose transA, ViennaCLDiag diag, + ViennaCLInt n, double *A, ViennaCLInt offA_row, ViennaCLInt offA_col, ViennaCLInt incA_row, ViennaCLInt incA_col, ViennaCLInt lda, + double *x, ViennaCLInt offx, ViennaCLInt incx) +{ + typedef viennacl::vector_base<double>::size_type size_type; + typedef viennacl::vector_base<double>::size_type difference_type; + + viennacl::vector_base<double> v(x, viennacl::MAIN_MEMORY, size_type(n), size_type(offx), difference_type(incx)); + viennacl::matrix_base<double> mat(A, viennacl::MAIN_MEMORY, + size_type(n), size_type(offA_row), difference_type(incA_row), size_type(n), + size_type(n), size_type(offA_col), difference_type(incA_col), size_type(lda), order == ViennaCLRowMajor); + if (transA == ViennaCLTrans) + { + if (uplo == ViennaCLUpper) + if (diag == ViennaCLUnit) + viennacl::linalg::inplace_solve(viennacl::trans(mat), v, viennacl::linalg::unit_upper_tag()); + else + viennacl::linalg::inplace_solve(viennacl::trans(mat), v, viennacl::linalg::upper_tag()); + else + if (diag == ViennaCLUnit) + viennacl::linalg::inplace_solve(viennacl::trans(mat), v, viennacl::linalg::unit_lower_tag()); + else + viennacl::linalg::inplace_solve(viennacl::trans(mat), v, viennacl::linalg::lower_tag()); + } + else + { + if (uplo == ViennaCLUpper) + if (diag == ViennaCLUnit) + viennacl::linalg::inplace_solve(mat, v, viennacl::linalg::unit_upper_tag()); + else + viennacl::linalg::inplace_solve(mat, v, viennacl::linalg::upper_tag()); + else + if (diag == ViennaCLUnit) + viennacl::linalg::inplace_solve(mat, v, viennacl::linalg::unit_lower_tag()); + else + viennacl::linalg::inplace_solve(mat, v, viennacl::linalg::lower_tag()); + } + + return ViennaCLSuccess; +} + + + +// xGER + +VIENNACL_EXPORTED_FUNCTION ViennaCLStatus ViennaCLHostSger(ViennaCLBackend /*backend*/, + ViennaCLOrder order, + ViennaCLInt m, ViennaCLInt n, + float alpha, + float *x, ViennaCLInt offx, ViennaCLInt incx, + float *y, ViennaCLInt offy, ViennaCLInt incy, + float *A, ViennaCLInt offA_row, ViennaCLInt offA_col, ViennaCLInt incA_row, ViennaCLInt incA_col, ViennaCLInt lda) +{ + typedef viennacl::vector_base<float>::size_type size_type; + typedef viennacl::vector_base<float>::size_type difference_type; + + viennacl::vector_base<float> v1(x, viennacl::MAIN_MEMORY, size_type(n), size_type(offx), difference_type(incx)); + viennacl::vector_base<float> v2(y, viennacl::MAIN_MEMORY, size_type(m), size_type(offy), difference_type(incy)); + viennacl::matrix_base<float> mat(A, viennacl::MAIN_MEMORY, + size_type(m), size_type(offA_row), difference_type(incA_row), size_type(m), + size_type(n), size_type(offA_col), difference_type(incA_col), size_type(lda), order == ViennaCLRowMajor); + + mat += alpha * viennacl::linalg::outer_prod(v1, v2); + + return ViennaCLSuccess; +} + +VIENNACL_EXPORTED_FUNCTION ViennaCLStatus ViennaCLHostDger(ViennaCLBackend /*backend*/, + ViennaCLOrder order, + ViennaCLInt m, ViennaCLInt n, + double alpha, + double *x, ViennaCLInt offx, ViennaCLInt incx, + double *y, ViennaCLInt offy, ViennaCLInt incy, + double *A, ViennaCLInt offA_row, ViennaCLInt offA_col, ViennaCLInt incA_row, ViennaCLInt incA_col, ViennaCLInt lda) +{ + typedef viennacl::vector_base<double>::size_type size_type; + typedef viennacl::vector_base<double>::size_type difference_type; + + viennacl::vector_base<double> v1(x, viennacl::MAIN_MEMORY, size_type(n), size_type(offx), difference_type(incx)); + viennacl::vector_base<double> v2(y, viennacl::MAIN_MEMORY, size_type(m), size_type(offy), difference_type(incy)); + viennacl::matrix_base<double> mat(A, viennacl::MAIN_MEMORY, + size_type(m), size_type(offA_row), difference_type(incA_row), size_type(m), + size_type(n), size_type(offA_col), difference_type(incA_col), size_type(lda), order == ViennaCLRowMajor); + + mat += alpha * viennacl::linalg::outer_prod(v1, v2); + + return ViennaCLSuccess; +} + http://git-wip-us.apache.org/repos/asf/mahout/blob/f7c1f802/native-viennaCL/src/main/cpp/libviennacl/src/blas2_opencl.cpp ---------------------------------------------------------------------- diff --git a/native-viennaCL/src/main/cpp/libviennacl/src/blas2_opencl.cpp b/native-viennaCL/src/main/cpp/libviennacl/src/blas2_opencl.cpp new file mode 100644 index 0000000..20c4994 --- /dev/null +++ b/native-viennaCL/src/main/cpp/libviennacl/src/blas2_opencl.cpp @@ -0,0 +1,219 @@ +/* ========================================================================= + Copyright (c) 2010-2014, Institute for Microelectronics, + Institute for Analysis and Scientific Computing, + TU Wien. + Portions of this software are copyright by UChicago Argonne, LLC. + + ----------------- + ViennaCL - The Vienna Computing Library + ----------------- + + Project Head: Karl Rupp [email protected] + + (A list of authors and contributors can be found in the PDF manual) + + License: MIT (X11), see file LICENSE in the base directory +============================================================================= */ + +// include necessary system headers +#include <iostream> + +#include "viennacl.hpp" +#include "viennacl_private.hpp" + +//include basic scalar and vector types of ViennaCL +#include "viennacl/scalar.hpp" +#include "viennacl/vector.hpp" + +#include "viennacl/vector.hpp" +#include "viennacl/matrix.hpp" +#include "viennacl/linalg/direct_solve.hpp" +#include "viennacl/linalg/prod.hpp" + + +// xGEMV + +VIENNACL_EXPORTED_FUNCTION ViennaCLStatus ViennaCLOpenCLSgemv(ViennaCLBackend backend, + ViennaCLOrder order, ViennaCLTranspose transA, + ViennaCLInt m, ViennaCLInt n, float alpha, cl_mem A, ViennaCLInt offA_row, ViennaCLInt offA_col, ViennaCLInt incA_row, ViennaCLInt incA_col, ViennaCLInt lda, + cl_mem x, ViennaCLInt offx, ViennaCLInt incx, + float beta, + cl_mem y, ViennaCLInt offy, ViennaCLInt incy) +{ + typedef viennacl::vector_base<float>::size_type size_type; + typedef viennacl::vector_base<float>::size_type difference_type; + + viennacl::vector_base<float> v1(x, size_type(n), size_type(offx), difference_type(incx), viennacl::ocl::get_context(backend->opencl_backend.context_id)); + viennacl::vector_base<float> v2(y, size_type(m), size_type(offy), difference_type(incy), viennacl::ocl::get_context(backend->opencl_backend.context_id)); + viennacl::matrix_base<float> mat(A, viennacl::ocl::get_context(backend->opencl_backend.context_id), + size_type(m), size_type(offA_row), difference_type(incA_row), size_type(m), + size_type(n), size_type(offA_col), difference_type(incA_col), size_type(lda), order == ViennaCLRowMajor); + v2 *= beta; + if (transA == ViennaCLTrans) + v2 += alpha * viennacl::linalg::prod(viennacl::trans(mat), v1); + else + v2 += alpha * viennacl::linalg::prod(mat, v1); + + return ViennaCLSuccess; +} + +VIENNACL_EXPORTED_FUNCTION ViennaCLStatus ViennaCLOpenCLDgemv(ViennaCLBackend backend, + ViennaCLOrder order, ViennaCLTranspose transA, + ViennaCLInt m, ViennaCLInt n, double alpha, cl_mem A, ViennaCLInt offA_row, ViennaCLInt offA_col, ViennaCLInt incA_row, ViennaCLInt incA_col, ViennaCLInt lda, + cl_mem x, ViennaCLInt offx, ViennaCLInt incx, + double beta, + cl_mem y, ViennaCLInt offy, ViennaCLInt incy) +{ + typedef viennacl::vector_base<double>::size_type size_type; + typedef viennacl::vector_base<double>::size_type difference_type; + + viennacl::vector_base<double> v1(x, size_type(n), size_type(offx), difference_type(incx), viennacl::ocl::get_context(backend->opencl_backend.context_id)); + viennacl::vector_base<double> v2(y, size_type(m), size_type(offy), difference_type(incy), viennacl::ocl::get_context(backend->opencl_backend.context_id)); + viennacl::matrix_base<double> mat(A, viennacl::ocl::get_context(backend->opencl_backend.context_id), + size_type(m), size_type(offA_row), difference_type(incA_row), size_type(m), + size_type(n), size_type(offA_col), difference_type(incA_col), size_type(lda), order == ViennaCLRowMajor); + v2 *= beta; + if (transA == ViennaCLTrans) + v2 += alpha * viennacl::linalg::prod(viennacl::trans(mat), v1); + else + v2 += alpha * viennacl::linalg::prod(mat, v1); + + return ViennaCLSuccess; +} + + + +// xTRSV + +VIENNACL_EXPORTED_FUNCTION ViennaCLStatus ViennaCLOpenCLStrsv(ViennaCLBackend backend, + ViennaCLUplo uplo, ViennaCLOrder order, ViennaCLTranspose transA, ViennaCLDiag diag, + ViennaCLInt n, cl_mem A, ViennaCLInt offA_row, ViennaCLInt offA_col, ViennaCLInt incA_row, ViennaCLInt incA_col, ViennaCLInt lda, + cl_mem x, ViennaCLInt offx, ViennaCLInt incx) +{ + typedef viennacl::vector_base<float>::size_type size_type; + typedef viennacl::vector_base<float>::size_type difference_type; + + viennacl::vector_base<float> v(x, size_type(n), size_type(offx), difference_type(incx), viennacl::ocl::get_context(backend->opencl_backend.context_id)); + viennacl::matrix_base<float> mat(A, viennacl::ocl::get_context(backend->opencl_backend.context_id), + size_type(n), size_type(offA_row), difference_type(incA_row), size_type(n), + size_type(n), size_type(offA_col), difference_type(incA_col), size_type(lda), order == ViennaCLRowMajor); + if (transA == ViennaCLTrans) + { + if (uplo == ViennaCLUpper) + if (diag == ViennaCLUnit) + viennacl::linalg::inplace_solve(viennacl::trans(mat), v, viennacl::linalg::unit_upper_tag()); + else + viennacl::linalg::inplace_solve(viennacl::trans(mat), v, viennacl::linalg::upper_tag()); + else + if (diag == ViennaCLUnit) + viennacl::linalg::inplace_solve(viennacl::trans(mat), v, viennacl::linalg::unit_lower_tag()); + else + viennacl::linalg::inplace_solve(viennacl::trans(mat), v, viennacl::linalg::lower_tag()); + } + else + { + if (uplo == ViennaCLUpper) + if (diag == ViennaCLUnit) + viennacl::linalg::inplace_solve(mat, v, viennacl::linalg::unit_upper_tag()); + else + viennacl::linalg::inplace_solve(mat, v, viennacl::linalg::upper_tag()); + else + if (diag == ViennaCLUnit) + viennacl::linalg::inplace_solve(mat, v, viennacl::linalg::unit_lower_tag()); + else + viennacl::linalg::inplace_solve(mat, v, viennacl::linalg::lower_tag()); + } + + return ViennaCLSuccess; +} + +VIENNACL_EXPORTED_FUNCTION ViennaCLStatus ViennaCLOpenCLDtrsv(ViennaCLBackend backend, + ViennaCLUplo uplo, ViennaCLOrder order, ViennaCLTranspose transA, ViennaCLDiag diag, + ViennaCLInt n, cl_mem A, ViennaCLInt offA_row, ViennaCLInt offA_col, ViennaCLInt incA_row, ViennaCLInt incA_col, ViennaCLInt lda, + cl_mem x, ViennaCLInt offx, ViennaCLInt incx) +{ + typedef viennacl::vector_base<double>::size_type size_type; + typedef viennacl::vector_base<double>::size_type difference_type; + + viennacl::vector_base<double> v(x, size_type(n), size_type(offx), difference_type(incx), viennacl::ocl::get_context(backend->opencl_backend.context_id)); + viennacl::matrix_base<double> mat(A, viennacl::ocl::get_context(backend->opencl_backend.context_id), + size_type(n), size_type(offA_row), difference_type(incA_row), size_type(n), + size_type(n), size_type(offA_col), difference_type(incA_col), size_type(lda), order == ViennaCLRowMajor); + if (transA == ViennaCLTrans) + { + if (uplo == ViennaCLUpper) + if (diag == ViennaCLUnit) + viennacl::linalg::inplace_solve(viennacl::trans(mat), v, viennacl::linalg::unit_upper_tag()); + else + viennacl::linalg::inplace_solve(viennacl::trans(mat), v, viennacl::linalg::upper_tag()); + else + if (diag == ViennaCLUnit) + viennacl::linalg::inplace_solve(viennacl::trans(mat), v, viennacl::linalg::unit_lower_tag()); + else + viennacl::linalg::inplace_solve(viennacl::trans(mat), v, viennacl::linalg::lower_tag()); + } + else + { + if (uplo == ViennaCLUpper) + if (diag == ViennaCLUnit) + viennacl::linalg::inplace_solve(mat, v, viennacl::linalg::unit_upper_tag()); + else + viennacl::linalg::inplace_solve(mat, v, viennacl::linalg::upper_tag()); + else + if (diag == ViennaCLUnit) + viennacl::linalg::inplace_solve(mat, v, viennacl::linalg::unit_lower_tag()); + else + viennacl::linalg::inplace_solve(mat, v, viennacl::linalg::lower_tag()); + } + + return ViennaCLSuccess; +} + + + +// xGER + +VIENNACL_EXPORTED_FUNCTION ViennaCLStatus ViennaCLOpenCLSger(ViennaCLBackend backend, + ViennaCLOrder order, + ViennaCLInt m, ViennaCLInt n, + float alpha, + cl_mem x, ViennaCLInt offx, ViennaCLInt incx, + cl_mem y, ViennaCLInt offy, ViennaCLInt incy, + cl_mem A, ViennaCLInt offA_row, ViennaCLInt offA_col, ViennaCLInt incA_row, ViennaCLInt incA_col, ViennaCLInt lda) +{ + typedef viennacl::vector_base<float>::size_type size_type; + typedef viennacl::vector_base<float>::size_type difference_type; + + viennacl::vector_base<float> v1(x, size_type(n), size_type(offx), difference_type(incx), viennacl::ocl::get_context(backend->opencl_backend.context_id)); + viennacl::vector_base<float> v2(y, size_type(m), size_type(offy), difference_type(incy), viennacl::ocl::get_context(backend->opencl_backend.context_id)); + viennacl::matrix_base<float> mat(A, viennacl::ocl::get_context(backend->opencl_backend.context_id), + size_type(m), size_type(offA_row), difference_type(incA_row), size_type(m), + size_type(n), size_type(offA_col), difference_type(incA_col), size_type(lda), order == ViennaCLRowMajor); + + mat += alpha * viennacl::linalg::outer_prod(v1, v2); + + return ViennaCLSuccess; +} + +VIENNACL_EXPORTED_FUNCTION ViennaCLStatus ViennaCLOpenCLDger(ViennaCLBackend backend, + ViennaCLOrder order, + ViennaCLInt m, ViennaCLInt n, + double alpha, + cl_mem x, ViennaCLInt offx, ViennaCLInt incx, + cl_mem y, ViennaCLInt offy, ViennaCLInt incy, + cl_mem A, ViennaCLInt offA_row, ViennaCLInt offA_col, ViennaCLInt incA_row, ViennaCLInt incA_col, ViennaCLInt lda) +{ + typedef viennacl::vector_base<double>::size_type size_type; + typedef viennacl::vector_base<double>::size_type difference_type; + + viennacl::vector_base<double> v1(x, size_type(n), size_type(offx), difference_type(incx), viennacl::ocl::get_context(backend->opencl_backend.context_id)); + viennacl::vector_base<double> v2(y, size_type(m), size_type(offy), difference_type(incy), viennacl::ocl::get_context(backend->opencl_backend.context_id)); + viennacl::matrix_base<double> mat(A, viennacl::ocl::get_context(backend->opencl_backend.context_id), + size_type(m), size_type(offA_row), difference_type(incA_row), size_type(m), + size_type(n), size_type(offA_col), difference_type(incA_col), size_type(lda), order == ViennaCLRowMajor); + + mat += alpha * viennacl::linalg::outer_prod(v1, v2); + + return ViennaCLSuccess; +} +
