map_grid.hpp

#ifndef MAP_HPP_
#define MAP_HPP_

#include "config.h"

#include "util/object_util.hpp"
#include "Grid/util.hpp"
#include "Vector/vect_isel.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 "Vector/map_vector.hpp"
//#include "Pack_selector.hpp"
#include <boost/fusion/include/mpl.hpp>
#include <boost/fusion/sequence/intrinsic/at_c.hpp>
#include <boost/fusion/include/at_c.hpp>
#include <boost/fusion/include/for_each.hpp>
#include <boost/fusion/container/vector.hpp>
#include <boost/fusion/include/vector.hpp>
#include <boost/fusion/container/vector/vector_fwd.hpp>
#include <boost/fusion/include/vector_fwd.hpp>
#include <boost/type_traits.hpp>
#include <boost/fusion/include/for_each.hpp>
#include <boost/mpl/range_c.hpp>
#include <boost/mpl/for_each.hpp>
#include "memory_ly/memory_conf.hpp"
#include "util/copy_compare/meta_copy.hpp"
#ifdef SE_CLASS2
#include "Memleak_check.hpp"
#endif
#include "util/for_each_ref.hpp"
#include "util.hpp"
#include <utility>
#ifdef CUDA_GPU
#include "memory/CudaMemory.cuh"
#endif
#include "grid_sm.hpp"
#include "Encap.hpp"
#include "memory_ly/memory_array.hpp"
#include "memory_ly/memory_c.hpp"
#include <vector>
#include "se_grid.hpp"
#include "memory/HeapMemory.hpp"
#include "memory/PtrMemory.hpp"
#include "grid_common.hpp"
#include "util/se_util.hpp"
#include "iterators/grid_key_dx_iterator.hpp"
#include "iterators/grid_key_dx_iterator_sub.hpp"
#include "iterators/grid_key_dx_iterator_sp.hpp"
#include "iterators/grid_key_dx_iterator_sub_bc.hpp"

#ifndef CUDA_GPU
typedef HeapMemory CudaMemory;
#endif

namespace openfpm {

template<typename T, typename Memory=HeapMemory, typename grow_p=grow_policy_double, unsigned int impl=vect_isel<T>::value> class vector;
}

template<unsigned int dim, typename T, typename S=HeapMemory, typename Mem = typename memory_traits_lin< typename T::type >::type >
class grid_cpu
{
public:
    // expose the dimansionality as a static const
    static constexpr unsigned int dims = dim;

    typedef grid_key_dx<dim> access_key;

    typedef typename T::type T_type;

    typedef Mem memory_conf;

    static bool pack()
    {
        return false;
    }

    static bool packRequest()
    {
        return false;
    }

    static bool calculateMem()
    {
        return false;
    }

    template<int ... prp> void pack(ExtPreAlloc<S> & mem, Pack_stat & sts)
    {
#ifdef DEBUG
        if (mem.ref() == 0)
            std::cerr << "Error : " << __FILE__ << ":" << __LINE__ << " the reference counter of mem should never be zero when packing \n";
#endif

        // Sending property object and vector
        typedef object<typename object_creator<typename grid_cpu<dim,T,S,Mem>::value_type::type,prp...>::type> prp_object;
        typedef openfpm::vector<prp_object,ExtPreAlloc<S>> dtype;
        dtype dvect;

        // Calculate the required memory for packing
        size_t alloc_ele = dvect.calculateMem(size(),0);

        // Create an object over the preallocated memory (No allocation is produced)
        dtype dest;
        dest.setMemory(mem);
        dest.resize(size());

        auto it = getIterator();

        pack_with_iterator<decltype(it),dtype,prp...>(it,dest);

        // Update statistic
        sts.incReq();
    }


    template<int ... prp> void pack(ExtPreAlloc<S> & mem, grid_key_dx_iterator_sub<dims> & sub_it, Pack_stat & sts)
    {
#ifdef DEBUG
        if (mem.ref() == 0)
            std::cerr << "Error : " << __FILE__ << ":" << __LINE__ << " the reference counter of mem should never be zero when packing \n";
#endif

        // Sending property object
        typedef object<typename object_creator<typename grid_cpu<dim,T,S,Mem>::value_type::type,prp...>::type> prp_object;
        typedef openfpm::vector<prp_object,ExtPreAlloc<S>,openfpm::grow_policy_identity> dtype;

        // Create an object over the preallocated memory (No allocation is produced)
        dtype dest;
        dest.setMemory(mem);
        dest.resize(sub_it.getVolume());

        pack_with_iterator<grid_key_dx_iterator_sub<dims>,dtype,prp...>(sub_it,dest);

        // Update statistic
        sts.incReq();
    }

