float3_optimization.test

PREAMBLE = \
    """
    #include <thrust/transform.h>
    #include <thrust/iterator/zip_iterator.h>
    
    #include <cmath>

    template <typename T>
    struct rotate_tuple
    {
        template <typename Tuple>
        __host__ __device__
        Tuple operator()(const Tuple& t) const
        {
            T x = thrust::get<0>(t);
            T y = thrust::get<1>(t);
            T z = thrust::get<2>(t);

            T rx = 0.36f*x +  0.48f*y + -0.80f*z;
            T ry =-0.80f*x +  0.60f*y +  0.00f*z;
            T rz = 0.48f*x +  0.64f*y +  0.60f*z;

            return Tuple(rx, ry, rz);
        }
    };
    
    struct rotate_float3
    {
        __host__ __device__
        float3 operator()(const float3& t) const
        {
            float x = t.x;
            float y = t.y;
            float z = t.z;

            float3 rt;

            rt.x = 0.36f*x +  0.48f*y + -0.80f*z;
            rt.y =-0.80f*x +  0.60f*y +  0.00f*z;
            rt.z = 0.48f*x +  0.64f*y +  0.60f*z;

            return rt;
        }
    };
    
    template <typename Vector, typename Vector3>
    void rotate_fast(Vector& x, Vector& y, Vector& z, Vector3& v)
    {
        typedef typename Vector::value_type T;

        size_t N = x.size();
        
        thrust::transform(thrust::make_zip_iterator(thrust::make_tuple(x.begin(), y.begin(), z.begin())),
                          thrust::make_zip_iterator(thrust::make_tuple(x.begin(), y.begin(), z.begin())) + N,
                          thrust::make_zip_iterator(thrust::make_tuple(x.begin(), y.begin(), z.begin())),
                          rotate_tuple<T>());
    }
    
    template <typename Vector, typename Vector3>
    void rotate_slow(Vector& x, Vector& y, Vector& z, Vector3& v)
    {
        thrust::transform(v.begin(), v.end(), v.begin(), rotate_float3());
    }

    """

INITIALIZE = \
    """
    thrust::host_vector<$InputType>   h_x = unittest::random_samples<$InputType>($InputSize);
    thrust::host_vector<$InputType>   h_y = unittest::random_samples<$InputType>($InputSize);
    thrust::host_vector<$InputType>   h_z = unittest::random_samples<$InputType>($InputSize);
    thrust::device_vector<$InputType> d_x = h_x;
    thrust::device_vector<$InputType> d_y = h_y;
    thrust::device_vector<$InputType> d_z = h_z;
    
    thrust::host_vector<float3>   h_v($InputSize, make_float3(1.0,0.4,0.2));
    thrust::device_vector<float3> d_v = h_v;

    $Method(h_x, h_y, h_z, h_v);
    $Method(d_x, d_y, d_z, d_v);

    ASSERT_ALMOST_EQUAL(h_x, d_x);
    ASSERT_ALMOST_EQUAL(h_y, d_y);
    ASSERT_ALMOST_EQUAL(h_z, d_z);
    """

TIME = \
    """
    $Method(d_x, d_y, d_z, d_v);
    """

FINALIZE = \
    """
    RECORD_TIME();
    RECORD_THROUGHPUT(2*9*double($InputSize));
    RECORD_BANDWIDTH(2*3*sizeof($InputType) *  double($InputSize));
    """

InputTypes = ['float']
InputSizes = [2**24]
Methods    = ['rotate_fast','rotate_slow']

TestVariables = [('InputType', InputTypes), ('InputSize', InputSizes), ('Method', Methods)]