Line data    Source code

       1            0 : // Distributed under the MIT License.
       2              : // See LICENSE.txt for details.
       3              : 
       4              : #pragma once
       5              : 
       6              : #include <cstddef>
       7              : #include <mutex>
       8              : 
       9              : #include "DataStructures/DataBox/DataBox.hpp"
      10              : #include "Domain/Structure/ElementId.hpp"
      11              : #include "Parallel/GlobalCache.hpp"
      12              : #include "Parallel/Invoke.hpp"
      13              : #include "Parallel/NodeLock.hpp"
      14              : #include "Utilities/Gsl.hpp"
      15              : 
      16              : namespace Parallel::Actions {
      17              : /// \brief A threaded action that calls `perform_algorithm()` for a specified
      18              : /// element on the nodegroup.
      19              : ///
      20              : /// If `Block` is `true` then the action will wait until the element is free
      21              : /// to be operated on. If it is `false` then a message will be sent to the
      22              : /// nodegroup to try invoking the element again.
      23              : ///
      24              : /// This is a threaded action intended to be run on the DG nodegroup.
      25              : template <bool Block>
      26            1 : struct PerformAlgorithmOnElement {
      27              :   /// \brief Invoke `perform_algorithm()` on a single element
      28              :   template <typename ParallelComponent, typename DbTagsList,
      29              :             typename Metavariables, typename ArrayIndex,
      30              :             typename DistributedObject, size_t Dim>
      31            1 :   static void apply(db::DataBox<DbTagsList>& box,
      32              :                     Parallel::GlobalCache<Metavariables>& cache,
      33              :                     const ArrayIndex& /*array_index*/,
      34              :                     const gsl::not_null<Parallel::NodeLock*> /*node_lock*/,
      35              :                     const DistributedObject* /*distributed_object*/,
      36              :                     const ElementId<Dim>& element_to_execute_on) {
      37              :     const size_t my_node = Parallel::my_node<size_t>(cache);
      38              :     auto& my_proxy = Parallel::get_parallel_component<ParallelComponent>(cache);
      39              : 
      40              :     auto& element_collection = db::get_mutable_reference<
      41              :         typename ParallelComponent::element_collection_tag>(
      42              :         make_not_null(&box));
      43              :     auto& element = element_collection.at(element_to_execute_on);
      44              :     std::unique_lock element_lock(element.element_lock(), std::defer_lock);
      45              :     if constexpr (Block) {
      46              :       element_lock.lock();
      47              :       element.perform_algorithm();
      48              :     } else {
      49              :       if (element_lock.try_lock()) {
      50              :         element.perform_algorithm();
      51              :       } else {
      52              :         Parallel::threaded_action<
      53              :             Parallel::Actions::PerformAlgorithmOnElement<Block>>(
      54              :             my_proxy[my_node], element_to_execute_on);
      55              :       }
      56              :     }
      57              :   }
      58              : 
      59              :   /// \brief Invoke `perform_algorithm()` on all elements
      60              :   ///
      61              :   /// \note This loops over all elements and spawns a message for each element.
      62              :   template <typename ParallelComponent, typename DbTagsList,
      63              :             typename Metavariables, typename ArrayIndex,
      64              :             typename DistributedObject, size_t Dim>
      65            1 :   static void apply(db::DataBox<DbTagsList>& box,
      66              :                     Parallel::GlobalCache<Metavariables>& cache,
      67              :                     const ArrayIndex& /*array_index*/,
      68              :                     const gsl::not_null<Parallel::NodeLock*> /*node_lock*/,
      69              :                     const DistributedObject* /*distributed_object*/) {
      70              :     const size_t my_node = Parallel::my_node<size_t>(cache);
      71              :     auto& my_proxy = Parallel::get_parallel_component<ParallelComponent>(cache);
      72              : 
      73              :     auto& element_collection = db::get_mutable_reference<
      74              :         typename ParallelComponent::element_collection_tag>(
      75              :         make_not_null(&box));
      76              :     for (const auto& [element_id, element] : element_collection) {
      77              :       Parallel::threaded_action<
      78              :           Parallel::Actions::PerformAlgorithmOnElement<Block>>(
      79              :           my_proxy[my_node], element_id);
      80              :     }
      81              :   }
      82              : };
      83              : }  // namespace Parallel::Actions