ceph/src/boost/libs/compute/include/boost/compute/types/fundamental.hpp

   1 //---------------------------------------------------------------------------//
   2 // Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com>
   3 //
   4 // Distributed under the Boost Software License, Version 1.0
   5 // See accompanying file LICENSE_1_0.txt or copy at
   6 // http://www.boost.org/LICENSE_1_0.txt
   7 //
   8 // See http://boostorg.github.com/compute for more information.
   9 //---------------------------------------------------------------------------//
  10
  11 #ifndef BOOST_COMPUTE_TYPES_FUNDAMENTAL_HPP
  12 #define BOOST_COMPUTE_TYPES_FUNDAMENTAL_HPP
  13
  14 #include <cstring>
  15 #include <ostream>
  16
  17 #include <boost/preprocessor/cat.hpp>
  18 #include <boost/preprocessor/comma.hpp>
  19 #include <boost/preprocessor/repetition.hpp>
  20 #include <boost/preprocessor/stringize.hpp>
  21
  22 #include <boost/compute/cl.hpp>
  23
  24 namespace boost {
  25 namespace compute {
  26
  27 // scalar data types
  28 typedef cl_char char_;
  29 typedef cl_uchar uchar_;
  30 typedef cl_short short_;
  31 typedef cl_ushort ushort_;
  32 typedef cl_int int_;
  33 typedef cl_uint uint_;
  34 typedef cl_long long_;
  35 typedef cl_ulong ulong_;
  36 typedef cl_float float_;
  37 typedef cl_double double_;
  38
  39 // converts uchar to ::boost::compute::uchar_
  40 #define BOOST_COMPUTE_MAKE_SCALAR_TYPE(scalar) \
  41     BOOST_PP_CAT(::boost::compute::scalar, _)
  42
  43 // converts float, 4 to ::boost::compute::float4_
  44 #define BOOST_COMPUTE_MAKE_VECTOR_TYPE(scalar, size) \
  45     BOOST_PP_CAT(BOOST_PP_CAT(::boost::compute::scalar, size), _)
  46
  47 // vector data types
  48 template<class Scalar, size_t N>
  49 class vector_type
  50 {
  51 public:
  52     typedef Scalar scalar_type;
  53
  54     vector_type()
  55     {
  56
  57     }
  58
  59     explicit vector_type(const Scalar scalar)
  60     {
  61         for(size_t i = 0; i < N; i++)
  62             m_value[i] = scalar;
  63     }
  64
  65     vector_type(const vector_type<Scalar, N> &other)
  66     {
  67         std::memcpy(m_value, other.m_value, sizeof(m_value));
  68     }
  69
  70     vector_type<Scalar, N>&
  71     operator=(const vector_type<Scalar, N> &other)
  72     {
  73         std::memcpy(m_value, other.m_value, sizeof(m_value));
  74         return *this;
  75     }
  76
  77     size_t size() const
  78     {
  79         return N;
  80     }
  81
  82     Scalar& operator[](size_t i)
  83     {
  84         return m_value[i];
  85     }
  86
  87     Scalar operator[](size_t i) const
  88     {
  89         return m_value[i];
  90     }
  91
  92     bool operator==(const vector_type<Scalar, N> &other) const
  93     {
  94         return std::memcmp(m_value, other.m_value, sizeof(m_value)) == 0;
  95     }
  96
  97     bool operator!=(const vector_type<Scalar, N> &other) const
  98     {
  99         return !(*this == other);
 100     }
 101
 102 protected:
 103     scalar_type m_value[N];
 104 };
 105
 106 #define BOOST_COMPUTE_VECTOR_TYPE_CTOR_ARG_FUNCTION(z, i, _) \
 107     BOOST_PP_COMMA_IF(i) scalar_type BOOST_PP_CAT(arg, i)
 108 #define BOOST_COMPUTE_VECTOR_TYPE_DECLARE_CTOR_ARGS(scalar, size) \
 109     BOOST_PP_REPEAT(size, BOOST_COMPUTE_VECTOR_TYPE_CTOR_ARG_FUNCTION, _)
 110 #define BOOST_COMPUTE_VECTOR_TYPE_ASSIGN_CTOR_ARG(z, i, _) \
 111     m_value[i] = BOOST_PP_CAT(arg, i);
 112 #define BOOST_COMPUTE_VECTOR_TYPE_ASSIGN_CTOR_SINGLE_ARG(z, i, _) \
 113     m_value[i] = arg;
 114
 115 #define BOOST_COMPUTE_DECLARE_VECTOR_TYPE_CLASS(cl_scalar, size, class_name) \
 116     class class_name : public vector_type<cl_scalar, size> \
 117     { \
 118     public: \
 119         class_name() { } \
 120         explicit class_name( scalar_type arg ) \
 121         { \
 122             BOOST_PP_REPEAT(size, BOOST_COMPUTE_VECTOR_TYPE_ASSIGN_CTOR_SINGLE_ARG, _) \
 123         } \
 124         class_name( \
 125             BOOST_PP_REPEAT(size, BOOST_COMPUTE_VECTOR_TYPE_CTOR_ARG_FUNCTION, _) \
 126         ) \
 127         { \
 128           BOOST_PP_REPEAT(size, BOOST_COMPUTE_VECTOR_TYPE_ASSIGN_CTOR_ARG, _) \
 129         } \
 130     };
 131
 132 #define BOOST_COMPUTE_DECLARE_VECTOR_TYPE(scalar, size) \
 133     BOOST_COMPUTE_DECLARE_VECTOR_TYPE_CLASS(BOOST_PP_CAT(cl_, scalar), \
 134                                             size, \
 135                                             BOOST_PP_CAT(BOOST_PP_CAT(scalar, size), _)) \
 136     \
 137     inline std::ostream& operator<<( \
 138         std::ostream &s, \
 139         const BOOST_COMPUTE_MAKE_VECTOR_TYPE(scalar, size) &v) \
 140     { \
 141         s << BOOST_PP_STRINGIZE(BOOST_PP_CAT(scalar, size)) << "("; \
 142         for(size_t i = 0; i < size; i++){\
 143             s << v[i]; \
 144             if(i != size - 1){\
 145                 s << ", "; \
 146             } \
 147         } \
 148         s << ")"; \
 149         return s; \
 150     }
 151
 152 #define BOOST_COMPUTE_DECLARE_VECTOR_TYPES(scalar) \
 153     BOOST_COMPUTE_DECLARE_VECTOR_TYPE(scalar, 2) \
 154     BOOST_COMPUTE_DECLARE_VECTOR_TYPE(scalar, 4) \
 155     BOOST_COMPUTE_DECLARE_VECTOR_TYPE(scalar, 8) \
 156     BOOST_COMPUTE_DECLARE_VECTOR_TYPE(scalar, 16) \
 157
 158 BOOST_COMPUTE_DECLARE_VECTOR_TYPES(char)
 159 BOOST_COMPUTE_DECLARE_VECTOR_TYPES(uchar)
 160 BOOST_COMPUTE_DECLARE_VECTOR_TYPES(short)
 161 BOOST_COMPUTE_DECLARE_VECTOR_TYPES(ushort)
 162 BOOST_COMPUTE_DECLARE_VECTOR_TYPES(int)
 163 BOOST_COMPUTE_DECLARE_VECTOR_TYPES(uint)
 164 BOOST_COMPUTE_DECLARE_VECTOR_TYPES(long)
 165 BOOST_COMPUTE_DECLARE_VECTOR_TYPES(ulong)
 166 BOOST_COMPUTE_DECLARE_VECTOR_TYPES(float)
 167 BOOST_COMPUTE_DECLARE_VECTOR_TYPES(double)
 168
 169 } // end compute namespace
 170 } // end boost namespace
 171
 172 #endif // BOOST_COMPUTE_TYPES_FUNDAMENTAL_HPP