Kokkos Core Kernels Package
Version of the Day
Main Page
Related Pages
Namespaces
Classes
Files
File List
All
Classes
Namespaces
Files
Functions
Variables
Typedefs
Enumerations
Enumerator
Friends
Groups
Pages
core
src
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
Generated on Thu Dec 26 2024 09:19:28 for Kokkos Core Kernels Package by
1.8.5