map_vector.hpp

/*
 * map_vector.hpp
 *
 *  Created on: Aug 30, 2014
 *      Author: Pietro Incardona
 */
 
#ifndef MAP_VECTOR_HPP
#define MAP_VECTOR_HPP
 
#include <iostream>
#include <typeinfo>
#include "util/common.hpp"
#include "memory/PtrMemory.hpp"
#include "util/object_util.hpp"
#include "Grid/util.hpp"
#include "Vector/util.hpp"
#include "Vector/map_vector_grow_p.hpp"
#include "memory/ExtPreAlloc.hpp"
#include "util/util_debug.hpp"
#include "util/Pack_stat.hpp"
#include "Grid/map_grid.hpp"
#include "memory/HeapMemory.hpp"
#include "vect_isel.hpp"
#include "util/object_s_di.hpp"
#include "util.hpp"
#include "util/Pack_stat.hpp"
#include "memory/ExtPreAlloc.hpp"
#include <string.h>
#include "Packer_Unpacker/Unpacker.hpp"
#include "Packer_Unpacker/Packer.hpp"
#include <fstream>
#include "Packer_Unpacker/Packer_util.hpp"
#include "Packer_Unpacker/has_pack_agg.hpp"
#include "timer.hpp"
#include "map_vector_std_util.hpp"
#include "data_type/aggregate.hpp"
#include "vector_map_iterator.hpp"
#include "util/cuda_util.hpp"
#include "cuda/map_vector_cuda_ker.cuh"
#include "map_vector_printers.hpp"
 
#include <stdexcept>
 
namespace openfpm
{
 
    template<bool active>
    struct copy_two_vectors_activate_impl
    {
        template<typename vector_type1, typename vector_type2>
        static void copy(vector_type1 & v1, vector_type2 & v2)
        {
 
        }
 
        template<typename vector_type1, typename vector_type2>
        static void copy2(vector_type1 & v1, vector_type2 & v2)
        {
 
        }
    };
 
    template<>
    struct copy_two_vectors_activate_impl<true>
    {
        template<typename vector_type1, typename vector_type2>
        static void copy(vector_type1 & v1, vector_type2 & v2)
        {
#ifdef __NVCC__
            if (v1.size() != 0)
            {
                auto it = v1.getGPUIterator();
                CUDA_LAUNCH(copy_two_vectors,it,v1.toKernel(),v2.toKernel());
            }
#endif
        }
 
        template<typename vector_type1, typename vector_type2>
        static void copy2(vector_type1 & v1, vector_type2 & v2)
        {
#ifdef __NVCC__
            if (v2.size() != 0)
            {
                auto it = v1.getGPUIterator();
                CUDA_LAUNCH(copy_two_vectors,it,v1.toKernel(),v2.toKernel());
            }
#endif
        }
    };
 
    template<bool is_ok_cuda,typename T, typename Memory,
             template<typename> class layout_base,
             typename grow_p>
    struct add_prp_device_impl
    {
        template <typename S,
                  typename M,
                  typename gp,
                  unsigned int impl,
                  template <typename> class layout_base2,
                  unsigned int ...args>
        static void run(openfpm::vector<T,Memory,layout_base,grow_p,impl> & this_ ,const openfpm::vector<S,M,layout_base2,gp,impl> & v)
        {
            std::cout << __FILE__ << ":" << __LINE__ << " Error the function add_prp_device only work with cuda enabled vector" << std::endl;
        }
    };
 
    template<bool is_ok_cuda,typename T, typename Memory,
             template<typename> class layout_base,
             typename grow_p>
    struct merge_prp_device_impl
    {
        template <typename S,
                  typename M,
                  typename gp,
                  unsigned int impl,
                  template <typename> class layout_base2,
                  unsigned int ...args>
        static void run(openfpm::vector<T,Memory,layout_base,grow_p,impl> & this_ ,
                        const openfpm::vector<S,M,layout_base2,gp,impl> & v,
                        unsigned int offset)
        {
            std::cout << __FILE__ << ":" << __LINE__ << " Error the function merge_prp_device only work with cuda enabled vector" << std::endl;
        }
    };
 
    template<typename T, typename Memory,
             template<typename> class layout_base,
             typename grow_p>
    struct add_prp_device_impl<true,T,Memory,layout_base,grow_p>
    {
        template <typename S,
                  typename M,
                  typename gp,
                  unsigned int impl,
                  template <typename> class layout_base2,
                  unsigned int ...args>
        static void run(vector<T,Memory,layout_base,grow_p,impl> & this_ ,const vector<S,M,layout_base2,gp,impl> & v)
        {
                // merge the data on device
 
    #if defined(CUDA_GPU) && defined(__NVCC__)
 
                size_t old_sz = this_.size();
                this_.resize(this_.size() + v.size(),DATA_ON_DEVICE);
 
                auto ite = v.getGPUIterator();
 
                CUDA_LAUNCH((merge_add_prp_device_impl<decltype(v.toKernel()),decltype(this_.toKernel()),args...>),ite,v.toKernel(),this_.toKernel(),(unsigned int)old_sz);
 
    #else
                std::cout << __FILE__ << ":" << __LINE__ << " Error the function add_prp_device only work when map_vector is compiled with nvcc" << std::endl;
    #endif
        }
    };
 
