Encap.hpp

/*
 * Encap.hpp
 *
 *  Created on: Feb 2, 2015
 *      Author: i-bird
 */
 
#ifndef ENCAP_HPP_
#define ENCAP_HPP_
 
#include "util/for_each_ref.hpp"
#include "util/copy_compare/meta_copy.hpp"
#include "boost/mpl/range_c.hpp"
#include <boost/fusion/container/vector.hpp>
#include "util/se_util.hpp"
#include "util/copy_compare/copy_fusion_vector.hpp"
#include "util/copy_compare/compare_fusion_vector.hpp"
#include "memory_ly/memory_conf.hpp"
 
 
template<typename e_src, typename e_dst, unsigned int ... prp>
struct copy_cpu_encap_encap_prp
{
    e_src & src;
    e_dst & dst;
 
    typedef typename to_boost_vmpl<prp...>::type vprp;
 
    __device__ __host__ inline copy_cpu_encap_encap_prp(e_src & src, e_dst & dst)
    :src(src),dst(dst)
    {
#if defined(SE_CLASS1) && !defined(__NVCC__)
        // e_src and e_dst must have the same number of properties
 
        if (e_src::T_type::max_prop != e_dst::T_type::max_prop)
            std::cerr << "Error " << __FILE__ << ":" << __LINE__ << " the number of properties between src and dst must match";
#endif
    };
 
 
#ifdef SE_CLASS1
    inline copy_cpu_encap_encap_prp(const e_src && src, const e_dst && dst)
    :src(src),dst(dst)
    {std::cerr << "Error: " <<__FILE__ << ":" << __LINE__ << " Passing a temporal object";};
#endif
 
    template<typename T>
    __device__ __host__ inline void operator()(T& t) const
    {
        typedef typename boost::mpl::at<vprp,T>::type prp_cp;
 
        // Remove the reference from the type to copy
        typedef typename boost::remove_reference<decltype(dst.template get<prp_cp::value>())>::type copy_rtype;
 
        meta_copy<copy_rtype>::meta_copy_(src.template get<prp_cp::value>(),dst.template get<prp_cp::value>());
    }
};
 
 
template<typename e_src, typename e_dst>
struct copy_cpu_encap_encap
{
    const e_src & src;
    e_dst & dst;
 
 
    __device__ __host__ inline copy_cpu_encap_encap(const e_src & src, e_dst & dst)
    :src(src),dst(dst)
    {
#if defined(SE_CLASS1) && !defined(__NVCC__)
        // e_src and e_dst must have the same number of properties
 
        if (e_src::T_type::max_prop != e_dst::T_type::max_prop)
            std::cerr << "Error " << __FILE__ << ":" << __LINE__ << " the number of properties between src and dst must match";
#endif
    };
 
 
#ifdef SE_CLASS1
    inline copy_cpu_encap_encap(const e_src && src, const e_dst && dst)
    :src(src),dst(dst)
    {std::cerr << "Error: " <<__FILE__ << ":" << __LINE__ << " Passing a temporal object";};
#endif
 
    template<typename T>
    __device__ __host__ 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>(),dst.template get<T::value>());
    }
};
 
 
template<typename e_src, typename e_dst>
struct copy_cpu_encap_encap_general
{
    const e_src & src;
    e_dst & dst;
 
 
    __device__ __host__ inline copy_cpu_encap_encap_general(const e_src & src, e_dst & dst)
    :src(src),dst(dst)
    {
#if defined(SE_CLASS1) && !defined(__NVCC__)
        // e_src and e_dst must have the same number of properties
 
        if (e_src::T_type::max_prop != e_dst::T_type::max_prop)
            std::cerr << "Error " << __FILE__ << ":" << __LINE__ << " the number of properties between src and dst must match";
#endif
    };
 
 
#ifdef SE_CLASS1
    inline copy_cpu_encap_encap_general(const e_src && src, const e_dst && dst)
    :src(src),dst(dst)
    {std::cerr << "Error: " <<__FILE__ << ":" << __LINE__ << " Passing a temporal object";};
#endif
 
    template<typename T>
    __device__ __host__ 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_dtype;
 
        // Remove the reference from the type to copy
        typedef typename boost::remove_reference<decltype(src.template get<T::value>())>::type copy_stype;
 
