Homec4science
Diffusion tamaas (master) Browse

tamaas/tests/test_mpi_loop.cpp
9614f93afd40master

Last Change
Raw File

test_mpi_loop.cpp
View Options

/**
*
* @author Lucas Frérot <lucas.frerot@epfl.ch>
*
* @section LICENSE
*
* Copyright (©) 2016 EPFL (Ecole Polytechnique Fédérale de
* Lausanne) Laboratory (LSMS - Laboratoire de Simulation en Mécanique des
* Solides)
*
* Tamaas is free software: you can redistribute it and/or modify it under the
* terms of the GNU Lesser General Public License as published by the Free
* Software Foundation, either version 3 of the License, or (at your option) any
* later version.
*
* Tamaas is distributed in the hope that it will be useful, but WITHOUT ANY
* WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
* A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
* details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with Tamaas. If not, see <http://www.gnu.org/licenses/>.
*
*/
/* -------------------------------------------------------------------------- */
#include "grid.hh"
#include "loop.hh"
#include "static_types.hh"
#include "tamaas.hh"
#include "test.hh"
#include <algorithm>
/* -------------------------------------------------------------------------- */
using namespace tamaas;
namespace tamaas {
extern int mpi_rank;
}
template <typename T>
void TEST1() {
Grid<T, 2> grid({2, 2}, 1);
Grid<T, 2> solution({2, 2}, 1);
std::iota(grid.begin(), grid.end(), 1);
// Makeing solution
auto add_one = [] CUDA_LAMBDA(T & x) { return x + 1; };
std::transform(grid.begin(), grid.end(), solution.begin(), add_one);
// apply tamaas loop
auto add_one_inplace = [] CUDA_LAMBDA(T & x) { x += 1; };
Loop::loop(add_one_inplace, grid);
assert(compare(grid, solution, AreFloatEqual()));
grid.gather();
solution.gather();
assert(compare(grid, solution, AreFloatEqual()));
}
void TEST2() {
Grid<UInt, 2> grid({10, 10}, 2);
std::iota(grid.begin(), grid.end(), 1);
Grid<UInt, 2> solution({10, 10}, 2);
solution = grid;
std::for_each(solution.begin(), solution.end(), [] CUDA_LAMBDA(UInt & x) {
if (x % 2 == 1)
x += 1;
});
Loop::stridedLoop([] CUDA_LAMBDA(UInt & x) { x += 1; }, grid);
cr_assert(compare(solution, grid), "One argument strided loop failed");
}
template <typename T>
void TEST3() {
Grid<T, 2> grid({2, 2}, 1);
std::iota(grid.begin(), grid.end(), 1);
const auto id = [] CUDA_LAMBDA(T & x) { return x; };
//TAMAAS_LOG(grid);
// Sum reduction
T red = Loop::reduce<operation::plus>(id, grid);
// gather the grid to test in sequential
grid.gather();
//TAMAAS_LOG(grid);
if (mpi_rank == 0) {
T sol = std::accumulate(grid.begin(), grid.end(), 0, std::plus<T>());
// UInt red_seq = Loop::reduce<operation::plus>(id, grid);
// std::cout << "yo: " << sol << std::endl;
// std::cout << "yo: " << red << std::endl;
// std::cout << red_seq << std::endl;
// assert(sol == red_seq);
assert(sol == red);
}
// re-distribute the grid to test in sequential
grid.distribute();
//TAMAAS_LOG(grid);
// Product reduction
red = Loop::reduce<operation::times>(id, grid);
// gather the grid to test in sequential
grid.gather();
//TAMAAS_LOG(grid);
if (mpi_rank == 0) {
T sol =
std::accumulate(grid.begin(), grid.end(), T(1.), std::multiplies<T>());
assert(sol == red);
}
// re-distribute the grid to test in sequential
grid.distribute();
//TAMAAS_LOG(grid);
red = Loop::reduce<operation::min>(id, grid);
grid.gather();
if (mpi_rank == 0) {
// Min reduction
T sol = *std::min_element(grid.begin(), grid.end());
assert(sol == red);
}
// re-distribute the grid to test in sequential
grid.distribute();
red = Loop::reduce<operation::max>(id, grid);
if (mpi_rank == 0) {
// Max reduction
T sol = *std::max_element(grid.begin(), grid.end());
assert(sol == red);
}
}
int main() {
initialize();
TEST1<Real>();
TEST1<UInt>();
TEST2();
TEST3<Real>();
finalize();
}
c4science · Help