    template<typename T, typename Memory,
             template<typename> class layout_base,
             typename grow_p>
    struct merge_prp_device_impl<true,T,Memory,layout_base,grow_p>
    {
        template <typename S,
                  typename M,
                  typename gp,
                  unsigned int impl,
                  template <typename> class layout_base2,
                  unsigned int ...args>
        static void run(vector<T,Memory,layout_base,grow_p,impl> & this_ ,
                        const vector<S,M,layout_base2,gp,impl> & v,
                        unsigned int offset)
        {
                // merge the data on device
 
    #if defined(CUDA_GPU) && defined(__NVCC__)
 
                auto ite = v.getGPUIterator();
 
                CUDA_LAUNCH((merge_add_prp_device_impl<decltype(v.toKernel()),decltype(this_.toKernel()),args...>),ite,v.toKernel(),this_.toKernel(),(unsigned int)offset);
 
    #else
                std::cout << __FILE__ << ":" << __LINE__ << " Error the function merge_prp_device only work when map_vector is compiled with nvcc" << std::endl;
    #endif
        }
    };
 
 
    template<typename T, typename Memory, template<typename> class layout_base, typename grow_p, unsigned int impl>
    class vector
    {
        size_t size()
        {
            std::cerr << __FILE__ << ":" << __LINE__ << " Error stub vector created" << std::endl;
            return 0;
        }
    };
 
    #include "map_vector_std.hpp"
    #include "map_vector_std_ptr.hpp"
 
#ifdef CUDA_GPU
    #include "cuda/map_vector_std_cuda.hpp"
#endif
 
    template<typename T,typename Memory, template <typename> class layout_base, typename grow_p>
    class vector<T,Memory,layout_base,grow_p,OPENFPM_NATIVE>
    {
        typedef vector<T,Memory,layout_base,grow_p,OPENFPM_NATIVE> self_type;
 
        size_t v_size;
 
        grid_base<1,T,Memory,typename layout_base<T>::type> base;
 
        void non_zero_one(size_t sz[1], size_t arg)
        {
            if (arg == 0)
            {sz[0] = 1;}
            else
            {sz[0] = arg;}
        }
 
#ifdef SE_CLASS1
 
        void check_overflow(size_t id) const
        {
            if (id >= v_size)
            {
                std::cerr << "Error " << __FILE__ << ":" << __LINE__ << " overflow id: " << id << "\n";
                throw std::invalid_argument( "stacktrace" );
                ACTION_ON_ERROR(VECTOR_ERROR_OBJECT);
            }
        }
 
#endif
 
    public:
 
        typedef int yes_i_am_vector;
 
        typedef int yes_i_am_vector_native;
 
        typedef typename layout_base<T>::type layout_type;
 
        typedef layout_base<T> layout_base_;
 
        typedef vector_key_iterator iterator_key;
 
        // you can access all the properties of T
        typedef typename grid_base<1,T,Memory,typename layout_base<T>::type>::container container;
 
        typedef T value_type;
 
        typedef Memory Memory_type;
 
        typedef grow_p grow_policy;
 
        template<typename Tobj>
        struct layout_base__
        {
            typedef layout_base<Tobj> type;
        };
 
        // Implementation of packer and unpacker for vector
#include "vector_pack_unpack.ipp"
 
        size_t size() const
        {
            return v_size;
        }
 //remove host device
        size_t size_local() const
        {
            return v_size;
        }
 
        size_t capacity()
        {
            return base.size();
        }
 
        void reserve(size_t sp)
        {
            if (sp > base.size())
            {
                size_t sz[1] = {sp};
                base.resize(sz);
            }
 
#if defined(CUDIFY_USE_SEQUENTIAL) || defined(CUDIFY_USE_OPENMP)
 
            base_gpu.constructor_impl(v_size,this->base.toKernel());
 
#endif
        }
 
        void clear()
        {
            resize(0);
        }
 
        void shrink_to_fit()
        {
            size_t sz[1] = {size()};
            base.resize(sz);
 
#if defined(CUDIFY_USE_SEQUENTIAL) || defined(CUDIFY_USE_OPENMP)
 
            base_gpu.constructor_impl(v_size,this->base.toKernel());
 
#endif
        }
 
        void resize(size_t slot, size_t opt = DATA_ON_DEVICE | DATA_ON_HOST, unsigned int blockSize = 1)
        {
            // If we need more space than what we allocated, allocate new memory
 
            if (slot > base.size())
            {
                size_t gr = slot;
                // If you increase by one we smartly resize the internal capacity more than 1
                // This is to make faster patterns like resize(size()+1)
                if (slot - base.size() == 1 && opt && (opt & EXACT_RESIZE) == 0)
                {
                    gr = grow_p::grow(base.size(),slot);
                }
 
                size_t sz[1] = {gr};
 
                base.resize(sz,opt,blockSize);
            }
 
            // update the vector size
            v_size = slot;
 
#if defined(CUDIFY_USE_SEQUENTIAL) || defined(CUDIFY_USE_OPENMP)
 
            base_gpu.constructor_impl(v_size,this->base.toKernel());
 
#endif
        }
 
 
        void resize_no_device(size_t slot)
        {
            // If we need more space than what we allocated, allocate new memory
 
            if (slot > base.size())
            {
                size_t gr = grow_p::grow(base.size(),slot);
 
                size_t sz[1] = {gr};
                base.resize_no_device(sz);
            }
 
            // update the vector size
            v_size = slot;
 
#if defined(CUDIFY_USE_SEQUENTIAL) || defined(CUDIFY_USE_OPENMP)
 
            base_gpu.constructor_impl(v_size,this->base.toKernel());
 
#endif
        }
 
        typedef size_t access_key;
 
        void add()
        {
 
            if (v_size >= base.size())
            {
                size_t sz[1];
                non_zero_one(sz,2*base.size());
                base.resize(sz);
            }
 
            v_size++;
 
#if defined(CUDIFY_USE_SEQUENTIAL) || defined(CUDIFY_USE_OPENMP)
 
            base_gpu.constructor_impl(v_size,this->base.toKernel());
 
#endif
        }
 
