cublas.hpp

Go to the documentation of this file.

//          Copyright RedPortal, mujjingun 2017 - 2018.
// Distributed under the Boost Software License, Version 1.0.
//    (See accompanying file LICENSE or copy at
//          http://www.boost.org/LICENSE_1_0.txt)

#ifndef _MGCPP_CUDA_LIBS_CUBLAS_HPP_
#define _MGCPP_CUDA_LIBS_CUBLAS_HPP_

#include <cstdlib>

#include <mgcpp/system/outcome.hpp>

#include <cublas_v2.h>

namespace mgcpp {
namespace cublas {
// lv1
template <typename T>
outcome::result<void> dot(cublasHandle_t handle,
                          size_t n,
                          T const* x,
                          size_t incx,
                          T const* y,
                          size_t incy,
                          T* result) noexcept;

template <typename T>
outcome::result<void> axpy(cublasHandle_t handle,
                           size_t n,
                           T const* alpha,
                           T const* x,
                           size_t incx,
                           T* y,
                           size_t incy) noexcept;

template <typename VectorType, typename ScalarType>
outcome::result<void> scal(cublasHandle_t handle,
                           size_t n,
                           ScalarType const* alpha,
                           VectorType* vec,
                           size_t incvec) noexcept;

// lv2

template <typename T>
outcome::result<void> gemv(cublasHandle_t handle,
                           cublasOperation_t trans,
                           int m,
                           int n,
                           T const* alpha,
                           T const* A,
                           int lda,
                           T const* x,
                           int incx,
                           T const* beta,
                           T* y,
                           int incy);

template <typename T>
outcome::result<void> ger(cublasHandle_t handle,
                          size_t m,
                          size_t n,
                          T const* alpha,
                          T const* x,
                          size_t incx,
                          T const* y,
                          size_t incy,
                          T* A,
                          int lda);

// lv3

template <typename T>
outcome::result<void> gemm(cublasHandle_t handle,
                           cublasOperation_t transa,
                           cublasOperation_t transb,
                           size_t m,
                           size_t n,
                           size_t k,
                           T const* alpha,
                           T const* A,
                           size_t lda,
                           T const* B,
                           size_t ldb,
                           T const* beta,
                           T* C,
                           size_t ldc) noexcept;

template <typename T>
outcome::result<void> gemm_batched(cublasHandle_t handle,
                                   cublasOperation_t transa,
                                   cublasOperation_t transb,
                                   size_t m,
                                   size_t n,
                                   size_t k,
                                   T const* alpha,
                                   T const* A,
                                   size_t lda,
                                   T const* B,
                                   size_t ldb,
                                   T const* beta,
                                   T* C,
                                   size_t ldc) noexcept;

// blas-like cublas extensions

template <typename T>
outcome::result<void> geam(cublasHandle_t handle,
                           cublasOperation_t transa,
                           cublasOperation_t transb,
                           size_t m,
                           size_t n,
                           const T* alpha,
                           const T* A,
                           size_t lda,
                           const T* beta,
                           const T* B,
                           size_t ldb,
                           T* C,
                           size_t ldc) noexcept;
}  // namespace cublas
}  // namespace mgcpp
#endif