grid_base_impl_layout.hpp

/*
 * grid_base_impl_layout.hpp
 *
 *  Created on: May 2, 2016
 *      Author: i-bird
 */
 
#ifndef OPENFPM_DATA_SRC_GRID_GRID_BASE_IMPL_LAYOUT_HPP_
#define OPENFPM_DATA_SRC_GRID_GRID_BASE_IMPL_LAYOUT_HPP_
 
#include <boost/fusion/include/mpl.hpp>
#include "memory_ly/memory_conf.hpp"
#include <boost/fusion/include/for_each.hpp>
#include "memory_ly/Encap.hpp"
#include "Space/Shape/Box.hpp"
 
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());
 
        if (sz != 0)    t.allocate(sz);
    }
};
 
 
template<typename s_m>
struct frswap
{
    s_m & swap_src;
    s_m & swap_dst;
 
    frswap(s_m & swap_dst, s_m & swap_src)
    :swap_src(swap_src),swap_dst(swap_dst)
    {};
 
    template<typename T>
    void operator()(T& t) const
    {
        boost::fusion::at_c<T::value>(swap_dst).swap(boost::fusion::at_c<T::value>(swap_src));
    }
};
 
 
template<typename s_m, typename Mem_type>
struct frswap_nomode
{
    s_m & swap_src;
    s_m & swap_dst;
 
    frswap_nomode(s_m & swap_dst, s_m & swap_src)
    :swap_src(swap_src),swap_dst(swap_dst)
    {};
 
    template<typename T>
    void operator()(T& t) const
    {
        boost::fusion::at_c<T::value>(swap_dst).template swap_nomode<Mem_type>(boost::fusion::at_c<T::value>(swap_src));
    }
};
 
template<typename S, typename layout, typename data_type, typename g1_type, unsigned int sel = 2*is_layout_mlin<layout>::value + is_layout_inte<layout>::value >
struct mem_setm
{
    static inline void setMemory(data_type & data_, const g1_type & g1, bool & is_mem_init)
    {
        S * mem = new S();
 
        data_.setMemory(*mem);
 
        if (g1.size() != 0) data_.allocate(g1.size());
 
        is_mem_init = true;
    }
};
 
template<typename S, typename layout, typename data_type, typename g1_type>
struct mem_setm<S,layout,data_type,g1_type,1>
{
    static inline void setMemory(data_type & data_, const g1_type & g1, bool & is_mem_init)
    {
        allocate<S> all(g1.size());
 
        boost::fusion::for_each(data_,all);
 
        is_mem_init = true;
    }
};
 
 
template<typename grid_type, typename S , typename layout, typename data_type, unsigned int sel = 2*is_layout_mlin<layout>::value + is_layout_inte<layout>::value >
struct mem_setext
{
    static inline void set(grid_type & grid_new, grid_type & old, data_type & data_)
    {
        grid_new.setMemory(static_cast<S&>(data_.getMemory()));
 
        // Create an empty memory allocator for the actual structure
 
        old.setMemory();
    }
};
 
template<typename grid_type, typename data_type, typename S>
struct mem_setext_prp
{
    grid_type & grid_new;
 
    grid_type & old;
 
    data_type & data_;
 
    inline mem_setext_prp(grid_type & g_new, grid_type & old, data_type & data_)
    :grid_new(g_new),old(old),data_(data_)
    {};
 
    template<typename T>
    inline void operator()(T& t)
    {
        grid_new.template setMemory<T::value>(static_cast<S&>(boost::fusion::at_c<T::value>(data_).getMemory()));
 
 
    }
};
 
 
template<typename grid_type, typename Memory>
struct mem_setarray
{
    grid_type & grid_new;
 
    Memory * mem;
 
    size_t sz;
 
    bool np;
 
    inline mem_setarray(grid_type & g_new, Memory * mem, size_t sz, bool np)
    :grid_new(g_new),mem(mem),sz(sz),np(np)
    {};
 
    template<typename T>
    inline void operator()(T& t)
    {
        grid_new.template setMemory<T::value>(mem[T::value]);
 
        if (sz != 0) boost::fusion::at_c<T::value>(grid_new.get_internal_data_()).allocate(sz,np);
    }
};
 
