templateCublas.hpp

Go to the documentation of this file.

/** \file templateCublas.hpp
 * \author Jared R. Males
 * \brief A template interface to cuBlas
 * \ingroup cuda_files
 *
 */
 
//***********************************************************************//
// Copyright 2019,2020 Jared R. Males (jaredmales@gmail.com)
//
// This file is part of mxlib.
//
// mxlib is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// mxlib is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with mxlib.  If not, see <http://www.gnu.org/licenses/>.
//***********************************************************************//
 
#ifndef math_templateCublas_hpp
#define math_templateCublas_hpp
 
#include <cuda_runtime.h>
#include <cublas_v2.h>
 
namespace mx
{
namespace cuda
{
 
/// Multiplies a vector by a scalar, overwriting the vector with the result.
/** Implements
 * \f[
 * \vec{x} = \alpha \vec{x}
 * \f]
 *
 * Specializations are provided for float, double, complex-float, and complex-double
 *
 * \tparam floatT a floating-point type, either float, double, complex-float, or complex-double
 *
 * \test Scenario: scaling a vector with cublas \ref test_math_templateCublas_scal "[test doc]"
 *
 * \ingroup cublas
 */
template <typename floatT>
cublasStatus_t cublasTscal( cublasHandle_t handle, ///< [in] The cublas context handle
                            int n,                 ///< [in] Number of elements in the vector
                            const floatT *alpha,   ///< [in] The scalar
                            floatT *x,             ///< [in.out] The vector of length n
                            int incx               ///< [in] The stride of the vector
);
 
/// Multiplies a vector by a scalar, adding it to a second vector which is overwritten by the result.
/** Implements
 * \f[
 * \vec{y} = \alpha \vec{x} + \vec{y}
 * \f]
 *
 * Specializations are provided for float, double, complex-float, and complex-double
 *
 * \tparam floatT a floating-point type, either float, double, complex-float, or complex-double
 *
 * \test Scenario: scaling and accumulating a vector with cublas \ref test_math_templateCublas_axpy "[test doc]"
 *
 * \ingroup cublas
 */
template <typename floatT>
cublasStatus_t cublasTaxpy( cublasHandle_t handle, ///< [in] handle to the cuBLAS library context.
                            int n,                 ///< [in] scalar used for multiplication.
                            const floatT *alpha,   ///< [in] number of elements in the vector x and y
                            const floatT *x,       ///< [in] vector with n elements.
                            int incx,              ///< [in] stride between consecutive elements of x
                            floatT *y,             ///< [in.out] vector with n elements.
                            int incy               ///< [in] stride between consecutive elements of y
);
 
//----------------------------------------------------
// Element-wise (Hadamard) products of vectors
 
/// Calculates the element-wise product of two vectors, storing the result in the first.
/** Calculates
 * \f$
 * x = x * y
 * \f$
 * element by element, a.k.a. the Hadamard product.
 *
 * Specializations are provided for:
 * - float,float
 * - complex-float, float
 * - complex-float, complex-float
 * - double, double
 * - complex-double, double
 * - complex-double, complex-double
 *
 * \test Scenario: multiplying two vectors element by element \ref test_math_templateCublas_elementwiseXxY "[test doc]"
 *
 * \ingroup cublas
 */
template <typename dataT1, typename dataT2>
cudaError_t elementwiseXxY(
    dataT1 *x, ///< [in.out] device pointer for the 1st vector.  Is replaced with the product of the two vectors
    dataT2 *y, ///< [in] device pointer for the 2nd vector.
    int size   ///< [in] the number of elements in the vectors.
);
 
//----------------------------------------------------
// Tgemv
 
/// Perform a matrix-vector multiplication.
/** Implements
 * \f[
 * \vec{y} = \alpha \mathbf{A} \vec{x} + \beta \vec{y}
 * \f]
 *
 * Specializations are provided for float, double, complex-float, and complex-double
 *
 * \tparam floatT a floating-point type, either float, double, complex-float, or complex-double
 *
 * \tests Scenario: multiplying a vectory by a matrix \ref test_math_templateCublas_cublasTgemv_inc "[code doc]"
 *
 * \ingroup cublas
 */
template <typename floatT>
cublasStatus_t
cublasTgemv( cublasHandle_t handle,   ///< [in] handle to the cuBLAS library context.
             cublasOperation_t trans, ///< [in] operation on a, CUBLAS_OP_N for none, and CUBLAS_OP_T for transpose
             int m,                   ///< [in] rows in matrix A.
             int n,                   ///< [in] columns in matrix A.
             const floatT *alpha,     ///< [in] scalar used for multiplication of A
             const floatT *A, ///< [in] array of dimension lda x n with lda >= max(1,m). The leading m by n part of the
                              ///< array A is multiplied by alpha and x.  Unchanged.
             int lda,         ///< [in] leading dimension of A. lda must be at least max(1,m).
             const floatT *x, ///< [in] vector of at least (1+(n-1)*abs(incx)) elements if transa==CUBLAS_OP_N and at
                              ///< least (1+(m-1)*abs(incx)) elements otherwise.
             int incx,        ///< [in] stride of x.
             const floatT *
                 beta, ///< [in] scalar used for multiplication of y, if beta==0 then y does not need to be initialized.
             floatT *y, ///< [in.out] vector of at least (1+(m-1)*abs(incy)) elements if transa==CUBLAS_OP_N and at
                        ///< least (1+(n-1)*abs(incy)) elements otherwise.
             int incy   ///< [in] stride of y
);
 
/// Perform a matrix-vector multiplication for stride-less arrays
/** Implements
 * \f[
 * \vec{y} = \alpha \mathbf{A} \vec{x} + \beta \vec{y}
 * \f]
 *
 * Specializations are provided for float, double, complex-float, and complex-double
 *
 * \overload
 * This version assumes stride is 1 in all arrays.
 *
 * \tparam floatT a floating-point type, either float, double, complex-float, or complex-double
 *
 * \ingroup cublas
 */
template <typename floatT>
cublasStatus_t
cublasTgemv( cublasHandle_t handle,   ///< [in] handle to the cuBLAS library context.
             cublasOperation_t trans, ///< [in] operation on a, CUBLAS_OP_N for none, and CUBLAS_OP_T for transpose
             int m,                   ///< [in] rows in matrix A.
             int n,                   ///< [in] columns in matrix A.
             const floatT *alpha,     ///< [in] scalar used for multiplication of A
             const floatT *A,         ///< [in] array of dimension m x n.  Unchanged.
             const floatT *x, ///< [in] vector of at least (1+(n-1)*abs(incx)) elements if transa==CUBLAS_OP_N and at
                              ///< least (1+(m-1)*abs(incx)) elements otherwise.
             const floatT *
                 beta, ///< [in] scalar used for multiplication of y, if beta==0 then y does not need to be initialized.
             floatT *y ///< [in.out] vector of at least (1+(m-1)*abs(incy)) elements if transa==CUBLAS_OP_N and at least
                       ///< (1+(n-1)*abs(incy)) elements otherwise.
);
 
template <>
cublasStatus_t cublasTgemv<float>( cublasHandle_t handle,
                                   cublasOperation_t trans,
                                   int m,
                                   int n,
                                   const float *alpha,
                                   const float *A,
                                   int lda,
                                   const float *x,
                                   int incx,
                                   const float *beta,
                                   float *y,
                                   int incy );
 
template <>
cublasStatus_t cublasTgemv<double>( cublasHandle_t handle,
                                    cublasOperation_t trans,
                                    int m,
                                    int n,
                                    const double *alpha,
                                    const double *A,
                                    int lda,
                                    const double *x,
                                    int incx,
                                    const double *beta,
                                    double *y,
                                    int incy );
 
template <>
cublasStatus_t cublasTgemv<float>( cublasHandle_t handle,
                                   cublasOperation_t trans,
                                   int m,
                                   int n,
                                   const float *alpha,
                                   const float *A,
                                   const float *x,
                                   const float *beta,
                                   float *y );
 
template <>
cublasStatus_t cublasTgemv<double>( cublasHandle_t handle,
                                    cublasOperation_t trans,
                                    int m,
                                    int n,
                                    const double *alpha,
                                    const double *A,
                                    const double *x,
                                    const double *beta,
                                    double *y );
 
} // namespace cuda
} // namespace mx
#endif // math_templateCublas_hpp