hoo2
/
PDS
1
0
Forka 0
Codice Problemi 0 Pull Requests 0 Rilasci 2 Wiki Attività
Sfoglia il codice sorgente

HW2: A local only version of the distbitonic

tags/v2.0
Christos Choutouridis 3 settimane fa
parent
428b50aab7
commit
43dff95f67
10 ha cambiato i file con 29525 aggiunte e 126 eliminazioni
Visualizzazione separata
Diff Options
Show Stats Download Patch File Download Diff File
  1. +57
    -58
      homework_2/Makefile
  2. +7
    -6
      homework_2/include/config.h
  3. +44
    -0
      homework_2/include/distbitonic.hpp
  4. +14
    -0
      homework_2/include/impl.hpp
  5. +59
    -50
      homework_2/include/utils.hpp
  6. +106
    -0
      homework_2/src/distbitonic.cpp
  7. +78
    -12
      homework_2/src/main.cpp
  8. +11673
    -0
      homework_2/test/gtest/gtest/gtest-all.cpp
  9. +17103
    -0
      homework_2/test/gtest/gtest/gtest.h
  10. +384
    -0
      homework_2/test/tests.cpp

+ 57
- 58
homework_2/Makefile Vedi File

@@ -20,12 +20,17 @@
# ============== Project settings ==============
# Project's name
PROJECT := PDS_homework_2

# Excecutable's name
TARGET := distbitonic
TARGET := bitonic

# Source directories list(space seperated). Makefile-relative path, UNDER current directory.
SRC_DIR_LIST := src
SRC_DIR_LIST := src test test/gtest

# Include directories list(space seperated). Makefile-relative path.
INC_DIR_LIST := include \
test \
test/gtest/ \
/usr/lib/x86_64-linux-gnu/openmpi/include/ \
src

@@ -148,6 +153,14 @@ $(BUILD_DIR)/$(TARGET): $(OBJ)
@$(CSIZE) $(@D)/$(TARGET)
@echo Done


#
# ================ Default local build rules =================
# example:
# make debug

.DEFAULT_GOAL := all

.PHONY: clean
clean:
@echo Cleaning build directories
@@ -155,67 +168,53 @@ clean:
@rm -rf $(DEP_DIR)
@rm -rf $(BUILD_DIR)

#
# ================ Local build rules =================
# example:
# make debug

debug: CFLAGS := $(DEB_CFLAGS)
debug: $(BUILD_DIR)/$(TARGET)

release: CFLAGS := $(REL_CFLAGS)
release: $(BUILD_DIR)/$(TARGET)

all: release

hpc-results/post:
$(CXX) $(CFLAGS) -o $@ hpc-results/main.cpp

hpc-clean:
rm hpc-results/post

#
# ================ Local (and/or) via docker build rules =================
#
# examples:
# make IMAGE=hpcimage v0
# make IMAGE=hpcimage v1_cilk
#
dist_v05: CC := mpicc
dist_v05: CXX := mpic++
dist_v05: CFLAGS := $(DEB_CFLAGS) -DCODE_VERSION=50
dist_v05: CXXFLAGS := $(DEB_CXXFLAGS) -DCODE_VERSION=50
dist_v05: TARGET := dist_v05
dist_v05: $(BUILD_DIR)/$(TARGET)

dist_v1: CC := mpicc
dist_v1: CXX := mpic++
dist_v1: CFLAGS := $(DEB_CFLAGS) -DCODE_VERSION=100
dist_v1: CXXFLAGS := $(DEB_CXXFLAGS) -DCODE_VERSION=100
dist_v1: TARGET := dist_v1
dist_v1: $(BUILD_DIR)/$(TARGET)

