arch/SYCL/MathFunctions.h
Go to the documentation of this file.
1 // This file is part of Eigen, a lightweight C++ template library
2 // for linear algebra.
3 //
4 // Mehdi Goli Codeplay Software Ltd.
5 // Ralph Potter Codeplay Software Ltd.
6 // Luke Iwanski Codeplay Software Ltd.
7 // Contact: <eigen@codeplay.com>
8 //
9 // This Source Code Form is subject to the terms of the Mozilla
10 // Public License v. 2.0. If a copy of the MPL was not distributed
11 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
12 
13 
21 #ifndef EIGEN_MATH_FUNCTIONS_SYCL_H
22 #define EIGEN_MATH_FUNCTIONS_SYCL_H
23 #include "../../InternalHeaderCheck.h"
24 
25 namespace Eigen {
26 
27 namespace internal {
28 
29 // Make sure this is only available when targeting a GPU: we don't want to
30 // introduce conflicts between these packet_traits definitions and the ones
31 // we'll use on the host side (SSE, AVX, ...)
32 #if defined(SYCL_DEVICE_ONLY)
33 #define SYCL_PLOG(packet_type) \
34  template <> \
35  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type plog<packet_type>( \
36  const packet_type& a) { \
37  return cl::sycl::log(a); \
38  }
39 
40 SYCL_PLOG(cl::sycl::cl_float4)
41 SYCL_PLOG(cl::sycl::cl_double2)
42 #undef SYCL_PLOG
43 
44 #define SYCL_PLOG1P(packet_type) \
45  template <> \
46  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type plog1p<packet_type>( \
47  const packet_type& a) { \
48  return cl::sycl::log1p(a); \
49  }
50 
51 SYCL_PLOG1P(cl::sycl::cl_float4)
52 SYCL_PLOG1P(cl::sycl::cl_double2)
53 #undef SYCL_PLOG1P
54 
55 #define SYCL_PLOG10(packet_type) \
56  template <> \
57  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type plog10<packet_type>( \
58  const packet_type& a) { \
59  return cl::sycl::log10(a); \
60  }
61 
62 SYCL_PLOG10(cl::sycl::cl_float4)
63 SYCL_PLOG10(cl::sycl::cl_double2)
64 #undef SYCL_PLOG10
65 
66 #define SYCL_PEXP(packet_type) \
67  template <> \
68  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type pexp<packet_type>( \
69  const packet_type& a) { \
70  return cl::sycl::exp(a); \
71  }
72 
73 SYCL_PEXP(cl::sycl::cl_float4)
74 SYCL_PEXP(cl::sycl::cl_float)
75 SYCL_PEXP(cl::sycl::cl_double2)
76 #undef SYCL_PEXP
77 
78 #define SYCL_PEXPM1(packet_type) \
79  template <> \
80  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type pexpm1<packet_type>( \
81  const packet_type& a) { \
82  return cl::sycl::expm1(a); \
83  }
84 
85 SYCL_PEXPM1(cl::sycl::cl_float4)
86 SYCL_PEXPM1(cl::sycl::cl_double2)
87 #undef SYCL_PEXPM1
88 
89 #define SYCL_PSQRT(packet_type) \
90  template <> \
91  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type psqrt<packet_type>( \
92  const packet_type& a) { \
93  return cl::sycl::sqrt(a); \
94  }
95 
96 SYCL_PSQRT(cl::sycl::cl_float4)
97 SYCL_PSQRT(cl::sycl::cl_double2)
98 #undef SYCL_PSQRT
99 
100 #define SYCL_PRSQRT(packet_type) \
101  template <> \
102  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type prsqrt<packet_type>( \
103  const packet_type& a) { \
104  return cl::sycl::rsqrt(a); \
105  }
106 
107 SYCL_PRSQRT(cl::sycl::cl_float4)
108 SYCL_PRSQRT(cl::sycl::cl_double2)
109 #undef SYCL_PRSQRT
110 
112 #define SYCL_PSIN(packet_type) \
113  template <> \
114  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type psin<packet_type>( \
115  const packet_type& a) { \
116  return cl::sycl::sin(a); \
117  }
118 
119 SYCL_PSIN(cl::sycl::cl_float4)
120 SYCL_PSIN(cl::sycl::cl_double2)
121 #undef SYCL_PSIN
122 
124 #define SYCL_PCOS(packet_type) \
125  template <> \
126  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type pcos<packet_type>( \
127  const packet_type& a) { \
128  return cl::sycl::cos(a); \
129  }
130 
131 SYCL_PCOS(cl::sycl::cl_float4)
132 SYCL_PCOS(cl::sycl::cl_double2)
133 #undef SYCL_PCOS
134 
136 #define SYCL_PTAN(packet_type) \
137  template <> \
138  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type ptan<packet_type>( \
139  const packet_type& a) { \
140  return cl::sycl::tan(a); \
141  }
142 
143 SYCL_PTAN(cl::sycl::cl_float4)
144 SYCL_PTAN(cl::sycl::cl_double2)
145 #undef SYCL_PTAN
146 
148 #define SYCL_PASIN(packet_type) \
149  template <> \
150  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type pasin<packet_type>( \
151  const packet_type& a) { \
152  return cl::sycl::asin(a); \
153  }
154 
155 SYCL_PASIN(cl::sycl::cl_float4)
156 SYCL_PASIN(cl::sycl::cl_double2)
157 #undef SYCL_PASIN
158 
160 #define SYCL_PACOS(packet_type) \
161  template <> \
162  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type pacos<packet_type>( \
163  const packet_type& a) { \
164  return cl::sycl::acos(a); \
165  }
166 
167 SYCL_PACOS(cl::sycl::cl_float4)
168 SYCL_PACOS(cl::sycl::cl_double2)
169 #undef SYCL_PACOS
170 
172 #define SYCL_PATAN(packet_type) \
173  template <> \
174  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type patan<packet_type>( \
175  const packet_type& a) { \
176  return cl::sycl::atan(a); \
177  }
178 
179 SYCL_PATAN(cl::sycl::cl_float4)
180 SYCL_PATAN(cl::sycl::cl_double2)
181 #undef SYCL_PATAN
182 
184 #define SYCL_PSINH(packet_type) \
185  template <> \
186  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type psinh<packet_type>( \
187  const packet_type& a) { \
188  return cl::sycl::sinh(a); \
189  }
190 
191 SYCL_PSINH(cl::sycl::cl_float4)
192 SYCL_PSINH(cl::sycl::cl_double2)
193 #undef SYCL_PSINH
194 
196 #define SYCL_PCOSH(packet_type) \
197  template <> \
198  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type pcosh<packet_type>( \
199  const packet_type& a) { \
200  return cl::sycl::cosh(a); \
201  }
202 
203 SYCL_PCOSH(cl::sycl::cl_float4)
204 SYCL_PCOSH(cl::sycl::cl_double2)
205 #undef SYCL_PCOSH
206 
208 #define SYCL_PTANH(packet_type) \
209  template <> \
210  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type ptanh<packet_type>( \
211  const packet_type& a) { \
212  return cl::sycl::tanh(a); \
213  }
214 
215 SYCL_PTANH(cl::sycl::cl_float4)
216 SYCL_PTANH(cl::sycl::cl_double2)
217 #undef SYCL_PTANH
218 
219 #define SYCL_PCEIL(packet_type) \
220  template <> \
221  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type pceil<packet_type>( \
222  const packet_type& a) { \
223  return cl::sycl::ceil(a); \
224  }
225 
226 SYCL_PCEIL(cl::sycl::cl_float4)
227 SYCL_PCEIL(cl::sycl::cl_double2)
228 #undef SYCL_PCEIL
229 
230 #define SYCL_PROUND(packet_type) \
231  template <> \
232  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type pround<packet_type>( \
233  const packet_type& a) { \
234  return cl::sycl::round(a); \
235  }
236 
237 SYCL_PROUND(cl::sycl::cl_float4)
238 SYCL_PROUND(cl::sycl::cl_double2)
239 #undef SYCL_PROUND
240 
241 #define SYCL_PRINT(packet_type) \
242  template <> \
243  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type print<packet_type>( \
244  const packet_type& a) { \
245  return cl::sycl::rint(a); \
246  }
247 
248 SYCL_PRINT(cl::sycl::cl_float4)
249 SYCL_PRINT(cl::sycl::cl_double2)
250 #undef SYCL_PRINT
251 
252 #define SYCL_FLOOR(packet_type) \
253  template <> \
254  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type pfloor<packet_type>( \
255  const packet_type& a) { \
256  return cl::sycl::floor(a); \
257  }
258 
259 SYCL_FLOOR(cl::sycl::cl_float4)
260 SYCL_FLOOR(cl::sycl::cl_double2)
261 #undef SYCL_FLOOR
262 
263 #define SYCL_PMIN(packet_type, expr) \
264  template <> \
265  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type pmin<packet_type>( \
266  const packet_type& a, const packet_type& b) { \
267  return expr; \
268  }
269 
270 SYCL_PMIN(cl::sycl::cl_float4, cl::sycl::fmin(a, b))
271 SYCL_PMIN(cl::sycl::cl_double2, cl::sycl::fmin(a, b))
272 #undef SYCL_PMIN
273 
274 #define SYCL_PMAX(packet_type, expr) \
275  template <> \
276  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type pmax<packet_type>( \
277  const packet_type& a, const packet_type& b) { \
278  return expr; \
279  }
280 
281 SYCL_PMAX(cl::sycl::cl_float4, cl::sycl::fmax(a, b))
282 SYCL_PMAX(cl::sycl::cl_double2, cl::sycl::fmax(a, b))
283 #undef SYCL_PMAX
284 
285 #define SYCL_PLDEXP(packet_type) \
286  template <> \
287  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type pldexp( \
288  const packet_type& a, const packet_type& exponent) { \
289  return cl::sycl::ldexp( \
290  a, exponent.template convert<cl::sycl::cl_int, \
291  cl::sycl::rounding_mode::automatic>()); \
292  }
293 
294 SYCL_PLDEXP(cl::sycl::cl_float4)
295 SYCL_PLDEXP(cl::sycl::cl_double2)
296 #undef SYCL_PLDEXP
297 
298 #endif
299 } // end namespace internal
300 
301 } // end namespace Eigen
302 
303 #endif // EIGEN_MATH_FUNCTIONS_SYCL_H
a
ArrayXXi a
Definition: Array_initializer_list_23_cxx11.cpp:1
b
Array< int, 3, 1 > b
Definition: Array_variadic_ctor_cxx11.cpp:2
Eigen::bfloat16_impl::fmax
bfloat16 fmax(const bfloat16 &a, const bfloat16 &b)
Definition: BFloat16.h:702
Eigen::bfloat16_impl::fmin
bfloat16 fmin(const bfloat16 &a, const bfloat16 &b)
Definition: BFloat16.h:696
Eigen
: InteropHeaders
Definition: Core:139
Generated on Tue Jul 18 2023 15:28:16 for Eigen by Doxygen 1.9.1 and the doxyYoda theme. This is an unofficial themed variant maintained by Rohit Goswami, based on the official documentation.