Skip to content

Commit 7a4e20e

Browse files
damageboydamageboy
committed
tests: rewrite smallsort tests, to reduce code-bloat and chances for manual errors
- Same manual test registration mechanism taken from fullsort tests - For now, still, only unique values data-sets are generated - Test "sizes" are coded as KB and adjusted down to actual type/element count
1 parent bbf3ca9 commit 7a4e20e

20 files changed

+355
-521
lines changed

‎tests/CMakeLists.txt

+1-21
Original file line numberDiff line numberDiff line change
@@ -44,32 +44,12 @@ list(APPEND test_SOURCES
4444
)
4545

4646
if (${PROCESSOR_IS_X86})
47-
set(test_avx2_SOURCES ${test_SOURCES})
48-
list(APPEND test_avx2_SOURCES
49-
smallsort/smallsort.avx2.cpp
50-
fullsort/fullsort.avx2.i.cpp
51-
mini_tests/masked_load_store.avx2.cpp
52-
mini_tests/partition_machine.avx2.cpp
53-
mini_tests/pack_machine.avx2.cpp
54-
)
55-
56-
set(test_avx512_SOURCES ${test_SOURCES})
57-
list(APPEND test_avx512_SOURCES
58-
smallsort/smallsort.avx512.cpp
59-
fullsort/fullsort.avx512.i.cpp
60-
mini_tests/masked_load_store.avx512.cpp
61-
mini_tests/partition_machine.avx512.cpp
62-
mini_tests/pack_machine.avx512.cpp
63-
)
64-
65-
66-
6747
foreach(v ${x86_isas})
6848
foreach(tf ${sort_types})
6949
string(TOUPPER ${v} vu)
7050

7151
add_executable(${TARGET_NAME}_${v}_${tf} ${test_SOURCES} ${test_HEADERS}
72-
smallsort/smallsort.${v}.cpp
52+
smallsort/smallsort.${v}.${tf}.cpp
7353
fullsort/fullsort.${v}.${tf}.cpp
7454
mini_tests/masked_load_store.${v}.cpp
7555
mini_tests/partition_machine.${v}.cpp

‎tests/fullsort/fullsort.avx2.f.cpp

+2-3
Original file line numberDiff line numberDiff line change
@@ -13,11 +13,10 @@ using VM = vxsort::vector_machine;
1313
using namespace vxsort;
1414

1515
void register_fullsort_avx2_f_tests() {
16-
register_fullsort_benchmarks<VM::AVX2, 8, f32>(10, 1000000, 10, 1234.5, 0.1);
17-
register_fullsort_benchmarks<VM::AVX2, 8, f32>(10, 1000000, 10, 1234.5, 0.1);
16+
register_fullsort_tests<VM::AVX2, 8, f32>(10, 1000000, 10, 1234.5, 0.1);
17+
register_fullsort_tests<VM::AVX2, 8, f32>(10, 1000000, 10, 1234.5, 0.1);
1818
}
1919

2020
}
2121

22-
2322
#include "vxsort_targets_disable.h"

‎tests/fullsort/fullsort.avx2.i.cpp

+3-4
Original file line numberDiff line numberDiff line change
@@ -13,12 +13,11 @@ using VM = vxsort::vector_machine;
1313
using namespace vxsort;
1414

1515
void register_fullsort_avx2_i_tests() {
16-
register_fullsort_benchmarks<VM::AVX2, 8, i16>(10, 10000, 10, 0x1000, 0x1);
17-
register_fullsort_benchmarks<VM::AVX2, 8, i32>(10, 1000000, 10, 0x1000, 0x1);
18-
register_fullsort_benchmarks<VM::AVX2, 8, i64>(10, 1000000, 10, 0x1000, 0x1);
16+
register_fullsort_tests<VM::AVX2, 8, i16>(10, 10000, 10, 0x1000, 0x1);
17+
register_fullsort_tests<VM::AVX2, 8, i32>(10, 1000000, 10, 0x1000, 0x1);
18+
register_fullsort_tests<VM::AVX2, 8, i64>(10, 1000000, 10, 0x1000, 0x1);
1919
}
2020

2121
}
2222

23-
2423
#include "vxsort_targets_disable.h"

‎tests/fullsort/fullsort.avx2.u.cpp

+3-4
Original file line numberDiff line numberDiff line change
@@ -13,12 +13,11 @@ using VM = vxsort::vector_machine;
1313
using namespace vxsort;
1414

