vector_dist_dlb_test.hpp

/*
 * vector_dist_dlb_test.hpp
 *
 *  Created on: Feb 21, 2017
 *      Author: i-bird
 */
 
#ifndef SRC_VECTOR_VECTOR_DIST_DLB_TEST_HPP_
#define SRC_VECTOR_VECTOR_DIST_DLB_TEST_HPP_
 
#include "DLB/LB_Model.hpp"
#include "Vector/vector_dist.hpp"
 
BOOST_AUTO_TEST_SUITE( vector_dist_dlb_test )
 
template<typename vector_type>
void mp_test_template(vector_type & vd0, vector_type & vd1, vector_type & vd2, vector_type & vd3)
{
    Vcluster<> & v_cl = create_vcluster();
 
    // Only processor 0 initialy add particles on a corner of a domain
 
    if (v_cl.getProcessUnitID() == 0)
    {
        for(size_t i = 0 ; i < 50000 ; i++)
        {
            vd0.add();
            vd1.add();
            vd2.add();
            vd3.add();
 
            // coverty[dont_call]
            vd0.getLastPos()[0] = ((float)rand())/RAND_MAX * 0.3;
            // coverty[dont_call]
            vd0.getLastPos()[1] = ((float)rand())/RAND_MAX * 0.3;
            // coverty[dont_call]
            vd0.getLastPos()[2] = ((float)rand())/RAND_MAX * 0.3;
 
            // coverty[dont_call]
            vd1.getLastPos()[0] = ((float)rand())/RAND_MAX * 0.3 + 0.1;
            // coverty[dont_call]
            vd1.getLastPos()[1] = ((float)rand())/RAND_MAX * 0.3 + 0.1;
            // coverty[dont_call]
            vd1.getLastPos()[2] = ((float)rand())/RAND_MAX * 0.3 + 0.1;
 
            // coverty[dont_call]
            vd2.getLastPos()[0] = ((float)rand())/RAND_MAX * 0.3 + 0.2;
            // coverty[dont_call]
            vd2.getLastPos()[1] = ((float)rand())/RAND_MAX * 0.3 + 0.2;
            // coverty[dont_call]
            vd2.getLastPos()[2] = ((float)rand())/RAND_MAX * 0.3 + 0.2;
 
            // coverty[dont_call]
            vd3.getLastPos()[0] = ((float)rand())/RAND_MAX * 0.3 + 0.3;
            // coverty[dont_call]
            vd3.getLastPos()[1] = ((float)rand())/RAND_MAX * 0.3 + 0.3;
            // coverty[dont_call]
            vd3.getLastPos()[2] = ((float)rand())/RAND_MAX * 0.3 + 0.3;
        }
    }
 
    vd0.map();
    vd0.template ghost_get<>();
    vd1.map();
    vd1.template ghost_get<>();
    vd2.map();
    vd2.template ghost_get<>();
    vd3.map();
    vd3.template ghost_get<>();
 
    ModelSquare md;
    md.factor = 1;
    vd0.initializeComputationCosts();
    vd0.addComputationCosts(vd0,md);
    vd0.addComputationCosts(vd1,md);
    vd0.addComputationCosts(vd2,md);
    vd0.addComputationCosts(vd3,md);
    vd0.finalizeComputationCosts();
 
    vd0.getDecomposition().decompose();
 
    // Copy the decomposition back to the other
    vd1.getDecomposition() = vd0.getDecomposition();
    vd2.getDecomposition() = vd0.getDecomposition();
    vd3.getDecomposition() = vd0.getDecomposition();
 
    vd0.map();
    vd1.map();
    vd2.map();
    vd3.map();
 
    vd0.initializeComputationCosts();
    vd0.addComputationCosts(vd0,md);
    vd0.addComputationCosts(vd1,md);
    vd0.addComputationCosts(vd2,md);
    vd0.addComputationCosts(vd3,md);
    vd0.finalizeComputationCosts();
 
    openfpm::vector<size_t> loads;
    size_t load = vd0.getDecomposition().getDistribution().getProcessorLoad();
    v_cl.allGather(load,loads);
    v_cl.execute();
 
    for (size_t i = 0 ; i < loads.size() ; i++)
    {
        float load_f = load;
        float load_fc = loads.get(i);
 
        BOOST_REQUIRE_CLOSE(load_f,load_fc,7.0);
    }
 
    Point<3,float> v({1.0,1.0,1.0});
 
    for (size_t i = 0 ; i < 25 ; i++)
    {
        // move the particles by 0.1
 
        {
        auto it = vd0.getDomainIterator();
 
        while (it.isNext())
        {
            auto p = it.get();
 
            vd0.getPos(p)[0] += v.get(0) * 0.09;
            vd0.getPos(p)[1] += v.get(1) * 0.09;
            vd0.getPos(p)[2] += v.get(2) * 0.09;
 
            ++it;
        }
        }
 
        {
        auto it = vd1.getDomainIterator();
        while (it.isNext())
        {
            auto p = it.get();
 
            vd1.getPos(p)[0] += v.get(0) * 0.06;
            vd1.getPos(p)[1] += v.get(1) * 0.06;
            vd1.getPos(p)[2] += v.get(2) * 0.06;
 
            ++it;
        }
        }
 
        {
        auto it = vd2.getDomainIterator();
        while (it.isNext())
        {
            auto p = it.get();
 
            vd2.getPos(p)[0] += v.get(0) * 0.06;
            vd2.getPos(p)[1] += v.get(1) * 0.06;
            vd2.getPos(p)[2] += v.get(2) * 0.06;
 
            ++it;
        }
        }
 
        {
        auto it = vd3.getDomainIterator();
        while (it.isNext())
        {
            auto p = it.get();
 
            vd3.getPos(p)[0] += v.get(0) * 0.06;
            vd3.getPos(p)[1] += v.get(1) * 0.06;
            vd3.getPos(p)[2] += v.get(2) * 0.06;
 
            ++it;
        }
        }
 
        vd0.map();
        vd1.map();
        vd2.map();
        vd3.map();
 
        ModelSquare md;
        vd0.initializeComputationCosts();
        vd0.addComputationCosts(vd0,md);
        vd0.addComputationCosts(vd1,md);
        vd0.addComputationCosts(vd2,md);
        vd0.addComputationCosts(vd3,md);
        vd0.finalizeComputationCosts();
 
        vd0.getDecomposition().redecompose(200);
 
        // Copy the decomposition back to the other
        vd1.getDecomposition() = vd0.getDecomposition();
        vd2.getDecomposition() = vd0.getDecomposition();
        vd3.getDecomposition() = vd0.getDecomposition();
        vd0.map();
        vd1.map();
        vd2.map();
        vd3.map();
 
        vd0.template ghost_get<>();
        vd1.template ghost_get<>();
        vd2.template ghost_get<>();
        vd3.template ghost_get<>();
 
        vd0.initializeComputationCosts();
        vd0.addComputationCosts(vd0,md);
        vd0.addComputationCosts(vd1,md);
        vd0.addComputationCosts(vd2,md);
        vd0.addComputationCosts(vd3,md);
        vd0.finalizeComputationCosts();
 
        openfpm::vector<size_t> loads;
        size_t load = vd0.getDecomposition().getDistribution().getProcessorLoad();
        v_cl.allGather(load,loads);
        v_cl.execute();
 
        for (size_t i = 0 ; i < loads.size() ; i++)
        {
            float load_f = load;
            float load_fc = loads.get(i);
 
            BOOST_REQUIRE_CLOSE(load_f,load_fc,10.0);
        }
    }
}
 
