qmcplusplus::compute::BLAS Namespace Reference

Functions
void	gemm (BLASHandle< PlatformKind::CUDA > &handle, const char transa, const char transb, int m, int n, int k, const float &alpha, const float *A, int lda, const float *B, int ldb, const float &beta, float *C, int ldc)
void	gemm (BLASHandle< PlatformKind::CUDA > &handle, const char transa, const char transb, int m, int n, int k, const double &alpha, const double *A, int lda, const double *B, int ldb, const double &beta, double *C, int ldc)
void	gemm (BLASHandle< PlatformKind::CUDA > &handle, const char transa, const char transb, int m, int n, int k, const std::complex< float > &alpha, const std::complex< float > *A, int lda, const std::complex< float > *B, int ldb, const std::complex< float > &beta, std::complex< float > *C, int ldc)
void	gemm (BLASHandle< PlatformKind::CUDA > &handle, const char transa, const char transb, int m, int n, int k, const std::complex< double > &alpha, const std::complex< double > *A, int lda, const std::complex< double > *B, int ldb, const std::complex< double > &beta, std::complex< double > *C, int ldc)
void	gemv (BLASHandle< PlatformKind::CUDA > &handle, const char trans, const int m, const int n, const float &alpha, const float *const A, const int lda, const float *const x, const int incx, const float &beta, float *const y, const int incy)
void	gemv (BLASHandle< PlatformKind::CUDA > &handle, const char trans, const int m, const int n, const double &alpha, const double *const A, const int lda, const double *const x, const int incx, const double &beta, double *const y, const int incy)
void	gemv (BLASHandle< PlatformKind::CUDA > &handle, const char trans, const int m, const int n, const std::complex< float > &alpha, const std::complex< float > *A, const int lda, const std::complex< float > *x, const int incx, const std::complex< float > &beta, std::complex< float > *y, const int incy)
void	gemv (BLASHandle< PlatformKind::CUDA > &handle, const char trans, const int m, const int n, const std::complex< double > &alpha, const std::complex< double > *A, const int lda, const std::complex< double > *x, const int incx, const std::complex< double > &beta, std::complex< double > *y, const int incy)
template<typename T >
void	gemv_batched (BLASHandle< PlatformKind::CUDA > &handle, const char trans, const int m, const int n, const T *alpha, const T *const A[], const int lda, const T *const x[], const int incx, const T *beta, T *const y[], const int incy, const int batch_count)
void	ger (BLASHandle< PlatformKind::CUDA > &handle, const int m, const int n, const float &alpha, const float *const x, const int incx, const float *const y, const int incy, float *const A, const int lda)
void	ger (BLASHandle< PlatformKind::CUDA > &handle, const int m, const int n, const double &alpha, const double *const x, const int incx, const double *const y, const int incy, double *const A, const int lda)
void	ger (BLASHandle< PlatformKind::CUDA > &handle, const int m, const int n, const std::complex< float > &alpha, const std::complex< float > *x, const int incx, const std::complex< float > *y, const int incy, std::complex< float > *A, const int lda)
void	ger (BLASHandle< PlatformKind::CUDA > &handle, const int m, const int n, const std::complex< double > &alpha, const std::complex< double > *x, const int incx, const std::complex< double > *y, const int incy, std::complex< double > *A, const int lda)
template<typename T >
void	ger_batched (BLASHandle< PlatformKind::CUDA > &handle, const int m, const int n, const T *alpha, const T *const x[], const int incx, const T *const y[], const int incy, T *const A[], const int lda, const int batch_count)
template<typename T >
void	copy_batched (BLASHandle< PlatformKind::CUDA > &handle, const int n, const T *const in[], const int incx, T *const out[], const int incy, const int batch_count)
void	gemm_batched (BLASHandle< PlatformKind::CUDA > &handle, const char transa, const char transb, int m, int n, int k, const float &alpha, const float *const A[], int lda, const float *const B[], int ldb, const float &beta, float *const C[], int ldc, int batchCount)
void	gemm_batched (BLASHandle< PlatformKind::CUDA > &handle, const char transa, const char transb, int m, int n, int k, const std::complex< float > &alpha, const std::complex< float > *const A[], int lda, const std::complex< float > *const B[], int ldb, const std::complex< float > &beta, std::complex< float > *const C[], int ldc, int batchCount)
void	gemm_batched (BLASHandle< PlatformKind::CUDA > &handle, const char transa, const char transb, int m, int n, int k, const double &alpha, const double *const A[], int lda, const double *const B[], int ldb, const double &beta, double *const C[], int ldc, int batchCount)
void	gemm_batched (BLASHandle< PlatformKind::CUDA > &handle, const char transa, const char transb, int m, int n, int k, const std::complex< double > &alpha, const std::complex< double > *const A[], int lda, const std::complex< double > *const B[], int ldb, const std::complex< double > &beta, std::complex< double > *const C[], int ldc, int batchCount)
template<typename T >
void	gemm (BLASHandle< PlatformKind::OMPTARGET > &handle, const char transa, const char transb, int m, int n, int k, const T &alpha, const T *A, int lda, const T *B, int ldb, const T &beta, T *C, int ldc)
template<typename T >
void	gemm_batched (BLASHandle< PlatformKind::OMPTARGET > &handle, const char transa, const char transb, int m, int n, int k, const T &alpha, const T *const A[], int lda, const T *const B[], int ldb, const T &beta, T *const C[], int ldc, int batchCount)
template<typename T >
void	gemv (BLASHandle< PlatformKind::OMPTARGET > &handle, const char trans, const int m, const int n, const T &alpha, const T *const A, const int lda, const T *const x, const int incx, const T &beta, T *const y, const int incy)
template<typename T >
void	gemv_batched (BLASHandle< PlatformKind::OMPTARGET > &handle, const char trans, const int m, const int n, const T *alpha, const T *const A[], const int lda, const T *const x[], const int incx, const T *beta, T *const y[], const int incy, const int batch_count)
template<typename T >
void	ger (BLASHandle< PlatformKind::OMPTARGET > &handle, const int m, const int n, const T &alpha, const T *const x, const int incx, const T *const y, const int incy, T *const A, const int lda)
template<typename T >
void	ger_batched (BLASHandle< PlatformKind::OMPTARGET > &handle, const int m, const int n, const T *alpha, const T *const x[], const int incx, const T *const y[], const int incy, T *const A[], const int lda, const int batch_count)
template<typename T >
void	copy_batched (BLASHandle< PlatformKind::OMPTARGET > &handle, const int n, const T *const x[], const int incx, T *const y[], const int incy, const int batch_count)
template<typename T >
void	gemm (BLASHandle< PlatformKind::SYCL > &handle, const char transa, const char transb, int m, int n, int k, const T &alpha, const T *A, int lda, const T *B, int ldb, const T &beta, T *C, int ldc)
template<typename T >
void	gemv (BLASHandle< PlatformKind::SYCL > &handle, const char trans, const int m, const int n, const T &alpha, const T *const A, const int lda, const T *const x, const int incx, const T &beta, T *const y, const int incy)
template<typename T >
void	gemv_batched (BLASHandle< PlatformKind::SYCL > &handle, const char trans, const int m, const int n, const T *alpha, const T *const A[], const int lda, const T *const x[], const int incx, const T *beta, T *const y[], const int incy, const size_t batch_count)
template<typename T >
void	ger (BLASHandle< PlatformKind::SYCL > &handle, const int m, const int n, const T &alpha, const T *const x, const int incx, const T *const y, const int incy, T *const A, const int lda)
template<typename T >
void	ger_batched (BLASHandle< PlatformKind::SYCL > &handle, const int m, const int n, const T *alpha, const T *const x[], const int incx, const T *const y[], const int incy, T *const A[], const int lda, const size_t batch_count)
template<typename T >
void	copy_batched (BLASHandle< PlatformKind::SYCL > &handle, syclBLAS::syclBLAS_int n, const T *const in[], syclBLAS::syclBLAS_int incx, T *const out[], syclBLAS::syclBLAS_int incy, const size_t batch_count)
template<typename T >
void	gemm_batched (BLASHandle< PlatformKind::SYCL > &handle, const char transa, const char transb, syclBLAS::syclBLAS_int m, syclBLAS::syclBLAS_int n, syclBLAS::syclBLAS_int k, const T &alpha, const T *const A[], syclBLAS::syclBLAS_int lda, const T *const B[], syclBLAS::syclBLAS_int ldb, const T &beta, T *const C[], syclBLAS::syclBLAS_int ldc, const size_t batch_count)