#
# ========= Inside CSAL Image build rules ===========
#
# 1) first jump into image (make sure you are in the directory where Makefile is):
# > docker run -it -v ${PWD}:/usr/src/exercise_1 -w /usr/src/exercise_1/ hpcimage
# 2) Clean binaries first **important**
# > make clean
# 3) for v4 cilk for example:
# > make csal_v4_cilk
# 4) run executables from `bin/`. Examples:
# > ./bin/tcount_ompv3 -i mtx/NACA0015.mtx --timing -r 3 -o /dev/null
# > ./bin/tcount_pthv4 -i mtx/com_Youtube.mtx --timing --dynamic --print_count



#
# ======== Run from container =========
#
# examples:
#
# make IMAGE=hpcimage EXEC=knnsearch_v1 run
# make IMAGE=hpcimage EXEC=knnsearch_v1 run
#
# ================ Build rules =================
#

# Local or inside HPC rules
distbubbletonic: CC := mpicc
distbubbletonic: CXX := mpic++
distbubbletonic: CFLAGS := $(REL_CFLAGS) -DCODE_VERSION=BUBBLETONIC
distbubbletonic: CXXFLAGS := $(REL_CXXFLAGS) -DCODE_VERSION=BUBBLETONIC
distbubbletonic: TARGET := distbubbletonic
distbubbletonic: $(BUILD_DIR)/$(TARGET)

distbitonic: CC := mpicc
distbitonic: CXX := mpic++
distbitonic: CFLAGS := $(REL_CFLAGS) -DCODE_VERSION=BITONIC
distbitonic: CXXFLAGS := $(REL_CXXFLAGS) -DCODE_VERSION=BITONIC
distbitonic: TARGET := distbitonic
distbitonic: $(BUILD_DIR)/$(TARGET)

deb_distbubbletonic: CC := mpicc
deb_distbubbletonic: CXX := mpic++
deb_distbubbletonic: CFLAGS := $(DEB_CFLAGS) -DCODE_VERSION=BUBBLETONIC -DDEBUG
deb_distbubbletonic: CXXFLAGS := $(DEB_CXXFLAGS) -DCODE_VERSION=BUBBLETONIC -DDEBUG
deb_distbubbletonic: TARGET := deb_distbubbletonic
deb_distbubbletonic: $(BUILD_DIR)/$(TARGET)

deb_distbitonic: CC := mpicc
deb_distbitonic: CXX := mpic++
deb_distbitonic: CFLAGS := $(DEB_CFLAGS) -DCODE_VERSION=BITONIC -DDEBUG
deb_distbitonic: CXXFLAGS := $(DEB_CXXFLAGS) -DCODE_VERSION=BITONIC -DDEBUG
deb_distbitonic: TARGET := deb_distbitonic
deb_distbitonic: $(BUILD_DIR)/$(TARGET)

tests: CFLAGS := $(DEB_CFLAGS) -DCODE_VERSION=BITONIC -DDEBUG -DTESTING
tests: CXXFLAGS := $(DEB_CXXFLAGS) -DCODE_VERSION=BITONIC -DDEBUG -DTESTING
tests: TARGET := tests
tests: $(BUILD_DIR)/$(TARGET)


all: debug distbubbletonic distbitonic
# Note:
# Add a gcc based make rule here in order for clangd to successfully scan the project files.
# Otherwise we do not need the gcc build.


+ 7
- 6
homework_2/include/config.h Vedi File

@@ -1,5 +1,5 @@
/*!
* \file config,h
* \file config.h
* \brief Build configuration file.
*
* \author
@@ -16,13 +16,13 @@
/*
* Defines for different version of the exercise
*/
#define V50 (50)
#define V100 (100)
#define BITONIC (1)
#define BUBBLETONIC (2)


// Fail-safe version selection
#if !defined CODE_VERSION
#define CODE_VERSION V1
#define CODE_VERSION BITONIC
#endif


@@ -30,10 +30,11 @@
* Session option for each invocation of the executable
*/
struct session_t {
bool timing {false};
bool verbose {false}; //!< Flag to enable verbose output to stdout
bool timing{false};
bool verbose{false}; //!< Flag to enable verbose output to stdout
};