template<typename grid_type, typename S , typename layout, typename data_type>
struct mem_setext<grid_type,S,layout,data_type,1>
{
    static inline void set(grid_type & grid_new, grid_type & old, data_type & data_)
    {
//      std::cerr << __FILE__ << ":" << "__LINE__" << " Error, " << demangle(typeid(grid_type).name()) << " this structure does not support setting from external memory" << std::endl;
        mem_setext_prp<grid_type,data_type,S> mst(grid_new,old,data_);
 
        // Create an empty memory allocator for the actual structure
        boost::mpl::for_each_ref<boost::mpl::range_c<int,0,grid_type::value_type::max_prop>>(mst);
 
        old.setMemory();
    }
};
 
 
template<typename T , typename layout, typename data_type, typename grid_type, unsigned int sel = 2*is_layout_mlin<layout>::value + is_layout_inte<layout>::value >
struct mem_swap
{
    static inline void swap(data_type & data_dst, data_type & data_src)
    {
        // move the data
        data_dst.swap(data_src);
    }
 
    template<typename Mem_type>
    static inline void swap_nomode(data_type & data_dst, data_type & data_src)
    {
        // move the data
        data_dst.swap_nomode(data_src);
    }
};
 
template<typename T , typename layout, typename data_type, typename grid_type>
struct mem_swap<T,layout,data_type,grid_type,1>
{
    static inline void swap(data_type & data_dst, data_type & data_src)
    {
        // swap the data for each property
        frswap<decltype(data_dst)> sw(data_dst,data_src);
 
        boost::mpl::for_each_ref< boost::mpl::range_c<int,0,T::max_prop> >(sw);
    }
 
    template<typename Mem_type>
    static inline void swap_nomode(data_type & data_dst, data_type & data_src)
    {
        // swap the data for each property
        frswap_nomode<decltype(data_dst),Mem_type> sw(data_dst,data_src);
 
        boost::mpl::for_each_ref< boost::mpl::range_c<int,0,T::max_prop> >(sw);
    }
};
 
template<typename data_type, typename layout, unsigned int sel = 2*is_layout_mlin<layout>::value + is_layout_inte<layout>::value>
struct mem_getpointer
{
    template<unsigned int d> __device__ __host__ static void * getPointer(data_type & data_)
    {
        return data_.mem_r.get_pointer();
    }
 
    template<unsigned int d> __device__ __host__ static void * getPointer(const data_type & data_)
    {
        return data_.mem_r.get_pointer();
    }
};
 
template<typename data_type, typename layout>
struct mem_getpointer<data_type,layout,1>
{
    template<unsigned int p> __device__ __host__ static void * getPointer(data_type & data_)
    {
        return boost::fusion::at_c<p>(data_).mem_r.get_pointer();
    }
 
    template<unsigned int p> __device__ __host__ static const void * getPointer(const data_type & data_)
    {
        return boost::fusion::at_c<p>(data_).mem_r.get_pointer();
    }
};
 
template<typename data_type, typename Mem_type, typename layout, unsigned int sel = 2*is_layout_mlin<layout>::value + is_layout_inte<layout>::value>
struct mem_setmemory
{
    template<unsigned int d> static void setMemory(data_type & data_, Mem_type & m, size_t sz, bool np)
    {
        data_.setMemory(m);
 
        if (sz != 0) data_.allocate(sz,np);
    }
 
    static void setMemoryArray(data_type & data_, Mem_type * m, size_t sz, bool np)
    {
        data_.setMemory(m[0]);
 
        if (sz != 0) data_.allocate(sz,np);
    }
};
 
template<typename data_type, typename Mem_type, typename layout>
struct mem_setmemory<data_type,Mem_type,layout,1>
{
    template<unsigned int p> static void setMemory(data_type & data_, Mem_type & m, size_t sz,bool np)
    {
        boost::fusion::at_c<p>(data_).setMemory(m);
 
        if (sz != 0) boost::fusion::at_c<p>(data_).allocate(sz,np);
    }
 
    template<typename grid_type> static void setMemoryArray(grid_type & grid, Mem_type * m, size_t sz,bool np)
    {
        mem_setarray<grid_type,Mem_type> ma(grid,m,sz,np);
 
        // Create an empty memory allocator for the actual structure
        boost::mpl::for_each_ref<boost::mpl::range_c<int,0,grid_type::value_type::max_prop>>(ma);
    }
};
 
 
#endif /* OPENFPM_DATA_SRC_GRID_GRID_BASE_IMPL_LAYOUT_HPP_ */