120 lines
4.2 KiB
C++
120 lines
4.2 KiB
C++
/**
|
|
* \file
|
|
* \brief PDS HW2 tests
|
|
*
|
|
* \author
|
|
* Christos Choutouridis AEM:8997
|
|
* <cchoutou@ece.auth.gr>
|
|
*/
|
|
|
|
#include <gtest/gtest.h>
|
|
|
|
#include <algorithm> // rand/srand
|
|
#include <ctime> // rand/srand
|
|
#include "distsort.hpp"
|
|
|
|
|
|
/* ================================== fullSort ================================== */
|
|
|
|
/*
|
|
*
|
|
*/
|
|
TEST(TdistCommonUT, fullSort_test1) {
|
|
std::vector<uint8_t> ts_data = {3, 2, 1, 4, 5, 7, 8, 6};
|
|
std::vector<uint8_t> ts_expected = {1, 2, 3, 4, 5, 6, 7, 8};
|
|
bool ts_ascending = true;
|
|
|
|
fullSort(ts_data, ts_ascending);
|
|
EXPECT_EQ((ts_data == ts_expected), true);
|
|
}
|
|
|
|
TEST(TdistCommonUT, fullSort_test2) {
|
|
std::vector<uint8_t> ts_data = {3, 2, 1, 4, 5, 7, 8, 6};
|
|
std::vector<uint8_t> ts_expected = {8, 7, 6, 5, 4, 3, 2, 1};
|
|
bool ts_ascending = false;
|
|
|
|
fullSort(ts_data, ts_ascending);
|
|
EXPECT_EQ((ts_data == ts_expected), true);
|
|
}
|
|
|
|
/* ================================== elbowSort ================================== */
|
|
|
|
TEST(TdistCommonUT, elbowSort_test1) {
|
|
ShadowedVec_t<uint8_t> ts_data1(std::vector<uint8_t>{3, 2, 1, 4, 5, 5, 7, 8});
|
|
ShadowedVec_t<uint8_t> ts_data2(std::vector<uint8_t>{4, 5, 7, 8, 5, 3, 2, 1});
|
|
ShadowedVec_t<uint8_t> ts_data3(std::vector<uint8_t>{1, 2, 3, 4, 5, 5, 7, 8});
|
|
ShadowedVec_t<uint8_t> ts_data4(std::vector<uint8_t>{8, 7, 5, 5, 4, 3, 2, 1});
|
|
std::vector<uint8_t> ts_expected = {1, 2, 3, 4, 5, 5, 7, 8};
|
|
bool ts_ascending = true;
|
|
|
|
elbowSort(ts_data1, ts_ascending);
|
|
elbowSort(ts_data2, ts_ascending);
|
|
elbowSort(ts_data3, ts_ascending);
|
|
elbowSort(ts_data4, ts_ascending);
|
|
EXPECT_EQ((ts_data1 == ts_expected), true);
|
|
EXPECT_EQ((ts_data2 == ts_expected), true);
|
|
EXPECT_EQ((ts_data3 == ts_expected), true);
|
|
EXPECT_EQ((ts_data4 == ts_expected), true);
|
|
}
|
|
|
|
TEST(TdistCommonUT, elbowSort_test2) {
|
|
ShadowedVec_t<uint8_t> ts_data1(std::vector<uint8_t>{3, 2, 1, 4, 5, 5, 7, 8});
|
|
ShadowedVec_t<uint8_t> ts_data2(std::vector<uint8_t>{4, 5, 7, 8, 5, 3, 2, 1});
|
|
ShadowedVec_t<uint8_t> ts_data3(std::vector<uint8_t>{1, 2, 3, 4, 5, 5, 7, 8});
|
|
ShadowedVec_t<uint8_t> ts_data4(std::vector<uint8_t>{8, 7, 5, 5, 4, 3, 2, 1});
|
|
std::vector<uint8_t> ts_expected = {8, 7, 5, 5, 4, 3, 2, 1};
|
|
bool ts_ascending = false;
|
|
|
|
elbowSort(ts_data1, ts_ascending);
|
|
elbowSort(ts_data2, ts_ascending);
|
|
elbowSort(ts_data3, ts_ascending);
|
|
elbowSort(ts_data4, ts_ascending);
|
|
EXPECT_EQ((ts_data1 == ts_expected), true);
|
|
EXPECT_EQ((ts_data2 == ts_expected), true);
|
|
EXPECT_EQ((ts_data3 == ts_expected), true);
|
|
EXPECT_EQ((ts_data4 == ts_expected), true);
|
|
}
|
|
|
|
TEST(TdistCommonUT, elbowSort_test3) {
|
|
ShadowedVec_t<uint8_t> ts_data(std::vector<uint8_t>{8, 7, 5, 5, 4, 3, 2, 1});
|
|
std::vector<uint8_t> ts_expected_asc = {1, 2, 3, 4, 5, 5, 7, 8};
|
|
std::vector<uint8_t> ts_expected_des = {8, 7, 5, 5, 4, 3, 2, 1};
|
|
|
|
// Check alternation for active-shadow vector inside Buffer and elbow algorithm
|
|
elbowSort(ts_data, true);
|
|
EXPECT_EQ((ts_data == ts_expected_asc), true);
|
|
elbowSort(ts_data, false);
|
|
EXPECT_EQ((ts_data == ts_expected_des), true);
|
|
elbowSort(ts_data, true);
|
|
EXPECT_EQ((ts_data == ts_expected_asc), true);
|
|
elbowSort(ts_data, false);
|
|
EXPECT_EQ((ts_data == ts_expected_des), true);
|
|
}
|
|
|
|
/*
|
|
* Tag generator test without stage calls
|
|
*/
|
|
TEST(TdistCommonUT, tagGenerator_test1) {
|
|
// The maximum MPI size we support
|
|
// static constexpr size_t MAX_MPI_SIZE = 1024UL;
|
|
// The maximum pipeline size we support
|
|
// static constexpr size_t MAX_PIPELINE_SIZE = 64UL;
|
|
|
|
std::vector<int> ts_tags;
|
|
auto ts_logSize = static_cast<uint32_t>(std::log2(MAX_MPI_SIZE));
|
|
|
|
for (size_t depth = 0; depth <= ts_logSize; ++depth) {
|
|
for (size_t step = 0 ; step < MAX_MPI_SIZE; ++step) {
|
|
int tag = static_cast<int>(tagGenerator(depth, step));
|
|
ts_tags.push_back(tag); // Exchange optimization
|
|
for (size_t stage = 0; stage < MAX_PIPELINE_SIZE; ++stage) {
|
|
ts_tags.push_back(++tag); // stages
|
|
}
|
|
}
|
|
}
|
|
std::sort(ts_tags.begin(), ts_tags.end());
|
|
for (size_t i = 0 ; i < ts_tags.size() - 1 ; ++i)
|
|
EXPECT_NE(ts_tags[i], ts_tags[i+1]);
|
|
}
|
|
|