extern session_t session;


#endif /* CONFIG_H_ */

+ 44
- 0
homework_2/include/distbitonic.hpp Vedi File

@@ -0,0 +1,44 @@
/*!
* \file
* \brief Distributed bitonic implementation header
*
* \author
* Christos Choutouridis AEM:8997
* <cchoutou@ece.auth.gr>
*/

#ifndef DISTBITONIC_H_
#define DISTBITONIC_H_

#if !defined DEBUG
#define NDEBUG
#endif
#include <cassert>

#include <vector>
#if !defined TESTING
#include <mpi.h>
#endif

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;


bool ascending(size_t node, size_t depth) noexcept;
size_t partner(size_t node, size_t step) noexcept;
bool keepsmall(size_t node, size_t partner, size_t depth) noexcept;

void exchange(size_t node, size_t partner);
void minmax(AllData_t& data, size_t node, size_t partner, bool keepsmall);
void sort_network(AllData_t& data, size_t nodes, size_t depth);
void distbitonic(size_t P, AllData_t& data);

#endif //DISTBITONIC_H_

+ 14
- 0
homework_2/include/impl.hpp Vedi File

@@ -0,0 +1,14 @@
/*!
* \file
* \brief The distributed bitonic implementation header
*
* \author
* Christos Choutouridis AEM:8997
* <cchoutou@ece.auth.gr>
*/

#ifndef IMPL_H_
#define IMPL_H_


#endif //IMPL_H_

+ 59
- 50
homework_2/include/utils.hpp Vedi File

@@ -19,32 +19,36 @@
/*!
* A Logger for entire program.
*/

struct Log {
struct Endl {} endl; //!< a tag object to to use it as a new line request.
struct Endl {
} endl; //!< a tag object to to use it as a new line request.

//! We provide logging via << operator
template<typename T>
Log &operator<<(T &&t) {
if (session.verbose) {
if (line_) {
std::cout << "[Log]: " << t;
line_ = false;
} else
std::cout << t;
}
return *this;
}

// overload for special end line handling
Log &operator<<(Endl e) {
(void) e;
if (session.verbose) {
std::cout << '\n';
line_ = true;
}
return *this;
}

//! We provide logging via << operator
template<typename T>
Log& operator<< (T&& t) {
if (session.verbose) {
if (line_) {
std::cout << "[Log]: " << t;
line_ = false;
}
else
std::cout << t;
}
return *this;
}
// overload for special end line handling
Log& operator<< (Endl e) { (void)e;
if (session.verbose) {
std::cout << '\n';
line_ = true;
}
return *this;
}
private:
bool line_ {true};
bool line_{true};
};

