Packer.hpp

/*
 * Packer_cls.hpp
 *
 *  Created on: Jul 15, 2015
 *      Author: i-bird
 */
 
#ifndef SRC_PACKER_HPP_
#define SRC_PACKER_HPP_
 
 
#include "util/cudify/cudify.hpp"
 
#include "util/object_util.hpp"
//#include "Grid/util.hpp"
#include "Vector/util.hpp"
#include "memory/ExtPreAlloc.hpp"
#include "util/util_debug.hpp"
 
#include "Grid/grid_sm.hpp"
#include "util/Pack_stat.hpp"
#include "Pack_selector.hpp"
#include "has_pack_encap.hpp"
#include "Packer_util.hpp"
 
 
template <typename> struct Debug;
 
template<typename T, typename Mem, int pack_type >
class Packer
{
public:
 
    static void pack(ExtPreAlloc<Mem> , const T & obj)
    {
#ifndef DISABLE_ALL_RTTI
        std::cerr << "Error: " << __FILE__ << ":" << __LINE__ << " packing for the type " << demangle(typeid(T).name()) << " is not implemented\n";
#endif
    }
 
    static size_t packRequest(const T & obj, size_t & req)
    {
#ifndef DISABLE_ALL_RTTI
        std::cerr << "Error: " << __FILE__ << ":" << __LINE__ << " packing for the type " << demangle(typeid(T).name()) << " is not implemented\n";
#endif
        return 0;
    }
};
 
template<typename T, typename Mem>
class Packer<T,Mem,PACKER_PRIMITIVE>
{
public:
 
    inline static void pack(ExtPreAlloc<Mem> & ext, const T & obj, Pack_stat & sts)
    {
        ext.allocate(sizeof(T));
        *(typename std::remove_const<T>::type *)ext.getPointer() = obj;
 
        // update statistic
        sts.incReq();
    }
 
    static void packRequest(const T & obj, size_t & req)
    {
        req += sizeof(T);
    }
 
    static void packRequest(size_t & req)
    {
        req += sizeof(T);
    }
};
 
template<typename T, typename Mem>
class Packer<T,Mem,PACKER_ARRAY_PRIMITIVE>
{
public:
 
    inline static void pack(ExtPreAlloc<Mem> & ext, const T & obj, Pack_stat & sts, size_t n)
    {
        //Pack the size of a vector
        Packer<size_t, Mem>::pack(ext,obj.size(),sts);
 
        //Pack a vector
        ext.allocate(sizeof(typename T::value_type)*n);
        memcpy(ext.getPointer(),obj.getPointer(),sizeof(typename T::value_type)*n);
 
        // update statistic
        sts.incReq();
    }
 
    static void packRequest(T & obj,size_t & req)
    {
        req += sizeof(typename T::value_type)*obj.size();
    }
};
 
 
template<typename T, typename Mem>
class Packer<T,Mem,PACKER_ARRAY_CP_PRIMITIVE>
{
public:
 
    inline static void pack(ExtPreAlloc<Mem> & ext, const T & obj, Pack_stat & sts)
    {
        typedef typename std::remove_extent<T>::type prim_type;
 
        //Pack a vector
        ext.allocate(sizeof(T));
 
        meta_copy<T>::meta_copy_(obj,(prim_type *)ext.getPointer());
 
        // update statistic
        sts.incReq();
    }
 
    template<typename tp, long unsigned int dim, typename vmpl>
    inline static void pack(ExtPreAlloc<Mem> & ext,
                            const openfpm::detail::multi_array::sub_array_openfpm<tp,dim,vmpl> & obj,
                            Pack_stat & sts)
    {
        typedef typename std::remove_extent<T>::type prim_type;
 
        //Pack a vector
        ext.allocate(sizeof(T));
 
        meta_copy<T>::meta_copy_(obj,(prim_type *)ext.getPointer());
 
        // update statistic
        sts.incReq();
    }
 
    static void packRequest(T & obj,size_t & req)
    {
        req += sizeof(T);
    }
 
    template<typename tp, long unsigned int dim, typename vmpl>
    static void packRequest(const openfpm::detail::multi_array::sub_array_openfpm<tp,dim,vmpl> & obj,
                            size_t & req)
    {
        req += sizeof(T);
    }
};
 
template<typename T, typename Mem>
class Packer<T,Mem,PACKER_OBJECTS_WITH_WARNING_POINTERS>
{
public:
 
    static void pack(ExtPreAlloc<Mem> & ext, const T & obj, Pack_stat & sts)
    {
#ifdef SE_CLASS1
        if (ext.ref() == 0)
            std::cerr << "Error : " << __FILE__ << ":" << __LINE__ << " the reference counter of mem should never be zero when packing \n";
 
        if (!(std::is_array<T>::value == true && std::is_fundamental<typename std::remove_all_extents<T>::type>::value == true))
            std::cerr << "Warning: " << __FILE__ << ":" << __LINE__ << " impossible to check the type " << demangle(typeid(T).name()) << " please consider to add a static method like \"static bool noPointers() {return true;}\" \n" ;
#endif
        ext.allocate(sizeof(T));
        memcpy((typename std::remove_reference<T>::type *)ext.getPointer(),&obj,sizeof(T));
 
        // update statistic
        sts.incReq();
    }
 