Function Documentation

copy_batched() [1/3]

void qmcplusplus::compute::BLAS::copy_batched ( BLASHandle< PlatformKind::OMPTARGET > &  handle, const int  n, const T *const  x[], const int  incx, T *const  y[], const int  incy, const int  batch_count  )

inline

Definition at line 147 of file AccelBLAS_OMPTarget.hpp.

References qmcplusplus::ompBLAS::copy_batched(), BLASHandle< PlatformKind::OMPTARGET >::h_ompblas, and qmcplusplus::n.

{
  if (ompBLAS::copy_batched(handle.h_ompblas, n, x, incx, y, incy, batch_count) != 0)
    throw std::runtime_error("ompBLAS::copy_batched failed!");
}

copy_batched() [2/3]

void qmcplusplus::compute::BLAS::copy_batched ( BLASHandle< PlatformKind::SYCL > &  handle, syclBLAS::syclBLAS_int  n, const T *const  in[], syclBLAS::syclBLAS_int  incx, T *const  out[], syclBLAS::syclBLAS_int  incy, const size_t  batch_count  )

inline

Definition at line 155 of file AccelBLAS_SYCL.hpp.

References qmcplusplus::Units::charge::e, qmcplusplus::n, and BLASHandle< PlatformKind::SYCL >::queue_.

{
  try
  {
    syclBLAS::syclBLAS_int bc = batch_count;
    oneapi::mkl::blas::copy_batch(handle.queue_, &n, const_cast<const T**>(in), &incx, const_cast<T**>(out), &incy, 1,
                                  &bc);
  }
  catch (oneapi::mkl::exception& e)
  {
    throw std::runtime_error(std::string("AccelBLAS::copy_batch exception: ") + e.what());
  }
}

copy_batched() [3/3]

void qmcplusplus::compute::BLAS::copy_batched ( BLASHandle< PlatformKind::CUDA > &  handle, const int  n, const T *const  in[], const int  incx, T *const  out[], const int  incy, const int  batch_count  )

inline

Definition at line 303 of file AccelBLAS_CUDA.hpp.

References qmcplusplus::cuBLAS_MFs::copy_batched(), qmcplusplus::cudaErrorCheck(), BLASHandle< PlatformKind::CUDA >::h_stream, and qmcplusplus::n.

Referenced by DelayedUpdateBatched< PL, VALUE >::mw_accept_rejectRow(), and DelayedUpdateBatched< PL, VALUE >::mw_prepareInvRow().

{
  cudaErrorCheck(cuBLAS_MFs::copy_batched(handle.h_stream, n, in, incx, out, incy, batch_count),
                 "cuBLAS_MFs::copy_batched failed!");
}

gemm() [1/6]

void qmcplusplus::compute::BLAS::gemm ( BLASHandle< PlatformKind::SYCL > &  handle, const char  transa, const char  transb, int  m, int  n, int  k, const T &  alpha, const T *  A, int  lda, const T *  B, int  ldb, const T &  beta, T *  C, int  ldc  )

