DistGraphFactory.hpp

/*
 * DistGraphFactory.hpp
 *
 *  Created on: Dec 03, 2015
 *      Author: Antonio Leo
 */
 
#ifndef DISTGRAPHFACTORYOLD_HPP_
#define DISTGRAPHFACTORYOLD_HPP_
 
#include "VCluster/VCluster.hpp"
#include "Vector/map_vector.hpp"
#include "Graph/map_graph.hpp"
#include "Grid/grid_sm.hpp"
#include "Space/Shape/Box.hpp"
#include "Space/Shape/HyperCube.hpp"
#include "parmetis.h"
 
template<unsigned int dim, typename dT, typename G_v, typename v, int impl>
class fill_prop_v
{
    const dT (&szd)[dim];
 
    grid_key_dx<dim> & gk;
 
    G_v & g_v;
 
    const grid_sm<dim, void> & gs;
 
public:
 
    fill_prop_v(G_v & g_v, const dT (&szd)[dim], grid_key_dx<dim> & gk, const grid_sm<dim, void> & gs) :
            szd(szd), gk(gk), g_v(g_v), gs(gs)
    {
    }
 
    template<typename T>
    void operator()(T& t) const
    {
        typedef typename boost::fusion::result_of::at<v, boost::mpl::int_<T::value>>::type t_val;
 
        g_v.template get<t_val::value>() = gk.get(T::value) * szd[T::value];
    }
};
 
 
template<unsigned int dim, typename dT, typename G_v, typename v>
class fill_prop_v<dim, dT, G_v, v, 0>
{
 
public:
 
    fill_prop_v(G_v & g_v, const dT (&szd)[dim], grid_key_dx<dim> & gk, const grid_sm<dim, void> & gs)
    {
    }
 
    template<typename T>
    void operator()(T& t) const
    {
    }
};
 
template<unsigned int dim, typename dT, typename G_v, typename v>
class fill_prop_v<dim, dT, G_v, v, 2>
{
 
    const dT (&szd)[dim];
 
    grid_key_dx<dim> & gk;
 
    G_v & g_v;
 
    const grid_sm<dim, void> & gs;
 
public:
 
    fill_prop_v(G_v & g_v, const dT (&szd)[dim], grid_key_dx<dim> & gk, const grid_sm<dim, void> & gs)
    :szd(szd), gk(gk), g_v(g_v), gs(gs)
    {
    }
 
    template<typename T>
    void operator()(T& t) const
    {
        typedef typename boost::fusion::result_of::at<v, boost::mpl::int_<0>>::type t_val;
        typedef typename boost::mpl::at<typename G_v::T_type::type,t_val>::type s_type;
 
        for (size_t i = 0 ; i < std::extent<s_type>::value ; i++)
            g_v.template get<t_val::value>()[i] = 0.0;
 
        for (size_t i = 0 ; i < dim ; i++)
            g_v.template get<t_val::value>()[i] = gk.get(i) * static_cast<float>(szd[i]);
    }
};
 
template<int i, typename p, typename Graph, int ... pos>
struct fill_prop_v_by_type
{
 
    typedef typename boost::mpl::at<p, boost::mpl::int_<0>>::type v_element;
    typedef typename boost::mpl::at<typename Graph::V_type::type, v_element>::type pos_prop_type;
 
    enum
    {
        value = ((sizeof...(pos) != 0) * (std::is_array<pos_prop_type>::value + 1))
    };
 
};
 
template<typename p, typename Graph, int ... pos>
struct fill_prop_v_by_type<0, p, Graph, pos...>
{
    enum
    {
        value = 0
    };
 
};
 
