tests: Beautify test output

We can run an individual test for each implementation now. Further, the
test names are easier to recognize.

Signed-off-by: Johannes Demel <[email protected]>

Author: jdemel

tests/CMakeLists.txt

@@ -26,6 +26,8 @@ add_executable(
   ${volk_test_files}
 )
 
+target_compile_features(volk_tests PUBLIC cxx_std_20)
+
 target_link_libraries(volk_tests
   PRIVATE
     GTest::gtest_main

tests/test_volk_32f_x3_sum_of_poly_32f.cc

@@ -22,8 +22,8 @@ class volk_32f_x3_sum_of_poly_32f_test : public VolkTest
 protected:
     void SetUp() override
     {
-        initialize_implementation_names(volk_32f_x3_sum_of_poly_32f_get_func_desc());
-        initialize_data(GetParam());
+        initialize_test(GetParam());
+        initialize_data(vector_length);
     }
 
     void initialize_data(const size_t length)
@@ -66,6 +66,7 @@ class volk_32f_x3_sum_of_poly_32f_test : public VolkTest
         result = volk::vector<float>(1, 0.0);
         ua_result.push_back(result.at(0));
         ua_result.push_back(result.at(0));
+        tolerance = std::max(expected * 1e-5, 1e-5);
     }
 
     void execute_aligned(const std::string impl_name)
@@ -76,6 +77,7 @@ class volk_32f_x3_sum_of_poly_32f_test : public VolkTest
                                            cutoff.data(),
                                            vector_length,
                                            impl_name.c_str());
+        EXPECT_NEAR(result.at(0), expected, tolerance);
     }
 
     void execute_unaligned(const std::string impl_name)
@@ -86,6 +88,7 @@ class volk_32f_x3_sum_of_poly_32f_test : public VolkTest
                                            ua_cutoff.data() + 1,
                                            vector_length,
                                            impl_name.c_str());
+        EXPECT_NEAR(ua_result.at(1), expected, tolerance);
     }
 
     // void TearDown() override {}
@@ -99,42 +102,30 @@ class volk_32f_x3_sum_of_poly_32f_test : public VolkTest
     volk::vector<float> result;
     volk::vector<float> ua_result;
     float expected = 0.0f;
+    float tolerance = 1.0e-5;
 };
 
-
-TEST_P(volk_32f_x3_sum_of_poly_32f_test, aligned)
-{
-    for (auto name : implementation_names) {
-        auto tol = std::max(expected * 1e-5, 1e-5);
-        fmt::print(
-            "test aligned implementation: {:>12}, size={} ...", name, vector_length);
-        auto start = std::chrono::steady_clock::now();
-
-        execute_aligned(name);
-
-        std::chrono::duration<double> elapsed = std::chrono::steady_clock::now() - start;
-        fmt::print("\tduration={}\n", elapsed);
-        EXPECT_NEAR(result.at(0), expected, tol);
-    }
-}
-
-TEST_P(volk_32f_x3_sum_of_poly_32f_test, unaligned)
+TEST_P(volk_32f_x3_sum_of_poly_32f_test, run)
 {
-    for (auto name : unaligned_impl_names) {
-        auto tol = std::max(expected * 1e-5, 1e-5);
-        fmt::print(
-            "test unaligned implementation: {:>12}, size={} ...", name, vector_length);
-        auto start = std::chrono::steady_clock::now();
-
-        execute_unaligned(name);
-
-        std::chrono::duration<double> elapsed = std::chrono::steady_clock::now() - start;
-        fmt::print("\tduration={}\n", elapsed);
-        EXPECT_NEAR(ua_result.at(1), expected, tol);
+    fmt::print("test {} implementation: {:>12}, size={} ...",
+               is_aligned_implementation ? "aligned" : "unaligned",
+               implementation_name,
+               vector_length);
+    auto start = std::chrono::steady_clock::now();
+
+    if (is_aligned_implementation) {
+        execute_aligned(implementation_name);
+    } else {
+        execute_unaligned(implementation_name);
     }
+    std::chrono::duration<double> elapsed = std::chrono::steady_clock::now() - start;
+    fmt::print("\tduration={}\n", elapsed);
 }
 
-
-INSTANTIATE_TEST_SUITE_P(volk_32f_x3_sum_of_poly_32f,
-                         volk_32f_x3_sum_of_poly_32f_test,
-                         testing::Values(7, 32, 128, 1023, 65535, 131071));
+INSTANTIATE_TEST_SUITE_P(
+    volk_32f_x3_sum_of_poly_32f,
+    volk_32f_x3_sum_of_poly_32f_test,
+    testing::Combine(testing::ValuesIn(get_kernel_implementation_name_list(
+                         volk_32f_x3_sum_of_poly_32f_get_func_desc())),
+                     testing::ValuesIn(default_vector_sizes)),
+    generate_volk_test_name());

tests/test_volk_32fc_x2_multiply_32fc.cc

@@ -11,19 +11,19 @@
 #include <fmt/chrono.h>
 #include <fmt/core.h>
 #include <fmt/ranges.h>
+#include <gtest/gtest-param-test.h>
 #include <gtest/gtest.h>
 #include <volk/volk.h>
 #include <volk/volk_alloc.hh>
 #include <chrono>
 
-
 class volk_32fc_x2_multiply_32fc_test : public VolkTest
 {
 protected:
     void SetUp() override
     {
-        initialize_implementation_names(volk_32fc_x2_multiply_32fc_get_func_desc());
-        initialize_data(GetParam());
+        initialize_test(GetParam());
+        initialize_data(vector_length);
     }
 
     void initialize_data(const size_t length)
@@ -61,10 +61,9 @@ class volk_32fc_x2_multiply_32fc_test : public VolkTest
                                           vec1.data() + 1,
                                           vector_length - 1,
                                           impl_name.c_str());
+        EXPECT_TRUE(AreComplexFloatingPointArraysAlmostEqual(expected, ua_result));
     }
 
