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
/*
2
//@HEADER
3
// ************************************************************************
4
//
5
// Kokkos v. 3.0
6
// Copyright (2020) National Technology & Engineering
7
// Solutions of Sandia, LLC (NTESS).
8
//
9
// Under the terms of Contract DE-NA0003525 with NTESS,
10
// the U.S. Government retains certain rights in this software.
11
//
12
// Redistribution and use in source and binary forms, with or without
13
// modification, are permitted provided that the following conditions are
14
// met:
15
//
16
// 1. Redistributions of source code must retain the above copyright
17
// notice, this list of conditions and the following disclaimer.
18
//
19
// 2. Redistributions in binary form must reproduce the above copyright
20
// notice, this list of conditions and the following disclaimer in the
21
// documentation and/or other materials provided with the distribution.
22
//
23
// 3. Neither the name of the Corporation nor the names of the
24
// contributors may be used to endorse or promote products derived from
25
// this software without specific prior written permission.
26
//
27
// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
28
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
29
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
30
// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
31
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
32
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
33
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
34
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
35
// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
36
// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
37
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
38
//
39
// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
40
//
41
// ************************************************************************
42
//@HEADER
43
*/
44
45
#ifndef KOKKOS_MACROS_HPP
46
#define KOKKOS_MACROS_HPP
47
48
//----------------------------------------------------------------------------
63
#ifndef KOKKOS_DONT_INCLUDE_CORE_CONFIG_H
64
#include <KokkosCore_config.h>
65
#endif
66
67
#include <impl/Kokkos_OldMacros.hpp>
68
69
//----------------------------------------------------------------------------
100
//----------------------------------------------------------------------------
101
102
#if defined(KOKKOS_ENABLE_SERIAL) || defined(KOKKOS_ENABLE_THREADS) || \
103
defined(KOKKOS_ENABLE_OPENMP) || defined(KOKKOS_ENABLE_HPX) || \
104
defined(KOKKOS_ENABLE_ROCM) || defined(KOKKOS_ENABLE_OPENMPTARGET) || \
105
defined(KOKKOS_ENABLE_HIP)
106
#define KOKKOS_INTERNAL_ENABLE_NON_CUDA_BACKEND
107
#endif
108
109
#if !defined(KOKKOS_ENABLE_THREADS) && !defined(KOKKOS_ENABLE_CUDA) && \
110
!defined(KOKKOS_ENABLE_OPENMP) && !defined(KOKKOS_ENABLE_HPX) && \
111
!defined(KOKKOS_ENABLE_ROCM) && !defined(KOKKOS_ENABLE_OPENMPTARGET) && \
112
!defined(KOKKOS_ENABLE_HIP)
113
#define KOKKOS_INTERNAL_NOT_PARALLEL
114
#endif
115
116
#define KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA
117
118
#if defined(KOKKOS_ENABLE_CUDA) && defined(__CUDACC__)
119
// Compiling with a CUDA compiler.
120
//
121
// Include <cuda.h> to pick up the CUDA_VERSION macro defined as:
122
// CUDA_VERSION = ( MAJOR_VERSION * 1000 ) + ( MINOR_VERSION * 10 )
123
//
124
// When generating device code the __CUDA_ARCH__ macro is defined as:
125
// __CUDA_ARCH__ = ( MAJOR_CAPABILITY * 100 ) + ( MINOR_CAPABILITY * 10 )
126
127
#include <cuda_runtime.h>
128
#include <cuda.h>
129
130
#if !defined(CUDA_VERSION)
131
#error "#include <cuda.h> did not define CUDA_VERSION."
132
#endif
133
134
#if defined(__CUDA_ARCH__) && (__CUDA_ARCH__ < 300)
135
// Compiling with CUDA compiler for device code.
136
#error "Cuda device capability >= 3.0 is required."
137
#endif
138
139
#ifdef KOKKOS_ENABLE_CUDA_LAMBDA
140
#define KOKKOS_LAMBDA [=] __host__ __device__
141
142
#if defined(KOKKOS_ENABLE_CXX17) || defined(KOKKOS_ENABLE_CXX20)
143
#define KOKKOS_CLASS_LAMBDA [ =, *this ] __host__ __device__
144
#endif
145
146
#if defined(__NVCC__)
147
#define KOKKOS_IMPL_NEED_FUNCTOR_WRAPPER
148
#endif
149
#else // !defined(KOKKOS_ENABLE_CUDA_LAMBDA)
150
#undef KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA
151
#endif // !defined(KOKKOS_ENABLE_CUDA_LAMBDA)
152
153
#if (10000 > CUDA_VERSION)
154
#define KOKKOS_ENABLE_PRE_CUDA_10_DEPRECATION_API
155
#endif
156
157
#if defined(__CUDA_ARCH__) && (__CUDA_ARCH__ >= 700)
158
// PTX atomics with memory order semantics are only available on volta and later
159
#if !defined(KOKKOS_DISABLE_CUDA_ASM)
160
#if !defined(KOKKOS_ENABLE_CUDA_ASM)
161
#define KOKKOS_ENABLE_CUDA_ASM
162
#if !defined(KOKKOS_DISABLE_CUDA_ASM_ATOMICS)
163
#define KOKKOS_ENABLE_CUDA_ASM_ATOMICS
164
#endif
165
#endif
166
#endif
167
#endif
168
169
#endif // #if defined( KOKKOS_ENABLE_CUDA ) && defined( __CUDACC__ )
170
171
#if defined(KOKKOS_ENABLE_HIP)
172
173
#define KOKKOS_IMPL_HIP_CLANG_WORKAROUND
174
175
#define HIP_ENABLE_PRINTF
176
#include <hip/hip_runtime.h>
177
#include <hip/hip_runtime_api.h>
178
179
#define KOKKOS_LAMBDA [=] __host__ __device__
180
#endif // #if defined(KOKKOS_ENABLE_HIP)
181
182
//----------------------------------------------------------------------------
183
// Mapping compiler built-ins to KOKKOS_COMPILER_*** macros
184
185
#if defined(__NVCC__)
186
// NVIDIA compiler is being used.
187
// Code is parsed and separated into host and device code.
188
// Host code is compiled again with another compiler.
189
// Device code is compile to 'ptx'.
190
#define KOKKOS_COMPILER_NVCC __NVCC__
191
#endif // #if defined( __NVCC__ )
192
193
#if !defined(KOKKOS_LAMBDA)
194
#define KOKKOS_LAMBDA [=]
195
#endif
196
197
#if (defined(KOKKOS_ENABLE_CXX17) || defined(KOKKOS_ENABLE_CXX20)) && \
198
!defined(KOKKOS_CLASS_LAMBDA)
199
#define KOKKOS_CLASS_LAMBDA [ =, *this ]
200
#endif
201
202
//#if !defined( __CUDA_ARCH__ ) // Not compiling Cuda code to 'ptx'.
203
204
// Intel compiler for host code.
205
206
#if defined(__INTEL_COMPILER)
207
#define KOKKOS_COMPILER_INTEL __INTEL_COMPILER
208
#elif defined(__ICC)
209
// Old define
210
#define KOKKOS_COMPILER_INTEL __ICC
211
#elif defined(__ECC)
212
// Very old define
213
#define KOKKOS_COMPILER_INTEL __ECC
214
#endif
215
216
// CRAY compiler for host code
217
#if defined(_CRAYC)
218
#define KOKKOS_COMPILER_CRAYC _CRAYC
219
#endif
220
221
#if defined(__IBMCPP__)
222
// IBM C++
223
#define KOKKOS_COMPILER_IBM __IBMCPP__
224
#elif defined(__IBMC__)
225
#define KOKKOS_COMPILER_IBM __IBMC__
226
#endif
227
228
#if defined(__APPLE_CC__)
229
#define KOKKOS_COMPILER_APPLECC __APPLE_CC__
230
#endif
231
232
#if defined(__clang__) && !defined(KOKKOS_COMPILER_INTEL)
233
#define KOKKOS_COMPILER_CLANG \
234
__clang_major__ * 100 + __clang_minor__ * 10 + __clang_patchlevel__
235
#endif
236
237
#if !defined(__clang__) && !defined(KOKKOS_COMPILER_INTEL) && defined(__GNUC__)
238
#define KOKKOS_COMPILER_GNU \
239
__GNUC__ * 100 + __GNUC_MINOR__ * 10 + __GNUC_PATCHLEVEL__
240
241
#if (472 > KOKKOS_COMPILER_GNU)
242
#error "Compiling with GCC version earlier than 4.7.2 is not supported."
243
#endif
244
#endif
245
246
#if defined(__PGIC__)
247
#define KOKKOS_COMPILER_PGI \
248
__PGIC__ * 100 + __PGIC_MINOR__ * 10 + __PGIC_PATCHLEVEL__
249
250
#if (1540 > KOKKOS_COMPILER_PGI)
251
#error "Compiling with PGI version earlier than 15.4 is not supported."
252
#endif
253
#endif
254
255
#if defined(_MSC_VER) && !defined(KOKKOS_COMPILER_INTEL)
256
#define KOKKOS_COMPILER_MSVC _MSC_VER
257
#endif
258
259
//#endif // #if !defined( __CUDA_ARCH__ )
260
//----------------------------------------------------------------------------
261
// Language info: C++, CUDA, OPENMP
262
263
#if defined(KOKKOS_ENABLE_CUDA)
264
// Compiling Cuda code to 'ptx'
265
266
#define KOKKOS_FORCEINLINE_FUNCTION __device__ __host__ __forceinline__
267
#define KOKKOS_IMPL_FORCEINLINE __forceinline__
268
#define KOKKOS_INLINE_FUNCTION __device__ __host__ inline
269
#define KOKKOS_FUNCTION __device__ __host__
270
#if defined(KOKKOS_COMPILER_NVCC)
271
#define KOKKOS_INLINE_FUNCTION_DELETED inline
272
#else
273
#define KOKKOS_INLINE_FUNCTION_DELETED __device__ __host__ inline
274
#endif
275
#if (CUDA_VERSION < 10000)
276
#define KOKKOS_DEFAULTED_FUNCTION __host__ __device__ inline
277
#else
278
#define KOKKOS_DEFAULTED_FUNCTION inline
279
#endif
280
#endif
281
282
#if defined(KOKKOS_ENABLE_HIP)
283
284
#define KOKKOS_FORCEINLINE_FUNCTION __device__ __host__ __forceinline__
285
#define KOKKOS_INLINE_FUNCTION __device__ __host__ inline
286
#define KOKKOS_DEFAULTED_FUNCTION __device__ __host__ inline
287
#define KOKKOS_INLINE_FUNCTION_DELETED __device__ __host__ inline
288
#define KOKKOS_FUNCTION __device__ __host__
289
#if defined(KOKKOS_ENABLE_CXX17) || defined(KOKKOS_ENABLE_CXX20)
290
#define KOKKOS_CLASS_LAMBDA [ =, *this ] __host__ __device__
291
#endif
292
#endif // #if defined( KOKKOS_ENABLE_HIP )
293
294
#if defined(KOKKOS_ENABLE_ROCM) && defined(__HCC__)
295
296
#define KOKKOS_FORCEINLINE_FUNCTION __attribute__((amp, cpu)) inline
297
#define KOKKOS_INLINE_FUNCTION __attribute__((amp, cpu)) inline
298
#define KOKKOS_FUNCTION __attribute__((amp, cpu))
299
#define KOKKOS_LAMBDA [=] __attribute__((amp, cpu))
300
#define KOKKOS_DEFAULTED_FUNCTION __attribute__((amp, cpu)) inline
301
#endif
302
303
#if defined(_OPENMP)
304
// Compiling with OpenMP.
305
// The value of _OPENMP is an integer value YYYYMM
306
// where YYYY and MM are the year and month designation
307
// of the supported OpenMP API version.
308
#endif // #if defined( _OPENMP )
309
310
//----------------------------------------------------------------------------
311
// Intel compiler macros
312
313
#if defined(KOKKOS_COMPILER_INTEL)
314
#define KOKKOS_ENABLE_PRAGMA_UNROLL 1
315
#define KOKKOS_ENABLE_PRAGMA_LOOPCOUNT 1
316
#define KOKKOS_ENABLE_PRAGMA_VECTOR 1
317
#if (1800 > KOKKOS_COMPILER_INTEL)
318
#define KOKKOS_ENABLE_PRAGMA_SIMD 1
319
#endif
320
321
#if (__INTEL_COMPILER > 1400)
322
#define KOKKOS_ENABLE_PRAGMA_IVDEP 1
323
#endif
324
325
#if !defined(KOKKOS_MEMORY_ALIGNMENT)
326
#define KOKKOS_MEMORY_ALIGNMENT 64
327
#endif
328
329
#define KOKKOS_RESTRICT __restrict__
330
331
#ifndef KOKKOS_IMPL_ALIGN_PTR
332
#define KOKKOS_IMPL_ALIGN_PTR(size) __attribute__((align_value(size)))
333
#endif
334
335
#if (1400 > KOKKOS_COMPILER_INTEL)
336
#if (1300 > KOKKOS_COMPILER_INTEL)
337
#error \
338
"Compiling with Intel version earlier than 13.0 is not supported. Official minimal version is 14.0."
339
#else
340
#warning \
341
"Compiling with Intel version 13.x probably works but is not officially supported. Official minimal version is 14.0."
342
#endif
343
#endif
344
345
#if !defined(KOKKOS_ENABLE_ASM) && !defined(_WIN32)
346
#define KOKKOS_ENABLE_ASM 1
347
#endif
348
349
#if !defined(KOKKOS_FORCEINLINE_FUNCTION)
350
#if !defined(_WIN32)
351
#define KOKKOS_FORCEINLINE_FUNCTION inline __attribute__((always_inline))
352
#define KOKKOS_IMPL_FORCEINLINE __attribute__((always_inline))
353
#else
354
#define KOKKOS_FORCEINLINE_FUNCTION inline
355
#endif
356
#endif
357
358
#if defined(KOKKOS_ARCH_AVX512MIC)
359
#define KOKKOS_ENABLE_RFO_PREFETCH 1
360
#if (KOKKOS_COMPILER_INTEL < 1800) && !defined(KOKKOS_KNL_USE_ASM_WORKAROUND)
361
#define KOKKOS_KNL_USE_ASM_WORKAROUND 1
362
#endif
363
#endif
364
365
#if (1800 > KOKKOS_COMPILER_INTEL)
366
#define KOKKOS_IMPL_INTEL_WORKAROUND_NOEXCEPT_SPECIFICATION_VIRTUAL_FUNCTION
367
#endif
368
369
#if defined(__MIC__)
370
// Compiling for Xeon Phi
371
#endif
372
#endif
373
374
//----------------------------------------------------------------------------
375
// Cray compiler macros
376
377
#if defined(KOKKOS_COMPILER_CRAYC)
378
#endif
379
380
//----------------------------------------------------------------------------
381
// IBM Compiler macros
382
383
#if defined(KOKKOS_COMPILER_IBM)
384
#define KOKKOS_ENABLE_PRAGMA_UNROLL 1
385
//#define KOKKOS_ENABLE_PRAGMA_IVDEP 1
386
//#define KOKKOS_ENABLE_PRAGMA_LOOPCOUNT 1
387
//#define KOKKOS_ENABLE_PRAGMA_VECTOR 1
388
//#define KOKKOS_ENABLE_PRAGMA_SIMD 1
389
390
#if !defined(KOKKOS_ENABLE_ASM)
391
#define KOKKOS_ENABLE_ASM 1
392
#endif
393
#endif
394
395
//----------------------------------------------------------------------------
396
// CLANG compiler macros
397
398
#if defined(KOKKOS_COMPILER_CLANG)
399
//#define KOKKOS_ENABLE_PRAGMA_UNROLL 1
400
//#define KOKKOS_ENABLE_PRAGMA_IVDEP 1
401
//#define KOKKOS_ENABLE_PRAGMA_LOOPCOUNT 1
402
//#define KOKKOS_ENABLE_PRAGMA_VECTOR 1
403
//#define KOKKOS_ENABLE_PRAGMA_SIMD 1
404
405
#if !defined(KOKKOS_FORCEINLINE_FUNCTION)
406
#define KOKKOS_FORCEINLINE_FUNCTION inline __attribute__((always_inline))
407
#define KOKKOS_IMPL_FORCEINLINE __attribute__((always_inline))
408
#endif
409
410
#if !defined(KOKKOS_IMPL_ALIGN_PTR)
411
#define KOKKOS_IMPL_ALIGN_PTR(size) __attribute__((aligned(size)))
412
#endif
413
414
#endif
415
416
//----------------------------------------------------------------------------
417
// GNU Compiler macros
418
419
#if defined(KOKKOS_COMPILER_GNU)
420
//#define KOKKOS_ENABLE_PRAGMA_UNROLL 1
421
//#define KOKKOS_ENABLE_PRAGMA_IVDEP 1
422
//#define KOKKOS_ENABLE_PRAGMA_LOOPCOUNT 1
423
//#define KOKKOS_ENABLE_PRAGMA_VECTOR 1
424
//#define KOKKOS_ENABLE_PRAGMA_SIMD 1
425
426
#if defined(KOKKOS_ARCH_AVX512MIC)
427
#define KOKKOS_ENABLE_RFO_PREFETCH 1
428
#endif
429
430
#if !defined(KOKKOS_FORCEINLINE_FUNCTION)
431
#define KOKKOS_FORCEINLINE_FUNCTION inline __attribute__((always_inline))
432
#define KOKKOS_IMPL_FORCEINLINE __attribute__((always_inline))
433
#endif
434
435
#define KOKKOS_RESTRICT __restrict__
436
437
#if !defined(KOKKOS_ENABLE_ASM) && !defined(__PGIC__) && \
438
(defined(__amd64) || defined(__amd64__) || defined(__x86_64) || \
439
defined(__x86_64__) || defined(__PPC64__))
440
#define KOKKOS_ENABLE_ASM 1
441
#endif
442
#endif
443
444
//----------------------------------------------------------------------------
445
446
#if defined(KOKKOS_COMPILER_PGI)
447
#define KOKKOS_ENABLE_PRAGMA_UNROLL 1
448
#define KOKKOS_ENABLE_PRAGMA_IVDEP 1
449
//#define KOKKOS_ENABLE_PRAGMA_LOOPCOUNT 1
450
#define KOKKOS_ENABLE_PRAGMA_VECTOR 1
451
//#define KOKKOS_ENABLE_PRAGMA_SIMD 1
452
#endif
453
454
//----------------------------------------------------------------------------
455
456
#if defined(KOKKOS_COMPILER_NVCC)
457
#if defined(__CUDA_ARCH__)
458
#define KOKKOS_ENABLE_PRAGMA_UNROLL 1
459
#endif
460
#endif
461
462
//----------------------------------------------------------------------------
463
// Define function marking macros if compiler specific macros are undefined:
464
465
#if !defined(KOKKOS_FORCEINLINE_FUNCTION)
466
#define KOKKOS_FORCEINLINE_FUNCTION inline
467
#endif
468
469
#if !defined(KOKKOS_IMPL_FORCEINLINE)
470
#define KOKKOS_IMPL_FORCEINLINE inline
471
#endif
472
473
#if !defined(KOKKOS_INLINE_FUNCTION)
474
#define KOKKOS_INLINE_FUNCTION inline
475
#endif
476
477
#if !defined(KOKKOS_FUNCTION)
478
#define KOKKOS_FUNCTION
479
#endif
480
481
#if !defined(KOKKOS_INLINE_FUNCTION_DELETED)
482
#define KOKKOS_INLINE_FUNCTION_DELETED inline
483
#endif
484
485
#if !defined(KOKKOS_DEFAULTED_FUNCTION)
486
#define KOKKOS_DEFAULTED_FUNCTION inline
487
#endif
488
//----------------------------------------------------------------------------
489
// Define empty macro for restrict if necessary:
490
491
#if !defined(KOKKOS_RESTRICT)
492
#define KOKKOS_RESTRICT
493
#endif
494
495
//----------------------------------------------------------------------------
496
// Define Macro for alignment:
497
498
#if !defined(KOKKOS_MEMORY_ALIGNMENT)
499
#define KOKKOS_MEMORY_ALIGNMENT 64
500
#endif
501
502
#if !defined(KOKKOS_MEMORY_ALIGNMENT_THRESHOLD)
503
#define KOKKOS_MEMORY_ALIGNMENT_THRESHOLD 1
504
#endif
505
506
#if !defined(KOKKOS_IMPL_ALIGN_PTR)
507
#define KOKKOS_IMPL_ALIGN_PTR(size)
/* */
508
#endif
509
510
//----------------------------------------------------------------------------
511
// Determine the default execution space for parallel dispatch.
512
// There is zero or one default execution space specified.
513
514
#if 1 < ((defined(KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_CUDA) ? 1 : 0) + \
515
(defined(KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_HIP) ? 1 : 0) + \
516
(defined(KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_ROCM) ? 1 : 0) + \
517
(defined(KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_OPENMPTARGET) ? 1 : 0) + \
518
(defined(KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_OPENMP) ? 1 : 0) + \
519
(defined(KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_THREADS) ? 1 : 0) + \
520
(defined(KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_HPX) ? 1 : 0) + \
521
(defined(KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_SERIAL) ? 1 : 0))
522
#error "More than one KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_* specified."
523
#endif
524
525
// If default is not specified then chose from enabled execution spaces.
526
// Priority: CUDA, HIP, ROCM, OPENMPTARGET, OPENMP, THREADS, HPX, SERIAL
527
#if defined(KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_CUDA)
528
#elif defined(KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_HIP)
529
#elif defined(KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_ROCM)
530
#elif defined(KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_OPENMPTARGET)
531
#elif defined(KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_OPENMP)
532
#elif defined(KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_THREADS)
533
#elif defined(KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_HPX)
534
#elif defined(KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_SERIAL)
535
#elif defined(KOKKOS_ENABLE_CUDA)
536
#define KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_CUDA
537
#elif defined(KOKKOS_ENABLE_HIP)
538
#define KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_HIP
539
#elif defined(KOKKOS_ENABLE_ROCM)
540
#define KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_ROCM
541
#elif defined(KOKKOS_ENABLE_OPENMPTARGET)
542
#define KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_OPENMPTARGET
543
#elif defined(KOKKOS_ENABLE_OPENMP)
544
#define KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_OPENMP
545
#elif defined(KOKKOS_ENABLE_THREADS)
546
#define KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_THREADS
547
#elif defined(KOKKOS_ENABLE_HPX)
548
#define KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_HPX
549
#else
550
#define KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_SERIAL
551
#endif
552
553
//----------------------------------------------------------------------------
554
// Determine for what space the code is being compiled:
555
556
#if defined(__CUDACC__) && defined(__CUDA_ARCH__) && defined(KOKKOS_ENABLE_CUDA)
557
#define KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_CUDA
558
#elif defined(__HCC__) && defined(__HCC_ACCELERATOR__) && \
559
defined(KOKKOS_ENABLE_ROCM)
560
#define KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_ROCM_GPU
561
#elif defined(__HIPCC__) && \
562
(defined(__HCC_ACCELERATOR__) || defined(__CUDA_ARCH__)) && \
563
defined(KOKKOS_ENABLE_HIP)
564
#define KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HIP_GPU
565
#else
566
#define KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST
567
#endif
568
569
//----------------------------------------------------------------------------
570
571
#if (defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE >= 200112L) || \
572
(defined(_XOPEN_SOURCE) && _XOPEN_SOURCE >= 600)
573
#if defined(KOKKOS_ENABLE_PERFORMANCE_POSIX_MEMALIGN)
574
#define KOKKOS_ENABLE_POSIX_MEMALIGN 1
575
#endif
576
#endif
577
578
//----------------------------------------------------------------------------
579
// If compiling with CUDA, we must use relocateable device code
580
// to enable the task policy.
581
582
#if defined(KOKKOS_ENABLE_CUDA)
583
#if defined(KOKKOS_ENABLE_CUDA_RELOCATABLE_DEVICE_CODE)
584
#define KOKKOS_ENABLE_TASKDAG
585
#endif
586
#else
587
#ifndef KOKKOS_ENABLE_HIP
588
#define KOKKOS_ENABLE_TASKDAG
589
#endif
590
#endif
591
592
#if defined(KOKKOS_ENABLE_CUDA)
593
#define KOKKOS_IMPL_CUDA_VERSION_9_WORKAROUND
594
#if (__CUDA_ARCH__)
595
#define KOKKOS_IMPL_CUDA_SYNCWARP_NEEDS_MASK
596
#endif
597
#endif
598
599
#define KOKKOS_INVALID_INDEX (~std::size_t(0))
600
601
#ifdef KOKKOS_ENABLE_DEPRECATED_CODE
602
#define KOKKOS_IMPL_CTOR_DEFAULT_ARG 0
603
#else
604
#define KOKKOS_IMPL_CTOR_DEFAULT_ARG KOKKOS_INVALID_INDEX
605
#endif
606
607
#if (defined(KOKKOS_ENABLE_CXX14) || defined(KOKKOS_ENABLE_CXX17) || \
608
defined(KOKKOS_ENABLE_CXX20))
609
#define KOKKOS_CONSTEXPR_14 constexpr
610
#define KOKKOS_DEPRECATED [[deprecated]]
611
#define KOKKOS_DEPRECATED_TRAILING_ATTRIBUTE
612
#else
613
#define KOKKOS_CONSTEXPR_14
614
#if defined(KOKKOS_COMPILER_GNU) || defined(KOKKOS_COMPILER_CLANG)
615
#define KOKKOS_DEPRECATED
616
#define KOKKOS_DEPRECATED_TRAILING_ATTRIBUTE __attribute__((deprecated))
617
#else
618
#define KOKKOS_DEPRECATED
619
#define KOKKOS_DEPRECATED_TRAILING_ATTRIBUTE
620
#endif
621
#endif
622
623
// DJS 05/28/2019: Bugfix: Issue 2155
624
// Use KOKKOS_ENABLE_CUDA_LDG_INTRINSIC to avoid memory leak in RandomAccess
625
// View
626
#if defined(KOKKOS_ENABLE_CUDA) && !defined(KOKKOS_ENABLE_CUDA_LDG_INTRINSIC)
627
#define KOKKOS_ENABLE_CUDA_LDG_INTRINSIC
628
#endif
629
630
#if defined(KOKKOS_ENABLE_CXX17) || defined(KOKKOS_ENABLE_CXX20)
631
#define KOKKOS_ATTRIBUTE_NODISCARD [[nodiscard]]
632
#else
633
#define KOKKOS_ATTRIBUTE_NODISCARD
634
#endif
635
636
#if defined(KOKKOS_COMPILER_GNU) || defined(KOKKOS_COMPILER_CLANG) || \
637
defined(KOKKOS_COMPILER_INTEL) || defined(KOKKOS_COMPILER_PGI)
638
#define KOKKOS_IMPL_ENABLE_STACKTRACE
639
#define KOKKOS_IMPL_ENABLE_CXXABI
640
#endif
641
642
// WORKAROUND for AMD aomp which apparently defines CUDA_ARCH when building for
643
// AMD GPUs with OpenMP Target ???
644
#if defined(__CUDA_ARCH__) && !defined(__CUDACC__) && \
645
!defined(KOKKOS_ENABLE_HIP) && !defined(KOKKOS_ENABLE_CUDA)
646
#undef __CUDA_ARCH__
647
#endif
648
649
#if defined(KOKKOS_COMPILER_MSVC)
650
#define KOKKOS_THREAD_LOCAL __declspec(thread)
651
#else
652
#define KOKKOS_THREAD_LOCAL __thread
653
#endif
654
655
#endif // #ifndef KOKKOS_MACROS_HPP
Generated by
1.8.5
1.8.5