You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@mahout.apache.org by ap...@apache.org on 2016/06/08 21:40:46 UTC
[49/51] [partial] mahout git commit: (nojira) add native-viennaCL
module to codebase. closes apache/mahout#241
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 rupp@iue.tuwien.ac.at
+
+ (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 rupp@iue.tuwien.ac.at
+
+ (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 rupp@iue.tuwien.ac.at
+
+ (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 rupp@iue.tuwien.ac.at
+
+ (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 rupp@iue.tuwien.ac.at
+
+ (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 rupp@iue.tuwien.ac.at
+
+ (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 rupp@iue.tuwien.ac.at
+
+ (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;
+}
+