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

Update Kokkos library in LAMMPS to v4.5.0

Browse Source
This commit is contained in:
Stan Moore
2024-12-13 09:23:03 -07:00
parent a78aee5731
commit 7f68aeb6d5
617 changed files with 21499 additions and 17255 deletions
Download Patch File Download Diff File Expand all files Collapse all files

213
lib/kokkos/core/unit_test/TestMathematicalFunctions.hpp
View File

@ -274,13 +274,13 @@ struct FloatingPointComparison {
#endif
// Using absolute here instead of abs, since we actually test abs ...
template <class T>
KOKKOS_FUNCTION std::enable_if_t<std::is_signed<T>::value, T> absolute(
KOKKOS_FUNCTION std::enable_if_t<std::is_signed_v<T>, T> absolute(
T val) const {
return val < T(0) ? -val : val;
}
template <class T>
KOKKOS_FUNCTION std::enable_if_t<!std::is_signed<T>::value, T> absolute(
KOKKOS_FUNCTION std::enable_if_t<!std::is_signed_v<T>, T> absolute(
T val) const {
return val;
}
@ -325,60 +325,56 @@ struct FloatingPointComparison {
template <class>
struct math_function_name;
#define DEFINE_UNARY_FUNCTION_EVAL(FUNC, ULP_FACTOR) \
struct MathUnaryFunction_##FUNC { \
template <typename T> \
static KOKKOS_FUNCTION auto eval(T x) { \
static_assert( \
std::is_same<decltype(Kokkos::FUNC((T)0)), \
math_unary_function_return_type_t<T>>::value); \
return Kokkos::FUNC(x); \
} \
template <typename T> \
static auto eval_std(T x) { \
if constexpr (std::is_same<T, KE::half_t>::value || \
std::is_same<T, KE::bhalf_t>::value) { \
return std::FUNC(static_cast<float>(x)); \
} else { \
static_assert( \
std::is_same<decltype(std::FUNC((T)0)), \
math_unary_function_return_type_t<T>>::value); \
return std::FUNC(x); \
} \
MATHEMATICAL_FUNCTIONS_TEST_UNREACHABLE \
} \
static KOKKOS_FUNCTION int ulp_factor() { return ULP_FACTOR; } \
}; \
using kk_##FUNC = MathUnaryFunction_##FUNC; \
template <> \
struct math_function_name<MathUnaryFunction_##FUNC> { \
static constexpr char name[] = #FUNC; \
}; \
#define DEFINE_UNARY_FUNCTION_EVAL(FUNC, ULP_FACTOR) \
struct MathUnaryFunction_##FUNC { \
template <typename T> \
static KOKKOS_FUNCTION auto eval(T x) { \
static_assert(std::is_same_v<decltype(Kokkos::FUNC((T)0)), \
math_unary_function_return_type_t<T>>); \
return Kokkos::FUNC(x); \
} \
template <typename T> \
static auto eval_std(T x) { \
if constexpr (std::is_same_v<T, KE::half_t> || \
std::is_same_v<T, KE::bhalf_t>) { \
return std::FUNC(static_cast<float>(x)); \
} else { \
static_assert(std::is_same_v<decltype(std::FUNC((T)0)), \
math_unary_function_return_type_t<T>>); \
return std::FUNC(x); \
} \
MATHEMATICAL_FUNCTIONS_TEST_UNREACHABLE \
} \
static KOKKOS_FUNCTION int ulp_factor() { return ULP_FACTOR; } \
}; \
using kk_##FUNC = MathUnaryFunction_##FUNC; \
template <> \
struct math_function_name<MathUnaryFunction_##FUNC> { \
static constexpr char name[] = #FUNC; \
}; \
constexpr char math_function_name<MathUnaryFunction_##FUNC>::name[]
#define DEFINE_UNARY_FUNCTION_EVAL_CUSTOM(FUNC, ULP_FACTOR, REF_FUNC) \
struct MathUnaryFunction_##FUNC { \
template <typename T> \
static KOKKOS_FUNCTION auto eval(T x) { \
static_assert( \
std::is_same<decltype(Kokkos::FUNC((T)0)), \
math_unary_function_return_type_t<T>>::value); \
return Kokkos::FUNC(x); \
} \
template <typename T> \
static auto eval_std(T x) { \
static_assert( \
std::is_same<decltype(REF_FUNC), \
math_unary_function_return_type_t<T>>::value); \
return REF_FUNC; \
} \
static KOKKOS_FUNCTION int ulp_factor() { return ULP_FACTOR; } \
}; \
using kk_##FUNC = MathUnaryFunction_##FUNC; \
template <> \
struct math_function_name<MathUnaryFunction_##FUNC> { \
static constexpr char name[] = #FUNC; \
}; \
#define DEFINE_UNARY_FUNCTION_EVAL_CUSTOM(FUNC, ULP_FACTOR, REF_FUNC) \
struct MathUnaryFunction_##FUNC { \
template <typename T> \
static KOKKOS_FUNCTION auto eval(T x) { \
static_assert(std::is_same_v<decltype(Kokkos::FUNC((T)0)), \
math_unary_function_return_type_t<T>>); \
return Kokkos::FUNC(x); \
} \
template <typename T> \
static auto eval_std(T x) { \
static_assert(std::is_same_v<decltype(REF_FUNC), \
math_unary_function_return_type_t<T>>); \
return REF_FUNC; \
} \
static KOKKOS_FUNCTION int ulp_factor() { return ULP_FACTOR; } \
}; \
using kk_##FUNC = MathUnaryFunction_##FUNC; \
template <> \
struct math_function_name<MathUnaryFunction_##FUNC> { \
static constexpr char name[] = #FUNC; \
}; \
constexpr char math_function_name<MathUnaryFunction_##FUNC>::name[]
#ifndef KOKKOS_MATHEMATICAL_FUNCTIONS_SKIP_3
@ -451,9 +447,8 @@ DEFINE_UNARY_FUNCTION_EVAL(logb, 2);
struct MathBinaryFunction_##FUNC { \
template <typename T, typename U> \
static KOKKOS_FUNCTION auto eval(T x, U y) { \
static_assert( \
std::is_same<decltype(Kokkos::FUNC((T)0, (U)0)), \
math_binary_function_return_type_t<T, U>>::value); \
static_assert(std::is_same_v<decltype(Kokkos::FUNC((T)0, (U)0)), \
math_binary_function_return_type_t<T, U>>); \
return Kokkos::FUNC(x, y); \
} \
template <typename T, typename U> \
@ -470,8 +465,8 @@ DEFINE_UNARY_FUNCTION_EVAL(logb, 2);
return std::FUNC(x, static_cast<float>(y)); \
else { \
static_assert( \
std::is_same<decltype(std::FUNC((T)0, (U)0)), \
math_binary_function_return_type_t<T, U>>::value); \
std::is_same_v<decltype(std::FUNC((T)0, (U)0)), \
math_binary_function_return_type_t<T, U>>); \
return std::FUNC(x, y); \
} \
MATHEMATICAL_FUNCTIONS_TEST_UNREACHABLE \
@ -494,29 +489,29 @@ DEFINE_BINARY_FUNCTION_EVAL(copysign, 1);
#undef DEFINE_BINARY_FUNCTION_EVAL
#define DEFINE_TERNARY_FUNCTION_EVAL(FUNC, ULP_FACTOR) \
struct MathTernaryFunction_##FUNC { \
template <typename T, typename U, typename V> \
static KOKKOS_FUNCTION auto eval(T x, U y, V z) { \
static_assert( \
std::is_same<decltype(Kokkos::FUNC((T)0, (U)0, (V)0)), \
math_ternary_function_return_type_t<T, U, V>>::value); \
return Kokkos::FUNC(x, y, z); \
} \
template <typename T, typename U, typename V> \
static auto eval_std(T x, U y, V z) { \
static_assert( \
std::is_same<decltype(std::FUNC((T)0, (U)0, (V)0)), \
math_ternary_function_return_type_t<T, U, V>>::value); \
return std::FUNC(x, y, z); \
} \
static KOKKOS_FUNCTION int ulp_factor() { return ULP_FACTOR; } \
}; \
using kk3_##FUNC = MathTernaryFunction_##FUNC; \
template <> \
struct math_function_name<MathTernaryFunction_##FUNC> { \
static constexpr char name[] = #FUNC; \
}; \
#define DEFINE_TERNARY_FUNCTION_EVAL(FUNC, ULP_FACTOR) \
struct MathTernaryFunction_##FUNC { \
template <typename T, typename U, typename V> \
static KOKKOS_FUNCTION auto eval(T x, U y, V z) { \
static_assert( \
std::is_same_v<decltype(Kokkos::FUNC((T)0, (U)0, (V)0)), \
math_ternary_function_return_type_t<T, U, V>>); \
return Kokkos::FUNC(x, y, z); \
} \
template <typename T, typename U, typename V> \
static auto eval_std(T x, U y, V z) { \
static_assert( \
std::is_same_v<decltype(std::FUNC((T)0, (U)0, (V)0)), \
math_ternary_function_return_type_t<T, U, V>>); \
return std::FUNC(x, y, z); \
} \
static KOKKOS_FUNCTION int ulp_factor() { return ULP_FACTOR; } \
}; \
using kk3_##FUNC = MathTernaryFunction_##FUNC; \
template <> \
struct math_function_name<MathTernaryFunction_##FUNC> { \
static constexpr char name[] = #FUNC; \
}; \
constexpr char math_function_name<MathTernaryFunction_##FUNC>::name[]
#ifndef KOKKOS_MATHEMATICAL_FUNCTIONS_SKIP_2
@ -1331,17 +1326,17 @@ struct TestAbsoluteValueFunction {
Kokkos::printf("failed abs(floating_point) special values\n");
}
static_assert(std::is_same<decltype(abs(1)), int>::value);
static_assert(std::is_same<decltype(abs(2l)), long>::value);
static_assert(std::is_same<decltype(abs(3ll)), long long>::value);
static_assert(std::is_same_v<decltype(abs(1)), int>);
static_assert(std::is_same_v<decltype(abs(2l)), long>);
static_assert(std::is_same_v<decltype(abs(3ll)), long long>);
static_assert(std::is_same<decltype(abs(static_cast<KE::half_t>(4.f))),
KE::half_t>::value);
static_assert(std::is_same<decltype(abs(static_cast<KE::bhalf_t>(4.f))),
KE::bhalf_t>::value);
static_assert(std::is_same<decltype(abs(4.f)), float>::value);
static_assert(std::is_same<decltype(abs(5.)), double>::value);
static_assert(std::is_same_v<decltype(abs(4.f)), float>);
static_assert(std::is_same_v<decltype(abs(5.)), double>);
#ifdef MATHEMATICAL_FUNCTIONS_HAVE_LONG_DOUBLE_OVERLOADS
static_assert(std::is_same<decltype(abs(6.l)), long double>::value);
static_assert(std::is_same_v<decltype(abs(6.l)), long double>);
#endif
}
};
@ -1396,10 +1391,10 @@ struct TestFloatingPointAbsoluteValueFunction {
KE::half_t>::value);
static_assert(std::is_same<decltype(fabs(static_cast<KE::bhalf_t>(4.f))),
KE::bhalf_t>::value);
static_assert(std::is_same<decltype(fabs(4.f)), float>::value);
static_assert(std::is_same<decltype(fabs(5.)), double>::value);
static_assert(std::is_same_v<decltype(fabs(4.f)), float>);
static_assert(std::is_same_v<decltype(fabs(5.)), double>);
#ifdef MATHEMATICAL_FUNCTIONS_HAVE_LONG_DOUBLE_OVERLOADS
static_assert(std::is_same<decltype(fabs(6.l)), long double>::value);
static_assert(std::is_same_v<decltype(fabs(6.l)), long double>);
#endif
}
};
@ -1467,10 +1462,10 @@ struct TestFloatingPointRemainderFunction : FloatingPointComparison {
static_assert(std::is_same<decltype(fmod(static_cast<KE::bhalf_t>(4.f),
static_cast<KE::bhalf_t>(4.f))),
KE::bhalf_t>::value);
static_assert(std::is_same<decltype(fmod(4.f, 4.f)), float>::value);
static_assert(std::is_same<decltype(fmod(5., 5.)), double>::value);
static_assert(std::is_same_v<decltype(fmod(4.f, 4.f)), float>);
static_assert(std::is_same_v<decltype(fmod(5., 5.)), double>);
#ifdef MATHEMATICAL_FUNCTIONS_HAVE_LONG_DOUBLE_OVERLOADS
static_assert(std::is_same<decltype(fmod(6.l, 6.l)), long double>::value);
static_assert(std::is_same_v<decltype(fmod(6.l, 6.l)), long double>);
#endif
}
};
@ -1544,11 +1539,11 @@ struct TestIEEEFloatingPointRemainderFunction : FloatingPointComparison {
std::is_same<decltype(remainder(static_cast<KE::bhalf_t>(4.f),
static_cast<KE::bhalf_t>(4.f))),
KE::bhalf_t>::value);
static_assert(std::is_same<decltype(remainder(4.f, 4.f)), float>::value);
static_assert(std::is_same<decltype(remainder(5., 5.)), double>::value);
static_assert(std::is_same_v<decltype(remainder(4.f, 4.f)), float>);
static_assert(std::is_same_v<decltype(remainder(5., 5.)), double>);
#ifdef MATHEMATICAL_FUNCTIONS_HAVE_LONG_DOUBLE_OVERLOADS
static_assert(
std::is_same<decltype(remainder(6.l, 6.l)), long double>::value);
std::is_same_v<decltype(remainder(6.l, 6.l)), long double>);
#endif
}
};
@ -1620,11 +1615,11 @@ struct TestIsFinite {
Kokkos::printf("failed isfinite(floating_point) special values\n");
}
static_assert(std::is_same<decltype(isfinite(1)), bool>::value);
static_assert(std::is_same<decltype(isfinite(2.f)), bool>::value);
static_assert(std::is_same<decltype(isfinite(3.)), bool>::value);
static_assert(std::is_same_v<decltype(isfinite(1)), bool>);
static_assert(std::is_same_v<decltype(isfinite(2.f)), bool>);
static_assert(std::is_same_v<decltype(isfinite(3.)), bool>);
#ifdef MATHEMATICAL_FUNCTIONS_HAVE_LONG_DOUBLE_OVERLOADS
static_assert(std::is_same<decltype(isfinite(4.l)), bool>::value);
static_assert(std::is_same_v<decltype(isfinite(4.l)), bool>);
#endif
}
};
@ -1691,11 +1686,11 @@ struct TestIsInf {
Kokkos::printf("failed isinf(floating_point) special values\n");
}
static_assert(std::is_same<decltype(isinf(1)), bool>::value);
static_assert(std::is_same<decltype(isinf(2.f)), bool>::value);
static_assert(std::is_same<decltype(isinf(3.)), bool>::value);
static_assert(std::is_same_v<decltype(isinf(1)), bool>);
static_assert(std::is_same_v<decltype(isinf(2.f)), bool>);
static_assert(std::is_same_v<decltype(isinf(3.)), bool>);
#ifdef MATHEMATICAL_FUNCTIONS_HAVE_LONG_DOUBLE_OVERLOADS
static_assert(std::is_same<decltype(isinf(4.l)), bool>::value);
static_assert(std::is_same_v<decltype(isinf(4.l)), bool>);
#endif
}
};
@ -1762,11 +1757,11 @@ struct TestIsNaN {
Kokkos::printf("failed isnan(floating_point) special values\n");
}
static_assert(std::is_same<decltype(isnan(1)), bool>::value);
static_assert(std::is_same<decltype(isnan(2.f)), bool>::value);
static_assert(std::is_same<decltype(isnan(3.)), bool>::value);
static_assert(std::is_same_v<decltype(isnan(1)), bool>);
static_assert(std::is_same_v<decltype(isnan(2.f)), bool>);
static_assert(std::is_same_v<decltype(isnan(3.)), bool>);
#ifdef MATHEMATICAL_FUNCTIONS_HAVE_LONG_DOUBLE_OVERLOADS
static_assert(std::is_same<decltype(isnan(4.l)), bool>::value);
static_assert(std::is_same_v<decltype(isnan(4.l)), bool>);
#endif
}
};