-    // void TearDown() override {}
-    size_t vector_length;
     volk::vector<lv_32fc_t> vec0;
     volk::vector<lv_32fc_t> vec1;
     volk::vector<lv_32fc_t> result;
@@ -73,46 +72,30 @@ class volk_32fc_x2_multiply_32fc_test : public VolkTest
     volk::vector<lv_32fc_t> ua_result;
 };
 
-
-TEST_P(volk_32fc_x2_multiply_32fc_test, aligned)
+TEST_P(volk_32fc_x2_multiply_32fc_test, run)
 {
-    for (auto name : implementation_names) {
-        fmt::print(
-            "test aligned implementation: {:>12}, size={} ...", name, vector_length);
-        auto start = std::chrono::steady_clock::now();
-
-        execute_aligned(name);
-
-        std::chrono::duration<double> elapsed = std::chrono::steady_clock::now() - start;
-        fmt::print("\tduration={}\n", elapsed);
-        EXPECT_TRUE(AreComplexFloatingPointArraysAlmostEqual(expected, result));
+    fmt::print("test {} implementation: {:>12}, size={} ...",
+               is_aligned_implementation ? "aligned" : "unaligned",
+               implementation_name,
+               vector_length);
+    auto start = std::chrono::steady_clock::now();
+
+    if (is_aligned_implementation) {
+        execute_aligned(implementation_name);
+    } else {
+        execute_unaligned(implementation_name);
     }
-}
-
-TEST_P(volk_32fc_x2_multiply_32fc_test, unaligned)
-{
-    for (auto name : unaligned_impl_names) {
-        RecordProperty("aligned", false);
-        RecordProperty("implementation", name);
-        RecordProperty("size", vector_length);
-        fmt::print(
-            "test unaligned implementation: {:>12}, size={} ...", name, vector_length);
-        auto start = std::chrono::steady_clock::now();
 
-        execute_unaligned(name);
 
-        std::chrono::duration<double> elapsed = std::chrono::steady_clock::now() - start;
-        fmt::print("\tduration={}\n", elapsed);
-        EXPECT_TRUE(AreComplexFloatingPointArraysAlmostEqual(expected, ua_result));
-    }
+    std::chrono::duration<double> elapsed = std::chrono::steady_clock::now() - start;
+    fmt::print("\tduration={}\n", elapsed);
 }
 
 
-INSTANTIATE_TEST_SUITE_P(volk_32fc_x2_multiply_32fc,
-                         volk_32fc_x2_multiply_32fc_test,
-                         testing::Values(7, 32, 128, 1023, 131071),
-                         testing::PrintToStringParamName()
-                         // [](const testing::TestParamInfo<int>& info) {
-                         //  return fmt::format("{}", info.param);
-                         // }
-);
+INSTANTIATE_TEST_SUITE_P(
+    volk_32fc_x2_multiply_32fc,
+    volk_32fc_x2_multiply_32fc_test,
+    testing::Combine(testing::ValuesIn(get_kernel_implementation_name_list(
+                         volk_32fc_x2_multiply_32fc_get_func_desc())),
+                     testing::ValuesIn(default_vector_sizes)),
+    generate_volk_test_name());

tests/volk_test.cc

@@ -55,7 +55,7 @@ ::testing::AssertionResult AreComplexFloatingPointArraysAlmostEqual(const T& exp
     return ::testing::AssertionSuccess();
 }
 
-std::vector<std::string> get_kernel_implementation_name_list(volk_func_desc_t desc)
+std::vector<std::string> get_kernel_implementation_name_list(const volk_func_desc_t desc)
 {
     std::vector<std::string> names;
     for (size_t i = 0; i < desc.n_impls; i++) {
@@ -65,17 +65,38 @@ std::vector<std::string> get_kernel_implementation_name_list(volk_func_desc_t de
     return names;
 }
 
+bool is_aligned_implementation_name(const std::string& name)
+{
+    return name.rfind("a_", 0) == 0;
+}
+
 std::tuple<std::vector<std::string>, std::vector<std::string>>
-separate_implementations_by_alignment(std::vector<std::string> names)
+separate_implementations_by_alignment(const std::vector<std::string>& names)
 {
     std::vector<std::string> aligned;
     std::vector<std::string> unaligned;
     for (auto name : names) {
-        if (name.rfind("a_", 0) == 0) {
+        if (is_aligned_implementation_name(name)) {
             aligned.push_back(name);
         } else {
             unaligned.push_back(name);
         }
     }
     return { aligned, unaligned };
 }
+
+std::vector<std::string>
+get_aligned_kernel_implementation_names(const volk_func_desc_t desc)
+{
+    auto impls = get_kernel_implementation_name_list(desc);
+    auto [aligned, unaligned] = separate_implementations_by_alignment(impls);
+    return aligned;
+}
+
+std::vector<std::string>
+get_unaligned_kernel_implementation_names(const volk_func_desc_t desc)
+{
+    auto impls = get_kernel_implementation_name_list(desc);
+    auto [aligned, unaligned] = separate_implementations_by_alignment(impls);
+    return unaligned;
+}

tests/volk_test.h

@@ -11,27 +11,43 @@
 #include <fmt/ranges.h>
 #include <gtest/gtest.h>
 #include <volk/volk.h>
+#include <array>
 #include <tuple>
 
+static constexpr std::array<size_t, 5> default_vector_sizes{ 7, 32, 128, 1023, 131071 };
 
-std::vector<std::string> get_kernel_implementation_name_list(volk_func_desc_t desc);
+std::vector<std::string> get_kernel_implementation_name_list(const volk_func_desc_t desc);
+
+bool is_aligned_implementation_name(const std::string& name);
 
 std::tuple<std::vector<std::string>, std::vector<std::string>>
-separate_implementations_by_alignment(std::vector<std::string> names);
+separate_implementations_by_alignment(const std::vector<std::string>& names);
+
+std::vector<std::string>
+get_aligned_kernel_implementation_names(const volk_func_desc_t desc);
+std::vector<std::string>
+get_unaligned_kernel_implementation_names(const volk_func_desc_t desc);
+
+struct generate_volk_test_name {
+    template <class ParamType>
+    std::string operator()(const ::testing::TestParamInfo<ParamType>& info) const
+    {
+        return fmt::format("{}_{}", std::get<0>(info.param), std::get<1>(info.param));
+    }
+};
 
-class VolkTest : public ::testing::TestWithParam<int>
+class VolkTest : public ::testing::TestWithParam<std::tuple<std::string, size_t>>
 {
 protected:
-    void initialize_implementation_names(volk_func_desc_t desc)
+    void initialize_test(const std::tuple<std::string, size_t>& param)
     {
-        implementation_names = get_kernel_implementation_name_list(desc);
-        std::tie(aligned_impl_names, unaligned_impl_names) =
-            separate_implementations_by_alignment(implementation_names);
+        std::tie(implementation_name, vector_length) = param;
+        is_aligned_implementation = is_aligned_implementation_name(implementation_name);
     }
 
-    std::vector<std::string> implementation_names;
-    std::vector<std::string> aligned_impl_names;
-    std::vector<std::string> unaligned_impl_names;
+    std::string implementation_name;
+    bool is_aligned_implementation;
+    size_t vector_length;
 };