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

Update Kokkos library in LAMMPS to v3.7.0

Browse Source
This commit is contained in:
Stan Gerald Moore
2022-10-04 14:04:40 -06:00
parent dd072f7e08
commit f9f9e44f2d
653 changed files with 41432 additions and 33597 deletions
Download Patch File Download Diff File Expand all files Collapse all files

155
lib/kokkos/algorithms/unit_tests/TestStdAlgorithmsNumerics.cpp
View File

@ -43,87 +43,12 @@
*/
#include <TestStdAlgorithmsCommon.hpp>
#include <std_algorithms/Kokkos_Numeric.hpp>
namespace KE = Kokkos::Experimental;
namespace Test {
namespace stdalgos {
struct CustomValueType {
KOKKOS_INLINE_FUNCTION
CustomValueType(){};
KOKKOS_INLINE_FUNCTION
CustomValueType(value_type val) : value(val){};
KOKKOS_INLINE_FUNCTION
CustomValueType(const CustomValueType& other) { this->value = other.value; }
KOKKOS_INLINE_FUNCTION
value_type& operator()() { return value; }
KOKKOS_INLINE_FUNCTION
const value_type& operator()() const { return value; }
KOKKOS_INLINE_FUNCTION
CustomValueType& operator+=(const CustomValueType& other) {
this->value += other.value;
return *this;
}
KOKKOS_INLINE_FUNCTION
CustomValueType& operator=(const CustomValueType& other) {
this->value = other.value;
return *this;
}
KOKKOS_INLINE_FUNCTION
CustomValueType operator+(const CustomValueType& other) const {
CustomValueType result;
result.value = this->value + other.value;
return result;
}
KOKKOS_INLINE_FUNCTION
CustomValueType operator*(const CustomValueType& other) const {
CustomValueType result;
result.value = this->value * other.value;
return result;
}
KOKKOS_INLINE_FUNCTION
bool operator==(const CustomValueType& other) const {
return this->value == other.value;
}
//
// volatile overloads needed for the kokkos reductions
//
// note the void return
KOKKOS_INLINE_FUNCTION
void operator+=(const volatile CustomValueType& other) volatile {
this->value += other.value;
}
// note the void return
KOKKOS_INLINE_FUNCTION
void operator=(const CustomValueType& other) volatile {
this->value = other.value;
}
KOKKOS_INLINE_FUNCTION
CustomValueType operator+(const volatile CustomValueType& other) const
volatile {
CustomValueType result;
result.value = this->value + other.value;
return result;
}
private:
value_type value = {};
};
template <class ValueType>
struct TimesTwoUnaryTransformFunctor {
KOKKOS_INLINE_FUNCTION
@ -144,12 +69,6 @@ struct SumJoinFunctor {
ValueType operator()(const ValueType& a, const ValueType& b) const {
return a + b;
}
KOKKOS_INLINE_FUNCTION
ValueType operator()(const volatile ValueType& a,
const volatile ValueType& b) const {
return a + b;
}
};
struct std_algorithms_numerics_test : public ::testing::Test {
@ -239,7 +158,7 @@ struct std_algorithms_numerics_test : public ::testing::Test {
}
};
#if not defined KOKKOS_ENABLE_OPENMPTARGET
#if !defined KOKKOS_ENABLE_OPENMPTARGET
// -------------------------------------------------------------------
// test default case of transform_reduce
@ -260,8 +179,8 @@ void run_and_check_transform_reduce_default(ViewType1 first_view,
const auto r2 = KE::transform_reduce(
"MYLABEL", ExecutionSpace(), KE::cbegin(first_view),
KE::cbegin(first_view), KE::cbegin(second_view), init_value);
EXPECT_TRUE(r1 == init_value);
EXPECT_TRUE(r2 == init_value);
EXPECT_EQ(r1, init_value);
EXPECT_EQ(r2, init_value);
// non-trivial cases
const auto r3 = KE::transform_reduce(ExecutionSpace(), KE::cbegin(first_view),
@ -277,10 +196,10 @@ void run_and_check_transform_reduce_default(ViewType1 first_view,
const auto r6 = KE::transform_reduce("MYLABEL", ExecutionSpace(), first_view,
second_view, init_value);
EXPECT_TRUE(r3 == result_value);
EXPECT_TRUE(r4 == result_value);
EXPECT_TRUE(r5 == result_value);
EXPECT_TRUE(r6 == result_value);
EXPECT_EQ(r3, result_value);
EXPECT_EQ(r4, result_value);
EXPECT_EQ(r5, result_value);
EXPECT_EQ(r6, result_value);
}
TEST_F(std_algorithms_numerics_test,
@ -363,8 +282,8 @@ void run_and_check_transform_reduce_overloadA(ViewType1 first_view,
KE::cbegin(first_view), KE::cbegin(second_view),
init_value, std::forward<Args>(args)...);
EXPECT_TRUE(r1 == init_value);
EXPECT_TRUE(r2 == init_value);
EXPECT_EQ(r1, init_value);
EXPECT_EQ(r2, init_value);
// non trivial cases
const auto r3 = KE::transform_reduce(
@ -382,10 +301,10 @@ void run_and_check_transform_reduce_overloadA(ViewType1 first_view,
KE::transform_reduce("MYLABEL", ExecutionSpace(), first_view, second_view,
init_value, std::forward<Args>(args)...);
EXPECT_TRUE(r3 == result_value);
EXPECT_TRUE(r4 == result_value);
EXPECT_TRUE(r5 == result_value);
EXPECT_TRUE(r6 == result_value);
EXPECT_EQ(r3, result_value);
EXPECT_EQ(r4, result_value);
EXPECT_EQ(r5, result_value);
EXPECT_EQ(r6, result_value);
}
TEST_F(std_algorithms_numerics_test,
@ -482,8 +401,8 @@ void run_and_check_transform_reduce_overloadB(ViewType view,
KE::cbegin(view), KE::cbegin(view),
init_value, std::forward<Args>(args)...);
EXPECT_TRUE(r1 == init_value);
EXPECT_TRUE(r2 == init_value);
EXPECT_EQ(r1, init_value);
EXPECT_EQ(r2, init_value);
// non trivial
const auto r3 =
@ -499,10 +418,10 @@ void run_and_check_transform_reduce_overloadB(ViewType view,
const auto r6 = KE::transform_reduce("MYLABEL", ExecutionSpace(), view,
init_value, std::forward<Args>(args)...);
EXPECT_TRUE(r3 == result_value);
EXPECT_TRUE(r4 == result_value);
EXPECT_TRUE(r5 == result_value);
EXPECT_TRUE(r6 == result_value);
EXPECT_EQ(r3, result_value);
EXPECT_EQ(r4, result_value);
EXPECT_EQ(r5, result_value);
EXPECT_EQ(r6, result_value);
}
TEST_F(std_algorithms_numerics_test,
@ -556,8 +475,8 @@ void run_and_check_reduce_overloadA(ViewType view, ValueType non_trivial_result,
KE::reduce(ExecutionSpace(), KE::cbegin(view), KE::cbegin(view));
const auto r2 = KE::reduce("MYLABEL", ExecutionSpace(), KE::cbegin(view),
KE::cbegin(view));
EXPECT_TRUE(r1 == trivial_result);
EXPECT_TRUE(r2 == trivial_result);
EXPECT_EQ(r1, trivial_result);
EXPECT_EQ(r2, trivial_result);
// non trivial cases
const auto r3 =
@ -567,10 +486,10 @@ void run_and_check_reduce_overloadA(ViewType view, ValueType non_trivial_result,
const auto r5 = KE::reduce(ExecutionSpace(), view);
const auto r6 = KE::reduce("MYLABEL", ExecutionSpace(), view);
EXPECT_TRUE(r3 == non_trivial_result);
EXPECT_TRUE(r4 == non_trivial_result);
EXPECT_TRUE(r5 == non_trivial_result);
EXPECT_TRUE(r6 == non_trivial_result);
EXPECT_EQ(r3, non_trivial_result);
EXPECT_EQ(r4, non_trivial_result);
EXPECT_EQ(r5, non_trivial_result);
EXPECT_EQ(r6, non_trivial_result);
}
TEST_F(std_algorithms_numerics_test,
@ -612,8 +531,8 @@ void run_and_check_reduce_overloadB(ViewType view, ValueType result_value,
KE::cbegin(view), init_value);
const auto r2 = KE::reduce("MYLABEL", ExecutionSpace(), KE::cbegin(view),
KE::cbegin(view), init_value);
EXPECT_TRUE(r1 == init_value);
EXPECT_TRUE(r2 == init_value);
EXPECT_EQ(r1, init_value);
EXPECT_EQ(r2, init_value);
// non trivial cases
const auto r3 = KE::reduce(ExecutionSpace(), KE::cbegin(view), KE::cend(view),
@ -623,10 +542,10 @@ void run_and_check_reduce_overloadB(ViewType view, ValueType result_value,
const auto r5 = KE::reduce(ExecutionSpace(), view, init_value);
const auto r6 = KE::reduce("MYLABEL", ExecutionSpace(), view, init_value);
EXPECT_TRUE(r3 == result_value);
EXPECT_TRUE(r4 == result_value);
EXPECT_TRUE(r5 == result_value);
EXPECT_TRUE(r6 == result_value);
EXPECT_EQ(r3, result_value);
EXPECT_EQ(r4, result_value);
EXPECT_EQ(r5, result_value);
EXPECT_EQ(r6, result_value);
}
TEST_F(std_algorithms_numerics_test,
@ -662,8 +581,8 @@ void run_and_check_reduce_overloadC(ViewType view, ValueType result_value,
KE::cbegin(view), init_value, joiner);
const auto r2 = KE::reduce("MYLABEL", ExecutionSpace(), KE::cbegin(view),
KE::cbegin(view), init_value, joiner);
EXPECT_TRUE(r1 == init_value);
EXPECT_TRUE(r2 == init_value);
EXPECT_EQ(r1, init_value);
EXPECT_EQ(r2, init_value);
// non trivial cases
const auto r3 = KE::reduce(ExecutionSpace(), KE::cbegin(view), KE::cend(view),
@ -674,10 +593,10 @@ void run_and_check_reduce_overloadC(ViewType view, ValueType result_value,
const auto r6 =
KE::reduce("MYLABEL", ExecutionSpace(), view, init_value, joiner);
EXPECT_TRUE(r3 == result_value);
EXPECT_TRUE(r4 == result_value);
EXPECT_TRUE(r5 == result_value);
EXPECT_TRUE(r6 == result_value);
EXPECT_EQ(r3, result_value);
EXPECT_EQ(r4, result_value);
EXPECT_EQ(r5, result_value);
EXPECT_EQ(r6, result_value);
}
TEST_F(std_algorithms_numerics_test,