    template<int ... prp> void packRequest(std::vector<size_t> & v)
    {
        // Sending property object
        typedef object<typename object_creator<typename grid_cpu<dim,T,S,Mem>::value_type::type,prp...>::type> prp_object;
        typedef openfpm::vector<prp_object,ExtPreAlloc<S>,openfpm::grow_policy_identity> dtype;
        dtype dvect;

        // Calculate the required memory for packing
        size_t alloc_ele = dvect.calculateMem(size(),0);

        v.push_back(alloc_ele);
    }

    template<int ... prp> void packRequest(grid_key_dx_iterator_sub<dims> & sub, std::vector<size_t> & v)
    {
        typedef openfpm::vector<typename grid_cpu<dim,T,S,Mem>::value_type,ExtPreAlloc<S>,openfpm::grow_policy_identity> dtype;
        dtype dvect;

        // Calculate the required memory for packing
        size_t alloc_ele = dvect.template calculateMem<prp...>(sub.getVolume(),0);

        v.push_back(alloc_ele);
    }

    template <typename it, typename dtype, int ... prp> void pack_with_iterator(it & sub_it, dtype & dest)
    {
        // Sending property object
        typedef object<typename object_creator<typename grid_cpu<dim,T,S,Mem>::value_type::type,prp...>::type> prp_object;

        size_t id = 0;

        // Packing the information
        while (sub_it.isNext())
        {
            // copy all the object in the send buffer
            typedef encapc<dims,value_type,memory_conf > encap_src;
            // destination object type
            typedef encapc<1,prp_object,typename dtype::memory_conf > encap_dst;

            // Copy only the selected properties
            object_si_d<encap_src,encap_dst,OBJ_ENCAP,prp...>(get_o(sub_it.get()),dest.get(id));

            ++id;
            ++sub_it;
        }
    }

    template <typename it, typename stype, unsigned int ... prp> void unpack_with_iterator(ExtPreAlloc<S> & mem, it & sub_it, stype & src, Unpack_stat & ps)
    {
        size_t id = 0;

        // Sending property object
        typedef object<typename object_creator<typename grid_cpu<dim,T,S,Mem>::value_type::type,prp...>::type> prp_object;

        // unpacking the information
        while (sub_it.isNext())
        {
            // copy all the object in the send buffer
            typedef encapc<dims,grid_cpu<dim,T,S,Mem>::value_type,grid_cpu<dim,T,S,Mem>::memory_conf > encap_dst;
            // destination object type
            typedef encapc<1,prp_object,typename grid_cpu<dims,prp_object>::memory_conf > encap_src;

            // Copy only the selected properties
            object_s_di<encap_src,encap_dst,OBJ_ENCAP,prp...>(src.get(id),this->get_o(sub_it.get()));

            ++id;
            ++sub_it;
        }
    }

    template<unsigned int ... prp> void unpack(ExtPreAlloc<S> & mem, Unpack_stat & ps)
    {
        // object that store the information in mem
        typedef object<typename object_creator<typename grid_cpu<dim,T,S,Mem>::value_type::type,prp...>::type> prp_object;
        typedef openfpm::vector<prp_object,PtrMemory,openfpm::grow_policy_identity> stype;
        stype svect;


        // Calculate the size to pack the object
        size_t size = svect.calculateMem(this->size(),0);

        // Create an Pointer object over the preallocated memory (No allocation is produced)
        PtrMemory & ptr = *(new PtrMemory(mem.getPointerOffset(ps.getOffset()),size));

        // Create an object over a pointer (No allocation is produced)
        stype src;
        src.setMemory(mem);
        src.resize(this->size());

        auto it = this->getIterator();

        unpack_with_iterator<decltype(it),stype,prp...>(mem,it,src,ps);

        ps.addOffset(size);
    }

