Debian Codegraph @

offload/unittests/Conformance/device_code/CUDAMath.cpp

raw
1 //===----------------------------------------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 ///
9 /// \file
10 /// This file contains the implementation of the device kernels that wrap the
11 /// math functions from the cuda-math provider.
12 ///
13 //===----------------------------------------------------------------------===//
14
15 #ifdef CUDA_MATH_FOUND
16
17 #include "Conformance/device_code/DeviceAPIs.hpp"
18 #include "Conformance/device_code/KernelRunner.hpp"
19
20 #include <gpuintrin.h>
21 #include <stddef.h>
22
23 using namespace kernels;
24
25 //===----------------------------------------------------------------------===//
26 // Helpers
27 //===----------------------------------------------------------------------===//
28
29 static inline float powfRoundedExponent(float Base, float Exponent) {
30 return __nv_powf(Base, __nv_roundf(Exponent));
31 }
32
33 static inline double sincosSin(double X) {
34 double SinX, CosX;
35 __nv_sincos(X, &SinX, &CosX);
36 return SinX;
37 }
38
39 static inline double sincosCos(double X) {
40 double SinX, CosX;
41 __nv_sincos(X, &SinX, &CosX);
42 return CosX;
43 }
44
45 static inline float sincosfSin(float X) {
46 float SinX, CosX;
47 __nv_sincosf(X, &SinX, &CosX);
48 return SinX;
49 }
50
51 static inline float sincosfCos(float X) {
52 float SinX, CosX;
53 __nv_sincosf(X, &SinX, &CosX);
54 return CosX;
55 }
56
57 //===----------------------------------------------------------------------===//
58 // Kernels
59 //===----------------------------------------------------------------------===//
60
61 extern "C" {
62
63 __gpu_kernel void acosKernel(const double *X, double *Out,
64 size_t NumElements) noexcept {
65 runKernelBody<__nv_acos>(NumElements, Out, X);
66 }
67
68 __gpu_kernel void acosfKernel(const float *X, float *Out,
69 size_t NumElements) noexcept {
70 runKernelBody<__nv_acosf>(NumElements, Out, X);
71 }
72
73 __gpu_kernel void acoshfKernel(const float *X, float *Out,
74 size_t NumElements) noexcept {
75 runKernelBody<__nv_acoshf>(NumElements, Out, X);
76 }
77
78 __gpu_kernel void asinKernel(const double *X, double *Out,
79 size_t NumElements) noexcept {
80 runKernelBody<__nv_asin>(NumElements, Out, X);
81 }
82
83 __gpu_kernel void asinfKernel(const float *X, float *Out,
84 size_t NumElements) noexcept {
85 runKernelBody<__nv_asinf>(NumElements, Out, X);
86 }
87
88 __gpu_kernel void asinhfKernel(const float *X, float *Out,
89 size_t NumElements) noexcept {
90 runKernelBody<__nv_asinhf>(NumElements, Out, X);
91 }
92
93 __gpu_kernel void atanfKernel(const float *X, float *Out,
94 size_t NumElements) noexcept {
95 runKernelBody<__nv_atanf>(NumElements, Out, X);
96 }
97
98 __gpu_kernel void atan2fKernel(const float *X, const float *Y, float *Out,
99 size_t NumElements) noexcept {
100 runKernelBody<__nv_atan2f>(NumElements, Out, X, Y);
101 }
102
103 __gpu_kernel void atanhfKernel(const float *X, float *Out,
104 size_t NumElements) noexcept {
105 runKernelBody<__nv_atanhf>(NumElements, Out, X);
106 }
107
108 __gpu_kernel void cbrtKernel(const double *X, double *Out,
109 size_t NumElements) noexcept {
110 runKernelBody<__nv_cbrt>(NumElements, Out, X);
111 }
112
113 __gpu_kernel void cbrtfKernel(const float *X, float *Out,
114 size_t NumElements) noexcept {
115 runKernelBody<__nv_cbrtf>(NumElements, Out, X);
116 }
117
118 __gpu_kernel void cosKernel(const double *X, double *Out,
119 size_t NumElements) noexcept {
120 runKernelBody<__nv_cos>(NumElements, Out, X);
121 }
122
123 __gpu_kernel void cosfKernel(const float *X, float *Out,
124 size_t NumElements) noexcept {
125 runKernelBody<__nv_cosf>(NumElements, Out, X);
126 }
127
128 __gpu_kernel void coshfKernel(const float *X, float *Out,
129 size_t NumElements) noexcept {
130 runKernelBody<__nv_coshf>(NumElements, Out, X);
131 }
132
133 __gpu_kernel void cospifKernel(const float *X, float *Out,
134 size_t NumElements) noexcept {
135 runKernelBody<__nv_cospif>(NumElements, Out, X);
136 }
137
138 __gpu_kernel void erffKernel(const float *X, float *Out,
139 size_t NumElements) noexcept {
140 runKernelBody<__nv_erff>(NumElements, Out, X);
141 }
142
143 __gpu_kernel void expKernel(const double *X, double *Out,
144 size_t NumElements) noexcept {
145 runKernelBody<__nv_exp>(NumElements, Out, X);
146 }
147
148 __gpu_kernel void expfKernel(const float *X, float *Out,
149 size_t NumElements) noexcept {
150 runKernelBody<__nv_expf>(NumElements, Out, X);
151 }
152
153 __gpu_kernel void exp10Kernel(const double *X, double *Out,
154 size_t NumElements) noexcept {
155 runKernelBody<__nv_exp10>(NumElements, Out, X);
156 }
157
158 __gpu_kernel void exp10fKernel(const float *X, float *Out,
159 size_t NumElements) noexcept {
160 runKernelBody<__nv_exp10f>(NumElements, Out, X);
161 }
162
163 __gpu_kernel void exp2Kernel(const double *X, double *Out,
164 size_t NumElements) noexcept {
165 runKernelBody<__nv_exp2>(NumElements, Out, X);
166 }
167
168 __gpu_kernel void exp2fKernel(const float *X, float *Out,
169 size_t NumElements) noexcept {
170 runKernelBody<__nv_exp2f>(NumElements, Out, X);
171 }
172
173 __gpu_kernel void expm1Kernel(const double *X, double *Out,
174 size_t NumElements) noexcept {
175 runKernelBody<__nv_expm1>(NumElements, Out, X);
176 }
177
178 __gpu_kernel void expm1fKernel(const float *X, float *Out,
179 size_t NumElements) noexcept {
180 runKernelBody<__nv_expm1f>(NumElements, Out, X);
181 }
182
183 __gpu_kernel void hypotKernel(const double *X, const double *Y, double *Out,
184 size_t NumElements) noexcept {
185 runKernelBody<__nv_hypot>(NumElements, Out, X, Y);
186 }
187
188 __gpu_kernel void hypotfKernel(const float *X, const float *Y, float *Out,
189 size_t NumElements) noexcept {
190 runKernelBody<__nv_hypotf>(NumElements, Out, X, Y);
191 }
192
193 __gpu_kernel void logKernel(const double *X, double *Out,
194 size_t NumElements) noexcept {
195 runKernelBody<__nv_log>(NumElements, Out, X);
196 }
197
198 __gpu_kernel void logfKernel(const float *X, float *Out,
199 size_t NumElements) noexcept {
200 runKernelBody<__nv_logf>(NumElements, Out, X);
201 }
202
203 __gpu_kernel void log10Kernel(const double *X, double *Out,
204 size_t NumElements) noexcept {
205 runKernelBody<__nv_log10>(NumElements, Out, X);
206 }
207
208 __gpu_kernel void log10fKernel(const float *X, float *Out,
209 size_t NumElements) noexcept {
210 runKernelBody<__nv_log10f>(NumElements, Out, X);
211 }
212
213 __gpu_kernel void log1pKernel(const double *X, double *Out,
214 size_t NumElements) noexcept {
215 runKernelBody<__nv_log1p>(NumElements, Out, X);
216 }
217
218 __gpu_kernel void log1pfKernel(const float *X, float *Out,
219 size_t NumElements) noexcept {
220 runKernelBody<__nv_log1pf>(NumElements, Out, X);
221 }
222
223 __gpu_kernel void log2Kernel(const double *X, double *Out,
224 size_t NumElements) noexcept {
225 runKernelBody<__nv_log2>(NumElements, Out, X);
226 }
227
228 __gpu_kernel void log2fKernel(const float *X, float *Out,
229 size_t NumElements) noexcept {
230 runKernelBody<__nv_log2f>(NumElements, Out, X);
231 }
232
233 __gpu_kernel void powfKernel(const float *X, float *Y, float *Out,
234 size_t NumElements) noexcept {
235 runKernelBody<__nv_powf>(NumElements, Out, X, Y);
236 }
237
238 __gpu_kernel void powfRoundedExponentKernel(const float *X, float *Y,
239 float *Out,
240 size_t NumElements) noexcept {
241 runKernelBody<powfRoundedExponent>(NumElements, Out, X, Y);
242 }
243
244 __gpu_kernel void sinKernel(const double *X, double *Out,
245 size_t NumElements) noexcept {
246 runKernelBody<__nv_sin>(NumElements, Out, X);
247 }
248
249 __gpu_kernel void sinfKernel(const float *X, float *Out,
250 size_t NumElements) noexcept {
251 runKernelBody<__nv_sinf>(NumElements, Out, X);
252 }
253
254 __gpu_kernel void sincosSinKernel(const double *X, double *Out,
255 size_t NumElements) noexcept {
256 runKernelBody<sincosSin>(NumElements, Out, X);
257 }
258
259 __gpu_kernel void sincosCosKernel(const double *X, double *Out,
260 size_t NumElements) noexcept {
261 runKernelBody<sincosCos>(NumElements, Out, X);
262 }
263
264 __gpu_kernel void sincosfSinKernel(const float *X, float *Out,
265 size_t NumElements) noexcept {
266 runKernelBody<sincosfSin>(NumElements, Out, X);
267 }
268
269 __gpu_kernel void sincosfCosKernel(const float *X, float *Out,
270 size_t NumElements) noexcept {
271 runKernelBody<sincosfCos>(NumElements, Out, X);
272 }
273
274 __gpu_kernel void sinhfKernel(const float *X, float *Out,
275 size_t NumElements) noexcept {
276 runKernelBody<__nv_sinhf>(NumElements, Out, X);
277 }
278
279 __gpu_kernel void sinpifKernel(const float *X, float *Out,
280 size_t NumElements) noexcept {
281 runKernelBody<__nv_sinpif>(NumElements, Out, X);
282 }
283
284 __gpu_kernel void tanKernel(const double *X, double *Out,
285 size_t NumElements) noexcept {
286 runKernelBody<__nv_tan>(NumElements, Out, X);
287 }
288
289 __gpu_kernel void tanfKernel(const float *X, float *Out,
290 size_t NumElements) noexcept {
291 runKernelBody<__nv_tanf>(NumElements, Out, X);
292 }
293
294 __gpu_kernel void tanhfKernel(const float *X, float *Out,
295 size_t NumElements) noexcept {
296 runKernelBody<__nv_tanhf>(NumElements, Out, X);
297 }
298 } // extern "C"
299
300 #endif // CUDA_MATH_FOUND