synthesis_cache_map.h

// -*-c++-*-
#ifndef STORMM_SYNTHESIS_SYSTEM_CACHE_MAP
#define STORMM_SYNTHESIS_SYSTEM_CACHE_MAP
 
#include <string>
#include <vector>
#include "copyright.h"
#include "Accelerator/hybrid.h"
#include "phasespace_synthesis.h"
#include "atomgraph_synthesis.h"
#include "synthesis_enumerators.h"
#include "systemcache.h"
 
namespace stormm {
namespace synthesis {
 
using card::Hybrid;
using card::HybridTargetLevel;
using card::GpuDetails;
  
struct SynthesisMapReader {

  SynthesisMapReader(int ncache_in, int nsynth_in, int nlabel_in, int ntopol_in,
                     const int* cache_origins_in, const int* topology_origins_in,
                     const int* label_origins_in, const int* csystem_proj_in,
                     const int* csystem_bounds_in, const int* clabel_proj_in,
                     const int* clabel_bounds_in, const int* ctopol_proj_in,
                     const int* ctopol_bounds_in);

  SynthesisMapReader(const SynthesisMapReader &original) = default;
  SynthesisMapReader(SynthesisMapReader &&original) = default;
 
  const int ncache;             
  const int nsynth;             
  const int nlabel;             
  const int ntopol;             
  const int* cache_origins;     
  const int* topology_origins;  
  const int* label_origins;     
  const int* csystem_proj;      
  const int* csystem_bounds;    
  const int* clabel_proj;       
  const int* clabel_bounds;     
  const int* ctopol_proj;       
  const int* ctopol_bounds;     
};
  
class SynthesisCacheMap {
public:

  SynthesisCacheMap();
  
  SynthesisCacheMap(const std::vector<int> &cache_origins_in, const SystemCache *sc_in,
                    const AtomGraphSynthesis *poly_ag_in = nullptr,
                    const PhaseSpaceSynthesis *poly_ps_in = nullptr);
 
  SynthesisCacheMap(const std::vector<int> &cache_origins_in, const SystemCache &sc_in,
                    const AtomGraphSynthesis &poly_ag_in, const PhaseSpaceSynthesis &poly_ps_in);
 
  SynthesisCacheMap(const std::vector<int> &cache_origins_in, const SystemCache &sc_in,
                    const AtomGraphSynthesis &poly_ag_in);
 
  SynthesisCacheMap(const std::vector<int> &cache_origins_in, const SystemCache &sc_in,
                    const PhaseSpaceSynthesis &poly_ps_in);

  SynthesisCacheMap(const SynthesisCacheMap &original);
  SynthesisCacheMap(SynthesisCacheMap &&original);
  SynthesisCacheMap& operator=(const SynthesisCacheMap &original);
  SynthesisCacheMap& operator=(SynthesisCacheMap &&original);

  int getCacheSystemCount() const;

  int getSynthesisSystemCount() const;

  int getCacheLabelCount() const;

  int getCacheTopologyCount() const;

  int getSynthesisTopologyCount() const;

  std::vector<int> getSourceGroup(int query_index) const;
  
  std::vector<int> getLabelGroup(const std::string &query_label) const;

  std::vector<int> getTopologyGroup(const AtomGraph *query_ag) const;  
  std::vector<int> getTopologyGroup(const AtomGraph &query_ag) const;  

  int getSystemCacheIndex(int synthesis_index) const;

  int getTopologyCacheIndex(int synthesis_index) const;

  int getLabelCacheIndex(int synthesis_index) const;

  int getPartitionCount(SystemGrouping organization) const;
  
  int getTotalProjection(int query_index, SystemGrouping organization) const;
  int getTotalProjection(const AtomGraph *query_ag) const;
  int getTotalProjection(const AtomGraph &query_ag) const;
  int getTotalProjection(const std::string &query_label) const;

  const SystemCache* getCachePointer() const;

  const AtomGraphSynthesis* getTopologySynthesisPointer() const;

  const PhaseSpaceSynthesis* getCoordinateSynthesisPointer() const;

  const SynthesisCacheMap* getSelfPointer() const;
  
  const SynthesisMapReader data(HybridTargetLevel tier = HybridTargetLevel::HOST) const;
 
#ifdef STORMM_USE_HPC
  void upload();

  void download();
#endif
  
  void setCache(const std::vector<int> &cache_origins_in, const SystemCache *sc_in);
  void setCache(const std::vector<int> &cache_origins_in, const SystemCache &sc_in);

  void setSynthesis(const AtomGraphSynthesis *poly_ag_in);
  void setSynthesis(const AtomGraphSynthesis &poly_ag_in);
  void setSynthesis(const PhaseSpaceSynthesis *poly_ps_in);
  void setSynthesis(const PhaseSpaceSynthesis &poly_ps_in);
 
private:
  int cache_system_count;                  
  int synthesis_system_count;              
  int cache_label_count;                   
  int cache_topology_count;                
  Hybrid<int> cache_origins;               
  Hybrid<int> topology_origins;            
  Hybrid<int> label_origins;               
  Hybrid<int> sys_projections;             
  Hybrid<int> sys_projection_bounds;       
  Hybrid<int> label_projections;           
  Hybrid<int> label_projection_bounds;     
  Hybrid<int> topology_projections;        
  Hybrid<int> topology_projection_bounds;  
  Hybrid<int> int_data;                    
 
  // Pointers to the objects being linked
  SystemCache *sc_ptr;               
  AtomGraphSynthesis *poly_ag_ptr;   
  PhaseSpaceSynthesis *poly_ps_ptr;  

  void rebasePointers();

  void validateCorrespondence() const;
};
  
} // namespace synthesis
} // namespace stormm
 
#endif