fix ternary op in subset of std algorithms not working with nvhpc (ko…

…kkos#6095) * fix std algorithms for nvhpc This fixes tests disabled in fb8179f Co-authored-by: Cezary Skrzyński * fix index type * improve comments * address PR comments * fix comments per CI suggestions * revert is_sort_until
nliber · May 4, 2023 · a45cc1e · a45cc1e
1 parent 7a166d2
commit a45cc1e
Show file tree

Hide file tree

Showing 21 changed files with 57 additions and 122 deletions.
diff --git a/algorithms/src/std_algorithms/impl/Kokkos_AdjacentFind.hpp b/algorithms/src/std_algorithms/impl/Kokkos_AdjacentFind.hpp
@@ -42,12 +42,13 @@ struct StdAdjacentFindFunctor {
     const auto& next_value = m_first[i + 1];
     const bool are_equal   = m_p(my_value, next_value);
 
-    auto rv =
-        are_equal
-            ? red_value_type{i}
-            : red_value_type{::Kokkos::reduction_identity<IndexType>::min()};
+    // FIXME_NVHPC using a ternary operator causes problems
+    red_value_type value = {::Kokkos::reduction_identity<IndexType>::min()};
+    if (are_equal) {
+      value.min_loc_true = i;
+    }
 
-    m_reducer.join(red_value, rv);
+    m_reducer.join(red_value, value);
   }
 
   KOKKOS_FUNCTION

diff --git a/algorithms/src/std_algorithms/impl/Kokkos_FindEnd.hpp b/algorithms/src/std_algorithms/impl/Kokkos_FindEnd.hpp
@@ -59,9 +59,11 @@ struct StdFindEndFunctor {
       }
     }
 
-    const auto rv =
-        found ? red_value_type{i}
-              : red_value_type{::Kokkos::reduction_identity<IndexType>::max()};
+    // FIXME_NVHPC using a ternary operator causes problems
+    red_value_type rv = {::Kokkos::reduction_identity<IndexType>::max()};
+    if (found) {
+      rv.max_loc_true = i;
+    }
 
     m_reducer.join(red_value, rv);
   }

diff --git a/algorithms/src/std_algorithms/impl/Kokkos_FindFirstOf.hpp b/algorithms/src/std_algorithms/impl/Kokkos_FindFirstOf.hpp
@@ -52,10 +52,11 @@ struct StdFindFirstOfFunctor {
       }
     }
 
-    const auto rv =
-        found ? red_value_type{i}
-              : red_value_type{::Kokkos::reduction_identity<IndexType>::min()};
-
+    // FIXME_NVHPC using a ternary operator causes problems
+    red_value_type rv = {::Kokkos::reduction_identity<IndexType>::min()};
+    if (found) {
+      rv.min_loc_true = i;
+    }
     m_reducer.join(red_value, rv);
   }
 

diff --git a/algorithms/src/std_algorithms/impl/Kokkos_FindIfOrNot.hpp b/algorithms/src/std_algorithms/impl/Kokkos_FindIfOrNot.hpp
@@ -44,10 +44,11 @@ struct StdFindIfOrNotFunctor {
     // if doing find_if_not, look for when predicate is false
     const bool found_condition = is_find_if ? m_p(my_value) : !m_p(my_value);
 
-    auto rv =
-        found_condition
-            ? red_value_type{i}
-            : red_value_type{::Kokkos::reduction_identity<IndexType>::min()};
+    // FIXME_NVHPC using a ternary operator causes problems
+    red_value_type rv = {::Kokkos::reduction_identity<IndexType>::min()};
+    if (found_condition) {
+      rv.min_loc_true = i;
+    }
 
     m_reducer.join(red_value, rv);
   }

