.

Lib/memory-holder.cpp

@@ -57,7 +57,7 @@ template bool size_comparator(const buffer<MemType::GPU>& obj, const size_t requ
 #endif
 
 template< MemType mem >
-void* buffer<mem>::get_ptr() const
+void* buffer<mem>::get_ptr()
 {
     return ptr;
 }
@@ -80,7 +80,6 @@ buffer<mem>& buffer<mem>::operator=(buffer<mem>& other)
     if (this == &other)
         return *this;
  
-    // memproc::realloc<mem>((void*&)ptr, allocated_size, other.get_size());
     std::swap(ptr, other.ptr);
     std::swap(allocated_size, other.allocated_size); // exchange resources between *this and other
     std::swap(scalar_size, other.scalar_size);
@@ -137,7 +136,7 @@ std::vector<buffer<MemType::GPU> >& memory_pipline::get_memtyped_vector()
 #endif
 
 template< MemType mem >
-int memory_pipline::get_buffer(const size_t required_size, void * ptr)
+int memory_pipline::get_buffer(const size_t required_size, void *& ptr)
 {
     typename std::vector<buffer<mem>>::iterator available_buf_it;
     available_buf_it = std::lower_bound (get_memtyped_vector<mem>().begin(), get_memtyped_vector<mem>().end(), required_size, size_comparator<mem>);
@@ -156,9 +155,9 @@ int memory_pipline::get_buffer(const size_t required_size, void * ptr)
     }
 }
 
-template int memory_pipline::get_buffer<MemType::CPU>(const size_t required_size, void * ptr);
+template int memory_pipline::get_buffer<MemType::CPU>(const size_t required_size, void *& ptr);
 #ifdef INCLUDE_CUDA
-template int memory_pipline::get_buffer<MemType::GPU>(const size_t required_size, void * ptr);
+template int memory_pipline::get_buffer<MemType::GPU>(const size_t required_size, void *& ptr);
 #endif
 
 template< MemType mem >
@@ -172,7 +171,7 @@ template void memory_pipline::set_available<MemType::CPU>(const int id);
 template void memory_pipline::set_available<MemType::GPU>(const int id);
 #endif
 
-memory_faucet::memory_faucet(){}
+memory_pipline* memory_faucet::mem_pipe = nullptr;
 
 memory_pipline* memory_faucet::get_faucet()
 {
@@ -183,8 +182,6 @@ memory_pipline* memory_faucet::get_faucet()
     return mem_pipe;
 }
 
-memory_pipline* memory_faucet::mem_pipe = nullptr;
-
 template< MemType mem >
 memBuf<mem>::memBuf(const size_t required_size)
 {
@@ -196,8 +193,8 @@ memBuf<mem>::memBuf(const size_t required_size)
 template< MemType mem >
 memBuf<mem>::~memBuf()
 {
-    // memory_pipline* mem_pipe = memory_faucet::get_faucet();
-    // mem_pipe->set_available<mem>(id);
+    memory_pipline* mem_pipe = memory_faucet::get_faucet();
+    mem_pipe->set_available<mem>(id);
 }
 
 template< MemType mem >

Lib/memory-holder.h

@@ -26,7 +26,7 @@ public:
     buffer(const size_t required_size);
 
     bool is_available() const;
-    void* get_ptr() const;
+    void* get_ptr();
     bool get_status() const;
     size_t get_size() const;
     buffer<mem>& operator=(buffer<mem>& other);
@@ -47,7 +47,7 @@ public:
     ~memory_pipline();
 
     template< MemType mem >
-    int get_buffer(const size_t required_size, void * ptr);
+    int get_buffer(const size_t required_size, void *& ptr);
 
     template< MemType mem >
     std::vector<buffer<mem> >& get_memtyped_vector();
@@ -59,7 +59,7 @@ public:
 class memory_faucet
 {
 private:
-    memory_faucet();
+    memory_faucet() = delete;
     memory_faucet(const memory_faucet&) = delete;
     memory_faucet& operator=(const memory_faucet&) = delete;
 

main.cpp

@@ -4,8 +4,10 @@ int main(void)
 {
     const size_t required_size = sizeof(float) * 100;
     memBuf<MemType::CPU> Buf(required_size);
+    memBuf<MemType::GPU> Buf_gpu(required_size);
 
     float* ptr = static_cast<float*>(Buf.ptr());
+    float* ptr_gpu = static_cast<float*>(Buf_gpu.ptr());
 
     for (int i = 0; i < 100; i++)
     {