inline

Definition at line 33 of file AccelBLAS_SYCL.hpp.

References qmcplusplus::Units::distance::A, B(), qmcplusplus::Units::charge::C, qmcplusplus::syclBLAS::convertTransEnum(), qmcplusplus::Units::charge::e, qmcplusplus::lda, qmcplusplus::Units::distance::m, qmcplusplus::n, and BLASHandle< PlatformKind::SYCL >::queue_.

{
  try
  {
    oneapi::mkl::blas::gemm(handle.queue_, syclBLAS::convertTransEnum(transa), syclBLAS::convertTransEnum(transb), m, n,
                            k, alpha, A, lda, B, ldb, beta, C, ldc);
  }
  catch (oneapi::mkl::exception& e)
  {
    throw std::runtime_error(std::string("AccelBLAS::gemm exception: ") + e.what());
  }
}

gemm() [2/6]

void qmcplusplus::compute::BLAS::gemm ( BLASHandle< PlatformKind::OMPTARGET > &  handle, const char  transa, const char  transb, int  m, int  n, int  k, const T &  alpha, const T *  A, int  lda, const T *  B, int  ldb, const T &  beta, T *  C, int  ldc  )

inline

Definition at line 34 of file AccelBLAS_OMPTarget.hpp.

References qmcplusplus::Units::distance::A, B(), qmcplusplus::Units::charge::C, qmcplusplus::ompBLAS::gemm(), BLASHandle< PlatformKind::OMPTARGET >::h_ompblas, qmcplusplus::lda, qmcplusplus::Units::distance::m, and qmcplusplus::n.

{
  if (ompBLAS::gemm(handle.h_ompblas, transa, transb, m, n, k, alpha, A, lda, B, ldb, beta, C, ldc) != 0)
    throw std::runtime_error("ompBLAS::gemm failed!");
}

gemm() [3/6]

void qmcplusplus::compute::BLAS::gemm ( BLASHandle< PlatformKind::CUDA > &  handle, const char  transa, const char  transb, int  m, int  n, int  k, const float &  alpha, const float *  A, int  lda, const float *  B, int  ldb, const float &  beta, float *  C, int  ldc  )

inline

Definition at line 49 of file AccelBLAS_CUDA.hpp.

References qmcplusplus::Units::distance::A, B(), qmcplusplus::Units::charge::C, qmcplusplus::cuBLAS::convertOperation(), cublasErrorCheck, cublasSgemm, BLASHandle< PlatformKind::CUDA >::h_cublas, qmcplusplus::lda, qmcplusplus::Units::distance::m, and qmcplusplus::n.

Referenced by LCAOrbitalSet::mw_evaluateValueImplGEMM(), LCAOrbitalSet::mw_evaluateValueVPsImplGEMM(), LCAOrbitalSet::mw_evaluateVGLImplGEMM(), qmcplusplus::test_one_gemm(), and DelayedUpdateCUDA< T, T_FP >::updateInvMat().

{
  cublasErrorCheck(cublasSgemm(handle.h_cublas, cuBLAS::convertOperation(transa), cuBLAS::convertOperation(transb), m,
                               n, k, &alpha, A, lda, B, ldb, &beta, C, ldc),
                   "cublasSgemm failed!");
}

gemm() [4/6]

void qmcplusplus::compute::BLAS::gemm ( BLASHandle< PlatformKind::CUDA > &  handle, const char  transa, const char  transb, int  m, int  n, int  k, const double &  alpha, const double *  A, int  lda, const double *  B, int  ldb, const double &  beta, double *  C, int  ldc  )

inline

Definition at line 69 of file AccelBLAS_CUDA.hpp.

References qmcplusplus::Units::distance::A, B(), qmcplusplus::Units::charge::C, qmcplusplus::cuBLAS::convertOperation(), cublasDgemm, cublasErrorCheck, BLASHandle< PlatformKind::CUDA >::h_cublas, qmcplusplus::lda, qmcplusplus::Units::distance::m, and qmcplusplus::n.

{
  cublasErrorCheck(cublasDgemm(handle.h_cublas, cuBLAS::convertOperation(transa), cuBLAS::convertOperation(transb), m,
                               n, k, &alpha, A, lda, B, ldb, &beta, C, ldc),
                   "cublasDgemm failed!");
}

gemm() [5/6]

void qmcplusplus::compute::BLAS::gemm ( BLASHandle< PlatformKind::CUDA > &  handle, const char  transa, const char  transb, int  m, int  n, int  k, const std::complex< float > &  alpha, const std::complex< float > *  A, int  lda, const std::complex< float > *  B, int  ldb, const std::complex< float > &  beta, std::complex< float > *  C, int  ldc  )

inline

Definition at line 89 of file AccelBLAS_CUDA.hpp.

References qmcplusplus::Units::distance::A, B(), qmcplusplus::Units::charge::C, castNativeType, qmcplusplus::cuBLAS::convertOperation(), cublasCgemm, cublasErrorCheck, BLASHandle< PlatformKind::CUDA >::h_cublas, qmcplusplus::lda, qmcplusplus::Units::distance::m, and qmcplusplus::n.

{
  cublasErrorCheck(cublasCgemm(handle.h_cublas, cuBLAS::convertOperation(transa), cuBLAS::convertOperation(transb), m,
                               n, k, castNativeType(&alpha), castNativeType(A), lda, castNativeType(B), ldb,
                               castNativeType(&beta), castNativeType(C), ldc),
                   "cublasCgemm failed!");
}

gemm() [6/6]