    template<unsigned int ... prp> void unpack(ExtPreAlloc<S> & mem, grid_key_dx_iterator_sub<dims> & sub_it, Unpack_stat & ps)
    {
        // object that store the information in mem
        typedef object<typename object_creator<typename grid_cpu<dim,T,S,Mem>::value_type::type,prp...>::type> prp_object;
        typedef openfpm::vector<prp_object,PtrMemory,openfpm::grow_policy_identity> stype;

        size_t size = stype::template calculateMem(sub_it.getVolume(),0);

        // Create an object over the preallocated memory (No allocation is produced)
        PtrMemory & ptr = *(new PtrMemory(mem.getPointerOffset(ps.getOffset()),size));

        // Create an object of the packed information over a pointer (No allocation is produced)
        stype src;
        src.setMemory(ptr);
        src.resize(sub_it.getVolume());

        unpack_with_iterator<grid_key_dx_iterator_sub<dims>,stype,prp...>(mem,sub_it,src,ps);

        ps.addOffset(size);
    }

private:

    bool is_mem_init = false;

    grid_sm<dim,T> g1;

    Mem data_;

    bool isExternal;

    size_t err_code;

    std::vector<size_t> getV()
    {
        std::vector<size_t> tmp;

        for (unsigned int i = 0 ; i < dim ; i++)
        {
            tmp.push_back(0);
        }

        return tmp;
    }

#ifdef SE_CLASS1

    inline void check_init() const
    {
        if (is_mem_init == false)
        {
            std::cerr << "Error " << __FILE__ << ":" << __LINE__ << " you must call SetMemory before access the grid\n";
            size_t * err_code_pointer = (size_t *)&this->err_code;
            *err_code_pointer = 1001;
            ACTION_ON_ERROR(GRID_ERROR);
        }
    }

    inline void check_bound(const grid_key_dx<dim> & v1) const
    {
        for (long int i = 0 ; i < dim ; i++)
        {
            if (v1.get(i) >= (long int)getGrid().size(i))
            {
                std::cerr << "Error " __FILE__ << ":" << __LINE__ <<" grid overflow " << "x=[" << i << "]=" << v1.get(i) << " >= " << getGrid().size(i) << "\n";
                size_t * err_code_pointer = (size_t *)&this->err_code;
                *err_code_pointer = 1002;
                ACTION_ON_ERROR(GRID_ERROR);
            }
            else if (v1.get(i) < 0)
            {
                std::cerr << "Error " __FILE__ << ":" << __LINE__ <<" grid overflow " << "x=[" << i << "]=" << v1.get(i) << " is negative " << "\n";
                size_t * err_code_pointer = (size_t *)&this->err_code;
                *err_code_pointer = 1003;
                ACTION_ON_ERROR(GRID_ERROR);
            }
        }
    }

    inline void check_bound(const grid_cpu<dim,T,S,Mem> & g,const grid_key_dx<dim> & key2) const
    {
        for (size_t i = 0 ; i < dim ; i++)
        {
            if (key2.get(i) >= (long int)g.g1.size(i))
            {
                std::cerr << "Error " __FILE__ << ":" << __LINE__ <<" grid overflow " << "x=[" << i << "]=" << key2.get(i) << " >= " << g.g1.size(i) << "\n";
                size_t * err_code_pointer = (size_t *)&this->err_code;
                *err_code_pointer = 1004;
                ACTION_ON_ERROR(GRID_ERROR);
            }
            else if (key2.get(i) < 0)
            {
                std::cerr << "Error " __FILE__ << ":" << __LINE__ <<" grid overflow " << "x=[" << i << "]=" << key2.get(i) << " is negative " << "\n";
                size_t * err_code_pointer = (size_t *)&this->err_code;
                *err_code_pointer = 1005;
                ACTION_ON_ERROR(GRID_ERROR);
            }
        }
    }

#endif

public:

    typedef int yes_i_am_grid;

    typedef typename memory_traits_lin<typename T::type>::type memory_lin;

    typedef Mem memory_t;

    // you can access all the properties of T
    typedef encapc<dim,T,Mem> container;

    // The object type the grid is storing
    typedef T value_type;

    grid_cpu() THROW
    :g1(getV()),isExternal(false),err_code(0)
    {
        // Add this pointer
#ifdef SE_CLASS2
        check_new(this,8,GRID_EVENT,1);
#endif
    }

    grid_cpu(const grid_cpu & g) THROW
    :isExternal(false),err_code(0)
    {
        this->operator=(g);
    }

