hybrid.h

// -*-c++-*-
#ifndef STORMM_HYBRID_H
#define STORMM_HYBRID_H
 
#include <cstdio>
#include <cstring>
#include <stdexcept>
#include <cassert>
#include <typeinfo>
#include <typeindex>
#include <vector>
#ifdef STORMM_USE_HPC
#  ifdef STORMM_USE_CUDA
#    include <cuda_runtime.h>
#  endif
#endif
#include "copyright.h"
#include "Constants/behavior.h"
#include "Constants/scaling.h"
#include "DataTypes/common_types.h"
#include "DataTypes/stormm_vector_types.h"
#include "Math/rounding.h"
#include "Parsing/polynumeric.h"
#include "Reporting/error_format.h"
#include "gpu_enumerators.h"
#ifdef STORMM_USE_HPC
#  include "hpc_hybrid.h"
#endif
 
namespace stormm {
namespace card {
 
using constants::ExceptionResponse;
using constants::mega;
using errors::rtErr;
using stmath::roundUp;
using stmath::getPaddedMemorySize;
using parse::PolyNumeric;

constexpr char expedited_code = 'X';
constexpr char decoupled_code = 'L';
constexpr char unified_code   = 'U';
constexpr char host_only_code = 'L';
constexpr char devc_only_code = 'D';
constexpr char host_mounted_code = 'H';

constexpr llint allocating = 1;
constexpr llint deallocating = -1;
constexpr ulint hybrid_byte_increment = 128;
#ifdef STORMM_USE_HPC
constexpr HybridFormat default_hpc_format = HybridFormat::EXPEDITED;
#else
constexpr HybridFormat default_hpc_format = HybridFormat::HOST_ONLY;
#endif

constexpr ulint tag_name_length = 23;

struct HybridLabel {

  char name[tag_name_length];

  char format;

  int serial_number;
};

struct LedgerEntry {
  HybridKind kind;
  HybridLabel label;
  size_t length;
  size_t element_size;
  int allocations;
  bool active;
};

class Ledger {
public:

  Ledger();

  ~Ledger() = default;

  int getActiveEntryCount() const;

  int getSerialNumber();

  llint getTotalExpedited() const;

  llint getTotalDecoupled() const;

  llint getTotalUnified() const;

  llint getTotalHostOnly() const;

  llint getTotalDevcOnly() const;

  llint getTotalHostMounted() const;

  void setEntry(int serno, HybridKind kind,  const HybridLabel hlbl, size_t length,
                size_t element_size, int allocations);

  void unsetEntry(int serno);

  LedgerEntry getEntry(int index) const;
  std::vector<LedgerEntry> getEntry(const std::string &name) const;

  void logMemory(size_t capacity, size_t element_size, HybridFormat fmt, const HybridLabel hlbl,
                 llint multiplier);

  bool testActive(int serno);

  int getAllocations(int serno);

  void printMemoryProfile(int n_display = 8, llint display_threshold = mega);
 
private:

  llint total_expedited;
  llint total_decoupled;
  llint total_unified;
  llint total_host_only;
  llint total_devc_only;
  llint total_host_mounted;

  std::vector<LedgerEntry> entries;

