Managed Vector Unit tests running on AMD GPUs

Author: mdavis36

cmake/SetupSpheral.cmake

@@ -180,6 +180,8 @@ endif()
 # Build C++ tests and install tests to install directory
 #-------------------------------------------------------------------------------
 if (ENABLE_TESTS)
+  add_subdirectory(${SPHERAL_ROOT_DIR}/tests)
+
   spheral_install_python_tests(${SPHERAL_ROOT_DIR}/tests/ ${SPHERAL_TEST_INSTALL_PREFIX})
   # Always install performance.py in the top of the testing script
   install(FILES ${SPHERAL_ROOT_DIR}/tests/performance.py

extern/chai

@@ -56,8 +56,8 @@ class Spheral(CachedCMakePackage, CudaPackage, ROCmPackage):
     depends_on('[email protected] +shared +hdf5~hdf5_compat -test ~parmetis', type='build')
 
     depends_on('[email protected] +hdf5 -lua -examples -python -fortran', type='build')
-    depends_on('axom +shared', when='~cuda', type='build')
     depends_on('axom ~shared', when='+cuda', type='build')
+    depends_on('axom ~shared', when='+rocm', type='build')
 
     depends_on('[email protected] ~shared +adiak +gotcha ~libdw ~papi ~libunwind +pic', type='build')
 

scripts/spack/packages/spheral/package.py

@@ -32,9 +32,6 @@ namespace Spheral {
 #endif
 
 
-
-//#define MV_VALUE_SEMANTICS
-
 template<typename DataType>
 class ManagedVector;
 
@@ -72,94 +69,52 @@ public:
   {
 #if !defined(SPHERAL_GPU_ACTIVE) 
     setCallback();
-
 #endif // SPHERAL_GPU_ACTIVE
   }
 
-  SPHERAL_HOST_DEVICE ManagedVector(size_t elems) : 
+  SPHERAL_HOST ManagedVector(size_t elems) : 
     MA(),
     m_size(elems) 
   {
-#if !defined(SPHERAL_GPU_ACTIVE) 
     MA::allocate(m_size < initial_capacity ? initial_capacity: pow2_ceil(m_size), chai::CPU, getCallback());
     for (size_t i = 0; i < m_size; i++) new (&MA::operator[](i)) DataType(); 
     MA::registerTouch(chai::CPU);
-#endif // SPHERAL_GPU_ACTIVE
   }
 
   SPHERAL_HOST ManagedVector(size_t elems, DataType identity) :
     MA(),
     m_size(elems) 
   {
-#if !defined(SPHERAL_GPU_ACTIVE) 
     MA::allocate(m_size < initial_capacity ? initial_capacity: pow2_ceil(m_size), chai::CPU, getCallback());
     for (size_t i = 0; i < m_size; i++) new (&MA::operator[](i)) DataType(identity);
     MA::registerTouch(chai::CPU);
-#endif // SPHERAL_GPU_ACTIVE
   }
 
-#ifdef MV_VALUE_SEMANTICS
-  // ---------------------
-  // Destructor
-  // ---------------------
-  SPHERAL_HOST ~ManagedVector() 
-  {
-    MA::free();
-  }
-#endif
   using MA::move;
   using MA::free;
 
   // ---------------------
   // Copy Constructor
   // ---------------------
-#ifdef MV_VALUE_SEMANTICS
-  SPHERAL_HOST_DEVICE constexpr inline ManagedVector(ManagedVector const& rhs) noexcept : 
-    ManagedVector(rhs.m_size)
-  {printf("MV Copy w/ Value Semantics.\n");
-    for (size_t i = 0; i < m_size; i++) new (&MA::operator[](i)) DataType(rhs[i]);
-  }
-#else
   SPHERAL_HOST_DEVICE constexpr inline ManagedVector(ManagedVector const& rhs) noexcept : MA(rhs), m_size(rhs.m_size) {}
-#endif
 
   // ---------------------
   // Assignment
   // ---------------------
-#ifdef MV_VALUE_SEMANTICS
-  SPHERAL_HOST_DEVICE ManagedVector<DataType>& operator=(ManagedVector const& rhs) { 
-    if (capacity() != rhs.capacity()) MA::reallocate(rhs.capacity());
-    m_size = rhs.m_size;
-    for (size_t i = 0; i < m_size; i++) new (&MA::operator[](i)) DataType(rhs[i]);
-    return *this; 
-  }
-#else
   SPHERAL_HOST_DEVICE ManagedVector<DataType>& operator=(ManagedVector const& rhs) {
     MA::operator=(rhs);
     m_size = rhs.m_size;
     return *this; 
   }
-#endif
 
   // ---------------------
   // Equivalence
   // ---------------------
-#ifdef MV_VALUE_SEMANTICS
-  SPHERAL_HOST bool operator==(ManagedVector const& rhs) const {
-    if (m_size != rhs.m_size) return false;
-    for (size_t i = 0; i < m_size; i++) {
-      if (MA::operator[](i) != rhs[i]) { 
-        return false;
-      }
-    }
-    return true;
-  }
-#else
   SPHERAL_HOST_DEVICE bool operator==(ManagedVector const& rhs) const {
     if (m_size != rhs.m_size) return false;
     return MA::operator==(rhs);
   }
-#endif
+
   SPHERAL_HOST_DEVICE bool operator!=(ManagedVector const& rhs) const {
     return !(*this == rhs);
   }
@@ -174,10 +129,10 @@ public:
   SPHERAL_HOST void push_back(DataType&& value) {
     if (capacity() == 0) MA::allocate(initial_capacity, chai::CPU, getCallback());
     if (m_size >= capacity()) MA::reallocate(pow2_ceil(m_size + 1));
-    //MA::operator[](m_size) = std::move(value);
     new(&MA::operator[](m_size)) DataType(value);
     m_size++;
   }
+
   template<typename... Args>
   SPHERAL_HOST
   DataType& emplace_back(Args&&... args) {
@@ -330,21 +285,14 @@ inline
 ManagedVector<U> deepCopy(ManagedVector<U> const& array)
 {
   ManagedVector<U> copy(array.size());
-  for (size_t i = 0; i < array.size(); i++) new (&copy[i]) U(array[i]);
+  for (size_t i = 0; i < array.size(); i++) {
+    new (&copy[i]) U(array[i]);
+  }
   return copy;
 }
 
 } //  namespace Spheral
 
-//#include "SphArrayInline.hh"
-
-#else
-
-//// Forward declare the SphArrayIterator class.
-//namespace Spheral {
-//  template<typename sph_array_t> class SphArrayIterator ;
-//} //  namespace Spheral
-
 #endif //  __Spheral_lvarray_hh__
 
 

src/Utilities/ManagedVector.hh

@@ -8,8 +8,13 @@
 #cmakedefine SPHERAL_ENABLE_OPENMP
 
 #cmakedefine SPHERAL_ENABLE_CUDA
+#cmakedefine SPHERAL_ENABLE_HIP
 #cmakedefine SPHERAL_ENABLE_VVI
 
+#if defined(SPHERAL_ENABLE_HIP) && defined(__HIPCC__)
+#define SPHERAL_GPU_ACTIVE
+#endif // SPHERAL_ENABLE_CUDA && __CUDACC__
+
 #if defined(SPHERAL_ENABLE_CUDA) && defined(__CUDA_ARCH__)
 #define SPHERAL_GPU_ACTIVE
 #endif // SPHERAL_ENABLE_CUDA && __CUDACC__

src/config.hh.in

@@ -1,3 +1,2 @@
 add_subdirectory(cpp/Field)
 add_subdirectory(cpp/Utilities)
-add_subdirectory(unit)

tests/CMakeLists.txt

@@ -8,6 +8,7 @@ spheral_add_test(
 spheral_add_test(
   NAME managed_vector_tests
   SOURCES managed_vector_tests.cc
+  DEBUG_LINKER
 )
 
 

tests/cpp/Utilities/CMakeLists.txt

@@ -14,7 +14,7 @@ template<typename T>
 class ManagedVectorTypedTest : public::testing::Test {};
 
 // All ManagedVectorTets cases will run over each type in EXEC_TYPES.
-TYPED_TEST_SUITE(ManagedVectorTypedTest, EXEC_TYPES,);
+TYPED_TEST_CASE(ManagedVectorTypedTest, EXEC_TYPES);
 
 
 GPU_TYPED_TEST(ManagedVectorTypedTest, DefaultConstructor)
@@ -43,6 +43,9 @@ TEST(ManagedVectorTest, SizeConstructor)
   MVDouble array2(MVDouble::initial_capacity + 1);
   SPHERAL_ASSERT_EQ(array2.size(),     MVDouble::initial_capacity + 1);
   SPHERAL_ASSERT_EQ(array2.capacity(), MVDouble::initial_capacity * 2);
+
+  array.free();
+  array2.free();
 }
 
 
@@ -56,6 +59,7 @@ TEST(ManagedVectorTest, IdentityConstructor)
   for(auto& elem: array){
     SPHERAL_ASSERT_EQ(elem, 5);
   }
+  array.free();
 }
 
 
@@ -80,6 +84,8 @@ GPU_TYPED_TEST(ManagedVectorTypedTest, IdentityConstructor)
     }
   );
 
+  array.free();
+  array2.free();
 }
 
 

tests/cpp/Utilities/managed_vector_tests.cc

@@ -10,6 +10,7 @@ using EXEC_TYPES = ::testing::Types<
 #ifdef SPHERAL_ENABLE_CUDA
   ,RAJA::cuda_exec<512>
 #endif
+  ,RAJA::hip_exec<512>
 >;
 
 

tests/cpp/include/test-basic-exec-policies.hh

@@ -16,6 +16,9 @@ using LOOP_EXEC_POLICY = RAJA::seq_exec;
 #define EXEC_IN_SPACE_END() \
   });
 
+//#if defined(SPHERAL_ENABLE_HIP) && defined(__HIPCC__)
+#define SPHERAL_GPU_ACTIVE
+//#endif // SPHERAL_ENABLE_CUDA && __CUDACC__
 
 template<typename T, typename U>
 inline