    static void packRequest(const T & obj,size_t & req)
    {
        req += sizeof(T);
    }
 
    static void packRequest(size_t & req)
    {
        req += sizeof(T);
    }
};
 
template<typename T, typename Mem>
class Packer<T,Mem,PACKER_OBJECTS_WITH_POINTER_CHECK>
{
public:
 
    static void pack(ExtPreAlloc<Mem> & ext, const T & obj, Pack_stat & sts)
    {
#ifdef SE_CLASS1
        if (ext.ref() == 0)
            std::cerr << "Error : " << __FILE__ << ":" << __LINE__ << " the reference counter of mem should never be zero when packing \n";
 
        if (obj.noPointers() == false)
            std::cerr << "Error: " << __FILE__ << ":" << __LINE__ << " the type " << demangle(typeid(T).name()) << " has pointers inside, sending pointers values has no sense\n";
#endif
        ext.allocate(sizeof(T));
        memcpy((typename std::remove_const<T>::type *)ext.getPointer(),&obj,sizeof(T));
 
        // Update statistic
        sts.incReq();
    }
 
    static void packRequest(const T & obj,size_t & req)
    {
        req += sizeof(T);
    }
 
    static void packRequest(size_t & req)
    {
        req += sizeof(T);
    }
};
 
template<typename T, typename Mem>
class Packer<T,Mem,PACKER_GENERAL>
{
public:
 
    template<int ... prp> static void packRequest(const T & obj, size_t & req)
    {
        obj.template packRequest<prp...>(req);
    }
 
    template<int ... prp> static void pack(ExtPreAlloc<Mem> & mem, const T & obj, Pack_stat & sts)
    {
        obj.template pack<prp...>(mem, sts);
    }
};
 
template<typename T, typename Mem>
class Packer<T,Mem,PACKER_GRID>
{
public:
 
    template<int ... prp> static void packRequest(const T & obj, size_t & req)
    {
        obj.template packRequest<prp...>(req);
    }
 
    template<typename grid_sub_it_type, int ... prp> static void packRequest(T & obj, grid_sub_it_type & sub, size_t & req)
    {
        obj.template packRequest<prp...>(sub, req);
    }
 
    template<int ... prp> static void pack(ExtPreAlloc<Mem> & mem, const T & obj, Pack_stat & sts)
    {
        obj.template pack<prp...>(mem, sts);
    }
 
    template<typename grid_sub_it_type, int ... prp> static void pack(ExtPreAlloc<Mem> & mem, T & obj, grid_sub_it_type & sub_it, Pack_stat & sts)
    {
        obj.template pack<prp...>(mem, sub_it, sts);
    }
};
 
template<typename T, typename Mem>
class Packer<T,Mem,PACKER_ENCAP_OBJECTS>
{
public:
 
    template<int ... prp> static void pack(ExtPreAlloc<Mem> & mem, const T & eobj, Pack_stat & sts)
    {
#ifdef SE_CLASS1
        if (mem.ref() == 0)
            std::cerr << "Error : " << __FILE__ << ":" << __LINE__ << " the reference counter of mem should never be zero when packing \n";
#endif
 
        if (has_pack_encap<T,prp ...>::result::value == true)
        {call_encapPack<T,Mem,prp ...>::call_pack(eobj,mem,sts);}
        else
        {
            if (sizeof...(prp) == 0)
            {
                mem.allocate(sizeof(typename T::T_type));
                encapc<1,typename T::T_type,typename memory_traits_lin< typename T::T_type >::type> enc(*static_cast<typename T::T_type::type *>(mem.getPointer()));
                enc = eobj;
            }
            else
            {
                typedef object<typename object_creator<typename T::type,prp...>::type> prp_object;
                mem.allocate(sizeof(prp_object));
                encapc<1,prp_object,typename memory_traits_lin< prp_object >::type> enc(*static_cast<typename prp_object::type *>(mem.getPointer()));
                object_si_d<T,decltype(enc),OBJ_ENCAP,prp ... >(eobj,enc);
            }
        }
 
        // update statistic
        sts.incReq();
    }
 
    template<int ... prp> void packRequest(T & eobj,size_t & req)
    {
        if (has_pack_encap<T>::value == true)
        {call_encapPackRequest<T,Mem,prp ...>::call_packRequest(eobj,req);}
        else
        {
            if (sizeof...(prp) == 0)
                return;
 
            typedef object<typename object_creator<typename T::type,prp...>::type> prp_object;
 
            req += sizeof(prp_object);
        }
    }
};
 
 
template<typename Timpl>
struct copy_packer_chunk_arr_impl
{
    template<typename T, typename e_src, typename e_dst>
    static inline void call(const e_src & src, size_t sub_id, e_dst & dst)
    {
        // Remove the reference from the type to copy
        typedef typename boost::remove_reference<decltype(dst.template get< T::value >())>::type copy_rtype;
 
        meta_copy<copy_rtype>::meta_copy_(src.template get< T::value >()[sub_id],dst.template get< T::value >());
    }
};
 