    grid_cpu(std::vector<size_t> & sz) THROW
    :g1(sz),isExternal(false),err_code(0)
    {
        // Add this pointer
#ifdef SE_CLASS2
        check_new(this,8,GRID_EVENT,1);
#endif
    }

    grid_cpu(std::vector<size_t> && sz) THROW
    :g1(sz),isExternal(false),err_code(0)
    {
        // Add this pointer
#ifdef SE_CLASS2
        check_new(this,8,GRID_EVENT,1);
#endif
    }

    grid_cpu(const size_t (& sz)[dim]) THROW
    :g1(sz),isExternal(false),err_code(0)
    {
        // Add this pointer
#ifdef SE_CLASS2
        check_new(this,8,GRID_EVENT,1);
#endif
    }

    ~grid_cpu() THROW
    {
        // delete this pointer
#ifdef SE_CLASS2
        check_delete(this);
#endif
    }

    grid_cpu<dim,T,S,Mem> & operator=(const grid_cpu<dim,T,S,Mem> & g)
    {
        // Add this pointer
#ifdef SE_CLASS2
        check_new(this,8,GRID_EVENT,1);
#endif
        swap(g.duplicate());

        return *this;
    }

    grid_cpu<dim,T,S,Mem> & operator=(grid_cpu<dim,T,S,Mem> && g)
    {
        // Add this pointer
#ifdef SE_CLASS2
        check_new(this,8,GRID_EVENT,1);
#endif

        swap(g);

        return *this;
    }

    bool operator==(const grid_cpu<dim,T,S,Mem> & g)
    {
        // check if the have the same size
        if (g1 != g.g1)
            return false;

        auto it = getIterator();

        while (it.isNext())
        {
            auto key = it.get();

            if (this->get_o(key) != this->get_o(key))
                return false;

            ++it;
        }

        return true;
    }

    grid_cpu<dim,T,S,Mem> duplicate() const THROW
    {
#ifdef SE_CLASS2
        check_valid(this,8);
#endif

        grid_cpu<dim,T,S,Mem> grid_new(g1.getSize());

        grid_new.setMemory();

        // We know that, if it is 1D we can safely copy the memory
//      if (dim == 1)
//      {
//          grid_new.data_.mem->copy(*data_.mem);
//      }
//      else
//      {

            grid_key_dx_iterator<dim> it(g1);

            while(it.isNext())
            {
                grid_new.get_o(it.get()) = this->get_o(it.get());

                ++it;
            }
//      }

        // copy grid_new to the base

        return grid_new;
    }

    const grid_sm<dim,T> & getGrid() const
    {
#ifdef SE_CLASS2
        check_valid(this,8);
#endif
        return g1;
    }

    void setMemory()
    {
#ifdef SE_CLASS2
        check_valid(this,8);
#endif
        S * mem = new S();

        data_.setMemory(*mem);

        if (g1.size() != 0) data_.allocate(g1.size());

        is_mem_init = true;
    }

    void setMemory(S & m)
    {
#ifdef SE_CLASS2
        check_valid(this,8);
#endif
        isExternal = true;

        data_.setMemory(m);

        if (g1.size() != 0) data_.allocate(g1.size());

        is_mem_init = true;
    }

    void * getPointer()
    {
#ifdef SE_CLASS2
        check_valid(this,8);
#endif
        if (data_.mem_r == NULL)
            return NULL;

        return data_.mem_r->get_pointer();
    }

    const void * getPointer() const
    {
#ifdef SE_CLASS2
        check_valid(this,8);
#endif
        if (data_.mem_r == NULL)
            return NULL;

        return data_.mem_r->get_pointer();
    }

    template <unsigned int p>inline typename type_cpu_prop<p,memory_lin>::type & get(grid_key_d<dim,p> & v1)
    {
#ifdef SE_CLASS2
        check_valid(this,8);
#endif
#ifdef SE_CLASS1
        check_init();
        check_bound(v1);
#endif
#ifdef SE_CLASS2
        if (check_valid(&boost::fusion::at_c<p>(data_.mem_r->operator[](g1.LinId(v1)))) == false) {ACTION_ON_ERROR();}
#endif
        return boost::fusion::at_c<p>(data_.mem_r->operator[](g1.LinId(v1)));
    }