        void add_no_device()
        {
 
            if (v_size >= base.size())
            {
                size_t sz[1];
                non_zero_one(sz,2*base.size());
                base.resize_no_device(sz);
            }
 
            v_size++;
 
#if defined(CUDIFY_USE_SEQUENTIAL) || defined(CUDIFY_USE_OPENMP)
 
            base_gpu.constructor_impl(v_size,this->base.toKernel());
 
#endif
        }
 
        void add(const T & v)
        {
 
            if (v_size >= base.size())
            {
                size_t sz[1];
                non_zero_one(sz,2*base.size());
                base.resize(sz);
            }
 
            base.set(v_size,v);
 
            v_size++;
 
#if defined(CUDIFY_USE_SEQUENTIAL) || defined(CUDIFY_USE_OPENMP)
 
            base_gpu.constructor_impl(v_size,this->base.toKernel());
 
#endif
        }
 
        void add(const typename grid_base<1,T,Memory,typename layout_base<T>::type>::container & v)
        {
 
            if (v_size >= base.size())
            {
                size_t sz[1];
                non_zero_one(sz,2*base.size());
                base.resize(sz);
            }
 
            base.set(v_size,v);
 
            v_size++;
 
#if defined(CUDIFY_USE_SEQUENTIAL) || defined(CUDIFY_USE_OPENMP)
 
            base_gpu.constructor_impl(v_size,this->base.toKernel());
 
#endif
        }
 
        template <typename M, typename gp> void add(const vector<T, M, layout_base,gp,OPENFPM_NATIVE> & v)
        {
            for (size_t i = 0 ; i < v.size() ; i++)
                add(v.get(i));
        }
 
        template <template<typename,typename> class op, typename S, typename M, typename gp, unsigned int ...args>
        void merge_prp(const vector<S,M,layout_base,gp,OPENFPM_NATIVE> & v,
                       const openfpm::vector<size_t> & opart)
        {
#ifdef SE_CLASS1
 
            if (v.size() != opart.size())
                std::cerr << __FILE__ << ":" << __LINE__ << " error merge_prp: v.size()=" << v.size() << " must be the same as o_part.size()" << opart.size() << std::endl;
 
#endif
            for (size_t i = 0 ; i < v.size() ; i++)
            {
#ifdef SE_CLASS1
 
                if (opart.get(i) > size())
                    std::cerr << "Error: " << __FILE__ << ":" << __LINE__ << " try to access element " << opart.get(i) << " but the vector has size " << size() << std::endl;
 
#endif
                // write the object in the last element
                object_s_di_op<op,decltype(v.get(i)),decltype(get(size()-1)),OBJ_ENCAP,args...>(v.get(i),get(opart.get(i)));
            }
        }
 
        template <template<typename,typename> class op, typename S, typename M, typename gp, unsigned int ...args>
        void merge_prp_device(const vector<S,M,layout_base,gp,OPENFPM_NATIVE> & v,
                       unsigned int start)
        {
            merge_prp_device_impl<std::is_same<Memory,CudaMemory>::value,T,Memory,layout_base,grow_p>
            ::template run<S,M,gp,OPENFPM_NATIVE,layout_base,args...>(*this,v,start);
        }
 
 
        template <template<typename,typename> class op,
                  typename S,
                  typename M,
                  typename gp,
                  template <typename> class layout_base2,
                  typename vector_opart_type,
                  unsigned int ...args>
        void merge_prp_v(const vector<S,M,layout_base2,gp,OPENFPM_NATIVE> & v,
                         const vector_opart_type & opart)
        {
#ifdef SE_CLASS1
 
            if (v.size() != opart.size())
                std::cerr << __FILE__ << ":" << __LINE__ << " error merge_prp: v.size()=" << v.size() << " must be the same as o_part.size()" << opart.size() << std::endl;
 
#endif
            for (size_t i = 0 ; i < v.size() ; i++)
            {
#ifdef SE_CLASS1
 
                if (i >= opart.size())
                    std::cerr << "Error: " << __FILE__ << ":" << __LINE__ << " try to access element " << opart.template get<0>(i) << " but the vector has size " << size() << std::endl;
 
#endif
                // write the object in the last element
                object_s_di_op<op,decltype(v.get(i)),decltype(get(size()-1)),OBJ_ENCAP,args...>(v.get(i),get(opart.template get<0>(i)));
            }
        }
 
        template <template<typename,typename> class op,
                  typename S,
                  typename M,
                  typename gp,
                  template <typename> class layout_base2,
                  typename vector_opart_type,
                  unsigned int ...args>
        void merge_prp_v(const vector<S,M,layout_base2,gp,OPENFPM_NATIVE> & v,
                         unsigned int offset,
                         const vector_opart_type & opart)
        {
            size_t i2 = 0;
 
            for (size_t i = offset ; i < v.size() ; i++)
            {
                auto dst = v.get(opart.template get<0>(i2));
                auto src = v.get(i);
                copy_cpu_encap_encap_op_prp<op,decltype(v.get(0)),decltype(v.get(0)),args...> cp(src,dst);
 
                boost::mpl::for_each_ref< boost::mpl::range_c<int,0,sizeof...(args)> >(cp);
                i2++;
            }
        }
 