        meta_copy_d<copy_stype,copy_dtype>::meta_copy_d_(src.template get<T::value>(),dst.template get<T::value>());
    }
};
 
 
template<typename e_src>
struct copy_cpu_encap_single
{
    const e_src & src;
    e_src & dst;
 
 
    __device__ __host__ inline copy_cpu_encap_single(const e_src & src, e_src & dst)
    :src(src),dst(dst)
    {
#if defined(SE_CLASS1) && !defined(__NVCC__)
        // e_src and e_dst must have the same number of properties
 
        if (e_src::T_type::max_prop != e_src::T_type::max_prop)
            std::cerr << "Error " << __FILE__ << ":" << __LINE__ << " the number of properties between src and dst must match";
#endif
    };
 
 
#ifdef SE_CLASS1
    inline copy_cpu_encap_single(const e_src && src, const e_src && dst)
    :src(src),dst(dst)
    {std::cerr << "Error: " <<__FILE__ << ":" << __LINE__ << " Passing a temporal object";};
#endif
 
    template<typename T>
    __device__ __host__ 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>(),dst.template get<T::value>());
    }
};
 
 
 
template<template<typename,typename> class op,typename e_src, typename e_dst, int ... prp>
struct copy_cpu_encap_encap_op_prp
{
    const e_src & src;
    e_dst & dst;
 
 
    inline copy_cpu_encap_encap_op_prp(const e_src & src, e_dst & dst)
    :src(src),dst(dst)
    {
#ifdef SE_CLASS1
        // e_src and e_dst must have the same number of properties
 
        if (e_src::T_type::max_prop != e_dst::T_type::max_prop)
            std::cerr << "Error " << __FILE__ << ":" << __LINE__ << " the number of properties between src and dst must match";
#endif
    };
 
 
#ifdef SE_CLASS1
    inline copy_cpu_encap_encap_op_prp(const e_src && src, const e_dst && dst)
    :src(src),dst(dst)
    {std::cerr << "Error: " <<__FILE__ << ":" << __LINE__ << " Passing a temporal object";};
#endif
 
    template<typename T>
    inline void operator()(T& t) const
    {
        // Convert variadic to boost::vector
        typedef typename boost::mpl::vector_c<unsigned int,prp...> prpv;
 
        // element id to copy applying an operation
        typedef typename boost::mpl::at<prpv,T>::type ele_cop;
 
        // Remove the reference from the type to copy
        typedef typename boost::remove_reference<decltype(src.template get< ele_cop::value >())>::type copy_rtype;
 
        meta_copy_op<op,copy_rtype>::meta_copy_op_(src.template get< ele_cop::value >(),dst.template get< ele_cop::value >());
    }
};
 
 
 
 
template<typename e_src, typename e_dst>
struct compare_cpu_encap_encap
{
    const e_src & src;
    const e_dst & dst;
 
 
    inline compare_cpu_encap_encap(const e_src & src, const e_dst & dst)
    :src(src),dst(dst)
    {
#ifdef SE_CLASS1
        // e_src and e_dst must have the same number of properties
 
        if (e_src::max_prop != e_dst::max_prop)
            std::cerr << "Error " << __FILE__ << ":" << __LINE__ << " the number of properties between src and dst must match";
#endif
    };
 
 
#ifdef SE_CLASS1
 
    inline compare_cpu_encap_encap(const e_src && src, const e_dst && dst)
    :src(src),dst(dst)
    {std::cerr << "Error: " <<__FILE__ << ":" << __LINE__ << " Passing a temporal object";};
#endif
 
    template<typename T>
    inline void operator()(T& t) const
    {
        typedef typename boost::fusion::result_of::at_c<typename e_src::type,T::value>::type copy_type;
 
        typedef typename boost::remove_reference<copy_type>::type copy_rtype;
 
        meta_compare<copy_rtype> cp(src.template get<T::value>(),dst.template get<T::value>());
    }
};
 
template<unsigned int dim,typename T,typename layout>
class encapc
{
 
};
 
template<unsigned int dim,typename T>
class encapc<dim,T,typename memory_traits_lin<T>::type >
{
public:
 
    typedef typename T::type type;
 
private:
 
#ifdef SE_CLASS1
    bool init = false;
#endif
 
    type & data_c;
 
    typedef typename memory_traits_lin<T>::type Mem;
 
    typedef typename memory_traits_inte<T>::type Mem2;
 
#ifdef SE_CLASS1
    __device__ __host__ void check_init() const
    {
        if (init == false)
        {
            #ifdef CUDA_ON_CPU
            std::cout << __FILE__ << ":" << __LINE__ << " Error using unallocated pointer" << std::endl;
            #else
            assert(init == true);
            #endif
        }
    }
#endif
 
public:
 
#ifdef SE_CLASS1
    __device__ __host__ ~encapc()
    {init = false;}
#endif
 
    typedef int yes_i_am_encap;
 
    typedef T T_type;
 
    static const int max_prop = T::max_prop;
 
    __device__ __host__ inline encapc(type & data_c)
    :data_c(data_c)
    {
#ifdef SE_CLASS1
        init = true;
#endif
    }
 
 
    inline type * operator&()
    {
#ifdef SE_CLASS1
        check_init();
#endif
        return &data_c;
    }
 
