Skip to content

Commit

Permalink
Fix test vector generation where some generation function were using …
Browse files Browse the repository at this point in the history 
…the std::vector c-tor with size and using push_back() instead of indexing into the new vector.
  • Loading branch information
@damageboy
damageboy committed Oct 9, 2023
1 parent 5226e06 commit 2174912
Show file tree
Hide file tree
Showing 5 changed files with 111 additions and 102 deletions.
23 changes: 12 additions & 11 deletions bench/util.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -75,52 +75,53 @@ template <typename T>
std::vector<T> shuffled_16_values(usize size, T start, T stride) {
std::vector<T> v(size);
for (usize i = 0; i < size; ++i)
v.push_back(start + stride * (i % 16));
v[i] = start + stride * (i % 16);

std::mt19937_64 rng(global_bench_random_seed);
std::shuffle(v.begin(), v.end(), rng);
return v;
}

template <typename T>
std::vector<T> all_equal(usize size, T start , T stride) {
std::vector<T> all_equal(usize size, T start , T) {
std::vector<T> v(size);
for (usize i = 0; i < size; ++i)
v.push_back(start);
v[i] = start;
return v;
}

template <typename T>
std::vector<T> ascending_int(usize size, T start, T stride) {
std::vector<T> v(size);
for (usize i = 0; i < size; ++i)
v.push_back(start + stride * i);
v[i] = start + stride * i;
return v;
}

template <typename T>
std::vector<T> descending_int(usize size, T start, T stride) {
std::vector<T> v(size);
for (isize i = size - 1; i >= 0; --i)
v.push_back(start + stride * i);
v[i] = start + stride * i;
return v;
}

template <typename T>
std::vector<T> pipe_organ(usize size, T start, T stride) {
std::vector<T> v(size);
for (usize i = 0; i < size/2; ++i)
v.push_back(start + stride * i);
v[i] = start + stride * i;
for (usize i = size/2; i < size; ++i)
v.push_back(start + (size - i) * stride);
v[i] = start + (size - i) * stride;
return v;
}

template <typename T>
std::vector<T> push_front(usize size, T start, T stride) {
std::vector<T> v(size);
for (usize i = 1; i < size; ++i)
v.push_back(start + stride * i);
v.push_back(start);
v[i-1] = start + stride * i;
v[size-1] = start;
return v;
}

Expand All @@ -129,9 +130,9 @@ std::vector<T> push_middle(usize size, T start, T stride) {
std::vector<T> v(size);
for (usize i = 0; i < size; ++i) {
if (i != size/2)
v.push_back(start + stride * i);
v[i] = start + stride * i;
}
v.push_back(start + stride * (size/2));
v[size/2] = start + stride * (size/2);
return v;
}

Expand Down
52 changes: 30 additions & 22 deletions tests/fullsort/fullsort_test.h
View file
Original file line number Diff line number Diff line change
@@ -1,15 +1,15 @@
#ifndef VXSORT_FULLSORT_TEST_H
#define VXSORT_FULLSORT_TEST_H

#include <fmt/format.h>
#include <gtest/gtest.h>
#include <algorithm>
#include <vector>
#include <fmt/format.h>
#include <magic_enum.hpp>
#include <vector>

#include "../test_vectors.h"
#include "../sort_fixtures.h"
#include "../test_isa.h"
#include "../test_vectors.h"
#include "vxsort.h"

namespace vxsort_tests {
Expand Down Expand Up @@ -59,28 +59,35 @@ void vxsort_hinted_test(std::vector<T>& V, T min_value, T max_value) {

static inline std::vector<sort_pattern> fullsort_test_patterns() {
return {
sort_pattern::unique_values,
//sort_pattern::shuffled_16_values,
//sort_pattern::all_equal,
sort_pattern::unique_values,
// sort_pattern::shuffled_16_values,
// sort_pattern::all_equal,
};
}

template <typename T>
struct fullsort_test_params {
public:
fullsort_test_params(sort_pattern pattern, usize size, i32 slack, T first_value, T value_stride)
: pattern(pattern), size(size), slack(slack), first_value(first_value), stride(value_stride) {}
: pattern(pattern),
size(size),
slack(slack),
first_value(first_value),
stride(value_stride) {}
sort_pattern pattern;
usize size;
i32 slack;
T first_value;
T stride;
};

template<typename T>
std::vector<fullsort_test_params<T>>
gen_params(usize start, usize stop, usize step, i32 slack, T first_value, T value_stride)
{
template <typename T>
std::vector<fullsort_test_params<T>> gen_params(usize start,
usize stop,
usize step,
i32 slack,
T first_value,
T value_stride) {
auto patterns = fullsort_test_patterns();

using TestParams = fullsort_test_params<T>;
Expand Down Expand Up @@ -112,25 +119,26 @@ void register_fullsort_tests(usize start, usize stop, usize step, T first_value,

// Test "slacks" are defined in terms of number of elements in the primitive size (T)
// up to the number of such elements contained in one vector type (VM::TV)
constexpr i32 slack = sizeof(typename VM::TV) / sizeof(T);
constexpr i32 slack = sizeof(typename VM::TV) / sizeof(T);
static_assert(slack > 1);

auto tests = gen_params(start, stop, step, slack, first_value, value_stride);

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

auto test_size = p.size + p.slack;
auto test_name = fmt::format("vxsort_pattern_test<{}, {}, {}>/{}/{}", test_type, U,
magic_enum::enum_name(M), magic_enum::enum_name(p.pattern), test_size);

RegisterSingleLambdaTest(
"fullsort", test_name.c_str(), nullptr,
std::to_string(test_size).c_str(),
__FILE__, __LINE__,
vxsort_pattern_test<T, U, M>, p.pattern, test_size, p.first_value, p.stride);
auto test_name =
fmt::format("vxsort_pattern_test<{}, {}, {}>/{}/{}", test_type, U,
magic_enum::enum_name(M), magic_enum::enum_name(p.pattern), test_size);

register_single_test_lambda(
"fullsort", test_name.c_str(), nullptr,
std::to_string(test_size).c_str(),
__FILE__, __LINE__,
vxsort_pattern_test<T, U, M>, p.pattern, test_size, p.first_value, p.stride);
}
}
}
} // namespace vxsort_tests

#endif // VXSORT_FULLSORT_TEST_H
78 changes: 40 additions & 38 deletions tests/smallsort/smallsort_test.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -4,12 +4,12 @@
#include <functional>
#include <magic_enum.hpp>

#include "gtest/gtest.h"
#include "../sort_fixtures.h"
#include "gtest/gtest.h"

#include "../test_isa.h"
#include "smallsort/bitonic_sort.h"
#include "fmt/format.h"
#include "smallsort/bitonic_sort.h"

namespace vxsort_tests {

Expand Down Expand Up @@ -56,37 +56,39 @@ void bitonic_sort_pattern_test(sort_pattern pattern, usize size, T first_value,

static inline std::vector<sort_pattern> smallsort_test_patterns() {
return {
sort_pattern::unique_values,
sort_pattern::shuffled_16_values,
sort_pattern::all_equal,
sort_pattern::unique_values,
sort_pattern::shuffled_16_values,
sort_pattern::all_equal,
};
}

template <typename T>
struct smallsort_test_params {
public:
smallsort_test_params(sort_pattern pattern, usize size, T first_value, T value_stride)
: pattern(pattern), size(size), first_value(first_value), stride(value_stride) {}
: pattern(pattern), size(size), first_value(first_value), stride(value_stride) {}
sort_pattern pattern;
usize size;
T first_value;
T stride;
};

template<typename T>
std::vector<smallsort_test_params<T>>
param_range(usize start, usize stop, usize step, T first_value, T value_stride) {

template <typename T>
std::vector<smallsort_test_params<T>> param_range(usize start,
usize stop,
usize step,
T first_value,
T value_stride) {
assert(step > 0);

auto patterns = smallsort_test_patterns();

using TestParams = smallsort_test_params<T>;
std::vector<TestParams> tests;

for(const auto& p: smallsort_test_patterns()) {
for(usize i = start; i <= stop; i += step) {
if(static_cast<i64>(i) <= 0)
for (const auto& p : smallsort_test_patterns()) {
for (usize i = start; i <= stop; i += step) {
if (static_cast<i64>(i) <= 0)
continue;

tests.push_back(TestParams(p, i, first_value, value_stride));
Expand All @@ -96,54 +98,54 @@ param_range(usize start, usize stop, usize step, T first_value, T value_stride)
}

template <vector_machine M, typename T>
void register_bitonic_tests(usize test_size_bytes, T first_value, T value_stride)
{

void register_bitonic_tests(usize test_size_bytes, T first_value, T value_stride) {
auto stop = test_size_bytes / sizeof(T);
usize step = 1;
auto tests = param_range(1, stop, step, first_value, value_stride);

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

auto test_size = p.size;
auto test_name = fmt::format("bitonic_sort_pattern_test<{}, {}>/{}/{}", test_type,
magic_enum::enum_name(M), magic_enum::enum_name(p.pattern), test_size);

RegisterSingleLambdaTest(
"smallsort", test_name.c_str(), nullptr,
std::to_string(test_size).c_str(),
__FILE__, __LINE__,
bitonic_sort_pattern_test<T, M>, p.pattern, test_size, p.first_value, p.stride);
auto test_name =
fmt::format("bitonic_sort_pattern_test<{}, {}>/{}/{}", test_type,
magic_enum::enum_name(M), magic_enum::enum_name(p.pattern), test_size);

register_single_test_lambda("smallsort", test_name.c_str(), nullptr,
std::to_string(test_size).c_str(),
__FILE__, __LINE__,
bitonic_sort_pattern_test<T, M>, p.pattern, test_size,
p.first_value, p.stride);
}
}

template <vector_machine M, typename T>
void register_bitonic_machine_tests(T first_value, T value_stride)
{
void register_bitonic_machine_tests(T first_value, T value_stride) {
using VM = vxsort::vxsort_machine_traits<T, M>;

// We test bitonic_machine from 1 up to 4 vectors in single vector increments
auto stop = (sizeof(typename VM::TV) * 4) / sizeof(T);
//auto stop = (sizeof(typename VM::TV) * 4) / sizeof(T);
auto stop = (sizeof(typename VM::TV) * 1) / sizeof(T);
usize step = sizeof(typename VM::TV) / sizeof(T);
assert(step > 0);

auto tests = param_range(step, stop, step, first_value, value_stride);

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

auto test_size = p.size;
auto test_name = fmt::format("bitonic_machine_sort_pattern_test<{}, {}>/{}/{}", test_type,
magic_enum::enum_name(M), magic_enum::enum_name(p.pattern), test_size);

RegisterSingleLambdaTest(
"smallsort", test_name.c_str(), nullptr,
std::to_string(test_size).c_str(),
__FILE__, __LINE__,
bitonic_machine_sort_pattern_test<T, M>, p.pattern, test_size, p.first_value, p.stride);
auto test_name =
fmt::format("bitonic_machine_sort_pattern_test<{}, {}>/{}/{}", test_type,
magic_enum::enum_name(M), magic_enum::enum_name(p.pattern), test_size);

register_single_test_lambda("smallsort", test_name.c_str(), nullptr,
std::to_string(test_size).c_str(),
__FILE__, __LINE__,
bitonic_machine_sort_pattern_test<T, M>, p.pattern, test_size,
p.first_value, p.stride);
}
}
}
} // namespace vxsort_tests

#endif // VXSORT_SMALLSORT_TEST_H
39 changes: 18 additions & 21 deletions tests/sort_fixtures.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -5,45 +5,42 @@
#include "stats/vxsort_stats.h"
#include "test_vectors.h"

#include <array>
#include <stdlib.h>
#include <algorithm>
#include <array>
#include <iterator>
#include <random>
#include <stdlib.h>

namespace vxsort_tests {
using namespace vxsort::types;
using testing::ValuesIn;
using testing::Types;

class VxSortLambdaFixture : public testing::Test {
public:
public:
using FunctionType = std::function<void()>;
explicit VxSortLambdaFixture(FunctionType fn) : _fn(std::move(fn)) {}

VxSortLambdaFixture(VxSortLambdaFixture const&) = delete;

void TestBody() override {
_fn();
}
void TestBody() override { _fn(); }

private:
private:
FunctionType _fn;
};

template <class Lambda, class... Args>
void RegisterSingleLambdaTest(const char* test_suite_name, const char* test_name,
const char* type_param, const char* value_param,
const char* file, int line,
Lambda&& fn, Args&&... args) {

testing::RegisterTest(
test_suite_name, test_name, type_param, value_param,
file, line,
[=]() mutable -> testing::Test* { return new VxSortLambdaFixture(
[=]() mutable { fn(args...); });
});
}
void register_single_test_lambda(const char* test_suite_name,
const char* test_name,
const char* type_param,
const char* value_param,
const char* file,
int line,
Lambda&& fn,
Args&&... args) {
testing::RegisterTest(test_suite_name, test_name, type_param, value_param, file, line,
[=]() mutable -> testing::Test* {
return new VxSortLambdaFixture([=]() mutable { fn(args...); });
});
}
} // namespace vxsort_tests

#endif // VXSORT_SORT_FIXTURES_H
Loading

0 comments on commit 2174912

Please sign in to comment.