verlet_performance_tests.hpp

/*
 * vector_dist_verlet_performance_tests.hpp
 *
 *  Created on: Mar 9, 2016
 *      Author: Yaroslav Zaluzhnyi
 */
 
#ifndef SRC_VECTOR_VECTOR_DIST_VERLET_PERFORMANCE_TESTS_HPP_
#define SRC_VECTOR_VECTOR_DIST_VERLET_PERFORMANCE_TESTS_HPP_
 
#include "util/stat/common_statistics.hpp"
 
// Property tree
struct report_verlet_tests
{
    boost::property_tree::ptree graphs;
};
 
report_verlet_tests report_vl;
 
void print_test_v(std::string test, size_t sz)
{
    if (create_vcluster().getProcessUnitID() == 0)
        std::cout << test << " " << sz << "\n";
}
 
BOOST_AUTO_TEST_SUITE( verletlist_performance_test )
 
 
 
// Cut-off radiuses. Can be put different number of values
openfpm::vector<float> r_cutoff {0.004, 0.007, 0.01};
// Orders of a curve. Can be put different number of values
// The starting amount of particles (remember that this number is multiplied by number of processors you use for testing)
size_t k_start = 100000;
// The minimal amount of particles
size_t k_min = 15000;
// Ghost part of distributed vector
 
 
// Numbers of particles vector
openfpm::vector<size_t> n_particles;
 
template<unsigned int dim> void vd_verlet_random_benchmark(size_t k_start,
                                                           size_t k_min,
                                                           openfpm::vector<float> & r_cutoff,
                                                           openfpm::vector<size_t> & n_particles)
{
    std::string str("Testing " + std::to_string(dim) + "D vector no-order, Verlet-list");
    print_test_v(str,0);
 
    {
        //For different r_cut
        for (size_t r = 0; r < r_cutoff.size(); r++ )
        {
            Vcluster<> & v_cl = create_vcluster();
 
            //Cut-off radius
            float r_cut = r_cutoff.get(r);
 
            report_vl.graphs.put("performance.verletlist.getVerletList" + std::to_string(dim) + "D(" + std::to_string(r) + ").rcut",r_cut);
 
            //Number of particles
            size_t k = k_start * v_cl.getProcessingUnits();
 
            //Counter number for amounts of particles
            size_t k_count = 1 + log2(k/k_min);
 
            int c = 0;
 
            for (size_t k_int = k ; k_int >= k_min ; k_int/=2 )
            {
                BOOST_TEST_CHECKPOINT( "Testing " << dim << "D vector without an Hilbert curve reordering k=" << k_int );
 
                report_vl.graphs.put("performance.verletlist.getVerletList" + std::to_string(dim) + "D(" + std::to_string(r) + ").npart(" + std::to_string(c) + ").n",k_int);
                report_vl.graphs.put("performance.verletlist.calc_forces" + std::to_string(dim) + "D(" + std::to_string(r) + ").npart(" + std::to_string(c) + ").n",k_int);
 
                if (n_particles.size() < k_count)
                    n_particles.add(k_int);
 
                Box<dim,float> box;
 
                for (size_t i = 0; i < dim; i++)
                {
                    box.setLow(i,0.0);
                    box.setHigh(i,1.0);
                }
 
                // Boundary conditions
                size_t bc[dim];
                for (size_t i = 0; i < dim; i++)
                    bc[i] = PERIODIC;
 
                vector_dist<dim,float, aggregate<float[dim]> > vd(k_int,box,bc,Ghost<dim,float>(r_cut));
 
                // Initialize a dist vector
                vd_initialize<dim>(vd, v_cl);
 
                vd.template ghost_get<0>();
 
                //Get verlet list
 
                openfpm::vector<double> measures;
                double sum_verlet_mean = 0;
                double sum_verlet_dev = 0;
                for (size_t n = 0 ; n < N_STAT_TEST; n++)
                {measures.add(benchmark_get_verlet(vd,r_cut));}
                standard_deviation(measures,sum_verlet_mean,sum_verlet_dev);
 
                report_vl.graphs.put("performance.verletlist.getVerletList" + std::to_string(dim) + "D(" + std::to_string(r) + ").npart(" + std::to_string(c) + ").mean",sum_verlet_mean);
                report_vl.graphs.put("performance.verletlist.getVerletList" + std::to_string(dim) + "D(" + std::to_string(r) + ").npart(" + std::to_string(c) + ").dev",sum_verlet_dev);
 
                //Calculate forces
 
                auto NN = vd.getCellList(r_cut);
                double sum_fr_mean = 0;
                double sum_fr_dev = 0;
 
                measures.clear();
                for (size_t l = 0 ; l < N_STAT_TEST ; l++)
                {measures.add(benchmark_calc_forces<dim>(NN,vd,r_cut));}
                standard_deviation(measures,sum_fr_mean,sum_fr_dev);
 
                report_vl.graphs.put("performance.verletlist.calc_forces" + std::to_string(dim) + "D(" + std::to_string(r) + ").npart(" + std::to_string(c) + ").mean",sum_fr_mean);
                report_vl.graphs.put("performance.verletlist.calc_forces" + std::to_string(dim) + "D(" + std::to_string(r) + ").npart(" + std::to_string(c) + ").dev",sum_fr_dev);
 
                if (v_cl.getProcessUnitID() == 0)
                {std::cout << "Particles: " << k_int << "," << "cut-off: " << r_cut << " time to construct a Verlet list = " << sum_verlet_mean << " dev: " << sum_verlet_dev << "    calculate force = " << sum_fr_mean << " dev: " << sum_fr_dev << std::endl;}
 
                c++;
            }
        }
    }
}
 
 
BOOST_AUTO_TEST_CASE( vector_dist_verlet_test )
{
    //Benchmark test for 2D and 3D
    vd_verlet_random_benchmark<3>(k_start,k_min,r_cutoff,n_particles);
    vd_verlet_random_benchmark<2>(k_start,k_min,r_cutoff,n_particles);
}
 
