From 6633d3296f3023f37ffc7974c1f163fc01778081 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?St=C3=A9phane=20Del=20Pino?= <stephane.delpino44@gmail.com>
Date: Mon, 14 Feb 2022 18:24:00 +0100
Subject: [PATCH] Reorganize tests and add missing ones
Now tests all item types of ItemArray, but due to the template
structure of the code, these tests where not really missing.
---
tests/test_Synchronizer.cpp | 971 ++++++++++++++++++++++++------------
1 file changed, 640 insertions(+), 331 deletions(-)
diff --git a/tests/test_Synchronizer.cpp b/tests/test_Synchronizer.cpp
index 8cc0ea661..29f2fbac5 100644
--- a/tests/test_Synchronizer.cpp
+++ b/tests/test_Synchronizer.cpp
@@ -12,440 +12,749 @@
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]);
+ SECTION("ItemValue")
+ {
+ 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);
- };
+ return parallel::allReduceAnd(is_same);
+ };
- SECTION("1D")
- {
- constexpr size_t Dimension = 1;
- using ConnectivityType = Connectivity<Dimension>;
+ SECTION("1D")
+ {
+ constexpr size_t Dimension = 1;
+ using ConnectivityType = Connectivity<Dimension>;
- const ConnectivityType& connectivity = MeshDataBaseForTests::get().unordered1DMesh()->connectivity();
+ const ConnectivityType& connectivity = MeshDataBaseForTests::get().unordered1DMesh()->connectivity();
- SECTION("synchonize NodeValue")
- {
- const auto node_owner = connectivity.nodeOwner();
- const auto node_number = connectivity.nodeNumber();
+ 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]; });
- 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]; });
+ if (parallel::size() > 1) {
+ REQUIRE(not is_same_item_value(node_value, node_value_ref));
+ }
- 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]; });
+ Synchronizer& synchronizer = SynchronizerManager::instance().getConnectivitySynchronizer(&connectivity);
+ synchronizer.synchronize(node_value);
- if (parallel::size() > 1) {
- REQUIRE(not is_same_item_value(node_value, node_value_ref));
+ REQUIRE(is_same_item_value(node_value, node_value_ref));
}
- Synchronizer& synchronizer = SynchronizerManager::instance().getConnectivitySynchronizer(&connectivity);
- synchronizer.synchronize(node_value);
+ SECTION("synchonize EdgeValue")
+ {
+ const auto edge_owner = connectivity.edgeOwner();
+ const auto edge_number = connectivity.edgeNumber();
- REQUIRE(is_same_item_value(node_value, node_value_ref));
- }
+ 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]; });
- SECTION("synchonize EdgeValue")
- {
- const auto edge_owner = connectivity.edgeOwner();
- const auto edge_number = connectivity.edgeNumber();
+ 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]; });
- 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]; });
+ if (parallel::size() > 1) {
+ REQUIRE(not is_same_item_value(edge_value, edge_value_ref));
+ }
- 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]; });
+ Synchronizer& synchronizer = SynchronizerManager::instance().getConnectivitySynchronizer(&connectivity);
+ synchronizer.synchronize(edge_value);
- if (parallel::size() > 1) {
- REQUIRE(not is_same_item_value(edge_value, edge_value_ref));
+ REQUIRE(is_same_item_value(edge_value, edge_value_ref));
}
- Synchronizer& synchronizer = SynchronizerManager::instance().getConnectivitySynchronizer(&connectivity);
- synchronizer.synchronize(edge_value);
+ SECTION("synchonize FaceValue")
+ {
+ const auto face_owner = connectivity.faceOwner();
+ const auto face_number = connectivity.faceNumber();
- REQUIRE(is_same_item_value(edge_value, edge_value_ref));
- }
+ 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]; });
- SECTION("synchonize FaceValue")
- {
- const auto face_owner = connectivity.faceOwner();
- const auto face_number = connectivity.faceNumber();
+ 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]; });
- 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]; });
+ if (parallel::size() > 1) {
+ REQUIRE(not is_same_item_value(face_value, face_value_ref));
+ }
- 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]; });
+ Synchronizer& synchronizer = SynchronizerManager::instance().getConnectivitySynchronizer(&connectivity);
+ synchronizer.synchronize(face_value);
- if (parallel::size() > 1) {
- REQUIRE(not is_same_item_value(face_value, face_value_ref));
+ REQUIRE(is_same_item_value(face_value, face_value_ref));
}
- Synchronizer& synchronizer = SynchronizerManager::instance().getConnectivitySynchronizer(&connectivity);
- synchronizer.synchronize(face_value);
+ SECTION("synchonize CellValue")
+ {
+ const auto cell_owner = connectivity.cellOwner();
+ const auto cell_number = connectivity.cellNumber();
- REQUIRE(is_same_item_value(face_value, face_value_ref));
- }
+ 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]; });
- SECTION("synchonize CellValue")
- {
- const auto cell_owner = connectivity.cellOwner();
- const auto cell_number = connectivity.cellNumber();
+ 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]; });
- 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]; });
+ if (parallel::size() > 1) {
+ REQUIRE(not is_same_item_value(cell_value, cell_value_ref));
+ }
- 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]; });
+ Synchronizer& synchronizer = SynchronizerManager::instance().getConnectivitySynchronizer(&connectivity);
+ synchronizer.synchronize(cell_value);
- if (parallel::size() > 1) {
- REQUIRE(not is_same_item_value(cell_value, cell_value_ref));
+ REQUIRE(is_same_item_value(cell_value, cell_value_ref));
}
-
- Synchronizer& synchronizer = SynchronizerManager::instance().getConnectivitySynchronizer(&connectivity);
- synchronizer.synchronize(cell_value);
-
- REQUIRE(is_same_item_value(cell_value, cell_value_ref));
}
- SECTION("synchonize CellArray")
+ SECTION("2D")
{
- 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 = SynchronizerManager::instance().getConnectivitySynchronizer(&connectivity);
- synchronizer.synchronize(cell_array);
+ constexpr size_t Dimension = 2;
+ using ConnectivityType = Connectivity<Dimension>;
- REQUIRE(is_same_item_array(cell_array, cell_array_ref));
- }
- }
+ const ConnectivityType& connectivity = MeshDataBaseForTests::get().hybrid2DMesh()->connectivity();
- SECTION("2D")
- {
- constexpr size_t Dimension = 2;
- using ConnectivityType = Connectivity<Dimension>;
+ SECTION("synchonize NodeValue")
+ {
+ const auto node_owner = connectivity.nodeOwner();
+ const auto node_number = connectivity.nodeNumber();
- const ConnectivityType& connectivity = MeshDataBaseForTests::get().hybrid2DMesh()->connectivity();
+ 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]; });
- SECTION("synchonize NodeValue")
- {
- const auto node_owner = connectivity.nodeOwner();
- const auto node_number = connectivity.nodeNumber();
+ 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]; });
- 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]; });
+ if (parallel::size() > 1) {
+ REQUIRE(not is_same_item_value(node_value, node_value_ref));
+ }
- 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]; });
+ Synchronizer& synchronizer = SynchronizerManager::instance().getConnectivitySynchronizer(&connectivity);
+ synchronizer.synchronize(node_value);
- if (parallel::size() > 1) {
- REQUIRE(not is_same_item_value(node_value, node_value_ref));
+ REQUIRE(is_same_item_value(node_value, node_value_ref));
}
- Synchronizer& synchronizer = SynchronizerManager::instance().getConnectivitySynchronizer(&connectivity);
- synchronizer.synchronize(node_value);
+ SECTION("synchonize EdgeValue")
+ {
+ const auto edge_owner = connectivity.edgeOwner();
+ const auto edge_number = connectivity.edgeNumber();
- REQUIRE(is_same_item_value(node_value, node_value_ref));
- }
+ 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]; });
- SECTION("synchonize EdgeValue")
- {
- const auto edge_owner = connectivity.edgeOwner();
- const auto edge_number = connectivity.edgeNumber();
+ 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]; });
- 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]; });
+ if (parallel::size() > 1) {
+ REQUIRE(not is_same_item_value(edge_value, edge_value_ref));
+ }
- 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]; });
+ Synchronizer& synchronizer = SynchronizerManager::instance().getConnectivitySynchronizer(&connectivity);
+ synchronizer.synchronize(edge_value);
- if (parallel::size() > 1) {
- REQUIRE(not is_same_item_value(edge_value, edge_value_ref));
+ REQUIRE(is_same_item_value(edge_value, edge_value_ref));
}
- Synchronizer& synchronizer = SynchronizerManager::instance().getConnectivitySynchronizer(&connectivity);
- synchronizer.synchronize(edge_value);
+ SECTION("synchonize FaceValue")
+ {
+ const auto face_owner = connectivity.faceOwner();
+ const auto face_number = connectivity.faceNumber();
- REQUIRE(is_same_item_value(edge_value, edge_value_ref));
- }
+ 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]; });
- SECTION("synchonize FaceValue")
- {
- const auto face_owner = connectivity.faceOwner();
- const auto face_number = connectivity.faceNumber();
+ 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]; });
- 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]; });
+ if (parallel::size() > 1) {
+ REQUIRE(not is_same_item_value(face_value, face_value_ref));
+ }
- 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]; });
+ Synchronizer& synchronizer = SynchronizerManager::instance().getConnectivitySynchronizer(&connectivity);
+ synchronizer.synchronize(face_value);
- if (parallel::size() > 1) {
- REQUIRE(not is_same_item_value(face_value, face_value_ref));
+ REQUIRE(is_same_item_value(face_value, face_value_ref));
}
- Synchronizer& synchronizer = SynchronizerManager::instance().getConnectivitySynchronizer(&connectivity);
- synchronizer.synchronize(face_value);
+ SECTION("synchonize CellValue")
+ {
+ const auto cell_owner = connectivity.cellOwner();
+ const auto cell_number = connectivity.cellNumber();
- REQUIRE(is_same_item_value(face_value, face_value_ref));
- }
+ 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]; });
- SECTION("synchonize CellValue")
- {
- const auto cell_owner = connectivity.cellOwner();
- const auto cell_number = connectivity.cellNumber();
+ 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]; });
- 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]; });
+ if (parallel::size() > 1) {
+ REQUIRE(not is_same_item_value(cell_value, cell_value_ref));
+ }
- 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]; });
+ Synchronizer& synchronizer = SynchronizerManager::instance().getConnectivitySynchronizer(&connectivity);
+ synchronizer.synchronize(cell_value);
- if (parallel::size() > 1) {
- REQUIRE(not is_same_item_value(cell_value, cell_value_ref));
+ REQUIRE(is_same_item_value(cell_value, cell_value_ref));
}
-
- Synchronizer& synchronizer = SynchronizerManager::instance().getConnectivitySynchronizer(&connectivity);
- synchronizer.synchronize(cell_value);
-
- REQUIRE(is_same_item_value(cell_value, cell_value_ref));
}
- SECTION("synchonize CellArray")
+ SECTION("3D")
{
- 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 = SynchronizerManager::instance().getConnectivitySynchronizer(&connectivity);
- synchronizer.synchronize(cell_array);
+ constexpr size_t Dimension = 3;
+ using ConnectivityType = Connectivity<Dimension>;
- REQUIRE(is_same_item_array(cell_array, cell_array_ref));
- }
- }
+ const ConnectivityType& connectivity = MeshDataBaseForTests::get().hybrid3DMesh()->connectivity();
- SECTION("3D")
- {
- constexpr size_t Dimension = 3;
- using ConnectivityType = Connectivity<Dimension>;
+ SECTION("synchonize NodeValue")
+ {
+ const auto node_owner = connectivity.nodeOwner();
+ const auto node_number = connectivity.nodeNumber();
- const ConnectivityType& connectivity = MeshDataBaseForTests::get().hybrid3DMesh()->connectivity();
+ 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]; });
- SECTION("synchonize NodeValue")
- {
- const auto node_owner = connectivity.nodeOwner();
- const auto node_number = connectivity.nodeNumber();
+ 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]; });
- 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]; });
+ if (parallel::size() > 1) {
+ REQUIRE(not is_same_item_value(node_value, node_value_ref));
+ }
- 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]; });
+ Synchronizer& synchronizer = SynchronizerManager::instance().getConnectivitySynchronizer(&connectivity);
+ synchronizer.synchronize(node_value);
- if (parallel::size() > 1) {
- REQUIRE(not is_same_item_value(node_value, node_value_ref));
+ REQUIRE(is_same_item_value(node_value, node_value_ref));
}
- Synchronizer& synchronizer = SynchronizerManager::instance().getConnectivitySynchronizer(&connectivity);
- synchronizer.synchronize(node_value);
+ SECTION("synchonize EdgeValue")
+ {
+ const auto edge_owner = connectivity.edgeOwner();
+ const auto edge_number = connectivity.edgeNumber();
- REQUIRE(is_same_item_value(node_value, node_value_ref));
- }
+ 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]; });
- SECTION("synchonize EdgeValue")
- {
- const auto edge_owner = connectivity.edgeOwner();
- const auto edge_number = connectivity.edgeNumber();
+ 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]; });
- 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]; });
+ if (parallel::size() > 1) {
+ REQUIRE(not is_same_item_value(edge_value, edge_value_ref));
+ }
- 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]; });
+ Synchronizer& synchronizer = SynchronizerManager::instance().getConnectivitySynchronizer(&connectivity);
+ synchronizer.synchronize(edge_value);
- if (parallel::size() > 1) {
- REQUIRE(not is_same_item_value(edge_value, edge_value_ref));
+ REQUIRE(is_same_item_value(edge_value, edge_value_ref));
}
- Synchronizer& synchronizer = SynchronizerManager::instance().getConnectivitySynchronizer(&connectivity);
- synchronizer.synchronize(edge_value);
+ SECTION("synchonize FaceValue")
+ {
+ const auto face_owner = connectivity.faceOwner();
+ const auto face_number = connectivity.faceNumber();
- REQUIRE(is_same_item_value(edge_value, edge_value_ref));
- }
+ 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]; });
- SECTION("synchonize FaceValue")
- {
- const auto face_owner = connectivity.faceOwner();
- const auto face_number = connectivity.faceNumber();
+ 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]; });
- 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]; });
+ if (parallel::size() > 1) {
+ REQUIRE(not is_same_item_value(face_value, face_value_ref));
+ }
- 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]; });
+ Synchronizer& synchronizer = SynchronizerManager::instance().getConnectivitySynchronizer(&connectivity);
+ synchronizer.synchronize(face_value);
- if (parallel::size() > 1) {
- REQUIRE(not is_same_item_value(face_value, face_value_ref));
+ REQUIRE(is_same_item_value(face_value, face_value_ref));
}
- Synchronizer& synchronizer = SynchronizerManager::instance().getConnectivitySynchronizer(&connectivity);
- synchronizer.synchronize(face_value);
+ SECTION("synchonize CellValue")
+ {
+ const auto cell_owner = connectivity.cellOwner();
+ const auto cell_number = connectivity.cellNumber();
- REQUIRE(is_same_item_value(face_value, face_value_ref));
+ 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 = SynchronizerManager::instance().getConnectivitySynchronizer(&connectivity);
+ synchronizer.synchronize(cell_value);
+
+ REQUIRE(is_same_item_value(cell_value, cell_value_ref));
+ }
}
+ }
+
+ SECTION("ItemArray")
+ {
+ 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("synchonize CellValue")
+ SECTION("1D")
{
- const auto cell_owner = connectivity.cellOwner();
- const auto cell_number = connectivity.cellNumber();
+ constexpr size_t Dimension = 1;
+ using ConnectivityType = Connectivity<Dimension>;
+
+ const ConnectivityType& connectivity = MeshDataBaseForTests::get().unordered1DMesh()->connectivity();
+
+ SECTION("synchonize NodeArray")
+ {
+ const auto node_owner = connectivity.nodeOwner();
+ const auto node_number = connectivity.nodeNumber();
+
+ NodeArray<int> node_array_ref{connectivity, 3};
+ parallel_for(
+ connectivity.numberOfNodes(), PUGS_LAMBDA(const NodeId node_id) {
+ for (size_t i = 0; i < node_array_ref.sizeOfArrays(); ++i) {
+ node_array_ref[node_id][i] = (i + 1) * node_owner[node_id] + i + node_number[node_id];
+ }
+ });
+
+ NodeArray<int> node_array{connectivity, 3};
+ parallel_for(
+ connectivity.numberOfNodes(), PUGS_LAMBDA(const NodeId node_id) {
+ for (size_t i = 0; i < node_array.sizeOfArrays(); ++i) {
+ node_array[node_id][i] = (i + 1) * parallel::rank() + i + node_number[node_id];
+ }
+ });
+
+ if (parallel::size() > 1) {
+ REQUIRE(not is_same_item_array(node_array, node_array_ref));
+ }
+
+ Synchronizer& synchronizer = SynchronizerManager::instance().getConnectivitySynchronizer(&connectivity);
+ synchronizer.synchronize(node_array);
+
+ REQUIRE(is_same_item_array(node_array, node_array_ref));
+ }
+
+ SECTION("synchonize EdgeArray")
+ {
+ const auto edge_owner = connectivity.edgeOwner();
+ const auto edge_number = connectivity.edgeNumber();
+
+ EdgeArray<int> edge_array_ref{connectivity, 3};
+ parallel_for(
+ connectivity.numberOfEdges(), PUGS_LAMBDA(const EdgeId edge_id) {
+ for (size_t i = 0; i < edge_array_ref.sizeOfArrays(); ++i) {
+ edge_array_ref[edge_id][i] = (i + 1) * edge_owner[edge_id] + i + edge_number[edge_id];
+ }
+ });
+
+ EdgeArray<int> edge_array{connectivity, 3};
+ parallel_for(
+ connectivity.numberOfEdges(), PUGS_LAMBDA(const EdgeId edge_id) {
+ for (size_t i = 0; i < edge_array.sizeOfArrays(); ++i) {
+ edge_array[edge_id][i] = (i + 1) * parallel::rank() + i + edge_number[edge_id];
+ }
+ });
+
+ if (parallel::size() > 1) {
+ REQUIRE(not is_same_item_array(edge_array, edge_array_ref));
+ }
+
+ Synchronizer& synchronizer = SynchronizerManager::instance().getConnectivitySynchronizer(&connectivity);
+ synchronizer.synchronize(edge_array);
+
+ REQUIRE(is_same_item_array(edge_array, edge_array_ref));
+ }
- 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]; });
+ SECTION("synchonize FaceArray")
+ {
+ const auto face_owner = connectivity.faceOwner();
+ const auto face_number = connectivity.faceNumber();
+
+ FaceArray<int> face_array_ref{connectivity, 3};
+ parallel_for(
+ connectivity.numberOfFaces(), PUGS_LAMBDA(const FaceId face_id) {
+ for (size_t i = 0; i < face_array_ref.sizeOfArrays(); ++i) {
+ face_array_ref[face_id][i] = (i + 1) * face_owner[face_id] + i + face_number[face_id];
+ }
+ });
+
+ FaceArray<int> face_array{connectivity, 3};
+ parallel_for(
+ connectivity.numberOfFaces(), PUGS_LAMBDA(const FaceId face_id) {
+ for (size_t i = 0; i < face_array.sizeOfArrays(); ++i) {
+ face_array[face_id][i] = (i + 1) * parallel::rank() + i + face_number[face_id];
+ }
+ });
+
+ if (parallel::size() > 1) {
+ REQUIRE(not is_same_item_array(face_array, face_array_ref));
+ }
+
+ Synchronizer& synchronizer = SynchronizerManager::instance().getConnectivitySynchronizer(&connectivity);
+ synchronizer.synchronize(face_array);
+
+ REQUIRE(is_same_item_array(face_array, face_array_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 = SynchronizerManager::instance().getConnectivitySynchronizer(&connectivity);
+ synchronizer.synchronize(cell_array);
+
+ REQUIRE(is_same_item_array(cell_array, cell_array_ref));
+ }
+ }
- 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]; });
+ SECTION("2D")
+ {
+ constexpr size_t Dimension = 2;
+ using ConnectivityType = Connectivity<Dimension>;
+
+ const ConnectivityType& connectivity = MeshDataBaseForTests::get().hybrid2DMesh()->connectivity();
+
+ SECTION("synchonize NodeArray")
+ {
+ const auto node_owner = connectivity.nodeOwner();
+ const auto node_number = connectivity.nodeNumber();
+
+ NodeArray<int> node_array_ref{connectivity, 3};
+ parallel_for(
+ connectivity.numberOfNodes(), PUGS_LAMBDA(const NodeId node_id) {
+ for (size_t i = 0; i < node_array_ref.sizeOfArrays(); ++i) {
+ node_array_ref[node_id][i] = (i + 1) * node_owner[node_id] + i + node_number[node_id];
+ }
+ });
+
+ NodeArray<int> node_array{connectivity, 3};
+ parallel_for(
+ connectivity.numberOfNodes(), PUGS_LAMBDA(const NodeId node_id) {
+ for (size_t i = 0; i < node_array.sizeOfArrays(); ++i) {
+ node_array[node_id][i] = (i + 1) * parallel::rank() + i + node_number[node_id];
+ }
+ });
+
+ if (parallel::size() > 1) {
+ REQUIRE(not is_same_item_array(node_array, node_array_ref));
+ }
+
+ Synchronizer& synchronizer = SynchronizerManager::instance().getConnectivitySynchronizer(&connectivity);
+ synchronizer.synchronize(node_array);
+
+ REQUIRE(is_same_item_array(node_array, node_array_ref));
+ }
- if (parallel::size() > 1) {
- REQUIRE(not is_same_item_value(cell_value, cell_value_ref));
+ SECTION("synchonize EdgeArray")
+ {
+ const auto edge_owner = connectivity.edgeOwner();
+ const auto edge_number = connectivity.edgeNumber();
+
+ EdgeArray<int> edge_array_ref{connectivity, 3};
+ parallel_for(
+ connectivity.numberOfEdges(), PUGS_LAMBDA(const EdgeId edge_id) {
+ for (size_t i = 0; i < edge_array_ref.sizeOfArrays(); ++i) {
+ edge_array_ref[edge_id][i] = (i + 1) * edge_owner[edge_id] + i + edge_number[edge_id];
+ }
+ });
+
+ EdgeArray<int> edge_array{connectivity, 3};
+ parallel_for(
+ connectivity.numberOfEdges(), PUGS_LAMBDA(const EdgeId edge_id) {
+ for (size_t i = 0; i < edge_array.sizeOfArrays(); ++i) {
+ edge_array[edge_id][i] = (i + 1) * parallel::rank() + i + edge_number[edge_id];
+ }
+ });
+
+ if (parallel::size() > 1) {
+ REQUIRE(not is_same_item_array(edge_array, edge_array_ref));
+ }
+
+ Synchronizer& synchronizer = SynchronizerManager::instance().getConnectivitySynchronizer(&connectivity);
+ synchronizer.synchronize(edge_array);
+
+ REQUIRE(is_same_item_array(edge_array, edge_array_ref));
}
- Synchronizer& synchronizer = SynchronizerManager::instance().getConnectivitySynchronizer(&connectivity);
- synchronizer.synchronize(cell_value);
+ SECTION("synchonize FaceArray")
+ {
+ const auto face_owner = connectivity.faceOwner();
+ const auto face_number = connectivity.faceNumber();
+
+ FaceArray<int> face_array_ref{connectivity, 3};
+ parallel_for(
+ connectivity.numberOfFaces(), PUGS_LAMBDA(const FaceId face_id) {
+ for (size_t i = 0; i < face_array_ref.sizeOfArrays(); ++i) {
+ face_array_ref[face_id][i] = (i + 1) * face_owner[face_id] + i + face_number[face_id];
+ }
+ });
+
+ FaceArray<int> face_array{connectivity, 3};
+ parallel_for(
+ connectivity.numberOfFaces(), PUGS_LAMBDA(const FaceId face_id) {
+ for (size_t i = 0; i < face_array.sizeOfArrays(); ++i) {
+ face_array[face_id][i] = (i + 1) * parallel::rank() + i + face_number[face_id];
+ }
+ });
+
+ if (parallel::size() > 1) {
+ REQUIRE(not is_same_item_array(face_array, face_array_ref));
+ }
+
+ Synchronizer& synchronizer = SynchronizerManager::instance().getConnectivitySynchronizer(&connectivity);
+ synchronizer.synchronize(face_array);
+
+ REQUIRE(is_same_item_array(face_array, face_array_ref));
+ }
- 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 = SynchronizerManager::instance().getConnectivitySynchronizer(&connectivity);
+ synchronizer.synchronize(cell_array);
+
+ REQUIRE(is_same_item_array(cell_array, cell_array_ref));
+ }
}
- SECTION("synchonize CellArray")
+ SECTION("3D")
{
- 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));
+ constexpr size_t Dimension = 3;
+ using ConnectivityType = Connectivity<Dimension>;
+
+ const ConnectivityType& connectivity = MeshDataBaseForTests::get().hybrid3DMesh()->connectivity();
+
+ SECTION("synchonize NodeArray")
+ {
+ const auto node_owner = connectivity.nodeOwner();
+ const auto node_number = connectivity.nodeNumber();
+
+ NodeArray<int> node_array_ref{connectivity, 3};
+ parallel_for(
+ connectivity.numberOfNodes(), PUGS_LAMBDA(const NodeId node_id) {
+ for (size_t i = 0; i < node_array_ref.sizeOfArrays(); ++i) {
+ node_array_ref[node_id][i] = (i + 1) * node_owner[node_id] + i + node_number[node_id];
+ }
+ });
+
+ NodeArray<int> node_array{connectivity, 3};
+ parallel_for(
+ connectivity.numberOfNodes(), PUGS_LAMBDA(const NodeId node_id) {
+ for (size_t i = 0; i < node_array.sizeOfArrays(); ++i) {
+ node_array[node_id][i] = (i + 1) * parallel::rank() + i + node_number[node_id];
+ }
+ });
+
+ if (parallel::size() > 1) {
+ REQUIRE(not is_same_item_array(node_array, node_array_ref));
+ }
+
+ Synchronizer& synchronizer = SynchronizerManager::instance().getConnectivitySynchronizer(&connectivity);
+ synchronizer.synchronize(node_array);
+
+ REQUIRE(is_same_item_array(node_array, node_array_ref));
}
- Synchronizer& synchronizer = SynchronizerManager::instance().getConnectivitySynchronizer(&connectivity);
- synchronizer.synchronize(cell_array);
+ SECTION("synchonize EdgeArray")
+ {
+ const auto edge_owner = connectivity.edgeOwner();
+ const auto edge_number = connectivity.edgeNumber();
+
+ EdgeArray<int> edge_array_ref{connectivity, 3};
+ parallel_for(
+ connectivity.numberOfEdges(), PUGS_LAMBDA(const EdgeId edge_id) {
+ for (size_t i = 0; i < edge_array_ref.sizeOfArrays(); ++i) {
+ edge_array_ref[edge_id][i] = (i + 1) * edge_owner[edge_id] + i + edge_number[edge_id];
+ }
+ });
+
+ EdgeArray<int> edge_array{connectivity, 3};
+ parallel_for(
+ connectivity.numberOfEdges(), PUGS_LAMBDA(const EdgeId edge_id) {
+ for (size_t i = 0; i < edge_array.sizeOfArrays(); ++i) {
+ edge_array[edge_id][i] = (i + 1) * parallel::rank() + i + edge_number[edge_id];
+ }
+ });
+
+ if (parallel::size() > 1) {
+ REQUIRE(not is_same_item_array(edge_array, edge_array_ref));
+ }
+
+ Synchronizer& synchronizer = SynchronizerManager::instance().getConnectivitySynchronizer(&connectivity);
+ synchronizer.synchronize(edge_array);
+
+ REQUIRE(is_same_item_array(edge_array, edge_array_ref));
+ }
+
+ SECTION("synchonize FaceArray")
+ {
+ const auto face_owner = connectivity.faceOwner();
+ const auto face_number = connectivity.faceNumber();
+
+ FaceArray<int> face_array_ref{connectivity, 3};
+ parallel_for(
+ connectivity.numberOfFaces(), PUGS_LAMBDA(const FaceId face_id) {
+ for (size_t i = 0; i < face_array_ref.sizeOfArrays(); ++i) {
+ face_array_ref[face_id][i] = (i + 1) * face_owner[face_id] + i + face_number[face_id];
+ }
+ });
+
+ FaceArray<int> face_array{connectivity, 3};
+ parallel_for(
+ connectivity.numberOfFaces(), PUGS_LAMBDA(const FaceId face_id) {
+ for (size_t i = 0; i < face_array.sizeOfArrays(); ++i) {
+ face_array[face_id][i] = (i + 1) * parallel::rank() + i + face_number[face_id];
+ }
+ });
+
+ if (parallel::size() > 1) {
+ REQUIRE(not is_same_item_array(face_array, face_array_ref));
+ }
+
+ Synchronizer& synchronizer = SynchronizerManager::instance().getConnectivitySynchronizer(&connectivity);
+ synchronizer.synchronize(face_array);
+
+ REQUIRE(is_same_item_array(face_array, face_array_ref));
+ }
- REQUIRE(is_same_item_array(cell_array, cell_array_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 = SynchronizerManager::instance().getConnectivitySynchronizer(&connectivity);
+ synchronizer.synchronize(cell_array);
+
+ REQUIRE(is_same_item_array(cell_array, cell_array_ref));
+ }
}
}
}
--
GitLab