hotfix

src/MemoryProcessing.cpp

@@ -2,53 +2,56 @@
 #include <cstdlib>
 #include <cstring>
 
-template<>
-bool memproc::dealloc<MemType::CPU>(void *&array, size_t &allocated_size)
+namespace memproc
 {
-    if(allocated_size > 0)
+    template<>
+    bool dealloc<MemType::CPU>(void *&array, size_t &allocated_size)
     {
-        free(array);
-        allocated_size = 0;
-    }
-
-    return true;
-}
-
-template<>
-bool memproc::dealloc<MemType::CPU>(void *&array)
-{
-    free(array);
-    return true;
-}
+        if(allocated_size > 0)
+        {
+            free(array);
+            allocated_size = 0;
+        }
 
-template <>
-bool memproc::alloc<MemType::CPU>(void *&array, const size_t new_size)
-{
-    array = malloc(new_size);
-    memset(array, 0, new_size);
-
-    return true;
-}
+        return true;
+    }
 
+    template<>
+    bool dealloc<MemType::CPU>(void *&array)
+    {
+        free(array);
+        return true;
+    }
 
-template <>
-bool memproc::realloc<MemType::CPU>(void *&array, size_t &allocated_size, const size_t new_size)
-{
-    if(new_size > allocated_size)
+    template <>
+    bool alloc<MemType::CPU>(void *&array, const size_t new_size)
     {
-        if(allocated_size > 0) dealloc<MemType::CPU>(array, allocated_size);
-        allocated_size = new_size;
         array = malloc(new_size);
         memset(array, 0, new_size);
+
+        return true;
     }
 
-    return true;
-}
 
-template <>
-bool memproc::memcopy<MemType::CPU, MemType::CPU>(void *dst, const void* src, const size_t copy_elem_size)
-{
-    memcpy(dst, src, copy_elem_size);
+    template <>
+    bool realloc<MemType::CPU>(void *&array, size_t &allocated_size, const size_t new_size)
+    {
+        if(new_size > allocated_size)
+        {
+            if(allocated_size > 0) dealloc<MemType::CPU>(array, allocated_size);
+            allocated_size = new_size;
+            array = malloc(new_size);
+            memset(array, 0, new_size);
+        }
+
+        return true;
+    }
+
+    template <>
+    bool memcopy<MemType::CPU, MemType::CPU>(void *dst, const void* src, const size_t copy_elem_size)
+    {
+        memcpy(dst, src, copy_elem_size);
 
-    return true;
+        return true;
+    }
 }
\ No newline at end of file

src/MemoryProcessing.cu

@@ -2,66 +2,69 @@
 #include <cuda.h>
 #include <cuda_runtime_api.h>
 
-template<>
-bool memproc::dealloc<MemType::GPU>(void *&array, size_t &allocated_size)
+namespace memproc
 {
-    if(allocated_size > 0)
+    template<>
+    bool dealloc<MemType::GPU>(void *&array, size_t &allocated_size)
     {
-        cudaFree(array);
-        allocated_size = 0;
-    }
-
-    return true;
-}
+        if(allocated_size > 0)
+        {
+            cudaFree(array);
+            allocated_size = 0;
+        }
 
-template<>
-bool memproc::dealloc<MemType::GPU>(void *&array)
-{
-    cudaFree(array);
-    return true;
-}
-
-template <>
-bool memproc::alloc<MemType::GPU>(void *&array, const size_t new_size)
-{
-    cudaMalloc ( (void **)&array, new_size);
-    cudaMemset(array, 0, new_size);
+        return true;
+    }
 
-    return true;
-}
+    template<>
+    bool dealloc<MemType::GPU>(void *&array)
+    {
+        cudaFree(array);
+        return true;
+    }
 
-template <>
-bool memproc::realloc<MemType::GPU>(void *&array, size_t &allocated_size, const size_t new_size)
-{
-    if(new_size > allocated_size)
+    template <>
+    bool alloc<MemType::GPU>(void *&array, const size_t new_size)
     {
-        if(allocated_size > 0) dealloc<MemType::GPU>(array, allocated_size);
-        allocated_size = new_size;
         cudaMalloc ( (void **)&array, new_size);
         cudaMemset(array, 0, new_size);
+
+        return true;
     }
 
-    return true;
-}
+    template <>
+    bool realloc<MemType::GPU>(void *&array, size_t &allocated_size, const size_t new_size)
+    {
+        if(new_size > allocated_size)
+        {
+            if(allocated_size > 0) dealloc<MemType::GPU>(array, allocated_size);
+            allocated_size = new_size;
+            cudaMalloc ( (void **)&array, new_size);
+            cudaMemset(array, 0, new_size);
+        }
 
-template <>
-bool memproc::memcopy<MemType::GPU, MemType::CPU>(void *dst, const void* src, const size_t copy_elem_size)
-{
-    cudaMemcpy ( dst, src, copy_elem_size, cudaMemcpyHostToDevice);
+        return true;
+    }
 
-    return true;
-}
+    template <>
+    bool memcopy<MemType::GPU, MemType::CPU>(void *dst, const void* src, const size_t copy_elem_size)
+    {
+        cudaMemcpy ( dst, src, copy_elem_size, cudaMemcpyHostToDevice);
 
-template <>
-bool memproc::memcopy<MemType::CPU, MemType::GPU>(void *dst, const void* src, const size_t copy_elem_size)
-{
-    cudaMemcpy ( dst, src, copy_elem_size, cudaMemcpyDeviceToHost);
-    return true;
-}
+        return true;
+    }
 
-template <>
-bool memproc::memcopy<MemType::GPU, MemType::GPU>(void *dst, const void* src, const size_t copy_elem_size)
-{
-    cudaMemcpy ( dst, src, copy_elem_size, cudaMemcpyDeviceToDevice);
-    return true;
+    template <>
+    bool memcopy<MemType::CPU, MemType::GPU>(void *dst, const void* src, const size_t copy_elem_size)
+    {
+        cudaMemcpy ( dst, src, copy_elem_size, cudaMemcpyDeviceToHost);
+        return true;
+    }
+
+    template <>
+    bool memcopy<MemType::GPU, MemType::GPU>(void *dst, const void* src, const size_t copy_elem_size)
+    {
+        cudaMemcpy ( dst, src, copy_elem_size, cudaMemcpyDeviceToDevice);
+        return true;
+    }
 }
\ No newline at end of file