template<unsigned int dim, typename Graph, int se, typename T, unsigned int dim_c, int ... pos>
class DistGraph_constr_impl
{
public:
    static Graph construct(const size_t (&sz)[dim], Box<dim, T> dom)
    {
        Vcluster<> &v_cl = create_vcluster();
 
        // Calculate the size of the hyper-cubes on each dimension
        T szd[dim];
 
        for (size_t i = 0; i < dim; i++)
        {
            szd[i] = (dom.getHigh(i) - dom.getLow(i)) / sz[i];
        }
 
 
        HyperCube<dim> hc;
 
        // Construct a grid info
 
        grid_sm<dim, void> g(sz);
 
        size_t p_id = v_cl.getProcessUnitID();
 
        size_t Np = v_cl.getProcessingUnits();
 
        size_t mod_v = g.size() % Np;
        size_t div_v = g.size() / Np;
 
        openfpm::vector<idx_t> vtxdist(v_cl.getProcessingUnits() + 1);
 
        for (int i = 0; i <= Np; i++)
        {
            if (i < mod_v)
                vtxdist.get(i) = (div_v + 1) * (i);
            else
                vtxdist.get(i) = (div_v) * (i) + mod_v;
        }
 
        size_t gp_size = vtxdist.get(p_id + 1) - vtxdist.get(p_id);
 
        Graph gp(gp_size);
 
        gp.initDistributionVector(vtxdist);
 
        /******************
         *
         * Create the edges and fill spatial
         * information properties
         *
         ******************/
 
        grid_key_dx_iterator<dim> k_it(g);
 
        size_t local_it = 0;
 
 
        while (k_it.isNext())
        {
            size_t v_id = g.LinId(k_it.get());
 
            if (v_id < vtxdist.get(p_id + 1) && v_id >= vtxdist.get(p_id))
            {
 
                grid_key_dx<dim> key = k_it.get();
 
                // Vertex object
 
                auto obj = gp.vertex(local_it);
 
                typedef typename to_boost_vmpl<pos...>::type p;
 
                // vertex spatial properties functor
 
                fill_prop_v<dim, T, decltype(gp.vertex(local_it)), typename to_boost_vmpl<pos...>::type, fill_prop_v_by_type<sizeof...(pos), p, Graph, pos...>::value> flp(obj, szd, key, g);
 
                // fill properties
 
                boost::mpl::for_each<boost::mpl::range_c<int, 0, sizeof...(pos)> >(flp);
 
                // set map global to local in the graph, needed because vertex is already created without addVertex method
 
                gp.setGlobalMap(v_id, local_it, v_id);
 
                // Get the combinations of dimension d
 
                for (size_t d = dim - 1; d >= dim_c; d--)
                {
                    // create the edges for that dimension
 
                    std::vector<comb<dim>> c = hc.getCombinations_R(d);
 
                    // for each combination calculate a safe linearization and create an edge
 
                    for (size_t j = 0; j < c.size(); j++)
                    {
                        // Calculate the element size
 
                        T ele_sz = 0;
 
                        // for each dimension multiply and reduce
 
                        for (size_t s = 0; s < dim; s++)
                        {
                            ele_sz += szd[s] * abs(c[j][s]);
                        }
 
                        // Calculate the end point vertex id
                        // Calculate the start point id
 
                        size_t start_v = local_it;
                        size_t end_v = g.template LinId<CheckExistence>(key, c[j].getComb());
 
                        // check if the end_v is valid globally
                        if (end_v < g.size())
                        {
                            // Add an edge and set the the edge property to the size of the face (communication weight)
                            gp.template addEdge<NoCheck>(start_v, end_v).template get<se>() = ele_sz;
                        }
                    }
                }
                ++local_it;
            }
            ++k_it;
        }
 
        return gp;
    }
};
 