        template <template<typename,typename> class op,
                  typename S,
                  typename M,
                  typename gp,
                  template <typename> class layout_base2,
                  typename vector_opart_type,
                  unsigned int ...args>
        void merge_prp_v_device(const vector<S,M,layout_base2,gp,OPENFPM_NATIVE> & v,
                         const vector_opart_type & opart,
                         unsigned int start,
                         unsigned int stop)
        {
#ifdef SE_CLASS1
 
            if (v.size() != stop - start)
                std::cerr << __FILE__ << ":" << __LINE__ << " error merge_prp: v.size()=" << v.size() << " must be the same as stop - start" << stop - start << std::endl;
 
#endif
 
#ifdef __NVCC__
 
            size_t sz[1] = {stop - start};
            grid_sm<1,void> nm(sz);
 
            auto ite = nm.getGPUIterator();
 
            // write the object in the last element
            CUDA_LAUNCH((merge_add_prp_device_impl_src_dst_opar_offset<op,
                                                                       decltype(v.toKernel()),
                                                                       decltype(this->toKernel()),
                                                                       decltype(opart.toKernel()),
                                                                       args...>),ite,v.toKernel(),this->toKernel(),opart.toKernel(),start);
 
            // calculate
#else
            std::cout << __FILE__ << ":" << __LINE__ << " Error you have to compile map_vector.hpp with nvcc to make GPU code working" << std::endl;
 
#endif
        }
 
        template <template<typename,typename> class op,
                  typename S,
                  typename M,
                  typename gp,
                  template <typename> class layout_base2,
                  typename vector_opart_type,
                  unsigned int ...args>
        void merge_prp_v_device(const vector<S,M,layout_base2,gp,OPENFPM_NATIVE> & v,
                         unsigned int start,
                         const vector_opart_type & opart)
        {
#ifdef SE_CLASS1
 
            if (v.size() < opart.size() + start)
                std::cerr << __FILE__ << ":" << __LINE__ << " error merge_prp: v.size()=" << v.size() << " must be snaller than o_part.size() + start " << opart.size() + start << std::endl;
 
#endif
 
#ifdef __NVCC__
 
            auto ite = opart.getGPUIterator();
 
            // write the object in the last element
            CUDA_LAUNCH((merge_add_prp_device_impl_src_offset_dst_opar<op,
                                                                       decltype(v.toKernel()),
                                                                       decltype(this->toKernel()),
                                                                       decltype(opart.toKernel()),
                                                                       args... >),ite,v.toKernel(),this->toKernel(),opart.toKernel(),start);
 
            // calculate
#else
            std::cout << __FILE__ << ":" << __LINE__ << " Error you have to compile map_vector.hpp with nvcc to make GPU code working" << std::endl;
 
#endif
        }
 
        template <template<typename,typename> class op,
                  typename S,
                  typename M,
                  typename gp,
                  template <typename> class layout_base2,
                  unsigned int ...args>
        void merge_prp_v(const vector<S,M,layout_base2,gp,OPENFPM_NATIVE> & v,
                         size_t start)
        {
            for (size_t i = 0 ; i < v.size() ; i++)
            {
#ifdef SE_CLASS1
 
                if (start + i >= v_size)
                    std::cerr << "Error: " << __FILE__ << ":" << __LINE__ << " try to access element " << start+i << " but the vector has size " << size() << std::endl;
 
#endif
                // write the object in the last element
                object_s_di_op<op,decltype(v.get(0)),decltype(get(0)),OBJ_ENCAP,args...>(v.get(i),get(start+i));
            }
        }
 
        template <typename S,
                  typename M,
                  typename gp,
                  unsigned int impl,
                  template <typename> class layout_base2,
                  unsigned int ...args>
        void add_prp(const vector<S,M,layout_base2,gp,impl> & v)
        {
            for (size_t i = 0 ; i < v.size() ; i++)
            {
                // Add a new element
                add();
 
                // write the object in the last element
                object_s_di<decltype(v.get(i)),decltype(get(size()-1)),OBJ_ENCAP,args...>(v.get(i),get(size()-1));
            }
        }
 
        template <typename S,
                  typename M,
                  typename gp,
                  unsigned int impl,
                  template <typename> class layout_base2,
                  unsigned int ...args>
        void add_prp_device(const vector<S,M,layout_base2,gp,impl> & v)
        {
            add_prp_device_impl<std::is_same<Memory,CudaMemory>::value,T,Memory,layout_base,grow_p>
            ::template run<S,M,gp,impl,layout_base2,args...>(*this,v);
        }
 
        void insert(size_t key)
        {
            add();
 
            long int d_k = (long int)size()-1;
            long int s_k = (long int)size()-2;
 
            // keys
            while (s_k >= (long int)key)
            {
                set(d_k,get(s_k));
                d_k--;
                s_k--;
            }
        }
 
 
        void remove(size_t key)
        {
            size_t d_k = key;
            size_t s_k = key + 1;
 
            // keys
            while (s_k < size())
            {
                set(d_k,get(s_k));
                d_k++;
                s_k++;
            }
 
            // re-calculate the vector size
 
            v_size--;
        }
 
        void remove(openfpm::vector<size_t> & keys, size_t start = 0)
        {
            // Nothing to remove return
            if (keys.size() <= start )
                return;
 
            size_t a_key = start;
            size_t d_k = keys.get(a_key);
            size_t s_k = keys.get(a_key) + 1;
 
            // keys
            while (s_k < size())
            {
                // s_k should always point to a key that is not going to be deleted
                while (a_key+1 < keys.size() && s_k == keys.get(a_key+1))
                {
                    a_key++;
                    s_k = keys.get(a_key) + 1;
                }
 
                // In case of overflow
                if (s_k >= size())
                    break;
 
                set(d_k,get(s_k));
                d_k++;
                s_k++;
            }
 
            // re-calculate the vector size
 
            v_size -= keys.size() - start;
        }
 