    template <unsigned int p, typename r_type=decltype(boost::fusion::at_c<p>(data_c))>
    __device__ __host__ inline r_type get()
    {
#ifdef SE_CLASS1
        check_init();
#endif
        return boost::fusion::at_c<p>(data_c);
    }
 
    template <unsigned int p, typename r_type=decltype(boost::fusion::at_c<p>(data_c))>
    __device__ __host__ inline const r_type get() const
    {
#ifdef SE_CLASS1
        check_init();
#endif
        return boost::fusion::at_c<p>(data_c);
    }
 
    template <unsigned int p> inline
    __device__ __host__ void set(decltype(boost::fusion::at_c<p>(data_c)) & ele)
    {
#ifdef SE_CLASS1
        check_init();
#endif
            return boost::fusion::at_c<p>(data_c) = ele;
    }
 
    template<unsigned int dim2>
    __device__ __host__ inline encapc<dim,T,Mem> & set(const encapc<dim2,T,Mem> & ec)
    {
#ifdef SE_CLASS1
        check_init();
#endif
        copy_cpu_encap_encap<encapc<dim2,T,Mem>,encapc<dim,T,Mem>> cp(ec,*this);
 
        boost::mpl::for_each_ref< boost::mpl::range_c<int,0,T::max_prop> >(cp);
 
        return *this;
    }
 
    __device__ __host__ inline encapc<dim,T,Mem> & operator=(const encapc<dim,T,Mem> & ec)
    {
#ifdef SE_CLASS1
        check_init();
#endif
        copy_cpu_encap_single<encapc<dim,T,Mem>> cp(ec,*this);
 
        boost::mpl::for_each_ref< boost::mpl::range_c<int,0,T::max_prop> >(cp);
 
        return *this;
    }
 
    __device__ __host__ inline encapc<dim,T,Mem> & operator=(const encapc<dim,T,Mem2> & ec)
    {
#ifdef SE_CLASS1
        check_init();
#endif
        copy_cpu_encap_encap_general<encapc<dim,T,Mem2>,encapc<dim,T,Mem>> cp(ec,*this);
 
        boost::mpl::for_each_ref< boost::mpl::range_c<int,0,T::max_prop> >(cp);
 
        return *this;
    }
 
    __device__  __host__ inline encapc<dim,T,Mem> & operator=(const T & obj)
    {
#ifdef SE_CLASS1
        check_init();
#endif
        copy_fusion_vector<typename T::type> cp(obj.data,data_c);
 
        boost::mpl::for_each_ref< boost::mpl::range_c<int,0,T::max_prop> >(cp);
 
        return *this;
    }
 
    inline bool operator==(const encapc<dim,T,Mem> & ec) const
    {
#ifdef SE_CLASS1
        check_init();
#endif
        compare_fusion_vector<typename T::type> cp(ec.data_c,data_c);
 
        boost::mpl::for_each_ref< boost::mpl::range_c<int,0,T::max_prop> >(cp);
 
        return cp.result();
    }
 
    inline bool operator!=(const encapc<dim,T,Mem> & ec) const
    {
#ifdef SE_CLASS1
        check_init();
#endif
        return ! this->operator==(ec);
    }
};
 
template<unsigned int dim,typename Mem>
class encapc<dim,void,Mem>
{
public:
 
    // constructor require a key and a memory data
    encapc()
    {}
 
    template <unsigned int p> void get()
    {}
 
    template <unsigned int p, typename S> void set(S & ele)
    {}
};
 
template<unsigned int dim,typename T>
class encapc<dim,T,typename memory_traits_inte<T>::type>
{
    typedef typename memory_traits_inte<T>::type Mem;
 
    typedef typename memory_traits_lin<T>::type Mem2;
 
    Mem & data;
 
    size_t k;
 
#ifdef SE_CLASS1
    bool init = false;
#endif
 
#ifdef SE_CLASS1
    __device__ __host__ void check_init() const
    {
        if (init == false)
        {
            #ifdef CUDA_ON_CPU
            std::cout << __FILE__ << ":" << __LINE__ << " Error using unallocated pointer" << std::endl;
            #else
            assert(init == true);
            #endif
        }
    }
#endif
 
public:
 
    typedef typename T::type type;
 
    typedef int yes_i_am_encap;
 
    typedef T T_type;
 
    static const int max_prop = T::max_prop;
 
#ifdef SE_CLASS1
    __device__ __host__ ~encapc()
    {init = false;}
#endif
 
    __device__ __host__ encapc(typename memory_traits_inte<T>::type & data, size_t k)
    :data(data),k(k)
    {
#ifdef SE_CLASS1
        init = true;
#endif
    }
 
