ArrayIR.h

Go to the documentation of this file.

 
#pragma once
 
#include <array>
#include <iostream>
#include <type_traits>
 
namespace array_ir {
 
  int constexpr MEMORY_HOST   = 0;
  int constexpr MEMORY_DEVICE = 1;
  int constexpr MEMORY_SHARED = 2;
 
 
  template <class T, int N>
  class ArrayIR {
    private:
    T                    * my_data;         // Data pointer
    std::array<size_t,N>   my_dimensions;   // Dimensions (right-most varying the fastest
    char const           * my_label;        // Label for the array (for debugging and things)
    int                    my_memory_type;  // Memory type (host, device, or shared)
 
    void nullify() { my_data = nullptr; my_label = nullptr; my_dimensions.fill(0); }
 
    void copy_from(ArrayIR const &rhs) {
      my_data        = rhs.my_data;
      my_label       = rhs.my_label;
      my_memory_type = rhs.my_memory_type;
      my_dimensions  = rhs.my_dimensions;
    }
 
    void error_message(char const *message) const {
      std::cerr << "*** ArrayIR class: A FATAL ERROR WAS ENCOUNTERED ***" << std::endl;
      std::cerr << message << std::endl;
      throw std::runtime_error(message);
    }
 
    
    public:
    typedef T                                 exact_type;
    typedef typename std::remove_cv<T>::type  remove_cv_type;
 
    ArrayIR() { nullify(); }
    ArrayIR( T * data , std::array<size_t,N> dimensions , int memory_type , char const * label="" ) {
      my_data        = data;
      my_memory_type = memory_type;
      my_label       = label;
      my_dimensions  = dimensions;
    }
    ArrayIR           (ArrayIR const  &rhs) { copy_from(rhs); }
    ArrayIR           (ArrayIR const &&rhs) { copy_from(rhs); }
    ArrayIR &operator=(ArrayIR const  &rhs) { copy_from(rhs); }
    ArrayIR &operator=(ArrayIR const &&rhs) { copy_from(rhs); }
    ~ArrayIR() { nullify(); }
    bool empty   () const { return my_data == nullptr; }
    bool is_empty() const { return my_data == nullptr; }
    bool valid   () const { return ! empty(); }
    bool is_valid() const { return ! empty(); }
    T * data            () const { return my_data; }
    T * get_data        () const { return my_data; }
    T * get_data_pointer() const { return my_data; }
    size_t extent(int i) const {
      if (i < 0 || i > N-1) error_message("extent() index out of bounds");
      return my_dimensions[i];
    }
    std::array<size_t,N> shape() const { return my_dimensions; }
    size_t dimension(int i) const { return extent(i); }
    char const * label    () const { return my_label; }
    char const * get_label() const { return my_label; }
    int memory_type    () const { return my_memory_type; }
    int get_memory_type() const { return my_memory_type; }
    bool data_valid_on_host  () const { return (my_memory_type == MEMORY_HOST  ) || (my_memory_type == MEMORY_SHARED); }
    bool data_valid_on_device() const { return (my_memory_type == MEMORY_DEVICE) || (my_memory_type == MEMORY_SHARED); }
  };
 
}