Distribution_unit_tests.hpp

/*
 * Distribution_unit_tests.hpp
 *
 *  Created on: Feb 27, 2016
 *      Author: i-bird
 */

#ifndef SRC_DECOMPOSITION_DISTRIBUTION_DISTRIBUTION_UNIT_TESTS_HPP_
#define SRC_DECOMPOSITION_DISTRIBUTION_DISTRIBUTION_UNIT_TESTS_HPP_

#include "config.h"
#include "SpaceDistribution.hpp"
#include <unistd.h>
#include "BoxDistribution.hpp"

template<unsigned int dim, typename Distribution> void setSphereComputationCosts(Distribution & dist, grid_sm<dim, void> & gr, Point<3, float> center, float radius, size_t max_l, size_t min_l)
{
    float radius2 = radius * radius;
    float eq;

    // Position structure for the single vertex
    float pos[dim];

    for (size_t i = 0; i < dist.getNSubSubDomains(); i++)
    {
        dist.getSubSubDomainPosition(i, pos);

        eq = 0;
        for (size_t j = 0; j < dim; j++)
            eq += (pos[j] - center.get(j)) * (pos[j] - center.get(j));

        if (eq <= radius2)
        {
            dist.setComputationCost(i, max_l);
            dist.setMigrationCost(i, max_l * 2);
        }
        else
        {
            dist.setComputationCost(i, min_l);
            dist.setMigrationCost(i, min_l * 2);
        }

        // set Migration cost and communication cost
        for (size_t j = 0; j < dist.getNSubSubDomainNeighbors(i); j++)
            dist.setCommunicationCost(i, j, 1);
    }
}

BOOST_AUTO_TEST_SUITE (Distribution_test)

BOOST_AUTO_TEST_CASE( Metis_distribution_test)
{
    Vcluster<> & v_cl = create_vcluster();

    if (v_cl.getProcessingUnits() != 3)
    return;


    MetisDistribution<3, float> met_dist(v_cl);

    // Cartesian grid
    size_t sz[3] = { GS_SIZE, GS_SIZE, GS_SIZE };

    // Box
    Box<3, float> box( { 0.0, 0.0, 0.0 }, { 1.0, 1.0, 1.0 });

    // Grid info
    grid_sm<3, void> info(sz);

    // Set metis on test, It fix the seed (not required if we are not testing)
    met_dist.onTest();

    // Initialize Cart graph and decompose

    met_dist.createCartGraph(info,box);
    met_dist.decompose();

    BOOST_REQUIRE_EQUAL(met_dist.get_ndec(),1ul);


    BOOST_REQUIRE(met_dist.getUnbalance() < 0.03);

    if (v_cl.getProcessUnitID() == 0)
    {met_dist.write("vtk_metis_distribution");}

    size_t b = GS_SIZE * GS_SIZE * GS_SIZE / 5;


    // Initialize the weights to 1.0
    // not required, if we set ALL Computation,Migration,Communication cost

    // Change set some weight on the graph and re-decompose

    for (size_t k = 0; k < met_dist.getNOwnerSubSubDomains(); k++)
    {
        size_t i = met_dist.getOwnerSubSubDomain(k);

        if (i == 0 || i == b || i == 2*b || i == 3*b || i == 4*b)
            met_dist.setComputationCost(i,10);
        else
            met_dist.setComputationCost(i,1);
    }

    for (size_t i = 0 ; i <  met_dist.getNSubSubDomains() ; i++)
    {
        // We also show how to set some Communication and Migration cost

        met_dist.setMigrationCost(i,1);

        for (size_t j = 0; j < met_dist.getNSubSubDomainNeighbors(i); j++)
        met_dist.setCommunicationCost(i,j,1);
    }

    met_dist.decompose();

    BOOST_REQUIRE_EQUAL(met_dist.get_ndec(),2ul);


    BOOST_REQUIRE(met_dist.getUnbalance() < 0.06);

    if (v_cl.getProcessUnitID() == 0)
    {met_dist.write("vtk_metis_distribution_red");}

    // check that match

    bool test;

    if (v_cl.getProcessUnitID() == 0)
    {
    #ifdef HAVE_OSX

        #ifndef __ARM_ARCH
            test = compare("0_vtk_metis_distribution.vtk", "src/Decomposition/Distribution/test_data/vtk_metis_distribution_osx_test.vtk");
            BOOST_REQUIRE_EQUAL(true,test);
            test = compare("0_vtk_metis_distribution_red.vtk","src/Decomposition/Distribution/test_data/vtk_metis_distribution_red_osx_test.vtk");
            BOOST_REQUIRE_EQUAL(true,test);
        #endif

    #elif __GNUC__ == 6 && __GNUC_MINOR__ == 3

        test = compare("0_vtk_metis_distribution.vtk", "src/Decomposition/Distribution/test_data/vtk_metis_distribution_test.vtk");
        BOOST_REQUIRE_EQUAL(true,test);
        test = compare("0_vtk_metis_distribution_red.vtk","src/Decomposition/Distribution/test_data/vtk_metis_distribution_red_test.vtk");
        BOOST_REQUIRE_EQUAL(true,test);

    #endif
    }

    // Copy the Metis distribution

    MetisDistribution<3, float> met_dist2(v_cl);

    met_dist2 = met_dist;

    test = (met_dist2 == met_dist);

    BOOST_REQUIRE_EQUAL(test,true);

    // We fix the size of MetisDistribution if you are gointg to change this number
    // please check the following
    // duplicate functions
    // swap functions
    // Copy constructors
    // operator= functions
    // operator== functions

//  BOOST_REQUIRE_EQUAL(sizeof(MetisDistribution<3,float>),720ul);
}

BOOST_AUTO_TEST_CASE( Parmetis_distribution_test)
{
    Vcluster<> & v_cl = create_vcluster();

    if (v_cl.getProcessingUnits() != 3)
    return;


    ParMetisDistribution<3, float> pmet_dist(v_cl);

    // Physical domain
    Box<3, float> box( { 0.0, 0.0, 0.0 }, { 10.0, 10.0, 10.0 });

    // Grid info
    grid_sm<3, void> info( { GS_SIZE, GS_SIZE, GS_SIZE });

    // Initialize Cart graph and decompose
    pmet_dist.createCartGraph(info,box);

    // First create the center of the weights distribution, check it is coherent to the size of the domain
    Point<3, float> center( { 2.0, 2.0, 2.0 });

    // It produces a sphere of radius 2.0
    // with high computation cost (5) inside the sphere and (1) outside
    setSphereComputationCosts(pmet_dist, info, center, 2.0f, 5ul, 1ul);

    // first decomposition
    pmet_dist.decompose();

    BOOST_REQUIRE_EQUAL(pmet_dist.get_ndec(),1ul);


    if (v_cl.getProcessUnitID() == 0)
    {
        // write the first decomposition
        pmet_dist.write("vtk_parmetis_distribution_0");

#ifdef HAVE_OSX

        #ifndef __ARM_ARCH
        bool test = compare(std::to_string(v_cl.getProcessUnitID()) + "_vtk_parmetis_distribution_0.vtk","src/Decomposition/Distribution/test_data/" + std::to_string(v_cl.getProcessUnitID()) + "_vtk_parmetis_distribution_0_osx_test.vtk");
        BOOST_REQUIRE_EQUAL(true,test);
        #endif

#else

        bool test = compare(std::to_string(v_cl.getProcessUnitID()) + "_vtk_parmetis_distribution_0.vtk","src/Decomposition/Distribution/test_data/" + std::to_string(v_cl.getProcessUnitID()) + "_vtk_parmetis_distribution_0_test.vtk");
        BOOST_REQUIRE_EQUAL(true,test);

#endif
    }


    float stime = 0.0, etime = 10.0, tstep = 0.1;

    // Shift of the sphere at each iteration
    Point<3, float> shift( { tstep, tstep, tstep });

    size_t iter = 1;
    size_t n_dec = 1;

    for(float t = stime; t < etime; t = t + tstep, iter++)
    {
        if(t < etime/2)
        center += shift;
        else
        center -= shift;

        setSphereComputationCosts(pmet_dist, info, center, 2.0f, 5, 1);

        // With some regularity refine and write the parmetis distribution
        if ((size_t)iter % 10 == 0)
        {
            pmet_dist.refine();
            n_dec++;
            BOOST_REQUIRE_EQUAL(pmet_dist.get_ndec(),n_dec);

            if (v_cl.getProcessUnitID() == 0)
            {
                std::stringstream str;
                str << "vtk_parmetis_distribution_" << iter;
                pmet_dist.write(str.str());

#ifdef HAVE_OSX

                #ifndef __ARM_ARCH
                // Check
                bool test = compare(std::to_string(v_cl.getProcessUnitID()) + "_" + str.str() + ".vtk", "src/Decomposition/Distribution/test_data/" + std::to_string(v_cl.getProcessUnitID()) + "_" + str.str() + "_osx_test.vtk");
                BOOST_REQUIRE_EQUAL(true,test);
                #endif

#else

                // Check
                bool test = compare(std::to_string(v_cl.getProcessUnitID()) + "_" + str.str() + ".vtk", "src/Decomposition/Distribution/test_data/" + std::to_string(v_cl.getProcessUnitID()) + "_" + str.str() + "_test.vtk");
                BOOST_REQUIRE_EQUAL(true,test);

#endif
            }
        }
    }


//  BOOST_REQUIRE_EQUAL(sizeof(ParMetisDistribution<3,float>),872ul);
}

BOOST_AUTO_TEST_CASE( DistParmetis_distribution_test)
{
    Vcluster<> & v_cl = create_vcluster();

    if (v_cl.getProcessingUnits() != 3)
        return;


    DistParMetisDistribution<3, float> pmet_dist(v_cl);

    // Physical domain
    Box<3, float> box( { 0.0, 0.0, 0.0 }, { 10.0, 10.0, 10.0 });

    // Grid info
    grid_sm<3, void> info( { GS_SIZE, GS_SIZE, GS_SIZE });

    // Initialize Cart graph and decompose
    pmet_dist.createCartGraph(info,box);

    // First create the center of the weights distribution, check it is coherent to the size of the domain
    Point<3, float> center( { 2.0, 2.0, 2.0 });

    // It produces a sphere of radius 2.0
    // with high computation cost (5) inside the sphere and (1) outside
    setSphereComputationCosts(pmet_dist, info, center, 2.0f, 5ul, 1ul);

    // first decomposition
    pmet_dist.decompose();


    // write the first decomposition
    pmet_dist.write("vtk_dist_parmetis_distribution_0");

    // Check
    if (v_cl.getProcessUnitID() == 0)
    {

    #ifdef HAVE_OSX

        #ifndef __ARM_ARCH
        bool test = compare("vtk_dist_parmetis_distribution_0.vtk","src/Decomposition/Distribution/test_data/vtk_dist_parmetis_distribution_0_osx_test.vtk");
        BOOST_REQUIRE_EQUAL(true,test);
        #endif

    #else

        bool test = compare("vtk_dist_parmetis_distribution_0.vtk","src/Decomposition/Distribution/test_data/vtk_dist_parmetis_distribution_0_test.vtk");
        BOOST_REQUIRE_EQUAL(true,test);

    #endif

    }


    float stime = 0.0, etime = 10.0, tstep = 0.1;

    // Shift of the sphere at each iteration
    Point<3, float> shift( { tstep, tstep, tstep });

    size_t iter = 1;

    for(float t = stime; t < etime; t = t + tstep, iter++)
    {
        if(t < etime/2)
        center += shift;
        else
        center -= shift;

        setSphereComputationCosts(pmet_dist, info, center, 2.0f, 5, 1);

        // With some regularity refine and write the parmetis distribution
        if ((size_t)iter % 10 == 0)
        {
            pmet_dist.refine();

            std::stringstream str;
            str << "vtk_dist_parmetis_distribution_" << iter;
            pmet_dist.write(str.str());

            // Check
            if (v_cl.getProcessUnitID() == 0)
            {
#ifdef HAVE_OSX

                #ifndef __ARM_ARCH
                bool test = compare(str.str() + ".vtk",std::string("src/Decomposition/Distribution/test_data/") + str.str() + "_osx_test.vtk");
                BOOST_REQUIRE_EQUAL(true,test);
                #endif

#else

                bool test = compare(str.str() + ".vtk",std::string("src/Decomposition/Distribution/test_data/") + str.str() + "_test.vtk");
                BOOST_REQUIRE_EQUAL(true,test);

#endif

            }
        }
    }

}

