brickwork.h

// -*-c++-*-
#ifndef STORMM_BRICKWORK_H
#define STORMM_BRICKWORK_H
 
#include <vector>
#include "copyright.h"
#include "Accelerator/gpu_details.h"
#include "Constants/behavior.h"
#include "DataTypes/stormm_vector_types.h"
 
namespace stormm {
namespace synthesis {
 
using card::GpuDetails;
using constants::CartesianDimension;
using constants::UnitCellAxis;
  
class VolumePartition {
public:

  VolumePartition(int a_dim_in = 0, int b_dim_in = 0, int c_dim_in = 0, int a_orig_in = 0,
                  int b_orig_in = 0, int c_orig_in = 0, int halo_under_in = 0,
                  int halo_over_in = 0, int system_index_in = 0);

  VolumePartition(const VolumePartition &original) = default;
  VolumePartition(VolumePartition &&original) = default;
  VolumePartition& operator=(const VolumePartition &original) = default;
  VolumePartition& operator=(VolumePartition &&original) = default;

  int3 getLength() const;
  int getLength(UnitCellAxis dim) const;
  int getLength(CartesianDimension dim) const;

  int3 getLengthPlusHalo() const;
  int getLengthPlusHalo(UnitCellAxis dim) const;
  int getLengthPlusHalo(CartesianDimension dim) const;

  int3 getOrigin() const;

  int getVolumeWithHalo() const;
  
  int getSystemIndex() const;

  VolumePartition split(int a_dim_update);
  
private:
  int a_dim;         
  int b_dim;         
  int c_dim;         
  int a_orig;        
  int b_orig;        
  int c_orig;        
  int halo_under;    
  int halo_over;     
  int system_index;  
};

class Brickwork {
public:

  Brickwork(const std::vector<int3> &system_dimensions_in = {}, int a_span_max_in = 7,
            int bc_cross_section_max_in = 16, int halo_under_in = 1, int halo_over_in = 0,
            int max_nonhalo_volume_in = 48, int target_multiple = 1,
            const std::vector<int> &preferred_a_lengths = {},
            const std::vector<int> &discouraged_a_lengths = {});

  Brickwork(const Brickwork &original) = default;
  Brickwork(Brickwork &&original) = default;
  Brickwork& operator=(const Brickwork &original) = default;
  Brickwork& operator=(Brickwork &&original) = default;

  int getBrickCount() const;
  int getBrickCount(int system_index) const;

  int getSystemCount() const;

  double2 getAverageBrickLength(UnitCellAxis dim) const;
  double2 getAverageBrickLength(CartesianDimension dim) const;

  int3 getBrickOrigin(int brick_index) const;

  int3 getBrickOriginWithHalo(int brick_index) const;

  int3 getBrickLengths(int brick_index) const;

  int3 getBrickLengthsWithHalo(int brick_index) const;

  int getSystemMembership(int brick_index) const;
  
  int3 getSystemDimensions(int system_index) const;
  
  void subdivide(int target_work_unit_multiple = 1,
                 const std::vector<int> &preferred_a_lengths = {},
                 const std::vector<int> &discouraged_a_lengths = {});
 
private:
  
  // Store the parameters and metrics for later reference.
  int a_span_max;            
  int bc_cross_section_max;  
  int halo_under;            
  int halo_over;             
  int max_nonhalo_volume;    
  
  // Store the overall dimensions of each system's grid
  std::vector<int3> system_dimensions;
 
  // An array of volume partitions stores the manner in which everything is broken up
  std::vector<VolumePartition> bricks;

  void validateSystemIndex(int system_index, const char* caller) const;
  
  void validateBrickIndex(int index, const char* caller) const;
  
  int countMinimalWorkUnits(int trimmed_bdim, int trimmed_cdim) const;
};
  
} // namespace synthesis
} // namespace stormm
 
#endif