template<typename vector_type> void test_dlb_vector()
{
    Vcluster<> & v_cl = create_vcluster();
 
    if (v_cl.getProcessingUnits() > 8)
        return;
 
    Box<3,double> domain({0.0,0.0,0.0},{1.0,1.0,1.0});
    Ghost<3,double> g(0.1);
    size_t bc[3] = {PERIODIC,PERIODIC,PERIODIC};
 
    vector_type vd(0,domain,bc,g,DEC_GRAN(2048));
 
    // Only processor 0 initialy add particles on a corner of a domain
 
    if (v_cl.getProcessUnitID() == 0)
    {
        for(size_t i = 0 ; i < 50000 ; i++)
        {
            vd.add();
 
            vd.getLastPos()[0] = ((double)rand())/RAND_MAX * 0.3;
            vd.getLastPos()[1] = ((double)rand())/RAND_MAX * 0.3;
            vd.getLastPos()[2] = ((double)rand())/RAND_MAX * 0.3;
        }
    }
 
    vd.map();
    vd.template ghost_get<>();
 
    // Get the neighborhood of each particles
 
    auto VV = vd.getVerlet(0.01);
 
    // store the number of neighborhood for each particles
 
    auto it = vd.getDomainIterator();
 
    while (it.isNext())
    {
        auto p = it.get();
 
        vd.template getProp<0>(p) = VV.getNNPart(p.getKey());
 
        ++it;
    }
 
    ModelSquare md;
    md.factor = 10;
    vd.map();
 
    vd.addComputationCosts(md);
    vd.getDecomposition().decompose();
    vd.map();
 
    vd.addComputationCosts(md);
 
    openfpm::vector<size_t> loads;
    size_t load = vd.getDecomposition().getDistribution().getProcessorLoad();
    v_cl.allGather(load,loads);
    v_cl.execute();
 
    for (size_t i = 0 ; i < loads.size() ; i++)
    {
        double load_f = load;
        double load_fc = loads.get(i);
 
        BOOST_REQUIRE_CLOSE(load_f,load_fc,7.0);
    }
 
    BOOST_REQUIRE(vd.size_local() != 0);
 
    Point<3,double> v({1.0,1.0,1.0});
 
    for (size_t i = 0 ; i < 25 ; i++)
    {
        // move the particles by 0.1
 
        auto it = vd.getDomainIterator();
 
        while (it.isNext())
        {
            auto p = it.get();
 
            vd.getPos(p)[0] += v.get(0) * 0.09;
            vd.getPos(p)[1] += v.get(1) * 0.09;
            vd.getPos(p)[2] += v.get(2) * 0.09;
 
            ++it;
        }
 
        vd.map();
 
        vd.template ghost_get<>();
 
        auto VV2 = vd.getVerlet(0.01);
 
        auto it2 = vd.getDomainIterator();
 
        bool match = true;
        while (it2.isNext())
        {
            auto p = it2.get();
 
            match &= vd.template getProp<0>(p) == VV2.getNNPart(p.getKey());
 
            ++it2;
        }
 
        BOOST_REQUIRE_EQUAL(match,true);
 
        ModelSquare md;
        vd.addComputationCosts(md);
        vd.getDecomposition().redecompose(200);
        vd.map();
 
        BOOST_REQUIRE(vd.size_local() != 0);
 
        vd.template ghost_get<>();
 
        vd.addComputationCosts(md);
 
        openfpm::vector<size_t> loads;
        size_t load = vd.getDecomposition().getDistribution().getProcessorLoad();
        v_cl.allGather(load,loads);
        v_cl.execute();
 
        for (size_t i = 0 ; i < loads.size() ; i++)
        {
            double load_f = load;
            double load_fc = loads.get(i);
 
            BOOST_REQUIRE_CLOSE(load_f,load_fc,10.0);
        }
    }
}
 
 
template<typename vector_type> void test_dlb_multi_phase_vector()
{
    Vcluster<> & v_cl = create_vcluster();
 
    if (v_cl.getProcessingUnits() > 8)
        return;
 
    Box<3,float> domain({0.0,0.0,0.0},{1.0,1.0,1.0});
    Ghost<3,float> g(0.1);
    size_t bc[3] = {PERIODIC,PERIODIC,PERIODIC};
 
    vector_type vd0(0,domain,bc,g,DEC_GRAN(2048));
    vector_type vd1(0,domain,bc,g,DEC_GRAN(2048));
    vector_type vd2(0,domain,bc,g,DEC_GRAN(2048));
    vector_type vd3(0,domain,bc,g,DEC_GRAN(2048));
 
    mp_test_template(vd0,vd1,vd2,vd3);
}
 
 
 
template<typename vector_type> void test_dlb_multi_phase_v_vector()
{
    Vcluster<> & v_cl = create_vcluster();
 
    if (v_cl.getProcessingUnits() > 8)
        return;
 
    Box<3,float> domain({0.0,0.0,0.0},{1.0,1.0,1.0});
    Ghost<3,float> g(0.1);
    size_t bc[3] = {PERIODIC,PERIODIC,PERIODIC};
 
    openfpm::vector<vector_type> v_phases;
    {
        vector_type vd0(0,domain,bc,g,DEC_GRAN(2048));
        v_phases.add(vd0);
        v_phases.add(vector_type(vd0.getDecomposition(),0));
        v_phases.add(vector_type(vd0.getDecomposition(),0));
        v_phases.add(vector_type(vd0.getDecomposition(),0));
    }
 
    auto & vd0 = v_phases.get(0);
    auto & vd1 = v_phases.get(1);
    auto & vd2 = v_phases.get(2);
    auto & vd3 = v_phases.get(3);
 
    mp_test_template(vd0,vd1,vd2,vd3);
}
 
BOOST_AUTO_TEST_CASE( vector_dist_dlb )
{
    test_dlb_vector<vector_dist<3,double,aggregate<double>>>();
}
 
BOOST_AUTO_TEST_CASE( vector_dist_dlb_multi_phase_test_part )
{
    test_dlb_multi_phase_vector<vector_dist<3,float,aggregate<float>>>();
}
 
BOOST_AUTO_TEST_CASE( vector_dist_dlb_multi_phase_v_test_part )
{
    test_dlb_multi_phase_v_vector<vector_dist<3,float,aggregate<float>>>();
}
 
BOOST_AUTO_TEST_CASE( vector_dist_dlb_metis_test_part )
{
    test_dlb_vector<vector_dist<3,
                                double,
                                aggregate<double>,
                                CartDecomposition<3,double,HeapMemory,memory_traits_lin,MetisDistribution<3,double>>>>();
}
 
BOOST_AUTO_TEST_SUITE_END()
 
#endif /* SRC_VECTOR_VECTOR_DIST_DLB_TEST_HPP_ */