extern Log logger;
@@ -52,36 +56,41 @@ extern Log logger;
/*!
* A small timing utility based on chrono.
*/
struct Timing{
using Tpoint = std::chrono::steady_clock::time_point;
using microseconds = std::chrono::microseconds;
using milliseconds = std::chrono::milliseconds;
using seconds = std::chrono::seconds;
struct Timing {
using Tpoint = std::chrono::steady_clock::time_point;
using microseconds = std::chrono::microseconds;
using milliseconds = std::chrono::milliseconds;
using seconds = std::chrono::seconds;

//! tool to mark the starting point
Tpoint start() noexcept { return start_ = std::chrono::steady_clock::now(); }

//! tool to mark the starting point
Tpoint start () noexcept { return start_ = std::chrono::steady_clock::now(); }
//! tool to mark the ending point
Tpoint stop () noexcept { return stop_ = std::chrono::steady_clock::now(); }
//! tool to mark the ending point
Tpoint stop() noexcept { return stop_ = std::chrono::steady_clock::now(); }

auto dt() noexcept {
return std::chrono::duration_cast<std::chrono::microseconds>(stop_ - start_).count();
}

//! tool to print the time interval
void print_dt(const char *what) noexcept {
if (session.timing) {
auto t = stop_ - start_;
if (std::chrono::duration_cast<microseconds>(t).count() < 10000)
std::cout << "[Timing]: " << what << ": "
<< std::to_string(std::chrono::duration_cast<microseconds>(t).count()) << " [usec]\n";
else if (std::chrono::duration_cast<milliseconds>(t).count() < 10000)
std::cout << "[Timing]: " << what << ": "
<< std::to_string(std::chrono::duration_cast<milliseconds>(t).count()) << " [msec]\n";
else
std::cout << "[Timing]: " << what << ": "
<< std::to_string(std::chrono::duration_cast<seconds>(t).count()) << " [sec]\n";
}
}

auto dt () noexcept {
return std::chrono::duration_cast<std::chrono::microseconds>(stop_ - start_).count();
}
//! tool to print the time interval
void print_dt (const char* what) noexcept {
if (session.timing) {
auto t = stop_ - start_;
if (std::chrono::duration_cast<microseconds>(t).count() < 10000)
std::cout << "[Timing]: " << what << ": " << std::to_string(std::chrono::duration_cast<microseconds>(t).count()) << " [usec]\n";
else if (std::chrono::duration_cast<milliseconds>(t).count() < 10000)
std::cout << "[Timing]: " << what << ": " << std::to_string(std::chrono::duration_cast<milliseconds>(t).count()) << " [msec]\n";
else
std::cout << "[Timing]: " << what << ": " << std::to_string(std::chrono::duration_cast<seconds>(t).count()) << " [sec]\n";
}
}
private:
Tpoint start_;
Tpoint stop_;
Tpoint start_;
Tpoint stop_;
};


#endif /* UTILS_HPP_ */

+ 106
- 0
homework_2/src/distbitonic.cpp Vedi File

@@ -0,0 +1,106 @@
/*!
* \file
* \brief Distributed bitonic implementation.
*
* \author
* Christos Choutouridis AEM:8997
* <cchoutou@ece.auth.gr>
*/

#include <vector>
#include <algorithm>
#include <cmath>
#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
*
* @param node The current node (MPI process)
* @param depth The total depth of the sorting network (same for each step for a given network)
*
* @return True if we need ascending configuration, false otherwise
*/
bool ascending(size_t node, size_t depth) noexcept {
return !(node & (1 << depth));
}

/*!
* Returns the node's partner for data exchange during the sorting network iterations
*
* @param node The current node
* @param step The step of the sorting network
* @return The node id of the partner for data exchange
*/
size_t partner(size_t node, size_t step) noexcept {
return (node ^ (1 << step));
}

/*!
* Predicate to check if a node keeps the small numbers during the bitonic
* sort network exchange.
*
* @param node The node for which we check
* @param partner The partner of the data exchange
* @param depth The total depth of the sorting network (same for each step for a given network)
* @return True if the node should keep the small values, false otherwise
*/
bool keepsmall(size_t node, size_t partner, size_t depth) noexcept {
assert(node != partner);
return ascending(node, depth) == (node < partner);
}

void exchange(size_t node, size_t partner) {
assert(node != partner);

}

void minmax(AllData_t& data, size_t node, size_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]);
if (!keepsmall && data[node][i] < data[partner][i])
std::swap(data[node][i], data[partner][i]);
}
}

void sort_network(AllData_t& data, size_t nodes, size_t depth) {
for (size_t step = depth; step > 0;) {
--step;
for (size_t node = 0; node < nodes; ++node) {
auto part = partner(node, step);
auto ks = keepsmall(node, part, depth);
if (node < part) {
exchange(node, part);
minmax(data, node, part, ks);
}
}
}
}

void distbitonic(size_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!
// Initially sort to create the half part of a bitonic
if (ascending(node, 0))
std::sort(data[node].begin(), data[node].end(), std::less<>());
else
std::sort(data[node].begin(), data[node].end(), std::greater<>());
}

