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

Update Kokkos library in LAMMPS to v3.6.0

Browse Source
This commit is contained in:
Stan Gerald Moore
2022-05-05 11:44:47 -06:00
parent bd4bbbddbe
commit b79c0bc7b4
380 changed files with 41928 additions and 8786 deletions
Download Patch File Download Diff File Expand all files Collapse all files

87
lib/kokkos/core/unit_test/TestPolicyConstruction.hpp
View File

@ -288,37 +288,42 @@ class TestRangePolicyConstruction {
}
}
void test_runtime_parameters() {
using policy_t = Kokkos::RangePolicy<>;
using policy_t = Kokkos::RangePolicy<>;
using index_t = policy_t::index_type;
index_t work_begin = 5;
index_t work_end = 15;
index_t chunk_size = 10;
{
policy_t p(5, 15);
ASSERT_EQ(p.begin(), 5);
ASSERT_EQ(p.end(), 15);
policy_t p(work_begin, work_end);
ASSERT_EQ(p.begin(), work_begin);
ASSERT_EQ(p.end(), work_end);
}
{
policy_t p(Kokkos::DefaultExecutionSpace(), 5, 15);
ASSERT_EQ(p.begin(), 5);
ASSERT_EQ(p.end(), 15);
policy_t p(Kokkos::DefaultExecutionSpace(), work_begin, work_end);
ASSERT_EQ(p.begin(), work_begin);
ASSERT_EQ(p.end(), work_end);
}
{
policy_t p(5, 15, Kokkos::ChunkSize(10));
ASSERT_EQ(p.begin(), 5);
ASSERT_EQ(p.end(), 15);
ASSERT_EQ(p.chunk_size(), 10);
policy_t p(work_begin, work_end, Kokkos::ChunkSize(chunk_size));
ASSERT_EQ(p.begin(), work_begin);
ASSERT_EQ(p.end(), work_end);
ASSERT_EQ(p.chunk_size(), chunk_size);
}
{
policy_t p(Kokkos::DefaultExecutionSpace(), 5, 15, Kokkos::ChunkSize(10));
ASSERT_EQ(p.begin(), 5);
ASSERT_EQ(p.end(), 15);
ASSERT_EQ(p.chunk_size(), 10);
policy_t p(Kokkos::DefaultExecutionSpace(), work_begin, work_end,
Kokkos::ChunkSize(chunk_size));
ASSERT_EQ(p.begin(), work_begin);
ASSERT_EQ(p.end(), work_end);
ASSERT_EQ(p.chunk_size(), chunk_size);
}
{
policy_t p;
ASSERT_EQ(p.begin(), 0);
ASSERT_EQ(p.end(), 0);
p = policy_t(5, 15, Kokkos::ChunkSize(10));
ASSERT_EQ(p.begin(), 5);
ASSERT_EQ(p.end(), 15);
ASSERT_EQ(p.chunk_size(), 10);
ASSERT_EQ(p.begin(), index_t(0));
ASSERT_EQ(p.end(), index_t(0));
p = policy_t(work_begin, work_end, Kokkos::ChunkSize(chunk_size));
ASSERT_EQ(p.begin(), work_begin);
ASSERT_EQ(p.end(), work_end);
ASSERT_EQ(p.chunk_size(), chunk_size);
}
}
};
@ -580,88 +585,85 @@ class TestTeamPolicyConstruction {
policy_t p1(league_size, team_size);
ASSERT_EQ(p1.league_size(), league_size);
ASSERT_EQ(p1.team_size(), team_size);
// FIXME_SYCL implement chunk_size
#ifndef KOKKOS_ENABLE_SYCL
ASSERT_GT(p1.chunk_size(), 0);
#endif
ASSERT_EQ(p1.scratch_size(0), 0);
ASSERT_EQ(size_t(p1.scratch_size(0)), 0u);
policy_t p2 = p1.set_chunk_size(chunk_size);
ASSERT_EQ(p1.league_size(), league_size);
ASSERT_EQ(p1.team_size(), team_size);
ASSERT_EQ(p1.chunk_size(), chunk_size);
ASSERT_EQ(p1.scratch_size(0), 0);
ASSERT_EQ(size_t(p1.scratch_size(0)), 0u);
ASSERT_EQ(p2.league_size(), league_size);
ASSERT_EQ(p2.team_size(), team_size);
ASSERT_EQ(p2.chunk_size(), chunk_size);
ASSERT_EQ(p2.scratch_size(0), 0);
ASSERT_EQ(size_t(p2.scratch_size(0)), 0u);
policy_t p3 = p2.set_scratch_size(0, Kokkos::PerTeam(per_team_scratch));
ASSERT_EQ(p2.league_size(), league_size);
ASSERT_EQ(p2.team_size(), team_size);
ASSERT_EQ(p2.chunk_size(), chunk_size);
ASSERT_EQ(p2.scratch_size(0), per_team_scratch);
ASSERT_EQ(size_t(p2.scratch_size(0)), size_t(per_team_scratch));
ASSERT_EQ(p3.league_size(), league_size);
ASSERT_EQ(p3.team_size(), team_size);
ASSERT_EQ(p3.chunk_size(), chunk_size);
ASSERT_EQ(p3.scratch_size(0), per_team_scratch);
ASSERT_EQ(size_t(p3.scratch_size(0)), size_t(per_team_scratch));
policy_t p4 = p2.set_scratch_size(0, Kokkos::PerThread(per_thread_scratch));
ASSERT_EQ(p2.league_size(), league_size);
ASSERT_EQ(p2.team_size(), team_size);
ASSERT_EQ(p2.chunk_size(), chunk_size);
ASSERT_EQ(p2.scratch_size(0), scratch_size);
ASSERT_EQ(size_t(p2.scratch_size(0)), size_t(scratch_size));
ASSERT_EQ(p4.league_size(), league_size);
ASSERT_EQ(p4.team_size(), team_size);
ASSERT_EQ(p4.chunk_size(), chunk_size);
ASSERT_EQ(p4.scratch_size(0), scratch_size);
ASSERT_EQ(size_t(p4.scratch_size(0)), size_t(scratch_size));
policy_t p5 = p2.set_scratch_size(0, Kokkos::PerThread(per_thread_scratch),
Kokkos::PerTeam(per_team_scratch));
ASSERT_EQ(p2.league_size(), league_size);
ASSERT_EQ(p2.team_size(), team_size);
ASSERT_EQ(p2.chunk_size(), chunk_size);
ASSERT_EQ(p2.scratch_size(0), scratch_size);
ASSERT_EQ(size_t(p2.scratch_size(0)), size_t(scratch_size));
ASSERT_EQ(p5.league_size(), league_size);
ASSERT_EQ(p5.team_size(), team_size);
ASSERT_EQ(p5.chunk_size(), chunk_size);
ASSERT_EQ(p5.scratch_size(0), scratch_size);
ASSERT_EQ(size_t(p5.scratch_size(0)), size_t(scratch_size));
policy_t p6 = p2.set_scratch_size(0, Kokkos::PerTeam(per_team_scratch),
Kokkos::PerThread(per_thread_scratch));
ASSERT_EQ(p2.league_size(), league_size);
ASSERT_EQ(p2.team_size(), team_size);
ASSERT_EQ(p2.chunk_size(), chunk_size);
ASSERT_EQ(p2.scratch_size(0), scratch_size);
ASSERT_EQ(size_t(p2.scratch_size(0)), size_t(scratch_size));
ASSERT_EQ(p6.league_size(), league_size);
ASSERT_EQ(p6.team_size(), team_size);
ASSERT_EQ(p6.chunk_size(), chunk_size);
ASSERT_EQ(p6.scratch_size(0), scratch_size);
ASSERT_EQ(size_t(p6.scratch_size(0)), size_t(scratch_size));
policy_t p7 = p3.set_scratch_size(0, Kokkos::PerTeam(per_team_scratch),
Kokkos::PerThread(per_thread_scratch));
ASSERT_EQ(p3.league_size(), league_size);
ASSERT_EQ(p3.team_size(), team_size);
ASSERT_EQ(p3.chunk_size(), chunk_size);
ASSERT_EQ(p3.scratch_size(0), scratch_size);
ASSERT_EQ(size_t(p3.scratch_size(0)), size_t(scratch_size));
ASSERT_EQ(p7.league_size(), league_size);
ASSERT_EQ(p7.team_size(), team_size);
ASSERT_EQ(p7.chunk_size(), chunk_size);
ASSERT_EQ(p7.scratch_size(0), scratch_size);
ASSERT_EQ(size_t(p7.scratch_size(0)), size_t(scratch_size));
policy_t p8; // default constructed
ASSERT_EQ(p8.league_size(), 0);
ASSERT_EQ(p8.scratch_size(0), 0);
ASSERT_EQ(size_t(p8.scratch_size(0)), 0u);
p8 = p3; // call assignment operator
ASSERT_EQ(p3.league_size(), league_size);
ASSERT_EQ(p3.team_size(), team_size);
ASSERT_EQ(p3.chunk_size(), chunk_size);
ASSERT_EQ(p3.scratch_size(0), scratch_size);
ASSERT_EQ(size_t(p3.scratch_size(0)), size_t(scratch_size));
ASSERT_EQ(p8.league_size(), league_size);
ASSERT_EQ(p8.team_size(), team_size);
ASSERT_EQ(p8.chunk_size(), chunk_size);
ASSERT_EQ(p8.scratch_size(0), scratch_size);
ASSERT_EQ(size_t(p8.scratch_size(0)), size_t(scratch_size));
}
void test_run_time_parameters() {
@ -716,6 +718,7 @@ TEST(TEST_CATEGORY, policy_converting_constructor_from_other_policy) {
Kokkos::MDRangePolicy<TEST_EXECSPACE, Kokkos::Rank<2>>{});
}
#ifndef KOKKOS_COMPILER_NVHPC // FIXME_NVHPC
#ifndef KOKKOS_ENABLE_OPENMPTARGET // FIXME_OPENMPTARGET
TEST(TEST_CATEGORY_DEATH, policy_bounds_unsafe_narrowing_conversions) {
using Policy = Kokkos::MDRangePolicy<TEST_EXECSPACE, Kokkos::Rank<2>,
@ -729,6 +732,7 @@ TEST(TEST_CATEGORY_DEATH, policy_bounds_unsafe_narrowing_conversions) {
"unsafe narrowing conversion");
}
#endif
#endif
template <class Policy>
void test_prefer_desired_occupancy(Policy const& policy) {
@ -790,6 +794,8 @@ struct static_assert_dummy_policy_must_be_size_of_desired_occupancy<
sizeof(Kokkos::Experimental::DesiredOccupancy),
sizeof(Kokkos::Experimental::DesiredOccupancy)> {};
// EBO failure with VS 16.11.3 and CUDA 11.4.2
#if !(defined(_WIN32) && defined(KOKKOS_ENABLE_CUDA))
TEST(TEST_CATEGORY, desired_occupancy_empty_base_optimization) {
DummyPolicy<TEST_EXECSPACE> const policy{};
static_assert(sizeof(decltype(policy)) == 1, "");
@ -807,6 +813,7 @@ TEST(TEST_CATEGORY, desired_occupancy_empty_base_optimization) {
_assert2{};
(void)&_assert2; // avoid unused variable warning
}
#endif
template <typename Policy>
void test_desired_occupancy_converting_constructors(Policy const& policy) {