Deleting ManagedSmartPtr and MVSmartRef classes and tests. They will …

…not be used in prod.

src/Field/SphArray.hh

@@ -327,365 +327,6 @@ ManagedVector<U> deepCopy(ManagedVector<U> const& array)
   return copy;
 }
 
-template<typename T>
-class ManagedSmartPtr;
-
-template<typename U>
-ManagedSmartPtr<U> deepCopy(ManagedSmartPtr<U> const& rhs);
-
-template<typename T>
-ManagedSmartPtr<T> make_ManagedSmartPtr(T* host_ptr);
-
-template<typename T, typename... Args>
-ManagedSmartPtr<T> make_ManagedSmartPtr(Args... args);
-
-template<typename T>
-class ManagedSmartPtr : public chai::CHAICopyable
-{
-public:
-  using element_type = T;
-struct PrivateConstruct {};
-
-  SPHERAL_HOST_DEVICE ManagedSmartPtr() {
-#if !defined(SPHERAL_GPU_ACTIVE) 
-    //m_ref_count = new size_t(0);
-#endif // SPHERAL_GPU_ACTIVE
-  }
-
-  template<typename... Args>
-  SPHERAL_HOST ManagedSmartPtr(PrivateConstruct, Args... args) {
-#if !defined(SPHERAL_GPU_ACTIVE) 
-    m_ptr = chai::ManagedArray<T>();
-    m_ptr.allocate(1, chai::CPU, getCallback());
-    m_ptr[0] = T(args...);
-    m_ptr.registerTouch(chai::CPU);
-    m_ref_count = new size_t(1);
-
-#endif // SPHERAL_GPU_ACTIVE
-  }
-
-  SPHERAL_HOST ManagedSmartPtr(PrivateConstruct, T* host_ptr) {
-#if !defined(SPHERAL_GPU_ACTIVE) 
-    m_ptr = chai::makeManagedArray(host_ptr, 1, chai::CPU, true);
-    m_ptr.setUserCallback(getCallback());
-    m_ptr.registerTouch(chai::CPU);
-    m_ref_count = new size_t(1);
-#endif // SPHERAL_GPU_ACTIVE
-  }
-
-
-public:
-  SPHERAL_HOST void registerTouch(chai::ExecutionSpace space) { m_ptr.registerTouch(space); }
-
-  SPHERAL_HOST_DEVICE ManagedSmartPtr& operator=(ManagedSmartPtr const& rhs) {
-    if (this != &rhs) {
-      if (m_ptr != rhs.m_ptr) discontinue_ownership();
-      m_ptr = rhs.m_ptr;
-      m_ref_count = rhs.m_ref_count;
-      increment_ref_count();
-    }
-    return *this;
-  }
-
-  SPHERAL_HOST_DEVICE ManagedSmartPtr(ManagedSmartPtr const& rhs) : m_ptr(rhs.m_ptr), m_ref_count(rhs.m_ref_count) {
-    increment_ref_count();
-  }
-
-  SPHERAL_HOST void move(chai::ExecutionSpace space, bool touch = true) const { 
-    m_ptr[0].move(space, touch);
-  }
-
-  SPHERAL_HOST_DEVICE T* get() const { return (m_ref_count) ? (m_ptr.data()) : nullptr; }
-  SPHERAL_HOST_DEVICE T* operator->() { return get(); }
-  SPHERAL_HOST_DEVICE T* operator->() const { return get(); }
-  SPHERAL_HOST_DEVICE T& operator*() { return *get(); }
-  SPHERAL_HOST_DEVICE T& operator*() const { return *get(); }
-
-  SPHERAL_HOST_DEVICE ~ManagedSmartPtr() {
-    discontinue_ownership();
-  }
-
-  SPHERAL_HOST_DEVICE ManagedSmartPtr& operator=(std::nullptr_t) { m_ref_count=nullptr; m_ptr=nullptr; return *this; }
-  SPHERAL_HOST_DEVICE void shallowCopy(ManagedSmartPtr const& rhs) {
-    *this = rhs;
-  }
-
-  template< typename U=ManagedSmartPtr< T > >
-  SPHERAL_HOST
-  auto getCallback() {
-//#ifdef SPHERAL_CALLBACK_ENABLED
-//    std::string const typeString = LvArray::system::demangleType< U >();
-//    return [typeString] (const chai::PointerRecord* record, chai::Action action, chai::ExecutionSpace exec) {
-//        std::string const size = LvArray::system::calculateSize(record->m_size);
-//        std::string const paddedSize = std::string( 9 - size.size(), ' ' ) + size;
-//        char const * const spaceStr = ( exec == chai::CPU ) ? "HOST  " : "DEVICE";
-//
-//        if (action == chai::Action::ACTION_MOVE){
-//          SPHERAL_LOG(Info, "Moved " << paddedSize << " to the " << spaceStr << ": " << typeString << " @ " <<  record->m_pointers[exec] )
-//        }
-//        if (action == chai::Action::ACTION_ALLOC){
-//          SPHERAL_LOG(Info, "Allocated on " << spaceStr << " " << paddedSize << " : " << typeString << " @ " <<  record->m_pointers[exec] )
-//        }
-//        if (action == chai::Action::ACTION_FREE){
-//          SPHERAL_LOG(Info, "Deallocated " << paddedSize << " : " << typeString << " @ " <<  record->m_pointers[exec] )
-//        }
-//      };
-//#else
-    return [](const chai::PointerRecord* , chai::Action , chai::ExecutionSpace ) {};
-//#endif
-  }
-protected:
-
-  SPHERAL_HOST_DEVICE void increment_ref_count() {
-#if !defined(SPHERAL_GPU_ACTIVE) 
-    if (m_ref_count != nullptr) (*m_ref_count)++;
-#endif // SPHERAL_GPU_ACTIVE
-  }
-
-  SPHERAL_HOST_DEVICE void discontinue_ownership() {
-#if !defined(SPHERAL_GPU_ACTIVE) 
-    if (m_ref_count != nullptr){
-      (*m_ref_count)--;
-      if (*m_ref_count == 0)
-      {
-        m_ptr[0].free();
-        m_ptr.free();
-        delete m_ref_count;
-        m_ref_count = nullptr;
-      }
-    }
-#endif // SPHERAL_GPU_ACTIVE
-  }
-
-
-  SPHERAL_HOST_DEVICE
-  friend bool compare(ManagedSmartPtr const& lhs, ManagedSmartPtr const& rhs)
-  {
-    // TODO : not safe
-    return compare(lhs.m_ptr[0], rhs.m_ptr[0]);
-  }
-
-  chai::ManagedArray<T> m_ptr;
-  size_t* m_ref_count = nullptr;
-
-  template<typename U>
-  friend ManagedSmartPtr deepCopy(ManagedSmartPtr const& rhs);
-
-  template<typename U>
-  friend ManagedSmartPtr make_ManagedSmartPtr(U* host_ptr);
-
-  template<typename U, typename... Args>
-  friend ManagedSmartPtr make_ManagedSmartPtr(Args... args);
-
-};
-
-
-template<typename U>
-ManagedSmartPtr<U> make_ManagedSmartPtr(U* host_ptr)
-  {
-    ManagedSmartPtr<U> ptr = ManagedSmartPtr<U>(typename ManagedSmartPtr<U>::PrivateConstruct(), host_ptr);
-    return ptr;
-  }
-
-template<typename U, typename... Args>
-ManagedSmartPtr<U> make_ManagedSmartPtr(Args... args)
-  {
-    ManagedSmartPtr<U> ptr = ManagedSmartPtr<U>(typename ManagedSmartPtr<U>::PrivateConstruct(), args...);
-    return ptr;
-  }
-
-template<typename U>
-ManagedSmartPtr<U> deepCopy(ManagedSmartPtr<U> const& rhs)
-{
-  // TODO : not safe
-  ManagedSmartPtr<U> ptr = make_ManagedSmartPtr<U>(deepCopy(*rhs));
-  return ptr;
-  //return ManagedSmartPtr<U>(typename ManagedSmartPtr<U>::PrivateConstruct(), deepCopy(*rhs));
-}
-
-
-template<typename T>
-class MVSmartRef : public ManagedSmartPtr<ManagedVector<T>>
-{
-  using Base = ManagedSmartPtr<ManagedVector<T>>;
-  SPHERAL_HOST_DEVICE ManagedVector<T> & mv() { return Base::m_ptr[0]; }
-  SPHERAL_HOST_DEVICE ManagedVector<T> const& mv() const { return Base::m_ptr[0]; }
-
-public:
-
-  using Base::operator->;
-  using Base::operator*;
-  using Base::get;
-  using Base::move;
-
-  using MV = Spheral::ManagedVector<T>;
-
-  SPHERAL_HOST_DEVICE MVSmartRef() = default;
-
-  template<typename... Args>
-  MVSmartRef(Args... args) : Base(make_ManagedSmartPtr<MV>(args...)) {mv().setCallback();}
-
-  using iterator = typename MV::iterator;
-  using const_iterator = typename MV::const_iterator;
-
-  iterator begin() { return mv().begin(); }
-  const_iterator begin() const { return mv().begin(); }
-
-  iterator end() { return begin() + size(); }
-  const_iterator end() const { return begin() + size(); }
-
-  SPHERAL_HOST_DEVICE T& operator[](size_t idx) {return mv()[idx]; }
-  SPHERAL_HOST_DEVICE T& operator[](size_t idx) const {return mv()[idx]; }
-
-  SPHERAL_HOST_DEVICE size_t size() const { return mv().size(); }
-
-  SPHERAL_HOST void resize(size_t sz) {
-    move(chai::CPU);
-    mv().resize(sz);
-    Base::m_ptr.registerTouch(chai::CPU);
-  }
-
-  SPHERAL_HOST
-  void insert(iterator pos, T const& value) {
-    move(chai::CPU);
-    mv().insert(pos, value);
-    Base::m_ptr.registerTouch(chai::CPU);
-  }
-
-  SPHERAL_HOST void push_back(T const& value) {
-    move(chai::CPU);
-    mv().push_back(value);
-    Base::m_ptr.registerTouch(chai::CPU);
-  }
-
-  SPHERAL_HOST void push_back(T&& value) {
-    move(chai::CPU);
-    mv().push_back(value);
-    Base::m_ptr.registerTouch(chai::CPU);
-  }
-
-  SPHERAL_HOST
-  void reserve(size_t c) {
-    move(chai::CPU);
-    mv().reserve(c);
-    Base::m_ptr.registerTouch(chai::CPU);
-  }
-
-  SPHERAL_HOST
-  void clear() {
-    move(chai::CPU);
-    mv().clear();
-    Base::m_ptr.registerTouch(chai::CPU);
-  }
-
-  SPHERAL_HOST
-  void erase(iterator pos) {
-    move(chai::CPU);
-    mv().erase(pos);
-    Base::m_ptr.registerTouch(chai::CPU);
-  }
-
-  SPHERAL_HOST_DEVICE MVSmartRef& operator=(std::nullptr_t) { Base::operator=(nullptr); return *this; }
-  SPHERAL_HOST_DEVICE void shallowCopy(MVSmartRef const& rhs) {
-    Base::shallowCopy(rhs);
-  }
-
-  SPHERAL_HOST_DEVICE bool operator==(MVSmartRef const& rhs) const { return (mv() == rhs.mv()); }
-  SPHERAL_HOST_DEVICE bool operator!=(MVSmartRef const& rhs) const { return (mv() != rhs.mv()); }
-
-private:
-
-  friend MVSmartRef deepCopy(MVSmartRef const& rhs)
-  {
-    // TODO : not safe
-    return MVSmartRef(deepCopy(rhs.m_ptr[0]));
-  }
-
-  SPHERAL_HOST_DEVICE
-  friend bool compare(MVSmartRef const& lhs, MVSmartRef const& rhs)
-  {
-    // TODO : not safe
-    return compare(lhs.mv(), rhs.mv());
-  }
-};
-
-
-
-
-//template<typename DataType>
-//using SphArray = LvArray::Array<DataType, 1, camp::idx_seq<0>, std::ptrdiff_t, LvArray::ChaiBuffer>;
-//
-//template<typename DataType>
-//using SphArrayView = LvArray::ArrayView<DataType, 1, 0, std::ptrdiff_t, LvArray::ChaiBuffer>;
-
-//template<typename sph_array_t>
-//class SphArrayIterator {
-//public:
-//  using iterator_category = std::random_access_iterator_tag;
-//  using value_type = typename sph_array_t::ValueType;
-//  using difference_type = std::ptrdiff_t;
-//  using pointer = value_type*;
-//  using reference = value_type&;
-//  
-//  SphArrayIterator(pointer ptr);
-//
-//  SphArrayIterator& operator++();
-//  SphArrayIterator operator++(int);
-//
-//  SphArrayIterator& operator--();
-//  SphArrayIterator operator--(int);
-//
-//  SphArrayIterator operator+(const difference_type& index) const;
-//  SphArrayIterator operator-(const difference_type& index) const;
-//
-//  difference_type operator-(const SphArrayIterator& it);
-//
-//  reference operator[](int index);
-//  pointer operator->();
-//
-//  reference operator*() const;
-//
-//  bool operator==(const SphArrayIterator& rhs) const;
-//  bool operator!=(const SphArrayIterator& rhs) const;
-//  bool operator<(const SphArrayIterator& rhs) const;
-//  bool operator<=(const SphArrayIterator& rhs) const;
-//  bool operator>(const SphArrayIterator& rhs) const;
-//  bool operator>=(const SphArrayIterator& rhs) const;
-//
-//  operator SphArrayIterator<typename sph_array_t::ViewTypeConst>() const;
-//
-//private:
-//  pointer mPtr;
-//};
-//
-//template<typename sph_array_t>
-//class SphArrayFieldIterator {
-//public:
-//  using iterator_category = std::input_iterator_tag;
-//  using value_type = typename sph_array_t::ValueType;
-//  using difference_type = std::ptrdiff_t;
-//  using pointer = value_type*;
-//  using reference = value_type&;
-//
-//  using field_type = typename value_type::FieldType;
-//  using field_pointer = field_type*;
-//  using field_reference = field_type&;
-//
-//  SphArrayFieldIterator(pointer ptr);
-//
-//  field_reference operator*() const;
-//  field_pointer operator->();
-//
-//  SphArrayFieldIterator& operator++();
-//  SphArrayFieldIterator operator++(int);
-//
-//  bool operator==(const SphArrayFieldIterator& rhs) const;
-//
-//private:
-//  pointer mPtr;
-//};
-
-
 } //  namespace Spheral
 
 //#include "SphArrayInline.hh"