// Run through sort network using elbow-sort
for (size_t depth = 1; depth <= p; ++depth) {
sort_network(data, P, depth);

for (size_t node = 0 ; node < P ; ++node) { // Currently we do all nodes here!
// elbow-sort here
if (ascending(node, depth))
std::sort(data[node].begin(), data[node].end(), std::less<>());
else
std::sort(data[node].begin(), data[node].end(), std::greater<>());
}

}
}

+ 78
- 12
homework_2/src/main.cpp Vedi File

@@ -1,22 +1,43 @@
/*!
* \file main.cpp
* \file
* \brief Main application file for PDS HW2 (MPI)
*
* \author
* Christos Choutouridis AEM:8997
* <cchoutou@ece.auth.gr>
*/

#include <exception>
#include <iostream>
#include <algorithm> // rand/srand
//#include <ctime> // rand/srand
#if !defined TESTING
#include <mpi.h>
#endif

#include <mpi.h>

#include "matrix.hpp"
#include "distbitonic.hpp"
#include "utils.hpp"
#include "config.h"
//#include "matrix.hpp"

// Global session data
session_t session;
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)
};


/*!
* A small command line argument parser
@@ -64,6 +85,9 @@ bool get_options(int argc, char* argv[]){
return status;
}



#if !defined TESTING
int main(int argc, char* argv[]) try {
// try to read command line
if (!get_options(argc, argv))
@@ -72,22 +96,49 @@ int main(int argc, char* argv[]) try {
// Initialize the MPI environment
MPI_Init(NULL, NULL);

#if defined DEBUG
/*
* In case of a debug build we will wait here until sleep_wait
* will reset via debugger. In order to do that the user must attach
* debugger to all processes. For example:
* $> mpirun -np 2 ./<program path>
* $> ps aux | grep <program>
* $> gdb <program> <PID1>
* $> gdb <program> <PID2>
*/
#if defined TESTING
volatile bool sleep_wait = false;
#else
volatile bool sleep_wait = true;
#endif
while (sleep_wait)
sleep(1);
#endif

// Get the number of processes
int world_size;
MPI_Comm_size(MPI_COMM_WORLD, &world_size);
MPI_Comm_size(MPI_COMM_WORLD, reinterpret_cast<int *>(&mpi.world_size));

// Get the rank of the process
int world_rank;
MPI_Comm_rank(MPI_COMM_WORLD, &world_rank);
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
printf("Hello world from processor %s, rank %d out of %d processors\n",
processor_name, world_rank, world_size);
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();
@@ -97,4 +148,19 @@ catch (std::exception& e) {
//we probably pollute the user's screen. Comment `cerr << ...` if you don't like it.
std::cerr << "Error: " << e.what() << '\n';
exit(1);
}
}

#else

#include <gtest/gtest.h>
#include <exception>

GTEST_API_ int main(int argc, char **argv) try {
testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}
catch (std::exception& e) {
std::cout << "Exception: " << e.what() << '\n';
}

#endif

+ 11673
- 0
homework_2/test/gtest/gtest/gtest-all.cpp
File diff soppresso perché troppo grande
Vedi File


+ 17103
- 0
homework_2/test/gtest/gtest/gtest.h
File diff soppresso perché troppo grande
Vedi File


+ 384
- 0
homework_2/test/tests.cpp Vedi File

@@ -0,0 +1,384 @@
/**
* \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 "distbitonic.hpp"


/*
* ==========================================
*/

/*
* bool ascending(size_t node, size_t depth);
* depth 0 (the initial ascending pattern)
*/
TEST(Tdistbitonic_UT, ascending_test1) {

EXPECT_EQ(ascending(0, 0), true);
EXPECT_EQ(ascending(1, 0), false);
EXPECT_EQ(ascending(2, 0), true);
EXPECT_EQ(ascending(3, 0), false);
EXPECT_EQ(ascending(4, 0), true);
EXPECT_EQ(ascending(5, 0), false);
EXPECT_EQ(ascending(6, 0), true);
EXPECT_EQ(ascending(7, 0), false);

for (size_t node = 0 ; node < 256 ; ++node) {
EXPECT_EQ(ascending(node, 0), ((node % 2) ? false : true) );
}
}