void qmcplusplus::compute::BLAS::gemm ( BLASHandle< PlatformKind::CUDA > &  handle, const char  transa, const char  transb, int  m, int  n, int  k, const std::complex< double > &  alpha, const std::complex< double > *  A, int  lda, const std::complex< double > *  B, int  ldb, const std::complex< double > &  beta, std::complex< double > *  C, int  ldc  )

inline

Definition at line 110 of file AccelBLAS_CUDA.hpp.

References qmcplusplus::Units::distance::A, B(), qmcplusplus::Units::charge::C, castNativeType, qmcplusplus::cuBLAS::convertOperation(), cublasErrorCheck, cublasZgemm, BLASHandle< PlatformKind::CUDA >::h_cublas, qmcplusplus::lda, qmcplusplus::Units::distance::m, and qmcplusplus::n.

{
  cublasErrorCheck(cublasZgemm(handle.h_cublas, cuBLAS::convertOperation(transa), cuBLAS::convertOperation(transb), m,
                               n, k, castNativeType(&alpha), castNativeType(A), lda, castNativeType(B), ldb,
                               castNativeType(&beta), castNativeType(C), ldc),
                   "cublasZgemm failed!");
}

gemm_batched() [1/6]

void qmcplusplus::compute::BLAS::gemm_batched ( BLASHandle< PlatformKind::OMPTARGET > &  handle, const char  transa, const char  transb, int  m, int  n, int  k, const T &  alpha, const T *const  A[], int  lda, const T *const  B[], int  ldb, const T &  beta, T *const  C[], int  ldc, int  batchCount  )

inline

Definition at line 54 of file AccelBLAS_OMPTarget.hpp.

References qmcplusplus::Units::distance::A, B(), qmcplusplus::Units::charge::C, qmcplusplus::ompBLAS::gemm_batched(), BLASHandle< PlatformKind::OMPTARGET >::h_ompblas, qmcplusplus::lda, qmcplusplus::Units::distance::m, and qmcplusplus::n.

{
  if (ompBLAS::gemm_batched(handle.h_ompblas, transa, transb, m, n, k, alpha, A, lda, B, ldb, beta, C, ldc,
                            batchCount) != 0)
    throw std::runtime_error("ompBLAS::gemm_batched failed!");
}

gemm_batched() [2/6]

void qmcplusplus::compute::BLAS::gemm_batched ( BLASHandle< PlatformKind::SYCL > &  handle, const char  transa, const char  transb, syclBLAS::syclBLAS_int  m, syclBLAS::syclBLAS_int  n, syclBLAS::syclBLAS_int  k, const T &  alpha, const T *const  A[], syclBLAS::syclBLAS_int  lda, const T *const  B[], syclBLAS::syclBLAS_int  ldb, const T &  beta, T *const  C[], syclBLAS::syclBLAS_int  ldc, const size_t  batch_count  )

inline

Definition at line 176 of file AccelBLAS_SYCL.hpp.

References qmcplusplus::Units::distance::A, B(), qmcplusplus::Units::charge::C, qmcplusplus::syclBLAS::convertTransEnum(), qmcplusplus::Units::charge::e, qmcplusplus::lda, qmcplusplus::Units::distance::m, qmcplusplus::n, and BLASHandle< PlatformKind::SYCL >::queue_.

{
  auto trans_a = syclBLAS::convertTransEnum(transa);
  auto trans_b = syclBLAS::convertTransEnum(transb);
  try
  {
#if defined(GEMM_BATCH_SPAN)
    sycl::span alpha_span(sycl::malloc_shared<T>(1, handle.queue_), 1);
    alpha_span[0] = alpha;
    sycl::span beta_span(sycl::malloc_shared<T>(1, handle.queue_), 1);
    beta_span[0] = beta;

    oneapi::mkl::blas::gemm_batch(handle.queue_, sycl::span{&trans_a, 1}, sycl::span{&trans_b, 1}, sycl::span{&m, 1},
                                  sycl::span{&n, 1}, sycl::span{&k, 1}, alpha_span,
                                  sycl::span{const_cast<const T**>(A), batch_count}, sycl::span{&lda, 1},
                                  sycl::span{const_cast<const T**>(B), batch_count}, sycl::span{&ldb, 1}, beta_span,
                                  sycl::span{const_cast<T**>(C), batch_count}, sycl::span{&ldc, 1}, 1,
                                  sycl::span{const_cast<size_t*>(&batch_count), 1});
    sycl::free(alpha_span.data(), handle.queue_);
    sycl::free(beta_span.data(), handle.queue_);
#else
    syclBLAS::syclBLAS_int bc = batch_count;
    oneapi::mkl::blas::gemm_batch(handle.queue_, &trans_a, &trans_b, &m, &n, &k, const_cast<const T*>(&alpha),
                                  const_cast<const T**>(A), &lda, const_cast<const T**>(B), &ldb,
                                  const_cast<const T*>(&beta), const_cast<T**>(C), &ldc, 1, &bc);
#endif
  }
  catch (oneapi::mkl::exception& e)
  {
    throw std::runtime_error(std::string("AccelBLAS::gemm_batched  exception: ") + e.what());
  }
}

gemm_batched() [3/6]

void qmcplusplus::compute::BLAS::gemm_batched ( BLASHandle< PlatformKind::CUDA > &  handle, const char  transa, const char  transb, int  m, int  n, int  k, const float &  alpha, const float *const  A[], int  lda, const float *const  B[], int  ldb, const float &  beta, float *const  C[], int  ldc, int  batchCount  )

inline

Definition at line 315 of file AccelBLAS_CUDA.hpp.

References qmcplusplus::Units::distance::A, B(), qmcplusplus::Units::charge::C, qmcplusplus::cuBLAS::convertOperation(), cublasErrorCheck, cublasSgemmBatched, BLASHandle< PlatformKind::CUDA >::h_cublas, qmcplusplus::lda, qmcplusplus::Units::distance::m, and qmcplusplus::n.

