cublas_interface.cu

Go to the documentation of this file.

/*
 *  SPDX-FileCopyrightText: Copyright 2021, Siavash Ameli <sameli@berkeley.edu>
 *  SPDX-License-Identifier: BSD-3-Clause
 *  SPDX-FileType: SOURCE
 *
 *  This program is free software: you can redistribute it and/or modify it
 *  under the terms of the license found in the LICENSE.txt file in the root
 *  directory of this source tree.
 */
 
 
// =======
// Headers
// =======
 
#include "./cublas_interface.h"
 
 
// ================
// cublas interface
// ================
 
 
namespace cublas_interface
{
 
    // ===========
    // cublasXgemv (float)
    // ===========
 
 
    template<>
    cublasStatus_t cublasXgemv<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)
    {
        return cublasSgemv(handle, trans, m, n, alpha, A, lda, x, incx, beta,
                           y, incy);
    }
 
 
    // ===========
    // cublasXgemv (double)
    // ===========
 
 
    template<>
    cublasStatus_t cublasXgemv<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)
    {
        return cublasDgemv(handle, trans, m, n, alpha, A, lda, x, incx, beta,
                           y, incy);
    }
 
 
 
    // ===========
    // cublasXcopy (float)
    // ===========
 
 
    template<>
    cublasStatus_t cublasXcopy<float>(
            cublasHandle_t handle,
            int n,
            const float* x,
            int incx,
            float* y,
            int incy)
    {
        return cublasScopy(handle, n, x, incx, y, incy);
    }
 
 
    // ===========
    // cublasXcopy (double)
    // ===========
 
 
    template<>
    cublasStatus_t cublasXcopy<double>(
            cublasHandle_t handle,
            int n,
            const double* x,
            int incx,
            double* y,
            int incy)
    {
        return cublasDcopy(handle, n, x, incx, y, incy);
    }
 
 
    // ===========
    // cublasXaxpy (float)
    // ===========
 
 
    template<>
    cublasStatus_t cublasXaxpy<float>(
            cublasHandle_t handle,
            int n,
            const float *alpha,
            const float *x,
            int incx,
            float *y,
            int incy)
    {
        return cublasSaxpy(handle, n, alpha, x, incx, y, incy);
    }
 
 
    // ===========
    // cublasXaxpy (double)
    // ===========
 
 
    template<>
    cublasStatus_t cublasXaxpy<double>(
            cublasHandle_t handle,
            int n,
            const double *alpha,
            const double *x,
            int incx,
            double *y,
            int incy)
    {
        return cublasDaxpy(handle, n, alpha, x, incx, y, incy);
    }
 
 
    // ==========
    // cublasXdot (float)
    // ==========
 
 
    template<>
    cublasStatus_t cublasXdot<float>(
            cublasHandle_t handle,
            int n,
            const float *x,
            int incx,
            const float *y,
            int incy,
            float *result)
    {
        return cublasSdot(handle, n, x, incx, y, incy, result);
    }
 
 
    // ==========
    // cublasXdot (double)
    // ==========
 
 
    template<>
    cublasStatus_t cublasXdot<double>(
            cublasHandle_t handle,
            int n,
            const double *x,
            int incx,
            const double *y,
            int incy,
            double *result)
    {
        return cublasDdot(handle, n, x, incx, y, incy, result);
    }
 
 
    // ===========
    // cublasXnrm2 (float)
    // ===========
 
 
    template<>
    cublasStatus_t cublasXnrm2<float>(
            cublasHandle_t handle,
            int n,
            const float *x,
            int incx,
            float *result)
    {
        return cublasSnrm2(handle, n, x, incx, result);
    }
 
 
    // ===========
    // cublasXnrm2 (double)
    // ===========
 
 
    template<>
    cublasStatus_t cublasXnrm2<double>(
            cublasHandle_t handle,
            int n,
            const double *x,
            int incx,
            double *result)
    {
        return cublasDnrm2(handle, n, x, incx, result);
    }
 
 
    // ===========
    // cublasXscal (float)
    // ===========
 
 
    template<>
    cublasStatus_t cublasXscal<float>(
            cublasHandle_t handle,
            int n,
            const float *alpha,
            float *x,
            int incx)
    {
        return cublasSscal(handle, n, alpha, x, incx);
    }
 
 
    // ===========
    // cublasXscal (double)
    // ===========
 
 
    template<>
    cublasStatus_t cublasXscal<double>(
            cublasHandle_t handle,
            int n,
            const double *alpha,
            double *x,
            int incx)
    {
        return cublasDscal(handle, n, alpha, x, incx);
    }
}  // namespace cublas_interface