    template <unsigned int p>inline const typename type_cpu_prop<p,memory_lin>::type & get(grid_key_d<dim,p> & v1) const
    {
#ifdef SE_CLASS2
        check_valid(this,8);
#endif
#ifdef SE_CLASS1
        check_init();
        check_bound(v1);
#endif
#ifdef SE_CLASS2
        if (check_valid(&boost::fusion::at_c<p>(data_.mem_r->operator[](g1.LinId(v1)))) == false) {ACTION_ON_ERROR()};
#endif
        return boost::fusion::at_c<p>(data_.mem_r->operator[](g1.LinId(v1)));
    }

    template <unsigned int p>inline typename type_cpu_prop<p,memory_lin>::type & get(const grid_key_dx<dim> & v1)
    {
#ifdef SE_CLASS2
        check_valid(this,8);
#endif
#ifdef SE_CLASS1
        check_init();
        check_bound(v1);
#endif
#ifdef SE_CLASS2
        if (check_valid(&boost::fusion::at_c<p>(data_.mem_r->operator[](g1.LinId(v1))),sizeof(typename type_cpu_prop<p,memory_lin>::type)) == false) {ACTION_ON_ERROR()};
#endif
        return boost::fusion::at_c<p>(data_.mem_r->operator[](g1.LinId(v1)));
    }

    template <unsigned int p>inline const typename type_cpu_prop<p,memory_lin>::type & get(const grid_key_dx<dim> & v1) const
    {
#ifdef SE_CLASS2
        check_valid(this,8);
#endif
#ifdef SE_CLASS1
        check_init();
        check_bound(v1);
#endif
#ifdef SE_CLASS2
        if (check_valid(&boost::fusion::at_c<p>(data_.mem_r->operator[](g1.LinId(v1))),sizeof(typename type_cpu_prop<p,memory_lin>::type)) == false) {ACTION_ON_ERROR()};
#endif
        return boost::fusion::at_c<p>(data_.mem_r->operator[](g1.LinId(v1)));
    }

    inline encapc<dim,T,Mem> get_o(const grid_key_dx<dim> & v1)
    {
#ifdef SE_CLASS2
        check_valid(this,8);
#endif
#ifdef SE_CLASS1
        check_init();
        check_bound(v1);
#endif
#ifdef SE_CLASS2
        check_valid(&data_.mem_r->operator[](g1.LinId(v1)),sizeof(T));
#endif
        return encapc<dim,T,Mem>(data_.mem_r->operator[](g1.LinId(v1)));
    }

    inline const encapc<dim,T,Mem> get_o(const grid_key_dx<dim> & v1) const
    {
#ifdef SE_CLASS2
        check_valid(this,8);
#endif
#ifdef SE_CLASS1
        check_init();
        check_bound(v1);
#endif
#ifdef SE_CLASS2
        if (check_valid(&data_.mem_r->operator[](g1.LinId(v1)),sizeof(T)) == false) {ACTION_ON_ERROR()}
#endif
        return encapc<dim,T,Mem>(data_.mem_r->operator[](g1.LinId(v1)));
    }

    void fill(unsigned char fl)
    {
#ifdef SE_CLASS2
        check_valid(this,8);
#endif
        memset(getPointer(),fl,size() * sizeof(T));
    }

    void resize(const size_t (& sz)[dim])
    {
#ifdef SE_CLASS2
        check_valid(this,8);
#endif

        grid_cpu<dim,T,S,Mem> grid_new(sz);

        if (isExternal == true)
        {
            grid_new.setMemory(static_cast<S&>(data_.getMemory()));

            // Create an empty memory allocator for the actual structure

            setMemory();
        }
        else
            grid_new.setMemory();


        // We know that, if it is 1D we can safely copy the memory
//      if (dim == 1)
//      {
//          //! 1-D copy (This case is simple we use raw memory copy because is the fastest option)
//          grid_new.data_.mem->copy(*data_.mem);
//      }
//      else
//      {
        // It should be better to separate between fast and slow cases


            grid_key_dx_iterator<dim> it(g1);

            while(it.isNext())
            {
                // get the grid key
                grid_key_dx<dim> key = it.get();

                // create a copy element

                grid_new.get_o(key) = this->get_o(key);

                ++it;
            }
//      }

        // copy grid_new to the base

        this->swap(grid_new);
    }

