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;
 
    mutable QudaTransferType transfer_type;
 
    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, const QudaTransferType transfer_type, 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;}
 
    QudaTransferType getTransferType() const { return transfer_type; }
 
    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);
 
  void StaggeredProlongate(ColorSpinorField &out, const ColorSpinorField &in, const int *fine_to_coarse,
                           const int *const *spin_map, int parity = QUDA_INVALID_PARITY);
 
  void StaggeredRestrict(ColorSpinorField &out, const ColorSpinorField &in, const int *fine_to_coarse,
                         const int *const *spin_map, int parity = QUDA_INVALID_PARITY);
 
} // namespace quda
#endif // _TRANSFER_H