transfer.h

Go to the documentation of this file.

#ifndef _TRANSFER_H
#define _TRANSFER_H

#include <color_spinor_field.h>
#include <vector>

namespace quda {

  class Transfer {

  private:

    const std::vector<ColorSpinorField*> &B;

    const int Nvec;

    const int NblockOrtho;

    const QudaPrecision null_precision;

    mutable ColorSpinorField *V_h;

    mutable ColorSpinorField *V_d;

    mutable ColorSpinorField *fine_tmp_h;

    mutable ColorSpinorField *fine_tmp_d;

    mutable ColorSpinorField *coarse_tmp_h;

    mutable ColorSpinorField *coarse_tmp_d;

    int *geo_bs;

    mutable int *fine_to_coarse_h;

    mutable int *coarse_to_fine_h;

    mutable int *fine_to_coarse_d;

    mutable int *coarse_to_fine_d;

    int spin_bs;

    int **spin_map;

    const int nspin_fine;

    QudaSiteSubset site_subset;

    QudaParity parity;

    mutable bool enable_gpu;

    mutable bool enable_cpu;

    mutable bool use_gpu;

    void createV(QudaFieldLocation location) const;

    void createTmp(QudaFieldLocation location) const;

    void createGeoMap(int *geo_bs);

    void createSpinMap(int spin_bs);

    void initializeLazy(QudaFieldLocation location) const;

    mutable double flops_;

    TimeProfile &profile;

  public:
      Transfer(const std::vector<ColorSpinorField *> &B, int Nvec, int NblockOrtho, int *geo_bs, int spin_bs,
               QudaPrecision null_precision, TimeProfile &profile);

      virtual ~Transfer();

      void reset();

      void P(ColorSpinorField &out, const ColorSpinorField &in) const;

      void R(ColorSpinorField &out, const ColorSpinorField &in) const;

      QudaPrecision NullPrecision(QudaFieldLocation location) const
      {
        return location == QUDA_CUDA_FIELD_LOCATION ? null_precision : std::max(B[0]->Precision(), QUDA_SINGLE_PRECISION);
      }

    const ColorSpinorField& Vectors(QudaFieldLocation location=QUDA_INVALID_FIELD_LOCATION) const {
      if (location == QUDA_INVALID_FIELD_LOCATION) {
        // if not set then we return the memory space where the input vectors are stored
        return B[0]->Location() == QUDA_CUDA_FIELD_LOCATION ? *V_d : *V_h;
      } else {
        return location == QUDA_CUDA_FIELD_LOCATION ? *V_d : *V_h;
      }
    }

    int nvec() const {return Nvec;}

    int Spin_bs() const {return spin_bs;}

    const int *Geo_bs() const {return geo_bs;}
    
    const int* fineToCoarse(QudaFieldLocation location=QUDA_CPU_FIELD_LOCATION) const
    { return location == QUDA_CPU_FIELD_LOCATION ? fine_to_coarse_h : fine_to_coarse_d; }

    const int* coarseToFine(QudaFieldLocation location=QUDA_CPU_FIELD_LOCATION) const
    { return location == QUDA_CPU_FIELD_LOCATION ? coarse_to_fine_h : coarse_to_fine_d; }

    void setTransferGPU(bool use_gpu) const { this->use_gpu = use_gpu; }

    void setSiteSubset(QudaSiteSubset site_subset, QudaParity parity);

    double flops() const;
  };

  void BlockOrthogonalize(ColorSpinorField &V, const std::vector<ColorSpinorField *> &B, const int *fine_to_coarse,
                          const int *coarse_to_fine, const int *geo_bs, const int spin_bs, const int n_block_ortho);

  void Prolongate(ColorSpinorField &out, const ColorSpinorField &in, const ColorSpinorField &v, 
      int Nvec, const int *fine_to_coarse, const int * const *spin_map,
      int parity=QUDA_INVALID_PARITY);

  void Restrict(ColorSpinorField &out, const ColorSpinorField &in, const ColorSpinorField &v, 
    int Nvec, const int *fine_to_coarse, const int *coarse_to_fine, const int * const *spin_map,
    int parity=QUDA_INVALID_PARITY);
  

} // namespace quda
#endif // _TRANSFER_H