    void remove(size_t key)
    {
#ifdef SE_CLASS2
        check_valid(this,8);
#endif
        if (dim != 1)
        {
#ifdef SE_CLASS1
            std::cerr << "Error: " << __FILE__ << " " << __LINE__ << " remove work only on dimension == 1 " << "\n";
#endif
            return;
        }

        // It is safe to do a memory copy

        data_.move(&this->template get<0>());
    }


    void swap(grid_cpu<dim,T,S,Mem> & grid)
    {
#ifdef SE_CLASS2
        check_valid(this,8);
#endif
        // move the data
        data_.swap(grid.data_);

        // exghange the grid info
        g1.swap(grid.g1);

        // exchange the init status
        bool exg = is_mem_init;
        is_mem_init = grid.is_mem_init;
        grid.is_mem_init = exg;

        // exchange the is external status
        exg = isExternal;
        isExternal = grid.isExternal;
        grid.isExternal = exg;
    }

    void swap(grid_cpu<dim,T,S,Mem> && grid)
    {
#ifdef SE_CLASS2
        check_valid(this,8);
#endif
        swap(grid);
    }

    template<typename Memory> inline void set(grid_key_dx<dim> dx, const encapc<1,T,Memory> & obj)
    {
#ifdef SE_CLASS2
        check_valid(this,8);
#endif
#ifdef SE_CLASS1
        check_init();
        check_bound(dx);
#endif

        // create the object to copy the properties
        copy_cpu_encap<dim,grid_cpu<dim,T,S,Mem>,Mem> cp(dx,*this,obj);

        // copy each property
        boost::mpl::for_each_ref< boost::mpl::range_c<int,0,T::max_prop> >(cp);
    }

    inline void set(grid_key_dx<dim> dx, const T & obj)
    {
#ifdef SE_CLASS2
        check_valid(this,8);
#endif
#ifdef SE_CLASS1
        check_init();
        check_bound(dx);
#endif

        this->get_o(dx) = obj;
    }


    inline void set(const grid_key_dx<dim> & key1,const grid_cpu<dim,T,S,Mem> & g, const grid_key_dx<dim> & key2)
    {
#ifdef SE_CLASS2
        check_valid(this,8);
#endif
#ifdef SE_CLASS1
        check_init();
        check_bound(key1);
        check_bound(g,key2);
#endif

        this->get_o(key1) = g.get_o(key2);
    }

    inline size_t size() const
    {
#ifdef SE_CLASS2
        check_valid(this,8);
#endif
        return g1.size();
    }

    inline grid_key_dx_iterator_sub<dim> getSubIterator(grid_key_dx<dim> & start, grid_key_dx<dim> & stop) const
    {
#ifdef SE_CLASS2
        check_valid(this,8);
#endif
        return g1.getSubIterator(start,stop);
    }

    inline grid_key_dx_iterator_sub<dim> getSubIterator(size_t m)
    {
#ifdef SE_CLASS2
        check_valid(this,8);
#endif
        return grid_key_dx_iterator_sub<dim>(g1,m);
    }

    inline grid_key_dx_iterator<dim> getIterator() const
    {
#ifdef SE_CLASS2
        check_valid(this,8);
#endif
        return grid_key_dx_iterator<dim>(g1);
    }

    inline grid_key_dx_iterator_sub<dim> getIterator(const grid_key_dx<dim> & start, const grid_key_dx<dim> & stop) const
    {
#ifdef SE_CLASS2
        check_valid(this,8);
#endif
        // get the starting point and the end point of the real domain

        return grid_key_dx_iterator_sub<dim>(g1,start,stop);
    }

    size_t getLastError()
    {
#ifdef SE_CLASS2
        check_valid(this,8);
#endif
        return err_code;
    }

    size_t packObjectSize()
    {
#ifdef SE_CLASS2
        check_valid(this,8);
#endif
        return 0;
    }

    size_t packObject(void * mem)
    {
#ifdef SE_CLASS2
        check_valid(this,8);
#endif
        return 0;
    }

    /* \brief It return the id of structure in the allocation list
     *
     * \see print_alloc and SE_CLASS2
     *
     */
    long int who()
    {
#ifdef SE_CLASS2
        return check_whoami(this,8);
#else
        return -1;
#endif
    }
};

template<typename S>
struct allocate
{
    size_t sz;

    allocate(size_t sz)
    :sz(sz){};

    template<typename T>
    void operator()(T& t) const
    {
        t.setMemory(*new S());

        t.allocate(sz);
    }
};

#include "grid_gpu.hpp"

#endif