Fixes because of valgrind errors

Lib/buffer.cpp

@@ -3,29 +3,14 @@
 #ifdef INCLUDE_CUDA
 #include "MemoryProcessing.cuh"
 #endif
-// void dyn_dispatch_buffer::reallocate(buffer_base* obj, const size_t required_size)
-// {
-//     obj->reallocate(required_size);
-// }
 
-// void dyn_dispatch_buffer::deallocate(buffer_base* obj)
-// {
-//     obj->deallocate();
-// }
+#include <cassert>
+#include <utility>
 
-buffer_base::buffer_base()
+void buffer::reallocate(const size_t required_size)
 {
-    ptr = nullptr;
-    allocated_size = 0;
-    scalar_size = 0;
-    is_free = true;
-    id = -1;
-    // ! resolve
-    mem = MemType::CPU;
-}
+    assert(mem != MemType::UNDEF);
 
-void buffer_base::reallocate(const size_t required_size)
-{
     if(mem == MemType::CPU)
         memproc::realloc<MemType::CPU>((void *&)ptr, allocated_size, required_size); 
 #ifdef INCLUDE_CUDA
@@ -34,8 +19,11 @@ void buffer_base::reallocate(const size_t required_size)
 #endif
 }
 
-void buffer_base::deallocate()
+void buffer::deallocate()
 {
+    if(mem == MemType::UNDEF)
+        return;
+
     if(mem == MemType::CPU)
         memproc::dealloc<MemType::CPU>((void *&)ptr, allocated_size); 
 #ifdef INCLUDE_CUDA
@@ -44,18 +32,21 @@ void buffer_base::deallocate()
 #endif
 }
 
-buffer_base::~buffer_base()
+buffer::~buffer()
 {
     deallocate();
     ptr = nullptr;
     scalar_size = 0;
     is_free = true;
     id = -1;
+    mem = MemType::UNDEF;
 }
 
 
-buffer_base::buffer_base(const buffer_base& other)
+buffer::buffer(const buffer& other)
 {    
+    assert(other.mem != MemType::UNDEF);
+
     mem = other.mem;
     allocated_size = 0;
     reallocate(other.get_size());
@@ -63,27 +54,28 @@ buffer_base::buffer_base(const buffer_base& other)
     id = other.get_id();
 }
 
-buffer_base::buffer_base(buffer_base&& other) 
+buffer::buffer(buffer&& other) noexcept : 
+    mem(other.mem), ptr(std::move(other.ptr)), allocated_size(other.allocated_size),
+    scalar_size(other.scalar_size), is_free(other.is_free),
+    id(other.id)
 {    
-    mem = other.mem;
-    ptr = other.ptr;
-    allocated_size = other.allocated_size;
-    scalar_size = other.scalar_size;
-    is_free = other.is_free;
-    id = other.id;
+    assert(other.mem != MemType::UNDEF);
 
     other.ptr = nullptr;
     other.allocated_size = 0;
     other.scalar_size = 0;
     other.is_free = false;
     other.id = -1;
+    other.mem = MemType::UNDEF;
 }
 
-buffer_base& buffer_base::operator=(const buffer_base& other)
+buffer& buffer::operator=(const buffer& other)
 {
     if (this == &other)
         return *this;
- 
+    
+    assert(other.mem != MemType::UNDEF);
+
     mem = other.mem;
     reallocate(other.get_size());
     is_free = other.get_status();
@@ -92,13 +84,15 @@ buffer_base& buffer_base::operator=(const buffer_base& other)
     return *this;
 }
 
-buffer_base& buffer_base::operator=(buffer_base&& other) 
+buffer& buffer::operator=(buffer&& other) noexcept
 {
     if (this != &other)
     {
-        mem = other.mem;
+        assert(other.mem != MemType::UNDEF);
         deallocate();
-        ptr = other.ptr;
+
+        mem = other.mem;
+        ptr = std::move(other.ptr);
         allocated_size = other.allocated_size;
         scalar_size = other.scalar_size;
         is_free = other.is_free;
@@ -109,19 +103,22 @@ buffer_base& buffer_base::operator=(buffer_base&& other)
         other.scalar_size = 0;
         other.is_free = false;
         other.id = -1;
+        other.mem = MemType::UNDEF;
     }
 
     return *this;
 }
 
 
-bool buffer_base::is_available() const
+bool buffer::is_available() const
 {
     return is_free;
 }
 
