Replace AlignedCudaBuffer with AlignedBuffer and add a cuda specializtion

Author: biddisco

src/Communicate/BufferHandler.h

@@ -33,14 +33,15 @@ namespace ippl::comms {
         return ((2 * num + (ALIGMNEMT - 1)) & (-ALIGMNEMT));
     }
 
-    struct AlignedCudaBuffer {
+    template <typename MemorySpace>
+    struct AlignedBuffer {
         void* ptrOriginal{nullptr};
         void* ptrAligned{nullptr};
         detail::size_type space{0};
         //
-        AlignedCudaBuffer() {}
+        AlignedBuffer() {}
         //
-        AlignedCudaBuffer& operator=(AlignedCudaBuffer&& other) {
+        AlignedBuffer& operator=(AlignedBuffer&& other) {
             ptrOriginal       = other.ptrOriginal;
             ptrAligned        = other.ptrAligned;
             space             = other.space;
@@ -50,28 +51,51 @@ namespace ippl::comms {
             return *this;
         }
         //
-        AlignedCudaBuffer(std::size_t size) {
+        AlignedBuffer(std::size_t size) {
+            ptrOriginal = static_cast<int*>(std::aligned_alloc(ALIGMNEMT, size));
+            ptrAligned  = ptrOriginal;
+            space       = size;
+            SPDLOG_TRACE("AlignedBuffer: original {}, aligned {}, size {}, space {}",
+                         (void*)(ptrOriginal), (void*)(ptrAligned), size, space);
+            // sanity check should always be true when std::align used
+            assert(space >= size);
+        }
+        //
+        ~AlignedBuffer() {
+            if (ptrOriginal) {
+                SPDLOG_DEBUG("Destroying cuda buffer {}", ptrOriginal);
+                std::free(ptrOriginal);
+            }
+        }
+    };
+
+#ifdef KOKKOS_ENABLE_CUDA
+    template <>
+    struct AlignedBuffer<Kokkos::CudaSpace> {
+        //
+        AlignedBuffer(std::size_t size) {
             void* original;
             space = to_multiple(size);
             cudaMalloc(&original, space);
             if (!original) {
-                throw std::runtime_error("Error allocating cuda memory in AlignedCudaBuffer");
+                throw std::runtime_error("Error allocating cuda memory in AlignedBuffer");
             }
             ptrOriginal = original;
             ptrAligned  = std::align(ALIGMNEMT, size, original, space);
-            SPDLOG_TRACE("AlignedCudaBuffer: original {}, aligned {}, size {}, space {}",
+            SPDLOG_TRACE("AlignedBuffer: original {}, aligned {}, size {}, space {}",
                          (void*)(ptrOriginal), (void*)(ptrAligned), size, space);
             // sanity check should always be true when std::align used
             assert(space >= size);
         }
         //
-        ~AlignedCudaBuffer() {
+        ~AlignedBuffer() {
             if (ptrOriginal) {
                 SPDLOG_DEBUG("Destroying cuda buffer {}", ptrOriginal);
                 cudaFree(ptrOriginal);
             }
         }
     };
+#endif
 
     template <typename MemorySpace, typename... Properties>
     struct comm_storage_wrapper {
@@ -97,16 +121,16 @@ namespace ippl::comms {
         // Note that this makes no effort to preserve any existing data
         void reallocBuffer(size_type newsize) {
             // wipe the old memory, before allocating new, (help prevent out-of-space errors)
-            buffer = AlignedCudaBuffer();
+            buffer = AlignedBuffer<memory_space>();
             // allocate new
-            buffer = AlignedCudaBuffer(newsize);
+            buffer = AlignedBuffer<memory_space>(newsize);
             view   = buffer_type((pointer_type)buffer.ptrAligned, newsize);
             SPDLOG_DEBUG("Realloc  : view {}, aligned {}, size {}, space {}", (void*)(view.data()),
                          (void*)(buffer.ptrAligned), newsize, buffer.space);
         }
         //
-        AlignedCudaBuffer buffer;
         buffer_type view;
+        AlignedBuffer<memory_space> buffer;
     };
 
     // ---------------------------------------------