static_exclusionmask.h

// -*-c++-*-
#ifndef STORMM_SIMPLE_EXCLUSIONMASK_H
#define STORMM_SIMPLE_EXCLUSIONMASK_H
 
#include <vector>
#include "copyright.h"
#include "Accelerator/hybrid.h"
#include "DataTypes/common_types.h"
#include "Topology/atomgraph.h"
 
namespace stormm {
namespace energy {
 
using card::Hybrid;
using card::HybridTargetLevel;
using topology::AtomGraph;

constexpr int max_supertile_count = 46300;

constexpr int max_unique_tiles = 67108864;

constexpr int supertile_length = 256;

constexpr int tile_length = 16;
constexpr int half_tile_length = tile_length / 2;
constexpr int three_halves_tile_length = (tile_length * 3) / 2;
constexpr int tile_length_bits_mask = tile_length - 1;
constexpr int tile_length_bits = 4;

constexpr int tile_lengths_per_supertile = supertile_length / tile_length;

constexpr int tiles_per_supertile = tile_lengths_per_supertile * tile_lengths_per_supertile;

struct StaticExclusionMaskReader {

  StaticExclusionMaskReader(int natom_in, int supertile_stride_count_in,
                            const int* supertile_map_idx_in, const int* tile_map_idx_in,
                            const uint* mask_data_in);
 
  const int natom;                   
  const int supertile_stride_count;  
  const int* supertile_map_idx;      
  const int* tile_map_idx;           
  const uint* mask_data;             
};

class StaticExclusionMask {
public:

  StaticExclusionMask(const AtomGraph *ag_in = nullptr);
  StaticExclusionMask(const AtomGraph &ag_in);
  
  StaticExclusionMask(const StaticExclusionMask &original) = default;
  StaticExclusionMask(StaticExclusionMask &&original) = default;
  StaticExclusionMask& operator=(const StaticExclusionMask &other) = default;
  StaticExclusionMask& operator=(StaticExclusionMask &&other) = default;
  
  int getAtomCount() const;

  int getSuperTileStrideCount() const;

  int getTileStrideCount() const;

  int getUniqueSuperTileCount() const;

  int getUniqueTileCount() const;
  int getUniqueTileCount(int supertile_i_index, int supertile_j_index) const;

  std::vector<uint> getTileExclusions(int supertile_i_index, int supertile_j_index,
                                      int tile_i_index, int tile_j_index) const;

  const AtomGraph* getTopologyPointer() const;

  const StaticExclusionMaskReader data(HybridTargetLevel tier = HybridTargetLevel::HOST) const;

  const StaticExclusionMask* getSelfPointer() const;
  
#ifdef STORMM_USE_HPC
  void upload();

  void download();
#endif
  
  bool testExclusion(int atom_i, int atom_j) const;
 
private:
  int atom_count;               
  int supertile_stride_count;   
  int tile_stride_count;        
  int unique_supertile_count;   
  int unique_tile_count;        
 
  // A collection of the mask groups, arranged in a concatenated fashion
  Hybrid<uint> all_masks;             
  Hybrid<int> supertile_map_indices;  
  Hybrid<int> tile_map_indices;       
  AtomGraph *ag_pointer;              
};
 
} // namespace energy
} // namespace stormm
 
#endif