Referenced by DelayedUpdateBatched< PL, VALUE >::mw_updateInvMat(), and qmcplusplus::test_one_gemm().

{
  cublasErrorCheck(cublasSgemmBatched(handle.h_cublas, cuBLAS::convertOperation(transa),
                                      cuBLAS::convertOperation(transb), m, n, k, &alpha, A, lda, B, ldb, &beta, C, ldc,
                                      batchCount),
                   "cublasSgemmBatched failed!");
}

gemm_batched() [4/6]

void qmcplusplus::compute::BLAS::gemm_batched ( BLASHandle< PlatformKind::CUDA > &  handle, const char  transa, const char  transb, int  m, int  n, int  k, const std::complex< float > &  alpha, const std::complex< float > *const  A[], int  lda, const std::complex< float > *const  B[], int  ldb, const std::complex< float > &  beta, std::complex< float > *const  C[], int  ldc, int  batchCount  )

inline

Definition at line 337 of file AccelBLAS_CUDA.hpp.

References qmcplusplus::Units::distance::A, B(), qmcplusplus::Units::charge::C, castNativeType, qmcplusplus::cuBLAS::convertOperation(), cublasCgemmBatched, cublasErrorCheck, BLASHandle< PlatformKind::CUDA >::h_cublas, qmcplusplus::lda, qmcplusplus::Units::distance::m, and qmcplusplus::n.

{
  // This is necessary to not break the complex CUDA type mapping semantics while
  // dealing with the const cuComplex * A[] style API of cuBLAS
  // C++ makes you jump through some hoops to remove the bottom const on a double pointer.
  // see typetraits/type_manipulation.hpp
  auto non_const_A = const_cast<BottomConstRemoved<decltype(A)>::type>(A);
  auto non_const_B = const_cast<BottomConstRemoved<decltype(B)>::type>(B);
  auto non_const_C = const_cast<BottomConstRemoved<decltype(C)>::type>(C);

  cublasErrorCheck(cublasCgemmBatched(handle.h_cublas, cuBLAS::convertOperation(transa),
                                      cuBLAS::convertOperation(transb), m, n, k, castNativeType(&alpha),
                                      castNativeType(non_const_A), lda, castNativeType(non_const_B), ldb,
                                      castNativeType(&beta), castNativeType(non_const_C), ldc, batchCount),
                   "cublasCgemmBatched failed!");
}

gemm_batched() [5/6]

void qmcplusplus::compute::BLAS::gemm_batched ( BLASHandle< PlatformKind::CUDA > &  handle, const char  transa, const char  transb, int  m, int  n, int  k, const double &  alpha, const double *const  A[], int  lda, const double *const  B[], int  ldb, const double &  beta, double *const  C[], int  ldc, int  batchCount  )

inline

Definition at line 368 of file AccelBLAS_CUDA.hpp.

References qmcplusplus::Units::distance::A, B(), qmcplusplus::Units::charge::C, qmcplusplus::cuBLAS::convertOperation(), cublasDgemmBatched, cublasErrorCheck, BLASHandle< PlatformKind::CUDA >::h_cublas, qmcplusplus::lda, qmcplusplus::Units::distance::m, and qmcplusplus::n.

{
  cublasErrorCheck(cublasDgemmBatched(handle.h_cublas, cuBLAS::convertOperation(transa),
                                      cuBLAS::convertOperation(transb), m, n, k, &alpha, A, lda, B, ldb, &beta, C, ldc,
                                      batchCount),
                   "cublasDgemmBatched failed!");
}

gemm_batched() [6/6]

void qmcplusplus::compute::BLAS::gemm_batched ( BLASHandle< PlatformKind::CUDA > &  handle, const char  transa, const char  transb, int  m, int  n, int  k, const std::complex< double > &  alpha, const std::complex< double > *const  A[], int  lda, const std::complex< double > *const  B[], int  ldb, const std::complex< double > &  beta, std::complex< double > *const  C[], int  ldc, int  batchCount  )

inline

Definition at line 390 of file AccelBLAS_CUDA.hpp.

References qmcplusplus::Units::distance::A, B(), qmcplusplus::Units::charge::C, castNativeType, qmcplusplus::cuBLAS::convertOperation(), cublasErrorCheck, cublasZgemmBatched, BLASHandle< PlatformKind::CUDA >::h_cublas, qmcplusplus::lda, qmcplusplus::Units::distance::m, and qmcplusplus::n.

{
  auto non_const_A = const_cast<BottomConstRemoved<decltype(A)>::type>(A);
  auto non_const_B = const_cast<BottomConstRemoved<decltype(B)>::type>(B);
  auto non_const_C = const_cast<BottomConstRemoved<decltype(C)>::type>(C);

  cublasErrorCheck(cublasZgemmBatched(handle.h_cublas, cuBLAS::convertOperation(transa),
                                      cuBLAS::convertOperation(transb), m, n, k, castNativeType(&alpha),
                                      castNativeType(non_const_A), lda, castNativeType(non_const_B), ldb,
                                      castNativeType(&beta), castNativeType(non_const_C), ldc, batchCount),
                   "cublasZgemmBatched failed!");
}

gemv() [1/6]

void qmcplusplus::compute::BLAS::gemv ( BLASHandle< PlatformKind::SYCL > &  handle, const char  trans, const int  m, const int  n, const T &  alpha, const T *const  A, const int  lda, const T *const  x, const int  incx, const T &  beta, T *const  y, const int  incy  )

inline

Definition at line 60 of file AccelBLAS_SYCL.hpp.

References qmcplusplus::Units::distance::A, qmcplusplus::syclBLAS::convertTransEnum(), qmcplusplus::Units::charge::e, qmcplusplus::lda, qmcplusplus::Units::distance::m, qmcplusplus::n, and BLASHandle< PlatformKind::SYCL >::queue_.

