reduction_abstracts.h

// -*-c++-*-
#ifndef STORMM_REDUCTION_ABSTRACTS_H
#define STORMM_REDUCTION_ABSTRACTS_H
 
#include "copyright.h"
#include "Accelerator/hybrid.h"
#include "DataTypes/common_types.h"
#include "Synthesis/atomgraph_synthesis.h"
#include "Synthesis/phasespace_synthesis.h"
#include "reduction_bridge.h"
#include "reduction_enumerators.h"
 
namespace stormm {
namespace stmath {
 
using card::HybridTargetLevel;
using synthesis::AtomGraphSynthesis;
using synthesis::PhaseSpaceSynthesis;
using synthesis::PsSynthesisWriter;

struct ReductionKit {

  ReductionKit(int nrdwu_in, RdwuPerSystem rps_in, const int* rdwu_abstracts_in,
               const int* atom_counts_in);
 
  ReductionKit(const AtomGraphSynthesis &poly_ag,
               HybridTargetLevel tier = HybridTargetLevel::HOST);

  ReductionKit(const ReductionKit &original) = default;
  ReductionKit(ReductionKit &&original) = default;
 
  const int nrdwu;            
  const RdwuPerSystem rps;    
  const int* rdwu_abstracts;  
  const int* atom_counts;     
};

template <typename T> struct GenericRdSubstrate {

  GenericRdSubstrate(const T* x_read_in, double* x_buffer_in, T* x_write_in,
                     const int scale_bits_in = 0);
 
  GenericRdSubstrate(const T* x_read_in, const T* y_read_in, const T* z_read_in,
                     double* x_buffer_in, double* y_buffer_in, double* z_buffer_in, T* x_write_in,
                     T* y_write_in, T* z_write_in, const int scale_bits_in = 0);
 
  GenericRdSubstrate(const T* x_read_in, const int* x_read_ovrf_in, double* x_buffer_in,
                     T* x_write_in, int* x_write_ovrf_in, const int scale_bits_in = 0);
 
  GenericRdSubstrate(const T* x_read_in, const int* x_read_ovrf_in, const T* y_read_in,
                     const int* y_read_ovrf_in, const T* z_read_in, const int* z_read_ovrf_in,
                     double* x_buffer_in, double* y_buffer_in, double* z_buffer_in, T* x_write_in,
                     int* x_write_ovrf_in, T* y_write_in, int* y_write_ovrf_in, T* z_write_in,
                     int* z_write_ovrf_in, const int scale_bits_in = 0);

  GenericRdSubstrate(const GenericRdSubstrate &original) = default;
  GenericRdSubstrate(GenericRdSubstrate &&original) = default;
 
  const int dim;                
  const int scale_bits;         
  const double fp_scaling;      
  const double inv_fp_scaling;  
  const T* x_read;              
  const T* y_read;              
  const T* z_read;              
  const int* x_read_ovrf;       
  const int* y_read_ovrf;       
  const int* z_read_ovrf;       
  double* x_buffer;             
  double* y_buffer;             
  double* z_buffer;             
  T* x_write;                   
  T* y_write;                   
  T* z_write;                   
  int* x_write_ovrf;            
  int* y_write_ovrf;            
  int* z_write_ovrf;            
};

struct ConjGradSubstrate {

  ConjGradSubstrate(PsSynthesisWriter poly_psw, ReductionBridge *rbg,
                    HybridTargetLevel tier = HybridTargetLevel::HOST);
 
  ConjGradSubstrate(PhaseSpaceSynthesis *poly_ps, ReductionBridge *rbg,
                    HybridTargetLevel tier = HybridTargetLevel::HOST);

  const double inv_frc_scale;
 
  // The data pointers often repurpose arrays in the PhaseSpaceSynthesis object.
  llint* xfrc;          
  llint* yfrc;          
  llint* zfrc;          
  int* xfrc_ovrf;       
  int* yfrc_ovrf;       
  int* zfrc_ovrf;       
  llint* xprv;          
  llint* yprv;          
  llint* zprv;          
  int* xprv_ovrf;       
  int* yprv_ovrf;       
  int* zprv_ovrf;       
  llint* x_cg_temp;     
  llint* y_cg_temp;     
  llint* z_cg_temp;     
  int* x_cg_temp_ovrf;  
  int* y_cg_temp_ovrf;  
  int* z_cg_temp_ovrf;  
  double* gg_buffer;    
  double* dgg_buffer;   
  double* msum_buffer;  
};
 
} // namespace stmath
} // namespace stormm
 
#include "reduction_abstracts.tpp"
 
#endif