Change memory_pipeline* name to memory_pipe*

Lib/memory-holder.cpp

@@ -151,7 +151,7 @@ template class buffer<MemType::CPU>;
 template class buffer<MemType::GPU>;
 #endif
 
-memory_pipline_base::memory_pipline_base()
+memory_pipe_base::memory_pipe_base()
 {
 #ifdef INCLUDE_CUDA
     gpu_buff = std::vector<buffer<MemType::GPU> > ();
@@ -159,7 +159,7 @@ memory_pipline_base::memory_pipline_base()
     cpu_buff = std::vector<buffer<MemType::CPU> > ();
 }
 
-memory_pipline_base::~memory_pipline_base()
+memory_pipe_base::~memory_pipe_base()
 {
 #ifdef INCLUDE_CUDA
     gpu_buff.clear();
@@ -168,28 +168,28 @@ memory_pipline_base::~memory_pipline_base()
 }
 
 template< MemType mem >
-std::vector<buffer<mem> >& memory_pipline_base::get_memtyped_vector()
+std::vector<buffer<mem> >& memory_pipe_base::get_memtyped_vector()
 {
     return cpu_buff;
 }
 
 #ifdef INCLUDE_CUDA
 template<>
-std::vector<buffer<MemType::GPU> >& memory_pipline_base::get_memtyped_vector()
+std::vector<buffer<MemType::GPU> >& memory_pipe_base::get_memtyped_vector()
 {
     return gpu_buff;
 }
 #endif
 
 template< MemType mem >
-void memory_pipline_base::set_available(const int id)
+void memory_pipe_base::set_available(const int id)
 {
     get_memtyped_vector<mem>()[id].set_status(true);
 }
 
-template void memory_pipline_base::set_available<MemType::CPU>(const int id);
+template void memory_pipe_base::set_available<MemType::CPU>(const int id);
 #ifdef INCLUDE_CUDA
-template void memory_pipline_base::set_available<MemType::GPU>(const int id);
+template void memory_pipe_base::set_available<MemType::GPU>(const int id);
 #endif
 
 template< MemType mem >
@@ -260,7 +260,7 @@ template typename std::vector<buffer<MemType::GPU>>::iterator get_upper_bound<Me
 
 template<buf_choose_policy choose_type>
 template< MemType mem >
