diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index fd9d8b8c..42dbeca0 100644 --- a/tests/CMakeLists.txt +++ b/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 diff --git a/tests/test_volk_32f_x3_sum_of_poly_32f.cc b/tests/test_volk_32f_x3_sum_of_poly_32f.cc index 27d972dc..746623b9 100644 --- a/tests/test_volk_32f_x3_sum_of_poly_32f.cc +++ b/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(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 result; volk::vector 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 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 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 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()); diff --git a/tests/test_volk_32fc_x2_multiply_32fc.cc b/tests/test_volk_32fc_x2_multiply_32fc.cc index aa527afc..e7003144 100644 --- a/tests/test_volk_32fc_x2_multiply_32fc.cc +++ b/tests/test_volk_32fc_x2_multiply_32fc.cc @@ -11,19 +11,19 @@ #include #include #include +#include #include #include #include #include - 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 vec0; volk::vector vec1; volk::vector result; @@ -73,46 +72,30 @@ class volk_32fc_x2_multiply_32fc_test : public VolkTest volk::vector 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 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 elapsed = std::chrono::steady_clock::now() - start; - fmt::print("\tduration={}\n", elapsed); - EXPECT_TRUE(AreComplexFloatingPointArraysAlmostEqual(expected, ua_result)); - } + std::chrono::duration 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& 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()); diff --git a/tests/volk_test.cc b/tests/volk_test.cc index 6c0589a0..bf9a9915 100644 --- a/tests/volk_test.cc +++ b/tests/volk_test.cc @@ -55,7 +55,7 @@ ::testing::AssertionResult AreComplexFloatingPointArraysAlmostEqual(const T& exp return ::testing::AssertionSuccess(); } -std::vector get_kernel_implementation_name_list(volk_func_desc_t desc) +std::vector get_kernel_implementation_name_list(const volk_func_desc_t desc) { std::vector names; for (size_t i = 0; i < desc.n_impls; i++) { @@ -65,13 +65,18 @@ std::vector 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> -separate_implementations_by_alignment(std::vector names) +separate_implementations_by_alignment(const std::vector& names) { std::vector aligned; std::vector 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); @@ -79,3 +84,19 @@ separate_implementations_by_alignment(std::vector names) } return { aligned, unaligned }; } + +std::vector +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 +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; +} diff --git a/tests/volk_test.h b/tests/volk_test.h index 20f8780b..ebc2e323 100644 --- a/tests/volk_test.h +++ b/tests/volk_test.h @@ -11,27 +11,43 @@ #include #include #include +#include #include +static constexpr std::array default_vector_sizes{ 7, 32, 128, 1023, 131071 }; -std::vector get_kernel_implementation_name_list(volk_func_desc_t desc); +std::vector get_kernel_implementation_name_list(const volk_func_desc_t desc); + +bool is_aligned_implementation_name(const std::string& name); std::tuple, std::vector> -separate_implementations_by_alignment(std::vector names); +separate_implementations_by_alignment(const std::vector& names); + +std::vector +get_aligned_kernel_implementation_names(const volk_func_desc_t desc); +std::vector +get_unaligned_kernel_implementation_names(const volk_func_desc_t desc); + +struct generate_volk_test_name { + template + std::string operator()(const ::testing::TestParamInfo& info) const + { + return fmt::format("{}_{}", std::get<0>(info.param), std::get<1>(info.param)); + } +}; -class VolkTest : public ::testing::TestWithParam +class VolkTest : public ::testing::TestWithParam> { protected: - void initialize_implementation_names(volk_func_desc_t desc) + void initialize_test(const std::tuple& 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 implementation_names; - std::vector aligned_impl_names; - std::vector unaligned_impl_names; + std::string implementation_name; + bool is_aligned_implementation; + size_t vector_length; };