diff --git a/include/samurai/algorithm.hpp b/include/samurai/algorithm.hpp index d236ebabc..0b194cefe 100644 --- a/include/samurai/algorithm.hpp +++ b/include/samurai/algorithm.hpp @@ -174,12 +174,16 @@ namespace samurai template inline void parallel_for_each_meshinterval(SetType& set, Func&& f) { +#if defined(SAMURAI_WITH_OPENMP) #pragma omp parallel #pragma omp single nowait +#endif set( [&](const auto& i, const auto& index) { +#if defined(SAMURAI_WITH_OPENMP) #pragma omp task +#endif { MeshIntervalType mesh_interval(set.level()); mesh_interval.i = i; @@ -235,12 +239,16 @@ namespace samurai using cell_t = Cell; using index_value_t = typename cell_t::value_t; +#if defined(SAMURAI_WITH_OPENMP) #pragma omp parallel #pragma omp single nowait +#endif { for (auto it = lca.cbegin(); it != lca.cend(); ++it) { +#if defined(SAMURAI_WITH_OPENMP) #pragma omp task +#endif for (index_value_t i = it->start; i < it->end; ++i) { typename cell_t::indices_t index; diff --git a/include/samurai/level_cell_array.hpp b/include/samurai/level_cell_array.hpp index 8a1ff0ff0..580ede97f 100644 --- a/include/samurai/level_cell_array.hpp +++ b/include/samurai/level_cell_array.hpp @@ -496,7 +496,7 @@ namespace samurai { typename iterator::offset_type_iterator offset_index; typename iterator::iterator_container current_index; - typename iterator::coord_type index; + typename iterator::coord_type index{}; for (std::size_t d = 0; d < dim; ++d) { @@ -516,7 +516,7 @@ namespace samurai { typename iterator::offset_type_iterator offset_index; typename iterator::iterator_container current_index; - typename iterator::coord_type index; + typename iterator::coord_type index{}; for (std::size_t d = 0; d < dim; ++d) { @@ -538,7 +538,7 @@ namespace samurai { typename const_iterator::offset_type_iterator offset_index; typename const_iterator::iterator_container current_index; - typename const_iterator::coord_type index; + typename const_iterator::coord_type index{}; for (std::size_t d = 0; d < dim; ++d) { @@ -560,7 +560,7 @@ namespace samurai { typename const_iterator::offset_type_iterator offset_index; typename const_iterator::iterator_container current_index; - typename const_iterator::coord_type index; + typename const_iterator::coord_type index{}; for (std::size_t d = 0; d < dim; ++d) { diff --git a/include/samurai/mr/rel_detail.hpp b/include/samurai/mr/rel_detail.hpp index 0c8959696..aa1f1e9e9 100644 --- a/include/samurai/mr/rel_detail.hpp +++ b/include/samurai/mr/rel_detail.hpp @@ -40,10 +40,10 @@ namespace samurai template void set_inv_max_field(auto& inv_max_fields, const Field_tuple& field) { - auto f = [](auto& inv_max_fields, const auto& field, auto& dec) + auto f = [](auto& inv_max_fields_var, const auto& fld, auto& offset) { - set_inv_max_field(inv_max_fields, field, dec); - dec += field.n_comp; + set_inv_max_field(inv_max_fields_var, fld, offset); + offset += fld.n_comp; }; std::size_t dec = 0; diff --git a/include/samurai/petsc/nonlinear_local_solvers.hpp b/include/samurai/petsc/nonlinear_local_solvers.hpp index 6bd6201ff..b57452c24 100644 --- a/include/samurai/petsc/nonlinear_local_solvers.hpp +++ b/include/samurai/petsc/nonlinear_local_solvers.hpp @@ -134,7 +134,9 @@ namespace samurai std::vector J_list(n_threads); std::vector r_list(n_threads); +#if defined(SAMURAI_WITH_OPENMP) #pragma omp parallel for +#endif for (std::size_t thread_num = 0; thread_num < n_threads; ++thread_num) { SNESCreate(PETSC_COMM_SELF, &snes_list[thread_num]); @@ -186,7 +188,9 @@ namespace samurai VecDestroy(&b); }); +#if defined(SAMURAI_WITH_OPENMP) #pragma omp parallel for +#endif for (std::size_t thread_num = 0; thread_num < n_threads; ++thread_num) { MatDestroy(&J_list[thread_num]); diff --git a/include/samurai/reconstruction.hpp b/include/samurai/reconstruction.hpp index 00af7d166..d12583e13 100644 --- a/include/samurai/reconstruction.hpp +++ b/include/samurai/reconstruction.hpp @@ -280,9 +280,9 @@ namespace samurai }(std::make_index_sequence>>{}); auto end = std::apply( - [](auto&... coeff_arrays) + [](auto&... arrays) { - return std::make_tuple(coeff_arrays.size()...); + return std::make_tuple(arrays.size()...); }, coeff_arrays); @@ -666,9 +666,9 @@ namespace samurai const std::tuple& i, const std::tuple& ii) { - auto get_f = [&](std::size_t level, const auto&... indices) + auto get_f = [&](std::size_t lvl, const auto&... indices) { - return f(element, level, indices...); + return f(element, lvl, indices...); }; detail::portion_impl(result, f, get_f, level, delta_l, i, ii); } @@ -699,9 +699,9 @@ namespace samurai const std::tuple& i, const std::tuple& ii) { - auto get_f = [&](std::size_t level, const auto&... indices) + auto get_f = [&](std::size_t lvl, const auto&... indices) { - return f(level, indices...); + return f(lvl, indices...); }; detail::portion_impl(result, get_f, level, delta_l, i, ii); @@ -781,21 +781,21 @@ namespace samurai using interval_t = typename Field::interval_t; static_assert(dim <= 3, "Not implemented for dim > 3"); - auto get_f = [&](std::size_t level, const auto&... indices) + auto get_f = [&](std::size_t lvl, const auto&... indices) { if constexpr (Field::is_scalar) { - return f(level, indices...); + return f(lvl, indices...); } else { if constexpr (Field::is_soa) { - return xt::view(f(level, indices...), xt::all(), 0); + return xt::view(f(lvl, indices...), xt::all(), 0); } else { - return xt::view(f(level, indices...), 0); + return xt::view(f(lvl, indices...), 0); } } }; diff --git a/include/samurai/schemes/fv/flux_based/explicit_flux_based_scheme__lin_hom.hpp b/include/samurai/schemes/fv/flux_based/explicit_flux_based_scheme__lin_hom.hpp index ecc2cdddc..0baaf6fe5 100644 --- a/include/samurai/schemes/fv/flux_based/explicit_flux_based_scheme__lin_hom.hpp +++ b/include/samurai/schemes/fv/flux_based/explicit_flux_based_scheme__lin_hom.hpp @@ -67,12 +67,16 @@ namespace samurai // clang-format off if (left_cell.level == right_cell.level || i.size() == 1) // if same level, or a jump in the x-direction (<=> i.size()=1) { + #if defined(SAMURAI_WITH_OPENMP) #pragma omp simd + #endif for (index_t ii = 0; ii < static_cast(i.size()); ++ii) { field_value(output_field, left_cell_index_init + ii, field_i) += left_cell_coeff * field_value(input_field, comput_index_init + ii, field_j); } + #if defined(SAMURAI_WITH_OPENMP) #pragma omp simd + #endif for (index_t ii = 0; ii < static_cast(i.size()); ++ii) { field_value(output_field, right_cell_index_init + ii, field_i) += right_cell_coeff * field_value(input_field, comput_index_init + ii, field_j); @@ -84,13 +88,17 @@ namespace samurai // The fine interval is even (exept in the x-direction, handled by the preceding if). // We always have i.size() fine cells for i.size()/2 coarse cells. assert(i.size() % 2 == 0); + #if defined(SAMURAI_WITH_OPENMP) #pragma omp simd + #endif for (index_t ii = 0; ii < static_cast(i.size() / 2); ++ii) // iteration on the coarse cells { field_value(output_field, left_cell_index_init + ii, field_i) += left_cell_coeff * field_value(input_field, comput_index_init + 2*ii , field_j) + left_cell_coeff * field_value(input_field, comput_index_init + 2*ii+1, field_j); } + #if defined(SAMURAI_WITH_OPENMP) #pragma omp simd + #endif for (index_t ii = 0; ii < static_cast(i.size()); ++ii) // iteration on the fine cells { field_value(output_field, right_cell_index_init + ii, field_i) += right_cell_coeff * field_value(input_field, comput_index_init + ii, field_j); @@ -100,12 +108,16 @@ namespace samurai { // Same as above, the other way around. assert(i.size() % 2 == 0); + #if defined(SAMURAI_WITH_OPENMP) #pragma omp simd + #endif for (index_t ii = 0; ii < static_cast(i.size()); ++ii) { field_value(output_field, left_cell_index_init + ii, field_i) += left_cell_coeff * field_value(input_field, comput_index_init + ii, field_j); } + #if defined(SAMURAI_WITH_OPENMP) #pragma omp simd + #endif for (index_t ii = 0; ii < static_cast(i.size() / 2); ++ii) { field_value(output_field, right_cell_index_init + ii, field_i) += right_cell_coeff * field_value(input_field, comput_index_init + 2*ii , field_j) @@ -161,12 +173,16 @@ namespace samurai // clang-format off if (left_cell.level == right_cell.level || i.size() == 1) // if same level, or a jump in the x-direction (<=> i.size()=1) { + #if defined(SAMURAI_WITH_OPENMP) #pragma omp simd + #endif for (index_t ii = 0; ii < static_cast(i.size()); ++ii) { left_contributions[static_cast(ii)] += left_cell_coeff * field_value(input_field, comput_index_init + ii, field_j); } + #if defined(SAMURAI_WITH_OPENMP) #pragma omp simd + #endif for (index_t ii = 0; ii < static_cast(i.size()); ++ii) { right_contributions[static_cast(ii)] += right_cell_coeff * field_value(input_field, comput_index_init + ii, field_j); @@ -178,13 +194,17 @@ namespace samurai // The fine interval is even (exept in the x-direction, handled by the preceding if). // We always have i.size() fine cells for i.size()/2 coarse cells. assert(i.size() % 2 == 0); + #if defined(SAMURAI_WITH_OPENMP) #pragma omp simd + #endif for (index_t ii = 0; ii < static_cast(i.size() / 2); ++ii) // iteration on the coarse cells { left_contributions[static_cast(ii)] += left_cell_coeff * field_value(input_field, comput_index_init + 2*ii , field_j) + left_cell_coeff * field_value(input_field, comput_index_init + 2*ii+1, field_j); } + #if defined(SAMURAI_WITH_OPENMP) #pragma omp simd + #endif for (index_t ii = 0; ii < static_cast(i.size()); ++ii) // iteration on the fine cells { right_contributions[static_cast(ii)] += right_cell_coeff * field_value(input_field, comput_index_init + ii, field_j); @@ -194,12 +214,16 @@ namespace samurai { // Same as above, the other way around. assert(i.size() % 2 == 0); + #if defined(SAMURAI_WITH_OPENMP) #pragma omp simd + #endif for (index_t ii = 0; ii < static_cast(i.size()); ++ii) { left_contributions[static_cast(ii)] += left_cell_coeff * field_value(input_field, comput_index_init + ii, field_j); } + #if defined(SAMURAI_WITH_OPENMP) #pragma omp simd + #endif for (index_t ii = 0; ii < static_cast(i.size() / 2); ++ii) { right_contributions[static_cast(ii)] += right_cell_coeff * field_value(input_field, comput_index_init + 2*ii , field_j) @@ -216,12 +240,16 @@ namespace samurai // clang-format off for (index_t ii = 0; ii < static_cast(left_contributions.size()); ++ii) { + #if defined(SAMURAI_WITH_OPENMP) #pragma omp atomic update + #endif field_value(output_field, left_cell_index_init + ii, field_i) += left_contributions[static_cast(ii)]; } for (index_t ii = 0; ii < static_cast(right_contributions.size()); ++ii) { + #if defined(SAMURAI_WITH_OPENMP) #pragma omp atomic update + #endif field_value(output_field, right_cell_index_init + ii, field_i) += right_contributions[static_cast(ii)]; } // clang-format on @@ -303,7 +331,9 @@ namespace samurai // clang-format off + #if defined(SAMURAI_WITH_OPENMP) #pragma omp simd + #endif for (index_t ii = 0; ii < static_cast(stencil.interval().size()); ++ii) { field_value(output_field, cell_index_init + ii, field_i) += coeff * field_value(input_field, comput_index_init + ii, field_j); diff --git a/include/samurai/schemes/fv/flux_based/explicit_flux_based_scheme__nonlin.hpp b/include/samurai/schemes/fv/flux_based/explicit_flux_based_scheme__nonlin.hpp index 0eb713c79..e74763242 100644 --- a/include/samurai/schemes/fv/flux_based/explicit_flux_based_scheme__nonlin.hpp +++ b/include/samurai/schemes/fv/flux_based/explicit_flux_based_scheme__nonlin.hpp @@ -44,7 +44,9 @@ namespace samurai for (size_type field_i = 0; field_i < output_n_comp; ++field_i) { // clang-format off + #if defined(SAMURAI_WITH_OPENMP) #pragma omp atomic update + #endif field_value(output_field, cell, field_i) += this->scheme().flux_value_cmpnent(contrib, field_i); // clang-format on }