blas_quda.h

Go to the documentation of this file.

#ifndef _QUDA_BLAS_H
#define _QUDA_BLAS_H
 
#include <quda_internal.h>
#include <color_spinor_field.h>
 
// ---------- blas_quda.cu ----------
 
namespace quda {
 
  namespace blas {
 
    // creates and destroys reduction buffers
    void init();
    void destroy();
 
    void setParam(int kernel, int prec, int threads, int blocks);
 
    extern unsigned long long flops;
    extern unsigned long long bytes;
 
    void zero(ColorSpinorField &a);
 
    inline void copy(ColorSpinorField &dst, const ColorSpinorField &src)
    {
      if (&dst == &src) return;
 
      if (dst.Location() == QUDA_CUDA_FIELD_LOCATION && src.Location() == QUDA_CUDA_FIELD_LOCATION) {
        static_cast<cudaColorSpinorField &>(dst).copy(static_cast<const cudaColorSpinorField &>(src));
      } else if (dst.Location() == QUDA_CPU_FIELD_LOCATION && src.Location() == QUDA_CPU_FIELD_LOCATION) {
        static_cast<cpuColorSpinorField &>(dst).copy(static_cast<const cpuColorSpinorField &>(src));
      } else {
        errorQuda("Cannot call copy with fields with different locations");
      }
    }
 
    void ax(double a, ColorSpinorField &x);
 
    void axpbyz(double a, ColorSpinorField &x, double b, ColorSpinorField &y, ColorSpinorField &z);
 
    inline void xpy(ColorSpinorField &x, ColorSpinorField &y) { axpbyz(1.0, x, 1.0, y, y); }
    inline void mxpy(ColorSpinorField &x, ColorSpinorField &y) { axpbyz(-1.0, x, 1.0, y, y); }
    inline void axpy(double a, ColorSpinorField &x, ColorSpinorField &y) { axpbyz(a, x, 1.0, y, y); }
    inline void axpby(double a, ColorSpinorField &x, double b, ColorSpinorField &y) { axpbyz(a, x, b, y, y); }
    inline void xpay(ColorSpinorField &x, double a, ColorSpinorField &y) { axpbyz(1.0, x, a, y, y); }
    inline void xpayz(ColorSpinorField &x, double a, ColorSpinorField &y, ColorSpinorField &z) { axpbyz(1.0, x, a, y, z); }
 
    void axpyZpbx(double a, ColorSpinorField &x, ColorSpinorField &y, ColorSpinorField &z, double b);
    void axpyBzpcx(double a, ColorSpinorField& x, ColorSpinorField& y, double b, ColorSpinorField& z, double c);
 
    void caxpby(const Complex &a, ColorSpinorField &x, const Complex &b, ColorSpinorField &y);
    void caxpy(const Complex &a, ColorSpinorField &x, ColorSpinorField &y);
    void caxpbypczw(const Complex &a, ColorSpinorField &x, const Complex &b, ColorSpinorField &y, const Complex &c,
                    ColorSpinorField &z, ColorSpinorField &w);
    void cxpaypbz(ColorSpinorField &, const Complex &b, ColorSpinorField &y, const Complex &c, ColorSpinorField &z);
    void caxpbypzYmbw(const Complex &, ColorSpinorField &, const Complex &, ColorSpinorField &, ColorSpinorField &, ColorSpinorField &);
    void caxpyBzpx(const Complex &, ColorSpinorField &, ColorSpinorField &, const Complex &, ColorSpinorField &);
    void caxpyBxpz(const Complex &, ColorSpinorField &, ColorSpinorField &, const Complex &, ColorSpinorField &);
 
    void cabxpyAx(double a, const Complex &b, ColorSpinorField &x, ColorSpinorField &y);
    void caxpyXmaz(const Complex &a, ColorSpinorField &x,
                   ColorSpinorField &y, ColorSpinorField &z);
    void caxpyXmazMR(const double &a, ColorSpinorField &x, ColorSpinorField &y, ColorSpinorField &z);
 
    void tripleCGUpdate(double alpha, double beta, ColorSpinorField &q,
                        ColorSpinorField &r, ColorSpinorField &x, ColorSpinorField &p);
 
    // reduction kernels - defined in reduce_quda.cu
 
    double norm1(const ColorSpinorField &b);
    double norm2(const ColorSpinorField &a);
 
    double axpyReDot(double a, ColorSpinorField &x, ColorSpinorField &y);
 
    double reDotProduct(ColorSpinorField &x, ColorSpinorField &y);
 
    double axpbyzNorm(double a, ColorSpinorField &x, double b, ColorSpinorField &y, ColorSpinorField &z);
    inline double axpyNorm(double a, ColorSpinorField &x, ColorSpinorField &y) { return axpbyzNorm(a, x, 1.0, y, y); }
    inline double xmyNorm(ColorSpinorField &x, ColorSpinorField &y) { return axpbyzNorm(1.0, x, -1.0, y, y); }
 
    Complex cDotProduct(ColorSpinorField &, ColorSpinorField &);
    double3 cDotProductNormA(ColorSpinorField &a, ColorSpinorField &b);
 
    inline double3 cDotProductNormB(ColorSpinorField &a, ColorSpinorField &b) {
      double3 a3 = cDotProductNormA(b, a);
      return make_double3(a3.x, -a3.y, a3.z);
    }
 