        void remove(openfpm::vector<aggregate<int>> & keys, size_t start = 0)
        {
            // Nothing to remove return
            if (keys.size() <= start )
                return;
 
            size_t a_key = start;
            size_t d_k = keys.template get<0>(a_key);
            size_t s_k = keys.template get<0>(a_key) + 1;
 
            // keys
            while (s_k < size())
            {
                // s_k should always point to a key that is not going to be deleted
                while (a_key+1 < keys.size() && s_k == keys.template get<0>(a_key+1))
                {
                    a_key++;
                    s_k = keys.template get<0>(a_key) + 1;
                }
 
                // In case of overflow
                if (s_k >= size())
                    break;
 
                set(d_k,get(s_k));
                d_k++;
                s_k++;
            }
 
            // re-calculate the vector size
 
            v_size -= keys.size() - start;
        }
 
        template <unsigned int p>
        inline auto get(size_t id) const -> decltype(base.template get<p>(grid_key_dx<1>(0)))
        {
#if defined(SE_CLASS1) && !defined(__NVCC__)
            check_overflow(id);
#endif
            grid_key_dx<1> key(id);
 
 
            return base.template get<p>(key);
        }
 
        bool isSubset() const
        {
            return false;
        }
 
        inline auto get(size_t id) -> decltype(base.get_o(grid_key_dx<1>(id)))
        {
#if defined(SE_CLASS1) && !defined(__NVCC__)
            check_overflow(id);
#endif
            grid_key_dx<1> key(id);
 
            return base.get_o(key);
        }
 
        inline const typename grid_base<1,T,Memory,typename layout_base<T>::type>::container get_o(size_t id) const
        {
#if defined(SE_CLASS1) && !defined(__NVCC__)
            check_overflow(id);
#endif
            grid_key_dx<1> key(id);
 
            return base.get_o(key);
        }
 
        template<unsigned int id> void fill(unsigned char c)
        {
            base.template fill<id>(c);
        }
 
        template<unsigned int id> void * getDeviceBufferCopy()
        {
            return base.template getDeviceBuffer<id>();
        }
 
        template<unsigned int id> void * getDeviceBuffer()
        {
            return base.template getDeviceBuffer<id>();
        }
 
 
        inline const typename grid_base<1,T,Memory,layout_type>::container last() const
        {
            grid_key_dx<1> key(size()-1);
 
            return base.get_o(key);
        } //remove device host
        template <unsigned int p>
        inline auto getProp(const unsigned int & id) -> decltype(base.template get<p>(grid_key_dx<1>(0)))
        {   //uncomment this
            return this->template get<p>(id);
        }//remove host device
        template <unsigned int p,typename KeyType>
        inline auto getProp(const KeyType & id) -> decltype(base.template get<p>(grid_key_dx<1>(0)))
        {
            //uncomment this
            return this->template get<p>(id.getKey());
        }
 //remove device host
        template <unsigned int p, typename keyType>
         inline auto getProp(const keyType & id) const -> decltype(base.template get<p>(grid_key_dx<1>(0)))
        {   //uncomment this
            return this->template get<p>(id.getKey());
        }
 
        template <unsigned int p>
        inline auto get(size_t id) -> decltype(base.template get<p>(grid_key_dx<1>(0)))
        {
#if defined(SE_CLASS1) && !defined(__NVCC__)
            check_overflow(id);
#endif
            grid_key_dx<1> key(id);
 
            return base.template get<p>(key);
        }
 
        inline auto get(size_t id) const -> const decltype(base.get_o(grid_key_dx<1>(id)))
        {
#ifdef SE_CLASS2
            check_valid(this,8);
#endif
#if defined(SE_CLASS1) && !defined(__NVCC__)
            check_overflow(id);
#endif
            grid_key_dx<1> key(id);
 
            return base.get_o(key);
        }
 
        inline typename grid_base<1,T,Memory,typename layout_base<T>::type >::container last()
        {
            grid_key_dx<1> key(size()-1);
 
            return base.get_o(key);
        }
 
        ~vector() THROW
        {
            // Eliminate the pointer
        }
 
        vector<T, Memory,layout_base,grow_p,OPENFPM_NATIVE> duplicate() const
        {
            vector<T, Memory,layout_base,grow_p,OPENFPM_NATIVE> dup;
 
            dup.v_size = v_size;
            dup.base.swap(base.duplicate());
 
#if defined(CUDIFY_USE_SEQUENTIAL) || defined(CUDIFY_USE_OPENMP)
 
            dup.base_gpu.constructor_impl(v_size,dup.base.toKernel());
 
#endif
 
            copy_two_vectors_activate_impl<Memory::isDeviceHostSame() == false>::copy(dup,*this);
 
            return dup;
        }
 
        vector(vector<T, Memory,layout_base,grow_p,OPENFPM_NATIVE> && v)
        :v_size(0)
        {
            swap(v);
 
#if defined(CUDIFY_USE_SEQUENTIAL) || defined(CUDIFY_USE_OPENMP)
 
            base_gpu.constructor_impl(v_size,this->base.toKernel());
 
#endif
        }
 
        vector(const vector<T, Memory,layout_base,grow_p,OPENFPM_NATIVE> & v) THROW
        :v_size(0)
        {
            swap(v.duplicate());
 
#if defined(CUDIFY_USE_SEQUENTIAL) || defined(CUDIFY_USE_OPENMP)
 
            base_gpu.constructor_impl(v_size,this->base.toKernel());
 
#endif
        }
 
