From 4f3871ce2809b654974c462a47612ede78bead79 Mon Sep 17 00:00:00 2001 From: Dong Hun Lee Date: Mon, 12 Aug 2024 22:47:48 -0600 Subject: [PATCH] Refactored simd reductions; removed signed shift left tests --- simd/src/Kokkos_SIMD_Common.hpp | 121 +++++++++++------- simd/src/Kokkos_SIMD_Common_Math.hpp | 20 ++- simd/src/Kokkos_SIMD_Scalar.hpp | 110 +++++++++++++++- simd/unit_tests/include/SIMDTesting_Ops.hpp | 38 ++++-- simd/unit_tests/include/TestSIMD_ShiftOps.hpp | 8 -- 5 files changed, 222 insertions(+), 75 deletions(-) diff --git a/simd/src/Kokkos_SIMD_Common.hpp b/simd/src/Kokkos_SIMD_Common.hpp index 15245501e54..70ba0b00d65 100644 --- a/simd/src/Kokkos_SIMD_Common.hpp +++ b/simd/src/Kokkos_SIMD_Common.hpp @@ -25,6 +25,10 @@ namespace Kokkos { namespace Experimental { +namespace simd_abi { +class scalar; +} + template class simd; @@ -134,7 +138,7 @@ template template , bool> = false> -[[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION auto operator+( +[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION auto operator+( Experimental::simd const& lhs, U rhs) { using result_member = decltype(lhs[0] + rhs); return Experimental::simd(lhs) + @@ -143,16 +147,18 @@ template , bool> = false> -[[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION auto operator+( +[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION auto operator+( U lhs, Experimental::simd const& rhs) { using result_member = decltype(lhs + rhs[0]); return Experimental::simd(lhs) + Experimental::simd(rhs); } -template -KOKKOS_FORCEINLINE_FUNCTION simd& operator+=(simd& lhs, - U&& rhs) { +template < + class T, class U, class Abi, + std::enable_if_t, bool> = false> +KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd& operator+=( + simd& lhs, U&& rhs) { lhs = lhs + std::forward(rhs); return lhs; } @@ -166,7 +172,7 @@ KOKKOS_FORCEINLINE_FUNCTION where_expression& operator+=( template , bool> = false> -[[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION auto operator-( +[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION auto operator-( Experimental::simd const& lhs, U rhs) { using result_member = decltype(lhs[0] - rhs); return Experimental::simd(lhs) - @@ -175,22 +181,24 @@ template , bool> = false> -[[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION auto operator-( +[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION auto operator-( U lhs, Experimental::simd const& rhs) { using result_member = decltype(lhs - rhs[0]); return Experimental::simd(lhs) - Experimental::simd(rhs); } -template -KOKKOS_FORCEINLINE_FUNCTION simd& operator-=(simd& lhs, - U&& rhs) { +template < + class T, class U, class Abi, + std::enable_if_t, bool> = false> +KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd& operator-=( + simd& lhs, U&& rhs) { lhs = lhs - std::forward(rhs); return lhs; } template -KOKKOS_FORCEINLINE_FUNCTION where_expression& operator-=( +KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION where_expression& operator-=( where_expression& lhs, U&& rhs) { lhs = lhs.value() - std::forward(rhs); return lhs; @@ -198,7 +206,7 @@ KOKKOS_FORCEINLINE_FUNCTION where_expression& operator-=( template , bool> = false> -[[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION auto operator*( +[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION auto operator*( Experimental::simd const& lhs, U rhs) { using result_member = decltype(lhs[0] * rhs); return Experimental::simd(lhs) * @@ -207,22 +215,24 @@ template , bool> = false> -[[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION auto operator*( +[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION auto operator*( U lhs, Experimental::simd const& rhs) { using result_member = decltype(lhs * rhs[0]); return Experimental::simd(lhs) * Experimental::simd(rhs); } -template -KOKKOS_FORCEINLINE_FUNCTION simd& operator*=(simd& lhs, - U&& rhs) { +template < + class T, class U, class Abi, + std::enable_if_t, bool> = false> +KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd& operator*=( + simd& lhs, U&& rhs) { lhs = lhs * std::forward(rhs); return lhs; } template -KOKKOS_FORCEINLINE_FUNCTION where_expression& operator*=( +KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION where_expression& operator*=( where_expression& lhs, U&& rhs) { lhs = lhs.value() * std::forward(rhs); return lhs; @@ -230,7 +240,7 @@ KOKKOS_FORCEINLINE_FUNCTION where_expression& operator*=( template , bool> = false> -[[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION auto operator/( +[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION auto operator/( Experimental::simd const& lhs, Experimental::simd const& rhs) { return Experimental::simd( @@ -239,7 +249,7 @@ template , bool> = false> -[[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION auto operator/( +[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION auto operator/( Experimental::simd const& lhs, U rhs) { using result_member = decltype(lhs[0] / rhs); return Experimental::simd(lhs) / @@ -248,37 +258,43 @@ template , bool> = false> -[[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION auto operator/( +[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION auto operator/( U lhs, Experimental::simd const& rhs) { using result_member = decltype(lhs / rhs[0]); return Experimental::simd(lhs) / Experimental::simd(rhs); } -template -KOKKOS_FORCEINLINE_FUNCTION simd& operator/=(simd& lhs, - U&& rhs) { +template < + class T, class U, class Abi, + std::enable_if_t, bool> = false> +KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd& operator/=( + simd& lhs, U&& rhs) { lhs = lhs / std::forward(rhs); return lhs; } template -KOKKOS_FORCEINLINE_FUNCTION where_expression& operator/=( +KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION where_expression& operator/=( where_expression& lhs, U&& rhs) { lhs = lhs.value() / std::forward(rhs); return lhs; } -template -KOKKOS_FORCEINLINE_FUNCTION simd& operator>>=(simd& lhs, - U&& rhs) { +template < + class T, class U, class Abi, + std::enable_if_t, bool> = false> +KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd& operator>>=( + simd& lhs, U&& rhs) { lhs = lhs >> std::forward(rhs); return lhs; } -template -KOKKOS_FORCEINLINE_FUNCTION simd& operator<<=(simd& lhs, - U&& rhs) { +template < + class T, class U, class Abi, + std::enable_if_t, bool> = false> +KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd& operator<<=( + simd& lhs, U&& rhs) { lhs = lhs << std::forward(rhs); return lhs; } @@ -332,17 +348,16 @@ template return Kokkos::round(x); } -// fallback implementations of simd reductions: - +// common implementations of host only simd reductions: template > -[[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION constexpr T reduce( +[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr T reduce( const simd& x, BinaryOperation binary_op = {}) { auto v = where(true, x); return reduce(v, binary_op); } template -[[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION constexpr T reduce( +[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr T reduce( const simd& x, const typename simd::mask_type& mask, T identity_element, BinaryOperation binary_op) { if (none_of(mask)) return identity_element; @@ -350,50 +365,60 @@ template return reduce(v, binary_op); } -template -[[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION constexpr T reduce( +template < + class T, class Abi, + std::enable_if_t, bool> = false> +[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr T reduce( const simd& x, const typename simd::mask_type& mask, std::plus<> binary_op = {}) noexcept { return reduce(x, mask, T(0), binary_op); } -template -[[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION constexpr T reduce( +template < + class T, class Abi, + std::enable_if_t, bool> = false> +[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr T reduce( const simd& x, const typename simd::mask_type& mask, std::multiplies<> binary_op) noexcept { return reduce(x, mask, T(0), binary_op); } -template -[[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION constexpr T reduce( +template < + class T, class Abi, + std::enable_if_t, bool> = false> +[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr T reduce( const simd& x, const typename simd::mask_type& mask, std::bit_and<> binary_op) noexcept { return reduce(x, mask, 0, binary_op); } -template -[[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION constexpr T reduce( +template < + class T, class Abi, + std::enable_if_t, bool> = false> +[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr T reduce( const simd& x, const typename simd::mask_type& mask, std::bit_or<> binary_op) noexcept { return reduce(x, mask, 0, binary_op); } -template -[[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION constexpr T reduce( +template < + class T, class Abi, + std::enable_if_t, bool> = false> +[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr T reduce( const simd& x, const typename simd::mask_type& mask, std::bit_xor<> binary_op) noexcept { return reduce(x, mask, 0, binary_op); } template -[[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION constexpr T reduce_min( +[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr T reduce_min( const simd& x) noexcept { auto v = where(true, x); return reduce_min(v); } template -[[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION constexpr T reduce_min( +[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr T reduce_min( const simd& x, const typename simd::mask_type& mask) noexcept { auto v = where(mask, x); @@ -401,14 +426,14 @@ template } template -[[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION constexpr T reduce_max( +[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr T reduce_max( const simd& x) noexcept { auto v = where(true, x); return reduce_max(v); } template -[[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION constexpr T reduce_max( +[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr T reduce_max( const simd& x, const typename simd::mask_type& mask) noexcept { auto v = where(mask, x); diff --git a/simd/src/Kokkos_SIMD_Common_Math.hpp b/simd/src/Kokkos_SIMD_Common_Math.hpp index 8b96bc1dd9d..44e0531053c 100644 --- a/simd/src/Kokkos_SIMD_Common_Math.hpp +++ b/simd/src/Kokkos_SIMD_Common_Math.hpp @@ -23,6 +23,10 @@ namespace Kokkos { namespace Experimental { +namespace simd_abi { +class scalar; +} + template class simd; @@ -58,7 +62,9 @@ hmax(const_where_expression, simd> const& x) { } #endif -template +template < + typename T, typename Abi, + std::enable_if_t, bool> = false> [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION T reduce_min(const_where_expression, simd> const& x) { auto const& v = x.impl_get_value(); @@ -70,7 +76,9 @@ reduce_min(const_where_expression, simd> const& x) { return result; } -template +template < + class T, class Abi, + std::enable_if_t, bool> = false> [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION T reduce_max(const_where_expression, simd> const& x) { auto const& v = x.impl_get_value(); @@ -82,7 +90,9 @@ reduce_max(const_where_expression, simd> const& x) { return result; } -template > +template < + class T, class Abi, class BinaryOperation = std::plus<>, + std::enable_if_t, bool> = false> [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION T reduce(const_where_expression, simd> const& x, BinaryOperation op = {}) { @@ -95,7 +105,9 @@ reduce(const_where_expression, simd> const& x, return result; } -template +template < + class T, class Abi, + std::enable_if_t, bool> = false> [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION T reduce(const_where_expression, simd> const& x, T, std::plus<>) { diff --git a/simd/src/Kokkos_SIMD_Scalar.hpp b/simd/src/Kokkos_SIMD_Scalar.hpp index e2c82f0eb8c..7ac23d1a19b 100644 --- a/simd/src/Kokkos_SIMD_Scalar.hpp +++ b/simd/src/Kokkos_SIMD_Scalar.hpp @@ -154,18 +154,38 @@ class simd { simd const& lhs, simd const& rhs) noexcept { return simd(lhs.m_value * rhs.m_value); } + template , bool> = false> + [[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION friend constexpr simd operator*( + simd const& lhs, U rhs) { + return lhs.m_value * simd(rhs); + } [[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION friend constexpr simd operator/( simd const& lhs, simd const& rhs) noexcept { return simd(lhs.m_value / rhs.m_value); } + template , bool> = false> + [[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION friend constexpr simd operator/( + simd const& lhs, U rhs) { + return lhs.m_value / simd(rhs); + } [[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION friend constexpr simd operator+( simd const& lhs, simd const& rhs) noexcept { return simd(lhs.m_value + rhs.m_value); } + template , bool> = false> + [[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION friend constexpr simd operator+( + simd const& lhs, U rhs) { + return lhs.m_value + simd(rhs); + } [[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION friend constexpr simd operator-( simd const& lhs, simd const& rhs) noexcept { return simd(lhs.m_value - rhs.m_value); } + template , bool> = false> + [[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION friend constexpr simd operator-( + simd const& lhs, U rhs) { + return lhs.m_value - simd(rhs); + } [[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION friend constexpr simd operator>>( simd const& lhs, int rhs) noexcept { return simd(lhs.m_value >> rhs); @@ -190,6 +210,36 @@ class simd { simd const& lhs, simd const& rhs) noexcept { return lhs.m_value | rhs.m_value; } + [[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION friend constexpr simd operator+=( + simd& lhs, simd const& rhs) noexcept { + lhs = lhs + rhs; + return lhs; + } + [[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION friend constexpr simd operator-=( + simd& lhs, simd const& rhs) noexcept { + lhs = lhs - rhs; + return lhs; + } + [[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION friend constexpr simd operator*=( + simd& lhs, simd const& rhs) noexcept { + lhs = lhs * rhs; + return lhs; + } + [[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION friend constexpr simd operator/=( + simd& lhs, simd const& rhs) noexcept { + lhs = lhs / rhs; + return lhs; + } + [[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION friend constexpr simd operator>>=( + simd& lhs, simd const& rhs) noexcept { + lhs = lhs >> rhs; + return lhs; + } + [[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION friend constexpr simd operator<<=( + simd& lhs, simd const& rhs) noexcept { + lhs = lhs << rhs; + return lhs; + } [[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION friend constexpr mask_type operator<(simd const& lhs, simd const& rhs) noexcept { return mask_type(lhs.m_value < rhs.m_value); @@ -297,6 +347,54 @@ KOKKOS_FORCEINLINE_FUNCTION simd condition( : static_cast(c)); } +template +[[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION T +reduce(Experimental::simd const& x, + BinaryOperation binary_op) { + auto v = where(true, x); + return reduce(v, T(0), binary_op); +} + +template +[[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION T +reduce(Experimental::simd const& x, + Experimental::simd_mask const& mask, + BinaryOperation binary_op) { + if (!mask) return T(0); + auto v = where(mask, x); + return reduce(v, T(0), binary_op); +} + +template +[[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION T +reduce_min(Experimental::simd const& x) { + auto v = where(true, x); + return reduce_min(v); +} + +template +[[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION T reduce_min( + Experimental::simd const& x, + Experimental::simd_mask const& mask) { + auto v = where(mask, x); + return reduce_min(v); +} + +template +[[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION T +reduce_max(Experimental::simd const& x) { + auto v = where(true, x); + return reduce_max(v); +} + +template +[[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION T reduce_max( + Experimental::simd const& x, + Experimental::simd_mask const& mask) { + auto v = where(mask, x); + return reduce_max(v); +} + template class const_where_expression, simd> { @@ -416,16 +514,24 @@ template return a == simd_mask(false); } -template +template [[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION T reduce(const_where_expression, simd> const& x, - T identity_element, std::plus<>) { + T identity_element, BinaryOperation) { return static_cast(x.impl_get_mask()) ? static_cast(x.impl_get_value()) : identity_element; } +template +[[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION T +reduce(const_where_expression, + simd> const& x, + BinaryOperation op) { + return reduce(x, T(0), op); +} + #ifdef KOKKOS_ENABLE_DEPRECATED_CODE_4 template [[nodiscard]] KOKKOS_DEPRECATED KOKKOS_FORCEINLINE_FUNCTION T diff --git a/simd/unit_tests/include/SIMDTesting_Ops.hpp b/simd/unit_tests/include/SIMDTesting_Ops.hpp index 3ce00ddefff..e107c4b053c 100644 --- a/simd/unit_tests/include/SIMDTesting_Ops.hpp +++ b/simd/unit_tests/include/SIMDTesting_Ops.hpp @@ -34,11 +34,11 @@ class plus { class plus_eq { public: template - auto& on_host(T&& a, T&& b) const { + auto on_host(T&& a, T&& b) const { return a += b; } template - KOKKOS_INLINE_FUNCTION auto& on_device(T&& a, T&& b) const { + KOKKOS_INLINE_FUNCTION auto on_device(T&& a, T&& b) const { return a += b; } }; @@ -58,11 +58,11 @@ class minus { class minus_eq { public: template - auto& on_host(T&& a, T&& b) const { + auto on_host(T&& a, T&& b) const { return a -= b; } template - KOKKOS_INLINE_FUNCTION auto& on_device(T&& a, T&& b) const { + KOKKOS_INLINE_FUNCTION auto on_device(T&& a, T&& b) const { return a -= b; } }; @@ -82,11 +82,11 @@ class multiplies { class multiplies_eq { public: template - auto& on_host(T&& a, T&& b) const { + auto on_host(T&& a, T&& b) const { return a *= b; } template - KOKKOS_INLINE_FUNCTION auto& on_device(T&& a, T&& b) const { + KOKKOS_INLINE_FUNCTION auto on_device(T&& a, T&& b) const { return a *= b; } }; @@ -106,11 +106,11 @@ class divides { class divides_eq { public: template - auto& on_host(T&& a, T&& b) const { + auto on_host(T&& a, T&& b) const { return a /= b; } template - KOKKOS_INLINE_FUNCTION auto& on_device(T&& a, T&& b) const { + KOKKOS_INLINE_FUNCTION auto on_device(T&& a, T&& b) const { return a /= b; } }; @@ -250,11 +250,11 @@ class shift_right { class shift_right_eq { public: template - auto& on_host(T&& a, U&& b) const { + auto on_host(T&& a, U&& b) const { return a >>= b; } template - KOKKOS_INLINE_FUNCTION auto& on_device(T&& a, U&& b) const { + KOKKOS_INLINE_FUNCTION auto on_device(T&& a, U&& b) const { return a >>= b; } }; @@ -274,11 +274,11 @@ class shift_left { class shift_left_eq { public: template - auto& on_host(T&& a, U&& b) const { + auto on_host(T&& a, U&& b) const { return a <<= b; } template - KOKKOS_INLINE_FUNCTION auto& on_device(T&& a, U&& b) const { + KOKKOS_INLINE_FUNCTION auto on_device(T&& a, U&& b) const { return a <<= b; } }; @@ -364,7 +364,19 @@ class reduce_where_expr { auto const& m = w.impl_get_mask(); auto result = v[0]; for (std::size_t i = 1; i < v.size(); ++i) { - if (m[i]) result = BinaryOperation()(result, v[i]); + if constexpr (std::is_same_v>) { + if (m[i]) result = result + v[i]; + } else if constexpr (std::is_same_v>) { + if (m[i]) result = result * v[i]; + } else if constexpr (std::is_same_v>) { + if (m[i]) result = result & v[i]; + } else if constexpr (std::is_same_v>) { + if (m[i]) result = result | v[i]; + } else if constexpr (std::is_same_v>) { + if (m[i]) result = result ^ v[i]; + } else { + Kokkos::abort("Unsupported reduce operation"); + } } return result; } diff --git a/simd/unit_tests/include/TestSIMD_ShiftOps.hpp b/simd/unit_tests/include/TestSIMD_ShiftOps.hpp index 2963d1b6b70..07e82634bcb 100644 --- a/simd/unit_tests/include/TestSIMD_ShiftOps.hpp +++ b/simd/unit_tests/include/TestSIMD_ShiftOps.hpp @@ -138,10 +138,6 @@ inline void host_check_shift_ops() { num_cases); host_check_shift_op_all_loaders(shift_right_eq(), test_vals, shift_by, num_cases); - host_check_shift_op_all_loaders(shift_left(), test_vals, shift_by, - num_cases); - host_check_shift_op_all_loaders(shift_left_eq(), test_vals, - shift_by, num_cases); } } } @@ -269,10 +265,6 @@ KOKKOS_INLINE_FUNCTION void device_check_shift_ops() { shift_by, num_cases); device_check_shift_op_all_loaders(shift_right_eq(), test_vals, shift_by, num_cases); - device_check_shift_op_all_loaders(shift_left(), test_vals, - shift_by, num_cases); - device_check_shift_op_all_loaders(shift_left_eq(), test_vals, - shift_by, num_cases); } } }