/*
* bool ascending(size_t node, size_t depth);
* depth 1
*/
TEST(Tdistbitonic_UT, ascending_test2) {

EXPECT_EQ(ascending(0, 1), true);
EXPECT_EQ(ascending(1, 1), true);
EXPECT_EQ(ascending(2, 1), false);
EXPECT_EQ(ascending(3, 1), false);
EXPECT_EQ(ascending(4, 1), true);
EXPECT_EQ(ascending(5, 1), true);
EXPECT_EQ(ascending(6, 1), false);
EXPECT_EQ(ascending(7, 1), false);

for (size_t node = 0 ; node < 256 ; ++node) {
EXPECT_EQ(ascending(2*node, 1), ((node % 2) ? false:true));
EXPECT_EQ(ascending(2*node+1, 1), ((node % 2) ? false:true));
}
}

/*
* bool ascending(size_t node, size_t depth);
* various depths
*/
TEST(Tdistbitonic_UT, ascending_test3) {

// Depth = 3
size_t ts_depth = 3;

for (size_t n = 0UL ; n < (1UL<<(ts_depth)) ; ++n)
EXPECT_EQ(ascending(n, ts_depth), true);
for (size_t n = (1UL<<(ts_depth)) ; n < 2*(1UL<<(ts_depth)) ; ++n)
EXPECT_EQ(ascending(n, ts_depth), false);
for (size_t n = 2*(1UL<<(ts_depth)) ; n < 3*(1UL<<(ts_depth)) ; ++n)
EXPECT_EQ(ascending(n, ts_depth), true);
for (size_t n = 3*(1UL<<(ts_depth)) ; n < 4*(1UL<<(ts_depth)) ; ++n)
EXPECT_EQ(ascending(n, ts_depth), false);

// Depth = 4
ts_depth = 4;

for (size_t n = 0UL ; n < (1UL<<(ts_depth)) ; ++n)
EXPECT_EQ(ascending(n, ts_depth), true);
for (size_t n = (1UL<<(ts_depth)) ; n < 2*(1UL<<(ts_depth)) ; ++n)
EXPECT_EQ(ascending(n, ts_depth), false);
for (size_t n = 2*(1UL<<(ts_depth)) ; n < 3*(1UL<<(ts_depth)) ; ++n)
EXPECT_EQ(ascending(n, ts_depth), true);
for (size_t n = 3*(1UL<<(ts_depth)) ; n < 4*(1UL<<(ts_depth)) ; ++n)
EXPECT_EQ(ascending(n, ts_depth), false);

// Depth = 8
ts_depth = 8;

for (size_t n = 0UL ; n < (1UL<<(ts_depth)) ; ++n)
EXPECT_EQ(ascending(n, ts_depth), true);
for (size_t n = (1UL<<(ts_depth)) ; n < 2*(1UL<<(ts_depth)) ; ++n)
EXPECT_EQ(ascending(n, ts_depth), false);
for (size_t n = 2*(1UL<<(ts_depth)) ; n < 3*(1UL<<(ts_depth)) ; ++n)
EXPECT_EQ(ascending(n, ts_depth), true);
for (size_t n = 3*(1UL<<(ts_depth)) ; n < 4*(1UL<<(ts_depth)) ; ++n)
EXPECT_EQ(ascending(n, ts_depth), false);
}