1515
void register_fullsort_avx2_u_tests() {
16-
register_fullsort_benchmarks<VM::AVX2, 8, u16>(10, 10000, 10, 0x1000, 0x1);
17-
register_fullsort_benchmarks<VM::AVX2, 8, u32>(10, 1000000, 10, 0x1000, 0x1);
18-
register_fullsort_benchmarks<VM::AVX2, 8, u64>(10, 1000000, 10, 0x1000, 0x1);
16+
register_fullsort_tests<VM::AVX2, 8, u16>(10, 10000, 10, 0x1000, 0x1);
17+
register_fullsort_tests<VM::AVX2, 8, u32>(10, 1000000, 10, 0x1000, 0x1);
18+
register_fullsort_tests<VM::AVX2, 8, u64>(10, 1000000, 10, 0x1000, 0x1);
1919
}
2020

2121
}
2222

23-
2423
#include "vxsort_targets_disable.h"

‎tests/fullsort/fullsort.avx512.f.cpp

+2-2
Original file line numberDiff line numberDiff line change
@@ -14,8 +14,8 @@ using VM = vxsort::vector_machine;
1414
using namespace vxsort;
1515

1616
void register_fullsort_avx512_f_tests() {
17-
register_fullsort_benchmarks<VM::AVX512, 8, f32>(10, 1000000, 10, 1234.5, 0.1);
18-
register_fullsort_benchmarks<VM::AVX512, 8, f64>(10, 1000000, 10, 1234.5, 0.1);
17+
register_fullsort_tests<VM::AVX512, 8, f32>(10, 1000000, 10, 1234.5, 0.1);
18+
register_fullsort_tests<VM::AVX512, 8, f64>(10, 1000000, 10, 1234.5, 0.1);
1919
}
2020

2121
}

‎tests/fullsort/fullsort.avx512.i.cpp

+3-3
Original file line numberDiff line numberDiff line change
@@ -14,9 +14,9 @@ using VM = vxsort::vector_machine;
1414
using namespace vxsort;
1515

1616
void register_fullsort_avx512_i_tests() {
17-
register_fullsort_benchmarks<VM::AVX512, 8, i16>(10, 10000, 10, 0x1000, 0x1);
18-
register_fullsort_benchmarks<VM::AVX512, 8, i32>(10, 1000000, 10, 0x1000, 0x1);
19-
register_fullsort_benchmarks<VM::AVX512, 8, i64>(10, 1000000, 10, 0x1000, 0x1);
17+
register_fullsort_tests<VM::AVX512, 8, i16>(10, 10000, 10, 0x1000, 0x1);
18+
register_fullsort_tests<VM::AVX512, 8, i32>(10, 1000000, 10, 0x1000, 0x1);
19+
register_fullsort_tests<VM::AVX512, 8, i64>(10, 1000000, 10, 0x1000, 0x1);
2020
}
2121

2222
}

‎tests/fullsort/fullsort.avx512.u.cpp

+3-3
Original file line numberDiff line numberDiff line change
@@ -14,9 +14,9 @@ using VM = vxsort::vector_machine;
1414
using namespace vxsort;
1515

1616
void register_fullsort_avx512_u_tests() {
17-
register_fullsort_benchmarks<VM::AVX512, 8, u16>(10, 10000, 10, 0x1000, 0x1);
18-
register_fullsort_benchmarks<VM::AVX512, 8, u32>(10, 1000000, 10, 0x1000, 0x1);
19-
register_fullsort_benchmarks<VM::AVX512, 8, u64>(10, 1000000, 10, 0x1000, 0x1);
17+
register_fullsort_tests<VM::AVX512, 8, u16>(10, 10000, 10, 0x1000, 0x1);
18+
register_fullsort_tests<VM::AVX512, 8, u32>(10, 1000000, 10, 0x1000, 0x1);
19+
register_fullsort_tests<VM::AVX512, 8, u64>(10, 1000000, 10, 0x1000, 0x1);
2020
}
2121

2222
}

‎tests/fullsort/fullsort_test.h

+37-57
Original file line numberDiff line numberDiff line change
@@ -17,7 +17,7 @@ using namespace vxsort::types;
1717
using ::vxsort::vector_machine;
1818