BOOST_AUTO_TEST_CASE( Space_distribution_test)
{
    Vcluster<> & v_cl = create_vcluster();

    if (v_cl.getProcessingUnits() != 3)
        return;


    SpaceDistribution<3, float> space_dist(v_cl);

    // Physical domain
    Box<3, float> box( { 0.0, 0.0, 0.0 }, { 10.0, 10.0, 10.0 });

    // Grid info
    grid_sm<3, void> info( { 17, 17, 17 });

    // Initialize Cart graph and decompose
    space_dist.createCartGraph(info,box);

    // first decomposition
    space_dist.decompose();


    if (v_cl.getProcessUnitID() == 0)
    {
        // write the first decomposition
        space_dist.write("vtk_dist_space_distribution_0");

        bool test = compare(std::to_string(v_cl.getProcessUnitID()) + "_vtk_dist_space_distribution_0.vtk","src/Decomposition/Distribution/test_data/" + std::to_string(v_cl.getProcessUnitID()) + + "_vtk_dist_space_distribution_0_test.vtk");
        BOOST_REQUIRE_EQUAL(true,test);
    }

}


BOOST_AUTO_TEST_CASE( Box_distribution_test)
{
    Vcluster<> & v_cl = create_vcluster();

    if (v_cl.size() > 16)
    {return;}


    BoxDistribution<3, float> box_dist(v_cl);

    // Physical domain
    Box<3, float> box( { 0.0, 0.0, 0.0 }, { 10.0, 10.0, 10.0 });

    // Grid info
    grid_sm<3, void> info( { GS_SIZE, GS_SIZE, GS_SIZE });

    // Initialize Cart graph and decompose
    box_dist.createCartGraph(info,box);

    // First create the center of the weights distribution, check it is coherent to the size of the domain
    Point<3, float> center( { 2.0, 2.0, 2.0 });

    // first decomposition
    box_dist.decompose();

    BOOST_REQUIRE_EQUAL(box_dist.get_ndec(),0ul);

    auto & graph = box_dist.getGraph();

    for (int i = 0 ; i < graph.getNVertex() ; i++)
    {
        BOOST_REQUIRE(graph.vertex(i).template get<nm_v_proc_id>() < v_cl.size());
    }

    size_t n_sub = box_dist.getNOwnerSubSubDomains();

    size_t n_sub_tot = info.size();
    size_t n_sub_bal = n_sub_tot / v_cl.size();

    BOOST_REQUIRE( (((int)n_sub_bal - 64) <= (long int)n_sub) && (n_sub_bal + 64 >= n_sub) );


//  BOOST_REQUIRE_EQUAL(sizeof(ParMetisDistribution<3,float>),872ul);
}

BOOST_AUTO_TEST_SUITE_END()

#endif /* SRC_DECOMPOSITION_DISTRIBUTION_DISTRIBUTION_UNIT_TESTS_HPP_ */