-buffer_base::buffer_base(const size_t required_size, const MemType mem_in)
+buffer::buffer(const size_t required_size, const MemType mem_in)
 {
+    assert(mem_in != MemType::UNDEF);
+
     mem = mem_in;
     ptr = nullptr;
     allocated_size = 0;
@@ -130,59 +127,42 @@ buffer_base::buffer_base(const size_t required_size, const MemType mem_in)
     is_free = false;
 }
 
-void* buffer_base::get_ptr()
+void* buffer::get_ptr()
 {
     return ptr;
 }
 
-bool buffer_base::get_status() const
+bool buffer::get_status() const
 {
     return is_free;
 }
 
-size_t buffer_base::get_size() const
+size_t buffer::get_size() const
 {
     return allocated_size;
 }
 
-int buffer_base::get_id() const
+int buffer::get_id() const
 {
     return id;
 }
 
-void buffer_base::set_allocated_size(const size_t required_size) 
+void buffer::set_allocated_size(const size_t required_size) 
 {
     allocated_size = required_size;
 }
 
-void buffer_base::set_null_pointer()
+void buffer::set_null_pointer()
 {
     ptr = nullptr;
 }
 
-void buffer_base::set_status(const bool status)
+void buffer::set_status(const bool status)
 {
     is_free = status;
 }
 
-void buffer_base::set_id(const int idx)
+void buffer::set_id(const int idx)
 {
     id = idx;
-}
-
-// template< MemType mem >
-// void buffer<mem>::reallocate(const size_t required_size) 
-// {
-//     memproc::realloc<mem>((void *&)ptr, allocated_size, required_size);  
-// }
-
-// template< MemType mem >
-// void buffer<mem>::deallocate()
-// {
-//     memproc::deallocate<mem>((void *&)ptr, allocated_size);  
-// }
-
-// template class buffer<MemType::CPU>;
-// #ifdef INCLUDE_CUDA
-// template class buffer<MemType::GPU>;
-// #endif
\ No newline at end of file
+}
\ No newline at end of file

Lib/buffer.h

@@ -2,7 +2,7 @@
 #include "TemplateParameters.h"
 #include <cstdlib>
 
-class buffer_base
+class buffer
 {
 public:
     void *ptr;
@@ -12,11 +12,10 @@ public:
     int id;
     MemType mem;
 
-    buffer_base(); // Done
-    buffer_base(const size_t required_size, const MemType mem); // Done
-    buffer_base(const buffer_base& other); // Done
-    buffer_base(buffer_base&& other); // Done
-    ~buffer_base(); // Done
+    buffer(const size_t required_size, const MemType mem); // Done
+    buffer(const buffer& other); // Done
+    buffer(buffer&& other) noexcept; // Done
+    ~buffer(); // Done
 
     bool is_available() const; // Done
     void* get_ptr(); // Done
@@ -29,36 +28,9 @@ public:
     void set_id(const int id); // Done
     void set_null_pointer(); // Done
 
-    buffer_base& operator=(const buffer_base& other); // Done
-    buffer_base& operator=(buffer_base&& other);      // Done
+    buffer& operator=(const buffer& other); // Done
+    buffer& operator=(buffer&& other) noexcept;      // Done
 
     void reallocate(const size_t required_size);
     void deallocate();
 };
-
-// namespace dyn_dispatch_buffer
-// {
-//     void reallocate(buffer_base* obj, const size_t required_size);
-//     void deallocate(buffer_base* obj);
-// };
-
-// template< MemType mem >
-// class buffer: public buffer_base
-// {
-// private:
-//     using buffer_base::ptr;
-//     using buffer_base::allocated_size;
-//     using buffer_base::scalar_size;
-//     using buffer_base::is_free;
-//     using buffer_base::id;
-
-// public:
-//     buffer(const buffer<mem>& other) : buffer_base(other) {}
-//     buffer(buffer<mem>&& other) : buffer_base(other) {}
-//     buffer() : buffer_base() {}
-//     ~buffer(){};
-//     buffer(const size_t required_size) : buffer_base(required_size) {}
-
-//     void reallocate(const size_t required_size) override;
-//     void deallocate() override;
-// };
\ No newline at end of file

Lib/memory-faucet.cpp

@@ -9,7 +9,7 @@
 template< MemType mem, buf_choose_policy choose_type >
 memory_pipe<mem, choose_type>::memory_pipe()
 {
-    buff_vec = std::vector<buffer_base > ();
+    buff_vec = std::vector<buffer > ();
 }
 
 template< MemType mem, buf_choose_policy choose_type >
