17 #ifndef KOKKOS_CORE_HPP
18 #define KOKKOS_CORE_HPP
19 #ifndef KOKKOS_IMPL_PUBLIC_INCLUDE
20 #define KOKKOS_IMPL_PUBLIC_INCLUDE
21 #define KOKKOS_IMPL_PUBLIC_INCLUDE_NOTDEFINED_CORE
30 #pragma push_macro("min")
32 #define KOKKOS_IMPL_PUSH_MACRO_MIN
35 #pragma push_macro("max")
37 #define KOKKOS_IMPL_PUSH_MACRO_MAX
43 #include <Kokkos_Core_fwd.hpp>
45 #include <KokkosCore_Config_DeclareBackend.hpp>
47 #include <Kokkos_Half.hpp>
48 #include <Kokkos_AnonymousSpace.hpp>
50 #include <Kokkos_Clamp.hpp>
51 #include <Kokkos_MinMax.hpp>
52 #include <Kokkos_MathematicalConstants.hpp>
53 #include <Kokkos_MathematicalFunctions.hpp>
54 #include <Kokkos_MathematicalSpecialFunctions.hpp>
55 #include <Kokkos_NumericTraits.hpp>
56 #include <Kokkos_BitManipulation.hpp>
57 #include <Kokkos_Swap.hpp>
58 #include <Kokkos_MemoryPool.hpp>
59 #include <Kokkos_Array.hpp>
60 #include <Kokkos_View.hpp>
63 #include <Kokkos_hwloc.hpp>
64 #include <Kokkos_Timer.hpp>
65 #include <Kokkos_Tuners.hpp>
66 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE_4
67 #include <Kokkos_TaskScheduler.hpp>
69 #include <Kokkos_Complex.hpp>
70 #include <Kokkos_CopyViews.hpp>
71 #include <impl/Kokkos_TeamMDPolicy.hpp>
72 #include <impl/Kokkos_InitializationSettings.hpp>
82 void initialize(
int& argc,
char* argv[]);
85 InitializationSettings
const& settings = InitializationSettings());
89 void pre_initialize(
const InitializationSettings& settings);
91 void post_initialize(
const InitializationSettings& settings);
97 void declare_configuration_metadata(
const std::string& category,
98 const std::string& key,
99 const std::string& value);
103 [[nodiscard]]
bool is_initialized() noexcept;
104 [[nodiscard]]
bool is_finalized() noexcept;
106 [[nodiscard]]
int device_id() noexcept;
107 [[nodiscard]]
int num_devices() noexcept;
108 [[nodiscard]]
int num_threads() noexcept;
110 bool show_warnings() noexcept;
111 bool tune_internals() noexcept;
136 void push_finalize_hook(std::function<
void()> f);
138 void fence(const std::
string& name );
141 void print_configuration(std::ostream& os,
bool verbose = false);
152 static inline void check_init_final([[maybe_unused]]
char const* func_name) {
156 #if !defined(KOKKOS_ENABLE_THREADS)
157 if (is_finalized()) {
158 std::stringstream ss;
159 ss <<
"Kokkos ERROR: attempting to perform C-style memory management "
161 ss << func_name <<
"() **after** Kokkos::finalize() was called\n";
162 Kokkos::abort(ss.str().c_str());
163 }
else if (!is_initialized()) {
164 std::stringstream ss;
165 ss <<
"Kokkos ERROR: attempting to perform C-style memory management "
167 ss << func_name <<
"() **before** Kokkos::initialize() was called\n";
168 Kokkos::abort(ss.str().c_str());
179 template <
class Space = Kokkos::DefaultExecutionSpace::memory_space>
180 inline void* kokkos_malloc(
const std::string& arg_alloc_label,
181 const size_t arg_alloc_size) {
182 Impl::check_init_final(
"kokkos_malloc");
183 using MemorySpace =
typename Space::memory_space;
184 return Impl::SharedAllocationRecord<MemorySpace>::allocate_tracked(
185 MemorySpace(), arg_alloc_label, arg_alloc_size);
188 template <
class Space = Kokkos::DefaultExecutionSpace::memory_space>
189 inline void* kokkos_malloc(
const size_t arg_alloc_size) {
190 Impl::check_init_final(
"kokkos_malloc");
191 using MemorySpace =
typename Space::memory_space;
192 return Impl::SharedAllocationRecord<MemorySpace>::allocate_tracked(
193 MemorySpace(),
"no-label", arg_alloc_size);
196 template <
class Space = Kokkos::DefaultExecutionSpace::memory_space>
197 inline void kokkos_free(
void* arg_alloc) {
198 Impl::check_init_final(
"kokkos_free");
199 using MemorySpace =
typename Space::memory_space;
200 return Impl::SharedAllocationRecord<MemorySpace>::deallocate_tracked(
204 template <
class Space = Kokkos::DefaultExecutionSpace::memory_space>
205 inline void* kokkos_realloc(
void* arg_alloc,
const size_t arg_alloc_size) {
206 Impl::check_init_final(
"kokkos_realloc");
207 using MemorySpace =
typename Space::memory_space;
208 return Impl::SharedAllocationRecord<MemorySpace>::reallocate_tracked(
209 arg_alloc, arg_alloc_size);
226 inline std::string scopeguard_correct_usage() {
229 " std::unique_ptr<Kokkos::ScopeGuard> guard =\n"
230 " !Kokkos::is_initialized() && !Kokkos::is_finalized()?\n"
231 " new ScopeGuard(argc,argv) : nullptr;\n");
234 inline std::string scopeguard_create_while_initialized_warning() {
236 "Kokkos Error: Creating a ScopeGuard while Kokkos is initialized "
238 .append(scopeguard_correct_usage());
241 inline std::string scopeguard_create_after_finalize_warning() {
243 "Kokkos Error: Creating a ScopeGuard after Kokkos was finalized "
245 .append(scopeguard_correct_usage());
248 inline std::string scopeguard_destruct_after_finalize_warning() {
250 "Kokkos Error: Destroying a ScopeGuard after Kokkos was finalized "
252 .append(scopeguard_correct_usage());
257 class KOKKOS_ATTRIBUTE_NODISCARD ScopeGuard {
259 template <
class... Args>
260 #if defined(__has_cpp_attribute) && __has_cpp_attribute(nodiscard) >= 201907
263 ScopeGuard(Args&&... args) {
264 if (is_initialized()) {
266 Impl::scopeguard_create_while_initialized_warning().c_str());
268 if (is_finalized()) {
269 Kokkos::abort(Impl::scopeguard_create_after_finalize_warning().c_str());
271 initialize(static_cast<Args&&>(args)...);
275 if (is_finalized()) {
276 Kokkos::abort(Impl::scopeguard_destruct_after_finalize_warning().c_str());
281 ScopeGuard& operator=(
const ScopeGuard&) =
delete;
282 ScopeGuard& operator=(ScopeGuard&&) =
delete;
283 ScopeGuard(
const ScopeGuard&) =
delete;
284 ScopeGuard(ScopeGuard&&) =
delete;
290 namespace Experimental {
294 template <
class ExecSpace,
class T>
295 std::vector<ExecSpace> impl_partition_space(
const ExecSpace& base_instance,
296 const std::vector<T>& weights) {
297 std::vector<ExecSpace> instances;
298 instances.reserve(weights.size());
299 std::generate_n(std::back_inserter(instances), weights.size(),
300 [&base_instance]() {
return base_instance; });
313 template <
class ExecSpace,
class... Args>
314 std::array<ExecSpace,
sizeof...(Args)> partition_space(
315 ExecSpace
const& base_instance, Args... args) {
316 static_assert(is_execution_space<ExecSpace>::value,
317 "Kokkos Error: partition_space expects an Execution Space as "
320 (... && std::is_arithmetic_v<Args>),
321 "Kokkos Error: partitioning arguments must be integers or floats");
324 std::vector<std::common_type_t<Args...>> weights = {args...};
325 auto instances_vec = Impl::impl_partition_space(base_instance, weights);
328 std::array<ExecSpace,
sizeof...(Args)> instances;
329 std::copy(instances_vec.begin(), instances_vec.end(), instances.begin());
333 template <
class ExecSpace,
class T>
334 std::vector<ExecSpace> partition_space(ExecSpace
const& base_instance,
335 std::vector<T>
const& weights) {
336 static_assert(is_execution_space<ExecSpace>::value,
337 "Kokkos Error: partition_space expects an Execution Space as "
340 std::is_arithmetic_v<T>,
341 "Kokkos Error: partitioning arguments must be integers or floats");
344 return Impl::impl_partition_space(base_instance, weights);
349 #include <Kokkos_Crs.hpp>
350 #include <Kokkos_WorkGraphPolicy.hpp>
355 #include <impl/Kokkos_Combined_Reducer.hpp>
358 #include <Kokkos_AcquireUniqueTokenImpl.hpp>
363 #if defined(KOKKOS_IMPL_PUSH_MACRO_MIN)
364 #pragma pop_macro("min")
365 #undef KOKKOS_IMPL_PUSH_MACRO_MIN
367 #if defined(KOKKOS_IMPL_PUSH_MACRO_MAX)
368 #pragma pop_macro("max")
369 #undef KOKKOS_IMPL_PUSH_MACRO_MAX
375 #ifdef KOKKOS_IMPL_PUBLIC_INCLUDE_NOTDEFINED_CORE
376 #undef KOKKOS_IMPL_PUBLIC_INCLUDE
377 #undef KOKKOS_IMPL_PUBLIC_INCLUDE_NOTDEFINED_CORE
Declaration and definition of Kokkos::Vectorization interface.
Declaration and definition of Kokkos::pair.