tests/cpp/Field/managed_vector_tests.cc

@@ -83,69 +83,6 @@ GPU_TYPED_TEST(ManagedVectorTypedTest, IdentityConstructor)
 }
 
 
-GPU_TYPED_TEST(ManagedVectorTypedTest, ManagedPtrArrayTest)
-{
-  using WORK_EXEC_POLICY = TypeParam;
-
-  //Spheral::MVSmartRef array = Spheral::make_MVSmartRef<double>(5, chai::CPU);
-  Spheral::MVSmartRef<double> array;
-  //array = Spheral::make_MVSmartRef<double>(5, chai::CPU);
-  array = Spheral::MVSmartRef<double>(5, chai::CPU);
-
-  Spheral::MVSmartRef copy_array(array);
-
-  SPHERAL_ASSERT_EQ(array->size(), copy_array->size());
-
-  std::cout << "check0\n";
-  RAJA::forall<WORK_EXEC_POLICY>(TRS_UINT(0,array->size()),
-    [=] RAJA_HOST_DEVICE (unsigned i){
-      array[i] = i*2;
-      Spheral::MVSmartRef copy_array_2 = array;
-      SPHERAL_ASSERT_EQ(copy_array_2[i], i*2);
-    }
-  );
-
-
-  std::cout << "resize\n";
-  array.resize(20);
-
-
-  std::cout << "check1\n";
-  std::cout << copy_array->size();
-  RAJA::forall<WORK_EXEC_POLICY>(TRS_UINT(0,array->size()),
-    [=] RAJA_HOST_DEVICE (unsigned i){
-      if (i >= 5) copy_array[i] = i*3;
-      //SPHERAL_ASSERT_TRUE (copy_array->size() == 20);
-    }
-  );
-
-  std::cout << "check1.5\n";
-  RAJA::forall<LOOP_EXEC_POLICY>(TRS_UINT(0,array->size()),
-    [=] RAJA_HOST (unsigned i){
-      if (i < 5) SPHERAL_ASSERT_EQ(copy_array[i], i*2);
-      else SPHERAL_ASSERT_EQ(copy_array[i], i*3);
-    }
-  );
-
-  std::cout << "check2\n";
-  SPHERAL_ASSERT_EQ(&array[15], &copy_array[15]);
-  SPHERAL_ASSERT_EQ(array->size(), copy_array->size());
-
-  Spheral::MVSmartRef deep_copy_array = deepCopy(array);
-  //Spheral::MVSmartRef deep_copy_array = Spheral::make_MVSmartRef<double>(deepCopy(*array.get()));
-  SPHERAL_ASSERT_EQ(array->size(), deep_copy_array->size());
-
-  RAJA::forall<LOOP_EXEC_POLICY>(TRS_UINT(0,array->size()),
-    [=] RAJA_HOST (unsigned i){
-      SPHERAL_ASSERT_EQ(deep_copy_array[i], array[i]);
-    }
-  );
-
-  deep_copy_array[5] = 1234;
-  SPHERAL_ASSERT_NE(deep_copy_array[5], array[5]);
-  SPHERAL_ASSERT_NE(&deep_copy_array[0], &array[0]);
-}
-
 GPU_TYPED_TEST(ManagedVectorTypedTest, CopyConstructor)
 {
   using WORK_EXEC_POLICY = TypeParam;