        vector() THROW
        :v_size(0),base(0)
        {
            base.setMemory();
 
#if defined(CUDIFY_USE_SEQUENTIAL) || defined(CUDIFY_USE_OPENMP)
 
            base_gpu.constructor_impl(v_size,this->base.toKernel());
 
#endif
        }
 
        vector(size_t sz) THROW
        :v_size(sz),base(sz)
        {
            base.setMemory();
 
#if defined(CUDIFY_USE_SEQUENTIAL) || defined(CUDIFY_USE_OPENMP)
 
            base_gpu.constructor_impl(v_size,this->base.toKernel());
 
#endif
        }
 
        void set(size_t id, const typename grid_base<1,T,Memory,typename layout_base<T>::type>::container & obj)
        {
#ifdef SE_CLASS1
            check_overflow(id);
#endif
            base.set(id,obj);
        }
 
        template <typename encap_S, unsigned int ...args> void set_o(size_t i, const encap_S & obj)
        {
            // write the object in the last element
            object_s_di<encap_S,decltype(get(i)),OBJ_ENCAP,args...>(obj,get(i));
        }
 
        void set(size_t id, const T & obj)
        {
#ifdef SE_CLASS1
            check_overflow(id);
#endif
            base.set(id,obj);
        }
 
        void set(size_t id, vector<T,Memory,layout_base,grow_p,OPENFPM_NATIVE> & v, size_t src)
        {
#ifdef SE_CLASS1
            check_overflow(id);
#endif
            base.set(id,v.base,src);
        }
 
        vector<T, Memory,layout_base,grow_p,OPENFPM_NATIVE> & operator=(vector<T, Memory, layout_base,grow_p,OPENFPM_NATIVE> && mv)
        {
            v_size = mv.v_size;
            base.swap(mv.base);
 
#if defined(CUDIFY_USE_SEQUENTIAL) || defined(CUDIFY_USE_OPENMP)
 
            base_gpu.constructor_impl(v_size,this->base.toKernel());
 
#endif
 
            return *this;
        }
 
        vector<T, Memory,layout_base,grow_p,OPENFPM_NATIVE> & operator=(const vector<T, Memory, layout_base ,grow_p,OPENFPM_NATIVE> & mv)
        {
            v_size = mv.v_size;
            size_t rsz[1] = {v_size};
            if(rsz[0]>base.size()) {
                base.resize(rsz);
            }
            // copy the object on cpu
            for (size_t i = 0 ; i < v_size ; i++ )
            {
                grid_key_dx<1> key(i);
                base.set(key,mv.base,key);
            }
 
#if defined(CUDIFY_USE_SEQUENTIAL) || defined(CUDIFY_USE_OPENMP)
 
            base_gpu.constructor_impl(v_size,this->base.toKernel());
 
#endif
 
            copy_two_vectors_activate_impl<Memory::isDeviceHostSame() == false>::copy2(*this,mv);
 
            return *this;
        }
 
        template<typename Mem, typename gp> vector<T, Memory,layout_base,grow_p,OPENFPM_NATIVE> & operator=(vector<T, Mem, layout_base,gp,OPENFPM_NATIVE> && mv)
        {
            v_size = mv.v_size;
            base.swap(mv.base);
 
#if defined(CUDIFY_USE_SEQUENTIAL) || defined(CUDIFY_USE_OPENMP)
 
            base_gpu.constructor_impl(v_size,this->base.toKernel());
 
#endif
 
            return *this;
        }
 
        template<typename Mem, typename gp> vector<T, Memory,layout_base,grow_p,OPENFPM_NATIVE> & operator=(const vector<T, Mem, layout_base ,gp,OPENFPM_NATIVE> & mv)
        {
            v_size = mv.getInternal_v_size();
            size_t rsz[1] = {v_size};
            base.resize(rsz);
 
            // copy the object
            for (size_t i = 0 ; i < v_size ; i++ )
            {
                grid_key_dx<1> key(i);
                base.set(key,mv.getInternal_base(),key);
            }
 
#if defined(CUDIFY_USE_SEQUENTIAL) || defined(CUDIFY_USE_OPENMP)
 
            base_gpu.constructor_impl(v_size,this->base.toKernel());
 
#endif
 
            copy_two_vectors_activate_impl<Memory::isDeviceHostSame() == false && Mem::isDeviceHostSame() == false>::copy2(*this,mv);
 
            return *this;
        }
 
        template<typename Mem, template <typename> class layout_base2>
        vector<T, Memory,layout_base2,grow_p,OPENFPM_NATIVE> & operator=(vector<T, Mem, layout_base2,grow_p,OPENFPM_NATIVE> && mv)
        {
            v_size = mv.v_size;
            base.swap(mv.base);
 
#if defined(CUDIFY_USE_SEQUENTIAL) || defined(CUDIFY_USE_OPENMP)
 
            base_gpu.constructor_impl(v_size,this->base.toKernel());
 
#endif
 
            return *this;
        }
 
        template<typename Mem,
                 template <typename> class layout_base2,
                 typename check = typename std::enable_if<!std::is_same<typename layout_base2<T>::type,typename layout_base<T>::type>::value >::type>
        vector<T, Memory,layout_base,grow_p,OPENFPM_NATIVE> &
        operator=(const vector<T, Mem, layout_base2 ,grow_p,OPENFPM_NATIVE> & mv)
        {
            v_size = mv.getInternal_v_size();
            size_t rsz[1] = {v_size};
            base.resize(rsz);
 
            // copy the object
            for (size_t i = 0 ; i < v_size ; i++ )
            {
                grid_key_dx<1> key(i);
                base.set_general(key,mv.getInternal_base(),key);
            }
 
#if defined(CUDIFY_USE_SEQUENTIAL) || defined(CUDIFY_USE_OPENMP)
 
            base_gpu.constructor_impl(v_size,this->base.toKernel());
 
#endif
 
            copy_two_vectors_activate_impl<Memory::isDeviceHostSame() == false && Mem::isDeviceHostSame() == false>::copy2(*this,mv);
 
            return *this;
        }
 
