HW2: Add an MPI wrapper for the basic functionality and update all types
This commit is contained in:
parent
496ee69f54
commit
1d6b271d2a
@ -207,6 +207,8 @@ deb_distbitonic: CXXFLAGS := $(DEB_CXXFLAGS) -DCODE_VERSION=BITONIC -DDEBUG
|
||||
deb_distbitonic: TARGET := deb_distbitonic
|
||||
deb_distbitonic: $(BUILD_DIR)/$(TARGET)
|
||||
|
||||
tests: CC := mpicc
|
||||
tests: CXX := mpic++
|
||||
tests: CFLAGS := $(DEB_CFLAGS) -DCODE_VERSION=BITONIC -DDEBUG -DTESTING
|
||||
tests: CXXFLAGS := $(DEB_CXXFLAGS) -DCODE_VERSION=BITONIC -DDEBUG -DTESTING
|
||||
tests: TARGET := tests
|
||||
|
||||
@ -10,15 +10,9 @@
|
||||
#ifndef DISTBITONIC_H_
|
||||
#define DISTBITONIC_H_
|
||||
|
||||
#if !defined DEBUG
|
||||
#define NDEBUG
|
||||
#endif
|
||||
#include <cassert>
|
||||
#include <cstdint>
|
||||
#include "utils.hpp"
|
||||
|
||||
#include <vector>
|
||||
#if !defined TESTING
|
||||
#include <mpi.h>
|
||||
#endif
|
||||
|
||||
/*!
|
||||
* Enumerator for the different versions of the sorting method
|
||||
@ -31,14 +25,6 @@ enum class SortMode {
|
||||
using Data_t = std::vector<uint8_t>;
|
||||
using AllData_t = std::vector<Data_t>;
|
||||
|
||||
struct mpi_t {
|
||||
size_t world_size{};
|
||||
size_t world_rank{};
|
||||
std::string processor_name {};
|
||||
};
|
||||
|
||||
extern mpi_t mpi;
|
||||
|
||||
/*
|
||||
* ============================== Sort utilities ==============================
|
||||
*/
|
||||
@ -47,41 +33,41 @@ extern mpi_t mpi;
|
||||
* The primary function template of ascending(). It is DISABLED since , it is explicitly specialized
|
||||
* for each of the \c SortMode
|
||||
*/
|
||||
template <SortMode Mode> bool ascending(size_t, [[maybe_unused]] size_t) noexcept = delete;
|
||||
template <> bool ascending<SortMode::Bubbletonic>(size_t node, [[maybe_unused]] size_t depth) noexcept;
|
||||
template <> bool ascending<SortMode::Bitonic>(size_t node, size_t depth) noexcept;
|
||||
template <SortMode Mode> bool ascending(mpi_id_t, [[maybe_unused]] size_t) noexcept = delete;
|
||||
template <> bool ascending<SortMode::Bubbletonic>(mpi_id_t node, [[maybe_unused]] size_t depth) noexcept;
|
||||
template <> bool ascending<SortMode::Bitonic>(mpi_id_t node, size_t depth) noexcept;
|
||||
|
||||
/*!
|
||||
* The primary function template of partner(). It is DISABLED since , it is explicitly specialized
|
||||
* for each of the \c SortMode
|
||||
*/
|
||||
template <SortMode Mode> size_t partner(size_t, size_t) noexcept = delete;
|
||||
template <> size_t partner<SortMode::Bubbletonic>(size_t node, size_t step) noexcept;
|
||||
template <> size_t partner<SortMode::Bitonic>(size_t node, size_t step) noexcept;
|
||||
template <SortMode Mode> mpi_id_t partner(mpi_id_t, size_t) noexcept = delete;
|
||||
template <> mpi_id_t partner<SortMode::Bubbletonic>(mpi_id_t node, size_t step) noexcept;
|
||||
template <> mpi_id_t partner<SortMode::Bitonic>(mpi_id_t node, size_t step) noexcept;
|
||||
|
||||
/*!
|
||||
* The primary function template of keepsmall(). It is DISABLED since , it is explicitly specialized
|
||||
* The primary function template of keepSmall(). It is DISABLED since , it is explicitly specialized
|
||||
* for each of the \c SortMode
|
||||
*/
|
||||
template<SortMode Mode> bool keepsmall(size_t, size_t, [[maybe_unused]] size_t) noexcept = delete;
|
||||
template<> bool keepsmall<SortMode::Bubbletonic>(size_t node, size_t partner, [[maybe_unused]] size_t depth) noexcept;
|
||||
template<> bool keepsmall<SortMode::Bitonic>(size_t node, size_t partner, size_t depth) noexcept;
|
||||
template<SortMode Mode> bool keepSmall(mpi_id_t, mpi_id_t, [[maybe_unused]] size_t) noexcept = delete;
|
||||
template<> bool keepSmall<SortMode::Bubbletonic>(mpi_id_t node, mpi_id_t partner, [[maybe_unused]] size_t depth) noexcept;
|
||||
template<> bool keepSmall<SortMode::Bitonic>(mpi_id_t node, mpi_id_t partner, size_t depth) noexcept;
|
||||
|
||||
bool isActive(size_t node, size_t nodes) noexcept;
|
||||
bool isActive(mpi_id_t node, mpi_id_t nodes) noexcept;
|
||||
|
||||
/*
|
||||
* ============================== Data utilities ==============================
|
||||
*/
|
||||
void exchange(size_t node, size_t partner);
|
||||
void minmax(AllData_t& data, size_t node, size_t partner, bool keepsmall);
|
||||
void exchange(mpi_id_t node, mpi_id_t partner);
|
||||
void minmax(AllData_t& data, mpi_id_t node, mpi_id_t partner, bool keepsmall);
|
||||
|
||||
/*
|
||||
* ============================== Sort algorithms ==============================
|
||||
*/
|
||||
void bubbletonic_network(AllData_t& data, size_t nodes);
|
||||
void distbubbletonic(size_t P, AllData_t& data);
|
||||
void bubbletonic_network(AllData_t& data, mpi_id_t nodes);
|
||||
void distBubbletonic(mpi_id_t P, AllData_t& data);
|
||||
|
||||
void bitonic_network(AllData_t& data, size_t nodes, size_t depth);
|
||||
void distbitonic(size_t P, AllData_t& data);
|
||||
void bitonic_network(AllData_t& data, mpi_id_t nodes, mpi_id_t depth);
|
||||
void distBitonic(mpi_id_t P, AllData_t& data);
|
||||
|
||||
#endif //DISTBITONIC_H_
|
||||
|
||||
@ -12,14 +12,68 @@
|
||||
#include <iostream>
|
||||
#include <chrono>
|
||||
#include <unistd.h>
|
||||
#include <mpi.h>
|
||||
|
||||
#include "matrix.hpp"
|
||||
//#include "matrix.hpp"
|
||||
#include "config.h"
|
||||
|
||||
|
||||
template<typename TID = int>
|
||||
struct MPI_t {
|
||||
using ID_t = TID; // Export TID type (currently int defined by the standard)
|
||||
|
||||
void init(int *argc, char ***argv) {
|
||||
// Initialize the MPI environment
|
||||
MPI_Init(argc, argv);
|
||||
|
||||
// Get the number of processes
|
||||
int size_value, rank_value;
|
||||
size_ = static_cast<ID_t>(MPI_Comm_size(MPI_COMM_WORLD, &size_value));
|
||||
rank_ = static_cast<ID_t>(MPI_Comm_rank(MPI_COMM_WORLD, &rank_value));
|
||||
|
||||
// Get the name of the processor
|
||||
char processor_name[MPI_MAX_PROCESSOR_NAME];
|
||||
int name_len;
|
||||
MPI_Get_processor_name(processor_name, &name_len);
|
||||
name_ = std::string (processor_name, name_len);
|
||||
}
|
||||
|
||||
void finalize() {
|
||||
// Finalize the MPI environment.
|
||||
MPI_Finalize();
|
||||
}
|
||||
|
||||
bool exchange(ID_t partner, const void *send_data, void *recv_data, int data_count, MPI_Datatype datatype) {
|
||||
bool ret = true;
|
||||
MPI_Status status;
|
||||
MPI_Sendrecv(
|
||||
send_data, data_count, datatype, partner, 0,
|
||||
recv_data, data_count, datatype, partner, 0,
|
||||
MPI_COMM_WORLD, &status
|
||||
);
|
||||
if (status.MPI_ERROR != MPI_SUCCESS)
|
||||
ret = false;
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
// Accessors
|
||||
[[nodiscard]] ID_t rank() const noexcept { return rank_; }
|
||||
[[nodiscard]] ID_t size() const noexcept { return size_; }
|
||||
[[nodiscard]] const std::string& name() const noexcept { return name_; }
|
||||
|
||||
private:
|
||||
ID_t rank_{};
|
||||
ID_t size_{};
|
||||
std::string name_{};
|
||||
};
|
||||
|
||||
extern MPI_t<> mpi;
|
||||
using mpi_id_t = MPI_t<>::ID_t;
|
||||
|
||||
/*!
|
||||
* A Logger for entire program.
|
||||
*/
|
||||
|
||||
struct Log {
|
||||
struct Endl {
|
||||
} endl; //!< a tag object to to use it as a new line request.
|
||||
|
||||
@ -10,10 +10,15 @@
|
||||
#include <vector>
|
||||
#include <algorithm>
|
||||
#include <cmath>
|
||||
#if !defined DEBUG
|
||||
#define NDEBUG
|
||||
#endif
|
||||
#include <cassert>
|
||||
|
||||
#include "distbitonic.hpp"
|
||||
|
||||
|
||||
|
||||
/*!
|
||||
* Returns the ascending or descending configuration of the node's sequence based on
|
||||
* the current node (MPI process) and the depth of the sorting network
|
||||
@ -22,7 +27,7 @@
|
||||
* @return True if we need ascending configuration, false otherwise
|
||||
*/
|
||||
template <>
|
||||
bool ascending<SortMode::Bubbletonic>(size_t node, [[maybe_unused]] size_t depth) noexcept {
|
||||
bool ascending<SortMode::Bubbletonic>(mpi_id_t node, [[maybe_unused]] size_t depth) noexcept {
|
||||
return (node % 2) == 0;
|
||||
}
|
||||
|
||||
@ -36,7 +41,7 @@ bool ascending<SortMode::Bubbletonic>(size_t node, [[maybe_unused]] size_t depth
|
||||
* @return True if we need ascending configuration, false otherwise
|
||||
*/
|
||||
template <>
|
||||
bool ascending<SortMode::Bitonic>(size_t node, size_t depth) noexcept {
|
||||
bool ascending<SortMode::Bitonic>(mpi_id_t node, size_t depth) noexcept {
|
||||
return !(node & (1 << depth));
|
||||
}
|
||||
|
||||
@ -49,7 +54,7 @@ bool ascending<SortMode::Bitonic>(size_t node, size_t depth) noexcept {
|
||||
* @return The node id of the partner for data exchange
|
||||
*/
|
||||
template <>
|
||||
size_t partner<SortMode::Bubbletonic>(size_t node, size_t step) noexcept {
|
||||
mpi_id_t partner<SortMode::Bubbletonic>(mpi_id_t node, size_t step) noexcept {
|
||||
// return (node % 2 == step % 2) ? node + 1 : node - 1;
|
||||
return (((node+step) % 2) == 0) ? node + 1 : node - 1;
|
||||
}
|
||||
@ -63,7 +68,7 @@ size_t partner<SortMode::Bubbletonic>(size_t node, size_t step) noexcept {
|
||||
* @return The node id of the partner for data exchange
|
||||
*/
|
||||
template <>
|
||||
size_t partner<SortMode::Bitonic>(size_t node, size_t step) noexcept {
|
||||
mpi_id_t partner<SortMode::Bitonic>(mpi_id_t node, size_t step) noexcept {
|
||||
return (node ^ (1 << step));
|
||||
}
|
||||
|
||||
@ -76,7 +81,7 @@ size_t partner<SortMode::Bitonic>(size_t node, size_t step) noexcept {
|
||||
* @return True if the node should keep the small values, false otherwise
|
||||
*/
|
||||
template <>
|
||||
bool keepsmall<SortMode::Bubbletonic>(size_t node, size_t partner, [[maybe_unused]] size_t depth) noexcept {
|
||||
bool keepSmall<SortMode::Bubbletonic>(mpi_id_t node, mpi_id_t partner, [[maybe_unused]] size_t depth) noexcept {
|
||||
assert(node != partner);
|
||||
return (node < partner);
|
||||
}
|
||||
@ -90,7 +95,7 @@ bool keepsmall<SortMode::Bubbletonic>(size_t node, size_t partner, [[maybe_unuse
|
||||
* @return True if the node should keep the small values, false otherwise
|
||||
*/
|
||||
template <>
|
||||
bool keepsmall<SortMode::Bitonic>(size_t node, size_t partner, size_t depth) noexcept {
|
||||
bool keepSmall<SortMode::Bitonic>(mpi_id_t node, mpi_id_t partner, size_t depth) noexcept {
|
||||
assert(node != partner);
|
||||
return ascending<SortMode::Bitonic>(node, depth) == (node < partner);
|
||||
}
|
||||
@ -103,16 +108,16 @@ bool keepsmall<SortMode::Bitonic>(size_t node, size_t partner, size_t depth) noe
|
||||
* @param nodes The total number of nodes
|
||||
* @return True if the node is active, false otherwise
|
||||
*/
|
||||
bool isActive(size_t node, size_t nodes) noexcept {
|
||||
return (node < nodes);
|
||||
bool isActive(mpi_id_t node, mpi_id_t nodes) noexcept {
|
||||
return (node >= 0) && (node < (nodes-1));
|
||||
}
|
||||
|
||||
void exchange(size_t node, size_t partner) {
|
||||
|
||||
void exchange(mpi_id_t node, mpi_id_t partner) {
|
||||
assert(node != partner);
|
||||
|
||||
}
|
||||
|
||||
void minmax(AllData_t& data, size_t node, size_t partner, bool keepsmall) {
|
||||
void minmax(AllData_t& data, mpi_id_t node, mpi_id_t partner, bool keepsmall) {
|
||||
for (size_t i = 0; i < data[node].size(); ++i) {
|
||||
if (keepsmall && data[node][i] > data[partner][i])
|
||||
std::swap(data[node][i], data[partner][i]);
|
||||
@ -124,10 +129,10 @@ void minmax(AllData_t& data, size_t node, size_t partner, bool keepsmall) {
|
||||
|
||||
|
||||
|
||||
void bubbletonic_network(AllData_t& data, size_t nodes, size_t depth) {
|
||||
for (size_t node = 0 ; node < nodes ; ++node) { // Currently we do all nodes here!
|
||||
void bubbletonic_network(AllData_t& data, mpi_id_t nodes, size_t depth) {
|
||||
for (mpi_id_t node = 0 ; node < nodes ; ++node) { // Currently we do all nodes here!
|
||||
auto part = partner<SortMode::Bubbletonic>(node, depth);
|
||||
auto ks = keepsmall<SortMode::Bubbletonic>(node, part, 0);
|
||||
auto ks = keepSmall<SortMode::Bubbletonic>(node, part, 0);
|
||||
if (isActive(node, nodes) && node < part) {
|
||||
exchange(node, part);
|
||||
minmax(data, node, part, ks);
|
||||
@ -145,8 +150,8 @@ void bubbletonic_network(AllData_t& data, size_t nodes, size_t depth) {
|
||||
}
|
||||
}
|
||||
|
||||
void distbubbletonic(size_t P, AllData_t& data) {
|
||||
for (size_t node = 0 ; node < P ; ++node) { // Currently we do all nodes here!
|
||||
void distBubbletonic(mpi_id_t P, AllData_t& data) {
|
||||
for (mpi_id_t node = 0 ; node < P ; ++node) { // Currently we do all nodes here!
|
||||
// Initially sort to create the half part of a bitonic
|
||||
if (ascending<SortMode::Bubbletonic>(node, 0))
|
||||
std::sort(data[node].begin(), data[node].end(), std::less<>());
|
||||
@ -159,19 +164,19 @@ void distbubbletonic(size_t P, AllData_t& data) {
|
||||
}
|
||||
|
||||
// Invert the descending ones
|
||||
for (size_t node = 0 ; node < P ; ++node) { // Currently we do all nodes here!
|
||||
for (mpi_id_t node = 0 ; node < P ; ++node) { // Currently we do all nodes here!
|
||||
if (!ascending<SortMode::Bubbletonic>(node, 0))
|
||||
std::sort(data[node].begin(), data[node].end(), std::less<>());
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void bitonic_network(AllData_t& data, size_t nodes, size_t depth) {
|
||||
void bitonic_network(AllData_t& data, mpi_id_t nodes, size_t depth) {
|
||||
for (size_t step = depth; step > 0;) {
|
||||
--step;
|
||||
for (size_t node = 0; node < nodes; ++node) { // Currently we do all nodes here!
|
||||
for (mpi_id_t node = 0; node < nodes; ++node) { // Currently we do all nodes here!
|
||||
auto part = partner<SortMode::Bitonic>(node, step);
|
||||
auto ks = keepsmall<SortMode::Bitonic>(node, part, depth);
|
||||
auto ks = keepSmall<SortMode::Bitonic>(node, part, depth);
|
||||
if (node < part) {
|
||||
exchange(node, part);
|
||||
minmax(data, node, part, ks);
|
||||
@ -180,10 +185,10 @@ void bitonic_network(AllData_t& data, size_t nodes, size_t depth) {
|
||||
}
|
||||
}
|
||||
|
||||
void distbitonic(size_t P, AllData_t& data) {
|
||||
void distBitonic(mpi_id_t P, AllData_t& data) {
|
||||
auto p = static_cast<uint32_t>(std::log2(P));
|
||||
|
||||
for (size_t node = 0 ; node < P ; ++node) { // Currently we do all nodes here!
|
||||
for (mpi_id_t node = 0 ; node < P ; ++node) { // Currently we do all nodes here!
|
||||
// Initially sort to create the half part of a bitonic
|
||||
if (ascending<SortMode::Bitonic>(node, 0))
|
||||
std::sort(data[node].begin(), data[node].end(), std::less<>());
|
||||
@ -195,7 +200,7 @@ void distbitonic(size_t P, AllData_t& data) {
|
||||
for (size_t depth = 1; depth <= p; ++depth) {
|
||||
bitonic_network(data, P, depth);
|
||||
|
||||
for (size_t node = 0 ; node < P ; ++node) { // Currently we do all nodes here!
|
||||
for (mpi_id_t node = 0 ; node < P ; ++node) { // Currently we do all nodes here!
|
||||
// elbow-sort here
|
||||
if (ascending<SortMode::Bitonic>(node, depth))
|
||||
std::sort(data[node].begin(), data[node].end(), std::less<>());
|
||||
|
||||
@ -9,34 +9,14 @@
|
||||
|
||||
#include <exception>
|
||||
#include <iostream>
|
||||
#include <algorithm> // rand/srand
|
||||
//#include <ctime> // rand/srand
|
||||
#if !defined TESTING
|
||||
#include <mpi.h>
|
||||
#endif
|
||||
|
||||
#include "distbitonic.hpp"
|
||||
#include "utils.hpp"
|
||||
#include "config.h"
|
||||
//#include "matrix.hpp"
|
||||
|
||||
|
||||
// Global session data
|
||||
session_t session;
|
||||
mpi_t mpi;
|
||||
|
||||
/*
|
||||
* Sorting data for up to 8 processes
|
||||
*/
|
||||
AllData_t Data {
|
||||
Data_t (8),
|
||||
Data_t (8),
|
||||
Data_t (8),
|
||||
Data_t (8),
|
||||
Data_t (8),
|
||||
Data_t (8),
|
||||
Data_t (8),
|
||||
Data_t (8)
|
||||
};
|
||||
MPI_t<> mpi;
|
||||
|
||||
|
||||
/*!
|
||||
@ -62,8 +42,8 @@ bool get_options(int argc, char* argv[]){
|
||||
else if (arg == "-v" || arg == "--verbose")
|
||||
session.verbose = true;
|
||||
else if (arg == "-h" || arg == "--help") {
|
||||
std::cout << "distbitonic - A distributed bitonic sort\n\n";
|
||||
std::cout << "distbitonic -x <> [-v]\n";
|
||||
std::cout << "distBitonic - A distributed bitonic sort\n\n";
|
||||
std::cout << "distBitonic -x <> [-v]\n";
|
||||
std::cout << '\n';
|
||||
std::cout << "Options:\n\n";
|
||||
std::cout << " -v | --verbose\n";
|
||||
@ -72,7 +52,7 @@ bool get_options(int argc, char* argv[]){
|
||||
std::cout << " Prints this and exit.\n\n";
|
||||
std::cout << "Examples:\n\n";
|
||||
std::cout << " ...Example case...:\n";
|
||||
std::cout << " > distbitonic -x <xxxxx> \n\n";
|
||||
std::cout << " > distBitonic -x <xxxxx> \n\n";
|
||||
|
||||
exit(0);
|
||||
}
|
||||
@ -89,13 +69,13 @@ bool get_options(int argc, char* argv[]){
|
||||
|
||||
#if !defined TESTING
|
||||
int main(int argc, char* argv[]) try {
|
||||
// try to read command line
|
||||
// Initialize MPI environment
|
||||
mpi.init(&argc, &argv);
|
||||
|
||||
// try to read command line (after MPI parsing)
|
||||
if (!get_options(argc, argv))
|
||||
exit(1);
|
||||
|
||||
// Initialize the MPI environment
|
||||
MPI_Init(NULL, NULL);
|
||||
|
||||
#if defined DEBUG
|
||||
/*
|
||||
* In case of a debug build we will wait here until sleep_wait
|
||||
@ -107,41 +87,24 @@ int main(int argc, char* argv[]) try {
|
||||
* $> gdb <program> <PID2>
|
||||
*/
|
||||
#if defined TESTING
|
||||
volatile bool sleep_wait = false;
|
||||
volatile bool sleep_wait = false;
|
||||
#else
|
||||
volatile bool sleep_wait = true;
|
||||
volatile bool sleep_wait = true;
|
||||
#endif
|
||||
while (sleep_wait)
|
||||
sleep(1);
|
||||
while (sleep_wait)
|
||||
sleep(1);
|
||||
#endif
|
||||
|
||||
// Get the number of processes
|
||||
MPI_Comm_size(MPI_COMM_WORLD, reinterpret_cast<int *>(&mpi.world_size));
|
||||
|
||||
// Get the rank of the process
|
||||
MPI_Comm_rank(MPI_COMM_WORLD, reinterpret_cast<int *>(&mpi.world_rank));
|
||||
|
||||
// Get the name of the processor
|
||||
char processor_name[MPI_MAX_PROCESSOR_NAME];
|
||||
int name_len;
|
||||
MPI_Get_processor_name(processor_name, &name_len);
|
||||
mpi.processor_name = std::string (processor_name, name_len);
|
||||
|
||||
// Print off a hello world message
|
||||
std::cout << "Hello world from processor: " << mpi.processor_name
|
||||
<< " rank " << mpi.world_rank
|
||||
<< " out of " << mpi.world_size << " processors\n";
|
||||
// std::cout << "Hello world from processor: " << mpi.processor_name
|
||||
// << " rank " << mpi.world_rank
|
||||
// << " out of " << mpi.world_size << " processors\n";
|
||||
|
||||
// std::srand(unsigned(std::time(nullptr)));
|
||||
// for (auto& v : Data) {
|
||||
// std::generate(v.begin(), v.end(), std::rand);
|
||||
// }
|
||||
//
|
||||
// distbitonic (2, Data);
|
||||
// distbitonic (4, Data);
|
||||
|
||||
// Finalize the MPI environment.
|
||||
MPI_Finalize();
|
||||
// distBitonic (2, Data);
|
||||
// distBitonic (4, Data);
|
||||
|
||||
mpi.finalize();
|
||||
return 0;
|
||||
}
|
||||
catch (std::exception& e) {
|
||||
|
||||
@ -18,7 +18,7 @@
|
||||
/* ================================== ascending ================================== */
|
||||
|
||||
/*
|
||||
* bool ascending<SortMode::Bitonic>(size_t node, size_t depth);
|
||||
* bool ascending<SortMode::Bitonic>(mpi_id_t node, size_t depth);
|
||||
* depth 0 (the initial ascending pattern)
|
||||
*/
|
||||
TEST(TdistBitonic_UT, ascending_test1) {
|
||||
@ -32,13 +32,13 @@ TEST(TdistBitonic_UT, ascending_test1) {
|
||||
EXPECT_EQ(ascending<SortMode::Bitonic>(6, 0), true);
|
||||
EXPECT_EQ(ascending<SortMode::Bitonic>(7, 0), false);
|
||||
|
||||
for (size_t node = 0 ; node < 256 ; ++node) {
|
||||
for (mpi_id_t node = 0 ; node < 256 ; ++node) {
|
||||
EXPECT_EQ(ascending<SortMode::Bitonic>(node, 0), ((node % 2) ? false : true) );
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* bool ascending<SortMode::Bitonic>(size_t node, size_t depth);
|
||||
* bool ascending<SortMode::Bitonic>(mpi_id_t node, size_t depth);
|
||||
* depth 1
|
||||
*/
|
||||
TEST(TdistBitonic_UT, ascending_test2) {
|
||||
@ -52,14 +52,14 @@ TEST(TdistBitonic_UT, ascending_test2) {
|
||||
EXPECT_EQ(ascending<SortMode::Bitonic>(6, 1), false);
|
||||
EXPECT_EQ(ascending<SortMode::Bitonic>(7, 1), false);
|
||||
|
||||
for (size_t node = 0 ; node < 256 ; ++node) {
|
||||
for (mpi_id_t node = 0 ; node < 256 ; ++node) {
|
||||
EXPECT_EQ(ascending<SortMode::Bitonic>(2*node, 1), ((node % 2) ? false:true));
|
||||
EXPECT_EQ(ascending<SortMode::Bitonic>(2*node+1, 1), ((node % 2) ? false:true));
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* bool ascending<SortMode::Bitonic>(size_t node, size_t depth);
|
||||
* bool ascending<SortMode::Bitonic>(mpi_id_t node, size_t depth);
|
||||
* various depths
|
||||
*/
|
||||
TEST(TdistBitonic_UT, ascending_test3) {
|
||||
@ -67,37 +67,37 @@ TEST(TdistBitonic_UT, ascending_test3) {
|
||||
// Depth = 3
|
||||
size_t ts_depth = 3;
|
||||
|
||||
for (size_t n = 0UL ; n < (1UL<<(ts_depth)) ; ++n)
|
||||
for (mpi_id_t n = 0 ; n < (1<<(ts_depth)) ; ++n)
|
||||
EXPECT_EQ(ascending<SortMode::Bitonic>(n, ts_depth), true);
|
||||
for (size_t n = (1UL<<(ts_depth)) ; n < 2*(1UL<<(ts_depth)) ; ++n)
|
||||
for (mpi_id_t n = (1<<(ts_depth)) ; n < 2*(1<<(ts_depth)) ; ++n)
|
||||
EXPECT_EQ(ascending<SortMode::Bitonic>(n, ts_depth), false);
|
||||
for (size_t n = 2*(1UL<<(ts_depth)) ; n < 3*(1UL<<(ts_depth)) ; ++n)
|
||||
for (mpi_id_t n = 2*(1<<(ts_depth)) ; n < 3*(1<<(ts_depth)) ; ++n)
|
||||
EXPECT_EQ(ascending<SortMode::Bitonic>(n, ts_depth), true);
|
||||
for (size_t n = 3*(1UL<<(ts_depth)) ; n < 4*(1UL<<(ts_depth)) ; ++n)
|
||||
for (mpi_id_t n = 3*(1<<(ts_depth)) ; n < 4*(1<<(ts_depth)) ; ++n)
|
||||
EXPECT_EQ(ascending<SortMode::Bitonic>(n, ts_depth), false);
|
||||
|
||||
// Depth = 4
|
||||
ts_depth = 4;
|
||||
|
||||
for (size_t n = 0UL ; n < (1UL<<(ts_depth)) ; ++n)
|
||||
for (mpi_id_t n = 0L ; n < (1<<(ts_depth)) ; ++n)
|
||||
EXPECT_EQ(ascending<SortMode::Bitonic>(n, ts_depth), true);
|
||||
for (size_t n = (1UL<<(ts_depth)) ; n < 2*(1UL<<(ts_depth)) ; ++n)
|
||||
for (mpi_id_t n = (1<<(ts_depth)) ; n < 2*(1<<(ts_depth)) ; ++n)
|
||||
EXPECT_EQ(ascending<SortMode::Bitonic>(n, ts_depth), false);
|
||||
for (size_t n = 2*(1UL<<(ts_depth)) ; n < 3*(1UL<<(ts_depth)) ; ++n)
|
||||
for (mpi_id_t n = 2*(1<<(ts_depth)) ; n < 3*(1<<(ts_depth)) ; ++n)
|
||||
EXPECT_EQ(ascending<SortMode::Bitonic>(n, ts_depth), true);
|
||||
for (size_t n = 3*(1UL<<(ts_depth)) ; n < 4*(1UL<<(ts_depth)) ; ++n)
|
||||
for (mpi_id_t n = 3*(1<<(ts_depth)) ; n < 4*(1<<(ts_depth)) ; ++n)
|
||||
EXPECT_EQ(ascending<SortMode::Bitonic>(n, ts_depth), false);
|
||||
|
||||
// Depth = 8
|
||||
ts_depth = 8;
|
||||
|
||||
for (size_t n = 0UL ; n < (1UL<<(ts_depth)) ; ++n)
|
||||
for (mpi_id_t n = 0L ; n < (1<<(ts_depth)) ; ++n)
|
||||
EXPECT_EQ(ascending<SortMode::Bitonic>(n, ts_depth), true);
|
||||
for (size_t n = (1UL<<(ts_depth)) ; n < 2*(1UL<<(ts_depth)) ; ++n)
|
||||
for (mpi_id_t n = (1<<(ts_depth)) ; n < 2*(1<<(ts_depth)) ; ++n)
|
||||
EXPECT_EQ(ascending<SortMode::Bitonic>(n, ts_depth), false);
|
||||
for (size_t n = 2*(1UL<<(ts_depth)) ; n < 3*(1UL<<(ts_depth)) ; ++n)
|
||||
for (mpi_id_t n = 2*(1<<(ts_depth)) ; n < 3*(1<<(ts_depth)) ; ++n)
|
||||
EXPECT_EQ(ascending<SortMode::Bitonic>(n, ts_depth), true);
|
||||
for (size_t n = 3*(1UL<<(ts_depth)) ; n < 4*(1UL<<(ts_depth)) ; ++n)
|
||||
for (mpi_id_t n = 3*(1<<(ts_depth)) ; n < 4*(1<<(ts_depth)) ; ++n)
|
||||
EXPECT_EQ(ascending<SortMode::Bitonic>(n, ts_depth), false);
|
||||
}
|
||||
|
||||
@ -107,59 +107,59 @@ TEST(TdistBitonic_UT, ascending_test3) {
|
||||
/* ================================== partner ================================== */
|
||||
|
||||
/*
|
||||
* size_t partner<SortMode::Bitonic>(size_t node, size_t step);
|
||||
* mpi_id_t partner<SortMode::Bitonic>(mpi_id_t node, size_t step);
|
||||
* step = 0
|
||||
*/
|
||||
TEST(TdistBitonic_UT, partner_test1) {
|
||||
|
||||
EXPECT_EQ(partner<SortMode::Bitonic>(0, 0), 1UL);
|
||||
EXPECT_EQ(partner<SortMode::Bitonic>(1, 0), 0UL);
|
||||
EXPECT_EQ(partner<SortMode::Bitonic>(2, 0), 3UL);
|
||||
EXPECT_EQ(partner<SortMode::Bitonic>(3, 0), 2UL);
|
||||
EXPECT_EQ(partner<SortMode::Bitonic>(4, 0), 5UL);
|
||||
EXPECT_EQ(partner<SortMode::Bitonic>(5, 0), 4UL);
|
||||
EXPECT_EQ(partner<SortMode::Bitonic>(6, 0), 7UL);
|
||||
EXPECT_EQ(partner<SortMode::Bitonic>(7, 0), 6UL);
|
||||
EXPECT_EQ(partner<SortMode::Bitonic>(0, 0), 1);
|
||||
EXPECT_EQ(partner<SortMode::Bitonic>(1, 0), 0);
|
||||
EXPECT_EQ(partner<SortMode::Bitonic>(2, 0), 3);
|
||||
EXPECT_EQ(partner<SortMode::Bitonic>(3, 0), 2);
|
||||
EXPECT_EQ(partner<SortMode::Bitonic>(4, 0), 5);
|
||||
EXPECT_EQ(partner<SortMode::Bitonic>(5, 0), 4);
|
||||
EXPECT_EQ(partner<SortMode::Bitonic>(6, 0), 7);
|
||||
EXPECT_EQ(partner<SortMode::Bitonic>(7, 0), 6);
|
||||
|
||||
for (size_t node = 0 ; node < 256 ; ++node) {
|
||||
for (mpi_id_t node = 0 ; node < 256 ; ++node) {
|
||||
EXPECT_EQ(partner<SortMode::Bitonic>(node, 0), (node % 2) ? node-1 : node+1);
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* size_t partner<SortMode::Bitonic>(size_t node, size_t step);
|
||||
* mpi_id_t partner<SortMode::Bitonic>(mpi_id_t node, size_t step);
|
||||
* step = 1
|
||||
*/
|
||||
TEST(TdistBitonic_UT, partner_test2) {
|
||||
|
||||
EXPECT_EQ(partner<SortMode::Bitonic>(0, 1), 2UL);
|
||||
EXPECT_EQ(partner<SortMode::Bitonic>(1, 1), 3UL);
|
||||
EXPECT_EQ(partner<SortMode::Bitonic>(2, 1), 0UL);
|
||||
EXPECT_EQ(partner<SortMode::Bitonic>(3, 1), 1UL);
|
||||
EXPECT_EQ(partner<SortMode::Bitonic>(4, 1), 6UL);
|
||||
EXPECT_EQ(partner<SortMode::Bitonic>(5, 1), 7UL);
|
||||
EXPECT_EQ(partner<SortMode::Bitonic>(6, 1), 4UL);
|
||||
EXPECT_EQ(partner<SortMode::Bitonic>(7, 1), 5UL);
|
||||
EXPECT_EQ(partner<SortMode::Bitonic>(0, 1), 2);
|
||||
EXPECT_EQ(partner<SortMode::Bitonic>(1, 1), 3);
|
||||
EXPECT_EQ(partner<SortMode::Bitonic>(2, 1), 0);
|
||||
EXPECT_EQ(partner<SortMode::Bitonic>(3, 1), 1);
|
||||
EXPECT_EQ(partner<SortMode::Bitonic>(4, 1), 6);
|
||||
EXPECT_EQ(partner<SortMode::Bitonic>(5, 1), 7);
|
||||
EXPECT_EQ(partner<SortMode::Bitonic>(6, 1), 4);
|
||||
EXPECT_EQ(partner<SortMode::Bitonic>(7, 1), 5);
|
||||
|
||||
for (size_t n1 = 0 ; n1 < 256 ; n1 += 2) {
|
||||
auto n2 = n1 + 1UL;
|
||||
for (mpi_id_t n1 = 0 ; n1 < 256 ; n1 += 2) {
|
||||
auto n2 = n1 + 1;
|
||||
EXPECT_EQ(partner<SortMode::Bitonic>(n1, 1), ((n1 % 4) ? n1-2 : n1+2));
|
||||
EXPECT_EQ(partner<SortMode::Bitonic>(n2, 1), ((n1 % 4) ? n2-2 : n2+2));
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* size_t partner(size_t node, size_t step);
|
||||
* mpi_id_t partner(mpi_id_t node, size_t step);
|
||||
* various steps
|
||||
*/
|
||||
TEST(TdistBitonic_UT, partner_test3) {
|
||||
// step = 2
|
||||
size_t ts_step = 2;
|
||||
|
||||
for (size_t n1 = 0 ; n1 < 256 ; n1 += 4) {
|
||||
auto n2 = n1 + 1UL;
|
||||
auto n3 = n1 + 2UL;
|
||||
auto n4 = n1 + 3UL;
|
||||
for (mpi_id_t n1 = 0 ; n1 < 256 ; n1 += 4) {
|
||||
auto n2 = n1 + 1;
|
||||
auto n3 = n1 + 2;
|
||||
auto n4 = n1 + 3;
|
||||
EXPECT_EQ(partner<SortMode::Bitonic>(n1, ts_step), ((n1 % 8) ? n1-4 : n1+4));
|
||||
EXPECT_EQ(partner<SortMode::Bitonic>(n2, ts_step), ((n1 % 8) ? n2-4 : n2+4));
|
||||
EXPECT_EQ(partner<SortMode::Bitonic>(n3, ts_step), ((n1 % 8) ? n3-4 : n3+4));
|
||||
@ -169,14 +169,14 @@ TEST(TdistBitonic_UT, partner_test3) {
|
||||
// step = 3
|
||||
ts_step = 3;
|
||||
|
||||
for (size_t n1 = 0 ; n1 < 256 ; n1 += 8) {
|
||||
auto n2 = n1 + 1UL;
|
||||
auto n3 = n1 + 2UL;
|
||||
auto n4 = n1 + 3UL;
|
||||
auto n5 = n1 + 4UL;
|
||||
auto n6 = n1 + 5UL;
|
||||
auto n7 = n1 + 6UL;
|
||||
auto n8 = n1 + 7UL;
|
||||
for (mpi_id_t n1 = 0 ; n1 < 256 ; n1 += 8) {
|
||||
auto n2 = n1 + 1;
|
||||
auto n3 = n1 + 2;
|
||||
auto n4 = n1 + 3;
|
||||
auto n5 = n1 + 4;
|
||||
auto n6 = n1 + 5;
|
||||
auto n7 = n1 + 6;
|
||||
auto n8 = n1 + 7;
|
||||
EXPECT_EQ(partner<SortMode::Bitonic>(n1, ts_step), ((n1 % 16) ? n1-8 : n1+8));
|
||||
EXPECT_EQ(partner<SortMode::Bitonic>(n2, ts_step), ((n1 % 16) ? n2-8 : n2+8));
|
||||
EXPECT_EQ(partner<SortMode::Bitonic>(n3, ts_step), ((n1 % 16) ? n3-8 : n3+8));
|
||||
@ -190,22 +190,22 @@ TEST(TdistBitonic_UT, partner_test3) {
|
||||
// step = 4
|
||||
ts_step = 4;
|
||||
|
||||
for (size_t n1 = 0 ; n1 < 256 ; n1 += 16) {
|
||||
auto n2 = n1 + 1UL;
|
||||
auto n3 = n1 + 2UL;
|
||||
auto n4 = n1 + 3UL;
|
||||
auto n5 = n1 + 4UL;
|
||||
auto n6 = n1 + 5UL;
|
||||
auto n7 = n1 + 6UL;
|
||||
auto n8 = n1 + 7UL;
|
||||
auto n9 = n1 + 8UL;
|
||||
auto n10 = n1 + 9UL;
|
||||
auto n11 = n1 + 10UL;
|
||||
auto n12 = n1 + 11UL;
|
||||
auto n13 = n1 + 12UL;
|
||||
auto n14 = n1 + 13UL;
|
||||
auto n15 = n1 + 14UL;
|
||||
auto n16 = n1 + 15UL;
|
||||
for (mpi_id_t n1 = 0 ; n1 < 256 ; n1 += 16) {
|
||||
auto n2 = n1 + 1;
|
||||
auto n3 = n1 + 2;
|
||||
auto n4 = n1 + 3;
|
||||
auto n5 = n1 + 4;
|
||||
auto n6 = n1 + 5;
|
||||
auto n7 = n1 + 6;
|
||||
auto n8 = n1 + 7;
|
||||
auto n9 = n1 + 8;
|
||||
auto n10 = n1 + 9;
|
||||
auto n11 = n1 + 10;
|
||||
auto n12 = n1 + 11;
|
||||
auto n13 = n1 + 12;
|
||||
auto n14 = n1 + 13;
|
||||
auto n15 = n1 + 14;
|
||||
auto n16 = n1 + 15;
|
||||
EXPECT_EQ(partner<SortMode::Bitonic>(n1, ts_step), ((n1 % 32) ? n1-16 : n1+16));
|
||||
EXPECT_EQ(partner<SortMode::Bitonic>(n2, ts_step), ((n1 % 32) ? n2-16 : n2+16));
|
||||
EXPECT_EQ(partner<SortMode::Bitonic>(n3, ts_step), ((n1 % 32) ? n3-16 : n3+16));
|
||||
@ -227,108 +227,108 @@ TEST(TdistBitonic_UT, partner_test3) {
|
||||
|
||||
|
||||
|
||||
/* ================================== keepsmall ================================== */
|
||||
/* ================================== keepSmall ================================== */
|
||||
/*
|
||||
* bool keepsmall(size_t node, size_t partner, size_t depth);
|
||||
* bool keepSmall(mpi_id_t node, mpi_id_t partner, size_t depth);
|
||||
* Assertion check
|
||||
*/
|
||||
TEST(TdistBitonic_UT, keepsmall_test1) {
|
||||
ASSERT_DEATH(keepsmall<SortMode::Bitonic>(0, 0, 0), "");
|
||||
ASSERT_DEATH(keepsmall<SortMode::Bitonic>(1, 1, 42), "");
|
||||
ASSERT_DEATH(keepsmall<SortMode::Bitonic>(7, 7, 42), "");
|
||||
ASSERT_DEATH(keepSmall<SortMode::Bitonic>(0, 0, 0), "");
|
||||
ASSERT_DEATH(keepSmall<SortMode::Bitonic>(1, 1, 42), "");
|
||||
ASSERT_DEATH(keepSmall<SortMode::Bitonic>(7, 7, 42), "");
|
||||
}
|
||||
|
||||
/*
|
||||
* bool keepsmall(size_t node, size_t partner, size_t depth);
|
||||
* bool keepsmall(mpi_id_t node, mpi_id_t partner, size_t depth);
|
||||
*
|
||||
* depth: 1 | step: 0 | partner: [1, 0, 3, 2, 5, 4, 7, 6] | keepsmall: Bool[1, 0, 0, 1, 1, 0, 0, 1]
|
||||
* depth: 1 | step: 0 | partner: [1, 0, 3, 2, 5, 4, 7, 6] | keepSmall: Bool[1, 0, 0, 1, 1, 0, 0, 1]
|
||||
*/
|
||||
TEST(TdistBitonic_UT, keepsmall_test2) {
|
||||
size_t ts_depth = 1UL;
|
||||
size_t ts_partner[] = {1, 0, 3, 2, 5, 4, 7, 6};
|
||||
size_t ts_depth = 1;
|
||||
mpi_id_t ts_partner[] = {1, 0, 3, 2, 5, 4, 7, 6};
|
||||
bool ts_expected[] = {1, 0, 0, 1, 1, 0, 0, 1};
|
||||
|
||||
for (size_t node = 0 ; node < 8UL ; ++node ) {
|
||||
EXPECT_EQ(ts_expected[node], keepsmall<SortMode::Bitonic>(node, ts_partner[node], ts_depth));
|
||||
for (mpi_id_t node = 0 ; node < 8 ; ++node ) {
|
||||
EXPECT_EQ(ts_expected[node], keepSmall<SortMode::Bitonic>(node, ts_partner[node], ts_depth));
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* bool keepsmall(size_t node, size_t partner, size_t depth);
|
||||
* bool keepsmall(mpi_id_t node, mpi_id_t partner, size_t depth);
|
||||
*
|
||||
* depth: 2 | step: 1 | partner: [2, 3, 0, 1, 6, 7, 4, 5] | keepsmall: Bool[1, 1, 0, 0, 0, 0, 1, 1]
|
||||
* depth: 2 | step: 1 | partner: [2, 3, 0, 1, 6, 7, 4, 5] | keepSmall: Bool[1, 1, 0, 0, 0, 0, 1, 1]
|
||||
*/
|
||||
TEST(TdistBitonic_UT, keepsmall_test3) {
|
||||
size_t ts_depth = 2UL;
|
||||
size_t ts_partner[] = {2, 3, 0, 1, 6, 7, 4, 5};
|
||||
size_t ts_depth = 2;
|
||||
mpi_id_t ts_partner[] = {2, 3, 0, 1, 6, 7, 4, 5};
|
||||
bool ts_expected[] = {1, 1, 0, 0, 0, 0, 1, 1};
|
||||
|
||||
for (size_t node = 0 ; node < 8UL ; ++node ) {
|
||||
EXPECT_EQ(ts_expected[node], keepsmall<SortMode::Bitonic>(node, ts_partner[node], ts_depth));
|
||||
for (mpi_id_t node = 0 ; node < 8 ; ++node ) {
|
||||
EXPECT_EQ(ts_expected[node], keepSmall<SortMode::Bitonic>(node, ts_partner[node], ts_depth));
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* bool keepsmall(size_t node, size_t partner, size_t depth);
|
||||
* bool keepsmall(mpi_id_t node, mpi_id_t partner, size_t depth);
|
||||
*
|
||||
* depth: 2 | step: 0 | partner: [1, 0, 3, 2, 5, 4, 7, 6] | keepsmall: Bool[1, 0, 1, 0, 0, 1, 0, 1]
|
||||
* depth: 2 | step: 0 | partner: [1, 0, 3, 2, 5, 4, 7, 6] | keepSmall: Bool[1, 0, 1, 0, 0, 1, 0, 1]
|
||||
*/
|
||||
TEST(TdistBitonic_UT, keepsmall_test4) {
|
||||
size_t ts_depth = 2UL;
|
||||
size_t ts_partner[] = {1, 0, 3, 2, 5, 4, 7, 6};
|
||||
size_t ts_depth = 2;
|
||||
mpi_id_t ts_partner[] = {1, 0, 3, 2, 5, 4, 7, 6};
|
||||
bool ts_expected[] = {1, 0, 1, 0, 0, 1, 0, 1};
|
||||
|
||||
for (size_t node = 0 ; node < 8UL ; ++node ) {
|
||||
EXPECT_EQ(ts_expected[node], keepsmall<SortMode::Bitonic>(node, ts_partner[node], ts_depth));
|
||||
for (mpi_id_t node = 0 ; node < 8 ; ++node ) {
|
||||
EXPECT_EQ(ts_expected[node], keepSmall<SortMode::Bitonic>(node, ts_partner[node], ts_depth));
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* bool keepsmall(size_t node, size_t partner, size_t depth);
|
||||
* bool keepSmall(mpi_id_t node, mpi_id_t partner, size_t depth);
|
||||
*
|
||||
* depth: 3 | step: 2 | partner: [4, 5, 6, 7, 0, 1, 2, 3] | keepsmall: Bool[1, 1, 1, 1, 0, 0, 0, 0]
|
||||
*/
|
||||
TEST(TdistBitonic_UT, keepsmall_test5) {
|
||||
size_t ts_depth = 3UL;
|
||||
size_t ts_partner[] = {4, 5, 6, 7, 0, 1, 2, 3};
|
||||
size_t ts_depth = 3;
|
||||
mpi_id_t ts_partner[] = {4, 5, 6, 7, 0, 1, 2, 3};
|
||||
bool ts_expected[] = {1, 1, 1, 1, 0, 0, 0, 0};
|
||||
|
||||
for (size_t node = 0 ; node < 8UL ; ++node ) {
|
||||
EXPECT_EQ(ts_expected[node], keepsmall<SortMode::Bitonic>(node, ts_partner[node], ts_depth));
|
||||
for (mpi_id_t node = 0 ; node < 8 ; ++node ) {
|
||||
EXPECT_EQ(ts_expected[node], keepSmall<SortMode::Bitonic>(node, ts_partner[node], ts_depth));
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* bool keepsmall(size_t node, size_t partner, size_t depth);
|
||||
* bool keepSmall(mpi_id_t node, mpi_id_t partner, size_t depth);
|
||||
*
|
||||
* depth: 3 | step: 1 | partner: [2, 3, 0, 1, 6, 7, 4, 5] | keepsmall: Bool[1, 1, 0, 0, 1, 1, 0, 0]
|
||||
*/
|
||||
TEST(TdistBitonic_UT, keepsmall_test6) {
|
||||
size_t ts_depth = 3UL;
|
||||
size_t ts_partner[] = {2, 3, 0, 1, 6, 7, 4, 5};
|
||||
size_t ts_depth = 3;
|
||||
mpi_id_t ts_partner[] = {2, 3, 0, 1, 6, 7, 4, 5};
|
||||
bool ts_expected[] = {1, 1, 0, 0, 1, 1, 0, 0};
|
||||
|
||||
for (size_t node = 0 ; node < 8UL ; ++node ) {
|
||||
EXPECT_EQ(ts_expected[node], keepsmall<SortMode::Bitonic>(node, ts_partner[node], ts_depth));
|
||||
for (mpi_id_t node = 0 ; node < 8 ; ++node ) {
|
||||
EXPECT_EQ(ts_expected[node], keepSmall<SortMode::Bitonic>(node, ts_partner[node], ts_depth));
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* bool keepsmall(size_t node, size_t partner, size_t depth);
|
||||
* bool keepSmall(mpi_id_t node, mpi_id_t partner, size_t depth);
|
||||
*
|
||||
* depth: 3 | step: 0 | partner: [1, 0, 3, 2, 5, 4, 7, 6] | keepsmall: Bool[1, 0, 1, 0, 1, 0, 1, 0]
|
||||
*/
|
||||
TEST(TdistBitonic_UT, keepsmall_test7) {
|
||||
size_t ts_depth = 3UL;
|
||||
size_t ts_partner[] = {1, 0, 3, 2, 5, 4, 7, 6};
|
||||
size_t ts_depth = 3;
|
||||
mpi_id_t ts_partner[] = {1, 0, 3, 2, 5, 4, 7, 6};
|
||||
bool ts_expected[] = {1, 0, 1, 0, 1, 0, 1, 0};
|
||||
|
||||
for (size_t node = 0 ; node < 8UL ; ++node ) {
|
||||
EXPECT_EQ(ts_expected[node], keepsmall<SortMode::Bitonic>(node, ts_partner[node], ts_depth));
|
||||
for (mpi_id_t node = 0 ; node < 8 ; ++node ) {
|
||||
EXPECT_EQ(ts_expected[node], keepSmall<SortMode::Bitonic>(node, ts_partner[node], ts_depth));
|
||||
}
|
||||
}
|
||||
|
||||
TEST(TdistBitonic_UT, distbitonic_test1) {
|
||||
TEST(TdistBitonic_UT, distBitonic_test1) {
|
||||
AllData_t ts_Data {
|
||||
Data_t (8), Data_t (8)
|
||||
};
|
||||
@ -338,7 +338,7 @@ TEST(TdistBitonic_UT, distbitonic_test1) {
|
||||
std::generate(v.begin(), v.end(), std::rand);
|
||||
}
|
||||
|
||||
distbitonic(2, ts_Data);
|
||||
distBitonic(2, ts_Data);
|
||||
|
||||
auto max = std::numeric_limits<Data_t::value_type>::min();
|
||||
for (auto& v : ts_Data) {
|
||||
@ -348,7 +348,7 @@ TEST(TdistBitonic_UT, distbitonic_test1) {
|
||||
}
|
||||
}
|
||||
|
||||
TEST(TdistBitonic_UT, distbitonic_test2) {
|
||||
TEST(TdistBitonic_UT, distBitonic_test2) {
|
||||
AllData_t ts_Data {
|
||||
Data_t (8), Data_t (8), Data_t (8), Data_t (8)
|
||||
};
|
||||
@ -358,7 +358,7 @@ TEST(TdistBitonic_UT, distbitonic_test2) {
|
||||
std::generate(v.begin(), v.end(), std::rand);
|
||||
}
|
||||
|
||||
distbitonic(4, ts_Data);
|
||||
distBitonic(4, ts_Data);
|
||||
|
||||
auto max = std::numeric_limits<Data_t::value_type>::min();
|
||||
for (auto& v : ts_Data) {
|
||||
@ -368,7 +368,7 @@ TEST(TdistBitonic_UT, distbitonic_test2) {
|
||||
}
|
||||
}
|
||||
|
||||
TEST(TdistBitonic_UT, distbitonic_test3) {
|
||||
TEST(TdistBitonic_UT, distBitonic_test3) {
|
||||
AllData_t ts_Data {
|
||||
Data_t (32), Data_t (32), Data_t (32), Data_t (32),
|
||||
Data_t (32), Data_t (32), Data_t (32), Data_t (32)
|
||||
@ -379,7 +379,7 @@ TEST(TdistBitonic_UT, distbitonic_test3) {
|
||||
std::generate(v.begin(), v.end(), std::rand);
|
||||
}
|
||||
|
||||
distbitonic(8, ts_Data);
|
||||
distBitonic(8, ts_Data);
|
||||
|
||||
auto max = std::numeric_limits<Data_t::value_type>::min();
|
||||
for (auto& v : ts_Data) {
|
||||
|
||||
@ -18,7 +18,7 @@
|
||||
/* ================================== ascending ================================== */
|
||||
|
||||
/*
|
||||
* bool ascending<SortMode::Bubbletonic>(size_t node, size_t depth);
|
||||
* bool ascending<SortMode::Bubbletonic>(mpi_id_t node, size_t depth);
|
||||
*/
|
||||
TEST(TdistBubbletonic_UT, ascending_Bubbletonic_test1) {
|
||||
EXPECT_EQ(ascending<SortMode::Bubbletonic>(0, 0), true);
|
||||
@ -30,7 +30,7 @@ TEST(TdistBubbletonic_UT, ascending_Bubbletonic_test1) {
|
||||
EXPECT_EQ(ascending<SortMode::Bubbletonic>(6, 0), true);
|
||||
EXPECT_EQ(ascending<SortMode::Bubbletonic>(7, 0), false);
|
||||
|
||||
for (size_t node = 0 ; node < 256 ; ++node) {
|
||||
for (mpi_id_t node = 0 ; node < 256 ; ++node) {
|
||||
EXPECT_EQ(ascending<SortMode::Bubbletonic>(node, 7), ((node % 2) ? false : true) );
|
||||
}
|
||||
}
|
||||
@ -39,52 +39,52 @@ TEST(TdistBubbletonic_UT, ascending_Bubbletonic_test1) {
|
||||
/* ================================== partner ================================== */
|
||||
|
||||
/*
|
||||
* size_t partner<SortMode::Bubbletonic>(size_t node, size_t step);
|
||||
* mpi_id_t partner<SortMode::Bubbletonic>(mpi_id_t node, size_t step);
|
||||
* step = 0
|
||||
*/
|
||||
TEST(TdistBubbletonic_UT, partner_Bubbletonic_test1) {
|
||||
size_t ts_step = 0;
|
||||
size_t ts_expected[] = {1, 0, 3, 2, 5, 4, 7, 6};
|
||||
mpi_id_t ts_expected[] = {1, 0, 3, 2, 5, 4, 7, 6};
|
||||
|
||||
for (size_t node = 0 ; node < 8 ; ++node) {
|
||||
for (mpi_id_t node = 0 ; node < 8 ; ++node) {
|
||||
EXPECT_EQ(partner<SortMode::Bubbletonic>(node, ts_step), ts_expected[node]);
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* size_t partner<SortMode::Bubbletonic>(size_t node, size_t step);
|
||||
* mpi_id_t partner<SortMode::Bubbletonic>(mpi_id_t node, size_t step);
|
||||
* step = 1
|
||||
*/
|
||||
TEST(TdistBubbletonic_UT, partner_Bubbletonic_test2) {
|
||||
size_t ts_step = 1;
|
||||
size_t ts_expected[] = {(size_t)-1, 2, 1, 4, 3, 6, 5, 8};
|
||||
mpi_id_t ts_expected[] = {(mpi_id_t)-1, 2, 1, 4, 3, 6, 5, 8};
|
||||
|
||||
for (size_t node = 0 ; node < 8 ; ++node) {
|
||||
for (mpi_id_t node = 0 ; node < 8 ; ++node) {
|
||||
EXPECT_EQ(partner<SortMode::Bubbletonic>(node, ts_step), ts_expected[node]);
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* size_t partner<SortMode::Bubbletonic>(size_t node, size_t step);
|
||||
* mpi_id_t partner<SortMode::Bubbletonic>(mpi_id_t node, size_t step);
|
||||
* various steps
|
||||
*/
|
||||
TEST(TdistBubbletonic_UT, partner_Bubbletonic_test3) {
|
||||
|
||||
size_t ts_even_expected[] = {
|
||||
mpi_id_t ts_even_expected[] = {
|
||||
1, 0, 3, 2, 5, 4, 7, 6, 9, 8, 11, 10, 13, 12, 15, 14
|
||||
};
|
||||
size_t ts_odd_expected[] = {
|
||||
(size_t)-1, 2, 1, 4, 3, 6, 5, 8, 7, 10, 9, 12, 11, 14, 13, 16
|
||||
mpi_id_t ts_odd_expected[] = {
|
||||
(mpi_id_t)-1, 2, 1, 4, 3, 6, 5, 8, 7, 10, 9, 12, 11, 14, 13, 16
|
||||
};
|
||||
|
||||
for (size_t step = 0 ; step < 32 ; ++step) {
|
||||
if (step % 2) {
|
||||
for (size_t node = 0; node < 16; ++node) {
|
||||
for (mpi_id_t node = 0; node < 16; ++node) {
|
||||
EXPECT_EQ(partner<SortMode::Bubbletonic>(node, step), ts_odd_expected[node]);
|
||||
}
|
||||
}
|
||||
else {
|
||||
for (size_t node = 0; node < 16; ++node) {
|
||||
for (mpi_id_t node = 0; node < 16; ++node) {
|
||||
EXPECT_EQ(partner<SortMode::Bubbletonic>(node, step), ts_even_expected[node]);
|
||||
}
|
||||
}
|
||||
@ -92,36 +92,36 @@ TEST(TdistBubbletonic_UT, partner_Bubbletonic_test3) {
|
||||
}
|
||||
|
||||
|
||||
/* ================================== keepsmall ================================== */
|
||||
/* ================================== keepSmall ================================== */
|
||||
/*
|
||||
* bool keepsmall<SortMode::Bubbletonic>(size_t node, size_t partner, size_t depth);
|
||||
* bool keepSmall<SortMode::Bubbletonic>(mpi_id_t node, mpi_id_t partner, size_t depth);
|
||||
* Assertion check
|
||||
*/
|
||||
TEST(TdistBubbletonic_UT, keepsmall_test1) {
|
||||
ASSERT_DEATH(keepsmall<SortMode::Bubbletonic>(0, 0, 0), "");
|
||||
ASSERT_DEATH(keepsmall<SortMode::Bubbletonic>(1, 1, 42), "");
|
||||
ASSERT_DEATH(keepsmall<SortMode::Bubbletonic>(7, 7, 42), "");
|
||||
ASSERT_DEATH(keepSmall<SortMode::Bubbletonic>(0, 0, 0), "");
|
||||
ASSERT_DEATH(keepSmall<SortMode::Bubbletonic>(1, 1, 42), "");
|
||||
ASSERT_DEATH(keepSmall<SortMode::Bubbletonic>(7, 7, 42), "");
|
||||
}
|
||||
|
||||
/*
|
||||
* bool keepsmall<SortMode::Bubbletonic>(size_t node, size_t partner, size_t depth);
|
||||
* bool keepSmall<SortMode::Bubbletonic>(mpi_id_t node, mpi_id_t partner, size_t depth);
|
||||
*/
|
||||
TEST(TdistBubbletonic_UT, keepsmall_test2) {
|
||||
// Check various combinations
|
||||
EXPECT_EQ(keepsmall<SortMode::Bubbletonic>(0, 1, 42), true);
|
||||
EXPECT_EQ(keepsmall<SortMode::Bubbletonic>(0, 3, 42), true);
|
||||
EXPECT_EQ(keepsmall<SortMode::Bubbletonic>(2, 1, 42), false);
|
||||
EXPECT_EQ(keepsmall<SortMode::Bubbletonic>(7, 1, 42), false);
|
||||
EXPECT_EQ(keepsmall<SortMode::Bubbletonic>(0, 1, 42), true);
|
||||
EXPECT_EQ(keepsmall<SortMode::Bubbletonic>(7, 32,42), true);
|
||||
EXPECT_EQ(keepsmall<SortMode::Bubbletonic>(7, 1, 42), false);
|
||||
EXPECT_EQ(keepsmall<SortMode::Bubbletonic>(4, 0, 42), false);
|
||||
EXPECT_EQ(keepsmall<SortMode::Bubbletonic>(4, 9, 42), true);
|
||||
EXPECT_EQ(keepSmall<SortMode::Bubbletonic>(0, 1, 42), true);
|
||||
EXPECT_EQ(keepSmall<SortMode::Bubbletonic>(0, 3, 42), true);
|
||||
EXPECT_EQ(keepSmall<SortMode::Bubbletonic>(2, 1, 42), false);
|
||||
EXPECT_EQ(keepSmall<SortMode::Bubbletonic>(7, 1, 42), false);
|
||||
EXPECT_EQ(keepSmall<SortMode::Bubbletonic>(0, 1, 42), true);
|
||||
EXPECT_EQ(keepSmall<SortMode::Bubbletonic>(7, 32, 42), true);
|
||||
EXPECT_EQ(keepSmall<SortMode::Bubbletonic>(7, 1, 42), false);
|
||||
EXPECT_EQ(keepSmall<SortMode::Bubbletonic>(4, 0, 42), false);
|
||||
EXPECT_EQ(keepSmall<SortMode::Bubbletonic>(4, 9, 42), true);
|
||||
}
|
||||
|
||||
|
||||
|
||||
TEST(TdistBubbletonic_UT, distbubbletonic_test1) {
|
||||
TEST(TdistBubbletonic_UT, distBubbletonic_test1) {
|
||||
AllData_t ts_Data {
|
||||
Data_t (8), Data_t (8)
|
||||
};
|
||||
@ -131,7 +131,7 @@ TEST(TdistBubbletonic_UT, distbubbletonic_test1) {
|
||||
std::generate(v.begin(), v.end(), std::rand);
|
||||
}
|
||||
|
||||
distbubbletonic(2, ts_Data);
|
||||
distBubbletonic(2, ts_Data);
|
||||
|
||||
auto max = std::numeric_limits<Data_t::value_type>::min();
|
||||
for (auto& v : ts_Data) {
|
||||
@ -142,7 +142,7 @@ TEST(TdistBubbletonic_UT, distbubbletonic_test1) {
|
||||
}
|
||||
|
||||
|
||||
TEST(TdistBubbletonic_UT, distbubbletonic_test2) {
|
||||
TEST(TdistBubbletonic_UT, distBubbletonic_test2) {
|
||||
AllData_t ts_Data {
|
||||
Data_t (8), Data_t (8), Data_t (8), Data_t (8)
|
||||
};
|
||||
@ -152,7 +152,7 @@ TEST(TdistBubbletonic_UT, distbubbletonic_test2) {
|
||||
std::generate(v.begin(), v.end(), std::rand);
|
||||
}
|
||||
|
||||
distbubbletonic(4, ts_Data);
|
||||
distBubbletonic(4, ts_Data);
|
||||
|
||||
auto max = std::numeric_limits<Data_t::value_type>::min();
|
||||
for (auto& v : ts_Data) {
|
||||
@ -162,7 +162,7 @@ TEST(TdistBubbletonic_UT, distbubbletonic_test2) {
|
||||
}
|
||||
}
|
||||
|
||||
TEST(TdistBubbletonic_UT, distbubbletonic_test3) {
|
||||
TEST(TdistBubbletonic_UT, distBubbletonic_test3) {
|
||||
AllData_t ts_Data {
|
||||
Data_t (32), Data_t (32), Data_t (32), Data_t (32),
|
||||
Data_t (32), Data_t (32), Data_t (32), Data_t (32)
|
||||
@ -173,7 +173,7 @@ TEST(TdistBubbletonic_UT, distbubbletonic_test3) {
|
||||
std::generate(v.begin(), v.end(), std::rand);
|
||||
}
|
||||
|
||||
distbubbletonic(8, ts_Data);
|
||||
distBubbletonic(8, ts_Data);
|
||||
|
||||
auto max = std::numeric_limits<Data_t::value_type>::min();
|
||||
for (auto& v : ts_Data) {
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user