diff --git a/algorithms/src/std_algorithms/impl/Kokkos_IsPartitioned.hpp b/algorithms/src/std_algorithms/impl/Kokkos_IsPartitioned.hpp
@@ -43,8 +43,12 @@ struct StdIsPartitionedFunctor {
         ::Kokkos::reduction_identity<index_type>::min();
     constexpr index_type m_red_id_max =
         ::Kokkos::reduction_identity<index_type>::max();
-    auto rv = predicate_value ? red_value_type{i, m_red_id_min}
-                              : red_value_type{m_red_id_max, i};
+
+    // FIXME_NVHPC using a ternary operator causes problems
+    red_value_type rv = {m_red_id_max, i};
+    if (predicate_value) {
+      rv = {i, m_red_id_min};
+    }
 
     m_reducer.join(redValue, rv);
   }

diff --git a/algorithms/src/std_algorithms/impl/Kokkos_LexicographicalCompare.hpp b/algorithms/src/std_algorithms/impl/Kokkos_LexicographicalCompare.hpp
@@ -63,12 +63,14 @@ struct StdLexicographicalCompareFunctor {
     const auto& my_value1 = m_first1[i];
     const auto& my_value2 = m_first2[i];
 
-    bool different = m_comparator(my_value1, my_value2) ||
-                     m_comparator(my_value2, my_value1);
-    auto rv =
-        different
-            ? red_value_type{i}
-            : red_value_type{::Kokkos::reduction_identity<IndexType>::min()};
+    const bool different = m_comparator(my_value1, my_value2) ||
+                           m_comparator(my_value2, my_value1);
+
+    // FIXME_NVHPC using a ternary operator causes problems
+    red_value_type rv = {::Kokkos::reduction_identity<IndexType>::min()};
+    if (different) {
+      rv.min_loc_true = i;
+    }
 
     m_reducer.join(red_value, rv);
   }

diff --git a/algorithms/src/std_algorithms/impl/Kokkos_Mismatch.hpp b/algorithms/src/std_algorithms/impl/Kokkos_Mismatch.hpp
@@ -42,10 +42,11 @@ struct StdMismatchRedFunctor {
     const auto& my_value1 = m_first1[i];
     const auto& my_value2 = m_first2[i];
 
-    auto rv =
-        !m_predicate(my_value1, my_value2)
-            ? red_value_type{i}
-            : red_value_type{::Kokkos::reduction_identity<IndexType>::min()};
+    // FIXME_NVHPC using a ternary operator causes problems
+    red_value_type rv = {i};
+    if (m_predicate(my_value1, my_value2)) {
+      rv = {::Kokkos::reduction_identity<IndexType>::min()};
+    }
 
     m_reducer.join(red_value, rv);
   }

diff --git a/algorithms/src/std_algorithms/impl/Kokkos_PartitionPoint.hpp b/algorithms/src/std_algorithms/impl/Kokkos_PartitionPoint.hpp
@@ -39,10 +39,13 @@ struct StdPartitionPointFunctor {
   KOKKOS_FUNCTION
   void operator()(const index_type i, red_value_type& redValue) const {
     const auto predicate_value = m_p(m_first[i]);
-    auto rv =
-        predicate_value
-            ? red_value_type{::Kokkos::reduction_identity<index_type>::min()}
-            : red_value_type{i};
+
+    // FIXME_NVHPC using a ternary operator causes problems
+    red_value_type rv = {i};
+    if (predicate_value) {
+      rv = {::Kokkos::reduction_identity<index_type>::min()};
+    }
+
     m_reducer.join(redValue, rv);
   }
 

diff --git a/algorithms/src/std_algorithms/impl/Kokkos_Search.hpp b/algorithms/src/std_algorithms/impl/Kokkos_Search.hpp
@@ -60,9 +60,11 @@ struct StdSearchFunctor {
       }
     }
 
-    const auto rv =
-        found ? red_value_type{i}
-              : red_value_type{::Kokkos::reduction_identity<IndexType>::min()};
+    // FIXME_NVHPC using a ternary operator causes problems
+    red_value_type rv = {::Kokkos::reduction_identity<IndexType>::min()};
+    if (found) {
+      rv = {i};
+    }
 
     m_reducer.join(red_value, rv);
   }