        bool operator!=(const vector<T, Memory, layout_base,grow_p,OPENFPM_NATIVE> & v) const
        {
            return !this->operator==(v);
        }
 
        bool operator==(const vector<T, Memory, layout_base, grow_p,OPENFPM_NATIVE> & v) const
        {
            if (v_size != v.v_size)
                return false;
 
            // check object by object
            for (size_t i = 0 ; i < v_size ; i++ )
            {
                grid_key_dx<1> key(i);
 
                if (base.get_o(key) != v.base.get_o(key))
                    return false;
            }
 
            return true;
        }
 
        void swap_nomode(openfpm::vector<T,Memory, layout_base,grow_p,OPENFPM_NATIVE> & v)
        {
            size_t sz_sp = v_size;
 
            // swap the v_size
            v_size = v.v_size;
 
            base.swap_nomode(v.base);
 
#if defined(CUDIFY_USE_SEQUENTIAL) || defined(CUDIFY_USE_OPENMP)
 
            base_gpu.constructor_impl(v_size,this->base.toKernel());
 
#endif
 
            v.v_size = sz_sp;
        }
 
        void swap(openfpm::vector<T,Memory, layout_base,grow_p,OPENFPM_NATIVE> & v)
        {
            size_t sz_sp = v_size;
 
            // swap the v_size
            v_size = v.v_size;
 
            base.swap(v.base);
            v.v_size = sz_sp;
 
 
#if defined(CUDIFY_USE_SEQUENTIAL) || defined(CUDIFY_USE_OPENMP)
 
            base_gpu.constructor_impl(v_size,this->base.toKernel());
            v.base_gpu.constructor_impl(v.v_size,v.base.toKernel());
 
#endif
        }
 
        void swap(openfpm::vector<T,Memory, layout_base,grow_p,OPENFPM_NATIVE> && v)
        {
            size_t sz_sp = v_size;
 
            // swap the v_size
            v_size = v.v_size;
 
            base.swap(v.base);
            v.v_size = sz_sp;
 
#if defined(CUDIFY_USE_SEQUENTIAL) || defined(CUDIFY_USE_OPENMP)
 
            base_gpu.constructor_impl(v_size,this->base.toKernel());
            v.base_gpu.constructor_impl(v.v_size,v.base.toKernel());
 
#endif
        }
 
        vector_key_iterator getIteratorFrom(size_t start) const
        {
            return vector_key_iterator(v_size,start);
        }
 
        vector_key_iterator getIteratorTo(size_t stop) const
        {
            return vector_key_iterator(stop,0);
        }
 
#ifdef CUDA_GPU
 
        ite_gpu<1> getGPUIteratorTo(long int stop, size_t n_thr = default_kernel_wg_threads_) const
        {
            grid_key_dx<1,long int> start(0);
            grid_key_dx<1,long int> stop_(stop);
 
            return base.getGPUIterator(start,stop_,n_thr);
        }
 
 
#endif
 
        vector_key_iterator getDomainIterator() const
        {
#ifdef SE_CLASS2
            check_valid(this,8);
#endif
            return getIterator();
        }
 
        vector_key_iterator getIterator() const
        {
            return vector_key_iterator(v_size);
        }
 
        template<unsigned int p>
        vector_key_iterator_ele<p,self_type> getIteratorElements() const
        {
#ifdef SE_CLASS2
            check_valid(this,8);
#endif
            return vector_key_iterator_ele<p,self_type>(*this,size());
        }
 
#ifdef CUDA_GPU
 
        ite_gpu<1> getGPUIterator(size_t n_thr = default_kernel_wg_threads_) const
        {
            grid_key_dx<1> start(0);
            grid_key_dx<1> stop(size()-1);
 
            return base.getGPUIterator(start,stop,n_thr);
        }
 
        ite_gpu<1> getDomainIteratorGPU(size_t n_thr = default_kernel_wg_threads_) const
        {
            return getGPUIterator(n_thr);
        }
 
#endif
        size_t packObjectSize()
        {
            return base.packObjectSize();
        }
 
        size_t packObject(void * mem)
        {
            return base.packObject(mem);
        }
 
        template<int ... prp> static inline size_t calculateMem(size_t n, size_t e)
        {
            if (n == 0)
            {
                return 0;
            }
            else
            {
                if (sizeof...(prp) == 0)
                    return grow_p::grow(0,n) * sizeof(typename T::type);
 
                typedef object<typename object_creator<typename T::type,prp...>::type> prp_object;
 
                return grow_p::grow(0,n) * sizeof(prp_object);
            }
        }
 
        template<int ... prp> static inline size_t packMem(size_t n, size_t e)
        {
            if (sizeof...(prp) == 0)
                return n * sizeof(typename T::type);
 
            typedef object<typename object_creator<typename T::type,prp...>::type> prp_object;
 
            return n * sizeof(prp_object);
        }
 
        inline static size_t calculateNMem(size_t n)
        {
            return 1;
        }
 
        template<unsigned int p>
        auto getMemory() -> decltype(base.template getMemory<p>())
        {
            return base.template getMemory<p>();
        }
 