/*
* size_t partner(size_t node, size_t step);
* step = 0
*/
TEST(Tdistbitonic_UT, partner_test1) {

EXPECT_EQ(partner(0, 0), 1UL);
EXPECT_EQ(partner(1, 0), 0UL);
EXPECT_EQ(partner(2, 0), 3UL);
EXPECT_EQ(partner(3, 0), 2UL);
EXPECT_EQ(partner(4, 0), 5UL);
EXPECT_EQ(partner(5, 0), 4UL);
EXPECT_EQ(partner(6, 0), 7UL);
EXPECT_EQ(partner(7, 0), 6UL);

for (size_t node = 0 ; node < 256 ; ++node) {
EXPECT_EQ(partner(node, 0), (node % 2) ? node-1 : node+1);
}
}

/*
* size_t partner(size_t node, size_t step);
* step = 1
*/
TEST(Tdistbitonic_UT, partner_test2) {

EXPECT_EQ(partner(0, 1), 2UL);
EXPECT_EQ(partner(1, 1), 3UL);
EXPECT_EQ(partner(2, 1), 0UL);
EXPECT_EQ(partner(3, 1), 1UL);
EXPECT_EQ(partner(4, 1), 6UL);
EXPECT_EQ(partner(5, 1), 7UL);
EXPECT_EQ(partner(6, 1), 4UL);
EXPECT_EQ(partner(7, 1), 5UL);

for (size_t n1 = 0 ; n1 < 256 ; n1 += 2) {
auto n2 = n1 + 1UL;
EXPECT_EQ(partner(n1, 1), ((n1 % 4) ? n1-2 : n1+2));
EXPECT_EQ(partner(n2, 1), ((n1 % 4) ? n2-2 : n2+2));
}
}

/*
* size_t partner(size_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;
EXPECT_EQ(partner(n1, ts_step), ((n1 % 8) ? n1-4 : n1+4));
EXPECT_EQ(partner(n2, ts_step), ((n1 % 8) ? n2-4 : n2+4));
EXPECT_EQ(partner(n3, ts_step), ((n1 % 8) ? n3-4 : n3+4));
EXPECT_EQ(partner(n4, ts_step), ((n1 % 8) ? n4-4 : n4+4));
}

// 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;
EXPECT_EQ(partner(n1, ts_step), ((n1 % 16) ? n1-8 : n1+8));
EXPECT_EQ(partner(n2, ts_step), ((n1 % 16) ? n2-8 : n2+8));
EXPECT_EQ(partner(n3, ts_step), ((n1 % 16) ? n3-8 : n3+8));
EXPECT_EQ(partner(n4, ts_step), ((n1 % 16) ? n4-8 : n4+8));
EXPECT_EQ(partner(n5, ts_step), ((n1 % 16) ? n5-8 : n5+8));
EXPECT_EQ(partner(n6, ts_step), ((n1 % 16) ? n6-8 : n6+8));
EXPECT_EQ(partner(n7, ts_step), ((n1 % 16) ? n7-8 : n7+8));
EXPECT_EQ(partner(n8, ts_step), ((n1 % 16) ? n8-8 : n8+8));
}

// 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;
EXPECT_EQ(partner(n1, ts_step), ((n1 % 32) ? n1-16 : n1+16));
EXPECT_EQ(partner(n2, ts_step), ((n1 % 32) ? n2-16 : n2+16));
EXPECT_EQ(partner(n3, ts_step), ((n1 % 32) ? n3-16 : n3+16));
EXPECT_EQ(partner(n4, ts_step), ((n1 % 32) ? n4-16 : n4+16));
EXPECT_EQ(partner(n5, ts_step), ((n1 % 32) ? n5-16 : n5+16));
EXPECT_EQ(partner(n6, ts_step), ((n1 % 32) ? n6-16 : n6+16));
EXPECT_EQ(partner(n7, ts_step), ((n1 % 32) ? n7-16 : n7+16));
EXPECT_EQ(partner(n8, ts_step), ((n1 % 32) ? n8-16 : n8+16));
EXPECT_EQ(partner(n9, ts_step), ((n1 % 32) ? n9-16 : n9+16));
EXPECT_EQ(partner(n10, ts_step), ((n1 % 32) ? n10-16 : n10+16));
EXPECT_EQ(partner(n11, ts_step), ((n1 % 32) ? n11-16 : n11+16));
EXPECT_EQ(partner(n12, ts_step), ((n1 % 32) ? n12-16 : n12+16));
EXPECT_EQ(partner(n13, ts_step), ((n1 % 32) ? n13-16 : n13+16));
EXPECT_EQ(partner(n14, ts_step), ((n1 % 32) ? n14-16 : n14+16));
EXPECT_EQ(partner(n15, ts_step), ((n1 % 32) ? n15-16 : n15+16));
EXPECT_EQ(partner(n16, ts_step), ((n1 % 32) ? n16-16 : n16+16));
}
}


/*
* bool keepsmall(size_t node, size_t partner, size_t depth);
* Assertion check
*/
TEST(Tdistbitonic_UT, keepsmall_test1) {
ASSERT_DEATH(keepsmall(0, 0, 0), "");
ASSERT_DEATH(keepsmall(1, 1, 42), "");
ASSERT_DEATH(keepsmall(7, 7, 42), "");
}

