Device Vector added and Integrated with Neuro Vertices

Author: Avikant Wadhwa

CMakeLists.txt

@@ -462,6 +462,12 @@ endif()
 target_compile_options(gtest PRIVATE -Wno-error=maybe-uninitialized)
 target_compile_options(gtest_main PRIVATE -Wno-error=maybe-uninitialized)
 
+if(ENABLE_CUDA)
+    set(cuda_TestSources
+        Testing/UnitTesting/DeviceVectorTests.cpp)
+    set_source_files_properties(${cuda_TestSources} PROPERTIES LANGUAGE CUDA)
+endif()
+
 add_executable(tests
         Testing/RunTests.cpp
         Testing/UnitTesting/OperationManagerTests.cpp
@@ -481,7 +487,8 @@ add_executable(tests
         Testing/Utils/CircularBufferTests.cpp
         Testing/UnitTesting/EventBufferTests.cpp
         Testing/UnitTesting/XmlRecorderTests.cpp
-        Testing/UnitTesting/Hdf5RecorderTests.cpp)
+        Testing/UnitTesting/Hdf5RecorderTests.cpp
+        Testing/UnitTesting/DeviceVectorTests.cpp)
 
 # Links the Googletest framework with the testing executable
 target_link_libraries(tests gtest gtest_main)

Simulator/Utils/DeviceVector.h