template<unsigned int N1, typename Timpl>
struct copy_packer_chunk_arr_impl<Timpl[N1]>
{
    template<typename T, typename e_src, typename e_dst>
    static inline void call(const e_src & src, size_t sub_id, e_dst & dst)
    {
        // Remove the reference from the type to copy
        typedef typename boost::remove_reference<decltype(dst.template get< T::value >()[0])>::type copy_rtype;
 
        for (int i = 0 ; i < N1 ; i++)
        {meta_copy<copy_rtype>::meta_copy_(src.template get< T::value >()[i][sub_id],dst.template get< T::value >()[i]);}
    }
};
 
template<typename e_src, typename e_dst>
struct copy_packer_chunk
{
    const e_src & src;
    e_dst & dst;
 
    size_t sub_id;
 
    inline copy_packer_chunk(const e_src & src, size_t sub_id, e_dst & dst)
    :src(src),dst(dst),sub_id(sub_id)
    {};
 
 
 
    template<typename T>
    inline void operator()(T& t) const
    {
        // Remove the reference from the type to copy
        typedef typename boost::remove_reference<decltype(dst.template get< T::value >())>::type copy_rtype;
 
        // meta_copy<copy_rtype>::meta_copy_(src.template get< T::value >()[sub_id],dst.template get< T::value >());
 
        copy_packer_chunk_arr_impl<copy_rtype>::template call<T>(src,sub_id,dst);
    }
};
 
template <typename> struct Debug;
 
template<bool is_not_zero, typename T, typename T_nc, int ... prp>
struct selector_chunking_prp_has_zero_size
{
    template<typename Mem> static inline void select(ExtPreAlloc<Mem> & mem,  const T & eobj, size_t sub_id)
    {
        mem.allocate(sizeof(T_nc));
        encapc<1,T_nc,typename memory_traits_lin< T_nc >::type> enc(*static_cast<typename T_nc::type *>(mem.getPointer()));
        copy_packer_chunk<decltype(eobj),
                          encapc<1,T_nc,typename memory_traits_lin< T_nc >::type>> cp(eobj,sub_id,enc);
        boost::mpl::for_each_ref<boost::mpl::range_c<int,0,T::T_type::max_prop>>(cp);
        //enc = eobj[sub_id];
    }
};
 
template<typename T,  typename T_nc, int ... prp>
struct selector_chunking_prp_has_zero_size<true,T,T_nc,prp...>
{
    template<typename Mem> static inline void select(ExtPreAlloc<Mem> & mem,  const T & eobj, size_t sub_id)
    {
        // Here we create an encap without array extent
        typedef object<typename object_creator_chunking<typename T::type,prp...>::type> prp_object;
        mem.allocate(sizeof(prp_object));
        encapc<1,prp_object,typename memory_traits_lin< prp_object>::type> enc(*static_cast<typename prp_object::type *>(mem.getPointer()));
        object_si_d<T,decltype(enc),OBJ_ENCAP_CHUNKING,prp ... >(eobj,sub_id,enc);
    }
};
 
template<typename T, typename Mem>
class Packer<T,Mem,PACKER_ENCAP_OBJECTS_CHUNKING>
{
public:
 
    template<typename T_nc, int ... prp> static void pack(ExtPreAlloc<Mem> & mem, const T & eobj, size_t sub_id, Pack_stat & sts)
    {
#ifdef SE_CLASS1
        if (mem.ref() == 0)
            std::cerr << "Error : " << __FILE__ << ":" << __LINE__ << " the reference counter of mem should never be zero when packing \n";
#endif
 
        if (has_pack_encap<T,prp ...>::result::value == true)
        {call_encapPackChunking<T,Mem,prp ...>::call_pack(eobj,sub_id,mem,sts);}
        else
        {
            selector_chunking_prp_has_zero_size<sizeof...(prp) != 0,T, T_nc, prp ...>::select(mem,eobj,sub_id);
        }
 
        // update statistic
        sts.incReq();
    }
 
    template<int ... prp> void packRequest(T & eobj,size_t & req)
    {
        if (has_pack_encap<T>::value == true)
            call_encapPackRequest<T,Mem,prp ...>::call_packRequest(eobj,req);
        else
        {
            if (sizeof...(prp) == 0)
                return;
 
            typedef object<typename object_creator<typename T::type,prp...>::type> prp_object;
 
            req += sizeof(prp_object);
        }
    }
};
 
#endif /* SRC_PACKER_HPP_ */