/*
* bool keepsmall(size_t node, size_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]
*/
TEST(Tdistbitonic_UT, keepsmall_test2) {
size_t ts_depth = 1UL;
size_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(node, ts_partner[node], ts_depth));
}
}

/*
* bool keepsmall(size_t node, size_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]
*/
TEST(Tdistbitonic_UT, keepsmall_test3) {
size_t ts_depth = 2UL;
size_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(node, ts_partner[node], ts_depth));
}
}

/*
* bool keepsmall(size_t node, size_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]
*/
TEST(Tdistbitonic_UT, keepsmall_test4) {
size_t ts_depth = 2UL;
size_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(node, ts_partner[node], ts_depth));
}
}

/*
* bool keepsmall(size_t node, size_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};
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(node, ts_partner[node], ts_depth));
}
}

/*
* bool keepsmall(size_t node, size_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};
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(node, ts_partner[node], ts_depth));
}
}

/*
* bool keepsmall(size_t node, size_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};
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(node, ts_partner[node], ts_depth));
}
}

TEST(Tdistbitonic_UT, distbitonic_test1) {
AllData_t ts_Data {
Data_t (8), Data_t (8)
};

std::srand(unsigned(std::time(nullptr)));
for (auto& v : ts_Data) {
std::generate(v.begin(), v.end(), std::rand);
}

distbitonic(2, ts_Data);

auto max = std::numeric_limits<Data_t::value_type>::min();
for (auto& v : ts_Data) {
EXPECT_EQ((max <= v[0]), true);
EXPECT_EQ(std::is_sorted(v.begin(), v.end()), true);
max = v.back();
}
}

TEST(Tdistbitonic_UT, distbitonic_test2) {
AllData_t ts_Data {
Data_t (8), Data_t (8), Data_t (8), Data_t (8)
};

std::srand(unsigned(std::time(nullptr)));
for (auto& v : ts_Data) {
std::generate(v.begin(), v.end(), std::rand);
}

distbitonic(4, ts_Data);

auto max = std::numeric_limits<Data_t::value_type>::min();
for (auto& v : ts_Data) {
EXPECT_EQ((max <= v[0]), true);
EXPECT_EQ(std::is_sorted(v.begin(), v.end()), true);
max = v.back();
}
}

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)
};

std::srand(unsigned(std::time(nullptr)));
for (auto& v : ts_Data) {
std::generate(v.begin(), v.end(), std::rand);
}

distbitonic(8, ts_Data);

auto max = std::numeric_limits<Data_t::value_type>::min();
for (auto& v : ts_Data) {
EXPECT_EQ((max <= v[0]), true);
EXPECT_EQ(std::is_sorted(v.begin(), v.end()), true);
max = v.back();
}
}

Write Preview
Loading…
Annulla
Salva