opencl_converter.h

Go to the documentation of this file.

#pragma once

#ifndef OPENCL_CONVERTER_H
#define OPENCL_CONVERTER_H


/**
    \file
    \brief Contains OpenCL::Converter class.

    In addition to the Converter default specialization, this file also defines
    specializations for fixed-size arrays (using \c std::array for the host
    type), builtin integer and floating-point types, and vectors (using Vector
    for the host type, e.g. <tt>Vector< float, 3 ></tt> maps to \c cl_float3).
*/




#include "settings.h"




#if ( SETTING_OPENCL != 0 )




#include "vector.h"

#include <CL/cl.h>

#include <array>

#include <stdint.h>




namespace OpenCL {




/*==============================================================================
    Converter class and helper functions
==============================================================================*/


/**
    \brief Converts data for transmission to OpenCL device.

    \param t_Type  Host type from which to convert.

    This class, and its specializations, are inspired by the way that \c
    boost::serialization works. Every convertable host type has two associated
    pieces of information: the OpenCL type to which it converts (stored in the
    \c Type typedef), and a function for actually performing the conversion
    (the \c Convert static function).

    The default specialization of this class maps \c t_Type::OpenCLType to \c
    Type, and \c t_Type::OpenCLConvert to \c Convert. Hence, if you don't want
    to explicitly specialize this class for your type, you can instead add
    these two members, and they'll be used automatically.

    This class is primarily used by Synchronized::Heap and
    Synchronized::TextureHeap, which keep the host state synchronized with OpenCL
    by, for every convertable object on the host, allocating a corresponding
    block of memory on the OpenCL device, and using this class to convert
    objects before transferring them over, whenever the host object changes.

    \see \ref Synchronized::Heap
    \see \ref Synchronized::TextureHeap
*/
template< typename t_Type >
struct Converter {

    typedef typename t_Type::OpenCLType Type;

    static Type Convert( t_Type const& source ) {

        return source.OpenCLConvert();
    }
};


/// \brief Helper function which calls Converter::Convert for the type of its argument.
template< typename t_Type >
inline typename Converter< t_Type >::Type Convert( t_Type const& source ) {

    return Converter< t_Type >::Convert( source );
}




/*==============================================================================
    Converter array specialization
==============================================================================*/


/**
    \brief Converter specialization for fixed-size arrays.

    \param t_Type  Host type of array elements.
    \param t_Size  Number of elements.

    On the host, convertable fixed-size arrays are instances of \c std::array.
    They are serialized to the device by simply using the appropriate Converter
    element-by-element.

    \see \ref Converter
*/
template< typename t_Type, size_t t_Size >
struct Converter< std::array< t_Type, t_Size > > {

    typedef std::array< typename Converter< t_Type >::Type, t_Size > Type;