{
  try
  {
    oneapi::mkl::blas::gemv(handle.queue_, syclBLAS::convertTransEnum(trans), m, n, alpha, A, lda, x, incx, beta, y,
                            incy);
  }
  catch (oneapi::mkl::exception& e)
  {
    throw std::runtime_error(std::string("AccelBLAS::gemv exception: ") + e.what());
  }
}

gemv() [2/6]

void qmcplusplus::compute::BLAS::gemv ( BLASHandle< PlatformKind::OMPTARGET > &  handle, const char  trans, const int  m, const int  n, const T &  alpha, const T *const  A, const int  lda, const T *const  x, const int  incx, const T &  beta, T *const  y, const int  incy  )

inline

Definition at line 77 of file AccelBLAS_OMPTarget.hpp.

References qmcplusplus::Units::distance::A, qmcplusplus::ompBLAS::gemv(), BLASHandle< PlatformKind::OMPTARGET >::h_ompblas, qmcplusplus::lda, qmcplusplus::Units::distance::m, and qmcplusplus::n.

{
  if (ompBLAS::gemv(handle.h_ompblas, trans, m, n, alpha, A, lda, x, incx, beta, y, incy) != 0)
    throw std::runtime_error("ompBLAS::gemv_batched failed!");
}

gemv() [3/6]

void qmcplusplus::compute::BLAS::gemv ( BLASHandle< PlatformKind::CUDA > &  handle, const char  trans, const int  m, const int  n, const float &  alpha, const float *const  A, const int  lda, const float *const  x, const int  incx, const float &  beta, float *const  y, const int  incy  )

inline

Definition at line 131 of file AccelBLAS_CUDA.hpp.

References qmcplusplus::Units::distance::A, qmcplusplus::cuBLAS::convertOperation(), cublasErrorCheck, cublasSgemv, BLASHandle< PlatformKind::CUDA >::h_cublas, qmcplusplus::lda, qmcplusplus::Units::distance::m, and qmcplusplus::n.

Referenced by qmcplusplus::test_one_gemv().

{
  cublasErrorCheck(cublasSgemv(handle.h_cublas, cuBLAS::convertOperation(trans), m, n, &alpha, A, lda, x, incx, &beta,
                               y, incy),
                   "cublasSgemv failed!");
}

gemv() [4/6]

void qmcplusplus::compute::BLAS::gemv ( BLASHandle< PlatformKind::CUDA > &  handle, const char  trans, const int  m, const int  n, const double &  alpha, const double *const  A, const int  lda, const double *const  x, const int  incx, const double &  beta, double *const  y, const int  incy  )

inline

Definition at line 149 of file AccelBLAS_CUDA.hpp.

References qmcplusplus::Units::distance::A, qmcplusplus::cuBLAS::convertOperation(), cublasDgemv, cublasErrorCheck, BLASHandle< PlatformKind::CUDA >::h_cublas, qmcplusplus::lda, qmcplusplus::Units::distance::m, and qmcplusplus::n.

{
  cublasErrorCheck(cublasDgemv(handle.h_cublas, cuBLAS::convertOperation(trans), m, n, &alpha, A, lda, x, incx, &beta,
                               y, incy),
                   "cublasDgemv failed!");
}

gemv() [5/6]

void qmcplusplus::compute::BLAS::gemv ( BLASHandle< PlatformKind::CUDA > &  handle, const char  trans, const int  m, const int  n, const std::complex< float > &  alpha, const std::complex< float > *  A, const int  lda, const std::complex< float > *  x, const int  incx, const std::complex< float > &  beta, std::complex< float > *  y, const int  incy  )

inline

Definition at line 167 of file AccelBLAS_CUDA.hpp.

References qmcplusplus::Units::distance::A, castNativeType, qmcplusplus::cuBLAS::convertOperation(), cublasCgemv, cublasErrorCheck, BLASHandle< PlatformKind::CUDA >::h_cublas, qmcplusplus::lda, qmcplusplus::Units::distance::m, and qmcplusplus::n.

{
  cublasErrorCheck(cublasCgemv(handle.h_cublas, cuBLAS::convertOperation(trans), m, n, castNativeType(&alpha),
                               castNativeType(A), lda, castNativeType(x), incx, castNativeType(&beta),
                               castNativeType(y), incy),
                   "cublasCgemv failed!");
}

gemv() [6/6]

void qmcplusplus::compute::BLAS::gemv ( BLASHandle< PlatformKind::CUDA > &  handle, const char  trans, const int  m, const int  n, const std::complex< double > &  alpha, const std::complex< double > *  A, const int  lda, const std::complex< double > *  x, const int  incx, const std::complex< double > &  beta, std::complex< double > *  y, const int  incy  )

inline

Definition at line 186 of file AccelBLAS_CUDA.hpp.

References qmcplusplus::Units::distance::A, castNativeType, qmcplusplus::cuBLAS::convertOperation(), cublasErrorCheck, cublasZgemv, BLASHandle< PlatformKind::CUDA >::h_cublas, qmcplusplus::lda, qmcplusplus::Units::distance::m, and qmcplusplus::n.

{
  cublasErrorCheck(cublasZgemv(handle.h_cublas, cuBLAS::convertOperation(trans), m, n, castNativeType(&alpha),
                               castNativeType(A), lda, castNativeType(x), incx, castNativeType(&beta),
                               castNativeType(y), incy),
                   "cublasZgemv failed!");
}

gemv_batched() [1/3]

void qmcplusplus::compute::BLAS::gemv_batched ( BLASHandle< PlatformKind::SYCL > &  handle, const char  trans, const int  m, const int  n, const T *  alpha, const T *const  A[], const int  lda, const T *const  x[], const int  incx, const T *  beta, T *const  y[], const int  incy, const size_t  batch_count  )

