Kokkos Core Kernels Package  Version of the Day
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Groups Pages
Kokkos_Core_fwd.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_CORE_FWD_HPP
18 #define KOKKOS_CORE_FWD_HPP
19 #ifndef KOKKOS_IMPL_PUBLIC_INCLUDE
20 #define KOKKOS_IMPL_PUBLIC_INCLUDE
21 #define KOKKOS_IMPL_PUBLIC_INCLUDE_NOTDEFINED_CORE_FWD
22 #endif
23 
24 //----------------------------------------------------------------------------
25 // Kokkos_Macros.hpp does introspection on configuration options
26 // and compiler environment then sets a collection of #define macros.
27 
28 #include <Kokkos_Macros.hpp>
29 #include <Kokkos_Printf.hpp>
30 #include <impl/Kokkos_Error.hpp>
31 #include <impl/Kokkos_Utilities.hpp>
32 
33 //----------------------------------------------------------------------------
34 // Have assumed a 64-bit build (8-byte pointers) throughout the code base.
35 // 32-bit build allowed but unsupported.
36 #ifdef KOKKOS_IMPL_32BIT
37 static_assert(sizeof(void *) == 4,
38  "Kokkos assumes 64-bit build; i.e., 4-byte pointers");
39 #else
40 static_assert(sizeof(void *) == 8,
41  "Kokkos assumes 64-bit build; i.e., 8-byte pointers");
42 #endif
43 //----------------------------------------------------------------------------
44 
45 namespace Kokkos {
46 
47 struct AUTO_t {
48  KOKKOS_INLINE_FUNCTION
49  constexpr const AUTO_t &operator()() const { return *this; }
50 };
51 
52 namespace {
55 constexpr AUTO_t AUTO = Kokkos::AUTO_t();
56 } // namespace
57 
58 struct InvalidType {};
59 
60 } // namespace Kokkos
61 
62 //----------------------------------------------------------------------------
63 // Forward declarations for class interrelationships
64 
65 namespace Kokkos {
66 
67 class HostSpace;
68 class AnonymousSpace;
69 
70 template <class ExecutionSpace, class MemorySpace>
71 struct Device;
72 
73 // forward declare here so that backend initializer calls can use it.
74 class InitializationSettings;
75 
76 } // namespace Kokkos
77 
78 // Include backend forward statements as determined by build options
79 #include <KokkosCore_Config_FwdBackend.hpp>
80 
81 //----------------------------------------------------------------------------
82 // Set the default execution space.
83 
88 
89 #if defined(__clang_analyzer__)
90 #define KOKKOS_IMPL_DEFAULT_EXEC_SPACE_ANNOTATION \
91  [[clang::annotate("DefaultExecutionSpace")]]
92 #define KOKKOS_IMPL_DEFAULT_HOST_EXEC_SPACE_ANNOTATION \
93  [[clang::annotate("DefaultHostExecutionSpace")]]
94 #else
95 #define KOKKOS_IMPL_DEFAULT_EXEC_SPACE_ANNOTATION
96 #define KOKKOS_IMPL_DEFAULT_HOST_EXEC_SPACE_ANNOTATION
97 #endif
98 
99 namespace Kokkos {
100 
101 #if defined(KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_CUDA)
102 using DefaultExecutionSpace KOKKOS_IMPL_DEFAULT_EXEC_SPACE_ANNOTATION = Cuda;
103 #elif defined(KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_OPENMPTARGET)
104 using DefaultExecutionSpace KOKKOS_IMPL_DEFAULT_EXEC_SPACE_ANNOTATION =
105  Experimental::OpenMPTarget;
106 #elif defined(KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_HIP)
107 using DefaultExecutionSpace KOKKOS_IMPL_DEFAULT_EXEC_SPACE_ANNOTATION = HIP;
108 #elif defined(KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_SYCL)
109 using DefaultExecutionSpace KOKKOS_IMPL_DEFAULT_EXEC_SPACE_ANNOTATION = SYCL;
110 #elif defined(KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_OPENACC)
111 using DefaultExecutionSpace KOKKOS_IMPL_DEFAULT_EXEC_SPACE_ANNOTATION =
112  Experimental::OpenACC;
113 #elif defined(KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_OPENMP)
114 using DefaultExecutionSpace KOKKOS_IMPL_DEFAULT_EXEC_SPACE_ANNOTATION = OpenMP;
115 #elif defined(KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_THREADS)
116 using DefaultExecutionSpace KOKKOS_IMPL_DEFAULT_EXEC_SPACE_ANNOTATION = Threads;
117 #elif defined(KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_HPX)
118 using DefaultExecutionSpace KOKKOS_IMPL_DEFAULT_EXEC_SPACE_ANNOTATION =
119  Kokkos::Experimental::HPX;
120 #elif defined(KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_SERIAL)
121 using DefaultExecutionSpace KOKKOS_IMPL_DEFAULT_EXEC_SPACE_ANNOTATION = Serial;
122 #else
123 #error \
124  "At least one of the following execution spaces must be defined in order to use Kokkos: Kokkos::Cuda, Kokkos::HIP, Kokkos::SYCL, Kokkos::Experimental::OpenMPTarget, Kokkos::Experimental::OpenACC, Kokkos::OpenMP, Kokkos::Threads, Kokkos::Experimental::HPX, or Kokkos::Serial."
125 #endif
126 
127 #if defined(KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_OPENMP)
128 using DefaultHostExecutionSpace KOKKOS_IMPL_DEFAULT_HOST_EXEC_SPACE_ANNOTATION =
129  OpenMP;
130 #elif defined(KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_THREADS)
131 using DefaultHostExecutionSpace KOKKOS_IMPL_DEFAULT_HOST_EXEC_SPACE_ANNOTATION =
132  Threads;
133 #elif defined(KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_HPX)
134 using DefaultHostExecutionSpace KOKKOS_IMPL_DEFAULT_HOST_EXEC_SPACE_ANNOTATION =
135  Kokkos::Experimental::HPX;
136 #elif defined(KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_SERIAL)
137 using DefaultHostExecutionSpace KOKKOS_IMPL_DEFAULT_HOST_EXEC_SPACE_ANNOTATION =
138  Serial;
139 #elif defined(KOKKOS_ENABLE_OPENMP)
140 using DefaultHostExecutionSpace KOKKOS_IMPL_DEFAULT_HOST_EXEC_SPACE_ANNOTATION =
141  OpenMP;
142 #elif defined(KOKKOS_ENABLE_THREADS)
143 using DefaultHostExecutionSpace KOKKOS_IMPL_DEFAULT_HOST_EXEC_SPACE_ANNOTATION =
144  Threads;
145 #elif defined(KOKKOS_ENABLE_HPX)
146 using DefaultHostExecutionSpace KOKKOS_IMPL_DEFAULT_HOST_EXEC_SPACE_ANNOTATION =
147  Kokkos::Experimental::HPX;
148 #elif defined(KOKKOS_ENABLE_SERIAL)
149 using DefaultHostExecutionSpace KOKKOS_IMPL_DEFAULT_HOST_EXEC_SPACE_ANNOTATION =
150  Serial;
151 #else
152 #error \
153  "At least one of the following execution spaces must be defined in order to use Kokkos: Kokkos::OpenMP, Kokkos::Threads, Kokkos::Experimental::HPX, or Kokkos::Serial."
154 #endif
155 
156 // check for devices that support sharedSpace
157 #if defined(KOKKOS_ENABLE_CUDA)
158 using SharedSpace = CudaUVMSpace;
159 #define KOKKOS_HAS_SHARED_SPACE
160 #elif defined(KOKKOS_ENABLE_HIP)
161 using SharedSpace = HIPManagedSpace;
162 #define KOKKOS_HAS_SHARED_SPACE
163 #elif defined(KOKKOS_ENABLE_SYCL)
164 using SharedSpace = SYCLSharedUSMSpace;
165 #define KOKKOS_HAS_SHARED_SPACE
166 // if only host compile point to HostSpace
167 #elif !defined(KOKKOS_ENABLE_OPENACC) && !defined(KOKKOS_ENABLE_OPENMPTARGET)
168 using SharedSpace = HostSpace;
169 #define KOKKOS_HAS_SHARED_SPACE
170 #endif
171 
172 inline constexpr bool has_shared_space =
173 #if defined KOKKOS_HAS_SHARED_SPACE
174  true;
175 #else
176  false;
177 #endif
178 
179 #if defined(KOKKOS_ENABLE_CUDA)
180 using SharedHostPinnedSpace = CudaHostPinnedSpace;
181 #define KOKKOS_HAS_SHARED_HOST_PINNED_SPACE
182 #elif defined(KOKKOS_ENABLE_HIP)
183 using SharedHostPinnedSpace = HIPHostPinnedSpace;
184 #define KOKKOS_HAS_SHARED_HOST_PINNED_SPACE
185 #elif defined(KOKKOS_ENABLE_SYCL)
186  using SharedHostPinnedSpace = SYCLHostUSMSpace;
187 #define KOKKOS_HAS_SHARED_HOST_PINNED_SPACE
188 #elif !defined(KOKKOS_ENABLE_OPENACC) && !defined(KOKKOS_ENABLE_OPENMPTARGET)
189  using SharedHostPinnedSpace = HostSpace;
190 #define KOKKOS_HAS_SHARED_HOST_PINNED_SPACE
191 #endif
192 
193 inline constexpr bool has_shared_host_pinned_space =
194 #if defined KOKKOS_HAS_SHARED_HOST_PINNED_SPACE
195  true;
196 #else
197  false;
198 #endif
199 
200 } // namespace Kokkos
201 
202 //----------------------------------------------------------------------------
203 // Detect the active execution space and define its memory space.
204 // This is used to verify whether a running kernel can access
205 // a given memory space.
206 
207 namespace Kokkos {
208 
209 template <class AccessSpace, class MemorySpace>
210 struct SpaceAccessibility;
211 
212 namespace Impl {
213 
214 // primary template: memory space is accessible, do nothing.
215 template <class MemorySpace, class AccessSpace,
216  bool = SpaceAccessibility<AccessSpace, MemorySpace>::accessible>
217 struct RuntimeCheckMemoryAccessViolation {
218  KOKKOS_FUNCTION RuntimeCheckMemoryAccessViolation(char const *const) {}
219 };
220 
221 // explicit specialization: memory access violation will occur, call abort with
222 // the specified error message.
223 template <class MemorySpace, class AccessSpace>
224 struct RuntimeCheckMemoryAccessViolation<MemorySpace, AccessSpace, false> {
225  KOKKOS_FUNCTION RuntimeCheckMemoryAccessViolation(char const *const msg) {
226  Kokkos::abort(msg);
227  }
228 };
229 
230 // calls abort with default error message at runtime if memory access violation
231 // will occur
232 template <class MemorySpace>
233 KOKKOS_FUNCTION void runtime_check_memory_access_violation() {
234  KOKKOS_IF_ON_HOST((
235  RuntimeCheckMemoryAccessViolation<MemorySpace, DefaultHostExecutionSpace>(
236  "ERROR: attempt to access inaccessible memory space");))
237  KOKKOS_IF_ON_DEVICE(
238  (RuntimeCheckMemoryAccessViolation<MemorySpace, DefaultExecutionSpace>(
239  "ERROR: attempt to access inaccessible memory space");))
240 }
241 
242 // calls abort with specified error message at runtime if memory access
243 // violation will occur
244 template <class MemorySpace>
245 KOKKOS_FUNCTION void runtime_check_memory_access_violation(
246  char const *const msg) {
247  KOKKOS_IF_ON_HOST((
248  (void)RuntimeCheckMemoryAccessViolation<MemorySpace,
249  DefaultHostExecutionSpace>(msg);))
250  KOKKOS_IF_ON_DEVICE((
251  (void)
252  RuntimeCheckMemoryAccessViolation<MemorySpace, DefaultExecutionSpace>(
253  msg);))
254 }
255 
256 } // namespace Impl
257 } // namespace Kokkos
258 
259 //----------------------------------------------------------------------------
260 
261 namespace Kokkos {
262 void fence(const std::string &name = "Kokkos::fence: Unnamed Global Fence");
263 } // namespace Kokkos
264 
265 //----------------------------------------------------------------------------
266 
267 namespace Kokkos {
268 
269 template <class DataType, class... Properties>
270 class View;
271 
272 namespace Impl {
273 
274 template <class DstSpace, class SrcSpace,
275  class ExecutionSpace = typename DstSpace::execution_space,
276  class Enable = void>
277 struct DeepCopy;
278 
279 template <class ViewType, class Layout = typename ViewType::array_layout,
280  class ExecSpace = typename ViewType::execution_space,
281  int Rank = ViewType::rank, typename iType = int64_t>
282 struct ViewFill;
283 
284 template <class ViewTypeA, class ViewTypeB, class Layout, class ExecSpace,
285  int Rank, typename iType>
286 struct ViewCopy;
287 
288 template <class Functor, class Policy>
289 struct FunctorPolicyExecutionSpace;
290 
291 //----------------------------------------------------------------------------
298 template <class FunctorType, class ExecPolicy,
299  class ExecutionSpace = typename Impl::FunctorPolicyExecutionSpace<
300  FunctorType, ExecPolicy>::execution_space>
301 class ParallelFor;
302 
308 template <typename CombinedFunctorReducerType, typename PolicyType,
309  typename ExecutionSpaceType>
310 class ParallelReduce;
311 
312 template <typename FunctorType, typename FunctorAnalysisReducerType,
313  typename Enable = void>
314 class CombinedFunctorReducer;
315 
322 template <class FunctorType, class ExecPolicy,
323  class ExecutionSpace = typename Impl::FunctorPolicyExecutionSpace<
324  FunctorType, ExecPolicy>::execution_space>
325 class ParallelScan;
326 
327 template <class FunctorType, class ExecPolicy, class ReturnType = InvalidType,
328  class ExecutionSpace = typename Impl::FunctorPolicyExecutionSpace<
329  FunctorType, ExecPolicy>::execution_space>
330 class ParallelScanWithTotal;
331 
332 } // namespace Impl
333 
334 template <class ScalarType, class Space = HostSpace>
335 struct Sum;
336 template <class ScalarType, class Space = HostSpace>
337 struct Prod;
338 template <class ScalarType, class Space = HostSpace>
339 struct Min;
340 template <class ScalarType, class Space = HostSpace>
341 struct Max;
342 template <class ScalarType, class Space = HostSpace>
343 struct MinMax;
344 template <class ScalarType, class Index, class Space = HostSpace>
345 struct MinLoc;
346 template <class ScalarType, class Index, class Space = HostSpace>
347 struct MaxLoc;
348 template <class ScalarType, class Index, class Space = HostSpace>
349 struct MinMaxLoc;
350 template <class ScalarType, class Space = HostSpace>
351 struct BAnd;
352 template <class ScalarType, class Space = HostSpace>
353 struct BOr;
354 template <class ScalarType, class Space = HostSpace>
355 struct LAnd;
356 template <class ScalarType, class Space = HostSpace>
357 struct LOr;
358 
359 template <class Scalar, class Index, class Space = HostSpace>
360 struct MaxFirstLoc;
361 template <class Scalar, class Index, class ComparatorType,
362  class Space = HostSpace>
363 struct MaxFirstLocCustomComparator;
364 
365 template <class Scalar, class Index, class Space = HostSpace>
366 struct MinFirstLoc;
367 template <class Scalar, class Index, class ComparatorType,
368  class Space = HostSpace>
369 struct MinFirstLocCustomComparator;
370 
371 template <class Scalar, class Index, class Space = HostSpace>
372 struct MinMaxFirstLastLoc;
373 template <class Scalar, class Index, class ComparatorType,
374  class Space = HostSpace>
375 struct MinMaxFirstLastLocCustomComparator;
376 
377 template <class Index, class Space = HostSpace>
378 struct FirstLoc;
379 template <class Index, class Space = HostSpace>
380 struct LastLoc;
381 template <class Index, class Space = HostSpace>
382 struct StdIsPartitioned;
383 template <class Index, class Space = HostSpace>
384 struct StdPartitionPoint;
385 } // namespace Kokkos
386 
387 #ifdef KOKKOS_IMPL_PUBLIC_INCLUDE_NOTDEFINED_CORE_FWD
388 #undef KOKKOS_IMPL_PUBLIC_INCLUDE
389 #undef KOKKOS_IMPL_PUBLIC_INCLUDE_NOTDEFINED_CORE_FWD
390 #endif
391 #endif /* #ifndef KOKKOS_CORE_FWD_HPP */
ReturnType
ReturnType
Generated on Tue Apr 22 2025 09:19:24 for Kokkos Core Kernels Package by   doxygen 1.8.5