Skip to content
Snippets Groups Projects
Commit 76c29359 authored by Stéphane Del Pino's avatar Stéphane Del Pino
Browse files

Add tests for Synchronizer

parent 75375dad
No related branches found
No related tags found
1 merge request!128Feature/unit tests
Show whitespace changes
Inline Side-by-side
src/mesh/Synchronizer.hpp
+ 28
− 0
View file @ 76c29359
......@@ -7,9 +7,13 @@
#include <utils/Exceptions.hpp>
#include <utils/Messenger.hpp>
#include <utils/pugs_config.hpp>
#include <iostream>
#include <map>
#ifdef PUGS_HAS_MPI
class Synchronizer
{
template <ItemType item_type>
......@@ -289,4 +293,28 @@ class Synchronizer
}
};
#else // PUGS_HAS_MPI
class Synchronizer
{
public:
template <typename DataType, ItemType item_type, typename ConnectivityPtr>
PUGS_INLINE void
synchronize(ItemValue<DataType, item_type, ConnectivityPtr>&)
{}
template <typename DataType, ItemType item_type, typename ConnectivityPtr>
PUGS_INLINE void
synchronize(ItemArray<DataType, item_type, ConnectivityPtr>&)
{}
PUGS_INLINE
Synchronizer()
{
;
}
};
#endif // PUGS_HAS_MPI
#endif // SYNCHRONIZER_HPP
tests/CMakeLists.txt
+ 1
− 0
View file @ 76c29359
......@@ -174,6 +174,7 @@ add_executable (mpi_unit_tests
test_RandomEngine.cpp
test_SubItemValuePerItem.cpp
test_SubItemArrayPerItem.cpp
test_Synchronizer.cpp
)
add_library(test_Pugs_MeshDataBase
......
tests/test_Synchronizer.cpp 0 → 100644
+ 450
− 0
View file @ 76c29359
#include <catch2/catch_test_macros.hpp>
#include <catch2/matchers/catch_matchers_all.hpp>
#include <MeshDataBaseForTests.hpp>
#include <mesh/Connectivity.hpp>
#include <mesh/Mesh.hpp>
#include <mesh/Synchronizer.hpp>
#include <utils/pugs_config.hpp>
// clazy:excludeall=non-pod-global-static
TEST_CASE("Synchronizer", "[mesh]")
{
auto is_same_item_value = [](auto a, auto b) {
using IndexT = typename decltype(a)::index_type;
bool is_same = true;
for (IndexT i = 0; i < a.numberOfItems(); ++i) {
is_same &= (a[i] == b[i]);
}
return parallel::allReduceAnd(is_same);
};
auto is_same_item_array = [](auto a, auto b) {
using IndexT = typename decltype(a)::index_type;
bool is_same = true;
for (IndexT i = 0; i < a.numberOfItems(); ++i) {
for (size_t j = 0; j < a.sizeOfArrays(); ++j) {
is_same &= (a[i][j] == b[i][j]);
}
}
return parallel::allReduceAnd(is_same);
};
SECTION("1D")
{
constexpr size_t Dimension = 1;
using ConnectivityType = Connectivity<Dimension>;
const ConnectivityType& connectivity = MeshDataBaseForTests::get().unordered1DMesh()->connectivity();
SECTION("synchonize NodeValue")
{
const auto node_owner = connectivity.nodeOwner();
const auto node_number = connectivity.nodeNumber();
NodeValue<int> node_value_ref{connectivity};
parallel_for(
connectivity.numberOfNodes(),
PUGS_LAMBDA(const NodeId node_id) { node_value_ref[node_id] = node_owner[node_id] + node_number[node_id]; });
NodeValue<int> node_value{connectivity};
parallel_for(
connectivity.numberOfNodes(),
PUGS_LAMBDA(const NodeId node_id) { node_value[node_id] = parallel::rank() + node_number[node_id]; });
if (parallel::size() > 1) {
REQUIRE(not is_same_item_value(node_value, node_value_ref));
}
Synchronizer synchronizer;
synchronizer.synchronize(node_value);
REQUIRE(is_same_item_value(node_value, node_value_ref));
}
SECTION("synchonize EdgeValue")
{
const auto edge_owner = connectivity.edgeOwner();
const auto edge_number = connectivity.edgeNumber();
EdgeValue<int> edge_value_ref{connectivity};
parallel_for(
connectivity.numberOfEdges(),
PUGS_LAMBDA(const EdgeId edge_id) { edge_value_ref[edge_id] = edge_owner[edge_id] + edge_number[edge_id]; });
EdgeValue<int> edge_value{connectivity};
parallel_for(
connectivity.numberOfEdges(),
PUGS_LAMBDA(const EdgeId edge_id) { edge_value[edge_id] = parallel::rank() + edge_number[edge_id]; });
if (parallel::size() > 1) {
REQUIRE(not is_same_item_value(edge_value, edge_value_ref));
}
Synchronizer synchronizer;
synchronizer.synchronize(edge_value);
REQUIRE(is_same_item_value(edge_value, edge_value_ref));
}
SECTION("synchonize FaceValue")
{
const auto face_owner = connectivity.faceOwner();
const auto face_number = connectivity.faceNumber();
FaceValue<int> face_value_ref{connectivity};
parallel_for(
connectivity.numberOfFaces(),
PUGS_LAMBDA(const FaceId face_id) { face_value_ref[face_id] = face_owner[face_id] + face_number[face_id]; });
FaceValue<int> face_value{connectivity};
parallel_for(
connectivity.numberOfFaces(),
PUGS_LAMBDA(const FaceId face_id) { face_value[face_id] = parallel::rank() + face_number[face_id]; });
if (parallel::size() > 1) {
REQUIRE(not is_same_item_value(face_value, face_value_ref));
}
Synchronizer synchronizer;
synchronizer.synchronize(face_value);
REQUIRE(is_same_item_value(face_value, face_value_ref));
}
SECTION("synchonize CellValue")
{
const auto cell_owner = connectivity.cellOwner();
const auto cell_number = connectivity.cellNumber();
CellValue<int> cell_value_ref{connectivity};
parallel_for(
connectivity.numberOfCells(),
PUGS_LAMBDA(const CellId cell_id) { cell_value_ref[cell_id] = cell_owner[cell_id] + cell_number[cell_id]; });
CellValue<int> cell_value{connectivity};
parallel_for(
connectivity.numberOfCells(),
PUGS_LAMBDA(const CellId cell_id) { cell_value[cell_id] = parallel::rank() + cell_number[cell_id]; });
if (parallel::size() > 1) {
REQUIRE(not is_same_item_value(cell_value, cell_value_ref));
}
Synchronizer synchronizer;
synchronizer.synchronize(cell_value);
REQUIRE(is_same_item_value(cell_value, cell_value_ref));
}
SECTION("synchonize CellArray")
{
const auto cell_owner = connectivity.cellOwner();
const auto cell_number = connectivity.cellNumber();
CellArray<int> cell_array_ref{connectivity, 3};
parallel_for(
connectivity.numberOfCells(), PUGS_LAMBDA(const CellId cell_id) {
for (size_t i = 0; i < cell_array_ref.sizeOfArrays(); ++i) {
cell_array_ref[cell_id][i] = (i + 1) * cell_owner[cell_id] + i + cell_number[cell_id];
}
});
CellArray<int> cell_array{connectivity, 3};
parallel_for(
connectivity.numberOfCells(), PUGS_LAMBDA(const CellId cell_id) {
for (size_t i = 0; i < cell_array.sizeOfArrays(); ++i) {
cell_array[cell_id][i] = (i + 1) * parallel::rank() + i + cell_number[cell_id];
}
});
if (parallel::size() > 1) {
REQUIRE(not is_same_item_array(cell_array, cell_array_ref));
}
Synchronizer synchronizer;
synchronizer.synchronize(cell_array);
REQUIRE(is_same_item_array(cell_array, cell_array_ref));
}
}
SECTION("2D")
{
constexpr size_t Dimension = 2;
using ConnectivityType = Connectivity<Dimension>;
const ConnectivityType& connectivity = MeshDataBaseForTests::get().hybrid2DMesh()->connectivity();
SECTION("synchonize NodeValue")
{
const auto node_owner = connectivity.nodeOwner();
const auto node_number = connectivity.nodeNumber();
NodeValue<int> node_value_ref{connectivity};
parallel_for(
connectivity.numberOfNodes(),
PUGS_LAMBDA(const NodeId node_id) { node_value_ref[node_id] = node_owner[node_id] + node_number[node_id]; });
NodeValue<int> node_value{connectivity};
parallel_for(
connectivity.numberOfNodes(),
PUGS_LAMBDA(const NodeId node_id) { node_value[node_id] = parallel::rank() + node_number[node_id]; });
if (parallel::size() > 1) {
REQUIRE(not is_same_item_value(node_value, node_value_ref));
}
Synchronizer synchronizer;
synchronizer.synchronize(node_value);
REQUIRE(is_same_item_value(node_value, node_value_ref));
}
SECTION("synchonize EdgeValue")
{
const auto edge_owner = connectivity.edgeOwner();
const auto edge_number = connectivity.edgeNumber();
EdgeValue<int> edge_value_ref{connectivity};
parallel_for(
connectivity.numberOfEdges(),
PUGS_LAMBDA(const EdgeId edge_id) { edge_value_ref[edge_id] = edge_owner[edge_id] + edge_number[edge_id]; });
EdgeValue<int> edge_value{connectivity};
parallel_for(
connectivity.numberOfEdges(),
PUGS_LAMBDA(const EdgeId edge_id) { edge_value[edge_id] = parallel::rank() + edge_number[edge_id]; });
if (parallel::size() > 1) {
REQUIRE(not is_same_item_value(edge_value, edge_value_ref));
}
Synchronizer synchronizer;
synchronizer.synchronize(edge_value);
REQUIRE(is_same_item_value(edge_value, edge_value_ref));
}
SECTION("synchonize FaceValue")
{
const auto face_owner = connectivity.faceOwner();
const auto face_number = connectivity.faceNumber();
FaceValue<int> face_value_ref{connectivity};
parallel_for(
connectivity.numberOfFaces(),
PUGS_LAMBDA(const FaceId face_id) { face_value_ref[face_id] = face_owner[face_id] + face_number[face_id]; });
FaceValue<int> face_value{connectivity};
parallel_for(
connectivity.numberOfFaces(),
PUGS_LAMBDA(const FaceId face_id) { face_value[face_id] = parallel::rank() + face_number[face_id]; });
if (parallel::size() > 1) {
REQUIRE(not is_same_item_value(face_value, face_value_ref));
}
Synchronizer synchronizer;
synchronizer.synchronize(face_value);
REQUIRE(is_same_item_value(face_value, face_value_ref));
}
SECTION("synchonize CellValue")
{
const auto cell_owner = connectivity.cellOwner();
const auto cell_number = connectivity.cellNumber();
CellValue<int> cell_value_ref{connectivity};
parallel_for(
connectivity.numberOfCells(),
PUGS_LAMBDA(const CellId cell_id) { cell_value_ref[cell_id] = cell_owner[cell_id] + cell_number[cell_id]; });
CellValue<int> cell_value{connectivity};
parallel_for(
connectivity.numberOfCells(),
PUGS_LAMBDA(const CellId cell_id) { cell_value[cell_id] = parallel::rank() + cell_number[cell_id]; });
if (parallel::size() > 1) {
REQUIRE(not is_same_item_value(cell_value, cell_value_ref));
}
Synchronizer synchronizer;
synchronizer.synchronize(cell_value);
REQUIRE(is_same_item_value(cell_value, cell_value_ref));
}
SECTION("synchonize CellArray")
{
const auto cell_owner = connectivity.cellOwner();
const auto cell_number = connectivity.cellNumber();
CellArray<int> cell_array_ref{connectivity, 3};
parallel_for(
connectivity.numberOfCells(), PUGS_LAMBDA(const CellId cell_id) {
for (size_t i = 0; i < cell_array_ref.sizeOfArrays(); ++i) {
cell_array_ref[cell_id][i] = (i + 1) * cell_owner[cell_id] + i + cell_number[cell_id];
}
});
CellArray<int> cell_array{connectivity, 3};
parallel_for(
connectivity.numberOfCells(), PUGS_LAMBDA(const CellId cell_id) {
for (size_t i = 0; i < cell_array.sizeOfArrays(); ++i) {
cell_array[cell_id][i] = (i + 1) * parallel::rank() + i + cell_number[cell_id];
}
});
if (parallel::size() > 1) {
REQUIRE(not is_same_item_array(cell_array, cell_array_ref));
}
Synchronizer synchronizer;
synchronizer.synchronize(cell_array);
REQUIRE(is_same_item_array(cell_array, cell_array_ref));
}
}
SECTION("3D")
{
constexpr size_t Dimension = 3;
using ConnectivityType = Connectivity<Dimension>;
const ConnectivityType& connectivity = MeshDataBaseForTests::get().hybrid3DMesh()->connectivity();
SECTION("synchonize NodeValue")
{
const auto node_owner = connectivity.nodeOwner();
const auto node_number = connectivity.nodeNumber();
NodeValue<int> node_value_ref{connectivity};
parallel_for(
connectivity.numberOfNodes(),
PUGS_LAMBDA(const NodeId node_id) { node_value_ref[node_id] = node_owner[node_id] + node_number[node_id]; });
NodeValue<int> node_value{connectivity};
parallel_for(
connectivity.numberOfNodes(),
PUGS_LAMBDA(const NodeId node_id) { node_value[node_id] = parallel::rank() + node_number[node_id]; });
if (parallel::size() > 1) {
REQUIRE(not is_same_item_value(node_value, node_value_ref));
}
Synchronizer synchronizer;
synchronizer.synchronize(node_value);
REQUIRE(is_same_item_value(node_value, node_value_ref));
}
SECTION("synchonize EdgeValue")
{
const auto edge_owner = connectivity.edgeOwner();
const auto edge_number = connectivity.edgeNumber();
EdgeValue<int> edge_value_ref{connectivity};
parallel_for(
connectivity.numberOfEdges(),
PUGS_LAMBDA(const EdgeId edge_id) { edge_value_ref[edge_id] = edge_owner[edge_id] + edge_number[edge_id]; });
EdgeValue<int> edge_value{connectivity};
parallel_for(
connectivity.numberOfEdges(),
PUGS_LAMBDA(const EdgeId edge_id) { edge_value[edge_id] = parallel::rank() + edge_number[edge_id]; });
if (parallel::size() > 1) {
REQUIRE(not is_same_item_value(edge_value, edge_value_ref));
}
Synchronizer synchronizer;
synchronizer.synchronize(edge_value);
REQUIRE(is_same_item_value(edge_value, edge_value_ref));
}
SECTION("synchonize FaceValue")
{
const auto face_owner = connectivity.faceOwner();
const auto face_number = connectivity.faceNumber();
FaceValue<int> face_value_ref{connectivity};
parallel_for(
connectivity.numberOfFaces(),
PUGS_LAMBDA(const FaceId face_id) { face_value_ref[face_id] = face_owner[face_id] + face_number[face_id]; });
FaceValue<int> face_value{connectivity};
parallel_for(
connectivity.numberOfFaces(),
PUGS_LAMBDA(const FaceId face_id) { face_value[face_id] = parallel::rank() + face_number[face_id]; });
if (parallel::size() > 1) {
REQUIRE(not is_same_item_value(face_value, face_value_ref));
}
Synchronizer synchronizer;
synchronizer.synchronize(face_value);
REQUIRE(is_same_item_value(face_value, face_value_ref));
}
SECTION("synchonize CellValue")
{
const auto cell_owner = connectivity.cellOwner();
const auto cell_number = connectivity.cellNumber();
CellValue<int> cell_value_ref{connectivity};
parallel_for(
connectivity.numberOfCells(),
PUGS_LAMBDA(const CellId cell_id) { cell_value_ref[cell_id] = cell_owner[cell_id] + cell_number[cell_id]; });
CellValue<int> cell_value{connectivity};
parallel_for(
connectivity.numberOfCells(),
PUGS_LAMBDA(const CellId cell_id) { cell_value[cell_id] = parallel::rank() + cell_number[cell_id]; });
if (parallel::size() > 1) {
REQUIRE(not is_same_item_value(cell_value, cell_value_ref));
}
Synchronizer synchronizer;
synchronizer.synchronize(cell_value);
REQUIRE(is_same_item_value(cell_value, cell_value_ref));
}
SECTION("synchonize CellArray")
{
const auto cell_owner = connectivity.cellOwner();
const auto cell_number = connectivity.cellNumber();
CellArray<int> cell_array_ref{connectivity, 3};
parallel_for(
connectivity.numberOfCells(), PUGS_LAMBDA(const CellId cell_id) {
for (size_t i = 0; i < cell_array_ref.sizeOfArrays(); ++i) {
cell_array_ref[cell_id][i] = (i + 1) * cell_owner[cell_id] + i + cell_number[cell_id];
}
});
CellArray<int> cell_array{connectivity, 3};
parallel_for(
connectivity.numberOfCells(), PUGS_LAMBDA(const CellId cell_id) {
for (size_t i = 0; i < cell_array.sizeOfArrays(); ++i) {
cell_array[cell_id][i] = (i + 1) * parallel::rank() + i + cell_number[cell_id];
}
});
if (parallel::size() > 1) {
REQUIRE(not is_same_item_array(cell_array, cell_array_ref));
}
Synchronizer synchronizer;
synchronizer.synchronize(cell_array);
REQUIRE(is_same_item_array(cell_array, cell_array_ref));
}
}
}
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment