vector_test_util.hpp

/*
 * vector_test_util.hpp
 *
 *  Created on: Jun 19, 2015
 *      Author: Pietro Incardona
 */
 
#ifndef VECTOR_TEST_UTIL_HPP_
#define VECTOR_TEST_UTIL_HPP_
 
#include "config.h"
#include "Point_test.hpp"
#include "Vector/map_vector.hpp"
#include "data_type/aggregate.hpp"
 
typedef Point_test<float> P;
 
#ifdef TEST_COVERAGE_MODE
#define FIRST_PUSH 1000
#define SECOND_PUSH 1000
#else
#define FIRST_PUSH 1000000
#define SECOND_PUSH 1000000
#endif
 
#include "timer.hpp"
 
static std::vector<Point_orig<float>> allocate_stl()
{
    std::vector<Point_orig<float>> v_stl_test;
 
    // Now fill the vector
 
    Point_orig<float> po;
    po.setx(1.0);
    po.sety(2.0);
    po.setz(3.0);
    po.sets(4.0);
 
    for (size_t i = 0 ; i < FIRST_PUSH ; i++)
    {
        // Modify po
 
        po.v[0] = 1.0 + i;
        po.v[1] = 2.0 + i;
        po.v[2] = 7.0 + i;
 
        po.t[0][0] = 10.0 + i;
        po.t[0][1] = 13.0 + i;
        po.t[0][2] = 8.0 + i;
        po.t[1][0] = 19.0 + i;
        po.t[1][1] = 23.0 + i;
        po.t[1][2] = 5.0 + i;
        po.t[2][0] = 4.0 + i;
        po.t[2][1] = 3.0 + i;
        po.t[2][2] = 11.0 + i;
 
        // add p
 
        v_stl_test.push_back(po);
    }
 
    return v_stl_test;
}
 
template <typename T>
openfpm::vector<T> allocate_openfpm_primitive(size_t n, size_t fill)
{
    openfpm::vector<T> v;
 
    for (size_t i = 0 ; i < n ; i++)
        v.add(fill);
 
    return v;
}
 
static openfpm::vector<Point_test<float>> allocate_openfpm_fill(size_t n, size_t fill)
{
    Point_test<float> pt;
    openfpm::vector<Point_test<float>> v_send;
 
    pt.setx(fill);
    pt.sety(fill);
    pt.setz(fill);
    pt.sets(fill);
 
    pt.setv(0,fill);
    pt.setv(1,fill);
    pt.setv(2,fill);
 
    pt.sett(0,0,fill);
    pt.sett(0,1,fill);
    pt.sett(0,2,fill);
    pt.sett(1,0,fill);
    pt.sett(1,1,fill);
    pt.sett(1,2,fill);
    pt.sett(2,0,fill);
    pt.sett(2,1,fill);
    pt.sett(2,2,fill);
 
 
    // ADD n elements
    for (size_t i = 0 ; i < n ; i++)
        v_send.add(pt);
 
    return v_send;
}
 
 
template<typename vector> vector allocate_openfpm(size_t n_ele)
{
    vector v_ofp_test;
 
    Point_test<float> p;
 
    p.setx(1.0);
    p.sety(2.0);
    p.setz(3.0);
    p.sets(4.0);
 
    // push objects
 
    for (size_t i = 0 ; i < n_ele / 2 ; i++)
    {
        // Modify the point
 
        p.get<P::v>()[0] = 1.0 + i;
        p.get<P::v>()[1] = 2.0 + i;
        p.get<P::v>()[2] = 7.0 + i;
 
        p.get<P::t>()[0][0] = 10.0 + i;
        p.get<P::t>()[0][1] = 13.0 + i;
        p.get<P::t>()[0][2] = 8.0 + i;
        p.get<P::t>()[1][0] = 19.0 + i;
        p.get<P::t>()[1][1] = 23.0 + i;
        p.get<P::t>()[1][2] = 5.0 + i;
        p.get<P::t>()[2][0] = 4.0 + i;
        p.get<P::t>()[2][1] = 3.0 + i;
        p.get<P::t>()[2][2] = 11.0 + i;
 
        // add p
 
        v_ofp_test.add(p);
    }
 
    for (size_t i = n_ele / 2 ; i < n_ele ; i++)
    {
        v_ofp_test.add();
 
        size_t last = v_ofp_test.size()-1;
 
        // Modify the point
 
        v_ofp_test.template get<P::v>(last)[0] = 1.0 + i;
        v_ofp_test.template get<P::v>(last)[1] = 2.0 + i;
        v_ofp_test.template get<P::v>(last)[2] = 7.0 + i;
 
        v_ofp_test.template get<P::t>(last)[0][0] = 10.0 + i;
        v_ofp_test.template get<P::t>(last)[0][1] = 13.0 + i;
        v_ofp_test.template get<P::t>(last)[0][2] = 8.0 + i;
        v_ofp_test.template get<P::t>(last)[1][0] = 19.0 + i;
        v_ofp_test.template get<P::t>(last)[1][1] = 23.0 + i;
        v_ofp_test.template get<P::t>(last)[1][2] = 5.0 + i;
        v_ofp_test.template get<P::t>(last)[2][0] = 4.0 + i;
        v_ofp_test.template get<P::t>(last)[2][1] = 3.0 + i;
        v_ofp_test.template get<P::t>(last)[2][2] = 11.0 + i;
    }
 
    return v_ofp_test;
}
 