        template<unsigned int p = 0> void setMemory(Memory & mem)
        {
            base.template setMemory<p>(mem);
 
#if defined(CUDIFY_USE_SEQUENTIAL) || defined(CUDIFY_USE_OPENMP)
 
            base_gpu.constructor_impl(v_size,this->base.toKernel());
 
#endif
        }
 
        void setMemoryArray(Memory * mem)
        {
            base.setMemoryArray(mem);
 
#if defined(CUDIFY_USE_SEQUENTIAL) || defined(CUDIFY_USE_OPENMP)
 
            base_gpu.constructor_impl(v_size,this->base.toKernel());
 
#endif
        }
 
        template<unsigned int p = 0> void * getPointer()
        {
            return base.template getPointer<p>();
        }
 
        template<unsigned int p = 0> const void * getPointer() const
        {
            return base.getPointer();
        }
 
        static bool noPointers()
        {
            return false;
        }
 
        const size_t & getInternal_v_size() const
        {
            return v_size;
        }
 
        const grid_base<1,T,Memory,layout_type> & getInternal_base() const
        {
            return base;
        }
 
        template<unsigned int ... prp> void hostToDevice()
        {
            base.template hostToDevice<prp ...>();
        }
 
        template<unsigned int ... prp> void deviceToHost()
        {
            base.template deviceToHost<prp ...>();
        }
 
 
        template<unsigned int ... prp> void deviceToHost(size_t start, size_t stop)
        {
            base.template deviceToHost<prp ...>(start,stop);
        }
 
        template<unsigned int ... prp> void hostToDevice(size_t start, size_t stop)
        {
            base.template hostToDevice<prp ...>(start,stop);
        }
 
        template<unsigned int ... prp> void hostToDeviceNUMA(size_t start, size_t stop)
        {
            base.template hostToDeviceNUMA<prp ...>(start,stop);
        }
 
        template<unsigned int ... prp> void hostToDeviceNUMA()
        {
            base.template hostToDeviceNUMA<prp ...>();
        }
 
#if defined(CUDIFY_USE_SEQUENTIAL) || defined(CUDIFY_USE_OPENMP)
 
        mutable vector_gpu_ker<typename apply_transform<layout_base,T>::type,layout_base> base_gpu;
 
        inline vector_gpu_ker_ref<typename apply_transform<layout_base,T>::type,layout_base> toKernel()
        {
//          base_gpu.constructor_impl(v_size,this->base.toKernel());
 
            return vector_gpu_ker_ref<typename apply_transform<layout_base,T>::type,layout_base>(base_gpu);
        }
 
        inline const vector_gpu_ker_ref<typename apply_transform<layout_base,T>::type,layout_base> toKernel() const
        {
//          base_gpu.constructor_impl(v_size,this->base.toKernel());
 
            return vector_gpu_ker_ref<typename apply_transform<layout_base,T>::type,layout_base>(base_gpu);
        }
 
#else
 
        vector_gpu_ker<typename apply_transform<layout_base,T>::type,layout_base> toKernel()
        {
            vector_gpu_ker<typename apply_transform<layout_base,T>::type,layout_base> v(v_size,this->base.toKernel());
 
            return v;
        }
 
        const vector_gpu_ker<typename apply_transform<layout_base,T>::type,layout_base>  toKernel() const
        {
            if (base.size() == 0)
            {std::cout << __FILE__ << ":" << __LINE__ << " Warning you are off-loading with toGPU a vector that seem to be empty or not initialized" << std::endl; }
 
            vector_gpu_ker<typename apply_transform<layout_base,T>::type,layout_base> v(v_size,this->base.toKernel());
 
            return v;
        }
 
#endif
 
        template<unsigned int ... prps>
        const std::string toString(std::string prefix = std::string())
        {
            std::stringstream ss;
            auto it = getIterator();
 
            while (it.isNext())
            {
                auto p = it.get();
 
                ss << prefix;
 
                ss << prefix <<  " element[" << p << "]" << " ";
 
                vector_printer<self_type,prps ...> vp(*this,p,ss);
                boost::mpl::for_each_ref<boost::mpl::range_c<int,0,sizeof...(prps)>>(vp);
 
                ss << std::endl;
 
                ++it;
            }
 
            return ss.str();
        }
 
        void * internal_get_size_pointer()  {return &v_size;}
 
        void print_size()
        {
#ifndef DISABLE_ALL_RTTI
            std::cout << "the size of: " << demangle(typeid(self_type).name()) << " is " << sizeof(self_type) << std::endl;
            std::cout << "    " << demangle(typeid(decltype(v_size)).name()) << ":" << sizeof(decltype(v_size)) << std::endl;
            std::cout << "    " << demangle(typeid(decltype(base)).name()) << ":" << sizeof(decltype(base)) << std::endl;
#endif
        }
 
    };
 
    template <typename T> using vector_std = vector<T, HeapMemory, memory_traits_lin, openfpm::grow_policy_double, STD_VECTOR>;
    template<typename T> using vector_gpu = openfpm::vector<T,CudaMemory,memory_traits_inte>;
    template<typename T> using vector_soa = openfpm::vector<T,HeapMemory,memory_traits_inte>;
    template<typename T> using vector_gpu_lin = openfpm::vector<T,CudaMemory,memory_traits_lin>;
    template<typename T> using vector_gpu_single = openfpm::vector<T,CudaMemory,memory_traits_inte,openfpm::grow_policy_identity>;
    template<typename T> using vector_custd = vector<T, CudaMemory, memory_traits_inte, openfpm::grow_policy_double, STD_VECTOR>;
}
 
#endif