    template <unsigned int p>
    __device__ __host__ auto get() -> decltype(boost::fusion::at_c<p>(data).mem_r.operator[](k))
    {
#ifdef SE_CLASS1
        check_init();
#endif
        return boost::fusion::at_c<p>(data).mem_r.operator[](k);
    }
 
    template <unsigned int p> __device__ __host__ auto get() const -> decltype(boost::fusion::at_c<p>(data).mem_r.operator[](k))
    {
#ifdef SE_CLASS1
        check_init();
#endif
        return boost::fusion::at_c<p>(data).mem_r.operator[](k);
    }
 
//    __device__ __host__ encapc(const encapc<dim,T,Mem> & ec) = delete;
    __device__ __host__ encapc(const encapc<dim,T,Mem> & ec) : data(ec.data), k(ec.k)
    {
#ifdef SE_CLASS1
        init = true;
#endif
    }
//    __device__ __host__ inline encapc<dim,T,Mem> & operator=(const encapc<dim,T,Mem> & ec) = delete; //DEBUG
 
    __device__ __host__ inline encapc<dim,T,Mem> & operator=(const encapc<dim,T,Mem> & ec)
    {
#ifdef SE_CLASS1
        check_init();
#endif
        copy_cpu_encap_single<encapc<dim,T,Mem>> cp(ec,*this);
 
        boost::mpl::for_each_ref< boost::mpl::range_c<int,0,T::max_prop> >(cp);
 
        return *this;
    }
 
    __device__ __host__ inline encapc<dim,T,Mem> & operator=(const encapc<dim,T,Mem2> & ec)
    {
#ifdef SE_CLASS1
        check_init();
#endif
        copy_cpu_encap_encap_general<encapc<dim,T,Mem2>,encapc<dim,T,Mem>> cp(ec,*this);
 
        boost::mpl::for_each_ref< boost::mpl::range_c<int,0,T::max_prop> >(cp);
 
        return *this;
    }
 
    __device__ __host__ inline encapc<dim,T,Mem> & operator=(const T & obj)
    {
#ifdef SE_CLASS1
        check_init();
#endif
        copy_fusion_vector_encap<typename T::type,decltype(*this)> cp(obj.data,*this);
 
        boost::mpl::for_each_ref< boost::mpl::range_c<int,0,T::max_prop> >(cp);
 
        return *this;
    }
 
    __device__ __host__ inline void private_set_data_k(Mem & data_c, size_t k)
    {
#ifdef SE_CLASS1
        check_init();
#endif
        this->data = data;
        this->k = k;
    }
 
    __device__ __host__ inline Mem & private_get_data()
    {
#ifdef SE_CLASS1
        check_init();
#endif
        return data;
    }
 
    __device__ __host__ inline size_t private_get_k()
    {
#ifdef SE_CLASS1
        check_init();
#endif
        return k;
    }
 
    __device__ __host__ inline size_t private_set_k(unsigned int k)
    {
#ifdef SE_CLASS1
        check_init();
#endif
        return this->k = k;
    }
};
 
#include "util/common.hpp"
 
template<typename T, typename Sfinae = void>
struct is_encap: std::false_type {};
 
 
template<typename T>
struct is_encap<T, typename Void< typename T::yes_i_am_encap>::type> : std::true_type
{};
 
 
template<unsigned int dim , typename T, typename layout, typename data_type, typename g1_type, typename key_type, unsigned int sel = 2*is_layout_mlin<layout>::value + is_layout_inte<layout>::value >
struct mem_geto
{
    __device__ __host__ static inline encapc<dim,T,typename layout::type> get(data_type & data_, const g1_type & g1, const key_type & v1)
    {
        return encapc<dim,T,typename layout::type>(data_.mem_r.operator[](g1.LinId(v1)));
    }
 
    static inline encapc<dim,T,typename layout::type> get_lin(data_type & data_, const size_t & v1)
    {
        return encapc<dim,T,typename layout::type>(data_.mem_r.operator[](v1));
    }
};
 
template<unsigned int dim, typename T,typename layout, typename data_type, typename g1_type, typename key_type>
struct mem_geto<dim,T,layout,data_type,g1_type,key_type,1>
{
    __device__ __host__ static inline encapc<dim,T,typename layout::type> get(data_type & data_, const g1_type & g1, const key_type & v1)
    {
        return encapc<dim,T,typename layout::type>(data_,g1.LinId(v1));
    }
 
    static inline encapc<dim,T,typename layout::type> get_lin(data_type & data_, const size_t & v1)
    {
        return encapc<dim,T,typename layout::type>(data_,v1);
    }
};
 
#endif /* ENCAP_HPP_ */