BOOST_AUTO_TEST_CASE(vector_dist_verlet_performance_write_report)
{
    //For different r_cut
    for (size_t r = 0; r < r_cutoff.size(); r++ )
    {
        report_vl.graphs.put("graphs.graph(" + std::to_string(r) + ").type","line");
        report_vl.graphs.add("graphs.graph(" + std::to_string(r) + ").title","getVerletList 3D performance r_cut=" + std::to_string(r_cutoff.get(r)));
        report_vl.graphs.add("graphs.graph(" + std::to_string(r) + ").x.title","number of particles");
        report_vl.graphs.add("graphs.graph(" + std::to_string(r) + ").y.title","Time seconds");
        report_vl.graphs.add("graphs.graph(" + std::to_string(r) + ").y.data(0).source","performance.verletlist.getVerletList3D(" + std::to_string(r) + ").npart(#).mean");
        report_vl.graphs.add("graphs.graph(" + std::to_string(r) + ").x.data(0).source","performance.verletlist.getVerletList3D(" + std::to_string(r) + ").npart(#).n");
        report_vl.graphs.add("graphs.graph(" + std::to_string(r) + ").y.data(0).title","Verlet-list");
        report_vl.graphs.add("graphs.graph(" + std::to_string(r) + ").options.log_y","true");
    }
 
    //For different r_cut
    for (size_t r = 0; r < r_cutoff.size(); r++ )
    {
        report_vl.graphs.put("graphs.graph(" + std::to_string(r_cutoff.size() + r) + ").type","line");
        report_vl.graphs.add("graphs.graph(" + std::to_string(r_cutoff.size() + r) + ").title","calc_force 3D performance r_cut=" + std::to_string(r_cutoff.get(r)));
        report_vl.graphs.add("graphs.graph(" + std::to_string(r_cutoff.size() + r) + ").x.title","number of particles");
        report_vl.graphs.add("graphs.graph(" + std::to_string(r_cutoff.size() + r) + ").y.title","Time seconds");
        report_vl.graphs.add("graphs.graph(" + std::to_string(r_cutoff.size() + r) + ").y.data(0).source","performance.verletlist.calc_forces3D(" + std::to_string(r) + ").npart(#).mean");
        report_vl.graphs.add("graphs.graph(" + std::to_string(r_cutoff.size() + r) + ").x.data(0).source","performance.verletlist.calc_forces3D(" + std::to_string(r) + ").npart(#).n");
        report_vl.graphs.add("graphs.graph(" + std::to_string(r_cutoff.size() + r) + ").y.data(0).title","Verlet-list");
        report_vl.graphs.add("graphs.graph(" + std::to_string(r_cutoff.size() + r) + ").options.log_y","true");
    }
 
    //For different r_cut
    for (size_t r = 0; r < r_cutoff.size(); r++ )
    {
        report_vl.graphs.put("graphs.graph(" + std::to_string(2*r_cutoff.size() + r) + ").type","line");
        report_vl.graphs.add("graphs.graph(" + std::to_string(2*r_cutoff.size() + r) + ").title","getVerletList 2D performance r_cut=" + std::to_string(r_cutoff.get(r)));
        report_vl.graphs.add("graphs.graph(" + std::to_string(2*r_cutoff.size() + r) + ").x.title","number of particles");
        report_vl.graphs.add("graphs.graph(" + std::to_string(2*r_cutoff.size() + r) + ").y.title","Time seconds");
        report_vl.graphs.add("graphs.graph(" + std::to_string(2*r_cutoff.size() + r) + ").y.data(0).source","performance.verletlist.getVerletList2D(" + std::to_string(r) + ").npart(#).mean");
        report_vl.graphs.add("graphs.graph(" + std::to_string(2*r_cutoff.size() + r) + ").x.data(0).source","performance.verletlist.getVerletList2D(" + std::to_string(r) + ").npart(#).n");
        report_vl.graphs.add("graphs.graph(" + std::to_string(2*r_cutoff.size() + r) + ").y.data(0).title","Verlet-list");
        report_vl.graphs.add("graphs.graph(" + std::to_string(2*r_cutoff.size() + r) + ").options.log_y","true");
    }
 
    //For different r_cut
    for (size_t r = 0; r < r_cutoff.size(); r++ )
    {
        report_vl.graphs.put("graphs.graph(" + std::to_string(3*r_cutoff.size() + r) + ").type","line");
        report_vl.graphs.add("graphs.graph(" + std::to_string(3*r_cutoff.size() + r) + ").title","calc_force 2D performance r_cut=" + std::to_string(r_cutoff.get(r)));
        report_vl.graphs.add("graphs.graph(" + std::to_string(3*r_cutoff.size() + r) + ").x.title","number of particles");
        report_vl.graphs.add("graphs.graph(" + std::to_string(3*r_cutoff.size() + r) + ").y.title","Time seconds");
        report_vl.graphs.add("graphs.graph(" + std::to_string(3*r_cutoff.size() + r) + ").y.data(0).source","performance.verletlist.calc_forces2D(" + std::to_string(r) + ").npart(#).mean");
        report_vl.graphs.add("graphs.graph(" + std::to_string(3*r_cutoff.size() + r) + ").x.data(0).source","performance.verletlist.calc_forces2D(" + std::to_string(r) + ").npart(#).n");
        report_vl.graphs.add("graphs.graph(" + std::to_string(3*r_cutoff.size() + r) + ").y.data(0).title","Verlet-list");
        report_vl.graphs.add("graphs.graph(" + std::to_string(3*r_cutoff.size() + r) + ").options.log_y","true");
    }
 
    if (create_vcluster().rank() == 0)
    {
        boost::property_tree::xml_writer_settings<std::string> settings(' ', 4);
        boost::property_tree::write_xml("verletlist_performance.xml", report_vl.graphs,std::locale(),settings);
 
        std::string file_xml_ref(test_dir);
        file_xml_ref += std::string("/openfpm_pdata/verletlist_performance_ref.xml");
 
        GoogleChart cg;
 
        StandardXMLPerformanceGraph("verletlist_performance.xml",file_xml_ref,cg);
 
        addUpdateTime(cg,create_vcluster().size(),"pdata","verletlist_performance");
 
        if (create_vcluster().getProcessUnitID() == 0)
        {cg.write("verletlist_performance.html");}
    }
}
 
BOOST_AUTO_TEST_SUITE_END()
 
#endif /* SRC_VECTOR_VECTOR_DIST_VERLET_PERFORMANCE_TESTS_HPP_ */