monolish_vector.hpp

Go to the documentation of this file.

 
#pragma once
#include "./monolish_dense.hpp"
#include "./monolish_logger.hpp"
#include "./monolish_view1D.hpp"
#include <exception>
#include <fstream>
#include <iostream>
#include <iterator>
#include <memory>
#include <omp.h>
#include <stdexcept>
#include <string>
#include <vector>
 
#if USE_SXAT
#undef _HAS_CPP17
#endif
#include <random>
#if USE_SXAT
#define _HAS_CPP17 1
#endif
 
#if defined USE_MPI
#include <mpi.h>
#endif
 
namespace monolish {
 
template <typename Float> class vector {
private:
  std::vector<Float> val;
 
  mutable bool gpu_status = false;
 
public:
  vector() {}
 
  // constructor ///////////////////////////////////////////////////////
  vector(const size_t N);
 
  vector(const size_t N, const Float value);
 
  vector(const std::vector<Float> &vec);
 
  vector(const std::initializer_list<Float> &list);
 
  vector(const vector<Float> &vec);
 
  vector(const view1D<vector<Float>, Float> &vec);
 
  vector(const view1D<matrix::Dense<Float>, Float> &vec);
 
  vector(const Float *start, const Float *end);
 
  vector(const size_t N, const Float min, const Float max);
 
  // communication
  // ///////////////////////////////////////////////////////////////////////////
  void send() const;
 
  void recv();
 
  void nonfree_recv();
 
  void device_free() const;
 
  [[nodiscard]] bool get_device_mem_stat() const { return gpu_status; }
 
  ~vector() {
    if (get_device_mem_stat()) {
      device_free();
    }
  }
 
  [[nodiscard]] size_t get_offset() const { return 0; }
 
  // util
  // ///////////////////////////////////////////////////////////////////////////
 
  [[nodiscard]] const Float *data() const { return val.data(); }
 
  [[nodiscard]] Float *data() { return val.data(); }
 
  void resize(size_t N) {
    if (get_device_mem_stat()) {
      throw std::runtime_error("Error, GPU vector cant use resize");
    }
    val.resize(N);
  }
 
  void push_back(Float val) {
    if (get_device_mem_stat()) {
      throw std::runtime_error("Error, GPU vector cant use push_back");
    }
    val.push_back(val);
  }
 
  [[nodiscard]] const Float *begin() const { return val.data(); }
 
  [[nodiscard]] Float *begin() { return val.data(); }
 
  [[nodiscard]] const Float *end() const { return val.data() + size(); }
 
  [[nodiscard]] Float *end() { return val.data() + size(); }
 
  [[nodiscard]] auto size() const { return val.size(); }
 
  [[nodiscard]] auto get_nnz() const { return val.size(); }
 
  void fill(Float value);
 
  void print_all(bool force_cpu = false) const;
 
  void print_all(std::string filename) const;
 
  // operator
  // ///////////////////////////////////////////////////////////////////////////
 
  void operator=(const vector<Float> &vec);
 
  void operator=(const view1D<vector<Float>, Float> &vec);
 
  void operator=(const view1D<matrix::Dense<Float>, Float> &vec);
 
  void operator=(const std::vector<Float> &vec);
 
  [[nodiscard]] vector<Float> operator-();
 
  [[nodiscard]] Float &operator[](size_t i) {
    if (get_device_mem_stat()) {
      throw std::runtime_error("Error, GPU vector cant use operator[]");
    }
    return val[i];
  }
 
  bool equal(const vector<Float> &vec,
             bool compare_cpu_and_device = false) const;
 
  bool equal(const view1D<vector<Float>, Float> &vec,
             bool compare_cpu_and_device = false) const;
 
  bool equal(const view1D<matrix::Dense<Float>, Float> &vec,
             bool compare_cpu_and_device = false) const;
 
  bool operator==(const vector<Float> &vec) const;
 
  bool operator==(const view1D<vector<Float>, Float> &vec) const;
 
  bool operator==(const view1D<matrix::Dense<Float>, Float> &vec) const;
 
  bool operator!=(const vector<Float> &vec) const;
 
  bool operator!=(const view1D<vector<Float>, Float> &vec) const;
 
  bool operator!=(const view1D<matrix::Dense<Float>, Float> &vec) const;
};
} // namespace monolish