  std::vector<int> free_slots;
};

template <typename T> class Hybrid {
public:

  explicit Hybrid(size_t length_in = 0, const char* tag_in = nullptr,
                  const HybridFormat format_in = default_hpc_format,
                  const HybridKind kind_in = HybridKind::ARRAY);
 
  explicit Hybrid(const std::vector<T> &S_in, const char* tag_in = nullptr,
                  const HybridFormat format_in = default_hpc_format);
 
  explicit Hybrid(const HybridKind kind_in, const char* tag_in = nullptr,
                  const HybridFormat format_in = default_hpc_format, size_t length_in = 0);

  ~Hybrid();

  Hybrid(const Hybrid &original);

  Hybrid(Hybrid &&original);  
  
  Hybrid& operator=(const Hybrid &other);

  Hybrid& operator=(Hybrid &&other);
  
  HybridKind getKind() const;

  HybridFormat getFormat() const;

  size_t size() const;

  size_t capacity() const;

  size_t getPointerIndex() const;

  size_t getElementSize() const;

  HybridLabel getLabel() const;

  int getSerialNumber() const;

  int getAllocations() const;
  
  int getTargetSerialNumber() const;

  bool verifyTarget() const;

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

  T readHost(size_t index) const;
  std::vector<T> readHost(size_t offset, size_t count) const;
  std::vector<T> readHost() const;
  void readHost(T* v, size_t offset, size_t count) const;

  void putHost(const T value, size_t index);
  void putHost(const std::vector<T> &values, size_t offset, size_t count);
  void putHost(const std::vector<T> &values);
  size_t putHost(Hybrid<T> *target, const std::vector<T> &values, size_t offset = 0,
                 size_t padding = 0, size_t count = 0);
#ifdef STORMM_USE_HPC
  void upload(size_t start_pos = 0, size_t length_copy = 0);

  void download(size_t start_pos = 0, size_t length_copy = 0);

  T readDevice(size_t index) const;
  std::vector<T> readDevice(size_t offset, size_t count) const;
  std::vector<T> readDevice() const;
  void readDevice(T* v, size_t offset, size_t count) const;

  void putDevice(const T value, size_t index);
  void putDevice(const T* values, size_t offset, size_t count);
  void putDevice(const std::vector<T> &values, size_t offset, size_t count);
  void putDevice(const std::vector<T> &values);
#endif
  void shrinkToFit();

  void pushBack(const T element);
  void pushBack(const T* elements, const size_t element_count);
  void pushBack(const std::vector<T> &elements);
  void pushBack(const Hybrid<T> &elements);

  void resize(size_t new_length);
  void resize(size_t new_length, T value);

  void setPointer(Hybrid<T> *target, size_t position = 0, llint new_length = -1LL);

  void swapTarget(Hybrid<T> *new_target, ExceptionResponse policy = ExceptionResponse::SILENT);
  
  const Hybrid<T> getPointer(size_t position = 0, size_t new_length = 0,
                             const char* tag_in = nullptr) const;
  Hybrid<T> getPointer(size_t position = 0, size_t new_length = 0, const char* tag_in = nullptr);
#ifdef STORMM_USE_HPC
#  ifdef STORMM_USE_CUDA
  const T* getDeviceValidHostPointer() const;
  T* getDeviceValidHostPointer();
#  endif
#endif
private:

  HybridKind kind;

  HybridFormat format;

  size_t length;

  size_t element_size;

  size_t growth_increment;

  size_t max_capacity;

  size_t pointer_index;

  T* host_data;

#ifdef STORMM_USE_HPC
  T* devc_data;
#endif

  HybridLabel label;

  int allocations;

  int target_serial_number;

  void enforceDataTypeLimits();

  void allocate();

  void deallocate();

  void reallocate(size_t new_length, size_t new_capacity = 0);

  HybridLabel assignLabel(const char* tag);
#if 0
  template <typename Treturn>
  friend const Hybrid<Treturn> reinterpretCast(const Hybrid *target, size_t offset, size_t length,
                                               const char* output_name);
 
  template <typename Treturn>
  friend Hybrid<Treturn> reinterpretCast(Hybrid *target, size_t offset, size_t length,
                                         const char* output_name);
#endif
};

template <typename T>
const Hybrid<T> setPointer(const Hybrid<T> *target, size_t offset, size_t length,
                           const char* output_name = nullptr);
 
template <typename T>
Hybrid<T> setPointer(Hybrid<T> *target, size_t offset, size_t length,
                     const char* output_name = nullptr);
 
} // namespace card
} // namespace stormm

extern stormm::card::Ledger gbl_mem_balance_sheet;
 
#include "hybrid.tpp"
 
#endif