MPI_IBcastW.hpp

/*
 * MPI_IBcastW.hpp
 *
 *  Created on: Apr 8, 2017
 *      Author: i-bird
 */
 
#ifndef OPENFPM_VCLUSTER_SRC_MPI_WRAPPER_MPI_IBCASTW_HPP_
#define OPENFPM_VCLUSTER_SRC_MPI_WRAPPER_MPI_IBCASTW_HPP_
 
 
 
#include <mpi.h>
 
 
 
class MPI_IBcastWB
{
public:
    static inline void bcast(size_t proc ,void * buf, size_t sz, MPI_Request & req)
    {
        MPI_SAFE_CALL(MPI_Ibcast(buf,sz,MPI_BYTE, proc , MPI_COMM_WORLD,&req));
    }
};
 
template<typename T> class MPI_IBcastW
{
public:
    template<typename Memory> static inline void bcast(size_t proc ,openfpm::vector<T,Memory> & v, MPI_Request & req)
    {
        MPI_SAFE_CALL(MPI_Ibcast(v.getPointer(), v.size() * sizeof(T),MPI_BYTE, proc , MPI_COMM_WORLD,&req));
    }
};
 
 
template<> class MPI_IBcastW<int>
{
public:
    static inline void bcast(size_t proc ,openfpm::vector<int> & v, MPI_Request & req)
    {
        MPI_SAFE_CALL(MPI_Ibcast(v.getPointer(), v.size(),MPI_INT, proc , MPI_COMM_WORLD,&req));
    }
};
 
template<> class MPI_IBcastW<unsigned int>
{
public:
    static inline void bcast(size_t proc ,openfpm::vector<unsigned int> & v, MPI_Request & req)
    {
        MPI_SAFE_CALL(MPI_Ibcast(v.getPointer(), v.size(),MPI_UNSIGNED, proc , MPI_COMM_WORLD,&req));
    }
};
 
template<> class MPI_IBcastW<short>
{
public:
    static inline void bcast(size_t proc ,openfpm::vector<short> & v, MPI_Request & req)
    {
        MPI_SAFE_CALL(MPI_Ibcast(v.getPointer(), v.size(),MPI_SHORT, proc , MPI_COMM_WORLD,&req));
    }
};
 
template<> class MPI_IBcastW<unsigned short>
{
public:
    static inline void bcast(size_t proc ,openfpm::vector<unsigned short> & v, MPI_Request & req)
    {
        MPI_SAFE_CALL(MPI_Ibcast(v.getPointer(), v.size(),MPI_UNSIGNED_SHORT, proc , MPI_COMM_WORLD,&req));
    }
};
 
template<> class MPI_IBcastW<char>
{
public:
    static inline void bcast(size_t proc ,openfpm::vector<char> & v, MPI_Request & req)
    {
        MPI_SAFE_CALL(MPI_Ibcast(v.getPointer(), v.size(),MPI_CHAR, proc , MPI_COMM_WORLD,&req));
    }
};
 
template<> class MPI_IBcastW<unsigned char>
{
public:
    static inline void bcast(size_t proc ,openfpm::vector<unsigned char> & v, MPI_Request & req)
    {
        MPI_SAFE_CALL(MPI_Ibcast(v.getPointer(), v.size(),MPI_UNSIGNED_CHAR, proc , MPI_COMM_WORLD,&req));
    }
};
 
template<> class MPI_IBcastW<size_t>
{
public:
    static inline void bcast(size_t proc ,openfpm::vector<size_t> & v, MPI_Request & req)
    {
        MPI_SAFE_CALL(MPI_Ibcast(v.getPointer(), v.size(),MPI_UNSIGNED_LONG, proc , MPI_COMM_WORLD,&req));
    }
};
 
template<> class MPI_IBcastW<long int>
{
public:
    static inline void bcast(size_t proc ,openfpm::vector<long int> & v, MPI_Request & req)
    {
        MPI_SAFE_CALL(MPI_Ibcast(v.getPointer(), v.size(),MPI_LONG, proc , MPI_COMM_WORLD,&req));
    }
};
 
template<> class MPI_IBcastW<float>
{
public:
    static inline void bcast(size_t proc ,openfpm::vector<float> & v, MPI_Request & req)
    {
        MPI_SAFE_CALL(MPI_Ibcast(v.getPointer(), v.size(),MPI_FLOAT, proc , MPI_COMM_WORLD,&req));
    }
};
 
template<> class MPI_IBcastW<double>
{
public:
    static inline void bcast(size_t proc ,openfpm::vector<double> & v, MPI_Request & req)
    {
        MPI_SAFE_CALL(MPI_Ibcast(v.getPointer(), v.size(),MPI_DOUBLE, proc , MPI_COMM_WORLD,&req));
    }
};
 
 
template<typename vect>
struct bcast_inte_impl
{
    vect & send;
 
    openfpm::vector<MPI_Request> & req;
 
    size_t root;
 
    inline bcast_inte_impl(vect & send,
                           openfpm::vector<MPI_Request> & req,
                           size_t root)
    :send(send),req(req),root(root)
    {};
 
    template<typename T>
    inline void operator()(T& t)
    {
        typedef typename boost::mpl::at<typename vect::value_type::type,T>::type send_type;
 
        // Create one request
        req.add();
 
        // gather
        MPI_IBcastWB::bcast(root,&send.template get<T::value>(0),send.size()*sizeof(send_type),req.last());
    }
};
 
template<bool is_lin_or_inte>
struct b_cast_helper
{
     template<typename T, typename Mem, template<typename> class layout_base >
     static void bcast_(openfpm::vector<MPI_Request> & req,
                        openfpm::vector<T,Mem,layout_base> & v,
                        size_t root)
    {
        // Create one request
        req.add();
 
        // gather
        MPI_IBcastW<T>::bcast(root,v,req.last());
    }
};
 
template<>
struct b_cast_helper<false>
{
     template<typename T, typename Mem, template<typename> class layout_base >
     static void bcast_(openfpm::vector<MPI_Request> & req,
                        openfpm::vector<T,Mem,layout_base> & v,
                        size_t root)
    {
         bcast_inte_impl<openfpm::vector<T,Mem,layout_base>> bc(v,req,root);
 
         boost::mpl::for_each_ref<boost::mpl::range_c<int,0,T::max_prop>>(bc);
    }
};
 
#endif /* OPENFPM_VCLUSTER_SRC_MPI_WRAPPER_MPI_IBCASTW_HPP_ */