static openfpm::vector<Point_test_prp<float>> allocate_openfpm_prp(size_t n_ele)
{
    openfpm::vector<Point_test_prp<float>> v_ofp_test;
 
    Point_test_prp<float> p;
 
    p.setx(1.0);
    p.sety(2.0);
    p.setz(3.0);
    p.sets(4.0);
 
    // push objects
 
    for (size_t i = 0 ; i < n_ele / 2 ; i++)
    {
        // Modify the point
 
        p.get<P::v>()[0] = 1.0 + i;
        p.get<P::v>()[1] = 2.0 + i;
        p.get<P::v>()[2] = 7.0 + i;
 
        p.get<P::t>()[0][0] = 10.0 + i;
        p.get<P::t>()[0][1] = 13.0 + i;
        p.get<P::t>()[0][2] = 8.0 + i;
        p.get<P::t>()[1][0] = 19.0 + i;
        p.get<P::t>()[1][1] = 23.0 + i;
        p.get<P::t>()[1][2] = 5.0 + i;
        p.get<P::t>()[2][0] = 4.0 + i;
        p.get<P::t>()[2][1] = 3.0 + i;
        p.get<P::t>()[2][2] = 11.0 + i;
 
        // add p
 
        v_ofp_test.add(p);
    }
 
    for (size_t i = n_ele / 2 ; i < n_ele ; i++)
    {
        v_ofp_test.add();
 
        size_t last = v_ofp_test.size()-1;
 
        // Modify the point
 
        v_ofp_test.get<P::v>(last)[0] = 1.0 + i;
        v_ofp_test.get<P::v>(last)[1] = 2.0 + i;
        v_ofp_test.get<P::v>(last)[2] = 7.0 + i;
 
        v_ofp_test.get<P::t>(last)[0][0] = 10.0 + i;
        v_ofp_test.get<P::t>(last)[0][1] = 13.0 + i;
        v_ofp_test.get<P::t>(last)[0][2] = 8.0 + i;
        v_ofp_test.get<P::t>(last)[1][0] = 19.0 + i;
        v_ofp_test.get<P::t>(last)[1][1] = 23.0 + i;
        v_ofp_test.get<P::t>(last)[1][2] = 5.0 + i;
        v_ofp_test.get<P::t>(last)[2][0] = 4.0 + i;
        v_ofp_test.get<P::t>(last)[2][1] = 3.0 + i;
        v_ofp_test.get<P::t>(last)[2][2] = 11.0 + i;
    }
 
    return v_ofp_test;
}
 
 
static openfpm::vector< aggregate<float,float,float,float,float[3],float[3][3],openfpm::vector<int>> > allocate_openfpm_aggregate_with_complex(size_t n_ele)
{
    openfpm::vector< aggregate<float,float,float,float,float[3],float[3][3],openfpm::vector<int>> > v_ofp_test;
 
    for (size_t i = 0 ; i < n_ele ; i++)
    {
        v_ofp_test.add();
 
        size_t last = v_ofp_test.size()-1;
 
        // Modify the point
 
        v_ofp_test.get<P::x>(last) = 100.0 + i;
        v_ofp_test.get<P::y>(last) = 102.0 + i;
        v_ofp_test.get<P::z>(last) = 107.0 + i;
        v_ofp_test.get<P::s>(last) = 109.0 + i;
 
        v_ofp_test.get<P::v>(last)[0] = 1.0 + i;
        v_ofp_test.get<P::v>(last)[1] = 2.0 + i;
        v_ofp_test.get<P::v>(last)[2] = 7.0 + i;
 
        v_ofp_test.get<P::t>(last)[0][0] = 10.0 + i;
        v_ofp_test.get<P::t>(last)[0][1] = 13.0 + i;
        v_ofp_test.get<P::t>(last)[0][2] = 8.0 + i;
        v_ofp_test.get<P::t>(last)[1][0] = 19.0 + i;
        v_ofp_test.get<P::t>(last)[1][1] = 23.0 + i;
        v_ofp_test.get<P::t>(last)[1][2] = 5.0 + i;
        v_ofp_test.get<P::t>(last)[2][0] = 4.0 + i;
        v_ofp_test.get<P::t>(last)[2][1] = 3.0 + i;
        v_ofp_test.get<P::t>(last)[2][2] = 11.0 + i;
    }
 
 
    return v_ofp_test;
}
 
#endif /* VECTOR_TEST_UTIL_HPP_ */