    static Type Convert( std::array< t_Type, t_Size > const& source ) {

        Type result;
        for ( size_t ii = 0; ii < t_Size; ++ii )
            result[ ii ] = Converter< t_Type >::Convert( source[ ii ] );
        return result;
    }
};




/*==============================================================================
    Converter builtin specializations
==============================================================================*/


// **TODO: most of these are NOPs. is the compiler smart enough to realize this?

#define OPENCL_COMMA ,

/// \brief Generates converter specialization which converts the host type \p ss to the OpenCL type \p dd.
#define OPENCL_CONVERTER1( ss, dd ) \
    template<> \
    struct Converter< ss > { \
        typedef dd Type; \
        static Type Convert( ss const& source ) { \
            return source; \
        } \
    };

/// \brief Generates converter specialization which converts the host 2D vector type \p ss to the OpenCL 2D vector type \p dd.
#define OPENCL_CONVERTER2( ss, dd ) \
    template<> \
    struct Converter< ss > { \
        typedef dd Type; \
        static Type Convert( ss const& source ) { \
            Type const result = { { source[ 0 ], source[ 1 ] } }; \
            return result; \
        } \
    };

/// \brief Generates converter specialization which converts the host 3D vector type \p ss to the OpenCL 3D vector type \p dd.
#define OPENCL_CONVERTER3( ss, dd ) \
    template<> \
    struct Converter< ss > { \
        typedef dd Type; \
        static Type Convert( ss const& source ) { \
            Type const result = { { source[ 0 ], source[ 1 ], source[ 2 ] } }; \
            return result; \
        } \
    };

/// \brief Generates converter specialization which converts the host 4D vector type \p ss to the OpenCL 4D vector type \p dd.
#define OPENCL_CONVERTER4( ss, dd ) \
    template<> \
    struct Converter< ss > { \
        typedef dd Type; \
        static Type Convert( ss const& source ) { \
            Type const result = { { source[ 0 ], source[ 1 ], source[ 2 ], source[ 3 ] } }; \
            return result; \
        } \
    };

/// \brief Generates converter specialization which converts the host 8D vector type \p ss to the OpenCL 8D vector type \p dd.
#define OPENCL_CONVERTER8( ss, dd ) \
    template<> \
    struct Converter< ss > { \
        typedef dd Type; \
        static Type Convert( ss const& source ) { \
            Type const result = { { source[ 0 ], source[ 1 ], source[ 2 ], source[ 3 ], source[ 4 ], source[ 5 ], source[ 6 ], source[ 7 ] } }; \
            return result; \
        } \
    };

/// \brief Generates converter specialization which converts the host 16D vector type \p ss to the OpenCL 16D vector type \p dd.
#define OPENCL_CONVERTER16( ss, dd ) \
    template<> \
    struct Converter< ss > { \
        typedef dd Type; \
        static Type Convert( ss const& source ) { \
            Type const result = { { source[ 0 ], source[ 1 ], source[ 2 ], source[ 3 ], source[ 4 ], source[ 5 ], source[ 6 ], source[ 7 ], source[ 8 ], source[ 9 ], source[ 10 ], source[ 11 ], source[ 12 ], source[ 13 ], source[ 14 ], source[ 15 ] } }; \
            return result; \
        } \
    };

/// \brief Generates converter specializations which convert the host type \p ss to the OpenCL type \p dd, and likewise <tt>Vector< ss, n ></tt> to \c ddn for \f$n \in \{ 1, 2, 3, 4, 8, 16 \}\f$.
#define OPENCL_CONVERTER( ss, dd ) \
    OPENCL_CONVERTER1( ss, dd ) \
    OPENCL_CONVERTER2(  Vector< ss OPENCL_COMMA 2  >, dd##2  ) \
    OPENCL_CONVERTER3(  Vector< ss OPENCL_COMMA 3  >, dd##3  ) \
    OPENCL_CONVERTER4(  Vector< ss OPENCL_COMMA 4  >, dd##4  ) \
    OPENCL_CONVERTER8(  Vector< ss OPENCL_COMMA 8  >, dd##8  ) \
    OPENCL_CONVERTER16( Vector< ss OPENCL_COMMA 16 >, dd##16 )


OPENCL_CONVERTER( int8_t,   cl_char   )
OPENCL_CONVERTER( uint8_t,  cl_uchar  )
OPENCL_CONVERTER( int16_t,  cl_short  )
OPENCL_CONVERTER( uint16_t, cl_ushort )
OPENCL_CONVERTER( int32_t,  cl_int    )
OPENCL_CONVERTER( uint32_t, cl_uint   )
OPENCL_CONVERTER( int64_t,  cl_long   )
OPENCL_CONVERTER( uint64_t, cl_ulong  )
OPENCL_CONVERTER( float,    cl_float  )
OPENCL_CONVERTER( double,   cl_double )


#undef OPENCL_COMMA
#undef OPENCL_CONVERTER1
#undef OPENCL_CONVERTER2
#undef OPENCL_CONVERTER3
#undef OPENCL_CONVERTER4
#undef OPENCL_CONVERTER8
#undef OPENCL_CONVERTER16
#undef OPENCL_CONVERTER




}    // namespace OpenCL




#endif    // SETTING_OPENCL




#endif    // OPENCL_CONVERTER_H