template<unsigned int dim, typename Graph, typename T, unsigned int dim_c, int ... pos>
class DistGraph_constr_impl<dim, Graph, NO_EDGE, T, dim_c, pos...>
{
public:
    static Graph construct(const size_t (&sz)[dim], Box<dim, T> dom)
    {
        Vcluster<> &v_cl = create_vcluster();
 
        // Calculate the size of the hyper-cubes on each dimension
 
        T szd[dim];
 
        for (size_t i = 0; i < dim; i++)
        {
            szd[i] = (dom.getHigh(i) - dom.getLow(i)) / sz[i];
        }
 
 
        HyperCube<dim> hc;
 
        // Construct a grid info
 
        grid_sm<dim, void> g(sz);
 
        size_t p_id = v_cl.getProcessUnitID();
 
        size_t Np = v_cl.getProcessingUnits();
 
        size_t mod_v = g.size() % Np;
        size_t div_v = g.size() / Np;
 
        openfpm::vector<idx_t> vtxdist(v_cl.getProcessingUnits() + 1);
 
        for (size_t i = 0; i <= Np; i++)
        {
            if (i < mod_v)
                vtxdist.get(i) = (div_v + 1) * (i);
            else
                vtxdist.get(i) = (div_v) * (i) + mod_v;
        }
 
        size_t gp_size = vtxdist.get(p_id + 1) - vtxdist.get(p_id);
 
        Graph gp(gp_size);
 
        gp.initDistributionVector(vtxdist);
 
        /******************
         *
         * Create the edges and fill spatial
         * information properties
         *
         ******************/
 
        grid_key_dx_iterator<dim> k_it(g);
 
        size_t local_it = 0;
 
 
        while (k_it.isNext())
        {
            size_t v_id = g.LinId(k_it.get());
 
            if (v_id < (size_t)vtxdist.get(p_id + 1) && v_id >= (size_t)vtxdist.get(p_id))
            {
                grid_key_dx<dim> key = k_it.get();
 
                // Vertex object
                auto obj = gp.vertex(local_it);
 
                typedef typename to_boost_vmpl<pos...>::type p;
 
                // vertex spatial properties functor
 
                fill_prop_v<dim, T, decltype(gp.vertex(local_it)), typename to_boost_vmpl<pos...>::type, fill_prop_v_by_type<sizeof...(pos), p, Graph, pos...>::value> flp(obj, szd, key, g);
 
                // fill properties
 
                boost::mpl::for_each<boost::mpl::range_c<int, 0, sizeof...(pos)> >(flp);
 
                // set map global to local in the graph, needed because vertex is already created without addVertex method
 
                gp.setGlobalMap(v_id, local_it, v_id);
 
                // Get the combinations of dimension d
 
                for (size_t d = dim - 1; d >= dim_c; d--)
                {
                    // create the edges for that dimension
 
                    std::vector<comb<dim>> c = hc.getCombinations_R(d);
 
                    // for each combination calculate a safe linearization and create an edge
 
                    for (size_t j = 0; j < c.size(); j++)
                    {
                        // Calculate the element size
 
                        T ele_sz = 0;
 
                        // for each dimension multiply and reduce
 
                        for (size_t s = 0; s < dim; s++)
                        {
                            ele_sz += szd[s] * abs(c[j][s]);
                        }
 
                        // Calculate the end point vertex id
                        // Calculate the start point id
 
                        size_t start_v = local_it;
                        size_t end_v = g.template LinId<CheckExistence>(key, c[j].getComb());
 
                        // check if the end_v is valid globally
                        if (end_v < g.size())
                        {
                            // Add an edge and set the the edge property to the size of the face (communication weight)
                            gp.addEdge(start_v, end_v, v_id, end_v);
                        }
                    }
                }
                ++local_it;
            }
            ++k_it;
        }
        return gp;
    }
};
 
template<unsigned int dim, typename Graph>
class DistGraphFactory
{
 
public:
 
    template<int se, typename T, unsigned int dim_c, int ... pos>
    static Graph construct(const size_t (&sz)[dim], Box<dim, T> dom)
    {
        return DistGraph_constr_impl<dim, Graph, se, T, dim_c, pos...>::construct(sz, dom);
    }
};
 
#endif /* DISTGRAPHFACTORY_HPP_ */