-int memory_pipline<choose_type>::get_buffer(const size_t required_size, void *& ptr)
+int memory_pipe<choose_type>::get_buffer(const size_t required_size, void *& ptr)
 {
     std::vector<buffer<mem> >& buff_vec = get_memtyped_vector<mem>();
     const int allocated_buffer_n = buff_vec.size();
@@ -282,13 +282,13 @@ int memory_pipline<choose_type>::get_buffer(const size_t required_size, void *&
     return id;
 }
 
-template int memory_pipline<buf_choose_policy::naiv>::get_buffer<MemType::CPU>(const size_t required_size, void *& ptr);
+template int memory_pipe<buf_choose_policy::naiv>::get_buffer<MemType::CPU>(const size_t required_size, void *& ptr);
 #ifdef INCLUDE_CUDA
-template int memory_pipline<buf_choose_policy::naiv>::get_buffer<MemType::GPU>(const size_t required_size, void *& ptr);
+template int memory_pipe<buf_choose_policy::naiv>::get_buffer<MemType::GPU>(const size_t required_size, void *& ptr);
 #endif
 
 template< MemType mem >
-int memory_pipline<buf_choose_policy::sorted_vec>::get_buffer(const size_t required_size, void *& ptr)
+int memory_pipe<buf_choose_policy::sorted_vec>::get_buffer(const size_t required_size, void *& ptr)
 {
     std::vector<buffer<mem> >& buff_vec = get_memtyped_vector<mem>();
     const int allocated_buffer_n = buff_vec.size();
@@ -314,13 +314,13 @@ int memory_pipline<buf_choose_policy::sorted_vec>::get_buffer(const size_t requi
     return id;
 }
 
-template int memory_pipline<buf_choose_policy::sorted_vec>::get_buffer<MemType::CPU>(const size_t required_size, void *& ptr);
+template int memory_pipe<buf_choose_policy::sorted_vec>::get_buffer<MemType::CPU>(const size_t required_size, void *& ptr);
 #ifdef INCLUDE_CUDA
-template int memory_pipline<buf_choose_policy::sorted_vec>::get_buffer<MemType::GPU>(const size_t required_size, void *& ptr);
+template int memory_pipe<buf_choose_policy::sorted_vec>::get_buffer<MemType::GPU>(const size_t required_size, void *& ptr);
 #endif
 
 template< MemType mem >
-int memory_pipline<buf_choose_policy::find_best_unsorted>::get_buffer(const size_t required_size, void *& ptr)
+int memory_pipe<buf_choose_policy::find_best_unsorted>::get_buffer(const size_t required_size, void *& ptr)
 {
     std::vector<buffer<mem> >& buff_vec = get_memtyped_vector<mem>();
     typename std::vector<buffer<mem>>::iterator available_buf_it;
@@ -341,29 +341,29 @@ int memory_pipline<buf_choose_policy::find_best_unsorted>::get_buffer(const size
     }
 }
 
-template int memory_pipline<buf_choose_policy::find_best_unsorted>::get_buffer<MemType::CPU>(const size_t required_size, void *& ptr);
+template int memory_pipe<buf_choose_policy::find_best_unsorted>::get_buffer<MemType::CPU>(const size_t required_size, void *& ptr);
 #ifdef INCLUDE_CUDA
-template int memory_pipline<buf_choose_policy::find_best_unsorted>::get_buffer<MemType::GPU>(const size_t required_size, void *& ptr);
+template int memory_pipe<buf_choose_policy::find_best_unsorted>::get_buffer<MemType::GPU>(const size_t required_size, void *& ptr);
 #endif
 
 template< >
-memory_pipline<buf_choose_policy::naiv>& memory_faucet::get_faucet()
+memory_pipe<buf_choose_policy::naiv>& memory_faucet::get_faucet()
 {
-    static memory_pipline<buf_choose_policy::naiv> mem_pipe_naiv;
+    static memory_pipe<buf_choose_policy::naiv> mem_pipe_naiv;
     return mem_pipe_naiv;
 }
 
 template< >
-memory_pipline<buf_choose_policy::sorted_vec>& memory_faucet::get_faucet()
+memory_pipe<buf_choose_policy::sorted_vec>& memory_faucet::get_faucet()
 {
-    static memory_pipline<buf_choose_policy::sorted_vec> mem_pipe_sorted;
+    static memory_pipe<buf_choose_policy::sorted_vec> mem_pipe_sorted;
     return mem_pipe_sorted;
 }
 
 template< >
-memory_pipline<buf_choose_policy::find_best_unsorted>& memory_faucet::get_faucet()
+memory_pipe<buf_choose_policy::find_best_unsorted>& memory_faucet::get_faucet()
 {
-    static memory_pipline<buf_choose_policy::find_best_unsorted> mem_pipe_unsorted;
+    static memory_pipe<buf_choose_policy::find_best_unsorted> mem_pipe_unsorted;
     return mem_pipe_unsorted;
 }
 
@@ -371,7 +371,7 @@ memory_pipline<buf_choose_policy::find_best_unsorted>& memory_faucet::get_faucet
 template< MemType mem, buf_choose_policy choose_type >
 memBuf<mem, choose_type>::memBuf(const size_t required_size)
 {
-    memory_pipline<choose_type>& mem_pipe = memory_faucet::get_faucet<choose_type>();
+    memory_pipe<choose_type>& mem_pipe = memory_faucet::get_faucet<choose_type>();
     id = mem_pipe.template get_buffer<mem>(required_size, buf);
     size = required_size;
 }
@@ -379,7 +379,7 @@ memBuf<mem, choose_type>::memBuf(const size_t required_size)
 template< MemType mem, buf_choose_policy choose_type >
 memBuf<mem, choose_type>::~memBuf()
 {
-    memory_pipline<choose_type>& mem_pipe = memory_faucet::get_faucet<choose_type>();
+    memory_pipe<choose_type>& mem_pipe = memory_faucet::get_faucet<choose_type>();
     mem_pipe.template set_available<mem>(id);
 }
 

Lib/memory-holder.h

@@ -41,7 +41,7 @@ public:
     void set_id(const int id);
 };
 
-class memory_pipline_base
+class memory_pipe_base
 {
 public:
 #ifdef INCLUDE_CUDA
@@ -49,8 +49,8 @@ public:
 #endif
     std::vector<buffer<MemType::CPU> > cpu_buff;
 
-    memory_pipline_base();
-    ~memory_pipline_base();
+    memory_pipe_base();
+    ~memory_pipe_base();
 
     template< MemType mem >
     void set_available(const int id);
@@ -63,48 +63,48 @@ public:
 };
 
 template<buf_choose_policy choose_type = buf_choose_policy::naiv>
-class memory_pipline: public memory_pipline_base 
+class memory_pipe: public memory_pipe_base 
 {
 // private:
 // #ifdef INCLUDE_CUDA
-//     using memory_pipline_base::gpu_buff;
+//     using memory_pipe_base::gpu_buff;
 // #endif
-//     using memory_pipline_base::cpu_buff;
+//     using memory_pipe_base::cpu_buff;
 public:
-    memory_pipline(/* args */) : memory_pipline_base() {}
-    ~memory_pipline() = default;
+    memory_pipe(/* args */) : memory_pipe_base() {}
+    ~memory_pipe() = default;
 
     template< MemType mem >
     int get_buffer(const size_t required_size, void *& ptr);
 };
 
 template<>
-class memory_pipline<buf_choose_policy::sorted_vec>: public memory_pipline_base 
+class memory_pipe<buf_choose_policy::sorted_vec>: public memory_pipe_base 
 {
 // private:
 // #ifdef INCLUDE_CUDA
-//     using memory_pipline_base::gpu_buff;
+//     using memory_pipe_base::gpu_buff;
 // #endif
-//     using memory_pipline_base::cpu_buff;
+//     using memory_pipe_base::cpu_buff;
 public:
-    memory_pipline(/* args */) : memory_pipline_base() {}
-    ~memory_pipline() = default;
+    memory_pipe(/* args */) : memory_pipe_base() {}
+    ~memory_pipe() = default;
 
     template< MemType mem >
     int get_buffer(const size_t required_size, void *& ptr);
 };
 
 template<>
-class memory_pipline<buf_choose_policy::find_best_unsorted>: public memory_pipline_base 
+class memory_pipe<buf_choose_policy::find_best_unsorted>: public memory_pipe_base 
 {
 // private:
 // #ifdef INCLUDE_CUDA
-//     using memory_pipline_base::gpu_buff;
+//     using memory_pipe_base::gpu_buff;
 // #endif
-//     using memory_pipline_base::cpu_buff;
+//     using memory_pipe_base::cpu_buff;
 public:
-    memory_pipline(/* args */) : memory_pipline_base() {}
-    ~memory_pipline() = default;
+    memory_pipe(/* args */) : memory_pipe_base() {}
+    ~memory_pipe() = default;
 
     template< MemType mem >
     int get_buffer(const size_t required_size, void *& ptr);
@@ -120,7 +120,7 @@ private:
 public:
 
     template<buf_choose_policy choose_type = buf_choose_policy::naiv>
-    static memory_pipline<choose_type>& get_faucet();
+    static memory_pipe<choose_type>& get_faucet();
 };
 
 template< MemType mem, buf_choose_policy choose_type = buf_choose_policy::naiv >