@@ -0,0 +1,274 @@
+/**
+ * @file DeviceVector.h
+ *
+ * @ingroup Simulator/Utils
+ *
+ * @brief A vector class that manages both host and device (GPU) memory
+ *
+ * This class provides a std::vector-like interface for data that can be transferred
+ * between host and device memory. It manages the allocation and deallocation of
+ * GPU memory and provides synchronization methods between host and device.
+ */
+
+#pragma once
+#include <stdexcept>
+#include <vector>
+
+#if defined(__CUDACC__)
+   #include "BGTypes.h"
+   #include "Book.h"
+#endif
+
+template <typename T> class DeviceVector {
+public:
+   /// Reference type that handles bool specialization
+   using reference =
+      typename std::conditional_t<std::is_same_v<T, bool>, std::vector<bool>::reference, T &>;
+
+   /// Constructor (no GPU allocation)
+   explicit DeviceVector(size_t size = 0) : hostData_(size), devicePtr_(nullptr)
+   {
+   }
+
+   ~DeviceVector() = default;
+
+   /// Delete copy operations to prevent resource leaks
+   DeviceVector(const DeviceVector &) = delete;
+   DeviceVector &operator=(const DeviceVector &) = delete;
+
+   /// Add element to the end
+   void push_back(const T &value)
+   {
+      hostData_.push_back(value);
+   }
+
+   /// Resize the vector
+   void resize(size_t new_size)
+   {
+      hostData_.resize(new_size);
+   }
+
+   void resize(size_t new_size, const T &value)
+   {
+      hostData_.resize(new_size, value);
+   }
+
+   /// Clear all elements
+   void clear()
+   {
+      hostData_.clear();
+   }
+
+   /// Reserve capacity
+   void reserve(size_t new_cap)
+   {
+      hostData_.reserve(new_cap);
+   }
+
+   /// Get size
+   size_t size() const
+   {
+      return hostData_.size();
+   }
+
+   /// Check if empty
+   bool empty() const
+   {
+      return hostData_.empty();
+   }
+
+   /// Assign value to all elements
+   void assign(size_t n, const T &value)
+   {
+      hostData_.assign(n, value);
+   }
+
+   /// Get reference to host vector
+   const std::vector<T> &getHostVector() const
+   {
+      return hostData_;
+   }
+
+   std::vector<T> getHostVector()
+   {
+      return hostData_;
+   }
+
+   /// Get pointer to device memory
+   T *getDevicePointer()
+   {
+      return devicePtr_;
+   }
+
+   const T *getDevicePointer() const
+   {
+      return devicePtr_;
+   }
+
+   /// Implicit conversion to device pointer
+   operator T *()
+   {
+      return devicePtr_;
+   }
+
+   operator const T *() const
+   {
+      return devicePtr_;
+   }
+
+   /// Implicit conversion to host vector
+   operator std::vector<T> &()
+   {
+      return hostData_;
+   }
+
+   operator const std::vector<T> &() const
+   {
+      return hostData_;
+   }
+
+   /// Element access operator that works with both bool and non-bool types
+   reference operator[](size_t idx)
+   {
+      return hostData_[idx];
+   }
+
+   /// Const element access operator
+   const T operator[](size_t idx) const
+   {
+      if constexpr (std::is_same_v<T, bool>)
+         return static_cast<bool>(hostData_[idx]);   // ensure value, not proxy
+
+      return hostData_[idx];   // normal types
+   }
+
+   /// Get pointer to host data
+   T *data()
+   {
+      return hostData_.data();
+   }
+
+   const T *data() const
+   {
+      return hostData_.data();
+   }
+
+   /// Safe element access with bounds checking
+   T &at(size_t idx)
+   {
+      return hostData_.at(idx);
+   }
+
+   const T &at(size_t idx) const
+   {
+      return hostData_.at(idx);
+   }
+
+   /// Access first element
+   T &front()
+   {
+      return hostData_.front();
+   }
+
+   const T &front() const
+   {
+      return hostData_.front();
+   }
+
+   /// Access last element
+   T &back()
+   {
+      return hostData_.back();
+   }
+
+   const T &back() const
+   {
+      return hostData_.back();
+   }
+
+   /// Iterator support for range-based loops
+   auto begin()
+   {
+      return hostData_.begin();
+   }
+
+   auto end()
+   {
+      return hostData_.end();
+   }
+
+   auto begin() const
+   {
+      return hostData_.begin();
+   }
+
+   auto end() const
+   {
+      return hostData_.end();
+   }
+
+#if defined(__CUDACC__)
+public:
+   /// Allocates device memory for the vector data.
+   /// If device memory is already allocated, it is freed before allocating new memory.
+   void allocateDeviceMemory()
+   {
+      if (devicePtr_)
+         freeDeviceMemory();
+      cudaMalloc(&devicePtr_, hostData_.size() * sizeof(T));
+   }
+
+   /// Frees the allocated device memory.
+   void freeDeviceMemory()
+   {
+      if (devicePtr_) {
+         HANDLE_ERROR(cudaFree(devicePtr_));
+         devicePtr_ = nullptr;
+      }
+   }
+
+   /// Copy data from host to device memory
+   /// @throws std::runtime_error if device memory is not allocated
+   void copyToDevice()
+   {
+      if (!devicePtr_)
+         throw std::runtime_error("Device memory not allocated. Call allocateDeviceMemory()");
+
+      if constexpr (std::is_same_v<T, bool>) {
+         const size_t n = hostData_.size();
+         bool raw_data[n];
+         for (size_t i = 0; i < n; ++i) {
+            raw_data[i] = hostData_[i];
+         }
+         HANDLE_ERROR(cudaMemcpy(devicePtr_, raw_data, n * sizeof(bool), cudaMemcpyHostToDevice));
+      } else {
+         HANDLE_ERROR(cudaMemcpy(devicePtr_, hostData_.data(), hostData_.size() * sizeof(T),
+                                 cudaMemcpyHostToDevice));
+      }
+   }
+
+   /// Copy data from device to host memory
+   /// @throws std::runtime_error if device memory is not allocated
+   void copyToHost()
+   {
+      if (!devicePtr_)
+         throw std::runtime_error("Device memory not allocated.");
+
+      if constexpr (std::is_same_v<T, bool>) {
+         const size_t n = hostData_.size();
+         bool raw_data[n];
+         HANDLE_ERROR(cudaMemcpy(raw_data, devicePtr_, n * sizeof(bool), cudaMemcpyDeviceToHost));
+         for (size_t i = 0; i < n; ++i) {
+            hostData_[i] = raw_data[i];
+         }
+      } else {
+         HANDLE_ERROR(cudaMemcpy(hostData_.data(), devicePtr_, hostData_.size() * sizeof(T),
+                                 cudaMemcpyDeviceToHost));
+      }
+   }
+#endif
+
+private:
+   std::vector<T> hostData_;   // Host-side vector
+   T *devicePtr_;              // Device pointer
+};