diff --git a/algorithms/src/std_algorithms/impl/Kokkos_SearchN.hpp b/algorithms/src/std_algorithms/impl/Kokkos_SearchN.hpp
@@ -59,9 +59,11 @@ struct StdSearchNFunctor {
       }
     }
 
-    const auto rv =
-        found ? red_value_type{i}
-              : red_value_type{::Kokkos::reduction_identity<IndexType>::min()};
+    // FIXME_NVHPC using a ternary operator causes problems
+    red_value_type rv = {::Kokkos::reduction_identity<IndexType>::min()};
+    if (found) {
+      rv.min_loc_true = i;
+    }
 
     m_reducer.join(red_value, rv);
   }

diff --git a/algorithms/unit_tests/TestStdAlgorithmsAdjacentFind.cpp b/algorithms/unit_tests/TestStdAlgorithmsAdjacentFind.cpp
@@ -287,12 +287,6 @@ void run_all_scenarios() {
 }
 
 TEST(std_algorithms_nonmod_seq_ops, adjacent_find) {
-#if defined(KOKKOS_ENABLE_CUDA) && \
-    defined(KOKKOS_COMPILER_NVHPC)  // FIXME_NVHPC
-  if constexpr (std::is_same_v<exespace, Kokkos::Cuda>) {
-    GTEST_SKIP() << "FIXME wrong result";
-  }
-#endif
   run_all_scenarios<DynamicTag, int>();
   run_all_scenarios<DynamicTag, double>();
   run_all_scenarios<StridedThreeTag, int>();

diff --git a/algorithms/unit_tests/TestStdAlgorithmsAllAnyNoneOf.cpp b/algorithms/unit_tests/TestStdAlgorithmsAllAnyNoneOf.cpp
@@ -147,12 +147,6 @@ void run_all_scenarios() {
 }
 
 TEST(std_algorithms_all_any_none_of_test, test) {
-#if defined(KOKKOS_ENABLE_CUDA) && \
-    defined(KOKKOS_COMPILER_NVHPC)  // FIXME_NVHPC
-  if constexpr (std::is_same_v<exespace, Kokkos::Cuda>) {
-    GTEST_SKIP() << "FIXME wrong result";
-  }
-#endif
   run_all_scenarios<DynamicTag, double>();
   run_all_scenarios<StridedTwoTag, int>();
   run_all_scenarios<StridedThreeTag, unsigned>();

diff --git a/algorithms/unit_tests/TestStdAlgorithmsFind.cpp b/algorithms/unit_tests/TestStdAlgorithmsFind.cpp
@@ -151,12 +151,6 @@ void run_all_scenarios() {
 }
 
 TEST(std_algorithms_find_test, test) {
-#if defined(KOKKOS_ENABLE_CUDA) && \
-    defined(KOKKOS_COMPILER_NVHPC)  // FIXME_NVHPC
-  if constexpr (std::is_same_v<exespace, Kokkos::Cuda>) {
-    GTEST_SKIP() << "FIXME wrong result";
-  }
-#endif
   run_all_scenarios<DynamicTag, double>();
   run_all_scenarios<StridedTwoTag, int>();
   run_all_scenarios<StridedThreeTag, unsigned>();

diff --git a/algorithms/unit_tests/TestStdAlgorithmsFindEnd.cpp b/algorithms/unit_tests/TestStdAlgorithmsFindEnd.cpp
@@ -348,12 +348,6 @@ void run_all_scenarios() {
 }
 
 TEST(std_algorithms_non_mod_seq_ops, find_end) {
-#if defined(KOKKOS_ENABLE_CUDA) && \
-    defined(KOKKOS_COMPILER_NVHPC)  // FIXME_NVHPC
-  if constexpr (std::is_same_v<exespace, Kokkos::Cuda>) {
-    GTEST_SKIP() << "FIXME wrong result";
-  }
-#endif
   run_all_scenarios<DynamicTag, int>();
   run_all_scenarios<StridedThreeTag, int>();
 }

diff --git a/algorithms/unit_tests/TestStdAlgorithmsFindFirstOf.cpp b/algorithms/unit_tests/TestStdAlgorithmsFindFirstOf.cpp
@@ -264,12 +264,6 @@ void run_all_scenarios() {
 }
 
 TEST(std_algorithms_non_mod_seq_ops, find_first_of) {
-#if defined(KOKKOS_ENABLE_CUDA) && \
-    defined(KOKKOS_COMPILER_NVHPC)  // FIXME_NVHPC
-  if constexpr (std::is_same_v<exespace, Kokkos::Cuda>) {
-    GTEST_SKIP() << "FIXME wrong result";
-  }
-#endif
   run_all_scenarios<DynamicTag, int>();
   run_all_scenarios<StridedThreeTag, int>();
 }

diff --git a/algorithms/unit_tests/TestStdAlgorithmsIsSortedUntil.cpp b/algorithms/unit_tests/TestStdAlgorithmsIsSortedUntil.cpp
@@ -185,12 +185,6 @@ void run_is_sorted_until_all_scenarios() {
 }
 
 TEST(std_algorithms_sorting_ops_test, is_sorted_until) {
-#if defined(KOKKOS_ENABLE_CUDA) && \
-    defined(KOKKOS_COMPILER_NVHPC)  // FIXME_NVHPC
-  if constexpr (std::is_same_v<exespace, Kokkos::Cuda>) {
-    GTEST_SKIP() << "FIXME wrong result";
-  }
-#endif
   run_is_sorted_until_all_scenarios<DynamicTag, double>();
   run_is_sorted_until_all_scenarios<StridedTwoTag, double>();
   run_is_sorted_until_all_scenarios<StridedThreeTag, double>();

diff --git a/algorithms/unit_tests/TestStdAlgorithmsLexicographicalCompare.cpp b/algorithms/unit_tests/TestStdAlgorithmsLexicographicalCompare.cpp
@@ -140,12 +140,6 @@ void run_all_scenarios() {
 }
 
 TEST(std_algorithms_lexicographical_compare_test, test) {
-#if defined(KOKKOS_ENABLE_CUDA) && \
-    defined(KOKKOS_COMPILER_NVHPC)  // FIXME_NVHPC
-  if constexpr (std::is_same_v<exespace, Kokkos::Cuda>) {
-    GTEST_SKIP() << "FIXME wrong result";
-  }
-#endif
 // FIXME: should this disable only custom comparator tests?
 #if !defined KOKKOS_ENABLE_OPENMPTARGET
   run_all_scenarios<DynamicTag, double>();

diff --git a/algorithms/unit_tests/TestStdAlgorithmsMismatch.cpp b/algorithms/unit_tests/TestStdAlgorithmsMismatch.cpp
@@ -189,12 +189,6 @@ void run_all_scenarios() {
 }
 
 TEST(std_algorithms_mismatch_test, test) {
-#if defined(KOKKOS_ENABLE_CUDA) && \
-    defined(KOKKOS_COMPILER_NVHPC)  // FIXME_NVHPC
-  if constexpr (std::is_same_v<exespace, Kokkos::Cuda>) {
-    GTEST_SKIP() << "FIXME wrong result";
-  }
-#endif
   run_all_scenarios<DynamicTag, double>();
   run_all_scenarios<StridedThreeTag, int>();
 }

diff --git a/algorithms/unit_tests/TestStdAlgorithmsPartitioningOps.cpp b/algorithms/unit_tests/TestStdAlgorithmsPartitioningOps.cpp
@@ -148,12 +148,6 @@ struct std_algorithms_partitioning_test : public std_algorithms_test {
 };
 
 TEST_F(std_algorithms_partitioning_test, is_partitioned_trivial) {
-#if defined(KOKKOS_ENABLE_CUDA) && \
-    defined(KOKKOS_COMPILER_NVHPC)  // FIXME_NVHPC
-  if constexpr (std::is_same_v<exespace, Kokkos::Cuda>) {
-    GTEST_SKIP() << "FIXME wrong result";
-  }
-#endif
   IsNegativeFunctor<value_type> p;
   const auto result1 = KE::is_partitioned(exespace(), KE::cbegin(m_static_view),
                                           KE::cbegin(m_static_view), p);
@@ -169,12 +163,6 @@ TEST_F(std_algorithms_partitioning_test, is_partitioned_trivial) {
 }
 
 TEST_F(std_algorithms_partitioning_test, is_partitioned_accepting_iterators) {
-#if defined(KOKKOS_ENABLE_CUDA) && \
-    defined(KOKKOS_COMPILER_NVHPC)  // FIXME_NVHPC
-  if constexpr (std::is_same_v<exespace, Kokkos::Cuda>) {
-    GTEST_SKIP() << "FIXME wrong result";
-  }
-#endif
   const IsNegativeFunctor<value_type> p;
 
   for (int id = 0; id < FixtureViews::Count; ++id) {
@@ -196,12 +184,6 @@ TEST_F(std_algorithms_partitioning_test, is_partitioned_accepting_iterators) {
 }
 
 TEST_F(std_algorithms_partitioning_test, is_partitioned_accepting_view) {
-#if defined(KOKKOS_ENABLE_CUDA) && \
-    defined(KOKKOS_COMPILER_NVHPC)  // FIXME_NVHPC
-  if constexpr (std::is_same_v<exespace, Kokkos::Cuda>) {
-    GTEST_SKIP() << "FIXME wrong result";
-  }
-#endif
   const IsNegativeFunctor<value_type> p;
 
   for (int id = 0; id < FixtureViews::Count; ++id) {
@@ -220,12 +202,6 @@ TEST_F(std_algorithms_partitioning_test, is_partitioned_accepting_view) {
 }
 
 TEST_F(std_algorithms_partitioning_test, partition_point) {
-#if defined(KOKKOS_ENABLE_CUDA) && \
-    defined(KOKKOS_COMPILER_NVHPC)  // FIXME_NVHPC
-  if constexpr (std::is_same_v<exespace, Kokkos::Cuda>) {
-    GTEST_SKIP() << "FIXME wrong result";
-  }
-#endif
   const IsNegativeFunctor<value_type> p;
 
   for (int id = 0; id < FixtureViews::Count; ++id) {

diff --git a/algorithms/unit_tests/TestStdAlgorithmsSearch.cpp b/algorithms/unit_tests/TestStdAlgorithmsSearch.cpp
@@ -325,12 +325,6 @@ void run_all_scenarios() {
 }
 
 TEST(std_algorithms_non_mod_seq_ops, search) {
-#if defined(KOKKOS_ENABLE_CUDA) && \
-    defined(KOKKOS_COMPILER_NVHPC)  // FIXME_NVHPC
-  if constexpr (std::is_same_v<exespace, Kokkos::Cuda>) {
-    GTEST_SKIP() << "FIXME wrong result";
-  }
-#endif
   run_all_scenarios<DynamicTag, int>();
   run_all_scenarios<StridedThreeTag, int>();
 }

diff --git a/algorithms/unit_tests/TestStdAlgorithmsSearch_n.cpp b/algorithms/unit_tests/TestStdAlgorithmsSearch_n.cpp
@@ -297,12 +297,6 @@ void run_all_scenarios() {
 }
 
 TEST(std_algorithms_non_mod_seq_ops, search_n) {
-#if defined(KOKKOS_ENABLE_CUDA) && \
-    defined(KOKKOS_COMPILER_NVHPC)  // FIXME_NVHPC
-  if constexpr (std::is_same_v<exespace, Kokkos::Cuda>) {
-    GTEST_SKIP() << "FIXME wrong result";
-  }
-#endif
   run_all_scenarios<DynamicTag, int>();
   run_all_scenarios<StridedThreeTag, int>();
 }