    double3 caxpbypzYmbwcDotProductUYNormY(const Complex &a, ColorSpinorField &x, const Complex &b, ColorSpinorField &y,
                                           ColorSpinorField &z, ColorSpinorField &w, ColorSpinorField &u);
 
    double caxpyNorm(const Complex &a, ColorSpinorField &x, ColorSpinorField &y);
    double caxpyXmazNormX(const Complex &a, ColorSpinorField &x,
                          ColorSpinorField &y, ColorSpinorField &z);
    double cabxpyzAxNorm(double a, const Complex &b, ColorSpinorField &x, ColorSpinorField &y, ColorSpinorField &z);
 
    Complex caxpyDotzy(const Complex &a, ColorSpinorField &x, ColorSpinorField &y,
                       ColorSpinorField &z);
    Complex axpyCGNorm(double a, ColorSpinorField &x, ColorSpinorField &y);
    double3 HeavyQuarkResidualNorm(ColorSpinorField &x, ColorSpinorField &r);
    double3 xpyHeavyQuarkResidualNorm(ColorSpinorField &x, ColorSpinorField &y, ColorSpinorField &r);
 
    double3 tripleCGReduction(ColorSpinorField &x, ColorSpinorField &y, ColorSpinorField &z);
    double4 quadrupleCGReduction(ColorSpinorField &x, ColorSpinorField &y, ColorSpinorField &z);
 
    double quadrupleCG3InitNorm(double a, ColorSpinorField &x, ColorSpinorField &y, ColorSpinorField &z, ColorSpinorField &w, ColorSpinorField &v);
    double quadrupleCG3UpdateNorm(double a, double b, ColorSpinorField &x, ColorSpinorField &y, ColorSpinorField &z, ColorSpinorField &w, ColorSpinorField &v);
 
    // multi-blas kernels - defined in multi_blas.cu
 
    void axpy(const double *a, std::vector<ColorSpinorField *> &x, std::vector<ColorSpinorField *> &y);
 
    void axpy(const double *a, ColorSpinorField &x, ColorSpinorField &y);
 
    void axpy_U(const double *a, std::vector<ColorSpinorField *> &x, std::vector<ColorSpinorField *> &y);
 
    void axpy_U(const double *a, ColorSpinorField &x, ColorSpinorField &y);
 
    void axpy_L(const double *a, std::vector<ColorSpinorField *> &x, std::vector<ColorSpinorField *> &y);
 
    void axpy_L(const double *a, ColorSpinorField &x, ColorSpinorField &y);
 
    void caxpy(const Complex *a, std::vector<ColorSpinorField*> &x, std::vector<ColorSpinorField*> &y);
 
    void caxpy(const Complex *a, ColorSpinorField &x, ColorSpinorField &y);
 
    void caxpy_U(const Complex *a, std::vector<ColorSpinorField*> &x, std::vector<ColorSpinorField*> &y);
 
    void caxpy_U(const Complex *a, ColorSpinorField &x, ColorSpinorField &y);
 
    void caxpy_L(const Complex *a, std::vector<ColorSpinorField*> &x, std::vector<ColorSpinorField*> &y);
 
    void caxpy_L(const Complex *a, ColorSpinorField &x, ColorSpinorField &y);
 
    void caxpyz(const Complex *a, std::vector<ColorSpinorField*> &x, std::vector<ColorSpinorField*> &y, std::vector<ColorSpinorField*> &z);
 
    void caxpyz(const Complex *a, ColorSpinorField &x, ColorSpinorField &y, ColorSpinorField &z);
 
    void caxpyz_U(const Complex *a, std::vector<ColorSpinorField*> &x, std::vector<ColorSpinorField*> &y, std::vector<ColorSpinorField*> &z);
 
    void caxpyz_U(const Complex *a, ColorSpinorField &x, ColorSpinorField &y, ColorSpinorField &z);
 
    void caxpyz_L(const Complex *a, std::vector<ColorSpinorField*> &x, std::vector<ColorSpinorField*> &y, std::vector<ColorSpinorField*> &z);
 
    void caxpyz_L(const Complex *a, ColorSpinorField &x, ColorSpinorField &y, ColorSpinorField &z);
 
    void axpyBzpcx(const double *a, std::vector<ColorSpinorField*> &x, std::vector<ColorSpinorField*> &y,
                   const double *b, ColorSpinorField &z, const double *c);
 
    void caxpyBxpz(const Complex *a_, std::vector<ColorSpinorField*> &x_, ColorSpinorField &y_,
                   const Complex *b_, ColorSpinorField &z_);
 
 
    // multi-reduce kernels - defined in multi_reduce.cu
 
    void reDotProduct(double* result, std::vector<ColorSpinorField*>& a, std::vector<ColorSpinorField*>& b);
 
    void cDotProduct(Complex* result, std::vector<ColorSpinorField*>& a, std::vector<ColorSpinorField*>& b);
 
    void hDotProduct(Complex* result, std::vector<ColorSpinorField*>& a, std::vector<ColorSpinorField*>& b);
 
    void hDotProduct_Anorm(Complex* result, std::vector<ColorSpinorField*>& a, std::vector<ColorSpinorField*>& b);
 
 
    void cDotProductCopy(Complex* result, std::vector<ColorSpinorField*>& a, std::vector<ColorSpinorField*>& b, std::vector<ColorSpinorField*>& c);
 
  } // namespace blas
 
} // namespace quda
 
#endif // _QUDA_BLAS_H