inline

Definition at line 85 of file AccelBLAS_SYCL.hpp.

References qmcplusplus::Units::distance::A, qmcplusplus::Units::charge::e, qmcplusplus::syclBLAS::gemv_batched(), qmcplusplus::lda, qmcplusplus::Units::distance::m, qmcplusplus::n, and BLASHandle< PlatformKind::SYCL >::queue_.

{
  try
  { // calling makeshift version for now due to the lack of vendor optimized versions
    syclBLAS::gemv_batched(handle.queue_, trans, m, n, alpha, A, lda, x, incx, beta, y, incy, batch_count);
  }
  catch (sycl::exception& e)
  {
    throw std::runtime_error(std::string("AccelBLAS::gemv_batch exception: ") + e.what());
  }
}

gemv_batched() [2/3]

void qmcplusplus::compute::BLAS::gemv_batched ( BLASHandle< PlatformKind::OMPTARGET > &  handle, const char  trans, const int  m, const int  n, const T *  alpha, const T *const  A[], const int  lda, const T *const  x[], const int  incx, const T *  beta, T *const  y[], const int  incy, const int  batch_count  )

inline

Definition at line 95 of file AccelBLAS_OMPTarget.hpp.

References qmcplusplus::Units::distance::A, qmcplusplus::ompBLAS::gemv_batched(), BLASHandle< PlatformKind::OMPTARGET >::h_ompblas, qmcplusplus::lda, qmcplusplus::Units::distance::m, and qmcplusplus::n.

{
  if (ompBLAS::gemv_batched(handle.h_ompblas, trans, m, n, alpha, A, lda, x, incx, beta, y, incy, batch_count) != 0)
    throw std::runtime_error("ompBLAS::gemv_batched failed!");
}

gemv_batched() [3/3]

void qmcplusplus::compute::BLAS::gemv_batched ( BLASHandle< PlatformKind::CUDA > &  handle, const char  trans, const int  m, const int  n, const T *  alpha, const T *const  A[], const int  lda, const T *const  x[], const int  incx, const T *  beta, T *const  y[], const int  incy, const int  batch_count  )

inline

Definition at line 206 of file AccelBLAS_CUDA.hpp.

References qmcplusplus::Units::distance::A, qmcplusplus::cudaErrorCheck(), qmcplusplus::cuBLAS_MFs::gemv_batched(), BLASHandle< PlatformKind::CUDA >::h_stream, qmcplusplus::lda, qmcplusplus::Units::distance::m, and qmcplusplus::n.

Referenced by DelayedUpdateBatched< PL, VALUE >::mw_accept_rejectRow(), DelayedUpdateBatched< PL, VALUE >::mw_prepareInvRow(), DelayedUpdateBatched< PL, VALUE >::mw_updateRow(), and qmcplusplus::test_one_gemv().

{
  cudaErrorCheck(cuBLAS_MFs::gemv_batched(handle.h_stream, trans, m, n, alpha, A, lda, x, incx, beta, y, incy,
                                          batch_count),
                 "cuBLAS_MFs::gemv_batched failed!");
}

ger() [1/6]

void qmcplusplus::compute::BLAS::ger ( BLASHandle< PlatformKind::SYCL > &  handle, const int  m, const int  n, const T &  alpha, const T *const  x, const int  incx, const T *const  y, const int  incy, T *const  A, const int  lda  )

inline

Definition at line 110 of file AccelBLAS_SYCL.hpp.

References qmcplusplus::Units::distance::A, qmcplusplus::Units::charge::e, qmcplusplus::lda, qmcplusplus::Units::distance::m, qmcplusplus::n, and BLASHandle< PlatformKind::SYCL >::queue_.

{
  try
  {
    oneapi::mkl::blas::ger(handle.queue_, m, n, alpha, x, incx, y, incy, A, lda);
  }
  catch (oneapi::mkl::exception& e)
  {
    throw std::runtime_error(std::string("AccelBLAS::ger exception: ") + e.what());
  }
}

ger() [2/6]

void qmcplusplus::compute::BLAS::ger ( BLASHandle< PlatformKind::OMPTARGET > &  handle, const int  m, const int  n, const T &  alpha, const T *const  x, const int  incx, const T *const  y, const int  incy, T *const  A, const int  lda  )

inline

Definition at line 114 of file AccelBLAS_OMPTarget.hpp.

References qmcplusplus::Units::distance::A, qmcplusplus::ompBLAS::ger(), BLASHandle< PlatformKind::OMPTARGET >::h_ompblas, qmcplusplus::lda, qmcplusplus::Units::distance::m, and qmcplusplus::n.

{
  if (ompBLAS::ger(handle.h_ompblas, m, n, alpha, x, incx, y, incy, A, lda) != 0)
    throw std::runtime_error("ompBLAS::ger_batched failed!");
}

ger() [3/6]

void qmcplusplus::compute::BLAS::ger ( BLASHandle< PlatformKind::CUDA > &  handle, const int  m, const int  n, const float &  alpha, const float *const  x, const int  incx, const float *const  y, const int  incy, float *const  A, const int  lda  )

inline

Definition at line 225 of file AccelBLAS_CUDA.hpp.

References qmcplusplus::Units::distance::A, cublasErrorCheck, cublasSger, BLASHandle< PlatformKind::CUDA >::h_cublas, qmcplusplus::lda, qmcplusplus::Units::distance::m, and qmcplusplus::n.

Referenced by qmcplusplus::test_one_ger().

{
  cublasErrorCheck(cublasSger(handle.h_cublas, m, n, &alpha, x, incx, y, incy, A, lda), "cublasSger failed!");
}

