Add double and float separate benchmarks, more tests

Signed-off-by: Shreyas Atre <[email protected]>
STEllAR-GROUP · Feb 5, 2025 · 332665e · 332665e
1 parent 6e839f9
commit 332665e
Show file tree

Hide file tree

Showing 2 changed files with 113 additions and 49 deletions.
diff --git a/libs/core/algorithms/tests/performance/benchmark_reduce_deterministic.cpp b/libs/core/algorithms/tests/performance/benchmark_reduce_deterministic.cpp
@@ -79,56 +79,117 @@ int hpx_main(hpx::program_options::variables_map& vm)
     }
 
     {
-        using FloatTypeDeterministic = float;
-        std::size_t LEN = vector_size;
-
-        constexpr FloatTypeDeterministic num_bounds_det =
-            std::is_same_v<FloatTypeDeterministic, float> ? 1000.0 : 1000000.0;
-
-        std::vector<FloatTypeDeterministic> deterministic(LEN);
-
-        for (size_t i = 0; i < LEN; ++i)
-        {
-            deterministic[i] = get_rand<FloatTypeDeterministic>(
-                -num_bounds_det, num_bounds_det);
-        }
-
-        std::vector<FloatTypeDeterministic> deterministic_shuffled =
-            deterministic;
-
-        std::shuffle(
-            deterministic_shuffled.begin(), deterministic_shuffled.end(), gen);
-
-        FloatTypeDeterministic val_det(41.999);
-
-        auto op = [](FloatTypeDeterministic v1, FloatTypeDeterministic v2) {
-            return v1 + v2;
-        };
-        {
-            hpx::util::perftests_report("reduce", "seq", test_count, [&]() {
-                bench_reduce(
-                    hpx::execution::seq, deterministic_shuffled, val_det, op);
-            });
-        }
-        {
-            hpx::util::perftests_report("reduce", "par", test_count, [&]() {
-                bench_reduce(
-                    hpx::execution::par, deterministic_shuffled, val_det, op);
-            });
-        }
         {
-            hpx::util::perftests_report(
-                "reduce deterministic", "seq", test_count, [&]() {
-                    bench_reduce_deterministic(hpx::execution::seq,
-                        deterministic_shuffled, val_det, op);
-                });
+            using FloatTypeDeterministic = float;
+            std::size_t LEN = vector_size;
+
+            constexpr FloatTypeDeterministic num_bounds_det =
+                std::is_same_v<FloatTypeDeterministic, float> ? 1000.0 :
+                                                                1000000.0;
+
+            std::vector<FloatTypeDeterministic> deterministic(LEN);
+
+            for (size_t i = 0; i < LEN; ++i)
+            {
+                deterministic[i] = get_rand<FloatTypeDeterministic>(
+                    -num_bounds_det, num_bounds_det);
+            }
+
+            std::vector<FloatTypeDeterministic> deterministic_shuffled =
+                deterministic;
+
+            std::shuffle(deterministic_shuffled.begin(),
+                deterministic_shuffled.end(), gen);
+
+            FloatTypeDeterministic val_det(41.999);
+
+            auto op = [](FloatTypeDeterministic v1, FloatTypeDeterministic v2) {
+                return v1 + v2;
+            };
+            {
+                hpx::util::perftests_report(
+                    "fl reduce", "seq", test_count, [&]() {
+                        bench_reduce(hpx::execution::seq,
+                            deterministic_shuffled, val_det, op);
+                    });
+            }
+            {
+                hpx::util::perftests_report(
+                    "fl reduce", "par", test_count, [&]() {
+                        bench_reduce(hpx::execution::par,
+                            deterministic_shuffled, val_det, op);
+                    });
+            }
+            {
+                hpx::util::perftests_report(
+                    "fl reduce deterministic", "seq", test_count, [&]() {
+                        bench_reduce_deterministic(hpx::execution::seq,
+                            deterministic_shuffled, val_det, op);
+                    });
+            }
+            {
+                hpx::util::perftests_report(
+                    "fl reduce deterministic", "par", test_count, [&]() {
+                        bench_reduce_deterministic(hpx::execution::par,
+                            deterministic_shuffled, val_det, op);
+                    });
+            }
         }
         {
-            hpx::util::perftests_report(
-                "reduce deterministic", "par", test_count, [&]() {
-                    bench_reduce_deterministic(hpx::execution::par,
-                        deterministic_shuffled, val_det, op);
-                });
+            using FloatTypeDeterministic = double;
+            std::size_t LEN = vector_size;
+
+            constexpr FloatTypeDeterministic num_bounds_det =
+                std::is_same_v<FloatTypeDeterministic, float> ? 1000.0 :
+                                                                1000000.0;
+
+            std::vector<FloatTypeDeterministic> deterministic(LEN);
+
+            for (size_t i = 0; i < LEN; ++i)
+            {
+                deterministic[i] = get_rand<FloatTypeDeterministic>(
+                    -num_bounds_det, num_bounds_det);
+            }
+
+            std::vector<FloatTypeDeterministic> deterministic_shuffled =
+                deterministic;
+
+            std::shuffle(deterministic_shuffled.begin(),
+                deterministic_shuffled.end(), gen);
+
+            FloatTypeDeterministic val_det(41.999);
+
+            auto op = [](FloatTypeDeterministic v1, FloatTypeDeterministic v2) {
+                return v1 + v2;
+            };
+            {
+                hpx::util::perftests_report(
+                    "dbl reduce", "seq", test_count, [&]() {
+                        bench_reduce(hpx::execution::seq,
+                            deterministic_shuffled, val_det, op);
+                    });
+            }
+            {
+                hpx::util::perftests_report(
+                    "dbl reduce", "par", test_count, [&]() {
+                        bench_reduce(hpx::execution::par,
+                            deterministic_shuffled, val_det, op);
+                    });
+            }
+            {
+                hpx::util::perftests_report(
+                    "dbl reduce deterministic", "seq", test_count, [&]() {
+                        bench_reduce_deterministic(hpx::execution::seq,
+                            deterministic_shuffled, val_det, op);
+                    });
+            }
+            {
+                hpx::util::perftests_report(
+                    "dbl reduce deterministic", "par", test_count, [&]() {
+                        bench_reduce_deterministic(hpx::execution::par,
+                            deterministic_shuffled, val_det, op);
+                    });
+            }
         }
 
         hpx::util::perftests_print_times();

diff --git a/libs/core/algorithms/tests/unit/algorithms/reduce_deterministic.cpp b/libs/core/algorithms/tests/unit/algorithms/reduce_deterministic.cpp
@@ -122,8 +122,8 @@ void test_reduce_parallel1(IteratorTag)
     FloatTypeNonDeterministic r3 = std::accumulate(
         nondeterministic.begin(), nondeterministic.end(), val_non_det);
 
-    HPX_TEST_EQ(r1, r3);
-    HPX_TEST_EQ(r2, r3);
+    HPX_TEST_EQ(static_cast<FloatTypeNonDeterministic>(r1), r3);
+    HPX_TEST_EQ(static_cast<FloatTypeNonDeterministic>(r2), r3);
 }
 
 template <typename IteratorTag, typename FloatTypeDeterministic,
@@ -232,6 +232,9 @@ void test_reduce1()
     test_reduce1<IteratorTag, float, double, 1000>(IteratorTag());
     test_reduce1<IteratorTag, double, double, 1000>(IteratorTag());
     test_reduce_parallel1<IteratorTag, float, float, 1000>(IteratorTag());
+    test_reduce_parallel1<IteratorTag, float, double, 1000>(IteratorTag());
+    test_reduce_parallel1<IteratorTag, double, float, 1000>(IteratorTag());
+    test_reduce_parallel1<IteratorTag, double, double, 1000>(IteratorTag());
 }
 
 template <typename IteratorTag>