]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
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 |