ger() [4/6]

void qmcplusplus::compute::BLAS::ger ( BLASHandle< PlatformKind::CUDA > &  handle, const int  m, const int  n, const double &  alpha, const double *const  x, const int  incx, const double *const  y, const int  incy, double *const  A, const int  lda  )

inline

Definition at line 239 of file AccelBLAS_CUDA.hpp.

References qmcplusplus::Units::distance::A, cublasDger, cublasErrorCheck, BLASHandle< PlatformKind::CUDA >::h_cublas, qmcplusplus::lda, qmcplusplus::Units::distance::m, and qmcplusplus::n.

{
  cublasErrorCheck(cublasDger(handle.h_cublas, m, n, &alpha, x, incx, y, incy, A, lda), "cublasDger failed!");
}

ger() [5/6]

void qmcplusplus::compute::BLAS::ger ( BLASHandle< PlatformKind::CUDA > &  handle, const int  m, const int  n, const std::complex< float > &  alpha, const std::complex< float > *  x, const int  incx, const std::complex< float > *  y, const int  incy, std::complex< float > *  A, const int  lda  )

inline

Definition at line 253 of file AccelBLAS_CUDA.hpp.

References qmcplusplus::Units::distance::A, castNativeType, cublasCgeru, cublasErrorCheck, BLASHandle< PlatformKind::CUDA >::h_cublas, qmcplusplus::lda, qmcplusplus::Units::distance::m, and qmcplusplus::n.

{
  cublasErrorCheck(cublasCgeru(handle.h_cublas, m, n, castNativeType(&alpha), castNativeType(x), incx,
                               castNativeType(y), incy, castNativeType(A), lda),
                   "cublasCger failed!");
}

ger() [6/6]

void qmcplusplus::compute::BLAS::ger ( BLASHandle< PlatformKind::CUDA > &  handle, const int  m, const int  n, const std::complex< double > &  alpha, const std::complex< double > *  x, const int  incx, const std::complex< double > *  y, const int  incy, std::complex< double > *  A, const int  lda  )

inline

Definition at line 269 of file AccelBLAS_CUDA.hpp.

References qmcplusplus::Units::distance::A, castNativeType, cublasErrorCheck, cublasZgeru, BLASHandle< PlatformKind::CUDA >::h_cublas, qmcplusplus::lda, qmcplusplus::Units::distance::m, and qmcplusplus::n.

{
  cublasErrorCheck(cublasZgeru(handle.h_cublas, m, n, castNativeType(&alpha), castNativeType(x), incx,
                               castNativeType(y), incy, castNativeType(A), lda),
                   "cublasZger failed!");
}

ger_batched() [1/3]

void qmcplusplus::compute::BLAS::ger_batched ( BLASHandle< PlatformKind::OMPTARGET > &  handle, const int  m, const int  n, const T *  alpha, const T *const  x[], const int  incx, const T *const  y[], const int  incy, T *const  A[], const int  lda, const int  batch_count  )

inline

Definition at line 130 of file AccelBLAS_OMPTarget.hpp.

References qmcplusplus::Units::distance::A, qmcplusplus::ompBLAS::ger_batched(), BLASHandle< PlatformKind::OMPTARGET >::h_ompblas, qmcplusplus::lda, qmcplusplus::Units::distance::m, and qmcplusplus::n.

{
  if (ompBLAS::ger_batched(handle.h_ompblas, m, n, alpha, x, incx, y, incy, A, lda, batch_count) != 0)
    throw std::runtime_error("ompBLAS::ger_batched failed!");
}

ger_batched() [2/3]

void qmcplusplus::compute::BLAS::ger_batched ( BLASHandle< PlatformKind::SYCL > &  handle, const int  m, const int  n, const T *  alpha, const T *const  x[], const int  incx, const T *const  y[], const int  incy, T *const  A[], const int  lda, const size_t  batch_count  )

inline

Definition at line 132 of file AccelBLAS_SYCL.hpp.

References qmcplusplus::Units::distance::A, qmcplusplus::Units::charge::e, qmcplusplus::syclBLAS::ger_batched(), qmcplusplus::lda, qmcplusplus::Units::distance::m, qmcplusplus::n, and BLASHandle< PlatformKind::SYCL >::queue_.

{
  try
  { // calling makeshift version for now due to the lack of vendor optimized versions
    syclBLAS::ger_batched(handle.queue_, m, n, alpha, x, incx, y, incy, A, lda, batch_count);
  }
  catch (sycl::exception& e)
  {
    throw std::runtime_error(std::string("AccelBLAS::ger_batched exception: ") + e.what());
  }
}

ger_batched() [3/3]

void qmcplusplus::compute::BLAS::ger_batched ( BLASHandle< PlatformKind::CUDA > &  handle, const int  m, const int  n, const T *  alpha, const T *const  x[], const int  incx, const T *const  y[], const int  incy, T *const  A[], const int  lda, const int  batch_count  )

inline

Definition at line 286 of file AccelBLAS_CUDA.hpp.

References qmcplusplus::Units::distance::A, qmcplusplus::cudaErrorCheck(), qmcplusplus::cuBLAS_MFs::ger_batched(), BLASHandle< PlatformKind::CUDA >::h_stream, qmcplusplus::lda, qmcplusplus::Units::distance::m, and qmcplusplus::n.

Referenced by DelayedUpdateBatched< PL, VALUE >::mw_accept_rejectRow(), DelayedUpdateBatched< PL, VALUE >::mw_updateRow(), and qmcplusplus::test_one_ger().

{
  cudaErrorCheck(cuBLAS_MFs::ger_batched(handle.h_stream, m, n, alpha, x, incx, y, incy, A, lda, batch_count),
                 "cuBLAS_MFs::ger_batched failed!");
}