ICODE-ADC/lammps
4
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Update Kokkos library in LAMMPS to v4.3.0

Browse Source
This commit is contained in:
Stan Gerald Moore
2024-04-05 08:20:57 -06:00
parent 2927471892
commit f382eac5c2
393 changed files with 13253 additions and 12499 deletions
Download Patch File Download Diff File Expand all files Collapse all files

150
lib/kokkos/core/unit_test/TestRangePolicyCTAD.cpp Normal file
View File

@ -0,0 +1,150 @@
//@HEADER
// ************************************************************************
//
// Kokkos v. 4.0
// Copyright (2022) National Technology & Engineering
// Solutions of Sandia, LLC (NTESS).
//
// Under the terms of Contract DE-NA0003525 with NTESS,
// the U.S. Government retains certain rights in this software.
//
// Part of Kokkos, under the Apache License v2.0 with LLVM Exceptions.
// See https://kokkos.org/LICENSE for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//@HEADER
#include <Kokkos_Core.hpp>
#include "Kokkos_Core_fwd.hpp"
namespace {
struct TestRangePolicyCTAD {
struct SomeExecutionSpace {
using execution_space = SomeExecutionSpace;
using size_type = size_t;
[[maybe_unused]] static int concurrency() { return 0; }
};
static_assert(Kokkos::is_execution_space_v<SomeExecutionSpace>);
struct ImplicitlyConvertibleToDefaultExecutionSpace {
[[maybe_unused]] operator Kokkos::DefaultExecutionSpace() const {
return Kokkos::DefaultExecutionSpace();
}
};
static_assert(!Kokkos::is_execution_space_v<
ImplicitlyConvertibleToDefaultExecutionSpace>);
[[maybe_unused]] static inline auto i64 = int64_t();
[[maybe_unused]] static inline auto i32 = int32_t();
[[maybe_unused]] static inline auto cs = Kokkos::ChunkSize(0);
[[maybe_unused]] static inline auto des = Kokkos::DefaultExecutionSpace();
[[maybe_unused]] static inline auto nes =
ImplicitlyConvertibleToDefaultExecutionSpace();
[[maybe_unused]] static inline auto ses = SomeExecutionSpace();
// RangePolicy()
[[maybe_unused]] static inline auto rp = Kokkos::RangePolicy{};
static_assert(std::is_same_v<Kokkos::RangePolicy<>, decltype(rp)>);
// RangePolicy(index_type, index_type)
[[maybe_unused]] static inline auto rpi64i64 = Kokkos::RangePolicy(i64, i64);
static_assert(std::is_same_v<Kokkos::RangePolicy<>, decltype(rpi64i64)>);
[[maybe_unused]] static inline auto rpi64i32 = Kokkos::RangePolicy(i64, i32);
static_assert(std::is_same_v<Kokkos::RangePolicy<>, decltype(rpi64i32)>);
[[maybe_unused]] static inline auto rpi32i64 = Kokkos::RangePolicy(i32, i64);
static_assert(std::is_same_v<Kokkos::RangePolicy<>, decltype(rpi32i64)>);
[[maybe_unused]] static inline auto rpi32i32 = Kokkos::RangePolicy(i32, i32);
static_assert(std::is_same_v<Kokkos::RangePolicy<>, decltype(rpi32i32)>);
// RangePolicy(index_type, index_type, ChunkSize)
[[maybe_unused]] static inline auto rpi64i64cs =
Kokkos::RangePolicy(i64, i64, cs);
static_assert(std::is_same_v<Kokkos::RangePolicy<>, decltype(rpi64i64cs)>);
[[maybe_unused]] static inline auto rpi64i32cs =
Kokkos::RangePolicy(i64, i32, cs);
static_assert(std::is_same_v<Kokkos::RangePolicy<>, decltype(rpi64i32cs)>);
[[maybe_unused]] static inline auto rpi32i64cs =
Kokkos::RangePolicy(i32, i64, cs);
static_assert(std::is_same_v<Kokkos::RangePolicy<>, decltype(rpi32i64cs)>);
[[maybe_unused]] static inline auto rpi32i32cs =
Kokkos::RangePolicy(i32, i32, cs);
static_assert(std::is_same_v<Kokkos::RangePolicy<>, decltype(rpi32i32cs)>);
// RangePolicy(execution_space, index_type, index_type)
[[maybe_unused]] static inline auto rpdesi64i64 =
Kokkos::RangePolicy(des, i64, i64);
static_assert(std::is_same_v<Kokkos::RangePolicy<>, decltype(rpdesi64i64)>);
[[maybe_unused]] static inline auto rpdesi32i32 =
Kokkos::RangePolicy(des, i32, i32);
static_assert(std::is_same_v<Kokkos::RangePolicy<>, decltype(rpdesi32i32)>);
[[maybe_unused]] static inline auto rpnesi64i64 =
Kokkos::RangePolicy(nes, i64, i64);
static_assert(std::is_same_v<Kokkos::RangePolicy<>, decltype(rpnesi64i64)>);
[[maybe_unused]] static inline auto rpnesi32i32 =
Kokkos::RangePolicy(nes, i32, i32);
static_assert(std::is_same_v<Kokkos::RangePolicy<>, decltype(rpnesi32i32)>);
[[maybe_unused]] static inline auto rpsesi64i64 =
Kokkos::RangePolicy(ses, i64, i64);
static_assert(std::is_same_v<Kokkos::RangePolicy<SomeExecutionSpace>,
decltype(rpsesi64i64)>);
[[maybe_unused]] static inline auto rpsesi32i32 =
Kokkos::RangePolicy(ses, i32, i32);
static_assert(std::is_same_v<Kokkos::RangePolicy<SomeExecutionSpace>,
decltype(rpsesi32i32)>);
// RangePolicy(execution_space, index_type, index_type, ChunkSize)
[[maybe_unused]] static inline auto rpdesi64i64cs =
Kokkos::RangePolicy(des, i64, i64, cs);
static_assert(std::is_same_v<Kokkos::RangePolicy<>, decltype(rpdesi64i64cs)>);
[[maybe_unused]] static inline auto rpdesi32i32cs =
Kokkos::RangePolicy(des, i32, i32, cs);
static_assert(std::is_same_v<Kokkos::RangePolicy<>, decltype(rpdesi32i32cs)>);
[[maybe_unused]] static inline auto rpnesi64i64cs =
Kokkos::RangePolicy(nes, i64, i64, cs);
static_assert(std::is_same_v<Kokkos::RangePolicy<>, decltype(rpnesi64i64cs)>);
[[maybe_unused]] static inline auto rpnesi32i32cs =
Kokkos::RangePolicy(nes, i32, i32, cs);
static_assert(std::is_same_v<Kokkos::RangePolicy<>, decltype(rpnesi32i32cs)>);
[[maybe_unused]] static inline auto rpsesi64i64cs =
Kokkos::RangePolicy(ses, i64, i64, cs);
static_assert(std::is_same_v<Kokkos::RangePolicy<SomeExecutionSpace>,
decltype(rpsesi64i64cs)>);
[[maybe_unused]] static inline auto rpsesi32i32cs =
Kokkos::RangePolicy(ses, i32, i32, cs);
static_assert(std::is_same_v<Kokkos::RangePolicy<SomeExecutionSpace>,
decltype(rpsesi32i32cs)>);
}; // TestRangePolicyCTAD struct
// To eliminate maybe_unused warning on some compilers
[[maybe_unused]] const Kokkos::DefaultExecutionSpace nestodes =
TestRangePolicyCTAD::ImplicitlyConvertibleToDefaultExecutionSpace();
[[maybe_unused]] const auto sesconcurrency =
TestRangePolicyCTAD::ses.concurrency();
} // namespace