Kokkos Core Kernels Package  Version of the Day
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Groups Pages
Kokkos_Macros.hpp
1 //@HEADER
2 // ************************************************************************
3 //
4 // Kokkos v. 4.0
5 // Copyright (2022) National Technology & Engineering
6 // Solutions of Sandia, LLC (NTESS).
7 //
8 // Under the terms of Contract DE-NA0003525 with NTESS,
9 // the U.S. Government retains certain rights in this software.
10 //
11 // Part of Kokkos, under the Apache License v2.0 with LLVM Exceptions.
12 // See https://kokkos.org/LICENSE for license information.
13 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
14 //
15 //@HEADER
16 
17 #ifndef KOKKOS_MACROS_HPP
18 #define KOKKOS_MACROS_HPP
19 
20 //----------------------------------------------------------------------------
36 #define KOKKOS_VERSION_LESS(MAJOR, MINOR, PATCH) \
37  (KOKKOS_VERSION < ((MAJOR)*10000 + (MINOR)*100 + (PATCH)))
38 
39 #define KOKKOS_VERSION_LESS_EQUAL(MAJOR, MINOR, PATCH) \
40  (KOKKOS_VERSION <= ((MAJOR)*10000 + (MINOR)*100 + (PATCH)))
41 
42 #define KOKKOS_VERSION_GREATER(MAJOR, MINOR, PATCH) \
43  (KOKKOS_VERSION > ((MAJOR)*10000 + (MINOR)*100 + (PATCH)))
44 
45 #define KOKKOS_VERSION_GREATER_EQUAL(MAJOR, MINOR, PATCH) \
46  (KOKKOS_VERSION >= ((MAJOR)*10000 + (MINOR)*100 + (PATCH)))
47 
48 #define KOKKOS_VERSION_EQUAL(MAJOR, MINOR, PATCH) \
49  (KOKKOS_VERSION == ((MAJOR)*10000 + (MINOR)*100 + (PATCH)))
50 
51 #if !KOKKOS_VERSION_EQUAL(KOKKOS_VERSION_MAJOR, KOKKOS_VERSION_MINOR, \
52  KOKKOS_VERSION_PATCH)
53 #error implementation bug
54 #endif
55 
56 #ifndef KOKKOS_DONT_INCLUDE_CORE_CONFIG_H
57 #include <KokkosCore_config.h>
58 #include <impl/Kokkos_DesulAtomicsConfig.hpp>
59 #include <impl/Kokkos_NvidiaGpuArchitectures.hpp>
60 #endif
61 
62 #if !defined(KOKKOS_ENABLE_CXX17)
63 #if __has_include(<version>)
64 #include <version>
65 #else
66 #include <ciso646>
67 #endif
68 #if defined(_GLIBCXX_RELEASE) && _GLIBCXX_RELEASE < 10
69 #error \
70  "Compiling with support for C++20 or later requires a libstdc++ version later than 9"
71 #endif
72 #endif
73 
74 //----------------------------------------------------------------------------
98 //----------------------------------------------------------------------------
99 
100 #if defined(KOKKOS_ENABLE_ATOMICS_BYPASS) && \
101  (defined(KOKKOS_ENABLE_THREADS) || defined(KOKKOS_ENABLE_CUDA) || \
102  defined(KOKKOS_ENABLE_OPENMP) || defined(KOKKOS_ENABLE_HPX) || \
103  defined(KOKKOS_ENABLE_OPENMPTARGET) || defined(KOKKOS_ENABLE_HIP) || \
104  defined(KOKKOS_ENABLE_SYCL) || defined(KOKKOS_ENABLE_OPENACC))
105 #error Atomics may only be disabled if neither a host parallel nor a device backend is enabled
106 #endif
107 
108 #define KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA
109 
110 #include <KokkosCore_Config_SetupBackend.hpp>
111 
112 //----------------------------------------------------------------------------
113 // Mapping compiler built-ins to KOKKOS_COMPILER_*** macros
114 
115 #if defined(__NVCC__)
116 // NVIDIA compiler is being used.
117 // Code is parsed and separated into host and device code.
118 // Host code is compiled again with another compiler.
119 // Device code is compile to 'ptx'.
120 // NOTE: There is no __CUDACC_VER_PATCH__ officially, its __CUDACC_VER_BUILD__
121 // which does have more than one digit (potentially undefined number of them).
122 // This macro definition is in line with our other compiler defs
123 #define KOKKOS_COMPILER_NVCC \
124  __CUDACC_VER_MAJOR__ * 100 + __CUDACC_VER_MINOR__ * 10
125 #endif // #if defined( __NVCC__ )
126 
127 #if !defined(KOKKOS_LAMBDA)
128 #define KOKKOS_LAMBDA [=]
129 #endif
130 
131 #if !defined(KOKKOS_CLASS_LAMBDA)
132 #define KOKKOS_CLASS_LAMBDA [ =, *this ]
133 #endif
134 
135 // #if !defined( __CUDA_ARCH__ ) // Not compiling Cuda code to 'ptx'.
136 
137 // Intel compiler for host code.
138 
139 #if defined(__INTEL_COMPILER)
140 #define KOKKOS_COMPILER_INTEL __INTEL_COMPILER
141 
142 #elif defined(__INTEL_LLVM_COMPILER)
143 #define KOKKOS_COMPILER_INTEL_LLVM __INTEL_LLVM_COMPILER
144 
145 // Cray compiler for device offload code
146 #elif defined(__cray__) && defined(__clang__)
147 #define KOKKOS_COMPILER_CRAY_LLVM \
148  __cray_major__ * 100 + __cray_minor__ * 10 + __cray_patchlevel__
149 
150 #elif defined(_CRAYC)
151 // CRAY compiler for host code
152 #define KOKKOS_COMPILER_CRAYC _CRAYC
153 
154 #elif defined(__APPLE_CC__)
155 #define KOKKOS_COMPILER_APPLECC __APPLE_CC__
156 
157 #elif defined(__NVCOMPILER)
158 #define KOKKOS_COMPILER_NVHPC \
159  __NVCOMPILER_MAJOR__ * 10000 + __NVCOMPILER_MINOR__ * 100 + \
160  __NVCOMPILER_PATCHLEVEL__
161 
162 #elif defined(__clang__)
163 // Check this after the Clang-based proprietary compilers which will also define
164 // __clang__
165 #define KOKKOS_COMPILER_CLANG \
166  __clang_major__ * 100 + __clang_minor__ * 10 + __clang_patchlevel__
167 
168 #elif defined(__GNUC__)
169 // Check this here because many compilers (at least Clang variants and Intel
170 // classic) define `__GNUC__` for compatibility
171 #define KOKKOS_COMPILER_GNU \
172  __GNUC__ * 100 + __GNUC_MINOR__ * 10 + __GNUC_PATCHLEVEL__
173 
174 #if (820 > KOKKOS_COMPILER_GNU)
175 #error "Compiling with GCC version earlier than 8.2.0 is not supported."
176 #endif
177 
178 #elif defined(_MSC_VER)
179 // Check this after Intel and Clang because those define _MSC_VER for
180 // compatibility
181 #define KOKKOS_COMPILER_MSVC _MSC_VER
182 #endif
183 
184 #if defined(_OPENMP)
185 // Compiling with OpenMP.
186 // The value of _OPENMP is an integer value YYYYMM
187 // where YYYY and MM are the year and month designation
188 // of the supported OpenMP API version.
189 #endif // #if defined( _OPENMP )
190 
191 //----------------------------------------------------------------------------
192 // Intel compiler macros
193 
194 #if defined(KOKKOS_COMPILER_INTEL) || defined(KOKKOS_COMPILER_INTEL_LLVM)
195 #if defined(KOKKOS_COMPILER_INTEL_LLVM) && \
196  KOKKOS_COMPILER_INTEL_LLVM >= 20230100
197 #define KOKKOS_ENABLE_PRAGMA_UNROLL 1
198 #define KOKKOS_ENABLE_PRAGMA_LOOPCOUNT 1
199 #define KOKKOS_ENABLE_PRAGMA_VECTOR 1
200 
201 #define KOKKOS_ENABLE_PRAGMA_IVDEP 1
202 #endif
203 
204 #if !defined(KOKKOS_MEMORY_ALIGNMENT)
205 #define KOKKOS_MEMORY_ALIGNMENT 64
206 #endif
207 
208 #if defined(_WIN32)
209 #define KOKKOS_RESTRICT __restrict
210 #else
211 #define KOKKOS_RESTRICT __restrict__
212 #endif
213 
214 #ifndef KOKKOS_IMPL_ALIGN_PTR
215 #if defined(_WIN32)
216 #define KOKKOS_IMPL_ALIGN_PTR(size) __declspec(align_value(size))
217 #else
218 #define KOKKOS_IMPL_ALIGN_PTR(size) __attribute__((align_value(size)))
219 #endif
220 #endif
221 
222 #if defined(KOKKOS_COMPILER_INTEL) && (1900 > KOKKOS_COMPILER_INTEL)
223 #error "Compiling with Intel version earlier than 19.0.5 is not supported."
224 #endif
225 
226 #if !defined(KOKKOS_ENABLE_ASM) && !defined(_WIN32)
227 #define KOKKOS_ENABLE_ASM 1
228 #endif
229 
230 #if !defined(KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION)
231 #if !defined(_WIN32)
232 #define KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION \
233  inline __attribute__((always_inline))
234 #define KOKKOS_IMPL_HOST_FORCEINLINE __attribute__((always_inline))
235 #else
236 #define KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION inline
237 #endif
238 #endif
239 
240 #if defined(__MIC__)
241 // Compiling for Xeon Phi
242 #endif
243 #endif
244 
245 //----------------------------------------------------------------------------
246 // Cray compiler macros
247 
248 #if defined(KOKKOS_COMPILER_CRAYC)
249 #endif
250 
251 //----------------------------------------------------------------------------
252 // CLANG compiler macros
253 
254 #if defined(KOKKOS_COMPILER_CLANG)
255 // #define KOKKOS_ENABLE_PRAGMA_UNROLL 1
256 // #define KOKKOS_ENABLE_PRAGMA_IVDEP 1
257 // #define KOKKOS_ENABLE_PRAGMA_LOOPCOUNT 1
258 // #define KOKKOS_ENABLE_PRAGMA_VECTOR 1
259 
260 #if !defined(KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION)
261 #define KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION \
262  inline __attribute__((always_inline))
263 #define KOKKOS_IMPL_HOST_FORCEINLINE __attribute__((always_inline))
264 #endif
265 
266 #if !defined(KOKKOS_IMPL_ALIGN_PTR)
267 #define KOKKOS_IMPL_ALIGN_PTR(size) __attribute__((aligned(size)))
268 #endif
269 
270 #endif
271 
272 //----------------------------------------------------------------------------
273 // GNU Compiler macros
274 
275 #if defined(KOKKOS_COMPILER_GNU)
276 // #define KOKKOS_ENABLE_PRAGMA_UNROLL 1
277 // #define KOKKOS_ENABLE_PRAGMA_IVDEP 1
278 // #define KOKKOS_ENABLE_PRAGMA_LOOPCOUNT 1
279 // #define KOKKOS_ENABLE_PRAGMA_VECTOR 1
280 
281 #if !defined(KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION)
282 #define KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION \
283  inline __attribute__((always_inline))
284 #define KOKKOS_IMPL_HOST_FORCEINLINE __attribute__((always_inline))
285 #endif
286 
287 #define KOKKOS_RESTRICT __restrict__
288 
289 #if !defined(KOKKOS_ENABLE_ASM) && !defined(__PGIC__) && \
290  (defined(__amd64) || defined(__amd64__) || defined(__x86_64) || \
291  defined(__x86_64__) || defined(__PPC64__))
292 #define KOKKOS_ENABLE_ASM 1
293 #endif
294 #endif
295 
296 //----------------------------------------------------------------------------
297 
298 #if defined(KOKKOS_COMPILER_NVHPC)
299 #define KOKKOS_ENABLE_PRAGMA_UNROLL 1
300 #define KOKKOS_ENABLE_PRAGMA_IVDEP 1
301 // #define KOKKOS_ENABLE_PRAGMA_LOOPCOUNT 1
302 #define KOKKOS_ENABLE_PRAGMA_VECTOR 1
303 #endif
304 
305 //----------------------------------------------------------------------------
306 
307 #if defined(KOKKOS_COMPILER_NVCC)
308 #if defined(__CUDA_ARCH__)
309 #define KOKKOS_ENABLE_PRAGMA_UNROLL 1
310 #endif
311 #endif
312 
313 //----------------------------------------------------------------------------
314 // Define function marking macros if compiler specific macros are undefined:
315 
316 #if !defined(KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION)
317 #define KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION inline
318 #endif
319 
320 #if !defined(KOKKOS_IMPL_HOST_FORCEINLINE)
321 #define KOKKOS_IMPL_HOST_FORCEINLINE inline
322 #endif
323 
324 #if !defined(KOKKOS_IMPL_FORCEINLINE_FUNCTION)
325 #define KOKKOS_IMPL_FORCEINLINE_FUNCTION KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
326 #endif
327 
328 #if !defined(KOKKOS_IMPL_FORCEINLINE)
329 #define KOKKOS_IMPL_FORCEINLINE KOKKOS_IMPL_HOST_FORCEINLINE
330 #endif
331 
332 #if !defined(KOKKOS_IMPL_INLINE_FUNCTION)
333 #define KOKKOS_IMPL_INLINE_FUNCTION inline
334 #endif
335 
336 #if !defined(KOKKOS_IMPL_FUNCTION)
337 #define KOKKOS_IMPL_FUNCTION
338 #endif
339 
340 #if !defined(KOKKOS_INLINE_FUNCTION_DELETED)
341 #define KOKKOS_INLINE_FUNCTION_DELETED
342 #endif
343 
344 #if !defined(KOKKOS_DEFAULTED_FUNCTION)
345 #define KOKKOS_DEFAULTED_FUNCTION
346 #endif
347 
348 #if !defined(KOKKOS_DEDUCTION_GUIDE)
349 #define KOKKOS_DEDUCTION_GUIDE
350 #endif
351 
352 #if !defined(KOKKOS_IMPL_HOST_FUNCTION)
353 #define KOKKOS_IMPL_HOST_FUNCTION
354 #endif
355 
356 #if !defined(KOKKOS_IMPL_DEVICE_FUNCTION)
357 #define KOKKOS_IMPL_DEVICE_FUNCTION
358 #endif
359 
360 // FIXME_OPENACC FIXME_OPENMPTARGET
361 // Move to setup files once there is more content
362 // clang-format off
363 #if defined(KOKKOS_ENABLE_OPENACC)
364 #define KOKKOS_IMPL_RELOCATABLE_FUNCTION @"KOKKOS_RELOCATABLE_FUNCTION is not supported for the OpenACC backend"
365 #endif
366 #if defined(KOKKOS_ENABLE_OPENMPTARGET)
367 #define KOKKOS_IMPL_RELOCATABLE_FUNCTION @"KOKKOS_RELOCATABLE_FUNCTION is not supported for the OpenMPTarget backend"
368 #endif
369 // clang-format on
370 
371 #if !defined(KOKKOS_IMPL_RELOCATABLE_FUNCTION)
372 #define KOKKOS_IMPL_RELOCATABLE_FUNCTION
373 #endif
374 
375 //----------------------------------------------------------------------------
376 // Define final version of functions. This is so that clang tidy can find these
377 // macros more easily
378 #if defined(__clang_analyzer__)
379 #define KOKKOS_FUNCTION \
380  KOKKOS_IMPL_FUNCTION __attribute__((annotate("KOKKOS_FUNCTION")))
381 #define KOKKOS_INLINE_FUNCTION \
382  KOKKOS_IMPL_INLINE_FUNCTION \
383  __attribute__((annotate("KOKKOS_INLINE_FUNCTION")))
384 #define KOKKOS_FORCEINLINE_FUNCTION \
385  KOKKOS_IMPL_FORCEINLINE_FUNCTION \
386  __attribute__((annotate("KOKKOS_FORCEINLINE_FUNCTION")))
387 #define KOKKOS_RELOCATABLE_FUNCTION \
388  KOKKOS_IMPL_RELOCATABLE_FUNCTION \
389  __attribute__((annotate("KOKKOS_RELOCATABLE_FUNCTION")))
390 #else
391 #define KOKKOS_FUNCTION KOKKOS_IMPL_FUNCTION
392 #define KOKKOS_INLINE_FUNCTION KOKKOS_IMPL_INLINE_FUNCTION
393 #define KOKKOS_FORCEINLINE_FUNCTION KOKKOS_IMPL_FORCEINLINE_FUNCTION
394 #define KOKKOS_RELOCATABLE_FUNCTION KOKKOS_IMPL_RELOCATABLE_FUNCTION
395 #endif
396 
397 //----------------------------------------------------------------------------
398 // Define empty macro for restrict if necessary:
399 
400 #if !defined(KOKKOS_RESTRICT)
401 #define KOKKOS_RESTRICT
402 #endif
403 
404 //----------------------------------------------------------------------------
405 // Define Macro for alignment:
406 
407 #if !defined(KOKKOS_MEMORY_ALIGNMENT)
408 #define KOKKOS_MEMORY_ALIGNMENT 64
409 #endif
410 
411 #if !defined(KOKKOS_MEMORY_ALIGNMENT_THRESHOLD)
412 #define KOKKOS_MEMORY_ALIGNMENT_THRESHOLD 1
413 #endif
414 
415 #if !defined(KOKKOS_IMPL_ALIGN_PTR)
416 #define KOKKOS_IMPL_ALIGN_PTR(size) /* */
417 #endif
418 
419 //----------------------------------------------------------------------------
420 // Determine the default execution space for parallel dispatch.
421 // There is zero or one default execution space specified.
422 
423 #if 1 < ((defined(KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_CUDA) ? 1 : 0) + \
424  (defined(KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_HIP) ? 1 : 0) + \
425  (defined(KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_SYCL) ? 1 : 0) + \
426  (defined(KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_OPENACC) ? 1 : 0) + \
427  (defined(KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_OPENMPTARGET) ? 1 : 0) + \
428  (defined(KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_OPENMP) ? 1 : 0) + \
429  (defined(KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_THREADS) ? 1 : 0) + \
430  (defined(KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_HPX) ? 1 : 0) + \
431  (defined(KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_SERIAL) ? 1 : 0))
432 #error "More than one KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_* specified."
433 #endif
434 
435 // If default is not specified then chose from enabled execution spaces.
436 // Priority: CUDA, HIP, SYCL, OPENACC, OPENMPTARGET, OPENMP, THREADS, HPX,
437 // SERIAL
438 #if defined(KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_CUDA)
439 #elif defined(KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_HIP)
440 #elif defined(KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_SYCL)
441 #elif defined(KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_OPENACC)
442 #elif defined(KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_OPENMPTARGET)
443 #elif defined(KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_OPENMP)
444 #elif defined(KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_THREADS)
445 #elif defined(KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_HPX)
446 #elif defined(KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_SERIAL)
447 #elif defined(KOKKOS_ENABLE_CUDA)
448 #define KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_CUDA
449 #elif defined(KOKKOS_ENABLE_HIP)
450 #define KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_HIP
451 #elif defined(KOKKOS_ENABLE_SYCL)
452 #define KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_SYCL
453 #elif defined(KOKKOS_ENABLE_OPENACC)
454 #define KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_OPENACC
455 #elif defined(KOKKOS_ENABLE_OPENMPTARGET)
456 #define KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_OPENMPTARGET
457 #elif defined(KOKKOS_ENABLE_OPENMP)
458 #define KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_OPENMP
459 #elif defined(KOKKOS_ENABLE_THREADS)
460 #define KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_THREADS
461 #elif defined(KOKKOS_ENABLE_HPX)
462 #define KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_HPX
463 #else
464 #define KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_SERIAL
465 #endif
466 
467 //----------------------------------------------------------------------------
468 
469 // Remove surrounding parentheses if present
470 #define KOKKOS_IMPL_STRIP_PARENS(X) KOKKOS_IMPL_ESC(KOKKOS_IMPL_ISH X)
471 #define KOKKOS_IMPL_ISH(...) KOKKOS_IMPL_ISH __VA_ARGS__
472 #define KOKKOS_IMPL_ESC(...) KOKKOS_IMPL_ESC_(__VA_ARGS__)
473 #define KOKKOS_IMPL_ESC_(...) KOKKOS_IMPL_VAN_##__VA_ARGS__
474 #define KOKKOS_IMPL_VAN_KOKKOS_IMPL_ISH
475 
476 #if defined(KOKKOS_ENABLE_CUDA) && defined(KOKKOS_COMPILER_NVHPC)
477 #include <nv/target>
478 #define KOKKOS_IF_ON_DEVICE(CODE) NV_IF_TARGET(NV_IS_DEVICE, CODE)
479 #define KOKKOS_IF_ON_HOST(CODE) NV_IF_TARGET(NV_IS_HOST, CODE)
480 #endif
481 
482 #ifdef KOKKOS_ENABLE_OPENMPTARGET
483 #ifdef KOKKOS_COMPILER_NVHPC
484 #define KOKKOS_IF_ON_DEVICE(CODE) \
485  if (__builtin_is_device_code()) { \
486  KOKKOS_IMPL_STRIP_PARENS(CODE) \
487  }
488 #define KOKKOS_IF_ON_HOST(CODE) \
489  if (!__builtin_is_device_code()) { \
490  KOKKOS_IMPL_STRIP_PARENS(CODE) \
491  }
492 #else
493 // Base function.
494 static constexpr bool kokkos_omp_on_host() { return true; }
495 
496 #pragma omp begin declare variant match(device = {kind(host)})
497 static constexpr bool kokkos_omp_on_host() { return true; }
498 #pragma omp end declare variant
499 
500 #pragma omp begin declare variant match(device = {kind(nohost)})
501 static constexpr bool kokkos_omp_on_host() { return false; }
502 #pragma omp end declare variant
503 
504 #define KOKKOS_IF_ON_DEVICE(CODE) \
505  if constexpr (!kokkos_omp_on_host()) { \
506  KOKKOS_IMPL_STRIP_PARENS(CODE) \
507  }
508 #define KOKKOS_IF_ON_HOST(CODE) \
509  if constexpr (kokkos_omp_on_host()) { \
510  KOKKOS_IMPL_STRIP_PARENS(CODE) \
511  }
512 #endif
513 #endif
514 
515 #ifdef KOKKOS_ENABLE_OPENACC
516 #ifdef KOKKOS_COMPILER_NVHPC
517 #define KOKKOS_IF_ON_DEVICE(CODE) \
518  if (__builtin_is_device_code()) { \
519  KOKKOS_IMPL_STRIP_PARENS(CODE) \
520  }
521 #define KOKKOS_IF_ON_HOST(CODE) \
522  if (!__builtin_is_device_code()) { \
523  KOKKOS_IMPL_STRIP_PARENS(CODE) \
524  }
525 #else
526 #include <openacc.h>
527 // FIXME_OPENACC acc_on_device is a non-constexpr function
528 #define KOKKOS_IF_ON_DEVICE(CODE) \
529  if constexpr (acc_on_device(acc_device_not_host)) { \
530  KOKKOS_IMPL_STRIP_PARENS(CODE) \
531  }
532 #define KOKKOS_IF_ON_HOST(CODE) \
533  if constexpr (acc_on_device(acc_device_host)) { \
534  KOKKOS_IMPL_STRIP_PARENS(CODE) \
535  }
536 #endif
537 #endif
538 
539 #if !defined(KOKKOS_IF_ON_HOST) && !defined(KOKKOS_IF_ON_DEVICE)
540 #if (defined(KOKKOS_ENABLE_CUDA) && defined(__CUDA_ARCH__)) || \
541  (defined(KOKKOS_ENABLE_HIP) && defined(__HIP_DEVICE_COMPILE__)) || \
542  (defined(KOKKOS_ENABLE_SYCL) && defined(__SYCL_DEVICE_ONLY__))
543 #define KOKKOS_IF_ON_DEVICE(CODE) \
544  { KOKKOS_IMPL_STRIP_PARENS(CODE) }
545 #define KOKKOS_IF_ON_HOST(CODE) \
546  {}
547 #else
548 #define KOKKOS_IF_ON_DEVICE(CODE) \
549  {}
550 #define KOKKOS_IF_ON_HOST(CODE) \
551  { KOKKOS_IMPL_STRIP_PARENS(CODE) }
552 #endif
553 #endif
554 
555 //----------------------------------------------------------------------------
556 // If compiling with CUDA, we must use relocatable device code to enable the
557 // task policy.
558 
559 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE_4
560 #if defined(KOKKOS_ENABLE_CUDA)
561 #if defined(KOKKOS_ENABLE_CUDA_RELOCATABLE_DEVICE_CODE)
562 #define KOKKOS_ENABLE_TASKDAG
563 #endif
564 // FIXME_SYCL Tasks not implemented
565 #elif !defined(KOKKOS_ENABLE_HIP) && !defined(KOKKOS_ENABLE_SYCL) && \
566  !defined(KOKKOS_ENABLE_OPENMPTARGET)
567 #define KOKKOS_ENABLE_TASKDAG
568 #endif
569 #endif
570 
571 #if defined(KOKKOS_ENABLE_CUDA) && defined(KOKKOS_ENABLE_DEPRECATED_CODE_4)
572 #define KOKKOS_ENABLE_CUDA_LDG_INTRINSIC
573 #endif
574 
575 #define KOKKOS_INVALID_INDEX (~std::size_t(0))
576 
577 #define KOKKOS_IMPL_CTOR_DEFAULT_ARG KOKKOS_INVALID_INDEX
578 
579 // Guard intel compiler version 19 and older
580 // intel error #2651: attribute does not apply to any entity
581 // using <deprecated_type> KOKKOS_DEPRECATED = ...
582 #if defined(KOKKOS_ENABLE_DEPRECATION_WARNINGS) && !defined(__NVCC__) && \
583  (!defined(KOKKOS_COMPILER_INTEL) || KOKKOS_COMPILER_INTEL >= 2021)
584 #define KOKKOS_DEPRECATED [[deprecated]]
585 #define KOKKOS_DEPRECATED_WITH_COMMENT(comment) [[deprecated(comment)]]
586 #else
587 #define KOKKOS_DEPRECATED
588 #define KOKKOS_DEPRECATED_WITH_COMMENT(comment)
589 #endif
590 
591 #define KOKKOS_IMPL_STRINGIFY(x) #x
592 #define KOKKOS_IMPL_TOSTRING(x) KOKKOS_IMPL_STRINGIFY(x)
593 
594 #ifdef _MSC_VER
595 #define KOKKOS_IMPL_DO_PRAGMA(x) __pragma(x)
596 #define KOKKOS_IMPL_WARNING(desc) \
597  KOKKOS_IMPL_DO_PRAGMA(message( \
598  __FILE__ "(" KOKKOS_IMPL_TOSTRING(__LINE__) ") : warning: " #desc))
599 #else
600 #define KOKKOS_IMPL_DO_PRAGMA(x) _Pragma(#x)
601 #define KOKKOS_IMPL_WARNING(desc) KOKKOS_IMPL_DO_PRAGMA(message(#desc))
602 #endif
603 
604 // clang-format off
605 #if defined(__NVCOMPILER)
606  #define KOKKOS_IMPL_DISABLE_DEPRECATED_WARNINGS_PUSH() \
607  _Pragma("diag_suppress 1216") \
608  _Pragma("diag_suppress deprecated_entity_with_custom_message")
609  #define KOKKOS_IMPL_DISABLE_DEPRECATED_WARNINGS_POP() \
610  _Pragma("diag_default 1216") \
611  _Pragma("diag_suppress deprecated_entity_with_custom_message")
612 #elif defined(__EDG__)
613  #define KOKKOS_IMPL_DISABLE_DEPRECATED_WARNINGS_PUSH() \
614  _Pragma("warning push") \
615  _Pragma("warning disable 1478")
616  #define KOKKOS_IMPL_DISABLE_DEPRECATED_WARNINGS_POP() \
617  _Pragma("warning pop")
618 #elif defined(__GNUC__) || defined(__clang__)
619  #define KOKKOS_IMPL_DISABLE_DEPRECATED_WARNINGS_PUSH() \
620  _Pragma("GCC diagnostic push") \
621  _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"")
622  #define KOKKOS_IMPL_DISABLE_DEPRECATED_WARNINGS_POP() \
623  _Pragma("GCC diagnostic pop")
624 #elif defined(_MSC_VER)
625  #define KOKKOS_IMPL_DISABLE_DEPRECATED_WARNINGS_PUSH() \
626  _Pragma("warning(push)") \
627  _Pragma("warning(disable: 4996)")
628  #define KOKKOS_IMPL_DISABLE_DEPRECATED_WARNINGS_POP() \
629  _Pragma("warning(pop)")
630 #else
631  #define KOKKOS_IMPL_DISABLE_DEPRECATED_WARNINGS_PUSH()
632  #define KOKKOS_IMPL_DISABLE_DEPRECATED_WARNINGS_POP()
633 #endif
634 
635 #if defined(__NVCOMPILER)
636 #define KOKKOS_IMPL_DISABLE_UNREACHABLE_WARNINGS_PUSH() \
637  _Pragma("diag_suppress code_is_unreachable") \
638  _Pragma("diag_suppress initialization_not_reachable")
639 #define KOKKOS_IMPL_DISABLE_UNREACHABLE_WARNINGS_POP() \
640  _Pragma("diag_default code_is_unreachable") \
641  _Pragma("diag_default initialization_not_reachable")
642 #else
643 #define KOKKOS_IMPL_DISABLE_UNREACHABLE_WARNINGS_PUSH()
644 #define KOKKOS_IMPL_DISABLE_UNREACHABLE_WARNINGS_POP()
645 #endif
646 // clang-format on
647 
648 #define KOKKOS_ATTRIBUTE_NODISCARD [[nodiscard]]
649 
650 #ifndef KOKKOS_ENABLE_CXX17
651 #define KOKKOS_IMPL_ATTRIBUTE_UNLIKELY [[unlikely]]
652 #else
653 #define KOKKOS_IMPL_ATTRIBUTE_UNLIKELY
654 #endif
655 
656 #if (defined(KOKKOS_COMPILER_GNU) || defined(KOKKOS_COMPILER_CLANG) || \
657  defined(KOKKOS_COMPILER_INTEL) || defined(KOKKOS_COMPILER_INTEL_LLVM) || \
658  defined(KOKKOS_COMPILER_NVHPC)) && \
659  !defined(_WIN32) && !defined(__ANDROID__)
660 #if __has_include(<execinfo.h>)
661 #define KOKKOS_IMPL_ENABLE_STACKTRACE
662 #endif
663 #define KOKKOS_IMPL_ENABLE_CXXABI
664 #endif
665 
666 // WORKAROUND for AMD aomp which apparently defines CUDA_ARCH when building for
667 // AMD GPUs with OpenMP Target ???
668 #if defined(__CUDA_ARCH__) && !defined(__CUDACC__) && \
669  !defined(KOKKOS_ENABLE_HIP) && !defined(KOKKOS_ENABLE_CUDA)
670 #undef __CUDA_ARCH__
671 #endif
672 
673 #if (defined(KOKKOS_IMPL_WINDOWS_CUDA) || defined(KOKKOS_COMPILER_MSVC)) && \
674  !defined(KOKKOS_COMPILER_CLANG)
675 // MSVC (as of 16.5.5 at least) does not do empty base class optimization by
676 // default when there are multiple bases, even though the standard requires it
677 // for standard layout types.
678 #define KOKKOS_IMPL_ENFORCE_EMPTY_BASE_OPTIMIZATION __declspec(empty_bases)
679 #else
680 #define KOKKOS_IMPL_ENFORCE_EMPTY_BASE_OPTIMIZATION
681 #endif
682 
683 #endif // #ifndef KOKKOS_MACROS_HPP