1919
template <typename T, i32 Unroll, vector_machine M>
20-
void vxsort_pattern_test(SortPattern, usize size, T first_value, T stride) {
20+
void vxsort_pattern_test(sort_pattern, usize size, T first_value, T stride) {
2121
VXSORT_TEST_ISA();
2222

2323
auto V = unique_values<T>(size, first_value, stride);
@@ -57,64 +57,55 @@ void vxsort_hinted_test(std::vector<T>& V, T min_value, T max_value) {
5757
}
5858
}
5959

60-
static inline std::vector<SortPattern> test_patterns() {
60+
static inline std::vector<sort_pattern> fullsort_test_patterns() {
6161
return {
62-
SortPattern::unique_values,
63-
SortPattern::shuffled_16_values,
64-
SortPattern::all_equal,
62+
sort_pattern::unique_values,
63+
//sort_pattern::shuffled_16_values,
64+
//sort_pattern::all_equal,
6565
};
6666
}
6767

6868
template <typename T>
69-
struct SortTestParams2 {
69+
struct fullsort_test_params {
7070
public:
71-
SortTestParams2(SortPattern pattern, usize size, i32 slack, T first_value, T value_stride)
72-
: Pattern(pattern), Size(size), Slack(slack), FirstValue(first_value), ValueStride(value_stride) {}
73-
SortPattern Pattern;
74-
usize Size;
75-
i32 Slack;
76-
T FirstValue;
77-
T ValueStride;
71+
fullsort_test_params(sort_pattern pattern, usize size, i32 slack, T first_value, T value_stride)
72+
: pattern(pattern), size(size), slack(slack), first_value(first_value), stride(value_stride) {}
73+
sort_pattern pattern;
74+
usize size;
75+
i32 slack;
76+
T first_value;
77+
T stride;
7878
};
7979

80-
class VxSortFixture : public testing::Test {
81-
public:
82-
using FunctionType = std::function<void()>;
83-
explicit VxSortFixture(FunctionType fn) : _fn(std::move(fn)) {}
80+
template<typename T>
81+
std::vector<fullsort_test_params<T>>
82+
gen_params(usize start, usize stop, usize step, i32 slack, T first_value, T value_stride)
83+
{
84+
auto patterns = fullsort_test_patterns();
8485

85-
VxSortFixture(VxSortFixture const&) = delete;
86+
using TestParams = fullsort_test_params<T>;
87+
std::vector<TestParams> tests;
8688

87-
void TestBody() override {
88-
_fn();
89+
for (auto p : fullsort_test_patterns()) {
90+
for (auto i : multiply_range<i32>(start, stop, step)) {
91+
for (auto j : range<i32>(-slack, slack, 1)) {
92+
if ((i64)i + j <= 0)
93+
continue;
94+
tests.push_back(fullsort_test_params<T>(p, i, j, first_value, value_stride));
95+
}
96+
}
8997
}
90-
91-
private:
92-
FunctionType _fn;
93-
};
94-
95-
template <class Lambda, class... Args>
96-
void RegisterSingleTest(const char* test_suite_name, const char* test_name,
97-
const char* type_param, const char* value_param,
98-
const char* file, int line,
99-
Lambda&& fn, Args&&... args) {
100-
101-
testing::RegisterTest(
102-
test_suite_name, test_name, type_param, value_param,
103-
file, line,
104-
[=]() mutable -> testing::Test* { return new VxSortFixture(
105-
[=]() mutable { fn(args...); });
106-
});
98+
return tests;
10799
}
108100

109-
110101
template <vector_machine M, i32 U, typename T>
111-
void register_fullsort_benchmarks(usize start, usize stop, usize step, T first_value, T value_stride) {
102+
void register_fullsort_tests(usize start, usize stop, usize step, T first_value, T value_stride) {
112103
if (step == 0) {
113104
throw std::invalid_argument("step for range must be non-zero");
114105
}
115106

116107
if constexpr (U >= 2) {
117-
register_fullsort_benchmarks<M, U / 2, T>(start, stop, step, first_value, value_stride);
108+
register_fullsort_tests<M, U / 2, T>(start, stop, step, first_value, value_stride);
118109
}
119110

120111
using VM = vxsort::vxsort_machine_traits<T, M>;
@@ -124,31 +115,20 @@ void register_fullsort_benchmarks(usize start, usize stop, usize step, T first_v
124115
constexpr i32 slack = sizeof(typename VM::TV) / sizeof(T);
125116
static_assert(slack > 1);
126117

127-
std::vector<SortTestParams2<T>> tests;
128-
size_t i = start;
129-
for (auto p : test_patterns()) {
130-
while ((step > 0) ? (i <= stop) : (i > stop)) {
131-
for (auto j : range<int>(-slack, slack, 1)) {
132-
if ((i64)i + j <= 0)
133-
continue;
134-
tests.push_back(SortTestParams2<T>(p, i, j, first_value, value_stride));
135-
}
136-
i *= step;
137-
}
138-
}
118+
auto tests = gen_params(start, stop, step, slack, first_value, value_stride);
139119

140120
for (auto p : tests) {
141121
auto *test_type = get_canonical_typename<T>();
142122

143-
auto test_size = p.Size + p.Slack;
123+
auto test_size = p.size + p.slack;
144124
auto test_name = fmt::format("vxsort_pattern_test<{}, {}, {}>/{}/{}", test_type, U,
145-
magic_enum::enum_name(M), magic_enum::enum_name(p.Pattern), test_size);
125+
magic_enum::enum_name(M), magic_enum::enum_name(p.pattern), test_size);
146126

147-
RegisterSingleTest(
127+
RegisterSingleLambdaTest(
148128
"fullsort", test_name.c_str(), nullptr,
149-
std::to_string(p.Size).c_str(),
129+
std::to_string(test_size).c_str(),
150130
__FILE__, __LINE__,
151-
vxsort_pattern_test<T, U, M>, p.Pattern, test_size, p.FirstValue, p.ValueStride);
131+
vxsort_pattern_test<T, U, M>, p.pattern, test_size, p.first_value, p.stride);
152132
}
153133
}
154134

‎tests/gtest_main.cpp

+27-14
Original file line numberDiff line numberDiff line change
@@ -6,32 +6,45 @@
66
namespace vxsort_tests {
77

88

9-
void register_fullsort_avx2_i_tests();
10-
void register_fullsort_avx512_i_tests();
11-
void register_fullsort_avx2_u_tests();
12-
void register_fullsort_avx2_f_tests();
13-
void register_fullsort_avx512_u_tests();
14-
void register_fullsort_avx512_f_tests();
15-
16-
void register_fullsort_test_matrix() {
9+
void register_fullsort_avx2_i_tests();
10+
void register_fullsort_avx512_i_tests();
11+
void register_fullsort_avx2_u_tests();
12+
void register_fullsort_avx2_f_tests();
13+
void register_fullsort_avx512_u_tests();
14+
void register_fullsort_avx512_f_tests();
15+
16+
void register_smallsort_avx2_i_tests();
17+
void register_smallsort_avx512_i_tests();
18+
void register_smallsort_avx2_u_tests();
19+
void register_smallsort_avx2_f_tests();
20+
void register_smallsort_avx512_u_tests();
21+
void register_smallsort_avx512_f_tests();
22+
23+
void register_fullsort_test_matrix() {
1724

1825
#ifdef VXSORT_TEST_AVX2_I
19-
register_fullsort_avx2_i_tests();
26+
register_fullsort_avx2_i_tests();
27+
register_smallsort_avx2_i_tests();
2028
#endif
2129
#ifdef VXSORT_TEST_AVX2_U
22-
register_fullsort_avx2_u_tests();
30+
register_fullsort_avx2_u_tests();
31+
register_smallsort_avx2_u_tests();
2332
#endif
2433
#ifdef VXSORT_TEST_AVX2_F
25-
register_fullsort_avx2_f_tests();
34+
register_fullsort_avx2_f_tests();
35+
register_smallsort_avx2_f_tests();
2636
#endif
2737
#ifdef VXSORT_TEST_AVX512_I
28-
register_fullsort_avx512_i_tests();
38+
register_fullsort_avx512_i_tests();
39+
register_smallsort_avx512_i_tests();
2940
#endif
3041
#ifdef VXSORT_TEST_AVX512_U
31-
register_fullsort_avx512_u_tests();
42+
register_fullsort_avx512_u_tests();
43+
register_smallsort_avx512_u_tests();
3244
#endif
3345
#ifdef VXSORT_TEST_AVX512_F
34-
register_fullsort_avx512_f_tests();
46+
register_fullsort_avx512_f_tests();
47+
register_smallsort_avx512_f_tests();
3548
#endif
3649
}
3750
} // namespace vxsort_tests

0 commit comments

Comments
 (0)