tile_manager.h

// -*-c++-*-
#ifndef STORMM_TILE_MANAGER_H
#define STORMM_TILE_MANAGER_H
 
#include <vector>
#include "copyright.h"
#include "Accelerator/hybrid.h"
#include "DataTypes/stormm_vector_types.h"
 
namespace stormm {
namespace energy {
 
using card::Hybrid;
using card::HybridTargetLevel;
  
struct TilePlan {

  TilePlan(int nchoice_in, const int* read_assign_in, const int* self_assign_in,
           const int* reduce_prep_in, const int* self_prep_in, const float* scalings_in,
           const int* nt_stencil_in, int* xfrc_ovrf_in, int* yfrc_ovrf_in, int* zfrc_ovrf_in);

  TilePlan(const TilePlan &original) = default;
  TilePlan(TilePlan &&original) = default;
 
  const int nchoice;       
  const int* read_assign;  
  const int* self_assign;  
  const int* reduce_prep;  
  const int* self_prep;    
  const float* scalings;   
  const int* nt_stencil;   
  int* xfrc_ovrf;          
  int* yfrc_ovrf;          
  int* zfrc_ovrf;          
};

class TileManager {
public:

  TileManager(const int2 launch_parameters, int max_deg_in = 0);

  TileManager(const TileManager &original);
  TileManager(TileManager &&original);
  TileManager& operator=(const TileManager &original);
  TileManager& operator=(TileManager &&original);
  
  int getMaximumBatchDegeneracy() const;

  std::vector<int> getSendingAtomLayout(const int sending_atom_degeneracy) const;

  std::vector<int> getReadAssignments(int sending_atom_degeneracy,
                                      int recving_atom_degeneracy) const;

  std::vector<int> getSelfAssignments(int sending_atom_degeneracy,
                                      int recving_atom_degeneracy) const;
  
  std::vector<int> getReductionPreparations(int sending_atom_degeneracy,
                                            int recving_atom_degeneracy) const;

  std::vector<int> getSelfPreparations(int sending_atom_degeneracy,
                                       int recving_atom_degeneracy) const;

  std::vector<float> getThreadScalings(int atom_degeneracy) const;
  
  std::vector<int> getNeutralTerritoryStencil() const;
  
  TilePlan data(HybridTargetLevel tier = HybridTargetLevel::HOST);
 
#ifdef STORMM_USE_HPC
  void upload();

  void download();
#endif
 
private:
 
  int maximum_degeneracy;           
  int block_count;                  
  int thread_count;                 
  Hybrid<int> read_assignments;     
  Hybrid<int> self_assignments;     
  Hybrid<int> reduce_preparations;  
  Hybrid<int> self_preparations;    
  Hybrid<float> thread_scalings;    
  Hybrid<int> tower_plate_stencil;  
  Hybrid<int> x_force_overflow;     
  Hybrid<int> y_force_overflow;     
  Hybrid<int> z_force_overflow;     
  Hybrid<int> int_data;             

  void allocate();

  void planTowerPlateStencil();
  
  std::vector<int> computeStaggeredOrder(int natom, int sending_reps, int iter);
};
  
} // namespace energy
} // namespace stormm
 
#endif