@@ -25,7 +25,7 @@ void memory_pipe<mem, choose_type>::set_available(const int id)
 }
 
 template< MemType mem, buf_choose_policy choose_type >
-std::vector<buffer_base >& memory_pipe<mem, choose_type>::get_buff_vec()
+std::vector<buffer >& memory_pipe<mem, choose_type>::get_buff_vec()
 {
     return buff_vec;
 }

Lib/memory-faucet.h

@@ -5,12 +5,12 @@ template< MemType mem = MemType::CPU, buf_choose_policy choose_type = buf_choose
 class memory_pipe
 {
 private:
-    std::vector<buffer_base > buff_vec;
+    std::vector<buffer > buff_vec;
 public:
     memory_pipe(/* args */);
     ~memory_pipe();
     void set_available(const int id);
-    std::vector<buffer_base >& get_buff_vec();
+    std::vector<buffer >& get_buff_vec();
 };
 
 class memory_faucet

Lib/mf-utils.cpp

 #include "mf-utils.h"
 
-bool mf_utils::free_size_comparator(const buffer_base& obj, const size_t required_size)
+bool mf_utils::free_size_comparator(const buffer& obj, const size_t required_size)
 {
     if(obj.get_status() == false)
         return false;
@@ -8,18 +8,18 @@ bool mf_utils::free_size_comparator(const buffer_base& obj, const size_t require
     return obj.get_size() <= required_size;
 }
 
-bool mf_utils::size_comparator(const size_t required_size, const buffer_base& obj)
+bool mf_utils::size_comparator(const size_t required_size, const buffer& obj)
 {
     return required_size < obj.get_size();
 }
 
-typename std::vector<buffer_base>::iterator mf_utils::get_lower_bound(
-    typename std::vector<buffer_base>::iterator first, 
-    typename std::vector<buffer_base>::iterator last, const size_t value, 
-    std::function<bool (const buffer_base&, const size_t) >& comp)
+typename std::vector<buffer>::iterator mf_utils::get_lower_bound(
+    typename std::vector<buffer>::iterator first, 
+    typename std::vector<buffer>::iterator last, const size_t value, 
+    std::function<bool (const buffer&, const size_t) >& comp)
 {
-    typename std::vector<buffer_base>::iterator it;
-    typename std::iterator_traits<typename std::vector<buffer_base>::iterator>::difference_type count, step;
+    typename std::vector<buffer>::iterator it;
+    typename std::iterator_traits<typename std::vector<buffer>::iterator>::difference_type count, step;
     count = std::distance(first, last);
  
     while (count > 0)
@@ -40,13 +40,13 @@ typename std::vector<buffer_base>::iterator mf_utils::get_lower_bound(
     return first;
 }
 
-typename std::vector<buffer_base>::iterator mf_utils::get_upper_bound(
-    typename std::vector<buffer_base>::iterator first, 
-    typename std::vector<buffer_base>::iterator last, const size_t value, 
-    std::function<bool (const size_t, const buffer_base&) >& comp)
+typename std::vector<buffer>::iterator mf_utils::get_upper_bound(
+    typename std::vector<buffer>::iterator first, 
+    typename std::vector<buffer>::iterator last, const size_t value, 
+    std::function<bool (const size_t, const buffer&) >& comp)
 {
-    typename std::vector<buffer_base>::iterator it;
-    typename std::iterator_traits<typename std::vector<buffer_base>::iterator>::difference_type count, step;
+    typename std::vector<buffer>::iterator it;
+    typename std::iterator_traits<typename std::vector<buffer>::iterator>::difference_type count, step;
     count = std::distance(first, last);
  
     while (count > 0)
@@ -69,7 +69,7 @@ typename std::vector<buffer_base>::iterator mf_utils::get_upper_bound(
 
 template<>
 int mf_utils::get_buffer<buf_choose_policy::naive>(const size_t required_size, 
-        std::vector<buffer_base>& buff_vec, 
+        std::vector<buffer>& buff_vec, 
         const MemType mem, 
         void ** ptr)
 {
@@ -87,7 +87,7 @@ int mf_utils::get_buffer<buf_choose_policy::naive>(const size_t required_size,
         }
     }
 
-    buff_vec.push_back(buffer_base(required_size, mem));
+    buff_vec.push_back(buffer(required_size, mem));
     
     (*ptr) = buff_vec.back().get_ptr();
     int id = buff_vec.size() - 1;
@@ -100,7 +100,7 @@ int mf_utils::get_buffer<buf_choose_policy::naive>(const size_t required_size,
 
 template<>
 int mf_utils::get_buffer<buf_choose_policy::sorted_vec>(const size_t required_size, 
-        std::vector<buffer_base>& buff_vec, 
+        std::vector<buffer>& buff_vec, 
         const MemType mem, 
         void ** ptr)
 {
@@ -118,10 +118,10 @@ int mf_utils::get_buffer<buf_choose_policy::sorted_vec>(const size_t required_si
         }
     }
 
-    typename std::vector<buffer_base>::iterator buf_it;
-    std::function<bool (const size_t, const buffer_base&) > comparator = mf_utils::size_comparator;
+    typename std::vector<buffer>::iterator buf_it;
+    std::function<bool (const size_t, const buffer&) > comparator = mf_utils::size_comparator;
     buf_it = mf_utils::get_upper_bound (buff_vec.begin(), buff_vec.end(), required_size, comparator);
-    buf_it = buff_vec.insert(buf_it, buffer_base(required_size, mem));
+    buf_it = buff_vec.insert(buf_it, buffer(required_size, mem));
     (*ptr) = buf_it->get_ptr();
     int id = std::distance(buff_vec.begin(), buf_it);
     buff_vec.back().set_id(id);
@@ -130,12 +130,12 @@ int mf_utils::get_buffer<buf_choose_policy::sorted_vec>(const size_t required_si
 
 template<>
 int mf_utils::get_buffer<buf_choose_policy::find_best_unsorted>(const size_t required_size, 
-        std::vector<buffer_base>& buff_vec, 
+        std::vector<buffer>& buff_vec, 
         const MemType mem,  
         void ** ptr)
 {
-    typename std::vector<buffer_base>::iterator available_buf_it;
-    std::function<bool (const buffer_base&, const size_t) > comparator = mf_utils::free_size_comparator;
+    typename std::vector<buffer>::iterator available_buf_it;
+    std::function<bool (const buffer&, const size_t) > comparator = mf_utils::free_size_comparator;
     available_buf_it = mf_utils::get_lower_bound (buff_vec.begin(), buff_vec.end(), required_size, comparator);
     if(available_buf_it != buff_vec.end())
     {    
@@ -146,7 +146,7 @@ int mf_utils::get_buffer<buf_choose_policy::find_best_unsorted>(const size_t req
     }
     else
     {
-        buff_vec.push_back(buffer_base(required_size, mem));
+        buff_vec.push_back(buffer(required_size, mem));
         (*ptr) = buff_vec.back().get_ptr();
         int id = buff_vec.size() - 1;
         buff_vec.back().set_id(id);

Lib/mf-utils.h

@@ -12,22 +12,22 @@ enum class buf_choose_policy
 
 namespace mf_utils
 {
-    bool free_size_comparator(const buffer_base& obj, const size_t required_size);
-    bool size_comparator(const size_t required_size, const buffer_base& obj);
+    bool free_size_comparator(const buffer& obj, const size_t required_size);
+    bool size_comparator(const size_t required_size, const buffer& obj);
 
-    typename std::vector<buffer_base>::iterator get_lower_bound(
-        typename std::vector<buffer_base>::iterator first, 
-        typename std::vector<buffer_base>::iterator last, const size_t value, 
-        std::function<bool (const buffer_base&, const size_t) >& comp);
+    typename std::vector<buffer>::iterator get_lower_bound(
+        typename std::vector<buffer>::iterator first, 
+        typename std::vector<buffer>::iterator last, const size_t value, 
+        std::function<bool (const buffer&, const size_t) >& comp);
 
-    typename std::vector<buffer_base>::iterator get_upper_bound(
-        typename std::vector<buffer_base>::iterator first, 
-        typename std::vector<buffer_base>::iterator last, const size_t value, 
-        std::function<bool (const size_t, const buffer_base&) >& comp);
+    typename std::vector<buffer>::iterator get_upper_bound(
+        typename std::vector<buffer>::iterator first, 
+        typename std::vector<buffer>::iterator last, const size_t value, 
+        std::function<bool (const size_t, const buffer&) >& comp);
 
     template<buf_choose_policy choose_type = buf_choose_policy::naive>
     int get_buffer(const size_t required_size, 
-        std::vector<buffer_base>& buff_vec, 
+        std::vector<buffer>& buff_vec, 
         const MemType mem,
         void ** ptr);
 }
\ No newline at end of file