matrix.h

// -*-c++-*-
#ifndef STORMM_MATRIX_H
#define STORMM_MATRIX_H
 
#include "copyright.h"
#include "Accelerator/hybrid.h"
#include "Random/random.h"
 
namespace stormm {
namespace stmath {
 
using card::default_hpc_format;
using card::Hybrid;
using card::HybridFormat;
using card::HybridKind;
using card::HybridLabel;
using card::HybridTargetLevel;
using random::Ran2Generator;
 
enum class MatrixFillMode {
  ZEROS,    
  ONES,     
  EYE,      
  RANDU,    
  RANDN,    
  VALUE,    
};

template <typename T> class HpcMatrix {
public:
 
  // Public-facing, read-only forms of the private variables (allows syntactically simpler access
  // than getter functions)
  const size_t& n_rows;
  const size_t& n_cols;
  const size_t& n_elem;

  HpcMatrix(const char* tag_in = nullptr, HybridFormat format_in = default_hpc_format);
  HpcMatrix(size_t rows_in, size_t cols_in, const char* tag_in = nullptr,
            HybridFormat format_in = default_hpc_format,
            MatrixFillMode fill_method = MatrixFillMode::VALUE, T fill_value = static_cast<T>(0));
  HpcMatrix(size_t rows_in, size_t cols_in, MatrixFillMode fill_method,
            T fill_value = static_cast<T>(0), const char* tag_in = nullptr,
            HybridFormat format_in = default_hpc_format);
  HpcMatrix(size_t rows_in, size_t cols_in, MatrixFillMode fill_method,
            Ran2Generator *matrng, const char* tag_in = nullptr,
            HybridFormat format_in = default_hpc_format);

  HybridLabel getLabel() const;

  void resize(size_t new_rows, size_t new_cols);

  void reset();

  const T* memptr(HybridTargetLevel tier = HybridTargetLevel::HOST) const;
  T* memptr(HybridTargetLevel tier = HybridTargetLevel::HOST);

  T operator()(size_t row_idx, size_t col_idx, HybridTargetLevel tier = HybridTargetLevel::HOST);

  T atHost(size_t row_idx, size_t col_idx);

  T atDevice(size_t row_idx, size_t col_idx);

  Hybrid<T> colptr(size_t col_idx, const char* tag_in = nullptr);
 
#ifdef STORMM_USE_HPC
  void upload();

  void download();
#endif
 
private:
  size_t n_rows_pr;           
  size_t n_cols_pr;           
  size_t n_elem_pr;           
  Hybrid<T> contents;         
#ifdef STORMM_USE_HPC
  Hybrid<T> transfer_buffer;  
  T* devc_data;               
#endif
  T* host_data;               
};
 
} // namespace stmath
} // namespace stormm
 
#include "matrix.tpp"
 
#endif