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/ArrayCollection/Tags/ElementLocations.hpp"
      12             : #include "Parallel/GlobalCache.hpp"
      13             : #include "Parallel/Info.hpp"
      14             : #include "Parallel/Invoke.hpp"
      15             : #include "Parallel/NodeLock.hpp"
      16             : #include "Utilities/Gsl.hpp"
      17             : 
      18             : namespace Parallel::Actions {
      19             : /// \brief A threaded action that calls the simple action `SimpleActionToCall`
      20             : /// on either the specified element or broadcasts to the nodegroup.
      21             : ///
      22             : /// If `Block` is `true` then the action will wait until the element is free
      23             : /// to be operated on. If it is `false` then a message will be sent to the
      24             : /// nodegroup to try invoking the element again.
      25             : ///
      26             : /// This is a threaded action intended to be run on the DG nodegroup.
      27             : template <typename SimpleActionToCall, bool Block>
      28           1 : struct SimpleActionOnElement {
      29             :   /// \brief Invoke the simple action on a single element
      30             :   template <typename ParallelComponent, typename DbTagsList,
      31             :             typename Metavariables, typename ArrayIndex,
      32             :             typename DistributedObject, size_t Dim, typename... Args>
      33           1 :   static void apply(db::DataBox<DbTagsList>& box,
      34             :                     Parallel::GlobalCache<Metavariables>& cache,
      35             :                     const ArrayIndex& /*array_index*/,
      36             :                     const gsl::not_null<Parallel::NodeLock*> /*node_lock*/,
      37             :                     const DistributedObject* /*distributed_object*/,
      38             :                     const ElementId<Dim>& element_to_execute_on,
      39             :                     Args&&... args) {
      40             :     const size_t my_node = Parallel::my_node<size_t>(cache);
      41             :     auto& my_proxy = Parallel::get_parallel_component<ParallelComponent>(cache);
      42             : 
      43             :     auto& element_collection = db::get_mutable_reference<
      44             :         typename ParallelComponent::element_collection_tag>(
      45             :         make_not_null(&box));
      46             :     auto& element = element_collection.at(element_to_execute_on);
      47             :     std::unique_lock element_lock(element.element_lock(), std::defer_lock);
      48             :     if constexpr (Block) {
      49             :       element_lock.lock();
      50             :       element.template simple_action<SimpleActionToCall>(
      51             :           std::forward<Args>(args)...);
      52             :     } else {
      53             :       if (element_lock.try_lock()) {
      54             :         element.template simple_action<SimpleActionToCall>(
      55             :             std::forward<Args>(args)...);
      56             :       } else {
      57             :         Parallel::threaded_action<Parallel::Actions::SimpleActionOnElement<
      58             :             SimpleActionToCall, Block>>(my_proxy[my_node],
      59             :                                         element_to_execute_on,
      60             :                                         std::forward<Args>(args)...);
      61             :       }
      62             :     }
      63             :   }
      64             : 
      65             :   /// \brief Invoke the simple action on all elements
      66             :   ///
      67             :   /// \note This loops over all elements and spawns a message for each element.
      68             :   template <typename ParallelComponent, typename DbTagsList,
      69             :             typename Metavariables, typename ArrayIndex,
      70             :             typename DistributedObject, typename... Args>
      71           1 :   static void apply(db::DataBox<DbTagsList>& box,
      72             :                     Parallel::GlobalCache<Metavariables>& cache,
      73             :                     const ArrayIndex& /*array_index*/,
      74             :                     const gsl::not_null<Parallel::NodeLock*> /*node_lock*/,
      75             :                     const DistributedObject* /*distributed_object*/,
      76             :                     const Args&... args) {
      77             :     auto& my_proxy = Parallel::get_parallel_component<ParallelComponent>(cache);
      78             : 
      79             :     auto& element_locations = db::get_mutable_reference<
      80             :         Parallel::Tags::ElementLocations<Metavariables::volume_dim>>(
      81             :         make_not_null(&box));
      82             :     for (const auto& [element_id, node_id] : element_locations) {
      83             :       if (node_id == Parallel::my_node<size_t>(cache)) {
      84             :         Parallel::threaded_action<Parallel::Actions::SimpleActionOnElement<
      85             :             SimpleActionToCall, Block>>(my_proxy[node_id], element_id, args...);
      86             :       }
      87             :     }
      88             :   }
      89             : };
      90             : }  // namespace Parallel::Actions